This auto should not actually be const

Returning proper list of threads for better integration with VS debugger.

.gitignore

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

externals/glad/include/KHR/khrplatform.h

@@ -2,7 +2,7 @@
 #define __khrplatform_h_
 
 /*
-** Copyright (c) 2008-2018 The Khronos Group Inc.
+** Copyright (c) 2008-2009 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -26,16 +26,18 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * The master copy of khrplatform.h is maintained in the Khronos EGL
- * Registry repository at https://github.com/KhronosGroup/EGL-Registry
- * The last semantic modification to khrplatform.h was at commit ID:
- *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
  * group so that they can be included in future versions of this file.
- * Please submit changes by filing pull requests or issues on
- * the EGL Registry repository linked above.
+ * Please submit changes by sending them to the public Khronos Bugzilla
+ * (http://khronos.org/bugzilla) by filing a bug against product
+ * "Khronos (general)" component "Registry".
+ *
+ * A predefined template which fills in some of the bug fields can be
+ * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
+ * must create a Bugzilla login first.
  *
  *
  * See the Implementer's Guidelines for information about where this file

src/CMakeLists.txt

@@ -3,7 +3,6 @@ include_directories(.)
 
 add_subdirectory(common)
 add_subdirectory(core)
-add_subdirectory(audio_core)
 add_subdirectory(video_core)
 add_subdirectory(input_common)
 add_subdirectory(tests)

src/audio_core/CMakeLists.txt

@@ -1,11 +0,0 @@
-add_library(audio_core STATIC
-    audio_out.cpp
-    audio_out.h
-    buffer.h
-    stream.cpp
-    stream.h
-)
-
-create_target_directory_groups(audio_core)
-
-target_link_libraries(audio_core PUBLIC common core)

src/audio_core/audio_out.cpp

@@ -1,50 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "audio_core/audio_out.h"
-#include "common/assert.h"
-#include "common/logging/log.h"
-
-namespace AudioCore {
-
-/// Returns the stream format from the specified number of channels
-static Stream::Format ChannelsToStreamFormat(int num_channels) {
-    switch (num_channels) {
-    case 1:
-        return Stream::Format::Mono16;
-    case 2:
-        return Stream::Format::Stereo16;
-    case 6:
-        return Stream::Format::Multi51Channel16;
-    }
-
-    LOG_CRITICAL(Audio, "Unimplemented num_channels={}", num_channels);
-    UNREACHABLE();
-    return {};
-}
-
-StreamPtr AudioOut::OpenStream(int sample_rate, int num_channels,
-                               Stream::ReleaseCallback&& release_callback) {
-    streams.push_back(std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
-                                               std::move(release_callback)));
-    return streams.back();
-}
-
-std::vector<u64> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
-    return stream->GetTagsAndReleaseBuffers(max_count);
-}
-
-void AudioOut::StartStream(StreamPtr stream) {
-    stream->Play();
-}
-
-void AudioOut::StopStream(StreamPtr stream) {
-    stream->Stop();
-}
-
-bool AudioOut::QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data) {
-    return stream->QueueBuffer(std::make_shared<Buffer>(tag, std::move(data)));
-}
-
-} // namespace AudioCore

src/audio_core/audio_out.h

@@ -1,44 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "audio_core/buffer.h"
-#include "audio_core/stream.h"
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-using StreamPtr = std::shared_ptr<Stream>;
-
-/**
- * Represents an audio playback interface, used to open and play audio streams
- */
-class AudioOut {
-public:
-    /// Opens a new audio stream
-    StreamPtr OpenStream(int sample_rate, int num_channels,
-                         Stream::ReleaseCallback&& release_callback);
-
-    /// Returns a vector of recently released buffers specified by tag for the specified stream
-    std::vector<u64> GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count);
-
-    /// Starts an audio stream for playback
-    void StartStream(StreamPtr stream);
-
-    /// Stops an audio stream that is currently playing
-    void StopStream(StreamPtr stream);
-
-    /// Queues a buffer into the specified audio stream, returns true on success
-    bool QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data);
-
-private:
-    /// Active audio streams on the interface
-    std::vector<StreamPtr> streams;
-};
-
-} // namespace AudioCore

src/audio_core/buffer.h

@@ -1,37 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-/**
- * Represents a buffer of audio samples to be played in an audio stream
- */
-class Buffer {
-public:
-    using Tag = u64;
-
-    Buffer(Tag tag, std::vector<u8>&& data) : tag{tag}, data{std::move(data)} {}
-
-    /// Returns the raw audio data for the buffer
-    const std::vector<u8>& GetData() const {
-        return data;
-    }
-
-    /// Returns the buffer tag, this is provided by the game to the audout service
-    Tag GetTag() const {
-        return tag;
-    }
-
-private:
-    Tag tag;
-    std::vector<u8> data;
-};
-
-} // namespace AudioCore

src/audio_core/stream.cpp

@@ -1,103 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
-
-#include "audio_core/stream.h"
-
-namespace AudioCore {
-
-constexpr size_t MaxAudioBufferCount{32};
-
-/// Returns the sample size for the specified audio stream format
-static size_t SampleSizeFromFormat(Stream::Format format) {
-    switch (format) {
-    case Stream::Format::Mono16:
-        return 2;
-    case Stream::Format::Stereo16:
-        return 4;
-    case Stream::Format::Multi51Channel16:
-        return 12;
-    };
-
-    LOG_CRITICAL(Audio, "Unimplemented format={}", static_cast<u32>(format));
-    UNREACHABLE();
-    return {};
-}
-
-Stream::Stream(int sample_rate, Format format, ReleaseCallback&& release_callback)
-    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)} {
-    release_event = CoreTiming::RegisterEvent(
-        "Stream::Release", [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
-}
-
-void Stream::Play() {
-    state = State::Playing;
-    PlayNextBuffer();
-}
-
-void Stream::Stop() {
-    ASSERT_MSG(false, "Unimplemented");
-}
-
-s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
-    const size_t num_samples{buffer.GetData().size() / SampleSizeFromFormat(format)};
-    return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
-}
-
-void Stream::PlayNextBuffer() {
-    if (!IsPlaying()) {
-        // Ensure we are in playing state before playing the next buffer
-        return;
-    }
-
-    if (active_buffer) {
-        // Do not queue a new buffer if we are already playing a buffer
-        return;
-    }
-
-    if (queued_buffers.empty()) {
-        // No queued buffers - we are effectively paused
-        return;
-    }
-
-    active_buffer = queued_buffers.front();
-    queued_buffers.pop();
-
-    CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
-}
-
-void Stream::ReleaseActiveBuffer() {
-    released_buffers.push(std::move(active_buffer));
-    release_callback();
-    PlayNextBuffer();
-}
-
-bool Stream::QueueBuffer(BufferPtr&& buffer) {
-    if (queued_buffers.size() < MaxAudioBufferCount) {
-        queued_buffers.push(std::move(buffer));
-        PlayNextBuffer();
-        return true;
-    }
-    return false;
-}
-
-bool Stream::ContainsBuffer(Buffer::Tag tag) const {
-    ASSERT_MSG(false, "Unimplemented");
-    return {};
-}
-
-std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers(size_t max_count) {
-    std::vector<Buffer::Tag> tags;
-    for (size_t count = 0; count < max_count && !released_buffers.empty(); ++count) {
-        tags.push_back(released_buffers.front()->GetTag());
-        released_buffers.pop();
-    }
-    return tags;
-}
-
-} // namespace AudioCore

src/audio_core/stream.h

@@ -1,89 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <vector>
-#include <queue>
-
-#include "audio_core/buffer.h"
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "core/core_timing.h"
-
-namespace AudioCore {
-
-using BufferPtr = std::shared_ptr<Buffer>;
-
-/**
- * Represents an audio stream, which is a sequence of queued buffers, to be outputed by AudioOut
- */
-class Stream {
-public:
-    /// Audio format of the stream
-    enum class Format {
-        Mono16,
-        Stereo16,
-        Multi51Channel16,
-    };
-
-    /// Callback function type, used to change guest state on a buffer being released
-    using ReleaseCallback = std::function<void()>;
-
-    Stream(int sample_rate, Format format, ReleaseCallback&& release_callback);
-
-    /// Plays the audio stream
-    void Play();
-
-    /// Stops the audio stream
-    void Stop();
-
-    /// Queues a buffer into the audio stream, returns true on success
-    bool QueueBuffer(BufferPtr&& buffer);
-
-    /// Returns true if the audio stream contains a buffer with the specified tag
-    bool ContainsBuffer(Buffer::Tag tag) const;
-
-    /// Returns a vector of recently released buffers specified by tag
-    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(size_t max_count);
-
-    /// Returns true if the stream is currently playing
-    bool IsPlaying() const {
-        return state == State::Playing;
-    }
-
-    /// Returns the number of queued buffers
-    size_t GetQueueSize() const {
-        return queued_buffers.size();
-    }
-
-private:
-    /// Current state of the stream
-    enum class State {
-        Stopped,
-        Playing,
-    };
-
-    /// Plays the next queued buffer in the audio stream, starting playback if necessary
-    void PlayNextBuffer();
-
-    /// Releases the actively playing buffer, signalling that it has been completed
-    void ReleaseActiveBuffer();
-
-    /// Gets the number of core cycles when the specified buffer will be released
-    s64 GetBufferReleaseCycles(const Buffer& buffer) const;
-
-    int sample_rate;                        ///< Sample rate of the stream
-    Format format;                          ///< Format of the stream
-    ReleaseCallback release_callback;       ///< Buffer release callback for the stream
-    State state{State::Stopped};            ///< Playback state of the stream
-    CoreTiming::EventType* release_event{}; ///< Core timing release event for the stream
-    BufferPtr active_buffer;                ///< Actively playing buffer in the stream
-    std::queue<BufferPtr> queued_buffers;   ///< Buffers queued to be played in the stream
-    std::queue<BufferPtr> released_buffers; ///< Buffers recently released from the stream
-};
-
-} // namespace AudioCore

src/common/CMakeLists.txt

@@ -63,6 +63,7 @@ add_library(common STATIC
     string_util.cpp
     string_util.h
     swap.h
+    synchronized_wrapper.h
     telemetry.cpp
     telemetry.h
     thread.cpp

src/common/common_funcs.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <string>
-
 #if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
 #include <cstdlib> // for exit
 #endif
@@ -38,6 +36,40 @@
 #define Crash() exit(1)
 #endif
 
+// GCC 4.8 defines all the rotate functions now
+// Small issue with GCC's lrotl/lrotr intrinsics is they are still 32bit while we require 64bit
+#ifdef _rotl
+#define rotl _rotl
+#else
+inline u32 rotl(u32 x, int shift) {
+    shift &= 31;
+    if (!shift)
+        return x;
+    return (x << shift) | (x >> (32 - shift));
+}
+#endif
+
+#ifdef _rotr
+#define rotr _rotr
+#else
+inline u32 rotr(u32 x, int shift) {
+    shift &= 31;
+    if (!shift)
+        return x;
+    return (x >> shift) | (x << (32 - shift));
+}
+#endif
+
+inline u64 _rotl64(u64 x, unsigned int shift) {
+    unsigned int n = shift % 64;
+    return (x << n) | (x >> (64 - n));
+}
+
+inline u64 _rotr64(u64 x, unsigned int shift) {
+    unsigned int n = shift % 64;
+    return (x >> n) | (x << (64 - n));
+}
+
 #else // _MSC_VER
 
 // Locale Cross-Compatibility
@@ -48,13 +80,17 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 }
 #define Crash() DebugBreak()
 
+// cstdlib provides these on MSVC
+#define rotr _rotr
+#define rotl _rotl
+
 #endif // _MSC_VER ndef
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
 // Defined in Misc.cpp.
-std::string GetLastErrorMsg();
+const char* GetLastErrorMsg();
 
 namespace Common {
 

src/common/common_paths.h

@@ -26,7 +26,7 @@
 #define USA_DIR "USA"
 #define JAP_DIR "JAP"
 
-// Subdirs in the User dir returned by GetUserPath(UserPath::UserDir)
+// Subdirs in the User dir returned by GetUserPath(D_USER_IDX)
 #define CONFIG_DIR "config"
 #define CACHE_DIR "cache"
 #define SDMC_DIR "sdmc"
@@ -35,11 +35,11 @@
 #define LOG_DIR "log"
 
 // Filenames
-// Files in the directory returned by GetUserPath(UserPath::ConfigDir)
+// 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(UserPath::LogDir)
+// Files in the directory returned by GetUserPath(D_LOGS_IDX)
 #define LOG_FILE "yuzu_log.txt"
 
 // Sys files

src/common/file_util.cpp

@@ -2,10 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <memory>
-#include <sstream>
-#include <unordered_map>
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_paths.h"
@@ -277,10 +273,14 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
               GetLastErrorMsg());
     return false;
 #else
-    using CFilePointer = std::unique_ptr<FILE, decltype(&std::fclose)>;
+
+// buffer size
+#define BSIZE 1024
+
+    char buffer[BSIZE];
 
     // Open input file
-    CFilePointer input{fopen(srcFilename.c_str(), "rb"), std::fclose};
+    FILE* input = fopen(srcFilename.c_str(), "rb");
     if (!input) {
         LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
                   destFilename, GetLastErrorMsg());
@@ -288,36 +288,44 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     }
 
     // open output file
-    CFilePointer output{fopen(destFilename.c_str(), "wb"), std::fclose};
+    FILE* output = fopen(destFilename.c_str(), "wb");
     if (!output) {
+        fclose(input);
         LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
                   destFilename, GetLastErrorMsg());
         return false;
     }
 
     // copy loop
-    std::array<char, 1024> buffer;
-    while (!feof(input.get())) {
+    while (!feof(input)) {
         // read input
-        size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
-        if (rnum != buffer.size()) {
-            if (ferror(input.get()) != 0) {
+        size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
+        if (rnum != BSIZE) {
+            if (ferror(input) != 0) {
                 LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
                           srcFilename, destFilename, GetLastErrorMsg());
-                return false;
+                goto bail;
             }
         }
 
         // write output
-        size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
+        size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
         if (wnum != rnum) {
             LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
                       destFilename, GetLastErrorMsg());
-            return false;
+            goto bail;
         }
     }
-
+    // close files
+    fclose(input);
+    fclose(output);
     return true;
+bail:
+    if (input)
+        fclose(input);
+    if (output)
+        fclose(output);
+    return false;
 #endif
 }
 
