Android 240

README.md

@@ -1,3 +1,17 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+| [12461](https://github.com/yuzu-emu/yuzu//pull/12461) | [`acc26667b`](https://github.com/yuzu-emu/yuzu//pull/12461/files) | Rework Nvdec and VIC to fix out-of-order videos, and speed up decoding. | [Kelebek1](https://github.com/Kelebek1/) | Yes |
+| [12749](https://github.com/yuzu-emu/yuzu//pull/12749) | [`aad4b0d6f`](https://github.com/yuzu-emu/yuzu//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12756](https://github.com/yuzu-emu/yuzu//pull/12756) | [`13fd37ef6`](https://github.com/yuzu-emu/yuzu//pull/12756/files) | general: applet multiprocess | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12949](https://github.com/yuzu-emu/yuzu//pull/12949) | [`5a64a77df`](https://github.com/yuzu-emu/yuzu//pull/12949/files) | service: add os types and multi wait API | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12955](https://github.com/yuzu-emu/yuzu//pull/12955) | [`8d2ad3d8f`](https://github.com/yuzu-emu/yuzu//pull/12955/files) | dmnt: cheat: Avoid invalidating cache on 32bit | [german77](https://github.com/german77/) | Yes |
+| [12969](https://github.com/yuzu-emu/yuzu//pull/12969) | [`5bf64e874`](https://github.com/yuzu-emu/yuzu//pull/12969/files) | service: bcat: Migrate and refractor service to new IPC | [german77](https://github.com/german77/) | Yes |
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

externals/CMakeLists.txt

@@ -314,3 +314,10 @@ endif()
 if (NOT TARGET SimpleIni::SimpleIni)
     add_subdirectory(simpleini)
 endif()
+
+# sse2neon
+if (ARCHITECTURE_arm64 AND NOT TARGET sse2neon)
+    add_library(sse2neon INTERFACE)
+    target_include_directories(sse2neon INTERFACE sse2neon)
+endif()
+

src/CMakeLists.txt

@@ -164,6 +164,7 @@ else()
 
     if (MINGW)
         add_definitions(-DMINGW_HAS_SECURE_API)
+        add_compile_options("-msse4.1")
 
         if (MINGW_STATIC_BUILD)
             add_definitions(-DQT_STATICPLUGIN)

src/common/settings.cpp

@@ -30,6 +30,7 @@ namespace Settings {
 #define SETTING(TYPE, RANGED) template class Setting<TYPE, RANGED>
 #define SWITCHABLE(TYPE, RANGED) template class SwitchableSetting<TYPE, RANGED>
 
+SETTING(AppletMode, false);
 SETTING(AudioEngine, false);
 SETTING(bool, false);
 SETTING(int, false);
@@ -215,6 +216,8 @@ const char* TranslateCategory(Category category) {
         return "Debugging";
     case Category::GpuDriver:
         return "GpuDriver";
+    case Category::LibraryApplet:
+        return "LibraryApplet";
     case Category::Miscellaneous:
         return "Miscellaneous";
     case Category::Network:

src/common/settings.h

@@ -133,6 +133,38 @@ struct TouchFromButtonMap {
 struct Values {
     Linkage linkage{};
 
+    // Applet
+    Setting<AppletMode> cabinet_applet_mode{linkage, AppletMode::LLE, "cabinet_applet_mode",
+                                            Category::LibraryApplet};
+    Setting<AppletMode> controller_applet_mode{linkage, AppletMode::HLE, "controller_applet_mode",
+                                               Category::LibraryApplet};
+    Setting<AppletMode> data_erase_applet_mode{linkage, AppletMode::HLE, "data_erase_applet_mode",
+                                               Category::LibraryApplet};
+    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};
+    Setting<AppletMode> player_select_applet_mode{
+        linkage, AppletMode::HLE, "player_select_applet_mode", Category::LibraryApplet};
+    Setting<AppletMode> swkbd_applet_mode{linkage, AppletMode::LLE, "swkbd_applet_mode",
+                                          Category::LibraryApplet};
+    Setting<AppletMode> mii_edit_applet_mode{linkage, AppletMode::LLE, "mii_edit_applet_mode",
+                                             Category::LibraryApplet};
+    Setting<AppletMode> web_applet_mode{linkage, AppletMode::HLE, "web_applet_mode",
+                                        Category::LibraryApplet};
+    Setting<AppletMode> shop_applet_mode{linkage, AppletMode::HLE, "shop_applet_mode",
+                                         Category::LibraryApplet};
+    Setting<AppletMode> photo_viewer_applet_mode{
+        linkage, AppletMode::LLE, "photo_viewer_applet_mode", Category::LibraryApplet};
+    Setting<AppletMode> offline_web_applet_mode{linkage, AppletMode::LLE, "offline_web_applet_mode",
+                                                Category::LibraryApplet};
+    Setting<AppletMode> login_share_applet_mode{linkage, AppletMode::HLE, "login_share_applet_mode",
+                                                Category::LibraryApplet};
+    Setting<AppletMode> wifi_web_auth_applet_mode{
+        linkage, AppletMode::HLE, "wifi_web_auth_applet_mode", Category::LibraryApplet};
+    Setting<AppletMode> my_page_applet_mode{linkage, AppletMode::LLE, "my_page_applet_mode",
+                                            Category::LibraryApplet};
+
     // Audio
     SwitchableSetting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine",
                                            Category::Audio, Specialization::RuntimeList};

src/common/settings_common.h

@@ -44,6 +44,7 @@ enum class Category : u32 {
     Services,
     Paths,
     Linux,
+    LibraryApplet,
     MaxEnum,
 };
 

src/common/settings_enums.h

@@ -151,6 +151,8 @@ ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
 
 ENUM(ConsoleMode, Handheld, Docked);
 
+ENUM(AppletMode, HLE, LLE);
+
 template <typename Type>
 inline std::string CanonicalizeEnum(Type id) {
     const auto group = EnumMetadata<Type>::Canonicalizations();

src/core/CMakeLists.txt

@@ -512,10 +512,35 @@ add_library(core STATIC
     hle/service/audio/hwopus.h
     hle/service/bcat/backend/backend.cpp
     hle/service/bcat/backend/backend.h
+    hle/service/bcat/news/newly_arrived_event_holder.cpp
+    hle/service/bcat/news/newly_arrived_event_holder.h
+    hle/service/bcat/news/news_data_service.cpp
+    hle/service/bcat/news/news_data_service.h
+    hle/service/bcat/news/news_database_service.cpp
+    hle/service/bcat/news/news_database_service.h
+    hle/service/bcat/news/news_service.cpp
+    hle/service/bcat/news/news_service.h
+    hle/service/bcat/news/overwrite_event_holder.cpp
+    hle/service/bcat/news/overwrite_event_holder.h
+    hle/service/bcat/news/service_creator.cpp
+    hle/service/bcat/news/service_creator.h
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
-    hle/service/bcat/bcat_module.cpp
-    hle/service/bcat/bcat_module.h
+    hle/service/bcat/bcat_result.h
+    hle/service/bcat/bcat_service.cpp
+    hle/service/bcat/bcat_service.h
+    hle/service/bcat/bcat_types.h
+    hle/service/bcat/bcat_util.h
+    hle/service/bcat/delivery_cache_directory_service.cpp
+    hle/service/bcat/delivery_cache_directory_service.h
+    hle/service/bcat/delivery_cache_file_service.cpp
+    hle/service/bcat/delivery_cache_file_service.h
+    hle/service/bcat/delivery_cache_progress_service.cpp
+    hle/service/bcat/delivery_cache_progress_service.h
+    hle/service/bcat/delivery_cache_storage_service.cpp
+    hle/service/bcat/delivery_cache_storage_service.h
+    hle/service/bcat/service_creator.cpp
+    hle/service/bcat/service_creator.h
     hle/service/bpc/bpc.cpp
     hle/service/bpc/bpc.h
     hle/service/btdrv/btdrv.cpp
@@ -548,8 +573,6 @@ add_library(core STATIC
     hle/service/es/es.h
     hle/service/eupld/eupld.cpp
     hle/service/eupld/eupld.h
-    hle/service/event.cpp
-    hle/service/event.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
     hle/service/fatal/fatal_p.cpp
@@ -676,8 +699,6 @@ add_library(core STATIC
     hle/service/mm/mm_u.h
     hle/service/mnpp/mnpp_app.cpp
     hle/service/mnpp/mnpp_app.h
-    hle/service/mutex.cpp
-    hle/service/mutex.h
     hle/service/ncm/ncm.cpp
     hle/service/ncm/ncm.h
     hle/service/nfc/common/amiibo_crypto.cpp
@@ -790,6 +811,15 @@ add_library(core STATIC
     hle/service/nvnflinger/window.h
     hle/service/olsc/olsc.cpp
     hle/service/olsc/olsc.h
+    hle/service/os/event.cpp
+    hle/service/os/event.h
+    hle/service/os/multi_wait_holder.cpp
+    hle/service/os/multi_wait_holder.h
+    hle/service/os/multi_wait_utils.h
+    hle/service/os/multi_wait.cpp
+    hle/service/os/multi_wait.h
+    hle/service/os/mutex.cpp
+    hle/service/os/mutex.h
     hle/service/pcie/pcie.cpp
     hle/service/pcie/pcie.h
     hle/service/pctl/pctl.cpp

src/core/device_memory_manager.h

@@ -43,6 +43,8 @@ public:
     DeviceMemoryManager(const DeviceMemory& device_memory);
     ~DeviceMemoryManager();
 
+    static constexpr bool HAS_FLUSH_INVALIDATION = true;
+
     void BindInterface(DeviceInterface* device_inter);
 
     DAddr Allocate(size_t size);

src/core/file_sys/content_archive.cpp

@@ -172,6 +172,10 @@ u32 NCA::GetSDKVersion() const {
     return reader->GetSdkAddonVersion();
 }
 
+u8 NCA::GetKeyGeneration() const {
+    return reader->GetKeyGeneration();
+}
+
 bool NCA::IsUpdate() const {
     return is_update;
 }

src/core/file_sys/content_archive.h

@@ -77,6 +77,7 @@ public:
     u64 GetTitleId() const;
     RightsId GetRightsId() const;
     u32 GetSDKVersion() const;
+    u8 GetKeyGeneration() const;
     bool IsUpdate() const;
 
     VirtualFile GetRomFS() const;

src/core/file_sys/errors.h

@@ -91,6 +91,7 @@ constexpr Result ResultWriteNotPermitted{ErrorModule::FS, 6203};
 constexpr Result ResultUnsupportedSetSizeForIndirectStorage{ErrorModule::FS, 6325};
 constexpr Result ResultUnsupportedWriteForCompressedStorage{ErrorModule::FS, 6387};
 constexpr Result ResultUnsupportedOperateRangeForCompressedStorage{ErrorModule::FS, 6388};
+constexpr Result ResultPermissionDenied{ErrorModule::FS, 6400};
 constexpr Result ResultBufferAllocationFailed{ErrorModule::FS, 6705};
 
 } // namespace FileSys

src/core/guest_memory.h

@@ -44,15 +44,32 @@ public:
     GuestMemory() = delete;
     explicit GuestMemory(M& memory, u64 addr, std::size_t size,
                          Common::ScratchBuffer<T>* backup = nullptr)
-        : m_memory{memory}, m_addr{addr}, m_size{size} {
+        : m_memory{&memory}, m_addr{addr}, m_size{size} {
         static_assert(FLAGS & GuestMemoryFlags::Read || FLAGS & GuestMemoryFlags::Write);
-        if constexpr (FLAGS & GuestMemoryFlags::Read) {
+        if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
+            if (!this->TrySetSpan()) {
+                if (backup) {
+                    backup->resize_destructive(this->size());
+                    m_data_span = *backup;
+                    m_span_valid = true;
+                    m_is_data_copy = true;
+                } else {
+                    m_data_copy.resize(this->size());
+                    m_data_span = std::span(m_data_copy);
+                    m_span_valid = true;
+                    m_is_data_copy = true;
+                }
+            }
+        } else if constexpr (FLAGS & GuestMemoryFlags::Read) {
             Read(addr, size, backup);
         }
     }
 
     ~GuestMemory() = default;
 
+    GuestMemory(GuestMemory&& rhs) = default;
+    GuestMemory& operator=(GuestMemory&& rhs) = default;
+
     T* data() noexcept {
         return m_data_span.data();
     }
@@ -109,8 +126,8 @@ public:
         }
 
         if (this->TrySetSpan()) {
-            if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                m_memory.FlushRegion(m_addr, this->size_bytes());
+            if constexpr (FLAGS & GuestMemoryFlags::Safe && M::HAS_FLUSH_INVALIDATION) {
+                m_memory->FlushRegion(m_addr, this->size_bytes());
             }
         } else {
             if (backup) {
@@ -123,9 +140,9 @@ public:
             m_is_data_copy = true;
             m_span_valid = true;
             if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                m_memory.ReadBlock(m_addr, this->data(), this->size_bytes());
+                m_memory->ReadBlock(m_addr, this->data(), this->size_bytes());
             } else {
-                m_memory.ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
+                m_memory->ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
             }
         }
         return m_data_span;
@@ -133,18 +150,19 @@ public:
 
     void Write(std::span<T> write_data) noexcept {
         if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-            m_memory.WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
+            m_memory->WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
         } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-            m_memory.WriteBlock(m_addr, write_data.data(), this->size_bytes());
+            m_memory->WriteBlock(m_addr, write_data.data(), this->size_bytes());
         } else {
-            m_memory.WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
+            m_memory->WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
         }
     }
 
     bool TrySetSpan() noexcept {
-        if (u8* ptr = m_memory.GetSpan(m_addr, this->size_bytes()); ptr) {
+        if (u8* ptr = m_memory->GetSpan(m_addr, this->size_bytes()); ptr) {
             m_data_span = {reinterpret_cast<T*>(ptr), this->size()};
             m_span_valid = true;
+            m_is_data_copy = false;
             return true;
         }
         return false;
@@ -159,7 +177,7 @@ protected:
         return m_addr_changed;
     }
 
-    M& m_memory;
+    M* m_memory;
     u64 m_addr{};
     size_t m_size{};
     std::span<T> m_data_span{};
@@ -175,17 +193,7 @@ public:
     GuestMemoryScoped() = delete;
     explicit GuestMemoryScoped(M& memory, u64 addr, std::size_t size,
                                Common::ScratchBuffer<T>* backup = nullptr)
-        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {
-        if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
-            if (!this->TrySetSpan()) {
-                if (backup) {
-                    this->m_data_span = *backup;
-                    this->m_span_valid = true;
-                    this->m_is_data_copy = true;
-                }
-            }
-        }
-    }
+        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {}
 
     ~GuestMemoryScoped() {
         if constexpr (FLAGS & GuestMemoryFlags::Write) {
@@ -196,15 +204,17 @@ public:
             if (this->AddressChanged() || this->IsDataCopy()) {
                 ASSERT(this->m_span_valid);
                 if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-                    this->m_memory.WriteBlockCached(this->m_addr, this->data(), this->size_bytes());
+                    this->m_memory->WriteBlockCached(this->m_addr, this->data(),
+                                                     this->size_bytes());
                 } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                    this->m_memory.WriteBlock(this->m_addr, this->data(), this->size_bytes());
+                    this->m_memory->WriteBlock(this->m_addr, this->data(), this->size_bytes());
                 } else {
-                    this->m_memory.WriteBlockUnsafe(this->m_addr, this->data(), this->size_bytes());
+                    this->m_memory->WriteBlockUnsafe(this->m_addr, this->data(),
+                                                     this->size_bytes());
                 }
             } else if constexpr ((FLAGS & GuestMemoryFlags::Safe) ||
                                  (FLAGS & GuestMemoryFlags::Cached)) {
-                this->m_memory.InvalidateRegion(this->m_addr, this->size_bytes());
+                this->m_memory->InvalidateRegion(this->m_addr, this->size_bytes());
             }
         }
     }

src/core/hle/kernel/k_process.cpp

@@ -4,8 +4,9 @@
 #include <random>
 #include "common/scope_exit.h"
 #include "common/settings.h"
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "core/core.h"
-#include "core/gpu_dirty_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_shared_memory.h"
@@ -1258,6 +1259,10 @@ void KProcess::InitializeInterfaces() {
 
 #ifdef HAS_NCE
     if (this->IsApplication() && Settings::IsNceEnabled()) {
+        // Register the scoped JIT handler before creating any NCE instances
+        // so that its signal handler will appear first in the signal chain.
+        Core::ScopedJitExecution::RegisterHandler();
+
         for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
             m_arm_interfaces[i] = std::make_unique<Core::ArmNce>(m_kernel.System(), true, i);
         }

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

@@ -130,9 +130,9 @@ enum class AppletProgramId : u64 {
 
 enum class LibraryAppletMode : u32 {
     AllForeground = 0,
-    Background = 1,
-    NoUI = 2,
-    BackgroundIndirectDisplay = 3,
+    PartialForeground = 1,
+    NoUi = 2,
+    PartialForegroundIndirectDisplay = 3,
     AllForegroundInitiallyHidden = 4,
 };
 

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

@@ -9,8 +9,8 @@
 #include "common/math_util.h"
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/caps/caps_types.h"
-#include "core/hle/service/event.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/os/event.h"
 #include "core/hle/service/service.h"
 
 #include "core/hle/service/am/am_types.h"

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

@@ -7,8 +7,8 @@
 #include <memory>
 #include <mutex>
 
-#include "core/hle/service/event.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/os/event.h"
 
 union Result;
 

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

@@ -68,9 +68,9 @@ void SoftwareKeyboard::Initialize() {
     case LibraryAppletMode::AllForeground:
         InitializeForeground();
         break;
-    case LibraryAppletMode::Background:
-    case LibraryAppletMode::BackgroundIndirectDisplay:
-        InitializeBackground(applet_mode);
+    case LibraryAppletMode::PartialForeground:
+    case LibraryAppletMode::PartialForegroundIndirectDisplay:
+        InitializePartialForeground(applet_mode);
         break;
     default:
         ASSERT_MSG(false, "Invalid LibraryAppletMode={}", applet_mode);
@@ -243,7 +243,7 @@ void SoftwareKeyboard::InitializeForeground() {
     InitializeFrontendNormalKeyboard();
 }
 
-void SoftwareKeyboard::InitializeBackground(LibraryAppletMode library_applet_mode) {
+void SoftwareKeyboard::InitializePartialForeground(LibraryAppletMode library_applet_mode) {
     LOG_INFO(Service_AM, "Initializing Inline Software Keyboard Applet.");
 
     is_background = true;
@@ -258,9 +258,9 @@ void SoftwareKeyboard::InitializeBackground(LibraryAppletMode library_applet_mod
                 swkbd_inline_initialize_arg.size());
 
     if (swkbd_initialize_arg.library_applet_mode_flag) {
-        ASSERT(library_applet_mode == LibraryAppletMode::Background);
+        ASSERT(library_applet_mode == LibraryAppletMode::PartialForeground);
     } else {
-        ASSERT(library_applet_mode == LibraryAppletMode::BackgroundIndirectDisplay);
+        ASSERT(library_applet_mode == LibraryAppletMode::PartialForegroundIndirectDisplay);
     }
 }
 

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

@@ -62,7 +62,7 @@ private:
     void InitializeForeground();
 
     /// Initializes the inline software keyboard.
-    void InitializeBackground(LibraryAppletMode library_applet_mode);
+    void InitializePartialForeground(LibraryAppletMode library_applet_mode);
 
     /// Processes the text check sent by the application.
     void ProcessTextCheck();

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/settings.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/service/am/applet_data_broker.h"
 #include "core/hle/service/am/applet_manager.h"
@@ -16,6 +17,34 @@ namespace Service::AM {
 
 namespace {
 
+bool ShouldCreateGuestApplet(AppletId applet_id) {
+#define X(Name, name)                                                                              \
+    if (applet_id == AppletId::Name &&                                                             \
+        Settings::values.name##_applet_mode.GetValue() != Settings::AppletMode::LLE) {             \
+        return false;                                                                              \
+    }
+
+    X(Cabinet, cabinet)
+    X(Controller, controller)
+    X(DataErase, data_erase)
+    X(Error, error)
+    X(NetConnect, net_connect)
+    X(ProfileSelect, player_select)
+    X(SoftwareKeyboard, swkbd)
+    X(MiiEdit, mii_edit)
+    X(Web, web)
+    X(Shop, shop)
+    X(PhotoViewer, photo_viewer)
+    X(OfflineWeb, offline_web)
+    X(LoginShare, login_share)
+    X(WebAuth, wifi_web_auth)
+    X(MyPage, my_page)
+
+#undef X
+
+    return true;
+}
+
 AppletProgramId AppletIdToProgramId(AppletId applet_id) {
     switch (applet_id) {
     case AppletId::OverlayDisplay:
@@ -63,17 +92,24 @@ AppletProgramId AppletIdToProgramId(AppletId applet_id) {
     }
 }
 
-[[maybe_unused]] std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(
-    Core::System& system, std::shared_ptr<Applet> caller_applet, AppletId applet_id,
-    LibraryAppletMode mode) {
+std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
+                                                          std::shared_ptr<Applet> caller_applet,
+                                                          AppletId applet_id,
+                                                          LibraryAppletMode mode) {
     const auto program_id = static_cast<u64>(AppletIdToProgramId(applet_id));
     if (program_id == 0) {
         // Unknown applet
         return {};
     }
 
+    // TODO: enable other versions of applets
+    enum : u8 {
+        Firmware1600 = 15,
+        Firmware1700 = 16,
+    };
+
     auto process = std::make_unique<Process>(system);
-    if (!process->Initialize(program_id)) {
+    if (!process->Initialize(program_id, Firmware1600, Firmware1700)) {
         // Couldn't initialize the guest process
         return {};
     }
@@ -87,24 +123,18 @@ AppletProgramId AppletIdToProgramId(AppletId applet_id) {
     // Set focus state
     switch (mode) {
     case LibraryAppletMode::AllForeground:
-    case LibraryAppletMode::NoUI:
-        applet->focus_state = FocusState::InFocus;
+    case LibraryAppletMode::NoUi:
+    case LibraryAppletMode::PartialForeground:
+    case LibraryAppletMode::PartialForegroundIndirectDisplay:
         applet->hid_registration.EnableAppletToGetInput(true);
+        applet->focus_state = FocusState::InFocus;
         applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
-        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
         break;
     case LibraryAppletMode::AllForegroundInitiallyHidden:
-        applet->system_buffer_manager.SetWindowVisibility(false);
-        applet->focus_state = FocusState::NotInFocus;
         applet->hid_registration.EnableAppletToGetInput(false);
-        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
-        break;
-    case LibraryAppletMode::Background:
-    case LibraryAppletMode::BackgroundIndirectDisplay:
-    default:
-        applet->focus_state = FocusState::Background;
-        applet->hid_registration.EnableAppletToGetInput(true);
-        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
+        applet->focus_state = FocusState::NotInFocus;
+        applet->system_buffer_manager.SetWindowVisibility(false);
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoBackground);
         break;
     }
 
@@ -117,9 +147,10 @@ AppletProgramId AppletIdToProgramId(AppletId applet_id) {
     return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
 }
 
-[[maybe_unused]] std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(
-    Core::System& system, std::shared_ptr<Applet> caller_applet, AppletId applet_id,
-    LibraryAppletMode mode) {
+std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& system,
+                                                             std::shared_ptr<Applet> caller_applet,
+                                                             AppletId applet_id,
+                                                             LibraryAppletMode mode) {
     const auto program_id = static_cast<u64>(AppletIdToProgramId(applet_id));
 
     auto process = std::make_unique<Process>(system);
@@ -163,7 +194,13 @@ void ILibraryAppletCreator::CreateLibraryApplet(HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}", applet_id,
               applet_mode);
 
-    auto library_applet = CreateFrontendApplet(system, applet, applet_id, applet_mode);
+    std::shared_ptr<ILibraryAppletAccessor> library_applet;
+    if (ShouldCreateGuestApplet(applet_id)) {
+        library_applet = CreateGuestApplet(system, applet, applet_id, applet_mode);
+    }
+    if (!library_applet) {
+        library_applet = CreateFrontendApplet(system, applet, applet_id, applet_mode);
+    }
     if (!library_applet) {
         LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);
 

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

@@ -3,6 +3,7 @@
 
 #include "common/scope_exit.h"
 
+#include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/kernel/k_process.h"
@@ -20,7 +21,7 @@ Process::~Process() {
     this->Finalize();
 }
 
-bool Process::Initialize(u64 program_id) {
+bool Process::Initialize(u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
     // First, ensure we are not holding another process.
     this->Finalize();
 
@@ -29,21 +30,33 @@ bool Process::Initialize(u64 program_id) {
 
     // Attempt to load program NCA.
     const FileSys::RegisteredCache* bis_system{};
-    FileSys::VirtualFile nca{};
+    FileSys::VirtualFile nca_raw{};
 
     // Get the program NCA from built-in storage.
     bis_system = fsc.GetSystemNANDContents();
     if (bis_system) {
-        nca = bis_system->GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
+        nca_raw = bis_system->GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
     }
 
     // Ensure we retrieved a program NCA.
-    if (!nca) {
+    if (!nca_raw) {
         return false;
     }
 
+    // Ensure we have a suitable version.
+    if (minimum_key_generation > 0) {
+        FileSys::NCA nca(nca_raw);
+        if (nca.GetStatus() == Loader::ResultStatus::Success &&
+            (nca.GetKeyGeneration() < minimum_key_generation ||
+             nca.GetKeyGeneration() > maximum_key_generation)) {
+            LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id,
+                        nca.GetKeyGeneration());
+            return false;
+        }
+    }
+
     // Get the appropriate loader to parse this NCA.
-    auto app_loader = Loader::GetLoader(m_system, nca, program_id, 0);
+    auto app_loader = Loader::GetLoader(m_system, nca_raw, program_id, 0);
 
     // Ensure we have a loader which can parse the NCA.
     if (!app_loader) {

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

@@ -21,7 +21,7 @@ public:
     explicit Process(Core::System& system);
     ~Process();
 
-    bool Initialize(u64 program_id);
+    bool Initialize(u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
     void Finalize();
 
     bool Run();

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

@@ -1,10 +1,13 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/logging/log.h"
+#include "core/hle/result.h"
 #include "core/hle/service/am/am_results.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/self_controller.h"
 #include "core/hle/service/caps/caps_su.h"
+#include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/nvnflinger/fb_share_buffer_manager.h"
 #include "core/hle/service/nvnflinger/nvnflinger.h"
@@ -47,7 +50,7 @@ ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet>
         {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
         {51, &ISelfController::ApproveToDisplay, "ApproveToDisplay"},
         {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
-        {61, nullptr, "SetMediaPlaybackState"},
+        {61, &ISelfController::SetMediaPlaybackState, "SetMediaPlaybackState"},
         {62, &ISelfController::SetIdleTimeDetectionExtension, "SetIdleTimeDetectionExtension"},
         {63, &ISelfController::GetIdleTimeDetectionExtension, "GetIdleTimeDetectionExtension"},
         {64, nullptr, "SetInputDetectionSourceSet"},
@@ -288,7 +291,8 @@ void ISelfController::GetSystemSharedBufferHandle(HLERequestContext& ctx) {
 }
 
 Result ISelfController::EnsureBufferSharingEnabled(Kernel::KProcess* process) {
-    if (applet->system_buffer_manager.Initialize(&nvnflinger, process, applet->applet_id)) {
+    if (applet->system_buffer_manager.Initialize(&nvnflinger, process, applet->applet_id,
+                                                 applet->library_applet_mode)) {
         return ResultSuccess;
     }
 
@@ -323,6 +327,16 @@ void ISelfController::ApproveToDisplay(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
+void ISelfController::SetMediaPlaybackState(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const u8 state = rp.Pop<u8>();
+
+    LOG_WARNING(Service_AM, "(STUBBED) called, state={}", state);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 void ISelfController::SetIdleTimeDetectionExtension(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 

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

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/service.h"
 
@@ -38,6 +39,7 @@ private:
     void CreateManagedDisplaySeparableLayer(HLERequestContext& ctx);
     void SetHandlesRequestToDisplay(HLERequestContext& ctx);
     void ApproveToDisplay(HLERequestContext& ctx);
+    void SetMediaPlaybackState(HLERequestContext& ctx);
     void SetIdleTimeDetectionExtension(HLERequestContext& ctx);
     void GetIdleTimeDetectionExtension(HLERequestContext& ctx);
     void ReportUserIsActive(HLERequestContext& ctx);

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

@@ -17,11 +17,12 @@ SystemBufferManager::~SystemBufferManager() {
 
     // Clean up shared layers.
     if (m_buffer_sharing_enabled) {
+        m_nvnflinger->GetSystemBufferManager().Finalize(m_process);
     }
 }
 
 bool SystemBufferManager::Initialize(Nvnflinger::Nvnflinger* nvnflinger, Kernel::KProcess* process,
-                                     AppletId applet_id) {
+                                     AppletId applet_id, LibraryAppletMode mode) {
     if (m_nvnflinger) {
         return m_buffer_sharing_enabled;
     }
@@ -36,9 +37,15 @@ bool SystemBufferManager::Initialize(Nvnflinger::Nvnflinger* nvnflinger, Kernel:
         return false;
     }
 
+    Nvnflinger::LayerBlending blending = Nvnflinger::LayerBlending::None;
+    if (mode == LibraryAppletMode::PartialForeground ||
+        mode == LibraryAppletMode::PartialForegroundIndirectDisplay) {
+        blending = Nvnflinger::LayerBlending::Coverage;
+    }
+
     const auto display_id = m_nvnflinger->OpenDisplay("Default").value();
     const auto res = m_nvnflinger->GetSystemBufferManager().Initialize(
-        &m_system_shared_buffer_id, &m_system_shared_layer_id, display_id);
+        m_process, &m_system_shared_buffer_id, &m_system_shared_layer_id, display_id, blending);
 
     if (res.IsSuccess()) {
         m_buffer_sharing_enabled = true;
@@ -62,8 +69,12 @@ void SystemBufferManager::SetWindowVisibility(bool visible) {
 
 Result SystemBufferManager::WriteAppletCaptureBuffer(bool* out_was_written,
                                                      s32* out_fbshare_layer_index) {
-    // TODO
-    R_SUCCEED();
+    if (!m_buffer_sharing_enabled) {
+        return VI::ResultPermissionDenied;
+    }
+
+    return m_nvnflinger->GetSystemBufferManager().WriteAppletCaptureBuffer(out_was_written,
+                                                                           out_fbshare_layer_index);
 }
 
 } // namespace Service::AM

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

@@ -27,7 +27,8 @@ public:
     SystemBufferManager();
     ~SystemBufferManager();
 
-    bool Initialize(Nvnflinger::Nvnflinger* flinger, Kernel::KProcess* process, AppletId applet_id);
+    bool Initialize(Nvnflinger::Nvnflinger* flinger, Kernel::KProcess* process, AppletId applet_id,
+                    LibraryAppletMode mode);
 
     void GetSystemSharedLayerHandle(u64* out_system_shared_buffer_id,
                                     u64* out_system_shared_layer_id) {

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

@@ -62,12 +62,12 @@ void IWindowController::SetAppletWindowVisibility(HLERequestContext& ctx) {
     applet->hid_registration.EnableAppletToGetInput(visible);
 
     if (visible) {
-        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
         applet->focus_state = FocusState::InFocus;
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
     } else {
         applet->focus_state = FocusState::NotInFocus;
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoBackground);
     }
-    applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);

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

@@ -33,18 +33,18 @@ void ProgressServiceBackend::SetTotalSize(u64 size) {
 }
 
 void ProgressServiceBackend::StartConnecting() {
-    impl.status = DeliveryCacheProgressImpl::Status::Connecting;
+    impl.status = DeliveryCacheProgressStatus::Connecting;
     SignalUpdate();
 }
 
 void ProgressServiceBackend::StartProcessingDataList() {
-    impl.status = DeliveryCacheProgressImpl::Status::ProcessingDataList;
+    impl.status = DeliveryCacheProgressStatus::ProcessingDataList;
     SignalUpdate();
 }
 
 void ProgressServiceBackend::StartDownloadingFile(std::string_view dir_name,
                                                   std::string_view file_name, u64 file_size) {
-    impl.status = DeliveryCacheProgressImpl::Status::Downloading;
+    impl.status = DeliveryCacheProgressStatus::Downloading;
     impl.current_downloaded_bytes = 0;
     impl.current_total_bytes = file_size;
     std::memcpy(impl.current_directory.data(), dir_name.data(),
@@ -65,7 +65,7 @@ void ProgressServiceBackend::FinishDownloadingFile() {
 }
 
 void ProgressServiceBackend::CommitDirectory(std::string_view dir_name) {
-    impl.status = DeliveryCacheProgressImpl::Status::Committing;
+    impl.status = DeliveryCacheProgressStatus::Committing;
     impl.current_file.fill(0);
     impl.current_downloaded_bytes = 0;
     impl.current_total_bytes = 0;
@@ -76,7 +76,7 @@ void ProgressServiceBackend::CommitDirectory(std::string_view dir_name) {
 
 void ProgressServiceBackend::FinishDownload(Result result) {
     impl.total_downloaded_bytes = impl.total_bytes;
-    impl.status = DeliveryCacheProgressImpl::Status::Done;
+    impl.status = DeliveryCacheProgressStatus::Done;
     impl.result = result;
     SignalUpdate();
 }
@@ -85,15 +85,15 @@ void ProgressServiceBackend::SignalUpdate() {
     update_event->Signal();
 }
 
-Backend::Backend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}
+BcatBackend::BcatBackend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}
 
-Backend::~Backend() = default;
+BcatBackend::~BcatBackend() = default;
 
-NullBackend::NullBackend(DirectoryGetter getter) : Backend(std::move(getter)) {}
+NullBcatBackend::NullBcatBackend(DirectoryGetter getter) : BcatBackend(std::move(getter)) {}
 
-NullBackend::~NullBackend() = default;
+NullBcatBackend::~NullBcatBackend() = default;
 
-bool NullBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
+bool NullBcatBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id,
               title.build_id);
 
@@ -101,8 +101,8 @@ bool NullBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend& prog
     return true;
 }
 
-bool NullBackend::SynchronizeDirectory(TitleIDVersion title, std::string name,
-                                       ProgressServiceBackend& progress) {
+bool NullBcatBackend::SynchronizeDirectory(TitleIDVersion title, std::string name,
+                                           ProgressServiceBackend& progress) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}, name={}", title.title_id,
               title.build_id, name);
 
@@ -110,18 +110,18 @@ bool NullBackend::SynchronizeDirectory(TitleIDVersion title, std::string name,
     return true;
 }
 
-bool NullBackend::Clear(u64 title_id) {
+bool NullBcatBackend::Clear(u64 title_id) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
 
     return true;
 }
 
-void NullBackend::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
+void NullBcatBackend::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
               Common::HexToString(passphrase));
 }
 
-std::optional<std::vector<u8>> NullBackend::GetLaunchParameter(TitleIDVersion title) {
+std::optional<std::vector<u8>> NullBcatBackend::GetLaunchParameter(TitleIDVersion title) {
     LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id,
               title.build_id);
     return std::nullopt;

src/core/hle/service/bcat/backend/backend.h

@@ -10,6 +10,7 @@
 #include "common/common_types.h"
 #include "core/file_sys/vfs/vfs_types.h"
 #include "core/hle/result.h"
+#include "core/hle/service/bcat/bcat_types.h"
 #include "core/hle/service/kernel_helpers.h"
 
 namespace Core {
@@ -24,44 +25,6 @@ class KReadableEvent;
 
 namespace Service::BCAT {
 
-struct DeliveryCacheProgressImpl;
-
-using DirectoryGetter = std::function<FileSys::VirtualDir(u64)>;
-using Passphrase = std::array<u8, 0x20>;
-
-struct TitleIDVersion {
-    u64 title_id;
-    u64 build_id;
-};
-
-using DirectoryName = std::array<char, 0x20>;
-using FileName = std::array<char, 0x20>;
-
-struct DeliveryCacheProgressImpl {
-    enum class Status : s32 {
-        None = 0x0,
-        Queued = 0x1,
-        Connecting = 0x2,
-        ProcessingDataList = 0x3,
-        Downloading = 0x4,
-        Committing = 0x5,
-        Done = 0x9,
-    };
-
-    Status status;
-    Result result = ResultSuccess;
-    DirectoryName current_directory;
-    FileName current_file;
-    s64 current_downloaded_bytes; ///< Bytes downloaded on current file.
-    s64 current_total_bytes;      ///< Bytes total on current file.
-    s64 total_downloaded_bytes;   ///< Bytes downloaded on overall download.
-    s64 total_bytes;              ///< Bytes total on overall download.
-    INSERT_PADDING_BYTES(
-        0x198); ///< Appears to be unused in official code, possibly reserved for future use.
-};
-static_assert(sizeof(DeliveryCacheProgressImpl) == 0x200,
-              "DeliveryCacheProgressImpl has incorrect size.");
-
 // A class to manage the signalling to the game about BCAT download progress.
 // Some of this class is implemented in module.cpp to avoid exposing the implementation structure.
 class ProgressServiceBackend {
@@ -107,10 +70,10 @@ private:
 };
 
 // A class representing an abstract backend for BCAT functionality.
-class Backend {
+class BcatBackend {
 public:
-    explicit Backend(DirectoryGetter getter);
-    virtual ~Backend();
+    explicit BcatBackend(DirectoryGetter getter);
+    virtual ~BcatBackend();
 
     // Called when the backend is needed to synchronize the data for the game with title ID and
     // version in title. A ProgressServiceBackend object is provided to alert the application of
@@ -135,10 +98,10 @@ protected:
 };
 
 // A backend of BCAT that provides no operation.
-class NullBackend : public Backend {
+class NullBcatBackend : public BcatBackend {
 public:
-    explicit NullBackend(DirectoryGetter getter);
-    ~NullBackend() override;
+    explicit NullBcatBackend(DirectoryGetter getter);
+    ~NullBcatBackend() override;
 
     bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;
     bool SynchronizeDirectory(TitleIDVersion title, std::string name,
@@ -151,6 +114,7 @@ public:
     std::optional<std::vector<u8>> GetLaunchParameter(TitleIDVersion title) override;
 };
 
-std::unique_ptr<Backend> CreateBackendFromSettings(Core::System& system, DirectoryGetter getter);
+std::unique_ptr<BcatBackend> CreateBackendFromSettings(Core::System& system,
+                                                       DirectoryGetter getter);
 
 } // namespace Service::BCAT

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

@@ -1,24 +1,38 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/service/bcat/backend/backend.h"
 #include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/bcat/news/service_creator.h"
+#include "core/hle/service/bcat/service_creator.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::BCAT {
 
-BCAT::BCAT(Core::System& system_, std::shared_ptr<Module> module_,
-           FileSystem::FileSystemController& fsc_, const char* name_)
-    : Interface(system_, std::move(module_), fsc_, name_) {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, &BCAT::CreateBcatService, "CreateBcatService"},
-        {1, &BCAT::CreateDeliveryCacheStorageService, "CreateDeliveryCacheStorageService"},
-        {2, &BCAT::CreateDeliveryCacheStorageServiceWithApplicationId, "CreateDeliveryCacheStorageServiceWithApplicationId"},
-        {3, nullptr, "CreateDeliveryCacheProgressService"},
-        {4, nullptr, "CreateDeliveryCacheProgressServiceWithApplicationId"},
-    };
-    // clang-format on
-    RegisterHandlers(functions);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("bcat:a",
+                                         std::make_shared<IServiceCreator>(system, "bcat:a"));
+    server_manager->RegisterNamedService("bcat:m",
+                                         std::make_shared<IServiceCreator>(system, "bcat:m"));
+    server_manager->RegisterNamedService("bcat:u",
+                                         std::make_shared<IServiceCreator>(system, "bcat:u"));
+    server_manager->RegisterNamedService("bcat:s",
+                                         std::make_shared<IServiceCreator>(system, "bcat:s"));
+
+    server_manager->RegisterNamedService(
+        "news:a", std::make_shared<News::IServiceCreator>(system, 0xffffffff, "news:a"));
+    server_manager->RegisterNamedService(
+        "news:p", std::make_shared<News::IServiceCreator>(system, 0x1, "news:p"));
+    server_manager->RegisterNamedService(
+        "news:c", std::make_shared<News::IServiceCreator>(system, 0x2, "news:c"));
+    server_manager->RegisterNamedService(
+        "news:v", std::make_shared<News::IServiceCreator>(system, 0x4, "news:v"));
+    server_manager->RegisterNamedService(
+        "news:m", std::make_shared<News::IServiceCreator>(system, 0xd, "news:m"));
+
+    ServerManager::RunServer(std::move(server_manager));
 }
 
-BCAT::~BCAT() = default;
 } // namespace Service::BCAT

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

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "core/hle/service/bcat/bcat_module.h"
+#include "core/hle/service/service.h"
 
 namespace Core {
 class System;
@@ -11,11 +11,6 @@ class System;
 
 namespace Service::BCAT {
 
-class BCAT final : public Module::Interface {
-public:
-    explicit BCAT(Core::System& system_, std::shared_ptr<Module> module_,
-                  FileSystem::FileSystemController& fsc_, const char* name_);
-    ~BCAT() override;
-};
+void LoopProcess(Core::System& system);
 
 } // namespace Service::BCAT

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

@@ -1,606 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cctype>
-#include <mbedtls/md5.h>
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/file_sys/vfs/vfs.h"
-#include "core/hle/kernel/k_readable_event.h"
-#include "core/hle/service/bcat/backend/backend.h"
-#include "core/hle/service/bcat/bcat.h"
-#include "core/hle/service/bcat/bcat_module.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/server_manager.h"
-
-namespace Service::BCAT {
-
-constexpr Result ERROR_INVALID_ARGUMENT{ErrorModule::BCAT, 1};
-constexpr Result ERROR_FAILED_OPEN_ENTITY{ErrorModule::BCAT, 2};
-constexpr Result ERROR_ENTITY_ALREADY_OPEN{ErrorModule::BCAT, 6};
-constexpr Result ERROR_NO_OPEN_ENTITY{ErrorModule::BCAT, 7};
-
-// The command to clear the delivery cache just calls fs IFileSystem DeleteFile on all of the files
-// and if any of them have a non-zero result it just forwards that result. This is the FS error code
-// for permission denied, which is the closest approximation of this scenario.
-constexpr Result ERROR_FAILED_CLEAR_CACHE{ErrorModule::FS, 6400};
-
-using BCATDigest = std::array<u8, 0x10>;
-
-namespace {
-
-u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
-    u64 out{};
-    std::memcpy(&out, id.data(), sizeof(u64));
-    return out;
-}
-
-// The digest is only used to determine if a file is unique compared to others of the same name.
-// Since the algorithm isn't ever checked in game, MD5 is safe.
-BCATDigest DigestFile(const FileSys::VirtualFile& file) {
-    BCATDigest out{};
-    const auto bytes = file->ReadAllBytes();
-    mbedtls_md5_ret(bytes.data(), bytes.size(), out.data());
-    return out;
-}
-
-// For a name to be valid it must be non-empty, must have a null terminating character as the final
-// char, can only contain numbers, letters, underscores and a hyphen if directory and a period if
-// file.
-bool VerifyNameValidInternal(HLERequestContext& ctx, std::array<char, 0x20> name, char match_char) {
-    const auto null_chars = std::count(name.begin(), name.end(), 0);
-    const auto bad_chars = std::count_if(name.begin(), name.end(), [match_char](char c) {
-        return !std::isalnum(static_cast<u8>(c)) && c != '_' && c != match_char && c != '\0';
-    });
-    if (null_chars == 0x20 || null_chars == 0 || bad_chars != 0 || name[0x1F] != '\0') {
-        LOG_ERROR(Service_BCAT, "Name passed was invalid!");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERROR_INVALID_ARGUMENT);
-        return false;
-    }
-
-    return true;
-}
-
-bool VerifyNameValidDir(HLERequestContext& ctx, DirectoryName name) {
-    return VerifyNameValidInternal(ctx, name, '-');
-}
-
-bool VerifyNameValidFile(HLERequestContext& ctx, FileName name) {
-    return VerifyNameValidInternal(ctx, name, '.');
-}
-
-} // Anonymous namespace
-
-struct DeliveryCacheDirectoryEntry {
-    FileName name;
-    u64 size;
-    BCATDigest digest;
-};
-
-class IDeliveryCacheProgressService final : public ServiceFramework<IDeliveryCacheProgressService> {
-public:
-    explicit IDeliveryCacheProgressService(Core::System& system_, Kernel::KReadableEvent& event_,
-                                           const DeliveryCacheProgressImpl& impl_)
-        : ServiceFramework{system_, "IDeliveryCacheProgressService"}, event{event_}, impl{impl_} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IDeliveryCacheProgressService::GetEvent, "GetEvent"},
-            {1, &IDeliveryCacheProgressService::GetImpl, "GetImpl"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetEvent(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(event);
-    }
-
-    void GetImpl(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        ctx.WriteBuffer(impl);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    Kernel::KReadableEvent& event;
-    const DeliveryCacheProgressImpl& impl;
-};
-
-class IBcatService final : public ServiceFramework<IBcatService> {
-public:
-    explicit IBcatService(Core::System& system_, Backend& backend_)
-        : ServiceFramework{system_, "IBcatService"}, backend{backend_},
-          progress{{
-              ProgressServiceBackend{system_, "Normal"},
-              ProgressServiceBackend{system_, "Directory"},
-          }} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {10100, &IBcatService::RequestSyncDeliveryCache, "RequestSyncDeliveryCache"},
-            {10101, &IBcatService::RequestSyncDeliveryCacheWithDirectoryName, "RequestSyncDeliveryCacheWithDirectoryName"},
-            {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
-            {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
-            {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
-            {20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
-            {20301, nullptr, "RequestSuspendDeliveryTask"},
-            {20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
-            {20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
-            {20410, nullptr, "SetSystemApplicationDeliveryTaskTimer"},
-            {30100, &IBcatService::SetPassphrase, "SetPassphrase"},
-            {30101, nullptr, "Unknown30101"},
-            {30102, nullptr, "Unknown30102"},
-            {30200, nullptr, "RegisterBackgroundDeliveryTask"},
-            {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
-            {30202, nullptr, "BlockDeliveryTask"},
-            {30203, nullptr, "UnblockDeliveryTask"},
-            {30210, nullptr, "SetDeliveryTaskTimer"},
-            {30300, nullptr, "RegisterSystemApplicationDeliveryTasks"},
-            {90100, nullptr, "EnumerateBackgroundDeliveryTask"},
-            {90101, nullptr, "Unknown90101"},
-            {90200, nullptr, "GetDeliveryList"},
-            {90201, &IBcatService::ClearDeliveryCacheStorage, "ClearDeliveryCacheStorage"},
-            {90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
-            {90300, nullptr, "GetPushNotificationLog"},
-            {90301, nullptr, "Unknown90301"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-private:
-    enum class SyncType {
-        Normal,
-        Directory,
-        Count,
-    };
-
-    std::shared_ptr<IDeliveryCacheProgressService> CreateProgressService(SyncType type) {
-        auto& progress_backend{GetProgressBackend(type)};
-        return std::make_shared<IDeliveryCacheProgressService>(system, progress_backend.GetEvent(),
-                                                               progress_backend.GetImpl());
-    }
-
-    void RequestSyncDeliveryCache(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        backend.Synchronize({system.GetApplicationProcessProgramID(),
-                             GetCurrentBuildID(system.GetApplicationProcessBuildID())},
-                            GetProgressBackend(SyncType::Normal));
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface(CreateProgressService(SyncType::Normal));
-    }
-
-    void RequestSyncDeliveryCacheWithDirectoryName(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto name_raw = rp.PopRaw<DirectoryName>();
-        const auto name =
-            Common::StringFromFixedZeroTerminatedBuffer(name_raw.data(), name_raw.size());
-
-        LOG_DEBUG(Service_BCAT, "called, name={}", name);
-
-        backend.SynchronizeDirectory({system.GetApplicationProcessProgramID(),
-                                      GetCurrentBuildID(system.GetApplicationProcessBuildID())},
-                                     name, GetProgressBackend(SyncType::Directory));
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface(CreateProgressService(SyncType::Directory));
-    }
-
-    void SetPassphrase(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto title_id = rp.PopRaw<u64>();
-
-        const auto passphrase_raw = ctx.ReadBuffer();
-
-        LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
-                  Common::HexToString(passphrase_raw));
-
-        if (title_id == 0) {
-            LOG_ERROR(Service_BCAT, "Invalid title ID!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-        }
-
-        if (passphrase_raw.size() > 0x40) {
-            LOG_ERROR(Service_BCAT, "Passphrase too large!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        Passphrase passphrase{};
-        std::memcpy(passphrase.data(), passphrase_raw.data(),
-                    std::min(passphrase.size(), passphrase_raw.size()));
-
-        backend.SetPassphrase(title_id, passphrase);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void ClearDeliveryCacheStorage(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto title_id = rp.PopRaw<u64>();
-
-        LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
-
-        if (title_id == 0) {
-            LOG_ERROR(Service_BCAT, "Invalid title ID!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        if (!backend.Clear(title_id)) {
-            LOG_ERROR(Service_BCAT, "Could not clear the directory successfully!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_FAILED_CLEAR_CACHE);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    ProgressServiceBackend& GetProgressBackend(SyncType type) {
-        return progress.at(static_cast<size_t>(type));
-    }
-
-    const ProgressServiceBackend& GetProgressBackend(SyncType type) const {
-        return progress.at(static_cast<size_t>(type));
-    }
-
-    Backend& backend;
-    std::array<ProgressServiceBackend, static_cast<size_t>(SyncType::Count)> progress;
-};
-
-void Module::Interface::CreateBcatService(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IBcatService>(system, *backend);
-}
-
-class IDeliveryCacheFileService final : public ServiceFramework<IDeliveryCacheFileService> {
-public:
-    explicit IDeliveryCacheFileService(Core::System& system_, FileSys::VirtualDir root_)
-        : ServiceFramework{system_, "IDeliveryCacheFileService"}, root(std::move(root_)) {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IDeliveryCacheFileService::Open, "Open"},
-            {1, &IDeliveryCacheFileService::Read, "Read"},
-            {2, &IDeliveryCacheFileService::GetSize, "GetSize"},
-            {3, &IDeliveryCacheFileService::GetDigest, "GetDigest"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void Open(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto dir_name_raw = rp.PopRaw<DirectoryName>();
-        const auto file_name_raw = rp.PopRaw<FileName>();
-
-        const auto dir_name =
-            Common::StringFromFixedZeroTerminatedBuffer(dir_name_raw.data(), dir_name_raw.size());
-        const auto file_name =
-            Common::StringFromFixedZeroTerminatedBuffer(file_name_raw.data(), file_name_raw.size());
-
-        LOG_DEBUG(Service_BCAT, "called, dir_name={}, file_name={}", dir_name, file_name);
-
-        if (!VerifyNameValidDir(ctx, dir_name_raw) || !VerifyNameValidFile(ctx, file_name_raw))
-            return;
-
-        if (current_file != nullptr) {
-            LOG_ERROR(Service_BCAT, "A file has already been opened on this interface!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_ENTITY_ALREADY_OPEN);
-            return;
-        }
-
-        const auto dir = root->GetSubdirectory(dir_name);
-
-        if (dir == nullptr) {
-            LOG_ERROR(Service_BCAT, "The directory of name={} couldn't be opened!", dir_name);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_FAILED_OPEN_ENTITY);
-            return;
-        }
-
-        current_file = dir->GetFile(file_name);
-
-        if (current_file == nullptr) {
-            LOG_ERROR(Service_BCAT, "The file of name={} couldn't be opened!", file_name);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_FAILED_OPEN_ENTITY);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void Read(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto offset{rp.PopRaw<u64>()};
-
-        auto size = ctx.GetWriteBufferSize();
-
-        LOG_DEBUG(Service_BCAT, "called, offset={:016X}, size={:016X}", offset, size);
-
-        if (current_file == nullptr) {
-            LOG_ERROR(Service_BCAT, "There is no file currently open!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NO_OPEN_ENTITY);
-        }
-
-        size = std::min<u64>(current_file->GetSize() - offset, size);
-        const auto buffer = current_file->ReadBytes(size, offset);
-        ctx.WriteBuffer(buffer);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<u64>(buffer.size());
-    }
-
-    void GetSize(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        if (current_file == nullptr) {
-            LOG_ERROR(Service_BCAT, "There is no file currently open!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NO_OPEN_ENTITY);
-        }
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<u64>(current_file->GetSize());
-    }
-
-    void GetDigest(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        if (current_file == nullptr) {
-            LOG_ERROR(Service_BCAT, "There is no file currently open!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NO_OPEN_ENTITY);
-        }
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(DigestFile(current_file));
-    }
-
-    FileSys::VirtualDir root;
-    FileSys::VirtualFile current_file;
-};
-
-class IDeliveryCacheDirectoryService final
-    : public ServiceFramework<IDeliveryCacheDirectoryService> {
-public:
-    explicit IDeliveryCacheDirectoryService(Core::System& system_, FileSys::VirtualDir root_)
-        : ServiceFramework{system_, "IDeliveryCacheDirectoryService"}, root(std::move(root_)) {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IDeliveryCacheDirectoryService::Open, "Open"},
-            {1, &IDeliveryCacheDirectoryService::Read, "Read"},
-            {2, &IDeliveryCacheDirectoryService::GetCount, "GetCount"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void Open(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto name_raw = rp.PopRaw<DirectoryName>();
-        const auto name =
-            Common::StringFromFixedZeroTerminatedBuffer(name_raw.data(), name_raw.size());
-
-        LOG_DEBUG(Service_BCAT, "called, name={}", name);
-
-        if (!VerifyNameValidDir(ctx, name_raw))
-            return;
-
-        if (current_dir != nullptr) {
-            LOG_ERROR(Service_BCAT, "A file has already been opened on this interface!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_ENTITY_ALREADY_OPEN);
-            return;
-        }
-
-        current_dir = root->GetSubdirectory(name);
-
-        if (current_dir == nullptr) {
-            LOG_ERROR(Service_BCAT, "Failed to open the directory name={}!", name);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_FAILED_OPEN_ENTITY);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void Read(HLERequestContext& ctx) {
-        auto write_size = ctx.GetWriteBufferNumElements<DeliveryCacheDirectoryEntry>();
-
-        LOG_DEBUG(Service_BCAT, "called, write_size={:016X}", write_size);
-
-        if (current_dir == nullptr) {
-            LOG_ERROR(Service_BCAT, "There is no open directory!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NO_OPEN_ENTITY);
-            return;
-        }
-
-        const auto files = current_dir->GetFiles();
-        write_size = std::min<u64>(write_size, files.size());
-        std::vector<DeliveryCacheDirectoryEntry> entries(write_size);
-        std::transform(
-            files.begin(), files.begin() + write_size, entries.begin(), [](const auto& file) {
-                FileName name{};
-                std::memcpy(name.data(), file->GetName().data(),
-                            std::min(file->GetName().size(), name.size()));
-                return DeliveryCacheDirectoryEntry{name, file->GetSize(), DigestFile(file)};
-            });
-
-        ctx.WriteBuffer(entries);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(static_cast<u32>(write_size * sizeof(DeliveryCacheDirectoryEntry)));
-    }
-
-    void GetCount(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        if (current_dir == nullptr) {
-            LOG_ERROR(Service_BCAT, "There is no open directory!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NO_OPEN_ENTITY);
-            return;
-        }
-
-        const auto files = current_dir->GetFiles();
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(static_cast<u32>(files.size()));
-    }
-
-    FileSys::VirtualDir root;
-    FileSys::VirtualDir current_dir;
-};
-
-class IDeliveryCacheStorageService final : public ServiceFramework<IDeliveryCacheStorageService> {
-public:
-    explicit IDeliveryCacheStorageService(Core::System& system_, FileSys::VirtualDir root_)
-        : ServiceFramework{system_, "IDeliveryCacheStorageService"}, root(std::move(root_)) {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IDeliveryCacheStorageService::CreateFileService, "CreateFileService"},
-            {1, &IDeliveryCacheStorageService::CreateDirectoryService, "CreateDirectoryService"},
-            {10, &IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory, "EnumerateDeliveryCacheDirectory"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-
-        for (const auto& subdir : root->GetSubdirectories()) {
-            DirectoryName name{};
-            std::memcpy(name.data(), subdir->GetName().data(),
-                        std::min(sizeof(DirectoryName) - 1, subdir->GetName().size()));
-            entries.push_back(name);
-        }
-    }
-
-private:
-    void CreateFileService(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IDeliveryCacheFileService>(system, root);
-    }
-
-    void CreateDirectoryService(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_BCAT, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IDeliveryCacheDirectoryService>(system, root);
-    }
-
-    void EnumerateDeliveryCacheDirectory(HLERequestContext& ctx) {
-        auto size = ctx.GetWriteBufferNumElements<DirectoryName>();
-
-        LOG_DEBUG(Service_BCAT, "called, size={:016X}", size);
-
-        size = std::min<u64>(size, entries.size() - next_read_index);
-        ctx.WriteBuffer(entries.data() + next_read_index, size * sizeof(DirectoryName));
-        next_read_index += size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(static_cast<u32>(size));
-    }
-
-    FileSys::VirtualDir root;
-    std::vector<DirectoryName> entries;
-    u64 next_read_index = 0;
-};
-
-void Module::Interface::CreateDeliveryCacheStorageService(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_BCAT, "called");
-
-    const auto title_id = system.GetApplicationProcessProgramID();
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
-}
-
-void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto title_id = rp.PopRaw<u64>();
-
-    LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
-}
-
-std::unique_ptr<Backend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
-                                                   DirectoryGetter getter) {
-    return std::make_unique<NullBackend>(std::move(getter));
-}
-
-Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> module_,
-                             FileSystem::FileSystemController& fsc_, const char* name)
-    : ServiceFramework{system_, name}, fsc{fsc_}, module{std::move(module_)},
-      backend{CreateBackendFromSettings(system_,
-                                        [&fsc_](u64 tid) { return fsc_.GetBCATDirectory(tid); })} {}
-
-Module::Interface::~Interface() = default;
-
-void LoopProcess(Core::System& system) {
-    auto server_manager = std::make_unique<ServerManager>(system);
-    auto module = std::make_shared<Module>();
-
-    server_manager->RegisterNamedService(
-        "bcat:a",
-        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:a"));
-    server_manager->RegisterNamedService(
-        "bcat:m",
-        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:m"));
-    server_manager->RegisterNamedService(
-        "bcat:u",
-        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:u"));
-    server_manager->RegisterNamedService(
-        "bcat:s",
-        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:s"));
-    ServerManager::RunServer(std::move(server_manager));
-}
-
-} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_module.h

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service {
-
-namespace FileSystem {
-class FileSystemController;
-} // namespace FileSystem
-
-namespace BCAT {
-
-class Backend;
-
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        explicit Interface(Core::System& system_, std::shared_ptr<Module> module_,
-                           FileSystem::FileSystemController& fsc_, const char* name);
-        ~Interface() override;
-
-        void CreateBcatService(HLERequestContext& ctx);
-        void CreateDeliveryCacheStorageService(HLERequestContext& ctx);
-        void CreateDeliveryCacheStorageServiceWithApplicationId(HLERequestContext& ctx);
-
-    protected:
-        FileSystem::FileSystemController& fsc;
-
-        std::shared_ptr<Module> module;
-        std::unique_ptr<Backend> backend;
-    };
-};
-
-void LoopProcess(Core::System& system);
-
-} // namespace BCAT
-
-} // namespace Service

src/core/hle/service/bcat/bcat_result.h

@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace Service::BCAT {
+
+constexpr Result ResultInvalidArgument{ErrorModule::BCAT, 1};
+constexpr Result ResultFailedOpenEntity{ErrorModule::BCAT, 2};
+constexpr Result ResultEntityAlreadyOpen{ErrorModule::BCAT, 6};
+constexpr Result ResultNoOpenEntry{ErrorModule::BCAT, 7};
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,132 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/hex_util.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/file_sys/errors.h"
+#include "core/hle/service/bcat/backend/backend.h"
+#include "core/hle/service/bcat/bcat_result.h"
+#include "core/hle/service/bcat/bcat_service.h"
+#include "core/hle/service/bcat/bcat_util.h"
+#include "core/hle/service/bcat/delivery_cache_progress_service.h"
+#include "core/hle/service/bcat/delivery_cache_storage_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::BCAT {
+
+static u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
+    u64 out{};
+    std::memcpy(&out, id.data(), sizeof(u64));
+    return out;
+}
+
+IBcatService::IBcatService(Core::System& system_, BcatBackend& backend_)
+    : ServiceFramework{system_, "IBcatService"}, backend{backend_},
+      progress{{
+          ProgressServiceBackend{system_, "Normal"},
+          ProgressServiceBackend{system_, "Directory"},
+      }} {
+    // clang-format off
+        static const FunctionInfo functions[] = {
+            {10100, C<&IBcatService::RequestSyncDeliveryCache>, "RequestSyncDeliveryCache"},
+            {10101, C<&IBcatService::RequestSyncDeliveryCacheWithDirectoryName>, "RequestSyncDeliveryCacheWithDirectoryName"},
+            {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
+            {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
+            {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
+            {20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
+            {20301, nullptr, "RequestSuspendDeliveryTask"},
+            {20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
+            {20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
+            {20410, nullptr, "SetSystemApplicationDeliveryTaskTimer"},
+            {30100, C<&IBcatService::SetPassphrase>, "SetPassphrase"},
+            {30101, nullptr, "Unknown30101"},
+            {30102, nullptr, "Unknown30102"},
+            {30200, nullptr, "RegisterBackgroundDeliveryTask"},
+            {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
+            {30202, nullptr, "BlockDeliveryTask"},
+            {30203, nullptr, "UnblockDeliveryTask"},
+            {30210, nullptr, "SetDeliveryTaskTimer"},
+            {30300, C<&IBcatService::RegisterSystemApplicationDeliveryTasks>, "RegisterSystemApplicationDeliveryTasks"},
+            {90100, nullptr, "EnumerateBackgroundDeliveryTask"},
+            {90101, nullptr, "Unknown90101"},
+            {90200, nullptr, "GetDeliveryList"},
+            {90201, C<&IBcatService::ClearDeliveryCacheStorage>, "ClearDeliveryCacheStorage"},
+            {90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
+            {90300, nullptr, "GetPushNotificationLog"},
+            {90301, nullptr, "Unknown90301"},
+        };
+    // clang-format on
+    RegisterHandlers(functions);
+}
+
+IBcatService::~IBcatService() = default;
+
+Result IBcatService::RequestSyncDeliveryCache(
+    OutInterface<IDeliveryCacheProgressService> out_interface) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    auto& progress_backend{GetProgressBackend(SyncType::Normal)};
+    backend.Synchronize({system.GetApplicationProcessProgramID(),
+                         GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+                        GetProgressBackend(SyncType::Normal));
+
+    *out_interface = std::make_shared<IDeliveryCacheProgressService>(
+        system, progress_backend.GetEvent(), progress_backend.GetImpl());
+    R_SUCCEED();
+}
+
+Result IBcatService::RequestSyncDeliveryCacheWithDirectoryName(
+    const DirectoryName& name_raw, OutInterface<IDeliveryCacheProgressService> out_interface) {
+    const auto name = Common::StringFromFixedZeroTerminatedBuffer(name_raw.data(), name_raw.size());
+
+    LOG_DEBUG(Service_BCAT, "called, name={}", name);
+
+    auto& progress_backend{GetProgressBackend(SyncType::Directory)};
+    backend.SynchronizeDirectory({system.GetApplicationProcessProgramID(),
+                                  GetCurrentBuildID(system.GetApplicationProcessBuildID())},
+                                 name, progress_backend);
+
+    *out_interface = std::make_shared<IDeliveryCacheProgressService>(
+        system, progress_backend.GetEvent(), progress_backend.GetImpl());
+    R_SUCCEED();
+}
+
+Result IBcatService::SetPassphrase(u64 application_id,
+                                   InBuffer<BufferAttr_HipcPointer> passphrase_buffer) {
+    LOG_DEBUG(Service_BCAT, "called, application_id={:016X}, passphrase={}", application_id,
+              Common::HexToString(passphrase_buffer));
+
+    R_UNLESS(application_id != 0, ResultInvalidArgument);
+    R_UNLESS(passphrase_buffer.size() <= 0x40, ResultInvalidArgument);
+
+    Passphrase passphrase{};
+    std::memcpy(passphrase.data(), passphrase_buffer.data(),
+                std::min(passphrase.size(), passphrase_buffer.size()));
+
+    backend.SetPassphrase(application_id, passphrase);
+    R_SUCCEED();
+}
+
+Result IBcatService::RegisterSystemApplicationDeliveryTasks() {
+    LOG_WARNING(Service_BCAT, "(STUBBED) called");
+    R_SUCCEED();
+}
+
+Result IBcatService::ClearDeliveryCacheStorage(u64 application_id) {
+    LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", application_id);
+
+    R_UNLESS(application_id != 0, ResultInvalidArgument);
+    R_UNLESS(backend.Clear(application_id), FileSys::ResultPermissionDenied);
+    R_SUCCEED();
+}
+
+ProgressServiceBackend& IBcatService::GetProgressBackend(SyncType type) {
+    return progress.at(static_cast<size_t>(type));
+}
+
+const ProgressServiceBackend& IBcatService::GetProgressBackend(SyncType type) const {
+    return progress.at(static_cast<size_t>(type));
+}
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_service.h

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/bcat/backend/backend.h"
+#include "core/hle/service/bcat/bcat_types.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::BCAT {
+class BcatBackend;
+class IDeliveryCacheStorageService;
+class IDeliveryCacheProgressService;
+
+class IBcatService final : public ServiceFramework<IBcatService> {
+public:
+    explicit IBcatService(Core::System& system_, BcatBackend& backend_);
+    ~IBcatService() override;
+
+private:
+    Result RequestSyncDeliveryCache(OutInterface<IDeliveryCacheProgressService> out_interface);
+
+    Result RequestSyncDeliveryCacheWithDirectoryName(
+        const DirectoryName& name, OutInterface<IDeliveryCacheProgressService> out_interface);
+
+    Result SetPassphrase(u64 application_id, InBuffer<BufferAttr_HipcPointer> passphrase_buffer);
+
+    Result RegisterSystemApplicationDeliveryTasks();
+
+    Result ClearDeliveryCacheStorage(u64 application_id);
+
+private:
+    ProgressServiceBackend& GetProgressBackend(SyncType type);
+    const ProgressServiceBackend& GetProgressBackend(SyncType type) const;
+
+    BcatBackend& backend;
+    std::array<ProgressServiceBackend, static_cast<size_t>(SyncType::Count)> progress;
+};
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_types.h

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+#include <functional>
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "core/file_sys/vfs/vfs_types.h"
+#include "core/hle/result.h"
+
+namespace Service::BCAT {
+
+using DirectoryName = std::array<char, 0x20>;
+using FileName = std::array<char, 0x20>;
+using BcatDigest = std::array<u8, 0x10>;
+using Passphrase = std::array<u8, 0x20>;
+using DirectoryGetter = std::function<FileSys::VirtualDir(u64)>;
+
+enum class SyncType {
+    Normal,
+    Directory,
+    Count,
+};
+
+enum class DeliveryCacheProgressStatus : s32 {
+    None = 0x0,
+    Queued = 0x1,
+    Connecting = 0x2,
+    ProcessingDataList = 0x3,
+    Downloading = 0x4,
+    Committing = 0x5,
+    Done = 0x9,
+};
+
+struct DeliveryCacheDirectoryEntry {
+    FileName name;
+    u64 size;
+    BcatDigest digest;
+};
+
+struct TitleIDVersion {
+    u64 title_id;
+    u64 build_id;
+};
+
+struct DeliveryCacheProgressImpl {
+    DeliveryCacheProgressStatus status;
+    Result result;
+    DirectoryName current_directory;
+    FileName current_file;
+    s64 current_downloaded_bytes; ///< Bytes downloaded on current file.
+    s64 current_total_bytes;      ///< Bytes total on current file.
+    s64 total_downloaded_bytes;   ///< Bytes downloaded on overall download.
+    s64 total_bytes;              ///< Bytes total on overall download.
+    INSERT_PADDING_BYTES_NOINIT(
+        0x198); ///< Appears to be unused in official code, possibly reserved for future use.
+};
+static_assert(sizeof(DeliveryCacheProgressImpl) == 0x200,
+              "DeliveryCacheProgressImpl has incorrect size.");
+static_assert(std::is_trivial_v<DeliveryCacheProgressImpl>,
+              "DeliveryCacheProgressImpl type must be trivially copyable.");
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/bcat_util.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+#include <cctype>
+#include <mbedtls/md5.h>
+
+#include "core/hle/service/bcat/bcat_result.h"
+#include "core/hle/service/bcat/bcat_types.h"
+
+namespace Service::BCAT {
+
+// For a name to be valid it must be non-empty, must have a null terminating character as the final
+// char, can only contain numbers, letters, underscores and a hyphen if directory and a period if
+// file.
+constexpr Result VerifyNameValidInternal(std::array<char, 0x20> name, char match_char) {
+    const auto null_chars = std::count(name.begin(), name.end(), 0);
+    const auto bad_chars = std::count_if(name.begin(), name.end(), [match_char](char c) {
+        return !std::isalnum(static_cast<u8>(c)) && c != '_' && c != match_char && c != '\0';
+    });
+    if (null_chars == 0x20 || null_chars == 0 || bad_chars != 0 || name[0x1F] != '\0') {
+        LOG_ERROR(Service_BCAT, "Name passed was invalid!");
+        return ResultInvalidArgument;
+    }
+
+    return ResultSuccess;
+}
+
+constexpr Result VerifyNameValidDir(DirectoryName name) {
+    return VerifyNameValidInternal(name, '-');
+}
+
+constexpr Result VerifyNameValidFile(FileName name) {
+    return VerifyNameValidInternal(name, '.');
+}
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/string_util.h"
+#include "core/file_sys/vfs/vfs_types.h"
+#include "core/hle/service/bcat/bcat_result.h"
+#include "core/hle/service/bcat/bcat_util.h"
+#include "core/hle/service/bcat/delivery_cache_directory_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::BCAT {
+
+// The digest is only used to determine if a file is unique compared to others of the same name.
+// Since the algorithm isn't ever checked in game, MD5 is safe.
+static BcatDigest DigestFile(const FileSys::VirtualFile& file) {
+    BcatDigest out{};
+    const auto bytes = file->ReadAllBytes();
+    mbedtls_md5_ret(bytes.data(), bytes.size(), out.data());
+    return out;
+}
+
+IDeliveryCacheDirectoryService::IDeliveryCacheDirectoryService(Core::System& system_,
+                                                               FileSys::VirtualDir root_)
+    : ServiceFramework{system_, "IDeliveryCacheDirectoryService"}, root(std::move(root_)) {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IDeliveryCacheDirectoryService::Open>, "Open"},
+        {1, C<&IDeliveryCacheDirectoryService::Read>, "Read"},
+        {2, C<&IDeliveryCacheDirectoryService::GetCount>, "GetCount"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IDeliveryCacheDirectoryService::~IDeliveryCacheDirectoryService() = default;
+
+Result IDeliveryCacheDirectoryService::Open(const DirectoryName& dir_name_raw) {
+    const auto dir_name =
+        Common::StringFromFixedZeroTerminatedBuffer(dir_name_raw.data(), dir_name_raw.size());
+
+    LOG_DEBUG(Service_BCAT, "called, dir_name={}", dir_name);
+
+    R_TRY(VerifyNameValidDir(dir_name_raw));
+    R_UNLESS(current_dir == nullptr, ResultEntityAlreadyOpen);
+
+    const auto dir = root->GetSubdirectory(dir_name);
+    R_UNLESS(dir != nullptr, ResultFailedOpenEntity);
+
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheDirectoryService::Read(
+    Out<s32> out_count, OutArray<DeliveryCacheDirectoryEntry, BufferAttr_HipcMapAlias> out_buffer) {
+    LOG_DEBUG(Service_BCAT, "called, write_size={:016X}", out_buffer.size());
+
+    R_UNLESS(current_dir != nullptr, ResultNoOpenEntry);
+
+    const auto files = current_dir->GetFiles();
+    *out_count = static_cast<s32>(std::min(files.size(), out_buffer.size()));
+    std::transform(files.begin(), files.begin() + *out_count, out_buffer.begin(),
+                   [](const auto& file) {
+                       FileName name{};
+                       std::memcpy(name.data(), file->GetName().data(),
+                                   std::min(file->GetName().size(), name.size()));
+                       return DeliveryCacheDirectoryEntry{name, file->GetSize(), DigestFile(file)};
+                   });
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheDirectoryService::GetCount(Out<s32> out_count) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    R_UNLESS(current_dir != nullptr, ResultNoOpenEntry);
+
+    *out_count = static_cast<s32>(current_dir->GetFiles().size());
+    R_SUCCEED();
+}
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_directory_service.h

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/file_sys/vfs/vfs.h"
+#include "core/hle/service/bcat/bcat_types.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::BCAT {
+
+class IDeliveryCacheDirectoryService final
+    : public ServiceFramework<IDeliveryCacheDirectoryService> {
+public:
+    explicit IDeliveryCacheDirectoryService(Core::System& system_, FileSys::VirtualDir root_);
+    ~IDeliveryCacheDirectoryService() override;
+
+private:
+    Result Open(const DirectoryName& dir_name_raw);
+    Result Read(Out<s32> out_count,
+                OutArray<DeliveryCacheDirectoryEntry, BufferAttr_HipcMapAlias> out_buffer);
+    Result GetCount(Out<s32> out_count);
+
+    FileSys::VirtualDir root;
+    FileSys::VirtualDir current_dir;
+};
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/string_util.h"
+#include "core/hle/service/bcat/bcat_result.h"
+#include "core/hle/service/bcat/bcat_util.h"
+#include "core/hle/service/bcat/delivery_cache_file_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::BCAT {
+
+IDeliveryCacheFileService::IDeliveryCacheFileService(Core::System& system_,
+                                                     FileSys::VirtualDir root_)
+    : ServiceFramework{system_, "IDeliveryCacheFileService"}, root(std::move(root_)) {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IDeliveryCacheFileService::Open>, "Open"},
+        {1, C<&IDeliveryCacheFileService::Read>, "Read"},
+        {2, C<&IDeliveryCacheFileService::GetSize>, "GetSize"},
+        {3, C<&IDeliveryCacheFileService::GetDigest>, "GetDigest"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IDeliveryCacheFileService::~IDeliveryCacheFileService() = default;
+
+Result IDeliveryCacheFileService::Open(const DirectoryName& dir_name_raw,
+                                       const FileName& file_name_raw) {
+    const auto dir_name =
+        Common::StringFromFixedZeroTerminatedBuffer(dir_name_raw.data(), dir_name_raw.size());
+    const auto file_name =
+        Common::StringFromFixedZeroTerminatedBuffer(file_name_raw.data(), file_name_raw.size());
+
+    LOG_DEBUG(Service_BCAT, "called, dir_name={}, file_name={}", dir_name, file_name);
+
+    R_TRY(VerifyNameValidDir(dir_name_raw));
+    R_TRY(VerifyNameValidDir(file_name_raw));
+    R_UNLESS(current_file == nullptr, ResultEntityAlreadyOpen);
+
+    const auto dir = root->GetSubdirectory(dir_name);
+    R_UNLESS(dir != nullptr, ResultFailedOpenEntity);
+
+    current_file = dir->GetFile(file_name);
+    R_UNLESS(current_file != nullptr, ResultFailedOpenEntity);
+
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheFileService::Read(Out<u64> out_buffer_size, u64 offset,
+                                       OutBuffer<BufferAttr_HipcMapAlias> out_buffer) {
+    LOG_DEBUG(Service_BCAT, "called, offset={:016X}, size={:016X}", offset, out_buffer.size());
+
+    R_UNLESS(current_file != nullptr, ResultNoOpenEntry);
+
+    *out_buffer_size = std::min<u64>(current_file->GetSize() - offset, out_buffer.size());
+    const auto buffer = current_file->ReadBytes(*out_buffer_size, offset);
+    memcpy(out_buffer.data(), buffer.data(), buffer.size());
+
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheFileService::GetSize(Out<u64> out_size) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    R_UNLESS(current_file != nullptr, ResultNoOpenEntry);
+
+    *out_size = current_file->GetSize();
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheFileService::GetDigest(Out<BcatDigest> out_digest) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    R_UNLESS(current_file != nullptr, ResultNoOpenEntry);
+
+    //*out_digest = DigestFile(current_file);
+    R_SUCCEED();
+}
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_file_service.h

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/file_sys/vfs/vfs.h"
+#include "core/hle/service/bcat/bcat_types.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::BCAT {
+
+class IDeliveryCacheFileService final : public ServiceFramework<IDeliveryCacheFileService> {
+public:
+    explicit IDeliveryCacheFileService(Core::System& system_, FileSys::VirtualDir root_);
+    ~IDeliveryCacheFileService() override;
+
+private:
+    Result Open(const DirectoryName& dir_name_raw, const FileName& file_name_raw);
+    Result Read(Out<u64> out_buffer_size, u64 offset,
+                OutBuffer<BufferAttr_HipcMapAlias> out_buffer);
+    Result GetSize(Out<u64> out_size);
+    Result GetDigest(Out<BcatDigest> out_digest);
+
+    FileSys::VirtualDir root;
+    FileSys::VirtualFile current_file;
+};
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/bcat_types.h"
+#include "core/hle/service/bcat/delivery_cache_progress_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::BCAT {
+
+IDeliveryCacheProgressService::IDeliveryCacheProgressService(Core::System& system_,
+                                                             Kernel::KReadableEvent& event_,
+                                                             const DeliveryCacheProgressImpl& impl_)
+    : ServiceFramework{system_, "IDeliveryCacheProgressService"}, event{event_}, impl{impl_} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IDeliveryCacheProgressService::GetEvent>, "Get"},
+        {0, C<&IDeliveryCacheProgressService::GetImpl>, "Get"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IDeliveryCacheProgressService::~IDeliveryCacheProgressService() = default;
+
+Result IDeliveryCacheProgressService::GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    *out_event = &event;
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheProgressService::GetImpl(
+    OutLargeData<DeliveryCacheProgressImpl, BufferAttr_HipcPointer> out_impl) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    *out_impl = impl;
+    R_SUCCEED();
+}
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_progress_service.h

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel
+
+namespace Service::BCAT {
+struct DeliveryCacheProgressImpl;
+
+class IDeliveryCacheProgressService final : public ServiceFramework<IDeliveryCacheProgressService> {
+public:
+    explicit IDeliveryCacheProgressService(Core::System& system_, Kernel::KReadableEvent& event_,
+                                           const DeliveryCacheProgressImpl& impl_);
+    ~IDeliveryCacheProgressService() override;
+
+private:
+    Result GetEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
+    Result GetImpl(OutLargeData<DeliveryCacheProgressImpl, BufferAttr_HipcPointer> out_impl);
+
+    Kernel::KReadableEvent& event;
+    const DeliveryCacheProgressImpl& impl;
+};
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/bcat_result.h"
+#include "core/hle/service/bcat/delivery_cache_directory_service.h"
+#include "core/hle/service/bcat/delivery_cache_file_service.h"
+#include "core/hle/service/bcat/delivery_cache_storage_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::BCAT {
+
+IDeliveryCacheStorageService::IDeliveryCacheStorageService(Core::System& system_,
+                                                           FileSys::VirtualDir root_)
+    : ServiceFramework{system_, "IDeliveryCacheStorageService"}, root(std::move(root_)) {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IDeliveryCacheStorageService::CreateFileService>, "CreateFileService"},
+        {1, C<&IDeliveryCacheStorageService::CreateDirectoryService>, "CreateDirectoryService"},
+        {2, C<&IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory>, "EnumerateDeliveryCacheDirectory"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IDeliveryCacheStorageService::~IDeliveryCacheStorageService() = default;
+
+Result IDeliveryCacheStorageService::CreateFileService(
+    OutInterface<IDeliveryCacheFileService> out_interface) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    *out_interface = std::make_shared<IDeliveryCacheFileService>(system, root);
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheStorageService::CreateDirectoryService(
+    OutInterface<IDeliveryCacheDirectoryService> out_interface) {
+    LOG_DEBUG(Service_BCAT, "called");
+
+    *out_interface = std::make_shared<IDeliveryCacheDirectoryService>(system, root);
+    R_SUCCEED();
+}
+
+Result IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory(
+    Out<s32> out_directory_count,
+    OutArray<DirectoryName, BufferAttr_HipcMapAlias> out_directories) {
+    LOG_DEBUG(Service_BCAT, "called, size={:016X}", out_directories.size());
+
+    *out_directory_count =
+        static_cast<s32>(std::min(out_directories.size(), entries.size() - next_read_index));
+    memcpy(out_directories.data(), entries.data() + next_read_index,
+           *out_directory_count * sizeof(DirectoryName));
+    next_read_index += *out_directory_count;
+    R_SUCCEED();
+}
+
+} // namespace Service::BCAT

src/core/hle/service/bcat/delivery_cache_storage_service.h

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/file_sys/vfs/vfs.h"
+#include "core/hle/service/bcat/bcat_types.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::BCAT {
+class IDeliveryCacheFileService;
+class IDeliveryCacheDirectoryService;
+
+class IDeliveryCacheStorageService final : public ServiceFramework<IDeliveryCacheStorageService> {
+public:
+    explicit IDeliveryCacheStorageService(Core::System& system_, FileSys::VirtualDir root_);
+    ~IDeliveryCacheStorageService() override;
+
+private:
+    Result CreateFileService(OutInterface<IDeliveryCacheFileService> out_interface);
+    Result CreateDirectoryService(OutInterface<IDeliveryCacheDirectoryService> out_interface);
+    Result EnumerateDeliveryCacheDirectory(
+        Out<s32> out_directory_count,
+        OutArray<DirectoryName, BufferAttr_HipcMapAlias> out_directories);
+
+    FileSys::VirtualDir root;
+    std::vector<DirectoryName> entries;
+    std::size_t next_read_index = 0;
+};
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/newly_arrived_event_holder.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::News {
+
+INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
+    : ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
+                                                                 system_,
+                                                                 "INewlyArrivedEventHolder"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&INewlyArrivedEventHolder::Get>, "Get"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+    arrived_event = service_context.CreateEvent("INewlyArrivedEventHolder::ArrivedEvent");
+}
+
+INewlyArrivedEventHolder::~INewlyArrivedEventHolder() {
+    service_context.CloseEvent(arrived_event);
+}
+
+Result INewlyArrivedEventHolder::Get(OutCopyHandle<Kernel::KReadableEvent> out_event) {
+    LOG_INFO(Service_BCAT, "called");
+
+    *out_event = &arrived_event->GetReadableEvent();
+    R_SUCCEED();
+}
+
+} // namespace Service::News

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

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.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;
+class KReadableEvent;
+} // namespace Kernel
+
+namespace Service::News {
+
+class INewlyArrivedEventHolder final : public ServiceFramework<INewlyArrivedEventHolder> {
+public:
+    explicit INewlyArrivedEventHolder(Core::System& system_);
+    ~INewlyArrivedEventHolder() override;
+
+private:
+    Result Get(OutCopyHandle<Kernel::KReadableEvent> out_event);
+
+    Kernel::KEvent* arrived_event;
+    KernelHelpers::ServiceContext service_context;
+};
+
+} // namespace Service::News

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

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/news_data_service.h"
+
+namespace Service::News {
+
+INewsDataService::INewsDataService(Core::System& system_)
+    : ServiceFramework{system_, "INewsDataService"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "Open"},
+        {1, nullptr, "OpenWithNewsRecordV1"},
+        {2, nullptr, "Read"},
+        {3, nullptr, "GetSize"},
+        {1001, nullptr, "OpenWithNewsRecord"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+INewsDataService::~INewsDataService() = default;
+
+} // namespace Service::News

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

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

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

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/news_database_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::News {
+
+INewsDatabaseService::INewsDatabaseService(Core::System& system_)
+    : ServiceFramework{system_, "INewsDatabaseService"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetListV1"},
+        {1, C<&INewsDatabaseService::Count>, "Count"},
+        {2, nullptr, "CountWithKey"},
+        {3, nullptr, "UpdateIntegerValue"},
+        {4, nullptr, "UpdateIntegerValueWithAddition"},
+        {5, nullptr, "UpdateStringValue"},
+        {1000, nullptr, "GetList"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+INewsDatabaseService::~INewsDatabaseService() = default;
+
+Result INewsDatabaseService::Count(Out<s32> out_count,
+                                   InBuffer<BufferAttr_HipcPointer> buffer_data) {
+    LOG_WARNING(Service_BCAT, "(STUBBED) called, buffer_size={}", buffer_data.size());
+    *out_count = 0;
+    R_SUCCEED();
+}
+
+} // namespace Service::News

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

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::News {
+
+class INewsDatabaseService final : public ServiceFramework<INewsDatabaseService> {
+public:
+    explicit INewsDatabaseService(Core::System& system_);
+    ~INewsDatabaseService() override;
+
+private:
+    Result Count(Out<s32> out_count, InBuffer<BufferAttr_HipcPointer> buffer_data);
+};
+
+} // namespace Service::News

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

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/news_service.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::News {
+
+INewsService::INewsService(Core::System& system_) : ServiceFramework{system_, "INewsService"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {10100, nullptr, "PostLocalNews"},
+        {20100, nullptr, "SetPassphrase"},
+        {30100, C<&INewsService::GetSubscriptionStatus>, "GetSubscriptionStatus"},
+        {30101, nullptr, "GetTopicList"},
+        {30110, nullptr, "Unknown30110"},
+        {30200, nullptr, "IsSystemUpdateRequired"},
+        {30201, nullptr, "Unknown30201"},
+        {30210, nullptr, "Unknown30210"},
+        {30300, nullptr, "RequestImmediateReception"},
+        {30400, nullptr, "DecodeArchiveFile"},
+        {30500, nullptr, "Unknown30500"},
+        {30900, nullptr, "Unknown30900"},
+        {30901, nullptr, "Unknown30901"},
+        {30902, nullptr, "Unknown30902"},
+        {40100, nullptr, "SetSubscriptionStatus"},
+        {40101, nullptr, "RequestAutoSubscription"},
+        {40200, nullptr, "ClearStorage"},
+        {40201, nullptr, "ClearSubscriptionStatusAll"},
+        {90100, nullptr, "GetNewsDatabaseDump"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+INewsService::~INewsService() = default;
+
+Result INewsService::GetSubscriptionStatus(Out<u32> out_status,
+                                           InBuffer<BufferAttr_HipcPointer> buffer_data) {
+    LOG_WARNING(Service_BCAT, "(STUBBED) called, buffer_size={}", buffer_data.size());
+    *out_status = 0;
+    R_SUCCEED();
+}
+
+} // namespace Service::News

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

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::News {
+
+class INewsService final : public ServiceFramework<INewsService> {
+public:
+    explicit INewsService(Core::System& system_);
+    ~INewsService() override;
+
+private:
+    Result GetSubscriptionStatus(Out<u32> out_status, InBuffer<BufferAttr_HipcPointer> buffer_data);
+};
+
+} // namespace Service::News

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

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/overwrite_event_holder.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::News {
+
+IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
+    : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
+                                                                          "IOverwriteEventHolder"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IOverwriteEventHolder::Get>, "Get"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+    overwrite_event = service_context.CreateEvent("IOverwriteEventHolder::OverwriteEvent");
+}
+
+IOverwriteEventHolder::~IOverwriteEventHolder() {
+    service_context.CloseEvent(overwrite_event);
+}
+
+Result IOverwriteEventHolder::Get(OutCopyHandle<Kernel::KReadableEvent> out_event) {
+    LOG_INFO(Service_BCAT, "called");
+
+    *out_event = &overwrite_event->GetReadableEvent();
+    R_SUCCEED();
+}
+
+} // namespace Service::News

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

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.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;
+class KReadableEvent;
+} // namespace Kernel
+
+namespace Service::News {
+
+class IOverwriteEventHolder final : public ServiceFramework<IOverwriteEventHolder> {
+public:
+    explicit IOverwriteEventHolder(Core::System& system_);
+    ~IOverwriteEventHolder() override;
+
+private:
+    Result Get(OutCopyHandle<Kernel::KReadableEvent> out_event);
+
+    Kernel::KEvent* overwrite_event;
+    KernelHelpers::ServiceContext service_context;
+};
+
+} // namespace Service::News

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

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/bcat/news/newly_arrived_event_holder.h"
+#include "core/hle/service/bcat/news/news_data_service.h"
+#include "core/hle/service/bcat/news/news_database_service.h"
+#include "core/hle/service/bcat/news/news_service.h"
+#include "core/hle/service/bcat/news/overwrite_event_holder.h"
+#include "core/hle/service/bcat/news/service_creator.h"
+#include "core/hle/service/cmif_serialization.h"
+
+namespace Service::News {
+
+IServiceCreator::IServiceCreator(Core::System& system_, u32 permissions_, const char* name_)
+    : ServiceFramework{system_, name_}, permissions{permissions_} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IServiceCreator::CreateNewsService>, "CreateNewsService"},
+        {1, C<&IServiceCreator::CreateNewlyArrivedEventHolder>, "CreateNewlyArrivedEventHolder"},
+        {2, C<&IServiceCreator::CreateNewsDataService>, "CreateNewsDataService"},
+        {3, C<&IServiceCreator::CreateNewsDatabaseService>, "CreateNewsDatabaseService"},
+        {4, C<&IServiceCreator::CreateOverwriteEventHolder>, "CreateOverwriteEventHolder"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IServiceCreator::~IServiceCreator() = default;
+
+Result IServiceCreator::CreateNewsService(OutInterface<INewsService> out_interface) {
+    LOG_INFO(Service_BCAT, "called");
+    *out_interface = std::make_shared<INewsService>(system);
+    R_SUCCEED();
+}
+
+Result IServiceCreator::CreateNewlyArrivedEventHolder(
+    OutInterface<INewlyArrivedEventHolder> out_interface) {
+    LOG_INFO(Service_BCAT, "called");
+    *out_interface = std::make_shared<INewlyArrivedEventHolder>(system);
+    R_SUCCEED();
+}
+
+Result IServiceCreator::CreateNewsDataService(OutInterface<INewsDataService> out_interface) {
+    LOG_INFO(Service_BCAT, "called");
+    *out_interface = std::make_shared<INewsDataService>(system);
+    R_SUCCEED();
+}
+
+Result IServiceCreator::CreateNewsDatabaseService(
+    OutInterface<INewsDatabaseService> out_interface) {
+    LOG_INFO(Service_BCAT, "called");
+    *out_interface = std::make_shared<INewsDatabaseService>(system);
+    R_SUCCEED();
+}
+
+Result IServiceCreator::CreateOverwriteEventHolder(
+    OutInterface<IOverwriteEventHolder> out_interface) {
+    LOG_INFO(Service_BCAT, "called");
+    *out_interface = std::make_shared<IOverwriteEventHolder>(system);
+    R_SUCCEED();
+}
+
+} // namespace Service::News

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

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::News {
+class INewsService;
+class INewlyArrivedEventHolder;
+class INewsDataService;
+class INewsDatabaseService;
+class IOverwriteEventHolder;
+
+class IServiceCreator final : public ServiceFramework<IServiceCreator> {
+public:
+    explicit IServiceCreator(Core::System& system_, u32 permissions_, const char* name_);
+    ~IServiceCreator() override;
+
+private:
+    Result CreateNewsService(OutInterface<INewsService> out_interface);
+    Result CreateNewlyArrivedEventHolder(OutInterface<INewlyArrivedEventHolder> out_interface);
+    Result CreateNewsDataService(OutInterface<INewsDataService> out_interface);
+    Result CreateNewsDatabaseService(OutInterface<INewsDatabaseService> out_interface);
+    Result CreateOverwriteEventHolder(OutInterface<IOverwriteEventHolder> out_interface);
+
+    u32 permissions;
+};
+
+} // namespace Service::News

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

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#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"
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/filesystem/filesystem.h"
+
+namespace Service::BCAT {
+
+std::unique_ptr<BcatBackend> CreateBackendFromSettings([[maybe_unused]] Core::System& system,
+                                                       DirectoryGetter getter) {
+    return std::make_unique<NullBcatBackend>(std::move(getter));
+}
+
+IServiceCreator::IServiceCreator(Core::System& system_, const char* name_)
+    : ServiceFramework{system_, name_}, fsc{system.GetFileSystemController()} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, C<&IServiceCreator::CreateBcatService>, "CreateBcatService"},
+        {1, C<&IServiceCreator::CreateDeliveryCacheStorageService>, "CreateDeliveryCacheStorageService"},
+        {2, C<&IServiceCreator::CreateDeliveryCacheStorageServiceWithApplicationId>, "CreateDeliveryCacheStorageServiceWithApplicationId"},
+        {3, nullptr, "CreateDeliveryCacheProgressService"},
+        {4, nullptr, "CreateDeliveryCacheProgressServiceWithApplicationId"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+
+    backend =
+        CreateBackendFromSettings(system_, [this](u64 tid) { return fsc.GetBCATDirectory(tid); });
+}
+
+IServiceCreator::~IServiceCreator() = default;
+
+Result IServiceCreator::CreateBcatService(ClientProcessId process_id,
+                                          OutInterface<IBcatService> out_interface) {
+    LOG_INFO(Service_BCAT, "called, process_id={}", process_id.pid);
+    *out_interface = std::make_shared<IBcatService>(system, *backend);
+    R_SUCCEED();
+}
+
+Result IServiceCreator::CreateDeliveryCacheStorageService(
+    ClientProcessId process_id, OutInterface<IDeliveryCacheStorageService> out_interface) {
+    LOG_INFO(Service_BCAT, "called, process_id={}", process_id.pid);
+
+    const auto title_id = system.GetApplicationProcessProgramID();
+    *out_interface =
+        std::make_shared<IDeliveryCacheStorageService>(system, fsc.GetBCATDirectory(title_id));
+    R_SUCCEED();
+}
+
+Result IServiceCreator::CreateDeliveryCacheStorageServiceWithApplicationId(
+    u64 application_id, OutInterface<IDeliveryCacheStorageService> out_interface) {
+    LOG_DEBUG(Service_BCAT, "called, application_id={:016X}", application_id);
+    *out_interface = std::make_shared<IDeliveryCacheStorageService>(
+        system, fsc.GetBCATDirectory(application_id));
+    R_SUCCEED();
+}
+
+} // namespace Service::BCAT

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

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::FileSystem {
+class FileSystemController;
+}
+
+namespace Service::BCAT {
+class BcatBackend;
+class IBcatService;
+class IDeliveryCacheStorageService;
+
+class IServiceCreator final : public ServiceFramework<IServiceCreator> {
+public:
+    explicit IServiceCreator(Core::System& system_, const char* name_);
+    ~IServiceCreator() override;
+
+private:
+    Result CreateBcatService(ClientProcessId process_id, OutInterface<IBcatService> out_interface);
+
+    Result CreateDeliveryCacheStorageService(
+        ClientProcessId process_id, OutInterface<IDeliveryCacheStorageService> out_interface);
+
+    Result CreateDeliveryCacheStorageServiceWithApplicationId(
+        u64 application_id, OutInterface<IDeliveryCacheStorageService> out_interface);
+
+    std::unique_ptr<BcatBackend> backend;
+    Service::FileSystem::FileSystemController& fsc;
+};
+
+} // namespace Service::BCAT

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

@@ -7,6 +7,7 @@
 #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/worker.h"
+#include "core/hle/service/os/multi_wait_utils.h"
 #include "core/hle/service/psc/time/common.h"
 #include "core/hle/service/psc/time/service_manager.h"
 #include "core/hle/service/psc/time/static.h"
@@ -143,82 +144,46 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
     Common::SetCurrentThreadName("TimeWorker");
     Common::SetCurrentThreadPriority(Common::ThreadPriority::Low);
 
-    enum class EventType {
-        Exit = 0,
-        IpmModuleService_GetEvent = 1,
-        PowerStateChange = 2,
-        SignalAlarms = 3,
-        UpdateLocalSystemClock = 4,
-        UpdateNetworkSystemClock = 5,
-        UpdateEphemeralSystemClock = 6,
-        UpdateSteadyClock = 7,
-        UpdateFileTimestamp = 8,
-        AutoCorrect = 9,
-        Max = 10,
-    };
-
-    s32 num_objs{};
-    std::array<Kernel::KSynchronizationObject*, static_cast<u32>(EventType::Max)> wait_objs{};
-    std::array<EventType, static_cast<u32>(EventType::Max)> wait_indices{};
-
-    const auto AddWaiter{
-        [&](Kernel::KSynchronizationObject* synchronization_object, EventType type) {
-            // Open a new reference to the object.
-            synchronization_object->Open();
-
-            // Insert into the list.
-            wait_indices[num_objs] = type;
-            wait_objs[num_objs++] = synchronization_object;
-        }};
-
     while (!stop_token.stop_requested()) {
-        SCOPE_EXIT({
-            for (s32 i = 0; i < num_objs; i++) {
-                wait_objs[i]->Close();
-            }
-        });
+        enum class EventType : s32 {
+            Exit = 0,
+            PowerStateChange = 1,
+            SignalAlarms = 2,
+            UpdateLocalSystemClock = 3,
+            UpdateNetworkSystemClock = 4,
+            UpdateEphemeralSystemClock = 5,
+            UpdateSteadyClock = 6,
+            UpdateFileTimestamp = 7,
+            AutoCorrect = 8,
+        };
+
+        s32 index{};
 
-        num_objs = {};
-        wait_objs = {};
         if (m_pm_state_change_handler.m_priority != 0) {
-            AddWaiter(&m_event->GetReadableEvent(), EventType::Exit);
-            // TODO
-            // AddWaiter(gIPmModuleService::GetEvent(), 1);
-            AddWaiter(&m_alarm_worker.GetEvent(), EventType::PowerStateChange);
+            // TODO: gIPmModuleService::GetEvent() 1
+            index = WaitAny(m_system.Kernel(),
+                            &m_event->GetReadableEvent(), // 0
+                            &m_alarm_worker.GetEvent()    // 1
+            );
         } else {
-            AddWaiter(&m_event->GetReadableEvent(), EventType::Exit);
-            // TODO
-            // AddWaiter(gIPmModuleService::GetEvent(), 1);
-            AddWaiter(&m_alarm_worker.GetEvent(), EventType::PowerStateChange);
-            AddWaiter(&m_alarm_worker.GetTimerEvent().GetReadableEvent(), EventType::SignalAlarms);
-            AddWaiter(m_local_clock_event, EventType::UpdateLocalSystemClock);
-            AddWaiter(m_network_clock_event, EventType::UpdateNetworkSystemClock);
-            AddWaiter(m_ephemeral_clock_event, EventType::UpdateEphemeralSystemClock);
-            AddWaiter(&m_timer_steady_clock->GetReadableEvent(), EventType::UpdateSteadyClock);
-            AddWaiter(&m_timer_file_system->GetReadableEvent(), EventType::UpdateFileTimestamp);
-            AddWaiter(m_standard_user_auto_correct_clock_event, EventType::AutoCorrect);
+            // TODO: gIPmModuleService::GetEvent() 1
+            index = WaitAny(m_system.Kernel(),
+                            &m_event->GetReadableEvent(),                       // 0
+                            &m_alarm_worker.GetEvent(),                         // 1
+                            &m_alarm_worker.GetTimerEvent().GetReadableEvent(), // 2
+                            m_local_clock_event,                                // 3
+                            m_network_clock_event,                              // 4
+                            m_ephemeral_clock_event,                            // 5
+                            &m_timer_steady_clock->GetReadableEvent(),          // 6
+                            &m_timer_file_system->GetReadableEvent(),           // 7
+                            m_standard_user_auto_correct_clock_event            // 8
+            );
         }
 
-        s32 out_index{-1};
-        Kernel::KSynchronizationObject::Wait(m_system.Kernel(), &out_index, wait_objs.data(),
-                                             num_objs, -1);
-        ASSERT(out_index >= 0 && out_index < num_objs);
-
-        if (stop_token.stop_requested()) {
-            return;
-        }
-
-        switch (wait_indices[out_index]) {
+        switch (static_cast<EventType>(index)) {
         case EventType::Exit:
             return;
 
-        case EventType::IpmModuleService_GetEvent:
-            // TODO
-            // IPmModuleService::GetEvent()
-            // clear the event
-            // Handle power state change event
-            break;
-
         case EventType::PowerStateChange:
             m_alarm_worker.GetEvent().Clear();
             if (m_pm_state_change_handler.m_priority <= 1) {
@@ -235,19 +200,19 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
             m_local_clock_event->Clear();
 
             Service::PSC::Time::SystemClockContext context{};
-            auto res = m_local_clock->GetSystemClockContext(&context);
-            ASSERT(res == ResultSuccess);
+            R_ASSERT(m_local_clock->GetSystemClockContext(&context));
 
             m_set_sys->SetUserSystemClockContext(context);
-
             m_file_timestamp_worker.SetFilesystemPosixTime();
-        } break;
+            break;
+        }
 
         case EventType::UpdateNetworkSystemClock: {
             m_network_clock_event->Clear();
+
             Service::PSC::Time::SystemClockContext context{};
-            auto res = m_network_clock->GetSystemClockContext(&context);
-            ASSERT(res == ResultSuccess);
+            R_ASSERT(m_network_clock->GetSystemClockContext(&context));
+
             m_set_sys->SetNetworkSystemClockContext(context);
 
             s64 time{};
@@ -267,7 +232,8 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
             }
 
             m_file_timestamp_worker.SetFilesystemPosixTime();
-        } break;
+            break;
+        }
 
         case EventType::UpdateEphemeralSystemClock: {
             m_ephemeral_clock_event->Clear();
@@ -295,7 +261,8 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
             if (!g_ig_report_ephemeral_clock_context_set) {
                 g_ig_report_ephemeral_clock_context_set = true;
             }
-        } break;
+            break;
+        }
 
         case EventType::UpdateSteadyClock:
             m_timer_steady_clock->Clear();
@@ -314,21 +281,20 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
             m_standard_user_auto_correct_clock_event->Clear();
 
             bool automatic_correction{};
-            auto res = m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(
-                &automatic_correction);
-            ASSERT(res == ResultSuccess);
+            R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(
+                &automatic_correction));
 
             Service::PSC::Time::SteadyClockTimePoint time_point{};
-            res = m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&time_point);
-            ASSERT(res == ResultSuccess);
+            R_ASSERT(
+                m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&time_point));
 
             m_set_sys->SetUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
             m_set_sys->SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
-        } break;
+            break;
+        }
 
         default:
             UNREACHABLE();
-            break;
         }
     }
 }

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

@@ -49,6 +49,7 @@ SessionId Container::OpenSession(Kernel::KProcess* process) {
             continue;
         }
         if (session.process == process) {
+            session.ref_count++;
             return session.id;
         }
     }
@@ -66,6 +67,7 @@ SessionId Container::OpenSession(Kernel::KProcess* process) {
     }
     auto& session = impl->sessions[new_id];
     session.is_active = true;
+    session.ref_count = 1;
     // Optimization
     if (process->IsApplication()) {
         auto& page_table = process->GetPageTable().GetBasePageTable();
@@ -114,8 +116,11 @@ SessionId Container::OpenSession(Kernel::KProcess* process) {
 
 void Container::CloseSession(SessionId session_id) {
     std::scoped_lock lk(impl->session_guard);
-    impl->file.UnmapAllHandles(session_id);
     auto& session = impl->sessions[session_id.id];
+    if (--session.ref_count > 0) {
+        return;
+    }
+    impl->file.UnmapAllHandles(session_id);
     auto& smmu = impl->host1x.MemoryManager();
     if (session.has_preallocated_area) {
         const DAddr region_start = session.mapper->GetRegionStart();

src/core/hle/service/nvdrv/core/container.h

@@ -46,6 +46,7 @@ struct Session {
     bool has_preallocated_area{};
     std::unique_ptr<HeapMapper> mapper{};
     bool is_active{};
+    s32 ref_count{};
 };
 
 class Container {
@@ -67,10 +68,7 @@ public:
     const SyncpointManager& GetSyncpointManager() const;
 
     struct Host1xDeviceFileData {
-        std::unordered_map<DeviceFD, u32> fd_to_id{};
         std::deque<u32> syncpts_accumulated{};
-        u32 nvdec_next_id{};
-        u32 vic_next_id{};
     };
 
     Host1xDeviceFileData& Host1xDeviceFile();

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

@@ -333,9 +333,13 @@ void NvMap::UnmapAllHandles(NvCore::SessionId session_id) {
     }();
 
     for (auto& [id, handle] : handles_copy) {
-        if (handle->session_id.id == session_id.id) {
-            FreeHandle(id, false);
+        {
+            std::scoped_lock lk{handle->mutex};
+            if (handle->session_id.id != session_id.id || handle->dupes <= 0) {
+                continue;
+            }
         }
+        FreeHandle(id, false);
     }
 }
 

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

@@ -15,6 +15,22 @@
 
 namespace Service::Nvidia::Devices {
 
+namespace {
+
+Tegra::BlendMode ConvertBlending(Service::Nvnflinger::LayerBlending blending) {
+    switch (blending) {
+    case Service::Nvnflinger::LayerBlending::None:
+    default:
+        return Tegra::BlendMode::Opaque;
+    case Service::Nvnflinger::LayerBlending::Premultiplied:
+        return Tegra::BlendMode::Premultiplied;
+    case Service::Nvnflinger::LayerBlending::Coverage:
+        return Tegra::BlendMode::Coverage;
+    }
+}
+
+} // namespace
+
 nvdisp_disp0::nvdisp_disp0(Core::System& system_, NvCore::Container& core)
     : nvdevice{system_}, container{core}, nvmap{core.GetNvMapFile()} {}
 nvdisp_disp0::~nvdisp_disp0() = default;
@@ -56,6 +72,7 @@ void nvdisp_disp0::Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers
             .pixel_format = layer.format,
             .transform_flags = layer.transform,
             .crop_rect = layer.crop_rect,
+            .blending = ConvertBlending(layer.blending),
         });
 
         for (size_t i = 0; i < layer.acquire_fence.num_fences; i++) {

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

@@ -8,6 +8,7 @@
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
+#include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
@@ -21,13 +22,8 @@ NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> in
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
-        case 0x1: {
-            auto& host1x_file = core.Host1xDeviceFile();
-            if (!host1x_file.fd_to_id.contains(fd)) {
-                host1x_file.fd_to_id[fd] = host1x_file.nvdec_next_id++;
-            }
+        case 0x1:
             return WrapFixedVariable(this, &nvhost_nvdec::Submit, input, output, fd);
-        }
         case 0x2:
             return WrapFixed(this, &nvhost_nvdec::GetSyncpoint, input, output);
         case 0x3:
@@ -72,15 +68,12 @@ void nvhost_nvdec::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream started");
     system.SetNVDECActive(true);
     sessions[fd] = session_id;
+    host1x.StartDevice(fd, Tegra::Host1x::ChannelType::NvDec, channel_syncpoint);
 }
 
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
-    auto& host1x_file = core.Host1xDeviceFile();
-    const auto iter = host1x_file.fd_to_id.find(fd);
-    if (iter != host1x_file.fd_to_id.end()) {
-        system.GPU().ClearCdmaInstance(iter->second);
-    }
+    host1x.StopDevice(fd, Tegra::Host1x::ChannelType::NvDec);
     system.SetNVDECActive(false);
     auto it = sessions.find(fd);
     if (it != sessions.end()) {

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

@@ -55,8 +55,9 @@ std::size_t WriteVectors(std::span<u8> dst, const std::vector<T>& src, std::size
 
 nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system_, NvCore::Container& core_,
                                          NvCore::ChannelType channel_type_)
-    : nvdevice{system_}, core{core_}, syncpoint_manager{core.GetSyncpointManager()},
-      nvmap{core.GetNvMapFile()}, channel_type{channel_type_} {
+    : nvdevice{system_}, host1x{system_.Host1x()}, core{core_},
+      syncpoint_manager{core.GetSyncpointManager()}, nvmap{core.GetNvMapFile()},
+      channel_type{channel_type_} {
     auto& syncpts_accumulated = core.Host1xDeviceFile().syncpts_accumulated;
     if (syncpts_accumulated.empty()) {
         channel_syncpoint = syncpoint_manager.AllocateSyncpoint(false);
@@ -95,24 +96,24 @@ NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, De
     offset += SliceVectors(data, syncpt_increments, params.syncpoint_count, offset);
     offset += SliceVectors(data, fence_thresholds, params.fence_count, offset);
 
-    auto& gpu = system.GPU();
     auto* session = core.GetSession(sessions[fd]);
 
-    if (gpu.UseNvdec()) {
-        for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
-            const SyncptIncr& syncpt_incr = syncpt_increments[i];
-            fence_thresholds[i] =
-                syncpoint_manager.IncrementSyncpointMaxExt(syncpt_incr.id, syncpt_incr.increments);
-        }
+    for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
+        const SyncptIncr& syncpt_incr = syncpt_increments[i];
+        fence_thresholds[i] =
+            syncpoint_manager.IncrementSyncpointMaxExt(syncpt_incr.id, syncpt_incr.increments);
     }
+
     for (const auto& cmd_buffer : command_buffers) {
         const auto object = nvmap.GetHandle(cmd_buffer.memory_id);
         ASSERT_OR_EXECUTE(object, return NvResult::InvalidState;);
-        Tegra::ChCommandHeaderList cmdlist(cmd_buffer.word_count);
-        session->process->GetMemory().ReadBlock(object->address + cmd_buffer.offset, cmdlist.data(),
-                                                cmdlist.size() * sizeof(u32));
-        gpu.PushCommandBuffer(core.Host1xDeviceFile().fd_to_id[fd], cmdlist);
+        Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader,
+                                     Core::Memory::GuestMemoryFlags::SafeRead>
+            cmdlist(session->process->GetMemory(), object->address + cmd_buffer.offset,
+                    cmd_buffer.word_count);
+        host1x.PushEntries(fd, std::move(cmdlist));
     }
+
     // Some games expect command_buffers to be written back
     offset = 0;
     offset += WriteVectors(data, command_buffers, offset);

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

@@ -119,6 +119,7 @@ protected:
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;
 
+    Tegra::Host1x::Host1x& host1x;
     u32 channel_syncpoint;
     s32_le nvmap_fd{};
     u32_le submit_timeout{};

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

@@ -7,6 +7,7 @@
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_vic.h"
+#include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
@@ -21,13 +22,8 @@ NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
-        case 0x1: {
-            auto& host1x_file = core.Host1xDeviceFile();
-            if (!host1x_file.fd_to_id.contains(fd)) {
-                host1x_file.fd_to_id[fd] = host1x_file.vic_next_id++;
-            }
+        case 0x1:
             return WrapFixedVariable(this, &nvhost_vic::Submit, input, output, fd);
-        }
         case 0x2:
             return WrapFixed(this, &nvhost_vic::GetSyncpoint, input, output);
         case 0x3:
@@ -70,14 +66,11 @@ NvResult nvhost_vic::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
 
 void nvhost_vic::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     sessions[fd] = session_id;
+    host1x.StartDevice(fd, Tegra::Host1x::ChannelType::VIC, channel_syncpoint);
 }
 
 void nvhost_vic::OnClose(DeviceFD fd) {
-    auto& host1x_file = core.Host1xDeviceFile();
-    const auto iter = host1x_file.fd_to_id.find(fd);
-    if (iter != host1x_file.fd_to_id.end()) {
-        system.GPU().ClearCdmaInstance(iter->second);
-    }
+    host1x.StopDevice(fd, Tegra::Host1x::ChannelType::VIC);
     sessions.erase(fd);
 }
 

src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp

@@ -14,24 +14,20 @@
 #include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
 #include "core/hle/service/vi/vi_results.h"
+#include "video_core/gpu.h"
+#include "video_core/host1x/host1x.h"
 
 namespace Service::Nvnflinger {
 
 namespace {
 
-Result AllocateIoForProcessAddressSpace(Common::ProcessAddress* out_map_address,
-                                        std::unique_ptr<Kernel::KPageGroup>* out_page_group,
-                                        Core::System& system, u32 size) {
+Result AllocateSharedBufferMemory(std::unique_ptr<Kernel::KPageGroup>* out_page_group,
+                                  Core::System& system, u32 size) {
     using Core::Memory::YUZU_PAGESIZE;
 
     // Allocate memory for the system shared buffer.
-    // FIXME: Because the gmmu can only point to cpu addresses, we need
-    //        to map this in the application space to allow it to be used.
-    // FIXME: Add proper smmu emulation.
     // FIXME: This memory belongs to vi's .data section.
     auto& kernel = system.Kernel();
-    auto* process = system.ApplicationProcess();
-    auto& page_table = process->GetPageTable();
 
     // Hold a temporary page group reference while we try to map it.
     auto pg = std::make_unique<Kernel::KPageGroup>(
@@ -43,6 +39,30 @@ Result AllocateIoForProcessAddressSpace(Common::ProcessAddress* out_map_address,
         Kernel::KMemoryManager::EncodeOption(Kernel::KMemoryManager::Pool::Secure,
                                              Kernel::KMemoryManager::Direction::FromBack)));
 
+    // Fill the output data with red.
+    for (auto& block : *pg) {
+        u32* start = system.DeviceMemory().GetPointer<u32>(block.GetAddress());
+        u32* end = system.DeviceMemory().GetPointer<u32>(block.GetAddress() + block.GetSize());
+
+        for (; start < end; start++) {
+            *start = 0xFF0000FF;
+        }
+    }
+
+    // Return the mapped page group.
+    *out_page_group = std::move(pg);
+
+    // We succeeded.
+    R_SUCCEED();
+}
+
+Result MapSharedBufferIntoProcessAddressSpace(Common::ProcessAddress* out_map_address,
+                                              std::unique_ptr<Kernel::KPageGroup>& pg,
+                                              Kernel::KProcess* process, Core::System& system) {
+    using Core::Memory::YUZU_PAGESIZE;
+
+    auto& page_table = process->GetPageTable();
+
     // Get bounds of where mapping is possible.
     const VAddr alias_code_begin = GetInteger(page_table.GetAliasCodeRegionStart());
     const VAddr alias_code_size = page_table.GetAliasCodeRegionSize() / YUZU_PAGESIZE;
@@ -64,9 +84,6 @@ Result AllocateIoForProcessAddressSpace(Common::ProcessAddress* out_map_address,
     // Return failure, if necessary
     R_UNLESS(i < 64, res);
 
-    // Return the mapped page group.
-    *out_page_group = std::move(pg);
-
     // We succeeded.
     R_SUCCEED();
 }
@@ -135,6 +152,13 @@ Result AllocateHandleForBuffer(u32* out_handle, Nvidia::Module& nvdrv, Nvidia::D
     R_RETURN(AllocNvMapHandle(*nvmap, *out_handle, buffer, size, nvmap_fd));
 }
 
+void FreeHandle(u32 handle, Nvidia::Module& nvdrv, Nvidia::DeviceFD nvmap_fd) {
+    auto nvmap = nvdrv.GetDevice<Nvidia::Devices::nvmap>(nvmap_fd);
+    ASSERT(nvmap != nullptr);
+
+    R_ASSERT(FreeNvMapHandle(*nvmap, handle, nvmap_fd));
+}
+
 constexpr auto SharedBufferBlockLinearFormat = android::PixelFormat::Rgba8888;
 constexpr u32 SharedBufferBlockLinearBpp = 4;
 
@@ -186,53 +210,97 @@ FbShareBufferManager::FbShareBufferManager(Core::System& system, Nvnflinger& fli
 
 FbShareBufferManager::~FbShareBufferManager() = default;
 
-Result FbShareBufferManager::Initialize(u64* out_buffer_id, u64* out_layer_id, u64 display_id) {
+Result FbShareBufferManager::Initialize(Kernel::KProcess* owner_process, u64* out_buffer_id,
+                                        u64* out_layer_handle, u64 display_id,
+                                        LayerBlending blending) {
     std::scoped_lock lk{m_guard};
 
-    // Ensure we have not already created a buffer.
-    R_UNLESS(m_buffer_id == 0, VI::ResultOperationFailed);
+    // Ensure we haven't already created.
+    const u64 aruid = owner_process->GetProcessId();
+    R_UNLESS(!m_sessions.contains(aruid), VI::ResultPermissionDenied);
 
-    // Allocate memory and space for the shared buffer.
-    Common::ProcessAddress map_address;
-    R_TRY(AllocateIoForProcessAddressSpace(std::addressof(map_address),
-                                           std::addressof(m_buffer_page_group), m_system,
-                                           SharedBufferSize));
+    // Allocate memory for the shared buffer if needed.
+    if (!m_buffer_page_group) {
+        R_TRY(AllocateSharedBufferMemory(std::addressof(m_buffer_page_group), m_system,
+                                         SharedBufferSize));
+
+        // Record buffer id.
+        m_buffer_id = m_next_buffer_id++;
+
+        // Record display id.
+        m_display_id = display_id;
+    }
+
+    // Map into process.
+    Common::ProcessAddress map_address{};
+    R_TRY(MapSharedBufferIntoProcessAddressSpace(std::addressof(map_address), m_buffer_page_group,
+                                                 owner_process, m_system));
+
+    // Create new session.
+    auto [it, was_emplaced] = m_sessions.emplace(aruid, FbShareSession{});
+    auto& session = it->second;
 
     auto& container = m_nvdrv->GetContainer();
-    m_session_id = container.OpenSession(m_system.ApplicationProcess());
-    m_nvmap_fd = m_nvdrv->Open("/dev/nvmap", m_session_id);
+    session.session_id = container.OpenSession(owner_process);
+    session.nvmap_fd = m_nvdrv->Open("/dev/nvmap", session.session_id);
 
     // Create an nvmap handle for the buffer and assign the memory to it.
-    R_TRY(AllocateHandleForBuffer(std::addressof(m_buffer_nvmap_handle), *m_nvdrv, m_nvmap_fd,
-                                  map_address, SharedBufferSize));
-
-    // Record the display id.
-    m_display_id = display_id;
+    R_TRY(AllocateHandleForBuffer(std::addressof(session.buffer_nvmap_handle), *m_nvdrv,
+                                  session.nvmap_fd, map_address, SharedBufferSize));
 
     // Create and open a layer for the display.
-    m_layer_id = m_flinger.CreateLayer(m_display_id).value();
-    m_flinger.OpenLayer(m_layer_id);
-
-    // Set up the buffer.
-    m_buffer_id = m_next_buffer_id++;
+    session.layer_id = m_flinger.CreateLayer(m_display_id, blending).value();
+    m_flinger.OpenLayer(session.layer_id);
 
     // Get the layer.
-    VI::Layer* layer = m_flinger.FindLayer(m_display_id, m_layer_id);
+    VI::Layer* layer = m_flinger.FindLayer(m_display_id, session.layer_id);
     ASSERT(layer != nullptr);
 
     // Get the producer and set preallocated buffers.
     auto& producer = layer->GetBufferQueue();
-    MakeGraphicBuffer(producer, 0, m_buffer_nvmap_handle);
-    MakeGraphicBuffer(producer, 1, m_buffer_nvmap_handle);
+    MakeGraphicBuffer(producer, 0, session.buffer_nvmap_handle);
+    MakeGraphicBuffer(producer, 1, session.buffer_nvmap_handle);
 
     // Assign outputs.
     *out_buffer_id = m_buffer_id;
-    *out_layer_id = m_layer_id;
+    *out_layer_handle = session.layer_id;
 
     // We succeeded.
     R_SUCCEED();
 }
 
+void FbShareBufferManager::Finalize(Kernel::KProcess* owner_process) {
+    std::scoped_lock lk{m_guard};
+
+    if (m_buffer_id == 0) {
+        return;
+    }
+
+    const u64 aruid = owner_process->GetProcessId();
+    const auto it = m_sessions.find(aruid);
+    if (it == m_sessions.end()) {
+        return;
+    }
+
+    auto& session = it->second;
+
+    // Destroy the layer.
+    m_flinger.DestroyLayer(session.layer_id);
+
+    // Close nvmap handle.
+    FreeHandle(session.buffer_nvmap_handle, *m_nvdrv, session.nvmap_fd);
+
+    // Close nvmap device.
+    m_nvdrv->Close(session.nvmap_fd);
+
+    // Close session.
+    auto& container = m_nvdrv->GetContainer();
+    container.CloseSession(session.session_id);
+
+    // Erase.
+    m_sessions.erase(it);
+}
+
 Result FbShareBufferManager::GetSharedBufferMemoryHandleId(u64* out_buffer_size,
                                                            s32* out_nvmap_handle,
                                                            SharedMemoryPoolLayout* out_pool_layout,
@@ -242,17 +310,18 @@ Result FbShareBufferManager::GetSharedBufferMemoryHandleId(u64* out_buffer_size,
 
     R_UNLESS(m_buffer_id > 0, VI::ResultNotFound);
     R_UNLESS(buffer_id == m_buffer_id, VI::ResultNotFound);
+    R_UNLESS(m_sessions.contains(applet_resource_user_id), VI::ResultNotFound);
 
     *out_pool_layout = SharedBufferPoolLayout;
     *out_buffer_size = SharedBufferSize;
-    *out_nvmap_handle = m_buffer_nvmap_handle;
+    *out_nvmap_handle = m_sessions[applet_resource_user_id].buffer_nvmap_handle;
 
     R_SUCCEED();
 }
 
 Result FbShareBufferManager::GetLayerFromId(VI::Layer** out_layer, u64 layer_id) {
     // Ensure the layer id is valid.
-    R_UNLESS(m_layer_id > 0 && layer_id == m_layer_id, VI::ResultNotFound);
+    R_UNLESS(layer_id > 0, VI::ResultNotFound);
 
     // Get the layer.
     VI::Layer* layer = m_flinger.FindLayer(m_display_id, layer_id);
@@ -309,6 +378,10 @@ Result FbShareBufferManager::PresentSharedFrameBuffer(android::Fence fence,
                  android::Status::NoError,
              VI::ResultOperationFailed);
 
+    ON_RESULT_FAILURE {
+        producer.CancelBuffer(static_cast<s32>(slot), fence);
+    };
+
     // Queue the buffer to the producer.
     android::QueueBufferInput input{};
     android::QueueBufferOutput output{};
@@ -342,4 +415,33 @@ Result FbShareBufferManager::GetSharedFrameBufferAcquirableEvent(Kernel::KReadab
     R_SUCCEED();
 }
 
+Result FbShareBufferManager::WriteAppletCaptureBuffer(bool* out_was_written, s32* out_layer_index) {
+    std::vector<u8> capture_buffer(m_system.GPU().GetAppletCaptureBuffer());
+    Common::ScratchBuffer<u32> scratch;
+
+    // TODO: this could be optimized
+    s64 e = -1280 * 768 * 4;
+    for (auto& block : *m_buffer_page_group) {
+        u8* start = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress());
+        u8* end = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress() + block.GetSize());
+
+        for (; start < end; start++) {
+            *start = 0;
+
+            if (e >= 0 && e < static_cast<s64>(capture_buffer.size())) {
+                *start = capture_buffer[e];
+            }
+            e++;
+        }
+
+        m_system.GPU().Host1x().MemoryManager().ApplyOpOnPointer(start, scratch, [&](DAddr addr) {
+            m_system.GPU().InvalidateRegion(addr, end - start);
+        });
+    }
+
+    *out_was_written = true;
+    *out_layer_index = 1;
+    R_SUCCEED();
+}
+
 } // namespace Service::Nvnflinger

src/core/hle/service/nvnflinger/fb_share_buffer_manager.h

@@ -3,9 +3,12 @@
 
 #pragma once
 
+#include <map>
+
 #include "common/math_util.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/nvdata.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
 #include "core/hle/service/nvnflinger/nvnflinger.h"
 #include "core/hle/service/nvnflinger/ui/fence.h"
 
@@ -29,13 +32,18 @@ struct SharedMemoryPoolLayout {
 };
 static_assert(sizeof(SharedMemoryPoolLayout) == 0x188, "SharedMemoryPoolLayout has wrong size");
 
+struct FbShareSession;
+
 class FbShareBufferManager final {
 public:
     explicit FbShareBufferManager(Core::System& system, Nvnflinger& flinger,
                                   std::shared_ptr<Nvidia::Module> nvdrv);
     ~FbShareBufferManager();
 
-    Result Initialize(u64* out_buffer_id, u64* out_layer_handle, u64 display_id);
+    Result Initialize(Kernel::KProcess* owner_process, u64* out_buffer_id, u64* out_layer_handle,
+                      u64 display_id, LayerBlending blending);
+    void Finalize(Kernel::KProcess* owner_process);
+
     Result GetSharedBufferMemoryHandleId(u64* out_buffer_size, s32* out_nvmap_handle,
                                          SharedMemoryPoolLayout* out_pool_layout, u64 buffer_id,
                                          u64 applet_resource_user_id);
@@ -45,6 +53,8 @@ public:
                                     u32 transform, s32 swap_interval, u64 layer_id, s64 slot);
     Result GetSharedFrameBufferAcquirableEvent(Kernel::KReadableEvent** out_event, u64 layer_id);
 
+    Result WriteAppletCaptureBuffer(bool* out_was_written, s32* out_layer_index);
+
 private:
     Result GetLayerFromId(VI::Layer** out_layer, u64 layer_id);
 
@@ -52,11 +62,8 @@ private:
     u64 m_next_buffer_id = 1;
     u64 m_display_id = 0;
     u64 m_buffer_id = 0;
-    u64 m_layer_id = 0;
-    u32 m_buffer_nvmap_handle = 0;
     SharedMemoryPoolLayout m_pool_layout = {};
-    Nvidia::DeviceFD m_nvmap_fd = {};
-    Nvidia::NvCore::SessionId m_session_id = {};
+    std::map<u64, FbShareSession> m_sessions;
     std::unique_ptr<Kernel::KPageGroup> m_buffer_page_group;
 
     std::mutex m_guard;
@@ -65,4 +72,11 @@ private:
     std::shared_ptr<Nvidia::Module> m_nvdrv;
 };
 
+struct FbShareSession {
+    Nvidia::DeviceFD nvmap_fd = {};
+    Nvidia::NvCore::SessionId session_id = {};
+    u64 layer_id = {};
+    u32 buffer_nvmap_handle = 0;
+};
+
 } // namespace Service::Nvnflinger

src/core/hle/service/nvnflinger/hardware_composer.cpp

@@ -86,6 +86,7 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, VI::Display& display,
             .height = igbp_buffer.Height(),
             .stride = igbp_buffer.Stride(),
             .z_index = 0,
+            .blending = layer.GetBlending(),
             .transform = static_cast<android::BufferTransformFlags>(item.transform),
             .crop_rect = item.crop,
             .acquire_fence = item.fence,

src/core/hle/service/nvnflinger/hwc_layer.h

@@ -11,6 +11,18 @@
 
 namespace Service::Nvnflinger {
 
+// hwc_layer_t::blending values
+enum class LayerBlending : u32 {
+    // No blending
+    None = 0x100,
+
+    // ONE / ONE_MINUS_SRC_ALPHA
+    Premultiplied = 0x105,
+
+    // SRC_ALPHA / ONE_MINUS_SRC_ALPHA
+    Coverage = 0x405,
+};
+
 struct HwcLayer {
     u32 buffer_handle;
     u32 offset;
@@ -19,6 +31,7 @@ struct HwcLayer {
     u32 height;
     u32 stride;
     s32 z_index;
+    LayerBlending blending;
     android::BufferTransformFlags transform;
     Common::Rectangle<int> crop_rect;
     android::Fence acquire_fence;

src/core/hle/service/nvnflinger/nvnflinger.cpp

@@ -157,7 +157,7 @@ bool Nvnflinger::CloseDisplay(u64 display_id) {
     return true;
 }
 
-std::optional<u64> Nvnflinger::CreateLayer(u64 display_id) {
+std::optional<u64> Nvnflinger::CreateLayer(u64 display_id, LayerBlending blending) {
     const auto lock_guard = Lock();
     auto* const display = FindDisplay(display_id);
 
@@ -166,13 +166,14 @@ std::optional<u64> Nvnflinger::CreateLayer(u64 display_id) {
     }
 
     const u64 layer_id = next_layer_id++;
-    CreateLayerAtId(*display, layer_id);
+    CreateLayerAtId(*display, layer_id, blending);
     return layer_id;
 }
 
-void Nvnflinger::CreateLayerAtId(VI::Display& display, u64 layer_id) {
+void Nvnflinger::CreateLayerAtId(VI::Display& display, u64 layer_id, LayerBlending blending) {
     const auto buffer_id = next_buffer_queue_id++;
     display.CreateLayer(layer_id, buffer_id, nvdrv->container);
+    display.FindLayer(layer_id)->SetBlending(blending);
 }
 
 bool Nvnflinger::OpenLayer(u64 layer_id) {

src/core/hle/service/nvnflinger/nvnflinger.h

@@ -15,6 +15,7 @@
 #include "common/thread.h"
 #include "core/hle/result.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
 
 namespace Common {
 class Event;
@@ -72,7 +73,8 @@ public:
     /// Creates a layer on the specified display and returns the layer ID.
     ///
     /// If an invalid display ID is specified, then an empty optional is returned.
-    [[nodiscard]] std::optional<u64> CreateLayer(u64 display_id);
+    [[nodiscard]] std::optional<u64> CreateLayer(u64 display_id,
+                                                 LayerBlending blending = LayerBlending::None);
 
     /// Opens a layer on all displays for the given layer ID.
     bool OpenLayer(u64 layer_id);
@@ -128,7 +130,7 @@ private:
     [[nodiscard]] VI::Layer* FindLayer(u64 display_id, u64 layer_id);
 
     /// Creates a layer with the specified layer ID in the desired display.
-    void CreateLayerAtId(VI::Display& display, u64 layer_id);
+    void CreateLayerAtId(VI::Display& display, u64 layer_id, LayerBlending blending);
 
     void SplitVSync(std::stop_token stop_token);
 

src/core/hle/service/os/event.cpp

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/service/event.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/os/event.h"
 
 namespace Service {
 

src/core/hle/service/os/multi_wait.cpp

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/k_hardware_timer.h"
+#include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/svc_common.h"
+#include "core/hle/service/os/multi_wait.h"
+
+namespace Service {
+
+MultiWait::MultiWait() = default;
+MultiWait::~MultiWait() = default;
+
+MultiWaitHolder* MultiWait::WaitAny(Kernel::KernelCore& kernel) {
+    return this->TimedWaitImpl(kernel, -1);
+}
+
+MultiWaitHolder* MultiWait::TryWaitAny(Kernel::KernelCore& kernel) {
+    return this->TimedWaitImpl(kernel, 0);
+}
+
+MultiWaitHolder* MultiWait::TimedWaitAny(Kernel::KernelCore& kernel, s64 timeout_ns) {
+    return this->TimedWaitImpl(kernel, kernel.HardwareTimer().GetTick() + timeout_ns);
+}
+
+MultiWaitHolder* MultiWait::TimedWaitImpl(Kernel::KernelCore& kernel, s64 timeout_tick) {
+    std::array<MultiWaitHolder*, Kernel::Svc::ArgumentHandleCountMax> holders{};
+    std::array<Kernel::KSynchronizationObject*, Kernel::Svc::ArgumentHandleCountMax> objects{};
+
+    s32 out_index = -1;
+    s32 num_objects = 0;
+
+    for (auto it = m_wait_list.begin(); it != m_wait_list.end(); it++) {
+        ASSERT(num_objects < Kernel::Svc::ArgumentHandleCountMax);
+        holders[num_objects] = std::addressof(*it);
+        objects[num_objects] = it->GetNativeHandle();
+        num_objects++;
+    }
+
+    Kernel::KSynchronizationObject::Wait(kernel, std::addressof(out_index), objects.data(),
+                                         num_objects, timeout_tick);
+
+    if (out_index == -1) {
+        return nullptr;
+    } else {
+        return holders[out_index];
+    }
+}
+
+void MultiWait::MoveAll(MultiWait* other) {
+    while (!other->m_wait_list.empty()) {
+        MultiWaitHolder& holder = other->m_wait_list.front();
+        holder.UnlinkFromMultiWait();
+        holder.LinkToMultiWait(this);
+    }
+}
+
+} // namespace Service

src/core/hle/service/os/multi_wait.h

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/os/multi_wait_holder.h"
+
+namespace Kernel {
+class KernelCore;
+}
+
+namespace Service {
+
+class MultiWait final {
+public:
+    explicit MultiWait();
+    ~MultiWait();
+
+public:
+    MultiWaitHolder* WaitAny(Kernel::KernelCore& kernel);
+    MultiWaitHolder* TryWaitAny(Kernel::KernelCore& kernel);
+    MultiWaitHolder* TimedWaitAny(Kernel::KernelCore& kernel, s64 timeout_ns);
+    // TODO: SdkReplyAndReceive?
+
+    void MoveAll(MultiWait* other);
+
+private:
+    MultiWaitHolder* TimedWaitImpl(Kernel::KernelCore& kernel, s64 timeout_tick);
+
+private:
+    friend class MultiWaitHolder;
+    using ListType = Common::IntrusiveListMemberTraits<&MultiWaitHolder::m_list_node>::ListType;
+    ListType m_wait_list{};
+};
+
+} // namespace Service

src/core/hle/service/os/multi_wait_holder.cpp

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/os/multi_wait.h"
+#include "core/hle/service/os/multi_wait_holder.h"
+
+namespace Service {
+
+void MultiWaitHolder::LinkToMultiWait(MultiWait* multi_wait) {
+    if (m_multi_wait != nullptr) {
+        UNREACHABLE();
+    }
+
+    m_multi_wait = multi_wait;
+    m_multi_wait->m_wait_list.push_back(*this);
+}
+
+void MultiWaitHolder::UnlinkFromMultiWait() {
+    if (m_multi_wait) {
+        m_multi_wait->m_wait_list.erase(m_multi_wait->m_wait_list.iterator_to(*this));
+        m_multi_wait = nullptr;
+    }
+}
+
+} // namespace Service

src/core/hle/service/os/multi_wait_holder.h

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/intrusive_list.h"
+
+namespace Kernel {
+class KSynchronizationObject;
+} // namespace Kernel
+
+namespace Service {
+
+class MultiWait;
+
+class MultiWaitHolder {
+public:
+    explicit MultiWaitHolder(Kernel::KSynchronizationObject* native_handle)
+        : m_native_handle(native_handle) {}
+
+    void LinkToMultiWait(MultiWait* multi_wait);
+    void UnlinkFromMultiWait();
+
+    void SetUserData(uintptr_t user_data) {
+        m_user_data = user_data;
+    }
+
+    uintptr_t GetUserData() const {
+        return m_user_data;
+    }
+
+    Kernel::KSynchronizationObject* GetNativeHandle() const {
+        return m_native_handle;
+    }
+
+private:
+    friend class MultiWait;
+    Common::IntrusiveListNode m_list_node{};
+    MultiWait* m_multi_wait{};
+    Kernel::KSynchronizationObject* m_native_handle{};
+    uintptr_t m_user_data{};
+};
+
+} // namespace Service

src/core/hle/service/os/multi_wait_utils.h

@@ -0,0 +1,109 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/os/multi_wait.h"
+
+namespace Service {
+
+namespace impl {
+
+class AutoMultiWaitHolder {
+private:
+    MultiWaitHolder m_holder;
+
+public:
+    template <typename T>
+    explicit AutoMultiWaitHolder(MultiWait* multi_wait, T&& arg) : m_holder(arg) {
+        m_holder.LinkToMultiWait(multi_wait);
+    }
+
+    ~AutoMultiWaitHolder() {
+        m_holder.UnlinkFromMultiWait();
+    }
+
+    std::pair<MultiWaitHolder*, int> ConvertResult(const std::pair<MultiWaitHolder*, int> result,
+                                                   int index) {
+        if (result.first == std::addressof(m_holder)) {
+            return std::make_pair(static_cast<MultiWaitHolder*>(nullptr), index);
+        } else {
+            return result;
+        }
+    }
+};
+
+using WaitAnyFunction = decltype(&MultiWait::WaitAny);
+
+inline std::pair<MultiWaitHolder*, int> WaitAnyImpl(Kernel::KernelCore& kernel,
+                                                    MultiWait* multi_wait, WaitAnyFunction func,
+                                                    int) {
+    return std::pair<MultiWaitHolder*, int>((multi_wait->*func)(kernel), -1);
+}
+
+template <typename T, typename... Args>
+inline std::pair<MultiWaitHolder*, int> WaitAnyImpl(Kernel::KernelCore& kernel,
+                                                    MultiWait* multi_wait, WaitAnyFunction func,
+                                                    int index, T&& x, Args&&... args) {
+    AutoMultiWaitHolder holder(multi_wait, std::forward<T>(x));
+    return holder.ConvertResult(
+        WaitAnyImpl(kernel, multi_wait, func, index + 1, std::forward<Args>(args)...), index);
+}
+
+template <typename... Args>
+inline std::pair<MultiWaitHolder*, int> WaitAnyImpl(Kernel::KernelCore& kernel,
+                                                    MultiWait* multi_wait, WaitAnyFunction func,
+                                                    Args&&... args) {
+    return WaitAnyImpl(kernel, multi_wait, func, 0, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+inline std::pair<MultiWaitHolder*, int> WaitAnyImpl(Kernel::KernelCore& kernel,
+                                                    WaitAnyFunction func, Args&&... args) {
+    MultiWait temp_multi_wait;
+    return WaitAnyImpl(kernel, std::addressof(temp_multi_wait), func, 0,
+                       std::forward<Args>(args)...);
+}
+
+class NotBoolButInt {
+public:
+    constexpr NotBoolButInt(int v) : m_value(v) {}
+    constexpr operator int() const {
+        return m_value;
+    }
+    explicit operator bool() const = delete;
+
+private:
+    int m_value;
+};
+
+} // namespace impl
+
+template <typename... Args>
+    requires(sizeof...(Args) > 0)
+inline std::pair<MultiWaitHolder*, int> WaitAny(Kernel::KernelCore& kernel, MultiWait* multi_wait,
+                                                Args&&... args) {
+    return impl::WaitAnyImpl(kernel, &MultiWait::WaitAny, multi_wait, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+    requires(sizeof...(Args) > 0)
+inline int WaitAny(Kernel::KernelCore& kernel, Args&&... args) {
+    return impl::WaitAnyImpl(kernel, &MultiWait::WaitAny, std::forward<Args>(args)...).second;
+}
+
+template <typename... Args>
+    requires(sizeof...(Args) > 0)
+inline std::pair<MultiWaitHolder*, int> TryWaitAny(Kernel::KernelCore& kernel,
+                                                   MultiWait* multi_wait, Args&&... args) {
+    return impl::WaitAnyImpl(kernel, &MultiWait::TryWaitAny, multi_wait,
+                             std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+    requires(sizeof...(Args) > 0)
+inline impl::NotBoolButInt TryWaitAny(Kernel::KernelCore& kernel, Args&&... args) {
+    return impl::WaitAnyImpl(kernel, &MultiWait::TryWaitAny, std::forward<Args>(args)...).second;
+}
+
+} // namespace Service

src/core/hle/service/os/mutex.cpp

@@ -4,7 +4,7 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_synchronization_object.h"
-#include "core/hle/service/mutex.h"
+#include "core/hle/service/os/mutex.h"
 
 namespace Service {
 

src/core/hle/service/server_manager.cpp

@@ -20,50 +20,91 @@
 
 namespace Service {
 
-constexpr size_t MaximumWaitObjects = 0x40;
-
-enum HandleType {
+enum class UserDataTag {
     Port,
     Session,
     DeferEvent,
-    Event,
 };
 
-ServerManager::ServerManager(Core::System& system) : m_system{system}, m_serve_mutex{system} {
+class Port : public MultiWaitHolder, public Common::IntrusiveListBaseNode<Port> {
+public:
+    explicit Port(Kernel::KServerPort* server_port, SessionRequestHandlerFactory&& handler_factory)
+        : MultiWaitHolder(server_port), m_handler_factory(std::move(handler_factory)) {
+        this->SetUserData(static_cast<uintptr_t>(UserDataTag::Port));
+    }
+
+    ~Port() {
+        this->GetNativeHandle()->Close();
+    }
+
+    SessionRequestHandlerPtr CreateHandler() {
+        return m_handler_factory();
+    }
+
+private:
+    const SessionRequestHandlerFactory m_handler_factory;
+};
+
+class Session : public MultiWaitHolder, public Common::IntrusiveListBaseNode<Session> {
+public:
+    explicit Session(Kernel::KServerSession* server_session,
+                     std::shared_ptr<SessionRequestManager>&& manager)
+        : MultiWaitHolder(server_session), m_manager(std::move(manager)) {
+        this->SetUserData(static_cast<uintptr_t>(UserDataTag::Session));
+    }
+
+    ~Session() {
+        this->GetNativeHandle()->Close();
+    }
+
+    std::shared_ptr<SessionRequestManager>& GetManager() {
+        return m_manager;
+    }
+
+    std::shared_ptr<HLERequestContext>& GetContext() {
+        return m_context;
+    }
+
+private:
+    std::shared_ptr<SessionRequestManager> m_manager;
+    std::shared_ptr<HLERequestContext> m_context;
+};
+
+ServerManager::ServerManager(Core::System& system) : m_system{system}, m_selection_mutex{system} {
     // Initialize event.
-    m_event = Kernel::KEvent::Create(system.Kernel());
-    m_event->Initialize(nullptr);
+    m_wakeup_event = Kernel::KEvent::Create(system.Kernel());
+    m_wakeup_event->Initialize(nullptr);
 
     // Register event.
-    Kernel::KEvent::Register(system.Kernel(), m_event);
+    Kernel::KEvent::Register(system.Kernel(), m_wakeup_event);
+
+    // Link to holder.
+    m_wakeup_holder.emplace(std::addressof(m_wakeup_event->GetReadableEvent()));
+    m_wakeup_holder->LinkToMultiWait(std::addressof(m_deferred_list));
 }
 
 ServerManager::~ServerManager() {
     // Signal stop.
     m_stop_source.request_stop();
-    m_event->Signal();
+    m_wakeup_event->Signal();
 
     // Wait for processing to stop.
     m_stopped.Wait();
     m_threads.clear();
 
-    // Clean up server ports.
-    for (const auto& [port, handler] : m_ports) {
-        port->Close();
+    // Clean up ports.
+    for (auto it = m_servers.begin(); it != m_servers.end(); it = m_servers.erase(it)) {
+        delete std::addressof(*it);
     }
 
     // Clean up sessions.
-    for (const auto& [session, manager] : m_sessions) {
-        session->Close();
+    for (auto it = m_sessions.begin(); it != m_sessions.end(); it = m_sessions.erase(it)) {
+        delete std::addressof(*it);
     }
 
-    for (const auto& request : m_deferrals) {
-        request.session->Close();
-    }
-
-    // Close event.
-    m_event->GetReadableEvent().Close();
-    m_event->Close();
+    // Close wakeup event.
+    m_wakeup_event->GetReadableEvent().Close();
+    m_wakeup_event->Close();
 
     if (m_deferral_event) {
         m_deferral_event->GetReadableEvent().Close();
@@ -75,19 +116,19 @@ void ServerManager::RunServer(std::unique_ptr<ServerManager>&& server_manager) {
     server_manager->m_system.RunServer(std::move(server_manager));
 }
 
-Result ServerManager::RegisterSession(Kernel::KServerSession* session,
+Result ServerManager::RegisterSession(Kernel::KServerSession* server_session,
                                       std::shared_ptr<SessionRequestManager> manager) {
-    ASSERT(m_sessions.size() + m_ports.size() < MaximumWaitObjects);
-
     // We are taking ownership of the server session, so don't open it.
+    auto* session = new Session(server_session, std::move(manager));
+
     // Begin tracking the server session.
     {
-        std::scoped_lock ll{m_list_mutex};
-        m_sessions.emplace(session, std::move(manager));
+        std::scoped_lock ll{m_deferred_list_mutex};
+        m_sessions.push_back(*session);
     }
 
-    // Signal the wakeup event.
-    m_event->Signal();
+    // Register to wait on the session.
+    this->LinkToDeferredList(session);
 
     R_SUCCEED();
 }
@@ -95,21 +136,22 @@ Result ServerManager::RegisterSession(Kernel::KServerSession* session,
 Result ServerManager::RegisterNamedService(const std::string& service_name,
                                            SessionRequestHandlerFactory&& handler_factory,
                                            u32 max_sessions) {
-    ASSERT(m_sessions.size() + m_ports.size() < MaximumWaitObjects);
-
     // Add the new server to sm: and get the moved server port.
     Kernel::KServerPort* server_port{};
     R_ASSERT(m_system.ServiceManager().RegisterService(std::addressof(server_port), service_name,
                                                        max_sessions, handler_factory));
 
+    // We are taking ownership of the server port, so don't open it.
+    auto* server = new Port(server_port, std::move(handler_factory));
+
     // Begin tracking the server port.
     {
-        std::scoped_lock ll{m_list_mutex};
-        m_ports.emplace(server_port, std::move(handler_factory));
+        std::scoped_lock ll{m_deferred_list_mutex};
+        m_servers.push_back(*server);
     }
 
-    // Signal the wakeup event.
-    m_event->Signal();
+    // Register to wait on the server port.
+    this->LinkToDeferredList(server);
 
     R_SUCCEED();
 }
@@ -127,8 +169,6 @@ Result ServerManager::RegisterNamedService(const std::string& service_name,
 Result ServerManager::ManageNamedPort(const std::string& service_name,
                                       SessionRequestHandlerFactory&& handler_factory,
                                       u32 max_sessions) {
-    ASSERT(m_sessions.size() + m_ports.size() < MaximumWaitObjects);
-
     // Create a new port.
     auto* port = Kernel::KPort::Create(m_system.Kernel());
     port->Initialize(max_sessions, false, 0);
@@ -149,12 +189,18 @@ Result ServerManager::ManageNamedPort(const std::string& service_name,
     // Open a new reference to the server port.
     port->GetServerPort().Open();
 
-    // Begin tracking the server port.
+    // Transfer ownership into a new port object.
+    auto* server = new Port(std::addressof(port->GetServerPort()), std::move(handler_factory));
+
+    // Begin tracking the port.
     {
-        std::scoped_lock ll{m_list_mutex};
-        m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler_factory));
+        std::scoped_lock ll{m_deferred_list_mutex};
+        m_servers.push_back(*server);
     }
 
+    // Register to wait on the port.
+    this->LinkToDeferredList(server);
+
     // We succeeded.
     R_SUCCEED();
 }
@@ -173,6 +219,11 @@ Result ServerManager::ManageDeferral(Kernel::KEvent** out_event) {
     // Set the output.
     *out_event = m_deferral_event;
 
+    // Register to wait on the event.
+    m_deferral_holder.emplace(std::addressof(m_deferral_event->GetReadableEvent()));
+    m_deferral_holder->SetUserData(static_cast<uintptr_t>(UserDataTag::DeferEvent));
+    this->LinkToDeferredList(std::addressof(*m_deferral_holder));
+
     // We succeeded.
     R_SUCCEED();
 }
@@ -191,270 +242,185 @@ Result ServerManager::LoopProcess() {
     R_RETURN(this->LoopProcessImpl());
 }
 
+void ServerManager::LinkToDeferredList(MultiWaitHolder* holder) {
+    // Link.
+    {
+        std::scoped_lock lk{m_deferred_list_mutex};
+        holder->LinkToMultiWait(std::addressof(m_deferred_list));
+    }
+
+    // Signal the wakeup event.
+    m_wakeup_event->Signal();
+}
+
+void ServerManager::LinkDeferred() {
+    std::scoped_lock lk{m_deferred_list_mutex};
+    m_multi_wait.MoveAll(std::addressof(m_deferred_list));
+}
+
+MultiWaitHolder* ServerManager::WaitSignaled() {
+    // Ensure we are the only thread waiting for this server.
+    std::scoped_lock lk{m_selection_mutex};
+
+    while (true) {
+        this->LinkDeferred();
+
+        // If we're done, return before we start waiting.
+        if (m_stop_source.stop_requested()) {
+            return nullptr;
+        }
+
+        auto* selected = m_multi_wait.WaitAny(m_system.Kernel());
+        if (selected == std::addressof(*m_wakeup_holder)) {
+            // Clear and restart if we were woken up.
+            m_wakeup_event->Clear();
+        } else {
+            // Unlink and handle the event.
+            selected->UnlinkFromMultiWait();
+            return selected;
+        }
+    }
+}
+
+Result ServerManager::Process(MultiWaitHolder* holder) {
+    switch (static_cast<UserDataTag>(holder->GetUserData())) {
+    case UserDataTag::Session:
+        R_RETURN(this->OnSessionEvent(static_cast<Session*>(holder)));
+    case UserDataTag::Port:
+        R_RETURN(this->OnPortEvent(static_cast<Port*>(holder)));
+    case UserDataTag::DeferEvent:
+        R_RETURN(this->OnDeferralEvent());
+    default:
+        UNREACHABLE();
+    }
+}
+
+bool ServerManager::WaitAndProcessImpl() {
+    if (auto* signaled_holder = this->WaitSignaled(); signaled_holder != nullptr) {
+        R_ASSERT(this->Process(signaled_holder));
+        return true;
+    } else {
+        return false;
+    }
+}
+
 Result ServerManager::LoopProcessImpl() {
     while (!m_stop_source.stop_requested()) {
-        R_TRY(this->WaitAndProcessImpl());
+        this->WaitAndProcessImpl();
     }
 
     R_SUCCEED();
 }
 
-Result ServerManager::WaitAndProcessImpl() {
-    Kernel::KScopedAutoObject<Kernel::KSynchronizationObject> wait_obj;
-    HandleType wait_type{};
-
-    // Ensure we are the only thread waiting for this server.
-    std::unique_lock sl{m_serve_mutex};
-
-    // If we're done, return before we start waiting.
-    R_SUCCEED_IF(m_stop_source.stop_requested());
-
-    // Wait for a tracked object to become signaled.
-    {
-        s32 num_objs{};
-        std::array<HandleType, MaximumWaitObjects> wait_types{};
-        std::array<Kernel::KSynchronizationObject*, MaximumWaitObjects> wait_objs{};
-
-        const auto AddWaiter{
-            [&](Kernel::KSynchronizationObject* synchronization_object, HandleType type) {
-                // Open a new reference to the object.
-                synchronization_object->Open();
-
-                // Insert into the list.
-                wait_types[num_objs] = type;
-                wait_objs[num_objs++] = synchronization_object;
-            }};
-
-        {
-            std::scoped_lock ll{m_list_mutex};
-
-            // Add all of our ports.
-            for (const auto& [port, handler] : m_ports) {
-                AddWaiter(port, HandleType::Port);
-            }
-
-            // Add all of our sessions.
-            for (const auto& [session, manager] : m_sessions) {
-                AddWaiter(session, HandleType::Session);
-            }
-        }
-
-        // Add the deferral wakeup event.
-        if (m_deferral_event != nullptr) {
-            AddWaiter(std::addressof(m_deferral_event->GetReadableEvent()), HandleType::DeferEvent);
-        }
-
-        // Add the wakeup event.
-        AddWaiter(std::addressof(m_event->GetReadableEvent()), HandleType::Event);
-
-        // Clean up extra references on exit.
-        SCOPE_EXIT({
-            for (s32 i = 0; i < num_objs; i++) {
-                wait_objs[i]->Close();
-            }
-        });
-
-        // Wait for a signal.
-        s32 out_index{-1};
-        R_TRY_CATCH(Kernel::KSynchronizationObject::Wait(m_system.Kernel(), &out_index,
-                                                         wait_objs.data(), num_objs, -1)) {
-            R_CATCH(Kernel::ResultSessionClosed) {
-                // On session closed, index is updated and we don't want to return an error.
-            }
-        }
-        R_END_TRY_CATCH;
-        ASSERT(out_index >= 0 && out_index < num_objs);
-
-        // Set the output index.
-        wait_obj = wait_objs[out_index];
-        wait_type = wait_types[out_index];
-    }
-
-    // Process what we just received, temporarily removing the object so it is
-    // not processed concurrently by another thread.
-    {
-        switch (wait_type) {
-        case HandleType::Port: {
-            // Port signaled.
-            auto* port = wait_obj->DynamicCast<Kernel::KServerPort*>();
-            SessionRequestHandlerFactory handler_factory;
-
-            // Remove from tracking.
-            {
-                std::scoped_lock ll{m_list_mutex};
-                ASSERT(m_ports.contains(port));
-                m_ports.at(port).swap(handler_factory);
-                m_ports.erase(port);
-            }
-
-            // Allow other threads to serve.
-            sl.unlock();
-
-            // Finish.
-            R_RETURN(this->OnPortEvent(port, std::move(handler_factory)));
-        }
-        case HandleType::Session: {
-            // Session signaled.
-            auto* session = wait_obj->DynamicCast<Kernel::KServerSession*>();
-            std::shared_ptr<SessionRequestManager> manager;
-
-            // Remove from tracking.
-            {
-                std::scoped_lock ll{m_list_mutex};
-                ASSERT(m_sessions.contains(session));
-                m_sessions.at(session).swap(manager);
-                m_sessions.erase(session);
-            }
-
-            // Allow other threads to serve.
-            sl.unlock();
-
-            // Finish.
-            R_RETURN(this->OnSessionEvent(session, std::move(manager)));
-        }
-        case HandleType::DeferEvent: {
-            // Clear event.
-            ASSERT(R_SUCCEEDED(m_deferral_event->Clear()));
-
-            // Drain the list of deferrals while we process.
-            std::list<RequestState> deferrals;
-            {
-                std::scoped_lock ll{m_list_mutex};
-                m_deferrals.swap(deferrals);
-            }
-
-            // Allow other threads to serve.
-            sl.unlock();
-
-            // Finish.
-            R_RETURN(this->OnDeferralEvent(std::move(deferrals)));
-        }
-        case HandleType::Event: {
-            // Clear event and finish.
-            R_RETURN(m_event->Clear());
-        }
-        default: {
-            UNREACHABLE();
-        }
-        }
-    }
-}
-
-Result ServerManager::OnPortEvent(Kernel::KServerPort* port,
-                                  SessionRequestHandlerFactory&& handler_factory) {
+Result ServerManager::OnPortEvent(Port* server) {
     // Accept a new server session.
-    Kernel::KServerSession* session = port->AcceptSession();
-    ASSERT(session != nullptr);
+    auto* server_port = static_cast<Kernel::KServerPort*>(server->GetNativeHandle());
+    Kernel::KServerSession* server_session = server_port->AcceptSession();
+    ASSERT(server_session != nullptr);
 
     // Create the session manager and install the handler.
     auto manager = std::make_shared<SessionRequestManager>(m_system.Kernel(), *this);
-    manager->SetSessionHandler(handler_factory());
+    manager->SetSessionHandler(server->CreateHandler());
 
-    // Track the server session.
-    {
-        std::scoped_lock ll{m_list_mutex};
-        m_ports.emplace(port, std::move(handler_factory));
-        m_sessions.emplace(session, std::move(manager));
-    }
+    // Create and register the new session.
+    this->RegisterSession(server_session, std::move(manager));
 
-    // Signal the wakeup event.
-    m_event->Signal();
+    // Resume tracking the port.
+    this->LinkToDeferredList(server);
 
     // We succeeded.
     R_SUCCEED();
 }
 
-Result ServerManager::OnSessionEvent(Kernel::KServerSession* session,
-                                     std::shared_ptr<SessionRequestManager>&& manager) {
-    Result rc{ResultSuccess};
+Result ServerManager::OnSessionEvent(Session* session) {
+    Result res = ResultSuccess;
 
     // Try to receive a message.
-    std::shared_ptr<HLERequestContext> context;
-    rc = session->ReceiveRequestHLE(&context, manager);
+    auto* server_session = static_cast<Kernel::KServerSession*>(session->GetNativeHandle());
+    res = server_session->ReceiveRequestHLE(&session->GetContext(), session->GetManager());
 
     // If the session has been closed, we're done.
-    if (rc == Kernel::ResultSessionClosed) {
-        // Close the session.
-        session->Close();
-
-        // Finish.
+    if (res == Kernel::ResultSessionClosed) {
+        this->DestroySession(session);
         R_SUCCEED();
     }
-    ASSERT(R_SUCCEEDED(rc));
 
-    RequestState request{
-        .session = session,
-        .context = std::move(context),
-        .manager = std::move(manager),
-    };
+    R_ASSERT(res);
 
     // Complete the sync request with deferral handling.
-    R_RETURN(this->CompleteSyncRequest(std::move(request)));
+    R_RETURN(this->CompleteSyncRequest(session));
 }
 
-Result ServerManager::CompleteSyncRequest(RequestState&& request) {
-    Result rc{ResultSuccess};
-    Result service_rc{ResultSuccess};
+Result ServerManager::CompleteSyncRequest(Session* session) {
+    Result res = ResultSuccess;
+    Result service_res = ResultSuccess;
 
     // Mark the request as not deferred.
-    request.context->SetIsDeferred(false);
+    session->GetContext()->SetIsDeferred(false);
 
     // Complete the request. We have exclusive access to this session.
-    service_rc = request.manager->CompleteSyncRequest(request.session, *request.context);
+    auto* server_session = static_cast<Kernel::KServerSession*>(session->GetNativeHandle());
+    service_res =
+        session->GetManager()->CompleteSyncRequest(server_session, *session->GetContext());
 
     // If we've been deferred, we're done.
-    if (request.context->GetIsDeferred()) {
-        // Insert into deferral list.
-        std::scoped_lock ll{m_list_mutex};
-        m_deferrals.emplace_back(std::move(request));
+    if (session->GetContext()->GetIsDeferred()) {
+        // Insert into deferred session list.
+        std::scoped_lock ll{m_deferred_list_mutex};
+        m_deferred_sessions.push_back(session);
 
         // Finish.
         R_SUCCEED();
     }
 
     // Send the reply.
-    rc = request.session->SendReplyHLE();
+    res = server_session->SendReplyHLE();
 
     // If the session has been closed, we're done.
-    if (rc == Kernel::ResultSessionClosed || service_rc == IPC::ResultSessionClosed) {
-        // Close the session.
-        request.session->Close();
-
-        // Finish.
+    if (res == Kernel::ResultSessionClosed || service_res == IPC::ResultSessionClosed) {
+        this->DestroySession(session);
         R_SUCCEED();
     }
 
-    ASSERT(R_SUCCEEDED(rc));
-    ASSERT(R_SUCCEEDED(service_rc));
+    R_ASSERT(res);
+    R_ASSERT(service_res);
 
-    // Reinsert the session.
-    {
-        std::scoped_lock ll{m_list_mutex};
-        m_sessions.emplace(request.session, std::move(request.manager));
-    }
+    // We succeeded, so we can process future messages on this session.
+    this->LinkToDeferredList(session);
 
-    // Signal the wakeup event.
-    m_event->Signal();
-
-    // We succeeded.
     R_SUCCEED();
 }
 
-Result ServerManager::OnDeferralEvent(std::list<RequestState>&& deferrals) {
-    ON_RESULT_FAILURE {
-        std::scoped_lock ll{m_list_mutex};
-        m_deferrals.splice(m_deferrals.end(), deferrals);
-    };
+Result ServerManager::OnDeferralEvent() {
+    // Clear event before grabbing the list.
+    m_deferral_event->Clear();
 
-    while (!deferrals.empty()) {
-        RequestState request = deferrals.front();
-        deferrals.pop_front();
+    // Get and clear list.
+    const auto deferrals = [&] {
+        std::scoped_lock lk{m_deferred_list_mutex};
+        return std::move(m_deferred_sessions);
+    }();
 
-        // Try again to complete the request.
-        R_TRY(this->CompleteSyncRequest(std::move(request)));
+    // Relink deferral event.
+    this->LinkToDeferredList(std::addressof(*m_deferral_holder));
+
+    // For each session, try again to complete the request.
+    for (auto* session : deferrals) {
+        R_ASSERT(this->CompleteSyncRequest(session));
     }
 
     R_SUCCEED();
 }
 
+void ServerManager::DestroySession(Session* session) {
+    // Unlink.
+    {
+        std::scoped_lock lk{m_deferred_list_mutex};
+        m_sessions.erase(m_sessions.iterator_to(*session));
+    }
+
+    // Free the session.
+    delete session;
+}
+
 } // namespace Service

src/core/hle/service/server_manager.h

@@ -3,18 +3,17 @@
 
 #pragma once
 
-#include <functional>
 #include <list>
-#include <map>
 #include <mutex>
-#include <string_view>
+#include <optional>
 #include <vector>
 
 #include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/hle/result.h"
 #include "core/hle/service/hle_ipc.h"
-#include "core/hle/service/mutex.h"
+#include "core/hle/service/os/multi_wait.h"
+#include "core/hle/service/os/mutex.h"
 
 namespace Core {
 class System;
@@ -24,11 +23,13 @@ namespace Kernel {
 class KEvent;
 class KServerPort;
 class KServerSession;
-class KSynchronizationObject;
 } // namespace Kernel
 
 namespace Service {
 
+class Port;
+class Session;
+
 class ServerManager {
 public:
     explicit ServerManager(Core::System& system);
@@ -52,34 +53,40 @@ public:
     static void RunServer(std::unique_ptr<ServerManager>&& server);
 
 private:
-    struct RequestState;
-
+    void LinkToDeferredList(MultiWaitHolder* holder);
+    void LinkDeferred();
+    MultiWaitHolder* WaitSignaled();
+    Result Process(MultiWaitHolder* holder);
+    bool WaitAndProcessImpl();
     Result LoopProcessImpl();
-    Result WaitAndProcessImpl();
-    Result OnPortEvent(Kernel::KServerPort* port, SessionRequestHandlerFactory&& handler_factory);
-    Result OnSessionEvent(Kernel::KServerSession* session,
-                          std::shared_ptr<SessionRequestManager>&& manager);
-    Result OnDeferralEvent(std::list<RequestState>&& deferrals);
-    Result CompleteSyncRequest(RequestState&& state);
+
+    Result OnPortEvent(Port* port);
+    Result OnSessionEvent(Session* session);
+    Result OnDeferralEvent();
+    Result CompleteSyncRequest(Session* session);
+
+private:
+    void DestroySession(Session* session);
 
 private:
     Core::System& m_system;
-    Mutex m_serve_mutex;
-    std::mutex m_list_mutex;
+    Mutex m_selection_mutex;
 
-    // Guest state tracking
-    std::map<Kernel::KServerPort*, SessionRequestHandlerFactory> m_ports{};
-    std::map<Kernel::KServerSession*, std::shared_ptr<SessionRequestManager>> m_sessions{};
-    Kernel::KEvent* m_event{};
+    // Events
+    Kernel::KEvent* m_wakeup_event{};
     Kernel::KEvent* m_deferral_event{};
 
-    // Deferral tracking
-    struct RequestState {
-        Kernel::KServerSession* session;
-        std::shared_ptr<HLERequestContext> context;
-        std::shared_ptr<SessionRequestManager> manager;
-    };
-    std::list<RequestState> m_deferrals{};
+    // Deferred wait list
+    std::mutex m_deferred_list_mutex{};
+    MultiWait m_deferred_list{};
+
+    // Guest state tracking
+    MultiWait m_multi_wait{};
+    Common::IntrusiveListBaseTraits<Port>::ListType m_servers{};
+    Common::IntrusiveListBaseTraits<Session>::ListType m_sessions{};
+    std::list<Session*> m_deferred_sessions{};
+    std::optional<MultiWaitHolder> m_wakeup_holder{};
+    std::optional<MultiWaitHolder> m_deferral_holder{};
 
     // Host state tracking
     Common::Event m_stopped{};

src/core/hle/service/service.cpp

@@ -15,7 +15,7 @@
 #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_module.h"
+#include "core/hle/service/bcat/bcat.h"
 #include "core/hle/service/bpc/bpc.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/btm/btm.h"

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/hle/service/nvnflinger/hwc_layer.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
 
 namespace Service::VI {
@@ -8,8 +9,9 @@ namespace Service::VI {
 Layer::Layer(u64 layer_id_, u32 binder_id_, android::BufferQueueCore& core_,
              android::BufferQueueProducer& binder_,
              std::shared_ptr<android::BufferItemConsumer>&& consumer_)
-    : layer_id{layer_id_}, binder_id{binder_id_}, core{core_}, binder{binder_},
-      consumer{std::move(consumer_)}, open{false}, visible{true} {}
+    : layer_id{layer_id_}, binder_id{binder_id_}, core{core_}, binder{binder_}, consumer{std::move(
+                                                                                    consumer_)},
+      blending{Nvnflinger::LayerBlending::None}, open{false}, visible{true} {}
 
 Layer::~Layer() = default;
 

src/core/hle/service/vi/layer/vi_layer.h

@@ -14,6 +14,10 @@ class BufferQueueCore;
 class BufferQueueProducer;
 } // namespace Service::android
 
+namespace Service::Nvnflinger {
+enum class LayerBlending : u32;
+}
+
 namespace Service::VI {
 
 /// Represents a single display layer.
@@ -92,12 +96,21 @@ public:
         return !std::exchange(open, true);
     }
 
+    Nvnflinger::LayerBlending GetBlending() {
+        return blending;
+    }
+
+    void SetBlending(Nvnflinger::LayerBlending b) {
+        blending = b;
+    }
+
 private:
     const u64 layer_id;
     const u32 binder_id;
     android::BufferQueueCore& core;
     android::BufferQueueProducer& binder;
     std::shared_ptr<android::BufferItemConsumer> consumer;
+    Service::Nvnflinger::LayerBlending blending;
     bool open;
     bool visible;
 };

src/core/memory.h

@@ -64,6 +64,8 @@ public:
     Memory(Memory&&) = default;
     Memory& operator=(Memory&&) = delete;
 
+    static constexpr bool HAS_FLUSH_INVALIDATION = false;
+
     /**
      * Resets the state of the Memory system.
      */

src/core/memory/cheat_engine.cpp

@@ -65,7 +65,8 @@ void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64
         return;
     }
 
-    if (system.ApplicationMemory().WriteBlock(address, data, size)) {
+    if (system.ApplicationMemory().WriteBlock(address, data, size) &&
+        system.ApplicationProcess()->Is64Bit()) {
         Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size);
     }
 }

src/frontend_common/config.cpp

@@ -401,6 +401,14 @@ void Config::ReadNetworkValues() {
     EndGroup();
 }
 
+void Config::ReadLibraryAppletValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::LibraryApplet));
+
+    ReadCategory(Settings::Category::LibraryApplet);
+
+    EndGroup();
+}
+
 void Config::ReadValues() {
     if (global) {
         ReadDataStorageValues();
@@ -410,6 +418,7 @@ void Config::ReadValues() {
         ReadServiceValues();
         ReadWebServiceValues();
         ReadMiscellaneousValues();
+        ReadLibraryAppletValues();
     }
     ReadControlValues();
     ReadCoreValues();
@@ -511,6 +520,7 @@ void Config::SaveValues() {
         SaveNetworkValues();
         SaveWebServiceValues();
         SaveMiscellaneousValues();
+        SaveLibraryAppletValues();
     } else {
         LOG_DEBUG(Config, "Saving only generic configuration values");
     }
@@ -691,6 +701,14 @@ void Config::SaveWebServiceValues() {
     EndGroup();
 }
 
+void Config::SaveLibraryAppletValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::LibraryApplet));
+
+    WriteCategory(Settings::Category::LibraryApplet);
+
+    EndGroup();
+}
+
 bool Config::ReadBooleanSetting(const std::string& key, const std::optional<bool> default_value) {
     std::string full_key = GetFullKey(key, false);
     if (!default_value.has_value()) {

src/frontend_common/config.h

@@ -88,6 +88,7 @@ protected:
     void ReadSystemValues();
     void ReadWebServiceValues();
     void ReadNetworkValues();
+    void ReadLibraryAppletValues();
 
     // Read platform specific sections
     virtual void ReadHidbusValues() = 0;
@@ -121,6 +122,7 @@ protected:
     void SaveScreenshotValues();
     void SaveSystemValues();
     void SaveWebServiceValues();
+    void SaveLibraryAppletValues();
 
     // Save platform specific sections
     virtual void SaveHidbusValues() = 0;

src/video_core/CMakeLists.txt

@@ -18,6 +18,7 @@ add_library(video_core STATIC
     buffer_cache/usage_tracker.h
     buffer_cache/word_manager.h
     cache_types.h
+    capture.h
     cdma_pusher.cpp
     cdma_pusher.h
     compatible_formats.cpp
@@ -59,8 +60,8 @@ add_library(video_core STATIC
     framebuffer_config.h
     fsr.cpp
     fsr.h
-    host1x/codecs/codec.cpp
-    host1x/codecs/codec.h
+    host1x/codecs/decoder.cpp
+    host1x/codecs/decoder.h
     host1x/codecs/h264.cpp
     host1x/codecs/h264.h
     host1x/codecs/vp8.cpp
@@ -79,8 +80,6 @@ add_library(video_core STATIC
     host1x/nvdec.cpp
     host1x/nvdec.h
     host1x/nvdec_common.h
-    host1x/sync_manager.cpp
-    host1x/sync_manager.h
     host1x/syncpoint_manager.cpp
     host1x/syncpoint_manager.h
     host1x/vic.cpp
@@ -101,6 +100,7 @@ add_library(video_core STATIC
     memory_manager.cpp
     memory_manager.h
     precompiled_headers.h
+    present.h
     pte_kind.h
     query_cache/bank_base.h
     query_cache/query_base.h
@@ -390,4 +390,8 @@ if (ANDROID AND ARCHITECTURE_arm64)
     target_link_libraries(video_core PRIVATE adrenotools)
 endif()
 
+if (ARCHITECTURE_arm64)
+    target_link_libraries(video_core PRIVATE sse2neon)
+endif()
+
 create_target_directory_groups(video_core)

src/video_core/buffer_cache/buffer_cache.h

@@ -1488,7 +1488,10 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
             std::span<const u8> upload_span;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
             if (IsRangeGranular(device_addr, copy.size)) {
-                upload_span = std::span(device_memory.GetPointer<u8>(device_addr), copy.size);
+                auto* const ptr = device_memory.GetPointer<u8>(device_addr);
+                if (ptr != nullptr) {
+                    upload_span = std::span(ptr, copy.size);
+                }
             } else {
                 if (immediate_buffer.empty()) {
                     immediate_buffer = ImmediateBuffer(largest_copy);

src/video_core/capture.h

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/alignment.h"
+#include "common/bit_util.h"
+#include "common/common_types.h"
+#include "core/frontend/framebuffer_layout.h"
+#include "video_core/surface.h"
+
+namespace VideoCore::Capture {
+
+constexpr u32 BlockHeight = 4;
+constexpr u32 BlockDepth = 0;
+constexpr u32 BppLog2 = 2;
+
+constexpr auto PixelFormat = Surface::PixelFormat::B8G8R8A8_UNORM;
+
+constexpr auto LinearWidth = Layout::ScreenUndocked::Width;
+constexpr auto LinearHeight = Layout::ScreenUndocked::Height;
+constexpr auto LinearDepth = 1U;
+constexpr auto BytesPerPixel = 4U;
+
+constexpr auto TiledWidth = LinearWidth;
+constexpr auto TiledHeight = Common::AlignUpLog2(LinearHeight, BlockHeight + BlockDepth + BppLog2);
+constexpr auto TiledSize = TiledWidth * TiledHeight * (1 << BppLog2);
+
+constexpr Layout::FramebufferLayout Layout{
+    .width = LinearWidth,
+    .height = LinearHeight,
+    .screen = {0, 0, LinearWidth, LinearHeight},
+    .is_srgb = false,
+};
+
+} // namespace VideoCore::Capture

src/video_core/cdma_pusher.cpp

@@ -2,136 +2,130 @@
 // SPDX-License-Identifier: MIT
 
 #include <bit>
+
+#include "common/thread.h"
+#include "core/core.h"
 #include "video_core/cdma_pusher.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/host1x/control.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/host1x/nvdec.h"
 #include "video_core/host1x/nvdec_common.h"
-#include "video_core/host1x/sync_manager.h"
 #include "video_core/host1x/vic.h"
 #include "video_core/memory_manager.h"
 
 namespace Tegra {
-CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_)
-    : host1x{host1x_}, nvdec_processor(std::make_shared<Host1x::Nvdec>(host1x)),
-      vic_processor(std::make_unique<Host1x::Vic>(host1x, nvdec_processor)),
-      host1x_processor(std::make_unique<Host1x::Control>(host1x)),
-      sync_manager(std::make_unique<Host1x::SyncptIncrManager>(host1x)) {}
+
+CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
+    : host1x{host1x_}, memory_manager{host1x.GMMU()},
+      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
+                                                                      static_cast<ChClassId>(id)} {
+    thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
+}
 
 CDmaPusher::~CDmaPusher() = default;
 
-void CDmaPusher::ProcessEntries(ChCommandHeaderList&& entries) {
-    for (const auto& value : entries) {
-        if (mask != 0) {
-            const auto lbs = static_cast<u32>(std::countr_zero(mask));
-            mask &= ~(1U << lbs);
-            ExecuteCommand(offset + lbs, value.raw);
-            continue;
-        } else if (count != 0) {
-            --count;
-            ExecuteCommand(offset, value.raw);
-            if (incrementing) {
-                ++offset;
+void CDmaPusher::ProcessEntries(std::stop_token stop_token) {
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+    ChCommandHeaderList command_list{host1x.System().ApplicationMemory(), 0, 0};
+    u32 count{};
+    u32 method_offset{};
+    u32 mask{};
+    bool incrementing{};
+
+    while (!stop_token.stop_requested()) {
+        {
+            std::unique_lock l{command_mutex};
+            Common::CondvarWait(command_cv, l, stop_token,
+                                [this]() { return command_lists.size() > 0; });
+            if (stop_token.stop_requested()) {
+                return;
             }
-            continue;
+
+            command_list = std::move(command_lists.front());
+            command_lists.pop_front();
         }
-        const auto mode = value.submission_mode.Value();
-        switch (mode) {
-        case ChSubmissionMode::SetClass: {
-            mask = value.value & 0x3f;
-            offset = value.method_offset;
-            current_class = static_cast<ChClassId>((value.value >> 6) & 0x3ff);
-            break;
-        }
-        case ChSubmissionMode::Incrementing:
-        case ChSubmissionMode::NonIncrementing:
-            count = value.value;
-            offset = value.method_offset;
-            incrementing = mode == ChSubmissionMode::Incrementing;
-            break;
-        case ChSubmissionMode::Mask:
-            mask = value.value;
-            offset = value.method_offset;
-            break;
-        case ChSubmissionMode::Immediate: {
-            const u32 data = value.value & 0xfff;
-            offset = value.method_offset;
-            ExecuteCommand(offset, data);
-            break;
-        }
-        default:
-            UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!", static_cast<u32>(mode));
-            break;
+
+        size_t i = 0;
+        for (const auto value : command_list) {
+            i++;
+            if (mask != 0) {
+                const auto lbs = static_cast<u32>(std::countr_zero(mask));
+                mask &= ~(1U << lbs);
+                ExecuteCommand(method_offset + lbs, value.raw);
+                continue;
+            } else if (count != 0) {
+                --count;
+                ExecuteCommand(method_offset, value.raw);
+                if (incrementing) {
+                    ++method_offset;
+                }
+                continue;
+            }
+            const auto mode = value.submission_mode.Value();
+            switch (mode) {
+            case ChSubmissionMode::SetClass: {
+                mask = value.value & 0x3f;
+                method_offset = value.method_offset;
+                current_class = static_cast<ChClassId>((value.value >> 6) & 0x3ff);
+                break;
+            }
+            case ChSubmissionMode::Incrementing:
+            case ChSubmissionMode::NonIncrementing:
+                count = value.value;
+                method_offset = value.method_offset;
+                incrementing = mode == ChSubmissionMode::Incrementing;
+                break;
+            case ChSubmissionMode::Mask:
+                mask = value.value;
+                method_offset = value.method_offset;
+                break;
+            case ChSubmissionMode::Immediate: {
+                const u32 data = value.value & 0xfff;
+                method_offset = value.method_offset;
+                ExecuteCommand(method_offset, data);
+                break;
+            }
+            default:
+                LOG_ERROR(HW_GPU, "Bad command at index {} (bytes 0x{:X}), buffer size {}", i - 1,
+                          (i - 1) * sizeof(u32), command_list.size());
+                UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!",
+                                  static_cast<u32>(mode));
+                break;
+            }
         }
     }
 }
 
-void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
+void CDmaPusher::ExecuteCommand(u32 method, u32 arg) {
     switch (current_class) {
-    case ChClassId::NvDec:
-        ThiStateWrite(nvdec_thi_state, offset, data);
-        switch (static_cast<ThiMethod>(offset)) {
-        case ThiMethod::IncSyncpt: {
-            LOG_DEBUG(Service_NVDRV, "NVDEC Class IncSyncpt Method");
-            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
-            const auto cond = static_cast<u32>((data >> 8) & 0xFF);
-            if (cond == 0) {
-                sync_manager->Increment(syncpoint_id);
-            } else {
-                sync_manager->SignalDone(
-                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
-            }
-            break;
-        }
-        case ThiMethod::SetMethod1:
-            LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}",
-                      static_cast<u32>(nvdec_thi_state.method_0));
-            nvdec_processor->ProcessMethod(nvdec_thi_state.method_0, data);
-            break;
-        default:
-            break;
-        }
-        break;
-    case ChClassId::GraphicsVic:
-        ThiStateWrite(vic_thi_state, static_cast<u32>(state_offset), {data});
-        switch (static_cast<ThiMethod>(state_offset)) {
-        case ThiMethod::IncSyncpt: {
-            LOG_DEBUG(Service_NVDRV, "VIC Class IncSyncpt Method");
-            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
-            const auto cond = static_cast<u32>((data >> 8) & 0xFF);
-            if (cond == 0) {
-                sync_manager->Increment(syncpoint_id);
-            } else {
-                sync_manager->SignalDone(
-                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
-            }
-            break;
-        }
-        case ThiMethod::SetMethod1:
-            LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
-                      static_cast<u32>(vic_thi_state.method_0), data);
-            vic_processor->ProcessMethod(static_cast<Host1x::Vic::Method>(vic_thi_state.method_0),
-                                         data);
-            break;
-        default:
-            break;
-        }
-        break;
     case ChClassId::Control:
-        // This device is mainly for syncpoint synchronization
-        LOG_DEBUG(Service_NVDRV, "Host1X Class Method");
-        host1x_processor->ProcessMethod(static_cast<Host1x::Control::Method>(offset), data);
+        LOG_TRACE(Service_NVDRV, "Class {} method 0x{:X} arg 0x{:X}",
+                  static_cast<u32>(current_class), method, arg);
+        host_processor->ProcessMethod(static_cast<Host1x::Control::Method>(method), arg);
         break;
     default:
-        UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class));
-        break;
+        thi_regs.reg_array[method] = arg;
+        switch (static_cast<ThiMethod>(method)) {
+        case ThiMethod::IncSyncpt: {
+            const auto syncpoint_id = static_cast<u32>(arg & 0xFF);
+            [[maybe_unused]] const auto cond = static_cast<u32>((arg >> 8) & 0xFF);
+            LOG_TRACE(Service_NVDRV, "Class {} IncSyncpt Method, syncpt {} cond {}",
+                      static_cast<u32>(current_class), syncpoint_id, cond);
+            auto& syncpoint_manager = host1x.GetSyncpointManager();
+            syncpoint_manager.IncrementGuest(syncpoint_id);
+            syncpoint_manager.IncrementHost(syncpoint_id);
+            break;
+        }
+        case ThiMethod::SetMethod1:
+            LOG_TRACE(Service_NVDRV, "Class {} method 0x{:X} arg 0x{:X}",
+                      static_cast<u32>(current_class), static_cast<u32>(thi_regs.method_0), arg);
+            ProcessMethod(thi_regs.method_0, arg);
+            break;
+        default:
+            break;
+        }
     }
 }
 
-void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 state_offset, u32 argument) {
-    u8* const offset_ptr = reinterpret_cast<u8*>(&state) + sizeof(u32) * state_offset;
-    std::memcpy(offset_ptr, &argument, sizeof(u32));
-}
-
 } // namespace Tegra

src/video_core/cdma_pusher.h

@@ -3,12 +3,18 @@
 
 #pragma once
 
+#include <condition_variable>
+#include <deque>
 #include <memory>
+#include <mutex>
+#include <thread>
 #include <vector>
 
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/polyfill_thread.h"
+#include "core/memory.h"
 
 namespace Tegra {
 
@@ -62,23 +68,31 @@ struct ChCommand {
     std::vector<u32> arguments;
 };
 
-using ChCommandHeaderList = std::vector<ChCommandHeader>;
+using ChCommandHeaderList =
+    Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader, Core::Memory::GuestMemoryFlags::SafeRead>;
 
 struct ThiRegisters {
-    u32_le increment_syncpt{};
-    INSERT_PADDING_WORDS(1);
-    u32_le increment_syncpt_error{};
-    u32_le ctx_switch_incremement_syncpt{};
-    INSERT_PADDING_WORDS(4);
-    u32_le ctx_switch{};
-    INSERT_PADDING_WORDS(1);
-    u32_le ctx_syncpt_eof{};
-    INSERT_PADDING_WORDS(5);
-    u32_le method_0{};
-    u32_le method_1{};
-    INSERT_PADDING_WORDS(12);
-    u32_le int_status{};
-    u32_le int_mask{};
+    static constexpr std::size_t NUM_REGS = 0x20;
+
+    union {
+        struct {
+            u32_le increment_syncpt;
+            INSERT_PADDING_WORDS_NOINIT(1);
+            u32_le increment_syncpt_error;
+            u32_le ctx_switch_incremement_syncpt;
+            INSERT_PADDING_WORDS_NOINIT(4);
+            u32_le ctx_switch;
+            INSERT_PADDING_WORDS_NOINIT(1);
+            u32_le ctx_syncpt_eof;
+            INSERT_PADDING_WORDS_NOINIT(5);
+            u32_le method_0;
+            u32_le method_1;
+            INSERT_PADDING_WORDS_NOINIT(12);
+            u32_le int_status;
+            u32_le int_mask;
+        };
+        std::array<u32, NUM_REGS> reg_array;
+    };
 };
 
 enum class ThiMethod : u32 {
@@ -89,32 +103,39 @@ enum class ThiMethod : u32 {
 
 class CDmaPusher {
 public:
-    explicit CDmaPusher(Host1x::Host1x& host1x);
-    ~CDmaPusher();
+    CDmaPusher() = delete;
+    virtual ~CDmaPusher();
 
-    /// Process the command entry
-    void ProcessEntries(ChCommandHeaderList&& entries);
+    void PushEntries(ChCommandHeaderList&& entries) {
+        std::scoped_lock l{command_mutex};
+        command_lists.push_back(std::move(entries));
+        command_cv.notify_one();
+    }
+
+protected:
+    explicit CDmaPusher(Host1x::Host1x& host1x, s32 id);
+
+    virtual void ProcessMethod(u32 method, u32 arg) = 0;
+
+    Host1x::Host1x& host1x;
+    Tegra::MemoryManager& memory_manager;
 
 private:
+    /// Process the command entry
+    void ProcessEntries(std::stop_token stop_token);
+
     /// Invoke command class devices to execute the command based on the current state
     void ExecuteCommand(u32 state_offset, u32 data);
 
-    /// Write arguments value to the ThiRegisters member at the specified offset
-    void ThiStateWrite(ThiRegisters& state, u32 offset, u32 argument);
+    std::unique_ptr<Host1x::Control> host_processor;
 
-    Host1x::Host1x& host1x;
-    std::shared_ptr<Tegra::Host1x::Nvdec> nvdec_processor;
-    std::unique_ptr<Tegra::Host1x::Vic> vic_processor;
-    std::unique_ptr<Tegra::Host1x::Control> host1x_processor;
-    std::unique_ptr<Host1x::SyncptIncrManager> sync_manager;
-    ChClassId current_class{};
-    ThiRegisters vic_thi_state{};
-    ThiRegisters nvdec_thi_state{};
+    std::mutex command_mutex;
+    std::condition_variable_any command_cv;
+    std::deque<ChCommandHeaderList> command_lists;
+    std::jthread thread;
 
-    u32 count{};
-    u32 offset{};
-    u32 mask{};
-    bool incrementing{};
+    ThiRegisters thi_regs{};
+    ChClassId current_class;
 };
 
 } // namespace Tegra

src/video_core/framebuffer_config.h

@@ -11,6 +11,12 @@
 
 namespace Tegra {
 
+enum class BlendMode {
+    Opaque,
+    Premultiplied,
+    Coverage,
+};
+
 /**
  * Struct describing framebuffer configuration
  */
@@ -23,6 +29,7 @@ struct FramebufferConfig {
     Service::android::PixelFormat pixel_format{};
     Service::android::BufferTransformFlags transform_flags{};
     Common::Rectangle<int> crop_rect{};
+    BlendMode blending{};
 };
 
 Common::Rectangle<f32> NormalizeCrop(const FramebufferConfig& framebuffer, u32 texture_width,