gl_rasterizer: Remove default clip distance

svc: ResetSignal is not stubbed

.travis/linux-mingw/docker.sh

@@ -57,3 +57,4 @@ done
 
 pip3 install pefile
 python3 .travis/linux-mingw/scan_dll.py package/*.exe "package/"
+python3 .travis/linux-mingw/scan_dll.py package/imageformats/*.dll "package/"

appveyor.yml

@@ -125,17 +125,6 @@ after_build:
           Copy-Item -path "$CMAKE_SOURCE_DIR/license.txt" -destination $RELEASE_DIST
           Copy-Item -path "$CMAKE_SOURCE_DIR/README.md" -destination $RELEASE_DIST
 
-          # copy all the dll dependencies to the release folder
-          . "./.appveyor/UtilityFunctions.ps1"
-          $DLLSearchPath = "C:\msys64\mingw64\bin;$env:PATH"
-          $MingwDLLs = RecursivelyGetDeps $DLLSearchPath "$RELEASE_DIST\yuzu.exe"
-          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\yuzu_cmd.exe"
-          Write-Host "Detected the following dependencies:"
-          Write-Host $MingwDLLs
-          foreach ($file in $MingwDLLs) {
-            Copy-Item -path "$file" -force -destination "$RELEASE_DIST"
-          }
-
           # copy the qt windows plugin dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"
 
@@ -145,6 +134,18 @@ after_build:
           # copy the qt jpeg imageformat dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/imageformats/qjpeg.dll" -force -destination "$RELEASE_DIST/imageformats"
 
+          # copy all the dll dependencies to the release folder
+          . "./.appveyor/UtilityFunctions.ps1"
+          $DLLSearchPath = "C:\msys64\mingw64\bin;$env:PATH"
+          $MingwDLLs = RecursivelyGetDeps $DLLSearchPath "$RELEASE_DIST\yuzu.exe"
+          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\yuzu_cmd.exe"
+          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\imageformats\qjpeg.dll"
+          Write-Host "Detected the following dependencies:"
+          Write-Host $MingwDLLs
+          foreach ($file in $MingwDLLs) {
+            Copy-Item -path "$file" -force -destination "$RELEASE_DIST"
+          }
+
           7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
           7z a $MINGW_SEVENZIP $RELEASE_DIST
         }

src/audio_core/audio_renderer.h

@@ -143,7 +143,7 @@ struct AuxInfo {
     std::array<u8, 24> output_mix_buffers;
     u32_le mix_buffer_count;
     u32_le sample_rate; // Stored in the aux buffer currently
-    u32_le sampe_count;
+    u32_le sample_count;
     u64_le send_buffer_info;
     u64_le send_buffer_base;
 

src/audio_core/cubeb_sink.cpp

@@ -121,7 +121,8 @@ CubebSink::CubebSink(std::string target_device_name) {
             const auto collection_end{collection.device + collection.count};
             const auto device{
                 std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return target_device_name == info.friendly_name;
+                    return info.friendly_name != nullptr &&
+                           target_device_name == info.friendly_name;
                 })};
             if (device != collection_end) {
                 output_device = device->devid;

src/audio_core/stream.cpp

@@ -11,7 +11,6 @@
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "common/microprofile.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/settings.h"
@@ -104,10 +103,7 @@ void Stream::PlayNextBuffer() {
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
-MICROPROFILE_DEFINE(AudioOutput, "Audio", "ReleaseActiveBuffer", MP_RGB(100, 100, 255));
-
 void Stream::ReleaseActiveBuffer() {
-    MICROPROFILE_SCOPE(AudioOutput);
     ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();

src/audio_core/time_stretch.cpp

@@ -32,10 +32,10 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
     // We were given actual_samples number of samples, and num_samples were requested from us.
     double current_ratio = static_cast<double>(num_in) / static_cast<double>(num_out);
 
-    const double max_latency = 1.0; // seconds
+    const double max_latency = 0.25; // seconds
     const double max_backlog = m_sample_rate * max_latency;
     const double backlog_fullness = m_sound_touch.numSamples() / max_backlog;
-    if (backlog_fullness > 5.0) {
+    if (backlog_fullness > 4.0) {
         // Too many samples in backlog: Don't push anymore on
         num_in = 0;
     }
@@ -49,7 +49,7 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
 
     // This low-pass filter smoothes out variance in the calculated stretch ratio.
     // The time-scale determines how responsive this filter is.
-    constexpr double lpf_time_scale = 2.0; // seconds
+    constexpr double lpf_time_scale = 0.712; // seconds
     const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
     m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);
 

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;
 
-    // StorageType is T for non-enum types and the underlying type of T if
+    // UnderlyingType 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 StorageType = typename std::conditional_t<std::is_enum<T>::value, std::underlying_type<T>,
-                                                    std::enable_if<true, T>>::type;
+    using UnderlyingType = typename std::conditional_t<std::is_enum_v<T>, std::underlying_type<T>,
+                                                       std::enable_if<true, T>>::type;
 
-    // Unsigned version of StorageType
-    using StorageTypeU = std::make_unsigned_t<StorageType>;
+    // We store the value as the unsigned type to avoid undefined behaviour on value shifting
+    using StorageType = std::make_unsigned_t<UnderlyingType>;
 
 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 = (((StorageTypeU)~0) >> (8 * sizeof(T) - bits)) << position;
+    static constexpr StorageType mask = (((StorageType)~0) >> (8 * sizeof(T) - bits)) << position;
 
     /**
      * Formats a value by masking and shifting it according to the field parameters. A value
@@ -148,11 +148,12 @@ public:
      * union in a constexpr context.
      */
     static constexpr FORCE_INLINE T ExtractValue(const StorageType& storage) {
-        if (std::numeric_limits<T>::is_signed) {
+        if constexpr (std::numeric_limits<UnderlyingType>::is_signed) {
             std::size_t shift = 8 * sizeof(T) - bits;
-            return (T)((storage << (shift - position)) >> shift);
+            return static_cast<T>(static_cast<UnderlyingType>(storage << (shift - position)) >>
+                                  shift);
         } else {
-            return (T)((storage & mask) >> position);
+            return static_cast<T>((storage & mask) >> position);
         }
     }
 

src/common/logging/backend.cpp

@@ -12,7 +12,8 @@
 #include <thread>
 #include <vector>
 #ifdef _WIN32
-#include <share.h> // For _SH_DENYWR
+#include <share.h>   // For _SH_DENYWR
+#include <windows.h> // For OutputDebugStringA
 #else
 #define _SH_DENYWR 0
 #endif
@@ -139,12 +140,18 @@ void FileBackend::Write(const Entry& entry) {
     if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }
-    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
+    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
     if (entry.log_level >= Level::Error) {
         file.Flush();
     }
 }
 
+void DebuggerBackend::Write(const Entry& entry) {
+#ifdef _WIN32
+    ::OutputDebugStringA(FormatLogMessage(entry).append(1, '\n').c_str());
+#endif
+}
+
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \

src/common/logging/backend.h

@@ -103,6 +103,20 @@ private:
     std::size_t bytes_written;
 };
 
+/**
+ * Backend that writes to Visual Studio's output window
+ */
+class DebuggerBackend : public Backend {
+public:
+    static const char* Name() {
+        return "debugger";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
 void AddBackend(std::unique_ptr<Backend> backend);
 
 void RemoveBackend(std::string_view backend_name);

src/common/string_util.cpp

@@ -4,11 +4,10 @@
 
 #include <algorithm>
 #include <cctype>
-#include <cerrno>
 #include <codecvt>
-#include <cstdio>
 #include <cstdlib>
-#include <cstring>
+#include <locale>
+#include <sstream>
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -33,24 +32,6 @@ std::string ToUpper(std::string str) {
     return str;
 }
 
-// For Debugging. Read out an u8 array.
-std::string ArrayToString(const u8* data, std::size_t size, int line_len, bool spaces) {
-    std::ostringstream oss;
-    oss << std::setfill('0') << std::hex;
-
-    for (int line = 0; size; ++data, --size) {
-        oss << std::setw(2) << (int)*data;
-
-        if (line_len == ++line) {
-            oss << '\n';
-            line = 0;
-        } else if (spaces)
-            oss << ' ';
-    }
-
-    return oss.str();
-}
-
 std::string StringFromBuffer(const std::vector<u8>& data) {
     return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
@@ -75,40 +56,6 @@ std::string StripQuotes(const std::string& s) {
         return s;
 }
 
-bool TryParse(const std::string& str, u32* const output) {
-    char* endptr = nullptr;
-
-    // Reset errno to a value other than ERANGE
-    errno = 0;
-
-    unsigned long value = strtoul(str.c_str(), &endptr, 0);
-
-    if (!endptr || *endptr)
-        return false;
-
-    if (errno == ERANGE)
-        return false;
-
-#if ULONG_MAX > UINT_MAX
-    if (value >= 0x100000000ull && value <= 0xFFFFFFFF00000000ull)
-        return false;
-#endif
-
-    *output = static_cast<u32>(value);
-    return true;
-}
-
-bool TryParse(const std::string& str, bool* const output) {
-    if ("1" == str || "true" == ToLower(str))
-        *output = true;
-    else if ("0" == str || "false" == ToLower(str))
-        *output = false;
-    else
-        return false;
-
-    return true;
-}
-
 std::string StringFromBool(bool value) {
     return value ? "True" : "False";
 }

src/common/string_util.h

@@ -5,8 +5,6 @@
 #pragma once
 
 #include <cstddef>
-#include <iomanip>
-#include <sstream>
 #include <string>
 #include <vector>
 #include "common/common_types.h"
@@ -19,44 +17,13 @@ std::string ToLower(std::string str);
 /// Make a string uppercase
 std::string ToUpper(std::string str);
 
-std::string ArrayToString(const u8* data, std::size_t size, int line_len = 20, bool spaces = true);
-
 std::string StringFromBuffer(const std::vector<u8>& data);
 
 std::string StripSpaces(const std::string& s);
 std::string StripQuotes(const std::string& s);
 
-// Thousand separator. Turns 12345678 into 12,345,678
-template <typename I>
-std::string ThousandSeparate(I value, int spaces = 0) {
-    std::ostringstream oss;
-
-// std::locale("") seems to be broken on many platforms
-#if defined _WIN32 || (defined __linux__ && !defined __clang__)
-    oss.imbue(std::locale(""));
-#endif
-    oss << std::setw(spaces) << value;
-
-    return oss.str();
-}
-
 std::string StringFromBool(bool value);
 
-bool TryParse(const std::string& str, bool* output);
-bool TryParse(const std::string& str, u32* output);
-
-template <typename N>
-static bool TryParse(const std::string& str, N* const output) {
-    std::istringstream iss(str);
-
-    N tmp = 0;
-    if (iss >> tmp) {
-        *output = tmp;
-        return true;
-    } else
-        return false;
-}
-
 std::string TabsToSpaces(int tab_size, std::string in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);

src/common/telemetry.h

@@ -153,6 +153,7 @@ struct VisitorInterface : NonCopyable {
 
     /// Completion method, called once all fields have been visited
     virtual void Complete() = 0;
+    virtual bool SubmitTestcase() = 0;
 };
 
 /**
@@ -178,6 +179,9 @@ struct NullVisitor : public VisitorInterface {
     void Visit(const Field<std::chrono::microseconds>& /*field*/) override {}
 
     void Complete() override {}
+    bool SubmitTestcase() override {
+        return false;
+    }
 };
 
 /// Appends build-specific information to the given FieldCollection,

src/core/core.cpp

@@ -185,7 +185,7 @@ struct System::Impl {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
             return ResultStatus::ErrorGetLoader;
         }
-        std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
+        std::pair<std::optional<u32>, Loader::ResultStatus> system_mode =
             app_loader->LoadKernelSystemMode();
 
         if (system_mode.second != Loader::ResultStatus::Success) {
@@ -312,6 +312,10 @@ Cpu& System::CurrentCpuCore() {
     return impl->CurrentCpuCore();
 }
 
+const Cpu& System::CurrentCpuCore() const {
+    return impl->CurrentCpuCore();
+}
+
 System::ResultStatus System::RunLoop(bool tight_loop) {
     return impl->RunLoop(tight_loop);
 }
@@ -342,7 +346,11 @@ PerfStatsResults System::GetAndResetPerfStats() {
     return impl->GetAndResetPerfStats();
 }
 
-Core::TelemetrySession& System::TelemetrySession() const {
+TelemetrySession& System::TelemetrySession() {
+    return *impl->telemetry_session;
+}
+
+const TelemetrySession& System::TelemetrySession() const {
     return *impl->telemetry_session;
 }
 
@@ -350,7 +358,11 @@ ARM_Interface& System::CurrentArmInterface() {
     return CurrentCpuCore().ArmInterface();
 }
 
-std::size_t System::CurrentCoreIndex() {
+const ARM_Interface& System::CurrentArmInterface() const {
+    return CurrentCpuCore().ArmInterface();
+}
+
+std::size_t System::CurrentCoreIndex() const {
     return CurrentCpuCore().CoreIndex();
 }
 
@@ -358,6 +370,10 @@ Kernel::Scheduler& System::CurrentScheduler() {
     return CurrentCpuCore().Scheduler();
 }
 
+const Kernel::Scheduler& System::CurrentScheduler() const {
+    return CurrentCpuCore().Scheduler();
+}
+
 Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
     return CpuCore(core_index).Scheduler();
 }
@@ -378,6 +394,10 @@ ARM_Interface& System::ArmInterface(std::size_t core_index) {
     return CpuCore(core_index).ArmInterface();
 }
 
+const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
+    return CpuCore(core_index).ArmInterface();
+}
+
 Cpu& System::CpuCore(std::size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
     return *impl->cpu_cores[core_index];
@@ -392,6 +412,10 @@ ExclusiveMonitor& System::Monitor() {
     return *impl->cpu_exclusive_monitor;
 }
 
+const ExclusiveMonitor& System::Monitor() const {
+    return *impl->cpu_exclusive_monitor;
+}
+
 Tegra::GPU& System::GPU() {
     return *impl->gpu_core;
 }

src/core/core.h

@@ -129,11 +129,11 @@ public:
      */
     bool IsPoweredOn() const;
 
-    /**
-     * Returns a reference to the telemetry session for this emulation session.
-     * @returns Reference to the telemetry session.
-     */
-    Core::TelemetrySession& TelemetrySession() const;
+    /// Gets a reference to the telemetry session for this emulation session.
+    Core::TelemetrySession& TelemetrySession();
+
+    /// Gets a reference to the telemetry session for this emulation session.
+    const Core::TelemetrySession& TelemetrySession() const;
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
@@ -144,24 +144,36 @@ public:
     /// Gets an ARM interface to the CPU core that is currently running
     ARM_Interface& CurrentArmInterface();
 
+    /// Gets an ARM interface to the CPU core that is currently running
+    const ARM_Interface& CurrentArmInterface() const;
+
     /// Gets the index of the currently running CPU core
-    std::size_t CurrentCoreIndex();
+    std::size_t CurrentCoreIndex() const;
 
     /// Gets the scheduler for the CPU core that is currently running
     Kernel::Scheduler& CurrentScheduler();
 
-    /// Gets an ARM interface to the CPU core with the specified index
+    /// Gets the scheduler for the CPU core that is currently running
+    const Kernel::Scheduler& CurrentScheduler() const;
+
+    /// Gets a reference to an ARM interface for the CPU core with the specified index
     ARM_Interface& ArmInterface(std::size_t core_index);
 
+    /// Gets a const reference to an ARM interface from the CPU core with the specified index
+    const ARM_Interface& ArmInterface(std::size_t core_index) const;
+
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(std::size_t core_index);
 
     /// Gets a CPU interface to the CPU core with the specified index
     const Cpu& CpuCore(std::size_t core_index) const;
 
-    /// Gets the exclusive monitor
+    /// Gets a reference to the exclusive monitor
     ExclusiveMonitor& Monitor();
 
+    /// Gets a constant reference to the exclusive monitor
+    const ExclusiveMonitor& Monitor() const;
+
     /// Gets a mutable reference to the GPU interface
     Tegra::GPU& GPU();
 
@@ -230,6 +242,9 @@ private:
     /// Returns the currently running CPU core
     Cpu& CurrentCpuCore();
 
+    /// Returns the currently running CPU core
+    const Cpu& CurrentCpuCore() const;
+
     /**
      * Initialize the emulated system.
      * @param emu_window Reference to the host-system window used for video output and keyboard

src/core/crypto/key_manager.cpp

@@ -141,28 +141,28 @@ Key128 DeriveKeyblobMACKey(const Key128& keyblob_key, const Key128& mac_source)
     return mac_key;
 }
 
-boost::optional<Key128> DeriveSDSeed() {
+std::optional<Key128> DeriveSDSeed() {
     const FileUtil::IOFile save_43(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                                        "/system/save/8000000000000043",
                                    "rb+");
     if (!save_43.IsOpen())
-        return boost::none;
+        return {};
 
     const FileUtil::IOFile sd_private(
         FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) + "/Nintendo/Contents/private", "rb+");
     if (!sd_private.IsOpen())
-        return boost::none;
+        return {};
 
     std::array<u8, 0x10> private_seed{};
     if (sd_private.ReadBytes(private_seed.data(), private_seed.size()) != private_seed.size()) {
-        return boost::none;
+        return {};
     }
 
     std::array<u8, 0x10> buffer{};
     std::size_t offset = 0;
     for (; offset + 0x10 < save_43.GetSize(); ++offset) {
         if (!save_43.Seek(offset, SEEK_SET)) {
-            return boost::none;
+            return {};
         }
 
         save_43.ReadBytes(buffer.data(), buffer.size());
@@ -172,12 +172,12 @@ boost::optional<Key128> DeriveSDSeed() {
     }
 
     if (!save_43.Seek(offset + 0x10, SEEK_SET)) {
-        return boost::none;
+        return {};
     }
 
     Key128 seed{};
     if (save_43.ReadBytes(seed.data(), seed.size()) != seed.size()) {
-        return boost::none;
+        return {};
     }
     return seed;
 }
@@ -291,26 +291,26 @@ static std::array<u8, target_size> MGF1(const std::array<u8, in_size>& seed) {
 }
 
 template <size_t size>
-static boost::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
+static std::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
     u64 offset = 0;
     for (size_t i = 0x20; i < data.size() - 0x10; ++i) {
         if (data[i] == 0x1) {
             offset = i + 1;
             break;
         } else if (data[i] != 0x0) {
-            return boost::none;
+            return {};
         }
     }
 
     return offset;
 }
 
-boost::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
-                                                       const RSAKeyPair<2048>& key) {
+std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
+                                                     const RSAKeyPair<2048>& key) {
     u32 cert_authority;
     std::memcpy(&cert_authority, ticket.data() + 0x140, sizeof(cert_authority));
     if (cert_authority == 0)
-        return boost::none;
+        return {};
     if (cert_authority != Common::MakeMagic('R', 'o', 'o', 't')) {
         LOG_INFO(Crypto,
                  "Attempting to parse ticket with non-standard certificate authority {:08X}.",
@@ -321,7 +321,7 @@ boost::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
     std::memcpy(rights_id.data(), ticket.data() + 0x2A0, sizeof(Key128));
 
     if (rights_id == Key128{})
-        return boost::none;
+        return {};
 
     Key128 key_temp{};
 
@@ -356,17 +356,17 @@ boost::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
     std::memcpy(m_2.data(), rsa_step.data() + 0x21, m_2.size());
 
     if (m_0 != 0)
-        return boost::none;
+        return {};
 
     m_1 = m_1 ^ MGF1<0x20>(m_2);
     m_2 = m_2 ^ MGF1<0xDF>(m_1);
 
     const auto offset = FindTicketOffset(m_2);
-    if (offset == boost::none)
-        return boost::none;
-    ASSERT(offset.get() > 0);
+    if (!offset)
+        return {};
+    ASSERT(*offset > 0);
 
-    std::memcpy(key_temp.data(), m_2.data() + offset.get(), key_temp.size());
+    std::memcpy(key_temp.data(), m_2.data() + *offset, key_temp.size());
 
     return std::make_pair(rights_id, key_temp);
 }
@@ -395,7 +395,7 @@ static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_
     if (base.size() < begin + length)
         return false;
     return std::all_of(base.begin() + begin, base.begin() + begin + length,
-                       [](u8 c) { return std::isdigit(c); });
+                       [](u8 c) { return std::isxdigit(c); });
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
@@ -661,8 +661,8 @@ void KeyManager::DeriveSDSeedLazy() {
         return;
 
     const auto res = DeriveSDSeed();
-    if (res != boost::none)
-        SetKey(S128KeyType::SDSeed, res.get());
+    if (res)
+        SetKey(S128KeyType::SDSeed, *res);
 }
 
 static Key128 CalculateCMAC(const u8* source, size_t size, const Key128& key) {
@@ -889,9 +889,9 @@ void KeyManager::DeriveETicket(PartitionDataManager& data) {
 
     for (const auto& raw : res) {
         const auto pair = ParseTicket(raw, rsa_key);
-        if (pair == boost::none)
+        if (!pair)
             continue;
-        const auto& [rid, key] = pair.value();
+        const auto& [rid, key] = *pair;
         u128 rights_id;
         std::memcpy(rights_id.data(), rid.data(), rid.size());
         SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);

src/core/crypto/key_manager.h

@@ -6,9 +6,10 @@
 
 #include <array>
 #include <map>
+#include <optional>
 #include <string>
+
 #include <boost/container/flat_map.hpp>
-#include <boost/optional.hpp>
 #include <fmt/format.h>
 #include "common/common_types.h"
 #include "core/crypto/partition_data_manager.h"
@@ -191,14 +192,14 @@ Key128 DeriveMasterKey(const std::array<u8, 0x90>& keyblob, const Key128& master
 std::array<u8, 0x90> DecryptKeyblob(const std::array<u8, 0xB0>& encrypted_keyblob,
                                     const Key128& key);
 
-boost::optional<Key128> DeriveSDSeed();
+std::optional<Key128> DeriveSDSeed();
 Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& keys);
 
 std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save);
 
 // Returns a pair of {rights_id, titlekey}. Fails if the ticket has no certificate authority (offset
 // 0x140-0x144 is zero)
-boost::optional<std::pair<Key128, Key128>> ParseTicket(
-    const TicketRaw& ticket, const RSAKeyPair<2048>& eticket_extended_key);
+std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
+                                                     const RSAKeyPair<2048>& eticket_extended_key);
 
 } // namespace Core::Crypto

src/core/file_sys/bis_factory.cpp

@@ -8,8 +8,9 @@
 
 namespace FileSys {
 
-BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_)
+BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir dump_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>(
@@ -32,4 +33,10 @@ 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,17 +17,19 @@ class RegisteredCache;
 /// registered caches.
 class BISFactory {
 public:
-    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root);
+    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root, VirtualDir dump_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);
+        auto nca = std::make_shared<NCA>(file, nullptr, 0, keys);
         // TODO(DarkLordZach): Add proper Rev1+ Support
         if (nca->IsUpdate())
             continue;

src/core/file_sys/card_image.h

@@ -9,6 +9,7 @@
 #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 {
@@ -107,5 +108,7 @@ 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

@@ -4,10 +4,9 @@
 
 #include <algorithm>
 #include <cstring>
+#include <optional>
 #include <utility>
 
-#include <boost/optional.hpp>
-
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
@@ -102,8 +101,9 @@ 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)
-    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)) {
+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_)) {
     if (file == nullptr) {
         status = Loader::ResultStatus::ErrorNullFile;
         return;
@@ -306,18 +306,18 @@ bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTabl
         subsection_buckets.back().entries.push_back({section.bktr.relocation.offset, {0}, ctr_low});
         subsection_buckets.back().entries.push_back({size, {0}, 0});
 
-        boost::optional<Core::Crypto::Key128> key = boost::none;
+        std::optional<Core::Crypto::Key128> key = {};
         if (encrypted) {
             if (has_rights_id) {
                 status = Loader::ResultStatus::Success;
                 key = GetTitlekey();
-                if (key == boost::none) {
+                if (!key) {
                     status = Loader::ResultStatus::ErrorMissingTitlekey;
                     return false;
                 }
             } else {
                 key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
-                if (key == boost::none) {
+                if (!key) {
                     status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
                     return false;
                 }
@@ -332,7 +332,7 @@ bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTabl
         auto bktr = std::make_shared<BKTR>(
             bktr_base_romfs, std::make_shared<OffsetVfsFile>(file, romfs_size, base_offset),
             relocation_block, relocation_buckets, subsection_block, subsection_buckets, encrypted,
-            encrypted ? key.get() : Core::Crypto::Key128{}, base_offset, bktr_base_ivfc_offset,
+            encrypted ? *key : Core::Crypto::Key128{}, base_offset, bktr_base_ivfc_offset,
             section.raw.section_ctr);
 
         // BKTR applies to entire IVFC, so make an offset version to level 6
@@ -388,11 +388,11 @@ u8 NCA::GetCryptoRevision() const {
     return master_key_id;
 }
 
-boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
+std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
     const auto master_key_id = GetCryptoRevision();
 
     if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
-        return boost::none;
+        return {};
 
     std::vector<u8> key_area(header.key_area.begin(), header.key_area.end());
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -416,25 +416,25 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     return out;
 }
 
-boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
+std::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     const auto master_key_id = GetCryptoRevision();
 
     u128 rights_id{};
     memcpy(rights_id.data(), header.rights_id.data(), 16);
     if (rights_id == u128{}) {
         status = Loader::ResultStatus::ErrorInvalidRightsID;
-        return boost::none;
+        return {};
     }
 
     auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
     if (titlekey == Core::Crypto::Key128{}) {
         status = Loader::ResultStatus::ErrorMissingTitlekey;
-        return boost::none;
+        return {};
     }
 
     if (!keys.HasKey(Core::Crypto::S128KeyType::Titlekek, master_key_id)) {
         status = Loader::ResultStatus::ErrorMissingTitlekek;
-        return boost::none;
+        return {};
     }
 
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -458,25 +458,25 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
     case NCASectionCryptoType::BKTR:
         LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
-            boost::optional<Core::Crypto::Key128> key = boost::none;
+            std::optional<Core::Crypto::Key128> key = {};
             if (has_rights_id) {
                 status = Loader::ResultStatus::Success;
                 key = GetTitlekey();
-                if (key == boost::none) {
+                if (!key) {
                     if (status == Loader::ResultStatus::Success)
                         status = Loader::ResultStatus::ErrorMissingTitlekey;
                     return nullptr;
                 }
             } else {
                 key = GetKeyAreaKey(NCASectionCryptoType::CTR);
-                if (key == boost::none) {
+                if (!key) {
                     status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
                     return nullptr;
                 }
             }
 
-            auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(
-                std::move(in), key.value(), starting_offset);
+            auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(std::move(in), *key,
+                                                                          starting_offset);
             std::vector<u8> iv(16);
             for (u8 i = 0; i < 8; ++i)
                 iv[i] = s_header.raw.section_ctr[0x8 - i - 1];

src/core/file_sys/content_archive.h

@@ -6,9 +6,10 @@
 
 #include <array>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
-#include <boost/optional.hpp>
+
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -78,7 +79,8 @@ 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);
+                 u64 bktr_base_ivfc_offset = 0,
+                 Core::Crypto::KeyManager keys = Core::Crypto::KeyManager());
     ~NCA() override;
 
     Loader::ResultStatus GetStatus() const;
@@ -111,8 +113,8 @@ private:
     bool ReadPFS0Section(const NCASectionHeader& section, const NCASectionTableEntry& entry);
 
     u8 GetCryptoRevision() const;
-    boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
-    boost::optional<Core::Crypto::Key128> GetTitlekey();
+    std::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
+    std::optional<Core::Crypto::Key128> GetTitlekey();
     VirtualFile Decrypt(const NCASectionHeader& header, VirtualFile in, u64 starting_offset);
 
     std::vector<VirtualDir> dirs;

src/core/file_sys/control_metadata.cpp

@@ -66,4 +66,10 @@ std::string NACP::GetVersionString() const {
     return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(),
                                                        raw->version_string.size());
 }
+
+std::vector<u8> NACP::GetRawBytes() const {
+    std::vector<u8> out(sizeof(RawNACP));
+    std::memcpy(out.data(), raw.get(), sizeof(RawNACP));
+    return out;
+}
 } // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -81,6 +81,7 @@ public:
     u64 GetTitleId() const;
     u64 GetDLCBaseTitleId() const;
     std::string GetVersionString() const;
+    std::vector<u8> GetRawBytes() const;
 
 private:
     std::unique_ptr<RawNACP> raw;

src/core/file_sys/errors.h

@@ -8,25 +8,10 @@
 
 namespace FileSys {
 
-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);
+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 FileSys

src/core/file_sys/fsmitm_romfsbuild.h

@@ -27,7 +27,6 @@
 #include <map>
 #include <memory>
 #include <string>
-#include <boost/detail/container_fwd.hpp>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 

src/core/file_sys/ips_layer.cpp

@@ -103,12 +103,12 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
             offset += sizeof(u16);
 
             const auto data = ips->ReadByte(offset++);
-            if (data == boost::none)
+            if (!data)
                 return nullptr;
 
             if (real_offset + rle_size > in_data.size())
                 rle_size = static_cast<u16>(in_data.size() - real_offset);
-            std::memset(in_data.data() + real_offset, data.get(), rle_size);
+            std::memset(in_data.data() + real_offset, *data, rle_size);
         } else { // Standard Patch
             auto read = data_size;
             if (real_offset + read > in_data.size())

src/core/file_sys/patch_manager.cpp

@@ -19,6 +19,7 @@
 #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 {
 
@@ -61,13 +62,12 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
     const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
-    if (update != nullptr) {
-        if (update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
-            update->GetExeFS() != nullptr) {
-            LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
-            exefs = update->GetExeFS();
-        }
+
+    if (update != nullptr && update->GetExeFS() != nullptr &&
+        update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
+        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
+                 FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
+        exefs = update->GetExeFS();
     }
 
     return exefs;
@@ -120,6 +120,18 @@ 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);
@@ -237,7 +249,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
             LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
             romfs = new_nca->GetRomFS();
         }
     } else if (update_raw != nullptr) {
@@ -281,12 +293,11 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     } else {
         if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
             const auto meta_ver = installed->GetEntryVersion(update_tid);
-            if (meta_ver == boost::none || meta_ver.get() == 0) {
+            if (meta_ver.value_or(0) == 0) {
                 out.insert_or_assign("Update", "");
             } else {
                 out.insert_or_assign(
-                    "Update",
-                    FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements));
+                    "Update", FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
             }
         } else if (update_raw != nullptr) {
             out.insert_or_assign("Update", "PACKED");

src/core/file_sys/registered_cache.cpp

@@ -106,9 +106,12 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
 
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
-    if (dir->GetFileRelative(path) != nullptr)
-        return dir->GetFileRelative(path);
-    if (dir->GetDirectoryRelative(path) != nullptr) {
+    const auto file = dir->GetFileRelative(path);
+    if (file != nullptr)
+        return file;
+
+    const auto nca_dir = dir->GetDirectoryRelative(path);
+    if (nca_dir != nullptr) {
         const auto nca_dir = dir->GetDirectoryRelative(path);
         VirtualFile file = nullptr;
 
@@ -159,28 +162,28 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
     return file;
 }
 
-static boost::optional<NcaID> CheckMapForContentRecord(
+static std::optional<NcaID> CheckMapForContentRecord(
     const boost::container::flat_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
     if (map.find(title_id) == map.end())
-        return boost::none;
+        return {};
 
     const auto& cnmt = map.at(title_id);
 
     const auto iter = std::find_if(cnmt.GetContentRecords().begin(), cnmt.GetContentRecords().end(),
                                    [type](const ContentRecord& rec) { return rec.type == type; });
     if (iter == cnmt.GetContentRecords().end())
-        return boost::none;
+        return {};
 
-    return boost::make_optional(iter->nca_id);
+    return std::make_optional(iter->nca_id);
 }
 
-boost::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,
-                                                             ContentRecordType type) const {
+std::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,
+                                                           ContentRecordType type) const {
     if (type == ContentRecordType::Meta && meta_id.find(title_id) != meta_id.end())
         return meta_id.at(title_id);
 
     const auto res1 = CheckMapForContentRecord(yuzu_meta, title_id, type);
-    if (res1 != boost::none)
+    if (res1)
         return res1;
     return CheckMapForContentRecord(meta, title_id, type);
 }
@@ -225,7 +228,7 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
 
         if (file == nullptr)
             continue;
-        const auto nca = std::make_shared<NCA>(parser(file, id));
+        const auto nca = std::make_shared<NCA>(parser(file, id), nullptr, 0, keys);
         if (nca->GetStatus() != Loader::ResultStatus::Success ||
             nca->GetType() != NCAContentType::Meta) {
             continue;
@@ -283,17 +286,14 @@ bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
 
 VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
     const auto id = GetNcaIDFromMetadata(title_id, type);
-    if (id == boost::none)
-        return nullptr;
-
-    return GetFileAtID(id.get());
+    return id ? GetFileAtID(*id) : nullptr;
 }
 
 VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
     return GetEntryUnparsed(entry.title_id, entry.type);
 }
 
-boost::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
+std::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
     const auto meta_iter = meta.find(title_id);
     if (meta_iter != meta.end())
         return meta_iter->second.GetTitleVersion();
@@ -302,15 +302,12 @@ boost::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
     if (yuzu_meta_iter != yuzu_meta.end())
         return yuzu_meta_iter->second.GetTitleVersion();
 
-    return boost::none;
+    return {};
 }
 
 VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
     const auto id = GetNcaIDFromMetadata(title_id, type);
-    if (id == boost::none)
-        return nullptr;
-
-    return parser(GetFileAtID(id.get()), id.get());
+    return id ? parser(GetFileAtID(*id), *id) : nullptr;
 }
 
 VirtualFile RegisteredCache::GetEntryRaw(RegisteredCacheEntry entry) const {
@@ -321,7 +318,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);
+    return std::make_unique<NCA>(raw, nullptr, 0, keys);
 }
 
 std::unique_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
@@ -364,8 +361,8 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntries() const {
 }
 
 std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
-    boost::optional<TitleType> title_type, boost::optional<ContentRecordType> record_type,
-    boost::optional<u64> title_id) const {
+    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
+    std::optional<u64> title_id) const {
     std::vector<RegisteredCacheEntry> out;
     IterateAllMetadata<RegisteredCacheEntry>(
         out,
@@ -373,11 +370,11 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
             return RegisteredCacheEntry{c.GetTitleID(), r.type};
         },
         [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-            if (title_type != boost::none && title_type.get() != c.GetType())
+            if (title_type && *title_type != c.GetType())
                 return false;
-            if (record_type != boost::none && record_type.get() != r.type)
+            if (record_type && *record_type != r.type)
                 return false;
-            if (title_id != boost::none && title_id.get() != c.GetTitleID())
+            if (title_id && *title_id != c.GetTitleID())
                 return false;
             return true;
         });
@@ -459,7 +456,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NCA> nca, TitleType
 
 InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
                                              bool overwrite_if_exists,
-                                             boost::optional<NcaID> override_id) {
+                                             std::optional<NcaID> override_id) {
     const auto in = nca->GetBaseFile();
     Core::Crypto::SHA256Hash hash{};
 
@@ -468,12 +465,12 @@ InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const Vfs
     // game is massive), we're going to cheat and only hash the first MB of the NCA.
     // Also, for XCIs the NcaID matters, so if the override id isn't none, use that.
     NcaID id{};
-    if (override_id == boost::none) {
+    if (override_id) {
+        id = *override_id;
+    } else {
         const auto& data = in->ReadBytes(0x100000);
         mbedtls_sha256(data.data(), data.size(), hash.data(), 0);
         memcpy(id.data(), hash.data(), 16);
-    } else {
-        id = override_id.get();
     }
 
     std::string path = GetRelativePathFromNcaID(id, false, true);
@@ -543,14 +540,14 @@ bool RegisteredCacheUnion::HasEntry(RegisteredCacheEntry entry) const {
     return HasEntry(entry.title_id, entry.type);
 }
 
-boost::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
+std::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
     for (const auto& c : caches) {
         const auto res = c->GetEntryVersion(title_id);
-        if (res != boost::none)
+        if (res)
             return res;
     }
 
-    return boost::none;
+    return {};
 }
 
 VirtualFile RegisteredCacheUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
@@ -609,8 +606,8 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
 }
 
 std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
-    boost::optional<TitleType> title_type, boost::optional<ContentRecordType> record_type,
-    boost::optional<u64> title_id) const {
+    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
+    std::optional<u64> title_id) const {
     std::vector<RegisteredCacheEntry> out;
     for (const auto& c : caches) {
         c->IterateAllMetadata<RegisteredCacheEntry>(
@@ -619,11 +616,11 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
                 return RegisteredCacheEntry{c.GetTitleID(), r.type};
             },
             [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-                if (title_type != boost::none && title_type.get() != c.GetType())
+                if (title_type && *title_type != c.GetType())
                     return false;
-                if (record_type != boost::none && record_type.get() != r.type)
+                if (record_type && *record_type != r.type)
                     return false;
-                if (title_id != boost::none && title_id.get() != c.GetTitleID())
+                if (title_id && *title_id != c.GetTitleID())
                     return false;
                 return true;
             });

src/core/file_sys/registered_cache.h

@@ -12,6 +12,7 @@
 #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 {
@@ -84,7 +85,7 @@ public:
     bool HasEntry(u64 title_id, ContentRecordType type) const;
     bool HasEntry(RegisteredCacheEntry entry) const;
 
-    boost::optional<u32> GetEntryVersion(u64 title_id) const;
+    std::optional<u32> GetEntryVersion(u64 title_id) const;
 
     VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
     VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
@@ -96,11 +97,10 @@ public:
     std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
 
     std::vector<RegisteredCacheEntry> ListEntries() const;
-    // If a parameter is not boost::none, it will be filtered for from all entries.
+    // If a parameter is not std::nullopt, it will be filtered for from all entries.
     std::vector<RegisteredCacheEntry> ListEntriesFilter(
-        boost::optional<TitleType> title_type = boost::none,
-        boost::optional<ContentRecordType> record_type = boost::none,
-        boost::optional<u64> title_id = boost::none) const;
+        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
+        std::optional<u64> title_id = {}) const;
 
     // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
     // there is a meta NCA and all of them are accessible.
@@ -125,16 +125,17 @@ private:
     std::vector<NcaID> AccumulateFiles() const;
     void ProcessFiles(const std::vector<NcaID>& ids);
     void AccumulateYuzuMeta();
-    boost::optional<NcaID> GetNcaIDFromMetadata(u64 title_id, ContentRecordType type) const;
+    std::optional<NcaID> GetNcaIDFromMetadata(u64 title_id, ContentRecordType type) const;
     VirtualFile GetFileAtID(NcaID id) const;
     VirtualFile OpenFileOrDirectoryConcat(const VirtualDir& dir, std::string_view path) const;
     InstallResult RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
-                                bool overwrite_if_exists,
-                                boost::optional<NcaID> override_id = boost::none);
+                                bool overwrite_if_exists, std::optional<NcaID> override_id = {});
     bool RawInstallYuzuMeta(const CNMT& cnmt);
 
     VirtualDir dir;
     RegisteredCacheParsingFunction parser;
+    Core::Crypto::KeyManager keys;
+
     // maps tid -> NcaID of meta
     boost::container::flat_map<u64, NcaID> meta_id;
     // maps tid -> meta
@@ -153,7 +154,7 @@ public:
     bool HasEntry(u64 title_id, ContentRecordType type) const;
     bool HasEntry(RegisteredCacheEntry entry) const;
 
-    boost::optional<u32> GetEntryVersion(u64 title_id) const;
+    std::optional<u32> GetEntryVersion(u64 title_id) const;
 
     VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
     VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
@@ -165,11 +166,10 @@ public:
     std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
 
     std::vector<RegisteredCacheEntry> ListEntries() const;
-    // If a parameter is not boost::none, it will be filtered for from all entries.
+    // If a parameter is not std::nullopt, it will be filtered for from all entries.
     std::vector<RegisteredCacheEntry> ListEntriesFilter(
-        boost::optional<TitleType> title_type = boost::none,
-        boost::optional<ContentRecordType> record_type = boost::none,
-        boost::optional<u64> title_id = boost::none) const;
+        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
+        std::optional<u64> title_id = {}) const;
 
 private:
     std::vector<RegisteredCache*> caches;

src/core/file_sys/savedata_factory.cpp

@@ -83,6 +83,24 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
     return MakeResult<VirtualDir>(std::move(out));
 }
 
+VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
+    return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
+}
+
+std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
+    switch (space) {
+    case SaveDataSpaceId::NandSystem:
+        return "/system/";
+    case SaveDataSpaceId::NandUser:
+        return "/user/";
+    case SaveDataSpaceId::TemporaryStorage:
+        return "/temp/";
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+        return "/unrecognized/"; ///< To prevent corruption when ignoring asserts.
+    }
+}
+
 std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
                                          u128 user_id, u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
@@ -90,21 +108,7 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     if (type == SaveDataType::SaveData && title_id == 0)
         title_id = Core::CurrentProcess()->GetTitleID();
 
-    std::string out;
-
-    switch (space) {
-    case SaveDataSpaceId::NandSystem:
-        out = "/system/";
-        break;
-    case SaveDataSpaceId::NandUser:
-        out = "/user/";
-        break;
-    case SaveDataSpaceId::TemporaryStorage:
-        out = "/temp/";
-        break;
-    default:
-        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
-    }
+    std::string out = GetSaveDataSpaceIdPath(space);
 
     switch (type) {
     case SaveDataType::SystemSaveData:

src/core/file_sys/savedata_factory.h

@@ -52,6 +52,9 @@ public:
 
     ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
 
+    VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
+
+    static std::string GetSaveDataSpaceIdPath(SaveDataSpaceId space);
     static std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
                                    u128 user_id, u64 save_id);
 

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);
+                auto next_nca = std::make_shared<NCA>(next_file, nullptr, 0, keys);
                 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,6 +70,8 @@ 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/file_sys/vfs.cpp

@@ -167,13 +167,13 @@ std::string VfsFile::GetExtension() const {
 
 VfsDirectory::~VfsDirectory() = default;
 
-boost::optional<u8> VfsFile::ReadByte(std::size_t offset) const {
+std::optional<u8> VfsFile::ReadByte(std::size_t offset) const {
     u8 out{};
     std::size_t size = Read(&out, 1, offset);
     if (size == 1)
         return out;
 
-    return boost::none;
+    return {};
 }
 
 std::vector<u8> VfsFile::ReadBytes(std::size_t size, std::size_t offset) const {

src/core/file_sys/vfs.h

@@ -4,13 +4,15 @@
 
 #pragma once
 
+#include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include <boost/optional.hpp>
+
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 
@@ -103,8 +105,8 @@ public:
     // into file. Returns number of bytes successfully written.
     virtual std::size_t Write(const u8* data, std::size_t length, std::size_t offset = 0) = 0;
 
-    // Reads exactly one byte at the offset provided, returning boost::none on error.
-    virtual boost::optional<u8> ReadByte(std::size_t offset = 0) const;
+    // Reads exactly one byte at the offset provided, returning std::nullopt on error.
+    virtual std::optional<u8> ReadByte(std::size_t offset = 0) const;
     // Reads size bytes starting at offset in file into a vector.
     virtual std::vector<u8> ReadBytes(std::size_t size, std::size_t offset = 0) const;
     // Reads all the bytes from the file into a vector. Equivalent to 'file->Read(file->GetSize(),

src/core/file_sys/vfs_offset.cpp

@@ -57,11 +57,11 @@ std::size_t OffsetVfsFile::Write(const u8* data, std::size_t length, std::size_t
     return file->Write(data, TrimToFit(length, r_offset), offset + r_offset);
 }
 
-boost::optional<u8> OffsetVfsFile::ReadByte(std::size_t r_offset) const {
+std::optional<u8> OffsetVfsFile::ReadByte(std::size_t r_offset) const {
     if (r_offset < size)
         return file->ReadByte(offset + r_offset);
 
-    return boost::none;
+    return {};
 }
 
 std::vector<u8> OffsetVfsFile::ReadBytes(std::size_t r_size, std::size_t r_offset) const {

src/core/file_sys/vfs_offset.h

@@ -29,7 +29,7 @@ public:
     bool IsReadable() const override;
     std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
     std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override;
-    boost::optional<u8> ReadByte(std::size_t offset) const override;
+    std::optional<u8> ReadByte(std::size_t offset) const override;
     std::vector<u8> ReadBytes(std::size_t size, std::size_t offset) const override;
     std::vector<u8> ReadAllBytes() const override;
     bool WriteByte(u8 data, std::size_t offset) override;

src/core/file_sys/vfs_static.h

@@ -53,10 +53,10 @@ public:
         return 0;
     }
 
-    boost::optional<u8> ReadByte(std::size_t offset) const override {
+    std::optional<u8> ReadByte(std::size_t offset) const override {
         if (offset < size)
             return value;
-        return boost::none;
+        return {};
     }
 
     std::vector<u8> ReadBytes(std::size_t length, std::size_t offset) const override {

src/core/hle/ipc_helpers.h

@@ -117,8 +117,7 @@ public:
 
         AlignWithPadding();
 
-        const bool request_has_domain_header{context.GetDomainMessageHeader() != nullptr};
-        if (context.Session()->IsDomain() && request_has_domain_header) {
+        if (context.Session()->IsDomain() && context.HasDomainMessageHeader()) {
             IPC::DomainMessageHeader domain_header{};
             domain_header.num_objects = num_domain_objects;
             PushRaw(domain_header);

src/core/hle/kernel/errors.h

@@ -8,58 +8,28 @@
 
 namespace Kernel {
 
-namespace ErrCodes {
-enum {
-    // Confirmed Switch OS error codes
-    MaxConnectionsReached = 7,
-    InvalidSize = 101,
-    InvalidAddress = 102,
-    HandleTableFull = 105,
-    InvalidMemoryState = 106,
-    InvalidMemoryPermissions = 108,
-    InvalidMemoryRange = 110,
-    InvalidThreadPriority = 112,
-    InvalidProcessorId = 113,
-    InvalidHandle = 114,
-    InvalidPointer = 115,
-    InvalidCombination = 116,
-    Timeout = 117,
-    SynchronizationCanceled = 118,
-    TooLarge = 119,
-    InvalidEnumValue = 120,
-    NoSuchEntry = 121,
-    AlreadyRegistered = 122,
-    SessionClosed = 123,
-    InvalidState = 125,
-    ResourceLimitExceeded = 132,
-};
-}
+// Confirmed Switch kernel error codes
 
-// 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.
-
-constexpr ResultCode ERR_HANDLE_TABLE_FULL(ErrorModule::Kernel, ErrCodes::HandleTableFull);
-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_COMBINATION_KERNEL(ErrorModule::Kernel,
-                                                    ErrCodes::InvalidCombination);
-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,
-                                                    ErrCodes::InvalidMemoryPermissions);
-constexpr ResultCode ERR_INVALID_MEMORY_RANGE(ErrorModule::Kernel, ErrCodes::InvalidMemoryRange);
-constexpr ResultCode ERR_INVALID_HANDLE(ErrorModule::Kernel, ErrCodes::InvalidHandle);
-constexpr ResultCode ERR_INVALID_PROCESSOR_ID(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
-constexpr ResultCode ERR_INVALID_SIZE(ErrorModule::Kernel, ErrCodes::InvalidSize);
-constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::Kernel, ErrCodes::AlreadyRegistered);
-constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
-constexpr ResultCode ERR_INVALID_THREAD_PRIORITY(ErrorModule::Kernel,
-                                                 ErrCodes::InvalidThreadPriority);
-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);
+constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED{ErrorModule::Kernel, 7};
+constexpr ResultCode ERR_INVALID_SIZE{ErrorModule::Kernel, 101};
+constexpr ResultCode ERR_INVALID_ADDRESS{ErrorModule::Kernel, 102};
+constexpr ResultCode ERR_HANDLE_TABLE_FULL{ErrorModule::Kernel, 105};
+constexpr ResultCode ERR_INVALID_ADDRESS_STATE{ErrorModule::Kernel, 106};
+constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS{ErrorModule::Kernel, 108};
+constexpr ResultCode ERR_INVALID_MEMORY_RANGE{ErrorModule::Kernel, 110};
+constexpr ResultCode ERR_INVALID_PROCESSOR_ID{ErrorModule::Kernel, 113};
+constexpr ResultCode ERR_INVALID_THREAD_PRIORITY{ErrorModule::Kernel, 112};
+constexpr ResultCode ERR_INVALID_HANDLE{ErrorModule::Kernel, 114};
+constexpr ResultCode ERR_INVALID_POINTER{ErrorModule::Kernel, 115};
+constexpr ResultCode ERR_INVALID_COMBINATION{ErrorModule::Kernel, 116};
+constexpr ResultCode RESULT_TIMEOUT{ErrorModule::Kernel, 117};
+constexpr ResultCode ERR_SYNCHRONIZATION_CANCELED{ErrorModule::Kernel, 118};
+constexpr ResultCode ERR_OUT_OF_RANGE{ErrorModule::Kernel, 119};
+constexpr ResultCode ERR_INVALID_ENUM_VALUE{ErrorModule::Kernel, 120};
+constexpr ResultCode ERR_NOT_FOUND{ErrorModule::Kernel, 121};
+constexpr ResultCode ERR_ALREADY_REGISTERED{ErrorModule::Kernel, 122};
+constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE{ErrorModule::Kernel, 123};
+constexpr ResultCode ERR_INVALID_STATE{ErrorModule::Kernel, 125};
+constexpr ResultCode ERR_RESOURCE_LIMIT_EXCEEDED{ErrorModule::Kernel, 132};
 
 } // namespace Kernel

src/core/hle/kernel/hle_ipc.h

@@ -161,8 +161,12 @@ public:
         return buffer_c_desciptors;
     }
 
-    const std::shared_ptr<IPC::DomainMessageHeader>& GetDomainMessageHeader() const {
-        return domain_message_header;
+    const IPC::DomainMessageHeader* GetDomainMessageHeader() const {
+        return domain_message_header.get();
+    }
+
+    bool HasDomainMessageHeader() const {
+        return domain_message_header != nullptr;
     }
 
     /// Helper function to read a buffer using the appropriate buffer descriptor

src/core/hle/kernel/kernel.cpp

@@ -32,7 +32,7 @@ namespace Kernel {
  */
 static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_late) {
     const auto proper_handle = static_cast<Handle>(thread_handle);
-    auto& system = Core::System::GetInstance();
+    const auto& system = Core::System::GetInstance();
 
     // Lock the global kernel mutex when we enter the kernel HLE.
     std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
@@ -90,7 +90,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_
 /// The timer callback event, called when a timer is fired
 static void TimerCallback(u64 timer_handle, int cycles_late) {
     const auto proper_handle = static_cast<Handle>(timer_handle);
-    auto& system = Core::System::GetInstance();
+    const auto& system = Core::System::GetInstance();
     SharedPtr<Timer> timer = system.Kernel().RetrieveTimerFromCallbackHandleTable(proper_handle);
 
     if (timer == nullptr) {

src/core/hle/kernel/mutex.cpp

@@ -6,8 +6,6 @@
 #include <utility>
 #include <vector>
 
-#include <boost/range/algorithm_ext/erase.hpp>
-
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"

src/core/hle/kernel/process.cpp

@@ -5,11 +5,9 @@
 #include <algorithm>
 #include <memory>
 #include "common/assert.h"
-#include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -17,6 +15,7 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
+#include "core/settings.h"
 
 namespace Kernel {
 
@@ -35,6 +34,11 @@ SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
     process->process_id = kernel.CreateNewProcessID();
     process->svc_access_mask.set();
 
+    std::mt19937 rng(Settings::values.rng_seed.value_or(0));
+    std::uniform_int_distribution<u64> distribution;
+    std::generate(process->random_entropy.begin(), process->random_entropy.end(),
+                  [&] { return distribution(rng); });
+
     kernel.AppendNewProcess(process);
     return process;
 }
@@ -241,83 +245,15 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
 }
 
 ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
-    if (target < vm_manager.GetHeapRegionBaseAddress() ||
-        target + size > vm_manager.GetHeapRegionEndAddress() || target + size < target) {
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (heap_memory == nullptr) {
-        // Initialize heap
-        heap_memory = std::make_shared<std::vector<u8>>();
-        heap_start = heap_end = target;
-    } else {
-        vm_manager.UnmapRange(heap_start, heap_end - heap_start);
-    }
-
-    // If necessary, expand backing vector to cover new heap extents.
-    if (target < heap_start) {
-        heap_memory->insert(begin(*heap_memory), heap_start - target, 0);
-        heap_start = target;
-        vm_manager.RefreshMemoryBlockMappings(heap_memory.get());
-    }
-    if (target + size > heap_end) {
-        heap_memory->insert(end(*heap_memory), (target + size) - heap_end, 0);
-        heap_end = target + size;
-        vm_manager.RefreshMemoryBlockMappings(heap_memory.get());
-    }
-    ASSERT(heap_end - heap_start == heap_memory->size());
-
-    CASCADE_RESULT(auto vma, vm_manager.MapMemoryBlock(target, heap_memory, target - heap_start,
-                                                       size, MemoryState::Heap));
-    vm_manager.Reprotect(vma, perms);
-
-    heap_used = size;
-
-    return MakeResult<VAddr>(heap_end - size);
+    return vm_manager.HeapAllocate(target, size, perms);
 }
 
 ResultCode Process::HeapFree(VAddr target, u32 size) {
-    if (target < vm_manager.GetHeapRegionBaseAddress() ||
-        target + size > vm_manager.GetHeapRegionEndAddress() || target + size < target) {
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (size == 0) {
-        return RESULT_SUCCESS;
-    }
-
-    ResultCode result = vm_manager.UnmapRange(target, size);
-    if (result.IsError())
-        return result;
-
-    heap_used -= size;
-
-    return RESULT_SUCCESS;
+    return vm_manager.HeapFree(target, size);
 }
 
 ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
-    auto vma = vm_manager.FindVMA(src_addr);
-
-    ASSERT_MSG(vma != vm_manager.vma_map.end(), "Invalid memory address");
-    ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
-
-    // The returned VMA might be a bigger one encompassing the desired address.
-    auto vma_offset = src_addr - vma->first;
-    ASSERT_MSG(vma_offset + size <= vma->second.size,
-               "Shared memory exceeds bounds of mapped block");
-
-    const std::shared_ptr<std::vector<u8>>& backing_block = vma->second.backing_block;
-    std::size_t backing_block_offset = vma->second.offset + vma_offset;
-
-    CASCADE_RESULT(auto new_vma,
-                   vm_manager.MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
-                                             MemoryState::Mapped));
-    // Protect mirror with permissions from old region
-    vm_manager.Reprotect(new_vma, vma->second.permissions);
-    // Remove permissions from old region
-    vm_manager.Reprotect(vma, VMAPermission::None);
-
-    return RESULT_SUCCESS;
+    return vm_manager.MirrorMemory(dst_addr, src_addr, size);
 }
 
 ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {

src/core/hle/kernel/process.h

@@ -8,6 +8,7 @@
 #include <bitset>
 #include <cstddef>
 #include <memory>
+#include <random>
 #include <string>
 #include <vector>
 #include <boost/container/static_vector.hpp>
@@ -119,6 +120,8 @@ struct CodeSet final {
 
 class Process final : public Object {
 public:
+    static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
+
     static SharedPtr<Process> Create(KernelCore& kernel, std::string&& name);
 
     std::string GetTypeName() const override {
@@ -202,6 +205,21 @@ public:
         return is_64bit_process;
     }
 
+    /// Gets the total running time of the process instance in ticks.
+    u64 GetCPUTimeTicks() const {
+        return total_process_running_time_ticks;
+    }
+
+    /// Updates the total running time, adding the given ticks to it.
+    void UpdateCPUTimeTicks(u64 ticks) {
+        total_process_running_time_ticks += ticks;
+    }
+
+    /// Gets 8 bytes of random data for svcGetInfo RandomEntropy
+    u64 GetRandomEntropy(std::size_t index) const {
+        return random_entropy.at(index);
+    }
+
     /**
      * Loads process-specifics configuration info with metadata provided
      * by an executable.
@@ -282,17 +300,6 @@ private:
     u32 allowed_thread_priority_mask = 0xFFFFFFFF;
     u32 is_virtual_address_memory_enabled = 0;
 
-    // Memory used to back the allocations in the regular heap. A single vector is used to cover
-    // the entire virtual address space extents that bound the allocations, including any holes.
-    // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
-    // in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
-    std::shared_ptr<std::vector<u8>> heap_memory;
-
-    // The left/right bounds of the address space covered by heap_memory.
-    VAddr heap_start = 0;
-    VAddr heap_end = 0;
-    u64 heap_used = 0;
-
     /// The Thread Local Storage area is allocated as processes create threads,
     /// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
     /// holds the TLS for a specific thread. This vector contains which parts are in use for each
@@ -305,9 +312,15 @@ private:
     /// specified by metadata provided to the process during loading.
     bool is_64bit_process = true;
 
+    /// Total running time for the process in ticks.
+    u64 total_process_running_time_ticks = 0;
+
     /// Per-process handle table for storing created object handles in.
     HandleTable handle_table;
 
+    /// Random values for svcGetInfo RandomEntropy
+    std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy;
+
     std::string name;
 };
 

src/core/hle/kernel/scheduler.cpp

@@ -9,6 +9,7 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
+#include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
@@ -34,6 +35,10 @@ Thread* Scheduler::GetCurrentThread() const {
     return current_thread.get();
 }
 
+u64 Scheduler::GetLastContextSwitchTicks() const {
+    return last_context_switch_time;
+}
+
 Thread* Scheduler::PopNextReadyThread() {
     Thread* next = nullptr;
     Thread* thread = GetCurrentThread();
@@ -54,7 +59,10 @@ Thread* Scheduler::PopNextReadyThread() {
 }
 
 void Scheduler::SwitchContext(Thread* new_thread) {
-    Thread* previous_thread = GetCurrentThread();
+    Thread* const previous_thread = GetCurrentThread();
+    Process* const previous_process = Core::CurrentProcess();
+
+    UpdateLastContextSwitchTime(previous_thread, previous_process);
 
     // Save context for previous thread
     if (previous_thread) {
@@ -78,8 +86,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         // Cancel any outstanding wakeup events for this thread
         new_thread->CancelWakeupTimer();
 
-        auto* const previous_process = Core::CurrentProcess();
-
         current_thread = new_thread;
 
         ready_queue.remove(new_thread->GetPriority(), new_thread);
@@ -102,6 +108,22 @@ void Scheduler::SwitchContext(Thread* new_thread) {
     }
 }
 
+void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
+    const u64 prev_switch_ticks = last_context_switch_time;
+    const u64 most_recent_switch_ticks = CoreTiming::GetTicks();
+    const u64 update_ticks = most_recent_switch_ticks - prev_switch_ticks;
+
+    if (thread != nullptr) {
+        thread->UpdateCPUTimeTicks(update_ticks);
+    }
+
+    if (process != nullptr) {
+        process->UpdateCPUTimeTicks(update_ticks);
+    }
+
+    last_context_switch_time = most_recent_switch_ticks;
+}
+
 void Scheduler::Reschedule() {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 

src/core/hle/kernel/scheduler.h

@@ -17,6 +17,8 @@ class ARM_Interface;
 
 namespace Kernel {
 
+class Process;
+
 class Scheduler final {
 public:
     explicit Scheduler(Core::ARM_Interface& cpu_core);
@@ -31,6 +33,9 @@ public:
     /// Gets the current running thread
     Thread* GetCurrentThread() const;
 
+    /// Gets the timestamp for the last context switch in ticks.
+    u64 GetLastContextSwitchTicks() const;
+
     /// Adds a new thread to the scheduler
     void AddThread(SharedPtr<Thread> thread, u32 priority);
 
@@ -64,6 +69,19 @@ private:
      */
     void SwitchContext(Thread* new_thread);
 
+    /**
+     * Called on every context switch to update the internal timestamp
+     * This also updates the running time ticks for the given thread and
+     * process using the following difference:
+     *
+     * ticks += most_recent_ticks - last_context_switch_ticks
+     *
+     * The internal tick timestamp for the scheduler is simply the
+     * most recent tick count retrieved. No special arithmetic is
+     * applied to it.
+     */
+    void UpdateLastContextSwitchTime(Thread* thread, Process* process);
+
     /// Lists all thread ids that aren't deleted/etc.
     std::vector<SharedPtr<Thread>> thread_list;
 
@@ -73,6 +91,7 @@ private:
     SharedPtr<Thread> current_thread = nullptr;
 
     Core::ARM_Interface& cpu_core;
+    u64 last_context_switch_time = 0;
 
     static std::mutex scheduler_mutex;
 };

src/core/hle/kernel/server_session.cpp

@@ -63,7 +63,7 @@ void ServerSession::Acquire(Thread* thread) {
 }
 
 ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
-    auto& domain_message_header = context.GetDomainMessageHeader();
+    auto* const domain_message_header = context.GetDomainMessageHeader();
     if (domain_message_header) {
         // Set domain handlers in HLE context, used for domain objects (IPC interfaces) as inputs
         context.SetDomainRequestHandlers(domain_request_handlers);
@@ -111,7 +111,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
 
     ResultCode result = RESULT_SUCCESS;
     // If the session has been converted to a domain, handle the domain request
-    if (IsDomain() && context.GetDomainMessageHeader()) {
+    if (IsDomain() && context.HasDomainMessageHeader()) {
         result = HandleDomainSyncRequest(context);
         // If there is no domain header, the regular session handler is used
     } else if (hle_handler != nullptr) {

src/core/hle/kernel/svc.cpp

@@ -34,6 +34,7 @@
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
+#include "core/settings.h"
 
 namespace Kernel {
 namespace {
@@ -122,6 +123,48 @@ 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,
@@ -171,7 +214,7 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
     // Read 1 char beyond the max allowed port name to detect names that are too long.
     std::string port_name = Memory::ReadCString(port_name_address, PortNameMaxLength + 1);
     if (port_name.size() > PortNameMaxLength) {
-        return ERR_PORT_NAME_TOO_LONG;
+        return ERR_OUT_OF_RANGE;
     }
 
     LOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
@@ -267,8 +310,9 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 
     static constexpr u64 MaxHandles = 0x40;
 
-    if (handle_count > MaxHandles)
-        return ResultCode(ErrorModule::Kernel, ErrCodes::TooLarge);
+    if (handle_count > MaxHandles) {
+        return ERR_OUT_OF_RANGE;
+    }
 
     auto* const thread = GetCurrentThread();
 
@@ -333,8 +377,7 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
     }
 
     ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
-    thread->SetWaitSynchronizationResult(
-        ResultCode(ErrorModule::Kernel, ErrCodes::SynchronizationCanceled));
+    thread->SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
     thread->ResumeFromWait();
     return RESULT_SUCCESS;
 }
@@ -395,16 +438,42 @@ struct BreakReason {
 /// Break program execution
 static void Break(u32 reason, u64 info1, u64 info2) {
     BreakReason break_reason{reason};
+    bool has_dumped_buffer{};
 
+    const auto handle_debug_buffer = [&](VAddr addr, u64 sz) {
+        if (sz == 0 || addr == 0 || has_dumped_buffer) {
+            return;
+        }
+
+        // This typically is an error code so we're going to assume this is the case
+        if (sz == sizeof(u32)) {
+            LOG_CRITICAL(Debug_Emulated, "debug_buffer_err_code={:X}", Memory::Read32(addr));
+        } else {
+            // We don't know what's in here so we'll hexdump it
+            std::vector<u8> debug_buffer(sz);
+            Memory::ReadBlock(addr, debug_buffer.data(), sz);
+            std::string hexdump;
+            for (std::size_t i = 0; i < debug_buffer.size(); i++) {
+                hexdump += fmt::format("{:02X} ", debug_buffer[i]);
+                if (i != 0 && i % 16 == 0) {
+                    hexdump += '\n';
+                }
+            }
+            LOG_CRITICAL(Debug_Emulated, "debug_buffer=\n{}", hexdump);
+        }
+        has_dumped_buffer = true;
+    };
     switch (break_reason.break_type) {
     case BreakType::Panic:
         LOG_CRITICAL(Debug_Emulated, "Signalling debugger, PANIC! info1=0x{:016X}, info2=0x{:016X}",
                      info1, info2);
+        handle_debug_buffer(info1, info2);
         break;
     case BreakType::AssertionFailed:
         LOG_CRITICAL(Debug_Emulated,
                      "Signalling debugger, Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
                      info1, info2);
+        handle_debug_buffer(info1, info2);
         break;
     case BreakType::PreNROLoad:
         LOG_WARNING(
@@ -433,6 +502,7 @@ static void Break(u32 reason, u64 info1, u64 info2) {
             Debug_Emulated,
             "Signalling debugger, Unknown break reason {}, info1=0x{:016X}, info2=0x{:016X}",
             static_cast<u32>(break_reason.break_type.Value()), info1, info2);
+        handle_debug_buffer(info1, info2);
         break;
     }
 
@@ -441,6 +511,7 @@ static void Break(u32 reason, u64 info1, u64 info2) {
             Debug_Emulated,
             "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
             reason, info1, info2);
+        handle_debug_buffer(info1, info2);
         ASSERT(false);
 
         Core::CurrentProcess()->PrepareForTermination();
@@ -467,6 +538,37 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
               info_sub_id, handle);
 
+    enum class GetInfoType : u64 {
+        // 1.0.0+
+        AllowedCpuIdBitmask = 0,
+        AllowedThreadPrioBitmask = 1,
+        MapRegionBaseAddr = 2,
+        MapRegionSize = 3,
+        HeapRegionBaseAddr = 4,
+        HeapRegionSize = 5,
+        TotalMemoryUsage = 6,
+        TotalHeapUsage = 7,
+        IsCurrentProcessBeingDebugged = 8,
+        ResourceHandleLimit = 9,
+        IdleTickCount = 10,
+        RandomEntropy = 11,
+        PerformanceCounter = 0xF0000002,
+        // 2.0.0+
+        ASLRRegionBaseAddr = 12,
+        ASLRRegionSize = 13,
+        NewMapRegionBaseAddr = 14,
+        NewMapRegionSize = 15,
+        // 3.0.0+
+        IsVirtualAddressMemoryEnabled = 16,
+        PersonalMmHeapUsage = 17,
+        TitleId = 18,
+        // 4.0.0+
+        PrivilegedProcessId = 19,
+        // 5.0.0+
+        UserExceptionContextAddr = 20,
+        ThreadTickCount = 0xF0000002,
+    };
+
     const auto* current_process = Core::CurrentProcess();
     const auto& vm_manager = current_process->VMManager();
 
@@ -499,7 +601,16 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         *result = 0;
         break;
     case GetInfoType::RandomEntropy:
-        *result = 0;
+        if (handle != 0) {
+            return ERR_INVALID_HANDLE;
+        }
+
+        if (info_sub_id >= Process::RANDOM_ENTROPY_SIZE) {
+            return ERR_INVALID_COMBINATION;
+        }
+
+        *result = current_process->GetRandomEntropy(info_sub_id);
+        return RESULT_SUCCESS;
         break;
     case GetInfoType::ASLRRegionBaseAddr:
         *result = vm_manager.GetASLRRegionBaseAddress();
@@ -529,6 +640,36 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
                     "(STUBBED) Attempted to query user exception context address, returned 0");
         *result = 0;
         break;
+    case GetInfoType::ThreadTickCount: {
+        constexpr u64 num_cpus = 4;
+        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
+            return ERR_INVALID_COMBINATION;
+        }
+
+        const auto thread =
+            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
+        if (!thread) {
+            return ERR_INVALID_HANDLE;
+        }
+
+        const auto& system = Core::System::GetInstance();
+        const auto& scheduler = system.CurrentScheduler();
+        const auto* const current_thread = scheduler.GetCurrentThread();
+        const bool same_thread = current_thread == thread;
+
+        const u64 prev_ctx_ticks = scheduler.GetLastContextSwitchTicks();
+        u64 out_ticks = 0;
+        if (same_thread && info_sub_id == 0xFFFFFFFFFFFFFFFF) {
+            const u64 thread_ticks = current_thread->GetTotalCPUTimeTicks();
+
+            out_ticks = thread_ticks + (CoreTiming::GetTicks() - prev_ctx_ticks);
+        } else if (same_thread && info_sub_id == system.CurrentCoreIndex()) {
+            out_ticks = CoreTiming::GetTicks() - prev_ctx_ticks;
+        }
+
+        *result = out_ticks;
+        break;
+    }
     default:
         UNIMPLEMENTED();
     }
@@ -1040,7 +1181,7 @@ static ResultCode CloseHandle(Handle handle) {
 
 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
+    LOG_DEBUG(Kernel_SVC, "called handle 0x{:08X}", handle);
 
     const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
     auto event = handle_table.Get<Event>(handle);
@@ -1095,7 +1236,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
     }
 
     if (mask == 0) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidCombination);
+        return ERR_INVALID_COMBINATION;
     }
 
     /// This value is used to only change the affinity mask without changing the current ideal core.
@@ -1104,12 +1245,12 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
     if (core == OnlyChangeMask) {
         core = thread->GetIdealCore();
     } else if (core >= Core::NUM_CPU_CORES && core != static_cast<u32>(-1)) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
+        return ERR_INVALID_PROCESSOR_ID;
     }
 
     // Error out if the input core isn't enabled in the input mask.
     if (core < Core::NUM_CPU_CORES && (mask & (1ull << core)) == 0) {
-        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidCombination);
+        return ERR_INVALID_COMBINATION;
     }
 
     thread->ChangeCore(core, mask);
@@ -1198,7 +1339,7 @@ struct FunctionDef {
 static const FunctionDef SVC_Table[] = {
     {0x00, nullptr, "Unknown"},
     {0x01, SvcWrap<SetHeapSize>, "SetHeapSize"},
-    {0x02, nullptr, "SetMemoryPermission"},
+    {0x02, SvcWrap<SetMemoryPermission>, "SetMemoryPermission"},
     {0x03, SvcWrap<SetMemoryAttribute>, "SetMemoryAttribute"},
     {0x04, SvcWrap<MapMemory>, "MapMemory"},
     {0x05, SvcWrap<UnmapMemory>, "UnmapMemory"},

src/core/hle/kernel/svc.h

@@ -24,37 +24,6 @@ struct PageInfo {
     u64 flags;
 };
 
-/// Values accepted by svcGetInfo
-enum class GetInfoType : u64 {
-    // 1.0.0+
-    AllowedCpuIdBitmask = 0,
-    AllowedThreadPrioBitmask = 1,
-    MapRegionBaseAddr = 2,
-    MapRegionSize = 3,
-    HeapRegionBaseAddr = 4,
-    HeapRegionSize = 5,
-    TotalMemoryUsage = 6,
-    TotalHeapUsage = 7,
-    IsCurrentProcessBeingDebugged = 8,
-    ResourceHandleLimit = 9,
-    IdleTickCount = 10,
-    RandomEntropy = 11,
-    PerformanceCounter = 0xF0000002,
-    // 2.0.0+
-    ASLRRegionBaseAddr = 12,
-    ASLRRegionSize = 13,
-    NewMapRegionBaseAddr = 14,
-    NewMapRegionSize = 15,
-    // 3.0.0+
-    IsVirtualAddressMemoryEnabled = 16,
-    PersonalMmHeapUsage = 17,
-    TitleId = 18,
-    // 4.0.0+
-    PrivilegedProcessId = 19,
-    // 5.0.0+
-    UserExceptionContextAddr = 20,
-};
-
 void CallSVC(u32 immediate);
 
 } // namespace Kernel

src/core/hle/kernel/svc_wrap.h

@@ -121,6 +121,11 @@ 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

@@ -4,9 +4,9 @@
 
 #include <algorithm>
 #include <cinttypes>
+#include <optional>
 #include <vector>
 
-#include <boost/optional.hpp>
 #include <boost/range/algorithm_ext/erase.hpp>
 
 #include "common/assert.h"
@@ -94,7 +94,7 @@ void Thread::CancelWakeupTimer() {
     CoreTiming::UnscheduleEventThreadsafe(kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }
 
-static boost::optional<s32> GetNextProcessorId(u64 mask) {
+static std::optional<s32> GetNextProcessorId(u64 mask) {
     for (s32 index = 0; index < Core::NUM_CPU_CORES; ++index) {
         if (mask & (1ULL << index)) {
             if (!Core::System::GetInstance().Scheduler(index).GetCurrentThread()) {
@@ -142,36 +142,7 @@ void Thread::ResumeFromWait() {
 
     status = ThreadStatus::Ready;
 
-    boost::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();
+    ChangeScheduler();
 }
 
 /**
@@ -364,42 +335,45 @@ 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;
     }
 
-    boost::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
+    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 &&
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+    if (ideal_core != -1 && system.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);
+    auto& next_scheduler = system.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;
 
-    Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
+    system.CpuCore(processor_id).PrepareReschedule();
 }
 
 bool Thread::AllWaitObjectsReady() {

src/core/hle/kernel/thread.h

@@ -258,6 +258,14 @@ public:
         return last_running_ticks;
     }
 
+    u64 GetTotalCPUTimeTicks() const {
+        return total_cpu_time_ticks;
+    }
+
+    void UpdateCPUTimeTicks(u64 ticks) {
+        total_cpu_time_ticks += ticks;
+    }
+
     s32 GetProcessorID() const {
         return processor_id;
     }
@@ -366,6 +374,8 @@ private:
     explicit Thread(KernelCore& kernel);
     ~Thread() override;
 
+    void ChangeScheduler();
+
     Core::ARM_Interface::ThreadContext context{};
 
     u32 thread_id = 0;
@@ -378,7 +388,8 @@ private:
     u32 nominal_priority = 0; ///< Nominal thread priority, as set by the emulated application
     u32 current_priority = 0; ///< Current thread priority, can be temporarily changed
 
-    u64 last_running_ticks = 0; ///< CPU tick when thread was last running
+    u64 total_cpu_time_ticks = 0; ///< Total CPU running ticks.
+    u64 last_running_ticks = 0;   ///< CPU tick when thread was last running
 
     s32 processor_id = 0;
 

src/core/hle/kernel/vm_manager.cpp

@@ -243,6 +243,85 @@ ResultCode VMManager::ReprotectRange(VAddr target, u64 size, VMAPermission new_p
     return RESULT_SUCCESS;
 }
 
+ResultVal<VAddr> VMManager::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
+    if (target < GetHeapRegionBaseAddress() || target + size > GetHeapRegionEndAddress() ||
+        target + size < target) {
+        return ERR_INVALID_ADDRESS;
+    }
+
+    if (heap_memory == nullptr) {
+        // Initialize heap
+        heap_memory = std::make_shared<std::vector<u8>>();
+        heap_start = heap_end = target;
+    } else {
+        UnmapRange(heap_start, heap_end - heap_start);
+    }
+
+    // If necessary, expand backing vector to cover new heap extents.
+    if (target < heap_start) {
+        heap_memory->insert(begin(*heap_memory), heap_start - target, 0);
+        heap_start = target;
+        RefreshMemoryBlockMappings(heap_memory.get());
+    }
+    if (target + size > heap_end) {
+        heap_memory->insert(end(*heap_memory), (target + size) - heap_end, 0);
+        heap_end = target + size;
+        RefreshMemoryBlockMappings(heap_memory.get());
+    }
+    ASSERT(heap_end - heap_start == heap_memory->size());
+
+    CASCADE_RESULT(auto vma, MapMemoryBlock(target, heap_memory, target - heap_start, size,
+                                            MemoryState::Heap));
+    Reprotect(vma, perms);
+
+    heap_used = size;
+
+    return MakeResult<VAddr>(heap_end - size);
+}
+
+ResultCode VMManager::HeapFree(VAddr target, u64 size) {
+    if (target < GetHeapRegionBaseAddress() || target + size > GetHeapRegionEndAddress() ||
+        target + size < target) {
+        return ERR_INVALID_ADDRESS;
+    }
+
+    if (size == 0) {
+        return RESULT_SUCCESS;
+    }
+
+    const ResultCode result = UnmapRange(target, size);
+    if (result.IsError()) {
+        return result;
+    }
+
+    heap_used -= size;
+    return RESULT_SUCCESS;
+}
+
+ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
+    const auto vma = FindVMA(src_addr);
+
+    ASSERT_MSG(vma != vma_map.end(), "Invalid memory address");
+    ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
+
+    // The returned VMA might be a bigger one encompassing the desired address.
+    const auto vma_offset = src_addr - vma->first;
+    ASSERT_MSG(vma_offset + size <= vma->second.size,
+               "Shared memory exceeds bounds of mapped block");
+
+    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));
+    // Protect mirror with permissions from old region
+    Reprotect(new_vma, vma->second.permissions);
+    // Remove permissions from old region
+    Reprotect(vma, VMAPermission::None);
+
+    return RESULT_SUCCESS;
+}
+
 void VMManager::RefreshMemoryBlockMappings(const std::vector<u8>* block) {
     // If this ever proves to have a noticeable performance impact, allow users of the function to
     // specify a specific range of addresses to limit the scan to.
@@ -495,8 +574,7 @@ u64 VMManager::GetTotalMemoryUsage() const {
 }
 
 u64 VMManager::GetTotalHeapUsage() const {
-    LOG_WARNING(Kernel, "(STUBBED) called");
-    return 0x0;
+    return heap_used;
 }
 
 VAddr VMManager::GetAddressSpaceBaseAddress() const {

src/core/hle/kernel/vm_manager.h

@@ -186,6 +186,11 @@ public:
     /// Changes the permissions of a range of addresses, splitting VMAs as necessary.
     ResultCode ReprotectRange(VAddr target, u64 size, VMAPermission new_perms);
 
+    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);
+
     /**
      * Scans all VMAs and updates the page table range of any that use the given vector as backing
      * memory. This should be called after any operation that causes reallocation of the vector.
@@ -343,5 +348,15 @@ private:
 
     VAddr tls_io_region_base = 0;
     VAddr tls_io_region_end = 0;
+
+    // Memory used to back the allocations in the regular heap. A single vector is used to cover
+    // the entire virtual address space extents that bound the allocations, including any holes.
+    // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
+    // in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
+    std::shared_ptr<std::vector<u8>> heap_memory;
+    // The left/right bounds of the address space covered by heap_memory.
+    VAddr heap_start = 0;
+    VAddr heap_end = 0;
+    u64 heap_used = 0;
 };
 } // namespace Kernel

src/core/hle/result.h

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

src/core/hle/service/acc/acc.cpp

@@ -242,6 +242,30 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
     LOG_DEBUG(Service_ACC, "called");
 }
 
+void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+    // A u8 is passed into this function which we can safely ignore. It's to determine if we have
+    // access to use the network or not by the looks of it
+    IPC::ResponseBuilder rb{ctx, 6};
+    if (profile_manager->GetUserCount() != 1) {
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u128>(INVALID_UUID);
+        return;
+    }
+
+    const auto user_list = profile_manager->GetAllUsers();
+    if (std::all_of(user_list.begin(), user_list.end(),
+                    [](const auto& user) { return user.uuid == INVALID_UUID; })) {
+        rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
+        rb.PushRaw<u128>(INVALID_UUID);
+        return;
+    }
+
+    // Select the first user we have
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<u128>(profile_manager->GetUser(0)->uuid);
+}
+
 Module::Interface::Interface(std::shared_ptr<Module> module,
                              std::shared_ptr<ProfileManager> profile_manager, const char* name)
     : ServiceFramework(name), module(std::move(module)),

src/core/hle/service/acc/acc.h

@@ -27,6 +27,7 @@ public:
         void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
         void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
         void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
+        void TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;

src/core/hle/service/acc/acc_su.cpp

@@ -17,7 +17,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {5, &ACC_SU::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
         {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-        {51, nullptr, "TrySelectUserWithoutInteraction"},
+        {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},

src/core/hle/service/acc/acc_u0.cpp

@@ -17,7 +17,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {5, &ACC_U0::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
         {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-        {51, nullptr, "TrySelectUserWithoutInteraction"},
+        {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},

src/core/hle/service/acc/acc_u1.cpp

@@ -17,7 +17,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {5, &ACC_U1::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
         {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-        {51, nullptr, "TrySelectUserWithoutInteraction"},
+        {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},

src/core/hle/service/acc/profile_manager.cpp

@@ -2,8 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cstring>
 #include <random>
 
+#include <fmt/format.h>
+
 #include "common/file_util.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
@@ -39,6 +42,19 @@ UUID UUID::Generate() {
     return UUID{distribution(gen), distribution(gen)};
 }
 
+std::string UUID::Format() const {
+    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
+}
+
+std::string UUID::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]);
+}
+
 ProfileManager::ProfileManager() {
     ParseUserSaveFile();
 
@@ -195,7 +211,7 @@ 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) != std::nullopt;
+    return GetUserIndex(uuid).has_value();
 }
 
 bool ProfileManager::UserExistsIndex(std::size_t index) const {
@@ -325,11 +341,12 @@ void ProfileManager::ParseUserSaveFile() {
         return;
     }
 
-    for (std::size_t i = 0; i < MAX_USERS; ++i) {
-        const auto& user = data.users[i];
+    for (const auto& user : data.users) {
+        if (user.uuid == UUID(INVALID_UUID)) {
+            continue;
+        }
 
-        if (user.uuid != UUID(INVALID_UUID))
-            AddUser({user.uuid, user.username, user.timestamp, {}, false});
+        AddUser({user.uuid, user.username, user.timestamp, {}, false});
     }
 
     std::stable_partition(profiles.begin(), profiles.end(),

src/core/hle/service/acc/profile_manager.h

@@ -42,22 +42,14 @@ struct UUID {
     void Invalidate() {
         uuid = INVALID_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]);
-    }
+    std::string Format() const;
+    std::string FormatSwitch() const;
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
-using ProfileUsername = std::array<u8, 0x20>;
+constexpr std::size_t profile_username_size = 32;
+using ProfileUsername = std::array<u8, profile_username_size>;
 using ProfileData = std::array<u8, MAX_DATA>;
 using UserIDArray = std::array<UUID, MAX_USERS>;
 

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

@@ -203,8 +203,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
 ISelfController::~ISelfController() = default;
 
 void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
-    // Takes 3 input u8s with each field located immediately after the previous u8, these are
-    // bool flags. No output.
+    // Takes 3 input u8s with each field located immediately after the previous
+    // u8, these are bool flags. No output.
 
     IPC::RequestParser rp{ctx};
 
@@ -258,8 +258,8 @@ void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestCont
 }
 
 void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx) {
-    // Takes 3 input u8s with each field located immediately after the previous u8, these are
-    // bool flags. No output.
+    // Takes 3 input u8s with each field located immediately after the previous
+    // u8, these are bool flags. No output.
     IPC::RequestParser rp{ctx};
 
     bool enabled = rp.Pop<bool>();
@@ -302,8 +302,8 @@ void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& c
 }
 
 void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx) {
-    // TODO(Subv): Find out how AM determines the display to use, for now just create the layer
-    // in the Default display.
+    // TODO(Subv): Find out how AM determines the display to use, for now just
+    // create the layer in the Default display.
     u64 display_id = nvflinger->OpenDisplay("Default");
     u64 layer_id = nvflinger->CreateLayer(display_id);
 
@@ -338,7 +338,54 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
     LOG_WARNING(Service_AM, "(STUBBED) called");
 }
 
-ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
+AppletMessageQueue::AppletMessageQueue() {
+    auto& kernel = Core::System::GetInstance().Kernel();
+    on_new_message = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky,
+                                           "AMMessageQueue:OnMessageRecieved");
+    on_operation_mode_changed = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                      "AMMessageQueue:OperationModeChanged");
+}
+
+AppletMessageQueue::~AppletMessageQueue() = default;
+
+const Kernel::SharedPtr<Kernel::Event>& AppletMessageQueue::GetMesssageRecieveEvent() const {
+    return on_new_message;
+}
+
+const Kernel::SharedPtr<Kernel::Event>& AppletMessageQueue::GetOperationModeChangedEvent() const {
+    return on_operation_mode_changed;
+}
+
+void AppletMessageQueue::PushMessage(AppletMessage msg) {
+    messages.push(msg);
+    on_new_message->Signal();
+}
+
+AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() {
+    if (messages.empty()) {
+        on_new_message->Clear();
+        return AppletMessage::NoMessage;
+    }
+    auto msg = messages.front();
+    messages.pop();
+    if (messages.empty()) {
+        on_new_message->Clear();
+    }
+    return msg;
+}
+
+std::size_t AppletMessageQueue::GetMessageCount() const {
+    return messages.size();
+}
+
+void AppletMessageQueue::OperationModeChanged() {
+    PushMessage(AppletMessage::OperationModeChanged);
+    PushMessage(AppletMessage::PerformanceModeChanged);
+    on_operation_mode_changed->Signal();
+}
+
+ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)
+    : ServiceFramework("ICommonStateGetter"), msg_queue(std::move(msg_queue)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
@@ -388,21 +435,19 @@ void ICommonStateGetter::GetBootMode(Kernel::HLERequestContext& ctx) {
 }
 
 void ICommonStateGetter::GetEventHandle(Kernel::HLERequestContext& ctx) {
-    event->Signal();
-
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(event);
+    rb.PushCopyObjects(msg_queue->GetMesssageRecieveEvent());
 
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
 }
 
 void ICommonStateGetter::ReceiveMessage(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(15);
+    rb.PushEnum<AppletMessageQueue::AppletMessage>(msg_queue->PopMessage());
 
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
 }
 
 void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
@@ -414,13 +459,11 @@ void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
 }
 
 void ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent(Kernel::HLERequestContext& ctx) {
-    event->Signal();
-
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(event);
+    rb.PushCopyObjects(msg_queue->GetOperationModeChangedEvent());
 
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
 }
 
 void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx) {
@@ -444,7 +487,7 @@ void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
     rb.Push(static_cast<u8>(use_docked_mode ? OperationMode::Docked : OperationMode::Handheld));
 
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
 }
 
 void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
@@ -454,7 +497,7 @@ void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
     rb.Push(static_cast<u32>(use_docked_mode ? APM::PerformanceMode::Docked
                                              : APM::PerformanceMode::Handheld));
 
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
 }
 
 class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
@@ -690,7 +733,7 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {70, nullptr, "RequestToShutdown"},
         {71, nullptr, "RequestToReboot"},
         {80, nullptr, "ExitAndRequestToShowThanksMessage"},
-        {90, nullptr, "EnableApplicationCrashReport"},
+        {90, &IApplicationFunctions::EnableApplicationCrashReport, "EnableApplicationCrashReport"},
         {100, nullptr, "InitializeApplicationCopyrightFrameBuffer"},
         {101, nullptr, "SetApplicationCopyrightImage"},
         {102, nullptr, "SetApplicationCopyrightVisibility"},
@@ -709,6 +752,12 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
 
 IApplicationFunctions::~IApplicationFunctions() = default;
 
+void IApplicationFunctions::EnableApplicationCrashReport(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+}
+
 void IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed(
     Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2};
@@ -743,7 +792,7 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
 
     Account::ProfileManager profile_manager{};
     const auto uuid = profile_manager.GetUser(Settings::values.current_user);
-    ASSERT(uuid != std::nullopt);
+    ASSERT(uuid);
     params.current_user = uuid->uuid;
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -778,7 +827,8 @@ void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
 
 void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
     // Takes an input u32 Result, no output.
-    // For example, in some cases official apps use this with error 0x2A2 then uses svcBreak.
+    // For example, in some cases official apps use this with error 0x2A2 then
+    // uses svcBreak.
 
     IPC::RequestParser rp{ctx};
     u32 result = rp.Pop<u32>();
@@ -840,8 +890,12 @@ void IApplicationFunctions::GetPseudoDeviceId(Kernel::HLERequestContext& ctx) {
 
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nvflinger) {
-    std::make_shared<AppletAE>(nvflinger)->InstallAsService(service_manager);
-    std::make_shared<AppletOE>(nvflinger)->InstallAsService(service_manager);
+    auto message_queue = std::make_shared<AppletMessageQueue>();
+    message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged); // Needed on
+                                                                                      // game boot
+
+    std::make_shared<AppletAE>(nvflinger, message_queue)->InstallAsService(service_manager);
+    std::make_shared<AppletOE>(nvflinger, message_queue)->InstallAsService(service_manager);
     std::make_shared<IdleSys>()->InstallAsService(service_manager);
     std::make_shared<OMM>()->InstallAsService(service_manager);
     std::make_shared<SPSM>()->InstallAsService(service_manager);

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

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <queue>
 #include "core/hle/service/service.h"
 
 namespace Kernel {
@@ -39,6 +40,31 @@ enum SystemLanguage {
     TraditionalChinese = 16,
 };
 
+class AppletMessageQueue {
+public:
+    enum class AppletMessage : u32 {
+        NoMessage = 0,
+        FocusStateChanged = 15,
+        OperationModeChanged = 30,
+        PerformanceModeChanged = 31,
+    };
+
+    AppletMessageQueue();
+    ~AppletMessageQueue();
+
+    const Kernel::SharedPtr<Kernel::Event>& GetMesssageRecieveEvent() const;
+    const Kernel::SharedPtr<Kernel::Event>& GetOperationModeChangedEvent() const;
+    void PushMessage(AppletMessage msg);
+    AppletMessage PopMessage();
+    std::size_t GetMessageCount() const;
+    void OperationModeChanged();
+
+private:
+    std::queue<AppletMessage> messages;
+    Kernel::SharedPtr<Kernel::Event> on_new_message;
+    Kernel::SharedPtr<Kernel::Event> on_operation_mode_changed;
+};
+
 class IWindowController final : public ServiceFramework<IWindowController> {
 public:
     IWindowController();
@@ -102,7 +128,7 @@ private:
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
 public:
-    ICommonStateGetter();
+    explicit ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue);
     ~ICommonStateGetter() override;
 
 private:
@@ -126,6 +152,7 @@ private:
     void GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx);
 
     Kernel::SharedPtr<Kernel::Event> event;
+    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 class ILibraryAppletCreator final : public ServiceFramework<ILibraryAppletCreator> {
@@ -158,6 +185,7 @@ private:
     void EndBlockingHomeButtonShortAndLongPressed(Kernel::HLERequestContext& ctx);
     void BeginBlockingHomeButton(Kernel::HLERequestContext& ctx);
     void EndBlockingHomeButton(Kernel::HLERequestContext& ctx);
+    void EnableApplicationCrashReport(Kernel::HLERequestContext& ctx);
 };
 
 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {

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

@@ -12,8 +12,10 @@ namespace Service::AM {
 
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
-    explicit ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-        : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)) {
+    explicit ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                                 std::shared_ptr<AppletMessageQueue> msg_queue)
+        : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)),
+          msg_queue(std::move(msg_queue)) {
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &ILibraryAppletProxy::GetSelfController, "GetSelfController"},
@@ -32,7 +34,7 @@ private:
     void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>();
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
         LOG_DEBUG(Service_AM, "called");
     }
 
@@ -93,12 +95,15 @@ private:
     }
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 class ISystemAppletProxy final : public ServiceFramework<ISystemAppletProxy> {
 public:
-    explicit ISystemAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-        : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)) {
+    explicit ISystemAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                                std::shared_ptr<AppletMessageQueue> msg_queue)
+        : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)),
+          msg_queue(std::move(msg_queue)) {
         static const FunctionInfo functions[] = {
             {0, &ISystemAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &ISystemAppletProxy::GetSelfController, "GetSelfController"},
@@ -119,7 +124,7 @@ private:
     void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>();
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
         LOG_DEBUG(Service_AM, "called");
     }
 
@@ -186,31 +191,34 @@ private:
         LOG_DEBUG(Service_AM, "called");
     }
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 void AppletAE::OpenSystemAppletProxy(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger);
+    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger, msg_queue);
     LOG_DEBUG(Service_AM, "called");
 }
 
 void AppletAE::OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger);
+    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue);
     LOG_DEBUG(Service_AM, "called");
 }
 
 void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger);
+    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue);
     LOG_DEBUG(Service_AM, "called");
 }
 
-AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-    : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)) {
+AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                   std::shared_ptr<AppletMessageQueue> msg_queue)
+    : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)),
+      msg_queue(std::move(msg_queue)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},
@@ -228,4 +236,8 @@ AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
 
 AppletAE::~AppletAE() = default;
 
+const std::shared_ptr<AppletMessageQueue>& AppletAE::GetMessageQueue() const {
+    return msg_queue;
+}
+
 } // namespace Service::AM

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

@@ -17,15 +17,19 @@ namespace AM {
 
 class AppletAE final : public ServiceFramework<AppletAE> {
 public:
-    explicit AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
+    explicit AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                      std::shared_ptr<AppletMessageQueue> msg_queue);
     ~AppletAE() override;
 
+    const std::shared_ptr<AppletMessageQueue>& GetMessageQueue() const;
+
 private:
     void OpenSystemAppletProxy(Kernel::HLERequestContext& ctx);
     void OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx);
     void OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 } // namespace AM

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

@@ -12,8 +12,10 @@ namespace Service::AM {
 
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
-    explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-        : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)) {
+    explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                               std::shared_ptr<AppletMessageQueue> msg_queue)
+        : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)),
+          msg_queue(std::move(msg_queue)) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IApplicationProxy::GetCommonStateGetter, "GetCommonStateGetter"},
@@ -70,7 +72,7 @@ private:
     void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>();
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
         LOG_DEBUG(Service_AM, "called");
     }
 
@@ -89,17 +91,20 @@ private:
     }
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IApplicationProxy>(nvflinger);
+    rb.PushIpcInterface<IApplicationProxy>(nvflinger, msg_queue);
     LOG_DEBUG(Service_AM, "called");
 }
 
-AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-    : ServiceFramework("appletOE"), nvflinger(std::move(nvflinger)) {
+AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                   std::shared_ptr<AppletMessageQueue> msg_queue)
+    : ServiceFramework("appletOE"), nvflinger(std::move(nvflinger)),
+      msg_queue(std::move(msg_queue)) {
     static const FunctionInfo functions[] = {
         {0, &AppletOE::OpenApplicationProxy, "OpenApplicationProxy"},
     };
@@ -108,4 +113,8 @@ AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
 
 AppletOE::~AppletOE() = default;
 
+const std::shared_ptr<AppletMessageQueue>& AppletOE::GetMessageQueue() const {
+    return msg_queue;
+}
+
 } // namespace Service::AM

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

@@ -17,13 +17,17 @@ namespace AM {
 
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
-    explicit AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
+    explicit AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+                      std::shared_ptr<AppletMessageQueue> msg_queue);
     ~AppletOE() override;
 
+    const std::shared_ptr<AppletMessageQueue>& GetMessageQueue() const;
+
 private:
     void OpenApplicationProxy(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 } // namespace AM

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::RequestUpdate, "RequestUpdate"},
+            {4, &IAudioRenderer::RequestUpdateImpl, "RequestUpdate"},
             {5, &IAudioRenderer::Start, "Start"},
             {6, &IAudioRenderer::Stop, "Stop"},
             {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {8, nullptr, "SetRenderingTimeLimit"},
-            {9, nullptr, "GetRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAuto"},
+            {8, &IAudioRenderer::SetRenderingTimeLimit, "SetRenderingTimeLimit"},
+            {9, &IAudioRenderer::GetRenderingTimeLimit, "GetRenderingTimeLimit"},
+            {10, &IAudioRenderer::RequestUpdateImpl, "RequestUpdateAuto"},
             {11, nullptr, "ExecuteAudioRendererRendering"},
         };
         // clang-format on
@@ -79,7 +79,7 @@ private:
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void RequestUpdate(Kernel::HLERequestContext& ctx) {
+    void RequestUpdateImpl(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -110,8 +110,29 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
+    void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        rendering_time_limit_percent = rp.Pop<u32>();
+        ASSERT(rendering_time_limit_percent >= 0 && rendering_time_limit_percent <= 100);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+
+        LOG_DEBUG(Service_Audio, "called. rendering_time_limit_percent={}",
+                  rendering_time_limit_percent);
+    }
+
+    void GetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Audio, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(rendering_time_limit_percent);
+    }
+
     Kernel::SharedPtr<Kernel::Event> system_event;
     std::unique_ptr<AudioCore::AudioRenderer> renderer;
+    u32 rendering_time_limit_percent = 100;
 };
 
 class IAudioDevice final : public ServiceFramework<IAudioDevice> {

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<u64>(performance);
         rb.Push<u32>(sample_count);
+        rb.Push<u64>(performance);
         ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
     }
 
@@ -161,7 +161,7 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
     ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
 
     std::size_t worker_sz = WorkerBufferSize(channel_count);
-    ASSERT_MSG(buffer_sz < worker_sz, "Worker buffer too large");
+    ASSERT_MSG(buffer_sz >= worker_sz, "Worker buffer too large");
     std::unique_ptr<OpusDecoder, OpusDeleter> decoder{
         static_cast<OpusDecoder*>(operator new(worker_sz))};
     if (opus_decoder_init(decoder.get(), sample_rate, channel_count)) {

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

@@ -2,12 +2,49 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
+#include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::BtDrv {
 
+class Bt final : public ServiceFramework<Bt> {
+public:
+    explicit Bt() : ServiceFramework{"bt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown0"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
+            {9, &Bt::RegisterEvent, "RegisterEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+private:
+    void RegisterEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        register_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(register_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    Kernel::SharedPtr<Kernel::Event> register_event;
+};
+
 class BtDrv final : public ServiceFramework<BtDrv> {
 public:
     explicit BtDrv() : ServiceFramework{"btdrv"} {
@@ -67,6 +104,7 @@ public:
 
 void InstallInterfaces(SM::ServiceManager& sm) {
     std::make_shared<BtDrv>()->InstallAsService(sm);
+    std::make_shared<Bt>()->InstallAsService(sm);
 }
 
 } // namespace Service::BtDrv

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

@@ -6,13 +6,118 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/btm/btm.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::BTM {
 
+class IBtmUserCore final : public ServiceFramework<IBtmUserCore> {
+public:
+    explicit IBtmUserCore() : ServiceFramework{"IBtmUserCore"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IBtmUserCore::GetScanEvent, "GetScanEvent"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
+            {9, nullptr, "Unknown9"},
+            {10, nullptr, "Unknown10"},
+            {17, &IBtmUserCore::GetConnectionEvent, "GetConnectionEvent"},
+            {18, nullptr, "Unknown18"},
+            {19, nullptr, "Unknown19"},
+            {20, nullptr, "Unknown20"},
+            {21, nullptr, "Unknown21"},
+            {22, nullptr, "Unknown22"},
+            {23, nullptr, "Unknown23"},
+            {24, nullptr, "Unknown24"},
+            {25, nullptr, "Unknown25"},
+            {26, &IBtmUserCore::GetDiscoveryEvent, "AcquireBleServiceDiscoveryEventImpl"},
+            {27, nullptr, "Unknown27"},
+            {28, nullptr, "Unknown28"},
+            {29, nullptr, "Unknown29"},
+            {30, nullptr, "Unknown30"},
+            {31, nullptr, "Unknown31"},
+            {32, nullptr, "Unknown32"},
+            {33, &IBtmUserCore::GetConfigEvent, "GetConfigEvent"},
+            {34, nullptr, "Unknown34"},
+            {35, nullptr, "Unknown35"},
+            {36, nullptr, "Unknown36"},
+            {37, nullptr, "Unknown37"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetScanEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        scan_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(scan_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    void GetConnectionEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        connection_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+                                                 "IBtmUserCore:ConnectionEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(connection_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        service_discovery =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(service_discovery);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    void GetConfigEvent(Kernel::HLERequestContext& ctx) {
+        auto& kernel = Core::System::GetInstance().Kernel();
+        config_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent");
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(config_event);
+        LOG_WARNING(Service_BTM, "(STUBBED) called");
+    }
+    Kernel::SharedPtr<Kernel::Event> scan_event;
+    Kernel::SharedPtr<Kernel::Event> connection_event;
+    Kernel::SharedPtr<Kernel::Event> service_discovery;
+    Kernel::SharedPtr<Kernel::Event> config_event;
+};
+
+class BTM_USR final : public ServiceFramework<BTM_USR> {
+public:
+    explicit BTM_USR() : ServiceFramework{"btm:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &BTM_USR::GetCoreImpl, "GetCoreImpl"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetCoreImpl(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IBtmUserCore>();
+        LOG_DEBUG(Service_BTM, "called");
+    }
+};
+
 class BTM final : public ServiceFramework<BTM> {
 public:
     explicit BTM() : ServiceFramework{"btm"} {
@@ -116,6 +221,7 @@ void InstallInterfaces(SM::ServiceManager& sm) {
     std::make_shared<BTM>()->InstallAsService(sm);
     std::make_shared<BTM_DBG>()->InstallAsService(sm);
     std::make_shared<BTM_SYS>()->InstallAsService(sm);
+    std::make_shared<BTM_USR>()->InstallAsService(sm);
 }
 
 } // namespace Service::BTM

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

@@ -303,25 +303,42 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
               static_cast<u8>(space), save_struct.DebugInfo());
 
     if (save_data_factory == nullptr) {
-        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound);
+        return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
     return save_data_factory->Open(space, save_struct);
 }
 
+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 MakeResult(save_data_factory->GetSaveDataSpaceDirectory(space));
+}
+
 ResultVal<FileSys::VirtualDir> OpenSDMC() {
     LOG_TRACE(Service_FS, "Opening SDMC");
 
     if (sdmc_factory == nullptr) {
-        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SdCardNotFound);
+        return FileSys::ERROR_SD_CARD_NOT_FOUND;
     }
 
     return sdmc_factory->Open();
 }
 
-std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
-    return std::make_unique<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
-        GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
+std::shared_ptr<FileSys::RegisteredCacheUnion> registered_cache_union;
+
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
+    if (registered_cache_union == nullptr) {
+        registered_cache_union =
+            std::make_shared<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
+                GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
+    }
+
+    return registered_cache_union;
 }
 
 FileSys::RegisteredCache* GetSystemNANDContents() {
@@ -360,6 +377,15 @@ 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;
@@ -373,13 +399,21 @@ 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);
-    if (save_data_factory == nullptr)
+    if (bis_factory == nullptr) {
+        bis_factory =
+            std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_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

@@ -45,15 +45,17 @@ ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId stora
                                           FileSys::ContentRecordType type);
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
                                             FileSys::SaveDataDescriptor save_struct);
+ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 
-std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
+std::shared_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

@@ -11,6 +11,7 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/file_sys/directory.h"
@@ -62,12 +63,12 @@ private:
         // Error checking
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
+            rb.Push(FileSys::ERROR_INVALID_SIZE);
             return;
         }
         if (offset < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
+            rb.Push(FileSys::ERROR_INVALID_OFFSET);
             return;
         }
 
@@ -107,12 +108,12 @@ private:
         // Error checking
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
+            rb.Push(FileSys::ERROR_INVALID_SIZE);
             return;
         }
         if (offset < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
+            rb.Push(FileSys::ERROR_INVALID_OFFSET);
             return;
         }
 
@@ -138,12 +139,12 @@ private:
         // Error checking
         if (length < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidLength));
+            rb.Push(FileSys::ERROR_INVALID_SIZE);
             return;
         }
         if (offset < 0) {
             IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(ErrorModule::FS, ErrorDescription::InvalidOffset));
+            rb.Push(FileSys::ERROR_INVALID_OFFSET);
             return;
         }
 
@@ -273,8 +274,8 @@ public:
             {0, &IFileSystem::CreateFile, "CreateFile"},
             {1, &IFileSystem::DeleteFile, "DeleteFile"},
             {2, &IFileSystem::CreateDirectory, "CreateDirectory"},
-            {3, nullptr, "DeleteDirectory"},
-            {4, nullptr, "DeleteDirectoryRecursively"},
+            {3, &IFileSystem::DeleteDirectory, "DeleteDirectory"},
+            {4, &IFileSystem::DeleteDirectoryRecursively, "DeleteDirectoryRecursively"},
             {5, &IFileSystem::RenameFile, "RenameFile"},
             {6, nullptr, "RenameDirectory"},
             {7, &IFileSystem::GetEntryType, "GetEntryType"},
@@ -329,6 +330,30 @@ public:
         rb.Push(backend.CreateDirectory(name));
     }
 
+    void DeleteDirectory(Kernel::HLERequestContext& ctx) {
+        const IPC::RequestParser rp{ctx};
+
+        const auto file_buffer = ctx.ReadBuffer();
+        std::string name = Common::StringFromBuffer(file_buffer);
+
+        LOG_DEBUG(Service_FS, "called directory {}", name);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(backend.DeleteDirectory(name));
+    }
+
+    void DeleteDirectoryRecursively(Kernel::HLERequestContext& ctx) {
+        const IPC::RequestParser rp{ctx};
+
+        const auto file_buffer = ctx.ReadBuffer();
+        std::string name = Common::StringFromBuffer(file_buffer);
+
+        LOG_DEBUG(Service_FS, "called directory {}", name);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(backend.DeleteDirectoryRecursively(name));
+    }
+
     void RenameFile(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -427,7 +452,147 @@ private:
     VfsDirectoryServiceWrapper backend;
 };
 
+class ISaveDataInfoReader final : public ServiceFramework<ISaveDataInfoReader> {
+public:
+    explicit ISaveDataInfoReader(FileSys::SaveDataSpaceId space)
+        : ServiceFramework("ISaveDataInfoReader") {
+        static const FunctionInfo functions[] = {
+            {0, &ISaveDataInfoReader::ReadSaveDataInfo, "ReadSaveDataInfo"},
+        };
+        RegisterHandlers(functions);
+
+        FindAllSaves(space);
+    }
+
+    void ReadSaveDataInfo(Kernel::HLERequestContext& ctx) {
+        // Calculate how many entries we can fit in the output buffer
+        const u64 count_entries = ctx.GetWriteBufferSize() / sizeof(SaveDataInfo);
+
+        // Cap at total number of entries.
+        const u64 actual_entries = std::min(count_entries, info.size() - next_entry_index);
+
+        // Determine data start and end
+        const auto* begin = reinterpret_cast<u8*>(info.data() + next_entry_index);
+        const auto* end = reinterpret_cast<u8*>(info.data() + next_entry_index + actual_entries);
+        const auto range_size = static_cast<std::size_t>(std::distance(begin, end));
+
+        next_entry_index += actual_entries;
+
+        // Write the data to memory
+        ctx.WriteBuffer(begin, range_size);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(static_cast<u32>(actual_entries));
+    }
+
+private:
+    static u64 stoull_be(std::string_view str) {
+        if (str.size() != 16)
+            return 0;
+
+        const auto bytes = Common::HexStringToArray<0x8>(str);
+        u64 out{};
+        std::memcpy(&out, bytes.data(), sizeof(u64));
+
+        return Common::swap64(out);
+    }
+
+    void FindAllSaves(FileSys::SaveDataSpaceId space) {
+        const auto save_root = OpenSaveDataSpace(space);
+        ASSERT(save_root.Succeeded());
+
+        for (const auto& type : (*save_root)->GetSubdirectories()) {
+            if (type->GetName() == "save") {
+                for (const auto& save_id : type->GetSubdirectories()) {
+                    for (const auto& user_id : save_id->GetSubdirectories()) {
+                        const auto save_id_numeric = stoull_be(save_id->GetName());
+                        auto user_id_numeric = Common::HexStringToArray<0x10>(user_id->GetName());
+                        std::reverse(user_id_numeric.begin(), user_id_numeric.end());
+
+                        if (save_id_numeric != 0) {
+                            // System Save Data
+                            info.emplace_back(SaveDataInfo{
+                                0,
+                                space,
+                                FileSys::SaveDataType::SystemSaveData,
+                                {},
+                                user_id_numeric,
+                                save_id_numeric,
+                                0,
+                                user_id->GetSize(),
+                                {},
+                            });
+
+                            continue;
+                        }
+
+                        for (const auto& title_id : user_id->GetSubdirectories()) {
+                            const auto device =
+                                std::all_of(user_id_numeric.begin(), user_id_numeric.end(),
+                                            [](u8 val) { return val == 0; });
+                            info.emplace_back(SaveDataInfo{
+                                0,
+                                space,
+                                device ? FileSys::SaveDataType::DeviceSaveData
+                                       : FileSys::SaveDataType::SaveData,
+                                {},
+                                user_id_numeric,
+                                save_id_numeric,
+                                stoull_be(title_id->GetName()),
+                                title_id->GetSize(),
+                                {},
+                            });
+                        }
+                    }
+                }
+            } else if (space == FileSys::SaveDataSpaceId::TemporaryStorage) {
+                // Temporary Storage
+                for (const auto& user_id : type->GetSubdirectories()) {
+                    for (const auto& title_id : user_id->GetSubdirectories()) {
+                        if (!title_id->GetFiles().empty() ||
+                            !title_id->GetSubdirectories().empty()) {
+                            auto user_id_numeric =
+                                Common::HexStringToArray<0x10>(user_id->GetName());
+                            std::reverse(user_id_numeric.begin(), user_id_numeric.end());
+
+                            info.emplace_back(SaveDataInfo{
+                                0,
+                                space,
+                                FileSys::SaveDataType::TemporaryStorage,
+                                {},
+                                user_id_numeric,
+                                stoull_be(type->GetName()),
+                                stoull_be(title_id->GetName()),
+                                title_id->GetSize(),
+                                {},
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    struct SaveDataInfo {
+        u64_le save_id_unknown;
+        FileSys::SaveDataSpaceId space;
+        FileSys::SaveDataType type;
+        INSERT_PADDING_BYTES(0x6);
+        std::array<u8, 0x10> user_id;
+        u64_le save_id;
+        u64_le title_id;
+        u64_le save_image_size;
+        INSERT_PADDING_BYTES(0x28);
+    };
+    static_assert(sizeof(SaveDataInfo) == 0x60, "SaveDataInfo has incorrect size.");
+
+    std::vector<SaveDataInfo> info;
+    u64 next_entry_index = 0;
+};
+
 FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "MountContent"},
         {1, &FSP_SRV::Initialize, "Initialize"},
@@ -461,7 +626,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {58, nullptr, "ReadSaveDataFileSystemExtraData"},
         {59, nullptr, "WriteSaveDataFileSystemExtraData"},
         {60, nullptr, "OpenSaveDataInfoReader"},
-        {61, nullptr, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
+        {61, &FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
         {62, nullptr, "OpenCacheStorageList"},
         {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
         {65, nullptr, "UpdateSaveDataMacForDebug"},
@@ -520,6 +685,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {1009, nullptr, "GetAndClearMemoryReportInfo"},
         {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
     };
+    // clang-format on
     RegisterHandlers(functions);
 }
 
@@ -578,7 +744,7 @@ void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
 
     if (dir.Failed()) {
         IPC::ResponseBuilder rb{ctx, 2, 0, 0};
-        rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
+        rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
         return;
     }
 
@@ -594,6 +760,15 @@ void FSP_SRV::OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx) {
     MountSaveData(ctx);
 }
 
+void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto space = rp.PopRaw<FileSys::SaveDataSpaceId>();
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<ISaveDataInfoReader>(std::make_shared<ISaveDataInfoReader>(space));
+}
+
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
@@ -661,7 +836,7 @@ void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
               static_cast<u8>(storage_id), title_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
+    rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
 }
 
 } // namespace Service::FileSystem

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

@@ -25,6 +25,7 @@ private:
     void CreateSaveData(Kernel::HLERequestContext& ctx);
     void MountSaveData(Kernel::HLERequestContext& ctx);
     void OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx);
+    void OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);

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

@@ -40,6 +40,29 @@ 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;
 
@@ -288,10 +311,11 @@ 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.IsConnected.Assign(1);
-            if (!Settings::values.use_docked_mode) {
-                handheld_entry.connection_status.IsWired.Assign(1);
-            }
+            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.pad_states.raw = pad_state.raw;
             handheld_entry.l_stick = lstick_entry;
             handheld_entry.r_stick = rstick_entry;
@@ -310,6 +334,7 @@ void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
             dual_entry.pad_states.raw = pad_state.raw;
             dual_entry.l_stick = lstick_entry;
             dual_entry.r_stick = rstick_entry;
+            break;
         case NPadControllerType::JoyLeft:
             left_entry.connection_status.raw = 0;
 
@@ -370,16 +395,30 @@ 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)) {
-            controller.type = DecideBestController(PREFERRED_CONTROLLER);
-            InitNewlyAddedControler(i);
+            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;
         }
     }
+    if (had_controller_update) {
+        styleset_changed_event->Signal();
+    }
 }
 
 void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
@@ -392,8 +431,10 @@ std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const {
 }
 
 void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) {
+    styleset_changed_event->Signal();
     hold_type = joy_hold_type;
 }
+
 Controller_NPad::NpadHoldType Controller_NPad::GetHoldType() const {
     return hold_type;
 }
@@ -427,6 +468,9 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
 }
 
 Kernel::SharedPtr<Kernel::Event> Controller_NPad::GetStyleSetChangedEvent() const {
+    // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should
+    // be signalled at least once, and signaled after a new controller is connected?
+    styleset_changed_event->Signal();
     return styleset_changed_event;
 }
 
@@ -452,15 +496,11 @@ void Controller_NPad::AddNewController(NPadControllerType controller) {
 }
 
 void Controller_NPad::ConnectNPad(u32 npad_id) {
-    if (npad_id >= connected_controllers.size())
-        return;
-    connected_controllers[npad_id].is_connected = true;
+    connected_controllers[NPadIdToIndex(npad_id)].is_connected = true;
 }
 
 void Controller_NPad::DisconnectNPad(u32 npad_id) {
-    if (npad_id >= connected_controllers.size())
-        return;
-    connected_controllers[npad_id].is_connected = false;
+    connected_controllers[NPadIdToIndex(npad_id)].is_connected = false;
 }
 
 Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {

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

@@ -96,6 +96,8 @@ public:
         // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
         CoreTiming::ScheduleEvent(pad_update_ticks, pad_update_event);
+
+        ReloadInputDevices();
     }
 
     void ActivateController(HidController controller) {
@@ -284,10 +286,10 @@ public:
             {519, nullptr, "GetPalmaOperationResult"},
             {520, nullptr, "ReadPalmaPlayLog"},
             {521, nullptr, "ResetPalmaPlayLog"},
-            {522, nullptr, "SetIsPalmaAllConnectable"},
+            {522, &Hid::SetIsPalmaAllConnectable, "SetIsPalmaAllConnectable"},
             {523, nullptr, "SetIsPalmaPairedConnectable"},
             {524, nullptr, "PairPalma"},
-            {525, nullptr, "SetPalmaBoostMode"},
+            {525, &Hid::SetPalmaBoostMode, "SetPalmaBoostMode"},
             {1000, nullptr, "SetNpadCommunicationMode"},
             {1001, nullptr, "GetNpadCommunicationMode"},
         };
@@ -594,6 +596,18 @@ 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/nfp/nfp.cpp

@@ -212,7 +212,7 @@ private:
         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 = amiibo.uuid;
         tag_info.uuid_length = static_cast<u8>(tag_info.uuid.size());
 
         tag_info.protocol = 1; // TODO(ogniK): Figure out actual values

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

@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/file_sys/control_metadata.h"
+#include "core/file_sys/patch_manager.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/ns/ns.h"
@@ -118,7 +121,7 @@ public:
             {305, nullptr, "TerminateSystemApplet"},
             {306, nullptr, "LaunchOverlayApplet"},
             {307, nullptr, "TerminateOverlayApplet"},
-            {400, nullptr, "GetApplicationControlData"},
+            {400, &IApplicationManagerInterface::GetApplicationControlData, "GetApplicationControlData"},
             {401, nullptr, "InvalidateAllApplicationControlCache"},
             {402, nullptr, "RequestDownloadApplicationControlData"},
             {403, nullptr, "GetMaxApplicationControlCacheCount"},
@@ -243,6 +246,65 @@ public:
 
         RegisterHandlers(functions);
     }
+
+    void GetApplicationControlData(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto flag = rp.PopRaw<u64>();
+        LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
+
+        const auto title_id = rp.PopRaw<u64>();
+
+        const auto size = ctx.GetWriteBufferSize();
+
+        const FileSys::PatchManager pm{title_id};
+        const auto control = pm.GetControlMetadata();
+
+        std::vector<u8> out;
+
+        if (control.first != nullptr) {
+            if (size < 0x4000) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min=0x4000)",
+                          size);
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
+
+            out.resize(0x4000);
+            const auto bytes = control.first->GetRawBytes();
+            std::memcpy(out.data(), bytes.data(), bytes.size());
+        } else {
+            LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+            out.resize(std::min<u64>(0x4000, size));
+        }
+
+        if (control.second != nullptr) {
+            if (size < 0x4000 + control.second->GetSize()) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min={:016X})",
+                          size, 0x4000 + control.second->GetSize());
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
+
+            out.resize(0x4000 + control.second->GetSize());
+            control.second->Read(out.data() + 0x4000, control.second->GetSize());
+        } else {
+            LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+        }
+
+        ctx.WriteBuffer(out);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(static_cast<u32>(out.size()));
+    }
 };
 
 class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {

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

@@ -31,7 +31,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
     buffer_wait_event->Signal();
 }
 
-boost::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
+std::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
     auto itr = std::find_if(queue.begin(), queue.end(), [&](const Buffer& buffer) {
         // Only consider free buffers. Buffers become free once again after they've been Acquired
         // and Released by the compositor, see the NVFlinger::Compose method.
@@ -44,7 +44,7 @@ boost::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
     });
 
     if (itr == queue.end()) {
-        return boost::none;
+        return {};
     }
 
     itr->status = Buffer::Status::Dequeued;
@@ -70,12 +70,12 @@ void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
     itr->crop_rect = crop_rect;
 }
 
-boost::optional<const BufferQueue::Buffer&> BufferQueue::AcquireBuffer() {
+std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
     auto itr = std::find_if(queue.begin(), queue.end(), [](const Buffer& buffer) {
         return buffer.status == Buffer::Status::Queued;
     });
     if (itr == queue.end())
-        return boost::none;
+        return {};
     itr->status = Buffer::Status::Acquired;
     return *itr;
 }

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

@@ -4,8 +4,9 @@
 
 #pragma once
 
+#include <optional>
 #include <vector>
-#include <boost/optional.hpp>
+
 #include "common/common_funcs.h"
 #include "common/math_util.h"
 #include "common/swap.h"
@@ -57,9 +58,9 @@ public:
         /// Rotate source image 90 degrees clockwise
         Rotate90 = 0x04,
         /// Rotate source image 180 degrees
-        Roate180 = 0x03,
+        Rotate180 = 0x03,
         /// Rotate source image 270 degrees clockwise
-        Roate270 = 0x07,
+        Rotate270 = 0x07,
     };
 
     struct Buffer {
@@ -73,11 +74,11 @@ public:
     };
 
     void SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer);
-    boost::optional<u32> DequeueBuffer(u32 width, u32 height);
+    std::optional<u32> DequeueBuffer(u32 width, u32 height);
     const IGBPBuffer& RequestBuffer(u32 slot) const;
     void QueueBuffer(u32 slot, BufferTransformFlags transform,
                      const MathUtil::Rectangle<int>& crop_rect);
-    boost::optional<const Buffer&> AcquireBuffer();
+    std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
     void ReleaseBuffer(u32 slot);
     u32 Query(QueryType type);
 

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

@@ -3,7 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <boost/optional.hpp>
+#include <optional>
 
 #include "common/alignment.h"
 #include "common/assert.h"
@@ -134,7 +134,7 @@ void NVFlinger::Compose() {
 
         MicroProfileFlip();
 
-        if (buffer == boost::none) {
+        if (!buffer) {
             auto& system_instance = Core::System::GetInstance();
 
             // There was no queued buffer to draw, render previous frame
@@ -143,7 +143,7 @@ void NVFlinger::Compose() {
             continue;
         }
 
-        auto& igbp_buffer = buffer->igbp_buffer;
+        auto& igbp_buffer = buffer->get().igbp_buffer;
 
         // Now send the buffer to the GPU for drawing.
         // TODO(Subv): Support more than just disp0. The display device selection is probably based
@@ -152,10 +152,10 @@ void NVFlinger::Compose() {
         ASSERT(nvdisp);
 
         nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
-                     igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride, buffer->transform,
-                     buffer->crop_rect);
+                     igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride,
+                     buffer->get().transform, buffer->get().crop_rect);
 
-        buffer_queue->ReleaseBuffer(buffer->slot);
+        buffer_queue->ReleaseBuffer(buffer->get().slot);
     }
 }
 

src/core/hle/service/service.cpp

@@ -80,8 +80,8 @@ namespace Service {
  * Creates a function string for logging, complete with the name (or header code, depending
  * on what's passed in) the port name, and all the cmd_buff arguments.
  */
-static std::string MakeFunctionString(const char* name, const char* port_name,
-                                      const u32* cmd_buff) {
+[[maybe_unused]] static std::string MakeFunctionString(const char* name, const char* port_name,
+                                                       const u32* cmd_buff) {
     // Number of params == bits 0-5 + bits 6-11
     int num_params = (cmd_buff[0] & 0x3F) + ((cmd_buff[0] >> 6) & 0x3F);
 

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

@@ -3,18 +3,23 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <chrono>
 #include <cstdlib>
+#include <ctime>
+#include <functional>
 #include <vector>
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/spl/csrng.h"
 #include "core/hle/service/spl/module.h"
 #include "core/hle/service/spl/spl.h"
+#include "core/settings.h"
 
 namespace Service::SPL {
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
+    : ServiceFramework(name), module(std::move(module)),
+      rng(Settings::values.rng_seed.value_or(std::time(nullptr))) {}
 
 Module::Interface::~Interface() = default;
 
@@ -23,8 +28,9 @@ 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(), std::rand);
+    std::generate(data.begin(), data.end(), [&] { return static_cast<u8>(distribution(rng)); });
 
     ctx.WriteBuffer(data);
 

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

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <random>
 #include "core/hle/service/service.h"
 
 namespace Service::SPL {
@@ -19,6 +20,9 @@ public:
 
     protected:
         std::shared_ptr<Module> module;
+
+    private:
+        std::mt19937 rng;
     };
 };
 

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

@@ -21,7 +21,7 @@ Time::Time(std::shared_ptr<Module> time, const char* name)
         {102, nullptr, "GetStandardUserSystemClockInitialYear"},
         {200, nullptr, "IsStandardNetworkSystemClockAccuracySufficient"},
         {300, nullptr, "CalculateMonotonicSystemClockBaseTimePoint"},
-        {400, nullptr, "GetClockSnapshot"},
+        {400, &Time::GetClockSnapshot, "GetClockSnapshot"},
         {401, nullptr, "GetClockSnapshotFromSystemClockContext"},
         {500, nullptr, "CalculateStandardUserSystemClockDifferenceByUser"},
         {501, nullptr, "CalculateSpanBetween"},

src/core/hle/service/time/time.cpp

@@ -15,6 +15,44 @@
 
 namespace Service::Time {
 
+static void PosixToCalendar(u64 posix_time, CalendarTime& calendar_time,
+                            CalendarAdditionalInfo& additional_info,
+                            [[maybe_unused]] const TimeZoneRule& /*rule*/) {
+    const std::time_t time(posix_time);
+    const std::tm* tm = std::localtime(&time);
+    if (tm == nullptr) {
+        calendar_time = {};
+        additional_info = {};
+        return;
+    }
+    calendar_time.year = tm->tm_year + 1900;
+    calendar_time.month = tm->tm_mon + 1;
+    calendar_time.day = tm->tm_mday;
+    calendar_time.hour = tm->tm_hour;
+    calendar_time.minute = tm->tm_min;
+    calendar_time.second = tm->tm_sec;
+
+    additional_info.day_of_week = tm->tm_wday;
+    additional_info.day_of_year = tm->tm_yday;
+    std::memcpy(additional_info.name.data(), "UTC", sizeof("UTC"));
+    additional_info.utc_offset = 0;
+}
+
+static u64 CalendarToPosix(const CalendarTime& calendar_time,
+                           [[maybe_unused]] const TimeZoneRule& /*rule*/) {
+    std::tm time{};
+    time.tm_year = calendar_time.year - 1900;
+    time.tm_mon = calendar_time.month - 1;
+    time.tm_mday = calendar_time.day;
+
+    time.tm_hour = calendar_time.hour;
+    time.tm_min = calendar_time.minute;
+    time.tm_sec = calendar_time.second;
+
+    std::time_t epoch_time = std::mktime(&time);
+    return static_cast<u64>(epoch_time);
+}
+
 class ISystemClock final : public ServiceFramework<ISystemClock> {
 public:
     ISystemClock() : ServiceFramework("ISystemClock") {
@@ -80,8 +118,8 @@ public:
             {5, nullptr, "GetTimeZoneRuleVersion"},
             {100, &ITimeZoneService::ToCalendarTime, "ToCalendarTime"},
             {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
-            {201, nullptr, "ToPosixTime"},
-            {202, nullptr, "ToPosixTimeWithMyRule"},
+            {201, &ITimeZoneService::ToPosixTime, "ToPosixTime"},
+            {202, &ITimeZoneService::ToPosixTimeWithMyRule, "ToPosixTimeWithMyRule"},
         };
         RegisterHandlers(functions);
     }
@@ -151,24 +189,29 @@ private:
         rb.PushRaw(additional_info);
     }
 
-    void PosixToCalendar(u64 posix_time, CalendarTime& calendar_time,
-                         CalendarAdditionalInfo& additional_info, const TimeZoneRule& /*rule*/) {
-        std::time_t t(posix_time);
-        std::tm* tm = std::localtime(&t);
-        if (!tm) {
-            return;
-        }
-        calendar_time.year = tm->tm_year + 1900;
-        calendar_time.month = tm->tm_mon + 1;
-        calendar_time.day = tm->tm_mday;
-        calendar_time.hour = tm->tm_hour;
-        calendar_time.minute = tm->tm_min;
-        calendar_time.second = tm->tm_sec;
+    void ToPosixTime(Kernel::HLERequestContext& ctx) {
+        // TODO(ogniK): Figure out how to handle multiple times
+        LOG_WARNING(Service_Time, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
+        auto calendar_time = rp.PopRaw<CalendarTime>();
+        auto posix_time = CalendarToPosix(calendar_time, {});
 
-        additional_info.day_of_week = tm->tm_wday;
-        additional_info.day_of_year = tm->tm_yday;
-        std::memcpy(additional_info.name.data(), "UTC", sizeof("UTC"));
-        additional_info.utc_offset = 0;
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u32>(1); // Amount of times we're returning
+        ctx.WriteBuffer(&posix_time, sizeof(u64));
+    }
+
+    void ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_Time, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
+        auto calendar_time = rp.PopRaw<CalendarTime>();
+        auto posix_time = CalendarToPosix(calendar_time, {});
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<u32>(1); // Amount of times we're returning
+        ctx.WriteBuffer(&posix_time, sizeof(u64));
     }
 };
 
@@ -207,6 +250,55 @@ void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& c
     LOG_DEBUG(Service_Time, "called");
 }
 
+void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    IPC::RequestParser rp{ctx};
+    auto unknown_u8 = rp.PopRaw<u8>();
+
+    ClockSnapshot clock_snapshot{};
+
+    const s64 time_since_epoch{std::chrono::duration_cast<std::chrono::seconds>(
+                                   std::chrono::system_clock::now().time_since_epoch())
+                                   .count()};
+    CalendarTime calendar_time{};
+    const std::time_t time(time_since_epoch);
+    const std::tm* tm = std::localtime(&time);
+    if (tm == nullptr) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultCode(-1)); // TODO(ogniK): Find appropriate error code
+        return;
+    }
+    SteadyClockTimePoint steady_clock_time_point{CoreTiming::cyclesToMs(CoreTiming::GetTicks()) /
+                                                 1000};
+
+    LocationName location_name{"UTC"};
+    calendar_time.year = tm->tm_year + 1900;
+    calendar_time.month = tm->tm_mon + 1;
+    calendar_time.day = tm->tm_mday;
+    calendar_time.hour = tm->tm_hour;
+    calendar_time.minute = tm->tm_min;
+    calendar_time.second = tm->tm_sec;
+    clock_snapshot.system_posix_time = time_since_epoch;
+    clock_snapshot.network_posix_time = time_since_epoch;
+    clock_snapshot.system_calendar_time = calendar_time;
+    clock_snapshot.network_calendar_time = calendar_time;
+
+    CalendarAdditionalInfo additional_info{};
+    PosixToCalendar(time_since_epoch, calendar_time, additional_info, {});
+
+    clock_snapshot.system_calendar_info = additional_info;
+    clock_snapshot.network_calendar_info = additional_info;
+
+    clock_snapshot.steady_clock_timepoint = steady_clock_time_point;
+    clock_snapshot.location_name = location_name;
+    clock_snapshot.clock_auto_adjustment_enabled = 1;
+    clock_snapshot.ipc_u8 = unknown_u8;
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    ctx.WriteBuffer(&clock_snapshot, sizeof(ClockSnapshot));
+}
+
 Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)
     : ServiceFramework(name), time(std::move(time)) {}
 

src/core/hle/service/time/time.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include "common/common_funcs.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Time {
@@ -53,6 +54,23 @@ struct SystemClockContext {
 static_assert(sizeof(SystemClockContext) == 0x20,
               "SystemClockContext structure has incorrect size");
 
+struct ClockSnapshot {
+    SystemClockContext user_clock_context;
+    SystemClockContext network_clock_context;
+    s64_le system_posix_time;
+    s64_le network_posix_time;
+    CalendarTime system_calendar_time;
+    CalendarTime network_calendar_time;
+    CalendarAdditionalInfo system_calendar_info;
+    CalendarAdditionalInfo network_calendar_info;
+    SteadyClockTimePoint steady_clock_timepoint;
+    LocationName location_name;
+    u8 clock_auto_adjustment_enabled;
+    u8 ipc_u8;
+    INSERT_PADDING_BYTES(2);
+};
+static_assert(sizeof(ClockSnapshot) == 0xd0, "ClockSnapshot is an invalid size");
+
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
@@ -65,6 +83,7 @@ public:
         void GetStandardSteadyClock(Kernel::HLERequestContext& ctx);
         void GetTimeZoneService(Kernel::HLERequestContext& ctx);
         void GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx);
+        void GetClockSnapshot(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> time;

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

@@ -132,11 +132,11 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "BindNoticeEvent"},
-            {1, nullptr, "Unknown1"},
+            {1, nullptr, "UnbindNoticeEvent"},
             {2, nullptr, "GetStatus"},
             {3, nullptr, "GetNotice"},
-            {4, nullptr, "Unknown2"},
-            {5, nullptr, "Unknown3"},
+            {4, nullptr, "EnablePowerRequestNotice"},
+            {5, nullptr, "DisablePowerRequestNotice"},
             {6, nullptr, "ReplyPowerRequest"},
         };
         // clang-format on

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

@@ -6,9 +6,10 @@
 #include <array>
 #include <cstring>
 #include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
-#include <boost/optional.hpp>
+
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_funcs.h"
@@ -506,9 +507,9 @@ private:
             IGBPDequeueBufferRequestParcel request{ctx.ReadBuffer()};
             const u32 width{request.data.width};
             const u32 height{request.data.height};
-            boost::optional<u32> slot = buffer_queue->DequeueBuffer(width, height);
+            std::optional<u32> slot = buffer_queue->DequeueBuffer(width, height);
 
-            if (slot != boost::none) {
+            if (slot) {
                 // Buffer is available
                 IGBPDequeueBufferResponseParcel response{*slot};
                 ctx.WriteBuffer(response.Serialize());
@@ -520,7 +521,7 @@ private:
                         Kernel::ThreadWakeupReason reason) {
                         // Repeat TransactParcel DequeueBuffer when a buffer is available
                         auto buffer_queue = nv_flinger->GetBufferQueue(id);
-                        boost::optional<u32> slot = buffer_queue->DequeueBuffer(width, height);
+                        std::optional<u32> slot = buffer_queue->DequeueBuffer(width, height);
                         IGBPDequeueBufferResponseParcel response{*slot};
                         ctx.WriteBuffer(response.Serialize());
                         IPC::ResponseBuilder rb{ctx, 2};

src/core/loader/loader.h

@@ -6,10 +6,11 @@
 
 #include <iosfwd>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
-#include <boost/optional.hpp>
+
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 
@@ -145,7 +146,7 @@ public:
      * information.
      * @returns A pair with the optional system mode, and and the status.
      */
-    virtual std::pair<boost::optional<u32>, ResultStatus> LoadKernelSystemMode() {
+    virtual std::pair<std::optional<u32>, ResultStatus> LoadKernelSystemMode() {
         // 96MB allocated to the application.
         return std::make_pair(2, ResultStatus::Success);
     }

src/core/loader/nro.cpp

@@ -12,10 +12,12 @@
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/vm_manager.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/nro.h"
 #include "core/loader/nso.h"
 #include "core/memory.h"
@@ -208,6 +210,9 @@ ResultStatus AppLoader_NRO::Load(Kernel::Process& process) {
         return ResultStatus::ErrorLoadingNRO;
     }
 
+    if (romfs != nullptr)
+        Service::FileSystem::RegisterRomFS(std::make_unique<FileSys::RomFSFactory>(*this));
+
     process.Run(base_address, Kernel::THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
 
     is_loaded = true;

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)) {
+    if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::values.dump_nso)) {
         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/loader/nsp.cpp

@@ -36,6 +36,16 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file)
 
     std::tie(nacp_file, icon_file) =
         FileSys::PatchManager(nsp->GetProgramTitleID()).ParseControlNCA(*control_nca);
+
+    if (nsp->IsExtractedType()) {
+        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
+    } else {
+        if (title_id == 0)
+            return;
+
+        secondary_loader = std::make_unique<AppLoader_NCA>(
+            nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));
+    }
 }
 
 AppLoader_NSP::~AppLoader_NSP() = default;
@@ -67,26 +77,19 @@ ResultStatus AppLoader_NSP::Load(Kernel::Process& process) {
         return ResultStatus::ErrorAlreadyLoaded;
     }
 
-    if (nsp->IsExtractedType()) {
-        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
-    } else {
-        if (title_id == 0)
-            return ResultStatus::ErrorNSPMissingProgramNCA;
+    if (title_id == 0)
+        return ResultStatus::ErrorNSPMissingProgramNCA;
 
-        secondary_loader = std::make_unique<AppLoader_NCA>(
-            nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));
+    if (nsp->GetStatus() != ResultStatus::Success)
+        return nsp->GetStatus();
 
-        if (nsp->GetStatus() != ResultStatus::Success)
-            return nsp->GetStatus();
+    if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
+        return nsp->GetProgramStatus(title_id);
 
-        if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
-            return nsp->GetProgramStatus(title_id);
-
-        if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
-            if (!Core::Crypto::KeyManager::KeyFileExists(false))
-                return ResultStatus::ErrorMissingProductionKeyFile;
-            return ResultStatus::ErrorNSPMissingProgramNCA;
-        }
+    if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
+        if (!Core::Crypto::KeyManager::KeyFileExists(false))
+            return ResultStatus::ErrorMissingProductionKeyFile;
+        return ResultStatus::ErrorNSPMissingProgramNCA;
     }
 
     const auto result = secondary_loader->Load(process);

src/core/memory.cpp

@@ -4,9 +4,9 @@
 
 #include <algorithm>
 #include <cstring>
+#include <optional>
 #include <utility>
 
-#include <boost/optional.hpp>
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"

src/core/memory_hook.h

@@ -5,7 +5,8 @@
 #pragma once
 
 #include <memory>
-#include <boost/optional.hpp>
+#include <optional>
+
 #include "common/common_types.h"
 
 namespace Memory {
@@ -18,19 +19,19 @@ namespace Memory {
  *
  * A hook may be mapped to multiple regions of memory.
  *
- * If a boost::none or false is returned from a function, the read/write request is passed through
+ * If a std::nullopt or false is returned from a function, the read/write request is passed through
  * to the underlying memory region.
  */
 class MemoryHook {
 public:
     virtual ~MemoryHook();
 
-    virtual boost::optional<bool> IsValidAddress(VAddr addr) = 0;
+    virtual std::optional<bool> IsValidAddress(VAddr addr) = 0;
 
-    virtual boost::optional<u8> Read8(VAddr addr) = 0;
-    virtual boost::optional<u16> Read16(VAddr addr) = 0;
-    virtual boost::optional<u32> Read32(VAddr addr) = 0;
-    virtual boost::optional<u64> Read64(VAddr addr) = 0;
+    virtual std::optional<u8> Read8(VAddr addr) = 0;
+    virtual std::optional<u16> Read16(VAddr addr) = 0;
+    virtual std::optional<u32> Read32(VAddr addr) = 0;
+    virtual std::optional<u64> Read64(VAddr addr) = 0;
 
     virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size) = 0;
 

src/core/settings.h

@@ -6,6 +6,7 @@
 
 #include <array>
 #include <atomic>
+#include <optional>
 #include <string>
 #include "common/common_types.h"
 
@@ -114,8 +115,9 @@ struct Values {
     // System
     bool use_docked_mode;
     bool enable_nfc;
-    int current_user;
-    int language_index;
+    std::optional<u32> rng_seed;
+    s32 current_user;
+    s32 language_index;
 
     // Controls
     std::array<std::string, NativeButton::NumButtons> buttons;
@@ -157,6 +159,7 @@ struct Values {
     bool use_gdbstub;
     u16 gdbstub_port;
     std::string program_args;
+    bool dump_nso;
 
     // WebService
     bool enable_telemetry;