service: remove strong dependency on kernel headers

.github/workflows/verify.yml

@@ -81,7 +81,8 @@ jobs:
           fetch-depth: 0
       - name: Install dependencies
         run: |
-          brew install autoconf automake boost ccache ffmpeg fmt glslang hidapi libtool libusb lz4 ninja nlohmann-json openssl pkg-config qt@5 sdl2 speexdsp zlib zlib zstd
+          # workaround for https://github.com/actions/setup-python/issues/577
+          brew install autoconf automake boost@1.83 ccache ffmpeg fmt glslang hidapi libtool libusb lz4 ninja nlohmann-json openssl pkg-config qt@5 sdl2 speexdsp zlib zlib zstd || brew link --overwrite python@3.12
       - name: Build
         run: |
           mkdir build

src/common/logging/backend.cpp

@@ -343,7 +343,7 @@ void SetColorConsoleBackendEnabled(bool enabled) {
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
         Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,

src/common/logging/log.h

@@ -24,12 +24,12 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args);
 
 template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, fmt::format_string<Args...> format, const Args&... args) {
+                   const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
                       fmt::make_format_args(args...));
 }

src/common/ring_buffer.h

@@ -8,7 +8,6 @@
 #include <atomic>
 #include <cstddef>
 #include <cstring>
-#include <limits>
 #include <new>
 #include <span>
 #include <type_traits>

src/common/settings.h

@@ -140,7 +140,7 @@ struct Values {
                                                Category::LibraryApplet};
     Setting<AppletMode> data_erase_applet_mode{linkage, AppletMode::HLE, "data_erase_applet_mode",
                                                Category::LibraryApplet};
-    Setting<AppletMode> error_applet_mode{linkage, AppletMode::LLE, "error_applet_mode",
+    Setting<AppletMode> error_applet_mode{linkage, AppletMode::HLE, "error_applet_mode",
                                           Category::LibraryApplet};
     Setting<AppletMode> net_connect_applet_mode{linkage, AppletMode::HLE, "net_connect_applet_mode",
                                                 Category::LibraryApplet};
@@ -435,6 +435,8 @@ struct Values {
         linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
     Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
                                           Category::RendererDebug};
+    // TODO: remove this once AMDVLK supports VK_EXT_depth_bias_control
+    bool renderer_amdvlk_depth_bias_workaround{};
     Setting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
                                          Category::RendererDebug};
 

src/core/CMakeLists.txt

@@ -486,10 +486,8 @@ add_library(core STATIC
     hle/service/am/service/system_applet_proxy.h
     hle/service/am/service/window_controller.cpp
     hle/service/am/service/window_controller.h
-    hle/service/aoc/addon_content_manager.cpp
-    hle/service/aoc/addon_content_manager.h
-    hle/service/aoc/purchase_event_manager.cpp
-    hle/service/aoc/purchase_event_manager.h
+    hle/service/aoc/aoc_u.cpp
+    hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
     hle/service/apm/apm_controller.cpp
@@ -625,8 +623,6 @@ add_library(core STATIC
     hle/service/filesystem/fsp/fsp_srv.cpp
     hle/service/filesystem/fsp/fsp_srv.h
     hle/service/filesystem/fsp/fsp_types.h
-    hle/service/filesystem/fsp/save_data_transfer_prohibiter.cpp
-    hle/service/filesystem/fsp/save_data_transfer_prohibiter.h
     hle/service/filesystem/romfs_controller.cpp
     hle/service/filesystem/romfs_controller.h
     hle/service/filesystem/save_data_controller.cpp
@@ -1047,12 +1043,9 @@ add_library(core STATIC
     hle/service/spl/spl_module.h
     hle/service/spl/spl_results.h
     hle/service/spl/spl_types.h
-    hle/service/ssl/cert_store.cpp
-    hle/service/ssl/cert_store.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
     hle/service/ssl/ssl_backend.h
-    hle/service/ssl/ssl_types.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
     hle/service/vi/application_display_service.cpp

src/core/core.cpp

@@ -425,6 +425,11 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
+        // Workarounds:
+        // Activate this in Super Smash Brothers Ultimate, it only affects AMD cards using AMDVLK
+        Settings::values.renderer_amdvlk_depth_bias_workaround =
+            params.program_id == 0x1006A800016E000ULL;
+
         status = SystemResultStatus::Success;
         return status;
     }
@@ -484,6 +489,9 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
+        // Workarounds
+        Settings::values.renderer_amdvlk_depth_bias_workaround = false;
+
         LOG_DEBUG(Core, "Shutdown OK");
     }
 

src/core/file_sys/fs_save_data_types.h

@@ -164,19 +164,6 @@ static_assert(sizeof(SaveDataExtraData) == 0x200, "SaveDataExtraData has invalid
 static_assert(std::is_trivially_copyable_v<SaveDataExtraData>,
               "Data type must be trivially copyable.");
 
-struct SaveDataFilter {
-    bool use_program_id;
-    bool use_save_data_type;
-    bool use_user_id;
-    bool use_save_data_id;
-    bool use_index;
-    SaveDataRank rank;
-    SaveDataAttribute attribute;
-};
-static_assert(sizeof(SaveDataFilter) == 0x48, "SaveDataFilter has invalid size.");
-static_assert(std::is_trivially_copyable_v<SaveDataFilter>,
-              "Data type must be trivially copyable.");
-
 struct HashSalt {
     static constexpr size_t Size = 32;
 

src/core/file_sys/partition_filesystem.cpp

@@ -105,4 +105,12 @@ VirtualDir PartitionFilesystem::GetParentDirectory() const {
     return nullptr;
 }
 
+void PartitionFilesystem::PrintDebugInfo() const {
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", pfs_header.magic);
+    LOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
+    for (u32 i = 0; i < pfs_header.num_entries; i++) {
+        LOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes)", i,
+                  pfs_files[i]->GetName(), pfs_files[i]->GetSize());
+    }
+}
 } // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -35,6 +35,7 @@ public:
     std::vector<VirtualDir> GetSubdirectories() const override;
     std::string GetName() const override;
     VirtualDir GetParentDirectory() const override;
