Fixed crash due to unmapped memory

src/audio_core/audio_renderer.cpp

@@ -8,7 +8,7 @@
 #include "audio_core/codec.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/memory.h"
 
 namespace AudioCore {
@@ -72,7 +72,7 @@ private:
     EffectInStatus info{};
 };
 AudioRenderer::AudioRenderer(AudioRendererParameter params,
-                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event)
+                             Kernel::SharedPtr<Kernel::Event> buffer_event)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
       effects(params.effect_count) {
 

src/audio_core/audio_renderer.h

@@ -15,7 +15,7 @@
 #include "core/hle/kernel/object.h"
 
 namespace Kernel {
-class WritableEvent;
+class Event;
 }
 
 namespace AudioCore {
@@ -208,8 +208,7 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size
 
 class AudioRenderer {
 public:
-    AudioRenderer(AudioRendererParameter params,
-                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event);
+    AudioRenderer(AudioRendererParameter params, Kernel::SharedPtr<Kernel::Event> buffer_event);
     ~AudioRenderer();
 
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
@@ -225,7 +224,7 @@ private:
     class VoiceState;
 
     AudioRendererParameter worker_params;
-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
+    Kernel::SharedPtr<Kernel::Event> buffer_event;
     std::vector<VoiceState> voices;
     std::vector<EffectState> effects;
     std::unique_ptr<AudioOut> audio_out;

src/common/logging/backend.cpp

@@ -13,7 +13,7 @@
 #include <vector>
 #ifdef _WIN32
 #include <share.h>   // For _SH_DENYWR
-#include <windows.h> // For OutputDebugStringW
+#include <windows.h> // For OutputDebugStringA
 #else
 #define _SH_DENYWR 0
 #endif
@@ -148,7 +148,7 @@ void FileBackend::Write(const Entry& entry) {
 
 void DebuggerBackend::Write(const Entry& entry) {
 #ifdef _WIN32
-    ::OutputDebugStringW(Common::UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
+    ::OutputDebugStringA(FormatLogMessage(entry).append(1, '\n').c_str());
 #endif
 }
 

src/core/CMakeLists.txt

@@ -63,10 +63,6 @@ add_library(core STATIC
     file_sys/sdmc_factory.h
     file_sys/submission_package.cpp
     file_sys/submission_package.h
-    file_sys/system_archive/ng_word.cpp
-    file_sys/system_archive/ng_word.h
-    file_sys/system_archive/system_archive.cpp
-    file_sys/system_archive/system_archive.h
     file_sys/vfs.cpp
     file_sys/vfs.h
     file_sys/vfs_concat.cpp
@@ -101,6 +97,8 @@ add_library(core STATIC
     hle/kernel/client_session.cpp
     hle/kernel/client_session.h
     hle/kernel/errors.h
+    hle/kernel/event.cpp
+    hle/kernel/event.h
     hle/kernel/handle_table.cpp
     hle/kernel/handle_table.h
     hle/kernel/hle_ipc.cpp
@@ -113,8 +111,6 @@ add_library(core STATIC
     hle/kernel/object.h
     hle/kernel/process.cpp
     hle/kernel/process.h
-    hle/kernel/readable_event.cpp
-    hle/kernel/readable_event.h
     hle/kernel/resource_limit.cpp
     hle/kernel/resource_limit.h
     hle/kernel/scheduler.cpp
@@ -137,8 +133,6 @@ add_library(core STATIC
     hle/kernel/vm_manager.h
     hle/kernel/wait_object.cpp
     hle/kernel/wait_object.h
-    hle/kernel/writable_event.cpp
-    hle/kernel/writable_event.h
     hle/lock.cpp
     hle/lock.h
     hle/result.h

src/core/core.cpp

@@ -8,7 +8,6 @@
 #include <thread>
 #include <utility>
 
-#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
@@ -41,6 +40,7 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
+namespace {
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
                                          const std::string& path) {
     // To account for split 00+01+etc files.
@@ -69,13 +69,11 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
         return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(concat, dir->GetName());
     }
 
-    if (FileUtil::IsDirectory(path))
-        return vfs->OpenFile(path + "/" + "main", FileSys::Mode::Read);
-
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
-struct System::Impl {
+} // Anonymous namespace
 
+struct System::Impl {
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
     }

src/core/core.h

@@ -9,7 +9,6 @@
 #include <string>
 
 #include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
 
 namespace Core::Frontend {
@@ -56,9 +55,6 @@ class TelemetrySession;
 
 struct PerfStatsResults;
 
-FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
-                                         const std::string& path);
-
 class System {
 public:
     System(const System&) = delete;

src/core/crypto/key_manager.cpp

@@ -246,6 +246,7 @@ std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save) {
     }
 
     std::vector<TicketRaw> out;
+    u32 magic{};
     for (std::size_t offset = 0; offset + 0x4 < buffer.size(); ++offset) {
         if (buffer[offset] == 0x4 && buffer[offset + 1] == 0x0 && buffer[offset + 2] == 0x1 &&
             buffer[offset + 3] == 0x0) {
@@ -793,7 +794,7 @@ void KeyManager::DeriveBase() {
 
 void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // ETicket keys
-    const auto es = Service::FileSystem::GetUnionContents().GetEntry(
+    const auto es = Service::FileSystem::GetUnionContents()->GetEntry(
         0x0100000000000033, FileSys::ContentRecordType::Program);
 
     if (es == nullptr)

src/core/file_sys/directory.h

@@ -29,8 +29,8 @@ struct Entry {
         filename[copy_size] = '\0';
     }
 
-    char filename[0x301];
-    INSERT_PADDING_BYTES(3);
+    char filename[0x300];
+    INSERT_PADDING_BYTES(4);
     EntryType type;
     INSERT_PADDING_BYTES(3);
     u64 file_size;

src/core/file_sys/patch_manager.cpp

@@ -56,10 +56,6 @@ PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
 
-u64 PatchManager::GetTitleID() const {
-    return title_id;
-}
-
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
 
@@ -77,18 +73,14 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 
     const auto installed = Service::FileSystem::GetUnionContents();
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
-    const auto update_disabled =
-        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
-
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntry(update_tid, ContentRecordType::Program);
+    const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
 
-    if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr &&
+    if (update != nullptr && update->GetExeFS() != nullptr &&
         update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
         LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                 FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
         exefs = update->GetExeFS();
     }
 
@@ -103,9 +95,6 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         std::vector<VirtualDir> layers;
         layers.reserve(patch_dirs.size() + 1);
         for (const auto& subdir : patch_dirs) {
-            if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
-                continue;
-
             auto exefs_dir = subdir->GetSubdirectory("exefs");
             if (exefs_dir != nullptr)
                 layers.push_back(std::move(exefs_dir));
@@ -122,16 +111,11 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     return exefs;
 }
 
-std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                                      const std::string& build_id) const {
-    const auto& disabled = Settings::values.disabled_addons[title_id];
-
+static std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
+                                               const std::string& build_id) {
     std::vector<VirtualFile> out;
     out.reserve(patch_dirs.size());
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
-            continue;
-
         auto exefs_dir = subdir->GetSubdirectory("exefs");
         if (exefs_dir != nullptr) {
             for (const auto& file : exefs_dir->GetFiles()) {
@@ -244,7 +228,6 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         return;
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -254,9 +237,6 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
     layers.reserve(patch_dirs.size() + 1);
     layers_ext.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
-        if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
-            continue;
-
         auto romfs_dir = subdir->GetSubdirectory("romfs");
         if (romfs_dir != nullptr)
             layers.push_back(std::move(romfs_dir));
@@ -301,21 +281,16 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntryRaw(update_tid, type);
-
-    const auto& disabled = Settings::values.disabled_addons[title_id];
-    const auto update_disabled =
-        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
-
-    if (!update_disabled && update != nullptr) {
+    const auto update = installed->GetEntryRaw(update_tid, type);
+    if (update != nullptr) {
         const auto new_nca = std::make_shared<NCA>(update, romfs, ivfc_offset);
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
             LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
             romfs = new_nca->GetRomFS();
         }
-    } else if (!update_disabled && update_raw != nullptr) {
+    } else if (update_raw != nullptr) {
         const auto new_nca = std::make_shared<NCA>(update_raw, romfs, ivfc_offset);
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
@@ -345,30 +320,25 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     VirtualFile update_raw) const {
     std::map<std::string, std::string, std::less<>> out;
     const auto installed = Service::FileSystem::GetUnionContents();
-    const auto& disabled = Settings::values.disabled_addons[title_id];
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
     PatchManager update{update_tid};
     auto [nacp, discard_icon_file] = update.GetControlMetadata();
 
-    const auto update_disabled =
-        std::find(disabled.begin(), disabled.end(), "Update") != disabled.end();
-    const auto update_label = update_disabled ? "[D] Update" : "Update";
-
     if (nacp != nullptr) {
-        out.insert_or_assign(update_label, nacp->GetVersionString());
+        out.insert_or_assign("Update", nacp->GetVersionString());
     } else {
-        if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-            const auto meta_ver = installed.GetEntryVersion(update_tid);
+        if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
+            const auto meta_ver = installed->GetEntryVersion(update_tid);
             if (meta_ver.value_or(0) == 0) {
-                out.insert_or_assign(update_label, "");
+                out.insert_or_assign("Update", "");
             } else {
                 out.insert_or_assign(
-                    update_label, FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
+                    "Update", FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
             }
         } else if (update_raw != nullptr) {
-            out.insert_or_assign(update_label, "PACKED");
+            out.insert_or_assign("Update", "PACKED");
         }
     }
 
@@ -408,20 +378,19 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
             if (types.empty())
                 continue;
 
-            const auto mod_disabled =
-                std::find(disabled.begin(), disabled.end(), mod->GetName()) != disabled.end();
-            out.insert_or_assign(mod_disabled ? "[D] " + mod->GetName() : mod->GetName(), types);
+            out.insert_or_assign(mod->GetName(), types);
         }
     }
 
     // DLC
-    const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
+    const auto dlc_entries = installed->ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
     std::vector<RegisteredCacheEntry> dlc_match;
     dlc_match.reserve(dlc_entries.size());
     std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
                  [this, &installed](const RegisteredCacheEntry& entry) {
                      return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
-                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
+                            installed->GetEntry(entry)->GetStatus() ==
+                                Loader::ResultStatus::Success;
                  });
     if (!dlc_match.empty()) {
         // Ensure sorted so DLC IDs show in order.
@@ -433,9 +402,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 
         list += fmt::format("{}", dlc_match.back().title_id & 0x7FF);
 
-        const auto dlc_disabled =
-            std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end();
-        out.insert_or_assign(dlc_disabled ? "[D] DLC" : "DLC", std::move(list));
+        out.insert_or_assign("DLC", std::move(list));
     }
 
     return out;
@@ -444,7 +411,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
     const auto installed{Service::FileSystem::GetUnionContents()};
 
-    const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
+    const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr)
         return {};
 

src/core/file_sys/patch_manager.h

@@ -30,8 +30,6 @@ public:
     explicit PatchManager(u64 title_id);
     ~PatchManager();
 
-    u64 GetTitleID() const;
-
     // Currently tracked ExeFS patches:
     // - Game Updates
     VirtualDir PatchExeFS(VirtualDir exefs) const;
@@ -65,9 +63,6 @@ public:
     std::pair<std::unique_ptr<NACP>, VirtualFile> ParseControlNCA(const NCA& nca) const;
 
 private:
-    std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                            const std::string& build_id) const;
-
     u64 title_id;
 };
 

src/core/file_sys/program_metadata.cpp

@@ -63,6 +63,10 @@ u32 ProgramMetadata::GetMainThreadStackSize() const {
     return npdm_header.main_stack_size;
 }
 
+u32 ProgramMetadata::GetSystemResourceSize() const {
+    return npdm_header.system_resource_size;
+}
+
 u64 ProgramMetadata::GetTitleID() const {
     return aci_header.title_id;
 }

src/core/file_sys/program_metadata.h

@@ -50,6 +50,7 @@ public:
     u32 GetMainThreadStackSize() const;
     u64 GetTitleID() const;
     u64 GetFilesystemPermissions() const;
+    u32 GetSystemResourceSize() const;
 
     void Print() const;
 
@@ -68,7 +69,8 @@ private:
         u8 reserved_3;
         u8 main_thread_priority;
         u8 main_thread_cpu;
-        std::array<u8, 8> reserved_4;
+        std::array<u8, 4> reserved_4;
+        u32 system_resource_size;
         u32_le process_category;
         u32_le main_stack_size;
         std::array<u8, 0x10> application_name;

src/core/file_sys/registered_cache.cpp

@@ -107,41 +107,42 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
     const auto file = dir->GetFileRelative(path);
-    if (file != nullptr) {
+    if (file != nullptr)
         return file;
-    }
 
     const auto nca_dir = dir->GetDirectoryRelative(path);
-    if (nca_dir == nullptr) {
-        return nullptr;
-    }
+    if (nca_dir != nullptr) {
+        const auto nca_dir = dir->GetDirectoryRelative(path);
+        VirtualFile file = nullptr;
 
-    const auto files = nca_dir->GetFiles();
-    if (files.size() == 1 && files[0]->GetName() == "00") {
-        return files[0];
-    }
-
-    std::vector<VirtualFile> concat;
-    // Since the files are a two-digit hex number, max is FF.
-    for (std::size_t i = 0; i < 0x100; ++i) {
-        auto next = nca_dir->GetFile(fmt::format("{:02X}", i));
-        if (next != nullptr) {
-            concat.push_back(std::move(next));
+        const auto files = nca_dir->GetFiles();
+        if (files.size() == 1 && files[0]->GetName() == "00") {
+            file = files[0];
         } else {
-            next = nca_dir->GetFile(fmt::format("{:02x}", i));
-            if (next != nullptr) {
-                concat.push_back(std::move(next));
-            } else {
-                break;
+            std::vector<VirtualFile> concat;
+            // Since the files are a two-digit hex number, max is FF.
+            for (std::size_t i = 0; i < 0x100; ++i) {
+                auto next = nca_dir->GetFile(fmt::format("{:02X}", i));
+                if (next != nullptr) {
+                    concat.push_back(std::move(next));
+                } else {
+                    next = nca_dir->GetFile(fmt::format("{:02x}", i));
+                    if (next != nullptr)
+                        concat.push_back(std::move(next));
+                    else
+                        break;
+                }
             }
+
+            if (concat.empty())
+                return nullptr;
+
+            file = ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
         }
-    }
 
-    if (concat.empty()) {
-        return nullptr;
+        return file;
     }
-
-    return ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
+    return nullptr;
 }
 
 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {

src/core/file_sys/romfs_factory.cpp

@@ -48,7 +48,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, Conte
 
     switch (storage) {
     case StorageId::None:
-        res = Service::FileSystem::GetUnionContents().GetEntry(title_id, type);
+        res = Service::FileSystem::GetUnionContents()->GetEntry(title_id, type);
         break;
     case StorageId::NandSystem:
         res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);

src/core/file_sys/savedata_factory.cpp

@@ -18,11 +18,7 @@ std::string SaveDataDescriptor::DebugInfo() const {
                        static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id);
 }
 
-SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
-    // Delete all temporary storages
-    // On hardware, it is expected that temporary storage be empty at first use.
-    dir->DeleteSubdirectoryRecursive("temp");
-}
+SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {}
 
 SaveDataFactory::~SaveDataFactory() = default;
 
@@ -124,8 +120,6 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     case SaveDataType::TemporaryStorage:
         return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
-    case SaveDataType::CacheStorage:
-        return fmt::format("{}save/cache/{:016X}", out, title_id);
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
     }

src/core/file_sys/savedata_factory.h

@@ -17,10 +17,8 @@ namespace FileSys {
 enum class SaveDataSpaceId : u8 {
     NandSystem = 0,
     NandUser = 1,
-    SdCardSystem = 2,
+    SdCard = 2,
     TemporaryStorage = 3,
-    SdCardUser = 4,
-    ProperSystem = 100,
 };
 
 enum class SaveDataType : u8 {

src/core/file_sys/system_archive/ng_word.cpp

@@ -1,81 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <fmt/format.h>
-#include "common/common_types.h"
-#include "core/file_sys/system_archive/ng_word.h"
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys::SystemArchive {
-
-namespace NgWord1Data {
-
-constexpr std::size_t NUMBER_WORD_TXT_FILES = 0x10;
-
-// Should this archive replacement mysteriously not work on a future game, consider updating.
-constexpr std::array<u8, 4> VERSION_DAT{0x0, 0x0, 0x0, 0x19}; // 5.1.0 System Version
-
-constexpr std::array<u8, 30> WORD_TXT{
-    0xFE, 0xFF, 0x00, 0x5E, 0x00, 0x76, 0x00, 0x65, 0x00, 0x72, 0x00, 0x79, 0x00, 0x62, 0x00,
-    0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0A,
-}; // "^verybadword$" in UTF-16
-
-} // namespace NgWord1Data
-
-VirtualDir NgWord1() {
-    std::vector<VirtualFile> files(NgWord1Data::NUMBER_WORD_TXT_FILES);
-
-    for (std::size_t i = 0; i < files.size(); ++i) {
-        files[i] = std::make_shared<ArrayVfsFile<NgWord1Data::WORD_TXT.size()>>(
-            NgWord1Data::WORD_TXT, fmt::format("{}.txt", i));
-    }
-
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord1Data::WORD_TXT.size()>>(
-        NgWord1Data::WORD_TXT, "common.txt"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord1Data::VERSION_DAT.size()>>(
-        NgWord1Data::VERSION_DAT, "version.dat"));
-
-    return std::make_shared<VectorVfsDirectory>(files, std::vector<VirtualDir>{}, "data");
-}
-
-namespace NgWord2Data {
-
-constexpr std::size_t NUMBER_AC_NX_FILES = 0x10;
-
-// Should this archive replacement mysteriously not work on a future game, consider updating.
-constexpr std::array<u8, 4> VERSION_DAT{0x0, 0x0, 0x0, 0x15}; // 5.1.0 System Version
-
-constexpr std::array<u8, 0x2C> AC_NX_DATA{
-    0x1F, 0x8B, 0x08, 0x08, 0xD5, 0x2C, 0x09, 0x5C, 0x04, 0x00, 0x61, 0x63, 0x72, 0x61, 0x77,
-    0x00, 0xED, 0xC1, 0x01, 0x0D, 0x00, 0x00, 0x00, 0xC2, 0x20, 0xFB, 0xA7, 0xB6, 0xC7, 0x07,
-    0x0C, 0x00, 0x00, 0x00, 0xC8, 0x3B, 0x11, 0x00, 0x1C, 0xC7, 0x00, 0x10, 0x00, 0x00,
-}; // Deserializes to no bad words
-
-} // namespace NgWord2Data
-
-VirtualDir NgWord2() {
-    std::vector<VirtualFile> files(NgWord2Data::NUMBER_AC_NX_FILES * 3);
-
-    for (std::size_t i = 0; i < NgWord2Data::NUMBER_AC_NX_FILES; ++i) {
-        files[3 * i] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b1_nx", i));
-        files[3 * i + 1] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_b2_nx", i));
-        files[3 * i + 2] = std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-            NgWord2Data::AC_NX_DATA, fmt::format("ac_{}_not_b_nx", i));
-    }
-
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_b1_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_b2_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::AC_NX_DATA.size()>>(
-        NgWord2Data::AC_NX_DATA, "ac_common_not_b_nx"));
-    files.push_back(std::make_shared<ArrayVfsFile<NgWord2Data::VERSION_DAT.size()>>(
-        NgWord2Data::VERSION_DAT, "version.dat"));
-
-    return std::make_shared<VectorVfsDirectory>(files, std::vector<VirtualDir>{}, "data");
-}
-
-} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/ng_word.h

@@ -1,14 +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_types.h"
-
-namespace FileSys::SystemArchive {
-
-VirtualDir NgWord1();
-VirtualDir NgWord2();
-
-} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/system_archive.cpp

@@ -1,90 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/file_sys/romfs.h"
-#include "core/file_sys/system_archive/ng_word.h"
-#include "core/file_sys/system_archive/system_archive.h"
-
-namespace FileSys::SystemArchive {
-
-constexpr u64 SYSTEM_ARCHIVE_BASE_TITLE_ID = 0x0100000000000800;
-constexpr std::size_t SYSTEM_ARCHIVE_COUNT = 0x28;
-
-using SystemArchiveSupplier = VirtualDir (*)();
-
-struct SystemArchiveDescriptor {
-    u64 title_id;
-    const char* name;
-    SystemArchiveSupplier supplier;
-};
-
-constexpr std::array<SystemArchiveDescriptor, SYSTEM_ARCHIVE_COUNT> SYSTEM_ARCHIVES{{
-    {0x0100000000000800, "CertStore", nullptr},
-    {0x0100000000000801, "ErrorMessage", nullptr},
-    {0x0100000000000802, "MiiModel", nullptr},
-    {0x0100000000000803, "BrowserDll", nullptr},
-    {0x0100000000000804, "Help", nullptr},
-    {0x0100000000000805, "SharedFont", nullptr},
-    {0x0100000000000806, "NgWord", &NgWord1},
-    {0x0100000000000807, "SsidList", nullptr},
-    {0x0100000000000808, "Dictionary", nullptr},
-    {0x0100000000000809, "SystemVersion", nullptr},
-    {0x010000000000080A, "AvatarImage", nullptr},
-    {0x010000000000080B, "LocalNews", nullptr},
-    {0x010000000000080C, "Eula", nullptr},
-    {0x010000000000080D, "UrlBlackList", nullptr},
-    {0x010000000000080E, "TimeZoneBinary", nullptr},
-    {0x010000000000080F, "CertStoreCruiser", nullptr},
-    {0x0100000000000810, "FontNintendoExtension", nullptr},
-    {0x0100000000000811, "FontStandard", nullptr},
-    {0x0100000000000812, "FontKorean", nullptr},
-    {0x0100000000000813, "FontChineseTraditional", nullptr},
-    {0x0100000000000814, "FontChineseSimple", nullptr},
-    {0x0100000000000815, "FontBfcpx", nullptr},
-    {0x0100000000000816, "SystemUpdate", nullptr},
-    {0x0100000000000817, "0100000000000817", nullptr},
-    {0x0100000000000818, "FirmwareDebugSettings", nullptr},
-    {0x0100000000000819, "BootImagePackage", nullptr},
-    {0x010000000000081A, "BootImagePackageSafe", nullptr},
-    {0x010000000000081B, "BootImagePackageExFat", nullptr},
-    {0x010000000000081C, "BootImagePackageExFatSafe", nullptr},
-    {0x010000000000081D, "FatalMessage", nullptr},
-    {0x010000000000081E, "ControllerIcon", nullptr},
-    {0x010000000000081F, "PlatformConfigIcosa", nullptr},
-    {0x0100000000000820, "PlatformConfigCopper", nullptr},
-    {0x0100000000000821, "PlatformConfigHoag", nullptr},
-    {0x0100000000000822, "ControllerFirmware", nullptr},
-    {0x0100000000000823, "NgWord2", &NgWord2},
-    {0x0100000000000824, "PlatformConfigIcosaMariko", nullptr},
-    {0x0100000000000825, "ApplicationBlackList", nullptr},
-    {0x0100000000000826, "RebootlessSystemUpdateVersion", nullptr},
-    {0x0100000000000827, "ContentActionTable", nullptr},
-}};
-
-VirtualFile SynthesizeSystemArchive(const u64 title_id) {
-    if (title_id < SYSTEM_ARCHIVES.front().title_id || title_id > SYSTEM_ARCHIVES.back().title_id)
-        return nullptr;
-
-    const auto& desc = SYSTEM_ARCHIVES[title_id - SYSTEM_ARCHIVE_BASE_TITLE_ID];
-
-    LOG_INFO(Service_FS, "Synthesizing system archive '{}' (0x{:016X}).", desc.name, desc.title_id);
-
-    if (desc.supplier == nullptr)
-        return nullptr;
-
-    const auto dir = desc.supplier();
-
-    if (dir == nullptr)
-        return nullptr;
-
-    const auto romfs = CreateRomFS(dir);
-
-    if (romfs == nullptr)
-        return nullptr;
-
-    LOG_INFO(Service_FS, "    - System archive generation successful!");
-    return romfs;
-}
-} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/system_archive.h

@@ -1,14 +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"
-#include "core/file_sys/vfs_types.h"
-
-namespace FileSys::SystemArchive {
-
-VirtualFile SynthesizeSystemArchive(u64 title_id);
-
-} // namespace FileSys::SystemArchive

src/core/file_sys/vfs.cpp

@@ -384,28 +384,6 @@ bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
     return success;
 }
 
-bool VfsDirectory::CleanSubdirectoryRecursive(std::string_view name) {
-    auto dir = GetSubdirectory(name);
-    if (dir == nullptr) {
-        return false;
-    }
-
-    bool success = true;
-    for (const auto& file : dir->GetFiles()) {
-        if (!dir->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);
@@ -453,34 +431,10 @@ std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(std::string_view name)
     return nullptr;
 }
 
-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFileAbsolute(std::string_view path) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFileRelative(std::string_view path) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
-    return nullptr;
-}
-
-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateDirectoryRelative(std::string_view path) {
-    return nullptr;
-}
-
 bool ReadOnlyVfsDirectory::DeleteSubdirectory(std::string_view name) {
     return false;
 }
 
-bool ReadOnlyVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
-    return false;
-}
-
-bool ReadOnlyVfsDirectory::CleanSubdirectoryRecursive(std::string_view name) {
-    return false;
-}
-
 bool ReadOnlyVfsDirectory::DeleteFile(std::string_view name) {
     return false;
 }

src/core/file_sys/vfs.h

@@ -245,18 +245,12 @@ public:
     // any failure.
     virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path);
 
-    // Deletes the subdirectory with the given name and returns true on success.
+    // Deletes the subdirectory with name and returns true on success.
     virtual bool DeleteSubdirectory(std::string_view name) = 0;
-
-    // Deletes all subdirectories and files within the provided directory and then deletes
-    // the directory itself. Returns true on success.
+    // 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);
-
-    // Deletes all subdirectories and files within the provided directory.
-    // Unlike DeleteSubdirectoryRecursive, this does not delete the provided directory.
-    virtual bool CleanSubdirectoryRecursive(std::string_view name);
-
-    // Returns whether or not the file with name name was deleted successfully.
+    // 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.
@@ -282,13 +276,7 @@ public:
     bool IsReadable() const override;
     std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
     std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFileAbsolute(std::string_view path) override;
-    std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path) override;
     bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteSubdirectoryRecursive(std::string_view name) override;
-    bool CleanSubdirectoryRecursive(std::string_view name) override;
     bool DeleteFile(std::string_view name) override;
     bool Rename(std::string_view name) override;
 };

src/core/file_sys/vfs_vector.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <cstring>
 #include <utility>
 #include "core/file_sys/vfs_vector.h"
 

src/core/file_sys/vfs_vector.h

@@ -4,63 +4,10 @@
 
 #pragma once
 
-#include <cstring>
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
-// An implementation of VfsFile that is backed by a statically-sized array
-template <std::size_t size>
-class ArrayVfsFile : public VfsFile {
-public:
-    ArrayVfsFile(std::array<u8, size> data, std::string name = "", VirtualDir parent = nullptr)
-        : data(data), name(std::move(name)), parent(std::move(parent)) {}
-
-    std::string GetName() const override {
-        return name;
-    }
-
-    std::size_t GetSize() const override {
-        return size;
-    }
-
-    bool Resize(std::size_t new_size) override {
-        return false;
-    }
-
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override {
-        return parent;
-    }
-
-    bool IsWritable() const override {
-        return false;
-    }
-
-    bool IsReadable() const override {
-        return true;
-    }
-
-    std::size_t Read(u8* data_, std::size_t length, std::size_t offset) const override {
-        const auto read = std::min(length, size - offset);
-        std::memcpy(data_, data.data() + offset, read);
-        return read;
-    }
-
-    std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override {
-        return 0;
-    }
-
-    bool Rename(std::string_view name) override {
-        this->name = name;
-        return true;
-    }
-
-private:
-    std::array<u8, size> data;
-    std::string name;
-    VirtualDir parent;
-};
-
 // An implementation of VfsFile that is backed by a vector optionally supplied upon construction
 class VectorVfsFile : public VfsFile {
 public:

src/core/hle/kernel/event.cpp

@@ -4,47 +4,46 @@
 
 #include <algorithm>
 #include "common/assert.h"
-#include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/thread.h"
 
 namespace Kernel {
 
-ReadableEvent::ReadableEvent(KernelCore& kernel) : WaitObject{kernel} {}
-ReadableEvent::~ReadableEvent() = default;
+Event::Event(KernelCore& kernel) : WaitObject{kernel} {}
+Event::~Event() = default;
 
-bool ReadableEvent::ShouldWait(Thread* thread) const {
+SharedPtr<Event> Event::Create(KernelCore& kernel, ResetType reset_type, std::string name) {
+    SharedPtr<Event> evt(new Event(kernel));
+
+    evt->signaled = false;
+    evt->reset_type = reset_type;
+    evt->name = std::move(name);
+
+    return evt;
+}
+
+bool Event::ShouldWait(Thread* thread) const {
     return !signaled;
 }
 
-void ReadableEvent::Acquire(Thread* thread) {
+void Event::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
 
     if (reset_type == ResetType::OneShot)
         signaled = false;
 }
 
-void ReadableEvent::Signal() {
+void Event::Signal() {
     signaled = true;
     WakeupAllWaitingThreads();
 }
 
-void ReadableEvent::Clear() {
+void Event::Clear() {
     signaled = false;
 }
 
-ResultCode ReadableEvent::Reset() {
-    if (!signaled) {
-        return ERR_INVALID_STATE;
-    }
-
-    Clear();
-
-    return RESULT_SUCCESS;
-}
-
-void ReadableEvent::WakeupAllWaitingThreads() {
+void Event::WakeupAllWaitingThreads() {
     WaitObject::WakeupAllWaitingThreads();
 
     if (reset_type == ResetType::Pulse)

src/core/hle/kernel/event.h

@@ -11,52 +11,49 @@
 namespace Kernel {
 
 class KernelCore;
-class ReadableEvent;
-class WritableEvent;
 
-struct EventPair {
-    SharedPtr<ReadableEvent> readable;
-    SharedPtr<WritableEvent> writable;
-};
-
-class WritableEvent final : public Object {
+class Event final : public WaitObject {
 public:
-    ~WritableEvent() override;
-
     /**
      * Creates an event
      * @param kernel The kernel instance to create this event under.
      * @param reset_type ResetType describing how to create event
      * @param name Optional name of event
      */
-    static EventPair CreateEventPair(KernelCore& kernel, ResetType reset_type,
-                                     std::string name = "Unknown");
+    static SharedPtr<Event> Create(KernelCore& kernel, ResetType reset_type,
+                                   std::string name = "Unknown");
 
     std::string GetTypeName() const override {
-        return "WritableEvent";
+        return "Event";
     }
     std::string GetName() const override {
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::WritableEvent;
+    static const HandleType HANDLE_TYPE = HandleType::Event;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
 
-    SharedPtr<ReadableEvent> GetReadableEvent() const;
+    ResetType GetResetType() const {
+        return reset_type;
+    }
 
-    ResetType GetResetType() const;
+    bool ShouldWait(Thread* thread) const override;
+    void Acquire(Thread* thread) override;
+
+    void WakeupAllWaitingThreads() override;
 
     void Signal();
     void Clear();
-    bool IsSignaled() const;
 
 private:
-    explicit WritableEvent(KernelCore& kernel);
+    explicit Event(KernelCore& kernel);
+    ~Event() override;
 
-    SharedPtr<ReadableEvent> readable;
+    ResetType reset_type; ///< Current ResetType
 
+    bool signaled;    ///< Whether the event has already been signaled
     std::string name; ///< Name of event (optional)
 };
 

src/core/hle/kernel/handle_table.cpp

@@ -42,10 +42,9 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
     u16 generation = next_generation++;
 
     // Overflow count so it fits in the 15 bits dedicated to the generation in the handle.
-    // Horizon OS uses zero to represent an invalid handle, so skip to 1.
-    if (next_generation >= (1 << 15)) {
+    // CTR-OS doesn't use generation 0, so skip straight to 1.
+    if (next_generation >= (1 << 15))
         next_generation = 1;
-    }
 
     generations[slot] = generation;
     objects[slot] = std::move(obj);

src/core/hle/kernel/handle_table.h

@@ -13,7 +13,6 @@
 namespace Kernel {
 
 enum KernelHandle : Handle {
-    InvalidHandle = 0,
     CurrentThread = 0xFFFF8000,
     CurrentProcess = 0xFFFF8001,
 };

src/core/hle/kernel/hle_ipc.cpp

@@ -15,14 +15,13 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/server_session.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 
 namespace Kernel {
@@ -37,9 +36,11 @@ void SessionRequestHandler::ClientDisconnected(const SharedPtr<ServerSession>& s
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
-SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
-    SharedPtr<Thread> thread, const std::string& reason, u64 timeout, WakeupCallback&& callback,
-    SharedPtr<WritableEvent> writable_event) {
+SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
+                                                      const std::string& reason, u64 timeout,
+                                                      WakeupCallback&& callback,
+                                                      Kernel::SharedPtr<Kernel::Event> event) {
+
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
     thread->SetWakeupCallback([context = *this, callback](
                                   ThreadWakeupReason reason, SharedPtr<Thread> thread,
@@ -50,25 +51,23 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
         return true;
     });
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    if (!writable_event) {
+    if (!event) {
         // Create event if not provided
-        const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                         "HLE Pause Event: " + reason);
-        writable_event = pair.writable;
+        auto& kernel = Core::System::GetInstance().Kernel();
+        event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
     }
 
-    const auto readable_event{writable_event->GetReadableEvent()};
-    writable_event->Clear();
+    event->Clear();
     thread->SetStatus(ThreadStatus::WaitHLEEvent);
-    thread->SetWaitObjects({readable_event});
-    readable_event->AddWaitingThread(thread);
+    thread->SetWaitObjects({event});
+    event->AddWaitingThread(thread);
 
     if (timeout > 0) {
         thread->WakeAfterDelay(timeout);
     }
 
-    return writable_event;
+    return event;
 }
 
 HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session)

src/core/hle/kernel/hle_ipc.h

@@ -24,11 +24,10 @@ class ServiceFrameworkBase;
 namespace Kernel {
 
 class Domain;
+class Event;
 class HandleTable;
 class HLERequestContext;
 class Process;
-class ReadableEvent;
-class WritableEvent;
 
 /**
  * Interface implemented by HLE Session handlers.
@@ -120,13 +119,12 @@ public:
      * @param callback Callback to be invoked when the thread is resumed. This callback must write
      * the entire command response once again, regardless of the state of it before this function
      * was called.
-     * @param writable_event Event to use to wake up the thread. If unspecified, an event will be
-     * created.
+     * @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<WritableEvent> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
-                                               u64 timeout, WakeupCallback&& callback,
-                                               SharedPtr<WritableEvent> writable_event = nullptr);
+    SharedPtr<Event> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
+                                       u64 timeout, WakeupCallback&& callback,
+                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);
 
     /// Populates this context with data from the requesting process/thread.
     ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,

src/core/hle/kernel/object.cpp

@@ -13,17 +13,16 @@ Object::~Object() = default;
 
 bool Object::IsWaitable() const {
     switch (GetHandleType()) {
-    case HandleType::ReadableEvent:
+    case HandleType::Event:
     case HandleType::Thread:
-    case HandleType::Process:
     case HandleType::Timer:
     case HandleType::ServerPort:
     case HandleType::ServerSession:
         return true;
 
     case HandleType::Unknown:
-    case HandleType::WritableEvent:
     case HandleType::SharedMemory:
+    case HandleType::Process:
     case HandleType::AddressArbiter:
     case HandleType::ResourceLimit:
     case HandleType::ClientPort:

src/core/hle/kernel/object.h

@@ -19,8 +19,7 @@ using Handle = u32;
 
 enum class HandleType : u32 {
     Unknown,
-    WritableEvent,
-    ReadableEvent,
+    Event,
     SharedMemory,
     Thread,
     Process,
@@ -34,9 +33,9 @@ enum class HandleType : u32 {
 };
 
 enum class ResetType {
-    OneShot, ///< Reset automatically on object acquisition
-    Sticky,  ///< Never reset automatically
-    Pulse,   ///< Reset automatically on wakeup
+    OneShot,
+    Sticky,
+    Pulse,
 };
 
 class Object : NonCopyable {

src/core/hle/kernel/process.cpp

@@ -9,7 +9,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -45,28 +44,9 @@ SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
     return process;
 }
 
-SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
-    return resource_limit;
-}
-
-ResultCode Process::ClearSignalState() {
-    if (status == ProcessStatus::Exited) {
-        LOG_ERROR(Kernel, "called on a terminated process instance.");
-        return ERR_INVALID_STATE;
-    }
-
-    if (!is_signaled) {
-        LOG_ERROR(Kernel, "called on a process instance that isn't signaled.");
-        return ERR_INVALID_STATE;
-    }
-
-    is_signaled = false;
-    return RESULT_SUCCESS;
-}
-
 void Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
+    system_resource_size = metadata.GetSystemResourceSize();
     program_id = metadata.GetTitleID();
-    ideal_processor = metadata.GetMainThreadCore();
     is_64bit_process = metadata.Is64BitProgram();
     vm_manager.Reset(metadata.GetAddressSpaceType());
 }
@@ -150,17 +130,17 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
     vm_manager
         .MapMemoryBlock(vm_manager.GetTLSIORegionEndAddress() - stack_size,
                         std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size,
-                        MemoryState::Stack)
+                        MemoryState::Mapped)
         .Unwrap();
 
     vm_manager.LogLayout();
-    ChangeStatus(ProcessStatus::Running);
+    status = ProcessStatus::Running;
 
     Kernel::SetupMainThread(kernel, entry_point, main_thread_priority, *this);
 }
 
 void Process::PrepareForTermination() {
-    ChangeStatus(ProcessStatus::Exiting);
+    status = ProcessStatus::Exited;
 
     const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
         for (auto& thread : thread_list) {
@@ -184,8 +164,6 @@ void Process::PrepareForTermination() {
     stop_threads(system.Scheduler(1).GetThreadList());
     stop_threads(system.Scheduler(2).GetThreadList());
     stop_threads(system.Scheduler(3).GetThreadList());
-
-    ChangeStatus(ProcessStatus::Exited);
 }
 
 /**
@@ -284,25 +262,7 @@ ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {
     return vm_manager.UnmapRange(dst_addr, size);
 }
 
-Kernel::Process::Process(KernelCore& kernel) : WaitObject{kernel} {}
+Kernel::Process::Process(KernelCore& kernel) : Object{kernel} {}
 Kernel::Process::~Process() {}
 
-void Process::Acquire(Thread* thread) {
-    ASSERT_MSG(!ShouldWait(thread), "Object unavailable!");
-}
-
-bool Process::ShouldWait(Thread* thread) const {
-    return !is_signaled;
-}
-
-void Process::ChangeStatus(ProcessStatus new_status) {
-    if (status == new_status) {
-        return;
-    }
-
-    status = new_status;
-    is_signaled = true;
-    WakeupAllWaitingThreads();
-}
-
 } // namespace Kernel

src/core/hle/kernel/process.h

@@ -14,10 +14,9 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
-#include "core/hle/kernel/wait_object.h"
-#include "core/hle/result.h"
 
 namespace FileSys {
 class ProgramMetadata;
@@ -118,7 +117,7 @@ struct CodeSet final {
     VAddr entrypoint = 0;
 };
 
-class Process final : public WaitObject {
+class Process final : public Object {
 public:
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
@@ -171,8 +170,21 @@ public:
         return program_id;
     }
 
+    /// Gets the extra system resources we can allocate which is typically passed to
+    /// MapPhysicalMemory
+    u32 GetSystemResourceSize() const {
+        return system_resource_size;
+    }
+
     /// Gets the resource limit descriptor for this process
-    SharedPtr<ResourceLimit> GetResourceLimit() const;
+    ResourceLimit& GetResourceLimit() {
+        return *resource_limit;
+    }
+
+    /// Gets the resource limit descriptor for this process
+    const ResourceLimit& GetResourceLimit() const {
+        return *resource_limit;
+    }
 
     /// Gets the default CPU ID for this process
     u8 GetDefaultProcessorID() const {
@@ -213,16 +225,6 @@ public:
         return random_entropy.at(index);
     }
 
-    /// Clears the signaled state of the process if and only if it's signaled.
-    ///
-    /// @pre The process must not be already terminated. If this is called on a
-    ///      terminated process, then ERR_INVALID_STATE will be returned.
-    ///
-    /// @pre The process must be in a signaled state. If this is called on a
-    ///      process instance that is not signaled, ERR_INVALID_STATE will be
-    ///      returned.
-    ResultCode ClearSignalState();
-
     /**
      * Loads process-specifics configuration info with metadata provided
      * by an executable.
@@ -262,7 +264,8 @@ public:
     ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
     ResultCode HeapFree(VAddr target, u32 size);
 
-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, MemoryState state);
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size,
+                            MemoryState state = MemoryState::Mapped);
 
     ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
 
@@ -270,17 +273,6 @@ private:
     explicit Process(KernelCore& kernel);
     ~Process() override;
 
-    /// Checks if the specified thread should wait until this process is available.
-    bool ShouldWait(Thread* thread) const override;
-
-    /// Acquires/locks this process for the specified thread if it's available.
-    void Acquire(Thread* thread) override;
-
-    /// Changes the process status. If the status is different
-    /// from the current process status, then this will trigger
-    /// a process signal.
-    void ChangeStatus(ProcessStatus new_status);
-
     /// Memory manager for this process.
     Kernel::VMManager vm_manager;
 
@@ -293,6 +285,9 @@ private:
     /// Title ID corresponding to the process
     u64 program_id;
 
+    /// The extra system resources we can allocate which is typically passed to MapPhysicalMemory
+    u32 system_resource_size = 0;
+
     /// Resource limit descriptor for this process
     SharedPtr<ResourceLimit> resource_limit;
 
@@ -326,10 +321,6 @@ private:
     /// specified by metadata provided to the process during loading.
     bool is_64bit_process = true;
 
-    /// Whether or not this process is signaled. This occurs
-    /// upon the process changing to a different state.
-    bool is_signaled = false;
-
     /// Total running time for the process in ticks.
     u64 total_process_running_time_ticks = 0;
 

src/core/hle/kernel/readable_event.h

@@ -1,66 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/kernel/object.h"
-#include "core/hle/kernel/wait_object.h"
-
-union ResultCode;
-
-namespace Kernel {
-
-class KernelCore;
-class WritableEvent;
-
-class ReadableEvent final : public WaitObject {
-    friend class WritableEvent;
-
-public:
-    ~ReadableEvent() override;
-
-    std::string GetTypeName() const override {
-        return "ReadableEvent";
-    }
-    std::string GetName() const override {
-        return name;
-    }
-
-    ResetType GetResetType() const {
-        return reset_type;
-    }
-
-    static const HandleType HANDLE_TYPE = HandleType::ReadableEvent;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    bool ShouldWait(Thread* thread) const override;
-    void Acquire(Thread* thread) override;
-
-    void WakeupAllWaitingThreads() override;
-
-    /// Unconditionally clears the readable event's state.
-    void Clear();
-
-    /// Clears the readable event's state if and only if it
-    /// has already been signaled.
-    ///
-    /// @pre The event must be in a signaled state. If this event
-    ///      is in an unsignaled state and this function is called,
-    ///      then ERR_INVALID_STATE will be returned.
-    ResultCode Reset();
-
-private:
-    explicit ReadableEvent(KernelCore& kernel);
-
-    void Signal();
-
-    ResetType reset_type;
-    bool signaled;
-
-    std::string name; ///< Name of event (optional)
-};
-
-} // namespace Kernel

src/core/hle/kernel/shared_memory.cpp

@@ -39,15 +39,15 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, SharedPtr<Proce
                 shared_memory->backing_block.get());
         }
     } else {
-        const auto& vm_manager = shared_memory->owner_process->VMManager();
+        auto& vm_manager = shared_memory->owner_process->VMManager();
 
         // The memory is already available and mapped in the owner process.
-        const auto vma = vm_manager.FindVMA(address);
-        ASSERT_MSG(vm_manager.IsValidHandle(vma), "Invalid memory address");
+        auto vma = vm_manager.FindVMA(address);
+        ASSERT_MSG(vma != vm_manager.vma_map.end(), "Invalid memory address");
         ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
 
         // The returned VMA might be a bigger one encompassing the desired address.
-        const auto vma_offset = address - vma->first;
+        auto vma_offset = address - vma->first;
         ASSERT_MSG(vma_offset + size <= vma->second.size,
                    "Shared memory exceeds bounds of mapped block");
 

src/core/hle/kernel/svc.cpp

@@ -20,50 +20,24 @@
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/svc_wrap.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
-#include "core/memory.h"
+#include "core/settings.h"
 
 namespace Kernel {
 namespace {
-
-// Checks if address + size is greater than the given address
-// This can return false if the size causes an overflow of a 64-bit type
-// or if the given size is zero.
-constexpr bool IsValidAddressRange(VAddr address, u64 size) {
-    return address + size > address;
-}
-
-// Checks if a given address range lies within a larger address range.
-constexpr bool IsInsideAddressRange(VAddr address, u64 size, VAddr address_range_begin,
-                                    VAddr address_range_end) {
-    const VAddr end_address = address + size - 1;
-    return address_range_begin <= address && end_address <= address_range_end - 1;
-}
-
-bool IsInsideAddressSpace(const VMManager& vm, VAddr address, u64 size) {
-    return IsInsideAddressRange(address, size, vm.GetAddressSpaceBaseAddress(),
-                                vm.GetAddressSpaceEndAddress());
-}
-
-bool IsInsideNewMapRegion(const VMManager& vm, VAddr address, u64 size) {
-    return IsInsideAddressRange(address, size, vm.GetNewMapRegionBaseAddress(),
-                                vm.GetNewMapRegionEndAddress());
-}
-
 // 8 GiB
 constexpr u64 MAIN_MEMORY_SIZE = 0x200000000;
 
@@ -105,16 +79,16 @@ ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_add
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    if (!IsInsideAddressSpace(vm_manager, src_addr, size)) {
+    if (!vm_manager.IsInsideAddressSpace(src_addr, size)) {
         LOG_ERROR(Kernel_SVC,
-                  "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}",
+                  "Source is not inside the address space, addr=0x{:016X}, size=0x{:016X}",
                   src_addr, size);
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    if (!IsInsideNewMapRegion(vm_manager, dst_addr, size)) {
+    if (!vm_manager.IsInsideNewMapRegion(dst_addr, size)) {
         LOG_ERROR(Kernel_SVC,
-                  "Destination is not within the new map region, addr=0x{:016X}, size=0x{:016X}",
+                  "Destination is not inside the new map region, addr=0x{:016X}, size=0x{:016X}",
                   dst_addr, size);
         return ERR_INVALID_MEMORY_RANGE;
     }
@@ -140,6 +114,7 @@ ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_add
 
     return RESULT_SUCCESS;
 }
+} // namespace
 
 enum class ResourceLimitValueType {
     CurrentValue,
@@ -172,7 +147,6 @@ ResultVal<s64> RetrieveResourceLimitValue(Handle resource_limit, u32 resource_ty
 
     return MakeResult(resource_limit_object->GetMaxResourceValue(type));
 }
-} // Anonymous namespace
 
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
 static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
@@ -232,7 +206,7 @@ static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
     auto* const current_process = Core::CurrentProcess();
     auto& vm_manager = current_process->VMManager();
 
-    if (!IsInsideAddressSpace(vm_manager, addr, size)) {
+    if (!vm_manager.IsInsideAddressSpace(addr, size)) {
         LOG_ERROR(Kernel_SVC,
                   "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
                   size);
@@ -240,14 +214,14 @@ static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
     }
 
     const VMManager::VMAHandle iter = vm_manager.FindVMA(addr);
-    if (!vm_manager.IsValidHandle(iter)) {
+    if (iter == vm_manager.vma_map.end()) {
         LOG_ERROR(Kernel_SVC, "Unable to find VMA for address=0x{:016X}", addr);
         return ERR_INVALID_ADDRESS_STATE;
     }
 
     LOG_WARNING(Kernel_SVC, "Uniformity check on protected memory is not implemented.");
-    // TODO: Performs a uniformity check to make sure only protected memory is changed (it doesn't
-    // make sense to allow changing permissions on kernel memory itself, etc).
+    // TODO: Performs a uniformity check to make sure only protected memory is changed (it
+    // doesn't make sense to allow changing permissions on kernel memory itself, etc).
 
     const auto converted_permissions = SharedMemory::ConvertPermissions(permission);
 
@@ -274,7 +248,7 @@ static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
         return result;
     }
 
-    return current_process->MirrorMemory(dst_addr, src_addr, size, MemoryState::Stack);
+    return current_process->MirrorMemory(dst_addr, src_addr, size);
 }
 
 /// Unmaps a region that was previously mapped with svcMapMemory
@@ -621,10 +595,10 @@ static void Break(u32 reason, u64 info1, u64 info2) {
     }
 
     if (!break_reason.signal_debugger) {
-        LOG_CRITICAL(
-            Debug_Emulated,
-            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
-            reason, info1, info2);
+        LOG_CRITICAL(Debug_Emulated,
+                     "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, "
+                     "info2=0x{:016X}",
+                     reason, info1, info2);
         handle_debug_buffer(info1, info2);
         ASSERT(false);
 
@@ -663,7 +637,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         TotalMemoryUsage = 6,
         TotalHeapUsage = 7,
         IsCurrentProcessBeingDebugged = 8,
-        RegisterResourceLimit = 9,
+        ResourceHandleLimit = 9,
         IdleTickCount = 10,
         RandomEntropy = 11,
         PerformanceCounter = 0xF0000002,
@@ -673,7 +647,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         NewMapRegionBaseAddr = 14,
         NewMapRegionSize = 15,
         // 3.0.0+
-        IsVirtualAddressMemoryEnabled = 16,
+        SystemResourceSize = 16,
         PersonalMmHeapUsage = 17,
         TitleId = 18,
         // 4.0.0+
@@ -683,137 +657,37 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         ThreadTickCount = 0xF0000002,
     };
 
-    const auto info_id_type = static_cast<GetInfoType>(info_id);
+    const auto* current_process = Core::CurrentProcess();
+    const auto& vm_manager = current_process->VMManager();
 
-    switch (info_id_type) {
+    switch (static_cast<GetInfoType>(info_id)) {
     case GetInfoType::AllowedCpuIdBitmask:
+        *result = current_process->GetAllowedProcessorMask();
+        break;
     case GetInfoType::AllowedThreadPrioBitmask:
+        *result = current_process->GetAllowedThreadPriorityMask();
+        break;
     case GetInfoType::MapRegionBaseAddr:
+        *result = vm_manager.GetMapRegionBaseAddress();
+        break;
     case GetInfoType::MapRegionSize:
+        *result = vm_manager.GetMapRegionSize();
+        break;
     case GetInfoType::HeapRegionBaseAddr:
+        *result = vm_manager.GetHeapRegionBaseAddress();
+        break;
     case GetInfoType::HeapRegionSize:
-    case GetInfoType::ASLRRegionBaseAddr:
-    case GetInfoType::ASLRRegionSize:
-    case GetInfoType::NewMapRegionBaseAddr:
-    case GetInfoType::NewMapRegionSize:
+        *result = vm_manager.GetHeapRegionSize();
+        break;
     case GetInfoType::TotalMemoryUsage:
+        *result = vm_manager.GetTotalMemoryUsage();
+        break;
     case GetInfoType::TotalHeapUsage:
-    case GetInfoType::IsVirtualAddressMemoryEnabled:
-    case GetInfoType::PersonalMmHeapUsage:
-    case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr: {
-        if (info_sub_id != 0) {
-            return ERR_INVALID_ENUM_VALUE;
-        }
-
-        const auto& current_process_handle_table = Core::CurrentProcess()->GetHandleTable();
-        const auto process = current_process_handle_table.Get<Process>(static_cast<Handle>(handle));
-        if (!process) {
-            return ERR_INVALID_HANDLE;
-        }
-
-        switch (info_id_type) {
-        case GetInfoType::AllowedCpuIdBitmask:
-            *result = process->GetAllowedProcessorMask();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::AllowedThreadPrioBitmask:
-            *result = process->GetAllowedThreadPriorityMask();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::MapRegionBaseAddr:
-            *result = process->VMManager().GetMapRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::MapRegionSize:
-            *result = process->VMManager().GetMapRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::HeapRegionBaseAddr:
-            *result = process->VMManager().GetHeapRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::HeapRegionSize:
-            *result = process->VMManager().GetHeapRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::ASLRRegionBaseAddr:
-            *result = process->VMManager().GetASLRRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::ASLRRegionSize:
-            *result = process->VMManager().GetASLRRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::NewMapRegionBaseAddr:
-            *result = process->VMManager().GetNewMapRegionBaseAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::NewMapRegionSize:
-            *result = process->VMManager().GetNewMapRegionSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalMemoryUsage:
-            *result = process->VMManager().GetTotalMemoryUsage();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalHeapUsage:
-            *result = process->VMManager().GetTotalHeapUsage();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::IsVirtualAddressMemoryEnabled:
-            *result = process->IsVirtualMemoryEnabled();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TitleId:
-            *result = process->GetTitleID();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::UserExceptionContextAddr:
-            LOG_WARNING(Kernel_SVC,
-                        "(STUBBED) Attempted to query user exception context address, returned 0");
-            *result = 0;
-            return RESULT_SUCCESS;
-
-        default:
-            break;
-        }
-
-        LOG_WARNING(Kernel_SVC, "(STUBBED) Unimplemented svcGetInfo id=0x{:016X}", info_id);
-        return ERR_INVALID_ENUM_VALUE;
-    }
-
+        *result = vm_manager.GetTotalHeapUsage();
+        break;
     case GetInfoType::IsCurrentProcessBeingDebugged:
         *result = 0;
-        return RESULT_SUCCESS;
-
-    case GetInfoType::RegisterResourceLimit: {
-        if (handle != 0) {
-            return ERR_INVALID_HANDLE;
-        }
-
-        if (info_sub_id != 0) {
-            return ERR_INVALID_COMBINATION;
-        }
-
-        Process* const current_process = Core::CurrentProcess();
-        HandleTable& handle_table = current_process->GetHandleTable();
-        const auto resource_limit = current_process->GetResourceLimit();
-        if (!resource_limit) {
-            *result = KernelHandle::InvalidHandle;
-            // Yes, the kernel considers this a successful operation.
-            return RESULT_SUCCESS;
-        }
-
-        const auto table_result = handle_table.Create(resource_limit);
-        if (table_result.Failed()) {
-            return table_result.Code();
-        }
-
-        *result = *table_result;
-        return RESULT_SUCCESS;
-    }
-
+        break;
     case GetInfoType::RandomEntropy:
         if (handle != 0) {
             LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
@@ -827,15 +701,40 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
             return ERR_INVALID_COMBINATION;
         }
 
-        *result = Core::CurrentProcess()->GetRandomEntropy(info_sub_id);
+        *result = current_process->GetRandomEntropy(info_sub_id);
         return RESULT_SUCCESS;
-
+        break;
+    case GetInfoType::ASLRRegionBaseAddr:
+        *result = vm_manager.GetASLRRegionBaseAddress();
+        break;
+    case GetInfoType::ASLRRegionSize:
+        *result = vm_manager.GetASLRRegionSize();
+        break;
+    case GetInfoType::NewMapRegionBaseAddr:
+        *result = vm_manager.GetNewMapRegionBaseAddress();
+        break;
+    case GetInfoType::NewMapRegionSize:
+        *result = vm_manager.GetNewMapRegionSize();
+        break;
+    case GetInfoType::SystemResourceSize:
+        *result = current_process->GetSystemResourceSize();
+        break;
+    case GetInfoType::PersonalMmHeapUsage:
+        *result = vm_manager.GetPersonalMmHeapUsage();
+        break;
+    case GetInfoType::TitleId:
+        *result = current_process->GetTitleID();
+        break;
     case GetInfoType::PrivilegedProcessId:
         LOG_WARNING(Kernel_SVC,
                     "(STUBBED) Attempted to query privileged process id bounds, returned 0");
         *result = 0;
-        return RESULT_SUCCESS;
-
+        break;
+    case GetInfoType::UserExceptionContextAddr:
+        LOG_WARNING(Kernel_SVC,
+                    "(STUBBED) Attempted to query user exception context address, returned 0");
+        *result = 0;
+        break;
     case GetInfoType::ThreadTickCount: {
         constexpr u64 num_cpus = 4;
         if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
@@ -845,7 +744,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         }
 
         const auto thread =
-            Core::CurrentProcess()->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
+            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
         if (!thread) {
             LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
                       static_cast<Handle>(handle));
@@ -868,13 +767,14 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         }
 
         *result = out_ticks;
-        return RESULT_SUCCESS;
+        break;
     }
-
     default:
         LOG_WARNING(Kernel_SVC, "(STUBBED) Unimplemented svcGetInfo id=0x{:016X}", info_id);
         return ERR_INVALID_ENUM_VALUE;
     }
+
+    return RESULT_SUCCESS;
 }
 
 /// Sets the thread activity
@@ -944,10 +844,10 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
     LOG_TRACE(Kernel_SVC, "called");
 
     if (priority > THREADPRIO_LOWEST) {
-        LOG_ERROR(
-            Kernel_SVC,
-            "An invalid priority was specified, expected {} but got {} for thread_handle={:08X}",
-            THREADPRIO_LOWEST, priority, handle);
+        LOG_ERROR(Kernel_SVC,
+                  "An invalid priority was specified, expected {} but got {} for "
+                  "thread_handle={:08X}",
+                  THREADPRIO_LOWEST, priority, handle);
         return ERR_INVALID_THREAD_PRIORITY;
     }
 
@@ -1067,9 +967,10 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
     return shared_memory->Unmap(*current_process, addr);
 }
 
-static ResultCode QueryProcessMemory(VAddr memory_info_address, VAddr page_info_address,
-                                     Handle process_handle, VAddr address) {
-    LOG_TRACE(Kernel_SVC, "called process=0x{:08X} address={:X}", process_handle, address);
+/// Query process memory
+static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
+                                     Handle process_handle, u64 addr) {
+    LOG_TRACE(Kernel_SVC, "called process=0x{:08X} addr={:X}", process_handle, addr);
     const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
     SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
     if (!process) {
@@ -1077,34 +978,26 @@ static ResultCode QueryProcessMemory(VAddr memory_info_address, VAddr page_info_
                   process_handle);
         return ERR_INVALID_HANDLE;
     }
-
-    const auto& vm_manager = process->VMManager();
-    const MemoryInfo memory_info = vm_manager.QueryMemory(address);
-
-    Memory::Write64(memory_info_address, memory_info.base_address);
-    Memory::Write64(memory_info_address + 8, memory_info.size);
-    Memory::Write32(memory_info_address + 16, memory_info.state);
-    Memory::Write32(memory_info_address + 20, memory_info.attributes);
-    Memory::Write32(memory_info_address + 24, memory_info.permission);
-    Memory::Write32(memory_info_address + 32, memory_info.ipc_ref_count);
-    Memory::Write32(memory_info_address + 28, memory_info.device_ref_count);
-    Memory::Write32(memory_info_address + 36, 0);
-
-    // Page info appears to be currently unused by the kernel and is always set to zero.
-    Memory::Write32(page_info_address, 0);
-
+    auto vma = process->VMManager().FindVMA(addr);
+    memory_info->attributes = 0;
+    if (vma == process->VMManager().vma_map.end()) {
+        memory_info->base_address = 0;
+        memory_info->permission = static_cast<u32>(VMAPermission::None);
+        memory_info->size = 0;
+        memory_info->type = static_cast<u32>(MemoryState::Unmapped);
+    } else {
+        memory_info->base_address = vma->second.base;
+        memory_info->permission = static_cast<u32>(vma->second.permissions);
+        memory_info->size = vma->second.size;
+        memory_info->type = static_cast<u32>(vma->second.meminfo_state);
+    }
     return RESULT_SUCCESS;
 }
 
-static ResultCode QueryMemory(VAddr memory_info_address, VAddr page_info_address,
-                              VAddr query_address) {
-    LOG_TRACE(Kernel_SVC,
-              "called, memory_info_address=0x{:016X}, page_info_address=0x{:016X}, "
-              "query_address=0x{:016X}",
-              memory_info_address, page_info_address, query_address);
-
-    return QueryProcessMemory(memory_info_address, page_info_address, CurrentProcess,
-                              query_address);
+/// Query memory
+static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAddr addr) {
+    LOG_TRACE(Kernel_SVC, "called, addr={:X}", addr);
+    return QueryProcessMemory(memory_info, page_info, CurrentProcess, addr);
 }
 
 /// Exits the current process
@@ -1127,9 +1020,9 @@ static void ExitProcess() {
 static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, VAddr stack_top,
                                u32 priority, s32 processor_id) {
     LOG_TRACE(Kernel_SVC,
-              "called entrypoint=0x{:08X}, arg=0x{:08X}, stacktop=0x{:08X}, "
+              "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
               "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
-              entry_point, arg, stack_top, priority, processor_id, *out_handle);
+              entry_point, name, arg, stack_top, priority, processor_id, *out_handle);
 
     if (priority > THREADPRIO_LOWEST) {
         LOG_ERROR(Kernel_SVC, "An invalid priority was specified, expected {} but got {}",
@@ -1225,10 +1118,10 @@ static void SleepThread(s64 nanoseconds) {
 /// Wait process wide key atomic
 static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_variable_addr,
                                            Handle thread_handle, s64 nano_seconds) {
-    LOG_TRACE(
-        Kernel_SVC,
-        "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
-        mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
+    LOG_TRACE(Kernel_SVC,
+              "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, "
+              "timeout={}",
+              mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
 
     const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
     SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
@@ -1441,24 +1334,17 @@ static ResultCode CloseHandle(Handle handle) {
     return handle_table.Close(handle);
 }
 
-/// Clears the signaled state of an event or process.
+/// Reset an event
 static ResultCode ResetSignal(Handle handle) {
     LOG_DEBUG(Kernel_SVC, "called handle 0x{:08X}", handle);
 
     const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    auto event = handle_table.Get<Event>(handle);
 
-    auto event = handle_table.Get<ReadableEvent>(handle);
-    if (event) {
-        return event->Reset();
-    }
+    ASSERT(event != nullptr);
 
-    auto process = handle_table.Get<Process>(handle);
-    if (process) {
-        return process->ClearSignalState();
-    }
-
-    LOG_ERROR(Kernel_SVC, "Invalid handle (0x{:08X})", handle);
-    return ERR_INVALID_HANDLE;
+    event->Clear();
+    return RESULT_SUCCESS;
 }
 
 /// Creates a TransferMemory object
@@ -1543,7 +1429,8 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
         return ERR_INVALID_COMBINATION;
     }
 
-    /// This value is used to only change the affinity mask without changing the current ideal core.
+    /// This value is used to only change the affinity mask without changing the current ideal
+    /// core.
     static constexpr u32 OnlyChangeMask = static_cast<u32>(-3);
 
     if (core == OnlyChangeMask) {
@@ -1612,67 +1499,17 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
     return RESULT_SUCCESS;
 }
 
-static ResultCode CreateEvent(Handle* write_handle, Handle* read_handle) {
-    LOG_DEBUG(Kernel_SVC, "called");
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const auto [readable_event, writable_event] =
-        WritableEvent::CreateEventPair(kernel, ResetType::Sticky, "CreateEvent");
-
-    HandleTable& handle_table = kernel.CurrentProcess()->GetHandleTable();
-
-    const auto write_create_result = handle_table.Create(writable_event);
-    if (write_create_result.Failed()) {
-        return write_create_result.Code();
-    }
-    *write_handle = *write_create_result;
-
-    const auto read_create_result = handle_table.Create(readable_event);
-    if (read_create_result.Failed()) {
-        handle_table.Close(*write_create_result);
-        return read_create_result.Code();
-    }
-    *read_handle = *read_create_result;
-
-    LOG_DEBUG(Kernel_SVC,
-              "successful. Writable event handle=0x{:08X}, Readable event handle=0x{:08X}",
-              *write_create_result, *read_create_result);
-    return RESULT_SUCCESS;
-}
-
 static ResultCode ClearEvent(Handle handle) {
     LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
 
     const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-
-    auto writable_event = handle_table.Get<WritableEvent>(handle);
-    if (writable_event) {
-        writable_event->Clear();
-        return RESULT_SUCCESS;
-    }
-
-    auto readable_event = handle_table.Get<ReadableEvent>(handle);
-    if (readable_event) {
-        readable_event->Clear();
-        return RESULT_SUCCESS;
-    }
-
-    LOG_ERROR(Kernel_SVC, "Event handle does not exist, handle=0x{:08X}", handle);
-    return ERR_INVALID_HANDLE;
-}
-
-static ResultCode SignalEvent(Handle handle) {
-    LOG_DEBUG(Kernel_SVC, "called. Handle=0x{:08X}", handle);
-
-    HandleTable& handle_table = Core::CurrentProcess()->GetHandleTable();
-    auto writable_event = handle_table.Get<WritableEvent>(handle);
-
-    if (!writable_event) {
-        LOG_ERROR(Kernel_SVC, "Non-existent writable event handle used (0x{:08X})", handle);
+    SharedPtr<Event> evt = handle_table.Get<Event>(handle);
+    if (evt == nullptr) {
+        LOG_ERROR(Kernel_SVC, "Event handle does not exist, handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
     }
 
-    writable_event->Signal();
+    evt->Clear();
     return RESULT_SUCCESS;
 }
 
@@ -1772,17 +1609,103 @@ static ResultCode SetResourceLimitLimitValue(Handle resource_limit, u32 resource
 
     const auto set_result = resource_limit_object->SetLimitValue(type, static_cast<s64>(value));
     if (set_result.IsError()) {
-        LOG_ERROR(
-            Kernel_SVC,
-            "Attempted to lower resource limit ({}) for category '{}' below its current value ({})",
-            resource_limit_object->GetMaxResourceValue(type), resource_type,
-            resource_limit_object->GetCurrentResourceValue(type));
+        LOG_ERROR(Kernel_SVC,
+                  "Attempted to lower resource limit ({}) for category '{}' below its current "
+                  "value ({})",
+                  resource_limit_object->GetMaxResourceValue(type), resource_type,
+                  resource_limit_object->GetCurrentResourceValue(type));
         return set_result;
     }
-
     return RESULT_SUCCESS;
 }
 
+static ResultCode MapPhysicalMemory(VAddr addr, u64 size) {
+    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:08X}, size=0x{:X}", addr, size);
+
+    if (!Common::Is4KBAligned(addr)) {
+        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
+        return ERR_INVALID_ADDRESS;
+    }
+
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
+        return ERR_INVALID_SIZE;
+    }
+
+    if (!IsValidAddressRange(addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Address is not a valid address range, addr=0x{:016X}, size=0x{:016X}", addr,
+                  size);
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    auto* const current_process = Core::CurrentProcess();
+    auto& vm_manager = current_process->VMManager();
+
+    if (current_process->GetSystemResourceSize() == 0) {
+        LOG_ERROR(Kernel_SVC, "The system resource size is 0");
+        return ERR_INVALID_STATE;
+    }
+
+    if (!vm_manager.IsInsideMapRegion(addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination does not fit within the map region, addr=0x{:016X}, "
+                  "size=0x{:016X}",
+                  addr, size);
+        return ERR_INVALID_MEMORY_RANGE;
+    }
+
+    return vm_manager.MapPhysicalMemory(addr, size);
+}
+
+static ResultCode UnmapPhysicalMemory(VAddr addr, u64 size) {
+    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:08X}, size=0x{:X}", addr, size);
+    if (!Common::Is4KBAligned(addr)) {
+        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
+        return ERR_INVALID_ADDRESS;
+    }
+
+    if (size == 0) {
+        LOG_ERROR(Kernel_SVC, "Size is 0");
+        return ERR_INVALID_SIZE;
+    }
+
+    if (!Common::Is4KBAligned(size)) {
+        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:016X}", size);
+        return ERR_INVALID_SIZE;
+    }
+
+    if (!IsValidAddressRange(addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Address is not a valid address range, addr=0x{:016X}, size=0x{:016X}", addr,
+                  size);
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    auto* const current_process = Core::CurrentProcess();
+    auto& vm_manager = current_process->VMManager();
+
+    if (current_process->GetSystemResourceSize() == 0) {
+        LOG_ERROR(Kernel_SVC, "The system resource size is 0");
+        return ERR_INVALID_STATE;
+    }
+
+    if (!vm_manager.IsInsideMapRegion(addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination does not fit within the map region, addr=0x{:016X}, "
+                  "size=0x{:016X}",
+                  addr, size);
+        return ERR_INVALID_MEMORY_RANGE;
+    }
+
+    return vm_manager.UnmapPhysicalMemory(addr, size);
+}
+
 namespace {
 struct FunctionDef {
     using Func = void();
@@ -1811,7 +1734,7 @@ static const FunctionDef SVC_Table[] = {
     {0x0E, SvcWrap<GetThreadCoreMask>, "GetThreadCoreMask"},
     {0x0F, SvcWrap<SetThreadCoreMask>, "SetThreadCoreMask"},
     {0x10, SvcWrap<GetCurrentProcessorNumber>, "GetCurrentProcessorNumber"},
-    {0x11, SvcWrap<SignalEvent>, "SignalEvent"},
+    {0x11, nullptr, "SignalEvent"},
     {0x12, SvcWrap<ClearEvent>, "ClearEvent"},
     {0x13, SvcWrap<MapSharedMemory>, "MapSharedMemory"},
     {0x14, SvcWrap<UnmapSharedMemory>, "UnmapSharedMemory"},
@@ -1838,8 +1761,8 @@ static const FunctionDef SVC_Table[] = {
     {0x29, SvcWrap<GetInfo>, "GetInfo"},
     {0x2A, nullptr, "FlushEntireDataCache"},
     {0x2B, nullptr, "FlushDataCache"},
-    {0x2C, nullptr, "MapPhysicalMemory"},
-    {0x2D, nullptr, "UnmapPhysicalMemory"},
+    {0x2C, SvcWrap<MapPhysicalMemory>, "MapPhysicalMemory"},
+    {0x2D, SvcWrap<UnmapPhysicalMemory>, "UnmapPhysicalMemory"},
     {0x2E, nullptr, "GetFutureThreadInfo"},
     {0x2F, nullptr, "GetLastThreadInfo"},
     {0x30, SvcWrap<GetResourceLimitLimitValue>, "GetResourceLimitLimitValue"},
@@ -1863,7 +1786,7 @@ static const FunctionDef SVC_Table[] = {
     {0x42, nullptr, "ReplyAndReceiveLight"},
     {0x43, nullptr, "ReplyAndReceive"},
     {0x44, nullptr, "ReplyAndReceiveWithUserBuffer"},
-    {0x45, SvcWrap<CreateEvent>, "CreateEvent"},
+    {0x45, nullptr, "CreateEvent"},
     {0x46, nullptr, "Unknown"},
     {0x47, nullptr, "Unknown"},
     {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
@@ -1912,7 +1835,7 @@ static const FunctionDef SVC_Table[] = {
     {0x73, nullptr, "SetProcessMemoryPermission"},
     {0x74, nullptr, "MapProcessMemory"},
     {0x75, nullptr, "UnmapProcessMemory"},
-    {0x76, SvcWrap<QueryProcessMemory>, "QueryProcessMemory"},
+    {0x76, nullptr, "QueryProcessMemory"},
     {0x77, nullptr, "MapProcessCodeMemory"},
     {0x78, nullptr, "UnmapProcessCodeMemory"},
     {0x79, nullptr, "CreateProcess"},

src/core/hle/kernel/svc.h

@@ -8,6 +8,22 @@
 
 namespace Kernel {
 
+struct MemoryInfo {
+    u64 base_address;
+    u64 size;
+    u32 type;
+    u32 attributes;
+    u32 permission;
+    u32 device_refcount;
+    u32 ipc_refcount;
+    INSERT_PADDING_WORDS(1);
+};
+static_assert(sizeof(MemoryInfo) == 0x28, "MemoryInfo has incorrect size.");
+
+struct PageInfo {
+    u64 flags;
+};
+
 void CallSVC(u32 immediate);
 
 } // namespace Kernel

src/core/hle/kernel/svc_wrap.h

@@ -7,7 +7,9 @@
 #include "common/common_types.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
+#include "core/hle/kernel/svc.h"
 #include "core/hle/result.h"
+#include "core/memory.h"
 
 namespace Kernel {
 
@@ -57,19 +59,6 @@ void SvcWrap() {
     FuncReturn(retval);
 }
 
-template <ResultCode func(u32*, u32*)>
-void SvcWrap() {
-    u32 param_1 = 0;
-    u32 param_2 = 0;
-    const u32 retval = func(&param_1, &param_2).raw;
-
-    auto& arm_interface = Core::CurrentArmInterface();
-    arm_interface.SetReg(1, param_1);
-    arm_interface.SetReg(2, param_2);
-
-    FuncReturn(retval);
-}
-
 template <ResultCode func(u32*, u64)>
 void SvcWrap() {
     u32 param_1 = 0;
@@ -130,11 +119,6 @@ void SvcWrap() {
         func(Param(0), Param(1), static_cast<u32>(Param(3)), static_cast<u32>(Param(3))).raw);
 }
 
-template <ResultCode func(u64, u64, u32, u64)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2)), Param(3)).raw);
-}
-
 template <ResultCode func(u32, u64, u32)>
 void SvcWrap() {
     FuncReturn(func(static_cast<u32>(Param(0)), Param(1), static_cast<u32>(Param(2))).raw);
@@ -161,6 +145,11 @@ void SvcWrap() {
     FuncReturn(func(static_cast<u32>(Param(0)), Param(1), Param(2)).raw);
 }
 
+template <ResultCode func(u64, u64)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), Param(1)).raw);
+}
+
 template <ResultCode func(u32*, u64, u64, s64)>
 void SvcWrap() {
     u32 param_1 = 0;
@@ -194,6 +183,21 @@ void SvcWrap() {
     FuncReturn(retval);
 }
 
+template <ResultCode func(MemoryInfo*, PageInfo*, u64)>
+void SvcWrap() {
+    MemoryInfo memory_info = {};
+    PageInfo page_info = {};
+    u32 retval = func(&memory_info, &page_info, Param(2)).raw;
+
+    Memory::Write64(Param(0), memory_info.base_address);
+    Memory::Write64(Param(0) + 8, memory_info.size);
+    Memory::Write32(Param(0) + 16, memory_info.type);
+    Memory::Write32(Param(0) + 20, memory_info.attributes);
+    Memory::Write32(Param(0) + 24, memory_info.permission);
+
+    FuncReturn(retval);
+}
+
 template <ResultCode func(u32*, u64, u64, u32)>
 void SvcWrap() {
     u32 param_1 = 0;

src/core/hle/kernel/vm_manager.cpp

@@ -7,6 +7,7 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "common/scope_exit.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
@@ -25,14 +26,14 @@ static const char* GetMemoryStateName(MemoryState state) {
         "CodeMutable",      "Heap",
         "Shared",           "Unknown1",
         "ModuleCodeStatic", "ModuleCodeMutable",
-        "IpcBuffer0",       "Stack",
+        "IpcBuffer0",       "Mapped",
         "ThreadLocal",      "TransferMemoryIsolated",
         "TransferMemory",   "ProcessMemory",
-        "Inaccessible",     "IpcBuffer1",
+        "Unknown2",         "IpcBuffer1",
         "IpcBuffer3",       "KernelStack",
     };
 
-    return names[ToSvcMemoryState(state)];
+    return names[static_cast<int>(state)];
 }
 
 bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
@@ -87,10 +88,6 @@ VMManager::VMAHandle VMManager::FindVMA(VAddr target) const {
     }
 }
 
-bool VMManager::IsValidHandle(VMAHandle handle) const {
-    return handle != vma_map.cend();
-}
-
 ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
                                                           std::shared_ptr<std::vector<u8>> block,
                                                           std::size_t offset, u64 size,
@@ -167,6 +164,219 @@ ResultVal<VAddr> VMManager::FindFreeRegion(u64 size) const {
     return MakeResult<VAddr>(target);
 }
 
+constexpr bool AreOverlapping(VAddr addr_start, VAddr addr_end, VAddr region_start,
+                              VAddr region_end) {
+    return std::max(addr_end, region_end) - std::min(addr_start, region_start) <
+           (addr_end - addr_start) + (region_end - region_start);
+}
+
+ResultCode VMManager::MapPhysicalMemory(VAddr addr, u64 size) {
+    const auto base = GetMapRegionBaseAddress();
+    const auto end = GetMapRegionEndAddress();
+
+    if (!IsInsideMapRegion(addr, size)) {
+        LOG_ERROR(
+            Kernel,
+            "Address and size does not fall inside the map region, addr=0x{:016X}, size=0x{:016X}",
+            addr, size);
+        return ERR_INVALID_ADDRESS;
+    }
+
+    // We have nothing mapped, we can just map directly
+    if (personal_heap_usage == 0) {
+        const auto result = MapMemoryBlock(addr, std::make_shared<std::vector<u8>>(size, 0), 0,
+                                           size, MemoryState::Mapped);
+        personal_heap_usage += size;
+        return result.Code();
+    }
+
+    auto vma = FindVMA(base);
+    u64 remaining_to_map = size;
+    auto last_result = RESULT_SUCCESS;
+    // Needed just in case we fail to map a region, we'll unmap everything.
+    std::vector<std::pair<u64, u64>> mapped_regions;
+    while (vma != vma_map.end() && vma->second.base <= end && remaining_to_map > 0) {
+        const auto vma_start = vma->second.base;
+        const auto vma_end = vma_start + vma->second.size;
+        const auto is_mapped = vma->second.meminfo_state == MemoryState::Mapped;
+        // Something failed, lets bail out
+        if (last_result.IsError()) {
+            break;
+        }
+        last_result = RESULT_SUCCESS;
+
+        // Allows us to use continue without worrying about incrementing the vma
+        SCOPE_EXIT({ vma++; });
+
+        // We're out of range now, we can just break. We should be done with everything now
+        if (vma_start > addr + size - 1) {
+            break;
+        }
+
+        // We're not processing addresses yet, lets keep skipping
+        if (!AreOverlapping(addr, addr + size, vma_start, vma_end)) {
+            continue;
+        }
+
+        // If we fall within the vma, get the offset of where we begin in the said vma
+        const auto offset_in_vma = vma_start + ((addr + size - remaining_to_map) - vma_start);
+        const auto remaining_vma_size = (vma_end - offset_in_vma);
+        // Our vma is already mapped
+        if (is_mapped) {
+            if (remaining_vma_size >= remaining_to_map) {
+                // Our region we need is already mapped
+                break;
+            } else {
+                // We are partially mapped, Make note of it and move on
+                remaining_to_map -= remaining_vma_size;
+                continue;
+            }
+        } else {
+            // We're not mapped, so lets map some space
+            if (remaining_vma_size >= remaining_to_map) {
+                // We can fit everything in this region, lets finish off the mapping
+                last_result = MapMemoryBlock(offset_in_vma,
+                                             std::make_shared<std::vector<u8>>(remaining_to_map, 0),
+                                             0, remaining_to_map, MemoryState::Mapped)
+                                  .Code();
+                if (last_result.IsSuccess()) {
+                    personal_heap_usage += remaining_to_map;
+                    mapped_regions.push_back(std::make_pair(offset_in_vma, remaining_to_map));
+                } else {
+                    LOG_ERROR(Kernel,
+                              "Failed to map entire VMA with error 0x{:X}, addr=0x{:016X}, "
+                              "size=0x{:016X}, vma_start={:016X}, vma_end={:016X}, "
+                              "offset_in_vma={:016X}, remaining_to_map={:016X}",
+                              last_result.raw, addr, size, vma_start, vma_end, offset_in_vma,
+                              remaining_to_map);
+                }
+                break;
+            } else {
+                // We can do a partial mapping here
+                last_result =
+                    MapMemoryBlock(offset_in_vma,
+                                   std::make_shared<std::vector<u8>>(remaining_vma_size, 0), 0,
+                                   remaining_vma_size, MemoryState::Mapped)
+                        .Code();
+
+                // Update our usage and continue to the next vma
+                if (last_result.IsSuccess()) {
+                    personal_heap_usage += remaining_vma_size;
+                    remaining_to_map -= remaining_vma_size;
+                    mapped_regions.push_back(std::make_pair(offset_in_vma, remaining_vma_size));
+                } else {
+                    LOG_ERROR(Kernel,
+                              "Failed to map partial VMA with error 0x{:X}, addr=0x{:016X}, "
+                              "size=0x{:016X}, vma_start={:016X}, vma_end={:016X}, "
+                              "offset_in_vma={:016X}, remaining_to_map={:016X}",
+                              last_result.raw, addr, size, vma_start, vma_end, offset_in_vma,
+                              remaining_to_map);
+                }
+                continue;
+            }
+        }
+    }
+
+    // We failed to map something, lets unmap everything we mapped
+    if (last_result.IsError() && !mapped_regions.empty()) {
+        for (const auto [mapped_addr, mapped_size] : mapped_regions) {
+            if (UnmapRange(mapped_addr, mapped_size).IsSuccess()) {
+                personal_heap_usage -= mapped_size;
+            }
+        }
+    }
+
+    return last_result;
+}
+
+ResultCode VMManager::UnmapPhysicalMemory(VAddr addr, u64 size) {
+    const auto base = GetMapRegionBaseAddress();
+    const auto end = GetMapRegionEndAddress();
+
+    if (!IsInsideMapRegion(addr, size)) {
+        return ERR_INVALID_ADDRESS;
+    }
+
+    // We have nothing mapped, we can just map directly
+    if (personal_heap_usage == 0) {
+        LOG_WARNING(Kernel, "Unmap physical memory called when our personal usage is empty");
+        return RESULT_SUCCESS;
+    }
+
+    auto vma = FindVMA(base);
+    u64 remaining_to_unmap = size;
+    // Needed just in case we fail to map a region, we'll unmap everything.
+    std::vector<std::pair<u64, u64>> unmapped_regions;
+    while (vma != vma_map.end() && vma->second.base <= end && remaining_to_unmap > 0) {
+        const auto vma_start = vma->second.base;
+        const auto vma_end = vma_start + vma->second.size;
+        const auto is_unmapped = vma->second.meminfo_state != MemoryState::Mapped;
+        // Allows us to use continue without worrying about incrementing the vma
+        SCOPE_EXIT({ vma++; });
+
+        // We're out of range now, we can just break. We should be done with everything now
+        if (vma_start > addr + size - 1) {
+            break;
+        }
+
+        // We're not processing addresses yet, lets keep skipping
+        if (!AreOverlapping(addr, addr + size, vma_start, vma_end)) {
+            continue;
+        }
+
+        const auto offset_in_vma = vma_start + ((addr + size - remaining_to_unmap) - vma_start);
+        const auto remaining_vma_size = (vma_end - offset_in_vma);
+        // Our vma is already unmapped
+        if (is_unmapped) {
+            if (remaining_vma_size >= remaining_to_unmap) {
+                // Our region we need is already unmapped
+                break;
+            } else {
+                // We are partially unmapped, Make note of it and move on
+                remaining_to_unmap -= remaining_vma_size;
+                continue;
+            }
+        } else {
+            // We're mapped, so lets unmap
+            if (remaining_vma_size >= remaining_to_unmap) {
+                // The rest of what we need to unmap fits in this region
+                unmapped_regions.push_back(std::make_pair(offset_in_vma, remaining_to_unmap));
+                break;
+            } else {
+                // We only partially fit here, lets unmap what we can
+                // Update our usage and continue to the next vma
+                remaining_to_unmap -= remaining_vma_size;
+                unmapped_regions.push_back(std::make_pair(offset_in_vma, remaining_vma_size));
+                continue;
+            }
+        }
+    }
+    auto last_result = RESULT_SUCCESS;
+    if (!unmapped_regions.empty()) {
+        for (auto it = unmapped_regions.begin(); it != unmapped_regions.end(); ++it) {
+            last_result = UnmapRange((*it).first, (*it).second);
+            if (last_result.IsSuccess()) {
+                personal_heap_usage -= (*it).second;
+            } else {
+                LOG_ERROR(Kernel,
+                          "Failed to unmap region addr=0x{:016X}, size=0x{:016X} with error=0x{:X}",
+                          (*it).first, (*it).second, last_result.raw);
+                while (it != unmapped_regions.begin()) {
+                    if (MapMemoryBlock((*it).first,
+                                       std::make_shared<std::vector<u8>>((*it).second, 0), 0,
+                                       (*it).second, MemoryState::Mapped)
+                            .Succeeded()) {
+                        personal_heap_usage += (*it).second;
+                    }
+                    --it;
+                }
+            }
+        }
+    }
+
+    return last_result;
+}
+
 ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u64 size,
                                                    MemoryState state,
                                                    Memory::MemoryHookPointer mmio_handler) {
@@ -206,8 +416,8 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {
     const VAddr target_end = target + size;
 
     const VMAIter end = vma_map.end();
-    // The comparison against the end of the range must be done using addresses since VMAs can be
-    // merged during this process, causing invalidation of the iterators.
+    // The comparison against the end of the range must be done using addresses since VMAs can
+    // be merged during this process, causing invalidation of the iterators.
     while (vma != end && vma->second.base < target_end) {
         vma = std::next(Unmap(vma));
     }
@@ -238,8 +448,8 @@ ResultCode VMManager::ReprotectRange(VAddr target, u64 size, VMAPermission new_p
     const VAddr target_end = target + size;
 
     const VMAIter end = vma_map.end();
-    // The comparison against the end of the range must be done using addresses since VMAs can be
-    // merged during this process, causing invalidation of the iterators.
+    // The comparison against the end of the range must be done using addresses since VMAs can
+    // be merged during this process, causing invalidation of the iterators.
     while (vma != end && vma->second.base < target_end) {
         vma = std::next(StripIterConstness(Reprotect(vma, new_perms)));
     }
@@ -302,25 +512,6 @@ ResultCode VMManager::HeapFree(VAddr target, u64 size) {
     return RESULT_SUCCESS;
 }
 
-MemoryInfo VMManager::QueryMemory(VAddr address) const {
-    const auto vma = FindVMA(address);
-    MemoryInfo memory_info{};
-
-    if (IsValidHandle(vma)) {
-        memory_info.base_address = vma->second.base;
-        memory_info.permission = static_cast<u32>(vma->second.permissions);
-        memory_info.size = vma->second.size;
-        memory_info.state = ToSvcMemoryState(vma->second.meminfo_state);
-    } else {
-        memory_info.base_address = address_space_end;
-        memory_info.permission = static_cast<u32>(VMAPermission::None);
-        memory_info.size = 0 - address_space_end;
-        memory_info.state = static_cast<u32>(MemoryState::Inaccessible);
-    }
-
-    return memory_info;
-}
-
 ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, MemoryState state) {
     const auto vma = FindVMA(src_addr);
 
@@ -346,8 +537,8 @@ ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, Mem
 }
 
 void VMManager::RefreshMemoryBlockMappings(const std::vector<u8>* block) {
-    // If this ever proves to have a noticeable performance impact, allow users of the function to
-    // specify a specific range of addresses to limit the scan to.
+    // If this ever proves to have a noticeable performance impact, allow users of the function
+    // to specify a specific range of addresses to limit the scan to.
     for (const auto& p : vma_map) {
         const VirtualMemoryArea& vma = p.second;
         if (block == vma.backing_block.get()) {
@@ -442,8 +633,8 @@ VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u64 offset_in_vma) {
     VirtualMemoryArea& old_vma = vma_handle->second;
     VirtualMemoryArea new_vma = old_vma; // Make a copy of the VMA
 
-    // For now, don't allow no-op VMA splits (trying to split at a boundary) because it's probably
-    // a bug. This restriction might be removed later.
+    // For now, don't allow no-op VMA splits (trying to split at a boundary) because it's
+    // probably a bug. This restriction might be removed later.
     ASSERT(offset_in_vma < old_vma.size);
     ASSERT(offset_in_vma > 0);
 
@@ -708,4 +899,22 @@ u64 VMManager::GetTLSIORegionSize() const {
     return tls_io_region_end - tls_io_region_base;
 }
 
+u64 VMManager::GetPersonalMmHeapUsage() const {
+    return personal_heap_usage;
+}
+
+bool VMManager::IsInsideAddressSpace(VAddr address, u64 size) const {
+    return IsInsideAddressRange(address, size, GetAddressSpaceBaseAddress(),
+                                GetAddressSpaceEndAddress());
+}
+
+bool VMManager::IsInsideNewMapRegion(VAddr address, u64 size) const {
+    return IsInsideAddressRange(address, size, GetNewMapRegionBaseAddress(),
+                                GetNewMapRegionEndAddress());
+}
+
+bool VMManager::IsInsideMapRegion(VAddr address, u64 size) const {
+    return IsInsideAddressRange(address, size, GetMapRegionBaseAddress(), GetMapRegionEndAddress());
+}
+
 } // namespace Kernel

src/core/hle/kernel/vm_manager.h

@@ -18,6 +18,20 @@ enum class ProgramAddressSpaceType : u8;
 
 namespace Kernel {
 
+// Checks if address + size is greater than the given address
+// This can return false if the size causes an overflow of a 64-bit type
+// or if the given size is zero.
+constexpr bool IsValidAddressRange(VAddr address, u64 size) {
+    return address + size > address;
+}
+
+// Checks if a given address range lies within a larger address range.
+constexpr bool IsInsideAddressRange(VAddr address, u64 size, VAddr address_range_begin,
+                                    VAddr address_range_end) {
+    const VAddr end_address = address + size - 1;
+    return address_range_begin <= address && end_address <= address_range_end - 1;
+}
+
 enum class VMAType : u8 {
     /// VMA represents an unmapped region of the address space.
     Free,
@@ -43,129 +57,26 @@ enum class VMAPermission : u8 {
     ReadWriteExecute = Read | Write | Execute,
 };
 
-// clang-format off
-/// Represents memory states and any relevant flags, as used by the kernel.
-/// svcQueryMemory interprets these by masking away all but the first eight
-/// bits when storing memory state into a MemoryInfo instance.
+/// Set of values returned in MemoryInfo.state by svcQueryMemory.
 enum class MemoryState : u32 {
-    Mask                            = 0xFF,
-    FlagProtect                     = 1U << 8,
-    FlagDebug                       = 1U << 9,
-    FlagIPC0                        = 1U << 10,
-    FlagIPC3                        = 1U << 11,
-    FlagIPC1                        = 1U << 12,
-    FlagMapped                      = 1U << 13,
-    FlagCode                        = 1U << 14,
-    FlagAlias                       = 1U << 15,
-    FlagModule                      = 1U << 16,
-    FlagTransfer                    = 1U << 17,
-    FlagQueryPhysicalAddressAllowed = 1U << 18,
-    FlagSharedDevice                = 1U << 19,
-    FlagSharedDeviceAligned         = 1U << 20,
-    FlagIPCBuffer                   = 1U << 21,
-    FlagMemoryPoolAllocated         = 1U << 22,
-    FlagMapProcess                  = 1U << 23,
-    FlagUncached                    = 1U << 24,
-    FlagCodeMemory                  = 1U << 25,
-
-    // Convenience flag sets to reduce repetition
-    IPCFlags = FlagIPC0 | FlagIPC3 | FlagIPC1,
-
-    CodeFlags = FlagDebug | IPCFlags | FlagMapped | FlagCode | FlagQueryPhysicalAddressAllowed |
-                FlagSharedDevice | FlagSharedDeviceAligned | FlagMemoryPoolAllocated,
-
-    DataFlags = FlagProtect | IPCFlags | FlagMapped | FlagAlias | FlagTransfer |
-                FlagQueryPhysicalAddressAllowed | FlagSharedDevice | FlagSharedDeviceAligned |
-                FlagMemoryPoolAllocated | FlagIPCBuffer | FlagUncached,
-
-    Unmapped               = 0x00,
-    Io                     = 0x01 | FlagMapped,
-    Normal                 = 0x02 | FlagMapped | FlagQueryPhysicalAddressAllowed,
-    CodeStatic             = 0x03 | CodeFlags  | FlagMapProcess,
-    CodeMutable            = 0x04 | CodeFlags  | FlagMapProcess | FlagCodeMemory,
-    Heap                   = 0x05 | DataFlags  | FlagCodeMemory,
-    Shared                 = 0x06 | FlagMapped | FlagMemoryPoolAllocated,
-    ModuleCodeStatic       = 0x08 | CodeFlags  | FlagModule | FlagMapProcess,
-    ModuleCodeMutable      = 0x09 | DataFlags  | FlagModule | FlagMapProcess | FlagCodeMemory,
-
-    IpcBuffer0             = 0x0A | FlagMapped | FlagQueryPhysicalAddressAllowed | FlagMemoryPoolAllocated |
-                                    IPCFlags | FlagSharedDevice | FlagSharedDeviceAligned,
-
-    Stack                  = 0x0B | FlagMapped | IPCFlags | FlagQueryPhysicalAddressAllowed |
-                                    FlagSharedDevice | FlagSharedDeviceAligned | FlagMemoryPoolAllocated,
-
-    ThreadLocal            = 0x0C | FlagMapped | FlagMemoryPoolAllocated,
-
-    TransferMemoryIsolated = 0x0D | IPCFlags | FlagMapped | FlagQueryPhysicalAddressAllowed |
-                                    FlagSharedDevice | FlagSharedDeviceAligned | FlagMemoryPoolAllocated |
-                                    FlagUncached,
-
-    TransferMemory         = 0x0E | FlagIPC3   | FlagIPC1   | FlagMapped | FlagQueryPhysicalAddressAllowed |
-                                    FlagSharedDevice | FlagSharedDeviceAligned | FlagMemoryPoolAllocated,
-
-    ProcessMemory          = 0x0F | FlagIPC3   | FlagIPC1   | FlagMapped | FlagMemoryPoolAllocated,
-
-    // Used to signify an inaccessible or invalid memory region with memory queries
-    Inaccessible           = 0x10,
-
-    IpcBuffer1             = 0x11 | FlagIPC3   | FlagIPC1   | FlagMapped | FlagQueryPhysicalAddressAllowed |
-                                    FlagSharedDevice | FlagSharedDeviceAligned | FlagMemoryPoolAllocated,
-
-    IpcBuffer3             = 0x12 | FlagIPC3   | FlagMapped | FlagQueryPhysicalAddressAllowed |
-                                    FlagSharedDeviceAligned | FlagMemoryPoolAllocated,
-
-    KernelStack            = 0x13 | FlagMapped,
-};
-// clang-format on
-
-constexpr MemoryState operator|(MemoryState lhs, MemoryState rhs) {
-    return static_cast<MemoryState>(u32(lhs) | u32(rhs));
-}
-
-constexpr MemoryState operator&(MemoryState lhs, MemoryState rhs) {
-    return static_cast<MemoryState>(u32(lhs) & u32(rhs));
-}
-
-constexpr MemoryState operator^(MemoryState lhs, MemoryState rhs) {
-    return static_cast<MemoryState>(u32(lhs) ^ u32(rhs));
-}
-
-constexpr MemoryState operator~(MemoryState lhs) {
-    return static_cast<MemoryState>(~u32(lhs));
-}
-
-constexpr MemoryState& operator|=(MemoryState& lhs, MemoryState rhs) {
-    lhs = lhs | rhs;
-    return lhs;
-}
-
-constexpr MemoryState& operator&=(MemoryState& lhs, MemoryState rhs) {
-    lhs = lhs & rhs;
-    return lhs;
-}
-
-constexpr MemoryState& operator^=(MemoryState& lhs, MemoryState rhs) {
-    lhs = lhs ^ rhs;
-    return lhs;
-}
-
-constexpr u32 ToSvcMemoryState(MemoryState state) {
-    return static_cast<u32>(state & MemoryState::Mask);
-}
-
-struct MemoryInfo {
-    u64 base_address;
-    u64 size;
-    u32 state;
-    u32 attributes;
-    u32 permission;
-    u32 ipc_ref_count;
-    u32 device_ref_count;
-};
-static_assert(sizeof(MemoryInfo) == 0x28, "MemoryInfo has incorrect size.");
-
-struct PageInfo {
-    u32 flags;
+    Unmapped = 0x0,
+    Io = 0x1,
+    Normal = 0x2,
+    CodeStatic = 0x3,
+    CodeMutable = 0x4,
+    Heap = 0x5,
+    Shared = 0x6,
+    ModuleCodeStatic = 0x8,
+    ModuleCodeMutable = 0x9,
+    IpcBuffer0 = 0xA,
+    Mapped = 0xB,
+    ThreadLocal = 0xC,
+    TransferMemoryIsolated = 0xD,
+    TransferMemory = 0xE,
+    ProcessMemory = 0xF,
+    IpcBuffer1 = 0x11,
+    IpcBuffer3 = 0x12,
+    KernelStack = 0x13,
 };
 
 /**
@@ -216,10 +127,16 @@ struct VirtualMemoryArea {
  *  - http://duartes.org/gustavo/blog/post/page-cache-the-affair-between-memory-and-files/
  */
 class VMManager final {
-    using VMAMap = std::map<VAddr, VirtualMemoryArea>;
-
 public:
-    using VMAHandle = VMAMap::const_iterator;
+    /**
+     * A map covering the entirety of the managed address space, keyed by the `base` field of each
+     * VMA. It must always be modified by splitting or merging VMAs, so that the invariant
+     * `elem.base + elem.size == next.base` is preserved, and mergeable regions must always be
+     * merged when possible so that no two similar and adjacent regions exist that have not been
+     * merged.
+     */
+    std::map<VAddr, VirtualMemoryArea> vma_map;
+    using VMAHandle = decltype(vma_map)::const_iterator;
 
     VMManager();
     ~VMManager();
@@ -230,9 +147,6 @@ public:
     /// Finds the VMA in which the given address is included in, or `vma_map.end()`.
     VMAHandle FindVMA(VAddr target) const;
 
-    /// Indicates whether or not the given handle is within the VMA map.
-    bool IsValidHandle(VMAHandle handle) const;
-
     // TODO(yuriks): Should these functions actually return the handle?
 
     /**
@@ -265,6 +179,30 @@ public:
      */
     ResultVal<VAddr> FindFreeRegion(u64 size) const;
 
+    /**
+     * Maps memory to the PersonalMmHeap region at a given address. MapPhysicalMemory will not remap
+     * any regions. The goal of MapPhysicalMemory is to "fill" a regions empty space given an offset
+     * and a size. Any memory which is already mapped in the subsection we want to allocate is
+     * ignored and we only map the remaining data needed. Reminder that we're not remapping, just
+     * filling the space we want to fill. This is typically used with "PersonalMmHeap" which allows
+     * processes to have extra resources mapped. Typically this is seen with 5.0.0+ games and
+     * sysmodule specifically. The PersonalMmHeapSize is pulled from the NPDM and is passed to
+     * loader when the process is created which is in turn passed to the kernel when
+     * svcCreateProcess is called
+     *
+     * @param target The address of where you want to map
+     * @param size The size of the memory you want to map
+     */
+    ResultCode MapPhysicalMemory(VAddr target, u64 size);
+
+    /**
+     * Unmaps memory from the PersonalMmHeap region at a given address.
+     *
+     * @param target The address of where you want to unmap
+     * @param size The size of the memory you want to unmap
+     */
+    ResultCode UnmapPhysicalMemory(VAddr target, u64 size);
+
     /**
      * Maps a memory-mapped IO region at a given address.
      *
@@ -289,15 +227,8 @@ public:
     ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
     ResultCode HeapFree(VAddr target, u64 size);
 
-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, MemoryState state);
-
-    /// Queries the memory manager for information about the given address.
-    ///
-    /// @param address The address to query the memory manager about for information.
-    ///
-    /// @return A MemoryInfo instance containing information about the given address.
-    ///
-    MemoryInfo QueryMemory(VAddr address) const;
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size,
+                            MemoryState state = MemoryState::Mapped);
 
     /**
      * Scans all VMAs and updates the page table range of any that use the given vector as backing
@@ -383,12 +314,19 @@ public:
     /// Gets the total size of the TLS IO region in bytes.
     u64 GetTLSIORegionSize() const;
 
+    /// Gets the total size of the PersonalMmHeap region in bytes.
+    u64 GetPersonalMmHeapUsage() const;
+
+    bool IsInsideAddressSpace(VAddr address, u64 size) const;
+    bool IsInsideNewMapRegion(VAddr address, u64 size) const;
+    bool IsInsideMapRegion(VAddr address, u64 size) const;
+
     /// Each VMManager has its own page table, which is set as the main one when the owning process
     /// is scheduled.
     Memory::PageTable page_table;
 
 private:
-    using VMAIter = VMAMap::iterator;
+    using VMAIter = decltype(vma_map)::iterator;
 
     /// Converts a VMAHandle to a mutable VMAIter.
     VMAIter StripIterConstness(const VMAHandle& iter);
@@ -435,15 +373,6 @@ private:
     /// Clears out the page table
     void ClearPageTable();
 
-    /**
-     * A map covering the entirety of the managed address space, keyed by the `base` field of each
-     * VMA. It must always be modified by splitting or merging VMAs, so that the invariant
-     * `elem.base + elem.size == next.base` is preserved, and mergeable regions must always be
-     * merged when possible so that no two similar and adjacent regions exist that have not been
-     * merged.
-     */
-    VMAMap vma_map;
-
     u32 address_space_width = 0;
     VAddr address_space_base = 0;
     VAddr address_space_end = 0;
@@ -475,5 +404,7 @@ private:
     VAddr heap_start = 0;
     VAddr heap_end = 0;
     u64 heap_used = 0;
+
+    u64 personal_heap_usage = 0;
 };
 } // namespace Kernel

src/core/hle/kernel/writable_event.cpp

@@ -1,52 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include "common/assert.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/object.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/thread.h"
-#include "core/hle/kernel/writable_event.h"
-
-namespace Kernel {
-
-WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {}
-WritableEvent::~WritableEvent() = default;
-
-EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_type,
-                                         std::string name) {
-    SharedPtr<WritableEvent> writable_event(new WritableEvent(kernel));
-    SharedPtr<ReadableEvent> readable_event(new ReadableEvent(kernel));
-
-    writable_event->name = name + ":Writable";
-    writable_event->readable = readable_event;
-    readable_event->name = name + ":Readable";
-    readable_event->signaled = false;
-    readable_event->reset_type = reset_type;
-
-    return {std::move(readable_event), std::move(writable_event)};
-}
-
-SharedPtr<ReadableEvent> WritableEvent::GetReadableEvent() const {
-    return readable;
-}
-
-ResetType WritableEvent::GetResetType() const {
-    return readable->reset_type;
-}
-
-void WritableEvent::Signal() {
-    readable->Signal();
-}
-
-void WritableEvent::Clear() {
-    readable->Clear();
-}
-
-bool WritableEvent::IsSignaled() const {
-    return readable->signaled;
-}
-
-} // namespace Kernel

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

@@ -9,11 +9,9 @@
 #include "audio_core/audio_renderer.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/shared_memory.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
@@ -210,8 +208,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
-                                                              "ISelfController:LaunchableEvent");
+    launchable_event =
+        Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent");
 }
 
 ISelfController::~ISelfController() = default;
@@ -297,11 +295,11 @@ void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
 void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
-    launchable_event.writable->Signal();
+    launchable_event->Signal();
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(launchable_event.readable);
+    rb.PushCopyObjects(launchable_event);
 }
 
 void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) {
@@ -350,38 +348,36 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
 
 AppletMessageQueue::AppletMessageQueue() {
     auto& kernel = Core::System::GetInstance().Kernel();
-    on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
-                                                            "AMMessageQueue:OnMessageRecieved");
-    on_operation_mode_changed = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::OneShot, "AMMessageQueue:OperationModeChanged");
+    on_new_message = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky,
+                                           "AMMessageQueue:OnMessageRecieved");
+    on_operation_mode_changed = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                      "AMMessageQueue:OperationModeChanged");
 }
 
 AppletMessageQueue::~AppletMessageQueue() = default;
 
-const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetMesssageRecieveEvent()
-    const {
-    return on_new_message.readable;
+const Kernel::SharedPtr<Kernel::Event>& AppletMessageQueue::GetMesssageRecieveEvent() const {
+    return on_new_message;
 }
 
-const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
-    const {
-    return on_operation_mode_changed.readable;
+const Kernel::SharedPtr<Kernel::Event>& AppletMessageQueue::GetOperationModeChangedEvent() const {
+    return on_operation_mode_changed;
 }
 
 void AppletMessageQueue::PushMessage(AppletMessage msg) {
     messages.push(msg);
-    on_new_message.writable->Signal();
+    on_new_message->Signal();
 }
 
 AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() {
     if (messages.empty()) {
-        on_new_message.writable->Clear();
+        on_new_message->Clear();
         return AppletMessage::NoMessage;
     }
     auto msg = messages.front();
     messages.pop();
     if (messages.empty()) {
-        on_new_message.writable->Clear();
+        on_new_message->Clear();
     }
     return msg;
 }
@@ -393,7 +389,7 @@ std::size_t AppletMessageQueue::GetMessageCount() const {
 void AppletMessageQueue::OperationModeChanged() {
     PushMessage(AppletMessage::OperationModeChanged);
     PushMessage(AppletMessage::PerformanceModeChanged);
-    on_operation_mode_changed.writable->Signal();
+    on_operation_mode_changed->Signal();
 }
 
 ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)
@@ -430,6 +426,9 @@ ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_q
     // clang-format on
 
     RegisterHandlers(functions);
+
+    auto& kernel = Core::System::GetInstance().Kernel();
+    event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "ICommonStateGetter:Event");
 }
 
 ICommonStateGetter::~ICommonStateGetter() = default;
@@ -565,8 +564,8 @@ private:
     void GetAppletStateChangedEvent(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_AM, "called");
 
-        applet->GetBroker().SignalStateChanged();
         const auto event = applet->GetBroker().GetStateChangedEvent();
+        event->Signal();
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);

src/core/hle/service/am/am.h

@@ -6,9 +6,12 @@
 
 #include <memory>
 #include <queue>
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/service.h"
 
+namespace Kernel {
+class Event;
+}
+
 namespace Service {
 namespace NVFlinger {
 class NVFlinger;
@@ -49,8 +52,8 @@ public:
     AppletMessageQueue();
     ~AppletMessageQueue();
 
-    const Kernel::SharedPtr<Kernel::ReadableEvent>& GetMesssageRecieveEvent() const;
-    const Kernel::SharedPtr<Kernel::ReadableEvent>& GetOperationModeChangedEvent() const;
+    const Kernel::SharedPtr<Kernel::Event>& GetMesssageRecieveEvent() const;
+    const Kernel::SharedPtr<Kernel::Event>& GetOperationModeChangedEvent() const;
     void PushMessage(AppletMessage msg);
     AppletMessage PopMessage();
     std::size_t GetMessageCount() const;
@@ -58,8 +61,8 @@ public:
 
 private:
     std::queue<AppletMessage> messages;
-    Kernel::EventPair on_new_message;
-    Kernel::EventPair on_operation_mode_changed;
+    Kernel::SharedPtr<Kernel::Event> on_new_message;
+    Kernel::SharedPtr<Kernel::Event> on_operation_mode_changed;
 };
 
 class IWindowController final : public ServiceFramework<IWindowController> {
@@ -119,7 +122,7 @@ private:
     void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
-    Kernel::EventPair launchable_event;
+    Kernel::SharedPtr<Kernel::Event> launchable_event;
     u32 idle_time_detection_extension = 0;
 };
 
@@ -148,6 +151,7 @@ private:
     void GetBootMode(Kernel::HLERequestContext& ctx);
     void GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx);
 
+    Kernel::SharedPtr<Kernel::Event> event;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 

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

@@ -5,9 +5,8 @@
 #include <cstring>
 #include "common/assert.h"
 #include "core/core.h"
-#include "core/hle/kernel/readable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/server_port.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"
 
@@ -15,11 +14,11 @@ namespace Service::AM::Applets {
 
 AppletDataBroker::AppletDataBroker() {
     auto& kernel = Core::System::GetInstance().Kernel();
-    state_changed_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:StateChangedEvent");
-    pop_out_data_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopDataOutEvent");
-    pop_interactive_out_data_event = Kernel::WritableEvent::CreateEventPair(
+    state_changed_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                "ILibraryAppletAccessor:StateChangedEvent");
+    pop_out_data_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                               "ILibraryAppletAccessor:PopDataOutEvent");
+    pop_interactive_out_data_event = Kernel::Event::Create(
         kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
 }
 
@@ -67,7 +66,7 @@ void AppletDataBroker::PushNormalDataFromGame(IStorage storage) {
 
 void AppletDataBroker::PushNormalDataFromApplet(IStorage storage) {
     out_channel.push(std::make_unique<IStorage>(storage));
-    pop_out_data_event.writable->Signal();
+    pop_out_data_event->Signal();
 }
 
 void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
@@ -76,23 +75,23 @@ void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
 
 void AppletDataBroker::PushInteractiveDataFromApplet(IStorage storage) {
     out_interactive_channel.push(std::make_unique<IStorage>(storage));
-    pop_interactive_out_data_event.writable->Signal();
+    pop_interactive_out_data_event->Signal();
 }
 
 void AppletDataBroker::SignalStateChanged() const {
-    state_changed_event.writable->Signal();
+    state_changed_event->Signal();
 }
 
-Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
-    return pop_out_data_event.readable;
+Kernel::SharedPtr<Kernel::Event> AppletDataBroker::GetNormalDataEvent() const {
+    return pop_out_data_event;
 }
 
-Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
-    return pop_interactive_out_data_event.readable;
+Kernel::SharedPtr<Kernel::Event> AppletDataBroker::GetInteractiveDataEvent() const {
+    return pop_interactive_out_data_event;
 }
 
-Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
-    return state_changed_event.readable;
+Kernel::SharedPtr<Kernel::Event> AppletDataBroker::GetStateChangedEvent() const {
+    return state_changed_event;
 }
 
 Applet::Applet() = default;

src/core/hle/service/am/applets/applets.h

@@ -8,10 +8,13 @@
 #include <queue>
 #include "common/swap.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/writable_event.h"
 
 union ResultCode;
 
+namespace Kernel {
+class Event;
+}
+
 namespace Service::AM {
 
 class IStorage;
@@ -37,9 +40,9 @@ public:
 
     void SignalStateChanged() const;
 
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetNormalDataEvent() const;
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetInteractiveDataEvent() const;
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetStateChangedEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetNormalDataEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetInteractiveDataEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetStateChangedEvent() const;
 
 private:
     // Queues are named from applet's perspective
@@ -56,13 +59,13 @@ private:
     // PopInteractiveDataToGame and PushInteractiveDataFromApplet
     std::queue<std::unique_ptr<IStorage>> out_interactive_channel;
 
-    Kernel::EventPair state_changed_event;
+    Kernel::SharedPtr<Kernel::Event> state_changed_event;
 
     // Signaled on PushNormalDataFromApplet
-    Kernel::EventPair pop_out_data_event;
+    Kernel::SharedPtr<Kernel::Event> pop_out_data_event;
 
     // Signaled on PushInteractiveDataFromApplet
-    Kernel::EventPair pop_interactive_out_data_event;
+    Kernel::SharedPtr<Kernel::Event> pop_interactive_out_data_event;
 };
 
 class Applet {

src/core/hle/service/aoc/aoc_u.cpp

@@ -13,14 +13,11 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
-#include "core/settings.h"
 
 namespace Service::AOC {
 
@@ -35,14 +32,14 @@ static std::vector<u64> AccumulateAOCTitleIDs() {
     std::vector<u64> add_on_content;
     const auto rcu = FileSystem::GetUnionContents();
     const auto list =
-        rcu.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
+        rcu->ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
     std::transform(list.begin(), list.end(), std::back_inserter(add_on_content),
                    [](const FileSys::RegisteredCacheEntry& rce) { return rce.title_id; });
     add_on_content.erase(
         std::remove_if(
             add_on_content.begin(), add_on_content.end(),
             [&rcu](u64 tid) {
-                return rcu.GetEntry(tid, FileSys::ContentRecordType::Data)->GetStatus() !=
+                return rcu->GetEntry(tid, FileSys::ContentRecordType::Data)->GetStatus() !=
                        Loader::ResultStatus::Success;
             }),
         add_on_content.end());
@@ -64,8 +61,8 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    aoc_change_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
-                                                              "GetAddOnContentListChanged:Event");
+    aoc_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky,
+                                             "GetAddOnContentListChanged:Event");
 }
 
 AOC_U::~AOC_U() = default;
@@ -77,13 +74,6 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 
     const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-
-    const auto& disabled = Settings::values.disabled_addons[current];
-    if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
-        rb.Push<u32>(0);
-        return;
-    }
-
     rb.Push<u32>(static_cast<u32>(
         std::count_if(add_on_content.begin(), add_on_content.end(),
                       [current](u64 tid) { return CheckAOCTitleIDMatchesBase(tid, current); })));
@@ -104,10 +94,6 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
             out.push_back(static_cast<u32>(add_on_content[i] & 0x7FF));
     }
 
-    const auto& disabled = Settings::values.disabled_addons[current];
-    if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end())
-        out = {};
-
     if (out.size() < offset) {
         IPC::ResponseBuilder rb{ctx, 2};
         // TODO(DarkLordZach): Find the correct error code.
@@ -158,7 +144,7 @@ void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(aoc_change_event.readable);
+    rb.PushCopyObjects(aoc_change_event);
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {

src/core/hle/service/aoc/aoc_u.h

@@ -6,10 +6,6 @@
 
 #include "core/hle/service/service.h"
 
-namespace Kernel {
-class WritableEvent;
-}
-
 namespace Service::AOC {
 
 class AOC_U final : public ServiceFramework<AOC_U> {
@@ -25,7 +21,7 @@ private:
     void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
 
     std::vector<u64> add_on_content;
-    Kernel::EventPair aoc_change_event;
+    Kernel::SharedPtr<Kernel::Event> aoc_change_event;
 };
 
 /// Registers all AOC services with the specified service manager.

src/core/hle/service/audio/audout_u.cpp

@@ -13,10 +13,8 @@
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/audio/audout_u.h"
 #include "core/memory.h"
 
@@ -48,8 +46,8 @@ class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
     IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core, std::string&& device_name,
               std::string&& unique_name)
-        : ServiceFramework("IAudioOut"), audio_core(audio_core),
-          device_name(std::move(device_name)), audio_params(audio_params) {
+        : ServiceFramework("IAudioOut"), audio_core(audio_core), audio_params(audio_params),
+          device_name(std::move(device_name)) {
 
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
@@ -69,12 +67,11 @@ public:
 
         // This is the event handle used to check if the audio buffer was released
         auto& kernel = Core::System::GetInstance().Kernel();
-        buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
-                                                              "IAudioOutBufferReleased");
+        buffer_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
-                                       std::move(unique_name),
-                                       [=]() { buffer_event.writable->Signal(); });
+                                       std::move(unique_name), [=]() { buffer_event->Signal(); });
     }
 
 private:
@@ -124,7 +121,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(buffer_event.readable);
+        rb.PushCopyObjects(buffer_event);
     }
 
     void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
@@ -190,8 +187,8 @@ private:
 
     AudoutParams audio_params{};
 
-    /// This is the event handle used to check if the audio buffer was released
-    Kernel::EventPair buffer_event;
+    /// This is the evend handle used to check if the audio buffer was released
+    Kernel::SharedPtr<Kernel::Event> buffer_event;
 };
 
 void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {

src/core/hle/service/audio/audren_u.cpp

@@ -12,10 +12,8 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/audio/audren_u.h"
 
 namespace Service::Audio {
@@ -43,14 +41,14 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        system_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
-                                                              "IAudioRenderer:SystemEvent");
-        renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event.writable);
+        system_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent");
+        renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event);
     }
 
 private:
     void UpdateAudioCallback() {
-        system_event.writable->Signal();
+        system_event->Signal();
     }
 
     void GetSampleRate(Kernel::HLERequestContext& ctx) {
@@ -114,7 +112,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(system_event.readable);
+        rb.PushCopyObjects(system_event);
     }
 
     void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
@@ -137,7 +135,7 @@ private:
         rb.Push(rendering_time_limit_percent);
     }
 
-    Kernel::EventPair system_event;
+    Kernel::SharedPtr<Kernel::Event> system_event;
     std::unique_ptr<AudioCore::AudioRenderer> renderer;
     u32 rendering_time_limit_percent = 100;
 };
