Revert "[android] Add Enable GPU Buffer Readback option to Android (#4132)"

This reverts commit d142b5dd6a.

src/core/core.cpp

@@ -350,7 +350,7 @@ struct System::Impl {
 
         // Register with applet manager
         // All threads are started, begin main process execution, now that we're in the clear
-        applet_manager.CreateAndInsertByFrontendAppletParameters(std::make_unique<Service::Process>(*std::move(process)), params);
+        applet_manager.CreateAndInsertByFrontendAppletParameters(std::move(process), params);
 
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {

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

@@ -109,6 +109,10 @@ struct Applet {
     std::list<std::shared_ptr<Applet>> child_applets{};
     bool is_completed{};
 
+    std::shared_ptr<Applet> reserved_applet{};
+    bool unwind_after_reserved{};
+    bool is_winding{};
+
     // Self state
     bool exit_locked{};
     s32 fatal_section_count{};

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

@@ -25,6 +25,13 @@ void AppletStorageChannel::Push(Kernel::KernelCore& kernel, std::shared_ptr<ISto
     m_event.Signal(kernel);
 }
 
+void AppletStorageChannel::Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage) {
+    std::scoped_lock lk{m_lock};
+
+    m_data.emplace_front(std::move(storage));
+    m_event.Signal(kernel);
+}
+
 Result AppletStorageChannel::Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage) {
     std::scoped_lock lk{m_lock};
 

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

@@ -26,6 +26,7 @@ public:
     ~AppletStorageChannel();
 
     void Push(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
+    void Unpop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
     Result Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage);
     Kernel::KReadableEvent* GetEvent();
 

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

@@ -267,7 +267,7 @@ void AppletManager::SetWindowSystem(WindowSystem* window_system) {
 
     if (Settings::values.enable_overlay && m_window_system->GetOverlayDisplayApplet() == nullptr) {
         if (auto overlay_process = CreateProcess(m_system, static_cast<u64>(AppletProgramId::OverlayDisplay), 0, 0)) {
-            auto overlay_applet = std::make_shared<Applet>(m_system, std::make_unique<Service::Process>(*std::move(overlay_process)), false);
+            auto overlay_applet = std::make_shared<Applet>(m_system, std::move(overlay_process), false);
             overlay_applet->program_id = static_cast<u64>(AppletProgramId::OverlayDisplay);
             overlay_applet->applet_id = AppletId::OverlayDisplay;
             overlay_applet->type = AppletType::OverlayApplet;

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,7 +15,10 @@ namespace Service::AM {
 
 HidRegistration::HidRegistration(Core::System& system, Process& process) : m_process(process) {
     m_hid_server = system.ServiceManager().GetService<HID::IHidServer>("hid", true);
+    this->RegisterCurrentProcess();
+}
 
+void HidRegistration::RegisterCurrentProcess() {
     if (m_process.IsInitialized()) {
         m_hid_server->GetResourceManager()->RegisterAppletResourceUserId(m_process.GetProcessId(),
                                                                          true);

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -24,6 +27,7 @@ public:
     explicit HidRegistration(Core::System& system, Process& process);
     ~HidRegistration();
 
+    void RegisterCurrentProcess();
     void EnableAppletToGetInput(bool enable);
 
 private:

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

@@ -171,6 +171,18 @@ void LifecycleManager::SignalSystemEventIfNeeded(Kernel::KernelCore& kernel) {
     }
 }
 
+void LifecycleManager::ResetForRelaunch() {
+    m_unordered_messages.clear();
+
+    m_activity_state = ActivityState::BackgroundVisible;
+    m_requested_focus_state = FocusState{};
+    m_acknowledged_focus_state = FocusState{};
+    m_has_focus_state_changed = true;
+
+    m_suspend_mode = SuspendMode::NoOverride;
+    m_forced_suspend = false;
+}
+
 bool LifecycleManager::PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message) {
     const auto message = this->PopMessageInOrderOfPriority();
     this->SignalSystemEventIfNeeded(kernel);

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

@@ -138,6 +138,8 @@ public:
     void PushUnorderedMessage(Kernel::KernelCore& kernel, AppletMessage message);
     bool PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message);
 
+    void ResetForRelaunch();
+
 private:
     FocusState GetFocusStateWhileForegroundObscured() const;
     FocusState GetFocusStateWhileBackground(bool is_obscured) const;

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

@@ -40,23 +40,23 @@ namespace {
     }
 }
 
-[[nodiscard]] inline std::optional<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+[[nodiscard]] inline std::unique_ptr<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
     // Get the appropriate loader to parse this NCA.
     out_loader = Loader::GetLoader(system, file, program_id, program_index);
     // Ensure we have a loader which can parse the NCA.
     if (out_loader) {
         // Try to load the process.
-        auto process = std::make_optional<Process>(system);
+        auto process = std::make_unique<Process>(system);
         if (process->Initialize(*out_loader, out_load_result)) {
             return process;
         }
     }
-    return std::nullopt;
+    return nullptr;
 }
 
 } // Anonymous namespace
 
-std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
+std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
     // Attempt to load program NCA.
     FileSys::VirtualFile nca_raw{};
 
@@ -66,7 +66,7 @@ std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 mi
 
     // Ensure we retrieved a program NCA.
     if (!nca_raw) {
-        return std::nullopt;
+        return nullptr;
     }
 
     // Ensure we have a suitable version.
@@ -76,7 +76,7 @@ std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 mi
             (nca.GetKeyGeneration() < minimum_key_generation ||
              nca.GetKeyGeneration() > maximum_key_generation)) {
             LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id, nca.GetKeyGeneration());
-            return std::nullopt;
+            return nullptr;
         }
     }
 