+    void PrintDebugInfo() const;
 
 private:
     struct Header {

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

@@ -25,8 +25,8 @@
 #include "core/hle/service/acc/async_context.h"
 #include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/glue/glue_manager.h"
+#include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
@@ -74,12 +74,12 @@ static void SanitizeJPEGImageSize(std::vector<u8>& image) {
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
 public:
-    explicit IManagerForSystemService(Core::System& system_, Common::UUID uuid)
-        : ServiceFramework{system_, "IManagerForSystemService"}, account_id{uuid} {
+    explicit IManagerForSystemService(Core::System& system_, Common::UUID)
+        : ServiceFramework{system_, "IManagerForSystemService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, D<&IManagerForSystemService::CheckAvailability>, "CheckAvailability"},
-            {1, D<&IManagerForSystemService::GetAccountId>, "GetAccountId"},
+            {0, &IManagerForSystemService::CheckAvailability, "CheckAvailability"},
+            {1, nullptr, "GetAccountId"},
             {2, nullptr, "EnsureIdTokenCacheAsync"},
             {3, nullptr, "LoadIdTokenCache"},
             {100, nullptr, "SetSystemProgramIdentification"},
@@ -109,18 +109,11 @@ public:
     }
 
 private:
-    Result CheckAvailability() {
+    void CheckAvailability(HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
-
-    Result GetAccountId(Out<u64> out_account_id) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        *out_account_id = account_id.Hash();
-        R_SUCCEED();
-    }
-
-    Common::UUID account_id;
 };
 
 // 3.0.0+

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

@@ -23,7 +23,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, &ACC_U1::GetBaasAccountManagerForSystemService, "GetBaasAccountManagerForSystemService"},
+        {102, nullptr, "GetBaasAccountManagerForSystemService"},
         {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
         {104, nullptr, "GetProfileUpdateNotifier"},
         {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},

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

@@ -48,6 +48,11 @@ enum class SystemButtonType {
     CaptureButtonLongPressing,
 };
 
+enum class SysPlatformRegion : s32 {
+    Global = 1,
+    Terra = 2,
+};
+
 struct AppletProcessLaunchReason {
     u8 flag;
     INSERT_PADDING_BYTES(3);

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

@@ -6,6 +6,7 @@
 #include <mutex>
 
 #include "common/math_util.h"
+#include "core/hle/result.h"
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/kernel_helpers.h"

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/kernel/k_event.h"
 #include "core/hle/service/am/applet_message_queue.h"
 #include "core/hle/service/ipc_helpers.h"
 

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/service/applet_common_functions.h"
 #include "core/hle/service/cmif_serialization.h"

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

@@ -14,7 +14,8 @@ enum class SaveDataType : u8;
 
 namespace Kernel {
 class KReadableEvent;
-}
+class KTransferMemory;
+} // namespace Kernel
 
 namespace Service::AM {
 

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

@@ -260,9 +260,9 @@ Result ICommonStateGetter::GetAppletLaunchedHistory(
 }
 
 Result ICommonStateGetter::GetSettingsPlatformRegion(
-    Out<Set::PlatformRegion> out_settings_platform_region) {
+    Out<SysPlatformRegion> out_settings_platform_region) {
     LOG_INFO(Service_AM, "called");
-    *out_settings_platform_region = Set::PlatformRegion::Global;
+    *out_settings_platform_region = SysPlatformRegion::Global;
     R_SUCCEED();
 }
 

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

@@ -8,7 +8,6 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/set/settings_types.h"
 
 namespace Kernel {
 class KReadableEvent;
@@ -51,7 +50,7 @@ private:
     Result GetOperationModeSystemInfo(Out<u32> out_operation_mode_system_info);
     Result GetAppletLaunchedHistory(Out<s32> out_count,
                                     OutArray<AppletId, BufferAttr_HipcMapAlias> out_applet_ids);
-    Result GetSettingsPlatformRegion(Out<Set::PlatformRegion> out_settings_platform_region);
+    Result GetSettingsPlatformRegion(Out<SysPlatformRegion> out_settings_platform_region);
     Result SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled();
 
     void SetCpuBoostMode(HLERequestContext& ctx);

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

@@ -7,6 +7,10 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
+namespace Kernel {
+class KTransferMemory;
+}
+
 namespace Service::AM {
 
 struct Applet;

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

@@ -1,223 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <algorithm>
-#include <numeric>
-#include <vector>
-
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "core/core.h"
-#include "core/file_sys/common_funcs.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/patch_manager.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/service/aoc/addon_content_manager.h"
-#include "core/hle/service/aoc/purchase_event_manager.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/server_manager.h"
-#include "core/loader/loader.h"
-
-namespace Service::AOC {
-
-static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
-    return FileSys::GetBaseTitleID(title_id) == base;
-}
-
-static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
-    std::vector<u64> add_on_content;
-    const auto& rcu = system.GetContentProvider();
-    const auto list =
-        rcu.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
-    std::transform(list.begin(), list.end(), std::back_inserter(add_on_content),
-                   [](const FileSys::ContentProviderEntry& rce) { return rce.title_id; });
-    add_on_content.erase(
-        std::remove_if(
-            add_on_content.begin(), add_on_content.end(),
-            [&rcu](u64 tid) {
-                return rcu.GetEntry(tid, FileSys::ContentRecordType::Data)->GetStatus() !=
-                       Loader::ResultStatus::Success;
-            }),
-        add_on_content.end());
-    return add_on_content;
-}
-
-IAddOnContentManager::IAddOnContentManager(Core::System& system_)
-    : ServiceFramework{system_, "aoc:u"}, add_on_content{AccumulateAOCTitleIDs(system)},
-      service_context{system_, "aoc:u"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "CountAddOnContentByApplicationId"},
-        {1, nullptr, "ListAddOnContentByApplicationId"},
-        {2, D<&IAddOnContentManager::CountAddOnContent>, "CountAddOnContent"},
-        {3, D<&IAddOnContentManager::ListAddOnContent>, "ListAddOnContent"},
-        {4, nullptr, "GetAddOnContentBaseIdByApplicationId"},
-        {5, D<&IAddOnContentManager::GetAddOnContentBaseId>, "GetAddOnContentBaseId"},
-        {6, nullptr, "PrepareAddOnContentByApplicationId"},
-        {7, D<&IAddOnContentManager::PrepareAddOnContent>, "PrepareAddOnContent"},
-        {8, D<&IAddOnContentManager::GetAddOnContentListChangedEvent>, "GetAddOnContentListChangedEvent"},
-        {9, nullptr, "GetAddOnContentLostErrorCode"},
-        {10, D<&IAddOnContentManager::GetAddOnContentListChangedEventWithProcessId>, "GetAddOnContentListChangedEventWithProcessId"},
-        {11, D<&IAddOnContentManager::NotifyMountAddOnContent>, "NotifyMountAddOnContent"},
-        {12, D<&IAddOnContentManager::NotifyUnmountAddOnContent>, "NotifyUnmountAddOnContent"},
-        {13, nullptr, "IsAddOnContentMountedForDebug"},
-        {50, D<&IAddOnContentManager::CheckAddOnContentMountStatus>, "CheckAddOnContentMountStatus"},
-        {100, D<&IAddOnContentManager::CreateEcPurchasedEventManager>, "CreateEcPurchasedEventManager"},
-        {101, D<&IAddOnContentManager::CreatePermanentEcPurchasedEventManager>, "CreatePermanentEcPurchasedEventManager"},
-        {110, nullptr, "CreateContentsServiceManager"},
-        {200, nullptr, "SetRequiredAddOnContentsOnContentsAvailabilityTransition"},
-        {300, nullptr, "SetupHostAddOnContent"},
-        {301, nullptr, "GetRegisteredAddOnContentPath"},
-        {302, nullptr, "UpdateCachedList"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
-    aoc_change_event = service_context.CreateEvent("GetAddOnContentListChanged:Event");
-}
-
-IAddOnContentManager::~IAddOnContentManager() {
-    service_context.CloseEvent(aoc_change_event);
-}
-
-Result IAddOnContentManager::CountAddOnContent(Out<u32> out_count, ClientProcessId process_id) {
-    LOG_DEBUG(Service_AOC, "called. process_id={}", process_id.pid);
-
-    const auto current = system.GetApplicationProcessProgramID();
-
-    const auto& disabled = Settings::values.disabled_addons[current];
-    if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
-        *out_count = 0;
-        R_SUCCEED();
-    }
-
-    *out_count = static_cast<u32>(
-        std::count_if(add_on_content.begin(), add_on_content.end(),
-                      [current](u64 tid) { return CheckAOCTitleIDMatchesBase(tid, current); }));
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::ListAddOnContent(Out<u32> out_count,
-                                              OutBuffer<BufferAttr_HipcMapAlias> out_addons,
-                                              u32 offset, u32 count, ClientProcessId process_id) {
-    LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
-              process_id.pid);
-
-    const auto current = FileSys::GetBaseTitleID(system.GetApplicationProcessProgramID());
-
-    std::vector<u32> out;
-    const auto& disabled = Settings::values.disabled_addons[current];
-    if (std::find(disabled.begin(), disabled.end(), "DLC") == disabled.end()) {
-        for (u64 content_id : add_on_content) {
-            if (FileSys::GetBaseTitleID(content_id) != current) {
-                continue;
-            }
-
-            out.push_back(static_cast<u32>(FileSys::GetAOCID(content_id)));
-        }
-    }
-
-    // TODO(DarkLordZach): Find the correct error code.
-    R_UNLESS(out.size() >= offset, ResultUnknown);
-
-    *out_count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
-    std::rotate(out.begin(), out.begin() + offset, out.end());
-
-    std::memcpy(out_addons.data(), out.data(), *out_count * sizeof(u32));
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::GetAddOnContentBaseId(Out<u64> out_title_id,
-                                                   ClientProcessId process_id) {
-    LOG_DEBUG(Service_AOC, "called. process_id={}", process_id.pid);
-
-    const auto title_id = system.GetApplicationProcessProgramID();
-    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
-                                   system.GetContentProvider()};
-
-    const auto res = pm.GetControlMetadata();
-    if (res.first == nullptr) {
-        *out_title_id = FileSys::GetAOCBaseTitleID(title_id);
-        R_SUCCEED();
-    }
-
-    *out_title_id = res.first->GetDLCBaseTitleId();
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::PrepareAddOnContent(s32 addon_index, ClientProcessId process_id) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called with addon_index={}, process_id={}", addon_index,
-                process_id.pid);
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::GetAddOnContentListChangedEvent(
-    OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    *out_event = &aoc_change_event->GetReadableEvent();
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::GetAddOnContentListChangedEventWithProcessId(
-    OutCopyHandle<Kernel::KReadableEvent> out_event, ClientProcessId process_id) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    *out_event = &aoc_change_event->GetReadableEvent();
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::NotifyMountAddOnContent() {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::NotifyUnmountAddOnContent() {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::CheckAddOnContentMountStatus() {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::CreateEcPurchasedEventManager(
-    OutInterface<IPurchaseEventManager> out_interface) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    *out_interface = std::make_shared<IPurchaseEventManager>(system);
-
-    R_SUCCEED();
-}
-
-Result IAddOnContentManager::CreatePermanentEcPurchasedEventManager(
-    OutInterface<IPurchaseEventManager> out_interface) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    *out_interface = std::make_shared<IPurchaseEventManager>(system);
-
-    R_SUCCEED();
-}
-
-void LoopProcess(Core::System& system) {
-    auto server_manager = std::make_unique<ServerManager>(system);
-    server_manager->RegisterNamedService("aoc:u", std::make_shared<IAddOnContentManager>(system));
-    ServerManager::RunServer(std::move(server_manager));
-}
-
-} // namespace Service::AOC

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

@@ -1,51 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KEvent;
-}
-
-namespace Service::AOC {
-
-class IPurchaseEventManager;
-
-class IAddOnContentManager final : public ServiceFramework<IAddOnContentManager> {
-public:
-    explicit IAddOnContentManager(Core::System& system);
-    ~IAddOnContentManager() override;
-
-    Result CountAddOnContent(Out<u32> out_count, ClientProcessId process_id);
-    Result ListAddOnContent(Out<u32> out_count, OutBuffer<BufferAttr_HipcMapAlias> out_addons,
-                            u32 offset, u32 count, ClientProcessId process_id);
-    Result GetAddOnContentBaseId(Out<u64> out_title_id, ClientProcessId process_id);
-    Result PrepareAddOnContent(s32 addon_index, ClientProcessId process_id);
-    Result GetAddOnContentListChangedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
-    Result GetAddOnContentListChangedEventWithProcessId(
-        OutCopyHandle<Kernel::KReadableEvent> out_event, ClientProcessId process_id);
-    Result NotifyMountAddOnContent();
-    Result NotifyUnmountAddOnContent();
-    Result CheckAddOnContentMountStatus();
-    Result CreateEcPurchasedEventManager(OutInterface<IPurchaseEventManager> out_interface);
-    Result CreatePermanentEcPurchasedEventManager(
-        OutInterface<IPurchaseEventManager> out_interface);
-
-private:
-    std::vector<u64> add_on_content;
-    KernelHelpers::ServiceContext service_context;
-
-    Kernel::KEvent* aoc_change_event;
-};
-
-void LoopProcess(Core::System& system);
-
-} // namespace Service::AOC

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

@@ -0,0 +1,340 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <numeric>
+#include <vector>
+
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/file_sys/common_funcs.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/control_metadata.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/patch_manager.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/aoc/aoc_u.h"
+#include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/server_manager.h"
+#include "core/loader/loader.h"
+
+namespace Service::AOC {
+
+constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
+
+static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
+    return FileSys::GetBaseTitleID(title_id) == base;
+}
+
+static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
+    std::vector<u64> add_on_content;
+    const auto& rcu = system.GetContentProvider();
+    const auto list =
+        rcu.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
+    std::transform(list.begin(), list.end(), std::back_inserter(add_on_content),
+                   [](const FileSys::ContentProviderEntry& rce) { return rce.title_id; });
+    add_on_content.erase(
+        std::remove_if(
+            add_on_content.begin(), add_on_content.end(),
+            [&rcu](u64 tid) {
+                return rcu.GetEntry(tid, FileSys::ContentRecordType::Data)->GetStatus() !=
+                       Loader::ResultStatus::Success;
+            }),
+        add_on_content.end());
+    return add_on_content;
+}
+
+class IPurchaseEventManager final : public ServiceFramework<IPurchaseEventManager> {
+public:
+    explicit IPurchaseEventManager(Core::System& system_)
+        : ServiceFramework{system_, "IPurchaseEventManager"}, service_context{
+                                                                  system, "IPurchaseEventManager"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IPurchaseEventManager::SetDefaultDeliveryTarget, "SetDefaultDeliveryTarget"},
+            {1, &IPurchaseEventManager::SetDeliveryTarget, "SetDeliveryTarget"},
+            {2, &IPurchaseEventManager::GetPurchasedEventReadableHandle, "GetPurchasedEventReadableHandle"},
+            {3, &IPurchaseEventManager::PopPurchasedProductInfo, "PopPurchasedProductInfo"},
+            {4, &IPurchaseEventManager::PopPurchasedProductInfoWithUid, "PopPurchasedProductInfoWithUid"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+
+        purchased_event = service_context.CreateEvent("IPurchaseEventManager:PurchasedEvent");
+    }
+
+    ~IPurchaseEventManager() override {
+        service_context.CloseEvent(purchased_event);
+    }
+
+private:
+    void SetDefaultDeliveryTarget(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        const auto unknown_1 = rp.Pop<u64>();
+        [[maybe_unused]] const auto unknown_2 = ctx.ReadBuffer();
+
+        LOG_WARNING(Service_AOC, "(STUBBED) called, unknown_1={}", unknown_1);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void SetDeliveryTarget(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        const auto unknown_1 = rp.Pop<u64>();
+        [[maybe_unused]] const auto unknown_2 = ctx.ReadBuffer();
+
+        LOG_WARNING(Service_AOC, "(STUBBED) called, unknown_1={}", unknown_1);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
+
+    void GetPurchasedEventReadableHandle(HLERequestContext& ctx) {
+        LOG_WARNING(Service_AOC, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(purchased_event->GetReadableEvent());
+    }
+
+    void PopPurchasedProductInfo(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AOC, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultNoPurchasedProductInfoAvailable);
+    }
+
+    void PopPurchasedProductInfoWithUid(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_AOC, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultNoPurchasedProductInfoAvailable);
+    }
+
+    KernelHelpers::ServiceContext service_context;
+
+    Kernel::KEvent* purchased_event;
+};
+
+AOC_U::AOC_U(Core::System& system_)
+    : ServiceFramework{system_, "aoc:u"}, add_on_content{AccumulateAOCTitleIDs(system)},
+      service_context{system_, "aoc:u"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "CountAddOnContentByApplicationId"},
+        {1, nullptr, "ListAddOnContentByApplicationId"},
+        {2, &AOC_U::CountAddOnContent, "CountAddOnContent"},
+        {3, &AOC_U::ListAddOnContent, "ListAddOnContent"},
+        {4, nullptr, "GetAddOnContentBaseIdByApplicationId"},
+        {5, &AOC_U::GetAddOnContentBaseId, "GetAddOnContentBaseId"},
+        {6, nullptr, "PrepareAddOnContentByApplicationId"},
+        {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
+        {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
+        {9, nullptr, "GetAddOnContentLostErrorCode"},
+        {10, &AOC_U::GetAddOnContentListChangedEventWithProcessId, "GetAddOnContentListChangedEventWithProcessId"},
+        {11, &AOC_U::NotifyMountAddOnContent, "NotifyMountAddOnContent"},
+        {12, &AOC_U::NotifyUnmountAddOnContent, "NotifyUnmountAddOnContent"},
+        {13, nullptr, "IsAddOnContentMountedForDebug"},
+        {50, &AOC_U::CheckAddOnContentMountStatus, "CheckAddOnContentMountStatus"},
+        {100, &AOC_U::CreateEcPurchasedEventManager, "CreateEcPurchasedEventManager"},
+        {101, &AOC_U::CreatePermanentEcPurchasedEventManager, "CreatePermanentEcPurchasedEventManager"},
+        {110, nullptr, "CreateContentsServiceManager"},
+        {200, nullptr, "SetRequiredAddOnContentsOnContentsAvailabilityTransition"},
+        {300, nullptr, "SetupHostAddOnContent"},
+        {301, nullptr, "GetRegisteredAddOnContentPath"},
+        {302, nullptr, "UpdateCachedList"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+
+    aoc_change_event = service_context.CreateEvent("GetAddOnContentListChanged:Event");
+}
+
+AOC_U::~AOC_U() {
+    service_context.CloseEvent(aoc_change_event);
+}
+
+void AOC_U::CountAddOnContent(HLERequestContext& ctx) {
+    struct Parameters {
+        u64 process_id;
+    };
+    static_assert(sizeof(Parameters) == 8);
+
+    IPC::RequestParser rp{ctx};
+    const auto params = rp.PopRaw<Parameters>();
+
+    LOG_DEBUG(Service_AOC, "called. process_id={}", params.process_id);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+
+    const auto current = system.GetApplicationProcessProgramID();
+
+    const auto& disabled = Settings::values.disabled_addons[current];
+    if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end()) {
+        rb.Push<u32>(0);
+        return;
+    }
+
+    rb.Push<u32>(static_cast<u32>(
+        std::count_if(add_on_content.begin(), add_on_content.end(),
+                      [current](u64 tid) { return CheckAOCTitleIDMatchesBase(tid, current); })));
+}
+
+void AOC_U::ListAddOnContent(HLERequestContext& ctx) {
+    struct Parameters {
+        u32 offset;
+        u32 count;
+        u64 process_id;
+    };
+    static_assert(sizeof(Parameters) == 16);
+
+    IPC::RequestParser rp{ctx};
+    const auto [offset, count, process_id] = rp.PopRaw<Parameters>();
+
+    LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
+              process_id);
+
+    const auto current = FileSys::GetBaseTitleID(system.GetApplicationProcessProgramID());
+
+    std::vector<u32> out;
+    const auto& disabled = Settings::values.disabled_addons[current];
+    if (std::find(disabled.begin(), disabled.end(), "DLC") == disabled.end()) {
+        for (u64 content_id : add_on_content) {
+            if (FileSys::GetBaseTitleID(content_id) != current) {
+                continue;
+            }
+
+            out.push_back(static_cast<u32>(FileSys::GetAOCID(content_id)));
+        }
+    }
+
+    if (out.size() < offset) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        // TODO(DarkLordZach): Find the correct error code.
+        rb.Push(ResultUnknown);
+        return;
+    }
+
+    const auto out_count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
+    std::rotate(out.begin(), out.begin() + offset, out.end());
+    out.resize(out_count);
+
+    ctx.WriteBuffer(out);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push(out_count);
+}
+
+void AOC_U::GetAddOnContentBaseId(HLERequestContext& ctx) {
+    struct Parameters {
+        u64 process_id;
+    };
+    static_assert(sizeof(Parameters) == 8);
+
+    IPC::RequestParser rp{ctx};
+    const auto params = rp.PopRaw<Parameters>();
+
+    LOG_DEBUG(Service_AOC, "called. process_id={}", params.process_id);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+
+    const auto title_id = system.GetApplicationProcessProgramID();
+    const FileSys::PatchManager pm{title_id, system.GetFileSystemController(),
+                                   system.GetContentProvider()};
+
+    const auto res = pm.GetControlMetadata();
+    if (res.first == nullptr) {
+        rb.Push(FileSys::GetAOCBaseTitleID(title_id));
+        return;
+    }
+
+    rb.Push(res.first->GetDLCBaseTitleId());
+}
+
+void AOC_U::PrepareAddOnContent(HLERequestContext& ctx) {
+    struct Parameters {
+        s32 addon_index;
+        u64 process_id;
+    };
+    static_assert(sizeof(Parameters) == 16);
+
+    IPC::RequestParser rp{ctx};
+    const auto [addon_index, process_id] = rp.PopRaw<Parameters>();
+
+    LOG_WARNING(Service_AOC, "(STUBBED) called with addon_index={}, process_id={}", addon_index,
+                process_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void AOC_U::GetAddOnContentListChangedEvent(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(aoc_change_event->GetReadableEvent());
+}
+
+void AOC_U::GetAddOnContentListChangedEventWithProcessId(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(aoc_change_event->GetReadableEvent());
+}
+
+void AOC_U::NotifyMountAddOnContent(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void AOC_U::NotifyUnmountAddOnContent(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void AOC_U::CheckAddOnContentMountStatus(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void AOC_U::CreateEcPurchasedEventManager(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IPurchaseEventManager>(system);
+}
+
+void AOC_U::CreatePermanentEcPurchasedEventManager(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IPurchaseEventManager>(system);
+}
+
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+    server_manager->RegisterNamedService("aoc:u", std::make_shared<AOC_U>(system));
+    ServerManager::RunServer(std::move(server_manager));
+}
+
+} // namespace Service::AOC

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

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KEvent;
+}
+
+namespace Service::AOC {
+
+class AOC_U final : public ServiceFramework<AOC_U> {
+public:
+    explicit AOC_U(Core::System& system);
+    ~AOC_U() override;
+
+private:
+    void CountAddOnContent(HLERequestContext& ctx);
+    void ListAddOnContent(HLERequestContext& ctx);
+    void GetAddOnContentBaseId(HLERequestContext& ctx);
+    void PrepareAddOnContent(HLERequestContext& ctx);
+    void GetAddOnContentListChangedEvent(HLERequestContext& ctx);
+    void GetAddOnContentListChangedEventWithProcessId(HLERequestContext& ctx);
+    void NotifyMountAddOnContent(HLERequestContext& ctx);
+    void NotifyUnmountAddOnContent(HLERequestContext& ctx);
+    void CheckAddOnContentMountStatus(HLERequestContext& ctx);
+    void CreateEcPurchasedEventManager(HLERequestContext& ctx);
+    void CreatePermanentEcPurchasedEventManager(HLERequestContext& ctx);
+
+    std::vector<u64> add_on_content;
+    KernelHelpers::ServiceContext service_context;
+
+    Kernel::KEvent* aoc_change_event;
+};
+
+void LoopProcess(Core::System& system);
+
+} // namespace Service::AOC

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

@@ -1,67 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/aoc/purchase_event_manager.h"
-#include "core/hle/service/cmif_serialization.h"
-
-namespace Service::AOC {
-
-constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
-
-IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
-    : ServiceFramework{system_, "IPurchaseEventManager"}, service_context{system,
-                                                                          "IPurchaseEventManager"} {
-    // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},
-            {1, D<&IPurchaseEventManager::SetDeliveryTarget>, "SetDeliveryTarget"},
-            {2, D<&IPurchaseEventManager::GetPurchasedEvent>, "GetPurchasedEvent"},
-            {3, D<&IPurchaseEventManager::PopPurchasedProductInfo>, "PopPurchasedProductInfo"},
-            {4, D<&IPurchaseEventManager::PopPurchasedProductInfoWithUid>, "PopPurchasedProductInfoWithUid"},
-        };
-    // clang-format on
-
-    RegisterHandlers(functions);
-
-    purchased_event = service_context.CreateEvent("IPurchaseEventManager:PurchasedEvent");
-}
-
-IPurchaseEventManager::~IPurchaseEventManager() {
-    service_context.CloseEvent(purchased_event);
-}
-
-Result IPurchaseEventManager::SetDefaultDeliveryTarget(
-    ClientProcessId process_id, InBuffer<BufferAttr_HipcMapAlias> in_buffer) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called, process_id={}", process_id.pid);
-
-    R_SUCCEED();
-}
-
-Result IPurchaseEventManager::SetDeliveryTarget(u64 unknown,
-                                                InBuffer<BufferAttr_HipcMapAlias> in_buffer) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called, unknown={}", unknown);
-
-    R_SUCCEED();
-}
-
-Result IPurchaseEventManager::GetPurchasedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
-    LOG_WARNING(Service_AOC, "called");
-
-    *out_event = &purchased_event->GetReadableEvent();
-
-    R_SUCCEED();
-}
-
-Result IPurchaseEventManager::PopPurchasedProductInfo() {
-    LOG_DEBUG(Service_AOC, "(STUBBED) called");
-
-    R_RETURN(ResultNoPurchasedProductInfoAvailable);
-}
-
-Result IPurchaseEventManager::PopPurchasedProductInfoWithUid() {
-    LOG_DEBUG(Service_AOC, "(STUBBED) called");
-
-    R_RETURN(ResultNoPurchasedProductInfoAvailable);
-}
-
-} // namespace Service::AOC

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

@@ -1,30 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/os/event.h"
-#include "core/hle/service/service.h"
-
-namespace Service::AOC {
-
-class IPurchaseEventManager final : public ServiceFramework<IPurchaseEventManager> {
-public:
-    explicit IPurchaseEventManager(Core::System& system_);
-    ~IPurchaseEventManager() override;
-
-    Result SetDefaultDeliveryTarget(ClientProcessId process_id,
-                                    InBuffer<BufferAttr_HipcMapAlias> in_buffer);
-    Result SetDeliveryTarget(u64 unknown, InBuffer<BufferAttr_HipcMapAlias> in_buffer);
-    Result GetPurchasedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
-    Result PopPurchasedProductInfo();
-    Result PopPurchasedProductInfoWithUid();
-
-private:
-    KernelHelpers::ServiceContext service_context;
-    Kernel::KEvent* purchased_event;
-};
-
-} // namespace Service::AOC

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

@@ -138,7 +138,7 @@ Result IAudioController::SetOutputModeSetting(Set::AudioOutputModeTarget target,
 }
 
 Result IAudioController::SetHeadphoneOutputLevelMode(HeadphoneOutputLevelMode output_level_mode) {
-    LOG_WARNING(Audio, "(STUBBED) called, output_level_mode={}", output_level_mode);
+    LOG_WARNING(Audio, "(STUBBED) called");
     R_SUCCEED();
 }
 

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

@@ -3,6 +3,8 @@
 
 #include "audio_core/audio_core.h"
 #include "common/string_util.h"
+#include "core/core.h"
+#include "core/hle/kernel/k_event.h"
 #include "core/hle/service/audio/audio_device.h"
 #include "core/hle/service/cmif_serialization.h"
 

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/audio/audio_in.h"
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"

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

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/audio/audio_renderer.h"
 #include "core/hle/service/cmif_serialization.h"
 

src/core/hle/service/bcat/news/newly_arrived_event_holder.cpp

@@ -7,9 +7,8 @@
 namespace Service::News {
 
 INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
-    : ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
-                                                                 system_,
-                                                                 "INewlyArrivedEventHolder"} {
+    : ServiceFramework{system_, "INewlyArrivedEventHolder"},
+      service_context{system_, "INewlyArrivedEventHolder"}, arrived_event{service_context} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&INewlyArrivedEventHolder::Get>, "Get"},
@@ -17,17 +16,14 @@ INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
     // clang-format on
 
     RegisterHandlers(functions);
-    arrived_event = service_context.CreateEvent("INewlyArrivedEventHolder::ArrivedEvent");
 }
 
-INewlyArrivedEventHolder::~INewlyArrivedEventHolder() {
-    service_context.CloseEvent(arrived_event);
-}
+INewlyArrivedEventHolder::~INewlyArrivedEventHolder() = default;
 
 Result INewlyArrivedEventHolder::Get(OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_INFO(Service_BCAT, "called");
 
-    *out_event = &arrived_event->GetReadableEvent();
+    *out_event = arrived_event.GetHandle();
     R_SUCCEED();
 }
 

src/core/hle/service/bcat/news/newly_arrived_event_holder.h

@@ -5,6 +5,7 @@
 
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/os/event.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -26,8 +27,8 @@ public:
 private:
     Result Get(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
-    Kernel::KEvent* arrived_event;
     KernelHelpers::ServiceContext service_context;
+    Event arrived_event;
 };
 
 } // namespace Service::News

src/core/hle/service/bcat/news/overwrite_event_holder.cpp

@@ -7,8 +7,8 @@
 namespace Service::News {
 
 IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
-    : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
-                                                                          "IOverwriteEventHolder"} {
+    : ServiceFramework{system_, "IOverwriteEventHolder"},
+      service_context{system_, "IOverwriteEventHolder"}, overwrite_event{service_context} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IOverwriteEventHolder::Get>, "Get"},
@@ -16,17 +16,14 @@ IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
     // clang-format on
 
     RegisterHandlers(functions);
-    overwrite_event = service_context.CreateEvent("IOverwriteEventHolder::OverwriteEvent");
 }
 
-IOverwriteEventHolder::~IOverwriteEventHolder() {
-    service_context.CloseEvent(overwrite_event);
-}
+IOverwriteEventHolder::~IOverwriteEventHolder() = default;
 
 Result IOverwriteEventHolder::Get(OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_INFO(Service_BCAT, "called");
 
-    *out_event = &overwrite_event->GetReadableEvent();
+    *out_event = overwrite_event.GetHandle();
     R_SUCCEED();
 }
 

src/core/hle/service/bcat/news/overwrite_event_holder.h

@@ -5,6 +5,7 @@
 
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/os/event.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -26,8 +27,8 @@ public:
 private:
     Result Get(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
-    Kernel::KEvent* overwrite_event;
     KernelHelpers::ServiceContext service_context;
+    Event overwrite_event;
 };
 
 } // namespace Service::News

src/core/hle/service/bcat/service_creator.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
 #include "core/hle/service/bcat/bcat_service.h"
 #include "core/hle/service/bcat/delivery_cache_storage_service.h"
 #include "core/hle/service/bcat/service_creator.h"

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