@@ -378,7 +386,7 @@ u64 GetSize(FILE* f) {
 bool CreateEmptyFile(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "{}", filename);
 
-    if (!FileUtil::IOFile(filename, "wb").IsOpen()) {
+    if (!FileUtil::IOFile(filename, "wb")) {
         LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
         return false;
     }
@@ -386,12 +394,12 @@ bool CreateEmptyFile(const std::string& filename) {
     return true;
 }
 
-bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
+bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback) {
     LOG_TRACE(Common_Filesystem, "directory {}", directory);
 
     // How many files + directories we found
-    u64 found_entries = 0;
+    unsigned found_entries = 0;
 
     // Save the status of callback function
     bool callback_error = false;
@@ -421,7 +429,7 @@ bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
         if (virtual_name == "." || virtual_name == "..")
             continue;
 
-        u64 ret_entries = 0;
+        unsigned ret_entries = 0;
         if (!callback(&ret_entries, directory, virtual_name)) {
             callback_error = true;
             break;
@@ -445,9 +453,9 @@ bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
     return true;
 }
 
-u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                      unsigned int recursion) {
-    const auto callback = [recursion, &parent_entry](u64* num_entries_out,
+unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                           unsigned int recursion) {
+    const auto callback = [recursion, &parent_entry](unsigned* num_entries_out,
                                                      const std::string& directory,
                                                      const std::string& virtual_name) -> bool {
         FSTEntry entry;
@@ -459,7 +467,7 @@ u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
             // is a directory, lets go inside if we didn't recurse to often
             if (recursion > 0) {
                 entry.size = ScanDirectoryTree(entry.physicalName, entry, recursion - 1);
-                *num_entries_out += entry.size;
+                *num_entries_out += (int)entry.size;
             } else {
                 entry.size = 0;
             }
@@ -470,16 +478,16 @@ u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
         (*num_entries_out)++;
 
         // Push into the tree
-        parent_entry.children.push_back(std::move(entry));
+        parent_entry.children.push_back(entry);
         return true;
     };
 
-    u64 num_entries;
+    unsigned num_entries;
     return ForeachDirectoryEntry(&num_entries, directory, callback) ? num_entries : 0;
 }
 
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](u64* num_entries_out, const std::string& directory,
+    const auto callback = [recursion](unsigned* num_entries_out, const std::string& directory,
                                       const std::string& virtual_name) -> bool {
         std::string new_path = directory + DIR_SEP_CHR + virtual_name;
 
@@ -583,7 +591,7 @@ std::string GetBundleDirectory() {
 #endif
 
 #ifdef _WIN32
-const std::string& GetExeDirectory() {
+std::string& GetExeDirectory() {
     static std::string exe_path;
     if (exe_path.empty()) {
         wchar_t wchar_exe_path[2048];
@@ -672,68 +680,67 @@ std::string GetSysDirectory() {
 
 // 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(UserPath path, const std::string& new_path) {
-    static std::unordered_map<UserPath, std::string> paths;
-    auto& user_path = paths[UserPath::UserDir];
+const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath) {
+    static std::string paths[NUM_PATH_INDICES];
 
     // Set up all paths and files on the first run
-    if (user_path.empty()) {
+    if (paths[D_USER_IDX].empty()) {
 #ifdef _WIN32
-        user_path = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
-        if (!FileUtil::IsDirectory(user_path)) {
-            user_path = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
+        paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
+        if (!FileUtil::IsDirectory(paths[D_USER_IDX])) {
+            paths[D_USER_IDX] = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
         } else {
             LOG_INFO(Common_Filesystem, "Using the local user directory");
         }
 
-        paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
-        paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
+        paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
+        paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
 #else
         if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
-            user_path = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
-            paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
-            paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
+            paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
+            paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
+            paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
         } else {
             std::string data_dir = GetUserDirectory("XDG_DATA_HOME");
             std::string config_dir = GetUserDirectory("XDG_CONFIG_HOME");
             std::string cache_dir = GetUserDirectory("XDG_CACHE_HOME");
 
-            user_path = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
-            paths.emplace(UserPath::ConfigDir, config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
-            paths.emplace(UserPath::CacheDir, cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
+            paths[D_USER_IDX] = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
+            paths[D_CONFIG_IDX] = config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
+            paths[D_CACHE_IDX] = cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
         }
 #endif
-        paths.emplace(UserPath::SDMCDir, user_path + SDMC_DIR DIR_SEP);
-        paths.emplace(UserPath::NANDDir, user_path + NAND_DIR DIR_SEP);
-        paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
+        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.emplace(UserPath::LogDir, user_path + LOG_DIR DIR_SEP);
+        paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOG_DIR DIR_SEP;
     }
 
-    if (!new_path.empty()) {
-        if (!FileUtil::IsDirectory(new_path)) {
-            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", new_path);
-            return paths[path];
+    if (!newPath.empty()) {
+        if (!FileUtil::IsDirectory(newPath)) {
+            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
+            return paths[DirIDX];
         } else {
-            paths[path] = new_path;
+            paths[DirIDX] = newPath;
         }
 
-        switch (path) {
-        case UserPath::RootDir:
-            user_path = paths[UserPath::RootDir] + DIR_SEP;
+        switch (DirIDX) {
+        case D_ROOT_IDX:
+            paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
             break;
 
-        case UserPath::UserDir:
-            user_path = paths[UserPath::RootDir] + DIR_SEP;
-            paths[UserPath::ConfigDir] = user_path + CONFIG_DIR DIR_SEP;
-            paths[UserPath::CacheDir] = user_path + CACHE_DIR DIR_SEP;
-            paths[UserPath::SDMCDir] = user_path + SDMC_DIR DIR_SEP;
-            paths[UserPath::NANDDir] = user_path + NAND_DIR DIR_SEP;
+        case D_USER_IDX:
+            paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
+            paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
+            paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+            paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
+            paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
             break;
         }
     }
 
-    return paths[path];
+    return paths[DirIDX];
 }
 
 size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
@@ -743,7 +750,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.IsOpen())
+    if (!file)
         return false;
 
     str.resize(static_cast<u32>(file.GetSize()));
@@ -792,93 +799,6 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
     }
 }
 
-std::vector<std::string> SplitPathComponents(std::string_view filename) {
-    std::string copy(filename);
-    std::replace(copy.begin(), copy.end(), '\\', '/');
-    std::vector<std::string> out;
-
-    std::stringstream stream(copy);
-    std::string item;
-    while (std::getline(stream, item, '/')) {
-        out.push_back(std::move(item));
-    }
-
-    return out;
-}
-
-std::string_view GetParentPath(std::string_view path) {
-    const auto name_bck_index = path.rfind('\\');
-    const auto name_fwd_index = path.rfind('/');
-    size_t name_index;
-
-    if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
-        name_index = std::min(name_bck_index, name_fwd_index);
-    } else {
-        name_index = std::max(name_bck_index, name_fwd_index);
-    }
-
-    return path.substr(0, name_index);
-}
-
-std::string_view GetPathWithoutTop(std::string_view path) {
-    if (path.empty()) {
-        return path;
-    }
-
-    while (path[0] == '\\' || path[0] == '/') {
-        path.remove_prefix(1);
-        if (path.empty()) {
-            return path;
-        }
-    }
-
-    const auto name_bck_index = path.find('\\');
-    const auto name_fwd_index = path.find('/');
-    return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
-}
-
-std::string_view GetFilename(std::string_view path) {
-    const auto name_index = path.find_last_of("\\/");
-
-    if (name_index == std::string_view::npos) {
-        return {};
-    }
-
-    return path.substr(name_index + 1);
-}
-
-std::string_view GetExtensionFromFilename(std::string_view name) {
-    const size_t index = name.rfind('.');
-
-    if (index == std::string_view::npos) {
-        return {};
-    }
-
-    return name.substr(index + 1);
-}
-
-std::string_view RemoveTrailingSlash(std::string_view path) {
-    if (path.empty()) {
-        return path;
-    }
-
-    if (path.back() == '\\' || path.back() == '/') {
-        path.remove_suffix(1);
-        return path;
-    }
-
-    return path;
-}
-
-std::string SanitizePath(std::string_view path_) {
-    std::string path(path_);
-    std::replace(path.begin(), path.end(), '\\', '/');
-    path.erase(std::unique(path.begin(), path.end(),
-                           [](char c1, char c2) { return c1 == '/' && c2 == '/'; }),
-               path.end());
-    return std::string(RemoveTrailingSlash(path));
-}
-
 IOFile::IOFile() {}
 
 IOFile::IOFile(const std::string& filename, const char openmode[], int flags) {
@@ -900,6 +820,7 @@ IOFile& IOFile::operator=(IOFile&& other) noexcept {
 
 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[], int flags) {
@@ -916,15 +837,16 @@ bool IOFile::Open(const std::string& filename, const char openmode[], int flags)
     m_file = fopen(filename.c_str(), openmode);
 #endif
 
-    return IsOpen();
+    m_good = IsOpen();
+    return m_good;
 }
 
 bool IOFile::Close() {
     if (!IsOpen() || 0 != std::fclose(m_file))
-        return false;
+        m_good = false;
 
     m_file = nullptr;
-    return true;
+    return m_good;
 }
 
 u64 IOFile::GetSize() const {
@@ -934,8 +856,11 @@ u64 IOFile::GetSize() const {
     return 0;
 }
 
-bool IOFile::Seek(s64 off, int origin) const {
-    return IsOpen() && 0 == fseeko(m_file, off, origin);
+bool IOFile::Seek(s64 off, int origin) {
+    if (!IsOpen() || 0 != fseeko(m_file, off, origin))
+        m_good = false;
+
+    return m_good;
 }
 
 u64 IOFile::Tell() const {
@@ -946,20 +871,26 @@ u64 IOFile::Tell() const {
 }
 
 bool IOFile::Flush() {
-    return IsOpen() && 0 == std::fflush(m_file);
+    if (!IsOpen() || 0 != std::fflush(m_file))
+        m_good = false;
+
+    return m_good;
 }
 
 bool IOFile::Resize(u64 size) {
-    return IsOpen() && 0 ==
+    if (!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

@@ -9,7 +9,6 @@
 #include <fstream>
 #include <functional>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 #include "common/common_types.h"
@@ -17,20 +16,21 @@
 #include "common/string_util.h"
 #endif
 
-namespace FileUtil {
-
-// User paths for GetUserPath
-enum class UserPath {
-    CacheDir,
-    ConfigDir,
-    LogDir,
-    NANDDir,
-    RootDir,
-    SDMCDir,
-    SysDataDir,
-    UserDir,
+// User directory indices for GetUserPath
+enum {
+    D_USER_IDX,
+    D_ROOT_IDX,
+    D_CONFIG_IDX,
+    D_CACHE_IDX,
+    D_SDMC_IDX,
+    D_NAND_IDX,
+    D_SYSDATA_IDX,
+    D_LOGS_IDX,
+    NUM_PATH_INDICES
 };
 
+namespace FileUtil {
+
 // FileSystem tree node/
 struct FSTEntry {
     bool isDirectory;
@@ -85,7 +85,7 @@ bool CreateEmptyFile(const std::string& filename);
  * @return whether handling the entry succeeded
  */
 using DirectoryEntryCallable = std::function<bool(
-    u64* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
+    unsigned* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
 
 /**
  * Scans a directory, calling the callback for each file/directory contained within.
@@ -96,7 +96,7 @@ using DirectoryEntryCallable = std::function<bool(
  * @param callback The callback which will be called for each entry
  * @return whether scanning the directory succeeded
  */
-bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
+bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback);
 
 /**
@@ -106,8 +106,8 @@ bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
  * @param recursion Number of children directories to read before giving up.
  * @return the total number of files/directories found
  */
-u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                      unsigned int recursion = 0);
+unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                           unsigned int recursion = 0);
 
 // deletes the given directory and anything under it. Returns true on success.
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
@@ -123,7 +123,7 @@ bool SetCurrentDir(const std::string& directory);
 
 // Returns a pointer to a string with a yuzu data dir in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
+const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath = "");
 
 // Returns the path to where the sys file are
 std::string GetSysDirectory();
@@ -133,7 +133,7 @@ std::string GetBundleDirectory();
 #endif
 
 #ifdef _WIN32
-const std::string& GetExeDirectory();
+std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
@@ -150,37 +150,6 @@ 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(std::string_view filename);
-
-// Gets all of the text up to the last '/' or '\' in the path.
-std::string_view GetParentPath(std::string_view path);
-
-// Gets all of the text after the first '/' or '\' in the path.
-std::string_view GetPathWithoutTop(std::string_view path);
-
-// Gets the filename of the path
-std::string_view GetFilename(std::string_view path);
-
-// Gets the extension of the filename
-std::string_view GetExtensionFromFilename(std::string_view name);
-
-// Removes the final '/' or '\' if one exists
-std::string_view RemoveTrailingSlash(std::string_view 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);
-}
-
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'.
-std::string SanitizePath(std::string_view path);
-
 // simple wrapper for cstdlib file functions to
 // hopefully will make error checking easier
 // and make forgetting an fclose() harder
@@ -203,27 +172,41 @@ public:
     bool Close();
 
     template <typename T>
-    size_t ReadArray(T* data, size_t length) const {
+    size_t ReadArray(T* data, size_t length) {
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
 
-        if (!IsOpen())
+        if (!IsOpen()) {
+            m_good = false;
             return -1;
+        }
 
-        return std::fread(data, sizeof(T), length, m_file);
+        size_t items_read = std::fread(data, sizeof(T), length, m_file);
+        if (items_read != length)
+            m_good = false;
+
+        return items_read;
     }
 
     template <typename T>
     size_t WriteArray(const T* data, size_t length) {
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-        if (!IsOpen())
+
+        if (!IsOpen()) {
+            m_good = false;
             return -1;
-        return std::fwrite(data, sizeof(T), length, m_file);
+        }
+
+        size_t items_written = std::fwrite(data, sizeof(T), length, m_file);
+        if (items_written != length)
+            m_good = false;
+
+        return items_written;
     }
 
     template <typename T>
-    size_t ReadBytes(T* data, size_t length) const {
+    size_t ReadBytes(T* data, size_t length) {
         static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
@@ -248,7 +231,15 @@ public:
         return nullptr != m_file;
     }
 
-    bool Seek(s64 off, int origin) const;
+    // 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);
     u64 Tell() const;
     u64 GetSize() const;
     bool Resize(u64 size);
@@ -256,11 +247,13 @@ 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/logging/backend.cpp

@@ -3,20 +3,18 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <atomic>
+#include <array>
 #include <chrono>
-#include <climits>
 #include <condition_variable>
 #include <memory>
-#include <mutex>
 #include <thread>
-#include <vector>
 #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/log.h"
 #include "common/logging/text_formatter.h"
@@ -49,11 +47,11 @@ public:
         backends.push_back(std::move(backend));
     }
 
-    void RemoveBackend(std::string_view backend_name) {
+    void RemoveBackend(const std::string& backend_name) {
         std::lock_guard<std::mutex> lock(writing_mutex);
-        const auto it =
-            std::remove_if(backends.begin(), backends.end(),
-                           [&backend_name](const auto& i) { return backend_name == i->GetName(); });
+        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());
     }
 
@@ -65,10 +63,10 @@ public:
         filter = f;
     }
 
-    Backend* GetBackend(std::string_view backend_name) {
-        const auto it =
-            std::find_if(backends.begin(), backends.end(),
-                         [&backend_name](const auto& i) { return backend_name == i->GetName(); });
+    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();
@@ -85,10 +83,8 @@ private:
                 }
             };
             while (true) {
-                {
-                    std::unique_lock<std::mutex> lock(message_mutex);
-                    message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
-                }
+                std::unique_lock<std::mutex> lock(message_mutex);
+                message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
                 if (!running) {
                     break;
                 }
@@ -96,7 +92,7 @@ private:
             }
             // 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;
+            constexpr int MAX_LOGS_TO_WRITE = 100;
             int logs_written = 0;
             while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
                 write_logs(entry);
@@ -173,11 +169,8 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
-    SUB(Service, LBL)                                                                              \
-    SUB(Service, LDN)                                                                              \
     SUB(Service, LM)                                                                               \
     SUB(Service, MM)                                                                               \
-    SUB(Service, NFC)                                                                              \
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NS)                                                                               \
@@ -269,11 +262,11 @@ void AddBackend(std::unique_ptr<Backend> backend) {
     Impl::Instance().AddBackend(std::move(backend));
 }
 
-void RemoveBackend(std::string_view backend_name) {
+void RemoveBackend(const std::string& backend_name) {
     Impl::Instance().RemoveBackend(backend_name);
 }
 
-Backend* GetBackend(std::string_view backend_name) {
+Backend* GetBackend(const std::string& backend_name) {
     return Impl::Instance().GetBackend(backend_name);
 }
 
@@ -289,4 +282,4 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
 
     Impl::Instance().PushEntry(std::move(entry));
 }
-} // namespace Log
+} // namespace Log

src/common/logging/backend.h

@@ -4,9 +4,10 @@
 #pragma once
 
 #include <chrono>
+#include <cstdarg>
 #include <memory>
 #include <string>
-#include <string_view>
+#include <utility>
 #include "common/file_util.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
@@ -105,9 +106,9 @@ private:
 
 void AddBackend(std::unique_ptr<Backend> backend);
 
-void RemoveBackend(std::string_view backend_name);
+void RemoveBackend(const std::string& backend_name);
 
-Backend* GetBackend(std::string_view 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

src/common/logging/filter.cpp

@@ -8,9 +8,39 @@
 #include "common/string_util.h"
 
 namespace Log {
-namespace {
+
+Filter::Filter(Level default_level) {
+    ResetAll(default_level);
+}
+
+void Filter::ResetAll(Level level) {
+    class_levels.fill(level);
+}
+
+void Filter::SetClassLevel(Class log_class, Level level) {
+    class_levels[static_cast<size_t>(log_class)] = level;
+}
+
+void Filter::ParseFilterString(const std::string& filter_str) {
+    auto clause_begin = filter_str.cbegin();
+    while (clause_begin != filter_str.cend()) {
+        auto clause_end = std::find(clause_begin, filter_str.cend(), ' ');
+
+        // If clause isn't empty
+        if (clause_end != clause_begin) {
+            ParseFilterRule(clause_begin, clause_end);
+        }
+
+        if (clause_end != filter_str.cend()) {
+            // Skip over the whitespace
+            ++clause_end;
+        }
+        clause_begin = clause_end;
+    }
+}
+
 template <typename It>
-Level GetLevelByName(const It begin, const It end) {
+static Level GetLevelByName(const It begin, const It end) {
     for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
         const char* level_name = GetLevelName(static_cast<Level>(i));
         if (Common::ComparePartialString(begin, end, level_name)) {
@@ -21,7 +51,7 @@ Level GetLevelByName(const It begin, const It end) {
 }
 
 template <typename It>
-Class GetClassByName(const It begin, const It end) {
+static Class GetClassByName(const It begin, const It end) {
     for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
         const char* level_name = GetLogClassName(static_cast<Class>(i));
         if (Common::ComparePartialString(begin, end, level_name)) {
@@ -31,8 +61,8 @@ Class GetClassByName(const It begin, const It end) {
     return Class::Count;
 }
 
-template <typename Iterator>
-bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
+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) {
         LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
@@ -47,7 +77,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     }
 
     if (Common::ComparePartialString(begin, level_separator, "*")) {
-        instance.ResetAll(level);
+        ResetAll(level);
         return true;
     }
 
@@ -57,49 +87,11 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
         return false;
     }
 
-    instance.SetClassLevel(log_class, level);
+    SetClassLevel(log_class, level);
     return true;
 }
-} // Anonymous namespace
-
-Filter::Filter(Level default_level) {
-    ResetAll(default_level);
-}
-
-void Filter::ResetAll(Level level) {
-    class_levels.fill(level);
-}
-
-void Filter::SetClassLevel(Class log_class, Level level) {
-    class_levels[static_cast<size_t>(log_class)] = level;
-}
-
-void Filter::ParseFilterString(std::string_view filter_view) {
-    auto clause_begin = filter_view.cbegin();
-    while (clause_begin != filter_view.cend()) {
-        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
-
-        // If clause isn't empty
-        if (clause_end != clause_begin) {
-            ParseFilterRule(*this, clause_begin, clause_end);
-        }
-
-        if (clause_end != filter_view.cend()) {
-            // Skip over the whitespace
-            ++clause_end;
-        }
-        clause_begin = clause_end;
-    }
-}
 
 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

@@ -6,7 +6,7 @@
 
 #include <array>
 #include <cstddef>
-#include <string_view>
+#include <string>
 #include "common/logging/log.h"
 
 namespace Log {
@@ -40,14 +40,13 @@ public:
      *  - `Service:Info` -- Sets the level of Service to Info.
      *  - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
      */
-    void ParseFilterString(std::string_view filter_view);
+    void ParseFilterString(const std::string& filter_str);
+    bool ParseFilterRule(const std::string::const_iterator start,
+                         const std::string::const_iterator end);
 
     /// 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

@@ -60,11 +60,8 @@ enum class Class : ClassType {
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service
-    Service_LBL,       ///< The LBL (LCD backlight) service
-    Service_LDN,       ///< The LDN (Local domain network) service
     Service_LM,        ///< The LM (Logger) service
     Service_MM,        ///< The MM (Multimedia) service
-    Service_NFC,       ///< The NFC (Near-field communication) service
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NS,        ///< The NS services
@@ -106,7 +103,7 @@ template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                    const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
-                      fmt::make_format_args(args...));
+                      fmt::make_args(args...));
 }
 
 } // namespace Log

src/common/logging/text_formatter.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <cstddef>
-#include <string>
 
 namespace Log {
 

src/common/misc.cpp

@@ -4,28 +4,34 @@
 
 #include <cstddef>
 #ifdef _WIN32
-#include <Windows.h>
+#include <windows.h>
 #else
 #include <cerrno>
 #include <cstring>
 #endif
 
-#include "common/common_funcs.h"
+// Neither Android nor OS X support TLS
+#if defined(__APPLE__) || (ANDROID && __clang__)
+#define __thread
+#endif
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
-std::string GetLastErrorMsg() {
+const char* GetLastErrorMsg() {
     static const size_t buff_size = 255;
-    char err_str[buff_size];
 
 #ifdef _WIN32
+    static __declspec(thread) char err_str[buff_size] = {};
+
     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
 #else
+    static __thread char err_str[buff_size] = {};
+
     // Thread safe (XSI-compliant)
     strerror_r(errno, err_str, buff_size);
 #endif
 
-    return std::string(err_str, buff_size);
+    return err_str;
 }

src/common/param_package.cpp

@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <array>
-#include <utility>
 #include <vector>
-
 #include "common/logging/log.h"
 #include "common/param_package.h"
 #include "common/string_util.h"
@@ -14,11 +12,10 @@ namespace Common {
 
 constexpr char KEY_VALUE_SEPARATOR = ':';
 constexpr char PARAM_SEPARATOR = ',';
-
 constexpr char ESCAPE_CHARACTER = '$';
-constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
-constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
-constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
+const std::string KEY_VALUE_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '0'};
+const std::string PARAM_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '1'};
+const std::string ESCAPE_CHARACTER_ESCAPE{ESCAPE_CHARACTER, '2'};
 
 ParamPackage::ParamPackage(const std::string& serialized) {
     std::vector<std::string> pairs;
@@ -38,7 +35,7 @@ ParamPackage::ParamPackage(const std::string& serialized) {
             part = Common::ReplaceAll(part, ESCAPE_CHARACTER_ESCAPE, {ESCAPE_CHARACTER});
         }
 
-        Set(key_value[0], std::move(key_value[1]));
+        Set(key_value[0], key_value[1]);
     }
 }
 
@@ -104,16 +101,16 @@ float ParamPackage::Get(const std::string& key, float default_value) const {
     }
 }
 
-void ParamPackage::Set(const std::string& key, std::string value) {
-    data.insert_or_assign(key, std::move(value));
+void ParamPackage::Set(const std::string& key, const std::string& value) {
+    data[key] = value;
 }
 
 void ParamPackage::Set(const std::string& key, int value) {
-    data.insert_or_assign(key, std::to_string(value));
+    data[key] = std::to_string(value);
 }
 
 void ParamPackage::Set(const std::string& key, float value) {
-    data.insert_or_assign(key, std::to_string(value));
+    data[key] = std::to_string(value);
 }
 
 bool ParamPackage::Has(const std::string& key) const {

src/common/param_package.h

@@ -28,7 +28,7 @@ public:
     std::string Get(const std::string& key, const std::string& default_value) const;
     int Get(const std::string& key, int default_value) const;
     float Get(const std::string& key, float default_value) const;
-    void Set(const std::string& key, std::string value);
+    void Set(const std::string& key, const std::string& value);
     void Set(const std::string& key, int value);
     void Set(const std::string& key, float value);
     bool Has(const std::string& key) const;

src/common/string_util.cpp

@@ -34,6 +34,18 @@ std::string ToUpper(std::string str) {
     return str;
 }
 
+// faster than sscanf
+bool AsciiToHex(const char* _szValue, u32& result) {
+    char* endptr = nullptr;
+    const u32 value = strtoul(_szValue, &endptr, 16);
+
+    if (!endptr || *endptr)
+        return false;
+
+    result = value;
+    return true;
+}
+
 // For Debugging. Read out an u8 array.
 std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
     std::ostringstream oss;
@@ -162,21 +174,21 @@ void SplitString(const std::string& str, const char delim, std::vector<std::stri
     std::istringstream iss(str);
     output.resize(1);
 
-    while (std::getline(iss, *output.rbegin(), delim)) {
-        output.emplace_back();
-    }
+    while (std::getline(iss, *output.rbegin(), delim))
+        output.push_back("");
 
     output.pop_back();
 }
 
-std::string TabsToSpaces(int tab_size, std::string in) {
+std::string TabsToSpaces(int tab_size, const std::string& in) {
+    const std::string spaces(tab_size, ' ');
+    std::string out(in);
+
     size_t i = 0;
+    while (out.npos != (i = out.find('\t')))
+        out.replace(i, 1, spaces);
 
-    while ((i = in.find('\t')) != std::string::npos) {
-        in.replace(i, 1, tab_size, ' ');
-    }
-
-    return in;
+    return out;
 }
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
@@ -220,37 +232,31 @@ std::u16string UTF8ToUTF16(const std::string& input) {
 }
 
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
-    const auto size =
+    auto const size =
         MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
 
-    if (size == 0) {
-        return L"";
-    }
+    std::wstring output;
+    output.resize(size);
 
-    std::wstring output(size, L'\0');
-
-    if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size()))) {
+    if (size == 0 ||
+        size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size())))
         output.clear();
-    }
 
     return output;
 }
 
 std::string UTF16ToUTF8(const std::wstring& input) {
-    const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+    auto const size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
                                           nullptr, 0, nullptr, nullptr);
-    if (size == 0) {
-        return "";
-    }
 
-    std::string output(size, '\0');
+    std::string output;
+    output.resize(size);
 
-    if (size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size()), nullptr,
-                                    nullptr)) {
+    if (size == 0 ||
+        size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()), nullptr, nullptr))
         output.clear();
-    }
 
     return output;
 }
@@ -271,6 +277,8 @@ std::string CP1252ToUTF8(const std::string& input) {
 
 template <typename T>
 static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) {
+    std::string result;
+
     iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
     if ((iconv_t)(-1) == conv_desc) {
         LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
@@ -282,7 +290,8 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * in_bytes;
 
-    std::string out_buffer(out_buffer_size, '\0');
+    std::string out_buffer;
+    out_buffer.resize(out_buffer_size);
 
     auto src_buffer = &input[0];
     size_t src_bytes = in_bytes;
@@ -307,7 +316,6 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
         }
     }
 
-    std::string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 
@@ -317,6 +325,8 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
+    std::u16string result;
+
     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]: {}", strerror(errno));
@@ -328,7 +338,8 @@ std::u16string UTF8ToUTF16(const std::string& input) {
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
 
-    std::u16string out_buffer(out_buffer_size, char16_t{});
+    std::u16string out_buffer;
+    out_buffer.resize(out_buffer_size);
 
     char* src_buffer = const_cast<char*>(&input[0]);
     size_t src_bytes = in_bytes;
@@ -353,7 +364,6 @@ std::u16string UTF8ToUTF16(const std::string& input) {
         }
     }
 
-    std::u16string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 

src/common/string_util.h

@@ -57,7 +57,10 @@ static bool TryParse(const std::string& str, N* const output) {
         return false;
 }
 
-std::string TabsToSpaces(int tab_size, std::string in);
+// TODO: kill this
+bool AsciiToHex(const char* _szValue, u32& result);
+
+std::string TabsToSpaces(int tab_size, const std::string& in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
 

src/common/swap.h

@@ -167,7 +167,7 @@ inline double swapd(double f) {
 
 template <typename T, typename F>
 struct swap_struct_t {
-    using swapped_t = swap_struct_t;
+    typedef swap_struct_t<T, F> swapped_t;
 
 protected:
     T value = T();
@@ -177,7 +177,7 @@ protected:
     }
 
 public:
-    T swap() const {
+    T const swap() const {
         return swap(value);
     }
     swap_struct_t() = default;
@@ -185,39 +185,39 @@ public:
 
     template <typename S>
     swapped_t& operator=(const S& source) {
-        value = swap(static_cast<T>(source));
+        value = swap((T)source);
         return *this;
     }
 
     operator s8() const {
-        return static_cast<s8>(swap());
+        return (s8)swap();
     }
     operator u8() const {
-        return static_cast<u8>(swap());
+        return (u8)swap();
     }
     operator s16() const {
-        return static_cast<s16>(swap());
+        return (s16)swap();
     }
     operator u16() const {
-        return static_cast<u16>(swap());
+        return (u16)swap();
     }
     operator s32() const {
-        return static_cast<s32>(swap());
+        return (s32)swap();
     }
     operator u32() const {
-        return static_cast<u32>(swap());
+        return (u32)swap();
     }
     operator s64() const {
-        return static_cast<s64>(swap());
+        return (s64)swap();
     }
     operator u64() const {
-        return static_cast<u64>(swap());
+        return (u64)swap();
     }
     operator float() const {
-        return static_cast<float>(swap());
+        return (float)swap();
     }
     operator double() const {
-        return static_cast<double>(swap());
+        return (double)swap();
     }
 
     // +v
@@ -253,7 +253,7 @@ public:
     }
     template <typename S>
     swapped_t operator+(const S& i) const {
-        return swap() + static_cast<T>(i);
+        return swap() + (T)i;
     }
     // v - 5
     swapped_t operator-(const swapped_t& i) const {
@@ -261,7 +261,7 @@ public:
     }
     template <typename S>
     swapped_t operator-(const S& i) const {
-        return swap() - static_cast<T>(i);
+        return swap() - (T)i;
     }
 
     // v += 5
@@ -271,7 +271,7 @@ public:
     }
     template <typename S>
     swapped_t& operator+=(const S& i) {
-        value = swap(swap() + static_cast<T>(i));
+        value = swap(swap() + (T)i);
         return *this;
     }
     // v -= 5
@@ -281,7 +281,7 @@ public:
     }
     template <typename S>
     swapped_t& operator-=(const S& i) {
-        value = swap(swap() - static_cast<T>(i));
+        value = swap(swap() - (T)i);
         return *this;
     }
 
@@ -541,7 +541,7 @@ S operator&(const S& i, const swap_struct_t<T, F> v) {
 
 template <typename S, typename T, typename F>
 S operator&(const swap_struct_t<T, F> v, const S& i) {
-    return static_cast<S>(v.swap() & i);
+    return (S)(v.swap() & i);
 }
 
 // Comparaison
@@ -606,51 +606,51 @@ struct swap_double_t {
 };
 
 #if COMMON_LITTLE_ENDIAN
-using u16_le = u16;
-using u32_le = u32;
-using u64_le = u64;
+typedef u32 u32_le;
+typedef u16 u16_le;
+typedef u64 u64_le;
 
-using s16_le = s16;
-using s32_le = s32;
-using s64_le = s64;
+typedef s32 s32_le;
+typedef s16 s16_le;
+typedef s64 s64_le;
 
-using float_le = float;
-using double_le = double;
+typedef float float_le;
+typedef double double_le;
 
-using u64_be = swap_struct_t<u64, swap_64_t<u64>>;
-using s64_be = swap_struct_t<s64, swap_64_t<s64>>;
+typedef swap_struct_t<u64, swap_64_t<u64>> u64_be;
+typedef swap_struct_t<s64, swap_64_t<s64>> s64_be;
 
-using u32_be = swap_struct_t<u32, swap_32_t<u32>>;
-using s32_be = swap_struct_t<s32, swap_32_t<s32>>;
+typedef swap_struct_t<u32, swap_32_t<u32>> u32_be;
+typedef swap_struct_t<s32, swap_32_t<s32>> s32_be;
 
-using u16_be = swap_struct_t<u16, swap_16_t<u16>>;
-using s16_be = swap_struct_t<s16, swap_16_t<s16>>;
+typedef swap_struct_t<u16, swap_16_t<u16>> u16_be;
+typedef swap_struct_t<s16, swap_16_t<s16>> s16_be;
 
-using float_be = swap_struct_t<float, swap_float_t<float>>;
-using double_be = swap_struct_t<double, swap_double_t<double>>;
+typedef swap_struct_t<float, swap_float_t<float>> float_be;
+typedef swap_struct_t<double, swap_double_t<double>> double_be;
 #else
 
-using u64_le = swap_struct_t<u64, swap_64_t<u64>>;
-using s64_le = swap_struct_t<s64, swap_64_t<s64>>;
+typedef swap_struct_t<u64, swap_64_t<u64>> u64_le;
+typedef swap_struct_t<s64, swap_64_t<s64>> s64_le;
 
-using u32_le = swap_struct_t<u32, swap_32_t<u32>>;
-using s32_le = swap_struct_t<s32, swap_32_t<s32>>;
+typedef swap_struct_t<u32, swap_32_t<u32>> u32_le;
+typedef swap_struct_t<s32, swap_32_t<s32>> s32_le;
 
-using u16_le = swap_struct_t<u16, swap_16_t<u16>>;
-using s16_le = swap_struct_t<s16, swap_16_t<s16>>;
+typedef swap_struct_t<u16, swap_16_t<u16>> u16_le;
+typedef swap_struct_t<s16, swap_16_t<s16>> s16_le;
 
-using float_le = swap_struct_t<float, swap_float_t<float>>;
-using double_le = swap_struct_t<double, swap_double_t<double>>;
+typedef swap_struct_t<float, swap_float_t<float>> float_le;
+typedef swap_struct_t<double, swap_double_t<double>> double_le;
 
-using u16_be = u16;
-using u32_be = u32;
-using u64_be = u64;
+typedef u32 u32_be;
+typedef u16 u16_be;
+typedef u64 u64_be;
 
-using s16_be = s16;
-using s32_be = s32;
-using s64_be = s64;
+typedef s32 s32_be;
+typedef s16 s16_be;
+typedef s64 s64_be;
 
-using float_be = float;
-using double_be = double;
+typedef float float_be;
+typedef double double_be;
 
 #endif

src/common/synchronized_wrapper.h

@@ -0,0 +1,85 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <algorithm>
+#include <mutex>
+
+namespace Common {
+
+template <typename T>
+class SynchronizedWrapper;
+
+/**
+ * Synchronized reference, that keeps a SynchronizedWrapper's mutex locked during its lifetime. This
+ * greatly reduces the chance that someone will access the wrapped resource without locking the
+ * mutex.
+ */
+template <typename T>
+class SynchronizedRef {
+public:
+    SynchronizedRef(SynchronizedWrapper<T>& wrapper) : wrapper(&wrapper) {
+        wrapper.mutex.lock();
+    }
+
+    SynchronizedRef(SynchronizedRef&) = delete;
+    SynchronizedRef(SynchronizedRef&& o) : wrapper(o.wrapper) {
+        o.wrapper = nullptr;
+    }
+
+    ~SynchronizedRef() {
+        if (wrapper)
+            wrapper->mutex.unlock();
+    }
+
+    SynchronizedRef& operator=(SynchronizedRef&) = delete;
+    SynchronizedRef& operator=(SynchronizedRef&& o) {
+        std::swap(wrapper, o.wrapper);
+        return *this;
+    }
+
+    T& operator*() {
+        return wrapper->data;
+    }
+    const T& operator*() const {
+        return wrapper->data;
+    }
+
+    T* operator->() {
+        return &wrapper->data;
+    }
+    const T* operator->() const {
+        return &wrapper->data;
+    }
+
+private:
+    SynchronizedWrapper<T>* wrapper;
+};
+
+/**
+ * Wraps an object, only allowing access to it via a locking reference wrapper. Good to ensure no
+ * one forgets to lock a mutex before acessing an object. To access the wrapped object construct a
+ * SyncronizedRef on this wrapper. Inspired by Rust's Mutex type
+ * (http://doc.rust-lang.org/std/sync/struct.Mutex.html).
+ */
+template <typename T>
+class SynchronizedWrapper {
+public:
+    template <typename... Args>
+    SynchronizedWrapper(Args&&... args) : data(std::forward<Args>(args)...) {}
+
+    SynchronizedRef<T> Lock() {
+        return {*this};
+    }
+
+private:
+    template <typename U>
+    friend class SynchronizedRef;
+
+    std::mutex mutex;
+    T data;
+};
+
+} // namespace Common

src/common/telemetry.h

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

src/core/CMakeLists.txt

@@ -1,7 +1,5 @@
 add_library(core STATIC
     arm/arm_interface.h
-    arm/exclusive_monitor.cpp
-    arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
     arm/unicorn/arm_unicorn.h
     core.cpp
@@ -10,35 +8,27 @@ add_library(core STATIC
     core_cpu.h
     core_timing.cpp
     core_timing.h
-    core_timing_util.cpp
-    core_timing_util.h
-    file_sys/content_archive.cpp
-    file_sys/content_archive.h
-    file_sys/control_metadata.cpp
-    file_sys/control_metadata.h
     file_sys/directory.h
+    file_sys/disk_filesystem.cpp
+    file_sys/disk_filesystem.h
     file_sys/errors.h
-    file_sys/mode.h
+    file_sys/filesystem.cpp
+    file_sys/filesystem.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.cpp
-    file_sys/romfs.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/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
-    file_sys/vfs_vector.cpp
-    file_sys/vfs_vector.h
+    file_sys/storage.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -46,6 +36,8 @@ add_library(core STATIC
     frontend/input.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
+    hle/config_mem.cpp
+    hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/address_arbiter.cpp
@@ -120,34 +112,26 @@ add_library(core STATIC
     hle/service/apm/apm.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
-    hle/service/audio/audin_u.cpp
-    hle/service/audio/audin_u.h
     hle/service/audio/audio.cpp
     hle/service/audio/audio.h
+    hle/service/audio/audin_u.cpp
+    hle/service/audio/audin_u.h
     hle/service/audio/audout_u.cpp
     hle/service/audio/audout_u.h
     hle/service/audio/audrec_u.cpp
     hle/service/audio/audrec_u.h
     hle/service/audio/audren_u.cpp
-    hle/service/audio/audren_u.cpp
     hle/service/audio/audren_u.h
+    hle/service/audio/audren_u.cpp
     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/bcat.cpp
-    hle/service/bcat/bcat.h
     hle/service/bcat/module.cpp
     hle/service/bcat/module.h
-    hle/service/btdrv/btdrv.cpp
-    hle/service/btdrv/btdrv.h
-    hle/service/erpt/erpt.cpp
-    hle/service/erpt/erpt.h
-    hle/service/es/es.cpp
-    hle/service/es/es.h
-    hle/service/eupld/eupld.cpp
-    hle/service/eupld/eupld.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
@@ -160,36 +144,28 @@ add_library(core STATIC
     hle/service/filesystem/fsp_srv.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
-    hle/service/friend/interface.cpp
-    hle/service/friend/interface.h
-    hle/service/grc/grc.cpp
-    hle/service/grc/grc.h
+    hle/service/friend/friend_a.cpp
+    hle/service/friend/friend_a.h
+    hle/service/friend/friend_u.cpp
+    hle/service/friend/friend_u.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
-    hle/service/hid/irs.cpp
-    hle/service/hid/irs.h
-    hle/service/hid/xcd.cpp
-    hle/service/hid/xcd.h
-    hle/service/lbl/lbl.cpp
-    hle/service/lbl/lbl.h
-    hle/service/ldn/ldn.cpp
-    hle/service/ldn/ldn.h
-    hle/service/ldr/ldr.cpp
-    hle/service/ldr/ldr.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/nfc/nfc.cpp
-    hle/service/nfc/nfc.h
+    hle/service/nifm/nifm.cpp
+    hle/service/nifm/nifm.h
+    hle/service/nifm/nifm_a.cpp
+    hle/service/nifm/nifm_a.h
+    hle/service/nifm/nifm_s.cpp
+    hle/service/nifm/nifm_s.h
+    hle/service/nifm/nifm_u.cpp
+    hle/service/nifm/nifm_u.h
     hle/service/nfp/nfp.cpp
     hle/service/nfp/nfp.h
     hle/service/nfp/nfp_user.cpp
     hle/service/nfp/nfp_user.h
-    hle/service/nifm/nifm.cpp
-    hle/service/nifm/nifm.h
-    hle/service/nim/nim.cpp
-    hle/service/nim/nim.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -223,8 +199,6 @@ add_library(core STATIC
     hle/service/pctl/module.h
     hle/service/pctl/pctl.cpp
     hle/service/pctl/pctl.h
-    hle/service/pm/pm.cpp
-    hle/service/pm/pm.h
     hle/service/prepo/prepo.cpp
     hle/service/prepo/prepo.h
     hle/service/service.cpp
@@ -245,8 +219,6 @@ add_library(core STATIC
     hle/service/sm/sm.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
-    hle/service/sockets/ethc.cpp
-    hle/service/sockets/ethc.h
     hle/service/sockets/nsd.cpp
     hle/service/sockets/nsd.h
     hle/service/sockets/sfdnsres.cpp
@@ -261,10 +233,12 @@ add_library(core STATIC
     hle/service/spl/spl.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
-    hle/service/time/interface.cpp
-    hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
+    hle/service/time/time_s.cpp
+    hle/service/time/time_s.h
+    hle/service/time/time_u.cpp
+    hle/service/time/time_u.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp
@@ -273,6 +247,8 @@ add_library(core STATIC
     hle/service/vi/vi_s.h
     hle/service/vi/vi_u.cpp
     hle/service/vi/vi_u.h
+    hle/shared_page.cpp
+    hle/shared_page.h
     hw/hw.cpp
     hw/hw.h
     hw/lcd.cpp
@@ -309,7 +285,7 @@ add_library(core STATIC
 
 create_target_directory_groups(core)
 
-target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
+target_link_libraries(core PUBLIC common PRIVATE video_core)
 target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static unicorn)
 
 if (ARCHITECTURE_x86_64)

src/core/arm/arm_interface.h

@@ -20,6 +20,9 @@ public:
         u64 cpsr;
         std::array<u128, 32> fpu_registers;
         u64 fpscr;
+
+        // TODO(bunnei): Fix once we have proper support for tpidrro_el0, etc. in the JIT
+        VAddr tls_address;
     };
 
     /// Runs the CPU until an event happens
@@ -101,10 +104,6 @@ public:
 
     virtual void SetTlsAddress(VAddr address) = 0;
 
-    virtual u64 GetTPIDR_EL0() const = 0;
-
-    virtual void SetTPIDR_EL0(u64 value) = 0;
-
     /**
      * Saves the current CPU context
      * @param ctx Thread context to save
@@ -117,8 +116,6 @@ 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

@@ -102,28 +102,18 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
-    auto** const page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
+std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
+    const auto page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
-
-    // Callbacks
     config.callbacks = cb.get();
-
-    // Memory
-    config.page_table = reinterpret_cast<void**>(page_table);
-    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
-    config.silently_mirror_page_table = false;
-
-    // Multi-process state
-    config.processor_id = core_index;
-    config.global_monitor = &exclusive_monitor->monitor;
-
-    // System registers
     config.tpidrro_el0 = &cb->tpidrro_el0;
     config.tpidr_el0 = &cb->tpidr_el0;
     config.dczid_el0 = 4;
     config.ctr_el0 = 0x8444c004;
+    config.page_table = reinterpret_cast<void**>(page_table);
+    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
+    config.silently_mirror_page_table = false;
 
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
@@ -138,11 +128,8 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index)
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)),
-      jit(MakeJit()), exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(
-                          exclusive_monitor)},
-      core_index{core_index} {
+ARM_Dynarmic::ARM_Dynarmic()
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
     ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
@@ -209,14 +196,6 @@ void ARM_Dynarmic::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
-u64 ARM_Dynarmic::GetTPIDR_EL0() const {
-    return cb->tpidr_el0;
-}
-
-void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
-    cb->tpidr_el0 = value;
-}
-
 void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
@@ -224,6 +203,7 @@ void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpsr = jit->GetPstate();
     ctx.fpu_registers = jit->GetVectors();
     ctx.fpscr = jit->GetFpcr();
+    ctx.tls_address = cb->tpidrro_el0;
 }
 
 void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
@@ -233,6 +213,7 @@ void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
     jit->SetPstate(static_cast<u32>(ctx.cpsr));
     jit->SetVectors(ctx.fpu_registers);
     jit->SetFpcr(static_cast<u32>(ctx.fpscr));
+    cb->tpidrro_el0 = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
@@ -245,50 +226,7 @@ void ARM_Dynarmic::ClearInstructionCache() {
     jit->ClearCache();
 }
 
-void ARM_Dynarmic::ClearExclusiveState() {
-    jit->ClearExclusiveState();
-}
-
 void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit();
+    jit = MakeJit(cb);
     current_page_table = Memory::GetCurrentPageTable();
 }
-
-DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(size_t core_count) : monitor(core_count) {}
-DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;
-
-void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, VAddr addr) {
-    // Size doesn't actually matter.
-    monitor.Mark(core_index, addr, 16);
-}
-
-void DynarmicExclusiveMonitor::ClearExclusive() {
-    monitor.Clear();
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 1,
-                                        [&] { Memory::Write8(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 2,
-                                        [&] { Memory::Write16(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 4,
-                                        [&] { Memory::Write32(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 8,
-                                        [&] { Memory::Write64(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 16, [&] {
-        Memory::Write64(vaddr, value[0]);
-        Memory::Write64(vaddr, value[1]);
-    });
-}

src/core/arm/dynarmic/arm_dynarmic.h

@@ -6,18 +6,15 @@
 
 #include <memory>
 #include <dynarmic/A64/a64.h>
-#include <dynarmic/A64/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "core/arm/arm_interface.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
 class ARM_Dynarmic_Callbacks;
-class DynarmicExclusiveMonitor;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index);
+    ARM_Dynarmic();
     ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, size_t size, u8* memory,
@@ -37,47 +34,20 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
 
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
-    void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;
 
 private:
-    std::unique_ptr<Dynarmic::A64::Jit> MakeJit() const;
-
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
     std::unique_ptr<Dynarmic::A64::Jit> jit;
     ARM_Unicorn inner_unicorn;
 
-    size_t core_index;
-    std::shared_ptr<DynarmicExclusiveMonitor> exclusive_monitor;
-
     Memory::PageTable* current_page_table = nullptr;
 };
-
-class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
-public:
-    explicit DynarmicExclusiveMonitor(size_t core_count);
-    ~DynarmicExclusiveMonitor();
-
-    void SetExclusive(size_t core_index, VAddr addr) override;
-    void ClearExclusive() override;
-
-    bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) override;
-    bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) override;
-    bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) override;
-    bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) override;
-    bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) override;
-
-private:
-    friend class ARM_Dynarmic;
-    Dynarmic::A64::ExclusiveMonitor monitor;
-};

src/core/arm/exclusive_monitor.cpp

@@ -1,7 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/arm/exclusive_monitor.h"
-
-ExclusiveMonitor::~ExclusiveMonitor() = default;

src/core/arm/exclusive_monitor.h

@@ -1,21 +0,0 @@
-// 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"
-
-class ExclusiveMonitor {
-public:
-    virtual ~ExclusiveMonitor();
-
-    virtual void SetExclusive(size_t core_index, VAddr addr) = 0;
-    virtual void ClearExclusive() = 0;
-
-    virtual bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) = 0;
-    virtual bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) = 0;
-    virtual bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) = 0;
-    virtual bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) = 0;
-    virtual bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) = 0;
-};

src/core/arm/unicorn/arm_unicorn.cpp

@@ -169,16 +169,6 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
 }
 
-u64 ARM_Unicorn::GetTPIDR_EL0() const {
-    u64 value{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDR_EL0, &value));
-    return value;
-}
-
-void ARM_Unicorn::SetTPIDR_EL0(u64 value) {
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDR_EL0, &value));
-}
-
 void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));
@@ -230,6 +220,8 @@ void ARM_Unicorn::SaveContext(ARM_Interface::ThreadContext& ctx) {
 
     CHECKED(uc_reg_read_batch(uc, uregs, tregs, 31));
 
+    ctx.tls_address = GetTlsAddress();
+
     for (int i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
         tregs[i] = &ctx.fpu_registers[i];
@@ -257,6 +249,8 @@ void ARM_Unicorn::LoadContext(const ARM_Interface::ThreadContext& ctx) {
 
     CHECKED(uc_reg_write_batch(uc, uregs, tregs, 31));
 
+    SetTlsAddress(ctx.tls_address);
+
     for (auto i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
         tregs[i] = (void*)&ctx.fpu_registers[i];
@@ -269,8 +263,6 @@ void ARM_Unicorn::PrepareReschedule() {
     CHECKED(uc_emu_stop(uc));
 }
 
-void ARM_Unicorn::ClearExclusiveState() {}
-
 void ARM_Unicorn::ClearInstructionCache() {}
 
 void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {

src/core/arm/unicorn/arm_unicorn.h

@@ -28,12 +28,9 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
     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;

src/core/core.cpp

@@ -19,20 +19,17 @@
 #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()) {
+    while (Core::System().GetInstance().IsPoweredOn()) {
         cpu_state->RunLoop(true);
     }
 }
@@ -87,7 +84,7 @@ System::ResultStatus System::SingleStep() {
 }
 
 System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {
-    app_loader = Loader::GetLoader(std::make_shared<FileSys::RealVfsFile>(filepath));
+    app_loader = Loader::GetLoader(filepath);
 
     if (!app_loader) {
         LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
@@ -171,13 +168,11 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     current_process = Kernel::Process::Create("main");
 
     cpu_barrier = std::make_shared<CpuBarrier>();
-    cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
     for (size_t index = 0; index < cpu_cores.size(); ++index) {
-        cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
+        cpu_cores[index] = std::make_shared<Cpu>(cpu_barrier, index);
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();
-    audio_core = std::make_unique<AudioCore::AudioOut>();
     telemetry_session = std::make_unique<Core::TelemetrySession>();
     service_manager = std::make_shared<Service::SM::ServiceManager>();
 
@@ -229,7 +224,6 @@ void System::Shutdown() {
     service_manager.reset();
     telemetry_session.reset();
     gpu_core.reset();
-    audio_core.reset();
 
     // Close all CPU/threading state
     cpu_barrier->NotifyEnd();

src/core/core.h

@@ -8,9 +8,7 @@
 #include <memory>
 #include <string>
 #include <thread>
-#include "audio_core/audio_out.h"
 #include "common/common_types.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core_cpu.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
@@ -116,11 +114,6 @@ public:
         return CurrentCpuCore().ArmInterface();
     }
 
-    /// Gets the index of the currently running CPU core
-    size_t CurrentCoreIndex() {
-        return CurrentCpuCore().CoreIndex();
-    }
-
     /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(size_t core_index);
 
@@ -132,21 +125,11 @@ public:
         return *gpu_core;
     }
 
-    /// Gets the AudioCore interface
-    AudioCore::AudioOut& AudioCore() {
-        return *audio_core;
-    }
-
     /// Gets the scheduler for the CPU core that is currently running
     Kernel::Scheduler& CurrentScheduler() {
         return *CurrentCpuCore().Scheduler();
     }
 
-    /// Gets the exclusive monitor
-    ExclusiveMonitor& Monitor() {
-        return *cpu_exclusive_monitor;
-    }
-
     /// Gets the scheduler for the CPU core with the specified index
     const std::shared_ptr<Kernel::Scheduler>& Scheduler(size_t core_index);
 
@@ -185,8 +168,6 @@ public:
     }
 
 private:
-    System();
-
     /// Returns the currently running CPU core
     Cpu& CurrentCpuCore();
 
@@ -201,10 +182,8 @@ private:
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<Tegra::GPU> gpu_core;
-    std::unique_ptr<AudioCore::AudioOut> audio_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
     Kernel::SharedPtr<Kernel::Process> current_process;
-    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
     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;

src/core/core_cpu.cpp

@@ -48,15 +48,14 @@ bool CpuBarrier::Rendezvous() {
     return false;
 }
 
-Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-         std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
+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>(exclusive_monitor, core_index);
+        arm_interface = std::make_shared<ARM_Dynarmic>();
 #else
-        arm_interface = std::make_shared<ARM_Unicorn>();
+        cpu_core = std::make_shared<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
@@ -66,18 +65,6 @@ Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
     scheduler = std::make_shared<Kernel::Scheduler>(arm_interface.get());
 }
 
-std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(size_t num_cores) {
-    if (Settings::values.use_cpu_jit) {
-#ifdef ARCHITECTURE_x86_64
-        return std::make_shared<DynarmicExclusiveMonitor>(num_cores);
-#else
-        return nullptr; // TODO(merry): Passthrough exclusive monitor
-#endif
-    } else {
-        return nullptr; // TODO(merry): Passthrough exclusive monitor
-    }
-}
-
 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()) {

src/core/core_cpu.h

@@ -10,7 +10,6 @@
 #include <mutex>
 #include <string>
 #include "common/common_types.h"
-#include "core/arm/exclusive_monitor.h"
 
 class ARM_Interface;
 
@@ -41,8 +40,7 @@ private:
 
 class Cpu {
 public:
-    Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-        std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
+    Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
 
     void RunLoop(bool tight_loop = true);
 
@@ -66,12 +64,6 @@ public:
         return core_index == 0;
     }
 
-    size_t CoreIndex() const {
-        return core_index;
-    }
-
-    static std::shared_ptr<ExclusiveMonitor> MakeExclusiveMonitor(size_t num_cores);
-
 private:
     void Reschedule();
 

src/core/core_timing.cpp

@@ -5,15 +5,17 @@
 #include "core/core_timing.h"
 
 #include <algorithm>
+#include <cinttypes>
+#include <limits>
 #include <mutex>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <vector>
 #include "common/assert.h"
+#include "common/logging/log.h"
 #include "common/thread.h"
 #include "common/threadsafe_queue.h"
-#include "core/core_timing_util.h"
 
 namespace CoreTiming {
 
@@ -57,6 +59,7 @@ static u64 event_fifo_id;
 static Common::MPSCQueue<Event, false> ts_queue;
 
 constexpr int MAX_SLICE_LENGTH = 20000;
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 static s64 idled_cycles;
 
@@ -69,6 +72,54 @@ 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.

src/core/core_timing.h

@@ -23,6 +23,59 @@
 
 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
+
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
+}
+
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
+}
+
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
+}
+
 /**
  * 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/core_timing_util.cpp

@@ -1,63 +0,0 @@
-// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include "core/core_timing_util.h"
-
-#include <cinttypes>
-#include <limits>
-#include "common/logging/log.h"
-
-namespace CoreTiming {
-
-constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
-
-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;
-}
-
-} // namespace CoreTiming

src/core/core_timing_util.h

@@ -1,64 +0,0 @@
-// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.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
-
-inline s64 msToCycles(int ms) {
-    // since ms is int there is no way to overflow
-    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
-}
-
-inline s64 msToCycles(float ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
-}
-
-inline s64 msToCycles(double ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
-}
-
-inline s64 usToCycles(float us) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
-}
-
-inline s64 usToCycles(int us) {
-    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
-}
-
-s64 usToCycles(s64 us);
-
-s64 usToCycles(u64 us);
-
-inline s64 nsToCycles(float ns) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
-}
-
-inline s64 nsToCycles(int ns) {
-    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
-}
-
-s64 nsToCycles(s64 ns);
-
-s64 nsToCycles(u64 ns);
-
-inline u64 cyclesToNs(s64 cycles) {
-    return cycles * 1000000000 / BASE_CLOCK_RATE;
-}
-
-inline s64 cyclesToUs(s64 cycles) {
-    return cycles * 1000000 / BASE_CLOCK_RATE;
-}
-
-inline u64 cyclesToMs(s64 cycles) {
-    return cycles * 1000 / BASE_CLOCK_RATE;
-}
-
-} // namespace CoreTiming

src/core/file_sys/content_archive.cpp

@@ -1,159 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <utility>
-
-#include "common/logging/log.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/vfs_offset.h"
-#include "core/loader/loader.h"
-#include "romfs.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 RomFSSuperblock {
-    NCASectionHeaderBlock header_block;
-    IVFCHeader ivfc;
-};
-static_assert(sizeof(RomFSSuperblock) == 0xE8, "RomFSSuperblock has incorrect size.");
-
-NCA::NCA(VirtualFile file_) : file(std::move(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.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-            const size_t romfs_size = sb.ivfc.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

@@ -1,100 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <string>
-#include <vector>
-
-#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(const std::shared_ptr<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/control_metadata.cpp

@@ -1,42 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/string_util.h"
-#include "common/swap.h"
-#include "core/file_sys/control_metadata.h"
-
-namespace FileSys {
-
-std::string LanguageEntry::GetApplicationName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
-}
-
-std::string LanguageEntry::GetDeveloperName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
-}
-
-NACP::NACP(VirtualFile file_) : file(std::move(file_)), raw(std::make_unique<RawNACP>()) {
-    file->ReadObject(raw.get());
-}
-
-const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
-    return raw->language_entries.at(static_cast<u8>(language));
-}
-
-std::string NACP::GetApplicationName(Language language) const {
-    return GetLanguageEntry(language).GetApplicationName();
-}
-
-std::string NACP::GetDeveloperName(Language language) const {
-    return GetLanguageEntry(language).GetDeveloperName();
-}
-
-u64 NACP::GetTitleId() const {
-    return raw->title_id;
-}
-
-std::string NACP::GetVersionString() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(), 0x10);
-}
-} // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -1,81 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <string>
-#include "common/common_funcs.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-
-// A localized entry containing strings within the NACP.
-// One for each language of type Language.
-struct LanguageEntry {
-    std::array<char, 0x200> application_name;
-    std::array<char, 0x100> developer_name;
-
-    std::string GetApplicationName() const;
-    std::string GetDeveloperName() const;
-};
-static_assert(sizeof(LanguageEntry) == 0x300, "LanguageEntry has incorrect size.");
-
-// The raw file format of a NACP file.
-struct RawNACP {
-    std::array<LanguageEntry, 16> language_entries;
-    INSERT_PADDING_BYTES(0x38);
-    u64_le title_id;
-    INSERT_PADDING_BYTES(0x20);
-    std::array<char, 0x10> version_string;
-    u64_le dlc_base_title_id;
-    u64_le title_id_2;
-    INSERT_PADDING_BYTES(0x28);
-    u64_le product_code;
-    u64_le title_id_3;
-    std::array<u64_le, 0x7> title_id_array;
-    INSERT_PADDING_BYTES(0x8);
-    u64_le title_id_update;
-    std::array<u8, 0x40> bcat_passphrase;
-    INSERT_PADDING_BYTES(0xEC0);
-};
-static_assert(sizeof(RawNACP) == 0x4000, "RawNACP has incorrect size.");
-
-// A language on the NX. These are for names and icons.
-enum class Language : u8 {
-    AmericanEnglish = 0,
-    BritishEnglish = 1,
-    Japanese = 2,
-    French = 3,
-    German = 4,
-    LatinAmericanSpanish = 5,
-    Spanish = 6,
-    Italian = 7,
-    Dutch = 8,
-    CanadianFrench = 9,
-    Portugese = 10,
-    Russian = 11,
-    Korean = 12,
-    Taiwanese = 13,
-    Chinese = 14,
-};
-
-// A class representing the format used by NX metadata files, typically named Control.nacp.
-// These store application name, dev name, title id, and other miscellaneous data.
-class NACP {
-public:
-    explicit NACP(VirtualFile file);
-    const LanguageEntry& GetLanguageEntry(Language language = Language::AmericanEnglish) const;
-    std::string GetApplicationName(Language language = Language::AmericanEnglish) const;
-    std::string GetDeveloperName(Language language = Language::AmericanEnglish) const;
-    u64 GetTitleId() const;
-    std::string GetVersionString() const;
-
-private:
-    VirtualFile file;
-    std::unique_ptr<RawNACP> raw;
-};
-
-} // namespace FileSys

src/core/file_sys/directory.h

@@ -8,17 +8,13 @@
 #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

@@ -0,0 +1,237 @@
+// 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 std::string& src_path,
+                                       const std::string& dest_path) const {
+    const std::string full_src_path = base_directory + src_path;
+    const std::string full_dest_path = base_directory + dest_path;
+
+    if (!FileUtil::Exists(full_src_path)) {
+        return ERROR_PATH_NOT_FOUND;
+    }
+    // TODO(wwylele): Use correct error code
+    return FileUtil::Rename(full_src_path, full_dest_path) ? RESULT_SUCCESS : 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 {}", full_path);
+    // 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={}, length={}", 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) {
+    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 {}: size={} dir={}", filename, 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

@@ -0,0 +1,84 @@
+// 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 std::string& src_path, const std::string& 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:
+    explicit 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:
+    explicit 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:
+    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,22 +11,20 @@ namespace FileSys {
 namespace ErrCodes {
 enum {
     NotFound = 1,
-    TitleNotFound = 1002,
-    SdCardNotFound = 2001,
-    RomFSNotFound = 2520,
+    SaveDataNotFound = 1002,
 };
 }
 
 constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
 
 // TODO(bunnei): Replace these with correct errors for Switch OS
-constexpr ResultCode ERROR_INVALID_PATH(-1);
-constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
-constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
-constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
-constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
-constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
-constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
-constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
+constexpr ResultCode ERROR_INVALID_PATH(ResultCode(-1));
+constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(ResultCode(-1));
+constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(ResultCode(-1));
+constexpr ResultCode ERROR_FILE_NOT_FOUND(ResultCode(-1));
+constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(ResultCode(-1));
+constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(ResultCode(-1));
+constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(ResultCode(-1));
+constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(ResultCode(-1));
 
 } // namespace FileSys

src/core/file_sys/filesystem.cpp

@@ -0,0 +1,122 @@
+// 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

@@ -0,0 +1,201 @@
+// 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 std::string& src_path,
+                                  const std::string& 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

@@ -1,23 +0,0 @@
-// 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,
-    ReadWrite = 3,
-    Append = 4,
-    WriteAppend = 6,
-};
-
-inline u32 operator&(Mode lhs, Mode rhs) {
-    return static_cast<u32>(lhs) & static_cast<u32>(rhs);
-}
-
-} // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -2,118 +2,135 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <cstddef>
-#include <cstring>
-#include <iterator>
 #include <utility>
-
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
 
-bool PartitionFilesystem::Header::HasValidMagicValue() const {
-    return magic == Common::MakeMagic('H', 'F', 'S', '0') ||
-           magic == Common::MakeMagic('P', 'F', 'S', '0');
-}
+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)) {
-        status = Loader::ResultStatus::Error;
-        return;
-    }
+    if (file.GetSize() < sizeof(Header))
+        return Loader::ResultStatus::Error;
 
+    file.Seek(offset, SEEK_SET);
     // 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.
-    if (sizeof(Header) != file->ReadObject(&pfs_header)) {
-        status = Loader::ResultStatus::Error;
-        return;
+    Header pfs_header;
+    if (!file.ReadBytes(&pfs_header, sizeof(Header)))
+        return Loader::ResultStatus::Error;
+
+    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
+        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
+        return Loader::ResultStatus::ErrorInvalidFormat;
     }
 
-    if (!pfs_header.HasValidMagicValue()) {
-        status = Loader::ResultStatus::ErrorInvalidFormat;
-        return;
-    }
-
-    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
+    bool is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '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...
-    std::vector<u8> file_data = file->ReadBytes(metadata_size);
-    const size_t total_size = file_data.size();
+    file.Seek(offset, SEEK_SET);
+    std::vector<u8> file_data(metadata_size);
 
-    if (total_size != metadata_size) {
-        status = Loader::ResultStatus::Error;
-        return;
+    if (!file.ReadBytes(file_data.data(), metadata_size))
+        return Loader::ResultStatus::Error;
+
+    Loader::ResultStatus result = Load(file_data);
+    if (result != Loader::ResultStatus::Success)
+        LOG_ERROR(Service_FS, "Failed to load PFS from file {}!", file_path);
+
+    return result;
+}
+
+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;
+
+    memcpy(&pfs_header, &file_data[offset], sizeof(Header));
+    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
+        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
+        return Loader::ResultStatus::ErrorInvalidFormat;
     }
 
-    size_t entries_offset = sizeof(Header);
+    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
+
+    size_t entries_offset = offset + sizeof(Header);
+    size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
     size_t strtab_offset = entries_offset + (pfs_header.num_entries * entry_size);
-    content_offset = strtab_offset + pfs_header.strtab_size;
     for (u16 i = 0; i < pfs_header.num_entries; i++) {
-        FSEntry entry;
+        FileEntry entry;
 
-        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]));
-
-        pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
-            file, entry.size, content_offset + entry.offset, std::move(name)));
+        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));
     }
 
-    status = Loader::ResultStatus::Success;
+    content_offset = strtab_offset + pfs_header.strtab_size;
+
+    return Loader::ResultStatus::Success;
 }
 
-Loader::ResultStatus PartitionFilesystem::GetStatus() const {
-    return status;
+u32 PartitionFilesystem::GetNumEntries() const {
+    return pfs_header.num_entries;
 }
 
-std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
-    return pfs_files;
+u64 PartitionFilesystem::GetEntryOffset(u32 index) const {
+    if (index > GetNumEntries())
+        return 0;
+
+    return content_offset + pfs_entries[index].fs_entry.offset;
 }
 
-std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
-    return pfs_dirs;
+u64 PartitionFilesystem::GetEntrySize(u32 index) const {
+    if (index > GetNumEntries())
+        return 0;
+
+    return pfs_entries[index].fs_entry.size;
 }
 
-std::string PartitionFilesystem::GetName() const {
-    return is_hfs ? "HFS0" : "PFS0";
+std::string PartitionFilesystem::GetEntryName(u32 index) const {
+    if (index > GetNumEntries())
+        return "";
+
+    return pfs_entries[index].name;
 }
 
-std::shared_ptr<VfsDirectory> PartitionFilesystem::GetParentDirectory() const {
-    // TODO(DarkLordZach): Add support for nested containers.
-    return nullptr;
+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;
+    }
+
+    return 0;
 }
 
-void PartitionFilesystem::PrintDebugInfo() const {
-    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", pfs_header.magic);
+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;
+}
+
+void PartitionFilesystem::Print() const {
+    LOG_DEBUG(Service_FS, "Magic:                  {}", pfs_header.magic);
     LOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
     for (u32 i = 0; i < pfs_header.num_entries; i++) {
         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());
+                  pfs_entries[i].name.c_str(), pfs_entries[i].fs_entry.size,
+                  GetFileOffset(pfs_entries[i].name));
     }
 }
-
-bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
-    if (iter == pfs_files.end())
-        return false;
-
-    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
-    pfs_files[offset] = std::move(pfs_files.back());
-    pfs_files.pop_back();
-
-    pfs_dirs.emplace_back(std::move(dir));
-
-    return true;
-}
 } // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -10,7 +10,6 @@
 #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;
@@ -22,19 +21,19 @@ 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 : public ReadOnlyVfsDirectory {
+class PartitionFilesystem {
 public:
-    explicit PartitionFilesystem(std::shared_ptr<VfsFile> file);
-    Loader::ResultStatus GetStatus() const;
+    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);
 
-    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;
+    u32 GetNumEntries() const;
+    u64 GetEntryOffset(u32 index) const;
+    u64 GetEntrySize(u32 index) const;
+    std::string GetEntryName(u32 index) const;
+    u64 GetFileOffset(const std::string& name) const;
+    u64 GetFileSize(const std::string& name) const;
 
-protected:
-    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+    void Print() const;
 
 private:
     struct Header {
@@ -42,8 +41,6 @@ private:
         u32_le num_entries;
         u32_le strtab_size;
         INSERT_PADDING_BYTES(0x4);
-
-        bool HasValidMagicValue() const;
     };
 
     static_assert(sizeof(Header) == 0x10, "PFS/HFS header structure size is wrong");
@@ -75,14 +72,16 @@ private:
 
 #pragma pack(pop)
 
-    Loader::ResultStatus status{};
+    struct FileEntry {
+        FSEntry fs_entry;
+        std::string name;
+    };
 
-    Header pfs_header{};
-    bool is_hfs = false;
-    size_t content_offset = 0;
+    Header pfs_header;
+    bool is_hfs;
+    size_t content_offset;
 
-    std::vector<VirtualFile> pfs_files;
-    std::vector<VirtualDir> pfs_dirs;
+    std::vector<FileEntry> pfs_entries;
 };
 
 } // namespace FileSys

src/core/file_sys/path_parser.cpp

@@ -0,0 +1,98 @@
+// 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

@@ -0,0 +1,61 @@
+// 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

@@ -9,29 +9,40 @@
 
 namespace FileSys {
 
-Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
-    size_t total_size = static_cast<size_t>(file->GetSize());
+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 {}!", file_path);
+
+    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);
     if (total_size < sizeof(Header))
         return Loader::ResultStatus::Error;
 
-    // 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 header_offset = offset;
+    memcpy(&npdm_header, &file_data[offset], sizeof(Header));
 
-    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 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));
 
-    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;
+    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));
 
     return Loader::ResultStatus::Success;
 }

src/core/file_sys/program_metadata.h

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

@@ -1,124 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/file_sys/romfs.h"
-#include "core/file_sys/vfs.h"
-#include "core/file_sys/vfs_offset.h"
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys {
-
-constexpr u32 ROMFS_ENTRY_EMPTY = 0xFFFFFFFF;
-
-struct TableLocation {
-    u64_le offset;
-    u64_le size;
-};
-static_assert(sizeof(TableLocation) == 0x10, "TableLocation has incorrect size.");
-
-struct RomFSHeader {
-    u64_le header_size;
-    TableLocation directory_hash;
-    TableLocation directory_meta;
-    TableLocation file_hash;
-    TableLocation file_meta;
-    u64_le data_offset;
-};
-static_assert(sizeof(RomFSHeader) == 0x50, "RomFSHeader has incorrect size.");
-
-struct DirectoryEntry {
-    u32_le sibling;
-    u32_le child_dir;
-    u32_le child_file;
-    u32_le hash;
-    u32_le name_length;
-};
-static_assert(sizeof(DirectoryEntry) == 0x14, "DirectoryEntry has incorrect size.");
-
-struct FileEntry {
-    u32_le parent;
-    u32_le sibling;
-    u64_le offset;
-    u64_le size;
-    u32_le hash;
-    u32_le name_length;
-};
-static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size.");
-
-template <typename Entry>
-static std::pair<Entry, std::string> GetEntry(const VirtualFile& file, size_t offset) {
-    Entry entry{};
-    if (file->ReadObject(&entry, offset) != sizeof(Entry))
-        return {};
-    std::string string(entry.name_length, '\0');
-    if (file->ReadArray(&string[0], string.size(), offset + sizeof(Entry)) != string.size())
-        return {};
-    return {entry, string};
-}
-
-void ProcessFile(VirtualFile file, size_t file_offset, size_t data_offset, u32 this_file_offset,
-                 std::shared_ptr<VectorVfsDirectory> parent) {
-    while (true) {
-        auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset);
-
-        parent->AddFile(std::make_shared<OffsetVfsFile>(
-            file, entry.first.size, entry.first.offset + data_offset, entry.second, parent));
-
-        if (entry.first.sibling == ROMFS_ENTRY_EMPTY)
-            break;
-
-        this_file_offset = entry.first.sibling;
-    }
-}
-
-void ProcessDirectory(VirtualFile file, size_t dir_offset, size_t file_offset, size_t data_offset,
-                      u32 this_dir_offset, std::shared_ptr<VectorVfsDirectory> parent) {
-    while (true) {
-        auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset);
-        auto current = std::make_shared<VectorVfsDirectory>(
-            std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, parent, entry.second);
-
-        if (entry.first.child_file != ROMFS_ENTRY_EMPTY) {
-            ProcessFile(file, file_offset, data_offset, entry.first.child_file, current);
-        }
-
-        if (entry.first.child_dir != ROMFS_ENTRY_EMPTY) {
-            ProcessDirectory(file, dir_offset, file_offset, data_offset, entry.first.child_dir,
-                             current);
-        }
-
-        parent->AddDirectory(current);
-        if (entry.first.sibling == ROMFS_ENTRY_EMPTY)
-            break;
-        this_dir_offset = entry.first.sibling;
-    }
-}
-
-VirtualDir ExtractRomFS(VirtualFile file) {
-    RomFSHeader header{};
-    if (file->ReadObject(&header) != sizeof(RomFSHeader))
-        return nullptr;
-
-    if (header.header_size != sizeof(RomFSHeader))
-        return nullptr;
-
-    const u64 file_offset = header.file_meta.offset;
-    const u64 dir_offset = header.directory_meta.offset + 4;
-
-    const auto root =
-        std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{}, std::vector<VirtualDir>{},
-                                             file->GetContainingDirectory(), file->GetName());
-
-    ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root);
-
-    VirtualDir out = std::move(root);
-
-    while (out->GetSubdirectory("") != nullptr)
-        out = out->GetSubdirectory("");
-
-    return out;
-}
-} // namespace FileSys

src/core/file_sys/romfs.h

@@ -1,35 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include "common/common_funcs.h"
-#include "common/swap.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-
-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 IVFCHeader {
-    u32_le magic;
-    u32_le magic_number;
-    INSERT_PADDING_BYTES(8);
-    std::array<IVFCLevel, 6> levels;
-    INSERT_PADDING_BYTES(64);
-};
-static_assert(sizeof(IVFCHeader) == 0xE0, "IVFCHeader has incorrect size.");
-
-// Converts a RomFS binary blob to VFS Filesystem
-// Returns nullptr on failure
-VirtualDir ExtractRomFS(VirtualFile file);
-
-} // namespace FileSys

src/core/file_sys/romfs_factory.cpp

@@ -7,19 +7,32 @@
 #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 {
 
-RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
+RomFS_Factory::RomFS_Factory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
-    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(file)) {
+    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(romfs_file, data_offset, data_size)) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
-    // TODO(DarkLordZach): Use title id.
-    return MakeResult<VirtualFile>(file);
+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 {}", GetName());
+    // 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 {}", GetName());
+    // TODO(bunnei): Find the right error code for this
+    return ResultCode(-1);
 }
 
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -5,21 +5,31 @@
 #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 RomFSFactory {
+class RomFS_Factory final : public FileSystemFactory {
 public:
-    explicit RomFSFactory(Loader::AppLoader& app_loader);
+    explicit RomFS_Factory(Loader::AppLoader& app_loader);
 
-    ResultVal<VirtualFile> Open(u64 title_id);
+    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;
 
 private:
-    VirtualFile file;
+    std::shared_ptr<FileUtil::IOFile> romfs_file;
+    u64 data_offset;
+    u64 data_size;
 };
 
 } // namespace FileSys

src/core/file_sys/romfs_filesystem.cpp

@@ -0,0 +1,110 @@
+// 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 ({}).", GetName());
+    // TODO(bunnei): Use correct error code
+    return ResultCode(-1);
+}
+
+ResultCode RomFS_FileSystem::RenameFile(const std::string& src_path,
+                                        const std::string& dest_path) const {
+    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive ({}).", GetName());
+    // 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 ({}).",
+                 GetName());
+    // 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 ({}).",
+                 GetName());
+    // 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 ({}).", GetName());
+    // 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 ({}).",
+                 GetName());
+    // 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 ({}).", GetName());
+    // 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 {}).", path);
+    // 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={}, length={}", 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

@@ -0,0 +1,85 @@
+// 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 std::string& src_path, const std::string& 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

@@ -6,101 +6,58 @@
 #include "common/common_types.h"
 #include "common/logging/log.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 {
 
-std::string SaveDataDescriptor::DebugInfo() const {
-    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);
-}
+SaveData_Factory::SaveData_Factory(std::string nand_directory)
+    : nand_directory(std::move(nand_directory)) {}
 
-SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {}
+ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
+    std::string save_directory = GetFullPath();
 
-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) {
+    if (!FileUtil::Exists(save_directory)) {
         // 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);
+        FileUtil::CreateFullPath(save_directory);
     }
 
     // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
+    if (!FileUtil::IsDirectory(save_directory)) {
         // TODO(Subv): Find out correct error code.
         return ResultCode(-1);
     }
 
-    return MakeResult<VirtualDir>(std::move(out));
+    auto archive = std::make_unique<Disk_FileSystem>(save_directory);
+    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
 }
 
-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));
+ResultCode SaveData_Factory::Format(const Path& path) {
+    LOG_WARNING(Service_FS, "Format archive {}", GetName());
+    // Create the save data directory.
+    if (!FileUtil::CreateFullPath(GetFullPath())) {
+        // TODO(Subv): Find the correct error code.
+        return ResultCode(-1);
     }
 
-    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));
-    }
+    return RESULT_SUCCESS;
+}
+
+ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) const {
+    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive {}", GetName());
+    // 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 fmt::format("{}save/{:016X}/{:08X}/", nand_directory, title_id, user);
 }
 
 } // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -7,52 +7,27 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
+#include "core/file_sys/filesystem.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
 
-enum class SaveDataSpaceId : u8 {
-    NandSystem = 0,
-    NandUser = 1,
-    SdCard = 2,
-    TemporaryStorage = 3,
-};
-
-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() const;
-};
-static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorrect size.");
-
 /// File system interface to the SaveData archive
-class SaveDataFactory {
+class SaveData_Factory final : public FileSystemFactory {
 public:
-    explicit SaveDataFactory(VirtualDir dir);
+    explicit SaveData_Factory(std::string nand_directory);
 
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
+    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;
 
 private:
-    VirtualDir dir;
+    std::string nand_directory;
 
-    std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id,
-                            u64 save_id) const;
+    std::string GetFullPath() const;
 };
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.cpp

@@ -3,15 +3,37 @@
 // Refer to the license.txt file included.
 
 #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 {
 
-SDMCFactory::SDMCFactory(VirtualDir dir) : dir(std::move(dir)) {}
+SDMC_Factory::SDMC_Factory(std::string sd_directory) : sd_directory(std::move(sd_directory)) {}
 
-ResultVal<VirtualDir> SDMCFactory::Open() {
-    return MakeResult<VirtualDir>(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 {}", GetName());
+    // 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 {}", GetName());
+    // TODO(bunnei): Find the right error code for this
+    return ResultCode(-1);
 }
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -4,19 +4,28 @@
 
 #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 SDMCFactory {
+class SDMC_Factory final : public FileSystemFactory {
 public:
-    explicit SDMCFactory(VirtualDir dir);
+    explicit SDMC_Factory(std::string sd_directory);
 
-    ResultVal<VirtualDir> Open();
+    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;
 
 private:
-    VirtualDir dir;
+    std::string sd_directory;
 };
 
 } // namespace FileSys

src/core/file_sys/storage.h

@@ -0,0 +1,63 @@
+// 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

@@ -1,296 +0,0 @@
-// 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 std::string(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(const std::vector<u8>& data, size_t offset) {
-    return Write(data.data(), data.size(), offset);
-}
-
-std::string VfsFile::GetFullPath() const {
-    if (GetContainingDirectory() == nullptr)
-        return "/" + GetName();
-
-    return GetContainingDirectory()->GetFullPath() + "/" + GetName();
-}
-
-std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(std::string_view 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(std::string_view path) const {
-    if (IsRoot()) {
-        return GetFileRelative(path);
-    }
-
-    return GetParentDirectory()->GetFileAbsolute(path);
-}
-
-std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(std::string_view 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(std::string_view path) const {
-    if (IsRoot()) {
-        return GetDirectoryRelative(path);
-    }
-
-    return GetParentDirectory()->GetDirectoryAbsolute(path);
-}
-
-std::shared_ptr<VfsFile> VfsDirectory::GetFile(std::string_view 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(std::string_view 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 sum_sizes = [](const auto& range) {
-        return std::accumulate(range.begin(), range.end(), 0ULL,
-                               [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); });
-    };
-
-    const auto file_total = sum_sizes(files);
-    const auto& sub_dir = GetSubdirectories();
-    const auto subdir_total = sum_sizes(sub_dir);
-
-    return file_total + subdir_total;
-}
-
-std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(std::string_view 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(std::string_view path) {
-    if (IsRoot()) {
-        return CreateFileRelative(path);
-    }
-
-    return GetParentDirectory()->CreateFileAbsolute(path);
-}
-
-std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(std::string_view 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(std::string_view path) {
-    if (IsRoot()) {
-        return CreateDirectoryRelative(path);
-    }
-
-    return GetParentDirectory()->CreateDirectoryAbsolute(path);
-}
-
-bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view 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(std::string_view src, std::string_view 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();
-}
-
-std::string VfsDirectory::GetFullPath() const {
-    if (IsRoot())
-        return GetName();
-
-    return GetParentDirectory()->GetFullPath() + "/" + GetName();
-}
-
-bool ReadOnlyVfsDirectory::IsWritable() const {
-    return false;
-}
-
-bool ReadOnlyVfsDirectory::IsReadable() const {
-    return true;
-}
-
-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateSubdirectory(std::string_view name) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(std::string_view name) {
-    return nullptr;
-}
-
-bool ReadOnlyVfsDirectory::DeleteSubdirectory(std::string_view name) {
-    return false;
-}
-
-bool ReadOnlyVfsDirectory::DeleteFile(std::string_view name) {
-    return false;
-}
-
-bool ReadOnlyVfsDirectory::Rename(std::string_view name) {
-    return false;
-}
-
-bool VfsRawCopy(VirtualFile src, VirtualFile dest) {
-    if (src == nullptr || dest == nullptr)
-        return false;
-    if (!dest->Resize(src->GetSize()))
-        return false;
-    std::vector<u8> data = src->ReadAllBytes();
-    return dest->WriteBytes(data, 0) == data.size();
-}
-} // namespace FileSys

src/core/file_sys/vfs.h

@@ -1,253 +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 <string_view>
-#include <type_traits>
-#include <vector>
-#include "boost/optional.hpp"
-#include "common/common_types.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_v<T>, "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_v<T>, "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_v<T>, "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(const 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(const T* data, size_t number_elements, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable_v<T>, "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(const T* data, size_t size, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-        return Write(reinterpret_cast<const 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_v<T>, "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(std::string_view name) = 0;
-
-    // Returns the full path of this file as a string, recursively
-    virtual std::string GetFullPath() const;
-};
-
-// 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(std::string_view path) const;
-    // Calls GetFileRelative(path) on the root of the current directory.
-    virtual std::shared_ptr<VfsFile> GetFileAbsolute(std::string_view 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(std::string_view path) const;
-    // Calls GetDirectoryRelative(path) on the root of the current directory.
-    virtual std::shared_ptr<VfsDirectory> GetDirectoryAbsolute(std::string_view 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(std::string_view 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(std::string_view 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(std::string_view 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(std::string_view 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(std::string_view 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(std::string_view 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(std::string_view 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(std::string_view path);
-
-    // Deletes the subdirectory with name and returns true on success.
-    virtual bool DeleteSubdirectory(std::string_view name) = 0;
-    // Deletes all subdirectories and files of subdirectory with name recirsively and then deletes
-    // the subdirectory. Returns true on success.
-    virtual bool DeleteSubdirectoryRecursive(std::string_view name);
-    // Returnes whether or not the file with name name was deleted successfully.
-    virtual bool DeleteFile(std::string_view name) = 0;
-
-    // Returns whether or not this directory was renamed to name.
-    virtual bool Rename(std::string_view name) = 0;
-
-    // Returns whether or not the file with name src was successfully copied to a new file with name
-    // dest.
-    virtual bool Copy(std::string_view src, std::string_view 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(std::string_view file) {
-        auto file_p = GetFile(file);
-
-        if (file_p == nullptr) {
-            return false;
-        }
-
-        return ReplaceFileWithSubdirectory(file_p, std::make_shared<Directory>(file_p));
-    }
-
-    bool InterpretAsDirectory(const std::function<VirtualDir(VirtualFile)>& function,
-                              const std::string& file) {
-        auto file_p = GetFile(file);
-        if (file_p == nullptr)
-            return false;
-        return ReplaceFileWithSubdirectory(file_p, function(file_p));
-    }
-
-    // Returns the full path of this directory as a string, recursively
-    virtual std::string GetFullPath() const;
-
-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(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteFile(std::string_view name) override;
-    bool Rename(std::string_view name) override;
-};
-
-// A method that copies the raw data between two different implementations of VirtualFile. If you
-// are using the same implementation, it is probably better to use the Copy method in the parent
-// directory of src/dest.
-bool VfsRawCopy(VirtualFile src, VirtualFile dest);
-
-} // namespace FileSys

src/core/file_sys/vfs_offset.cpp

@@ -1,96 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <utility>
-
-#include "core/file_sys/vfs_offset.h"
-
-namespace FileSys {
-
-OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, size_t size_, size_t offset_,
-                             std::string name_, VirtualDir parent_)
-    : file(file_), offset(offset_), size(size_), name(std::move(name_)),
-      parent(parent_ == nullptr ? file->GetContainingDirectory() : std::move(parent_)) {}
-
-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 parent;
-}
-
-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(const std::vector<u8>& data, size_t r_offset) {
-    return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset);
-}
-
-bool OffsetVfsFile::Rename(std::string_view 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::clamp(r_size, size_t{0}, size - r_offset);
-}
-
-} // namespace FileSys

src/core/file_sys/vfs_offset.h

@@ -1,50 +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_view>
-
-#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,
-                  std::string new_name = "", VirtualDir new_parent = nullptr);
-
-    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(const std::vector<u8>& data, size_t offset) override;
-
-    bool Rename(std::string_view 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;
-    VirtualDir parent;
-};
-
-} // namespace FileSys

src/core/file_sys/vfs_real.cpp

@@ -1,217 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstddef>
-#include <iterator>
-#include <utility>
-
-#include "common/common_paths.h"
-#include "common/logging/log.h"
-#include "core/file_sys/vfs_real.h"
-
-namespace FileSys {
-
-static std::string ModeFlagsToString(Mode mode) {
-    std::string mode_str;
-
-    // Calculate the correct open mode for the file.
-    if (mode & Mode::Read && mode & Mode::Write) {
-        if (mode & Mode::Append)
-            mode_str = "a+";
-        else
-            mode_str = "r+";
-    } else {
-        if (mode & Mode::Read)
-            mode_str = "r";
-        else if (mode & Mode::Append)
-            mode_str = "a";
-        else if (mode & Mode::Write)
-            mode_str = "w";
-    }
-
-    mode_str += "b";
-
-    return mode_str;
-}
-
-RealVfsFile::RealVfsFile(const std::string& path_, Mode perms_)
-    : backing(path_, ModeFlagsToString(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::WriteAppend) != 0;
-}
-
-bool RealVfsFile::IsReadable() const {
-    return (perms & Mode::ReadWrite) != 0;
-}
-
-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(std::string_view name) {
-    std::string name_str(name.begin(), name.end());
-    const auto out = FileUtil::Rename(GetName(), name_str);
-
-    path = (parent_path + DIR_SEP).append(name);
-    path_components = parent_components;
-    path_components.push_back(std::move(name_str));
-    backing = FileUtil::IOFile(path, ModeFlagsToString(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::WriteAppend)
-        FileUtil::CreateDir(path);
-
-    if (perms == Mode::Append)
-        return;
-
-    FileUtil::ForeachDirectoryEntry(
-        nullptr, path,
-        [this](u64* 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 files;
-}
-
-std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories() const {
-    return subdirectories;
-}
-
-bool RealVfsDirectory::IsWritable() const {
-    return (perms & Mode::WriteAppend) != 0;
-}
-
-bool RealVfsDirectory::IsReadable() const {
-    return (perms & Mode::ReadWrite) != 0;
-}
-
-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(std::string_view name) {
-    const std::string subdir_path = (path + DIR_SEP).append(name);
-
-    if (!FileUtil::CreateDir(subdir_path)) {
-        return nullptr;
-    }
-
-    subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(subdir_path, perms));
-    return subdirectories.back();
-}
-
-std::shared_ptr<VfsFile> RealVfsDirectory::CreateFile(std::string_view name) {
-    const std::string file_path = (path + DIR_SEP).append(name);
-
-    if (!FileUtil::CreateEmptyFile(file_path)) {
-        return nullptr;
-    }
-
-    files.emplace_back(std::make_shared<RealVfsFile>(file_path, perms));
-    return files.back();
-}
-
-bool RealVfsDirectory::DeleteSubdirectory(std::string_view name) {
-    const std::string subdir_path = (path + DIR_SEP).append(name);
-
-    return FileUtil::DeleteDirRecursively(subdir_path);
-}
-
-bool RealVfsDirectory::DeleteFile(std::string_view name) {
-    const 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();
-
-    const std::string file_path = (path + DIR_SEP).append(name);
-    return FileUtil::Delete(file_path);
-}
-
-bool RealVfsDirectory::Rename(std::string_view name) {
-    const std::string new_name = (parent_path + DIR_SEP).append(name);
-
-    return FileUtil::Rename(path, new_name);
-}
-
-std::string RealVfsDirectory::GetFullPath() const {
-    auto out = path;
-    std::replace(out.begin(), out.end(), '\\', '/');
-    return out;
-}
-
-bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    const auto iter = std::find(files.begin(), files.end(), file);
-    if (iter == files.end())
-        return false;
-
-    const std::ptrdiff_t offset = std::distance(files.begin(), iter);
-    files[offset] = files.back();
-    files.pop_back();
-
-    subdirectories.emplace_back(std::move(dir));
-
-    return true;
-}
-} // namespace FileSys

src/core/file_sys/vfs_real.h

@@ -1,72 +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_view>
-
-#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(std::string_view 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 = Mode::Read);
-
-    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(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteFile(std::string_view name) override;
-    bool Rename(std::string_view name) override;
-    std::string GetFullPath() const 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/file_sys/vfs_vector.cpp

@@ -1,83 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys {
-VectorVfsDirectory::VectorVfsDirectory(std::vector<VirtualFile> files_,
-                                       std::vector<VirtualDir> dirs_, VirtualDir parent_,
-                                       std::string name_)
-    : files(std::move(files_)), dirs(std::move(dirs_)), parent(std::move(parent_)),
-      name(std::move(name_)) {}
-
-std::vector<std::shared_ptr<VfsFile>> VectorVfsDirectory::GetFiles() const {
-    return files;
-}
-
-std::vector<std::shared_ptr<VfsDirectory>> VectorVfsDirectory::GetSubdirectories() const {
-    return dirs;
-}
-
-bool VectorVfsDirectory::IsWritable() const {
-    return false;
-}
-
-bool VectorVfsDirectory::IsReadable() const {
-    return true;
-}
-
-std::string VectorVfsDirectory::GetName() const {
-    return name;
-}
-std::shared_ptr<VfsDirectory> VectorVfsDirectory::GetParentDirectory() const {
-    return parent;
-}
-
-template <typename T>
-static bool FindAndRemoveVectorElement(std::vector<T>& vec, std::string_view name) {
-    auto iter = std::find_if(vec.begin(), vec.end(), [name](T e) { return e->GetName() == name; });
-    if (iter == vec.end())
-        return false;
-    auto old_size = vec.size();
-    vec.erase(iter);
-    return true;
-}
-
-bool VectorVfsDirectory::DeleteSubdirectory(std::string_view name) {
-    return FindAndRemoveVectorElement(dirs, name);
-}
-
-bool VectorVfsDirectory::DeleteFile(std::string_view name) {
-    return FindAndRemoveVectorElement(files, name);
-}
-
-bool VectorVfsDirectory::Rename(std::string_view name_) {
-    name = name_;
-    return true;
-}
-
-std::shared_ptr<VfsDirectory> VectorVfsDirectory::CreateSubdirectory(std::string_view name) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsFile> VectorVfsDirectory::CreateFile(std::string_view name) {
-    return nullptr;
-}
-
-void VectorVfsDirectory::AddFile(VirtualFile file) {
-    files.push_back(std::move(file));
-}
-
-void VectorVfsDirectory::AddDirectory(VirtualDir dir) {
-    dirs.push_back(std::move(dir));
-}
-
-bool VectorVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    if (!DeleteFile(file->GetName()))
-        return false;
-    dirs.emplace_back(dir);
-    return true;
-}
-} // namespace FileSys

src/core/file_sys/vfs_vector.h

@@ -1,44 +0,0 @@
-// 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 VfsDirectory that maintains two vectors for subdirectories and files.
-// Vector data is supplied upon construction.
-struct VectorVfsDirectory : public VfsDirectory {
-    explicit VectorVfsDirectory(std::vector<VirtualFile> files = {},
-                                std::vector<VirtualDir> dirs = {}, VirtualDir parent = nullptr,
-                                std::string name = "");
-
-    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;
-    bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteFile(std::string_view name) override;
-    bool Rename(std::string_view name) override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-
-    virtual void AddFile(VirtualFile file);
-    virtual void AddDirectory(VirtualDir dir);
-
-protected:
-    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
-
-private:
-    std::vector<VirtualFile> files;
-    std::vector<VirtualDir> dirs;
-
-    VirtualDir parent;
-    std::string name;
-};
-
-} // namespace FileSys

src/core/gdbstub/gdbstub.cpp

@@ -68,10 +68,6 @@ 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
 // This XML defines what the registers are for this specific ARM device
@@ -205,7 +201,7 @@ 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() == static_cast<u32>(id)) {
+            if (thread->GetThreadId() == id) {
                 current_core = core;
                 return thread.get();
             }
@@ -214,7 +210,7 @@ static Kernel::Thread* FindThreadById(int id) {
     return nullptr;
 }
 
-static u64 RegRead(std::size_t id, Kernel::Thread* thread = nullptr) {
+static u64 RegRead(int id, Kernel::Thread* thread = nullptr) {
     if (!thread) {
         return 0;
     }
@@ -234,7 +230,7 @@ static u64 RegRead(std::size_t id, Kernel::Thread* thread = nullptr) {
     }
 }
 
-static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr) {
+static void RegWrite(int id, u64 val, Kernel::Thread* thread = nullptr) {
     if (!thread) {
         return;
     }
@@ -569,7 +565,7 @@ static void HandleQuery() {
     } else if (strncmp(query, "Supported", strlen("Supported")) == 0) {
         // PacketSize needs to be large enough for target xml
         std::string buffer = "PacketSize=2000;qXfer:features:read+;qXfer:threads:read+";
-        if (!modules.empty()) {
+        if (modules.size()) {
             buffer += ";qXfer:libraries:read+";
         }
         SendReply(buffer.c_str());
@@ -744,7 +740,7 @@ static bool IsDataAvailable() {
     fd_set fd_socket;
 
     FD_ZERO(&fd_socket);
-    FD_SET(static_cast<u32>(gdbserver_socket), &fd_socket);
+    FD_SET(gdbserver_socket, &fd_socket);
 
     struct timeval t;
     t.tv_sec = 0;
@@ -778,9 +774,10 @@ static void ReadRegister() {
     } 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));
+        LongToGdbHex(reply, RegRead(998, current_thread));
     } else {
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
+        // return SendReply("E01");
+        LongToGdbHex(reply, RegRead(997, current_thread));
     }
 
     SendReply(reinterpret_cast<char*>(reply));
@@ -793,7 +790,7 @@ static void ReadRegisters() {
 
     u8* bufptr = buffer;
 
-    for (u32 reg = 0; reg <= SP_REGISTER; reg++) {
+    for (int reg = 0; reg <= SP_REGISTER; reg++) {
         LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
     }
 
@@ -807,13 +804,13 @@ static void ReadRegisters() {
 
     bufptr += 8;
 
-    for (u32 reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
+    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));
+    LongToGdbHex(bufptr, RegRead(998, current_thread));
 
     bufptr += 8;
 
@@ -840,12 +837,12 @@ static void WriteRegister() {
     } 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);
+        RegWrite(998, GdbHexToLong(buffer_ptr), current_thread);
     } else {
-        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
+        // return SendReply("E01");
+        RegWrite(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");
@@ -858,7 +855,7 @@ static void WriteRegisters() {
     if (command_buffer[0] != 'G')
         return SendReply("E01");
 
-    for (u32 i = 0, reg = 0; reg <= FPSCR_REGISTER; i++, reg++) {
+    for (int i = 0, reg = 0; reg <= FPSCR_REGISTER; i++, reg++) {
         if (reg <= SP_REGISTER) {
             RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else if (reg == PC_REGISTER) {
@@ -868,13 +865,12 @@ static void WriteRegisters() {
         } 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);
+            RegWrite(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");
@@ -945,7 +941,6 @@ void Break(bool is_memory_break) {
 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;

src/core/hle/config_mem.cpp

@@ -0,0 +1,31 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "core/hle/config_mem.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace ConfigMem {
+
+ConfigMemDef config_mem;
+
+void Init() {
+    std::memset(&config_mem, 0, sizeof(config_mem));
+
+    // Values extracted from firmware 11.2.0-35E
+    config_mem.kernel_version_min = 0x34;
+    config_mem.kernel_version_maj = 0x2;
+    config_mem.ns_tid = 0x0004013000008002;
+    config_mem.sys_core_ver = 0x2;
+    config_mem.unit_info = 0x1; // Bit 0 set for Retail
+    config_mem.prev_firm = 0x1;
+    config_mem.ctr_sdk_ver = 0x0000F297;
+    config_mem.firm_version_min = 0x34;
+    config_mem.firm_version_maj = 0x2;
+    config_mem.firm_sys_core_ver = 0x2;
+    config_mem.firm_ctr_sdk_ver = 0x0000F297;
+}
+
+} // namespace ConfigMem

src/core/hle/config_mem.h

@@ -0,0 +1,56 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+// Configuration memory stores various hardware/kernel configuration settings. This memory page is
+// read-only for ARM11 processes. I'm guessing this would normally be written to by the firmware/
+// bootrom. Because we're not emulating this, and essentially just "stubbing" the functionality, I'm
+// putting this as a subset of HLE for now.
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/memory.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace ConfigMem {
+
+struct ConfigMemDef {
+    u8 kernel_unk;                       // 0
+    u8 kernel_version_rev;               // 1
+    u8 kernel_version_min;               // 2
+    u8 kernel_version_maj;               // 3
+    u32_le update_flag;                  // 4
+    u64_le ns_tid;                       // 8
+    u32_le sys_core_ver;                 // 10
+    u8 unit_info;                        // 14
+    u8 boot_firm;                        // 15
+    u8 prev_firm;                        // 16
+    INSERT_PADDING_BYTES(0x1);           // 17
+    u32_le ctr_sdk_ver;                  // 18
+    INSERT_PADDING_BYTES(0x30 - 0x1C);   // 1C
+    u32_le app_mem_type;                 // 30
+    INSERT_PADDING_BYTES(0x40 - 0x34);   // 34
+    u32_le app_mem_alloc;                // 40
+    u32_le sys_mem_alloc;                // 44
+    u32_le base_mem_alloc;               // 48
+    INSERT_PADDING_BYTES(0x60 - 0x4C);   // 4C
+    u8 firm_unk;                         // 60
+    u8 firm_version_rev;                 // 61
+    u8 firm_version_min;                 // 62
+    u8 firm_version_maj;                 // 63
+    u32_le firm_sys_core_ver;            // 64
+    u32_le firm_ctr_sdk_ver;             // 68
+    INSERT_PADDING_BYTES(0x1000 - 0x6C); // 6C
+};
+static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE,
+              "Config Memory structure size is wrong");
+
+extern ConfigMemDef config_mem;
+
+void Init();
+
+} // namespace ConfigMem

src/core/hle/ipc_helpers.h

@@ -25,9 +25,9 @@ protected:
     ptrdiff_t index = 0;
 
 public:
-    explicit RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
+    RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
 
-    explicit RequestHelperBase(Kernel::HLERequestContext& context)
+    RequestHelperBase(Kernel::HLERequestContext& context)
         : context(&context), cmdbuf(context.CommandBuffer()) {}
 
     void Skip(unsigned size_in_words, bool set_to_null) {
@@ -56,6 +56,13 @@ public:
 
 class ResponseBuilder : public RequestHelperBase {
 public:
+    ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+
+    u32 normal_params_size{};
+    u32 num_handles_to_copy{};
+    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
+    std::ptrdiff_t datapayload_index{};
+
     /// Flags used for customizing the behavior of ResponseBuilder
     enum class Flags : u32 {
         None = 0,
@@ -64,11 +71,9 @@ public:
         AlwaysMoveHandles = 1,
     };
 
-    explicit ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
-
-    explicit ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
-                             u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
-                             Flags flags = Flags::None)
+    ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
+                    u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
+                    Flags flags = Flags::None)
 
         : RequestHelperBase(context), normal_params_size(normal_params_size),
           num_handles_to_copy(num_handles_to_copy), num_objects_to_move(num_objects_to_move) {
@@ -169,25 +174,6 @@ public:
     template <typename First, typename... Other>
     void Push(const First& first_value, const Other&... other_values);
 
-    /**
-     * Helper function for pushing strongly-typed enumeration values.
-     *
-     * @tparam Enum The enumeration type to be pushed
-     *
-     * @param value The value to push.
-     *
-     * @note The underlying size of the enumeration type is the size of the
-     *       data that gets pushed. e.g. "enum class SomeEnum : u16" will
-     *       push a u16-sized amount of data.
-     */
-    template <typename Enum>
-    void PushEnum(Enum value) {
-        static_assert(std::is_enum_v<Enum>, "T must be an enum type within a PushEnum call.");
-        static_assert(!std::is_convertible_v<Enum, int>,
-                      "enum type in PushEnum must be a strongly typed enum.");
-        Push(static_cast<std::underlying_type_t<Enum>>(value));
-    }
-
     /**
      * @brief Copies the content of the given trivially copyable class to the buffer as a normal
      * param
@@ -201,12 +187,6 @@ public:
 
     template <typename... O>
     void PushCopyObjects(Kernel::SharedPtr<O>... pointers);
-
-private:
-    u32 normal_params_size{};
-    u32 num_handles_to_copy{};
-    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
-    std::ptrdiff_t datapayload_index{};
 };
 
 /// Push ///
@@ -274,9 +254,9 @@ inline void ResponseBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
 
 class RequestParser : public RequestHelperBase {
 public:
-    explicit RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+    RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
 
-    explicit RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
+    RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
         ASSERT_MSG(context.GetDataPayloadOffset(), "context is incomplete");
         Skip(context.GetDataPayloadOffset(), false);
         // Skip the u64 command id, it's already stored in the context
@@ -286,9 +266,8 @@ public:
 
     ResponseBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy,
                                 u32 num_handles_to_move,
-                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) const {
-        return ResponseBuilder{*context, normal_params_size, num_handles_to_copy,
-                               num_handles_to_move, flags};
+                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) {
+        return {*context, normal_params_size, num_handles_to_copy, num_handles_to_move, flags};
     }
 
     template <typename T>
@@ -300,14 +279,6 @@ public:
     template <typename First, typename... Other>
     void Pop(First& first_value, Other&... other_values);
 
-    template <typename T>
-    T PopEnum() {
-        static_assert(std::is_enum_v<T>, "T must be an enum type within a PopEnum call.");
-        static_assert(!std::is_convertible_v<T, int>,
-                      "enum type in PopEnum must be a strongly typed enum.");
-        return static_cast<T>(Pop<std::underlying_type_t<T>>());
-    }
-
     /**
      * @brief Reads the next normal parameters as a struct, by copying it
      * @note: The output class must be correctly packed/padded to fit hardware layout.

src/core/hle/kernel/address_arbiter.cpp

@@ -20,7 +20,7 @@ namespace AddressArbiter {
 static ResultCode WaitForAddress(VAddr address, s64 timeout) {
     SharedPtr<Thread> current_thread = GetCurrentThread();
     current_thread->arb_wait_address = address;
-    current_thread->status = ThreadStatus::WaitArb;
+    current_thread->status = THREADSTATUS_WAIT_ARB;
     current_thread->wakeup_callback = nullptr;
 
     current_thread->WakeAfterDelay(timeout);
@@ -65,7 +65,7 @@ static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num
 
     // Signal the waiting threads.
     for (size_t i = 0; i < last; i++) {
-        ASSERT(waiting_threads[i]->status == ThreadStatus::WaitArb);
+        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();
@@ -115,7 +115,7 @@ ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 valu
     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)) {
+    } else if (num_to_wake <= 0 || waiting_threads.size() <= num_to_wake) {
         updated_value = value + 1;
     } else {
         updated_value = value;
@@ -140,9 +140,7 @@ ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool
 
     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));
-        }
+        Memory::Write32(address, static_cast<u32>(cur_value - 1));
     } else {
         return ERR_INVALID_STATE;
     }

src/core/hle/kernel/hle_ipc.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <utility>
-
 #include <boost/range/algorithm_ext/erase.hpp>
 #include "common/assert.h"
 #include "common/common_funcs.h"
@@ -21,36 +19,30 @@ namespace Kernel {
 
 void SessionRequestHandler::ClientConnected(SharedPtr<ServerSession> server_session) {
     server_session->SetHleHandler(shared_from_this());
-    connected_sessions.push_back(std::move(server_session));
+    connected_sessions.push_back(server_session);
 }
 
-void SessionRequestHandler::ClientDisconnected(const SharedPtr<ServerSession>& server_session) {
+void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_session) {
     server_session->SetHleHandler(nullptr);
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
 SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
                                                       const std::string& reason, u64 timeout,
-                                                      WakeupCallback&& callback,
-                                                      Kernel::SharedPtr<Kernel::Event> event) {
+                                                      WakeupCallback&& callback) {
 
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
     thread->wakeup_callback =
         [context = *this, callback](ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                     SharedPtr<WaitObject> object, size_t index) mutable -> bool {
-        ASSERT(thread->status == ThreadStatus::WaitHLEEvent);
+        ASSERT(thread->status == THREADSTATUS_WAIT_HLE_EVENT);
         callback(thread, context, reason);
         context.WriteToOutgoingCommandBuffer(*thread);
         return true;
     };
 
-    if (!event) {
-        // Create event if not provided
-        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
-    }
-
-    event->Clear();
-    thread->status = ThreadStatus::WaitHLEEvent;
+    auto event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+    thread->status = THREADSTATUS_WAIT_HLE_EVENT;
     thread->wait_objects = {event};
     event->AddWaitingThread(thread);
 
@@ -222,8 +214,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(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
-        ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);
+        ASSERT_MSG(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
+        ASSERT_MSG(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
@@ -301,6 +293,10 @@ size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size, int buffe
     return size;
 }
 
+size_t HLERequestContext::WriteBuffer(const std::vector<u8>& buffer, int buffer_index) const {
+    return WriteBuffer(buffer.data(), buffer.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()

src/core/hle/kernel/hle_ipc.h

@@ -5,10 +5,8 @@
 #pragma once
 
 #include <array>
-#include <iterator>
 #include <memory>
 #include <string>
-#include <type_traits>
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include "common/common_types.h"
@@ -61,12 +59,12 @@ public:
      * associated ServerSession.
      * @param server_session ServerSession associated with the connection.
      */
-    void ClientDisconnected(const SharedPtr<ServerSession>& server_session);
+    void ClientDisconnected(SharedPtr<ServerSession> server_session);
 
 protected:
     /// List of sessions that are connected to this handler.
     /// A ServerSession whose server endpoint is an HLE implementation is kept alive by this list
-    /// for the duration of the connection.
+    // for the duration of the connection.
     std::vector<SharedPtr<ServerSession>> connected_sessions;
 };
 
@@ -91,7 +89,7 @@ protected:
  */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(SharedPtr<ServerSession> session);
+    HLERequestContext(SharedPtr<Kernel::ServerSession> session);
     ~HLERequestContext();
 
     /// Returns a pointer to the IPC command buffer for this request.
@@ -120,12 +118,10 @@ 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,
-                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);
+                                       u64 timeout, WakeupCallback&& callback);
 
     void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
 
@@ -173,25 +169,8 @@ public:
     /// Helper function to write a buffer using the appropriate buffer descriptor
     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
-     *
-     * @tparam ContiguousContainer an arbitrary container that satisfies the
-     *         ContiguousContainer concept in the C++ standard library.
-     *
-     * @param container    The container to write the data of into a buffer.
-     * @param buffer_index The buffer in particular to write to.
-     */
-    template <typename ContiguousContainer,
-              typename = std::enable_if_t<!std::is_pointer_v<ContiguousContainer>>>
-    size_t WriteBuffer(const ContiguousContainer& container, int buffer_index = 0) const {
-        using ContiguousType = typename ContiguousContainer::value_type;
-
-        static_assert(std::is_trivially_copyable_v<ContiguousType>,
-                      "Container to WriteBuffer must contain trivially copyable objects");
-
-        return WriteBuffer(std::data(container), std::size(container) * sizeof(ContiguousType),
-                           buffer_index);
-    }
+    /// Helper function to write a buffer using the appropriate buffer descriptor
+    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(int buffer_index = 0) const;

src/core/hle/kernel/kernel.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "core/hle/config_mem.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
@@ -10,6 +11,7 @@
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
+#include "core/hle/shared_page.h"
 
 namespace Kernel {
 
@@ -17,6 +19,9 @@ unsigned int Object::next_object_id;
 
 /// Initialize the kernel
 void Init(u32 system_mode) {
+    ConfigMem::Init();
+    SharedPage::Init();
+
     Kernel::MemoryInit(system_mode);
 
     Kernel::ResourceLimitsInit();

src/core/hle/kernel/memory.cpp

@@ -11,9 +11,11 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/hle/config_mem.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/hle/result.h"
+#include "core/hle/shared_page.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
 
@@ -61,6 +63,14 @@ void MemoryInit(u32 mem_type) {
 
     // We must've allocated the entire FCRAM by the end
     ASSERT(base == Memory::FCRAM_SIZE);
+
+    using ConfigMem::config_mem;
+    config_mem.app_mem_type = mem_type;
+    // app_mem_malloc does not always match the configured size for memory_region[0]: in case the
+    // n3DS type override is in effect it reports the size the game expects, not the real one.
+    config_mem.app_mem_alloc = memory_region_sizes[mem_type][0];
+    config_mem.sys_mem_alloc = static_cast<u32_le>(memory_regions[1].size);
+    config_mem.base_mem_alloc = static_cast<u32_le>(memory_regions[2].size);
 }
 
 void MemoryShutdown() {

src/core/hle/kernel/mutex.cpp

@@ -19,7 +19,7 @@ namespace Kernel {
 /// 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(
-    const SharedPtr<Thread>& current_thread, VAddr mutex_addr) {
+    SharedPtr<Thread> current_thread, VAddr mutex_addr) {
 
     SharedPtr<Thread> highest_priority_thread;
     u32 num_waiters = 0;
@@ -28,7 +28,7 @@ static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
         if (thread->mutex_wait_address != mutex_addr)
             continue;
 
-        ASSERT(thread->status == ThreadStatus::WaitMutex);
+        ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
 
         ++num_waiters;
         if (highest_priority_thread == nullptr ||
@@ -83,7 +83,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     GetCurrentThread()->mutex_wait_address = address;
     GetCurrentThread()->wait_handle = requesting_thread_handle;
 
-    GetCurrentThread()->status = ThreadStatus::WaitMutex;
+    GetCurrentThread()->status = THREADSTATUS_WAIT_MUTEX;
     GetCurrentThread()->wakeup_callback = nullptr;
 
     // Update the lock holder thread's priority to prevent priority inversion.
@@ -121,7 +121,7 @@ ResultCode Mutex::Release(VAddr address) {
     // Grant the mutex to the next waiting thread and resume it.
     Memory::Write32(address, mutex_value);
 
-    ASSERT(thread->status == ThreadStatus::WaitMutex);
+    ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
     thread->ResumeFromWait();
 
     thread->lock_owner = nullptr;

src/core/hle/kernel/object_address_table.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <utility>
-
 #include "common/assert.h"
 #include "core/hle/kernel/object_address_table.h"
 
@@ -13,7 +11,7 @@ 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{:X}", addr);
-    objects[addr] = std::move(obj);
+    objects[addr] = obj;
 }
 
 void ObjectAddressTable::Close(VAddr addr) {

src/core/hle/kernel/scheduler.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <utility>
-
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
@@ -34,7 +32,7 @@ Thread* Scheduler::PopNextReadyThread() {
     Thread* next = nullptr;
     Thread* thread = GetCurrentThread();
 
-    if (thread && thread->status == ThreadStatus::Running) {
+    if (thread && thread->status == THREADSTATUS_RUNNING) {
         // We have to do better than the current thread.
         // This call returns null when that's not possible.
         next = ready_queue.pop_first_better(thread->current_priority);
@@ -56,20 +54,18 @@ void Scheduler::SwitchContext(Thread* new_thread) {
     if (previous_thread) {
         previous_thread->last_running_ticks = CoreTiming::GetTicks();
         cpu_core->SaveContext(previous_thread->context);
-        // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->tpidr_el0 = cpu_core->GetTPIDR_EL0();
 
-        if (previous_thread->status == ThreadStatus::Running) {
+        if (previous_thread->status == THREADSTATUS_RUNNING) {
             // This is only the case when a reschedule is triggered without the current thread
             // yielding execution (i.e. an event triggered, system core time-sliced, etc)
             ready_queue.push_front(previous_thread->current_priority, previous_thread);
-            previous_thread->status = ThreadStatus::Ready;
+            previous_thread->status = THREADSTATUS_READY;
         }
     }
 
     // Load context of new thread
     if (new_thread) {
-        ASSERT_MSG(new_thread->status == ThreadStatus::Ready,
+        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
                    "Thread must be ready to become running.");
 
         // Cancel any outstanding wakeup events for this thread
@@ -80,7 +76,7 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         current_thread = new_thread;
 
         ready_queue.remove(new_thread->current_priority, new_thread);
-        new_thread->status = ThreadStatus::Running;
+        new_thread->status = THREADSTATUS_RUNNING;
 
         if (previous_process != current_thread->owner_process) {
             Core::CurrentProcess() = current_thread->owner_process;
@@ -89,8 +85,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
 
         cpu_core->LoadContext(new_thread->context);
         cpu_core->SetTlsAddress(new_thread->GetTLSAddress());
-        cpu_core->SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
-        cpu_core->ClearExclusiveState();
     } else {
         current_thread = nullptr;
         // Note: We do not reset the current process and current page table when idling because
@@ -118,7 +112,7 @@ void Scheduler::Reschedule() {
 void Scheduler::AddThread(SharedPtr<Thread> thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    thread_list.push_back(std::move(thread));
+    thread_list.push_back(thread);
     ready_queue.prepare(priority);
 }
 
@@ -132,14 +126,14 @@ void Scheduler::RemoveThread(Thread* thread) {
 void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    ASSERT(thread->status == ThreadStatus::Ready);
+    ASSERT(thread->status == THREADSTATUS_READY);
     ready_queue.push_back(priority, thread);
 }
 
 void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    ASSERT(thread->status == ThreadStatus::Ready);
+    ASSERT(thread->status == THREADSTATUS_READY);
     ready_queue.remove(priority, thread);
 }
 
@@ -147,7 +141,7 @@ void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
     // If thread was ready, adjust queues
-    if (thread->status == ThreadStatus::Ready)
+    if (thread->status == THREADSTATUS_READY)
         ready_queue.move(thread, thread->current_priority, priority);
     else
         ready_queue.prepare(priority);

src/core/hle/kernel/server_session.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <tuple>
-#include <utility>
 
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -110,10 +109,10 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
         result = hle_handler->HandleSyncRequest(context);
     }
 
-    if (thread->status == ThreadStatus::Running) {
+    if (thread->status == THREADSTATUS_RUNNING) {
         // Put the thread to sleep until the server replies, it will be awoken in
         // svcReplyAndReceive for LLE servers.
-        thread->status = ThreadStatus::WaitIPC;
+        thread->status = THREADSTATUS_WAIT_IPC;
 
         if (hle_handler != nullptr) {
             // For HLE services, we put the request threads to sleep for a short duration to
@@ -159,7 +158,7 @@ ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& n
     std::shared_ptr<Session> parent(new Session);
     parent->client = client_session.get();
     parent->server = server_session.get();
-    parent->port = std::move(port);
+    parent->port = port;
 
     client_session->parent = parent;
     server_session->parent = parent;

src/core/hle/kernel/shared_memory.cpp

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <utility>
+#include <cstring>
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
@@ -21,7 +21,7 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
                                              MemoryRegion region, std::string name) {
     SharedPtr<SharedMemory> shared_memory(new SharedMemory);
 
-    shared_memory->owner_process = std::move(owner_process);
+    shared_memory->owner_process = owner_process;
     shared_memory->name = std::move(name);
     shared_memory->size = size;
     shared_memory->permissions = permissions;
@@ -87,7 +87,7 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vecto
     shared_memory->size = size;
     shared_memory->permissions = permissions;
     shared_memory->other_permissions = other_permissions;
-    shared_memory->backing_block = std::move(heap_block);
+    shared_memory->backing_block = heap_block;
     shared_memory->backing_block_offset = offset;
     shared_memory->base_address = Memory::HEAP_VADDR + offset;