@@ -85,7 +85,7 @@ std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 mi
     return CreateProcessImpl(loader, status, system, nca_raw, program_id, 0);
 }
 
-std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
+std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
     if (auto process = CreateProcessImpl(out_loader, out_load_result, system, file, program_id, program_index); process) {
         FileSys::NACP nacp;
         if (out_loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
@@ -110,7 +110,23 @@ std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, st
         system.GetARPManager().Register(launch.title_id, launch, out_control);
         return process;
     }
-    return std::nullopt;
+    return nullptr;
+}
+
+bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id) {
+    auto& storage = system.GetContentProviderUnion();
+    const auto nca_raw = storage.GetEntryRaw(program_id, FileSys::ContentRecordType::Program);
+    if (!nca_raw) {
+        return false;
+    }
+
+    auto loader = Loader::GetLoader(system, nca_raw, program_id, 0);
+    if (!loader) {
+        return false;
+    }
+
+    Loader::ResultStatus status{};
+    return process.Initialize(*loader, status);
 }
 
 } // namespace Service::AM

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

@@ -27,7 +27,9 @@ class Process;
 
 namespace Service::AM {
 
-std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
-std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
+std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
+std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
+
+bool ReinitializeProcess(Core::System& system, Process& process, u64 program_id);
 
 } // namespace Service::AM

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

@@ -35,9 +35,9 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
     std::unique_ptr<Loader::AppLoader> loader;
     Loader::ResultStatus result;
     auto process = CreateApplicationProcess(control, loader, result, system, nca_raw, program_id, 0);
-    R_UNLESS(process != std::nullopt, ResultUnknown);
+    R_UNLESS(process != nullptr, ResultUnknown);
 
-    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
+    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
     applet->program_id = program_id;
     applet->applet_id = AppletId::Application;
     applet->type = AppletType::Application;
