2026-09-17 05:45:29

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/common/CMakeLists.txt

@@ -110,7 +110,6 @@ add_library(
     socket_types.h
     sparse_large_vector.cpp
     sparse_large_vector.h
-    spin_lock.h
     stb.cpp
     stb.h
     steady_clock.cpp

src/common/error.cpp

@@ -24,7 +24,7 @@ std::string NativeErrorToString(int e) {
     DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                    FORMAT_MESSAGE_IGNORE_INSERTS,
                                nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               LPSTR(&err_str), 1, nullptr);
+                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
     if (!res) {
         return "(FormatMessageA failed to format error)";
     }
@@ -32,10 +32,9 @@ std::string NativeErrorToString(int e) {
     LocalFree(err_str);
     return ret;
 #else
-    char err_str[256];
-    // See https://github.com/llvm/llvm-project/blob/c8fdb5f8b93c3e1da5e2ff3ba8b18627d6147b51/openmp/runtime/src/kmp_i18n.cpp#L711
-    // musl doesn't provide a macro gate but defines strerror_r() even if _GNU_SOURCE is defined
-#if defined(__managarm__) || (defined(__GLIBC__) || defined(__BIONIC__)) || defined(_GNU_SOURCE)
+    char err_str[255];
+#if defined(__ANDROID__) ||                                                                            \
+    (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600)))
     // Thread safe (GNU-specific)
     const char* str = strerror_r(e, err_str, sizeof(err_str));
     return std::string(str);

src/common/fs/path_util.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <cctype>
 #include <iostream>
 #include <sstream>
 #include "common/container/unordered_map.h"
@@ -480,28 +481,80 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
                            [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
                path.end());
 
-    const bool absolute = !path.empty() && path[0] == type2;
-    std::vector<std::string_view> parts;
+    std::string root;
+    std::string_view components{path};
+    bool drive_relative = false;
 
-    for (const auto part : SplitPathComponents(path))
-    {
-        if (part.empty() || part == ".")
-            continue;
-        if (part == ".." && !parts.empty() && parts.back() != "..")
-            parts.pop_back();
-        else if (part != "..") parts.push_back(part);
+#ifdef _WIN32
+    const bool network = path.size() > 1 && path[0] == type2 && path[1] == type2;
+    const bool drive =
+        path.size() > 1 && std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':';
+
+    if (network) {
+        root.assign(2, type2);
+        components.remove_prefix(2);
+    } else if (drive) {
+        root.assign(path.data(), 2);
+        components.remove_prefix(2);
+        if (!components.empty() && components.front() == type2) {
+            root += type2;
+            components.remove_prefix(1);
+        } else {
+            drive_relative = true;
+        }
+    }
+#endif
+
+    if (root.empty() && !components.empty() && components.front() == type2) {
+        root += type2;
+        components.remove_prefix(1);
     }
 
-    std::string resolved = absolute ? std::string(1, type2) : std::string{};
-    for (std::size_t i = 0; i < parts.size(); ++i)
-    {
-        if (i != 0)
+    const auto path_parts = SplitPathComponents(components);
+    std::size_t root_component_count = 0;
+#ifdef _WIN32
+    if (network) {
+        root_component_count = 2;
+
+        const auto is_unc = [](std::string_view part) {
+            return part.size() == 3 && (part[0] == 'U' || part[0] == 'u') &&
+                   (part[1] == 'N' || part[1] == 'n') && (part[2] == 'C' || part[2] == 'c');
+        };
+        if (path_parts.size() >= 2 && path_parts[0] == "?" && is_unc(path_parts[1])) {
+            root_component_count = 4;
+        }
+    }
+#endif
+
+    std::vector<std::string_view> parts;
+    for (std::size_t i = 0; i < path_parts.size(); ++i) {
+        const auto part = path_parts[i];
+        if (i < root_component_count) {
+            parts.push_back(part);
+        } else if (part.empty() || part == ".") {
+            continue;
+        } else if (part == "..") {
+            if (parts.size() > root_component_count) {
+                parts.pop_back();
+            }
+        } else {
+            parts.push_back(part);
+        }
+    }
+
+    const std::size_t root_length = root.size();
+    std::string resolved = std::move(root);
+    for (std::size_t i = 0; i < parts.size(); ++i) {
+        if (i != 0 || (!resolved.empty() && resolved.back() != type2 && !drive_relative))
             resolved += type2;
         resolved.append(parts[i].data(), parts[i].size());
     }
 
     path = std::move(resolved);
 
+    if (!path.empty() && path.size() == root_length) {
+        return path;
+    }
     return std::string(RemoveTrailingSlash(path));
 }
 

src/common/fs/path_util.h

@@ -347,8 +347,9 @@ enum class DirectorySeparator {
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
 [[nodiscard]] std::vector<std::string> SplitPathComponentsCopy(std::string_view filename);
 
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
-// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
+// Normalizes directory separators, removes duplicate and non-root trailing separators, and resolves
+// '.' and '..' components without traversing above the path root. Windows drive and UNC roots are
+// preserved.
 [[nodiscard]] std::string SanitizePath(
     std::string_view path,
     DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);

src/common/page_table.h

@@ -96,15 +96,15 @@ struct PageTable {
         }
 
         /// Write page info atomically
-        constexpr void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
+        inline void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
             data_raw.store(std::bit_cast<u64>(Data{marked, type, block, pointer}));
         }
 
-        constexpr void MarkRasterizerCached() noexcept {
+        inline void MarkRasterizerCached() noexcept {
             data_raw.fetch_or(0b111);
         }
 
-        constexpr void MarkDebug(u64 ptr, u16 block) noexcept {
+        inline void MarkDebug(u64 ptr, u16 block) noexcept {
             Store(true, PageType::DebugMemory, block, ptr);
         }
 

src/common/settings.h

@@ -649,10 +649,10 @@ struct Values {
 
     SwitchableSetting<bool> fix_bloom_effects{linkage, false, "fix_bloom_effects",
                                                      Category::RendererHacks};
-
+#ifdef __ANDROID__
     SwitchableSetting<bool> emulate_bgr565{linkage, false, "emulate_bgr565",
                                             Category::RendererHacks};
-
+#endif
     SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
                                          Category::RendererHacks};
     SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,

src/common/sparse_large_vector.h

@@ -38,7 +38,8 @@ void FreeMemoryPages(void* base, std::size_t size) noexcept;
 
 /// A large page-aligned buffer that has optimized memory usage for zero-writes.
 template <typename T>
-requires std::is_trivially_copyable_v<T>
+    // MSVC doesn't regard structs with atomics as trivially copyable
+    // requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
     constexpr SparseLargeVector() = default;

src/common/spin_lock.h

@@ -1,50 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#elif defined(ARCHITECTURE_x86_64)
-#include <xmmintrin.h>
-#endif
-#include <atomic>
-
-namespace Common {
-
-/// @brief A lock similar to mutex that forces a thread to spin wait instead calling the
-/// supervisor. Should be used on short sequences of code.
-struct SpinLock {
-    SpinLock() noexcept = default;
-    SpinLock(const SpinLock&) noexcept = delete;
-    SpinLock& operator=(const SpinLock&) noexcept = delete;
-    SpinLock(SpinLock&&) noexcept = delete;
-    SpinLock& operator=(SpinLock&&) noexcept = delete;
-
-    inline void lock() noexcept {
-        while (lck.test_and_set(std::memory_order_acquire)) {
-#if defined(ARCHITECTURE_x86_64)
-            _mm_pause();
-#elif defined(ARCHITECTURE_arm64) && defined(_MSC_VER)
-            __yield();
-#elif defined(ARCHITECTURE_arm64)
-            asm("yield");
-#endif
-        }
-    }
-
-    inline void unlock() noexcept {
-        lck.clear(std::memory_order_release);
-    }
-
-    [[nodiscard]] inline bool try_lock() noexcept {
-        return !lck.test_and_set(std::memory_order_acquire);
-    }
-
-    std::atomic_flag lck = ATOMIC_FLAG_INIT;
-};
-
-} // namespace Common

src/common/uuid.cpp

@@ -208,9 +208,9 @@ UUID UUID::MakeRandomRFC4122V4() {
     return uuid;
 }
 
-UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
+UUID UUID::MakeRFC4122V5(std::span<u8, 16> sha1) {
     UUID uuid{};
-    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
+    std::memcpy(&uuid.uuid, sha1.data(), sha1.size());
     uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
     uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
     return uuid;

src/common/uuid.h

@@ -104,7 +104,7 @@ struct UUID {
     /// @returns A random UUID that is RFC 4122 Version 4 compliant.
     [[nodiscard]] static UUID MakeRandomRFC4122V4();
 
-    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);
+    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 16> sha1);
 
     friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -177,7 +177,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
         config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>(
             const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
         config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = 0;
+        config.page_table_marked_bit = uint8_t(0);
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
         config.only_detect_misalignment_via_page_table_on_page_boundary = true;
@@ -193,7 +193,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
             Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
             // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
             // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
+            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
         }
     }
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -216,7 +216,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
             const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
         config.page_table_address_space_bits = std::uint32_t(address_space_bits);
         config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = 0;
+        config.page_table_marked_bit = uint8_t(0);
         config.silently_mirror_page_table = false;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -235,7 +235,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
             Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
             // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
             // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
+            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
         }
     }
 

