ldr_ro: Add error check for memory allocation failure

Includes actual unmapping and address error checking.

src/common/bit_field.h

@@ -117,21 +117,21 @@ private:
     // We don't delete it because we want BitField to be trivially copyable.
     constexpr BitField& operator=(const BitField&) = default;
 
-    // UnderlyingType is T for non-enum types and the underlying type of T if
+    // StorageType is T for non-enum types and the underlying type of T if
     // T is an enumeration. Note that T is wrapped within an enable_if in the
     // former case to workaround compile errors which arise when using
     // std::underlying_type<T>::type directly.
-    using UnderlyingType = typename std::conditional_t<std::is_enum_v<T>, std::underlying_type<T>,
-                                                       std::enable_if<true, T>>::type;
+    using StorageType = typename std::conditional_t<std::is_enum<T>::value, std::underlying_type<T>,
+                                                    std::enable_if<true, T>>::type;
 
-    // We store the value as the unsigned type to avoid undefined behaviour on value shifting
-    using StorageType = std::make_unsigned_t<UnderlyingType>;
+    // Unsigned version of StorageType
+    using StorageTypeU = std::make_unsigned_t<StorageType>;
 
 public:
     /// Constants to allow limited introspection of fields if needed
     static constexpr std::size_t position = Position;
     static constexpr std::size_t bits = Bits;
-    static constexpr StorageType mask = (((StorageType)~0) >> (8 * sizeof(T) - bits)) << position;
+    static constexpr StorageType mask = (((StorageTypeU)~0) >> (8 * sizeof(T) - bits)) << position;
 
     /**
      * Formats a value by masking and shifting it according to the field parameters. A value
@@ -148,12 +148,11 @@ public:
      * union in a constexpr context.
      */
     static constexpr FORCE_INLINE T ExtractValue(const StorageType& storage) {
-        if constexpr (std::numeric_limits<UnderlyingType>::is_signed) {
+        if (std::numeric_limits<T>::is_signed) {
             std::size_t shift = 8 * sizeof(T) - bits;
-            return static_cast<T>(static_cast<UnderlyingType>(storage << (shift - position)) >>
-                                  shift);
+            return (T)((storage << (shift - position)) >> shift);
         } else {
-            return static_cast<T>((storage & mask) >> position);
+            return (T)((storage & mask) >> position);
         }
     }
 

src/core/file_sys/bis_factory.cpp

@@ -8,9 +8,8 @@
 
 namespace FileSys {
 
-BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir dump_root_)
+BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_)
     : nand_root(std::move(nand_root_)), load_root(std::move(load_root_)),
-      dump_root(std::move(dump_root_)),
       sysnand_cache(std::make_unique<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
       usrnand_cache(std::make_unique<RegisteredCache>(
@@ -33,10 +32,4 @@ VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {
     return GetOrCreateDirectoryRelative(load_root, fmt::format("/{:016X}", title_id));
 }
 
-VirtualDir BISFactory::GetModificationDumpRoot(u64 title_id) const {
-    if (title_id == 0)
-        return nullptr;
-    return GetOrCreateDirectoryRelative(dump_root, fmt::format("/{:016X}", title_id));
-}
-
 } // namespace FileSys

src/core/file_sys/bis_factory.h

@@ -17,19 +17,17 @@ class RegisteredCache;
 /// registered caches.
 class BISFactory {
 public:
-    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root, VirtualDir dump_root);
+    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root);
     ~BISFactory();
 
     RegisteredCache* GetSystemNANDContents() const;
     RegisteredCache* GetUserNANDContents() const;
 
     VirtualDir GetModificationLoadRoot(u64 title_id) const;
-    VirtualDir GetModificationDumpRoot(u64 title_id) const;
 
 private:
     VirtualDir nand_root;
     VirtualDir load_root;
-    VirtualDir dump_root;
 
     std::unique_ptr<RegisteredCache> sysnand_cache;
     std::unique_ptr<RegisteredCache> usrnand_cache;

src/core/file_sys/card_image.cpp

@@ -176,7 +176,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     for (const VirtualFile& file : partitions[static_cast<std::size_t>(part)]->GetFiles()) {
         if (file->GetExtension() != "nca")
             continue;
-        auto nca = std::make_shared<NCA>(file, nullptr, 0, keys);
+        auto nca = std::make_shared<NCA>(file);
         // TODO(DarkLordZach): Add proper Rev1+ Support
         if (nca->IsUpdate())
             continue;

src/core/file_sys/card_image.h

@@ -9,7 +9,6 @@
 #include <vector>
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs.h"
 
 namespace Loader {
@@ -108,7 +107,5 @@ private:
     std::shared_ptr<NSP> secure_partition;
     std::shared_ptr<NCA> program;
     std::vector<std::shared_ptr<NCA>> ncas;
-
-    Core::Crypto::KeyManager keys;
 };
 } // namespace FileSys

src/core/file_sys/content_archive.cpp

@@ -101,9 +101,8 @@ static bool IsValidNCA(const NCAHeader& header) {
     return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }
 
-NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset,
-         Core::Crypto::KeyManager keys_)
-    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)), keys(std::move(keys_)) {
+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) {
         status = Loader::ResultStatus::ErrorNullFile;
         return;

src/core/file_sys/content_archive.h

@@ -79,8 +79,7 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
 class NCA : public ReadOnlyVfsDirectory {
 public:
     explicit NCA(VirtualFile file, VirtualFile bktr_base_romfs = nullptr,
-                 u64 bktr_base_ivfc_offset = 0,
-                 Core::Crypto::KeyManager keys = Core::Crypto::KeyManager());
+                 u64 bktr_base_ivfc_offset = 0);
     ~NCA() override;
 
     Loader::ResultStatus GetStatus() const;

src/core/file_sys/errors.h

@@ -8,10 +8,25 @@
 
 namespace FileSys {
 
-constexpr ResultCode ERROR_PATH_NOT_FOUND{ErrorModule::FS, 1};
-constexpr ResultCode ERROR_ENTITY_NOT_FOUND{ErrorModule::FS, 1002};
-constexpr ResultCode ERROR_SD_CARD_NOT_FOUND{ErrorModule::FS, 2001};
-constexpr ResultCode ERROR_INVALID_OFFSET{ErrorModule::FS, 6061};
-constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::FS, 6062};
+namespace ErrCodes {
+enum {
+    NotFound = 1,
+    TitleNotFound = 1002,
+    SdCardNotFound = 2001,
+    RomFSNotFound = 2520,
+};
+}
+
+constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
+
+// TODO(bunnei): Replace these with correct errors for Switch OS
+constexpr ResultCode ERROR_INVALID_PATH(-1);
+constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
+constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
+constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
 
 } // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -19,7 +19,6 @@
 #include "core/file_sys/vfs_vector.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
-#include "core/settings.h"
 
 namespace FileSys {
 
@@ -120,18 +119,6 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
     const auto build_id_raw = Common::HexArrayToString(header.build_id);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
-    if (Settings::values.dump_nso) {
-        LOG_INFO(Loader, "Dumping NSO for build_id={}, title_id={:016X}", build_id, title_id);
-        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
-        if (dump_dir != nullptr) {
-            const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
-            const auto file = nso_dir->CreateFile(fmt::format("{}.nso", build_id));
-
-            file->Resize(nso.size());
-            file->WriteBytes(nso);
-        }
-    }
-
     LOG_INFO(Loader, "Patching NSO for build_id={}", build_id);
 
     const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);

src/core/file_sys/registered_cache.cpp