@@ -88,9 +88,9 @@ Result IApplicationCreator::CreateSystemApplication(
     std::vector<u8> control;
     std::unique_ptr<Loader::AppLoader> loader;
     auto process = CreateProcess(system, application_id, 1, 22);
-    R_UNLESS(process != std::nullopt, ResultUnknown);
+    R_UNLESS(process != nullptr, ResultUnknown);
 
-    const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
+    const auto applet = std::make_shared<Applet>(system, std::move(process), true);
     applet->program_id = application_id;
     applet->applet_id = AppletId::Starter;
     applet->type = AppletType::LibraryApplet;

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

@@ -75,7 +75,7 @@ ILibraryAppletAccessor::ILibraryAppletAccessor(Core::System& system_,
         {105, D<&ILibraryAppletAccessor::GetPopOutDataEvent>, "GetPopOutDataEvent"},
         {106, D<&ILibraryAppletAccessor::GetPopInteractiveOutDataEvent>, "GetPopInteractiveOutDataEvent"},
         {110, nullptr, "NeedsToExitProcess"},
-        {120, nullptr, "GetLibraryAppletInfo"},
+        {120, D<&ILibraryAppletAccessor::GetLibraryAppletInfo>, "GetLibraryAppletInfo"},
         {150, nullptr, "RequestForAppletToGetForeground"},
         {160, D<&ILibraryAppletAccessor::GetIndirectLayerConsumerHandle>, "GetIndirectLayerConsumerHandle"}, //2.0.0+
         {170, D<&ILibraryAppletAccessor::Unknown170>, "Unknown170"}, //22.0.0+
@@ -218,6 +218,16 @@ Result ILibraryAppletAccessor::GetIndirectLayerConsumerHandle(Out<u64> out_handl
     R_SUCCEED();
 }
 
+Result ILibraryAppletAccessor::GetLibraryAppletInfo(
+    Out<LibraryAppletInfo> out_library_applet_info) {
+    LOG_INFO(Service_AM, "called");
+    *out_library_applet_info = {
+        .applet_id = m_applet->applet_id,
+        .library_applet_mode = m_applet->library_applet_mode,
+    };
+    R_SUCCEED();
+}
+
 Result ILibraryAppletAccessor::Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     *out_event = m_applet->unknown_event.GetHandle();

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

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include "core/hle/service/am/service/library_applet_self_accessor.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 
@@ -21,6 +22,10 @@ public:
                                     std::shared_ptr<Applet> applet);
     ~ILibraryAppletAccessor();
 
+    std::shared_ptr<Applet> GetApplet() const {
+        return m_applet;
+    }
+
 private:
     Result GetAppletStateChangedEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result IsCompleted(Out<bool> out_is_completed);
@@ -37,6 +42,7 @@ private:
     Result GetPopOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetPopInteractiveOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetIndirectLayerConsumerHandle(Out<u64> out_handle);
+    Result GetLibraryAppletInfo(Out<LibraryAppletInfo> out_library_applet_info);
     Result Unknown170(OutCopyHandle<Kernel::KReadableEvent> out_event);
 
     void FrontendExecute();

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

@@ -123,7 +123,7 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
 
     auto process = CreateProcess(system, program_id, Firmware1400, Firmware2200);
     if (process) {
-        const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), false);
+        const auto applet = std::make_shared<Applet>(system, std::move(process), false);
         applet->program_id = program_id;
         applet->applet_id = applet_id;
         applet->type = AppletType::LibraryApplet;

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

@@ -233,8 +233,9 @@ Result ILibraryAppletSelfAccessor::ReportVisibleErrorWithErrorContext(
     R_SUCCEED();
 }
 