@@ -164,8 +162,8 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                              "IAudioOutBufferReleasedEvent");
+        buffer_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                             "IAudioOutBufferReleasedEvent");
     }
 
 private:
@@ -209,11 +207,11 @@ private:
     void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        buffer_event.writable->Signal();
+        buffer_event->Signal();
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(buffer_event.readable);
+        rb.PushCopyObjects(buffer_event);
     }
 
     void GetActiveChannelCount(Kernel::HLERequestContext& ctx) {
@@ -224,7 +222,7 @@ private:
         rb.Push<u32>(1);
     }
 
-    Kernel::EventPair buffer_event;
+    Kernel::SharedPtr<Kernel::Event> buffer_event;
 
 }; // namespace Audio
 

src/core/hle/service/btdrv/btdrv.cpp

@@ -4,10 +4,8 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -32,22 +30,20 @@ public:
         };
         // clang-format on
         RegisterHandlers(functions);
-
-        auto& kernel = Core::System::GetInstance().Kernel();
-        register_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                                "BT:RegisterEvent");
     }
 
 private:
     void RegisterEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
+        auto& kernel = Core::System::GetInstance().Kernel();
+        register_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent");
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(register_event.readable);
+        rb.PushCopyObjects(register_event);
     }
-
-    Kernel::EventPair register_event;
+    Kernel::SharedPtr<Kernel::Event> register_event;
 };
 
 class BtDrv final : public ServiceFramework<BtDrv> {

src/core/hle/service/btm/btm.cpp

@@ -6,10 +6,8 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/btm/btm.h"
 #include "core/hle/service/service.h"
 
@@ -55,55 +53,53 @@ public:
         };
         // clang-format on
         RegisterHandlers(functions);