src/core/file_sys/ips_layer.cpp

@@ -100,8 +100,7 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
 
 
 struct IPSwitchRecord {
-    std::array<uint8_t, 256 - sizeof(size_t)> data;
-    size_t count;
+    std::vector<uint8_t> data;
 };
 struct IPSwitchCompiler::IPSwitchPatch {
     ::Common::unordered_map<u32, IPSwitchRecord> records;
@@ -122,22 +121,23 @@ static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
     IPSwitchRecord r{};
     for (auto it = sv.cbegin(); it < sv.cend(); ) {
         if (*it == '\\' && it + 1 < sv.cend()) {
-            switch (it[1]) {
-            case 'a': r.data[r.count] = '\a'; break;
-            case 'b': r.data[r.count] = '\b'; break;
-            case 'e': r.data[r.count] = '\e'; break;
-            case 'f': r.data[r.count] = '\f'; break;
-            case 'n': r.data[r.count] = '\n'; break;
-            case 'r': r.data[r.count] = '\r'; break;
-            case 't': r.data[r.count] = '\t'; break;
-            case 'v': r.data[r.count] = '\v'; break;
-            case '?': r.data[r.count] = '\?'; break;
-            default: r.data[r.count] = it[1]; break;
-            }
-            ++r.count;
+            r.data.push_back([it]() {
+                switch (it[1]) {
+                case 'a': return '\a';
+                case 'b': return '\b';
+                case 'e': return '\e';
+                case 'f': return '\f';
+                case 'n': return '\n';
+                case 'r': return '\r';
+                case 't': return '\t';
+                case 'v': return '\v';
+                case '?': return '\?';
+                default: return it[1];
+                }
+            }());
             it += 2;
         } else {
-            ++r.count;
+            r.data.push_back(*it);
             ++it;
         }
     }
@@ -223,8 +223,8 @@ void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
                 if (start <= line.cend() && end <= line.cend()) {
                     // Actually IPS wants ordering from {lsb, ..., msb} -- so LE and BE are inverted, fun!
                     auto const hs = Common::HexStringToVector({start, end}, is_little_endian);
+                    r.data.resize(hs.size());
                     std::memcpy(r.data.data(), hs.data(), hs.size());
-                    r.count = hs.size();
                     LOG_INFO(Loader, "[H] value @ {:#08X}", offset);
                     patches.back().records.insert_or_assign(u32(offset), std::move(r));
                 } else {
@@ -293,7 +293,7 @@ VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
         if (patch.enabled) {
             for (const auto& record : patch.records) {
                 if (record.first < in_data.size()) {
-                    auto replace_size = record.second.count;
+                    auto replace_size = record.second.data.size();
                     if (record.first + replace_size > in_data.size())
                         replace_size = in_data.size() - record.first;
                     std::memcpy(in_data.data() + record.first, record.second.data.data(), replace_size);

src/core/hle/kernel/k_scheduler.cpp

@@ -465,6 +465,10 @@ void KScheduler::ScheduleImplFiber(KernelCore& kernel) {
         // Check if we need scheduling. If we do, then we can't complete the switch and should
         // retry.
         if (m_state.needs_scheduling.load(std::memory_order_seq_cst)) {
+            // Some libc++ lazily init mutex
+            [[maybe_unused]] auto const can_lock = highest_priority_thread->m_context_guard.try_lock();
+            DEBUG_ASSERT(!can_lock);
+
             // Our switch failed.
             // We should unlock the thread context, and then retry.
             highest_priority_thread->m_context_guard.unlock();
@@ -496,6 +500,10 @@ void KScheduler::Unload(KernelCore& kernel, KThread* thread) {
 
     // Check if the thread is terminated by checking the DPC flags.
     if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) {
+        // Some libc++ lazily init mutex
+        [[maybe_unused]] auto const can_lock = thread->m_context_guard.try_lock();
+        DEBUG_ASSERT(!can_lock);
+
         // The thread isn't terminated, so we want to unlock it.
         thread->m_context_guard.unlock();
     }

src/core/hle/kernel/k_slab_heap.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -12,7 +12,6 @@
 #include "common/atomic_ops.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/spin_lock.h"
 
 namespace Kernel {
 
@@ -30,7 +29,7 @@ public:
     };
 
 public:
-    constexpr KSlabHeapImpl() = default;
+    KSlabHeapImpl() = default;
 
     void Initialize() {
         ASSERT(m_head == nullptr);
@@ -68,7 +67,7 @@ public:
 
 private:
     std::atomic<Node*> m_head{};
-    Common::SpinLock m_lock;
+    std::mutex m_lock;
 };
 
 } // namespace impl

src/core/hle/kernel/k_thread.h

@@ -19,7 +19,6 @@
 
 #include "common/intrusive_red_black_tree.h"
 #include "common/scratch_buffer.h"
-#include "common/spin_lock.h"
 #include "core/arm/arm_interface.h"
 #include "core/hle/kernel/k_affinity_mask.h"
 #include "core/hle/kernel/k_light_lock.h"
@@ -920,7 +919,7 @@ private:
     bool m_resource_limit_release_hint{};
     bool m_is_kernel_address_key{};
     StackParameters m_stack_parameters{};
-    Common::SpinLock m_context_guard{};
+    std::mutex m_context_guard{};
 
     // For emulation
     std::shared_ptr<Common::Fiber> m_host_context{};

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

@@ -23,6 +23,12 @@ constexpr std::size_t profile_username_size{32};
 using ProfileUsername = std::array<u8, profile_username_size>;
 using UserIDArray = std::array<Common::UUID, MAX_USERS>;
 
+// This is nn::account::Uid
+struct Uid {
+    std::array<u8, 0x10> unk0;
+};
+static_assert(sizeof(Uid) == 0x10);
+
 /// Contains extra data related to a user.
 /// TODO: RE this structure
 struct UserData {

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

@@ -347,21 +347,22 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {
 
 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
     LOG_WARNING(Service_AM, "(stubbed)");
-    R_UNLESS(out_pseudo_device_id, ResultUnknown);
+    R_UNLESS(out_pseudo_device_id != nullptr, ResultUnknown);
 
     // This should be hashed with the device specific hash
     // for now this will do
     const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
-    u8 hash[EVP_MAX_MD_SIZE];
+    R_UNLESS(res.first != nullptr, ResultUnknown);
+    std::array<u8, EVP_MAX_MD_SIZE> hash;
     unsigned int hash_len = 0;
     auto const seed = res.first->raw.seed_for_pseudo_device_id;
     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
     auto const algorithm = EVP_sha1();
     EVP_DigestInit_ex(ctx, algorithm, nullptr);
     EVP_DigestUpdate(ctx, &seed, sizeof(seed));
-    EVP_DigestFinal_ex(ctx, hash, &hash_len);
+    EVP_DigestFinal_ex(ctx, hash.data(), &hash_len);
     EVP_MD_CTX_free(ctx);
-    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
+    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 16>{hash.begin(), hash.begin() + 16});
     R_SUCCEED();
 }
 

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

@@ -154,6 +154,9 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {720, nullptr, "AbandonAccessFailure"},
         {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
         {810, nullptr, "RegisterProgramIndexMapInfo"},
+        {820, nullptr, "GetContentStorageInfoIndex"},
+        {830, nullptr, "EncryptStreamPlaySaveData"},
+        {831, nullptr, "DecryptStreamPlaySaveData"},
         {1000, nullptr, "SetBisRootForHost"},
         {1001, nullptr, "SetSaveDataSize"},
         {1002, nullptr, "SetSaveDataRootPath"},

src/core/hle/service/ipc_helpers.h

@@ -22,6 +22,7 @@
 
 namespace IPC {
 
+constexpr Result ResultNotSupported{ErrorModule::HIPC, 1};
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};
 
 struct ResponseBuilder {

src/core/hle/service/ngc/ngc.cpp

@@ -6,10 +6,16 @@
 
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_client_session.h"
+#include "core/hle/result.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ngc/ngc.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
+#include "frontend_common/firmware_manager.h"
 
 namespace Service::NGC {
 
@@ -166,12 +172,123 @@ public:
     }
 };
 
+struct SaveDataHandle {
+    u64 unk0;
+};
+static_assert(sizeof(SaveDataHandle) == 0x08);
+
+class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
+public:
+    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {450, nullptr, "InitializeForSaveData"},
+            {451, nullptr, "FinalizeForSaveData"},
+            {452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
+            {453, nullptr, "CloseSaveData"},
+            {454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
+            {455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
+            {456, nullptr, "FlushSaveSlot"},
+            {457, nullptr, "CommitSaveData"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+    Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result ReadSaveSlot(s32 offset, SaveDataHandle handle, OutBuffer<BufferAttr_HipcAutoSelect> out_data, Out<u32> out_size) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result WriteSaveSlot(s32 offset, SaveDataHandle handle, InBuffer<BufferAttr_HipcAutoSelect> out_data) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        // to implement
+        R_SUCCEED();
+    }
+};
+
+class IUserService final : public ServiceFramework<IUserService> {
+public:
+    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&IUserService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+    Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        *out_interface = std::make_shared<IUserShimScopedObject>(system);
+        R_SUCCEED();
+    }
+};
+
+class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
+public:
+    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {106, nullptr, "Cmd106"},
+            {107, nullptr, "Cmd107"},
+            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
+            {207, nullptr, "Cmd207"},
+            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
+            {209, nullptr, "Cmd209"},
+            {210, nullptr, "Cmd210"},
+            {211, nullptr, "Cmd211"},
+            {212, nullptr, "Cmd212"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+    Result Cmd108() {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result Cmd208(Out<std::array<u8, 0x20>> unk0) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+};
+
+class ISystemService final : public ServiceFramework<ISystemService> {
+public:
+    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+    Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        *out_interface = std::make_shared<ISystemShimScopedObject>(system);
+        R_SUCCEED();
+    }
+};
+
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
     server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system), 4);
     server_manager->RegisterNamedService("ngct:s", std::make_shared<IServiceWithManagementApi>(system), 4);
     server_manager->RegisterNamedService("ngc:u", std::make_shared<NgcServiceImpl>(system), 4);
+
+    // +23.0.0
+    if (FirmwareManager::GetFirmwareVersion(system).first.major >= 23) {
+        server_manager->RegisterNamedService("stpl:u", std::make_shared<IUserService>(system), 4);
+        server_manager->RegisterNamedService("stpl:sys", std::make_shared<ISystemService>(system), 4);
+    }
+
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/ssl/ssl.cpp

@@ -48,6 +48,12 @@ enum class OptionType : u32 {
     EnableAlpn = 3,
 };
 
+// This is nn::ssl::sf::RenegotiationMode
+enum RenegotiationMode : u32 {
+    None = 0, ///< None
+    Secure = 1, ///< Secure
+};
+
 // This is nn::ssl::sf::SslVersion
 struct SslVersion {
     union {
@@ -75,34 +81,34 @@ public:
           shared_data{shared_data_in}, backend{std::move(backend_in)} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &ISslConnection::SetSocketDescriptor, "SetSocketDescriptor"},
-            {1, &ISslConnection::SetHostName, "SetHostName"},
-            {2, &ISslConnection::SetVerifyOption, "SetVerifyOption"},
-            {3, &ISslConnection::SetIoMode, "SetIoMode"},
-            {4, nullptr, "GetSocketDescriptor"},
-            {5, nullptr, "GetHostName"},
+            {0, D<&ISslConnection::SetSocketDescriptor>, "SetSocketDescriptor"},
+            {1, D<&ISslConnection::SetHostName>, "SetHostName"},
+            {2, D<&ISslConnection::SetVerifyOption>, "SetVerifyOption"},
+            {3, D<&ISslConnection::SetIoMode>, "SetIoMode"},
+            {4, D<&ISslConnection::GetSocketDescriptor>, "GetSocketDescriptor"},
+            {5, D<&ISslConnection::GetHostName>, "GetHostName"},
             {6, nullptr, "GetVerifyOption"},
-            {7, nullptr, "GetIoMode"},
-            {8, &ISslConnection::DoHandshake, "DoHandshake"},
+            {7, D<&ISslConnection::GetIoMode>, "GetIoMode"},
+            {8, D<&ISslConnection::DoHandshake>, "DoHandshake"},
             {9, &ISslConnection::DoHandshakeGetServerCert, "DoHandshakeGetServerCert"},
-            {10, &ISslConnection::Read, "Read"},
-            {11, &ISslConnection::Write, "Write"},
-            {12, &ISslConnection::Pending, "Pending"},
-            {13, nullptr, "Peek"},
-            {14, nullptr, "Poll"},
-            {15, nullptr, "GetVerifyCertError"},
-            {16, nullptr, "GetNeededServerCertBufferSize"},
-            {17, &ISslConnection::SetSessionCacheMode, "SetSessionCacheMode"},
-            {18, nullptr, "GetSessionCacheMode"},
-            {19, nullptr, "FlushSessionCache"},
-            {20, nullptr, "SetRenegotiationMode"},
-            {21, nullptr, "GetRenegotiationMode"},
-            {22, &ISslConnection::SetOption, "SetOption"},
-            {23, &ISslConnection::GetOption, "GetOption"},
+            {10, D<&ISslConnection::Read>, "Read"},
+            {11, D<&ISslConnection::Write>, "Write"},
+            {12, D<&ISslConnection::Pending>, "Pending"},
+            {13, D<&ISslConnection::Peek>, "Peek"},
+            {14, D<&ISslConnection::Poll>, "Poll"},
+            {15, D<&ISslConnection::GetVerifyCertError>, "GetVerifyCertError"},
+            {16, D<&ISslConnection::GetNeededServerCertBufferSize>, "GetNeededServerCertBufferSize"},
+            {17, D<&ISslConnection::SetSessionCacheMode>, "SetSessionCacheMode"},
+            {18, D<&ISslConnection::GetSessionCacheMode>, "GetSessionCacheMode"},
+            {19, D<&ISslConnection::FlushSessionCache>, "FlushSessionCache"},
+            {20, D<&ISslConnection::SetRenegotiationMode>, "SetRenegotiationMode"},
+            {21, D<&ISslConnection::GetRenegotiationMode>, "GetRenegotiationMode"},
+            {22, D<&ISslConnection::SetOption>, "SetOption"},
+            {23, D<&ISslConnection::GetOption>, "GetOption"},
             {24, nullptr, "GetVerifyCertErrors"},
             {25, nullptr, "GetCipherInfo"},
-            {26, &ISslConnection::SetNextAlpnProto, "SetNextAlpnProto"},
-            {27, &ISslConnection::GetNextAlpnProto, "GetNextAlpnProto"},
+            {26, D<&ISslConnection::SetNextAlpnProto>, "SetNextAlpnProto"},
+            {27, D<&ISslConnection::GetNextAlpnProto>, "GetNextAlpnProto"},
             {28, nullptr, "SetDtlsSocketDescriptor"},
             {29, nullptr, "GetDtlsHandshakeTimeout"},
             {30, nullptr, "SetPrivateOption"},
@@ -141,80 +147,6 @@ public:
     }
 
 private:
-    SslVersion ssl_version;
-    std::shared_ptr<SslContextSharedData> shared_data;
-    std::unique_ptr<SSLConnectionBackend> backend;
-    std::optional<int> fd_to_close;
-    bool do_not_close_socket = false;
-    bool get_server_cert_chain = false;
-    bool skip_default_verify = false;
-    bool enable_alpn = false;
-    std::shared_ptr<Network::SocketBase> socket;
-    std::vector<u8> next_alpn_proto;
-    bool did_handshake = false;
-    u32 verify_option = 0;
-
-    Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
-        LOG_DEBUG(Service_SSL, "called, fd={}", fd);
-        ASSERT(!did_handshake);
-        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
-        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
-
-        auto const res_v = bsd->DuplicateSocketImpl(fd);
-        if (auto *res = std::get_if<s32>(&res_v)) {
-            const s32 duplicated_fd = *res;
-            if (do_not_close_socket) {
-                *out_fd = duplicated_fd;
-            } else {
-                *out_fd = -1;
-                fd_to_close = duplicated_fd;
-            }
-            std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);
-            if (!sock.has_value()) {
-                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);
-                return ResultInvalidSocket;
-            }
-            socket = std::move(*sock);
-            backend->SetSocket(socket);
-            return ResultSuccess;
-        }
-        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);
-        return ResultInvalidSocket;
-    }
-
-    Result SetHostNameImpl(const std::string& hostname) {
-        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
-        ASSERT(!did_handshake);
-        return backend->SetHostName(hostname);
-    }
-
-    Result SetVerifyOptionImpl(u32 option) {
-        ASSERT(!did_handshake);
-        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
-        verify_option = 0;
-        backend->SetVerifyOption(0);
-        return ResultSuccess;
-    }
-
-    Result SetIoModeImpl(u32 input_mode) {
-        auto mode = static_cast<IoMode>(input_mode);
-        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
-        ASSERT_OR_EXECUTE(socket, { return ResultNoSocket; });
-
-        const bool non_block = mode == IoMode::NonBlocking;
-        const Network::Errno error = socket->SetNonBlock(non_block);
-        if (error != Network::Errno::SUCCESS) {
-            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
-        }
-        return ResultSuccess;
-    }
-
-    Result SetSessionCacheModeImpl(u32 mode) {
-        ASSERT(!did_handshake);
-        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
-        return ResultSuccess;
-    }
-
     Result DoHandshakeImpl() {
         ASSERT_OR_EXECUTE(!did_handshake && socket, { return ResultNoSocket; });
         Result res = backend->DoHandshake();
@@ -234,19 +166,17 @@ private:
         };
         if (!get_server_cert_chain) {
             // Just return the first one, unencoded.
-            ASSERT_OR_EXECUTE_MSG(
-                !certs.empty(), { return {}; }, "Should be at least one server cert");
+            ASSERT_OR_EXECUTE_MSG(!certs.empty(), { return {}; }, "Should be at least one server cert");
             return certs[0];
         }
         std::vector<u8> ret;
-        Header header{0x4E4D684374726543, static_cast<u32>(certs.size()), 0};
+        Header header{0x4E4D684374726543, u32(certs.size()), 0};
         ret.insert(ret.end(), reinterpret_cast<u8*>(&header), reinterpret_cast<u8*>(&header + 1));
         size_t data_offset = sizeof(Header) + certs.size() * sizeof(EntryHeader);
         for (auto& cert : certs) {
-            EntryHeader entry_header{static_cast<u32>(cert.size()), static_cast<u32>(data_offset)};
+            EntryHeader entry_header{u32(cert.size()), u32(data_offset)};
             data_offset += cert.size();
-            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header),
-                       reinterpret_cast<u8*>(&entry_header + 1));
+            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header), reinterpret_cast<u8*>(&entry_header + 1));
         }
         for (auto& cert : certs) {
             ret.insert(ret.end(), cert.begin(), cert.end());
@@ -254,65 +184,77 @@ private:
         return ret;
     }
 