-Result ILibraryAppletSelfAccessor::UnpopInData() {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+Result ILibraryAppletSelfAccessor::UnpopInData(SharedPointer<IStorage> storage) {
+    LOG_INFO(Service_AM, "called");
+    m_broker->GetInData().Unpop(system.Kernel(), storage);
     R_SUCCEED();
 }
 

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

@@ -72,7 +72,7 @@ private:
     Result ReportVisibleError(ErrorCode error_code);
     Result ReportVisibleErrorWithErrorContext(
         ErrorCode error_code, InLargeData<ErrorContext, BufferAttr_HipcMapAlias> error_context);
-    Result UnpopInData();
+    Result UnpopInData(SharedPointer<IStorage> storage);
     Result GetMainAppletApplicationDesiredLanguage(Out<u64> out_desired_language);
     Result GetCurrentApplicationId(Out<u64> out_application_id);
     Result GetMainAppletAvailableUsers(Out<bool> out_can_select_any_user, Out<s32> out_users_count,

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

@@ -1,9 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
+#include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/service/library_applet_accessor.h"
 #include "core/hle/service/am/service/process_winding_controller.h"
@@ -43,6 +45,18 @@ Result IProcessWindingController::OpenCallingLibraryApplet(
     Out<SharedPointer<ILibraryAppletAccessor>> out_calling_library_applet) {
     LOG_INFO(Service_AM, "called");
 
+    std::shared_ptr<Applet> reserved_applet;
+    {
+        std::scoped_lock lk{m_applet->lock};
+        reserved_applet = std::move(m_applet->reserved_applet);
+    }
+
+    if (reserved_applet != nullptr) {
+        *out_calling_library_applet = std::make_shared<ILibraryAppletAccessor>(
+            system, reserved_applet->caller_applet_broker, reserved_applet);
+        R_SUCCEED();
+    }
+
     const auto caller_applet = m_applet->caller_applet.lock();
     if (caller_applet == nullptr) {
         LOG_ERROR(Service_AM, "No caller applet available");
@@ -74,22 +88,82 @@ Result IProcessWindingController::PopContext(Out<SharedPointer<IStorage>> out_co
 }
 
 Result IProcessWindingController::CancelWindingReservation() {
-    LOG_WARNING(Service_AM, "STUBBED");
+    LOG_INFO(Service_AM, "called");
+
+    std::scoped_lock lk{m_applet->lock};
+    m_applet->reserved_applet.reset();
+    m_applet->unwind_after_reserved = false;
+
     R_SUCCEED();
 }
 
 Result IProcessWindingController::WindAndDoReserved() {
-    LOG_WARNING(Service_AM, "STUBBED");
+    LOG_INFO(Service_AM, "called");
+
+    std::shared_ptr<Applet> reserved_applet;
+    {
+        std::scoped_lock lk{m_applet->lock};
+
+        reserved_applet = m_applet->reserved_applet;
+        m_applet->display_layer_manager.SetWindowVisibility(false);
+        m_applet->exit_locked = false;
+        system.SetExitLocked(false);
+    }
+
+    if (reserved_applet) {
+        {
+            std::scoped_lock lk{m_applet->lock};
+            m_applet->is_winding = true;
+        }
+
+        {
+            std::scoped_lock lk{reserved_applet->lock};
+            reserved_applet->window_visible = true;
+            reserved_applet->process->Run();
+        }
+
+        if (reserved_applet->frontend) {
+            reserved_applet->frontend->Initialize();
+            reserved_applet->frontend->Execute();
+        }
+    } else {
+        LOG_WARNING(Service_AM, "called without a reserved applet to start");
+    }
+
+    m_applet->process->Terminate();
+
     R_SUCCEED();
 }
 
-Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis() {
-    LOG_WARNING(Service_AM, "STUBBED");
+Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis(
+    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
+    LOG_INFO(Service_AM, "called");
+
+    if (reserved_applet_accessor == nullptr) {
+        LOG_ERROR(Service_AM, "No applet accessor provided");
+        R_THROW(ResultUnknown);
+    }
+
+    std::scoped_lock lk{m_applet->lock};
+    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
+    m_applet->unwind_after_reserved = true;
+
     R_SUCCEED();
 }
 
-Result IProcessWindingController::ReserveToStartAndWait() {
-    LOG_WARNING(Service_AM, "STUBBED");
+Result IProcessWindingController::ReserveToStartAndWait(
+    SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor) {
+    LOG_INFO(Service_AM, "called");
+
+    if (reserved_applet_accessor == nullptr) {
+        LOG_ERROR(Service_AM, "No applet accessor provided");
+        R_THROW(ResultUnknown);
+    }
+
+    std::scoped_lock lk{m_applet->lock};
+    m_applet->reserved_applet = reserved_applet_accessor->GetApplet();
+    m_applet->unwind_after_reserved = false;
+
     R_SUCCEED();
 }
 

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -29,8 +29,9 @@ private:
     Result PopContext(Out<SharedPointer<IStorage>> out_context);
     Result CancelWindingReservation();
     Result WindAndDoReserved();
-    Result ReserveToStartAndWaitAndUnwindThis();
-    Result ReserveToStartAndWait();
+    Result ReserveToStartAndWaitAndUnwindThis(
+        SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
+    Result ReserveToStartAndWait(SharedPointer<ILibraryAppletAccessor> reserved_applet_accessor);
 
     const std::shared_ptr<Applet> m_applet;
 };

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

@@ -9,6 +9,7 @@
 #include "core/hle/service/am/applet.h"
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/event_observer.h"
+#include "core/hle/service/am/process_creation.h"
 #include "core/hle/service/am/window_system.h"
 
 namespace Service::AM {
@@ -240,6 +241,37 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
             continue;
         }
 
+        // A winding applet has had its own process killed but is kept alive as a transparent slot
+        // while the reserved applet running in its place finishes (see WindAndDoReserved()).
+        if (applet->is_winding) {
+            if (!applet->child_applets.empty()) {
+                it = std::next(it);
+                continue;
+            }
+
+            const bool unwind = applet->unwind_after_reserved;
+            applet->is_winding = false;
+            applet->unwind_after_reserved = false;
+
+            if (unwind && this->RestartAppletProcessLocked(applet.get())) {
+                const u64 new_aruid = applet->aruid.pid;
+                const auto next = std::next(it);
+
+                if (new_aruid != aruid) {
+                    auto node = m_applets.extract(it);
+                    node.key() = new_aruid;
+                    m_applets.insert(std::move(node));
+                }
+
+                applet->process->Run();
+                m_event_observer->RequestUpdate();
+                it = next;
+                continue;
+            }
+
+            applet->reserved_applet.reset();
+        }
+
         // Terminated, so ensure all child applets are terminated.
         if (!applet->child_applets.empty()) {
             this->TerminateChildAppletsLocked(applet.get());
@@ -301,6 +333,28 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
     }
 }
 
+bool WindowSystem::RestartAppletProcessLocked(Applet* applet) {
+    if (!ReinitializeProcess(m_system, *applet->process, applet->program_id)) {
+        LOG_ERROR(Service_AM, "Failed to restart winding applet_id={}",
+                  static_cast<u32>(applet->applet_id));
+        return false;
+    }
+
+    applet->aruid.pid = applet->process->GetProcessId();
+    applet->is_process_running = false;
+    applet->is_completed = false;
+
+    applet->hid_registration.RegisterCurrentProcess();
+
+    applet->lifecycle_manager.ResetForRelaunch();
+    applet->is_activity_runnable = false;
+
+    applet->launch_reason.flag = 1;
+
+    m_event_observer->TrackAppletProcess(*applet);
+    return true;
+}
+
 bool WindowSystem::LockHomeMenuIntoForegroundLocked() {
     // If the home menu is not locked into foreground, then there's nothing to do.
     if (m_home_menu == nullptr || !m_home_menu_foreground_locked) {
@@ -352,6 +406,9 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
     const bool has_obscuring_child_applets = [&] {
         for (const auto& child_applet : applet->child_applets) {
             std::scoped_lock lk2{child_applet->lock};
+            if (child_applet->is_winding) {
+                return true;
+            }
             const auto mode = child_applet->library_applet_mode;
             if (child_applet->is_process_running && child_applet->window_visible &&
                 (mode == LibraryAppletMode::AllForeground ||

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

@@ -61,6 +61,7 @@ public:
 
 private:
     void PruneTerminatedAppletsLocked();
+    bool RestartAppletProcessLocked(Applet* applet);
     bool LockHomeMenuIntoForegroundLocked();
     void TerminateChildAppletsLocked(Applet* applet);
     void UpdateAppletStateLocked(Applet* applet, bool is_foreground, bool overlay_blocking = false);

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

@@ -6,6 +6,8 @@
 
 #pragma once
 
+#include <utility>
+
 #include "common/common_types.h"
 
 namespace Core {
@@ -28,6 +30,15 @@ public:
     inline explicit Process(Core::System& system) noexcept : m_system(system) {}
     inline ~Process() { this->Finalize(); }
 
+    Process(const Process&) = delete;
+    Process& operator=(const Process&) = delete;
+    Process& operator=(Process&&) = delete;
+    inline Process(Process&& other) noexcept
+        : m_system(other.m_system), m_process(std::exchange(other.m_process, nullptr)),
+          m_main_thread_stack_size(std::exchange(other.m_main_thread_stack_size, 0)),
+          m_main_thread_priority(std::exchange(other.m_main_thread_priority, 0)),
+          m_process_started(std::exchange(other.m_process_started, false)) {}
+
     bool Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_load_result);
     void Finalize();
 

src/tests/common/host_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,12 +18,19 @@ static constexpr auto PERMS = Common::MemoryPermission::ReadWrite;
 static constexpr auto HEAP = false;
 
 TEST_CASE("HostMemory: Initialize and deinitialize", "[common]") {
-    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
-    { HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE); }
+    {
+        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+        REQUIRE(mem.BackingBasePointer() != nullptr);
+    }
+    {
+        HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+        REQUIRE(mem.BackingBasePointer() != nullptr);
+    }
 }
 
 TEST_CASE("HostMemory: Simple map", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x8000, 0x1000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -30,6 +40,7 @@ TEST_CASE("HostMemory: Simple map", "[common]") {
 
 TEST_CASE("HostMemory: Simple mirror map", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
     mem.Map(0x8000, 0x4000, 0x1000, PERMS, HEAP);
 
@@ -41,6 +52,7 @@ TEST_CASE("HostMemory: Simple mirror map", "[common]") {
 
 TEST_CASE("HostMemory: Simple unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -52,6 +64,7 @@ TEST_CASE("HostMemory: Simple unmap", "[common]") {
 
 TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x5000, 0x3000, 0x2000, PERMS, HEAP);
 
     volatile u8* const data = mem.VirtualBasePointer() + 0x5000;
@@ -69,6 +82,7 @@ TEST_CASE("HostMemory: Simple unmap and remap", "[common]") {
 
 TEST_CASE("HostMemory: Nieche allocation", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x20000, PERMS, HEAP);
     mem.Unmap(0x0000, 0x4000, HEAP);
     mem.Map(0x1000, 0, 0x2000, PERMS, HEAP);
@@ -78,6 +92,7 @@ TEST_CASE("HostMemory: Nieche allocation", "[common]") {
 
 TEST_CASE("HostMemory: Full unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x8000, 0x4000, HEAP);
     mem.Map(0x6000, 0, 0x16000, PERMS, HEAP);
@@ -85,6 +100,7 @@ TEST_CASE("HostMemory: Full unmap", "[common]") {
 
 TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x2000, 0x4000, HEAP);
     mem.Map(0x2000, 0x80000, 0x4000, PERMS, HEAP);
@@ -92,6 +108,7 @@ TEST_CASE("HostMemory: Right out of bounds unmap", "[common]") {
 
 TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x6000, 0x4000, HEAP);
     mem.Map(0x8000, 0, 0x2000, PERMS, HEAP);
@@ -99,6 +116,7 @@ TEST_CASE("HostMemory: Left out of bounds unmap", "[common]") {
 
 TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x4000, 0, 0x1b000, PERMS, HEAP);
     mem.Unmap(0x3000, 0x1c000, HEAP);
@@ -107,6 +125,7 @@ TEST_CASE("HostMemory: Multiple placeholder unmap", "[common]") {
 
 TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x0000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x2000, 0x4000, HEAP);
@@ -115,6 +134,7 @@ TEST_CASE("HostMemory: Unmap between placeholders", "[common]") {
 
 TEST_CASE("HostMemory: Unmap to origin", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x4000, 0x4000, HEAP);
@@ -124,6 +144,7 @@ TEST_CASE("HostMemory: Unmap to origin", "[common]") {
 
 TEST_CASE("HostMemory: Unmap to right", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0, 0x4000, PERMS, HEAP);
     mem.Map(0x8000, 0, 0x4000, PERMS, HEAP);
     mem.Unmap(0x8000, 0x4000, HEAP);
@@ -132,6 +153,7 @@ TEST_CASE("HostMemory: Unmap to right", "[common]") {
 
 TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -144,6 +166,7 @@ TEST_CASE("HostMemory: Partial right unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -158,6 +181,7 @@ TEST_CASE("HostMemory: Partial left unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x4000, PERMS, HEAP);
 
     volatile u8* const ptr = mem.VirtualBasePointer() + 0x4000;
@@ -172,6 +196,7 @@ TEST_CASE("HostMemory: Partial middle unmap check bindings", "[common]") {
 
 TEST_CASE("HostMemory: Partial sparse middle unmap and check bindings", "[common]") {
     HostMemory mem(BACKING_SIZE, VIRTUAL_SIZE);
+    REQUIRE(mem.BackingBasePointer() != nullptr);
     mem.Map(0x4000, 0x10000, 0x2000, PERMS, HEAP);
     mem.Map(0x6000, 0x20000, 0x2000, PERMS, HEAP);
 

src/video_core/buffer_cache/buffer_cache.h

@@ -1619,35 +1619,36 @@ void BufferCache<P>::TouchBuffer(Buffer& buffer, BufferId buffer_id) noexcept {
 template <class P>
 bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 size) {
     upload_copies.clear();
-    u64 total_size_bytes = 0;
+    u64 staging_offset = 0;
     u64 largest_copy = 0;
-    const DAddr buffer_start = buffer.cpu_addr_cached;
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
-        upload_copies.push_back(BufferCopy{
-            .src_offset = total_size_bytes,
-            .dst_offset = device_addr_out - buffer_start,
-            .size = range_size,
+    DAddr buffer_start = buffer.CpuAddr();
+    auto push = [&](u64 start, u64 end) {
+        if (start >= end) {
+            return;
+        }
+        u64 sz = end - start;
+        upload_copies.push_back({
+            .src_offset = staging_offset,
+            .dst_offset = start - buffer_start,
+            .size = sz
         });
-        total_size_bytes += range_size;
-        largest_copy = (std::max)(largest_copy, range_size);
+        staging_offset += sz;
+        largest_copy = (std::max)(largest_copy, sz);
+    };
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 addr, u64 range_size) {
+        u64 start = addr;
+        u64 end = addr + range_size;
+        gpu_modified_ranges.ForEachInRange(start, range_size, [&](u64 gstart, u64 gsize) {
+            u64 gend = gstart + gsize;
+            push(start, gstart);
+            start = (std::max)(start, gend);
+        });
+        push(start, end);
     });
-    if (total_size_bytes == 0) {
+    if (upload_copies.empty()) {
         return true;
     }
-    if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-        u64 min_offset = (std::numeric_limits<u64>::max)();
-        u64 max_offset = 0;
-        for (const auto& copy : upload_copies) {
-            min_offset = (std::min)(min_offset, copy.dst_offset);
-            max_offset = (std::max)(max_offset, copy.dst_offset + copy.size);
-        }
-        const DAddr sync_addr = buffer.CpuAddr() + min_offset;
-        const u64 sync_size = max_offset - min_offset;
-        DownloadBufferMemory(buffer, sync_addr, sync_size);
-    }
-    const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
-    UploadMemory(buffer, total_size_bytes, largest_copy, copies_span);
-    any_buffer_uploaded = true;
+    UploadMemory(buffer, staging_offset, largest_copy, std::span(upload_copies));
     return false;
 }
 
@@ -1698,6 +1699,7 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
             u8* const src_pointer = staging_pointer.data() + copy.src_offset;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
             device_memory.ReadBlockUnsafe(device_addr, src_pointer, copy.size);
+
             // Apply the staging offset
             copy.src_offset += upload_staging.offset;
         }

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -492,10 +492,14 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         device.IsExtExtendedDynamicState3BlendingSupported();
     dynamic_features.has_extended_dynamic_state_3_enables =
         device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
+    dynamic_features.has_dynamic_state3_depth_clamp_enable =
+        dynamic_features.has_extended_dynamic_state_3_enables &&
+        device.SupportsDynamicState3DepthClampEnable();
     dynamic_features.has_dynamic_state3_logic_op_enable =
+        dynamic_features.has_extended_dynamic_state_3_enables &&
         device.SupportsDynamicState3LogicOpEnable();
     dynamic_features.has_dynamic_state3_line_stipple_enable =
+        dynamic_features.has_extended_dynamic_state_3_enables &&
         device.SupportsDynamicState3LineStippleEnable();
 
     // VIDS: Independent toggle (not affected by dyna_state levels)

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -218,8 +218,7 @@ public:
         }
         PauseCounter();
         const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
             pending_sync.clear();
             sync_values_stash.clear();
             return;