-
-        auto& kernel = Core::System::GetInstance().Kernel();
-        scan_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                            "IBtmUserCore:ScanEvent");
-        connection_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConnectionEvent");
-        service_discovery = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
-        config_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                              "IBtmUserCore:ConfigEvent");
     }
 
 private:
     void GetScanEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
+        auto& kernel = Core::System::GetInstance().Kernel();
+        scan_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent");
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(scan_event.readable);
+        rb.PushCopyObjects(scan_event);
     }
-
     void GetConnectionEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
+        auto& kernel = Core::System::GetInstance().Kernel();
+        connection_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                 "IBtmUserCore:ConnectionEvent");
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(connection_event.readable);
+        rb.PushCopyObjects(connection_event);
     }
-
     void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
+        auto& kernel = Core::System::GetInstance().Kernel();
+        service_discovery =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(service_discovery.readable);
+        rb.PushCopyObjects(service_discovery);
     }
-
     void GetConfigEvent(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
+        auto& kernel = Core::System::GetInstance().Kernel();
+        config_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent");
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(config_event.readable);
+        rb.PushCopyObjects(config_event);
     }
-
-    Kernel::EventPair scan_event;
-    Kernel::EventPair connection_event;
-    Kernel::EventPair service_discovery;
-    Kernel::EventPair config_event;
+    Kernel::SharedPtr<Kernel::Event> scan_event;
+    Kernel::SharedPtr<Kernel::Event> connection_event;
+    Kernel::SharedPtr<Kernel::Event> service_discovery;
+    Kernel::SharedPtr<Kernel::Event> config_event;
 };
 
 class BTM_USR final : public ServiceFramework<BTM_USR> {

src/core/hle/service/erpt/erpt.cpp

@@ -17,13 +17,11 @@ public:
         static const FunctionInfo functions[] = {
             {0, nullptr, "SubmitContext"},
             {1, nullptr, "CreateReport"},
-            {2, nullptr, "SetInitialLaunchSettingsCompletionTime"},
-            {3, nullptr, "ClearInitialLaunchSettingsCompletionTime"},
-            {4, nullptr, "UpdatePowerOnTime"},
-            {5, nullptr, "UpdateAwakeTime"},
-            {6, nullptr, "SubmitMultipleCategoryContext"},
-            {7, nullptr, "UpdateApplicationLaunchTime"},
-            {8, nullptr, "ClearApplicationLaunchTime"},
+            {2, nullptr, "Unknown1"},
+            {3, nullptr, "Unknown2"},
+            {4, nullptr, "Unknown3"},
+            {5, nullptr, "Unknown4"},
+            {6, nullptr, "Unknown5"},
         };
         // clang-format on
 

src/core/hle/service/filesystem/filesystem.cpp

@@ -113,18 +113,6 @@ ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::str
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::CleanDirectoryRecursively(const std::string& path) const {
-    const std::string sanitized_path(FileUtil::SanitizePath(path));
-    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(sanitized_path));
-
-    if (!dir->CleanSubdirectoryRecursive(FileUtil::GetFilename(sanitized_path))) {
-        // TODO(DarkLordZach): Find a better error code for this
-        return ResultCode(-1);
-    }
-
-    return RESULT_SUCCESS;
-}
-
 ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
                                                   const std::string& dest_path_) const {
     std::string src_path(FileUtil::SanitizePath(src_path_));
@@ -341,9 +329,20 @@ ResultVal<FileSys::VirtualDir> OpenSDMC() {
     return sdmc_factory->Open();
 }
 
-FileSys::RegisteredCacheUnion GetUnionContents() {
-    return FileSys::RegisteredCacheUnion{
-        {GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()}};
+std::shared_ptr<FileSys::RegisteredCacheUnion> registered_cache_union;
+
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
+    if (registered_cache_union == nullptr) {
+        registered_cache_union =
+            std::make_shared<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
+                GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
+    }
+
+    return registered_cache_union;
+}
+
+void ClearUnionContents() {
+    registered_cache_union = nullptr;
 }
 
 FileSys::RegisteredCache* GetSystemNANDContents() {
@@ -396,6 +395,7 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
         bis_factory = nullptr;
         save_data_factory = nullptr;
         sdmc_factory = nullptr;
+        ClearUnionContents();
     }
 
     auto nand_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),

