Remove unnessesary nullptr checks

Merge pull request #1584 from FearlessTobi/patch-3
Delete git file
2018-10-25 23:37:36 +02:00 · 2018-10-25 13:55:10 -06:00 · 2018-10-25 21:53:41 +02:00 · 2018-10-25 12:22:57 -04:00 · 2018-10-25 12:22:10 -04:00 · 2018-10-25 01:10:26 -04:00
91 changed files with 1845 additions and 740 deletions
@@ -23,21 +23,21 @@ option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)

-if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
+if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
    message(STATUS "Copying pre-commit hook")
    file(COPY hooks/pre-commit
-        DESTINATION ${CMAKE_SOURCE_DIR}/.git/hooks)
+        DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
 endif()

 # Sanity check : Check that all submodules are present
 # =======================================================================

 function(check_submodules_present)
-    file(READ "${CMAKE_SOURCE_DIR}/.gitmodules" gitmodules)
+    file(READ "${PROJECT_SOURCE_DIR}/.gitmodules" gitmodules)
    string(REGEX MATCHALL "path *= *[^ \t\r\n]*" gitmodules ${gitmodules})
    foreach(module ${gitmodules})
        string(REGEX REPLACE "path *= *" "" module ${module})
-        if (NOT EXISTS "${CMAKE_SOURCE_DIR}/${module}/.git")
+        if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
            message(FATAL_ERROR "Git submodule ${module} not found. "
                    "Please run: git submodule update --init --recursive")
        endif()
@@ -45,17 +45,17 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()