@@ -5,7 +5,6 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/btdrv/btdrv.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/server_manager.h"
@@ -14,9 +13,9 @@
 
 namespace Service::BtDrv {
 
-class IBluetoothUser final : public ServiceFramework<IBluetoothUser> {
+class Bt final : public ServiceFramework<Bt> {
 public:
-    explicit IBluetoothUser(Core::System& system_)
+    explicit Bt(Core::System& system_)
         : ServiceFramework{system_, "bt"}, service_context{system_, "bt"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -29,7 +28,7 @@ public:
             {6, nullptr, "SetLeResponse"},
             {7, nullptr, "LeSendIndication"},
             {8, nullptr, "GetLeEventInfo"},
-            {9, C<&IBluetoothUser::RegisterBleEvent>, "RegisterBleEvent"},
+            {9, &Bt::RegisterBleEvent, "RegisterBleEvent"},
         };
         // clang-format on
         RegisterHandlers(functions);
@@ -37,16 +36,17 @@ public:
         register_event = service_context.CreateEvent("BT:RegisterEvent");
     }
 
-    ~IBluetoothUser() override {
+    ~Bt() override {
         service_context.CloseEvent(register_event);
     }
 
 private:
-    Result RegisterBleEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
+    void RegisterBleEvent(HLERequestContext& ctx) {
         LOG_WARNING(Service_BTM, "(STUBBED) called");
 
-        *out_event = &register_event->GetReadableEvent();
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(ResultSuccess);
+        rb.PushCopyObjects(register_event->GetReadableEvent());
     }
 
     KernelHelpers::ServiceContext service_context;
@@ -54,9 +54,9 @@ private:
     Kernel::KEvent* register_event;
 };
 
-class IBluetoothDriver final : public ServiceFramework<IBluetoothDriver> {
+class BtDrv final : public ServiceFramework<BtDrv> {
 public:
-    explicit IBluetoothDriver(Core::System& system_) : ServiceFramework{system_, "btdrv"} {
+    explicit BtDrv(Core::System& system_) : ServiceFramework{system_, "btdrv"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "InitializeBluetoothDriver"},
@@ -93,7 +93,7 @@ public:
             {31, nullptr, "EnableMcMode"},
             {32, nullptr, "EnableLlrScan"},
             {33, nullptr, "DisableLlrScan"},
-            {34, C<&IBluetoothDriver::EnableRadio>, "EnableRadio"},
+            {34, nullptr, "EnableRadio"},
             {35, nullptr, "SetVisibility"},
             {36, nullptr, "EnableTbfcScan"},
             {37, nullptr, "RegisterHidReportEvent"},
@@ -195,19 +195,13 @@ public:
 
         RegisterHandlers(functions);
     }
-
-private:
-    Result EnableRadio() {
-        LOG_WARNING(Service_BTDRV, "(STUBBED) called");
-        R_SUCCEED();
-    }
 };
 
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
-    server_manager->RegisterNamedService("btdrv", std::make_shared<IBluetoothDriver>(system));
-    server_manager->RegisterNamedService("bt", std::make_shared<IBluetoothUser>(system));
+    server_manager->RegisterNamedService("btdrv", std::make_shared<BtDrv>(system));
+    server_manager->RegisterNamedService("bt", std::make_shared<Bt>(system));
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/cmif_serialization.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "common/alignment.h"
 #include "common/div_ceil.h"
 
 #include "core/hle/service/cmif_types.h"
@@ -284,7 +285,7 @@ void ReadInArgument(bool is_domain, CallArguments& args, const u8* raw_data, HLE
 
             return ReadInArgument<MethodArguments, CallArguments, ArgAlign, ArgEnd, HandleIndex, InBufferIndex, OutBufferIndex, true, ArgIndex + 1>(is_domain, args, raw_data, ctx, temp);
         } else if constexpr (ArgumentTraits<ArgType>::Type == ArgumentType::InCopyHandle) {
-            std::get<ArgIndex>(args) = ctx.GetObjectFromHandle<typename ArgType::Type>(ctx.GetCopyHandle(HandleIndex)).GetPointerUnsafe();
+            std::get<ArgIndex>(args) = ctx.GetObjectFromHandle<typename ArgType::Type>(ctx.GetCopyHandle(HandleIndex));
 
             return ReadInArgument<MethodArguments, CallArguments, PrevAlign, DataOffset, HandleIndex + 1, InBufferIndex, OutBufferIndex, RawDataFinished, ArgIndex + 1>(is_domain, args, raw_data, ctx, temp);
         } else if constexpr (ArgumentTraits<ArgType>::Type == ArgumentType::InLargeData) {

src/core/hle/service/cmif_types.h

@@ -7,6 +7,7 @@
 #include <span>
 
 #include "common/common_types.h"
+#include "core/hle/result.h"
 
 namespace Service {
 

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

@@ -18,7 +18,7 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, C<&ErrorReportContext::SubmitContext>, "SubmitContext"},
-            {1, C<&ErrorReportContext::CreateReportV0>, "CreateReportV0"},
+            {1, nullptr, "CreateReportV0"},
             {2, nullptr, "SetInitialLaunchSettingsCompletionTime"},
             {3, nullptr, "ClearInitialLaunchSettingsCompletionTime"},
             {4, nullptr, "UpdatePowerOnTime"},
@@ -28,8 +28,7 @@ public:
             {8, nullptr, "ClearApplicationLaunchTime"},
             {9, nullptr, "SubmitAttachment"},
             {10, nullptr, "CreateReportWithAttachments"},
-            {11, C<&ErrorReportContext::CreateReportV1>, "CreateReportV1"},
-            {12, C<&ErrorReportContext::CreateReport>, "CreateReport"},
+            {11, nullptr, "CreateReport"},
             {20, nullptr, "RegisterRunningApplet"},
             {21, nullptr, "UnregisterRunningApplet"},
             {22, nullptr, "UpdateAppletSuspendedDuration"},
@@ -41,37 +40,10 @@ public:
     }
 
 private:
-    Result SubmitContext(InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                         InBuffer<BufferAttr_HipcMapAlias> field_list) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, context_entry_size={}, field_list_size={}",
-                    context_entry.size(), field_list.size());
-        R_SUCCEED();
-    }
-
-    Result CreateReportV0(u32 report_type, InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                          InBuffer<BufferAttr_HipcMapAlias> report_list,
-                          InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, report_type={:#x}", report_type);
-        R_SUCCEED();
-    }
-
-    Result CreateReportV1(u32 report_type, u32 unknown,
-                          InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                          InBuffer<BufferAttr_HipcMapAlias> report_list,
-                          InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, report_type={:#x}, unknown={:#x}", report_type,
-                    unknown);
-        R_SUCCEED();
-    }
-
-    Result CreateReport(u32 report_type, u32 unknown, u32 create_report_option_flag,
-                        InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                        InBuffer<BufferAttr_HipcMapAlias> report_list,
-                        InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
-        LOG_WARNING(
-            Service_SET,
-            "(STUBBED) called, report_type={:#x}, unknown={:#x}, create_report_option_flag={:#x}",
-            report_type, unknown, create_report_option_flag);
+    Result SubmitContext(InBuffer<BufferAttr_HipcMapAlias> buffer_a,
+                         InBuffer<BufferAttr_HipcMapAlias> buffer_b) {
+        LOG_WARNING(Service_SET, "(STUBBED) called, buffer_a_size={}, buffer_b_size={}",
+                    buffer_a.size(), buffer_b.size());
         R_SUCCEED();
     }
 };

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

@@ -34,7 +34,6 @@
 #include "core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h"
 #include "core/hle/service/filesystem/fsp/fs_i_storage.h"
 #include "core/hle/service/filesystem/fsp/fsp_srv.h"
-#include "core/hle/service/filesystem/fsp/save_data_transfer_prohibiter.h"
 #include "core/hle/service/filesystem/romfs_controller.h"
 #include "core/hle/service/filesystem/save_data_controller.h"
 #include "core/hle/service/hle_ipc.h"
@@ -71,7 +70,7 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {28, nullptr, "DeleteSaveDataFileSystemBySaveDataAttribute"},
         {30, nullptr, "OpenGameCardStorage"},
         {31, nullptr, "OpenGameCardFileSystem"},
-        {32, D<&FSP_SRV::ExtendSaveDataFileSystem>, "ExtendSaveDataFileSystem"},
+        {32, nullptr, "ExtendSaveDataFileSystem"},
         {33, nullptr, "DeleteCacheStorage"},
         {34, D<&FSP_SRV::GetCacheStorageSize>, "GetCacheStorageSize"},
         {35, nullptr, "CreateSaveDataFileSystemByHashSalt"},
@@ -79,24 +78,24 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {51, D<&FSP_SRV::OpenSaveDataFileSystem>, "OpenSaveDataFileSystem"},
         {52, D<&FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId>, "OpenSaveDataFileSystemBySystemSaveDataId"},
         {53, D<&FSP_SRV::OpenReadOnlySaveDataFileSystem>, "OpenReadOnlySaveDataFileSystem"},
-        {57, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataSpaceId>, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
-        {58, D<&FSP_SRV::ReadSaveDataFileSystemExtraData>, "ReadSaveDataFileSystemExtraData"},
-        {59, D<&FSP_SRV::WriteSaveDataFileSystemExtraData>, "WriteSaveDataFileSystemExtraData"},
+        {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
+        {58, nullptr, "ReadSaveDataFileSystemExtraData"},
+        {59, nullptr, "WriteSaveDataFileSystemExtraData"},
         {60, nullptr, "OpenSaveDataInfoReader"},
         {61, D<&FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId>, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
         {62, D<&FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage>, "OpenSaveDataInfoReaderOnlyCacheStorage"},
         {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
         {65, nullptr, "UpdateSaveDataMacForDebug"},
         {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
-        {67, D<&FSP_SRV::FindSaveDataWithFilter>, "FindSaveDataWithFilter"},
+        {67, nullptr, "FindSaveDataWithFilter"},
         {68, nullptr, "OpenSaveDataInfoReaderBySaveDataFilter"},
-        {69, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
+        {69, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
+        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
         {71, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
         {80, nullptr, "OpenSaveDataMetaFile"},
         {81, nullptr, "OpenSaveDataTransferManager"},
         {82, nullptr, "OpenSaveDataTransferManagerVersion2"},
-        {83, D<&FSP_SRV::OpenSaveDataTransferProhibiter>, "OpenSaveDataTransferProhibiter"},
+        {83, nullptr, "OpenSaveDataTransferProhibiterForCloudBackUp"},
         {84, nullptr, "ListApplicationAccessibleSaveDataOwnerId"},
         {85, nullptr, "OpenSaveDataTransferManagerForSaveDataRepair"},
         {86, nullptr, "OpenSaveDataMover"},
@@ -236,7 +235,7 @@ Result FSP_SRV::CreateSaveDataFileSystem(FileSys::SaveDataCreationInfo save_crea
 }
 
 Result FSP_SRV::CreateSaveDataFileSystemBySystemSaveDataId(
-    FileSys::SaveDataAttribute save_struct, FileSys::SaveDataCreationInfo save_create_struct) {
+    FileSys::SaveDataCreationInfo save_create_struct, FileSys::SaveDataAttribute save_struct) {
     LOG_DEBUG(Service_FS, "called save_struct = {}", save_struct.DebugInfo());
 
     FileSys::VirtualDir save_data_dir{};
@@ -309,31 +308,9 @@ Result FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage(
     R_SUCCEED();
 }
 
-Result FSP_SRV::FindSaveDataWithFilter(Out<s64> out_count,
-                                       OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                       FileSys::SaveDataSpaceId space_id,
-                                       FileSys::SaveDataFilter filter) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    R_THROW(FileSys::ResultTargetNotFound);
-}
+Result FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute() {
+    LOG_WARNING(Service_FS, "(STUBBED) called.");
 
-Result FSP_SRV::WriteSaveDataFileSystemExtraData(InBuffer<BufferAttr_HipcMapAlias> buffer,
-                                                 FileSys::SaveDataSpaceId space_id,
-                                                 u64 save_data_id) {
-    LOG_WARNING(Service_FS, "(STUBBED) called, space_id={}, save_data_id={:016X}", space_id,
-                save_data_id);
-    R_SUCCEED();
-}
-
-Result FSP_SRV::WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
-    InBuffer<BufferAttr_HipcMapAlias> buffer, InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
-    FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute) {
-    LOG_WARNING(Service_FS,
-                "(STUBBED) called, space_id={}, attribute.program_id={:016X}\n"
-                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
-                "attribute.type={}, attribute.rank={}, attribute.index={}",
-                space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
-                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
     R_SUCCEED();
 }
 
@@ -355,45 +332,6 @@ Result FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
     R_SUCCEED();
 }
 
-Result FSP_SRV::ReadSaveDataFileSystemExtraData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                                u64 save_data_id) {
-    // Stub, backend needs an impl to read/write the SaveDataExtraData
-    LOG_WARNING(Service_FS, "(STUBBED) called, save_data_id={:016X}", save_data_id);
-    std::memset(out_buffer.data(), 0, out_buffer.size());
-    R_SUCCEED();
-}
-
-Result FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataAttribute(
-    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-    FileSys::SaveDataAttribute attribute) {
-    // Stub, backend needs an impl to read/write the SaveDataExtraData
-    LOG_WARNING(Service_FS,
-                "(STUBBED) called, space_id={}, attribute.program_id={:016X}\n"
-                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
-                "attribute.type={}, attribute.rank={}, attribute.index={}",
-                space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
-                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
-    std::memset(out_buffer.data(), 0, out_buffer.size());
-    R_SUCCEED();
-}
-
-Result FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(
-    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-    u64 save_data_id) {
-    // Stub, backend needs an impl to read/write the SaveDataExtraData
-    LOG_WARNING(Service_FS, "(STUBBED) called, space_id={}, save_data_id={:016X}", space_id,
-                save_data_id);
-    std::memset(out_buffer.data(), 0, out_buffer.size());
-    R_SUCCEED();
-}
-
-Result FSP_SRV::OpenSaveDataTransferProhibiter(
-    OutInterface<ISaveDataTransferProhibiter> out_prohibiter, u64 id) {
-    LOG_WARNING(Service_FS, "(STUBBED) called, id={:016X}", id);
-    *out_prohibiter = std::make_shared<ISaveDataTransferProhibiter>(system);
-    R_SUCCEED();
-}
-
 Result FSP_SRV::OpenDataStorageByCurrentProcess(OutInterface<IStorage> out_interface) {
     LOG_DEBUG(Service_FS, "called");
 
@@ -522,16 +460,6 @@ Result FSP_SRV::FlushAccessLogOnSdCard() {
     R_SUCCEED();
 }
 
-Result FSP_SRV::ExtendSaveDataFileSystem(FileSys::SaveDataSpaceId space_id, u64 save_data_id,
-                                         s64 available_size, s64 journal_size) {
-    // We don't have an index of save data ids, so we can't implement this.
-    LOG_WARNING(Service_FS,
-                "(STUBBED) called, space_id={}, save_data_id={:016X}, available_size={:#x}, "
-                "journal_size={:#x}",
-                space_id, save_data_id, available_size, journal_size);
-    R_SUCCEED();
-}
-
 Result FSP_SRV::GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size) {
     LOG_WARNING(Service_FS, "(STUBBED) called with index={}", index);
 

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

@@ -25,7 +25,6 @@ class SaveDataController;
 
 class IFileSystem;
 class ISaveDataInfoReader;
-class ISaveDataTransferProhibiter;
 class IStorage;
 class IMultiCommitManager;
 
@@ -54,7 +53,7 @@ private:
     Result CreateSaveDataFileSystem(FileSys::SaveDataCreationInfo save_create_struct,
                                     FileSys::SaveDataAttribute save_struct, u128 uid);
     Result CreateSaveDataFileSystemBySystemSaveDataId(
-        FileSys::SaveDataAttribute save_struct, FileSys::SaveDataCreationInfo save_create_struct);
+        FileSys::SaveDataCreationInfo save_create_struct, FileSys::SaveDataAttribute save_struct);
     Result OpenSaveDataFileSystem(OutInterface<IFileSystem> out_interface,
                                   FileSys::SaveDataSpaceId space_id,
                                   FileSys::SaveDataAttribute attribute);
@@ -67,28 +66,11 @@ private:
     Result OpenSaveDataInfoReaderBySaveDataSpaceId(OutInterface<ISaveDataInfoReader> out_interface,
                                                    FileSys::SaveDataSpaceId space);
     Result OpenSaveDataInfoReaderOnlyCacheStorage(OutInterface<ISaveDataInfoReader> out_interface);
-    Result FindSaveDataWithFilter(Out<s64> out_count, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                  FileSys::SaveDataSpaceId space_id,
-                                  FileSys::SaveDataFilter filter);
-    Result WriteSaveDataFileSystemExtraData(InBuffer<BufferAttr_HipcMapAlias> buffer,
-                                            FileSys::SaveDataSpaceId space_id, u64 save_data_id);
-    Result WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
-        InBuffer<BufferAttr_HipcMapAlias> buffer, InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
-        FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute);
-    Result ReadSaveDataFileSystemExtraData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                           u64 save_data_id);
-    Result ReadSaveDataFileSystemExtraDataBySaveDataAttribute(
-        OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-        FileSys::SaveDataAttribute attribute);
-    Result ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(
-        OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-        u64 save_data_id);
+    Result WriteSaveDataFileSystemExtraDataBySaveDataAttribute();
     Result ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
         FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute,
         InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
         OutBuffer<BufferAttr_HipcMapAlias> out_buffer);
-    Result OpenSaveDataTransferProhibiter(OutInterface<ISaveDataTransferProhibiter> out_prohibiter,
-                                          u64 id);
     Result OpenDataStorageByCurrentProcess(OutInterface<IStorage> out_interface);
     Result OpenDataStorageByDataId(OutInterface<IStorage> out_interface,
                                    FileSys::StorageId storage_id, u32 unknown, u64 title_id);
@@ -103,8 +85,6 @@ private:
     Result GetProgramIndexForAccessLog(Out<AccessLogVersion> out_access_log_version,
                                        Out<u32> out_access_log_program_index);
     Result OpenMultiCommitManager(OutInterface<IMultiCommitManager> out_interface);
-    Result ExtendSaveDataFileSystem(FileSys::SaveDataSpaceId space_id, u64 save_data_id,
-                                    s64 available_size, s64 journal_size);
     Result GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size);
 
     FileSystemController& fsc;

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

@@ -1,13 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/filesystem/fsp/save_data_transfer_prohibiter.h"
-
-namespace Service::FileSystem {
-
-ISaveDataTransferProhibiter::ISaveDataTransferProhibiter(Core::System& system_)
-    : ServiceFramework{system_, "ISaveDataTransferProhibiter"} {}
-
-ISaveDataTransferProhibiter::~ISaveDataTransferProhibiter() = default;
-
-} // namespace Service::FileSystem

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

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service::FileSystem {
-
-class ISaveDataTransferProhibiter : public ServiceFramework<ISaveDataTransferProhibiter> {
-public:
-    explicit ISaveDataTransferProhibiter(Core::System& system_);
-    ~ISaveDataTransferProhibiter() override;
-};
-
-} // namespace Service::FileSystem

src/core/hle/service/friend/friend.cpp

@@ -42,13 +42,13 @@ public:
             {10701, nullptr, "GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId"},
             {10702, nullptr, "AddPlayHistory"},
             {11000, nullptr, "GetProfileImageUrl"},
-            {20100, &IFriendService::GetFriendCount, "GetFriendCount"},
-            {20101, &IFriendService::GetNewlyFriendCount, "GetNewlyFriendCount"},
+            {20100, nullptr, "GetFriendCount"},
+            {20101, nullptr, "GetNewlyFriendCount"},
             {20102, nullptr, "GetFriendDetailedInfo"},
             {20103, nullptr, "SyncFriendList"},
             {20104, nullptr, "RequestSyncFriendList"},
             {20110, nullptr, "LoadFriendSetting"},
-            {20200, &IFriendService::GetReceivedFriendRequestCount, "GetReceivedFriendRequestCount"},
+            {20200, nullptr, "GetReceivedFriendRequestCount"},
             {20201, nullptr, "GetFriendRequestList"},
             {20300, nullptr, "GetFriendCandidateList"},
             {20301, nullptr, "GetNintendoNetworkIdInfo"},
@@ -61,14 +61,14 @@ public:
             {20501, nullptr, "GetRelationship"},
             {20600, nullptr, "GetUserPresenceView"},
             {20700, nullptr, "GetPlayHistoryList"},
-            {20701, &IFriendService::GetPlayHistoryStatistics, "GetPlayHistoryStatistics"},
+            {20701, nullptr, "GetPlayHistoryStatistics"},
             {20800, nullptr, "LoadUserSetting"},
             {20801, nullptr, "SyncUserSetting"},
             {20900, nullptr, "RequestListSummaryOverlayNotification"},
             {21000, nullptr, "GetExternalApplicationCatalog"},
             {22000, nullptr, "GetReceivedFriendInvitationList"},
             {22001, nullptr, "GetReceivedFriendInvitationDetailedInfo"},
-            {22010, &IFriendService::GetReceivedFriendInvitationCountCache, "GetReceivedFriendInvitationCountCache"},
+            {22010, nullptr, "GetReceivedFriendInvitationCountCache"},
             {30100, nullptr, "DropFriendNewlyFlags"},
             {30101, nullptr, "DeleteFriend"},
             {30110, nullptr, "DropFriendNewlyFlag"},
@@ -144,33 +144,6 @@ private:
         rb.PushCopyObjects(completion_event->GetReadableEvent());
     }
 
-    void GetFriendList(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto friend_offset = rp.Pop<u32>();
-        const auto uuid = rp.PopRaw<Common::UUID>();
-        [[maybe_unused]] const auto filter = rp.PopRaw<SizedFriendFilter>();
-        const auto pid = rp.Pop<u64>();
-        LOG_WARNING(Service_Friend, "(STUBBED) called, offset={}, uuid=0x{}, pid={}", friend_offset,
-                    uuid.RawString(), pid);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-
-        rb.Push<u32>(0); // Friend count
-        // TODO(ogniK): Return a buffer of u64s which are the "NetworkServiceAccountId"
-    }
-
-    void CheckFriendListAvailability(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-
-        LOG_WARNING(Service_Friend, "(STUBBED) called, uuid=0x{}", uuid.RawString());
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(true);
-    }
-
     void GetBlockedUserListIds(HLERequestContext& ctx) {
         // This is safe to stub, as there should be no adverse consequences from reporting no
         // blocked users.
@@ -180,17 +153,6 @@ private:
         rb.Push<u32>(0); // Indicates there are no blocked users
     }
 
-    void CheckBlockedUserListAvailability(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-
-        LOG_WARNING(Service_Friend, "(STUBBED) called, uuid=0x{}", uuid.RawString());
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(true);
-    }
-
     void DeclareCloseOnlinePlaySession(HLERequestContext& ctx) {
         // Stub used by Splatoon 2
         LOG_WARNING(Service_Friend, "(STUBBED) called");
@@ -217,43 +179,42 @@ private:
         rb.Push(ResultSuccess);
     }
 
-    void GetFriendCount(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Friend, "(STUBBED) called");
+    void GetFriendList(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto friend_offset = rp.Pop<u32>();
+        const auto uuid = rp.PopRaw<Common::UUID>();
+        [[maybe_unused]] const auto filter = rp.PopRaw<SizedFriendFilter>();
+        const auto pid = rp.Pop<u64>();
+        LOG_WARNING(Service_Friend, "(STUBBED) called, offset={}, uuid=0x{}, pid={}", friend_offset,
+                    uuid.RawString(), pid);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push(0);
+
+        rb.Push<u32>(0); // Friend count
+        // TODO(ogniK): Return a buffer of u64s which are the "NetworkServiceAccountId"
     }
 
-    void GetNewlyFriendCount(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Friend, "(STUBBED) called");
+    void CheckFriendListAvailability(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto uuid{rp.PopRaw<Common::UUID>()};
+
+        LOG_WARNING(Service_Friend, "(STUBBED) called, uuid=0x{}", uuid.RawString());
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push(0);
+        rb.Push(true);
     }
 
-    void GetReceivedFriendRequestCount(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Friend, "(STUBBED) called");
+    void CheckBlockedUserListAvailability(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto uuid{rp.PopRaw<Common::UUID>()};
+
+        LOG_WARNING(Service_Friend, "(STUBBED) called, uuid=0x{}", uuid.RawString());
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
-        rb.Push(0);
-    }
-
-    void GetPlayHistoryStatistics(HLERequestContext& ctx) {
-        LOG_ERROR(Service_Friend, "(STUBBED) called, check in out");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void GetReceivedFriendInvitationCountCache(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Friend, "(STUBBED) called, check in out");
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(0);
+        rb.Push(true);
     }
 
     KernelHelpers::ServiceContext service_context;

src/core/hle/service/glue/notif.cpp

@@ -10,6 +10,7 @@
 #include "core/hle/service/glue/notif.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/os/event.h"
 
 namespace Service::Glue {
 
@@ -178,7 +179,8 @@ class INotificationSystemEventAccessor final
 public:
     explicit INotificationSystemEventAccessor(Core::System& system_)
         : ServiceFramework{system_, "INotificationSystemEventAccessor"},
-          service_context{system_, "INotificationSystemEventAccessor"} {
+          service_context{system_, "INotificationSystemEventAccessor"}, notification_event{
+                                                                            service_context} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, D<&INotificationSystemEventAccessor::GetSystemEvent>, "GetSystemEvent"},
@@ -186,25 +188,20 @@ public:
         // clang-format on
 
         RegisterHandlers(functions);
-
-        notification_event =
-            service_context.CreateEvent("INotificationSystemEventAccessor:NotificationEvent");
     }
 
-    ~INotificationSystemEventAccessor() {
-        service_context.CloseEvent(notification_event);
-    }
+    ~INotificationSystemEventAccessor() = default;
 
 private:
     Result GetSystemEvent(OutCopyHandle<Kernel::KReadableEvent> out_readable_event) {
         LOG_WARNING(Service_NOTIF, "(STUBBED) called");
 
-        *out_readable_event = &notification_event->GetReadableEvent();
+        *out_readable_event = notification_event.GetHandle();
         R_SUCCEED();
     }
 
     KernelHelpers::ServiceContext service_context;
-    Kernel::KEvent* notification_event;
+    Event notification_event;
 };
 
 INotificationServices::INotificationServices(Core::System& system_)

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

@@ -11,6 +11,7 @@
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/service/glue/time/manager.h"
+#include "core/hle/service/glue/time/time_zone_binary.h"
 #include "core/hle/service/psc/time/service_manager.h"
 #include "core/hle/service/psc/time/static.h"
 #include "core/hle/service/psc/time/system_clock.h"
@@ -19,8 +20,8 @@
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::Glue::Time {
-
-static s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
+namespace {
+s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
     constexpr auto is_leap = [](s32 year) -> bool {
         return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
     };
@@ -49,48 +50,45 @@ static s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
     return epoch_s - 62135683200ll;
 }
 
-static s64 GetEpochTimeFromInitialYear(
-    std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) {
-    s32 year{2000};
-    set_sys->GetSettingsItemValueImpl(year, "time", "standard_user_clock_initial_year");
-
+s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) {
     Service::PSC::Time::CalendarTime calendar{
-        .year = static_cast<s16>(year),
+        .year = 2000,
         .month = 1,
         .day = 1,
         .hour = 0,
         .minute = 0,
         .second = 0,
     };
+    set_sys->GetSettingsItemValueImpl<s16>(calendar.year, "time",
+                                           "standard_user_clock_initial_year");
     return CalendarTimeToEpoch(calendar);
 }
 
-static Service::PSC::Time::LocationName GetTimeZoneString(
-    TimeZoneBinary& time_zone_binary, Service::PSC::Time::LocationName& in_name) {
+Service::PSC::Time::LocationName GetTimeZoneString(Service::PSC::Time::LocationName& in_name) {
     auto configured_zone = Settings::GetTimeZoneString(Settings::values.time_zone_index.GetValue());
 
     Service::PSC::Time::LocationName configured_name{};
     std::memcpy(configured_name.data(), configured_zone.data(),
                 std::min(configured_name.size(), configured_zone.size()));
 
-    if (!time_zone_binary.IsValid(configured_name)) {
+    if (!IsTimeZoneBinaryValid(configured_name)) {
         configured_zone = Common::TimeZone::FindSystemTimeZone();
         configured_name = {};
         std::memcpy(configured_name.data(), configured_zone.data(),
                     std::min(configured_name.size(), configured_zone.size()));
     }
 
-    ASSERT_MSG(time_zone_binary.IsValid(configured_name), "Invalid time zone {}!",
+    ASSERT_MSG(IsTimeZoneBinaryValid(configured_name), "Invalid time zone {}!",
                configured_name.data());
 
     return configured_name;
 }
 
+} // namespace
+
 TimeManager::TimeManager(Core::System& system)
-    : m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
-                                                                       system,
-                                                                       m_steady_clock_resource,
-                                                                       m_file_timestamp_worker} {
+    : m_steady_clock_resource{system}, m_worker{system, m_steady_clock_resource,
+                                                m_file_timestamp_worker} {
     m_time_m =
         system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
 
@@ -100,7 +98,7 @@ TimeManager::TimeManager(Core::System& system)
     m_set_sys =
         system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
 
-    res = m_time_zone_binary.Mount();
+    res = MountTimeZoneBinary(system);
     ASSERT(res == ResultSuccess);
 
     m_worker.Initialize(m_time_sm, m_set_sys);
@@ -188,6 +186,10 @@ TimeManager::TimeManager(Core::System& system)
     }
 }
 
+TimeManager::~TimeManager() {
+    ResetTimeZoneBinary();
+}
+
 Result TimeManager::SetupStandardSteadyClockCore() {
     Common::UUID external_clock_source_id{};
     auto res = m_set_sys->GetExternalSteadyClockSourceId(&external_clock_source_id);
@@ -233,7 +235,7 @@ Result TimeManager::SetupTimeZoneServiceCore() {
     auto res = m_set_sys->GetDeviceTimeZoneLocationName(&name);
     ASSERT(res == ResultSuccess);
 
-    auto configured_zone = GetTimeZoneString(m_time_zone_binary, name);
+    auto configured_zone = GetTimeZoneString(name);
 
     if (configured_zone != name) {
         m_set_sys->SetDeviceTimeZoneLocationName(configured_zone);
@@ -251,13 +253,13 @@ Result TimeManager::SetupTimeZoneServiceCore() {
     res = m_set_sys->GetDeviceTimeZoneLocationUpdatedTime(&time_point);
     ASSERT(res == ResultSuccess);
 
-    auto location_count = m_time_zone_binary.GetTimeZoneCount();
+    auto location_count = GetTimeZoneCount();
     Service::PSC::Time::RuleVersion rule_version{};
-    m_time_zone_binary.GetTimeZoneVersion(rule_version);
+    GetTimeZoneVersion(rule_version);
 
     std::span<const u8> rule_buffer{};
     size_t rule_size{};
-    res = m_time_zone_binary.GetTimeZoneRule(rule_buffer, rule_size, name);
+    res = GetTimeZoneRule(rule_buffer, rule_size, name);
     ASSERT(res == ResultSuccess);
 
     res = m_time_m->SetupTimeZoneServiceCore(name, rule_version, location_count, time_point,

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

@@ -10,7 +10,6 @@
 #include "core/file_sys/vfs/vfs_types.h"
 #include "core/hle/service/glue/time/file_timestamp_worker.h"
 #include "core/hle/service/glue/time/standard_steady_clock_resource.h"
-#include "core/hle/service/glue/time/time_zone_binary.h"
 #include "core/hle/service/glue/time/worker.h"
 #include "core/hle/service/service.h"
 
@@ -27,7 +26,7 @@ namespace Service::Glue::Time {
 class TimeManager {
 public:
     explicit TimeManager(Core::System& system);
-    ~TimeManager() = default;
+    ~TimeManager();
 
     std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
 
@@ -35,7 +34,6 @@ public:
     std::shared_ptr<Service::PSC::Time::StaticService> m_time_sm{};
     StandardSteadyClockResource m_steady_clock_resource;
     FileTimestampWorker m_file_timestamp_worker;
-    TimeZoneBinary m_time_zone_binary;
     TimeWorker m_worker;
 
 private:

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

@@ -26,9 +26,8 @@ StaticService::StaticService(Core::System& system_,
                              std::shared_ptr<TimeManager> time, const char* name)
     : ServiceFramework{system_, name}, m_system{system_}, m_time_m{time->m_time_m},
       m_setup_info{setup_info}, m_time_sm{time->m_time_sm},
-      m_file_timestamp_worker{time->m_file_timestamp_worker},
-      m_standard_steady_clock_resource{time->m_steady_clock_resource},
-      m_time_zone_binary{time->m_time_zone_binary} {
+      m_file_timestamp_worker{time->m_file_timestamp_worker}, m_standard_steady_clock_resource{
+                                                                  time->m_steady_clock_resource} {
     // clang-format off
         static const FunctionInfo functions[] = {
             {0,   D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},
@@ -107,7 +106,7 @@ Result StaticService::GetTimeZoneService(OutInterface<TimeZoneService> out_servi
 
     *out_service = std::make_shared<TimeZoneService>(
         m_system, m_file_timestamp_worker, m_setup_info.can_write_timezone_device_location,
-        m_time_zone_binary, m_time_zone);
+        m_time_zone);
     R_SUCCEED();
 }
 

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

@@ -80,6 +80,5 @@ private:
     std::shared_ptr<Service::PSC::Time::TimeZoneService> m_time_zone;
     FileTimestampWorker& m_file_timestamp_worker;
     StandardSteadyClockResource& m_standard_steady_clock_resource;
-    TimeZoneBinary& m_time_zone_binary;
 };
 } // namespace Service::Glue::Time

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

@@ -15,16 +15,19 @@
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::Glue::Time {
+namespace {
+static std::mutex g_list_mutex;
+static Common::IntrusiveListBaseTraits<Service::PSC::Time::OperationEvent>::ListType g_list_nodes{};
+} // namespace
 
 TimeZoneService::TimeZoneService(
     Core::System& system_, FileTimestampWorker& file_timestamp_worker,
-    bool can_write_timezone_device_location, TimeZoneBinary& time_zone_binary,
+    bool can_write_timezone_device_location,
     std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
     : ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
       m_can_write_timezone_device_location{can_write_timezone_device_location},
-      m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
-                                                          time_zone_service)},
-      m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
+      m_file_timestamp_worker{file_timestamp_worker},
+      m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0,   D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
@@ -45,6 +48,7 @@ TimeZoneService::TimeZoneService(
     // clang-format on
     RegisterHandlers(functions);
 
+    g_list_nodes.clear();
     m_set_sys =
         m_system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
 }
@@ -65,13 +69,13 @@ Result TimeZoneService::SetDeviceLocationName(
     LOG_DEBUG(Service_Time, "called. location_name={}", location_name);
 
     R_UNLESS(m_can_write_timezone_device_location, Service::PSC::Time::ResultPermissionDenied);
-    R_UNLESS(m_time_zone_binary.IsValid(location_name), Service::PSC::Time::ResultTimeZoneNotFound);
+    R_UNLESS(IsTimeZoneBinaryValid(location_name), Service::PSC::Time::ResultTimeZoneNotFound);
 
     std::scoped_lock l{m_mutex};
 
     std::span<const u8> binary{};
     size_t binary_size{};
-    R_TRY(m_time_zone_binary.GetTimeZoneRule(binary, binary_size, location_name))
+    R_TRY(GetTimeZoneRule(binary, binary_size, location_name))
 
     R_TRY(m_wrapped_service->SetDeviceLocationNameWithTimeZoneRule(location_name, binary));
 
@@ -84,8 +88,8 @@ Result TimeZoneService::SetDeviceLocationName(
     m_set_sys->SetDeviceTimeZoneLocationName(name);
     m_set_sys->SetDeviceTimeZoneLocationUpdatedTime(time_point);
 
-    std::scoped_lock m{m_list_mutex};
-    for (auto& operation_event : m_list_nodes) {
+    std::scoped_lock m{g_list_mutex};
+    for (auto& operation_event : g_list_nodes) {
         operation_event.m_event->Signal();
     }
     R_SUCCEED();
@@ -108,8 +112,7 @@ Result TimeZoneService::LoadLocationNameList(
     };
 
     std::scoped_lock l{m_mutex};
-    R_RETURN(
-        m_time_zone_binary.GetTimeZoneLocationList(*out_count, out_names, out_names.size(), index));
+    R_RETURN(GetTimeZoneLocationList(*out_count, out_names, out_names.size(), index));
 }
 
 Result TimeZoneService::LoadTimeZoneRule(OutRule out_rule,
@@ -119,7 +122,7 @@ Result TimeZoneService::LoadTimeZoneRule(OutRule out_rule,
     std::scoped_lock l{m_mutex};
     std::span<const u8> binary{};
     size_t binary_size{};
-    R_TRY(m_time_zone_binary.GetTimeZoneRule(binary, binary_size, name))
+    R_TRY(GetTimeZoneRule(binary, binary_size, name))
     R_RETURN(m_wrapped_service->ParseTimeZoneBinary(out_rule, binary));
 }
 
@@ -171,7 +174,7 @@ Result TimeZoneService::GetDeviceLocationNameOperationEventReadableHandle(
             m_operation_event.m_ctx.CreateEvent("Psc:TimeZoneService:OperationEvent");
         operation_event_initialized = true;
         std::scoped_lock l{m_mutex};
-        m_list_nodes.push_back(m_operation_event);
+        g_list_nodes.push_back(m_operation_event);
     }
 
     *out_event = &m_operation_event.m_event->GetReadableEvent();

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

@@ -32,7 +32,6 @@ class TimeZoneService;
 
 namespace Service::Glue::Time {
 class FileTimestampWorker;
-class TimeZoneBinary;
 
 class TimeZoneService final : public ServiceFramework<TimeZoneService> {
     using InRule = InLargeData<Tz::Rule, BufferAttr_HipcMapAlias>;
@@ -41,7 +40,7 @@ class TimeZoneService final : public ServiceFramework<TimeZoneService> {
 public:
     explicit TimeZoneService(
         Core::System& system, FileTimestampWorker& file_timestamp_worker,
-        bool can_write_timezone_device_location, TimeZoneBinary& time_zone_binary,
+        bool can_write_timezone_device_location,
         std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service);
 
     ~TimeZoneService() override;
@@ -86,10 +85,6 @@ private:
     std::mutex m_mutex;
     bool operation_event_initialized{};
     Service::PSC::Time::OperationEvent m_operation_event;
-    TimeZoneBinary& m_time_zone_binary;
-
-    std::mutex m_list_mutex;
-    Common::IntrusiveListBaseTraits<Service::PSC::Time::OperationEvent>::ListType m_list_nodes{};
 };
 
 } // namespace Service::Glue::Time

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

@@ -12,58 +12,18 @@
 #include "core/hle/service/glue/time/time_zone_binary.h"
 
 namespace Service::Glue::Time {
+namespace {
 constexpr u64 TimeZoneBinaryId = 0x10000000000080E;
 
-void TimeZoneBinary::Reset() {
-    time_zone_binary_romfs = {};
-    time_zone_binary_mount_result = ResultUnknown;
-    time_zone_scratch_space.clear();
-    time_zone_scratch_space.resize(0x2800, 0);
-}
+static FileSys::VirtualDir g_time_zone_binary_romfs{};
+static Result g_time_zone_binary_mount_result{ResultUnknown};
+static std::vector<u8> g_time_zone_scratch_space(0x2800, 0);
 
-Result TimeZoneBinary::Mount() {
-    Reset();
+Result TimeZoneReadBinary(size_t& out_read_size, std::span<u8> out_buffer, size_t out_buffer_size,
+                          std::string_view path) {
+    R_UNLESS(g_time_zone_binary_mount_result == ResultSuccess, g_time_zone_binary_mount_result);
 
-    auto& fsc{system.GetFileSystemController()};
-    std::unique_ptr<FileSys::NCA> nca{};
-
-    auto* bis_system = fsc.GetSystemNANDContents();
-
-    R_UNLESS(bis_system, ResultUnknown);
-
-    nca = bis_system->GetEntry(TimeZoneBinaryId, FileSys::ContentRecordType::Data);
-
-    if (nca) {
-        time_zone_binary_romfs = FileSys::ExtractRomFS(nca->GetRomFS());
-    }
-
-    if (time_zone_binary_romfs) {
-        // Validate that the romfs is readable, using invalid firmware keys can cause this to get
-        // set but the files to be garbage. In that case, we want to hit the next path and
-        // synthesise them instead.
-        time_zone_binary_mount_result = ResultSuccess;
-        Service::PSC::Time::LocationName name{"Etc/GMT"};
-        if (!IsValid(name)) {
-            Reset();
-        }
-    }
-
-    if (!time_zone_binary_romfs) {
-        time_zone_binary_romfs = FileSys::ExtractRomFS(
-            FileSys::SystemArchive::SynthesizeSystemArchive(TimeZoneBinaryId));
-    }
-
-    R_UNLESS(time_zone_binary_romfs, ResultUnknown);
-
-    time_zone_binary_mount_result = ResultSuccess;
-    R_SUCCEED();
-}
-
-Result TimeZoneBinary::Read(size_t& out_read_size, std::span<u8> out_buffer, size_t out_buffer_size,
-                            std::string_view path) {
-    R_UNLESS(time_zone_binary_mount_result == ResultSuccess, time_zone_binary_mount_result);
-
-    auto vfs_file{time_zone_binary_romfs->GetFileRelative(path)};
+    auto vfs_file{g_time_zone_binary_romfs->GetFileRelative(path)};
     R_UNLESS(vfs_file, ResultUnknown);
 
     auto file_size{vfs_file->GetSize()};
@@ -76,37 +36,82 @@ Result TimeZoneBinary::Read(size_t& out_read_size, std::span<u8> out_buffer, siz
 
     R_SUCCEED();
 }
+} // namespace
 
-void TimeZoneBinary::GetListPath(std::string& out_path) {
-    if (time_zone_binary_mount_result != ResultSuccess) {
+void ResetTimeZoneBinary() {
+    g_time_zone_binary_romfs = {};
+    g_time_zone_binary_mount_result = ResultUnknown;
+    g_time_zone_scratch_space.clear();
+    g_time_zone_scratch_space.resize(0x2800, 0);
+}
+
+Result MountTimeZoneBinary(Core::System& system) {
+    ResetTimeZoneBinary();
+
+    auto& fsc{system.GetFileSystemController()};
+    std::unique_ptr<FileSys::NCA> nca{};
+
+    auto* bis_system = fsc.GetSystemNANDContents();
+
+    R_UNLESS(bis_system, ResultUnknown);
+
+    nca = bis_system->GetEntry(TimeZoneBinaryId, FileSys::ContentRecordType::Data);
+
+    if (nca) {
+        g_time_zone_binary_romfs = FileSys::ExtractRomFS(nca->GetRomFS());
+    }
+
+    if (g_time_zone_binary_romfs) {
+        // Validate that the romfs is readable, using invalid firmware keys can cause this to get
+        // set but the files to be garbage. In that case, we want to hit the next path and
+        // synthesise them instead.
+        g_time_zone_binary_mount_result = ResultSuccess;
+        Service::PSC::Time::LocationName name{"Etc/GMT"};
+        if (!IsTimeZoneBinaryValid(name)) {
+            ResetTimeZoneBinary();
+        }
+    }
+
+    if (!g_time_zone_binary_romfs) {
+        g_time_zone_binary_romfs = FileSys::ExtractRomFS(
+            FileSys::SystemArchive::SynthesizeSystemArchive(TimeZoneBinaryId));
+    }
+
+    R_UNLESS(g_time_zone_binary_romfs, ResultUnknown);
+
+    g_time_zone_binary_mount_result = ResultSuccess;
+    R_SUCCEED();
+}
+
+void GetTimeZoneBinaryListPath(std::string& out_path) {
+    if (g_time_zone_binary_mount_result != ResultSuccess) {
         return;
     }
     // out_path = fmt::format("{}:/binaryList.txt", "TimeZoneBinary");
     out_path = "/binaryList.txt";
 }
 
-void TimeZoneBinary::GetVersionPath(std::string& out_path) {
-    if (time_zone_binary_mount_result != ResultSuccess) {
+void GetTimeZoneBinaryVersionPath(std::string& out_path) {
+    if (g_time_zone_binary_mount_result != ResultSuccess) {
         return;
     }
     // out_path = fmt::format("{}:/version.txt", "TimeZoneBinary");
     out_path = "/version.txt";
 }
 
-void TimeZoneBinary::GetTimeZonePath(std::string& out_path,
-                                     const Service::PSC::Time::LocationName& name) {
-    if (time_zone_binary_mount_result != ResultSuccess) {
+void GetTimeZoneZonePath(std::string& out_path, const Service::PSC::Time::LocationName& name) {
+    if (g_time_zone_binary_mount_result != ResultSuccess) {
         return;
     }
     // out_path = fmt::format("{}:/zoneinfo/{}", "TimeZoneBinary", name);
     out_path = fmt::format("/zoneinfo/{}", name.data());
 }
 
-bool TimeZoneBinary::IsValid(const Service::PSC::Time::LocationName& name) {
+bool IsTimeZoneBinaryValid(const Service::PSC::Time::LocationName& name) {
     std::string path{};
-    GetTimeZonePath(path, name);
+    GetTimeZoneZonePath(path, name);
 
-    auto vfs_file{time_zone_binary_romfs->GetFileRelative(path)};
+    auto vfs_file{g_time_zone_binary_romfs->GetFileRelative(path)};
     if (!vfs_file) {
         LOG_INFO(Service_Time, "Could not find timezone file {}", path);
         return false;
@@ -114,19 +119,19 @@ bool TimeZoneBinary::IsValid(const Service::PSC::Time::LocationName& name) {
     return vfs_file->GetSize() != 0;
 }
 
-u32 TimeZoneBinary::GetTimeZoneCount() {
+u32 GetTimeZoneCount() {
     std::string path{};
-    GetListPath(path);
+    GetTimeZoneBinaryListPath(path);
 
     size_t bytes_read{};
-    if (Read(bytes_read, time_zone_scratch_space, 0x2800, path) != ResultSuccess) {
+    if (TimeZoneReadBinary(bytes_read, g_time_zone_scratch_space, 0x2800, path) != ResultSuccess) {
         return 0;
     }
     if (bytes_read == 0) {
         return 0;
     }
 
-    auto chars = std::span(reinterpret_cast<char*>(time_zone_scratch_space.data()), bytes_read);
+    auto chars = std::span(reinterpret_cast<char*>(g_time_zone_scratch_space.data()), bytes_read);
     u32 count{};
     for (auto chr : chars) {
         if (chr == '\n') {
@@ -136,47 +141,50 @@ u32 TimeZoneBinary::GetTimeZoneCount() {
     return count;
 }
 
-Result TimeZoneBinary::GetTimeZoneVersion(Service::PSC::Time::RuleVersion& out_rule_version) {
+Result GetTimeZoneVersion(Service::PSC::Time::RuleVersion& out_rule_version) {
     std::string path{};
-    GetVersionPath(path);
+    GetTimeZoneBinaryVersionPath(path);
 
     auto rule_version_buffer{std::span(reinterpret_cast<u8*>(&out_rule_version),
                                        sizeof(Service::PSC::Time::RuleVersion))};
     size_t bytes_read{};
-    R_TRY(Read(bytes_read, rule_version_buffer, rule_version_buffer.size_bytes(), path));
+    R_TRY(TimeZoneReadBinary(bytes_read, rule_version_buffer, rule_version_buffer.size_bytes(),
+                             path));
 
     rule_version_buffer[bytes_read] = 0;
     R_SUCCEED();
 }
 
-Result TimeZoneBinary::GetTimeZoneRule(std::span<const u8>& out_rule, size_t& out_rule_size,
-                                       const Service::PSC::Time::LocationName& name) {
+Result GetTimeZoneRule(std::span<const u8>& out_rule, size_t& out_rule_size,
+                       const Service::PSC::Time::LocationName& name) {
     std::string path{};
-    GetTimeZonePath(path, name);
+    GetTimeZoneZonePath(path, name);
 
     size_t bytes_read{};
-    R_TRY(Read(bytes_read, time_zone_scratch_space, time_zone_scratch_space.size(), path));
+    R_TRY(TimeZoneReadBinary(bytes_read, g_time_zone_scratch_space,
+                             g_time_zone_scratch_space.size(), path));
 
-    out_rule = std::span(time_zone_scratch_space.data(), bytes_read);
+    out_rule = std::span(g_time_zone_scratch_space.data(), bytes_read);
     out_rule_size = bytes_read;
     R_SUCCEED();
 }
 
-Result TimeZoneBinary::GetTimeZoneLocationList(
-    u32& out_count, std::span<Service::PSC::Time::LocationName> out_names, size_t max_names,
-    u32 index) {
+Result GetTimeZoneLocationList(u32& out_count,
+                               std::span<Service::PSC::Time::LocationName> out_names,
+                               size_t max_names, u32 index) {
     std::string path{};
-    GetListPath(path);
+    GetTimeZoneBinaryListPath(path);
 
     size_t bytes_read{};
-    R_TRY(Read(bytes_read, time_zone_scratch_space, time_zone_scratch_space.size(), path));
+    R_TRY(TimeZoneReadBinary(bytes_read, g_time_zone_scratch_space,
+                             g_time_zone_scratch_space.size(), path));
 
     out_count = 0;
     R_SUCCEED_IF(bytes_read == 0);
 
     Service::PSC::Time::LocationName current_name{};
     size_t current_name_len{};
-    std::span<const u8> chars{time_zone_scratch_space};
+    std::span<const u8> chars{g_time_zone_scratch_space};
     u32 name_count{};
 
     for (auto chr : chars) {

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

@@ -6,7 +6,6 @@
 #include <span>
 #include <string>
 #include <string_view>
-#include <vector>
 
 #include "core/hle/service/psc/time/common.h"
 
@@ -16,34 +15,18 @@ class System;
 
 namespace Service::Glue::Time {
 
-class TimeZoneBinary {
-public:
-    explicit TimeZoneBinary(Core::System& system_)
-        : time_zone_scratch_space(0x2800, 0), system{system_} {}
-
-    Result Mount();
-    bool IsValid(const Service::PSC::Time::LocationName& name);
-    u32 GetTimeZoneCount();
-    Result GetTimeZoneVersion(Service::PSC::Time::RuleVersion& out_rule_version);
-    Result GetTimeZoneRule(std::span<const u8>& out_rule, size_t& out_rule_size,
-                           const Service::PSC::Time::LocationName& name);
-    Result GetTimeZoneLocationList(u32& out_count,
-                                   std::span<Service::PSC::Time::LocationName> out_names,
-                                   size_t max_names, u32 index);
-
-private:
-    void Reset();
-    Result Read(size_t& out_read_size, std::span<u8> out_buffer, size_t out_buffer_size,
-                std::string_view path);
-    void GetListPath(std::string& out_path);
-    void GetVersionPath(std::string& out_path);
-    void GetTimeZonePath(std::string& out_path, const Service::PSC::Time::LocationName& name);
-
-    FileSys::VirtualDir time_zone_binary_romfs{};
-    Result time_zone_binary_mount_result{ResultUnknown};
-    std::vector<u8> time_zone_scratch_space;
-
-    Core::System& system;
-};
+void ResetTimeZoneBinary();
+Result MountTimeZoneBinary(Core::System& system);
+void GetTimeZoneBinaryListPath(std::string& out_path);
+void GetTimeZoneBinaryVersionPath(std::string& out_path);
+void GetTimeZoneZonePath(std::string& out_path, const Service::PSC::Time::LocationName& name);
+bool IsTimeZoneBinaryValid(const Service::PSC::Time::LocationName& name);
+u32 GetTimeZoneCount();
+Result GetTimeZoneVersion(Service::PSC::Time::RuleVersion& out_rule_version);
+Result GetTimeZoneRule(std::span<const u8>& out_rule, size_t& out_rule_size,
+                       const Service::PSC::Time::LocationName& name);
+Result GetTimeZoneLocationList(u32& out_count,
+                               std::span<Service::PSC::Time::LocationName> out_names,
+                               size_t max_names, u32 index);
 
 } // namespace Service::Glue::Time

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

@@ -16,6 +16,26 @@
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::Glue::Time {
+namespace {
+
+bool g_ig_report_network_clock_context_set{};
+Service::PSC::Time::SystemClockContext g_report_network_clock_context{};
+bool g_ig_report_ephemeral_clock_context_set{};
+Service::PSC::Time::SystemClockContext g_report_ephemeral_clock_context{};
+
+template <typename T>
+T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
+                       const char* category, const char* name) {
+    std::vector<u8> interval_buf;
+    auto res = set_sys->GetSettingsItemValueImpl(interval_buf, category, name);
+    ASSERT(res == ResultSuccess);
+
+    T v{};
+    std::memcpy(&v, interval_buf.data(), sizeof(T));
+    return v;
+}
+
+} // namespace
 
 TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
                        FileTimestampWorker& file_timestamp_worker)
@@ -26,6 +46,11 @@ TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady
                                                           "Glue:TimeWorker:SteadyClockTimerEvent")},
       m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
       m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
+    g_ig_report_network_clock_context_set = false;
+    g_report_network_clock_context = {};
+    g_ig_report_ephemeral_clock_context_set = false;
+    g_report_ephemeral_clock_context = {};
+
     m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(
         "Time::SteadyClockEvent",
         [this](s64 time,
@@ -60,14 +85,6 @@ TimeWorker::~TimeWorker() {
     m_ctx.CloseEvent(m_timer_file_system);
 }
 
-template <typename T>
-T TimeWorker::GetSettingsItemValue(const std::string& category, const std::string& name) {
-    T v{};
-    auto res = m_set_sys->GetSettingsItemValueImpl(v, category, name);
-    ASSERT(res == ResultSuccess);
-    return v;
-}
-
 void TimeWorker::Initialize(std::shared_ptr<Service::PSC::Time::StaticService> time_sm,
                             std::shared_ptr<Service::Set::ISystemSettingsServer> set_sys) {
     m_set_sys = std::move(set_sys);
@@ -77,8 +94,8 @@ void TimeWorker::Initialize(std::shared_ptr<Service::PSC::Time::StaticService> t
 
     m_alarm_worker.Initialize(m_time_m);
 
-    auto steady_clock_interval_m =
-        GetSettingsItemValue<s32>("time", "standard_steady_clock_rtc_update_interval_minutes");
+    auto steady_clock_interval_m = GetSettingsItemValue<s32>(
+        m_set_sys, "time", "standard_steady_clock_rtc_update_interval_minutes");
 
     auto one_minute_ns{
         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()};
@@ -88,7 +105,8 @@ void TimeWorker::Initialize(std::shared_ptr<Service::PSC::Time::StaticService> t
                                                std::chrono::nanoseconds(steady_clock_interval_ns),
                                                m_timer_steady_clock_timing_event);
 
-    auto fs_notify_time_s = GetSettingsItemValue<s32>("time", "notify_time_to_fs_interval_seconds");
+    auto fs_notify_time_s =
+        GetSettingsItemValue<s32>(m_set_sys, "time", "notify_time_to_fs_interval_seconds");
     auto one_second_ns{
         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::seconds(1)).count()};
     s64 fs_notify_time_ns{fs_notify_time_s * one_second_ns};
@@ -203,14 +221,14 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
             }
 
             [[maybe_unused]] auto offset_before{
-                m_ig_report_network_clock_context_set ? m_report_network_clock_context.offset : 0};
+                g_ig_report_network_clock_context_set ? g_report_network_clock_context.offset : 0};
             // TODO system report "standard_netclock_operation"
             //              "clock_time" = time
             //              "context_offset_before" = offset_before
             //              "context_offset_after"  = context.offset
-            m_report_network_clock_context = context;
-            if (!m_ig_report_network_clock_context_set) {
-                m_ig_report_network_clock_context_set = true;
+            g_report_network_clock_context = context;
+            if (!g_ig_report_network_clock_context_set) {
+                g_ig_report_network_clock_context_set = true;
             }
 
             m_file_timestamp_worker.SetFilesystemPosixTime();
@@ -232,16 +250,16 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
                 break;
             }
 
-            [[maybe_unused]] auto offset_before{m_ig_report_ephemeral_clock_context_set
-                                                    ? m_report_ephemeral_clock_context.offset
+            [[maybe_unused]] auto offset_before{g_ig_report_ephemeral_clock_context_set
+                                                    ? g_report_ephemeral_clock_context.offset
                                                     : 0};
             // TODO system report "ephemeral_netclock_operation"
             //              "clock_time" = time
             //              "context_offset_before" = offset_before
             //              "context_offset_after"  = context.offset
-            m_report_ephemeral_clock_context = context;
-            if (!m_ig_report_ephemeral_clock_context_set) {
-                m_ig_report_ephemeral_clock_context_set = true;
+            g_report_ephemeral_clock_context = context;
+            if (!g_ig_report_ephemeral_clock_context_set) {
+                g_ig_report_ephemeral_clock_context_set = true;
             }
             break;
         }

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

@@ -34,9 +34,6 @@ public:
     void StartThread();
 
 private:
-    template <typename T>
-    T GetSettingsItemValue(const std::string& category, const std::string& name);
-
     void ThreadFunc(std::stop_token stop_token);
 
     Core::System& m_system;
@@ -62,11 +59,6 @@ private:
     std::shared_ptr<Core::Timing::EventType> m_timer_file_system_timing_event;
     AlarmWorker m_alarm_worker;
     PmStateChangeHandler m_pm_state_change_handler;
-
-    bool m_ig_report_network_clock_context_set{};
-    Service::PSC::Time::SystemClockContext m_report_network_clock_context{};
-    bool m_ig_report_ephemeral_clock_context_set{};
-    Service::PSC::Time::SystemClockContext m_report_ephemeral_clock_context{};
 };
 
 } // namespace Service::Glue::Time

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

@@ -1982,7 +1982,7 @@ void IHidServer::InitializeSevenSixAxisSensor(HLERequestContext& ctx) {
 
     auto t_mem_1 = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_1_handle);
 
-    if (t_mem_1.IsNull()) {
+    if (!t_mem_1) {
         LOG_ERROR(Service_HID, "t_mem_1 is a nullptr for handle=0x{:08X}", t_mem_1_handle);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultUnknown);
@@ -1991,7 +1991,7 @@ void IHidServer::InitializeSevenSixAxisSensor(HLERequestContext& ctx) {
 
     auto t_mem_2 = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_2_handle);
 
-    if (t_mem_2.IsNull()) {
+    if (!t_mem_2) {
         LOG_ERROR(Service_HID, "t_mem_2 is a nullptr for handle=0x{:08X}", t_mem_2_handle);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultUnknown);
@@ -2272,7 +2272,7 @@ void IHidServer::WritePalmaWaveEntry(HLERequestContext& ctx) {
 
     auto t_mem = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(t_mem_handle);
 
-    if (t_mem.IsNull()) {
+    if (!t_mem) {
         LOG_ERROR(Service_HID, "t_mem is a nullptr for handle=0x{:08X}", t_mem_handle);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultUnknown);

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

@@ -201,7 +201,7 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
         {1269, nullptr, "DeleteButtonConfigStorageLeft"},
         {1270, nullptr, "DeleteButtonConfigStorageRight"},
         {1271, &IHidSystemServer::IsUsingCustomButtonConfig, "IsUsingCustomButtonConfig"},
-        {1272, &IHidSystemServer::IsAnyCustomButtonConfigEnabled, "IsAnyCustomButtonConfigEnabled"},
+        {1272, nullptr, "IsAnyCustomButtonConfigEnabled"},
         {1273, nullptr, "SetAllCustomButtonConfigEnabled"},
         {1274, nullptr, "SetDefaultButtonConfig"},
         {1275, nullptr, "SetAllDefaultButtonConfig"},
@@ -926,16 +926,6 @@ void IHidSystemServer::IsUsingCustomButtonConfig(HLERequestContext& ctx) {
     rb.Push(is_enabled);
 }
 
-void IHidSystemServer::IsAnyCustomButtonConfigEnabled(HLERequestContext& ctx) {
-    const bool is_enabled = false;
-
-    LOG_DEBUG(Service_HID, "(STUBBED) called, is_enabled={}", is_enabled);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(is_enabled);
-}
-
 std::shared_ptr<ResourceManager> IHidSystemServer::GetResourceManager() {
     resource_manager->Initialize();
     return resource_manager;

src/core/hle/service/hid/hid_system_server.h

@@ -77,7 +77,6 @@ private:
     void GetTouchScreenDefaultConfiguration(HLERequestContext& ctx);
     void SetForceHandheldStyleVibration(HLERequestContext& ctx);
     void IsUsingCustomButtonConfig(HLERequestContext& ctx);
-    void IsAnyCustomButtonConfigEnabled(HLERequestContext& ctx);
 
     std::shared_ptr<ResourceManager> GetResourceManager();
 

src/core/hle/service/hle_ipc.cpp

@@ -11,17 +11,21 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/scratch_buffer.h"
 #include "core/guest_memory.h"
 #include "core/hle/kernel/k_auto_object.h"
+#include "core/hle/kernel/k_code_memory.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_server_port.h"
 #include "core/hle/kernel/k_server_session.h"
+#include "core/hle/kernel/k_session.h"
+#include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/server_manager.h"
 #include "core/memory.h"
 
 namespace Service {
@@ -134,6 +138,45 @@ HLERequestContext::HLERequestContext(Kernel::KernelCore& kernel_, Core::Memory::
 
 HLERequestContext::~HLERequestContext() = default;
 
+template <typename T>
+T* HLERequestContext::GetObjectFromHandle(u32 handle) {
+    auto obj = client_handle_table->GetObjectForIpc(handle, thread);
+    if (obj.IsNotNull()) {
+        return obj->DynamicCast<T*>();
+    }
+    return nullptr;
+}
+
+template <typename T>
+void HLERequestContext::AddCopyObject(T* object) {
+    outgoing_copy_objects.push_back(object);
+}
+
+template <typename T>
+void HLERequestContext::AddMoveObject(T* object) {
+    outgoing_move_objects.push_back(object);
+}
+
+template Kernel::KCodeMemory* HLERequestContext::GetObjectFromHandle<Kernel::KCodeMemory>(
+    u32 handle);
+template Kernel::KProcess* HLERequestContext::GetObjectFromHandle<Kernel::KProcess>(u32 handle);
+template Kernel::KReadableEvent* HLERequestContext::GetObjectFromHandle<Kernel::KReadableEvent>(
+    u32 handle);
+template Kernel::KTransferMemory* HLERequestContext::GetObjectFromHandle<Kernel::KTransferMemory>(
+    u32 handle);
+
+template void HLERequestContext::AddCopyObject<Kernel::KProcess>(Kernel::KProcess* object);
+template void HLERequestContext::AddCopyObject<Kernel::KReadableEvent>(
+    Kernel::KReadableEvent* object);
+template void HLERequestContext::AddCopyObject<Kernel::KSharedMemory>(
+    Kernel::KSharedMemory* object);
+template void HLERequestContext::AddCopyObject<Kernel::KTransferMemory>(
+    Kernel::KTransferMemory* object);
+
+template void HLERequestContext::AddMoveObject<Kernel::KClientSession>(
+    Kernel::KClientSession* object);
+template void HLERequestContext::AddMoveObject<Kernel::KServerPort>(Kernel::KServerPort* object);
+
 void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     IPC::RequestParser rp(src_cmdbuf);
     command_header = rp.PopRaw<IPC::CommandHeader>();

src/core/hle/service/hle_ipc.h

@@ -15,9 +15,9 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/concepts.h"
+#include "common/scratch_buffer.h"
 #include "common/swap.h"
 #include "core/hle/ipc.h"
-#include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/svc_common.h"
 
 union Result;
@@ -40,9 +40,8 @@ class KAutoObject;
 class KernelCore;
 class KHandleTable;
 class KProcess;
+class KReadableEvent;
 class KServerSession;
-template <typename T>
-class KScopedAutoObject;
 class KThread;
 } // namespace Kernel
 
@@ -335,15 +334,13 @@ public:
         return incoming_move_handles.at(index);
     }
 
-    void AddMoveObject(Kernel::KAutoObject* object) {
-        outgoing_move_objects.emplace_back(object);
-    }
+    template <typename T>
+    void AddMoveObject(T* object);
 
     void AddMoveInterface(SessionRequestHandlerPtr s);
 
-    void AddCopyObject(Kernel::KAutoObject* object) {
-        outgoing_copy_objects.emplace_back(object);
-    }
+    template <typename T>
+    void AddCopyObject(T* object);
 
     void AddDomainObject(SessionRequestHandlerPtr object) {
         outgoing_domain_objects.emplace_back(std::move(object));
@@ -369,13 +366,7 @@ public:
     }
 
     template <typename T>
-    Kernel::KScopedAutoObject<T> GetObjectFromHandle(u32 handle) {
-        auto obj = client_handle_table->GetObjectForIpc(handle, thread);
-        if (obj.IsNotNull()) {
-            return obj->DynamicCast<T*>();
-        }
-        return nullptr;
-    }
+    T* GetObjectFromHandle(u32 handle);
 
     [[nodiscard]] std::shared_ptr<SessionRequestManager> GetManager() const {
         return manager.lock();

src/core/hle/service/ipc_helpers.h

@@ -10,12 +10,8 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/hle/ipc.h"
-#include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_resource_limit.h"
-#include "core/hle/kernel/k_session.h"
 #include "core/hle/result.h"
 #include "core/hle/service/hle_ipc.h"
-#include "core/hle/service/server_manager.h"
 
 namespace IPC {
 
@@ -151,19 +147,7 @@ public:
         if (manager->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
-            ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(
-                Kernel::LimitableResource::SessionCountMax, 1));
-
-            auto* session = Kernel::KSession::Create(kernel);
-            session->Initialize(nullptr, 0);
-            Kernel::KSession::Register(kernel, session);
-
-            auto next_manager = std::make_shared<Service::SessionRequestManager>(
-                kernel, manager->GetServerManager());
-            next_manager->SetSessionHandler(iface);
-            manager->GetServerManager().RegisterSession(&session->GetServerSession(), next_manager);
-
-            context->AddMoveObject(&session->GetClientSession());
+            context->AddMoveInterface(std::move(iface));
         }
     }
 

src/core/hle/service/lbl/lbl.cpp

@@ -18,8 +18,8 @@ public:
     explicit LBL(Core::System& system_) : ServiceFramework{system_, "lbl"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &LBL::SaveCurrentSetting, "SaveCurrentSetting"},
-            {1, &LBL::LoadCurrentSetting, "LoadCurrentSetting"},
+            {0, nullptr, "SaveCurrentSetting"},
+            {1, nullptr, "LoadCurrentSetting"},
             {2, &LBL::SetCurrentBrightnessSetting, "SetCurrentBrightnessSetting"},
             {3, &LBL::GetCurrentBrightnessSetting, "GetCurrentBrightnessSetting"},
             {4, nullptr, "ApplyCurrentBrightnessSettingToBacklight"},
@@ -47,7 +47,7 @@ public:
             {26, &LBL::EnableVrMode, "EnableVrMode"},
             {27, &LBL::DisableVrMode, "DisableVrMode"},
             {28, &LBL::IsVrModeEnabled, "IsVrModeEnabled"},
-            {29, &LBL::IsAutoBrightnessControlSupported, "IsAutoBrightnessControlSupported"},
+            {29, nullptr, "IsAutoBrightnessControlSupported"},
         };
         // clang-format on
 
@@ -60,20 +60,6 @@ private:
         On = 1,
     };
 
-    void SaveCurrentSetting(HLERequestContext& ctx) {
-        LOG_WARNING(Service_LBL, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void LoadCurrentSetting(HLERequestContext& ctx) {
-        LOG_WARNING(Service_LBL, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
     void SetCurrentBrightnessSetting(HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         auto brightness = rp.Pop<float>();
@@ -324,14 +310,6 @@ private:
         rb.Push(vr_mode_enabled);
     }
 
-    void IsAutoBrightnessControlSupported(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_LBL, "called");
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push<u8>(auto_brightness_supported);
-    }
-
     bool vr_mode_enabled = false;
     float current_brightness = 1.0f;
     float ambient_light_value = 0.0f;
@@ -339,8 +317,7 @@ private:
     bool dimming = true;
     bool backlight_enabled = true;
     bool update_instantly = false;
-    bool auto_brightness = false;
-    bool auto_brightness_supported = true; // TODO(ogniK): Move to system settings
+    bool auto_brightness = false; // TODO(ogniK): Move to system settings
 };
 
 void LoopProcess(Core::System& system) {

src/core/hle/service/ldn/ldn.cpp

@@ -10,6 +10,7 @@
 #include "core/hle/service/ldn/sf_service_monitor.h"
 #include "core/hle/service/ldn/system_local_communication_service.h"
 #include "core/hle/service/ldn/user_local_communication_service.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::LDN {
 

src/core/hle/service/ldn/monitor_service.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ldn/ldn_results.h"
 #include "core/hle/service/ldn/monitor_service.h"
 
 namespace Service::LDN {
@@ -18,7 +17,7 @@ IMonitorService::IMonitorService(Core::System& system_)
         {4, nullptr, "GetSecurityParameterForMonitor"},
         {5, nullptr, "GetNetworkConfigForMonitor"},
         {100, C<&IMonitorService::InitializeMonitor>, "InitializeMonitor"},
-        {101, C<&IMonitorService::FinalizeMonitor>, "FinalizeMonitor"},
+        {101, nullptr, "FinalizeMonitor"},
     };
     // clang-format on
 
@@ -28,18 +27,16 @@ IMonitorService::IMonitorService(Core::System& system_)
 IMonitorService::~IMonitorService() = default;
 
 Result IMonitorService::GetStateForMonitor(Out<State> out_state) {
-    LOG_WARNING(Service_LDN, "(STUBBED) called");
-    *out_state = State::None;
+    LOG_INFO(Service_LDN, "called");
+
+    *out_state = state;
     R_SUCCEED();
 }
 
 Result IMonitorService::InitializeMonitor() {
     LOG_INFO(Service_LDN, "called");
-    R_SUCCEED();
-}
 
-Result IMonitorService::FinalizeMonitor() {
-    LOG_INFO(Service_LDN, "called");
+    state = State::Initialized;
     R_SUCCEED();
 }
 

src/core/hle/service/ldn/monitor_service.h

@@ -21,7 +21,6 @@ public:
 private:
     Result GetStateForMonitor(Out<State> out_state);
     Result InitializeMonitor();
-    Result FinalizeMonitor();
 
     State state{State::None};
 };

src/core/hle/service/nfc/common/device_manager.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/psc/time/steady_clock.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/set/system_settings_server.h"
 #include "core/hle/service/sm/sm.h"
 #include "hid_core/hid_types.h"
 #include "hid_core/hid_util.h"
@@ -33,9 +32,6 @@ DeviceManager::DeviceManager(Core::System& system_, KernelHelpers::ServiceContex
     }
 
     is_initialized = false;
-
-    m_set_sys =
-        system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
 }
 
 DeviceManager ::~DeviceManager() {
@@ -778,8 +774,8 @@ Result DeviceManager::CheckDeviceState(std::shared_ptr<NfcDevice> device) const
 }
 
 Result DeviceManager::IsNfcEnabled() const {
-    bool is_enabled{};
-    R_TRY(m_set_sys->GetNfcEnableFlag(&is_enabled));
+    // TODO: This calls nn::settings::detail::GetNfcEnableFlag
+    const bool is_enabled = true;
     if (!is_enabled) {
         return ResultNfcDisabled;
     }

src/core/hle/service/nfc/common/device_manager.h

@@ -15,10 +15,6 @@
 #include "core/hle/service/service.h"
 #include "hid_core/hid_types.h"
 
-namespace Service::Set {
-class ISystemSettingsServer;
-}
-
 namespace Service::NFC {
 class NfcDevice;
 
@@ -102,7 +98,6 @@ private:
     Core::System& system;
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* availability_change_event;
-    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
 };
 
 } // namespace Service::NFC

src/core/hle/service/nfc/nfc.cpp

@@ -57,7 +57,7 @@ public:
             {1, &NfcInterface::Finalize, "FinalizeOld"},
             {2, &NfcInterface::GetState, "GetStateOld"},
             {3, &NfcInterface::IsNfcEnabled, "IsNfcEnabledOld"},
-            {100, &NfcInterface::SetNfcEnabled, "SetNfcEnabledOld"},
+            {100, nullptr, "SetNfcEnabledOld"},
             {400, &NfcInterface::Initialize, "Initialize"},
             {401, &NfcInterface::Finalize, "Finalize"},
             {402, &NfcInterface::GetState, "GetState"},
@@ -71,7 +71,7 @@ public:
             {410, &NfcInterface::GetTagInfo, "GetTagInfo"},
             {411, &NfcInterface::AttachActivateEvent, "AttachActivateEvent"},
             {412, &NfcInterface::AttachDeactivateEvent, "AttachDeactivateEvent"},
-            {500, &NfcInterface::SetNfcEnabled, "SetNfcEnabled"},
+            {500, nullptr, "SetNfcEnabled"},
             {510, nullptr, "OutputTestWave"},
             {1000, &NfcInterface::ReadMifare, "ReadMifare"},
             {1001, &NfcInterface::WriteMifare, "WriteMifare"},

src/core/hle/service/nfc/nfc_interface.cpp

@@ -13,18 +13,13 @@
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/nfc/nfc_types.h"
 #include "core/hle/service/nfp/nfp_result.h"
-#include "core/hle/service/set/system_settings_server.h"
-#include "core/hle/service/sm/sm.h"
 #include "hid_core/hid_types.h"
 
 namespace Service::NFC {
 
 NfcInterface::NfcInterface(Core::System& system_, const char* name, BackendType service_backend)
     : ServiceFramework{system_, name}, service_context{system_, service_name},
-      backend_type{service_backend} {
-    m_set_sys =
-        system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
-}
+      backend_type{service_backend} {}
 
 NfcInterface ::~NfcInterface() = default;
 
@@ -70,11 +65,11 @@ void NfcInterface::GetState(HLERequestContext& ctx) {
 void NfcInterface::IsNfcEnabled(HLERequestContext& ctx) {
     LOG_DEBUG(Service_NFC, "called");
 
-    bool is_enabled{};
-    const auto result = m_set_sys->GetNfcEnableFlag(&is_enabled);
+    // TODO: This calls nn::settings::detail::GetNfcEnableFlag
+    const bool is_enabled = true;
 
     IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(result);
+    rb.Push(ResultSuccess);
     rb.Push(is_enabled);
 }
 
@@ -217,17 +212,6 @@ void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
     rb.PushCopyObjects(out_event);
 }
 
-void NfcInterface::SetNfcEnabled(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto is_enabled{rp.Pop<bool>()};
-    LOG_DEBUG(Service_NFC, "called, is_enabled={}", is_enabled);
-
-    const auto result = m_set_sys->SetNfcEnableFlag(is_enabled);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(result);
-}
-
 void NfcInterface::ReadMifare(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto device_handle{rp.Pop<u64>()};

src/core/hle/service/nfc/nfc_interface.h

@@ -7,10 +7,6 @@
 #include "core/hle/service/nfc/nfc_types.h"
 #include "core/hle/service/service.h"
 
-namespace Service::Set {
-class ISystemSettingsServer;
-}
-
 namespace Service::NFC {
 class DeviceManager;
 
@@ -33,7 +29,6 @@ public:
     void AttachActivateEvent(HLERequestContext& ctx);
     void AttachDeactivateEvent(HLERequestContext& ctx);
     void ReadMifare(HLERequestContext& ctx);
-    void SetNfcEnabled(HLERequestContext& ctx);
     void WriteMifare(HLERequestContext& ctx);
     void SendCommandByPassThrough(HLERequestContext& ctx);
 
@@ -49,7 +44,6 @@ protected:
     BackendType backend_type;
     State state{State::NonInitialized};
     std::shared_ptr<DeviceManager> device_manager = nullptr;
-    std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
 };
 
 } // namespace Service::NFC

src/core/hle/service/npns/npns.cpp

@@ -3,26 +3,22 @@
 
 #include <memory>
 
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/npns/npns.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::NPNS {
 
-class INpnsSystem final : public ServiceFramework<INpnsSystem> {
+class NPNS_S final : public ServiceFramework<NPNS_S> {
 public:
-    explicit INpnsSystem(Core::System& system_)
-        : ServiceFramework{system_, "npns:s"}, service_context{system, "npns:s"} {
+    explicit NPNS_S(Core::System& system_) : ServiceFramework{system_, "npns:s"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {1, nullptr, "ListenAll"},
-            {2, C<&INpnsSystem::ListenTo>, "ListenTo"},
+            {2, nullptr, "ListenTo"},
             {3, nullptr, "Receive"},
             {4, nullptr, "ReceiveRaw"},
-            {5, C<&INpnsSystem::GetReceiveEvent>, "GetReceiveEvent"},
+            {5, nullptr, "GetReceiveEvent"},
             {6, nullptr, "ListenUndelivered"},
             {7, nullptr, "GetStateChangeEVent"},
             {11, nullptr, "SubscribeTopic"},
@@ -63,34 +59,12 @@ public:
         // clang-format on
 
         RegisterHandlers(functions);
-
-        get_receive_event = service_context.CreateEvent("npns:s:GetReceiveEvent");
     }
-
-    ~INpnsSystem() override {
-        service_context.CloseEvent(get_receive_event);
-    }
-
-private:
-    Result ListenTo(u32 program_id) {
-        LOG_WARNING(Service_AM, "(STUBBED) called, program_id={}", program_id);
-        R_SUCCEED();
-    }
-
-    Result GetReceiveEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
-        LOG_WARNING(Service_AM, "(STUBBED) called");
-
-        *out_event = &get_receive_event->GetReadableEvent();
-        R_SUCCEED();
-    }
-
-    KernelHelpers::ServiceContext service_context;
-    Kernel::KEvent* get_receive_event;
 };
 
-class INpnsUser final : public ServiceFramework<INpnsUser> {
+class NPNS_U final : public ServiceFramework<NPNS_U> {
 public:
-    explicit INpnsUser(Core::System& system_) : ServiceFramework{system_, "npns:u"} {
+    explicit NPNS_U(Core::System& system_) : ServiceFramework{system_, "npns:u"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {1, nullptr, "ListenAll"},
@@ -123,8 +97,8 @@ public:
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
-    server_manager->RegisterNamedService("npns:s", std::make_shared<INpnsSystem>(system));
-    server_manager->RegisterNamedService("npns:u", std::make_shared<INpnsUser>(system));
+    server_manager->RegisterNamedService("npns:s", std::make_shared<NPNS_S>(system));
+    server_manager->RegisterNamedService("npns:u", std::make_shared<NPNS_U>(system));
     ServerManager::RunServer(std::move(server_manager));
 }
 

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/service/cmif_serialization.h"

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/settings.h"
+#include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/vfs/vfs.h"

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -7,6 +7,7 @@
 
 #include "common/alignment.h"
 #include "common/assert.h"
+#include "common/bit_util.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/core/container.h"

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -5,7 +5,6 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
 #include "core/hle/service/nvdrv/core/syncpoint_manager.h"
@@ -76,7 +75,7 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
         case 0xd:
             return WrapFixed(this, &nvhost_gpu::SetChannelPriority, input, output);
         case 0x1a:
-            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output, fd);
+            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output);
         case 0x1b:
             return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, true);
         case 0x1d:
@@ -121,13 +120,8 @@ NvResult nvhost_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     return NvResult::NotImplemented;
 }
 
-void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
-    sessions[fd] = session_id;
-}
-
-void nvhost_gpu::OnClose(DeviceFD fd) {
-    sessions.erase(fd);
-}
+void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
+void nvhost_gpu::OnClose(DeviceFD fd) {}
 
 NvResult nvhost_gpu::SetNVMAPfd(IoctlSetNvmapFD& params) {
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
@@ -167,7 +161,7 @@ NvResult nvhost_gpu::SetChannelPriority(IoctlChannelSetPriority& params) {
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd) {
+NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params) {
     LOG_WARNING(Service_NVDRV,
                 "(STUBBED) called, num_entries={:X}, flags={:X}, unk0={:X}, "
                 "unk1={:X}, unk2={:X}, unk3={:X}",
@@ -179,12 +173,7 @@ NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd) {
         return NvResult::AlreadyAllocated;
     }
 
-    u64 program_id{};
-    if (auto* const session = core.GetSession(sessions[fd]); session != nullptr) {
-        program_id = session->process->GetProgramId();
-    }
-
-    system.GPU().InitChannel(*channel_state, program_id);
+    system.GPU().InitChannel(*channel_state);
 
     params.fence_out = syncpoint_manager.GetSyncpointFence(channel_syncpoint);
 

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -192,7 +192,7 @@ private:
     NvResult ZCullBind(IoctlZCullBind& params);
     NvResult SetErrorNotifier(IoctlSetErrorNotifier& params);
     NvResult SetChannelPriority(IoctlChannelSetPriority& params);
-    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd);
+    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params);
     NvResult AllocateObjectContext(IoctlAllocObjCtx& params);
 
     NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandList&& entries);
@@ -210,7 +210,6 @@ private:
     NvCore::SyncpointManager& syncpoint_manager;
     NvCore::NvMap& nvmap;
     std::shared_ptr<Tegra::Control::ChannelState> channel_state;
-    std::unordered_map<DeviceFD, NvCore::SessionId> sessions;
     u32 channel_syncpoint;
     std::mutex channel_mutex;
 

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

@@ -173,7 +173,7 @@ void NVDRV::Initialize(HLERequestContext& ctx) {
 
     auto& container = nvdrv->GetContainer();
     auto process = ctx.GetObjectFromHandle<Kernel::KProcess>(process_handle);
-    session_id = container.OpenSession(process.GetPointerUnsafe());
+    session_id = container.OpenSession(process);
 
     is_initialized = true;
 }

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/alignment.h"
 #include "core/core.h"
 #include "core/hle/service/psc/time/alarms.h"
 #include "core/hle/service/psc/time/manager.h"

src/core/hle/service/services.cpp

@@ -5,7 +5,7 @@
 
 #include "core/hle/service/acc/acc.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/aoc/addon_content_manager.h"
+#include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
 #include "core/hle/service/bcat/bcat.h"

src/core/hle/service/set/setting_formats/system_settings.cpp

@@ -52,10 +52,6 @@ SystemSettings DefaultSystemSettings() {
     settings.battery_percentage_flag = true;
     settings.chinese_traditional_input_method = ChineseTraditionalInputMethod::Unknown0;
     settings.vibration_master_volume = 1.0f;
-    settings.touch_screen_mode = TouchScreenMode::Standard;
-    settings.nfc_enable_flag = true;
-    settings.bluetooth_enable_flag = true;
-    settings.wireless_lan_enable_flag = true;
 
     const auto language_code =
         available_language_codes[static_cast<s32>(::Settings::values.language_index.GetValue())];

src/core/hle/service/set/settings_types.h

@@ -243,11 +243,6 @@ enum class TvResolution : u32 {
     Resolution480p,
 };
 
-enum class PlatformRegion : s32 {
-    Global = 1,
-    Terra = 2,
-};
-
 constexpr std::array<LanguageCode, 18> available_language_codes = {{
     LanguageCode::JA,
     LanguageCode::EN_US,
@@ -410,7 +405,8 @@ struct EulaVersion {
     SystemRegionCode region_code;
     EulaVersionClockType clock_type;
     INSERT_PADDING_BYTES(0x4);
-    Service::PSC::Time::SystemClockContext system_clock_context;
+    s64 posix_time;
+    Service::PSC::Time::SteadyClockTimePoint timestamp;
 };
 static_assert(sizeof(EulaVersion) == 0x30, "EulaVersion is incorrect size");
 

src/core/hle/service/set/system_settings_server.cpp

@@ -10,6 +10,7 @@
 #include "common/logging/log.h"
 #include "common/settings.h"
 #include "common/string_util.h"
+#include "common/thread.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/errors.h"
@@ -26,7 +27,7 @@
 namespace Service::Set {
 
 namespace {
-constexpr u32 SETTINGS_VERSION{4u};
+constexpr u32 SETTINGS_VERSION{3u};
 constexpr auto SETTINGS_MAGIC = Common::MakeMagic('y', 'u', 'z', 'u', '_', 's', 'e', 't');
 struct SettingsHeader {
     u64 magic;
@@ -272,8 +273,8 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_)
         {180, nullptr, "SetZoomFlag"},
         {181, nullptr, "GetT"},
         {182, nullptr, "SetT"},
-        {183, C<&ISystemSettingsServer::GetPlatformRegion>, "GetPlatformRegion"},
-        {184, C<&ISystemSettingsServer::SetPlatformRegion>, "SetPlatformRegion"},
+        {183, nullptr, "GetPlatformRegion"},
+        {184, nullptr, "SetPlatformRegion"},
         {185, C<&ISystemSettingsServer::GetHomeMenuSchemeModel>, "GetHomeMenuSchemeModel"},
         {186, nullptr, "GetMemoryUsageRateFlag"},
         {187, C<&ISystemSettingsServer::GetTouchScreenMode>, "GetTouchScreenMode"},
@@ -306,20 +307,6 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_)
     RegisterHandlers(functions);
 
     SetupSettings();
-
-    m_system_settings.region_code =
-        static_cast<SystemRegionCode>(::Settings::values.region_index.GetValue());
-
-    // TODO: Remove this when starter applet is fully functional
-    EulaVersion eula_version{
-        .version = 0x10000,
-        .region_code = m_system_settings.region_code,
-        .clock_type = EulaVersionClockType::SteadyClock,
-        .system_clock_context = m_system_settings.user_system_clock_context,
-    };
-    m_system_settings.eula_versions[0] = eula_version;
-    m_system_settings.eula_version_count = 1;
-
     m_save_thread =
         std::jthread([this](std::stop_token stop_token) { StoreSettingsThreadFunc(stop_token); });
 }
@@ -715,7 +702,7 @@ Result ISystemSettingsServer::GetSettingsItemValueSize(
 }
 
 Result ISystemSettingsServer::GetSettingsItemValue(
-    Out<u64> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_data,
+    OutBuffer<BufferAttr_HipcMapAlias> out_data,
     InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer,
     InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buffer) {
     const std::string setting_category{Common::StringFromBuffer(*setting_category_buffer)};
@@ -723,7 +710,7 @@ Result ISystemSettingsServer::GetSettingsItemValue(
 
     LOG_INFO(Service_SET, "called, category={}, name={}", setting_category, setting_name);
 
-    R_RETURN(GetSettingsItemValueImpl(out_data, *out_size, setting_category, setting_name));
+    R_RETURN(GetSettingsItemValueImpl(out_data, setting_category, setting_name));
 }
 
 Result ISystemSettingsServer::GetTvSettings(Out<TvSettings> out_tv_settings) {
@@ -1250,18 +1237,6 @@ Result ISystemSettingsServer::GetHomeMenuScheme(Out<HomeMenuScheme> out_home_men
     R_SUCCEED();
 }
 
-Result ISystemSettingsServer::GetPlatformRegion(Out<PlatformRegion> out_platform_region) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    *out_platform_region = PlatformRegion::Global;
-    R_SUCCEED();
-}
-
-Result ISystemSettingsServer::SetPlatformRegion(PlatformRegion platform_region) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-    R_SUCCEED();
-}
-
 Result ISystemSettingsServer::GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model) {
     LOG_WARNING(Service_SET, "(STUBBED) called");
 
@@ -1375,16 +1350,13 @@ void ISystemSettingsServer::SetSaveNeeded() {
     m_save_needed = true;
 }
 
-Result ISystemSettingsServer::GetSettingsItemValueImpl(std::span<u8> out_value, u64& out_size,
+Result ISystemSettingsServer::GetSettingsItemValueImpl(std::vector<u8>& out_value,
                                                        const std::string& category,
                                                        const std::string& name) {
     auto settings{GetSettings()};
     R_UNLESS(settings.contains(category) && settings[category].contains(name), ResultUnknown);
 
-    ASSERT_MSG(out_value.size() >= settings[category][name].size(),
-               "Stored type is bigger than requested type");
-    out_size = std::min<u64>(settings[category][name].size(), out_value.size());
-    std::memcpy(out_value.data(), settings[category][name].data(), out_size);
+    out_value = settings[category][name];
     R_SUCCEED();
 }
 

src/core/hle/service/set/system_settings_server.h

@@ -34,17 +34,20 @@ public:
     explicit ISystemSettingsServer(Core::System& system_);
     ~ISystemSettingsServer() override;
 
-    Result GetSettingsItemValueImpl(std::span<u8> out_value, u64& out_size,
-                                    const std::string& category, const std::string& name);
+    Result GetSettingsItemValueImpl(std::vector<u8>& out_value, const std::string& category,
+                                    const std::string& name);
 
     template <typename T>
-    Result GetSettingsItemValueImpl(T& out_value, const std::string& category,
+    Result GetSettingsItemValueImpl(T& value, const std::string& category,
                                     const std::string& name) {
-        u64 data_size{};
-        std::vector<u8> data(sizeof(T));
-        R_TRY(GetSettingsItemValueImpl(data, data_size, category, name));
-        std::memcpy(&out_value, data.data(), data_size);
-        R_SUCCEED();
+        std::vector<u8> data;
+        const auto result = GetSettingsItemValueImpl(data, category, name);
+        if (result.IsError()) {
+            return result;
+        }
+        ASSERT(data.size() >= sizeof(T));
+        std::memcpy(&value, data.data(), sizeof(T));
+        return result;
     }
 
 public:
@@ -81,7 +84,7 @@ public:
         InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer,
         InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buf);
     Result GetSettingsItemValue(
-        Out<u64> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_data,
+        OutBuffer<BufferAttr_HipcMapAlias> out_data,
         InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer,
         InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buffer);
     Result GetTvSettings(Out<TvSettings> out_tv_settings);
@@ -149,8 +152,6 @@ public:
     Result GetHomeMenuScheme(Out<HomeMenuScheme> out_home_menu_scheme);
     Result GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model);
     Result GetTouchScreenMode(Out<TouchScreenMode> out_touch_screen_mode);
-    Result GetPlatformRegion(Out<PlatformRegion> out_platform_region);
-    Result SetPlatformRegion(PlatformRegion platform_region);
     Result SetTouchScreenMode(TouchScreenMode touch_screen_mode);
     Result GetFieldTestingFlag(Out<bool> out_field_testing_flag);
     Result GetPanelCrcMode(Out<s32> out_panel_crc_mode);

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

@@ -1,156 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/alignment.h"
-#include "core/core.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/ssl/cert_store.h"
-
-namespace Service::SSL {
-
-// https://switchbrew.org/wiki/SSL_services#CertStore
-
-CertStore::CertStore(Core::System& system) {
-    constexpr u64 CertStoreDataId = 0x0100000000000800ULL;
-
-    auto& fsc = system.GetFileSystemController();
-
-    // Attempt to load certificate data from storage
-    const auto nca =
-        fsc.GetSystemNANDContents()->GetEntry(CertStoreDataId, FileSys::ContentRecordType::Data);
-    if (!nca) {
-        return;
-    }
-    const auto romfs = nca->GetRomFS();
-    if (!romfs) {
-        return;
-    }
-    const auto extracted = FileSys::ExtractRomFS(romfs);
-    if (!extracted) {
-        LOG_ERROR(Service_SSL, "CertStore could not be extracted, corrupt RomFS?");
-        return;
-    }
-    const auto cert_store_file = extracted->GetFile("ssl_TrustedCerts.bdf");
-    if (!cert_store_file) {
-        LOG_ERROR(Service_SSL, "Failed to find trusted certificates in CertStore");
-        return;
-    }
-
-    // Read and verify the header.
-    CertStoreHeader header;
-    cert_store_file->ReadObject(std::addressof(header));
-
-    if (header.magic != Common::MakeMagic('s', 's', 'l', 'T')) {
-        LOG_ERROR(Service_SSL, "Invalid certificate store magic");
-        return;
-    }
-
-    // Ensure the file can contains the number of entries it says it does.
-    const u64 expected_size = sizeof(header) + sizeof(CertStoreEntry) * header.num_entries;
-    const u64 actual_size = cert_store_file->GetSize();
-    if (actual_size < expected_size) {
-        LOG_ERROR(Service_SSL, "Size mismatch, expected at least {} bytes, got {}", expected_size,
-                  actual_size);
-        return;
-    }
-
-    // Read entries.
-    std::vector<CertStoreEntry> entries(header.num_entries);
-    cert_store_file->ReadArray(entries.data(), header.num_entries, sizeof(header));
-
-    // Insert into memory store.
-    for (const auto& entry : entries) {
-        m_certs.emplace(entry.certificate_id,
-                        Certificate{
-                            .status = entry.certificate_status,
-                            .der_data = cert_store_file->ReadBytes(
-                                entry.der_size, entry.der_offset + sizeof(header)),
-                        });
-    }
-}
-
-CertStore::~CertStore() = default;
-
-template <typename F>
-void CertStore::ForEachCertificate(std::span<const CaCertificateId> certificate_ids, F&& f) {
-    if (certificate_ids.size() == 1 && certificate_ids.front() == CaCertificateId::All) {
-        for (const auto& entry : m_certs) {
-            f(entry);
-        }
-    } else {
-        for (const auto certificate_id : certificate_ids) {
-            const auto entry = m_certs.find(certificate_id);
-            if (entry == m_certs.end()) {
-                continue;
-            }
-            f(*entry);
-        }
-    }
-}
-
-Result CertStore::GetCertificates(u32* out_num_entries, std::span<u8> out_data,
-                                  std::span<const CaCertificateId> certificate_ids) {
-    // Ensure the buffer is large enough to hold the output.
-    u32 required_size;
-    R_TRY(this->GetCertificateBufSize(std::addressof(required_size), out_num_entries,
-                                      certificate_ids));
-    R_UNLESS(out_data.size_bytes() >= required_size, ResultUnknown);
-
-    // Make parallel arrays.
-    std::vector<BuiltInCertificateInfo> cert_infos;
-    std::vector<u8> der_datas;
-
-    const u32 der_data_offset = (*out_num_entries + 1) * sizeof(BuiltInCertificateInfo);
-    u32 cur_der_offset = der_data_offset;
-
-    // Fill output.
-    this->ForEachCertificate(certificate_ids, [&](auto& entry) {
-        const auto& [status, cur_der_data] = entry.second;
-        BuiltInCertificateInfo cert_info{
-            .cert_id = entry.first,
-            .status = status,
-            .der_size = cur_der_data.size(),
-            .der_offset = cur_der_offset,
-        };
-
-        cert_infos.push_back(cert_info);
-        der_datas.insert(der_datas.end(), cur_der_data.begin(), cur_der_data.end());
-        cur_der_offset += static_cast<u32>(cur_der_data.size());
-    });
-
-    // Append terminator entry.
-    cert_infos.push_back(BuiltInCertificateInfo{
-        .cert_id = CaCertificateId::All,
-        .status = TrustedCertStatus::Invalid,
-        .der_size = 0,
-        .der_offset = 0,
-    });
-
-    // Write to output span.
-    std::memcpy(out_data.data(), cert_infos.data(),
-                cert_infos.size() * sizeof(BuiltInCertificateInfo));
-    std::memcpy(out_data.data() + der_data_offset, der_datas.data(), der_datas.size());
-
-    R_SUCCEED();
-}
-
-Result CertStore::GetCertificateBufSize(u32* out_size, u32* out_num_entries,
-                                        std::span<const CaCertificateId> certificate_ids) {
-    // Output size is at least the size of the terminator entry.
-    *out_size = sizeof(BuiltInCertificateInfo);
-    *out_num_entries = 0;
-
-    this->ForEachCertificate(certificate_ids, [&](auto& entry) {
-        *out_size += sizeof(BuiltInCertificateInfo);
-        *out_size += Common::AlignUp(static_cast<u32>(entry.second.der_data.size()), 4);
-        (*out_num_entries)++;
-    });
-
-    R_SUCCEED();
-}
-
-} // namespace Service::SSL

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

@@ -1,42 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <map>
-#include <span>
-#include <vector>
-
-#include "core/hle/result.h"
-#include "core/hle/service/ssl/ssl_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::SSL {
-
-class CertStore {
-public:
-    explicit CertStore(Core::System& system);
-    ~CertStore();
-
-    Result GetCertificates(u32* out_num_entries, std::span<u8> out_data,
-                           std::span<const CaCertificateId> certificate_ids);
-    Result GetCertificateBufSize(u32* out_size, u32* out_num_entries,
-                                 std::span<const CaCertificateId> certificate_ids);
-
-private:
-    template <typename F>
-    void ForEachCertificate(std::span<const CaCertificateId> certs, F&& f);
-
-private:
-    struct Certificate {
-        TrustedCertStatus status;
-        std::vector<u8> der_data;
-    };
-
-    std::map<CaCertificateId, Certificate> m_certs;
-};
-
-} // namespace Service::SSL

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

@@ -5,13 +5,11 @@
 
 #include "core/core.h"
 #include "core/hle/result.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/sockets/bsd.h"
-#include "core/hle/service/ssl/cert_store.h"
 #include "core/hle/service/ssl/ssl.h"
 #include "core/hle/service/ssl/ssl_backend.h"
 #include "core/internal_network/network.h"
@@ -494,14 +492,13 @@ private:
 
 class ISslService final : public ServiceFramework<ISslService> {
 public:
-    explicit ISslService(Core::System& system_)
-        : ServiceFramework{system_, "ssl"}, cert_store{system} {
+    explicit ISslService(Core::System& system_) : ServiceFramework{system_, "ssl"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISslService::CreateContext, "CreateContext"},
             {1, nullptr, "GetContextCount"},
-            {2, D<&ISslService::GetCertificates>, "GetCertificates"},
-            {3, D<&ISslService::GetCertificateBufSize>, "GetCertificateBufSize"},
+            {2, nullptr, "GetCertificates"},
+            {3, nullptr, "GetCertificateBufSize"},
             {4, nullptr, "DebugIoctl"},
             {5, &ISslService::SetInterfaceVersion, "SetInterfaceVersion"},
             {6, nullptr, "FlushSessionCache"},
@@ -543,22 +540,6 @@ private:
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
     }
-
-    Result GetCertificateBufSize(
-        Out<u32> out_size, InArray<CaCertificateId, BufferAttr_HipcMapAlias> certificate_ids) {
-        LOG_INFO(Service_SSL, "called");
-        u32 num_entries;
-        R_RETURN(cert_store.GetCertificateBufSize(out_size, &num_entries, certificate_ids));
-    }
-
-    Result GetCertificates(Out<u32> out_num_entries, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                           InArray<CaCertificateId, BufferAttr_HipcMapAlias> certificate_ids) {
-        LOG_INFO(Service_SSL, "called");
-        R_RETURN(cert_store.GetCertificates(out_num_entries, out_buffer, certificate_ids));
-    }
-
-private:
-    CertStore cert_store;
 };
 
 void LoopProcess(Core::System& system) {

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

@@ -1,107 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Service::SSL {
-
-enum class CaCertificateId : s32 {
-    All = -1,
-    NintendoCAG3 = 1,
-    NintendoClass2CAG3 = 2,
-    NintendoRootCAG4 = 3,
-    AmazonRootCA1 = 1000,
-    StarfieldServicesRootCertificateAuthorityG2 = 1001,
-    AddTrustExternalCARoot = 1002,
-    COMODOCertificationAuthority = 1003,
-    UTNDATACorpSGC = 1004,
-    UTNUSERFirstHardware = 1005,
-    BaltimoreCyberTrustRoot = 1006,
-    CybertrustGlobalRoot = 1007,
-    VerizonGlobalRootCA = 1008,
-    DigiCertAssuredIDRootCA = 1009,
-    DigiCertAssuredIDRootG2 = 1010,
-    DigiCertGlobalRootCA = 1011,
-    DigiCertGlobalRootG2 = 1012,
-    DigiCertHighAssuranceEVRootCA = 1013,
-    EntrustnetCertificationAuthority2048 = 1014,
-    EntrustRootCertificationAuthority = 1015,
-    EntrustRootCertificationAuthorityG2 = 1016,
-    GeoTrustGlobalCA2 = 1017,
-    GeoTrustGlobalCA = 1018,
-    GeoTrustPrimaryCertificationAuthorityG3 = 1019,
-    GeoTrustPrimaryCertificationAuthority = 1020,
-    GlobalSignRootCA = 1021,
-    GlobalSignRootCAR2 = 1022,
-    GlobalSignRootCAR3 = 1023,
-    GoDaddyClass2CertificationAuthority = 1024,
-    GoDaddyRootCertificateAuthorityG2 = 1025,
-    StarfieldClass2CertificationAuthority = 1026,
-    StarfieldRootCertificateAuthorityG2 = 1027,
-    thawtePrimaryRootCAG3 = 1028,
-    thawtePrimaryRootCA = 1029,
-    VeriSignClass3PublicPrimaryCertificationAuthorityG3 = 1030,
-    VeriSignClass3PublicPrimaryCertificationAuthorityG5 = 1031,
-    VeriSignUniversalRootCertificationAuthority = 1032,
-    DSTRootCAX3 = 1033,
-    USERTrustRsaCertificationAuthority = 1034,
-    ISRGRootX10 = 1035,
-    USERTrustEccCertificationAuthority = 1036,
-    COMODORsaCertificationAuthority = 1037,
-    COMODOEccCertificationAuthority = 1038,
-    AmazonRootCA2 = 1039,
-    AmazonRootCA3 = 1040,
-    AmazonRootCA4 = 1041,
-    DigiCertAssuredIDRootG3 = 1042,
-    DigiCertGlobalRootG3 = 1043,
-    DigiCertTrustedRootG4 = 1044,
-    EntrustRootCertificationAuthorityEC1 = 1045,
-    EntrustRootCertificationAuthorityG4 = 1046,
-    GlobalSignECCRootCAR4 = 1047,
-    GlobalSignECCRootCAR5 = 1048,
-    GlobalSignECCRootCAR6 = 1049,
-    GTSRootR1 = 1050,
-    GTSRootR2 = 1051,
-    GTSRootR3 = 1052,
-    GTSRootR4 = 1053,
-    SecurityCommunicationRootCA = 1054,
-    GlobalSignRootE4 = 1055,
-    GlobalSignRootR4 = 1056,
-    TTeleSecGlobalRootClass2 = 1057,
-    DigiCertTLSECCP384RootG5 = 1058,
-    DigiCertTLSRSA4096RootG5 = 1059,
-};
-
-enum class TrustedCertStatus : s32 {
-    Invalid = -1,
-    Removed = 0,
-    EnabledTrusted = 1,
-    EnabledNotTrusted = 2,
-    Revoked = 3,
-};
-
-struct BuiltInCertificateInfo {
-    CaCertificateId cert_id;
-    TrustedCertStatus status;
-    u64 der_size;
-    u64 der_offset;
-};
-static_assert(sizeof(BuiltInCertificateInfo) == 0x18, "BuiltInCertificateInfo has incorrect size.");
-
-struct CertStoreHeader {
-    u32 magic;
-    u32 num_entries;
-};
-static_assert(sizeof(CertStoreHeader) == 0x8, "CertStoreHeader has incorrect size.");
-
-struct CertStoreEntry {
-    CaCertificateId certificate_id;
-    TrustedCertStatus certificate_status;
-    u32 der_size;
-    u32 der_offset;
-};
-static_assert(sizeof(CertStoreEntry) == 0x10, "CertStoreEntry has incorrect size.");
-
-} // namespace Service::SSL

src/hid_core/frontend/emulated_controller.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
-#include <chrono>
 #include <common/scope_exit.h>
 
 #include "common/polyfill_ranges.h"
@@ -176,9 +175,10 @@ void EmulatedController::LoadDevices() {
     if (npad_id_type == NpadIdType::Player1 || npad_id_type == NpadIdType::Handheld) {
         camera_params[1] = Common::ParamPackage{"engine:camera,camera:1"};
         nfc_params[0] = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
-#ifndef ANDROID
+#ifdef HAVE_LIBUSB
         ring_params[1] = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
-#else
+#endif
+#ifdef ANDROID
         android_params = Common::ParamPackage{"engine:android,port:100"};
 #endif
     }
@@ -1287,22 +1287,6 @@ bool EmulatedController::SetVibration(DeviceIndex device_index, const VibrationV
         return false;
     }
 
-    if (!Settings::values.enable_accurate_vibrations.GetValue()) {
-        using std::chrono::duration_cast;
-        using std::chrono::milliseconds;
-        using std::chrono::steady_clock;
-
-        const auto now = steady_clock::now();
-
-        // Filter out non-zero vibrations that are within 15ms of each other.
-        if ((vibration.low_amplitude != 0.0f || vibration.high_amplitude != 0.0f) &&
-            duration_cast<milliseconds>(now - last_vibration_timepoint[index]) < milliseconds(15)) {
-            return false;
-        }
-
-        last_vibration_timepoint[index] = now;
-    }
-
     // Exponential amplification is too strong at low amplitudes. Switch to a linear
     // amplification if strength is set below 0.7f
     const Common::Input::VibrationAmplificationType type =

src/hid_core/frontend/emulated_controller.h

@@ -583,7 +583,6 @@ private:
     std::size_t nfc_handles{0};
     std::array<VibrationValue, 2> last_vibration_value{DEFAULT_VIBRATION_VALUE,
                                                        DEFAULT_VIBRATION_VALUE};
-    std::array<std::chrono::steady_clock::time_point, 2> last_vibration_timepoint{};
 
     // Temporary values to avoid doing changes while the controller is in configuring mode
     NpadStyleIndex tmp_npad_type{NpadStyleIndex::None};

src/hid_core/hid_types.h

@@ -638,11 +638,7 @@ struct VibrationValue {
         if (low_amplitude != b.low_amplitude || high_amplitude != b.high_amplitude) {
             return false;
         }
-        // Changes in frequency without amplitude don't have any effect
-        if (low_amplitude == 0 && high_amplitude == 0) {
-            return true;
-        }
-        if (low_frequency != b.low_frequency || high_frequency != b.high_frequency) {
+        if (low_frequency != b.low_amplitude || high_frequency != b.high_frequency) {
             return false;
         }
         return true;

src/hid_core/resources/npad/npad.cpp

@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <array>
+#include <chrono>
 #include <cstring>
 
 #include "common/assert.h"

src/input_common/drivers/android.cpp

@@ -3,7 +3,6 @@
 
 #include <set>
 #include <common/settings_input.h>
-#include <common/thread.h>
 #include <jni.h>
 #include "common/android/android_common.h"
 #include "common/android/id_cache.h"
@@ -11,18 +10,7 @@
 
 namespace InputCommon {
 
-Android::Android(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-    vibration_thread = std::jthread([this](std::stop_token token) {
-        Common::SetCurrentThreadName("Android_Vibration");
-        auto env = Common::Android::GetEnvForThread();
-        using namespace std::chrono_literals;
-        while (!token.stop_requested()) {
-            SendVibrations(env, token);
-        }
-    });
-}
-
-Android::~Android() = default;
+Android::Android(std::string input_engine_) : InputEngine(std::move(input_engine_)) {}
 
 void Android::RegisterController(jobject j_input_device) {
     auto env = Common::Android::GetEnvForThread();
@@ -69,11 +57,17 @@ void Android::SetMotionState(std::string guid, size_t port, u64 delta_timestamp,
 Common::Input::DriverResult Android::SetVibration(
     [[maybe_unused]] const PadIdentifier& identifier,
     [[maybe_unused]] const Common::Input::VibrationStatus& vibration) {
-    vibration_queue.Push(VibrationRequest{
-        .identifier = identifier,
-        .vibration = vibration,
-    });
-    return Common::Input::DriverResult::Success;
+    auto device = input_devices.find(identifier);
+    if (device != input_devices.end()) {
+        Common::Android::RunJNIOnFiber<void>([&](JNIEnv* env) {
+            float average_intensity =
+                static_cast<float>((vibration.high_amplitude + vibration.low_amplitude) / 2.0);
+            env->CallVoidMethod(device->second, Common::Android::GetYuzuDeviceVibrate(),
+                                average_intensity);
+        });
+        return Common::Input::DriverResult::Success;
+    }
+    return Common::Input::DriverResult::NotSupported;
 }
 
 bool Android::IsVibrationEnabled([[maybe_unused]] const PadIdentifier& identifier) {
@@ -353,15 +347,4 @@ PadIdentifier Android::GetIdentifier(const std::string& guid, size_t port) const
     };
 }
 
-void Android::SendVibrations(JNIEnv* env, std::stop_token token) {
-    VibrationRequest request = vibration_queue.PopWait(token);
-    auto device = input_devices.find(request.identifier);
-    if (device != input_devices.end()) {
-        float average_intensity = static_cast<float>(
-            (request.vibration.high_amplitude + request.vibration.low_amplitude) / 2.0);
-        env->CallVoidMethod(device->second, Common::Android::GetYuzuDeviceVibrate(),
-                            average_intensity);
-    }
-}
-
 } // namespace InputCommon

src/input_common/drivers/android.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #include <set>
-#include <common/threadsafe_queue.h>
 #include <jni.h>
 #include "input_common/input_engine.h"
 
@@ -17,8 +16,6 @@ class Android final : public InputEngine {
 public:
     explicit Android(std::string input_engine_);
 
-    ~Android() override;
-
     /**
      * Registers controller number to accept new inputs.
      * @param j_input_device YuzuInputDevice object from the Android frontend to register.
@@ -92,9 +89,6 @@ private:
     /// Returns the correct identifier corresponding to the player index
     PadIdentifier GetIdentifier(const std::string& guid, size_t port) const;
 
-    /// Takes all vibrations from the queue and sends the command to the controller
-    void SendVibrations(JNIEnv* env, std::stop_token token);
-
     static constexpr s32 AXIS_X = 0;
     static constexpr s32 AXIS_Y = 1;
     static constexpr s32 AXIS_Z = 11;
@@ -139,10 +133,6 @@ private:
                                                    redmagic_vid, backbone_labs_vid, xbox_vid};
     const std::vector<std::string> flipped_xy_vids{sony_vid, razer_vid, redmagic_vid,
                                                    backbone_labs_vid, xbox_vid};
-
-    /// Queue of vibration request to controllers
-    Common::SPSCQueue<VibrationRequest> vibration_queue;
-    std::jthread vibration_thread;
 };
 
 } // namespace InputCommon

src/input_common/drivers/sdl_driver.h

@@ -69,6 +69,11 @@ public:
     bool IsVibrationEnabled(const PadIdentifier& identifier) override;
 
 private:
+    struct VibrationRequest {
+        PadIdentifier identifier;
+        Common::Input::VibrationStatus vibration;
+    };
+
     void InitJoystick(int joystick_index);
     void CloseJoystick(SDL_Joystick* sdl_joystick);
 

src/input_common/input_engine.h

@@ -46,11 +46,6 @@ enum class EngineInputType {
     Nfc,
 };
 
-struct VibrationRequest {
-    PadIdentifier identifier;
-    Common::Input::VibrationStatus vibration;
-};
-
 namespace std {
 // Hash used to create lists from PadIdentifier data
 template <>

src/video_core/control/channel_state.cpp

@@ -16,9 +16,8 @@ namespace Tegra::Control {
 
 ChannelState::ChannelState(s32 bind_id_) : bind_id{bind_id_}, initialized{} {}
 
-void ChannelState::Init(Core::System& system, GPU& gpu, u64 program_id_) {
+void ChannelState::Init(Core::System& system, GPU& gpu) {
     ASSERT(memory_manager);
-    program_id = program_id_;
     dma_pusher = std::make_unique<Tegra::DmaPusher>(system, gpu, *memory_manager, *this);
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, *memory_manager);
     fermi_2d = std::make_unique<Engines::Fermi2D>(*memory_manager);

src/video_core/control/channel_state.h

@@ -40,12 +40,11 @@ struct ChannelState {
     ChannelState(ChannelState&& other) noexcept = default;
     ChannelState& operator=(ChannelState&& other) noexcept = default;
 
-    void Init(Core::System& system, GPU& gpu, u64 program_id);
+    void Init(Core::System& system, GPU& gpu);
 
     void BindRasterizer(VideoCore::RasterizerInterface* rasterizer);
 
     s32 bind_id = -1;
-    u64 program_id = 0;
     /// 3D engine
     std::unique_ptr<Engines::Maxwell3D> maxwell_3d;
     /// 2D engine

src/video_core/control/channel_state_cache.cpp

@@ -7,7 +7,7 @@ namespace VideoCommon {
 
 ChannelInfo::ChannelInfo(Tegra::Control::ChannelState& channel_state)
     : maxwell3d{*channel_state.maxwell_3d}, kepler_compute{*channel_state.kepler_compute},
-      gpu_memory{*channel_state.memory_manager}, program_id{channel_state.program_id} {}
+      gpu_memory{*channel_state.memory_manager} {}
 
 template class VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo>;
 

src/video_core/control/channel_state_cache.h

@@ -39,7 +39,6 @@ public:
     Tegra::Engines::Maxwell3D& maxwell3d;
     Tegra::Engines::KeplerCompute& kepler_compute;
     Tegra::MemoryManager& gpu_memory;
-    u64 program_id;
 };
 
 template <class P>
@@ -78,10 +77,9 @@ protected:
     P* channel_state;
     size_t current_channel_id{UNSET_CHANNEL};
     size_t current_address_space{};
-    Tegra::Engines::Maxwell3D* maxwell3d{};
-    Tegra::Engines::KeplerCompute* kepler_compute{};
-    Tegra::MemoryManager* gpu_memory{};
-    u64 program_id{};
+    Tegra::Engines::Maxwell3D* maxwell3d;
+    Tegra::Engines::KeplerCompute* kepler_compute;
+    Tegra::MemoryManager* gpu_memory;
 
     std::deque<P> channel_storage;
     std::deque<size_t> free_channel_ids;

src/video_core/control/channel_state_cache.inc

@@ -58,7 +58,6 @@ void ChannelSetupCaches<P>::BindToChannel(s32 id) {
     maxwell3d = &channel_state->maxwell3d;
     kepler_compute = &channel_state->kepler_compute;
     gpu_memory = &channel_state->gpu_memory;
-    program_id = channel_state->program_id;
     current_address_space = gpu_memory->GetID();
 }
 
@@ -77,7 +76,6 @@ void ChannelSetupCaches<P>::EraseChannel(s32 id) {
         maxwell3d = nullptr;
         kepler_compute = nullptr;
         gpu_memory = nullptr;
-        program_id = 0;
     } else if (current_channel_id != UNSET_CHANNEL) {
         channel_state = &channel_storage[current_channel_id];
     }