src/core/hle/service/filesystem/filesystem.h

@@ -48,7 +48,8 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
 ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 
-FileSys::RegisteredCacheUnion GetUnionContents();
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
+void ClearUnionContents();
 
 FileSys::RegisteredCache* GetSystemNANDContents();
 FileSys::RegisteredCache* GetUserNANDContents();
@@ -112,18 +113,6 @@ public:
      */
     ResultCode DeleteDirectoryRecursively(const std::string& path) const;
 
-    /**
-     * Cleans the specified directory. This is similar to DeleteDirectoryRecursively,
-     * in that it deletes all the contents of the specified directory, however, this
-     * function does *not* delete the directory itself. It only deletes everything
-     * within it.
-     *
-     * @param path Path relative to the archive.
-     *
-     * @return Result of the operation.
-     */
-    ResultCode CleanDirectoryRecursively(const std::string& path) const;
-
     /**
      * Rename a File specified by its path
      * @param src_path Source path relative to the archive

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -20,7 +20,6 @@
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/savedata_factory.h"
-#include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/process.h"
@@ -292,7 +291,7 @@ public:
             {10, &IFileSystem::Commit, "Commit"},
             {11, nullptr, "GetFreeSpaceSize"},
             {12, nullptr, "GetTotalSpaceSize"},
-            {13, &IFileSystem::CleanDirectoryRecursively, "CleanDirectoryRecursively"},
+            {13, nullptr, "CleanDirectoryRecursively"},
             {14, nullptr, "GetFileTimeStampRaw"},
             {15, nullptr, "QueryEntry"},
         };
@@ -362,16 +361,6 @@ public:
         rb.Push(backend.DeleteDirectoryRecursively(name));
     }
 
-    void CleanDirectoryRecursively(Kernel::HLERequestContext& ctx) {
-        const auto file_buffer = ctx.ReadBuffer();
-        const std::string name = Common::StringFromBuffer(file_buffer);
-
-        LOG_DEBUG(Service_FS, "called. Directory: {}", name);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(backend.CleanDirectoryRecursively(name));
-    }
-
     void RenameFile(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -796,18 +785,9 @@ void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext&
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
-    enum class LogMode : u32 {
-        Off,
-        Log,
-        RedirectToSdCard,
-        LogToSdCard = Log | RedirectToSdCard,
-    };
-
-    // Given we always want to receive logging information,
-    // we always specify logging as enabled.
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(LogMode::Log);
+    rb.Push<u32>(5);
 }
 
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
@@ -841,15 +821,6 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
     auto data = OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
 
     if (data.Failed()) {
-        const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id);
-
-        if (archive != nullptr) {
-            IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-            rb.Push(RESULT_SUCCESS);
-            rb.PushIpcInterface(std::make_shared<IStorage>(archive));
-            return;
-        }
-
         // TODO(DarkLordZach): Find the right error code to use here
         LOG_ERROR(Service_FS,
                   "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,

src/core/hle/service/hid/controllers/npad.cpp

@@ -12,9 +12,7 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/frontend/input.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/settings.h"
 
@@ -169,8 +167,8 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
 
 void Controller_NPad::OnInit() {
     auto& kernel = Core::System::GetInstance().Kernel();
-    styleset_changed_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
+    styleset_changed_event =
+        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
 
     if (!IsControllerActivated()) {
         return;
@@ -496,7 +494,7 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
             had_controller_update = true;
         }
         if (had_controller_update) {
-            styleset_changed_event.writable->Signal();
+            styleset_changed_event->Signal();
         }
     }
 }
@@ -511,7 +509,7 @@ std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const {
 }
 
 void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) {
-    styleset_changed_event.writable->Signal();
+    styleset_changed_event->Signal();
     hold_type = joy_hold_type;
 }
 
@@ -520,9 +518,8 @@ Controller_NPad::NpadHoldType Controller_NPad::GetHoldType() const {
 }
 
 void Controller_NPad::SetNpadMode(u32 npad_id, NPadAssignments assignment_mode) {
-    const std::size_t npad_index = NPadIdToIndex(npad_id);
-    ASSERT(npad_index < shared_memory_entries.size());
-    shared_memory_entries[npad_index].pad_assignment = assignment_mode;
+    ASSERT(npad_id < shared_memory_entries.size());
+    shared_memory_entries[npad_id].pad_assignment = assignment_mode;
 }
 
 void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
@@ -541,11 +538,11 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
     last_processed_vibration = vibrations.back();
 }
 
-Kernel::SharedPtr<Kernel::ReadableEvent> Controller_NPad::GetStyleSetChangedEvent() const {
+Kernel::SharedPtr<Kernel::Event> Controller_NPad::GetStyleSetChangedEvent() const {
     // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should
     // be signalled at least once, and signaled after a new controller is connected?
-    styleset_changed_event.writable->Signal();
-    return styleset_changed_event.readable;
+    styleset_changed_event->Signal();
+    return styleset_changed_event;
 }
 
 Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {

src/core/hle/service/hid/controllers/npad.h

@@ -8,8 +8,7 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "core/frontend/input.h"
-#include "core/hle/kernel/object.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/hid/controllers/controller_base.h"
 #include "core/settings.h"
 
@@ -109,7 +108,7 @@ public:
     void VibrateController(const std::vector<u32>& controller_ids,
                            const std::vector<Vibration>& vibrations);
 
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetStyleSetChangedEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetStyleSetChangedEvent() const;
     Vibration GetLastVibration() const;
 
     void AddNewController(NPadControllerType controller);
@@ -304,7 +303,7 @@ private:
         sticks;
     std::vector<u32> supported_npad_id_types{};
     NpadHoldType hold_type{NpadHoldType::Vertical};
-    Kernel::EventPair styleset_changed_event;
+    Kernel::SharedPtr<Kernel::Event> styleset_changed_event;
     Vibration last_processed_vibration{};
     std::array<ControllerHolder, 10> connected_controllers{};
     bool can_controllers_vibrate{true};

src/core/hle/service/hid/hid.cpp

@@ -13,9 +13,8 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/readable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/hid/irs.h"
 #include "core/hle/service/hid/xcd.h"

src/core/hle/service/ldr/ldr.cpp

@@ -335,7 +335,10 @@ public:
         vm_manager.ReprotectRange(*map_address + header.rw_offset, header.rw_size,
                                   Kernel::VMAPermission::ReadWrite);
 
-        Core::System::GetInstance().InvalidateCpuInstructionCaches();
+        Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
 
         nro.insert_or_assign(*map_address, NROInfo{hash, nro_size + bss_size});
 
@@ -388,7 +391,10 @@ public:
                                      Kernel::MemoryState::ModuleCodeStatic) == RESULT_SUCCESS);
         ASSERT(process->UnmapMemory(mapped_addr, 0, nro_size) == RESULT_SUCCESS);
 
-        Core::System::GetInstance().InvalidateCpuInstructionCaches();
+        Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
 
         nro.erase(iter);
         IPC::ResponseBuilder rb{ctx, 2};
@@ -408,13 +414,13 @@ private:
     using SHA256Hash = std::array<u8, 0x20>;
 
     struct NROHeader {
-        INSERT_PADDING_WORDS(1);
+        u32_le entrypoint_insn;
         u32_le mod_offset;
         INSERT_PADDING_WORDS(2);
         u32_le magic;
-        u32_le version;
+        INSERT_PADDING_WORDS(1);
         u32_le nro_size;
-        u32_le flags;
+        INSERT_PADDING_WORDS(1);
         u32_le text_offset;
         u32_le text_size;
         u32_le ro_offset;
@@ -430,10 +436,9 @@ private:
 
     struct NRRHeader {
         u32_le magic;
-        INSERT_PADDING_BYTES(12);
+        INSERT_PADDING_BYTES(0x1C);
         u64_le title_id_mask;
         u64_le title_id_pattern;
-        INSERT_PADDING_BYTES(16);
         std::array<u8, 0x100> modulus;
         std::array<u8, 0x100> signature_1;
         std::array<u8, 0x100> signature_2;

src/core/hle/service/nfp/nfp.cpp

@@ -7,9 +7,7 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/lock.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/nfp/nfp.h"
@@ -25,8 +23,8 @@ constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                          "IUser:NFCTagDetected");
+    nfc_tag_load =
+        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected");
 }
 
 Module::Interface::~Interface() = default;
@@ -65,10 +63,10 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        deactivate_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
-        availability_change_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::OneShot, "IUser:AvailabilityChangeEvent");
+        deactivate_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
+        availability_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                          "IUser:AvailabilityChangeEvent");
     }
 
 private:
@@ -166,7 +164,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(deactivate_event.readable);
+        rb.PushCopyObjects(deactivate_event);
     }
 
     void StopDetection(Kernel::HLERequestContext& ctx) {
@@ -175,7 +173,7 @@ private:
         switch (device_state) {
         case DeviceState::TagFound:
         case DeviceState::TagNearby:
-            deactivate_event.writable->Signal();
+            deactivate_event->Signal();
             device_state = DeviceState::Initialized;
             break;
         case DeviceState::SearchingForTag:
@@ -266,7 +264,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(availability_change_event.readable);
+        rb.PushCopyObjects(availability_change_event);
     }
 
     void GetRegisterInfo(Kernel::HLERequestContext& ctx) {
@@ -321,8 +319,8 @@ private:
     const u32 npad_id{0}; // Player 1 controller
     State state{State::NonInitialized};
     DeviceState device_state{DeviceState::Initialized};
-    Kernel::EventPair deactivate_event;
-    Kernel::EventPair availability_change_event;
+    Kernel::SharedPtr<Kernel::Event> deactivate_event;
+    Kernel::SharedPtr<Kernel::Event> availability_change_event;
     const Module::Interface& nfp_interface;
 };
 
@@ -341,14 +339,12 @@ bool Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
     }
 
     std::memcpy(&amiibo, buffer.data(), sizeof(amiibo));
-    nfc_tag_load.writable->Signal();
+    nfc_tag_load->Signal();
     return true;
 }
-
-const Kernel::SharedPtr<Kernel::ReadableEvent>& Module::Interface::GetNFCEvent() const {
-    return nfc_tag_load.readable;
+const Kernel::SharedPtr<Kernel::Event>& Module::Interface::GetNFCEvent() const {
+    return nfc_tag_load;
 }
-
 const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const {
     return amiibo;
 }

src/core/hle/service/nfp/nfp.h

@@ -6,8 +6,7 @@
 
 #include <array>
 #include <vector>
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/service.h"
 
 namespace Service::NFP {
@@ -34,11 +33,11 @@ public:
 
         void CreateUserInterface(Kernel::HLERequestContext& ctx);
         bool LoadAmiibo(const std::vector<u8>& buffer);
-        const Kernel::SharedPtr<Kernel::ReadableEvent>& GetNFCEvent() const;
+        const Kernel::SharedPtr<Kernel::Event>& GetNFCEvent() const;
         const AmiiboFile& GetAmiiboBuffer() const;
 
     private:
-        Kernel::EventPair nfc_tag_load{};
+        Kernel::SharedPtr<Kernel::Event> nfc_tag_load{};
         AmiiboFile amiibo{};
 
     protected:

src/core/hle/service/nifm/nifm.cpp

@@ -4,9 +4,7 @@
 
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/service.h"
 
@@ -58,10 +56,8 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        event1 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                        "IRequest:Event1");
-        event2 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                        "IRequest:Event2");
+        event1 = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IRequest:Event1");
+        event2 = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IRequest:Event2");
     }
 
 private:
@@ -92,7 +88,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 2};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(event1.readable, event2.readable);
+        rb.PushCopyObjects(event1, event2);
     }
 
     void Cancel(Kernel::HLERequestContext& ctx) {
@@ -109,7 +105,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    Kernel::EventPair event1, event2;
+    Kernel::SharedPtr<Kernel::Event> event1, event2;
 };
 
 class INetworkProfile final : public ServiceFramework<INetworkProfile> {

src/core/hle/service/nim/nim.cpp

@@ -6,9 +6,7 @@
 #include <ctime>
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/nim/nim.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -140,18 +138,19 @@ public:
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
-        finished_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::OneShot,
-            "IEnsureNetworkClockAvailabilityService:FinishEvent");
+        finished_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                  "IEnsureNetworkClockAvailabilityService:FinishEvent");
     }
 
 private:
-    Kernel::EventPair finished_event;
+    Kernel::SharedPtr<Kernel::Event> finished_event;
 
     void StartTask(Kernel::HLERequestContext& ctx) {
         // No need to connect to the internet, just finish the task straight away.
         LOG_DEBUG(Service_NIM, "called");
-        finished_event.writable->Signal();
+
+        finished_event->Signal();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
@@ -161,7 +160,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(finished_event.readable);
+        rb.PushCopyObjects(finished_event);
     }
 
     void GetResult(Kernel::HLERequestContext& ctx) {
@@ -173,7 +172,8 @@ private:
 
     void Cancel(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_NIM, "called");
-        finished_event.writable->Clear();
+
+        finished_event->Clear();
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }

src/core/hle/service/nvdrv/interface.cpp

@@ -6,9 +6,7 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/interface.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 
@@ -71,7 +69,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(query_event.readable);
+    rb.PushCopyObjects(query_event);
     rb.Push<u32>(0);
 }
 
@@ -129,8 +127,7 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    query_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
-                                                         "NVDRV::query_event");
+    query_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "NVDRV::query_event");
 }
 
 NVDRV::~NVDRV() = default;

src/core/hle/service/nvdrv/interface.h

@@ -5,13 +5,10 @@
 #pragma once
 
 #include <memory>
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/service.h"
 
-namespace Kernel {
-class WritableEvent;
-}
-
 namespace Service::Nvidia {
 
 class NVDRV final : public ServiceFramework<NVDRV> {
@@ -34,7 +31,7 @@ private:
 
     u64 pid{};
 
-    Kernel::EventPair query_event;
+    Kernel::SharedPtr<Kernel::Event> query_event;
 };
 
 } // namespace Service::Nvidia

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -7,17 +7,14 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 
 namespace Service::NVFlinger {
 
 BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
-                                                               "BufferQueue NativeHandle");
+    buffer_wait_event =
+        Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle");
 }
 
 BufferQueue::~BufferQueue() = default;
@@ -31,7 +28,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
     buffer.status = Buffer::Status::Free;
 
     queue.emplace_back(buffer);
-    buffer_wait_event.writable->Signal();
+    buffer_wait_event->Signal();
 }
 
 std::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
@@ -90,7 +87,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
     ASSERT(itr->status == Buffer::Status::Acquired);
     itr->status = Buffer::Status::Free;
 
-    buffer_wait_event.writable->Signal();
+    buffer_wait_event->Signal();
 }
 
 u32 BufferQueue::Query(QueryType type) {
@@ -107,12 +104,4 @@ u32 BufferQueue::Query(QueryType type) {
     return 0;
 }
 
-Kernel::SharedPtr<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
-    return buffer_wait_event.writable;
-}
-
-Kernel::SharedPtr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
-    return buffer_wait_event.readable;
-}
-
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/buffer_queue.h

@@ -10,8 +10,7 @@
 #include "common/common_funcs.h"
 #include "common/math_util.h"
 #include "common/swap.h"
-#include "core/hle/kernel/object.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 
 namespace CoreTiming {
 struct EventType;
@@ -87,16 +86,16 @@ public:
         return id;
     }
 
-    Kernel::SharedPtr<Kernel::WritableEvent> GetWritableBufferWaitEvent() const;
-
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetBufferWaitEvent() const;
+    Kernel::SharedPtr<Kernel::Event> GetBufferWaitEvent() const {
+        return buffer_wait_event;
+    }
 
 private:
     u32 id;
     u64 layer_id;
 
     std::vector<Buffer> queue;
-    Kernel::EventPair buffer_wait_event;
+    Kernel::SharedPtr<Kernel::Event> buffer_wait_event;
 };
 
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -13,9 +13,6 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
@@ -86,8 +83,9 @@ u32 NVFlinger::GetBufferQueueId(u64 display_id, u64 layer_id) {
     return layer.buffer_queue->GetId();
 }
 
-Kernel::SharedPtr<Kernel::ReadableEvent> NVFlinger::GetVsyncEvent(u64 display_id) {
-    return GetDisplay(display_id).vsync_event.readable;
+Kernel::SharedPtr<Kernel::Event> NVFlinger::GetVsyncEvent(u64 display_id) {
+    const auto& display = GetDisplay(display_id);
+    return display.vsync_event;
 }
 
 std::shared_ptr<BufferQueue> NVFlinger::GetBufferQueue(u32 id) const {
@@ -119,7 +117,7 @@ Layer& NVFlinger::GetLayer(u64 display_id, u64 layer_id) {
 void NVFlinger::Compose() {
     for (auto& display : displays) {
         // Trigger vsync for this display at the end of drawing
-        SCOPE_EXIT({ display.vsync_event.writable->Signal(); });
+        SCOPE_EXIT({ display.vsync_event->Signal(); });
 
         // Don't do anything for displays without layers.
         if (display.layers.empty())
@@ -166,8 +164,7 @@ Layer::~Layer() = default;
 
 Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) {
     auto& kernel = Core::System::GetInstance().Kernel();
-    vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Pulse,
-                                                         fmt::format("Display VSync Event {}", id));
+    vsync_event = Kernel::Event::Create(kernel, Kernel::ResetType::Pulse, "Display VSync Event");
 }
 
 Display::~Display() = default;

src/core/hle/service/nvflinger/nvflinger.h

@@ -10,17 +10,12 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/event.h"
 
 namespace CoreTiming {
 struct EventType;
 }
 
-namespace Kernel {
-class ReadableEvent;
-class WritableEvent;
-} // namespace Kernel
-
 namespace Service::Nvidia {
 class Module;
 }
@@ -45,7 +40,7 @@ struct Display {
     std::string name;
 
     std::vector<Layer> layers;
-    Kernel::EventPair vsync_event;
+    Kernel::SharedPtr<Kernel::Event> vsync_event;
 };
 
 class NVFlinger final {
@@ -66,7 +61,7 @@ public:
     u32 GetBufferQueueId(u64 display_id, u64 layer_id);
 
     /// Gets the vsync event for the specified display.
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetVsyncEvent(u64 display_id);
+    Kernel::SharedPtr<Kernel::Event> GetVsyncEvent(u64 display_id);
 
     /// Obtains a buffer queue identified by the id.
     std::shared_ptr<BufferQueue> GetBufferQueue(u32 id) const;

src/core/hle/service/service.cpp

@@ -70,6 +70,10 @@
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/wlan/wlan.h"
 
+using Kernel::ClientPort;
+using Kernel::ServerPort;
+using Kernel::SharedPtr;
+
 namespace Service {
 
 /**
@@ -106,8 +110,10 @@ void ServiceFrameworkBase::InstallAsNamedPort() {
     ASSERT(port == nullptr);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    auto [server_port, client_port] =
-        Kernel::ServerPort::CreatePortPair(kernel, max_sessions, service_name);
+    SharedPtr<ServerPort> server_port;
+    SharedPtr<ClientPort> client_port;
+    std::tie(server_port, client_port) =
+        ServerPort::CreatePortPair(kernel, max_sessions, service_name);
     server_port->SetHleHandler(shared_from_this());
     kernel.AddNamedPort(service_name, std::move(client_port));
 }
@@ -116,9 +122,11 @@ Kernel::SharedPtr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
     ASSERT(port == nullptr);
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    auto [server_port, client_port] =
+    Kernel::SharedPtr<Kernel::ServerPort> server_port;
+    Kernel::SharedPtr<Kernel::ClientPort> client_port;
+    std::tie(server_port, client_port) =
         Kernel::ServerPort::CreatePortPair(kernel, max_sessions, service_name);
-    port = MakeResult(std::move(server_port)).Unwrap();
+    port = MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port)).Unwrap();
     port->SetHleHandler(shared_from_this());
     return client_port;
 }
@@ -144,7 +152,8 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext
     }
     buf.push_back('}');
 
-    UNIMPLEMENTED_MSG("Unknown / unimplemented {}", fmt::to_string(buf));
+    LOG_ERROR(Service, "unknown / unimplemented {}", fmt::to_string(buf));
+    UNIMPLEMENTED();
 }
 
 void ServiceFrameworkBase::InvokeRequest(Kernel::HLERequestContext& ctx) {

src/core/hle/service/sm/sm.cpp

@@ -54,11 +54,13 @@ ResultVal<Kernel::SharedPtr<Kernel::ServerPort>> ServiceManager::RegisterService
         return ERR_ALREADY_REGISTERED;
 
     auto& kernel = Core::System::GetInstance().Kernel();
-    auto [server_port, client_port] =
+    Kernel::SharedPtr<Kernel::ServerPort> server_port;
+    Kernel::SharedPtr<Kernel::ClientPort> client_port;
+    std::tie(server_port, client_port) =
         Kernel::ServerPort::CreatePortPair(kernel, max_sessions, name);
 
     registered_services.emplace(std::move(name), std::move(client_port));
-    return MakeResult(std::move(server_port));
+    return MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port));
 }
 
 ResultCode ServiceManager::UnregisterService(const std::string& name) {
@@ -81,7 +83,7 @@ ResultVal<Kernel::SharedPtr<Kernel::ClientPort>> ServiceManager::GetServicePort(
         return ERR_SERVICE_NOT_REGISTERED;
     }
 
-    return MakeResult(it->second);
+    return MakeResult<Kernel::SharedPtr<Kernel::ClientPort>>(it->second);
 }
 
 ResultVal<Kernel::SharedPtr<Kernel::ClientSession>> ServiceManager::ConnectToService(

src/core/hle/service/usb/usb.cpp

@@ -73,7 +73,7 @@ public:
             {3, nullptr, "Populate"},
             {4, nullptr, "PostBufferAsync"},
             {5, nullptr, "GetXferReport"},
-            {6, nullptr, "PostBufferMultiAsync"},
+            {6, nullptr, "Unknown2"},
             {7, nullptr, "Unknown3"},
             {8, nullptr, "Unknown4"},
         };

src/core/hle/service/vi/vi.cpp

@@ -18,8 +18,7 @@
 #include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -543,14 +542,12 @@ private:
                         // Repeat TransactParcel DequeueBuffer when a buffer is available
                         auto buffer_queue = nv_flinger->GetBufferQueue(id);
                         std::optional<u32> slot = buffer_queue->DequeueBuffer(width, height);
-                        ASSERT_MSG(slot != std::nullopt, "Could not dequeue buffer.");
-
                         IGBPDequeueBufferResponseParcel response{*slot};
                         ctx.WriteBuffer(response.Serialize());
                         IPC::ResponseBuilder rb{ctx, 2};
                         rb.Push(RESULT_SUCCESS);
                     },
-                    buffer_queue->GetWritableBufferWaitEvent());
+                    buffer_queue->GetBufferWaitEvent());
             }
         } else if (transaction == TransactionId::RequestBuffer) {
             IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()};

src/core/loader/deconstructed_rom_directory.cpp

@@ -7,6 +7,7 @@
 #include "common/common_funcs.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -145,7 +146,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
         const VAddr load_addr = next_load_addr;
         const bool should_pass_arguments = std::strcmp(module, "rtld") == 0;
         const auto tentative_next_load_addr =
-            AppLoader_NSO::LoadModule(process, *module_file, load_addr, should_pass_arguments, pm);
+            AppLoader_NSO::LoadModule(*module_file, load_addr, should_pass_arguments, pm);
         if (!tentative_next_load_addr) {
             return ResultStatus::ErrorLoadingNSO;
         }

src/core/loader/deconstructed_rom_directory.h

@@ -33,7 +33,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 

src/core/loader/elf.h

@@ -22,7 +22,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 

src/core/loader/loader.h

@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include "core/file_sys/control_metadata.h"
 #include "core/file_sys/vfs.h"
 
 namespace Kernel {
@@ -132,7 +131,7 @@ public:
      * Returns the type of this file
      * @return FileType corresponding to the loaded file
      */