-configure_file(${CMAKE_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
-               ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
+configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
+               ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
               COPYONLY)
-if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
    message(STATUS "Downloading compatibility list for yuzu...")
    file(DOWNLOAD
        https://api.yuzu-emu.org/gamedb/
-        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
+        "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
 endif()
-if (NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    file(WRITE ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+    file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
 endif()

 # Detect current compilation architecture and create standard definitions
@@ -185,13 +185,13 @@ find_package(Boost 1.63.0 QUIET)
 if (NOT Boost_FOUND)
    message(STATUS "Boost 1.63.0 or newer not found, falling back to externals")

-    set(BOOST_ROOT "${CMAKE_SOURCE_DIR}/externals/boost")
+    set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
    set(Boost_NO_SYSTEM_PATHS OFF)
    find_package(Boost QUIET REQUIRED)
 endif()

 # Output binaries to bin/
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)

 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -260,7 +260,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
        endif()

        set(UNICORN_FOUND YES)
-        set(UNICORN_PREFIX ${CMAKE_SOURCE_DIR}/externals/unicorn)
+        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
@@ -352,12 +352,12 @@ set(CLANG_FORMAT_POSTFIX "-6.0")
 find_program(CLANG_FORMAT
    NAMES clang-format${CLANG_FORMAT_POSTFIX}
          clang-format
-    PATHS ${CMAKE_BINARY_DIR}/externals)
+    PATHS ${PROJECT_BINARY_DIR}/externals)
 # if find_program doesn't find it, try to download from externals
 if (NOT CLANG_FORMAT)
    if (WIN32)
        message(STATUS "Clang format not found! Downloading...")
-        set(CLANG_FORMAT "${CMAKE_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
+        set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
        file(DOWNLOAD
            https://github.com/yuzu-emu/ext-windows-bin/raw/master/clang-format${CLANG_FORMAT_POSTFIX}.exe
            "${CLANG_FORMAT}" SHOW_PROGRESS
@@ -373,7 +373,7 @@ if (NOT CLANG_FORMAT)
 endif()

 if (CLANG_FORMAT)
-    set(SRCS ${CMAKE_SOURCE_DIR}/src)
+    set(SRCS ${PROJECT_SOURCE_DIR}/src)
    set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
    if (WIN32)
        add_custom_target(clang-format
@@ -446,10 +446,10 @@ endif()
 # http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
 # http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html
 if(ENABLE_QT AND UNIX AND NOT APPLE)
-    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.desktop"
+    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.desktop"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
-    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.svg"
+    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.svg"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
-    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
+    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.xml"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 endif()
@@ -10,8 +10,7 @@

 namespace AudioCore {

-TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count)
-    : m_sample_rate(sample_rate), m_channel_count(channel_count) {
+TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count) : m_sample_rate{sample_rate} {
    m_sound_touch.setChannels(channel_count);
    m_sound_touch.setSampleRate(sample_rate);
    m_sound_touch.setPitch(1.0);
@@ -27,7 +27,6 @@ public:

 private:
    u32 m_sample_rate;
-    u32 m_channel_count;
    soundtouch::SoundTouch m_sound_touch;
    double m_stretch_ratio = 1.0;
 };
@@ -196,6 +196,7 @@ void FileBackend::Write(const Entry& entry) {
    SUB(Service, NFP)                                                                              \
    SUB(Service, NIFM)                                                                             \
    SUB(Service, NIM)                                                                              \
+    SUB(Service, NPNS)                                                                             \
    SUB(Service, NS)                                                                               \
    SUB(Service, NVDRV)                                                                            \
    SUB(Service, PCIE)                                                                             \
@@ -204,10 +205,12 @@ void FileBackend::Write(const Entry& entry) {
    SUB(Service, PM)                                                                               \
    SUB(Service, PREPO)                                                                            \
    SUB(Service, PSC)                                                                              \
+    SUB(Service, PSM)                                                                              \
    SUB(Service, SET)                                                                              \
    SUB(Service, SM)                                                                               \
    SUB(Service, SPL)                                                                              \
    SUB(Service, SSL)                                                                              \
+    SUB(Service, TCAP)                                                                             \
    SUB(Service, Time)                                                                             \
    SUB(Service, USB)                                                                              \
    SUB(Service, VI)                                                                               \
@@ -83,6 +83,7 @@ enum class Class : ClassType {
    Service_NFP,       ///< The NFP service
    Service_NIFM,      ///< The NIFM (Network interface) service
    Service_NIM,       ///< The NIM service
+    Service_NPNS,      ///< The NPNS service
    Service_NS,        ///< The NS services
    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
    Service_PCIE,      ///< The PCIe service
@@ -96,6 +97,7 @@ enum class Class : ClassType {
    Service_SM,        ///< The SM (Service manager) service
    Service_SPL,       ///< The SPL service
    Service_SSL,       ///< The SSL service
+    Service_TCAP,      ///< The TCAP service.
    Service_Time,      ///< The time service
    Service_USB,       ///< The USB (Universal Serial Bus) service
    Service_VI,        ///< The VI (Video interface) service
@@ -133,7 +133,7 @@ struct System::Impl {
        kernel.Initialize();

        // Create a default fs if one doesn't already exist.
-        if (virtual_filesystem == nullptr)
+        if (virtual_filesystem)
            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();

        auto main_process = Kernel::Process::Create(kernel, "main");
@@ -259,7 +259,7 @@ struct System::Impl {
    }

    Loader::ResultStatus GetGameName(std::string& out) const {
-        if (app_loader == nullptr)
+        if (app_loader)
            return Loader::ResultStatus::ErrorNotInitialized;
        return app_loader->ReadTitle(out);
    }
@@ -88,7 +88,7 @@ void Cpu::RunLoop(bool tight_loop) {

    // If we don't have a currently active thread then don't execute instructions,
    // instead advance to the next event and try to yield to the next thread
-    if (Kernel::GetCurrentThread() == nullptr) {
+    if (Kernel::GetCurrentThread()) {
        LOG_TRACE(Core, "Core-{} idling", core_index);

        if (IsMainCore()) {
@@ -713,7 +713,6 @@ void KeyManager::DeriveBase() {

    const auto sbk = GetKey(S128KeyType::SecureBoot);
    const auto tsec = GetKey(S128KeyType::TSEC);
-    const auto master_source = GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::Master));

    for (size_t i = 0; i < revisions.size(); ++i) {
        if (!revisions[i])
@@ -798,15 +797,15 @@ void KeyManager::DeriveETicket(PartitionDataManager& data) {
    const auto es = Service::FileSystem::GetUnionContents()->GetEntry(
        0x0100000000000033, FileSys::ContentRecordType::Program);

-    if (es == nullptr)
+    if (es)
        return;

    const auto exefs = es->GetExeFS();
-    if (exefs == nullptr)
+    if (exefs)
        return;

    const auto main = exefs->GetFile("main");
-    if (main == nullptr)
+    if (main)
        return;

    const auto bytes = main->ReadAllBytes();
@@ -316,11 +316,9 @@ PartitionDataManager::PartitionDataManager(const FileSys::VirtualDir& sysdata_di
      prodinfo(FindFileInDirWithNames(sysdata_dir, "PRODINFO")),
      secure_monitor(FindFileInDirWithNames(sysdata_dir, "secmon")),
      package1_decrypted(FindFileInDirWithNames(sysdata_dir, "pkg1_decr")),
-      secure_monitor_bytes(secure_monitor == nullptr ? std::vector<u8>{}
-                                                     : secure_monitor->ReadAllBytes()),
-      package1_decrypted_bytes(package1_decrypted == nullptr ? std::vector<u8>{}
-                                                             : package1_decrypted->ReadAllBytes()) {
-}
+      secure_monitor_bytes(secure_monitor ? std::vector<u8>{} : secure_monitor->ReadAllBytes()),
+      package1_decrypted_bytes(package1_decrypted ? std::vector<u8>{}
+                                                  : package1_decrypted->ReadAllBytes()) {}

 PartitionDataManager::~PartitionDataManager() = default;

@@ -579,7 +577,7 @@ FileSys::VirtualFile PartitionDataManager::GetProdInfoRaw() const {
 }

 void PartitionDataManager::DecryptProdInfo(std::array<u8, 0x20> bis_key) {
-    if (prodinfo == nullptr)
+    if (prodinfo)
        return;

    prodinfo_decrypted = std::make_shared<XTSEncryptionLayer>(prodinfo, bis_key);
@@ -173,7 +173,7 @@ bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
 }

 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
-    if (partitions[static_cast<std::size_t>(part)] == nullptr) {
+    if (partitions[static_cast<std::size_t>(part)]) {
        return Loader::ResultStatus::ErrorXCIMissingPartition;
    }

@@ -201,6 +201,6 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
 }

 u8 XCI::GetFormatVersion() const {
-    return GetLogoPartition() == nullptr ? 0x1 : 0x2;
+    return GetLogoPartition() ? 0x1 : 0x2;
 }
 } // namespace FileSys
@@ -104,7 +104,7 @@ static bool IsValidNCA(const NCAHeader& header) {

 NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)) {
-    if (file == nullptr) {
+    if (file) {
        status = Loader::ResultStatus::ErrorNullFile;
        return;
    }
@@ -231,7 +231,7 @@ bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTabl
    auto raw = std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset);
    auto dec = Decrypt(section, raw, romfs_offset);

-    if (dec == nullptr) {
+    if (dec) {
        if (status != Loader::ResultStatus::Success)
            return false;
        if (has_rights_id)
@@ -324,7 +324,7 @@ bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTabl
            }
        }

-        if (bktr_base_romfs == nullptr) {
+        if (bktr_base_romfs) {
            status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
            return false;
        }
@@ -300,8 +300,7 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
        RomFSFileEntry cur_entry{};

        cur_entry.parent = cur_file->parent->entry_offset;
-        cur_entry.sibling =
-            cur_file->sibling == nullptr ? ROMFS_ENTRY_EMPTY : cur_file->sibling->entry_offset;
+        cur_entry.sibling = cur_file->sibling ? ROMFS_ENTRY_EMPTY : cur_file->sibling->entry_offset;
        cur_entry.offset = cur_file->offset;
        cur_entry.size = cur_file->size;

@@ -327,11 +326,9 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
        RomFSDirectoryEntry cur_entry{};

        cur_entry.parent = cur_dir == root ? 0 : cur_dir->parent->entry_offset;
-        cur_entry.sibling =
-            cur_dir->sibling == nullptr ? ROMFS_ENTRY_EMPTY : cur_dir->sibling->entry_offset;
-        cur_entry.child =
-            cur_dir->child == nullptr ? ROMFS_ENTRY_EMPTY : cur_dir->child->entry_offset;
-        cur_entry.file = cur_dir->file == nullptr ? ROMFS_ENTRY_EMPTY : cur_dir->file->entry_offset;
+        cur_entry.sibling = cur_dir->sibling ? ROMFS_ENTRY_EMPTY : cur_dir->sibling->entry_offset;
+        cur_entry.child = cur_dir->child ? ROMFS_ENTRY_EMPTY : cur_dir->child->entry_offset;
+        cur_entry.file = cur_dir->file ? ROMFS_ENTRY_EMPTY : cur_dir->file->entry_offset;

        const auto name_size = cur_dir->path_len - cur_dir->cur_path_ofs;
        const auto hash = romfs_calc_path_hash(cur_dir == root ? 0 : cur_dir->parent->entry_offset,
@@ -66,7 +66,7 @@ static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
 }

 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
-    if (in == nullptr || ips == nullptr)
+    if (in || ips)
        return nullptr;

    const auto type = IdentifyMagic(ips->ReadBytes(0x5));
@@ -311,7 +311,7 @@ void IPSwitchCompiler::Parse() {
 }

 VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
-    if (in == nullptr || !valid)
+    if (in || !valid)
        return nullptr;

    auto in_data = in->ReadAllBytes();
@@ -53,7 +53,7 @@ PatchManager::~PatchManager() = default;
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);

-    if (exefs == nullptr)
+    if (exefs)
        return exefs;

    const auto installed = Service::FileSystem::GetUnionContents();
@@ -168,12 +168,13 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {

 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if (type != ContentRecordType::Program || load_dir == nullptr || load_dir->GetSize() <= 0) {
+    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) || load_dir ||
+        load_dir->GetSize() <= 0) {
        return;
    }

    auto extracted = ExtractRomFS(romfs);
-    if (extracted == nullptr) {
+    if (extracted) {
        return;
    }

@@ -197,14 +198,14 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
    layers.push_back(std::move(extracted));

    auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
-    if (layered == nullptr) {
+    if (layered) {
        return;
    }

    auto layered_ext = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers_ext));

    auto packed = CreateRomFS(std::move(layered), std::move(layered_ext));
-    if (packed == nullptr) {
+    if (packed) {
        return;
    }

@@ -218,12 +219,12 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
                                        title_id, static_cast<u8>(type))
                                .c_str();

-    if (type == ContentRecordType::Program)
+    if (type == ContentRecordType::Program || type == ContentRecordType::Data)
        LOG_INFO(Loader, log_string);
    else
        LOG_DEBUG(Loader, log_string);

-    if (romfs == nullptr)
+    if (romfs)
        return romfs;

    const auto installed = Service::FileSystem::GetUnionContents();
@@ -355,7 +356,7 @@ std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata()
    const auto installed{Service::FileSystem::GetUnionContents()};

    const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
-    if (base_control_nca == nullptr)
+    if (base_control_nca)
        return {};

    return ParseControlNCA(*base_control_nca);
@@ -363,22 +364,22 @@ std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata()

 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(const NCA& nca) const {
    const auto base_romfs = nca.GetRomFS();
-    if (base_romfs == nullptr)
+    if (base_romfs)
        return {};

    const auto romfs = PatchRomFS(base_romfs, nca.GetBaseIVFCOffset(), ContentRecordType::Control);
-    if (romfs == nullptr)
+    if (romfs)
        return {};

    const auto extracted = ExtractRomFS(romfs);
-    if (extracted == nullptr)
+    if (extracted)
        return {};

    auto nacp_file = extracted->GetFile("control.nacp");
-    if (nacp_file == nullptr)
+    if (nacp_file)
        nacp_file = extracted->GetFile("Control.nacp");

-    auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
+    auto nacp = nacp_file ? nullptr : std::make_unique<NACP>(nacp_file);

    VirtualFile icon_file;
    for (const auto& language : FileSys::LANGUAGE_NAMES) {
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
@@ -30,6 +31,14 @@ bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs)
    return (lhs.title_id < rhs.title_id) || (lhs.title_id == rhs.title_id && lhs.type < rhs.type);
 }

+bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
+    return std::tie(lhs.title_id, lhs.type) == std::tie(rhs.title_id, rhs.type);
+}
+
+bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
+    return !operator==(lhs, rhs);
+}
+
 static bool FollowsTwoDigitDirFormat(std::string_view name) {
    static const std::regex two_digit_regex("000000[0-9A-F]{2}", std::regex_constants::ECMAScript |
                                                                     std::regex_constants::icase);
@@ -214,7 +223,7 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
    for (const auto& id : ids) {
        const auto file = GetFileAtID(id);

-        if (file == nullptr)
+        if (file)
            continue;
        const auto nca = std::make_shared<NCA>(parser(file, id));
        if (nca->GetStatus() != Loader::ResultStatus::Success ||
@@ -237,7 +246,7 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {

 void RegisteredCache::AccumulateYuzuMeta() {
    const auto dir = this->dir->GetSubdirectory("yuzu_meta");
-    if (dir == nullptr)
+    if (dir)
        return;

    for (const auto& file : dir->GetFiles()) {
@@ -250,7 +259,7 @@ void RegisteredCache::AccumulateYuzuMeta() {
 }

 void RegisteredCache::Refresh() {
-    if (dir == nullptr)
+    if (dir)
        return;
    const auto ids = AccumulateFiles();
    ProcessFiles(ids);
@@ -310,7 +319,7 @@ VirtualFile RegisteredCache::GetEntryRaw(RegisteredCacheEntry entry) const {

 std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType type) const {
    const auto raw = GetEntryRaw(title_id, type);
-    if (raw == nullptr)
+    if (raw)
        return nullptr;
    return std::make_unique<NCA>(raw);
 }
@@ -377,7 +386,7 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(

 static std::shared_ptr<NCA> GetNCAFromNSPForID(std::shared_ptr<NSP> nsp, const NcaID& id) {
    const auto file = nsp->GetFile(fmt::format("{}.nca", Common::HexArrayToString(id, false)));
-    if (file == nullptr)
+    if (file)
        return nullptr;
    return std::make_shared<NCA>(file);
 }
@@ -414,7 +423,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overw
    const CNMT cnmt(cnmt_file);
    for (const auto& record : cnmt.GetContentRecords()) {
        const auto nca = GetNCAFromNSPForID(nsp, record.nca_id);
-        if (nca == nullptr)
+        if (nca)
            return InstallResult::ErrorCopyFailed;
        const auto res2 = RawInstallNCA(nca, copy, overwrite_if_exists, record.nca_id);
        if (res2 != InstallResult::Success)
@@ -482,7 +491,7 @@ InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const Vfs
    }

    auto out = dir->CreateFileRelative(path);
-    if (out == nullptr)
+    if (out)
        return InstallResult::ErrorCopyFailed;
    return copy(in, out, VFS_RC_LARGE_COPY_BLOCK) ? InstallResult::Success
                                                  : InstallResult::ErrorCopyFailed;
@@ -492,7 +501,7 @@ bool RegisteredCache::RawInstallYuzuMeta(const CNMT& cnmt) {
    // Reasoning behind this method can be found in the comment for InstallEntry, NCA overload.
    const auto dir = this->dir->CreateDirectoryRelative("yuzu_meta");
    const auto filename = GetCNMTName(cnmt.GetType(), cnmt.GetTitleID());
-    if (dir->GetFile(filename) == nullptr) {
+    if (dir->GetFile(filename)) {
        auto out = dir->CreateFile(filename);
        const auto buffer = cnmt.Serialize();
        out->Resize(buffer.size());
@@ -574,7 +583,7 @@ VirtualFile RegisteredCacheUnion::GetEntryRaw(RegisteredCacheEntry entry) const

 std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(u64 title_id, ContentRecordType type) const {
    const auto raw = GetEntryRaw(title_id, type);
-    if (raw == nullptr)
+    if (raw)
        return nullptr;
    return std::make_unique<NCA>(raw);
 }
@@ -593,6 +602,9 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
            },
            [](const CNMT& c, const ContentRecord& r) { return true; });
    }
+
+    std::sort(out.begin(), out.end());
+    out.erase(std::unique(out.begin(), out.end()), out.end());
    return out;
 }

@@ -616,6 +628,9 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
                return true;
            });
    }
+
+    std::sort(out.begin(), out.end());
+    out.erase(std::unique(out.begin(), out.end()), out.end());
    return out;
 }
 } // namespace FileSys
@@ -50,6 +50,10 @@ constexpr u64 GetUpdateTitleID(u64 base_title_id) {
 // boost flat_map requires operator< for O(log(n)) lookups.
 bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);

+// std unique requires operator== to identify duplicates.
+bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
+bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
+
 /*
 * A class that catalogues NCAs in the registered directory structure.
 * Nintendo's registered format follows this structure:
@@ -60,8 +64,8 @@ bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs)
 *         | 00
 *         | 01 <- Actual content split along 4GB boundaries. (optional)
 *
- * (This impl also supports substituting the nca dir for an nca file, as that's more convenient when
- * 4GB splitting can be ignored.)
+ * (This impl also supports substituting the nca dir for an nca file, as that's more convenient
+ * when 4GB splitting can be ignored.)
 */
 class RegisteredCache {
    friend class RegisteredCacheUnion;
@@ -130,7 +130,7 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
 }

 VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
-    if (dir == nullptr)
+    if (dir)
        return nullptr;

    RomFSBuildContext ctx{dir, ext};
@@ -63,12 +63,12 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, Conte
        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
    }

-    if (res == nullptr) {
+    if (res) {
        // TODO(DarkLordZach): Find the right error code to use here
        return ResultCode(-1);
    }
    const auto romfs = res->GetRomFS();
-    if (romfs == nullptr) {
+    if (romfs) {
        // TODO(DarkLordZach): Find the right error code to use here
        return ResultCode(-1);
    }
@@ -66,7 +66,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr

    auto out = dir->GetDirectoryRelative(save_directory);

-    if (out == nullptr) {
+    if (out) {
        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
        // already exist. This is a hack, as we do not understand yet how this works on hardware.
        // Without a save data directory, many games will assert on boot. This should not have any
@@ -75,7 +75,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
    }

    // Return an error if the save data doesn't actually exist.
-    if (out == nullptr) {
+    if (out) {
        // TODO(Subv): Find out correct error code.
        return ResultCode(-1);
    }
@@ -23,7 +23,7 @@ void SetTicketKeys(const std::vector<VirtualFile>& files) {
    Core::Crypto::KeyManager keys;

    for (const auto& ticket_file : files) {
-        if (ticket_file == nullptr) {
+        if (ticket_file) {
            continue;
        }

@@ -176,9 +176,8 @@ std::vector<Core::Crypto::Key128> NSP::GetTitlekey() const {
        LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
    std::vector<Core::Crypto::Key128> out;
    for (const auto& ticket_file : ticket_files) {
-        if (ticket_file == nullptr ||
-            ticket_file->GetSize() <
-                Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET + sizeof(Core::Crypto::Key128)) {
+        if (ticket_file || ticket_file->GetSize() < Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET +
+                                                        sizeof(Core::Crypto::Key128)) {
            continue;
        }

@@ -248,7 +247,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
            for (const auto& rec : cnmt.GetContentRecords()) {
                const auto id_string = Common::HexArrayToString(rec.nca_id, false);
                const auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
-                if (next_file == nullptr) {
+                if (next_file) {
                    LOG_WARNING(Service_FS,
                                "NCA with ID {}.nca is listed in content metadata, but cannot "
                                "be found in PFS. NSP appears to be corrupted.",
@@ -62,13 +62,13 @@ VirtualFile VfsFilesystem::CopyFile(std::string_view old_path_, std::string_view

    // Do it using RawCopy. Non-default impls are encouraged to optimize this.
    const auto old_file = OpenFile(old_path, Mode::Read);
-    if (old_file == nullptr)
+    if (old_file)
        return nullptr;
    auto new_file = OpenFile(new_path, Mode::Read);
    if (new_file != nullptr)
        return nullptr;
    new_file = CreateFile(new_path, Mode::Write);
-    if (new_file == nullptr)
+    if (new_file)
        return nullptr;
    if (!VfsRawCopy(old_file, new_file))
        return nullptr;
@@ -81,7 +81,7 @@ VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view

    // Again, non-default impls are highly encouraged to provide a more optimized version of this.
    auto out = CopyFile(sanitized_old_path, sanitized_new_path);
-    if (out == nullptr)
+    if (out)
        return nullptr;
    if (DeleteFile(sanitized_old_path))
        return out;
@@ -91,7 +91,7 @@ VirtualFile VfsFilesystem::MoveFile(std::string_view old_path, std::string_view
 bool VfsFilesystem::DeleteFile(std::string_view path_) {
    const auto path = FileUtil::SanitizePath(path_);
    auto parent = OpenDirectory(FileUtil::GetParentPath(path), Mode::Write);
-    if (parent == nullptr)
+    if (parent)
        return false;
    return parent->DeleteFile(FileUtil::GetFilename(path));
 }
@@ -112,26 +112,26 @@ VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_

    // Non-default impls are highly encouraged to provide a more optimized version of this.
    auto old_dir = OpenDirectory(old_path, Mode::Read);
-    if (old_dir == nullptr)
+    if (old_dir)
        return nullptr;
    auto new_dir = OpenDirectory(new_path, Mode::Read);
    if (new_dir != nullptr)
        return nullptr;
    new_dir = CreateDirectory(new_path, Mode::Write);
-    if (new_dir == nullptr)
+    if (new_dir)
        return nullptr;

    for (const auto& file : old_dir->GetFiles()) {
        const auto x =
            CopyFile(old_path + DIR_SEP + file->GetName(), new_path + DIR_SEP + file->GetName());
-        if (x == nullptr)
+        if (x)
            return nullptr;
    }

    for (const auto& dir : old_dir->GetSubdirectories()) {
        const auto x =
            CopyDirectory(old_path + DIR_SEP + dir->GetName(), new_path + DIR_SEP + dir->GetName());
-        if (x == nullptr)
+        if (x)
            return nullptr;
    }

@@ -144,7 +144,7 @@ VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_v

    // Non-default impls are highly encouraged to provide a more optimized version of this.
    auto out = CopyDirectory(sanitized_old_path, sanitized_new_path);
-    if (out == nullptr)
+    if (out)
        return nullptr;
    if (DeleteDirectory(sanitized_old_path))
        return out;
@@ -154,7 +154,7 @@ VirtualDir VfsFilesystem::MoveDirectory(std::string_view old_path, std::string_v
 bool VfsFilesystem::DeleteDirectory(std::string_view path_) {
    const auto path = FileUtil::SanitizePath(path_);
    auto parent = OpenDirectory(FileUtil::GetParentPath(path), Mode::Write);
-    if (parent == nullptr)
+    if (parent)
        return false;
    return parent->DeleteSubdirectoryRecursive(FileUtil::GetFilename(path));
 }
@@ -196,7 +196,7 @@ std::size_t VfsFile::WriteBytes(const std::vector<u8>& data, std::size_t offset)
 }

 std::string VfsFile::GetFullPath() const {
-    if (GetContainingDirectory() == nullptr)
+    if (GetContainingDirectory())
        return "/" + GetName();

    return GetContainingDirectory()->GetFullPath() + "/" + GetName();
@@ -216,14 +216,14 @@ std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(std::string_view path) co

    auto dir = GetSubdirectory(vec[0]);
    for (std::size_t component = 1; component < vec.size() - 1; ++component) {
-        if (dir == nullptr) {
+        if (dir) {
            return nullptr;
        }

        dir = dir->GetSubdirectory(vec[component]);
    }

-    if (dir == nullptr) {
+    if (dir) {
        return nullptr;
    }

@@ -250,7 +250,7 @@ std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(std::string_vie

    auto dir = GetSubdirectory(vec[0]);
    for (std::size_t component = 1; component < vec.size(); ++component) {
-        if (dir == nullptr) {
+        if (dir) {
            return nullptr;
        }

@@ -283,7 +283,7 @@ std::shared_ptr<VfsDirectory> VfsDirectory::GetSubdirectory(std::string_view nam
 }

 bool VfsDirectory::IsRoot() const {
-    return GetParentDirectory() == nullptr;
+    return GetParentDirectory().get();
 }

 std::size_t VfsDirectory::GetSize() const {
@@ -313,9 +313,9 @@ std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(std::string_view path)
    }

    auto dir = GetSubdirectory(vec[0]);
-    if (dir == nullptr) {
+    if (dir) {
        dir = CreateSubdirectory(vec[0]);
-        if (dir == nullptr) {
+        if (dir) {
            return nullptr;
        }
    }
@@ -344,9 +344,9 @@ std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(std::string_
    }

    auto dir = GetSubdirectory(vec[0]);
-    if (dir == nullptr) {
+    if (dir) {
        dir = CreateSubdirectory(vec[0]);
-        if (dir == nullptr) {
+        if (dir) {
            return nullptr;
        }
    }
@@ -364,7 +364,7 @@ std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryAbsolute(std::string_

 bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
    auto dir = GetSubdirectory(name);
-    if (dir == nullptr) {
+    if (dir) {
        return false;
    }

@@ -387,7 +387,7 @@ bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
 bool VfsDirectory::Copy(std::string_view src, std::string_view dest) {
    const auto f1 = GetFile(src);
    auto f2 = CreateFile(dest);
-    if (f1 == nullptr || f2 == nullptr) {
+    if (f1 || f2) {
        return false;
    }

@@ -464,7 +464,7 @@ bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, std::size_t
 }

 bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t block_size) {
-    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
+    if (src || dest || !src->IsReadable() || !dest->IsWritable())
        return false;
    if (!dest->Resize(src->GetSize()))
        return false;
@@ -472,17 +472,21 @@ bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t blo
    std::vector<u8> temp(std::min(block_size, src->GetSize()));
    for (std::size_t i = 0; i < src->GetSize(); i += block_size) {
        const auto read = std::min(block_size, src->GetSize() - i);
-        const auto block = src->Read(temp.data(), read, i);

-        if (dest->Write(temp.data(), read, i) != read)
+        if (src->Read(temp.data(), read, i) != read) {
            return false;
+        }
+
+        if (dest->Write(temp.data(), read, i) != read) {
+            return false;
+        }
    }

    return true;
 }

 bool VfsRawCopyD(const VirtualDir& src, const VirtualDir& dest, std::size_t block_size) {
-    if (src == nullptr || dest == nullptr || !src->IsReadable() || !dest->IsWritable())
+    if (src || dest || !src->IsReadable() || !dest->IsWritable())
        return false;

    for (const auto& file : src->GetFiles()) {
@@ -502,7 +506,7 @@ bool VfsRawCopyD(const VirtualDir& src, const VirtualDir& dest, std::size_t bloc

 VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path) {
    const auto res = rel->GetDirectoryRelative(path);
-    if (res == nullptr)
+    if (res)
        return rel->CreateDirectoryRelative(path);
    return res;
 }
@@ -270,7 +270,7 @@ public:
    bool InterpretAsDirectory(std::string_view file) {
        auto file_p = GetFile(file);

-        if (file_p == nullptr) {
+        if (file_p) {
            return false;
        }

@@ -280,7 +280,7 @@ public:
    bool InterpretAsDirectory(const std::function<VirtualDir(VirtualFile)>& function,
                              const std::string& file) {
        auto file_p = GetFile(file);
-        if (file_p == nullptr)
+        if (file_p)
            return false;
        return ReplaceFileWithSubdirectory(file_p, function(file_p));
    }
@@ -12,7 +12,7 @@ namespace FileSys {
 OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, std::size_t size_, std::size_t offset_,
                             std::string name_, VirtualDir parent_)
    : file(file_), offset(offset_), size(size_), name(std::move(name_)),
-      parent(parent_ == nullptr ? file->GetContainingDirectory() : std::move(parent_)) {}
+      parent(parent_ ? file->GetContainingDirectory() : std::move(parent_)) {}

 OffsetVfsFile::~OffsetVfsFile() = default;

@@ -14,11 +14,6 @@ namespace IPC {
 /// Size of the command buffer area, in 32-bit words.
 constexpr std::size_t COMMAND_BUFFER_LENGTH = 0x100 / sizeof(u32);

-// These errors are commonly returned by invalid IPC translations, so alias them here for
-// convenience.
-// TODO(yuriks): These will probably go away once translation is implemented inside the kernel.
-constexpr auto ERR_INVALID_HANDLE = Kernel::ERR_INVALID_HANDLE_OS;
-
 enum class ControlCommand : u32 {
    ConvertSessionToDomain = 0,
    ConvertDomainToSession = 1,
@@ -39,7 +39,7 @@ ClientSession::~ClientSession() {
 ResultCode ClientSession::SendSyncRequest(SharedPtr<Thread> thread) {
    // Keep ServerSession alive until we're done working with it.
    SharedPtr<ServerSession> server = parent->server;
-    if (server == nullptr)
+    if (server)
        return ERR_SESSION_CLOSED_BY_REMOTE;

    // Signal the server session that new data is available
@@ -10,11 +10,6 @@ namespace Kernel {

 namespace ErrCodes {
 enum {
-    // TODO(Subv): Remove these 3DS OS error codes.
-    SessionClosedByRemote = 26,
-    NoPendingSessions = 35,
-    InvalidBufferDescriptor = 48,
-
    // Confirmed Switch OS error codes
    MaxConnectionsReached = 7,
    InvalidSize = 101,
@@ -26,6 +21,7 @@ enum {
    InvalidThreadPriority = 112,
    InvalidProcessorId = 113,
    InvalidHandle = 114,
+    InvalidPointer = 115,
    InvalidCombination = 116,
    Timeout = 117,
    SynchronizationCanceled = 118,
@@ -33,6 +29,7 @@ enum {
    InvalidEnumValue = 120,
    NoSuchEntry = 121,
    AlreadyRegistered = 122,
+    SessionClosed = 123,
    InvalidState = 125,
    ResourceLimitExceeded = 132,
 };
@@ -41,18 +38,14 @@ enum {
 // WARNING: The kernel is quite inconsistent in it's usage of errors code. Make sure to always
 // double check that the code matches before re-using the constant.

-// TODO(bunnei): Replace -1 with correct errors for Switch OS
 constexpr ResultCode ERR_HANDLE_TABLE_FULL(ErrorModule::Kernel, ErrCodes::HandleTableFull);
-constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(-1);
+constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(ErrorModule::Kernel, ErrCodes::SessionClosed);
 constexpr ResultCode ERR_PORT_NAME_TOO_LONG(ErrorModule::Kernel, ErrCodes::TooLarge);
 constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(ErrorModule::Kernel,
                                                 ErrCodes::MaxConnectionsReached);
 constexpr ResultCode ERR_INVALID_ENUM_VALUE(ErrorModule::Kernel, ErrCodes::InvalidEnumValue);
-constexpr ResultCode ERR_INVALID_ENUM_VALUE_FND(-1);
-constexpr ResultCode ERR_INVALID_COMBINATION(-1);
 constexpr ResultCode ERR_INVALID_COMBINATION_KERNEL(ErrorModule::Kernel,
                                                    ErrCodes::InvalidCombination);
-constexpr ResultCode ERR_OUT_OF_MEMORY(-1);
 constexpr ResultCode ERR_INVALID_ADDRESS(ErrorModule::Kernel, ErrCodes::InvalidAddress);
 constexpr ResultCode ERR_INVALID_ADDRESS_STATE(ErrorModule::Kernel, ErrCodes::InvalidMemoryState);
 constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS(ErrorModule::Kernel,
@@ -65,14 +58,8 @@ constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::Kernel, ErrCodes::Alrea
 constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
 constexpr ResultCode ERR_INVALID_THREAD_PRIORITY(ErrorModule::Kernel,
                                                 ErrCodes::InvalidThreadPriority);
-constexpr ResultCode ERR_INVALID_POINTER(-1);
-constexpr ResultCode ERR_INVALID_OBJECT_ADDR(-1);
-constexpr ResultCode ERR_NOT_AUTHORIZED(-1);
-/// Alternate code returned instead of ERR_INVALID_HANDLE in some code paths.
-constexpr ResultCode ERR_INVALID_HANDLE_OS(-1);
+constexpr ResultCode ERR_INVALID_POINTER(ErrorModule::Kernel, ErrCodes::InvalidPointer);
 constexpr ResultCode ERR_NOT_FOUND(ErrorModule::Kernel, ErrCodes::NoSuchEntry);
 constexpr ResultCode RESULT_TIMEOUT(ErrorModule::Kernel, ErrCodes::Timeout);
-/// Returned when Accept() is called on a port with no sessions to be accepted.
-constexpr ResultCode ERR_NO_PENDING_SESSIONS(-1);

 } // namespace Kernel
@@ -44,7 +44,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {

 ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
    SharedPtr<Object> object = GetGeneric(handle);
-    if (object == nullptr) {
+    if (object) {
        LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
        return ERR_INVALID_HANDLE;
    }
@@ -77,7 +77,8 @@ HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_ses

 HLERequestContext::~HLERequestContext() = default;

-void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
+void HLERequestContext::ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf,
+                                           bool incoming) {
    IPC::RequestParser rp(src_cmdbuf);
    command_header = std::make_shared<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());

@@ -94,8 +95,6 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
            rp.Skip(2, false);
        }
        if (incoming) {
-            auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
            // Populate the object lists with the data in the IPC request.
            for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
                copy_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
@@ -189,10 +188,9 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
    rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
 }

-ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf,
-                                                                Process& src_process,
-                                                                HandleTable& src_table) {
-    ParseCommandBuffer(src_cmdbuf, true);
+ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
+                                                                u32_le* src_cmdbuf) {
+    ParseCommandBuffer(handle_table, src_cmdbuf, true);
    if (command_header->type == IPC::CommandType::Close) {
        // Close does not populate the rest of the IPC header
        return RESULT_SUCCESS;
@@ -207,14 +205,17 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdb
    return RESULT_SUCCESS;
 }

-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread) {
+ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
+    auto& owner_process = *thread.GetOwnerProcess();
+    auto& handle_table = owner_process.GetHandleTable();
+
    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
-    Memory::ReadBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::ReadBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
                      dst_cmdbuf.size() * sizeof(u32));

    // The header was already built in the internal command buffer. Attempt to parse it to verify
    // the integrity and then copy it over to the target command buffer.
-    ParseCommandBuffer(cmd_buf.data(), false);
+    ParseCommandBuffer(handle_table, cmd_buf.data(), false);

    // The data_size already includes the payload header, the padding and the domain header.
    std::size_t size = data_payload_offset + command_header->data_size -
@@ -236,8 +237,6 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
        ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
        ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);

-        auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
        // We don't make a distinction between copy and move handles when translating since HLE
        // services don't deal with handles directly. However, the guest applications might check
        // for specific values in each of these descriptors.
@@ -268,7 +267,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
    }

    // Copy the translated command buffer back into the thread's command buffer area.
-    Memory::WriteBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::WriteBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
                       dst_cmdbuf.size() * sizeof(u32));

    return RESULT_SUCCESS;
@@ -24,10 +24,10 @@ class ServiceFrameworkBase;
 namespace Kernel {

 class Domain;
+class Event;
 class HandleTable;
 class HLERequestContext;
 class Process;
-class Event;

 /**
 * Interface implemented by HLE Session handlers.
@@ -126,13 +126,12 @@ public:
                                       u64 timeout, WakeupCallback&& callback,
                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);

-    void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
-
    /// Populates this context with data from the requesting process/thread.
-    ResultCode PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf, Process& src_process,
-                                                 HandleTable& src_table);
+    ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
+                                                 u32_le* src_cmdbuf);
+
    /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(const Thread& thread);
+    ResultCode WriteToOutgoingCommandBuffer(Thread& thread);

    u32_le GetCommand() const {
        return command;
@@ -255,6 +254,8 @@ public:
    std::string Description() const;

 private:
+    void ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf, bool incoming);
+
    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
    SharedPtr<Kernel::ServerSession> server_session;
    // TODO(yuriks): Check common usage of this and optimize size accordingly
@@ -39,7 +39,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_

    SharedPtr<Thread> thread =
        system.Kernel().RetrieveThreadFromWakeupCallbackHandleTable(proper_handle);
-    if (thread == nullptr) {
+    if (thread) {
        LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
        return;
    }
@@ -93,7 +93,7 @@ static void TimerCallback(u64 timer_handle, int cycles_late) {
    auto& system = Core::System::GetInstance();
    SharedPtr<Timer> timer = system.Kernel().RetrieveTimerFromCallbackHandleTable(proper_handle);

-    if (timer == nullptr) {
+    if (timer) {
        LOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
        return;
    }
@@ -118,7 +118,6 @@ struct KernelCore::Impl {
        process_list.clear();
        current_process = nullptr;

-        handle_table.Clear();
        resource_limits.fill(nullptr);

        thread_wakeup_callback_handle_table.Clear();
@@ -209,7 +208,6 @@ struct KernelCore::Impl {
    std::vector<SharedPtr<Process>> process_list;
    Process* current_process = nullptr;

-    Kernel::HandleTable handle_table;
    std::array<SharedPtr<ResourceLimit>, 4> resource_limits;

    /// The event type of the generic timer callback event
@@ -241,14 +239,6 @@ void KernelCore::Shutdown() {
    impl->Shutdown();
 }

-Kernel::HandleTable& KernelCore::HandleTable() {
-    return impl->handle_table;
-}
-
-const Kernel::HandleTable& KernelCore::HandleTable() const {
-    return impl->handle_table;
-}
-
 SharedPtr<ResourceLimit> KernelCore::ResourceLimitForCategory(
    ResourceLimitCategory category) const {
    return impl->resource_limits.at(static_cast<std::size_t>(category));
@@ -47,12 +47,6 @@ public:
    /// Clears all resources in use by the kernel instance.
    void Shutdown();

-    /// Provides a reference to the handle table.
-    Kernel::HandleTable& HandleTable();
-
-    /// Provides a const reference to the handle table.
-    const Kernel::HandleTable& HandleTable() const;
-
    /// Retrieves a shared pointer to a ResourceLimit identified by the given category.
    SharedPtr<ResourceLimit> ResourceLimitForCategory(ResourceLimitCategory category) const;

@@ -35,7 +35,7 @@ static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
        ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);

        ++num_waiters;
-        if (highest_priority_thread == nullptr ||
+        if (highest_priority_thread ||
            thread->GetPriority() < highest_priority_thread->GetPriority()) {
            highest_priority_thread = thread;
        }
@@ -80,7 +80,7 @@ ResultCode Mutex::TryAcquire(HandleTable& handle_table, VAddr address, Handle ho
        return RESULT_SUCCESS;
    }

-    if (holding_thread == nullptr)
+    if (holding_thread)
        return ERR_INVALID_HANDLE;

    // Wait until the mutex is released
@@ -107,7 +107,7 @@ ResultCode Mutex::Release(VAddr address) {
    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(GetCurrentThread(), address);

    // There are no more threads waiting for the mutex, release it completely.
-    if (thread == nullptr) {
+    if (thread) {
        Memory::Write32(address, 0);
        return RESULT_SUCCESS;
    }
@@ -240,7 +240,7 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission per
        return ERR_INVALID_ADDRESS;
    }

-    if (heap_memory == nullptr) {
+    if (heap_memory) {
        // Initialize heap
        heap_memory = std::make_shared<std::vector<u8>>();
        heap_start = heap_end = target;
@@ -13,6 +13,7 @@
 #include <boost/container/static_vector.hpp>
 #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"
@@ -142,6 +143,16 @@ public:
        return vm_manager;
    }

+    /// Gets a reference to the process' handle table.
+    HandleTable& GetHandleTable() {
+        return handle_table;
+    }
+
+    /// Gets a const reference to the process' handle table.
+    const HandleTable& GetHandleTable() const {
+        return handle_table;
+    }
+
    /// Gets the current status of the process
    ProcessStatus GetStatus() const {
        return status;
@@ -294,6 +305,9 @@ private:
    /// specified by metadata provided to the process during loading.
    bool is_64bit_process = true;

+    /// Per-process handle table for storing created object handles in.
+    HandleTable handle_table;
+
    std::string name;
 };

@@ -18,7 +18,7 @@ ServerPort::~ServerPort() = default;

 ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
    if (pending_sessions.empty()) {
-        return ERR_NO_PENDING_SESSIONS;
+        return ERR_NOT_FOUND;
    }

    auto session = std::move(pending_sessions.back());
@@ -28,7 +28,7 @@ ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {

 bool ServerPort::ShouldWait(Thread* thread) const {
    // If there are no pending sessions, we wait until a new one is added.
-    return pending_sessions.size() == 0;
+    return pending_sessions.empty();
 }

 void ServerPort::Acquire(Thread* thread) {
@@ -47,7 +47,7 @@ ResultVal<SharedPtr<ServerSession>> ServerSession::Create(KernelCore& kernel, st

 bool ServerSession::ShouldWait(Thread* thread) const {
    // Closed sessions should never wait, an error will be returned from svcReplyAndReceive.
-    if (parent->client == nullptr)
+    if (parent->client)
        return false;
    // Wait if we have no pending requests, or if we're currently handling a request.
    return pending_requesting_threads.empty() || currently_handling != nullptr;
@@ -107,8 +107,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
    // similar.
    Kernel::HLERequestContext context(this);
    u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
-    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
-                                              kernel.HandleTable());
+    context.PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);

    ResultCode result = RESULT_SUCCESS;
    // If the session has been converted to a domain, handle the domain request
@@ -80,20 +80,19 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(

 ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermission permissions,
                             MemoryPermission other_permissions) {
-
-    MemoryPermission own_other_permissions =
+    const MemoryPermission own_other_permissions =
        target_process == owner_process ? this->permissions : this->other_permissions;

    // Automatically allocated memory blocks can only be mapped with other_permissions = DontCare
    if (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
-        return ERR_INVALID_COMBINATION;
+        return ERR_INVALID_MEMORY_PERMISSIONS;
    }

    // Error out if the requested permissions don't match what the creator process allows.
    if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
        LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
                  GetObjectId(), address, name);
-        return ERR_INVALID_COMBINATION;
+        return ERR_INVALID_MEMORY_PERMISSIONS;
    }

    // Error out if the provided permissions are not compatible with what the creator process needs.
@@ -189,14 +189,15 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
    CASCADE_RESULT(client_session, client_port->Connect());

    // Return the client session
-    CASCADE_RESULT(*out_handle, kernel.HandleTable().Create(client_session));
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    CASCADE_RESULT(*out_handle, handle_table.Create(client_session));
    return RESULT_SUCCESS;
 }

 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<ClientSession> session = kernel.HandleTable().Get<ClientSession>(handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<ClientSession> session = handle_table.Get<ClientSession>(handle);
    if (!session) {
        LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
@@ -215,8 +216,8 @@ static ResultCode SendSyncRequest(Handle handle) {
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -229,8 +230,8 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
    LOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
    if (!process) {
        return ERR_INVALID_HANDLE;
    }
@@ -273,13 +274,13 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64

    using ObjectPtr = Thread::ThreadWaitObjects::value_type;
    Thread::ThreadWaitObjects objects(handle_count);
-    auto& kernel = Core::System::GetInstance().Kernel();
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();

    for (u64 i = 0; i < handle_count; ++i) {
        const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        const auto object = kernel.HandleTable().Get<WaitObject>(handle);
+        const auto object = handle_table.Get<WaitObject>(handle);

-        if (object == nullptr) {
+        if (object) {
            return ERR_INVALID_HANDLE;
        }

@@ -325,8 +326,8 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 static ResultCode CancelSynchronization(Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -354,7 +355,7 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
        return ERR_INVALID_ADDRESS;
    }

-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    return Mutex::TryAcquire(handle_table, mutex_addr, holding_thread_handle,
                             requesting_thread_handle);
 }
@@ -374,9 +375,19 @@ static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
    return Mutex::Release(mutex_addr);
 }

+enum class BreakType : u32 {
+    Panic = 0,
+    AssertionFailed = 1,
+    PreNROLoad = 3,
+    PostNROLoad = 4,
+    PreNROUnload = 5,
+    PostNROUnload = 6,
+};
+
 struct BreakReason {
    union {
        u32 raw;
+        BitField<0, 30, BreakType> break_type;
        BitField<31, 1, u32> signal_debugger;
    };
 };
@@ -384,12 +395,48 @@ struct BreakReason {
 /// Break program execution
 static void Break(u32 reason, u64 info1, u64 info2) {
    BreakReason break_reason{reason};
-    if (break_reason.signal_debugger) {
-        LOG_ERROR(
+
+    switch (break_reason.break_type) {
+    case BreakType::Panic:
+        LOG_CRITICAL(Debug_Emulated, "Signalling debugger, PANIC! info1=0x{:016X}, info2=0x{:016X}",
+                     info1, info2);
+        break;
+    case BreakType::AssertionFailed:
+        LOG_CRITICAL(Debug_Emulated,
+                     "Signalling debugger, Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
+                     info1, info2);
+        break;
+    case BreakType::PreNROLoad:
+        LOG_WARNING(
            Debug_Emulated,
-            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
-            reason, info1, info2);
-    } else {
+            "Signalling debugger, Attempting to load an NRO at 0x{:016X} with size 0x{:016X}",
+            info1, info2);
+        break;
+    case BreakType::PostNROLoad:
+        LOG_WARNING(Debug_Emulated,
+                    "Signalling debugger, Loaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
+                    info2);
+        break;
+    case BreakType::PreNROUnload:
+        LOG_WARNING(
+            Debug_Emulated,
+            "Signalling debugger, Attempting to unload an NRO at 0x{:016X} with size 0x{:016X}",
+            info1, info2);
+        break;
+    case BreakType::PostNROUnload:
+        LOG_WARNING(Debug_Emulated,
+                    "Signalling debugger, Unloaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
+                    info2);
+        break;
+    default:
+        LOG_WARNING(
+            Debug_Emulated,
+            "Signalling debugger, Unknown break reason {}, info1=0x{:016X}, info2=0x{:016X}",
+            static_cast<u32>(break_reason.break_type.Value()), info1, info2);
+        break;
+    }
+
+    if (!break_reason.signal_debugger) {
        LOG_CRITICAL(
            Debug_Emulated,
            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
@@ -499,13 +546,12 @@ static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
 static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
    LOG_DEBUG(Kernel_SVC, "called, context=0x{:08X}, thread=0x{:X}", thread_context, handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    const auto* current_process = Core::CurrentProcess();
+    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }

-    const auto* current_process = Core::CurrentProcess();
    if (thread->GetOwnerProcess() != current_process) {
        return ERR_INVALID_HANDLE;
    }
@@ -531,10 +577,11 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {

 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
-    if (!thread)
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(handle);
+    if (!thread) {
        return ERR_INVALID_HANDLE;
+    }

    *priority = thread->GetPriority();
    return RESULT_SUCCESS;
@@ -546,16 +593,18 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
        return ERR_INVALID_THREAD_PRIORITY;
    }

-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
-    if (!thread)
-        return ERR_INVALID_HANDLE;
+    const auto* const current_process = Core::CurrentProcess();

    // Note: The kernel uses the current process's resource limit instead of
    // the one from the thread owner's resource limit.
-    const ResourceLimit& resource_limit = Core::CurrentProcess()->GetResourceLimit();
+    const ResourceLimit& resource_limit = current_process->GetResourceLimit();
    if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
-        return ERR_NOT_AUTHORIZED;
+        return ERR_INVALID_THREAD_PRIORITY;
+    }
+
+    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    if (!thread) {
+        return ERR_INVALID_HANDLE;
    }

    thread->SetPriority(priority);
@@ -595,15 +644,13 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
        return ERR_INVALID_MEMORY_PERMISSIONS;
    }

-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    auto* const current_process = Core::CurrentProcess();
+    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
    if (!shared_memory) {
        return ERR_INVALID_HANDLE;
    }

-    auto* const current_process = Core::CurrentProcess();
    const auto& vm_manager = current_process->VMManager();
-
    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
        return ERR_INVALID_MEMORY_RANGE;
    }
@@ -627,15 +674,13 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
        return ERR_INVALID_ADDRESS_STATE;
    }

-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    auto* const current_process = Core::CurrentProcess();
+    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
    if (!shared_memory) {
        return ERR_INVALID_HANDLE;
    }

-    auto* const current_process = Core::CurrentProcess();
    const auto& vm_manager = current_process->VMManager();
-
    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
        return ERR_INVALID_MEMORY_RANGE;
    }
@@ -646,9 +691,8 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                     Handle process_handle, u64 addr) {
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
    if (!process) {
        return ERR_INVALID_HANDLE;
    }
@@ -695,20 +739,19 @@ static void ExitProcess() {
 /// Creates a new thread
 static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, VAddr stack_top,
                               u32 priority, s32 processor_id) {
-    std::string name = fmt::format("thread-{:X}", entry_point);
-
    if (priority > THREADPRIO_LOWEST) {
        return ERR_INVALID_THREAD_PRIORITY;
    }

-    const ResourceLimit& resource_limit = Core::CurrentProcess()->GetResourceLimit();
+    auto* const current_process = Core::CurrentProcess();
+    const ResourceLimit& resource_limit = current_process->GetResourceLimit();
    if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
-        return ERR_NOT_AUTHORIZED;
+        return ERR_INVALID_THREAD_PRIORITY;
    }

    if (processor_id == THREADPROCESSORID_DEFAULT) {
        // Set the target CPU to the one specified in the process' exheader.
-        processor_id = Core::CurrentProcess()->GetDefaultProcessorID();
+        processor_id = current_process->GetDefaultProcessorID();
        ASSERT(processor_id != THREADPROCESSORID_DEFAULT);
    }

@@ -723,11 +766,13 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
        return ERR_INVALID_PROCESSOR_ID;
    }

+    const std::string name = fmt::format("thread-{:X}", entry_point);
    auto& kernel = Core::System::GetInstance().Kernel();
    CASCADE_RESULT(SharedPtr<Thread> thread,
                   Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
-                                  *Core::CurrentProcess()));
-    const auto new_guest_handle = kernel.HandleTable().Create(thread);
+                                  *current_process));
+
+    const auto new_guest_handle = current_process->GetHandleTable().Create(thread);
    if (new_guest_handle.Failed()) {
        return new_guest_handle.Code();
    }
@@ -748,8 +793,8 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 static ResultCode StartThread(Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -796,8 +841,8 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
        "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
        mutex_addr, condition_variable_addr, thread_handle, nano_seconds);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    ASSERT(thread);

    CASCADE_CODE(Mutex::Release(mutex_addr));
@@ -908,9 +953,9 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
                                               mutex_val | Mutex::MutexHasWaitersFlag));

            // The mutex is already owned by some other thread, make this thread wait on it.
-            auto& kernel = Core::System::GetInstance().Kernel();
-            Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-            auto owner = kernel.HandleTable().Get<Thread>(owner_handle);
+            const Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
+            const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+            auto owner = handle_table.Get<Thread>(owner_handle);
            ASSERT(owner);
            ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
            thread->InvalidateWakeupCallback();
@@ -989,16 +1034,16 @@ static u64 GetSystemTick() {
 static ResultCode CloseHandle(Handle handle) {
    LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    return kernel.HandleTable().Close(handle);
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    return handle_table.Close(handle);
 }

 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
    LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto event = kernel.HandleTable().Get<Event>(handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    auto event = handle_table.Get<Event>(handle);

    ASSERT(event != nullptr);

@@ -1017,8 +1062,8 @@ static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32
 static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask) {
    LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -1033,8 +1078,8 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
              mask, core);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -1095,7 +1140,7 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
    }

    auto& kernel = Core::System::GetInstance().Kernel();
-    auto& handle_table = kernel.HandleTable();
+    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
    auto shared_mem_handle =
        SharedMemory::Create(kernel, handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
                             local_perms, remote_perms);
@@ -1107,10 +1152,12 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
 static ResultCode ClearEvent(Handle handle) {
    LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);

-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Event> evt = kernel.HandleTable().Get<Event>(handle);
-    if (evt == nullptr)
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    SharedPtr<Event> evt = handle_table.Get<Event>(handle);
+    if (evt) {
        return ERR_INVALID_HANDLE;
+    }
+
    evt->Clear();
    return RESULT_SUCCESS;
 }
@@ -1123,8 +1170,8 @@ static ResultCode GetProcessInfo(u64* out, Handle process_handle, u32 type) {
        Status,
    };

-    const auto& kernel = Core::System::GetInstance().Kernel();
-    const auto process = kernel.HandleTable().Get<Process>(process_handle);
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    const auto process = handle_table.Get<Process>(process_handle);
    if (!process) {
        return ERR_INVALID_HANDLE;
    }
@@ -122,7 +122,7 @@ void Thread::ResumeFromWait() {
    case ThreadStatus::Ready:
        // The thread's wakeup callback must have already been cleared when the thread was first
        // awoken.
-        ASSERT(wakeup_callback == nullptr);
+        ASSERT(wakeup_callback);
        // If the thread is waiting on multiple wait objects, it might be awoken more than once
        // before actually resuming. We can ignore subsequent wakeups if the thread status has
        // already been set to ThreadStatus::Ready.
@@ -146,8 +146,7 @@ void Thread::ResumeFromWait() {
    if (!new_processor_id) {
        new_processor_id = processor_id;
    }
-    if (ideal_core != -1 &&
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+    if (ideal_core != -1 && Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread()) {
        new_processor_id = ideal_core;
    }

@@ -266,7 +265,7 @@ SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 pri
    SharedPtr<Thread> thread = std::move(thread_res).Unwrap();

    // Register 1 must be a handle to the main thread
-    const Handle guest_handle = kernel.HandleTable().Create(thread).Unwrap();
+    const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
    thread->SetGuestHandle(guest_handle);
    thread->GetContext().cpu_registers[1] = guest_handle;

@@ -318,7 +317,7 @@ void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
    }

    // A thread can't wait on two different mutexes at the same time.
-    ASSERT(thread->lock_owner == nullptr);
+    ASSERT(thread->lock_owner);

    // Ensure that the thread is not already in the list of mutex waiters
    auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
@@ -374,8 +373,7 @@ void Thread::ChangeCore(u32 core, u64 mask) {
    if (!new_processor_id) {
        new_processor_id = processor_id;
    }
-    if (ideal_core != -1 &&
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+    if (ideal_core != -1 && Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread()) {
        new_processor_id = ideal_core;
    }

@@ -2,9 +2,13 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
 #include <array>
+#include "common/common_paths.h"
 #include "common/common_types.h"
+#include "common/file_util.h"
 #include "common/logging/log.h"
+#include "common/string_util.h"
 #include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
@@ -16,6 +20,7 @@
 #include "core/hle/service/acc/profile_manager.h"

 namespace Service::Account {
+
 // TODO: RE this structure
 struct UserData {
    INSERT_PADDING_WORDS(1);
@@ -27,6 +32,29 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");

+// Smallest JPEG https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
+// used as a backup should the one on disk not exist
+constexpr u32 backup_jpeg_size = 107;
+constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
+    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
+    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
+    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
+    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
+    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
+    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
+}};
+
+static std::string GetImagePath(UUID uuid) {
+    return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+           "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
+}
+
+static constexpr u32 SanitizeJPEGSize(std::size_t size) {
+    constexpr std::size_t max_jpeg_image_size = 0x20000;
+    return static_cast<u32>(std::min(size, max_jpeg_image_size));
+}
+
 class IProfile final : public ServiceFramework<IProfile> {
 public:
    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
@@ -73,32 +101,42 @@ private:
    }

    void LoadImage(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
-        // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
-        constexpr u32 jpeg_size = 107;
-        static constexpr std::array<u8, jpeg_size> jpeg{
-            0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
-            0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
-            0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
-            0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e, 0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f,
-            0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13, 0x12, 0x10, 0x13, 0x0f, 0x10, 0x10,
-            0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
-            0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
-            0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-        };
-        ctx.WriteBuffer(jpeg);
+        LOG_DEBUG(Service_ACC, "called");
+
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(jpeg_size);
+
+        const FileUtil::IOFile image(GetImagePath(user_id), "rb");
+        if (!image.IsOpen()) {
+            LOG_WARNING(Service_ACC,
+                        "Failed to load user provided image! Falling back to built-in backup...");
+            ctx.WriteBuffer(backup_jpeg);
+            rb.Push<u32>(backup_jpeg_size);
+            return;
+        }
+
+        const u32 size = SanitizeJPEGSize(image.GetSize());
+        std::vector<u8> buffer(size);
+        image.ReadBytes(buffer.data(), buffer.size());
+
+        ctx.WriteBuffer(buffer.data(), buffer.size());
+        rb.Push<u32>(size);
    }

    void GetImageSize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        constexpr u32 jpeg_size = 107;
+        LOG_DEBUG(Service_ACC, "called");
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(jpeg_size);
+
+        const FileUtil::IOFile image(GetImagePath(user_id), "rb");
+
+        if (!image.IsOpen()) {
+            LOG_WARNING(Service_ACC,
+                        "Failed to load user provided image! Falling back to built-in backup...");
+            rb.Push<u32>(backup_jpeg_size);
+        } else {
+            rb.Push<u32>(SanitizeJPEGSize(image.GetSize()));
+        }
    }

    const ProfileManager& profile_manager;
@@ -3,41 +3,66 @@
 // Refer to the license.txt file included.

 #include <random>
-#include <boost/optional.hpp>
+
+#include "common/file_util.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"

 namespace Service::Account {
+
+struct UserRaw {
+    UUID uuid;
+    UUID uuid2;
+    u64 timestamp;
+    ProfileUsername username;
+    INSERT_PADDING_BYTES(0x80);
+};
+static_assert(sizeof(UserRaw) == 0xC8, "UserRaw has incorrect size.");
+
+struct ProfileDataRaw {
+    INSERT_PADDING_BYTES(0x10);
+    std::array<UserRaw, MAX_USERS> users;
+};
+static_assert(sizeof(ProfileDataRaw) == 0x650, "ProfileDataRaw has incorrect size.");
+
 // TODO(ogniK): Get actual error codes
 constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
 constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
 constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);

-const UUID& UUID::Generate() {
+constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/avators/";
+
+UUID UUID::Generate() {
    std::random_device device;
    std::mt19937 gen(device());
    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    uuid[0] = distribution(gen);
-    uuid[1] = distribution(gen);
-    return *this;
+    return UUID{distribution(gen), distribution(gen)};
 }

 ProfileManager::ProfileManager() {
-    // TODO(ogniK): Create the default user we have for now until loading/saving users is added
-    auto user_uuid = UUID{1, 0};
-    ASSERT(CreateNewUser(user_uuid, Settings::values.username).IsSuccess());
-    OpenUser(user_uuid);
+    ParseUserSaveFile();
+
+    if (user_count == 0)
+        CreateNewUser(UUID::Generate(), "yuzu");
+
+    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
+    if (UserExistsIndex(current))
+        current = 0;
+
+    OpenUser(*GetUser(current));
 }

-ProfileManager::~ProfileManager() = default;
+ProfileManager::~ProfileManager() {
+    WriteUserSaveFile();
+}

 /// After a users creation it needs to be "registered" to the system. AddToProfiles handles the
 /// internal management of the users profiles
-boost::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& user) {
+std::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& profile) {
    if (user_count >= MAX_USERS) {
-        return boost::none;
+        return {};
    }
-    profiles[user_count] = user;
+    profiles[user_count] = profile;
    return user_count++;
 }

@@ -56,7 +81,7 @@ bool ProfileManager::RemoveProfileAtIndex(std::size_t index) {

 /// Helper function to register a user to the system
 ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
-    if (AddToProfiles(user) == boost::none) {
+    if (!AddToProfiles(user)) {
        return ERROR_TOO_MANY_USERS;
    }
    return RESULT_SUCCESS;
@@ -101,31 +126,40 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username)
    return CreateNewUser(uuid, username_output);
 }

+std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
+    if (index >= MAX_USERS) {
+        return {};
+    }
+
+    return profiles[index].user_uuid;
+}
+
 /// Returns a users profile index based on their user id.
-boost::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
+std::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
    if (!uuid) {
-        return boost::none;
+        return {};
    }
-    auto iter = std::find_if(profiles.begin(), profiles.end(),
-                             [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
+
+    const auto iter = std::find_if(profiles.begin(), profiles.end(),
+                                   [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
    if (iter == profiles.end()) {
-        return boost::none;
+        return {};
    }
+
    return static_cast<std::size_t>(std::distance(profiles.begin(), iter));
 }

 /// Returns a users profile index based on their profile
-boost::optional<std::size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
+std::optional<std::size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
    return GetUserIndex(user.user_uuid);
 }

 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(boost::optional<std::size_t> index,
-                                    ProfileBase& profile) const {
-    if (index == boost::none || index >= MAX_USERS) {
+bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const {
+    if (!index || index >= MAX_USERS) {
        return false;
    }
-    const auto& prof_info = profiles[index.get()];
+    const auto& prof_info = profiles[*index];
    profile.user_uuid = prof_info.user_uuid;
    profile.username = prof_info.username;
    profile.timestamp = prof_info.creation_time;
@@ -134,7 +168,7 @@ bool ProfileManager::GetProfileBase(boost::optional<std::size_t> index,

 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
 bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
-    auto idx = GetUserIndex(uuid);
+    const auto idx = GetUserIndex(uuid);
    return GetProfileBase(idx, profile);
 }

@@ -161,26 +195,34 @@ std::size_t ProfileManager::GetOpenUserCount() const {

 /// Checks if a user id exists in our profile manager
 bool ProfileManager::UserExists(UUID uuid) const {
-    return (GetUserIndex(uuid) != boost::none);
+    return GetUserIndex(uuid) != std::nullopt;
+}
+
+bool ProfileManager::UserExistsIndex(std::size_t index) const {
+    if (index >= MAX_USERS)
+        return false;
+    return profiles[index].user_uuid.uuid != INVALID_UUID;
 }

 /// Opens a specific user
 void ProfileManager::OpenUser(UUID uuid) {
-    auto idx = GetUserIndex(uuid);
-    if (idx == boost::none) {
+    const auto idx = GetUserIndex(uuid);
+    if (!idx) {
        return;
    }
-    profiles[idx.get()].is_open = true;
+
+    profiles[*idx].is_open = true;
    last_opened_user = uuid;
 }

 /// Closes a specific user
 void ProfileManager::CloseUser(UUID uuid) {
-    auto idx = GetUserIndex(uuid);
-    if (idx == boost::none) {
+    const auto idx = GetUserIndex(uuid);
+    if (!idx) {
        return;
    }
-    profiles[idx.get()].is_open = false;
+
+    profiles[*idx].is_open = false;
 }

 /// Gets all valid user ids on the system
@@ -210,10 +252,10 @@ UUID ProfileManager::GetLastOpenedUser() const {
 }

 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(boost::optional<std::size_t> index, ProfileBase& profile,
+bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
                                           ProfileData& data) const {
    if (GetProfileBase(index, profile)) {
-        data = profiles[index.get()].data;
+        data = profiles[*index].data;
        return true;
    }
    return false;
@@ -222,7 +264,7 @@ bool ProfileManager::GetProfileBaseAndData(boost::optional<std::size_t> index, P
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
                                           ProfileData& data) const {
-    auto idx = GetUserIndex(uuid);
+    const auto idx = GetUserIndex(uuid);
    return GetProfileBaseAndData(idx, profile, data);
 }

@@ -239,4 +281,96 @@ bool ProfileManager::CanSystemRegisterUser() const {
    // emulate qlaunch. Update this to dynamically change.
 }

+bool ProfileManager::RemoveUser(UUID uuid) {
+    const auto index = GetUserIndex(uuid);
+    if (!index) {
+        return false;
+    }
+
+    profiles[*index] = ProfileInfo{};
+    std::stable_partition(profiles.begin(), profiles.end(),
+                          [](const ProfileInfo& profile) { return profile.user_uuid; });
+    return true;
+}
+
+bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
+    const auto index = GetUserIndex(uuid);
+    if (!index || profile_new.user_uuid == UUID(INVALID_UUID)) {
+        return false;
+    }
+
+    auto& profile = profiles[*index];
+    profile.user_uuid = profile_new.user_uuid;
+    profile.username = profile_new.username;
+    profile.creation_time = profile_new.timestamp;
+
+    return true;
+}
+
+void ProfileManager::ParseUserSaveFile() {
+    FileUtil::IOFile save(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+                              ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat",
+                          "rb");
+
+    if (!save.IsOpen()) {
+        LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
+                                 "user 'yuzu' with random UUID.");
+        return;
+    }
+
+    ProfileDataRaw data;
+    if (save.ReadBytes(&data, sizeof(ProfileDataRaw)) != sizeof(ProfileDataRaw)) {
+        LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
+                                 "'yuzu' with random UUID.");
+        return;
+    }
+
+    for (std::size_t i = 0; i < MAX_USERS; ++i) {
+        const auto& user = data.users[i];
+
+        if (user.uuid != UUID(INVALID_UUID))
+            AddUser({user.uuid, user.username, user.timestamp, {}, false});
+    }
+
+    std::stable_partition(profiles.begin(), profiles.end(),
+                          [](const ProfileInfo& profile) { return profile.user_uuid; });
+}
+
+void ProfileManager::WriteUserSaveFile() {
+    ProfileDataRaw raw{};
+
+    for (std::size_t i = 0; i < MAX_USERS; ++i) {
+        raw.users[i].username = profiles[i].username;
+        raw.users[i].uuid2 = profiles[i].user_uuid;
+        raw.users[i].uuid = profiles[i].user_uuid;
+        raw.users[i].timestamp = profiles[i].creation_time;
+    }
+
+    const auto raw_path =
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010";
+    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
+        FileUtil::Delete(raw_path);
+
+    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+                      ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat";
+
+    if (!FileUtil::CreateFullPath(path)) {
+        LOG_WARNING(Service_ACC, "Failed to create full path of profiles.dat. Create the directory "
+                                 "nand/system/save/8000000000000010/su/avators to mitigate this "
+                                 "issue.");
+        return;
+    }
+
+    FileUtil::IOFile save(path, "wb");
+
+    if (!save.IsOpen()) {
+        LOG_WARNING(Service_ACC, "Failed to write save data to file... No changes to user data "
+                                 "made in current session will be saved.");
+        return;
+    }
+
+    save.Resize(sizeof(ProfileDataRaw));
+    save.WriteBytes(&raw, sizeof(ProfileDataRaw));
+}
+
 }; // namespace Service::Account
@@ -5,8 +5,8 @@
 #pragma once

 #include <array>
+#include <optional>

-#include "boost/optional.hpp"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/result.h"
@@ -36,7 +36,7 @@ struct UUID {
    }

    // TODO(ogniK): Properly generate uuids based on RFC-4122
-    const UUID& Generate();
+    static UUID Generate();

    // Set the UUID to {0,0} to be considered an invalid user
    void Invalidate() {
@@ -45,6 +45,15 @@ struct UUID {
    std::string Format() const {
        return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
    }
+
+    std::string FormatSwitch() const {
+        std::array<u8, 16> s{};
+        std::memcpy(s.data(), uuid.data(), sizeof(u128));
+        return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
+                           ":02x}{:02x}{:02x}{:02x}{:02x}",
+                           s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
+                           s[12], s[13], s[14], s[15]);
+    }
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");

@@ -81,18 +90,19 @@ static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase is an invalid size");
 /// objects
 class ProfileManager {
 public:
-    ProfileManager(); // TODO(ogniK): Load from system save
+    ProfileManager();
    ~ProfileManager();

    ResultCode AddUser(const ProfileInfo& user);
    ResultCode CreateNewUser(UUID uuid, const ProfileUsername& username);
    ResultCode CreateNewUser(UUID uuid, const std::string& username);
-    boost::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
-    boost::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
-    bool GetProfileBase(boost::optional<std::size_t> index, ProfileBase& profile) const;
+    std::optional<UUID> GetUser(std::size_t index) const;
+    std::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
+    std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
+    bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
    bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
-    bool GetProfileBaseAndData(boost::optional<std::size_t> index, ProfileBase& profile,
+    bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
                               ProfileData& data) const;
    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
    bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
@@ -100,6 +110,7 @@ public:
    std::size_t GetUserCount() const;
    std::size_t GetOpenUserCount() const;
    bool UserExists(UUID uuid) const;
+    bool UserExistsIndex(std::size_t index) const;
    void OpenUser(UUID uuid);
    void CloseUser(UUID uuid);
    UserIDArray GetOpenUsers() const;
@@ -108,11 +119,17 @@ public:

    bool CanSystemRegisterUser() const;

+    bool RemoveUser(UUID uuid);
+    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
+
 private:
+    void ParseUserSaveFile();
+    void WriteUserSaveFile();
+    std::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
+    bool RemoveProfileAtIndex(std::size_t index);
+
    std::array<ProfileInfo, MAX_USERS> profiles{};
    std::size_t user_count = 0;
-    boost::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
-    bool RemoveProfileAtIndex(std::size_t index);
    UUID last_opened_user{INVALID_UUID};
 };

@@ -4,11 +4,13 @@

 #include <array>
 #include <cinttypes>
+#include <cstring>
 #include <stack>
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
@@ -26,6 +28,16 @@

 namespace Service::AM {

+constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;
+
+struct LaunchParameters {
+    u32_le magic;
+    u32_le is_account_selected;
+    u128 current_user;
+    INSERT_PADDING_BYTES(0x70);
+};
+static_assert(sizeof(LaunchParameters) == 0x88);
+
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
    // clang-format off
    static const FunctionInfo functions[] = {
@@ -724,20 +736,23 @@ void IApplicationFunctions::EndBlockingHomeButton(Kernel::HLERequestContext& ctx
 }

 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
-    constexpr std::array<u8, 0x88> data{{
-        0xca, 0x97, 0x94, 0xc7, // Magic
-        1,    0,    0,    0,    // IsAccountSelected (bool)
-        1,    0,    0,    0,    // User Id (word 0)
-        0,    0,    0,    0,    // User Id (word 1)
-        0,    0,    0,    0,    // User Id (word 2)
-        0,    0,    0,    0     // User Id (word 3)
-    }};
+    LaunchParameters params{};

-    std::vector<u8> buffer(data.begin(), data.end());
+    params.magic = POP_LAUNCH_PARAMETER_MAGIC;
+    params.is_account_selected = 1;
+
+    Account::ProfileManager profile_manager{};
+    const auto uuid = profile_manager.GetUser(Settings::values.current_user);
+    ASSERT(uuid != std::nullopt);
+    params.current_user = uuid->uuid;

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};

    rb.Push(RESULT_SUCCESS);
+
+    std::vector<u8> buffer(sizeof(LaunchParameters));
+    std::memcpy(buffer.data(), &params, buffer.size());
+
    rb.PushIpcInterface<AM::IStorage>(buffer);

    LOG_DEBUG(Service_AM, "called");
@@ -24,8 +24,8 @@ namespace Service::AOC {
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
 constexpr u64 DLC_BASE_TO_AOC_ID = 0x1000;

-static bool CheckAOCTitleIDMatchesBase(u64 base, u64 aoc) {
-    return (aoc & DLC_BASE_TITLE_ID_MASK) == base;
+static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
+    return (title_id & DLC_BASE_TITLE_ID_MASK) == base;
 }

 static std::vector<u64> AccumulateAOCTitleIDs() {
@@ -74,7 +74,7 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
    const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
    rb.Push<u32>(static_cast<u32>(
        std::count_if(add_on_content.begin(), add_on_content.end(),
-                      [&current](u64 tid) { return (tid & DLC_BASE_TITLE_ID_MASK) == current; })));
+                      [current](u64 tid) { return CheckAOCTitleIDMatchesBase(tid, current); })));
 }

 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
@@ -116,7 +116,7 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
    FileSys::PatchManager pm{title_id};

    const auto res = pm.GetControlMetadata();
-    if (res.first == nullptr) {
+    if (res.first) {
        rb.Push(title_id + DLC_BASE_TO_AOC_ID);
        return;
    }
@@ -50,7 +50,7 @@ ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64
    std::string path(FileUtil::SanitizePath(path_));
    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
    auto file = dir->CreateFile(FileUtil::GetFilename(path));
-    if (file == nullptr) {
+    if (file) {
        // TODO(DarkLordZach): Find a better error code for this
        return ResultCode(-1);
    }
@@ -69,7 +69,7 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
    }

    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (dir->GetFile(FileUtil::GetFilename(path)) == nullptr) {
+    if (dir->GetFile(FileUtil::GetFilename(path))) {
        return FileSys::ERROR_PATH_NOT_FOUND;
    }
    if (!dir->DeleteFile(FileUtil::GetFilename(path))) {
@@ -83,10 +83,10 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
 ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
    std::string path(FileUtil::SanitizePath(path_));
    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (dir == nullptr && FileUtil::GetFilename(FileUtil::GetParentPath(path)).empty())
+    if (dir && FileUtil::GetFilename(FileUtil::GetParentPath(path)).empty())
        dir = backing;
    auto new_dir = dir->CreateSubdirectory(FileUtil::GetFilename(path));
-    if (new_dir == nullptr) {
+    if (new_dir) {
        // TODO(DarkLordZach): Find a better error code for this
        return ResultCode(-1);
    }
@@ -120,7 +120,7 @@ ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
    auto src = backing->GetFileRelative(src_path);
    if (FileUtil::GetParentPath(src_path) == FileUtil::GetParentPath(dest_path)) {
        // Use more-optimized vfs implementation rename.
-        if (src == nullptr)
+        if (src)
            return FileSys::ERROR_PATH_NOT_FOUND;
        if (!src->Rename(FileUtil::GetFilename(dest_path))) {
            // TODO(DarkLordZach): Find a better error code for this
@@ -155,7 +155,7 @@ ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_pa
    auto src = GetDirectoryRelativeWrapped(backing, src_path);
    if (FileUtil::GetParentPath(src_path) == FileUtil::GetParentPath(dest_path)) {
        // Use more-optimized vfs implementation rename.
-        if (src == nullptr)
+        if (src)
            return FileSys::ERROR_PATH_NOT_FOUND;
        if (!src->Rename(FileUtil::GetFilename(dest_path))) {
            // TODO(DarkLordZach): Find a better error code for this
@@ -181,7 +181,7 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
    while (npath.size() > 0 && (npath[0] == '/' || npath[0] == '\\'))
        npath = npath.substr(1);
    auto file = backing->GetFileRelative(npath);
-    if (file == nullptr)
+    if (file)
        return FileSys::ERROR_PATH_NOT_FOUND;

    if (mode == FileSys::Mode::Append) {
@@ -195,7 +195,7 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
 ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) {
    std::string path(FileUtil::SanitizePath(path_));
    auto dir = GetDirectoryRelativeWrapped(backing, path);
-    if (dir == nullptr) {
+    if (dir) {
        // TODO(DarkLordZach): Find a better error code for this
        return FileSys::ERROR_PATH_NOT_FOUND;
    }
@@ -213,7 +213,7 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
    const std::string& path_) const {
    std::string path(FileUtil::SanitizePath(path_));
    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (dir == nullptr)
+    if (dir)
        return FileSys::ERROR_PATH_NOT_FOUND;
    auto filename = FileUtil::GetFilename(path);
    // TODO(Subv): Some games use the '/' path, find out what this means.
@@ -237,28 +237,28 @@ static std::unique_ptr<FileSys::SDMCFactory> sdmc_factory;
 static std::unique_ptr<FileSys::BISFactory> bis_factory;

 ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory) {
-    ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second RomFS");
+    ASSERT_MSG(romfs_factory, "Tried to register a second RomFS");
    romfs_factory = std::move(factory);
    LOG_DEBUG(Service_FS, "Registered RomFS");
    return RESULT_SUCCESS;
 }

 ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory) {
-    ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second save data");
+    ASSERT_MSG(romfs_factory, "Tried to register a second save data");
    save_data_factory = std::move(factory);
    LOG_DEBUG(Service_FS, "Registered save data");
    return RESULT_SUCCESS;
 }

 ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory) {
-    ASSERT_MSG(sdmc_factory == nullptr, "Tried to register a second SDMC");
+    ASSERT_MSG(sdmc_factory, "Tried to register a second SDMC");
    sdmc_factory = std::move(factory);
    LOG_DEBUG(Service_FS, "Registered SDMC");
    return RESULT_SUCCESS;
 }

 ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
-    ASSERT_MSG(bis_factory == nullptr, "Tried to register a second BIS");
+    ASSERT_MSG(bis_factory, "Tried to register a second BIS");
    bis_factory = std::move(factory);
    LOG_DEBUG(Service_FS, "Registered BIS");
    return RESULT_SUCCESS;
@@ -267,7 +267,7 @@ ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
 void SetPackedUpdate(FileSys::VirtualFile update_raw) {
    LOG_TRACE(Service_FS, "Setting packed update for romfs");

-    if (romfs_factory == nullptr)
+    if (romfs_factory)
        return;

    romfs_factory->SetPackedUpdate(std::move(update_raw));
@@ -276,7 +276,7 @@ void SetPackedUpdate(FileSys::VirtualFile update_raw) {
 ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() {
    LOG_TRACE(Service_FS, "Opening RomFS for current process");

-    if (romfs_factory == nullptr) {
+    if (romfs_factory) {
        // TODO(bunnei): Find a better error code for this
        return ResultCode(-1);
    }
@@ -289,7 +289,7 @@ ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId stora
    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
              title_id, static_cast<u8>(storage_id), static_cast<u8>(type));

-    if (romfs_factory == nullptr) {
+    if (romfs_factory) {
        // TODO(bunnei): Find a better error code for this
        return ResultCode(-1);
    }
@@ -302,7 +302,7 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}",
              static_cast<u8>(space), save_struct.DebugInfo());

-    if (save_data_factory == nullptr) {
+    if (save_data_factory) {
        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound);
    }

@@ -312,7 +312,7 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
 ResultVal<FileSys::VirtualDir> OpenSDMC() {
    LOG_TRACE(Service_FS, "Opening SDMC");

-    if (sdmc_factory == nullptr) {
+    if (sdmc_factory) {
        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SdCardNotFound);
    }

@@ -327,7 +327,7 @@ std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
 FileSys::RegisteredCache* GetSystemNANDContents() {
    LOG_TRACE(Service_FS, "Opening System NAND Contents");

-    if (bis_factory == nullptr)
+    if (bis_factory)
        return nullptr;

    return bis_factory->GetSystemNANDContents();
@@ -336,7 +336,7 @@ FileSys::RegisteredCache* GetSystemNANDContents() {
 FileSys::RegisteredCache* GetUserNANDContents() {
    LOG_TRACE(Service_FS, "Opening User NAND Contents");

-    if (bis_factory == nullptr)
+    if (bis_factory)
        return nullptr;

    return bis_factory->GetUserNANDContents();
@@ -345,7 +345,7 @@ FileSys::RegisteredCache* GetUserNANDContents() {
 FileSys::RegisteredCache* GetSDMCContents() {
    LOG_TRACE(Service_FS, "Opening SDMC Contents");

-    if (sdmc_factory == nullptr)
+    if (sdmc_factory)
        return nullptr;

    return sdmc_factory->GetSDMCContents();
@@ -354,7 +354,7 @@ FileSys::RegisteredCache* GetSDMCContents() {
 FileSys::VirtualDir GetModificationLoadRoot(u64 title_id) {
    LOG_TRACE(Service_FS, "Opening mod load root for tid={:016X}", title_id);

-    if (bis_factory == nullptr)
+    if (bis_factory)
        return nullptr;

    return bis_factory->GetModificationLoadRoot(title_id);
@@ -374,11 +374,11 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
    auto load_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::LoadDir),
                                            FileSys::Mode::ReadWrite);

-    if (bis_factory == nullptr)
+    if (bis_factory)
        bis_factory = std::make_unique<FileSys::BISFactory>(nand_directory, load_directory);
-    if (save_data_factory == nullptr)
+    if (save_data_factory)
        save_data_factory = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
-    if (sdmc_factory == nullptr)
+    if (sdmc_factory)
        sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
 }

@@ -17,6 +17,7 @@
 #include "core/file_sys/errors.h"
 #include "core/file_sys/mode.h"
 #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/vfs.h"
 #include "core/hle/ipc_helpers.h"
@@ -630,6 +631,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
              static_cast<u8>(storage_id), unknown, title_id);

    auto data = OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
+
    if (data.Failed()) {
        // TODO(DarkLordZach): Find the right error code to use here
        LOG_ERROR(Service_FS,
@@ -640,7 +642,9 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
        return;
    }

-    IStorage storage(std::move(data.Unwrap()));
+    FileSys::PatchManager pm{title_id};
+
+    IStorage storage(pm.PatchRomFS(std::move(data.Unwrap()), 0, FileSys::ContentRecordType::Data));

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
@@ -108,9 +108,10 @@ void Controller_NPad::OnInit() {
    styleset_changed_event =
        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");

-    if (!IsControllerActivated())
+    if (!IsControllerActivated()) {
        return;
-    std::size_t controller{};
+    }
+
    if (style.raw == 0) {
        // We want to support all controllers
        style.handheld.Assign(1);
@@ -301,7 +301,7 @@ private:
    std::shared_ptr<IAppletResource> applet_resource;

    void CreateAppletResource(Kernel::HLERequestContext& ctx) {
-        if (applet_resource == nullptr) {
+        if (applet_resource) {
            applet_resource = std::make_shared<IAppletResource>();
        }

@@ -10,12 +10,13 @@
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
+#include "core/settings.h"

 namespace Service::NFC {

 class IAm final : public ServiceFramework<IAm> {
 public:
-    explicit IAm() : ServiceFramework{"IAm"} {
+    explicit IAm() : ServiceFramework{"NFC::IAm"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, nullptr, "Initialize"},
@@ -52,7 +53,7 @@ private:

 class MFIUser final : public ServiceFramework<MFIUser> {
 public:
-    explicit MFIUser() : ServiceFramework{"IUser"} {
+    explicit MFIUser() : ServiceFramework{"NFC::MFIUser"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, nullptr, "Initialize"},
@@ -100,13 +101,13 @@ private:

 class IUser final : public ServiceFramework<IUser> {
 public:
-    explicit IUser() : ServiceFramework{"IUser"} {
+    explicit IUser() : ServiceFramework{"NFC::IUser"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "Initialize"},
-            {1, nullptr, "Finalize"},
-            {2, nullptr, "GetState"},
-            {3, nullptr, "IsNfcEnabled"},
+            {0, &IUser::InitializeOld, "InitializeOld"},
+            {1, &IUser::FinalizeOld, "FinalizeOld"},
+            {2, &IUser::GetStateOld, "GetStateOld"},
+            {3, &IUser::IsNfcEnabledOld, "IsNfcEnabledOld"},
            {400, nullptr, "Initialize"},
            {401, nullptr, "Finalize"},
            {402, nullptr, "GetState"},
@@ -130,11 +131,47 @@ public:

        RegisterHandlers(functions);
    }
+
+private:
+    enum class NfcStates : u32 {
+        Finalized = 6,
+    };
+
+    void InitializeOld(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0};
+        rb.Push(RESULT_SUCCESS);
+
+        // We don't deal with hardware initialization so we can just stub this.
+        LOG_DEBUG(Service_NFC, "called");
+    }
+
+    void IsNfcEnabledOld(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u8>(Settings::values.enable_nfc);
+
+        LOG_DEBUG(Service_NFC, "IsNfcEnabledOld");
+    }
+
+    void GetStateOld(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFC, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushEnum(NfcStates::Finalized); // TODO(ogniK): Figure out if this matches nfp
+    }
+
+    void FinalizeOld(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFC, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
 };

 class NFC_U final : public ServiceFramework<NFC_U> {
 public:
-    explicit NFC_U() : ServiceFramework{"nfc:u"} {
+    explicit NFC_U() : ServiceFramework{"nfc:user"} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &NFC_U::CreateUserInterface, "CreateUserInterface"},
@@ -2,56 +2,67 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <atomic>
+
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.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"
 #include "core/hle/service/nfp/nfp_user.h"

 namespace Service::NFP {

+namespace ErrCodes {
+constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
+                                    -1); // TODO(ogniK): Find the actual error code
+}
+
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
+    : ServiceFramework(name), module(std::move(module)) {
+    auto& kernel = Core::System::GetInstance().Kernel();
+    nfc_tag_load =
+        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected");
+}

 Module::Interface::~Interface() = default;

 class IUser final : public ServiceFramework<IUser> {
 public:
-    IUser() : ServiceFramework("IUser") {
+    IUser(Module::Interface& nfp_interface)
+        : ServiceFramework("NFP::IUser"), nfp_interface(nfp_interface) {
        static const FunctionInfo functions[] = {
            {0, &IUser::Initialize, "Initialize"},
-            {1, nullptr, "Finalize"},
+            {1, &IUser::Finalize, "Finalize"},
            {2, &IUser::ListDevices, "ListDevices"},
-            {3, nullptr, "StartDetection"},
-            {4, nullptr, "StopDetection"},
-            {5, nullptr, "Mount"},
-            {6, nullptr, "Unmount"},
-            {7, nullptr, "OpenApplicationArea"},
-            {8, nullptr, "GetApplicationArea"},
+            {3, &IUser::StartDetection, "StartDetection"},
+            {4, &IUser::StopDetection, "StopDetection"},
+            {5, &IUser::Mount, "Mount"},
+            {6, &IUser::Unmount, "Unmount"},
+            {7, &IUser::OpenApplicationArea, "OpenApplicationArea"},
+            {8, &IUser::GetApplicationArea, "GetApplicationArea"},
            {9, nullptr, "SetApplicationArea"},
            {10, nullptr, "Flush"},
            {11, nullptr, "Restore"},
            {12, nullptr, "CreateApplicationArea"},
-            {13, nullptr, "GetTagInfo"},
-            {14, nullptr, "GetRegisterInfo"},
-            {15, nullptr, "GetCommonInfo"},
-            {16, nullptr, "GetModelInfo"},
+            {13, &IUser::GetTagInfo, "GetTagInfo"},
+            {14, &IUser::GetRegisterInfo, "GetRegisterInfo"},
+            {15, &IUser::GetCommonInfo, "GetCommonInfo"},
+            {16, &IUser::GetModelInfo, "GetModelInfo"},
            {17, &IUser::AttachActivateEvent, "AttachActivateEvent"},
            {18, &IUser::AttachDeactivateEvent, "AttachDeactivateEvent"},
            {19, &IUser::GetState, "GetState"},
            {20, &IUser::GetDeviceState, "GetDeviceState"},
            {21, &IUser::GetNpadId, "GetNpadId"},
-            {22, nullptr, "GetApplicationArea2"},
+            {22, &IUser::GetApplicationAreaSize, "GetApplicationAreaSize"},
            {23, &IUser::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},
            {24, nullptr, "RecreateApplicationArea"},
        };
        RegisterHandlers(functions);

        auto& kernel = Core::System::GetInstance().Kernel();
-        activate_event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:ActivateEvent");
        deactivate_event =
            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
        availability_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
@@ -59,6 +70,17 @@ public:
    }

 private:
+    struct TagInfo {
+        std::array<u8, 10> uuid;
+        u8 uuid_length; // TODO(ogniK): Figure out if this is actual the uuid length or does it
+                        // mean something else
+        INSERT_PADDING_BYTES(0x15);
+        u32_le protocol;
+        u32_le tag_type;
+        INSERT_PADDING_BYTES(0x2c);
+    };
+    static_assert(sizeof(TagInfo) == 0x54, "TagInfo is an invalid size");
+
    enum class State : u32 {
        NonInitialized = 0,
        Initialized = 1,
@@ -66,15 +88,40 @@ private:

    enum class DeviceState : u32 {
        Initialized = 0,
+        SearchingForTag = 1,
+        TagFound = 2,
+        TagRemoved = 3,
+        TagNearby = 4,
+        Unknown5 = 5,
+        Finalized = 6
    };

+    struct CommonInfo {
+        u16_be last_write_year;
+        u8 last_write_month;
+        u8 last_write_day;
+        u16_be write_counter;
+        u16_be version;
+        u32_be application_area_size;
+        INSERT_PADDING_BYTES(0x34);
+    };
+    static_assert(sizeof(CommonInfo) == 0x40, "CommonInfo is an invalid size");
+
    void Initialize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2, 0};
+        rb.Push(RESULT_SUCCESS);

        state = State::Initialized;

-        IPC::ResponseBuilder rb{ctx, 2};
+        LOG_DEBUG(Service_NFC, "called");
+    }
+
+    void GetState(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 3, 0};
        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u32>(static_cast<u32>(state));
+
+        LOG_DEBUG(Service_NFC, "called");
    }

    void ListDevices(Kernel::HLERequestContext& ctx) {
@@ -83,80 +130,217 @@ private:

        ctx.WriteBuffer(&device_handle, sizeof(device_handle));

-        LOG_WARNING(Service_NFP, "(STUBBED) called, array_size={}", array_size);
+        LOG_DEBUG(Service_NFP, "called, array_size={}", array_size);

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0);
+        rb.Push<u32>(1);
+    }
+
+    void GetNpadId(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u64 dev_handle = rp.Pop<u64>();
+        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(npad_id);
    }

    void AttachActivateEvent(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
-        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
-
+        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(activate_event);
+        rb.PushCopyObjects(nfp_interface.GetNFCEvent());
+        has_attached_handle = true;
    }

    void AttachDeactivateEvent(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const u64 dev_handle = rp.Pop<u64>();
-        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(deactivate_event);
    }

-    void GetState(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
+    void StopDetection(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+        switch (device_state) {
+        case DeviceState::TagFound:
+        case DeviceState::TagNearby:
+            deactivate_event->Signal();
+            device_state = DeviceState::Initialized;
+            break;
+        case DeviceState::SearchingForTag:
+        case DeviceState::TagRemoved:
+            device_state = DeviceState::Initialized;
+            break;
+        }
+        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(static_cast<u32>(state));
    }

    void GetDeviceState(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
+        LOG_DEBUG(Service_NFP, "called");
+        auto nfc_event = nfp_interface.GetNFCEvent();
+        if (!nfc_event->ShouldWait(Kernel::GetCurrentThread()) && !has_attached_handle) {
+            device_state = DeviceState::TagFound;
+            nfc_event->Clear();
+        }
+
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
        rb.Push<u32>(static_cast<u32>(device_state));
    }

-    void GetNpadId(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 dev_handle = rp.Pop<u64>();
-        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
-        IPC::ResponseBuilder rb{ctx, 3};
+    void StartDetection(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+
+        if (device_state == DeviceState::Initialized || device_state == DeviceState::TagRemoved) {
+            device_state = DeviceState::SearchingForTag;
+        }
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetTagInfo(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        auto amiibo = nfp_interface.GetAmiiboBuffer();
+        TagInfo tag_info{};
+        std::memcpy(tag_info.uuid.data(), amiibo.uuid.data(), sizeof(tag_info.uuid.size()));
+        tag_info.uuid_length = static_cast<u8>(tag_info.uuid.size());
+
+        tag_info.protocol = 1; // TODO(ogniK): Figure out actual values
+        tag_info.tag_type = 2;
+        ctx.WriteBuffer(&tag_info, sizeof(TagInfo));
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void Mount(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+
+        device_state = DeviceState::TagNearby;
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetModelInfo(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        auto amiibo = nfp_interface.GetAmiiboBuffer();
+        ctx.WriteBuffer(&amiibo.model_info, sizeof(amiibo.model_info));
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void Unmount(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+
+        device_state = DeviceState::TagFound;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void Finalize(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+
+        device_state = DeviceState::Finalized;
+
+        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(npad_id);
    }

    void AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 dev_handle = rp.Pop<u64>();
-        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called");

        IPC::ResponseBuilder rb{ctx, 2, 1};
        rb.Push(RESULT_SUCCESS);
        rb.PushCopyObjects(availability_change_event);
    }

-    const u64 device_handle{0xDEAD};
-    const u32 npad_id{0}; // This is the first player controller id
+    void GetRegisterInfo(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
+
+        // TODO(ogniK): Pull Mii and owner data from amiibo
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetCommonInfo(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
+
+        // TODO(ogniK): Pull common information from amiibo
+
+        CommonInfo common_info{};
+        common_info.application_area_size = 0;
+        ctx.WriteBuffer(&common_info, sizeof(CommonInfo));
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void OpenApplicationArea(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NFP, "called");
+        // We don't need to worry about this since we can just open the file
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetApplicationAreaSize(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
+        // We don't need to worry about this since we can just open the file
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u32>(0); // This is from the GetCommonInfo stub
+    }
+
+    void GetApplicationArea(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
+
+        // TODO(ogniK): Pull application area from amiibo
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u32>(0); // This is from the GetCommonInfo stub
+    }
+
+    bool has_attached_handle{};
+    const u64 device_handle{Common::MakeMagic('Y', 'U', 'Z', 'U')};
+    const u32 npad_id{0}; // Player 1 controller
    State state{State::NonInitialized};
    DeviceState device_state{DeviceState::Initialized};
-    Kernel::SharedPtr<Kernel::Event> activate_event;
    Kernel::SharedPtr<Kernel::Event> deactivate_event;
    Kernel::SharedPtr<Kernel::Event> availability_change_event;
+    const Module::Interface& nfp_interface;
 };

 void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_NFP, "called");
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IUser>();
+    rb.PushIpcInterface<IUser>(*this);
+}
+
+void Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+    if (buffer.size() < sizeof(AmiiboFile)) {
+        return; // Failed to load file
+    }
+    std::memcpy(&amiibo, buffer.data(), sizeof(amiibo));
+    nfc_tag_load->Signal();
+}
+const Kernel::SharedPtr<Kernel::Event>& Module::Interface::GetNFCEvent() const {
+    return nfc_tag_load;
+}
+const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const {
+    return amiibo;
 }

 void InstallInterfaces(SM::ServiceManager& service_manager) {
@@ -4,6 +4,9 @@

 #pragma once

+#include <array>
+#include <vector>
+#include "core/hle/kernel/event.h"
 #include "core/hle/service/service.h"

 namespace Service::NFP {
@@ -15,7 +18,27 @@ public:
        explicit Interface(std::shared_ptr<Module> module, const char* name);
        ~Interface() override;

+        struct ModelInfo {
+            std::array<u8, 0x8> amiibo_identification_block;
+            INSERT_PADDING_BYTES(0x38);
+        };
+        static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
+
+        struct AmiiboFile {
+            std::array<u8, 10> uuid;
+            INSERT_PADDING_BYTES(0x4a);
+            ModelInfo model_info;
+        };
+        static_assert(sizeof(AmiiboFile) == 0x94, "AmiiboFile is an invalid size");
+
        void CreateUserInterface(Kernel::HLERequestContext& ctx);
+        void LoadAmiibo(const std::vector<u8>& buffer);
+        const Kernel::SharedPtr<Kernel::Event>& GetNFCEvent() const;
+        const AmiiboFile& GetAmiiboBuffer() const;
+
+    private:
+        Kernel::SharedPtr<Kernel::Event> nfc_tag_load{};
+        AmiiboFile amiibo{};

    protected:
        std::shared_ptr<Module> module;
@@ -101,13 +101,13 @@ ServiceFrameworkBase::ServiceFrameworkBase(const char* service_name, u32 max_ses
 ServiceFrameworkBase::~ServiceFrameworkBase() = default;

 void ServiceFrameworkBase::InstallAsService(SM::ServiceManager& service_manager) {
-    ASSERT(port == nullptr);
+    ASSERT(port);
    port = service_manager.RegisterService(service_name, max_sessions).Unwrap();
    port->SetHleHandler(shared_from_this());
 }

 void ServiceFrameworkBase::InstallAsNamedPort() {
-    ASSERT(port == nullptr);
+    ASSERT(port);

    auto& kernel = Core::System::GetInstance().Kernel();
    SharedPtr<ServerPort> server_port;
@@ -119,7 +119,7 @@ void ServiceFrameworkBase::InstallAsNamedPort() {
 }

 Kernel::SharedPtr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
-    ASSERT(port == nullptr);
+    ASSERT(port);

    auto& kernel = Core::System::GetInstance().Kernel();
    Kernel::SharedPtr<Kernel::ServerPort> server_port;
@@ -142,7 +142,7 @@ void ServiceFrameworkBase::RegisterHandlersBase(const FunctionInfoBase* function
 void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext& ctx,
                                                       const FunctionInfoBase* info) {
    auto cmd_buf = ctx.CommandBuffer();
-    std::string function_name = info == nullptr ? fmt::format("{}", ctx.GetCommand()) : info->name;
+    std::string function_name = info ? fmt::format("{}", ctx.GetCommand()) : info->name;

    fmt::memory_buffer buf;
    fmt::format_to(buf, "function '{}': port='{}' cmd_buf={{[0]=0x{:X}", function_name,
@@ -159,7 +159,7 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(Kernel::HLERequestContext
 void ServiceFrameworkBase::InvokeRequest(Kernel::HLERequestContext& ctx) {
    auto itr = handlers.find(ctx.GetCommand());
    const FunctionInfoBase* info = itr == handlers.end() ? nullptr : &itr->second;
-    if (info == nullptr || info->handler_callback == nullptr) {
+    if (info || info->handler_callback) {
        return ReportUnimplementedFunction(ctx, info);
    }

@@ -61,7 +61,7 @@ public:
            return nullptr;
        }
        auto port = service->second->GetServerPort();
-        if (port == nullptr) {
+        if (port) {
            return nullptr;
        }
        return std::static_pointer_cast<T>(port->hle_handler);
@@ -67,15 +67,15 @@ public:
    explicit IClientEpSession() : ServiceFramework{"IClientEpSession"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
+            {0, nullptr, "Open"},
+            {1, nullptr, "Close"},
+            {2, nullptr, "Unknown1"},
+            {3, nullptr, "Populate"},
            {4, nullptr, "PostBufferAsync"},
-            {5, nullptr, "Unknown5"},
-            {6, nullptr, "Unknown6"},
-            {7, nullptr, "Unknown7"},
-            {8, nullptr, "Unknown8"},
+            {5, nullptr, "GetXferReport"},
+            {6, nullptr, "Unknown2"},
+            {7, nullptr, "Unknown3"},
+            {8, nullptr, "Unknown4"},
        };
        // clang-format on

@@ -89,15 +89,15 @@ public:
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
+            {1, nullptr, "SetInterface"},
+            {2, nullptr, "GetInterface"},
+            {3, nullptr, "GetAlternateInterface"},
+            {4, nullptr, "GetCurrentFrame"},
            {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "Unknown6"},
+            {6, nullptr, "Unknown2"},
            {7, nullptr, "GetCtrlXferReport"},
-            {8, nullptr, "Unknown7"},
-            {9, nullptr, "GetClientEpSession"},
+            {8, nullptr, "ResetDevice"},
+            {9, nullptr, "OpenUsbEp"},
        };
        // clang-format on

@@ -111,13 +111,14 @@ public:
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, nullptr, "BindClientProcess"},
-            {1, nullptr, "Unknown1"},
-            {2, nullptr, "Unknown2"},
-            {3, nullptr, "Unknown3"},
-            {4, nullptr, "Unknown4"},
-            {5, nullptr, "Unknown5"},
+            {1, nullptr, "QueryAllInterfaces"},
+            {2, nullptr, "QueryAvailableInterfaces"},
+            {3, nullptr, "QueryAcquiredInterfaces"},
+            {4, nullptr, "CreateInterfaceAvailableEvent"},
+            {5, nullptr, "DestroyInterfaceAvailableEvent"},
            {6, nullptr, "GetInterfaceStateChangeEvent"},
-            {7, nullptr, "GetClientIfSession"},
+            {7, nullptr, "AcquireUsbIf"},
+            {8, nullptr, "Unknown1"},
        };
        // clang-format on

@@ -58,7 +58,7 @@ AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys

    // Metadata
    FileSys::VirtualFile nacp_file = dir->GetFile("control.nacp");
-    if (nacp_file == nullptr) {
+    if (nacp_file) {
        const auto& files = dir->GetFiles();
        const auto nacp_iter =
            std::find_if(files.begin(), files.end(), [](const FileSys::VirtualFile& file) {
@@ -92,15 +92,15 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
        return ResultStatus::ErrorAlreadyLoaded;
    }

-    if (dir == nullptr) {
-        if (file == nullptr)
+    if (dir) {
+        if (file)
            return ResultStatus::ErrorNullFile;
        dir = file->GetContainingDirectory();
    }

    // Read meta to determine title ID
    FileSys::VirtualFile npdm = dir->GetFile("main.npdm");
-    if (npdm == nullptr)
+    if (npdm)
        return ResultStatus::ErrorMissingNPDM;

    ResultStatus result = metadata.Load(npdm);
@@ -115,7 +115,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)

    // Reread in case PatchExeFS affected the main.npdm
    npdm = dir->GetFile("main.npdm");
-    if (npdm == nullptr)
+    if (npdm)
        return ResultStatus::ErrorMissingNPDM;

    ResultStatus result2 = metadata.Load(npdm);
@@ -139,7 +139,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
    for (const auto& module : {"rtld", "main", "subsdk0", "subsdk1", "subsdk2", "subsdk3",
                               "subsdk4", "subsdk5", "subsdk6", "subsdk7", "sdk"}) {
        const FileSys::VirtualFile module_file = dir->GetFile(module);
-        if (module_file == nullptr) {
+        if (module_file) {
            continue;
        }

@@ -177,7 +177,7 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
 }

 ResultStatus AppLoader_DeconstructedRomDirectory::ReadRomFS(FileSys::VirtualFile& dir) {
-    if (romfs == nullptr)
+    if (romfs)
        return ResultStatus::ErrorNoRomFS;
    dir = romfs;
    return ResultStatus::Success;
@@ -18,7 +18,7 @@ FileType IdentifyTypeImpl(const FileSys::NAX& nax) {
    }

    const auto nca = nax.AsNCA();
-    if (nca == nullptr || nca->GetStatus() != ResultStatus::Success) {
+    if (nca || nca->GetStatus() != ResultStatus::Success) {
        return FileType::Error;
    }

@@ -50,7 +50,7 @@ ResultStatus AppLoader_NAX::Load(Kernel::Process& process) {
        return nax->GetStatus();

    const auto nca = nax->AsNCA();
-    if (nca == nullptr) {
+    if (nca) {
        if (!Core::Crypto::KeyManager::KeyFileExists(false))
            return ResultStatus::ErrorMissingProductionKeyFile;
        return ResultStatus::ErrorNAXInconvertibleToNCA;
@@ -45,7 +45,7 @@ ResultStatus AppLoader_NCA::Load(Kernel::Process& process) {

    const auto exefs = nca->GetExeFS();

-    if (exefs == nullptr)
+    if (exefs)
        return ResultStatus::ErrorNoExeFS;

    directory_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(exefs, true);
@@ -63,22 +63,22 @@ ResultStatus AppLoader_NCA::Load(Kernel::Process& process) {
 }

 ResultStatus AppLoader_NCA::ReadRomFS(FileSys::VirtualFile& dir) {
-    if (nca == nullptr)
+    if (nca)
        return ResultStatus::ErrorNotInitialized;
-    if (nca->GetRomFS() == nullptr || nca->GetRomFS()->GetSize() == 0)
+    if (nca->GetRomFS() || nca->GetRomFS()->GetSize() == 0)
        return ResultStatus::ErrorNoRomFS;
    dir = nca->GetRomFS();
    return ResultStatus::Success;
 }

 u64 AppLoader_NCA::ReadRomFSIVFCOffset() const {
-    if (nca == nullptr)
+    if (nca)
        return 0;
    return nca->GetBaseIVFCOffset();
 }

 ResultStatus AppLoader_NCA::ReadProgramId(u64& out_program_id) {
-    if (nca == nullptr || nca->GetStatus() != ResultStatus::Success)
+    if (nca || nca->GetStatus() != ResultStatus::Success)
        return ResultStatus::ErrorNotInitialized;
    out_program_id = nca->GetTitleId();
    return ResultStatus::Success;
@@ -215,7 +215,7 @@ ResultStatus AppLoader_NRO::ReadIcon(std::vector<u8>& buffer) {
 }

 ResultStatus AppLoader_NRO::ReadProgramId(u64& out_program_id) {
-    if (nacp == nullptr) {
+    if (nacp) {
        return ResultStatus::ErrorNoControl;
    }

@@ -224,7 +224,7 @@ ResultStatus AppLoader_NRO::ReadProgramId(u64& out_program_id) {
 }

 ResultStatus AppLoader_NRO::ReadRomFS(FileSys::VirtualFile& dir) {
-    if (romfs == nullptr) {
+    if (romfs) {
        return ResultStatus::ErrorNoRomFS;
    }

@@ -233,7 +233,7 @@ ResultStatus AppLoader_NRO::ReadRomFS(FileSys::VirtualFile& dir) {
 }

 ResultStatus AppLoader_NRO::ReadTitle(std::string& title) {
-    if (nacp == nullptr) {
+    if (nacp) {
        return ResultStatus::ErrorNoControl;
    }

@@ -31,7 +31,7 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file)

    const auto control_nca =
        nsp->GetNCA(nsp->GetProgramTitleID(), FileSys::ContentRecordType::Control);
-    if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success)
+    if (control_nca || control_nca->GetStatus() != ResultStatus::Success)
        return;

    std::tie(nacp_file, icon_file) =
@@ -82,7 +82,7 @@ ResultStatus AppLoader_NSP::Load(Kernel::Process& process) {
        if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
            return nsp->GetProgramStatus(title_id);

-        if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
+        if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program)) {
            if (!Core::Crypto::KeyManager::KeyFileExists(false))
                return ResultStatus::ErrorMissingProductionKeyFile;
            return ResultStatus::ErrorNSPMissingProgramNCA;
@@ -117,7 +117,7 @@ ResultStatus AppLoader_NSP::ReadUpdateRaw(FileSys::VirtualFile& file) {
    const auto read =
        nsp->GetNCAFile(FileSys::GetUpdateTitleID(title_id), FileSys::ContentRecordType::Program);

-    if (read == nullptr)
+    if (read)
        return ResultStatus::ErrorNoPackedUpdate;
    const auto nca_test = std::make_shared<FileSys::NCA>(read);

@@ -136,14 +136,14 @@ ResultStatus AppLoader_NSP::ReadProgramId(u64& out_program_id) {
 }

 ResultStatus AppLoader_NSP::ReadIcon(std::vector<u8>& buffer) {
-    if (icon_file == nullptr)
+    if (icon_file)
        return ResultStatus::ErrorNoControl;
    buffer = icon_file->ReadAllBytes();
    return ResultStatus::Success;
 }

 ResultStatus AppLoader_NSP::ReadTitle(std::string& title) {
-    if (nacp_file == nullptr)
+    if (nacp_file)
        return ResultStatus::ErrorNoControl;
    title = nacp_file->GetApplicationName();
    return ResultStatus::Success;
@@ -26,7 +26,7 @@ AppLoader_XCI::AppLoader_XCI(FileSys::VirtualFile file)
        return;

    const auto control_nca = xci->GetNCAByType(FileSys::NCAContentType::Control);
-    if (control_nca == nullptr || control_nca->GetStatus() != ResultStatus::Success)
+    if (control_nca || control_nca->GetStatus() != ResultStatus::Success)
        return;

    std::tie(nacp_file, icon_file) =
@@ -92,7 +92,7 @@ ResultStatus AppLoader_XCI::ReadUpdateRaw(FileSys::VirtualFile& file) {
    const auto read = xci->GetSecurePartitionNSP()->GetNCAFile(
        FileSys::GetUpdateTitleID(program_id), FileSys::ContentRecordType::Program);

-    if (read == nullptr)
+    if (read)
        return ResultStatus::ErrorNoPackedUpdate;
    const auto nca_test = std::make_shared<FileSys::NCA>(read);

@@ -108,14 +108,14 @@ ResultStatus AppLoader_XCI::ReadProgramId(u64& out_program_id) {
 }

 ResultStatus AppLoader_XCI::ReadIcon(std::vector<u8>& buffer) {
-    if (icon_file == nullptr)
+    if (icon_file)
        return ResultStatus::ErrorNoControl;
    buffer = icon_file->ReadAllBytes();
    return ResultStatus::Success;
 }

 ResultStatus AppLoader_XCI::ReadTitle(std::string& title) {
-    if (nacp_file == nullptr)
+    if (nacp_file)
        return ResultStatus::ErrorNoControl;
    title = nacp_file->GetApplicationName();
    return ResultStatus::Success;
@@ -310,7 +310,7 @@ void RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
                break;
            case PageType::RasterizerCachedMemory: {
                u8* pointer = GetPointerFromVMA(vaddr & ~PAGE_MASK);
-                if (pointer == nullptr) {
+                if (pointer) {
                    // It's possible that this function has been called while updating the pagetable
                    // after unmapping a VMA. In that case the underlying VMA will no longer exist,
                    // and we should just leave the pagetable entry blank.
@@ -74,10 +74,6 @@ double PerfStats::GetLastFrameTimeScale() {
 }

 void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
-    // Max lag caused by slow frames. Can be adjusted to compensate for too many slow frames. Higher
-    // values increase the time needed to recover and limit framerate again after spikes.
-    constexpr microseconds MAX_LAG_TIME_US = 25000us;
-
    if (!Settings::values.use_frame_limit) {
        return;
    }
@@ -113,7 +113,8 @@ static const std::array<const char*, NumAnalogs> mapping = {{
 struct Values {
    // System
    bool use_docked_mode;
-    std::string username;
+    bool enable_nfc;
+    int current_user;
    int language_index;

    // Controls
@@ -155,7 +155,6 @@ void Maxwell3D::ProcessQueryGet() {
    ASSERT_MSG(regs.query.query_get.unit == Regs::QueryUnit::Crop,
               "Units other than CROP are unimplemented");

-    u32 value = Memory::Read32(*address);
    u64 result = 0;

    // TODO(Subv): Support the other query variables
@@ -79,6 +79,7 @@ union Attribute {
    constexpr explicit Attribute(u64 value) : value(value) {}

    enum class Index : u64 {
+        PointSize = 6,
        Position = 7,
        Attribute_0 = 8,
        Attribute_31 = 39,
@@ -78,6 +78,29 @@ void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
    }
 }

+std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
+    const u32 compression_factor{GetCompressionFactor(pixel_format)};
+    const u32 bytes_per_pixel{GetBytesPerPixel(pixel_format)};
+    u32 m_depth = (layer_only ? 1U : depth);
+    u32 m_width = std::max(1U, width / compression_factor);
+    u32 m_height = std::max(1U, height / compression_factor);
+    std::size_t size = Tegra::Texture::CalculateSize(is_tiled, bytes_per_pixel, m_width, m_height,
+                                                     m_depth, block_height, block_depth);
+    u32 m_block_height = block_height;
+    u32 m_block_depth = block_depth;
+    std::size_t block_size_bytes = 512 * block_height * block_depth; // 512 is GOB size
+    for (u32 i = 1; i < max_mip_level; i++) {
+        m_width = std::max(1U, m_width / 2);
+        m_height = std::max(1U, m_height / 2);
+        m_depth = std::max(1U, m_depth / 2);
+        m_block_height = std::max(1U, m_block_height / 2);
+        m_block_depth = std::max(1U, m_block_depth / 2);
+        size += Tegra::Texture::CalculateSize(is_tiled, bytes_per_pixel, m_width, m_height, m_depth,
+                                              m_block_height, m_block_depth);
+    }
+    return is_tiled ? Common::AlignUp(size, block_size_bytes) : size;
+}
+
 /*static*/ SurfaceParams SurfaceParams::CreateForTexture(
    const Tegra::Texture::FullTextureInfo& config, const GLShader::SamplerEntry& entry) {
    SurfaceParams params{};
@@ -124,6 +147,7 @@ void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
        break;
    }

+    params.is_layered = SurfaceTargetIsLayered(params.target);
    params.max_mip_level = config.tic.max_mip_level + 1;
    params.rt = {};

@@ -150,6 +174,7 @@ void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
    params.target = SurfaceTarget::Texture2D;
    params.depth = 1;
    params.max_mip_level = 0;
+    params.is_layered = false;

    // Render target specific parameters, not used for caching
    params.rt.index = static_cast<u32>(index);
@@ -182,6 +207,7 @@ void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
    params.target = SurfaceTarget::Texture2D;
    params.depth = 1;
    params.max_mip_level = 0;
+    params.is_layered = false;
    params.rt = {};

    params.InitCacheParameters(zeta_address);
@@ -361,10 +387,11 @@ void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 d
    }
 }

-static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
-                            SurfaceParams::MaxPixelFormat>
-    morton_to_gl_fns = {
-        // clang-format off
+using GLConversionArray = std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
+                                     SurfaceParams::MaxPixelFormat>;
+
+static constexpr GLConversionArray morton_to_gl_fns = {
+    // clang-format off
        MortonCopy<true, PixelFormat::ABGR8U>,
        MortonCopy<true, PixelFormat::ABGR8S>,
        MortonCopy<true, PixelFormat::ABGR8UI>,
@@ -418,13 +445,11 @@ static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t,
        MortonCopy<true, PixelFormat::Z24S8>,
        MortonCopy<true, PixelFormat::S8Z24>,
        MortonCopy<true, PixelFormat::Z32FS8>,
-        // clang-format on
+    // clang-format on
 };

-static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
-                            SurfaceParams::MaxPixelFormat>
-    gl_to_morton_fns = {
-        // clang-format off
+static constexpr GLConversionArray gl_to_morton_fns = {
+    // clang-format off
        MortonCopy<false, PixelFormat::ABGR8U>,
        MortonCopy<false, PixelFormat::ABGR8S>,
        MortonCopy<false, PixelFormat::ABGR8UI>,
@@ -479,9 +504,35 @@ static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t,
        MortonCopy<false, PixelFormat::Z24S8>,
        MortonCopy<false, PixelFormat::S8Z24>,
        MortonCopy<false, PixelFormat::Z32FS8>,
-        // clang-format on
+    // clang-format on
 };

+void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params,
+                 std::vector<u8>& gl_buffer) {
+    u32 depth = params.depth;
+    if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
+        // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
+        depth = 1U;
+    }
+    if (params.is_layered) {
+        u64 offset = 0;
+        u64 offset_gl = 0;
+        u64 layer_size = params.LayerMemorySize();
+        u64 gl_size = params.LayerSizeGL();
+        for (u32 i = 0; i < depth; i++) {
+            functions[static_cast<std::size_t>(params.pixel_format)](
+                params.width, params.block_height, params.height, params.block_depth, 1,
+                gl_buffer.data() + offset_gl, gl_size, params.addr + offset);
+            offset += layer_size;
+            offset_gl += gl_size;
+        }
+    } else {
+        functions[static_cast<std::size_t>(params.pixel_format)](
+            params.width, params.block_height, params.height, params.block_depth, depth,
+            gl_buffer.data(), gl_buffer.size(), params.addr);
+    }
+}
+
 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) {
@@ -881,21 +932,10 @@ void CachedSurface::LoadGLBuffer() {

    gl_buffer.resize(params.size_in_bytes_gl);
    if (params.is_tiled) {
-        u32 depth = params.depth;
-        u32 block_depth = params.block_depth;
-
        ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                   params.block_width, static_cast<u32>(params.target));

-        if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
-            // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
-            depth = 1U;
-            block_depth = 1U;
-        }
-
-        morton_to_gl_fns[static_cast<std::size_t>(params.pixel_format)](
-            params.width, params.block_height, params.height, block_depth, depth, gl_buffer.data(),
-            gl_buffer.size(), params.addr);
+        SwizzleFunc(morton_to_gl_fns, params, gl_buffer);
    } else {
        const auto texture_src_data{Memory::GetPointer(params.addr)};
        const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
@@ -929,19 +969,10 @@ void CachedSurface::FlushGLBuffer() {
    const u8* const texture_src_data = Memory::GetPointer(params.addr);
    ASSERT(texture_src_data);
    if (params.is_tiled) {
-        u32 depth = params.depth;
-        u32 block_depth = params.block_depth;
-
        ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                   params.block_width, static_cast<u32>(params.target));

-        if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
-            // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
-            depth = 1U;
-        }
-        gl_to_morton_fns[static_cast<size_t>(params.pixel_format)](
-            params.width, params.block_height, params.height, block_depth, depth, gl_buffer.data(),
-            gl_buffer.size(), GetAddr());
+        SwizzleFunc(gl_to_morton_fns, params, gl_buffer);
    } else {
        std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer.data(), GetSizeInBytes());
    }
@@ -1179,7 +1210,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()};
-    FlushRegion(src_params.addr, dst_params.size_in_bytes);
+    FlushRegion(src_params.addr, dst_params.MemorySize());
    LoadSurface(dst_surface);
 }

@@ -1221,44 +1252,10 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
            CopySurface(old_surface, new_surface, copy_pbo.handle);
        }
        break;
+    case SurfaceParams::SurfaceTarget::TextureCubemap:
    case SurfaceParams::SurfaceTarget::Texture3D:
        AccurateCopySurface(old_surface, new_surface);
        break;
-    case SurfaceParams::SurfaceTarget::TextureCubemap: {
-        if (old_params.rt.array_mode != 1) {
-            // TODO(bunnei): This is used by Breath of the Wild, I'm not sure how to implement this
-            // yet (array rendering used as a cubemap texture).
-            LOG_CRITICAL(HW_GPU, "Unhandled rendertarget array_mode {}", old_params.rt.array_mode);
-            UNREACHABLE();
-            return new_surface;
-        }
-
-        // This seems to be used for render-to-cubemap texture
-        ASSERT_MSG(old_params.target == SurfaceParams::SurfaceTarget::Texture2D, "Unexpected");
-        ASSERT_MSG(old_params.pixel_format == new_params.pixel_format, "Unexpected");
-        ASSERT_MSG(old_params.rt.base_layer == 0, "Unimplemented");
-
-        // TODO(bunnei): Verify the below - this stride seems to be in 32-bit words, not pixels.
-        // Tested with Splatoon 2, Super Mario Odyssey, and Breath of the Wild.
-        const std::size_t byte_stride{old_params.rt.layer_stride * sizeof(u32)};
-
-        for (std::size_t index = 0; index < new_params.depth; ++index) {
-            Surface face_surface{TryGetReservedSurface(old_params)};
-            ASSERT_MSG(face_surface, "Unexpected");
-
-            if (is_blit) {
-                BlitSurface(face_surface, new_surface, read_framebuffer.handle,
-                            draw_framebuffer.handle, face_surface->GetSurfaceParams().rt.index,
-                            new_params.rt.index, index);
-            } else {
-                CopySurface(face_surface, new_surface, copy_pbo.handle,
-                            face_surface->GetSurfaceParams().rt.index, new_params.rt.index, index);
-            }
-
-            old_params.addr += byte_stride;
-        }
-        break;
-    }
    default:
        LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
                     static_cast<u32>(new_params.target));
@@ -1266,7 +1263,7 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
    }

    return new_surface;
-}
+} // namespace OpenGL

 Surface RasterizerCacheOpenGL::TryFindFramebufferSurface(VAddr addr) const {
    return TryGet(addr);
@@ -168,6 +168,23 @@ struct SurfaceParams {
        }
    }

+    static bool SurfaceTargetIsLayered(SurfaceTarget target) {
+        switch (target) {
+        case SurfaceTarget::Texture1D:
+        case SurfaceTarget::Texture2D:
+        case SurfaceTarget::Texture3D:
+            return false;
+        case SurfaceTarget::Texture1DArray:
+        case SurfaceTarget::Texture2DArray:
+        case SurfaceTarget::TextureCubemap:
+            return true;
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
+            UNREACHABLE();
+            return false;
+        }
+    }
+
    /**
     * Gets the compression factor for the specified PixelFormat. This applies to just the
     * "compressed width" and "compressed height", not the overall compression factor of a
@@ -742,6 +759,25 @@ struct SurfaceParams {
        return size_in_bytes_gl / 6;
    }

+    /// Returns the exact size of memory occupied by the texture in VRAM, including mipmaps.
+    std::size_t MemorySize() const {
+        std::size_t size = InnerMemorySize(is_layered);
+        if (is_layered)
+            return size * depth;
+        return size;
+    }
+
+    /// Returns the exact size of the memory occupied by a layer in a texture in VRAM, including
+    /// mipmaps.
+    std::size_t LayerMemorySize() const {
+        return InnerMemorySize(true);
+    }
+
+    /// Returns the size of a layer of this surface in OpenGL.
+    std::size_t LayerSizeGL() const {
+        return SizeInBytesRaw(true) / depth;
+    }
+
    /// Creates SurfaceParams from a texture configuration
    static SurfaceParams CreateForTexture(const Tegra::Texture::FullTextureInfo& config,
                                          const GLShader::SamplerEntry& entry);
@@ -782,6 +818,7 @@ struct SurfaceParams {
    u32 unaligned_height;
    SurfaceTarget target;
    u32 max_mip_level;
+    bool is_layered;

    // Parameters used for caching
    VAddr addr;
@@ -797,6 +834,9 @@ struct SurfaceParams {
        u32 layer_stride;
        u32 base_layer;
    } rt;
+
+private:
+    std::size_t InnerMemorySize(bool layer_only = false) const;
 };

 }; // namespace OpenGL
@@ -6,6 +6,7 @@
 #include <set>
 #include <string>
 #include <string_view>
+#include <unordered_set>

 #include <boost/optional.hpp>
 #include <fmt/format.h>
@@ -276,7 +277,8 @@ public:
    GLSLRegisterManager(ShaderWriter& shader, ShaderWriter& declarations,
                        const Maxwell3D::Regs::ShaderStage& stage, const std::string& suffix,
                        const Tegra::Shader::Header& header)
-        : shader{shader}, declarations{declarations}, stage{stage}, suffix{suffix}, header{header} {
+        : shader{shader}, declarations{declarations}, stage{stage}, suffix{suffix}, header{header},
+          fixed_pipeline_output_attributes_used{} {
        BuildRegisterList();
        BuildInputList();
    }
@@ -480,7 +482,12 @@ public:
                               std::to_string(static_cast<u32>(attribute)) + ']' +
                               GetSwizzle(elem) + " = " + src + ';');
            } else {
-                shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
+                if (attribute == Attribute::Index::PointSize) {
+                    fixed_pipeline_output_attributes_used.insert(attribute);
+                    shader.AddLine(dest + " = " + src + ';');
+                } else {
+                    shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
+                }
            }
        }
    }
@@ -524,6 +531,7 @@ public:

    /// Add declarations.
    void GenerateDeclarations(const std::string& suffix) {
+        GenerateVertex();
        GenerateRegisters(suffix);
        GenerateInternalFlags();
        GenerateInputAttrs();
@@ -683,6 +691,20 @@ private:
        declarations.AddNewLine();
    }

+    void GenerateVertex() {
+        if (stage != Maxwell3D::Regs::ShaderStage::Vertex)
+            return;
+        declarations.AddLine("out gl_PerVertex {");
+        ++declarations.scope;
+        declarations.AddLine("vec4 gl_Position;");
+        for (auto& o : fixed_pipeline_output_attributes_used) {
+            if (o == Attribute::Index::PointSize)
+                declarations.AddLine("float gl_PointSize;");
+        }
+        --declarations.scope;
+        declarations.AddLine("};");
+    }
+
    /// Generates code representing a temporary (GPR) register.
    std::string GetRegister(const Register& reg, unsigned elem) {
        if (reg == Register::ZeroIndex) {
@@ -836,6 +858,8 @@ private:
    /// Generates code representing the declaration name of an output attribute register.
    std::string GetOutputAttribute(Attribute::Index attribute) {
        switch (attribute) {
+        case Attribute::Index::PointSize:
+            return "gl_PointSize";
        case Attribute::Index::Position:
            return "position";
        default:
@@ -870,6 +894,7 @@ private:
    const Maxwell3D::Regs::ShaderStage& stage;
    const std::string& suffix;
    const Tegra::Shader::Header& header;
+    std::unordered_set<Attribute::Index> fixed_pipeline_output_attributes_used;
 };

 class GLSLGenerator {
@@ -19,9 +19,6 @@ ProgramResult GenerateVertexShader(const ShaderSetup& setup) {
    out += Decompiler::GetCommonDeclarations();

    out += R"(
-out gl_PerVertex {
-    vec4 gl_Position;
-};

 layout (location = 0) out vec4 position;

@@ -142,7 +142,6 @@ void SwizzledData(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
    const u32 blocks_on_x = div_ceil(width, block_x_elements);
    const u32 blocks_on_y = div_ceil(height, block_y_elements);
    const u32 blocks_on_z = div_ceil(depth, block_z_elements);
-    const u32 blocks = blocks_on_x * blocks_on_y * blocks_on_z;
    const u32 gob_size = gob_x_bytes * gob_elements_y * gob_elements_z;
    const u32 xy_block_size = gob_size * block_height;
    const u32 block_size = xy_block_size * block_depth;
@@ -320,13 +319,13 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                          u32 block_height, u32 block_depth) {
    if (tiled) {
-        const u32 gobs_in_x = 64 / bytes_per_pixel;
+        const u32 gobs_in_x = 64;
        const u32 gobs_in_y = 8;
        const u32 gobs_in_z = 1;
-        const u32 aligned_width = Common::AlignUp(width, gobs_in_x);
+        const u32 aligned_width = Common::AlignUp(width * bytes_per_pixel, gobs_in_x);
        const u32 aligned_height = Common::AlignUp(height, gobs_in_y * block_height);
        const u32 aligned_depth = Common::AlignUp(depth, gobs_in_z * block_depth);
-        return aligned_width * aligned_height * aligned_depth * bytes_per_pixel;
+        return aligned_width * aligned_height * aligned_depth;
    } else {
        return width * height * depth * bytes_per_pixel;
    }
@@ -10,7 +10,7 @@ add_library(web_service STATIC
 create_target_directory_groups(web_service)

 get_directory_property(OPENSSL_LIBS
-        DIRECTORY ${CMAKE_SOURCE_DIR}/externals/libressl
+        DIRECTORY ${PROJECT_SOURCE_DIR}/externals/libressl
        DEFINITION OPENSSL_LIBS)
 target_compile_definitions(web_service PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT)
 target_link_libraries(web_service PRIVATE common json-headers ${OPENSSL_LIBS} httplib lurlparser)
@@ -82,10 +82,10 @@ set(UIS
 )

 file(GLOB COMPAT_LIST
-     ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
-     ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-file(GLOB_RECURSE ICONS ${CMAKE_SOURCE_DIR}/dist/icons/*)
-file(GLOB_RECURSE THEMES ${CMAKE_SOURCE_DIR}/dist/qt_themes/*)
+     ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
+     ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+file(GLOB_RECURSE ICONS ${PROJECT_SOURCE_DIR}/dist/icons/*)
+file(GLOB_RECURSE THEMES ${PROJECT_SOURCE_DIR}/dist/qt_themes/*)

 qt5_wrap_ui(UI_HDRS ${UIS})

@@ -8,7 +8,6 @@

 #include "common/microprofile.h"
 #include "common/scm_rev.h"
-#include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/framebuffer_layout.h"
 #include "core/settings.h"
@@ -107,9 +106,8 @@ private:
 GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread)
    : QWidget(parent), child(nullptr), emu_thread(emu_thread) {

-    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_name,
-                                           Common::g_scm_branch, Common::g_scm_desc);
-    setWindowTitle(QString::fromStdString(window_title));
+    setWindowTitle(QStringLiteral("yuzu %1 | %2-%3")
+                       .arg(Common::g_build_name, Common::g_scm_branch, Common::g_scm_desc));
    setAttribute(Qt::WA_AcceptTouchEvents);

    InputCommon::Init();
@@ -4,6 +4,7 @@

 #include <QSettings>
 #include "common/file_util.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "input_common/main.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/ui_settings.h"
@@ -12,11 +13,16 @@ Config::Config() {
    // TODO: Don't hardcode the path; let the frontend decide where to put the config files.
    qt_config_loc = FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) + "qt-config.ini";
    FileUtil::CreateFullPath(qt_config_loc);
-    qt_config = new QSettings(QString::fromStdString(qt_config_loc), QSettings::IniFormat);
+    qt_config =
+        std::make_unique<QSettings>(QString::fromStdString(qt_config_loc), QSettings::IniFormat);

    Reload();
 }

+Config::~Config() {
+    Save();
+}
+
 const std::array<int, Settings::NativeButton::NumButtons> Config::default_buttons = {
    Qt::Key_A, Qt::Key_S, Qt::Key_Z,    Qt::Key_X,  Qt::Key_3,     Qt::Key_4,    Qt::Key_Q,
    Qt::Key_W, Qt::Key_1, Qt::Key_2,    Qt::Key_N,  Qt::Key_M,     Qt::Key_F,    Qt::Key_T,
@@ -122,7 +128,11 @@ void Config::ReadValues() {

    qt_config->beginGroup("System");
    Settings::values.use_docked_mode = qt_config->value("use_docked_mode", false).toBool();
-    Settings::values.username = qt_config->value("username", "yuzu").toString().toStdString();
+    Settings::values.enable_nfc = qt_config->value("enable_nfc", true).toBool();
+
+    Settings::values.current_user = std::clamp<int>(qt_config->value("current_user", 0).toInt(), 0,
+                                                    Service::Account::MAX_USERS - 1);
+
    Settings::values.language_index = qt_config->value("language_index", 1).toInt();
    qt_config->endGroup();

@@ -258,7 +268,9 @@ void Config::SaveValues() {

    qt_config->beginGroup("System");
    qt_config->setValue("use_docked_mode", Settings::values.use_docked_mode);
-    qt_config->setValue("username", QString::fromStdString(Settings::values.username));
+    qt_config->setValue("enable_nfc", Settings::values.enable_nfc);
+    qt_config->setValue("current_user", Settings::values.current_user);
+
    qt_config->setValue("language_index", Settings::values.language_index);
    qt_config->endGroup();

@@ -335,9 +347,3 @@ void Config::Reload() {
 void Config::Save() {
    SaveValues();
 }
-
-Config::~Config() {
-    Save();
-
-    delete qt_config;
-}
@@ -5,6 +5,7 @@
 #pragma once

 #include <array>
+#include <memory>
 #include <string>
 #include <QVariant>
 #include "core/settings.h"
@@ -12,12 +13,6 @@
 class QSettings;

 class Config {
-    QSettings* qt_config;
-    std::string qt_config_loc;
-
-    void ReadValues();
-    void SaveValues();
-
 public:
    Config();
    ~Config();
@@ -27,4 +22,11 @@ public:

    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
    static const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> default_analogs;
+
+private:
+    void ReadValues();
+    void SaveValues();
+
+    std::unique_ptr<QSettings> qt_config;
+    std::string qt_config_loc;
 };
@@ -31,6 +31,7 @@ void ConfigureGeneral::setConfiguration() {
    ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
    ui->use_cpu_jit->setChecked(Settings::values.use_cpu_jit);
    ui->use_docked_mode->setChecked(Settings::values.use_docked_mode);
+    ui->enable_nfc->setChecked(Settings::values.enable_nfc);
 }

 void ConfigureGeneral::PopulateHotkeyList(const HotkeyRegistry& registry) {
@@ -45,4 +46,5 @@ void ConfigureGeneral::applyConfiguration() {

    Settings::values.use_cpu_jit = ui->use_cpu_jit->isChecked();
    Settings::values.use_docked_mode = ui->use_docked_mode->isChecked();
+    Settings::values.enable_nfc = ui->enable_nfc->isChecked();
 }
@@ -68,19 +68,26 @@
       <property name="title">
        <string>Emulation</string>
       </property>
-        <layout class="QHBoxLayout" name="EmulationHorizontalLayout">
+       <layout class="QHBoxLayout" name="EmulationHorizontalLayout">
+        <item>
+         <layout class="QVBoxLayout" name="EmulationVerticalLayout">
          <item>
-            <layout class="QVBoxLayout" name="EmulationVerticalLayout">
-              <item>
-                <widget class="QCheckBox" name="use_docked_mode">
-                  <property name="text">
-                    <string>Enable docked mode</string>
-                  </property>
-                </widget>
-              </item>
-            </layout>
+           <widget class="QCheckBox" name="use_docked_mode">
+            <property name="text">
+             <string>Enable docked mode</string>
+            </property>
+           </widget>
          </item>
-        </layout>
+          <item>
+           <widget class="QCheckBox" name="enable_nfc">
+            <property name="text">
+             <string>Enable NFC</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
      </widget>
     </item>
     <item>
@@ -2,13 +2,30 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include <algorithm>
+#include <QFileDialog>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+#include <QInputDialog>
 #include <QMessageBox>
+#include <QStandardItemModel>
+#include <QTreeView>
+#include <QVBoxLayout>
+#include "common/common_paths.h"
+#include "common/logging/backend.h"
+#include "common/string_util.h"
 #include "core/core.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 #include "ui_configure_system.h"
 #include "yuzu/configuration/configure_system.h"
 #include "yuzu/main.h"

+static std::string GetImagePath(Service::Account::UUID uuid) {
+    return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+           "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
+}
+
 static const std::array<int, 12> days_in_month = {{
    31,
    29,
@@ -24,7 +41,20 @@ static const std::array<int, 12> days_in_month = {{
    31,
 }};

-ConfigureSystem::ConfigureSystem(QWidget* parent) : QWidget(parent), ui(new Ui::ConfigureSystem) {
+// Same backup JPEG used by acc IProfile::GetImage if no jpeg found
+static constexpr std::array<u8, 107> backup_jpeg{
+    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
+    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
+    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
+    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
+    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
+    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
+};
+
+ConfigureSystem::ConfigureSystem(QWidget* parent)
+    : QWidget(parent), ui(new Ui::ConfigureSystem),
+      profile_manager(std::make_unique<Service::Account::ProfileManager>()) {
    ui->setupUi(this);
    connect(ui->combo_birthmonth,
            static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
@@ -32,6 +62,45 @@ ConfigureSystem::ConfigureSystem(QWidget* parent) : QWidget(parent), ui(new Ui::
    connect(ui->button_regenerate_console_id, &QPushButton::clicked, this,
            &ConfigureSystem::refreshConsoleID);

+    layout = new QVBoxLayout;
+    tree_view = new QTreeView;
+    item_model = new QStandardItemModel(tree_view);
+    tree_view->setModel(item_model);
+
+    tree_view->setAlternatingRowColors(true);
+    tree_view->setSelectionMode(QHeaderView::SingleSelection);
+    tree_view->setSelectionBehavior(QHeaderView::SelectRows);
+    tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel);
+    tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
+    tree_view->setSortingEnabled(true);
+    tree_view->setEditTriggers(QHeaderView::NoEditTriggers);
+    tree_view->setUniformRowHeights(true);
+    tree_view->setIconSize({64, 64});
+    tree_view->setContextMenuPolicy(Qt::NoContextMenu);
+
+    item_model->insertColumns(0, 1);
+    item_model->setHeaderData(0, Qt::Horizontal, "Users");
+
+    // We must register all custom types with the Qt Automoc system so that we are able to use it
+    // with signals/slots. In this case, QList falls under the umbrells of custom types.
+    qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
+
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    layout->addWidget(tree_view);
+
+    ui->scrollArea->setLayout(layout);
+
+    connect(tree_view, &QTreeView::clicked, this, &ConfigureSystem::SelectUser);
+
+    connect(ui->pm_add, &QPushButton::pressed, this, &ConfigureSystem::AddUser);
+    connect(ui->pm_rename, &QPushButton::pressed, this, &ConfigureSystem::RenameUser);
+    connect(ui->pm_remove, &QPushButton::pressed, this, &ConfigureSystem::DeleteUser);
+    connect(ui->pm_set_image, &QPushButton::pressed, this, &ConfigureSystem::SetUserImage);
+
+    scene = new QGraphicsScene;
+    ui->current_user_icon->setScene(scene);
+
    this->setConfiguration();
 }

@@ -39,16 +108,74 @@ ConfigureSystem::~ConfigureSystem() = default;

 void ConfigureSystem::setConfiguration() {
    enabled = !Core::System::GetInstance().IsPoweredOn();
-    ui->edit_username->setText(QString::fromStdString(Settings::values.username));
+
    ui->combo_language->setCurrentIndex(Settings::values.language_index);
+
+    item_model->removeRows(0, item_model->rowCount());
+    list_items.clear();
+
+    PopulateUserList();
+    UpdateCurrentUser();
+}
+
+static QPixmap GetIcon(Service::Account::UUID uuid) {
+    const auto icon_url = QString::fromStdString(GetImagePath(uuid));
+    QPixmap icon{icon_url};
+
+    if (!icon) {
+        icon.fill(Qt::black);
+        icon.loadFromData(backup_jpeg.data(), backup_jpeg.size());
+    }
+
+    return icon;
+}
+
+void ConfigureSystem::PopulateUserList() {
+    const auto& profiles = profile_manager->GetAllUsers();
+    for (const auto& user : profiles) {
+        Service::Account::ProfileBase profile;
+        if (!profile_manager->GetProfileBase(user, profile))
+            continue;
+
+        const auto username = Common::StringFromFixedZeroTerminatedBuffer(
+            reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
+
+        list_items.push_back(QList<QStandardItem*>{new QStandardItem{
+            GetIcon(user).scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+            QString::fromStdString(username + '\n' + user.FormatSwitch())}});
+    }
+
+    for (const auto& item : list_items)
+        item_model->appendRow(item);
+}
+
+void ConfigureSystem::UpdateCurrentUser() {
+    ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
+
+    const auto& current_user = profile_manager->GetUser(Settings::values.current_user);
+    ASSERT(current_user != std::nullopt);
+    const auto username = GetAccountUsername(*current_user);
+
+    scene->clear();
+    scene->addPixmap(
+        GetIcon(*current_user).scaled(48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
+    ui->current_user_username->setText(QString::fromStdString(username));
 }

 void ConfigureSystem::ReadSystemSettings() {}

+std::string ConfigureSystem::GetAccountUsername(Service::Account::UUID uuid) const {
+    Service::Account::ProfileBase profile;
+    if (!profile_manager->GetProfileBase(uuid, profile))
+        return "";
+    return Common::StringFromFixedZeroTerminatedBuffer(
+        reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
+}
+
 void ConfigureSystem::applyConfiguration() {
    if (!enabled)
        return;
-    Settings::values.username = ui->edit_username->text().toStdString();
+
    Settings::values.language_index = ui->combo_language->currentIndex();
    Settings::Apply();
 }
@@ -92,3 +219,130 @@ void ConfigureSystem::refreshConsoleID() {
    ui->label_console_id->setText(
        tr("Console ID: 0x%1").arg(QString::number(console_id, 16).toUpper()));
 }
+
+void ConfigureSystem::SelectUser(const QModelIndex& index) {
+    Settings::values.current_user =
+        std::clamp<std::size_t>(index.row(), 0, profile_manager->GetUserCount() - 1);
+
+    UpdateCurrentUser();
+
+    ui->pm_remove->setEnabled(profile_manager->GetUserCount() >= 2);
+    ui->pm_rename->setEnabled(true);
+    ui->pm_set_image->setEnabled(true);
+}
+
+void ConfigureSystem::AddUser() {
+    Service::Account::UUID uuid;
+    uuid.Generate();
+
+    bool ok = false;
+    const auto username =
+        QInputDialog::getText(this, tr("Enter Username"), tr("Enter a username for the new user:"),
+                              QLineEdit::Normal, QString(), &ok);
+    if (!ok)
+        return;
+
+    profile_manager->CreateNewUser(uuid, username.toStdString());
+
+    item_model->appendRow(new QStandardItem{
+        GetIcon(uuid).scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+        QString::fromStdString(username.toStdString() + '\n' + uuid.FormatSwitch())});
+}
+
+void ConfigureSystem::RenameUser() {
+    const auto user = tree_view->currentIndex().row();
+    const auto uuid = profile_manager->GetUser(user);
+    ASSERT(uuid != std::nullopt);
+    const auto username = GetAccountUsername(*uuid);
+
+    Service::Account::ProfileBase profile;
+    if (!profile_manager->GetProfileBase(*uuid, profile))
+        return;
+
+    bool ok = false;
+    const auto new_username =
+        QInputDialog::getText(this, tr("Enter Username"), tr("Enter a new username:"),
+                              QLineEdit::Normal, QString::fromStdString(username), &ok);
+
+    if (!ok)
+        return;
+
+    std::fill(profile.username.begin(), profile.username.end(), '\0');
+    const auto username_std = new_username.toStdString();
+    if (username_std.size() > profile.username.size()) {
+        std::copy_n(username_std.begin(), std::min(profile.username.size(), username_std.size()),
+                    profile.username.begin());
+    } else {
+        std::copy(username_std.begin(), username_std.end(), profile.username.begin());
+    }
+
+    profile_manager->SetProfileBase(*uuid, profile);
+
+    item_model->setItem(
+        user, 0,
+        new QStandardItem{
+            GetIcon(*uuid).scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+            tr("%1\n%2", "%1 is the profile username, %2 is the formatted UUID (e.g. "
+                         "00112233-4455-6677-8899-AABBCCDDEEFF))")
+                .arg(QString::fromStdString(username_std),
+                     QString::fromStdString(uuid->FormatSwitch()))});
+    UpdateCurrentUser();
+}
+
+void ConfigureSystem::DeleteUser() {
+    const auto index = tree_view->currentIndex().row();
+    const auto uuid = profile_manager->GetUser(index);
+    ASSERT(uuid != std::nullopt);
+    const auto username = GetAccountUsername(*uuid);
+
+    const auto confirm =
+        QMessageBox::question(this, tr("Confirm Delete"),
+                              tr("You are about to delete user with name %1. Are you sure?")
+                                  .arg(QString::fromStdString(username)));
+
+    if (confirm == QMessageBox::No)
+        return;
+
+    if (Settings::values.current_user == tree_view->currentIndex().row())
+        Settings::values.current_user = 0;
+    UpdateCurrentUser();
+
+    if (!profile_manager->RemoveUser(*uuid))
+        return;
+
+    item_model->removeRows(tree_view->currentIndex().row(), 1);
+    tree_view->clearSelection();
+
+    ui->pm_remove->setEnabled(false);
+    ui->pm_rename->setEnabled(false);
+}
+
+void ConfigureSystem::SetUserImage() {
+    const auto index = tree_view->currentIndex().row();
+    const auto uuid = profile_manager->GetUser(index);
+    ASSERT(uuid != std::nullopt);
+    const auto username = GetAccountUsername(*uuid);
+
+    const auto file = QFileDialog::getOpenFileName(this, tr("Select User Image"), QString(),
+                                                   "JPEG Images (*.jpg *.jpeg)");
+
+    if (file.isEmpty())
+        return;
+
+    FileUtil::Delete(GetImagePath(*uuid));
+
+    const auto raw_path =
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010";
+    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
+        FileUtil::Delete(raw_path);
+
+    FileUtil::CreateFullPath(GetImagePath(*uuid));
+    FileUtil::Copy(file.toStdString(), GetImagePath(*uuid));
+
+    item_model->setItem(
+        index, 0,
+        new QStandardItem{
+            GetIcon(*uuid).scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+            QString::fromStdString(username + '\n' + uuid->FormatSwitch())});
+    UpdateCurrentUser();
+}
@@ -5,8 +5,21 @@
 #pragma once

 #include <memory>
+
+#include <QList>
 #include <QWidget>

+namespace Service::Account {
+class ProfileManager;
+struct UUID;
+} // namespace Service::Account
+
+class QGraphicsScene;
+class QStandardItem;
+class QStandardItemModel;
+class QTreeView;
+class QVBoxLayout;
+
 namespace Ui {
 class ConfigureSystem;
 }
@@ -21,18 +34,36 @@ public:
    void applyConfiguration();
    void setConfiguration();

+    void PopulateUserList();
+    void UpdateCurrentUser();
+
 public slots:
    void updateBirthdayComboBox(int birthmonth_index);
    void refreshConsoleID();

+    void SelectUser(const QModelIndex& index);
+    void AddUser();
+    void RenameUser();
+    void DeleteUser();
+    void SetUserImage();
+
 private:
    void ReadSystemSettings();
+    std::string GetAccountUsername(Service::Account::UUID uuid) const;
+
+    QVBoxLayout* layout;
+    QTreeView* tree_view;
+    QStandardItemModel* item_model;
+    QGraphicsScene* scene;
+
+    std::vector<QList<QStandardItem*>> list_items;

    std::unique_ptr<Ui::ConfigureSystem> ui;
    bool enabled;

-    std::u16string username;
    int birthmonth, birthday;
    int language_index;
    int sound_index;
+
+    std::unique_ptr<Service::Account::ProfileManager> profile_manager;
 };
@@ -7,7 +7,7 @@
    <x>0</x>
    <y>0</y>
    <width>360</width>
-    <height>377</height>
+    <height>483</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -22,34 +22,28 @@
        <string>System Settings</string>
       </property>
       <layout class="QGridLayout" name="gridLayout">
-        <item row="0" column="0">
-         <widget class="QLabel" name="label_username">
-          <property name="text">
-           <string>Username</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
-         <widget class="QLineEdit" name="edit_username">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="maxLength">
-           <number>32</number>
-          </property>
-         </widget>
-        </item>
        <item row="1" column="0">
+         <widget class="QLabel" name="label_language">
+          <property name="text">
+           <string>Language</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="0">
         <widget class="QLabel" name="label_birthday">
          <property name="text">
           <string>Birthday</string>
          </property>
         </widget>
        </item>
-        <item row="1" column="1">
+        <item row="3" column="0">
+         <widget class="QLabel" name="label_console_id">
+          <property name="text">
+           <string>Console ID:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
         <layout class="QHBoxLayout" name="horizontalLayout_birthday2">
          <item>
           <widget class="QComboBox" name="combo_birthmonth">
@@ -120,14 +114,7 @@
          </item>
         </layout>
        </item>
-        <item row="2" column="0">
-         <widget class="QLabel" name="label_language">
-          <property name="text">
-           <string>Language</string>
-          </property>
-         </widget>
-        </item>
-        <item row="2" column="1">
+        <item row="1" column="1">
         <widget class="QComboBox" name="combo_language">
          <property name="toolTip">
           <string>Note: this can be overridden when region setting is auto-select</string>
@@ -187,31 +174,31 @@
            <string>Russian (Русский)</string>
           </property>
          </item>
-           <item>
-             <property name="text">
-               <string>Taiwanese</string>
-             </property>
-           </item>
-           <item>
-             <property name="text">
-               <string>British English</string>
-             </property>
-           </item>
-           <item>
-             <property name="text">
-               <string>Canadian French</string>
-             </property>
-           </item>
-           <item>
-             <property name="text">
-               <string>Latin American Spanish</string>
-             </property>
-           </item>
-           <item>
-             <property name="text">
-               <string>Simplified Chinese</string>
-             </property>
-           </item>
+          <item>
+           <property name="text">
+            <string>Taiwanese</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>British English</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Canadian French</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Latin American Spanish</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Simplified Chinese</string>
+           </property>
+          </item>
          <item>
           <property name="text">
            <string>Traditional Chinese (正體中文)</string>
@@ -219,14 +206,14 @@
          </item>
         </widget>
        </item>
-        <item row="3" column="0">
+        <item row="2" column="0">
         <widget class="QLabel" name="label_sound">
          <property name="text">
           <string>Sound output mode</string>
          </property>
         </widget>
        </item>
-        <item row="3" column="1">
+        <item row="2" column="1">
         <widget class="QComboBox" name="combo_sound">
          <item>
           <property name="text">
@@ -245,14 +232,7 @@
          </item>
         </widget>
        </item>
-        <item row="4" column="0">
-         <widget class="QLabel" name="label_console_id">
-          <property name="text">
-           <string>Console ID:</string>
-          </property>
-         </widget>
-        </item>
-        <item row="4" column="1">
+        <item row="3" column="1">
         <widget class="QPushButton" name="button_regenerate_console_id">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -271,6 +251,143 @@
       </layout>
      </widget>
     </item>
+     <item>
+      <widget class="QGroupBox" name="gridGroupBox">
+       <property name="title">
+        <string>Profile Manager</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_2">
+        <property name="sizeConstraint">
+         <enum>QLayout::SetNoConstraint</enum>
+        </property>
+        <item row="0" column="0">
+         <layout class="QHBoxLayout" name="horizontalLayout_2">
+          <item>
+           <widget class="QLabel" name="label">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Current User</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGraphicsView" name="current_user_icon">
+            <property name="minimumSize">
+             <size>
+              <width>48</width>
+              <height>48</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>48</width>
+              <height>48</height>
+             </size>
+            </property>
+            <property name="verticalScrollBarPolicy">
+             <enum>Qt::ScrollBarAlwaysOff</enum>
+            </property>
+            <property name="horizontalScrollBarPolicy">
+             <enum>Qt::ScrollBarAlwaysOff</enum>
+            </property>
+            <property name="interactive">
+             <bool>false</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="current_user_username">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Username</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+        <item row="1" column="0">
+         <widget class="QScrollArea" name="scrollArea">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="frameShape">
+           <enum>QFrame::StyledPanel</enum>
+          </property>
+          <property name="widgetResizable">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <layout class="QHBoxLayout" name="horizontalLayout_3">
+          <item>
+           <widget class="QPushButton" name="pm_set_image">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="text">
+             <string>Set Image</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <spacer name="horizontalSpacer">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item>
+           <widget class="QPushButton" name="pm_add">
+            <property name="text">
+             <string>Add</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="pm_rename">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="text">
+             <string>Rename</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="pm_remove">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="text">
+             <string>Remove</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
     <item>
      <widget class="QLabel" name="label_disable_info">
       <property name="text">
@@ -281,19 +398,6 @@
       </property>
      </widget>
     </item>
-     <item>
-      <spacer name="verticalSpacer">
-       <property name="orientation">
-        <enum>Qt::Vertical</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>20</width>
-         <height>40</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
    </layout>
   </item>
  </layout>
@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <map>
 #include <QLabel>
 #include <QMetaType>
 #include <QPushButton>
@@ -32,21 +31,8 @@ QVariant BreakPointModel::data(const QModelIndex& index, int role) const {
    switch (role) {
    case Qt::DisplayRole: {
        if (index.column() == 0) {
-            static const std::map<Tegra::DebugContext::Event, QString> map = {
-                {Tegra::DebugContext::Event::MaxwellCommandLoaded, tr("Maxwell command loaded")},
-                {Tegra::DebugContext::Event::MaxwellCommandProcessed,
-                 tr("Maxwell command processed")},
-                {Tegra::DebugContext::Event::IncomingPrimitiveBatch,
-                 tr("Incoming primitive batch")},
-                {Tegra::DebugContext::Event::FinishedPrimitiveBatch,
-                 tr("Finished primitive batch")},
-            };
-
-            DEBUG_ASSERT(map.size() ==
-                         static_cast<std::size_t>(Tegra::DebugContext::Event::NumEvents));
-            return (map.find(event) != map.end()) ? map.at(event) : QString();
+            return DebugContextEventToString(event);
        }
-
        break;
    }

@@ -128,6 +114,23 @@ void BreakPointModel::OnResumed() {
    active_breakpoint = context->active_breakpoint;
 }

+QString BreakPointModel::DebugContextEventToString(Tegra::DebugContext::Event event) {
+    switch (event) {
+    case Tegra::DebugContext::Event::MaxwellCommandLoaded:
+        return tr("Maxwell command loaded");
+    case Tegra::DebugContext::Event::MaxwellCommandProcessed:
+        return tr("Maxwell command processed");
+    case Tegra::DebugContext::Event::IncomingPrimitiveBatch:
+        return tr("Incoming primitive batch");
+    case Tegra::DebugContext::Event::FinishedPrimitiveBatch:
+        return tr("Finished primitive batch");
+    case Tegra::DebugContext::Event::NumEvents:
+        break;
+    }
+
+    return tr("Unknown debug context event");
+}
+
 GraphicsBreakPointsWidget::GraphicsBreakPointsWidget(
    std::shared_ptr<Tegra::DebugContext> debug_context, QWidget* parent)
    : QDockWidget(tr("Maxwell Breakpoints"), parent), Tegra::DebugContext::BreakPointObserver(
@@ -29,6 +29,8 @@ public:
    void OnResumed();

 private:
+    static QString DebugContextEventToString(Tegra::DebugContext::Event event);
+
    std::weak_ptr<Tegra::DebugContext> context_weak;
    bool at_breakpoint;
    Tegra::DebugContext::Event active_breakpoint;
@@ -9,8 +9,8 @@
 #include "core/core.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/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
@@ -83,7 +83,7 @@ QString WaitTreeText::GetText() const {
 }

 WaitTreeMutexInfo::WaitTreeMutexInfo(VAddr mutex_address) : mutex_address(mutex_address) {
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();

    mutex_value = Memory::Read32(mutex_address);
    owner_handle = static_cast<Kernel::Handle>(mutex_value & Kernel::Mutex::MutexOwnerMask);
@@ -16,7 +16,6 @@
 #include <fmt/format.h>
 #include "common/common_paths.h"
 #include "common/common_types.h"
-#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/patch_manager.h"
 #include "yuzu/compatibility_list.h"
@@ -217,11 +216,11 @@ GameList::GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent)
    tree_view->setContextMenuPolicy(Qt::CustomContextMenu);

    item_model->insertColumns(0, COLUMN_COUNT);
-    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, "Name");
-    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, "Compatibility");
-    item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, "Add-ons");
-    item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, "File type");
-    item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, "Size");
+    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
+    item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
+    item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
+    item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));

    connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry);
    connect(tree_view, &QTreeView::customContextMenuRequested, this, &GameList::PopupContextMenu);
@@ -387,9 +386,9 @@ void GameList::LoadCompatibilityList() {
 }

 void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
-    if (!FileUtil::Exists(dir_path.toStdString()) ||
-        !FileUtil::IsDirectory(dir_path.toStdString())) {
-        LOG_ERROR(Frontend, "Could not find game list folder at {}", dir_path.toLocal8Bit().data());
+    const QFileInfo dir_info{dir_path};
+    if (!dir_info.exists() || !dir_info.isDir()) {
+        LOG_ERROR(Frontend, "Could not find game list folder at {}", dir_path.toStdString());
        search_field->setFilterResult(0, 0);
        return;
    }
@@ -62,19 +62,24 @@ QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager,
    FileSys::VirtualFile update_raw;
    loader.ReadUpdateRaw(update_raw);
    for (const auto& kv : patch_manager.GetPatchVersionNames(update_raw)) {
-        if (!updatable && kv.first == "Update")
+        const bool is_update = kv.first == "Update";
+        if (!updatable && is_update) {
            continue;
+        }
+
+        const QString type = QString::fromStdString(kv.first);

        if (kv.second.empty()) {
-            out.append(fmt::format("{}\n", kv.first).c_str());
+            out.append(QStringLiteral("%1\n").arg(type));
        } else {
            auto ver = kv.second;

            // Display container name for packed updates
-            if (ver == "PACKED" && kv.first == "Update")
+            if (is_update && ver == "PACKED") {
                ver = Loader::GetFileTypeString(loader.GetFileType());
+            }

-            out.append(fmt::format("{} ({})\n", kv.first, ver).c_str());
+            out.append(QStringLiteral("%1 (%2)\n").arg(type, QString::fromStdString(ver)));
        }
    }

@@ -10,6 +10,7 @@
 // VFS includes must be before glad as they will conflict with Windows file api, which uses defines.
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_real.h"
+#include "core/hle/service/acc/profile_manager.h"

 // These are wrappers to avoid the calls to CreateDirectory and CreateFile becuase of the Windows
 // defines.
@@ -60,6 +61,8 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_ldr.h"
+#include "core/hle/service/nfp/nfp.h"
+#include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
 #include "core/settings.h"
@@ -100,6 +103,8 @@ __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif

+constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
+
 /**
 * "Callouts" are one-time instructional messages shown to the user. In the config settings, there
 * is a bitfield "callout_flags" options, used to track if a message has already been shown to the
@@ -422,6 +427,7 @@ void GMainWindow::ConnectMenuEvents() {
    connect(ui.action_Select_SDMC_Directory, &QAction::triggered, this,
            [this] { OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget::SDMC); });
    connect(ui.action_Exit, &QAction::triggered, this, &QMainWindow::close);
+    connect(ui.action_Load_Amiibo, &QAction::triggered, this, &GMainWindow::OnLoadAmiibo);

    // Emulation
    connect(ui.action_Start, &QAction::triggered, this, &GMainWindow::OnStartGame);
@@ -690,6 +696,7 @@ void GMainWindow::ShutdownGame() {
    ui.action_Stop->setEnabled(false);
    ui.action_Restart->setEnabled(false);
    ui.action_Report_Compatibility->setEnabled(false);
+    ui.action_Load_Amiibo->setEnabled(false);
    render_window->hide();
    game_list->show();
    game_list->setFilterFocus();
@@ -751,12 +758,43 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
        open_target = "Save Data";
        const std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
        ASSERT(program_id != 0);
-        // TODO(tech4me): Update this to work with arbitrary user profile
-        // Refer to core/hle/service/acc/profile_manager.cpp ProfileManager constructor
-        constexpr u128 user_id = {1, 0};
+
+        Service::Account::ProfileManager manager{};
+        const auto user_ids = manager.GetAllUsers();
+        QStringList list;
+        for (const auto& user_id : user_ids) {
+            if (user_id == Service::Account::UUID{})
+                continue;
+            Service::Account::ProfileBase base;
+            if (!manager.GetProfileBase(user_id, base))
+                continue;
+
+            list.push_back(QString::fromStdString(Common::StringFromFixedZeroTerminatedBuffer(
+                reinterpret_cast<const char*>(base.username.data()), base.username.size())));
+        }
+
+        bool ok = false;
+        const auto index_string =
+            QInputDialog::getItem(this, tr("Select User"),
+                                  tr("Please select the user's save data you would like to open."),
+                                  list, Settings::values.current_user, false, &ok);
+        if (!ok)
+            return;
+
+        const auto index = list.indexOf(index_string);
+        ASSERT(index != -1 && index < 8);
+
+        const auto user_id = manager.GetUser(index);
+        ASSERT(user_id != std::nullopt);
        path = nand_dir + FileSys::SaveDataFactory::GetFullPath(FileSys::SaveDataSpaceId::NandUser,
                                                                FileSys::SaveDataType::SaveData,
-                                                                program_id, user_id, 0);
+                                                                program_id, user_id->uuid, 0);
+
+        if (!FileUtil::Exists(path)) {
+            FileUtil::CreateFullPath(path);
+            FileUtil::CreateDir(path);
+        }
+
        break;
    }
    case GameListOpenTarget::ModData: {
@@ -823,14 +861,10 @@ static bool RomFSRawCopy(QProgressDialog& dialog, const FileSys::VirtualDir& src
 }

 void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_path) {
-    const auto path = fmt::format("{}{:016X}/romfs",
-                                  FileUtil::GetUserPath(FileUtil::UserPath::DumpDir), program_id);
-
-    const auto failed = [this, &path] {
+    const auto failed = [this] {
        QMessageBox::warning(this, tr("RomFS Extraction Failed!"),
                             tr("There was an error copying the RomFS files or the user "
                                "cancelled the operation."));
-        vfs->DeleteDirectory(path);
    };

    const auto loader = Loader::GetLoader(vfs->OpenFile(game_path, FileSys::Mode::Read));
@@ -845,10 +879,24 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
        return;
    }

-    const auto romfs =
-        loader->IsRomFSUpdatable()
-            ? FileSys::PatchManager(program_id).PatchRomFS(file, loader->ReadRomFSIVFCOffset())
-            : file;
+    const auto installed = Service::FileSystem::GetUnionContents();
+    auto romfs_title_id = SelectRomFSDumpTarget(*installed, program_id);
+
+    if (!romfs_title_id) {
+        failed();
+        return;
+    }
+
+    const auto path = fmt::format(
+        "{}{:016X}/romfs", FileUtil::GetUserPath(FileUtil::UserPath::DumpDir), *romfs_title_id);
+
+    FileSys::VirtualFile romfs;
+
+    if (*romfs_title_id == program_id) {
+        romfs = file;
+    } else {
+        romfs = installed->GetEntry(*romfs_title_id, FileSys::ContentRecordType::Data)->GetRomFS();
+    }

    const auto extracted = FileSys::ExtractRomFS(romfs, FileSys::RomFSExtractionType::Full);
    if (extracted == nullptr) {
@@ -860,6 +908,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa

    if (out == nullptr) {
        failed();
+        vfs->DeleteDirectory(path);
        return;
    }

@@ -870,8 +919,11 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
           "files into the new directory while <br>skeleton will only create the directory "
           "structure."),
        {"Full", "Skeleton"}, 0, false, &ok);
-    if (!ok)
+    if (!ok) {
        failed();
+        vfs->DeleteDirectory(path);
+        return;
+    }

    const auto full = res == "Full";
    const auto entry_size = CalculateRomFSEntrySize(extracted, full);
@@ -888,6 +940,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
    } else {
        progress.close();
        failed();
+        vfs->DeleteDirectory(path);
    }
 }

@@ -1174,6 +1227,7 @@ void GMainWindow::OnStartGame() {
    ui.action_Report_Compatibility->setEnabled(true);

    discord_rpc->Update();
+    ui.action_Load_Amiibo->setEnabled(true);
 }

 void GMainWindow::OnPauseGame() {
@@ -1278,6 +1332,27 @@ void GMainWindow::OnConfigure() {
    }
 }

+void GMainWindow::OnLoadAmiibo() {
+    const QString extensions{"*.bin"};
+    const QString file_filter = tr("Amiibo File (%1);; All Files (*.*)").arg(extensions);
+    const QString filename = QFileDialog::getOpenFileName(this, tr("Load Amiibo"), "", file_filter);
+    if (!filename.isEmpty()) {
+        Core::System& system{Core::System::GetInstance()};
+        Service::SM::ServiceManager& sm = system.ServiceManager();
+        auto nfc = sm.GetService<Service::NFP::Module::Interface>("nfp:user");
+        if (nfc != nullptr) {
+            auto nfc_file = FileUtil::IOFile(filename.toStdString(), "rb");
+            if (!nfc_file.IsOpen()) {
+                return;
+            }
+            std::vector<u8> amiibo_buffer(nfc_file.GetSize());
+            nfc_file.ReadBytes(amiibo_buffer.data(), amiibo_buffer.size());
+            nfc_file.Close();
+            nfc->LoadAmiibo(amiibo_buffer);
+        }
+    }
+}
+
 void GMainWindow::OnAbout() {
    AboutDialog aboutDialog(this);
    aboutDialog.exec();
@@ -1318,15 +1393,17 @@ void GMainWindow::UpdateStatusBar() {
 void GMainWindow::OnCoreError(Core::System::ResultStatus result, std::string details) {
    QMessageBox::StandardButton answer;
    QString status_message;
-    const QString common_message = tr(
-        "The game you are trying to load requires additional files from your Switch to be dumped "
-        "before playing.<br/><br/>For more information on dumping these files, please see the "
-        "following wiki page: <a "
-        "href='https://yuzu-emu.org/wiki/"
-        "dumping-system-archives-and-the-shared-fonts-from-a-switch-console/'>Dumping System "
-        "Archives and the Shared Fonts from a Switch Console</a>.<br/><br/>Would you like to quit "
-        "back to the game list? Continuing emulation may result in crashes, corrupted save "
-        "data, or other bugs.");
+    const QString common_message =
+        tr("The game you are trying to load requires additional files from your Switch to be "
+           "dumped "
+           "before playing.<br/><br/>For more information on dumping these files, please see the "
+           "following wiki page: <a "
+           "href='https://yuzu-emu.org/wiki/"
+           "dumping-system-archives-and-the-shared-fonts-from-a-switch-console/'>Dumping System "
+           "Archives and the Shared Fonts from a Switch Console</a>.<br/><br/>Would you like to "
+           "quit "
+           "back to the game list? Continuing emulation may result in crashes, corrupted save "
+           "data, or other bugs.");
    switch (result) {
    case Core::System::ResultStatus::ErrorSystemFiles: {
        QString message = "yuzu was unable to locate a Switch system archive";
@@ -1357,9 +1434,12 @@ void GMainWindow::OnCoreError(Core::System::ResultStatus result, std::string det
            this, tr("Fatal Error"),
            tr("yuzu has encountered a fatal error, please see the log for more details. "
               "For more information on accessing the log, please see the following page: "
-               "<a href='https://community.citra-emu.org/t/how-to-upload-the-log-file/296'>How to "
-               "Upload the Log File</a>.<br/><br/>Would you like to quit back to the game list? "
-               "Continuing emulation may result in crashes, corrupted save data, or other bugs."),
+               "<a href='https://community.citra-emu.org/t/how-to-upload-the-log-file/296'>How "
+               "to "
+               "Upload the Log File</a>.<br/><br/>Would you like to quit back to the game "
+               "list? "
+               "Continuing emulation may result in crashes, corrupted save data, or other "
+               "bugs."),
            QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
        status_message = "Fatal Error encountered";
        break;
@@ -1459,6 +1539,42 @@ void GMainWindow::OnReinitializeKeys(ReinitializeKeyBehavior behavior) {
    }
 }

+boost::optional<u64> GMainWindow::SelectRomFSDumpTarget(
+    const FileSys::RegisteredCacheUnion& installed, u64 program_id) {
+    const auto dlc_entries =
+        installed.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
+    std::vector<FileSys::RegisteredCacheEntry> dlc_match;
+    dlc_match.reserve(dlc_entries.size());
+    std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
+                 [&program_id, &installed](const FileSys::RegisteredCacheEntry& entry) {
+                     return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == program_id &&
+                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
+                 });
+
+    std::vector<u64> romfs_tids;
+    romfs_tids.push_back(program_id);
+    for (const auto& entry : dlc_match)
+        romfs_tids.push_back(entry.title_id);
+
+    if (romfs_tids.size() > 1) {
+        QStringList list{"Base"};
+        for (std::size_t i = 1; i < romfs_tids.size(); ++i)
+            list.push_back(QStringLiteral("DLC %1").arg(romfs_tids[i] & 0x7FF));
+
+        bool ok;
+        const auto res = QInputDialog::getItem(
+            this, tr("Select RomFS Dump Target"),
+            tr("Please select which RomFS you would like to dump."), list, 0, false, &ok);
+        if (!ok) {
+            return boost::none;
+        }
+
+        return romfs_tids[list.indexOf(res)];
+    }
+
+    return program_id;
+}
+
 bool GMainWindow::ConfirmClose() {
    if (emu_thread == nullptr || !UISettings::values.confirm_before_closing)
        return true;
@@ -10,6 +10,7 @@
 #include <QMainWindow>
 #include <QTimer>

+#include <boost/optional.hpp>
 #include "common/common_types.h"
 #include "core/core.h"
 #include "ui_main.h"
@@ -29,8 +30,9 @@ class WaitTreeWidget;
 enum class GameListOpenTarget;

 namespace FileSys {
+class RegisteredCacheUnion;
 class VfsFilesystem;
-}
+} // namespace FileSys

 namespace Tegra {
 class DebugContext;
@@ -164,6 +166,7 @@ private slots:
    void OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget target);
    void OnMenuRecentFile();
    void OnConfigure();
+    void OnLoadAmiibo();
    void OnAbout();
    void OnToggleFilterBar();
    void OnDisplayTitleBars(bool);
@@ -175,6 +178,8 @@ private slots:
    void OnReinitializeKeys(ReinitializeKeyBehavior behavior);

 private:
+    boost::optional<u64> SelectRomFSDumpTarget(const FileSys::RegisteredCacheUnion&,
+                                               u64 program_id);
    void UpdateStatusBar();

    Ui::MainWindow ui;
@@ -57,8 +57,8 @@
      <string>Recent Files</string>
     </property>
    </widget>
-     <addaction name="action_Install_File_NAND" />
-     <addaction name="separator"/>
+    <addaction name="action_Install_File_NAND"/>
+    <addaction name="separator"/>
    <addaction name="action_Load_File"/>
    <addaction name="action_Load_Folder"/>
    <addaction name="separator"/>
@@ -68,6 +68,8 @@
    <addaction name="action_Select_NAND_Directory"/>
    <addaction name="action_Select_SDMC_Directory"/>
    <addaction name="separator"/>
+    <addaction name="action_Load_Amiibo"/>
+    <addaction name="separator"/>
    <addaction name="action_Exit"/>
   </widget>
   <widget class="QMenu" name="menu_Emulation">
@@ -117,11 +119,14 @@
   <addaction name="menu_Tools" />
   <addaction name="menu_Help"/>
  </widget>
-   <action name="action_Install_File_NAND">
-     <property name="text">
-       <string>Install File to NAND...</string>
-     </property>
-   </action>
+  <action name="action_Install_File_NAND">
+   <property name="enabled">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Install File to NAND...</string>
+   </property>
+  </action>
  <action name="action_Load_File">
   <property name="text">
    <string>Load File...</string>
@@ -253,6 +258,14 @@
       <string>Restart</string>
     </property>
   </action>
+  <action name="action_Load_Amiibo">
+    <property name="enabled">
+      <bool>false</bool>
+    </property>
+    <property name="text">
+      <string>Load Amiibo...</string>
+    </property>
+  </action>
   <action name="action_Report_Compatibility">
     <property name="enabled">
       <bool>false</bool>
@@ -8,6 +8,7 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/param_package.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 #include "input_common/main.h"
 #include "yuzu_cmd/config.h"
@@ -125,10 +126,11 @@ void Config::ReadValues() {

    // System
    Settings::values.use_docked_mode = sdl2_config->GetBoolean("System", "use_docked_mode", false);
-    Settings::values.username = sdl2_config->Get("System", "username", "yuzu");
-    if (Settings::values.username.empty()) {
-        Settings::values.username = "yuzu";
-    }
+    Settings::values.enable_nfc = sdl2_config->GetBoolean("System", "enable_nfc", true);
+    const auto size = sdl2_config->GetInteger("System", "users_size", 0);
+
+    Settings::values.current_user = std::clamp<int>(
+        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);

    // Miscellaneous
    Settings::values.log_filter = sdl2_config->Get("Miscellaneous", "log_filter", "*:Trace");
@@ -174,6 +174,10 @@ use_virtual_sd =
 # 1: Yes, 0 (default): No
 use_docked_mode =

+# Allow the use of NFC in games
+# 1 (default): Yes, 0 : No
+enable_nfc =
+
 # Sets the account username, max length is 32 characters
 # yuzu (default)
 username = yuzu
Author	SHA1	Message	Date
Frederic Laing	369996a1d4	Remove unnessesary nullptr checks	2018-10-25 23:37:36 +02:00
James Rowe	e54c9e19f3	Merge pull request #1584 from FearlessTobi/patch-3 Delete git file	2018-10-25 13:55:10 -06:00
Tobias	bf0d3e1fea	Delete git	2018-10-25 21:53:41 +02:00
bunnei	2bc2b32662	Merge pull request #1579 from lioncash/usb service/usb: Update service function tables	2018-10-25 12:22:57 -04:00
bunnei	0634aee267	Merge pull request #1576 from lioncash/acc-warn service/acc: Silence compiler truncation warnings	2018-10-25 12:22:10 -04:00
bunnei	c94db0e071	Merge pull request #1577 from lioncash/err kernel/error: Amend error return code values	2018-10-25 01:10:26 -04:00
bunnei	f7a173de6c	Merge pull request #1524 from FernandoS27/layers-fix rasterizer: Fix Layered Textures Loading and Cubemaps	2018-10-25 00:29:18 -04:00
bunnei	b43cfe6c02	Merge pull request #1575 from lioncash/qstring game_list_worker: Use QString's formatting instead of fmt in FormatPatchNameVersions()	2018-10-24 19:39:43 -04:00
Lioncash	fbbb58b226	service/usb: Update service function tables Updated based off the information provided by Hexkyz on Switchbrew.	2018-10-24 19:07:55 -04:00
Lioncash	1e3b139cd7	service/acc: Move fallback image to file scope This is just flat data, so it doesn't really need to be in the function itself. This also allows deduplicating the constant for the backup size in GetImageSize().	2018-10-24 18:22:24 -04:00
Lioncash	6f00628564	service/acc: Silence compiler warnings Silences compiler warnings related to truncation. This also introduces a small helper function to perform the clamping of the image size.	2018-10-24 18:22:24 -04:00
Lioncash	3ec90dc6ef	service/acc: Early return in failure case in LoadImage() Allows unindenting the other branch's code.	2018-10-24 18:22:20 -04:00
bunnei	9aa5c1894e	Merge pull request #1570 from lioncash/optional profile_manager: Use std::optional instead of boost::optional	2018-10-24 18:11:03 -04:00
bunnei	3a6e76e9b5	Merge pull request #1558 from lioncash/ptr yuzu/configuration/config: Use a std::unique_ptr for qt_config instead of a raw pointer	2018-10-24 18:07:14 -04:00
bunnei	29f748a658	Merge pull request #1565 from lioncash/audio time_stretch: Remove unused m_channel_count member variable	2018-10-24 17:39:53 -04:00
bunnei	69b35d7615	Merge pull request #1554 from FernandoS27/pointsize Implement PointSize Output Attribute.	2018-10-24 17:38:38 -04:00
bunnei	b723390ab1	Merge pull request #1571 from lioncash/debug-translate graphic_breakpoints: Correct translation of strings in BreakpointModel's data() function	2018-10-24 17:37:18 -04:00
bunnei	ce2403d975	Merge pull request #1564 from lioncash/npad npad: Remove unused controller variable from OnInit()	2018-10-24 17:36:55 -04:00
bunnei	d9590d7dfa	Merge pull request #1568 from lioncash/dir game_list: Use QFileInfo instead of common's file functions	2018-10-24 17:13:51 -04:00
bunnei	2694b43d3a	Merge pull request #1567 from lioncash/translate game_list: Make game list column headers translatable	2018-10-24 17:13:08 -04:00
bunnei	e6e17a3fc6	Merge pull request #1566 from lioncash/str bootmanager: Use QStringLiteral instead of std::string to represent the window title.	2018-10-24 17:12:53 -04:00
bunnei	ddff188c65	Merge pull request #1563 from lioncash/frame perf_stats: Remove unused variable within DoFrameLimiting()	2018-10-24 16:29:16 -04:00
bunnei	d14ba122e2	Merge pull request #1562 from lioncash/aoc aoc_u: Make use of previously-unused CheckAOCTitleIDMatchesBase() function	2018-10-24 16:28:56 -04:00
bunnei	2eff8336f4	Merge pull request #1560 from lioncash/unused maxwell_3d/decoders: Remove unused variables	2018-10-24 16:28:38 -04:00
bunnei	cdd499c261	Merge pull request #1561 from lioncash/fs file_sys: Remove unused variables	2018-10-24 16:28:17 -04:00
bunnei	e65f5e4d66	Merge pull request #1559 from lioncash/log logging/backend: Add missing services to the log filters	2018-10-24 16:28:01 -04:00
Lioncash	1fb4bebb63	kernel/errors: Remove now-unused, unnecessary, error codes Now that we've gotten the innaccurate error codes out of the way, we can finally toss away a bunch of these, trimming down the error codes to ones that are actually used and knocking out two TODO comments.	2018-10-24 14:58:37 -04:00
Lioncash	239dfea34a	kernel/shared_memory: Return ERR_INVALID_MEMORY_PERMISSIONS instead of ERR_INVALID_COMBINATION This is more consistent with what the kernel does.	2018-10-24 14:54:36 -04:00
Lioncash	474bc29208	kernel/server_port: Simplify emptiness check within ShouldWait()	2018-10-24 14:24:36 -04:00
Lioncash	b703aba622	kernel/server_port: Change error case return value in Accept() to ERR_NOT_FOUND This is what the kernel does in this instance.	2018-10-24 14:23:38 -04:00
Lioncash	afb7e5cc05	kernel/error: Remove leftover 3DS error codes These are now entirely unused and can be removed.	2018-10-24 14:21:37 -04:00
Lioncash	fcf8f53a63	kernel/svc: Amend returned error code for invalid priorities in CreateThread Like with the previous change, the kernel doesn't return NOT_AUTHORIZED here. It returns INVALID_THREAD_PRIORITY.	2018-10-24 14:11:11 -04:00
Lioncash	77328b0f19	kernel/svc: Move and correct returned error code for invalid thread priorities in SetThreadPriority() All priority checks are supposed to occur before checking the validity of the thread handle, we're also not supposed to return ERR_NOT_AUTHORIZED here.	2018-10-24 14:10:48 -04:00
Lioncash	c7c346a15d	kernel/error: Add error code for invalid pointers The kernel appears to return 0xE601 for this situation. Particularly in svcWaitSynchronization, svcReplyAndReceive, and svcGetThreadContext	2018-10-24 13:41:32 -04:00
Lioncash	6df09f5b76	kernel/error: Add error code for closed sessions The kernel appears to return 0xF601 for this case.	2018-10-24 13:38:39 -04:00
Lioncash	1edf8660bc	game_list_worker: Use QString's formatting instead of fmt in FormatPatchNameVersions() Using fmt here requires unnecessary string conversions back into QString. Instead, we can just use QString's formatting and get the end result of the formatting operation in the proper type.	2018-10-24 11:27:35 -04:00
Lioncash	4a31f99a02	profile_manager: Use std::optional instead of boost::optional Now that we can actually use std::optional on macOS, we don't need to continue using boost::optional here.	2018-10-24 11:06:52 -04:00
Lioncash	030847d5fa	graphic_breakpoints: Correct translation of strings in BreakpointModel's data() function tr() will not function properly on static/global data like this, as the object is only ever constructed once, so the strings won't translate if the language is changed without restarting the program, which is undesirable. Instead we can just turn the map into a plain old function that maps the values to their equivalent strings. This is also lessens the memory allocated, since it's only allocating memory for the strings themselves, and not an encompassing map as well.	2018-10-24 11:01:23 -04:00
Mat M	77e705a8fa	Merge pull request #1468 from DarkLordZach/profile-manager-ui qt: Add UI to manage emulated user profiles	2018-10-24 10:10:29 -04:00
Zach Hilman	e7ac42677b	configure_system: Clear current username before overwriting Prevents bug where old username would remain if the new username was shorter in length.	2018-10-24 09:25:20 -04:00
Lioncash	a1c85b8c55	game_list: Use QFileInfo instead of common's file functions We can just use the facilities that Qt provides instead of pulling in stuff from common. While we're at it, we can also simplify the nearby logging statement's argument by just calling .toStdString()	2018-10-24 08:40:22 -04:00
Lioncash	47f081d513	game_list: Make game list column headers translatable These are user-facing strings, so they should be marked as translatable	2018-10-24 08:20:35 -04:00
Lioncash	2cbc284c2b	bootmanager: Use QStringLiteral instead of std::string to represent the window title This gets rid of an unnecessary type conversion. We can just use the regular QStringLiteral to already format the string as the type setWindowTitle accepts instead of converting from a std::string instance.	2018-10-24 08:14:26 -04:00
Lioncash	6d27614994	time_stretch: Remove unused m_channel_count member variable This is only stored to, but never read from.	2018-10-24 00:46:17 -04:00
Lioncash	93596d03ec	npad: Remove unused controller variable from OnInit() This also gets rid of variable shadowing related to the lambda parameter a little bit below this code as well.	2018-10-24 00:38:03 -04:00
Lioncash	7c9f7aeacc	perf_stats: Remove unused variable within DoFrameLimiting() This hasn't been used since `ba8ff096fd`	2018-10-24 00:33:26 -04:00
Lioncash	6949f73149	yuzu/configuration/config: Use a std::unique_ptr for qt_config instead of a raw pointer Same behavior, less code.	2018-10-24 00:24:02 -04:00
Lioncash	a3d1ede25f	aoc_u: Make use of previously-unused CheckAOCTitleIDMatchesBase() function We can just call the function instead of duplicating the code here. This also prevents an unused function warning. We also don't need to take the lambda capture by reference. It's just a u64 value, so by value is fine here.	2018-10-24 00:13:08 -04:00
Lioncash	c7c594a6b8	vfs: Handle failure of file reading within VfsRawCopy() Also gets rid of an unused variable.	2018-10-24 00:01:32 -04:00
Lioncash	c6529688fc	key_manager: Remove unused variable in DeriveBase()	2018-10-24 00:00:12 -04:00
Lioncash	257b7bbfee	decoders: Remove unused variable within SwizzledData()	2018-10-23 23:51:13 -04:00
Lioncash	a97cdb5eb4	maxwell_3d: Remove unused variable within ProcessQueryGet()	2018-10-23 23:50:16 -04:00
Lioncash	f80b80b922	logging/backend: Add missing services to the log filters Just a few overlooked services.	2018-10-23 22:35:59 -04:00
Lioncash	6f5bede402	yuzu/configuration/config: Reorganize member variable and function layout Makes the class layout consistent with the others.	2018-10-23 21:46:49 -04:00
bunnei	a94e5d9e68	Merge pull request #1551 from ogniK5377/improved-svcbreak Added break types to svcBreak	2018-10-23 19:56:42 -04:00
Zach Hilman	bfad41b0c1	profile_manager: Create save data if it doesn't exist on use	2018-10-23 19:31:28 -04:00
Zach Hilman	45f2a2fe29	acc: Fix account UUID duplication error	2018-10-23 19:31:28 -04:00
Zach Hilman	e408bbceed	configure_system: Clear selection after user delete	2018-10-23 19:31:28 -04:00
Zach Hilman	702622b8f1	profile_manager: Load user icons, names, and UUIDs from system save	2018-10-23 19:31:28 -04:00
Zach Hilman	19c5cf9c63	acc: Load user images from config dir	2018-10-23 19:31:28 -04:00
Zach Hilman	466960c8ab	qt: Allow user to select emu user on open save data	2018-10-23 19:31:28 -04:00
Zach Hilman	b2a8209c5b	qt: Add Profile Manager UI to system settings	2018-10-23 19:31:28 -04:00
Zach Hilman	d3fbf45705	am: Pass current user UUID to launch parameters	2018-10-23 19:31:28 -04:00
Zach Hilman	aeffd4b436	profile_manager: Load users from emulator settings	2018-10-23 19:31:28 -04:00
Zach Hilman	e7e3d5898e	settings: Add users and current_user settings and remove username	2018-10-23 19:31:28 -04:00
David	50e4e81fd3	Added Amiibo support (#1390 ) * Fixed conflict with nfp * Few fixups for nfc * Conflict 2 * Fixed AttachAvailabilityChangeEvent * Conflict 3 * Fixed byte padding * Refactored amiibo to not reside in "System" * Removed remaining references of nfc from system * used enum for Nfc GetStateOld * Added missing newline * Moved file operations to front end * Conflict 4 * Amiibos now use structs and added mutexes * Removed amiibo_path	2018-10-23 19:28:17 -04:00
bunnei	5edb2403c2	Merge pull request #1515 from DarkLordZach/dlc-lfs patch_manager: Add support for LayeredFS on DLC RomFS	2018-10-23 19:26:57 -04:00
bunnei	fc9d8afead	Merge pull request #1542 from lioncash/project CMakeLists: Use PROJECT_SOURCE_DIR instead of CMAKE_SOURCE_DIR	2018-10-23 18:44:08 -04:00
bunnei	a5106fb9f5	Merge pull request #1553 from lioncash/mem common: Remove memory_util.h/.cpp	2018-10-23 18:43:45 -04:00
bunnei	e61a62066a	Merge pull request #1540 from lioncash/handle kernel/process: Make the handle table per-process	2018-10-23 18:43:11 -04:00
FernandoS27	ed8ca608a0	Implement PointSize	2018-10-23 15:08:00 -04:00
FernandoS27	e0ea2f5f6e	Fixed Layered Textures Loading and Cubemaps	2018-10-23 14:27:36 -04:00
David Marcec	38cdb6744d	Added assertion failed, reworked logging levels	2018-10-23 15:17:13 +11:00
David Marcec	8042731da9	Added break types to svcBreak There seems to be more such as type 1, and 2. Unsure what these currently are but when a game hits them we can investigate and add the rest	2018-10-23 15:03:59 +11:00
Lioncash	c8beb665dc	CMakeLists: Use PROJECT_SOURCE_DIR instead of CMAKE_SOURCE_DIR This is more localized to what we want to enforce directory-wise with the project. CMAKE_SOURCE_DIR indicates the root of the source tree, but this would cause the wrong behavior if someone included yuzu as part of a larger buildsystem (for whatever reason). Instead, we want to use the directory where the "project(yuzu)" command was declared as the root path reference.	2018-10-20 17:36:31 -04:00
Lioncash	90a981a03a	kernel/process: Make the handle table per-process In the kernel, there isn't a singular handle table that everything gets tossed into or used, rather, each process gets its own handle table that it uses. This currently isn't an issue for us, since we only execute one process at the moment, but we may as well get this out of the way so it's not a headache later on.	2018-10-20 16:38:32 -04:00
Zach Hilman	9d0fb0f815	qt: Add support for dumping a DLC Data RomFS	2018-10-17 18:27:29 -04:00
Zach Hilman	59044862a9	registered_cache: Deduplicate results of ListEntry and ListEntryFilter Prevents a Entry from appearing in the list twice if the user has it installed in two places (e.g. User NAND and SDMC)	2018-10-17 14:04:18 -04:00
Zach Hilman	780c21ab2d	fsp_srv: Apply patches to Data storage in OpenDataStorageByDataId	2018-10-17 09:04:20 -04:00
Zach Hilman	d8273c3857	patch_manager: Add support for using LayeredFS with Data	2018-10-17 09:03:56 -04:00