-    Result ReadImpl(std::vector<u8>* out_data) {
-        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
-        size_t actual_size{};
-        Result res = backend->Read(&actual_size, *out_data);
-        if (res != ResultSuccess) {
-            return res;
+    Result SetSocketDescriptor(s32 in_fd, Out<s32> out_fd) {
+        LOG_DEBUG(Service_SSL, "called, fd={}", in_fd);
+        ASSERT(!did_handshake);
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
+        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
+
+        auto const res_v = bsd->DuplicateSocketImpl(in_fd);
+        if (auto *res = std::get_if<s32>(&res_v)) {
+            const s32 dup_fd = *res;
+            *out_fd = do_not_close_socket ? dup_fd : -1;
+            if (!do_not_close_socket)
+                fd_to_close = dup_fd;
+            auto const sock = bsd->GetSocket(dup_fd);
+            if (!sock.has_value()) {
+                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", dup_fd);
+                return ResultInvalidSocket;
+            }
+            socket = std::move(*sock);
+            backend->SetSocket(std::move(socket));
+            return ResultSuccess;
         }
-        out_data->resize(actual_size);
-        return res;
+        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", in_fd);
+        return ResultInvalidSocket;
     }
 
-    Result WriteImpl(size_t* out_size, std::span<const u8> data) {
-        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
-        return backend->Write(out_size, data);
+    Result SetHostName(InBuffer<BufferAttr_HipcMapAlias> buf) {
+        auto const hostname = Common::StringFromBuffer(buf);
+        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
+        ASSERT(!did_handshake);
+        return backend->SetHostName(hostname.c_str());
     }
 
-    Result PendingImpl(s32* out_pending) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called.");
-        *out_pending = 0;
-        return ResultSuccess;
+    Result SetVerifyOption(u32 option) {
+        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
+        ASSERT(!did_handshake);
+        verify_option = 0;
+        backend->SetVerifyOption(0);
+        R_SUCCEED();
     }
 
-    void SetSocketDescriptor(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const s32 in_fd = rp.Pop<s32>();
-        s32 out_fd{-1};
-        const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res);
-        rb.Push<s32>(out_fd);
+    Result SetIoMode(u32 input_mode) {
+        auto mode = IoMode(input_mode);
+        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
+        R_UNLESS(socket, ResultNoSocket);
+        const bool non_block = mode == IoMode::NonBlocking;
+        const Network::Errno error = socket->SetNonBlock(non_block);
+        if (error != Network::Errno::SUCCESS) {
+            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
+        }
+        R_SUCCEED();
     }
 
-    void SetHostName(HLERequestContext& ctx) {
-        const std::string hostname = Common::StringFromBuffer(ctx.ReadBuffer());
-        const Result res = SetHostNameImpl(hostname);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res);
+    Result GetSocketDescriptor(Out<u32> out_fd) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        *out_fd = uint32_t(socket->GetFD());
+        R_SUCCEED();
     }
 
-    void SetVerifyOption(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 option = rp.Pop<u32>();
-        const Result res = SetVerifyOptionImpl(option);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res);
+    Result GetHostName(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        ASSERT(!did_handshake);
+        return backend->GetHostName(std::span<u8>{data.begin(), data.end()}, out_size);
     }
 
-    void SetIoMode(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 mode = rp.Pop<u32>();
-        const Result res = SetIoModeImpl(mode);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res);
+    Result GetIoMode(Out<u32> out_mode) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_SUCCEED();
     }
 
-    void DoHandshake(HLERequestContext& ctx) {
-        const Result res = DoHandshakeImpl();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res);
+    Result DoHandshake() {
+        return DoHandshakeImpl();
     }
 
     void DoHandshakeGetServerCert(HLERequestContext& ctx) {
@@ -351,131 +293,158 @@ private:
         rb.PushRaw(out);
     }
 
-    void Read(HLERequestContext& ctx) {
-        std::vector<u8> output_bytes(ctx.GetWriteBufferSize());
-        const Result res = ReadImpl(&output_bytes);
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res);
-        if (res == ResultSuccess) {
-            rb.Push(static_cast<u32>(output_bytes.size()));
-            ctx.WriteBuffer(output_bytes);
-        } else {
-            rb.Push(static_cast<u32>(0));
-        }
+    Result Read(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
+        R_UNLESS(did_handshake, ResultInternalError);
+        size_t tmp{};
+        auto const res = backend->Read(&tmp, data);
+        *out_size = u32(tmp);
+        return res;
     }
 
-    void Write(HLERequestContext& ctx) {
-        size_t write_size{0};
-        const Result res = WriteImpl(&write_size, ctx.ReadBuffer());
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res);
-        rb.Push(static_cast<u32>(write_size));
+    Result Write(InBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
+        R_UNLESS(did_handshake, ResultInternalError);
+        size_t tmp{};
+        auto const res = backend->Write(&tmp, data);
+        *out_size = u32(tmp);
+        return res;
     }
 
-    void Pending(HLERequestContext& ctx) {
-        s32 pending_size{0};
-        const Result res = PendingImpl(&pending_size);
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(res);
-        rb.Push<s32>(pending_size);
+    Result Pending(Out<s32> out_pending_size) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        *out_pending_size = s32(backend->Pending());
+        R_SUCCEED();
     }
 
-    void SetSessionCacheMode(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 mode = rp.Pop<u32>();
-        const Result res = SetSessionCacheModeImpl(mode);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res);
+    Result Peek(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        size_t tmp{};
+        auto const res = backend->Peek(&tmp, data);
+        *out_size = u32(tmp);
+        return res;
     }
 
-    void SetOption(HLERequestContext& ctx) {
-        struct Parameters {
-            OptionType option;
-            s32 value;
-        };
-        static_assert(sizeof(Parameters) == 0x8, "Parameters is an invalid size");
-
-        IPC::RequestParser rp{ctx};
-        const auto parameters = rp.PopRaw<Parameters>();
-
-        switch (parameters.option) {
-        case OptionType::DoNotCloseSocket:
-            do_not_close_socket = static_cast<bool>(parameters.value);
-            break;
-        case OptionType::GetServerCertChain:
-            get_server_cert_chain = static_cast<bool>(parameters.value);
-            break;
-        case OptionType::SkipDefaultVerify:
-            skip_default_verify = static_cast<bool>(parameters.value);
-            break;
-        case OptionType::EnableAlpn:
-            enable_alpn = static_cast<bool>(parameters.value);
-            break;
-        default:
-            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", parameters.option,
-                        parameters.value);
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+    Result Poll(u32 in_pollevent, u32 timer, Out<u32> out_pollevent) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_SUCCEED();
     }
 
-    void GetOption(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto option = rp.PopRaw<OptionType>();
+    Result GetVerifyCertError() {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_SUCCEED();
+    }
 
-        u8 value = 0;
+    Result GetNeededServerCertBufferSize(Out<u32> out_needed_buffer_size) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_SUCCEED();
+    }
 
+    Result SetSessionCacheMode(u32 mode) {
+        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
+        R_UNLESS(!did_handshake, ResultInternalError);
+        R_SUCCEED();
+    }
+
+    Result GetSessionCacheMode(Out<u32> mode) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_UNLESS(!did_handshake, ResultInternalError);
+        R_SUCCEED();
+    }
+
+    Result FlushSessionCache() {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_UNLESS(!did_handshake, ResultInternalError);
+        R_SUCCEED();
+    }
+
+    Result SetRenegotiationMode(RenegotiationMode mode) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        backend->SetRenegotiationMode(u32(mode));
+        R_SUCCEED();
+    }
+
+    Result GetRenegotiationMode(Out<RenegotiationMode> mode) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        u32 tmp{};
+        auto const res = backend->GetRenegotiationMode(&tmp);
+        *mode = RenegotiationMode(tmp);
+        return res;
+    }
+
+    Result SetOption(OptionType option, s32 value) {
         switch (option) {
         case OptionType::DoNotCloseSocket:
-            value = static_cast<u8>(do_not_close_socket);
+            do_not_close_socket = bool(value);
             break;
         case OptionType::GetServerCertChain:
-            value = static_cast<u8>(get_server_cert_chain);
+            get_server_cert_chain = bool(value);
             break;
         case OptionType::SkipDefaultVerify:
-            value = static_cast<u8>(skip_default_verify);
+            skip_default_verify = bool(value);
             break;
         case OptionType::EnableAlpn:
-            value = static_cast<u8>(enable_alpn);
+            enable_alpn = bool(value);
             break;
         default:
-            LOG_WARNING(Service_SSL, "Unknown option={}", option);
-            value = 0;
+            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", option, value);
+        }
+        R_SUCCEED();
+    }
+
+    Result GetOption(OptionType option, Out<u8> value) {
+        switch (option) {
+        case OptionType::DoNotCloseSocket:
+            *value = u8(do_not_close_socket);
+            break;
+        case OptionType::GetServerCertChain:
+            *value = u8(get_server_cert_chain);
+            break;
+        case OptionType::SkipDefaultVerify:
+            *value = u8(skip_default_verify);
+            break;
+        case OptionType::EnableAlpn:
+            *value = u8(enable_alpn);
+            break;
+        default:
+            LOG_WARNING(Service_SSL, "Unknown option={}", u32(option));
+            *value = 0;
             break;
         }
-
-        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", option, value);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push<u8>(value);
+        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", u32(option), *value);
+        R_SUCCEED();
     }
 