-    virtual FileType GetFileType() const = 0;
+    virtual FileType GetFileType() = 0;
 
     /**
      * Load the application and return the created Process instance
@@ -244,15 +243,6 @@ public:
         return ResultStatus::ErrorNotImplemented;
     }
 
-    /**
-     * Get the developer of the application
-     * @param developer Reference to store the application developer into
-     * @return ResultStatus result of function
-     */
-    virtual ResultStatus ReadDeveloper(std::string& developer) {
-        return ResultStatus::ErrorNotImplemented;
-    }
-
 protected:
     FileSys::VirtualFile file;
     bool is_loaded = false;

src/core/loader/nax.cpp

@@ -37,7 +37,7 @@ FileType AppLoader_NAX::IdentifyType(const FileSys::VirtualFile& file) {
     return IdentifyTypeImpl(nax);
 }
 
-FileType AppLoader_NAX::GetFileType() const {
+FileType AppLoader_NAX::GetFileType() {
     return IdentifyTypeImpl(*nax);
 }
 

src/core/loader/nax.h

@@ -31,7 +31,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override;
+    FileType GetFileType() override;
 
     ResultStatus Load(Kernel::Process& process) override;
 

src/core/loader/nca.h

@@ -29,7 +29,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 

src/core/loader/nro.cpp

@@ -10,6 +10,7 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/swap.h"
+#include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/vfs_offset.h"
@@ -128,8 +129,9 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
-static bool LoadNroImpl(Kernel::Process& process, const std::vector<u8>& data,
-                        const std::string& name, VAddr load_base) {
+/*static*/ bool AppLoader_NRO::LoadNro(const std::vector<u8>& data, const std::string& name,
+                                       VAddr load_base) {
+
     if (data.size() < sizeof(NroHeader)) {
         return {};
     }
@@ -187,7 +189,7 @@ static bool LoadNroImpl(Kernel::Process& process, const std::vector<u8>& data,
 
     // Load codeset for current process
     codeset.memory = std::make_shared<std::vector<u8>>(std::move(program_image));
-    process.LoadModule(std::move(codeset), load_base);
+    Core::CurrentProcess()->LoadModule(std::move(codeset), load_base);
 
     // Register module with GDBStub
     GDBStub::RegisterModule(name, load_base, load_base);
@@ -195,9 +197,8 @@ static bool LoadNroImpl(Kernel::Process& process, const std::vector<u8>& data,
     return true;
 }
 
-bool AppLoader_NRO::LoadNro(Kernel::Process& process, const FileSys::VfsFile& file,
-                            VAddr load_base) {
-    return LoadNroImpl(process, file.ReadAllBytes(), file.GetName(), load_base);
+bool AppLoader_NRO::LoadNro(const FileSys::VfsFile& file, VAddr load_base) {
+    return AppLoader_NRO::LoadNro(file.ReadAllBytes(), file.GetName(), load_base);
 }
 
 ResultStatus AppLoader_NRO::Load(Kernel::Process& process) {
@@ -208,7 +209,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::Process& process) {
     // Load NRO
     const VAddr base_address = process.VMManager().GetCodeRegionBaseAddress();
 
-    if (!LoadNro(process, *file, base_address)) {
+    if (!LoadNro(*file, base_address)) {
         return ResultStatus::ErrorLoadingNRO;
     }
 

src/core/loader/nro.h

@@ -14,10 +14,6 @@ namespace FileSys {
 class NACP;
 }
 
-namespace Kernel {
-class Process;
-}
-
 namespace Loader {
 
 /// Loads an NRO file
@@ -33,7 +29,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 
@@ -45,8 +41,10 @@ public:
     ResultStatus ReadTitle(std::string& title) override;
     bool IsRomFSUpdatable() const override;
 
+    static bool LoadNro(const std::vector<u8>& data, const std::string& name, VAddr load_base);
+
 private:
-    bool LoadNro(Kernel::Process& process, const FileSys::VfsFile& file, VAddr load_base);
+    bool LoadNro(const FileSys::VfsFile& file, VAddr load_base);
 
     std::vector<u8> icon_data;
     std::unique_ptr<FileSys::NACP> nacp;

src/core/loader/nso.cpp

@@ -9,6 +9,7 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/swap.h"
+#include "core/core.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
@@ -92,8 +93,7 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
-std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
-                                               const FileSys::VfsFile& file, VAddr load_base,
+std::optional<VAddr> AppLoader_NSO::LoadModule(const FileSys::VfsFile& file, VAddr load_base,
                                                bool should_pass_arguments,
                                                std::optional<FileSys::PatchManager> pm) {
     if (file.GetSize() < sizeof(NsoHeader))
@@ -166,7 +166,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
 
     // Load codeset for current process
     codeset.memory = std::make_shared<std::vector<u8>>(std::move(program_image));
-    process.LoadModule(std::move(codeset), load_base);
+    Core::CurrentProcess()->LoadModule(std::move(codeset), load_base);
 
     // Register module with GDBStub
     GDBStub::RegisterModule(file.GetName(), load_base, load_base);
@@ -181,7 +181,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::Process& process) {
 
     // Load module
     const VAddr base_address = process.VMManager().GetCodeRegionBaseAddress();
-    if (!LoadModule(process, *file, base_address, true)) {
+    if (!LoadModule(*file, base_address, true)) {
         return ResultStatus::ErrorLoadingNSO;
     }
     LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", file->GetName(), base_address);

src/core/loader/nso.h

@@ -10,10 +10,6 @@
 #include "core/loader/linker.h"
 #include "core/loader/loader.h"
 
-namespace Kernel {
-class Process;
-}
-
 namespace Loader {
 
 constexpr u64 NSO_ARGUMENT_DATA_ALLOCATION_SIZE = 0x9000;
@@ -37,12 +33,12 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 
-    static std::optional<VAddr> LoadModule(Kernel::Process& process, const FileSys::VfsFile& file,
-                                           VAddr load_base, bool should_pass_arguments,
+    static std::optional<VAddr> LoadModule(const FileSys::VfsFile& file, VAddr load_base,
+                                           bool should_pass_arguments,
                                            std::optional<FileSys::PatchManager> pm = {});
 
     ResultStatus Load(Kernel::Process& process) override;

src/core/loader/nsp.cpp

@@ -151,11 +151,4 @@ ResultStatus AppLoader_NSP::ReadTitle(std::string& title) {
     title = nacp_file->GetApplicationName();
     return ResultStatus::Success;
 }
-
-ResultStatus AppLoader_NSP::ReadDeveloper(std::string& developer) {
-    if (nacp_file == nullptr)
-        return ResultStatus::ErrorNoControl;
-    developer = nacp_file->GetDeveloperName();
-    return ResultStatus::Success;
-}
 } // namespace Loader

src/core/loader/nsp.h

@@ -31,7 +31,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 
@@ -43,7 +43,6 @@ public:
     ResultStatus ReadProgramId(u64& out_program_id) override;
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;
     ResultStatus ReadTitle(std::string& title) override;
-    ResultStatus ReadDeveloper(std::string& developer) override;
 
 private:
     std::unique_ptr<FileSys::NSP> nsp;

src/core/loader/xci.cpp

@@ -120,11 +120,4 @@ ResultStatus AppLoader_XCI::ReadTitle(std::string& title) {
     title = nacp_file->GetApplicationName();
     return ResultStatus::Success;
 }
-
-ResultStatus AppLoader_XCI::ReadDeveloper(std::string& developer) {
-    if (nacp_file == nullptr)
-        return ResultStatus::ErrorNoControl;
-    developer = nacp_file->GetDeveloperName();
-    return ResultStatus::Success;
-}
 } // namespace Loader

src/core/loader/xci.h

@@ -31,7 +31,7 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() const override {
+    FileType GetFileType() override {
         return IdentifyType(file);
     }
 
@@ -43,7 +43,6 @@ public:
     ResultStatus ReadProgramId(u64& out_program_id) override;
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;
     ResultStatus ReadTitle(std::string& title) override;
-    ResultStatus ReadDeveloper(std::string& developer) override;
 
 private:
     std::unique_ptr<FileSys::XCI> xci;

src/core/memory.cpp

@@ -53,14 +53,6 @@ void PageTable::Resize(std::size_t address_space_width_in_bits) {
 
     pointers.resize(num_page_table_entries);
     attributes.resize(num_page_table_entries);
-
-    // The default is a 39-bit address space, which causes an initial 1GB allocation size. If the
-    // vector size is subsequently decreased (via resize), the vector might not automatically
-    // actually reallocate/resize its underlying allocation, which wastes up to ~800 MB for
-    // 36-bit titles. Call shrink_to_fit to reduce capacity to what's actually in use.
-
-    pointers.shrink_to_fit();
-    attributes.shrink_to_fit();
 }
 
 static void MapPages(PageTable& page_table, VAddr base, u64 size, u8* memory, PageType type) {
@@ -125,13 +117,14 @@ void RemoveDebugHook(PageTable& page_table, VAddr base, u64 size, MemoryHookPoin
  * using a VMA from the current process
  */
 static u8* GetPointerFromVMA(const Kernel::Process& process, VAddr vaddr) {
-    const auto& vm_manager = process.VMManager();
-
-    const auto it = vm_manager.FindVMA(vaddr);
-    DEBUG_ASSERT(vm_manager.IsValidHandle(it));
-
     u8* direct_pointer = nullptr;
-    const auto& vma = it->second;
+
+    auto& vm_manager = process.VMManager();
+
+    auto it = vm_manager.FindVMA(vaddr);
+    ASSERT(it != vm_manager.vma_map.end());
+
+    auto& vma = it->second;
     switch (vma.type) {
     case Kernel::VMAType::AllocatedMemoryBlock:
         direct_pointer = vma.backing_block->data() + vma.offset;

src/core/settings.h

@@ -6,10 +6,8 @@
 
 #include <array>
 #include <atomic>
-#include <map>
 #include <optional>
 #include <string>
-#include <vector>
 #include "common/common_types.h"
 
 namespace Settings {
@@ -413,9 +411,6 @@ struct Values {
     std::string web_api_url;
     std::string yuzu_username;
     std::string yuzu_token;
-
-    // Add-Ons
-    std::map<u64, std::vector<std::string>> disabled_addons;
 } extern values;
 
 void Apply();

src/core/telemetry_session.cpp

@@ -103,8 +103,13 @@ bool VerifyLogin(const std::string& username, const std::string& token) {
 
 TelemetrySession::TelemetrySession() {
 #ifdef ENABLE_WEB_SERVICE
-    backend = std::make_unique<WebService::TelemetryJson>(
-        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
+    if (Settings::values.enable_telemetry) {
+        backend = std::make_unique<WebService::TelemetryJson>(Settings::values.web_api_url,
+                                                              Settings::values.yuzu_username,
+                                                              Settings::values.yuzu_token);
+    } else {
+        backend = std::make_unique<Telemetry::NullVisitor>();
+    }
 #else
     backend = std::make_unique<Telemetry::NullVisitor>();
 #endif
@@ -175,8 +180,7 @@ TelemetrySession::~TelemetrySession() {
     // This is just a placeholder to wrap up the session once the core completes and this is
     // destroyed. This will be moved elsewhere once we are actually doing real I/O with the service.
     field_collection.Accept(*backend);
-    if (Settings::values.enable_telemetry)
-        backend->Complete();
+    backend->Complete();
     backend = nullptr;
 }
 

src/video_core/command_processor.cpp

@@ -0,0 +1,142 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <cstddef>
+#include <memory>
+#include <utility>
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "common/microprofile.h"
+#include "common/vector_math.h"
+#include "core/memory.h"
+#include "core/tracer/recorder.h"
+#include "video_core/command_processor.h"
+#include "video_core/engines/fermi_2d.h"
+#include "video_core/engines/kepler_memory.h"
+#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/maxwell_compute.h"
+#include "video_core/engines/maxwell_dma.h"
+#include "video_core/gpu.h"
+#include "video_core/renderer_base.h"
+#include "video_core/video_core.h"
+
+namespace Tegra {
+
+enum class BufferMethods {
+    BindObject = 0,
+    CountBufferMethods = 0x40,
+};
+
+MICROPROFILE_DEFINE(ProcessCommandLists, "GPU", "Execute command buffer", MP_RGB(128, 128, 192));
+
+void GPU::ProcessCommandLists(const std::vector<CommandListHeader>& commands) {
+    MICROPROFILE_SCOPE(ProcessCommandLists);
+
+    // On entering GPU code, assume all memory may be touched by the ARM core.
+    maxwell_3d->dirty_flags.OnMemoryWrite();
+
+    auto WriteReg = [this](u32 method, u32 subchannel, u32 value, u32 remaining_params) {
+        LOG_TRACE(HW_GPU,
+                  "Processing method {:08X} on subchannel {} value "
+                  "{:08X} remaining params {}",
+                  method, subchannel, value, remaining_params);
+
+        ASSERT(subchannel < bound_engines.size());
+
+        if (method == static_cast<u32>(BufferMethods::BindObject)) {
+            // Bind the current subchannel to the desired engine id.
+            LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", subchannel, value);
+            bound_engines[subchannel] = static_cast<EngineID>(value);
+            return;
+        }
+
+        if (method < static_cast<u32>(BufferMethods::CountBufferMethods)) {
+            // TODO(Subv): Research and implement these methods.
+            LOG_ERROR(HW_GPU, "Special buffer methods other than Bind are not implemented");
+            return;
+        }
+
+        const EngineID engine = bound_engines[subchannel];
+
+        switch (engine) {
+        case EngineID::FERMI_TWOD_A:
+            fermi_2d->WriteReg(method, value);
+            break;
+        case EngineID::MAXWELL_B:
+            maxwell_3d->WriteReg(method, value, remaining_params);
+            break;
+        case EngineID::MAXWELL_COMPUTE_B:
+            maxwell_compute->WriteReg(method, value);
+            break;
+        case EngineID::MAXWELL_DMA_COPY_A:
+            maxwell_dma->WriteReg(method, value);
+            break;
+        case EngineID::KEPLER_INLINE_TO_MEMORY_B:
+            kepler_memory->WriteReg(method, value);
+            break;
+        default:
+            UNIMPLEMENTED_MSG("Unimplemented engine");
+        }
+    };
+
+    for (auto entry : commands) {
+        Tegra::GPUVAddr address = entry.Address();
+        u32 size = entry.sz;
+        const std::optional<VAddr> head_address = memory_manager->GpuToCpuAddress(address);
+        VAddr current_addr = *head_address;
+        while (current_addr < *head_address + size * sizeof(CommandHeader)) {
+            const CommandHeader header = {Memory::Read32(current_addr)};
+            current_addr += sizeof(u32);
+
+            switch (header.mode.Value()) {
+            case SubmissionMode::IncreasingOld:
+            case SubmissionMode::Increasing: {
+                // Increase the method value with each argument.
+                for (unsigned i = 0; i < header.arg_count; ++i) {
+                    WriteReg(header.method + i, header.subchannel, Memory::Read32(current_addr),
+                             header.arg_count - i - 1);
+                    current_addr += sizeof(u32);
+                }
+                break;
+            }
+            case SubmissionMode::NonIncreasingOld:
+            case SubmissionMode::NonIncreasing: {
+                // Use the same method value for all arguments.
+                for (unsigned i = 0; i < header.arg_count; ++i) {
+                    WriteReg(header.method, header.subchannel, Memory::Read32(current_addr),
+                             header.arg_count - i - 1);
+                    current_addr += sizeof(u32);
+                }
+                break;
+            }
+            case SubmissionMode::IncreaseOnce: {
+                ASSERT(header.arg_count.Value() >= 1);
+
+                // Use the original method for the first argument and then the next method for all
+                // other arguments.
+                WriteReg(header.method, header.subchannel, Memory::Read32(current_addr),
+                         header.arg_count - 1);
+                current_addr += sizeof(u32);
+
+                for (unsigned i = 1; i < header.arg_count; ++i) {
+                    WriteReg(header.method + 1, header.subchannel, Memory::Read32(current_addr),
+                             header.arg_count - i - 1);
+                    current_addr += sizeof(u32);
+                }
+                break;
+            }
+            case SubmissionMode::Inline: {
+                // The register value is stored in the bits 16-28 as an immediate
+                WriteReg(header.method, header.subchannel, header.inline_data, 0);
+                break;
+            }
+            default:
+                UNIMPLEMENTED();
+            }
+        }
+    }
+}
+
+} // namespace Tegra

src/video_core/engines/maxwell_3d.h

@@ -42,7 +42,6 @@ public:
         static constexpr std::size_t NumVertexArrays = 32;
         static constexpr std::size_t NumVertexAttributes = 32;
         static constexpr std::size_t NumTextureSamplers = 32;
-        static constexpr std::size_t NumClipDistances = 8;
         static constexpr std::size_t MaxShaderProgram = 6;
         static constexpr std::size_t MaxShaderStage = 5;
         // Maximum number of const buffers per shader stage.

src/video_core/engines/shader_bytecode.h

@@ -1049,7 +1049,6 @@ union Instruction {
         BitField<49, 1, u64> nodep_flag;
         BitField<50, 3, u64> component_mask_selector;
         BitField<53, 4, u64> texture_info;
-        BitField<60, 1, u64> fp32_flag;
 
         TextureType GetTextureType() const {
             // The TEXS instruction has a weird encoding for the texture type.
@@ -1550,7 +1549,7 @@ private:
             INST("1110111011011---", Id::STG, Type::Memory, "STG"),
             INST("110000----111---", Id::TEX, Type::Memory, "TEX"),
             INST("1101111101001---", Id::TXQ, Type::Memory, "TXQ"),
-            INST("1101-00---------", Id::TEXS, Type::Memory, "TEXS"),
+            INST("1101100---------", Id::TEXS, Type::Memory, "TEXS"),
             INST("1101101---------", Id::TLDS, Type::Memory, "TLDS"),
             INST("110010----111---", Id::TLD4, Type::Memory, "TLD4"),
             INST("1101111100------", Id::TLD4S, Type::Memory, "TLD4S"),

src/video_core/gpu.cpp

@@ -128,8 +128,10 @@ enum class BufferMethods {
 };
 
 void GPU::CallMethod(const MethodCall& method_call) {
-    LOG_TRACE(HW_GPU, "Processing method {:08X} on subchannel {}", method_call.method,
-              method_call.subchannel);
+    LOG_TRACE(HW_GPU,
+              "Processing method {:08X} on subchannel {} value "
+              "{:08X} remaining params {}",
+              MethCall.method, MethCall.subchannel, value, remaining_params);
 
     ASSERT(method_call.subchannel < bound_engines.size());
 
@@ -141,12 +143,6 @@ void GPU::CallMethod(const MethodCall& method_call) {
         return;
     }
 
-    if (method_call.method < static_cast<u32>(BufferMethods::CountBufferMethods)) {
-        // TODO(Subv): Research and implement these methods.
-        LOG_ERROR(HW_GPU, "Special buffer methods other than Bind are not implemented");
-        return;
-    }
-
     const EngineID engine = bound_engines[method_call.subchannel];
 
     switch (engine) {

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -79,26 +79,6 @@ struct DrawParameters {
     }
 };
 
-struct FramebufferCacheKey {
-    bool is_single_buffer = false;
-    bool stencil_enable = false;
-
-    std::array<GLenum, Maxwell::NumRenderTargets> color_attachments{};
-    std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumRenderTargets> colors{};
-    u32 colors_count = 0;
-
-    GLuint zeta = 0;
-
-    auto Tie() const {
-        return std::tie(is_single_buffer, stencil_enable, color_attachments, colors, colors_count,
-                        zeta);
-    }
-
-    bool operator<(const FramebufferCacheKey& rhs) const {
-        return Tie() < rhs.Tie();
-    }
-};
-
 RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo& info)
     : res_cache{*this}, shader_cache{*this}, emu_window{window}, screen_info{info},
       buffer_cache(*this, STREAM_BUFFER_SIZE) {
@@ -108,8 +88,24 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo
         state.texture_units[i].sampler = texture_samplers[i].sampler.handle;
     }
 
+    GLint ext_num;
+    glGetIntegerv(GL_NUM_EXTENSIONS, &ext_num);
+    for (GLint i = 0; i < ext_num; i++) {
+        const std::string_view extension{
+            reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
+
+        if (extension == "GL_ARB_direct_state_access") {
+            has_ARB_direct_state_access = true;
+        } else if (extension == "GL_ARB_multi_bind") {
+            has_ARB_multi_bind = true;
+        }
+    }
+
     OpenGLState::ApplyDefaultState();
 
+    // Create render framebuffer
+    framebuffer.Create();
+
     shader_program_manager = std::make_unique<GLShader::ProgramManager>();
     state.draw.shader_program = 0;
     state.Apply();
@@ -299,7 +295,6 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
     // shaders. The constbuffer bindpoint starts after the shader stage configuration bind points.
     u32 current_constbuffer_bindpoint = Tegra::Engines::Maxwell3D::Regs::MaxShaderStage;
     u32 current_texture_bindpoint = 0;
-    std::array<bool, Maxwell::NumClipDistances> clip_distances{};
 
     for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
         const auto& shader_config = gpu.regs.shader_config[index];
@@ -360,60 +355,12 @@ void RasterizerOpenGL::SetupShaders(GLenum primitive_mode) {
         current_texture_bindpoint = SetupTextures(static_cast<Maxwell::ShaderStage>(stage), shader,
                                                   primitive_mode, current_texture_bindpoint);
 
-        // Workaround for Intel drivers.
-        // When a clip distance is enabled but not set in the shader it crops parts of the screen
-        // (sometimes it's half the screen, sometimes three quarters). To avoid this, enable the
-        // clip distances only when it's written by a shader stage.
-        for (std::size_t i = 0; i < Maxwell::NumClipDistances; ++i) {
-            clip_distances[i] |= shader->GetShaderEntries().clip_distances[i];
-        }
-
         // When VertexA is enabled, we have dual vertex shaders
         if (program == Maxwell::ShaderProgram::VertexA) {
             // VertexB was combined with VertexA, so we skip the VertexB iteration
             index++;
         }
     }
-
-    SyncClipEnabled(clip_distances);
-}
-
-void RasterizerOpenGL::SetupCachedFramebuffer(const FramebufferCacheKey& fbkey,
-                                              OpenGLState& current_state) {
-    const auto [entry, is_cache_miss] = framebuffer_cache.try_emplace(fbkey);
-    auto& framebuffer = entry->second;
-
-    if (is_cache_miss)
-        framebuffer.Create();
-
-    current_state.draw.draw_framebuffer = framebuffer.handle;
-    current_state.ApplyFramebufferState();
-
-    if (!is_cache_miss)
-        return;
-
-    if (fbkey.is_single_buffer) {
-        if (fbkey.color_attachments[0] != GL_NONE) {
-            glFramebufferTexture(GL_DRAW_FRAMEBUFFER, fbkey.color_attachments[0], fbkey.colors[0],
-                                 0);
-        }
-        glDrawBuffer(fbkey.color_attachments[0]);
-    } else {
-        for (std::size_t index = 0; index < Maxwell::NumRenderTargets; ++index) {
-            if (fbkey.colors[index]) {
-                glFramebufferTexture(GL_DRAW_FRAMEBUFFER,
-                                     GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(index),
-                                     fbkey.colors[index], 0);
-            }
-        }
-        glDrawBuffers(fbkey.colors_count, fbkey.color_attachments.data());
-    }
-
-    if (fbkey.zeta) {
-        GLenum zeta_attachment =
-            fbkey.stencil_enable ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
-        glFramebufferTexture(GL_DRAW_FRAMEBUFFER, zeta_attachment, fbkey.zeta, 0);
-    }
 }
 
 std::size_t RasterizerOpenGL::CalculateVertexArraysSize() const {
@@ -496,13 +443,13 @@ void RasterizerOpenGL::ConfigureFramebuffers(OpenGLState& current_state, bool us
     // TODO(bunnei): Figure out how the below register works. According to envytools, this should be
     // used to enable multiple render targets. However, it is left unset on all games that I have
     // tested.
-    UNIMPLEMENTED_IF(regs.rt_separate_frag_data != 0);
+    ASSERT_MSG(regs.rt_separate_frag_data == 0, "Unimplemented");
 
     // Bind the framebuffer surfaces
+    current_state.draw.draw_framebuffer = framebuffer.handle;
+    current_state.ApplyFramebufferState();
     current_state.framebuffer_srgb.enabled = regs.framebuffer_srgb != 0;
 
-    FramebufferCacheKey fbkey;
-
     if (using_color_fb) {
         if (single_color_target) {
             // Used when just a single color attachment is enabled, e.g. for clearing a color buffer
@@ -518,12 +465,14 @@ void RasterizerOpenGL::ConfigureFramebuffers(OpenGLState& current_state, bool us
                 state.framebuffer_srgb.enabled |= color_surface->GetSurfaceParams().srgb_conversion;
             }
 
-            fbkey.is_single_buffer = true;
-            fbkey.color_attachments[0] =
-                GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(*single_color_target);
-            fbkey.colors[0] = color_surface != nullptr ? color_surface->Texture().handle : 0;
+            glFramebufferTexture2D(
+                GL_DRAW_FRAMEBUFFER,
+                GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(*single_color_target), GL_TEXTURE_2D,
+                color_surface != nullptr ? color_surface->Texture().handle : 0, 0);
+            glDrawBuffer(GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(*single_color_target));
         } else {
             // Multiple color attachments are enabled
+            std::array<GLenum, Maxwell::NumRenderTargets> buffers;
             for (std::size_t index = 0; index < Maxwell::NumRenderTargets; ++index) {
                 Surface color_surface = res_cache.GetColorBufferSurface(index, preserve_contents);
 
@@ -538,17 +487,22 @@ void RasterizerOpenGL::ConfigureFramebuffers(OpenGLState& current_state, bool us
                         color_surface->GetSurfaceParams().srgb_conversion;
                 }
 
-                fbkey.color_attachments[index] =
-                    GL_COLOR_ATTACHMENT0 + regs.rt_control.GetMap(index);
-                fbkey.colors[index] =
-                    color_surface != nullptr ? color_surface->Texture().handle : 0;
+                buffers[index] = GL_COLOR_ATTACHMENT0 + regs.rt_control.GetMap(index);
+                glFramebufferTexture2D(
+                    GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(index),
+                    GL_TEXTURE_2D, color_surface != nullptr ? color_surface->Texture().handle : 0,
+                    0);
             }
-            fbkey.is_single_buffer = false;
-            fbkey.colors_count = regs.rt_control.count;
+            glDrawBuffers(regs.rt_control.count, buffers.data());
         }
     } else {
-        // No color attachments are enabled - leave them as zero
-        fbkey.is_single_buffer = true;
+        // No color attachments are enabled - zero out all of them
+        for (std::size_t index = 0; index < Maxwell::NumRenderTargets; ++index) {
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER,
+                                   GL_COLOR_ATTACHMENT0 + static_cast<GLenum>(index), GL_TEXTURE_2D,
+                                   0, 0);
+        }
+        glDrawBuffer(GL_NONE);
     }
 
     if (depth_surface) {
@@ -556,12 +510,22 @@ void RasterizerOpenGL::ConfigureFramebuffers(OpenGLState& current_state, bool us
         // the shader doesn't actually write to it.
         depth_surface->MarkAsModified(true, res_cache);
 
-        fbkey.zeta = depth_surface->Texture().handle;
-        fbkey.stencil_enable = regs.stencil_enable;
+        if (regs.stencil_enable) {
+            // Attach both depth and stencil
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                                   depth_surface->Texture().handle, 0);
+        } else {
+            // Attach depth
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
+                                   depth_surface->Texture().handle, 0);
+            // Clear stencil attachment
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+        }
+    } else {
+        // Clear both depth and stencil attachment
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
+                               0);
     }
-
-    SetupCachedFramebuffer(fbkey, current_state);
-
     SyncViewport(current_state);
 }
 
@@ -678,6 +642,7 @@ void RasterizerOpenGL::DrawArrays() {
     SyncCullMode();
     SyncPrimitiveRestart();
     SyncScissorTest(state);
+    SyncClipEnabled();
     // Alpha Testing is synced on shaders.
     SyncTransformFeedback();
     SyncPointState();
@@ -1054,23 +1019,20 @@ void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
     state.depth_clamp.near_plane = regs.view_volume_clip_control.depth_clamp_near != 0;
 }
 
-void RasterizerOpenGL::SyncClipEnabled(
-    const std::array<bool, Maxwell::Regs::NumClipDistances>& clip_mask) {
-
+void RasterizerOpenGL::SyncClipEnabled() {
     const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-    const std::array<bool, Maxwell::Regs::NumClipDistances> reg_state{
-        regs.clip_distance_enabled.c0 != 0, regs.clip_distance_enabled.c1 != 0,
-        regs.clip_distance_enabled.c2 != 0, regs.clip_distance_enabled.c3 != 0,
-        regs.clip_distance_enabled.c4 != 0, regs.clip_distance_enabled.c5 != 0,
-        regs.clip_distance_enabled.c6 != 0, regs.clip_distance_enabled.c7 != 0};
-
-    for (std::size_t i = 0; i < Maxwell::Regs::NumClipDistances; ++i) {
-        state.clip_distance[i] = reg_state[i] && clip_mask[i];
-    }
+    state.clip_distance[0] = regs.clip_distance_enabled.c0 != 0;
+    state.clip_distance[1] = regs.clip_distance_enabled.c1 != 0;
+    state.clip_distance[2] = regs.clip_distance_enabled.c2 != 0;
+    state.clip_distance[3] = regs.clip_distance_enabled.c3 != 0;
+    state.clip_distance[4] = regs.clip_distance_enabled.c4 != 0;
+    state.clip_distance[5] = regs.clip_distance_enabled.c5 != 0;
+    state.clip_distance[6] = regs.clip_distance_enabled.c6 != 0;
+    state.clip_distance[7] = regs.clip_distance_enabled.c7 != 0;
 }
 
 void RasterizerOpenGL::SyncClipCoef() {
-    UNIMPLEMENTED();
+    UNREACHABLE();
 }
 
 void RasterizerOpenGL::SyncCullMode() {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -40,7 +40,6 @@ namespace OpenGL {
 
 struct ScreenInfo;
 struct DrawParameters;
-struct FramebufferCacheKey;
 
 class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 public:
@@ -61,6 +60,20 @@ public:
     bool AccelerateDrawBatch(bool is_indexed) override;
     void UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta) override;
 
+    /// OpenGL shader generated for a given Maxwell register state
+    struct MaxwellShader {
+        /// OpenGL shader resource
+        OGLProgram shader;
+    };
+
+    struct VertexShader {
+        OGLShader shader;
+    };
+
+    struct FragmentShader {
+        OGLShader shader;
+    };
+
     /// Maximum supported size that a constbuffer can have in bytes.
     static constexpr std::size_t MaxConstbufferSize = 0x10000;
     static_assert(MaxConstbufferSize % sizeof(GLvec4) == 0,
@@ -129,8 +142,7 @@ private:
     void SyncViewport(OpenGLState& current_state);
 
     /// Syncs the clip enabled status to match the guest state
-    void SyncClipEnabled(
-        const std::array<bool, Tegra::Engines::Maxwell3D::Regs::NumClipDistances>& clip_mask);
+    void SyncClipEnabled();
 
     /// Syncs the clip coefficients to match the guest state
     void SyncClipCoef();
@@ -181,6 +193,9 @@ private:
     /// but are needed for correct emulation
     void CheckExtensions();
 
+    bool has_ARB_direct_state_access = false;
+    bool has_ARB_multi_bind = false;
+
     OpenGLState state;
 
     RasterizerCacheOpenGL res_cache;
@@ -196,12 +211,11 @@ private:
              OGLVertexArray>
         vertex_array_cache;
 
-    std::map<FramebufferCacheKey, OGLFramebuffer> framebuffer_cache;
-
     std::array<SamplerInfo, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> texture_samplers;
 
     static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
     OGLBufferCache buffer_cache;
+    OGLFramebuffer framebuffer;
     PrimitiveAssembler primitive_assembler{buffer_cache};
     GLint uniform_buffer_alignment;
 
@@ -216,8 +230,6 @@ private:
 
     void SetupShaders(GLenum primitive_mode);
 
-    void SetupCachedFramebuffer(const FramebufferCacheKey& fbkey, OpenGLState& current_state);
-
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw = AccelDraw::Disabled;
 

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -405,6 +405,138 @@ void SwizzleFunc(const MortonSwizzleMode& mode, const SurfaceParams& params,
     }
 }
 
+MICROPROFILE_DEFINE(OpenGL_BlitSurface, "OpenGL", "BlitSurface", MP_RGB(128, 192, 64));
+static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
+                        GLuint read_fb_handle, GLuint draw_fb_handle, GLenum src_attachment = 0,
+                        GLenum dst_attachment = 0, std::size_t cubemap_face = 0) {
+    MICROPROFILE_SCOPE(OpenGL_BlitSurface);
+
+    const auto& src_params{src_surface->GetSurfaceParams()};
+    const auto& dst_params{dst_surface->GetSurfaceParams()};
+
+    OpenGLState prev_state{OpenGLState::GetCurState()};
+    SCOPE_EXIT({ prev_state.Apply(); });
+
+    OpenGLState state;
+    state.draw.read_framebuffer = read_fb_handle;
+    state.draw.draw_framebuffer = draw_fb_handle;
+    // Set sRGB enabled if the destination surfaces need it
+    state.framebuffer_srgb.enabled = dst_params.srgb_conversion;
+    state.ApplyFramebufferState();
+
+    u32 buffers{};
+
+    if (src_params.type == SurfaceType::ColorTexture) {
+        switch (src_params.target) {
+        case SurfaceTarget::Texture2D:
+            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                                   GL_TEXTURE_2D, src_surface->Texture().handle, 0);
+            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                                   0, 0);
+            break;
+        case SurfaceTarget::TextureCubemap:
+            glFramebufferTexture2D(
+                GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face),
+                src_surface->Texture().handle, 0);
+            glFramebufferTexture2D(
+                GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face), 0, 0);
+            break;
+        case SurfaceTarget::Texture2DArray:
+            glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                                      src_surface->Texture().handle, 0, 0);
+            glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, 0, 0, 0);
+            break;
+        case SurfaceTarget::Texture3D:
+            glFramebufferTexture3D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                                   SurfaceTargetToGL(src_params.target),
+                                   src_surface->Texture().handle, 0, 0);
+            glFramebufferTexture3D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                   SurfaceTargetToGL(src_params.target), 0, 0, 0);
+            break;
+        default:
+            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                                   GL_TEXTURE_2D, src_surface->Texture().handle, 0);
+            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                                   0, 0);
+            break;
+        }
+
+        switch (dst_params.target) {
+        case SurfaceTarget::Texture2D:
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                                   GL_TEXTURE_2D, dst_surface->Texture().handle, 0);
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                                   0, 0);
+            break;
+        case SurfaceTarget::TextureCubemap:
+            glFramebufferTexture2D(
+                GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face),
+                dst_surface->Texture().handle, 0);
+            glFramebufferTexture2D(
+                GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubemap_face), 0, 0);
+            break;
+        case SurfaceTarget::Texture2DArray:
+            glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                                      dst_surface->Texture().handle, 0, 0);
+            glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, 0, 0, 0);
+            break;
+
+        case SurfaceTarget::Texture3D:
+            glFramebufferTexture3D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                                   SurfaceTargetToGL(dst_params.target),
+                                   dst_surface->Texture().handle, 0, 0);
+            glFramebufferTexture3D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                   SurfaceTargetToGL(dst_params.target), 0, 0, 0);
+            break;
+        default:
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                                   GL_TEXTURE_2D, dst_surface->Texture().handle, 0);
+            glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                                   0, 0);
+            break;
+        }
+
+        buffers = GL_COLOR_BUFFER_BIT;
+    } else if (src_params.type == SurfaceType::Depth) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                               GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
+                               src_surface->Texture().handle, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                               GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
+                               dst_surface->Texture().handle, 0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+
+        buffers = GL_DEPTH_BUFFER_BIT;
+    } else if (src_params.type == SurfaceType::DepthStencil) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + src_attachment,
+                               GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                               src_surface->Texture().handle, 0);
+
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + dst_attachment,
+                               GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                               dst_surface->Texture().handle, 0);
+
+        buffers = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+    }
+
+    const auto& rect{src_params.GetRect()};
+    glBlitFramebuffer(rect.left, rect.bottom, rect.right, rect.top, rect.left, rect.bottom,
+                      rect.right, rect.top, buffers,
+                      buffers == GL_COLOR_BUFFER_BIT ? GL_LINEAR : GL_NEAREST);
+
+    return true;
+}
+
 static void FastCopySurface(const Surface& src_surface, const Surface& dst_surface) {
     const auto& src_params{src_surface->GetSurfaceParams()};
     const auto& dst_params{dst_surface->GetSurfaceParams()};
@@ -709,10 +841,9 @@ void CachedSurface::LoadGLBuffer() {
         const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
         gl_buffer[0].assign(texture_src_data, texture_src_data_end);
     }
-    for (u32 i = 0; i < params.max_mip_level; i++) {
+    for (u32 i = 0; i < params.max_mip_level; i++)
         ConvertFormatAsNeeded_LoadGLBuffer(gl_buffer[i], params.pixel_format, params.MipWidth(i),
                                            params.MipHeight(i), params.MipDepth(i));
-    }
 }
 
 MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