@@ -106,12 +106,9 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
 
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
-    const auto file = dir->GetFileRelative(path);
-    if (file != nullptr)
-        return file;
-
-    const auto nca_dir = dir->GetDirectoryRelative(path);
-    if (nca_dir != nullptr) {
+    if (dir->GetFileRelative(path) != nullptr)
+        return dir->GetFileRelative(path);
+    if (dir->GetDirectoryRelative(path) != nullptr) {
         const auto nca_dir = dir->GetDirectoryRelative(path);
         VirtualFile file = nullptr;
 
@@ -228,7 +225,7 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
 
         if (file == nullptr)
             continue;
-        const auto nca = std::make_shared<NCA>(parser(file, id), nullptr, 0, keys);
+        const auto nca = std::make_shared<NCA>(parser(file, id));
         if (nca->GetStatus() != Loader::ResultStatus::Success ||
             nca->GetType() != NCAContentType::Meta) {
             continue;
@@ -318,7 +315,7 @@ std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType t
     const auto raw = GetEntryRaw(title_id, type);
     if (raw == nullptr)
         return nullptr;
-    return std::make_unique<NCA>(raw, nullptr, 0, keys);
+    return std::make_unique<NCA>(raw);
 }
 
 std::unique_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {

src/core/file_sys/registered_cache.h

@@ -12,7 +12,6 @@
 #include <vector>
 #include <boost/container/flat_map.hpp>
 #include "common/common_types.h"
-#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
@@ -134,8 +133,6 @@ private:
 
     VirtualDir dir;
     RegisteredCacheParsingFunction parser;
-    Core::Crypto::KeyManager keys;
-
     // maps tid -> NcaID of meta
     boost::container::flat_map<u64, NcaID> meta_id;
     // maps tid -> meta

src/core/file_sys/submission_package.cpp

@@ -252,7 +252,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                     continue;
                 }
 
-                auto next_nca = std::make_shared<NCA>(next_file, nullptr, 0, keys);
+                auto next_nca = std::make_shared<NCA>(next_file);
                 if (next_nca->GetType() == NCAContentType::Program)
                     program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
                 if (next_nca->GetStatus() == Loader::ResultStatus::Success ||

src/core/file_sys/submission_package.h

@@ -70,8 +70,6 @@ private:
     std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> ncas;
     std::vector<VirtualFile> ticket_files;
 
-    Core::Crypto::KeyManager keys;
-
     VirtualFile romfs;
     VirtualDir exefs;
 };

src/core/hle/kernel/process.cpp

@@ -252,8 +252,8 @@ ResultCode Process::HeapFree(VAddr target, u32 size) {
     return vm_manager.HeapFree(target, size);
 }
 
-ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    return vm_manager.MirrorMemory(dst_addr, src_addr, size);
+ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, MemoryState state) {
+    return vm_manager.MirrorMemory(dst_addr, src_addr, size, state);
 }
 
 ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {

src/core/hle/kernel/process.h

@@ -259,7 +259,8 @@ public:
     ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
     ResultCode HeapFree(VAddr target, u32 size);
 
-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size,
+                            MemoryState state = MemoryState::Mapped);
 
     ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
 

src/core/hle/kernel/svc.cpp

@@ -123,48 +123,6 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
     return RESULT_SUCCESS;
 }
 
-static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
-    LOG_TRACE(Kernel_SVC, "called, addr=0x{:X}, size=0x{:X}, prot=0x{:X}", addr, size, prot);
-
-    if (!Common::Is4KBAligned(addr)) {
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (size == 0 || !Common::Is4KBAligned(size)) {
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!IsValidAddressRange(addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    const auto permission = static_cast<MemoryPermission>(prot);
-    if (permission != MemoryPermission::None && permission != MemoryPermission::Read &&
-        permission != MemoryPermission::ReadWrite) {
-        return ERR_INVALID_MEMORY_PERMISSIONS;
-    }
-
-    auto* const current_process = Core::CurrentProcess();
-    auto& vm_manager = current_process->VMManager();
-
-    if (!IsInsideAddressSpace(vm_manager, addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    const VMManager::VMAHandle iter = vm_manager.FindVMA(addr);
-    if (iter == vm_manager.vma_map.end()) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    LOG_WARNING(Kernel_SVC, "Uniformity check on protected memory is not implemented.");
-    // TODO: Performs a uniformity check to make sure only protected memory is changed (it doesn't
-    // make sense to allow changing permissions on kernel memory itself, etc).
-
-    const auto converted_permissions = SharedMemory::ConvertPermissions(permission);
-
-    return vm_manager.ReprotectRange(addr, size, converted_permissions);
-}
-
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
     LOG_WARNING(Kernel_SVC,
                 "(STUBBED) called, addr=0x{:X}, size=0x{:X}, state0=0x{:X}, state1=0x{:X}", addr,
@@ -1339,7 +1297,7 @@ struct FunctionDef {
 static const FunctionDef SVC_Table[] = {
     {0x00, nullptr, "Unknown"},
     {0x01, SvcWrap<SetHeapSize>, "SetHeapSize"},
-    {0x02, SvcWrap<SetMemoryPermission>, "SetMemoryPermission"},
+    {0x02, nullptr, "SetMemoryPermission"},
     {0x03, SvcWrap<SetMemoryAttribute>, "SetMemoryAttribute"},
     {0x04, SvcWrap<MapMemory>, "MapMemory"},
     {0x05, SvcWrap<UnmapMemory>, "UnmapMemory"},

src/core/hle/kernel/svc_wrap.h

@@ -121,11 +121,6 @@ void SvcWrap() {
     FuncReturn(func(Param(0), Param(1), Param(2)).raw);
 }
 
-template <ResultCode func(u64, u64, u32)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2))).raw);
-}
-
 template <ResultCode func(u32, u64, u64, u32)>
 void SvcWrap() {
     FuncReturn(

src/core/hle/kernel/thread.cpp

@@ -142,7 +142,36 @@ void Thread::ResumeFromWait() {
 
     status = ThreadStatus::Ready;
 
-    ChangeScheduler();
+    std::optional<s32> new_processor_id = GetNextProcessorId(affinity_mask);
+    if (!new_processor_id) {
+        new_processor_id = processor_id;
+    }
+    if (ideal_core != -1 &&
+        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+        new_processor_id = ideal_core;
+    }
+
+    ASSERT(*new_processor_id < 4);
+
+    // Add thread to new core's scheduler
+    auto* next_scheduler = &Core::System::GetInstance().Scheduler(*new_processor_id);
+
+    if (*new_processor_id != processor_id) {
+        // Remove thread from previous core's scheduler
+        scheduler->RemoveThread(this);
+        next_scheduler->AddThread(this, current_priority);
+    }
+
+    processor_id = *new_processor_id;
+
+    // If the thread was ready, unschedule from the previous core and schedule on the new core
+    scheduler->UnscheduleThread(this, current_priority);
+    next_scheduler->ScheduleThread(this, current_priority);
+
+    // Change thread's scheduler
+    scheduler = next_scheduler;
+
+    Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
 
 /**
@@ -335,45 +364,42 @@ void Thread::UpdatePriority() {
 void Thread::ChangeCore(u32 core, u64 mask) {
     ideal_core = core;
     affinity_mask = mask;
-    ChangeScheduler();
-}
 
-void Thread::ChangeScheduler() {
     if (status != ThreadStatus::Ready) {
         return;
     }
 
-    auto& system = Core::System::GetInstance();
     std::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
 
     if (!new_processor_id) {
         new_processor_id = processor_id;
     }
-    if (ideal_core != -1 && system.Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+    if (ideal_core != -1 &&
+        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
         new_processor_id = ideal_core;
     }
 
     ASSERT(*new_processor_id < 4);
 
     // Add thread to new core's scheduler
-    auto& next_scheduler = system.Scheduler(*new_processor_id);
+    auto* next_scheduler = &Core::System::GetInstance().Scheduler(*new_processor_id);
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler
         scheduler->RemoveThread(this);
-        next_scheduler.AddThread(this, current_priority);
+        next_scheduler->AddThread(this, current_priority);
     }
 
     processor_id = *new_processor_id;
 
     // If the thread was ready, unschedule from the previous core and schedule on the new core
     scheduler->UnscheduleThread(this, current_priority);
-    next_scheduler.ScheduleThread(this, current_priority);
+    next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler
-    scheduler = &next_scheduler;
+    scheduler = next_scheduler;
 
-    system.CpuCore(processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
 
 bool Thread::AllWaitObjectsReady() {

src/core/hle/kernel/thread.h

@@ -374,8 +374,6 @@ private:
     explicit Thread(KernelCore& kernel);
     ~Thread() override;
 
-    void ChangeScheduler();
-
     Core::ARM_Interface::ThreadContext context{};
 
     u32 thread_id = 0;

src/core/hle/kernel/vm_manager.cpp

@@ -298,7 +298,7 @@ ResultCode VMManager::HeapFree(VAddr target, u64 size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
+ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, MemoryState state) {
     const auto vma = FindVMA(src_addr);
 
     ASSERT_MSG(vma != vma_map.end(), "Invalid memory address");
@@ -312,8 +312,8 @@ ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
     const std::shared_ptr<std::vector<u8>>& backing_block = vma->second.backing_block;
     const std::size_t backing_block_offset = vma->second.offset + vma_offset;
 
-    CASCADE_RESULT(auto new_vma, MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
-                                                MemoryState::Mapped));
+    CASCADE_RESULT(auto new_vma,
+                   MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size, state));
     // Protect mirror with permissions from old region
     Reprotect(new_vma, vma->second.permissions);
     // Remove permissions from old region

src/core/hle/kernel/vm_manager.h

@@ -189,7 +189,8 @@ public:
     ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
     ResultCode HeapFree(VAddr target, u64 size);
 
-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size,
+                            MemoryState state = MemoryState::Mapped);
 
     /**
      * Scans all VMAs and updates the page table range of any that use the given vector as backing

src/core/hle/result.h

@@ -19,6 +19,8 @@
 enum class ErrorDescription : u32 {
     Success = 0,
     RemoteProcessDead = 301,
+    InvalidOffset = 6061,
+    InvalidLength = 6062,
 };
 
 /**

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

@@ -28,13 +28,13 @@ public:
             {1, &IAudioRenderer::GetSampleCount, "GetSampleCount"},
             {2, &IAudioRenderer::GetMixBufferCount, "GetMixBufferCount"},
             {3, &IAudioRenderer::GetState, "GetState"},
-            {4, &IAudioRenderer::RequestUpdateImpl, "RequestUpdate"},
+            {4, &IAudioRenderer::RequestUpdate, "RequestUpdate"},
             {5, &IAudioRenderer::Start, "Start"},
             {6, &IAudioRenderer::Stop, "Stop"},
             {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
             {8, &IAudioRenderer::SetRenderingTimeLimit, "SetRenderingTimeLimit"},
             {9, &IAudioRenderer::GetRenderingTimeLimit, "GetRenderingTimeLimit"},
-            {10, &IAudioRenderer::RequestUpdateImpl, "RequestUpdateAuto"},
+            {10, nullptr, "RequestUpdateAuto"},
             {11, nullptr, "ExecuteAudioRendererRendering"},
         };
         // clang-format on
@@ -79,7 +79,7 @@ private:
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void RequestUpdateImpl(Kernel::HLERequestContext& ctx) {
+    void RequestUpdate(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

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

@@ -77,8 +77,8 @@ private:
         IPC::ResponseBuilder rb{ctx, 6};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(consumed);
-        rb.Push<u32>(sample_count);
         rb.Push<u64>(performance);
+        rb.Push<u32>(sample_count);
         ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
     }
 

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

@@ -303,7 +303,7 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
               static_cast<u8>(space), save_struct.DebugInfo());
 
     if (save_data_factory == nullptr) {
-        return FileSys::ERROR_ENTITY_NOT_FOUND;
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound);
     }
 
     return save_data_factory->Open(space, save_struct);
@@ -313,7 +313,7 @@ ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space)
     LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", static_cast<u8>(space));
 
     if (save_data_factory == nullptr) {
-        return FileSys::ERROR_ENTITY_NOT_FOUND;
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound);
     }
 
     return MakeResult(save_data_factory->GetSaveDataSpaceDirectory(space));
@@ -323,22 +323,15 @@ ResultVal<FileSys::VirtualDir> OpenSDMC() {
     LOG_TRACE(Service_FS, "Opening SDMC");
 
     if (sdmc_factory == nullptr) {
-        return FileSys::ERROR_SD_CARD_NOT_FOUND;
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SdCardNotFound);
     }
 
     return sdmc_factory->Open();
 }
 
-std::shared_ptr<FileSys::RegisteredCacheUnion> registered_cache_union;
-
-std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
-    if (registered_cache_union == nullptr) {
-        registered_cache_union =
-            std::make_shared<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
-                GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
-    }
-
-    return registered_cache_union;
+std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
+    return std::make_unique<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
+        GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
 }
 
 FileSys::RegisteredCache* GetSystemNANDContents() {
@@ -377,15 +370,6 @@ FileSys::VirtualDir GetModificationLoadRoot(u64 title_id) {
     return bis_factory->GetModificationLoadRoot(title_id);
 }
 
-FileSys::VirtualDir GetModificationDumpRoot(u64 title_id) {
-    LOG_TRACE(Service_FS, "Opening mod dump root for tid={:016X}", title_id);
-
-    if (bis_factory == nullptr)
-        return nullptr;
-
-    return bis_factory->GetModificationDumpRoot(title_id);
-}
-
 void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
     if (overwrite) {
         bis_factory = nullptr;
@@ -399,21 +383,13 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
                                           FileSys::Mode::ReadWrite);
     auto load_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::LoadDir),
                                             FileSys::Mode::ReadWrite);
-    auto dump_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::DumpDir),
-                                            FileSys::Mode::ReadWrite);
 
-    if (bis_factory == nullptr) {
-        bis_factory =
-            std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_directory);
-    }
-
-    if (save_data_factory == nullptr) {
+    if (bis_factory == nullptr)
+        bis_factory = std::make_unique<FileSys::BISFactory>(nand_directory, load_directory);
+    if (save_data_factory == nullptr)
         save_data_factory = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
-    }
-
-    if (sdmc_factory == nullptr) {
+    if (sdmc_factory == nullptr)
         sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
-    }
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager, FileSys::VfsFilesystem& vfs) {

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

@@ -48,14 +48,13 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
 ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 
-std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
+std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
 
 FileSys::RegisteredCache* GetSystemNANDContents();
 FileSys::RegisteredCache* GetUserNANDContents();
 FileSys::RegisteredCache* GetSDMCContents();
 
 FileSys::VirtualDir GetModificationLoadRoot(u64 title_id);
-FileSys::VirtualDir GetModificationDumpRoot(u64 title_id);
 
 // Creates the SaveData, SDMC, and BIS Factories. Should be called once and before any function
 // above is called.

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

@@ -63,12 +63,12 @@ private:
         // Error checking
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(FileSys::ERROR_INVALID_SIZE);
+            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
             return;
         }
         if (offset < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(FileSys::ERROR_INVALID_OFFSET);
+            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
             return;
         }
 
@@ -108,12 +108,12 @@ private:
         // Error checking
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(FileSys::ERROR_INVALID_SIZE);
+            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
             return;
         }
         if (offset < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(FileSys::ERROR_INVALID_OFFSET);
+            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
             return;
         }
 
@@ -139,12 +139,12 @@ private:
         // Error checking
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(FileSys::ERROR_INVALID_SIZE);
+            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
             return;
         }
         if (offset < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(FileSys::ERROR_INVALID_OFFSET);
+            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
             return;
         }
 
@@ -744,7 +744,7 @@ void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
 
     if (dir.Failed()) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 0};
-        rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
+        rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
         return;
     }
 
@@ -836,7 +836,7 @@ void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
               static_cast<u8>(storage_id), title_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
+    rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
 }
 
 } // namespace Service::FileSystem

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

@@ -40,29 +40,6 @@ enum class JoystickId : std::size_t {
     Joystick_Right,
 };
 
-static std::size_t NPadIdToIndex(u32 npad_id) {
-    switch (npad_id) {
-    case 0:
-    case 1:
-    case 2:
-    case 3:
-    case 4:
-    case 5:
-    case 6:
-    case 7:
-        return npad_id;
-    case 8:
-    case NPAD_HANDHELD:
-        return 8;
-    case 9:
-    case NPAD_UNKNOWN:
-        return 9;
-    default:
-        UNIMPLEMENTED_MSG("Unknown npad id {}", npad_id);
-        return 0;
-    }
-}
-
 Controller_NPad::Controller_NPad() = default;
 Controller_NPad::~Controller_NPad() = default;
 
@@ -311,11 +288,10 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
         switch (controller_type) {
         case NPadControllerType::Handheld:
             handheld_entry.connection_status.raw = 0;
-            handheld_entry.connection_status.IsWired.Assign(1);
-            handheld_entry.connection_status.IsLeftJoyConnected.Assign(1);
-            handheld_entry.connection_status.IsRightJoyConnected.Assign(1);
-            handheld_entry.connection_status.IsLeftJoyWired.Assign(1);
-            handheld_entry.connection_status.IsRightJoyWired.Assign(1);
+            handheld_entry.connection_status.IsConnected.Assign(1);
+            if (!Settings::values.use_docked_mode) {
+                handheld_entry.connection_status.IsWired.Assign(1);
+            }
             handheld_entry.pad_states.raw = pad_state.raw;
             handheld_entry.l_stick = lstick_entry;
             handheld_entry.r_stick = rstick_entry;
@@ -395,30 +371,16 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
     supported_npad_id_types.clear();
     supported_npad_id_types.resize(length / sizeof(u32));
     std::memcpy(supported_npad_id_types.data(), data, length);
-    bool had_controller_update = false;
     for (std::size_t i = 0; i < connected_controllers.size(); i++) {
         auto& controller = connected_controllers[i];
         if (!controller.is_connected) {
             continue;
         }
         if (!IsControllerSupported(PREFERRED_CONTROLLER)) {
-            const auto best_type = DecideBestController(PREFERRED_CONTROLLER);
-            const bool is_handheld = (best_type == NPadControllerType::Handheld ||
-                                      PREFERRED_CONTROLLER == NPadControllerType::Handheld);
-            if (is_handheld) {
-                controller.type = NPadControllerType::None;
-                controller.is_connected = false;
-                AddNewController(best_type);
-            } else {
-                controller.type = best_type;
-                InitNewlyAddedControler(i);
-            }
-            had_controller_update = true;
+            controller.type = DecideBestController(PREFERRED_CONTROLLER);
+            InitNewlyAddedControler(i);
         }
     }
-    if (had_controller_update) {
-        styleset_changed_event->Signal();
-    }
 }
 
 void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
@@ -496,11 +458,15 @@ void Controller_NPad::AddNewController(NPadControllerType controller) {
 }
 
 void Controller_NPad::ConnectNPad(u32 npad_id) {
-    connected_controllers[NPadIdToIndex(npad_id)].is_connected = true;
+    if (npad_id >= connected_controllers.size())
+        return;
+    connected_controllers[npad_id].is_connected = true;
 }
 
 void Controller_NPad::DisconnectNPad(u32 npad_id) {
-    connected_controllers[NPadIdToIndex(npad_id)].is_connected = false;
+    if (npad_id >= connected_controllers.size())
+        return;
+    connected_controllers[npad_id].is_connected = false;
 }
 
 Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {

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

@@ -286,10 +286,10 @@ public:
             {519, nullptr, "GetPalmaOperationResult"},
             {520, nullptr, "ReadPalmaPlayLog"},
             {521, nullptr, "ResetPalmaPlayLog"},
-            {522, &Hid::SetIsPalmaAllConnectable, "SetIsPalmaAllConnectable"},
+            {522, nullptr, "SetIsPalmaAllConnectable"},
             {523, nullptr, "SetIsPalmaPairedConnectable"},
             {524, nullptr, "PairPalma"},
-            {525, &Hid::SetPalmaBoostMode, "SetPalmaBoostMode"},
+            {525, nullptr, "SetPalmaBoostMode"},
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
@@ -596,18 +596,6 @@ private:
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
-
-    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
-
-    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_HID, "(STUBBED) called");
-    }
 };
 
 class HidDbg final : public ServiceFramework<HidDbg> {

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

@@ -4,7 +4,10 @@
 
 #include <memory>
 #include <fmt/format.h>
+#include <mbedtls/sha256.h>
 
+#include "common/alignment.h"
+#include "common/hex_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/ldr/ldr.h"
@@ -13,6 +16,38 @@
 
 namespace Service::LDR {
 
+namespace ErrCodes {
+enum {
+    InvalidMemoryState = 51,
+    InvalidNRO = 52,
+    InvalidNRR = 53,
+    MissingNRRHash = 54,
+    MaximumNRO = 55,
+    MaximumNRR = 56,
+    AlreadyLoaded = 57,
+    InvalidAlignment = 81,
+    InvalidSize = 82,
+    InvalidNROAddress = 84,
+    InvalidNRRAddress = 85,
+    NotInitialized = 87,
+};
+}
+
+constexpr ResultCode ERROR_INVALID_MEMORY_STATE(ErrorModule::Loader, ErrCodes::InvalidMemoryState);
+constexpr ResultCode ERROR_INVALID_NRO(ErrorModule::Loader, ErrCodes::InvalidNRO);
+constexpr ResultCode ERROR_INVALID_NRR(ErrorModule::Loader, ErrCodes::InvalidNRR);
+constexpr ResultCode ERROR_MISSING_NRR_HASH(ErrorModule::Loader, ErrCodes::MissingNRRHash);
+constexpr ResultCode ERROR_MAXIMUM_NRO(ErrorModule::Loader, ErrCodes::MaximumNRO);
+constexpr ResultCode ERROR_MAXIMUM_NRR(ErrorModule::Loader, ErrCodes::MaximumNRR);
+constexpr ResultCode ERROR_ALREADY_LOADED(ErrorModule::Loader, ErrCodes::AlreadyLoaded);
+constexpr ResultCode ERROR_INVALID_ALIGNMENT(ErrorModule::Loader, ErrCodes::InvalidAlignment);
+constexpr ResultCode ERROR_INVALID_SIZE(ErrorModule::Loader, ErrCodes::InvalidSize);
+constexpr ResultCode ERROR_INVALID_NRO_ADDRESS(ErrorModule::Loader, ErrCodes::InvalidNROAddress);
+constexpr ResultCode ERROR_INVALID_NRR_ADDRESS(ErrorModule::Loader, ErrCodes::InvalidNRRAddress);
+constexpr ResultCode ERROR_NOT_INITIALIZED(ErrorModule::Loader, ErrCodes::NotInitialized);
+
+constexpr u64 MAXIMUM_LOADED_RO = 0x40;
+
 class DebugMonitor final : public ServiceFramework<DebugMonitor> {
 public:
     explicit DebugMonitor() : ServiceFramework{"ldr:dmnt"} {
@@ -64,9 +99,9 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &RelocatableObject::LoadNro, "LoadNro"},
-            {1, nullptr, "UnloadNro"},
+            {1, &RelocatableObject::UnloadNro, "UnloadNro"},
             {2, &RelocatableObject::LoadNrr, "LoadNrr"},
-            {3, nullptr, "UnloadNrr"},
+            {3, &RelocatableObject::UnloadNrr, "UnloadNrr"},
             {4, &RelocatableObject::Initialize, "Initialize"},
         };
         // clang-format on
@@ -75,9 +110,123 @@ public:
     }
 
     void LoadNrr(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        rp.Skip(2, false);
+        const VAddr nrr_addr{rp.Pop<VAddr>()};
+        const u64 nrr_size{rp.Pop<u64>()};
+
+        if (!initialized) {
+            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NOT_INITIALIZED);
+            return;
+        }
+
+        if (nrr.size() >= MAXIMUM_LOADED_RO) {
+            LOG_ERROR(Service_LDR, "Loading new NRR would exceed the maximum number of loaded NRRs "
+                                   "(0x40)! Failing...");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_MAXIMUM_NRR);
+            return;
+        }
+
+        // NRR Address does not fall on 0x1000 byte boundary
+        if (!Common::Is4KBAligned(nrr_addr)) {
+            LOG_ERROR(Service_LDR, "NRR Address has invalid alignment (actual {:016X})!", nrr_addr);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ALIGNMENT);
+            return;
+        }
+
+        // NRR Size is zero or causes overflow
+        if (nrr_addr + nrr_size <= nrr_addr || nrr_size == 0 || !Common::Is4KBAligned(nrr_size)) {
+            LOG_ERROR(Service_LDR, "NRR Size is invalid! (nrr_address={:016X}, nrr_size={:016X})",
+                      nrr_addr, nrr_size);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_SIZE);
+            return;
+        }
+        // Read NRR data from memory
+        std::vector<u8> nrr_data(nrr_size);
+        Memory::ReadBlock(nrr_addr, nrr_data.data(), nrr_size);
+        NRRHeader header;
+        std::memcpy(&header, nrr_data.data(), sizeof(NRRHeader));
+
+        if (header.magic != Common::MakeMagic('N', 'R', 'R', '0')) {
+            LOG_ERROR(Service_LDR, "NRR did not have magic 'NRR0' (actual {:08X})!", header.magic);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_NRR);
+            return;
+        }
+
+        if (header.size != nrr_size) {
+            LOG_ERROR(Service_LDR,
+                      "NRR header reported size did not match LoadNrr parameter size! "
+                      "(header_size={:016X}, loadnrr_size={:016X})",
+                      header.size, nrr_size);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_SIZE);
+            return;
+        }
+
+        if (Core::CurrentProcess()->GetTitleID() != header.title_id) {
+            LOG_ERROR(Service_LDR,
+                      "Attempting to load NRR with title ID other than current process. (actual "
+                      "{:016X})!",
+                      header.title_id);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_NRR);
+            return;
+        }
+
+        std::vector<SHA256Hash> hashes;
+
+        // Copy all hashes in the NRR (specified by hash count/hash offset) into vector.
+        for (std::size_t i = header.hash_offset;
+             i < (header.hash_offset + (header.hash_count * sizeof(SHA256Hash))); i += 8) {
+            SHA256Hash hash;
+            std::memcpy(hash.data(), nrr_data.data() + i, sizeof(SHA256Hash));
+            hashes.emplace_back(hash);
+        }
+
+        nrr.insert_or_assign(nrr_addr, std::move(hashes));
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void UnloadNrr(Kernel::HLERequestContext& ctx) {
+        if (!initialized) {
+            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NOT_INITIALIZED);
+            return;
+        }
+
+        IPC::RequestParser rp{ctx};
+        rp.Skip(2, false);
+        const auto nrr_addr{rp.Pop<VAddr>()};
+
+        if (!Common::Is4KBAligned(nrr_addr)) {
+            LOG_ERROR(Service_LDR, "NRR Address has invalid alignment (actual {:016X})!", nrr_addr);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ALIGNMENT);
+            return;
+        }
+
+        const auto iter = nrr.find(nrr_addr);
+        if (iter == nrr.end()) {
+            LOG_ERROR(Service_LDR,
+                      "Attempting to unload NRR which has not been loaded! (addr={:016X})",
+                      nrr_addr);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_NRR_ADDRESS);
+            return;
+        }
+
+        nrr.erase(iter);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_LDR, "(STUBBED) called");
     }
 
     void LoadNro(Kernel::HLERequestContext& ctx) {
@@ -88,33 +237,253 @@ public:
         const VAddr bss_addr{rp.Pop<VAddr>()};
         const u64 bss_size{rp.Pop<u64>()};
 
+        if (!initialized) {
+            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NOT_INITIALIZED);
+            return;
+        }
+
+        if (nro.size() >= MAXIMUM_LOADED_RO) {
+            LOG_ERROR(Service_LDR, "Loading new NRO would exceed the maximum number of loaded NROs "
+                                   "(0x40)! Failing...");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_MAXIMUM_NRO);
+            return;
+        }
+
+        // NRO Address does not fall on 0x1000 byte boundary
+        if (!Common::Is4KBAligned(nro_addr)) {
+            LOG_ERROR(Service_LDR, "NRO Address has invalid alignment (actual {:016X})!", nro_addr);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ALIGNMENT);
+            return;
+        }
+
+        // NRO Size or BSS Size is zero or causes overflow
+        const auto nro_size_valid =
+            nro_size != 0 && nro_addr + nro_size > nro_addr && Common::Is4KBAligned(nro_size);
+        const auto bss_size_valid =
+            nro_size + bss_size >= nro_size && (bss_size == 0 || bss_addr + bss_size > bss_addr);
+
+        if (!nro_size_valid || !bss_size_valid) {
+            LOG_ERROR(Service_LDR,
+                      "NRO Size or BSS Size is invalid! (nro_address={:016X}, nro_size={:016X}, "
+                      "bss_address={:016X}, bss_size={:016X})",
+                      nro_addr, nro_size, bss_addr, bss_size);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_SIZE);
+            return;
+        }
+
         // Read NRO data from memory
         std::vector<u8> nro_data(nro_size);
         Memory::ReadBlock(nro_addr, nro_data.data(), nro_size);
 
-        // Load NRO as new executable module
-        const VAddr addr{*Core::CurrentProcess()->VMManager().FindFreeRegion(nro_size + bss_size)};
-        Loader::AppLoader_NRO::LoadNro(nro_data, fmt::format("nro-{:08x}", addr), addr);
+        SHA256Hash hash{};
+        mbedtls_sha256(nro_data.data(), nro_data.size(), hash.data(), 0);
 
-        // TODO(bunnei): This is an incomplete implementation. It was tested with Super Mario Party.
-        // It is currently missing:
-        // - Signature checks with LoadNRR
-        // - Checking if a module has already been loaded
-        // - Using/validating BSS, etc. params (these are used from NRO header instead)
-        // - Error checking
-        // - ...Probably other things
+        // NRO Hash is already loaded
+        if (std::any_of(nro.begin(), nro.end(), [&hash](const std::pair<VAddr, NROInfo>& info) {
+                return info.second.hash == hash;
+            })) {
+            LOG_ERROR(Service_LDR, "NRO is already loaded!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_ALREADY_LOADED);
+            return;
+        }
+
+        // NRO Hash is not in any loaded NRR
+        if (!IsValidNROHash(hash)) {
+            LOG_ERROR(Service_LDR,
+                      "NRO hash is not present in any currently loaded NRRs (hash={})!",
+                      Common::HexArrayToString(hash));
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_MISSING_NRR_HASH);
+            return;
+        }
+
+        NROHeader header;
+        std::memcpy(&header, nro_data.data(), sizeof(NROHeader));
+
+        if (!IsValidNRO(header, nro_size, bss_size)) {
+            LOG_ERROR(Service_LDR, "NRO was invalid!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_NRO);
+            return;
+        }
+
+        // Load NRO as new executable module
+        auto* process = Core::CurrentProcess();
+        auto& vm_manager = process->VMManager();
+        auto map_address = vm_manager.FindFreeRegion(nro_size + bss_size);
+
+        if (!map_address.Succeeded() ||
+            *map_address + nro_size + bss_size > vm_manager.GetAddressSpaceEndAddress()) {
+
+            LOG_ERROR(Service_LDR,
+                      "General error while allocation memory or no available memory to allocate!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_MEMORY_STATE);
+            return;
+        }
+
+        ASSERT(process->MirrorMemory(*map_address, nro_addr, nro_size,
+                                     Kernel::MemoryState::ModuleCodeStatic) == RESULT_SUCCESS);
+        ASSERT(process->UnmapMemory(nro_addr, 0, nro_size) == RESULT_SUCCESS);
+
+        if (bss_size > 0) {
+            ASSERT(process->MirrorMemory(*map_address + nro_size, bss_addr, bss_size,
+                                         Kernel::MemoryState::ModuleCodeStatic) == RESULT_SUCCESS);
+            ASSERT(process->UnmapMemory(bss_addr, 0, bss_size) == RESULT_SUCCESS);
+        }
+
+        vm_manager.ReprotectRange(*map_address, header.text_size,
+                                  Kernel::VMAPermission::ReadExecute);
+        vm_manager.ReprotectRange(*map_address + header.ro_offset, header.ro_size,
+                                  Kernel::VMAPermission::Read);
+        vm_manager.ReprotectRange(*map_address + header.rw_offset, header.rw_size,
+                                  Kernel::VMAPermission::ReadWrite);
+
+        Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
+
+        nro.insert_or_assign(*map_address, NROInfo{hash, nro_size + bss_size});
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(addr);
-        LOG_WARNING(Service_LDR, "(STUBBED) called");
+        rb.Push(*map_address);
+    }
+
+    void UnloadNro(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        rp.Skip(2, false);
+        const VAddr mapped_addr{rp.PopRaw<VAddr>()};
+        const VAddr heap_addr{rp.PopRaw<VAddr>()};
+
+        if (!initialized) {
+            LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!");
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_NOT_INITIALIZED);
+            return;
+        }
+
+        if (!Common::Is4KBAligned(mapped_addr) || !Common::Is4KBAligned(heap_addr)) {
+            LOG_ERROR(Service_LDR,
+                      "NRO/BSS Address has invalid alignment (actual nro_addr={:016X}, "
+                      "bss_addr={:016X})!",
+                      mapped_addr, heap_addr);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_ALIGNMENT);
+            return;
+        }
+
+        const auto iter = nro.find(mapped_addr);
+        if (iter == nro.end()) {
+            LOG_ERROR(Service_LDR,
+                      "The NRO attempting to unmap was not mapped or has an invalid address "
+                      "(actual {:016X})!",
+                      mapped_addr);
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_INVALID_NRO_ADDRESS);
+            return;
+        }
+
+        auto* process = Core::CurrentProcess();
+        auto& vm_manager = process->VMManager();
+        const auto& nro_size = iter->second.size;
+
+        ASSERT(process->MirrorMemory(heap_addr, mapped_addr, nro_size,
+                                     Kernel::MemoryState::ModuleCodeStatic) == RESULT_SUCCESS);
+        ASSERT(process->UnmapMemory(mapped_addr, 0, nro_size) == RESULT_SUCCESS);
+
+        Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
+        Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
+
+        nro.erase(iter);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
     }
 
     void Initialize(Kernel::HLERequestContext& ctx) {
+        initialized = true;
+
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_LDR, "(STUBBED) called");
     }
+
+private:
+    using SHA256Hash = std::array<u8, 0x20>;
+
+    struct NROHeader {
+        u32_le entrypoint_insn;
+        u32_le mod_offset;
+        INSERT_PADDING_WORDS(2);
+        u32_le magic;
+        INSERT_PADDING_WORDS(1);
+        u32_le nro_size;
+        INSERT_PADDING_WORDS(1);
+        u32_le text_offset;
+        u32_le text_size;
+        u32_le ro_offset;
+        u32_le ro_size;
+        u32_le rw_offset;
+        u32_le rw_size;
+        u32_le bss_size;
+        INSERT_PADDING_WORDS(1);
+        std::array<u8, 0x20> build_id;
+        INSERT_PADDING_BYTES(0x20);
+    };
+    static_assert(sizeof(NROHeader) == 0x80, "NROHeader has invalid size.");
+
+    struct NRRHeader {
+        u32_le magic;
+        INSERT_PADDING_BYTES(0x1C);
+        u64_le title_id_mask;
+        u64_le title_id_pattern;
+        std::array<u8, 0x100> modulus;
+        std::array<u8, 0x100> signature_1;
+        std::array<u8, 0x100> signature_2;
+        u64_le title_id;
+        u32_le size;
+        INSERT_PADDING_BYTES(4);
+        u32_le hash_offset;
+        u32_le hash_count;
+        INSERT_PADDING_BYTES(8);
+    };
+    static_assert(sizeof(NRRHeader) == 0x350, "NRRHeader has incorrect size.");
+
+    struct NROInfo {
+        SHA256Hash hash;
+        u64 size;
+    };
+
+    bool initialized = false;
+
+    std::map<VAddr, NROInfo> nro;
+    std::map<VAddr, std::vector<SHA256Hash>> nrr;
+
+    bool IsValidNROHash(const SHA256Hash& hash) {
+        return std::any_of(
+            nrr.begin(), nrr.end(), [&hash](const std::pair<VAddr, std::vector<SHA256Hash>>& p) {
+                return std::find(p.second.begin(), p.second.end(), hash) != p.second.end();
+            });
+    }
+
+    static bool IsValidNRO(const NROHeader& header, u64 nro_size, u64 bss_size) {
+        return header.magic == Common::MakeMagic('N', 'R', 'O', '0') &&
+               header.nro_size == nro_size && header.bss_size == bss_size &&
+               header.ro_offset == header.text_offset + header.text_size &&
+               header.rw_offset == header.ro_offset + header.ro_size &&
+               nro_size == header.rw_offset + header.rw_size &&
+               Common::Is4KBAligned(header.text_size) && Common::Is4KBAligned(header.ro_size) &&
+               Common::Is4KBAligned(header.rw_size);
+    }
 };
 
 void InstallInterfaces(SM::ServiceManager& sm) {

src/core/hle/service/ns/pl_u.cpp

@@ -351,6 +351,14 @@ void PL_U::GetSharedFontInOrderOfPriority(Kernel::HLERequestContext& ctx) {
         font_sizes.push_back(region.size);
     }
 
+    // Resize buffers if game requests smaller size output.
+    font_codes.resize(
+        std::min<std::size_t>(font_codes.size(), ctx.GetWriteBufferSize(0) / sizeof(u32)));
+    font_offsets.resize(
+        std::min<std::size_t>(font_offsets.size(), ctx.GetWriteBufferSize(1) / sizeof(u32)));
+    font_sizes.resize(
+        std::min<std::size_t>(font_sizes.size(), ctx.GetWriteBufferSize(2) / sizeof(u32)));
+
     ctx.WriteBuffer(font_codes, 0);
     ctx.WriteBuffer(font_offsets, 1);
     ctx.WriteBuffer(font_sizes, 2);

src/core/hle/service/spl/module.cpp

@@ -28,9 +28,8 @@ void Module::Interface::GetRandomBytes(Kernel::HLERequestContext& ctx) {
 
     std::size_t size = ctx.GetWriteBufferSize();
 
-    std::uniform_int_distribution<u16> distribution(0, std::numeric_limits<u8>::max());
     std::vector<u8> data(size);
-    std::generate(data.begin(), data.end(), [&] { return static_cast<u8>(distribution(rng)); });
+    std::generate(data.begin(), data.end(), rng);
 
     ctx.WriteBuffer(data);
 

src/core/loader/nro.cpp

@@ -170,17 +170,20 @@ static constexpr u32 PageAlignSize(u32 size) {
                     arg_data.size());
     }
 
-    // Read MOD header
-    ModHeader mod_header{};
     // Default .bss to NRO header bss size if MOD0 section doesn't exist
     u32 bss_size{PageAlignSize(nro_header.bss_size)};
+
+    // Read MOD header
+    ModHeader mod_header{};
     std::memcpy(&mod_header, program_image.data() + nro_header.module_header_offset,
                 sizeof(ModHeader));
+
     const bool has_mod_header{mod_header.magic == Common::MakeMagic('M', 'O', 'D', '0')};
     if (has_mod_header) {
         // Resize program image to include .bss section and page align each section
         bss_size = PageAlignSize(mod_header.bss_end_offset - mod_header.bss_start_offset);
     }
+
     codeset.DataSegment().size += bss_size;
     program_image.resize(static_cast<u32>(program_image.size()) + bss_size);
 

src/core/loader/nso.cpp

@@ -154,7 +154,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(const FileSys::VfsFile& file, VAd
     program_image.resize(image_size);
 
     // Apply patches if necessary
-    if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::values.dump_nso)) {
+    if (pm && pm->HasNSOPatch(nso_header.build_id)) {
         std::vector<u8> pi_header(program_image.size() + 0x100);
         std::memcpy(pi_header.data(), &nso_header, sizeof(NsoHeader));
         std::memcpy(pi_header.data() + 0x100, program_image.data(), program_image.size());

src/core/settings.h

@@ -159,7 +159,6 @@ struct Values {
     bool use_gdbstub;
     u16 gdbstub_port;
     std::string program_args;
-    bool dump_nso;
 
     // WebService
     bool enable_telemetry;

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -550,8 +550,8 @@ void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params
     if (params.is_layered) {
         u64 offset = params.GetMipmapLevelOffset(mip_level);
         u64 offset_gl = 0;
-        const u64 layer_size = params.LayerMemorySize();
-        const u64 gl_size = params.LayerSizeGL(mip_level);
+        u64 layer_size = params.LayerMemorySize();
+        u64 gl_size = params.LayerSizeGL(mip_level);
         for (u32 i = 0; i < params.depth; i++) {
             functions[static_cast<std::size_t>(params.pixel_format)](
                 params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
@@ -561,7 +561,7 @@ void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params
             offset_gl += gl_size;
         }
     } else {
-        const u64 offset = params.GetMipmapLevelOffset(mip_level);
+        u64 offset = params.GetMipmapLevelOffset(mip_level);
         functions[static_cast<std::size_t>(params.pixel_format)](
             params.MipWidth(mip_level), params.MipBlockHeight(mip_level),
             params.MipHeight(mip_level), params.MipBlockDepth(mip_level), depth, gl_buffer.data(),

src/video_core/renderer_opengl/gl_state.cpp

@@ -266,8 +266,7 @@ void OpenGLState::ApplyViewport() const {
         const auto& updated = viewports[0];
         if (updated.x != current.x || updated.y != current.y || updated.width != current.width ||
             updated.height != current.height) {
-            glViewport(static_cast<GLint>(updated.x), static_cast<GLint>(updated.y),
-                       static_cast<GLsizei>(updated.width), static_cast<GLsizei>(updated.height));
+            glViewport(updated.x, updated.y, updated.width, updated.height);
         }
         if (updated.depth_range_near != current.depth_range_near ||
             updated.depth_range_far != current.depth_range_far) {
@@ -314,7 +313,7 @@ void OpenGLState::ApplyGlobalBlending() const {
     }
 }
 
-void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
+void OpenGLState::ApplyTargetBlending(int target, bool force) const {
     const Blend& updated = blend[target];
     const Blend& current = cur_state.blend[target];
     const bool blend_changed = updated.enabled != current.enabled || force;

src/video_core/renderer_opengl/gl_state.h

@@ -208,7 +208,7 @@ private:
     void ApplyPrimitiveRestart() const;
     void ApplyStencilTest() const;
     void ApplyViewport() const;
-    void ApplyTargetBlending(std::size_t target, bool force) const;
+    void ApplyTargetBlending(int target, bool force) const;
     void ApplyGlobalBlending() const;
     void ApplyBlending() const;
     void ApplyLogicOp() const;

src/video_core/textures/decoders.cpp

@@ -45,7 +45,7 @@ constexpr auto fast_swizzle_table = SwizzleTable<8, 4, 16>();
  * Instead of going gob by gob, we map the coordinates inside a block and manage from
  * those. Block_Width is assumed to be 1.
  */
-void PreciseProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
+void PreciseProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
                          const u32 x_start, const u32 y_start, const u32 z_start, const u32 x_end,
                          const u32 y_end, const u32 z_end, const u32 tile_offset,
                          const u32 xy_block_size, const u32 layer_z, const u32 stride_x,
@@ -81,7 +81,7 @@ void PreciseProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, con
  * Instead of going gob by gob, we map the coordinates inside a block and manage from
  * those. Block_Width is assumed to be 1.
  */
-void FastProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
+void FastProcessBlock(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
                       const u32 x_start, const u32 y_start, const u32 z_start, const u32 x_end,
                       const u32 y_end, const u32 z_end, const u32 tile_offset,
                       const u32 xy_block_size, const u32 layer_z, const u32 stride_x,
@@ -90,10 +90,10 @@ void FastProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const
     u32 z_address = tile_offset;
     const u32 x_startb = x_start * bytes_per_pixel;
     const u32 x_endb = x_end * bytes_per_pixel;
-    constexpr u32 copy_size = 16;
-    constexpr u32 gob_size_x = 64;
-    constexpr u32 gob_size_y = 8;
-    constexpr u32 gob_size_z = 1;
+    const u32 copy_size = 16;
+    const u32 gob_size_x = 64;
+    const u32 gob_size_y = 8;
+    const u32 gob_size_z = 1;
     const u32 gob_size = gob_size_x * gob_size_y * gob_size_z;
     for (u32 z = z_start; z < z_end; z++) {
         u32 y_address = z_address;
@@ -126,23 +126,23 @@ void FastProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const
  *  https://envytools.readthedocs.io/en/latest/hw/memory/g80-surface.html#blocklinear-surfaces
  */
 template <bool fast>
-void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool unswizzle,
-                  const u32 width, const u32 height, const u32 depth, const u32 bytes_per_pixel,
+void SwizzledData(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle, const u32 width,
+                  const u32 height, const u32 depth, const u32 bytes_per_pixel,
                   const u32 out_bytes_per_pixel, const u32 block_height, const u32 block_depth) {
     auto div_ceil = [](const u32 x, const u32 y) { return ((x + y - 1) / y); };
     const u32 stride_x = width * out_bytes_per_pixel;
     const u32 layer_z = height * stride_x;
-    constexpr u32 gob_x_bytes = 64;
+    const u32 gob_x_bytes = 64;
     const u32 gob_elements_x = gob_x_bytes / bytes_per_pixel;
-    constexpr u32 gob_elements_y = 8;
-    constexpr u32 gob_elements_z = 1;
+    const u32 gob_elements_y = 8;
+    const u32 gob_elements_z = 1;
     const u32 block_x_elements = gob_elements_x;
     const u32 block_y_elements = gob_elements_y * block_height;
     const u32 block_z_elements = gob_elements_z * block_depth;
     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);
-    constexpr u32 gob_size = gob_x_bytes * gob_elements_y * gob_elements_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;
     u32 tile_offset = 0;
@@ -171,7 +171,7 @@ void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool
 }
 
 void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
-                      u32 out_bytes_per_pixel, u8* const swizzled_data, u8* const unswizzled_data,
+                      u32 out_bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data,
                       bool unswizzle, u32 block_height, u32 block_depth) {
     if (bytes_per_pixel % 3 != 0 && (width * bytes_per_pixel) % 16 == 0) {
         SwizzledData<true>(swizzled_data, unswizzled_data, unswizzle, width, height, depth,
@@ -325,9 +325,9 @@ 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) {
-        constexpr u32 gobs_in_x = 64;
-        constexpr u32 gobs_in_y = 8;
-        constexpr u32 gobs_in_z = 1;
+        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 * 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);

src/yuzu/configuration/config.cpp

@@ -153,7 +153,6 @@ void Config::ReadValues() {
     Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
     Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
     Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
-    Settings::values.dump_nso = qt_config->value("dump_nso", false).toBool();
     qt_config->endGroup();
 
     qt_config->beginGroup("WebService");
@@ -171,7 +170,6 @@ void Config::ReadValues() {
 
     qt_config->beginGroup("UIGameList");
     UISettings::values.show_unknown = qt_config->value("show_unknown", true).toBool();
-    UISettings::values.show_add_ons = qt_config->value("show_add_ons", true).toBool();
     UISettings::values.icon_size = qt_config->value("icon_size", 64).toUInt();
     UISettings::values.row_1_text_id = qt_config->value("row_1_text_id", 3).toUInt();
     UISettings::values.row_2_text_id = qt_config->value("row_2_text_id", 2).toUInt();
@@ -297,7 +295,6 @@ void Config::SaveValues() {
     qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
     qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
     qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
-    qt_config->setValue("dump_nso", Settings::values.dump_nso);
     qt_config->endGroup();
 
     qt_config->beginGroup("WebService");
@@ -313,7 +310,6 @@ void Config::SaveValues() {
 
     qt_config->beginGroup("UIGameList");
     qt_config->setValue("show_unknown", UISettings::values.show_unknown);
-    qt_config->setValue("show_add_ons", UISettings::values.show_add_ons);
     qt_config->setValue("icon_size", UISettings::values.icon_size);
     qt_config->setValue("row_1_text_id", UISettings::values.row_1_text_id);
     qt_config->setValue("row_2_text_id", UISettings::values.row_2_text_id);

src/yuzu/configuration/configure_debug.cpp

@@ -34,7 +34,6 @@ void ConfigureDebug::setConfiguration() {
     ui->toggle_console->setChecked(UISettings::values.show_console);
     ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
     ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
-    ui->dump_decompressed_nso->setChecked(Settings::values.dump_nso);
 }
 
 void ConfigureDebug::applyConfiguration() {
@@ -43,7 +42,6 @@ void ConfigureDebug::applyConfiguration() {
     UISettings::values.show_console = ui->toggle_console->isChecked();
     Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
     Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
-    Settings::values.dump_nso = ui->dump_decompressed_nso->isChecked();
     Debugger::ToggleConsole();
     Log::Filter filter;
     filter.ParseFilterString(Settings::values.log_filter);

src/yuzu/configuration/configure_debug.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>400</width>
-    <height>357</height>
+    <height>300</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -129,25 +129,6 @@
      </layout>
     </widget>
    </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox_4">
-     <property name="title">
-      <string>Dump</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_4">
-      <item>
-       <widget class="QCheckBox" name="dump_decompressed_nso">
-        <property name="whatsThis">
-         <string>When checked, any NSO yuzu tries to load or patch will be copied decompressed to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump Decompressed NSOs</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">

src/yuzu/configuration/configure_gamelist.cpp

@@ -42,7 +42,6 @@ ConfigureGameList::~ConfigureGameList() = default;
 
 void ConfigureGameList::applyConfiguration() {
     UISettings::values.show_unknown = ui->show_unknown->isChecked();
-    UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
     UISettings::values.icon_size = ui->icon_size_combobox->currentData().toUInt();
     UISettings::values.row_1_text_id = ui->row_1_text_combobox->currentData().toUInt();
     UISettings::values.row_2_text_id = ui->row_2_text_combobox->currentData().toUInt();
@@ -51,7 +50,6 @@ void ConfigureGameList::applyConfiguration() {
 
 void ConfigureGameList::setConfiguration() {
     ui->show_unknown->setChecked(UISettings::values.show_unknown);
-    ui->show_add_ons->setChecked(UISettings::values.show_add_ons);
     ui->icon_size_combobox->setCurrentIndex(
         ui->icon_size_combobox->findData(UISettings::values.icon_size));
     ui->row_1_text_combobox->setCurrentIndex(

src/yuzu/configuration/configure_gamelist.ui

@@ -1,133 +1,126 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>ConfigureGameList</class>
- <widget class="QWidget" name="ConfigureGameList">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>300</width>
-    <height>377</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QHBoxLayout" name="HorizontalLayout">
-   <item>
-    <layout class="QVBoxLayout" name="VerticalLayout">
-     <item>
-      <widget class="QGroupBox" name="GeneralGroupBox">
-       <property name="title">
-        <string>General</string>
-       </property>
-       <layout class="QHBoxLayout" name="GeneralHorizontalLayout">
-        <item>
-         <layout class="QVBoxLayout" name="GeneralVerticalLayout">
+  <widget class="QWidget" name="ConfigureGeneral">
+    <property name="geometry">
+      <rect>
+        <x>0</x>
+        <y>0</y>
+        <width>300</width>
+        <height>377</height>
+      </rect>
+    </property>
+    <property name="windowTitle">
+      <string>Form</string>
+    </property>
+    <layout class="QHBoxLayout" name="HorizontalLayout">
+      <item>
+        <layout class="QVBoxLayout" name="VerticalLayout">
           <item>
-           <widget class="QCheckBox" name="show_unknown">
-            <property name="text">
-             <string>Show files with type 'Unknown'</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QCheckBox" name="show_add_ons">
-            <property name="text">
-             <string>Show Add-Ons Column</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="IconSizeGroupBox">
-       <property name="title">
-        <string>Icon Size</string>
-       </property>
-       <layout class="QHBoxLayout" name="icon_size_qhbox_layout">
-        <item>
-         <layout class="QVBoxLayout" name="icon_size_qvbox_layout">
-          <item>
-           <layout class="QHBoxLayout" name="icon_size_qhbox_layout_2">
-            <item>
-             <widget class="QLabel" name="icon_size_label">
-              <property name="text">
-               <string>Icon Size:</string>
+            <widget class="QGroupBox" name="GeneralGroupBox">
+              <property name="title">
+                <string>General</string>
               </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QComboBox" name="icon_size_combobox"/>
-            </item>
-           </layout>
-          </item>
-         </layout>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="RowGroupBox">
-       <property name="title">
-        <string>Row Text</string>
-       </property>
-       <layout class="QHBoxLayout" name="RowHorizontalLayout">
-        <item>
-         <layout class="QVBoxLayout" name="RowVerticalLayout">
-          <item>
-           <layout class="QHBoxLayout" name="row_1_qhbox_layout">
-            <item>
-             <widget class="QLabel" name="row_1_label">
-              <property name="text">
-               <string>Row 1 Text:</string>
-              </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QComboBox" name="row_1_text_combobox"/>
-            </item>
-           </layout>
+              <layout class="QHBoxLayout" name="GeneralHorizontalLayout">
+                <item>
+                  <layout class="QVBoxLayout" name="GeneralVerticalLayout">
+                    <item>
+                      <widget class="QCheckBox" name="show_unknown">
+                        <property name="text">
+                          <string>Show files with type 'Unknown'</string>
+                        </property>
+                      </widget>
+                    </item>
+                  </layout>
+                </item>
+              </layout>
+            </widget>
           </item>
           <item>
-           <layout class="QHBoxLayout" name="row_2_qhbox_layout">
-            <item>
-             <widget class="QLabel" name="row_2_label">
-              <property name="text">
-               <string>Row 2 Text:</string>
+            <widget class="QGroupBox" name="IconSizeGroupBox">
+              <property name="title">
+                <string>Icon Size</string>
               </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QComboBox" name="row_2_text_combobox"/>
-            </item>
-           </layout>
+              <layout class="QHBoxLayout" name="icon_size_qhbox_layout">
+                <item>
+                  <layout class="QVBoxLayout" name="icon_size_qvbox_layout">
+                    <item>
+                      <layout class="QHBoxLayout" name="icon_size_qhbox_layout_2">
+                        <item>
+                          <widget class="QLabel" name="icon_size_label">
+                            <property name="text">
+                              <string>Icon Size:</string>
+                            </property>
+                          </widget>
+                        </item>
+                        <item>
+                          <widget class="QComboBox" name="icon_size_combobox"/>
+                        </item>
+                      </layout>
+                    </item>
+                  </layout>
+                </item>
+              </layout>
+            </widget>
           </item>
-         </layout>
-        </item>
-       </layout>
-      </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>
+          <item>
+            <widget class="QGroupBox" name="RowGroupBox">
+              <property name="title">
+                <string>Row Text</string>
+              </property>
+              <layout class="QHBoxLayout" name="RowHorizontalLayout">
+                <item>
+                  <layout class="QVBoxLayout" name="RowVerticalLayout">
+                    <item>
+                      <layout class="QHBoxLayout" name="row_1_qhbox_layout">
+                        <item>
+                          <widget class="QLabel" name="row_1_label">
+                            <property name="text">
+                              <string>Row 1 Text:</string>
+                            </property>
+                          </widget>
+                        </item>
+                        <item>
+                          <widget class="QComboBox" name="row_1_text_combobox"/>
+                        </item>
+                      </layout>
+                    </item>
+                    <item>
+                      <layout class="QHBoxLayout" name="row_2_qhbox_layout">
+                        <item>
+                          <widget class="QLabel" name="row_2_label">
+                            <property name="text">
+                              <string>Row 2 Text:</string>
+                            </property>
+                          </widget>
+                        </item>
+                        <item>
+                          <widget class="QComboBox" name="row_2_text_combobox"/>
+                        </item>
+                      </layout>
+                    </item>
+                  </layout>
+                </item>
+              </layout>
+            </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>
-   </item>
-  </layout>
- </widget>
+  </widget>
  <resources/>
  <connections/>
 </ui>

src/yuzu/configuration/configure_general.cpp

@@ -47,9 +47,6 @@ void ConfigureGeneral::OnDockedModeChanged(bool last_state, bool new_state) {
     }
 
     Core::System& system{Core::System::GetInstance()};
-    if (!system.IsPoweredOn()) {
-        return;
-    }
     Service::SM::ServiceManager& sm = system.ServiceManager();
 
     // Message queue is shared between these services, we just need to signal an operation

src/yuzu/game_list.cpp

@@ -215,18 +215,12 @@ GameList::GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent)
     tree_view->setUniformRowHeights(true);
     tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
 
-    item_model->insertColumns(0, UISettings::values.show_add_ons ? COLUMN_COUNT : COLUMN_COUNT - 1);
+    item_model->insertColumns(0, COLUMN_COUNT);
     item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
     item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
-
-    if (UISettings::values.show_add_ons) {
-        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"));
-    } else {
-        item_model->setHeaderData(COLUMN_FILE_TYPE - 1, Qt::Horizontal, tr("File type"));
-        item_model->setHeaderData(COLUMN_SIZE - 1, Qt::Horizontal, tr("Size"));
-    }
+    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);
@@ -400,25 +394,6 @@ void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
     }
 
     tree_view->setEnabled(false);
-
-    // Update the columns in case UISettings has changed
-    item_model->removeColumns(0, item_model->columnCount());
-    item_model->insertColumns(0, UISettings::values.show_add_ons ? COLUMN_COUNT : COLUMN_COUNT - 1);
-    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
-    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
-
-    if (UISettings::values.show_add_ons) {
-        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"));
-    } else {
-        item_model->setHeaderData(COLUMN_FILE_TYPE - 1, Qt::Horizontal, tr("File type"));
-        item_model->setHeaderData(COLUMN_SIZE - 1, Qt::Horizontal, tr("Size"));
-        item_model->removeColumns(COLUMN_COUNT - 1, 1);
-    }
-
-    LoadInterfaceLayout();
-
     // Delete any rows that might already exist if we're repopulating
     item_model->removeRows(0, item_model->rowCount());
 

src/yuzu/game_list_worker.cpp

@@ -123,22 +123,17 @@ void GameListWorker::AddInstalledTitlesToGameList() {
         if (it != compatibility_list.end())
             compatibility = it->second.first;
 
-        QList<QStandardItem*> list{
+        emit EntryReady({
             new GameListItemPath(
                 FormatGameName(file->GetFullPath()), icon, QString::fromStdString(name),
                 QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                 program_id),
             new GameListItemCompat(compatibility),
+            new GameListItem(FormatPatchNameVersions(patch, *loader)),
             new GameListItem(
                 QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
             new GameListItemSize(file->GetSize()),
-        };
-
-        if (UISettings::values.show_add_ons) {
-            list.insert(2, new GameListItem(FormatPatchNameVersions(patch, *loader)));
-        }
-
-        emit EntryReady(list);
+        });
     }
 
     const auto control_data = cache->ListEntriesFilter(FileSys::TitleType::Application,
@@ -221,23 +216,18 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
             if (it != compatibility_list.end())
                 compatibility = it->second.first;
 
-            QList<QStandardItem*> list{
+            emit EntryReady({
                 new GameListItemPath(
                     FormatGameName(physical_name), icon, QString::fromStdString(name),
                     QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                     program_id),
                 new GameListItemCompat(compatibility),
+                new GameListItem(
+                    FormatPatchNameVersions(patch, *loader, loader->IsRomFSUpdatable())),
                 new GameListItem(
                     QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
                 new GameListItemSize(FileUtil::GetSize(physical_name)),
-            };
-
-            if (UISettings::values.show_add_ons) {
-                list.insert(2, new GameListItem(FormatPatchNameVersions(
-                                   patch, *loader, loader->IsRomFSUpdatable())));
-            }
-
-            emit EntryReady(std::move(list));
+            });
         } else if (is_dir && recursion > 0) {
             watch_list.append(QString::fromStdString(physical_name));
             AddFstEntriesToGameList(physical_name, recursion - 1);

src/yuzu/ui_settings.h

@@ -59,7 +59,6 @@ struct Values {
 
     // Game List
     bool show_unknown;
-    bool show_add_ons;
     uint32_t icon_size;
     uint8_t row_1_text_id;
     uint8_t row_2_text_id;

src/yuzu_cmd/config.cpp

@@ -148,7 +148,6 @@ void Config::ReadValues() {
     Settings::values.gdbstub_port =
         static_cast<u16>(sdl2_config->GetInteger("Debugging", "gdbstub_port", 24689));
     Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
-    Settings::values.dump_nso = sdl2_config->GetBoolean("Debugging", "dump_nso", false);
 
     // Web Service
     Settings::values.enable_telemetry =

src/yuzu_cmd/default_ini.h

@@ -206,8 +206,6 @@ log_filter = *:Trace
 # Port for listening to GDB connections.
 use_gdbstub=false
 gdbstub_port=24689
-# Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
-dump_nso=false
 
 [WebService]
 # Whether or not to enable telemetry