-    void SetNextAlpnProto(HLERequestContext& ctx) {
-        const auto data = ctx.ReadBuffer(0);
-        next_alpn_proto.assign(data.begin(), data.end());
-
+    Result SetNextAlpnProto(InBuffer<BufferAttr_HipcMapAlias> data) {
+        auto const to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
+        next_alpn_proto.assign(data.begin(), data.begin() + to_write);
         LOG_DEBUG(Service_SSL, "SetNextAlpnProto called, size={}", next_alpn_proto.size());
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
+        R_SUCCEED();
     }
 
-    void GetNextAlpnProto(HLERequestContext& ctx) {
-        const size_t writable = ctx.GetWriteBufferSize();
-        const size_t to_write = (std::min)(next_alpn_proto.size(), writable);
-
-        if (to_write != 0) {
-            ctx.WriteBuffer(std::span<const u8>(next_alpn_proto.data(), to_write));
-        }
-
-        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", to_write);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(to_write));
+    Result GetNextAlpnProto(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> to_write) {
+        *to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
+        next_alpn_proto.assign(data.begin(), data.begin() + *to_write);
+        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", *to_write);
+        R_SUCCEED();
     }
+
+    Result GetVerifyCertErrors(OutBuffer<BufferAttr_HipcMapAlias> unk0, Out<u32> unk1, Out<u32> unk2) {
+        LOG_WARNING(Service_SSL, "(STUBBED)");
+        R_SUCCEED();
+    }
+
+    SslVersion ssl_version;
+    std::shared_ptr<SslContextSharedData> shared_data;
+    std::unique_ptr<SSLConnectionBackend> backend;
+    std::optional<int> fd_to_close;
+    std::shared_ptr<Network::SocketBase> socket;
+    std::vector<u8> next_alpn_proto;
+    u32 verify_option = 0;
+
+    bool do_not_close_socket = false;
+    bool get_server_cert_chain = false;
+    bool skip_default_verify = false;
+    bool enable_alpn = false;
+    bool did_handshake = false;
 };
 
 class ISslContext final : public ServiceFramework<ISslContext> {
@@ -492,7 +461,7 @@ public:
             {5, &ISslContext::ImportClientPki, "ImportClientPki"},
             {6, nullptr, "RemoveServerPki"},
             {7, nullptr, "RemoveClientPki"},
-            {8, nullptr, "RegisterInternalPki"},
+            {8, D<&ISslContext::RegisterInternalPki>, "RegisterInternalPki"},
             {9, nullptr, "AddPolicyOid"},
             {10, nullptr, "ImportCrl"},
             {11, nullptr, "RemoveCrl"},
@@ -587,6 +556,11 @@ private:
         rb.Push(ResultSuccess);
         rb.Push(client_id);
     }
+
+    Result RegisterInternalPki() {
+        LOG_WARNING(Service_SSL, "(STUBBED) called");
+        R_SUCCEED();
+    }
 };
 
 class ISslService final : public ServiceFramework<ISslService> {

src/core/hle/service/ssl/ssl_backend.h

@@ -36,12 +36,17 @@ class SSLConnectionBackend {
 public:
     virtual ~SSLConnectionBackend() {}
     virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0;
-    virtual Result SetHostName(const std::string& hostname) = 0;
     virtual void SetVerifyOption(u32 option) = 0;
     virtual Result DoHandshake() = 0;
     virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
+    virtual Result Peek(size_t* out_size, std::span<u8> data) = 0;
     virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
     virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
+    virtual Result SetHostName(const char* hostname) = 0;
+    virtual Result GetHostName(std::span<u8> hostname, u32* out_size) = 0;
+    virtual int Pending() = 0;
+    virtual Result SetRenegotiationMode(u32 mode) = 0;
+    virtual Result GetRenegotiationMode(u32* mode) = 0;
 };
 
 Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -157,18 +157,30 @@ public:
         socket = std::move(socket_in);
     }
 
-    Result SetHostName(const std::string& hostname) override {
+    Result SetHostName(const char* hostname) override {
         if (!skip_cert_verification) {
-            if (!SSL_set1_host(ssl, hostname.c_str())) {
+            if (!SSL_set1_host(ssl, hostname)) {
                 LOG_ERROR(Service_SSL, "SSL_set1_host({}) failed", hostname);
                 return CheckOpenSSLErrors();
             }
         }
-        if (!SSL_set_tlsext_host_name(ssl, hostname.c_str())) { // hostname for SNI
+        if (!SSL_set_tlsext_host_name(ssl, hostname)) { // hostname for SNI
             LOG_ERROR(Service_SSL, "SSL_set_tlsext_host_name({}) failed", hostname);
             return CheckOpenSSLErrors();
         }
-        return ResultSuccess;
+        R_SUCCEED();
+    }
+
+    Result GetHostName(std::span<u8> data, u32* out_size) override {
+        auto const peer_name = SSL_get0_peername(ssl);
+        if (peer_name == nullptr) {
+            LOG_ERROR(Service_SSL, "SSL_get0_peername()");
+            return CheckOpenSSLErrors();
+        }
+        auto const s = std::string{peer_name};
+        *out_size = u32(s.size());
+        std::memcpy(data.data(), s.data(), (std::min)(s.size(), data.size()));
+        R_SUCCEED();
     }
 
     void SetVerifyOption(u32 option) override {
@@ -213,6 +225,13 @@ public:
         return HandleReturn("SSL_read_ex", out_size, ret);
     }
 
+    Result Peek(size_t* out_size, std::span<u8> data) override {
+        auto const n = (std::min)(data.size(), *out_size);
+        const int ret = SSL_peek(ssl, data.data(), int(n));
+        *out_size = n;
+        return HandleReturn("SSL_write_ex", out_size, ret);
+    }
+
     Result Write(size_t* out_size, std::span<const u8> data) override {
         const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
         return HandleReturn("SSL_write_ex", out_size, ret);
@@ -263,7 +282,25 @@ public:
             out_certs->emplace_back(buf, buf + len);
             OPENSSL_free(buf);
         }
-        return ResultSuccess;
+        R_SUCCEED();
+    }
+
+    int Pending() override {
+        return SSL_pending(ssl);
+    }
+
+    Result SetRenegotiationMode(u32 mode) override {
+        if (mode == 0) {
+            SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_RENEGOTIATION);
+        } else {
+            SSL_CTX_set_options(ssl_ctx, SSL_OP_ALLOW_CLIENT_RENEGOTIATION);
+        }
+        R_SUCCEED();
+    }
+
+    Result GetRenegotiationMode(u32* mode) override {
+        *mode = SSL_get_secure_renegotiation_support(ssl) ? 1 : 0;
+        R_SUCCEED();
     }
 
     ~SSLConnectionBackendOpenSSL() {

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -90,7 +90,7 @@ template<>
         code.shl(tmp, int(ctx.conf.page_table_log2_stride));
         code.mov(page, qword[r14 + tmp.cvt64()]);
     } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(ctx.conf.page_table_log2_stride)]);
+        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
     }
 
     // check for marked bit, use as unmapped if marked
@@ -161,8 +161,12 @@ template<>
         code.jnz(abort, code.T_NEAR);
     }
 
-    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-    code.mov(page, qword[r14 + tmp]);
+    if (ctx.conf.page_table_log2_stride > 3) {
+        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+        code.mov(page, qword[r14 + tmp.cvt64()]);
+    } else {
+        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+    }
 
     // check for marked bit, use as unmapped if marked
     if (ctx.conf.page_table_marked_bit) {
@@ -178,6 +182,7 @@ template<>
         code.mov(tmp, ctx.conf.page_table_pointer_mask);
         code.and_(page, tmp);
     }
+    // check for sign bit, apply sign extension as needed
     if (ctx.conf.page_table_sign_extension) {
         code.shl(page, *ctx.conf.page_table_sign_extension);
         code.sar(page, *ctx.conf.page_table_sign_extension);

src/video_core/vulkan_common/vulkan_device.cpp

@@ -993,7 +993,11 @@ bool Device::HasTimelineSemaphore() const {
 }
 
 bool Device::MustEmulateBGR565() const {
+#ifdef __ANDROID__
     return Settings::values.emulate_bgr565.GetValue();
+#else
+    return false;
+#endif
 }
 
 bool Device::GetSuitability(bool requires_swapchain) {

src/yuzu/configuration/shared_widget.cpp

@@ -774,7 +774,7 @@ Builder::~Builder() = default;
 
 static bool IsAndroidOnly(const Settings::BasicSetting& setting) {
     const std::string& label = setting.GetLabel();
-    return label.starts_with("frame_gen") || label == "emulate_bgr565";
+    return label.starts_with("frame_gen");
 }
 
 Widget* Builder::BuildWidget(Settings::BasicSetting* setting,