@@ -1032,10 +1163,7 @@ void RasterizerCacheOpenGL::AccurateCopySurface(const Surface& src_surface,
                                                 const Surface& dst_surface) {
     const auto& src_params{src_surface->GetSurfaceParams()};
     const auto& dst_params{dst_surface->GetSurfaceParams()};
-
-    // Flush enough memory for both the source and destination surface
-    FlushRegion(src_params.addr, std::max(src_params.MemorySize(), dst_params.MemorySize()));
-
+    FlushRegion(src_params.addr, dst_params.MemorySize());
     LoadSurface(dst_surface);
 }
 
@@ -1061,9 +1189,20 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
         return new_surface;
     }
 
+    // If the format is the same, just do a framebuffer blit. This is significantly faster than
+    // using PBOs. The is also likely less accurate, as textures will be converted rather than
+    // reinterpreted. When use_accurate_gpu_emulation setting is enabled, perform a more accurate
+    // surface copy, where pixels are reinterpreted as a new format (without conversion). This
+    // code path uses OpenGL PBOs and is quite slow.
+    const bool is_blit{old_params.pixel_format == new_params.pixel_format};
+
     switch (new_params.target) {
     case SurfaceTarget::Texture2D:
-        CopySurface(old_surface, new_surface, copy_pbo.handle);
+        if (is_blit) {
+            BlitSurface(old_surface, new_surface, read_framebuffer.handle, draw_framebuffer.handle);
+        } else {
+            CopySurface(old_surface, new_surface, copy_pbo.handle);
+        }
         break;
     case SurfaceTarget::Texture3D:
         AccurateCopySurface(old_surface, new_surface);

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -2,9 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <boost/functional/hash.hpp>
 #include "common/assert.h"
-#include "common/hash.h"
 #include "core/core.h"
 #include "core/memory.h"
 #include "video_core/engines/maxwell_3d.h"
@@ -68,17 +66,14 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
         // stage here.
         setup.SetProgramB(GetShaderCode(GetShaderAddress(Maxwell::ShaderProgram::VertexB)));
     case Maxwell::ShaderProgram::VertexB:
-        CalculateProperties();
         program_result = GLShader::GenerateVertexShader(setup);
         gl_type = GL_VERTEX_SHADER;
         break;
     case Maxwell::ShaderProgram::Geometry:
-        CalculateProperties();
         program_result = GLShader::GenerateGeometryShader(setup);
         gl_type = GL_GEOMETRY_SHADER;
         break;
     case Maxwell::ShaderProgram::Fragment:
-        CalculateProperties();
         program_result = GLShader::GenerateFragmentShader(setup);
         gl_type = GL_FRAGMENT_SHADER;
         break;
@@ -145,46 +140,6 @@ GLuint CachedShader::LazyGeometryProgram(OGLProgram& target_program,
     return target_program.handle;
 };
 
-static bool IsSchedInstruction(u32 offset, u32 main_offset) {
-    // sched instructions appear once every 4 instructions.
-    static constexpr std::size_t SchedPeriod = 4;
-    const std::size_t absolute_offset = offset - main_offset;
-    return (absolute_offset % SchedPeriod) == 0;
-}
-
-static std::size_t CalculateProgramSize(const GLShader::ProgramCode& program) {
-    const std::size_t start_offset = 10;
-    std::size_t offset = start_offset;
-    std::size_t size = start_offset * sizeof(u64);
-    while (offset < program.size()) {
-        const u64 inst = program[offset];
-        if (!IsSchedInstruction(offset, start_offset)) {
-            if (inst == 0 || (inst >> 52) == 0x50b) {
-                break;
-            }
-        }
-        size += 8;
-        offset++;
-    }
-    return size;
-}
-
-void CachedShader::CalculateProperties() {
-    setup.program.real_size = CalculateProgramSize(setup.program.code);
-    setup.program.real_size_b = 0;
-    setup.program.unique_identifier = Common::CityHash64(
-        reinterpret_cast<const char*>(setup.program.code.data()), setup.program.real_size);
-    if (program_type == Maxwell::ShaderProgram::VertexA) {
-        std::size_t seed = 0;
-        boost::hash_combine(seed, setup.program.unique_identifier);
-        setup.program.real_size_b = CalculateProgramSize(setup.program.code_b);
-        const u64 identifier_b = Common::CityHash64(
-            reinterpret_cast<const char*>(setup.program.code_b.data()), setup.program.real_size_b);
-        boost::hash_combine(seed, identifier_b);
-        setup.program.unique_identifier = static_cast<u64>(seed);
-    }
-}
-
 ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer) : RasterizerCache{rasterizer} {}
 
 Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {