return ResultSessionClosed when a session is closed

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md)
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------
This one deserves a long story, but imma try to resume:

During investigating Absolum 1.2 black screen of death upon loading intro video, i've discovered guest was aborting for failing to allocate room for the video.

By logging everything prior to crash and decoding guest side instructions managed to confirm its media allocator was reading data faster than it was updating free available bucket list.

Since the IStorage::Read was happening 247 times before the crash, i've decided to add a very small sleep there, and boom, not only Absolum but some other titles got the same issue fixed.

But i was unsatisfied with the sleep and kept tracking guest instructions upstream in order to find a sync point for the read worker and the memory allocation update. But unfortunately the media allocator helpers live in guest, accessing memory directly via MMU, so any sync signaling would need to come from some dynarmic hack.

It's been 6 days now, so i've decided to polish the sleep: Moved it upstream to where i could have access for proper predicate, and added machinery to service and nvhost to support that. Now the sleep is restricted only for nvdec istorage reads. Any other reads will flow normally.

TL;DR: currently our code is so blazing async that guest is capable to request reads before its very self refresh it have freed room to do so. The sleep accepted as broadly stable was 600 us (MICROseconds), and it affects ONLY nvdec chunk reading.
Reports confirm that now videos are smoother now.

Code was polished at my knowledge limits.
Mostly machinery to track when a request comes from a process with nvdec active, and is istorage read.
I can provide more details if it comes to be needed.

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4316
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: Samuel <lizzie@eden-emu.dev>

src/core/core.cpp

@@ -4,6 +4,7 @@
 #include <array>
 #include <atomic>
 #include <memory>
+#include <unordered_map>
 #include <utility>
 
 #include "game_settings.h"
@@ -248,12 +249,30 @@ struct System::Impl {
         }
     }
 
-    void SetNVDECActive(bool is_nvdec_active) {
-        nvdec_active = is_nvdec_active;
+    void NotifyNVDECChannelOpen(u64 process_id) {
+        std::scoped_lock lock{nvdec_active_mutex};
+        ++nvdec_active_channels[process_id];
+    }
+
+    void NotifyNVDECChannelClose(u64 process_id) {
+        std::scoped_lock lock{nvdec_active_mutex};
+        const auto it = nvdec_active_channels.find(process_id);
+        if (it == nvdec_active_channels.end()) {
+            return;
+        }
+        if (--it->second == 0) {
+            nvdec_active_channels.erase(it);
+        }
     }
 
     bool GetNVDECActive() {
-        return nvdec_active;
+        std::scoped_lock lock{nvdec_active_mutex};
+        return !nvdec_active_channels.empty();
+    }
+
+    bool IsNVDECActiveForProcess(u64 process_id) {
+        std::scoped_lock lock{nvdec_active_mutex};
+        return nvdec_active_channels.contains(process_id);
     }
 
     void InitializeDebugger(System& system, u16 port) {
@@ -505,6 +524,8 @@ struct System::Impl {
 
     mutable std::mutex suspend_guard;
     std::mutex general_channel_mutex;
+    std::mutex nvdec_active_mutex;
+    std::unordered_map<u64, u32> nvdec_active_channels;
     std::atomic_bool is_paused{};
     std::atomic_bool is_shutting_down{};
     std::atomic_bool is_powered_on{};
@@ -512,7 +533,6 @@ struct System::Impl {
     bool extended_memory_layout : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
-    bool nvdec_active : 1 = false;
 
     void EnsureGeneralChannelInitialized(System& system) {
         if (!general_channel_event) {
@@ -576,14 +596,22 @@ void System::UnstallApplication() {
     impl->UnstallApplication();
 }
 
-void System::SetNVDECActive(bool is_nvdec_active) {
-    impl->SetNVDECActive(is_nvdec_active);
+void System::NotifyNVDECChannelOpen(u64 process_id) {
+    impl->NotifyNVDECChannelOpen(process_id);
+}
+
+void System::NotifyNVDECChannelClose(u64 process_id) {
+    impl->NotifyNVDECChannelClose(process_id);
 }
 
 bool System::GetNVDECActive() {
     return impl->GetNVDECActive();
 }
 
+bool System::IsNVDECActiveForProcess(u64 process_id) {
+    return impl->IsNVDECActiveForProcess(process_id);
+}
+
 void System::InitializeDebugger() {
     impl->InitializeDebugger(*this, Settings::values.gdbstub_port.GetValue());
 }

src/core/core.h

@@ -191,8 +191,10 @@ public:
     std::unique_lock<std::mutex> StallApplication();
     void UnstallApplication();
 
-    void SetNVDECActive(bool is_nvdec_active);
+    void NotifyNVDECChannelOpen(u64 process_id);
+    void NotifyNVDECChannelClose(u64 process_id);
     [[nodiscard]] bool GetNVDECActive();
+    [[nodiscard]] bool IsNVDECActiveForProcess(u64 process_id);
 
     /**
      * Initialize the debugger.

src/core/hle/kernel/k_server_session.cpp

@@ -1216,7 +1216,7 @@ Result KServerSession::ReceiveRequest(KernelCore& kernel, uintptr_t server_messa
 }
 
 Result KServerSession::SendReply(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
-                                 KPhysicalAddress server_message_paddr, bool is_hle) {
+                                 KPhysicalAddress server_message_paddr, bool is_hle, bool session_closed) {
     // Lock the session.
     KScopedLightLock lk{m_lock};
 
@@ -1248,7 +1248,7 @@ Result KServerSession::SendReply(KernelCore& kernel, uintptr_t server_message, u
     KEvent* event = request->GetEvent();
 
     // Check whether we're closed.
-    const bool closed = (client_thread == nullptr || m_parent->IsClientClosed());
+    const bool closed = (client_thread == nullptr || m_parent->IsClientClosed() || session_closed);
 
     Result result = ResultSuccess;
     if (!closed) {

src/core/hle/kernel/k_server_session.h

@@ -54,14 +54,14 @@ public:
 
     Result OnRequest(KernelCore& kernel, KSessionRequest* request);
     Result SendReply(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
-                     KPhysicalAddress server_message_paddr, bool is_hle = false);
+                     KPhysicalAddress server_message_paddr, bool is_hle = false, bool session_closed = false);
     Result ReceiveRequest(KernelCore& kernel, uintptr_t server_message, uintptr_t server_buffer_size,
                           KPhysicalAddress server_message_paddr,
                           std::shared_ptr<Service::HLERequestContext>* out_context = nullptr,
                           std::weak_ptr<Service::SessionRequestManager> manager = {});
 
-    Result SendReplyHLE(KernelCore& kernel) {
-        R_RETURN(this->SendReply(kernel, 0, 0, 0, true));
+    Result SendReplyHLE(KernelCore& kernel, bool session_closed = false) {
+        R_RETURN(this->SendReply(kernel, 0, 0, 0, true, session_closed));
     }
 
     Result ReceiveRequestHLE(KernelCore& kernel, std::shared_ptr<Service::HLERequestContext>* out_context,

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

@@ -25,33 +25,42 @@ NvMap::Handle::Handle(u64 size_, Id id_)
     flags.raw = 0;
 }
 
-NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress, NvCore::SessionId pSessionId) {
+NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress,
+                              NvCore::SessionId pSessionId) {
+    std::scoped_lock lock(mutex);
     // Handles cannot be allocated twice
     if (allocated) {
         return NvResult::AccessDenied;
     }
+
     flags = pFlags;
     kind = pKind;
     align = pAlign < YUZU_PAGESIZE ? YUZU_PAGESIZE : pAlign;
     session_id = pSessionId;
+
     // This flag is only applicable for handles with an address passed
     if (pAddress) {
         flags.keep_uncached_after_free.Assign(0);
     } else {
-        LOG_CRITICAL(Service_NVDRV, "Mapping nvmap handles without a CPU side address is unimplemented!");
+        LOG_CRITICAL(Service_NVDRV,
+                     "Mapping nvmap handles without a CPU side address is unimplemented!");
     }
+
     size = Common::AlignUp(size, YUZU_PAGESIZE);
     aligned_size = Common::AlignUp(size, align);
     address = pAddress;
     allocated = true;
+
     return NvResult::Success;
 }
 
 NvResult NvMap::Handle::Duplicate(bool internal_session) {
+    std::scoped_lock lock(mutex);
     // Unallocated handles cannot be duplicated as duplication requires memory accounting (in HOS)
     if (!allocated) [[unlikely]] {
         return NvResult::BadValue;
     }
+
     // If we internally use FromId the duplication tracking of handles won't work accurately due to
     // us not implementing per-process handle refs.
     if (internal_session) {
@@ -59,14 +68,16 @@ NvResult NvMap::Handle::Duplicate(bool internal_session) {
     } else {
         dupes++;
     }
+
     return NvResult::Success;
 }
 
 NvMap::NvMap(Container& core_, Tegra::Host1x::Host1x& host1x_) : host1x{host1x_}, core{core_} {}
 
-void NvMap::AddHandle(Handle&& handle_description) {
-    std::scoped_lock l(handles_lock);
-    handles.insert_or_assign(handle_description.id, std::move(handle_description));
+void NvMap::AddHandle(std::shared_ptr<Handle> handle_description) {
+    std::scoped_lock lock(handles_lock);
+
+    handles.emplace(handle_description->id, std::move(handle_description));
 }
 
 void NvMap::UnmapHandle(Handle& handle_description) {
@@ -105,48 +116,57 @@ void NvMap::UnmapHandle(Handle& handle_description) {
 bool NvMap::TryRemoveHandle(const Handle& handle_description) {
     // No dupes left, we can remove from handle map
     if (handle_description.dupes == 0 && handle_description.internal_dupes == 0) {
-        std::scoped_lock l(handles_lock);
-        auto it = handles.find(handle_description.id);
+        std::scoped_lock lock(handles_lock);
+
+        auto it{handles.find(handle_description.id)};
         if (it != handles.end()) {
             handles.erase(it);
         }
+
         return true;
     } else {
         return false;
     }
 }
 
-NvResult NvMap::CreateHandle(u64 size, Handle::Id& out_handle) {
-    if (!Common::AlignUp(size, YUZU_PAGESIZE)) {
+NvResult NvMap::CreateHandle(u64 size, std::shared_ptr<NvMap::Handle>& result_out) {
+    if (!size) [[unlikely]] {
         return NvResult::BadValue;
     }
-    u32 id = next_handle_id.fetch_add(HandleIdIncrement, std::memory_order_relaxed);
-    AddHandle(Handle(size, id));
-    out_handle = id;
+
+    u32 id{next_handle_id.fetch_add(HandleIdIncrement, std::memory_order_relaxed)};
+    auto handle_description{std::make_shared<Handle>(size, id)};
+    AddHandle(handle_description);
+
+    result_out = handle_description;
     return NvResult::Success;
 }
 
-std::optional<std::reference_wrapper<NvMap::Handle>> NvMap::GetHandle(Handle::Id handle) {
-    if (auto const it = handles.find(handle); it != handles.end())
-        return {it->second};
-    return std::nullopt;
+std::shared_ptr<NvMap::Handle> NvMap::GetHandle(Handle::Id handle) {
+    std::scoped_lock lock(handles_lock);
+    try {
+        return handles.at(handle);
+    } catch (std::out_of_range&) {
+        return nullptr;
+    }
 }
 
 DAddr NvMap::GetHandleAddress(Handle::Id handle) {
-    if (auto const it = handles.find(handle); it != handles.end())
-        return it->second.d_address;
-    return 0;
+    std::scoped_lock lock(handles_lock);
+    try {
+        return handles.at(handle)->d_address;
+    } catch (std::out_of_range&) {
+        return 0;
+    }
 }
 
 DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
-    std::scoped_lock lock(handles_lock);
-    auto o = GetHandle(handle);
-    if (!o) [[unlikely]] {
+    auto handle_description{GetHandle(handle)};
+    if (!handle_description) [[unlikely]] {
         return 0;
     }
 
-    auto handle_description = &o->get();
-
+    std::scoped_lock lock(handle_description->mutex);
     const auto map_low_area = [&] {
         if (handle_description->pin_virt_address == 0) {
             u32 address = host1x.Allocator().Allocate(u32(handle_description->aligned_size));
@@ -160,15 +180,17 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
         {
             // Lock now to prevent our queue entry from being removed for allocation in-between the
             // following check and erase
-            std::scoped_lock ql(unmap_queue_lock);
+            std::scoped_lock queueLock(unmap_queue_lock);
             if (handle_description->unmap_queue_entry) {
                 unmap_queue.erase(*handle_description->unmap_queue_entry);
                 handle_description->unmap_queue_entry.reset();
+
                 if (low_area_pin) {
                     map_low_area();
                     handle_description->pins++;
-                    return DAddr(handle_description->pin_virt_address);
+                    return static_cast<DAddr>(handle_description->pin_virt_address);
                 }
+
                 handle_description->pins++;
                 return handle_description->d_address;
             }
@@ -189,11 +211,12 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
             while ((address = smmu.Allocate(aligned_up)) == 0) {
                 // Free handles until the allocation succeeds
                 std::scoped_lock queueLock(unmap_queue_lock);
-                if (auto free_handle = handles.find(unmap_queue.front()); free_handle != handles.end()) {
+                if (auto freeHandleDesc{unmap_queue.front()}) {
                     // Handles in the unmap queue are guaranteed not to be pinned so don't bother
                     // checking if they are before unmapping
+                    std::scoped_lock freeLock(freeHandleDesc->mutex);
                     if (handle_description->d_address)
-                        UnmapHandle(free_handle->second);
+                        UnmapHandle(*freeHandleDesc);
                 } else {
                     LOG_CRITICAL(Service_NVDRV, "Ran out of SMMU address space!");
                 }
@@ -211,44 +234,51 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
 
     handle_description->pins++;
     if (low_area_pin) {
-        return DAddr(handle_description->pin_virt_address);
+        return static_cast<DAddr>(handle_description->pin_virt_address);
     }
     return handle_description->d_address;
 }
 
 void NvMap::UnpinHandle(Handle::Id handle) {
-    std::scoped_lock lock(handles_lock);
-    if (auto o = GetHandle(handle); o) {
-        auto handle_description = &o->get();
-        if (--handle_description->pins < 0) {
-            LOG_WARNING(Service_NVDRV, "Pin count imbalance detected!");
-        } else if (!handle_description->pins) {
-            std::scoped_lock ql(unmap_queue_lock);
-            // Add to the unmap queue allowing this handle's memory to be freed if needed
-            unmap_queue.push_back(handle);
-            handle_description->unmap_queue_entry = std::prev(unmap_queue.end());
-        }
+    auto handle_description{GetHandle(handle)};
+    if (!handle_description) {
+        return;
+    }
+
+    std::scoped_lock lock(handle_description->mutex);
+    if (--handle_description->pins < 0) {
+        LOG_WARNING(Service_NVDRV, "Pin count imbalance detected!");
+    } else if (!handle_description->pins) {
+        std::scoped_lock queueLock(unmap_queue_lock);
+
+        // Add to the unmap queue allowing this handle's memory to be freed if needed
+        unmap_queue.push_back(handle_description);
+        handle_description->unmap_queue_entry = std::prev(unmap_queue.end());
     }
 }
 
 void NvMap::DuplicateHandle(Handle::Id handle, bool internal_session) {
-    std::scoped_lock lock(handles_lock);
-    auto o = GetHandle(handle);
-    if (!o) {
+    auto handle_description{GetHandle(handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Unregistered handle!");
         return;
     }
-    auto result = o->get().Duplicate(internal_session);
+
+    auto result = handle_description->Duplicate(internal_session);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Could not duplicate handle!");
     }
 }
 
 std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool internal_session) {
-    // We use a weak ptr here so we can tell when the handle has been freed and report that back to guest
-    std::scoped_lock lock(handles_lock);
-    if (auto o = GetHandle(handle); o) {
-        auto handle_description = &o->get();
+    std::weak_ptr<Handle> hWeak{GetHandle(handle)};
+    FreeInfo freeInfo;
+
+    // We use a weak ptr here so we can tell when the handle has been freed and report that back to
+    // guest
+    if (auto handle_description = hWeak.lock()) {
+        std::scoped_lock lock(handle_description->mutex);
+
         if (internal_session) {
             if (--handle_description->internal_dupes < 0)
                 LOG_WARNING(Service_NVDRV, "Internal duplicate count imbalance detected!");
@@ -258,25 +288,25 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
             } else if (handle_description->dupes == 0) {
                 // Force unmap the handle
                 if (handle_description->d_address) {
-                    std::scoped_lock ql(unmap_queue_lock);
+                    std::scoped_lock queueLock(unmap_queue_lock);
                     UnmapHandle(*handle_description);
                 }
+
                 handle_description->pins = 0;
             }
         }
+
         // Try to remove the shared ptr to the handle from the map, if nothing else is using the
         // handle then it will now be freed when `handle_description` goes out of scope
         if (TryRemoveHandle(*handle_description)) {
             LOG_DEBUG(Service_NVDRV, "Removed nvmap handle: {}", handle);
         } else {
-            LOG_DEBUG(Service_NVDRV, "Tried to free nvmap handle: {} but didn't as it still has duplicates", handle);
+            LOG_DEBUG(Service_NVDRV,
+                      "Tried to free nvmap handle: {} but didn't as it still has duplicates",
+                      handle);
         }
-        // // If the handle hasn't been freed from memory, mark that
-        // if (!hWeak.expired()) {
-        //     LOG_DEBUG(Service_NVDRV, "nvmap handle: {} wasn't freed as it is still in use", handle);
-        //     freeInfo.can_unlock = false;
-        // }
-        return FreeInfo{
+
+        freeInfo = {
             .address = handle_description->address,
             .size = handle_description->size,
             .was_uncached = handle_description->flags.map_uncached.Value() != 0,
@@ -285,15 +315,30 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
     } else {
         return std::nullopt;
     }
+
+    // If the handle hasn't been freed from memory, mark that
+    if (!hWeak.expired()) {
+        LOG_DEBUG(Service_NVDRV, "nvmap handle: {} wasn't freed as it is still in use", handle);
+        freeInfo.can_unlock = false;
+    }
+
+    return freeInfo;
 }
 
 void NvMap::UnmapAllHandles(NvCore::SessionId session_id) {
-    std::scoped_lock lk{handles_lock};
-    for (auto it = handles.begin(); it != handles.end(); ++it) {
-        if (it->second.session_id.id != session_id.id || it->second.dupes <= 0) {
-            continue;
+    auto handles_copy = [&] {
+        std::scoped_lock lk{handles_lock};
+        return handles;
+    }();
+
+    for (auto& [id, handle] : handles_copy) {
+        {
+            std::scoped_lock lk{handle->mutex};
+            if (handle->session_id.id != session_id.id || handle->dupes <= 0) {
+                continue;
+            }
         }
-        FreeHandle(it->first, false);
+        FreeHandle(id, false);
     }
 }
 

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

@@ -12,11 +12,6 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#if BOOST_VERSION >= 109000
-#include <boost/unordered/unordered_node_map.hpp>
-#else
-#include <unordered_map>
-#endif
 #include <ankerl/unordered_dense.h>
 #include <assert.h>
 
@@ -36,36 +31,54 @@ class Host1x;
 namespace Service::Nvidia::NvCore {
 
 class Container;
-/// @brief The nvmap core class holds the global state for nvmap and provides methods to manage handles
+/**
+ * @brief The nvmap core class holds the global state for nvmap and provides methods to manage
+ * handles
+ */
 class NvMap {
 public:
-    /// @brief A handle to a contiguous block of memory in an application's address space
+    /**
+     * @brief A handle to a contiguous block of memory in an application's address space
+     */
     struct Handle {
-        using Id = u32;
-        std::optional<typename std::list<Handle::Id>::iterator> unmap_queue_entry{};
+        std::mutex mutex;
+
         u64 align{};      //!< The alignment to use when pinning the handle onto the SMMU
         u64 size;         //!< Page-aligned size of the memory the handle refers to
         u64 aligned_size; //!< `align`-aligned size of the memory the handle refers to
         u64 orig_size;    //!< Original unaligned size of the memory this handle refers to
-        DAddr d_address{}; //!< The memory location in the device's AS that this handle corresponds to, this can also be in the nvdrv tmem
-        VAddr address{}; //!< The memory location in the guest's AS that this handle corresponds to, this can also be in the nvdrv tmem
-        s64 pins{};
+
         s32 dupes{1};          //!< How many guest references there are to this handle
         s32 internal_dupes{0}; //!< How many emulator-internal references there are to this handle
+
+        using Id = u32;
         Id id; //!< A globally unique identifier for this handle
+
+        s64 pins{};
         u32 pin_virt_address{};
+        std::optional<typename std::list<std::shared_ptr<Handle>>::iterator> unmap_queue_entry{};
+
         union Flags {
             u32 raw;
             BitField<0, 1, u32> map_uncached; //!< If the handle should be mapped as uncached
-            BitField<2, 1, u32> keep_uncached_after_free; //!< Only applicable when the handle was allocated with a fixed address
-            BitField<4, 1, u32> _unk0_; //!< Passed to IOVMM for pins
+            BitField<2, 1, u32> keep_uncached_after_free; //!< Only applicable when the handle was
+                                                          //!< allocated with a fixed address
+            BitField<4, 1, u32> _unk0_;                   //!< Passed to IOVMM for pins
         } flags{};
         static_assert(sizeof(Flags) == sizeof(u32));
-        NvCore::SessionId session_id{};
+
+        VAddr address{}; //!< The memory location in the guest's AS that this handle corresponds to,
+                         //!< this can also be in the nvdrv tmem
+        bool is_shared_mem_mapped{}; //!< If this nvmap has been mapped with the MapSharedMem IPC
+                                     //!< call
+
         u8 kind{};        //!< Used for memory compression
-        bool allocated : 1 = false; //!< If the handle has been allocated with `Alloc`
-        bool in_heap : 1 = false;
-        bool is_shared_mem_mapped : 1 = false; //!< If this nvmap has been mapped with the MapSharedMem IPC < call
+        bool allocated{}; //!< If the handle has been allocated with `Alloc`
+        bool in_heap{};
+        NvCore::SessionId session_id{};
+
+        DAddr d_address{}; //!< The memory location in the device's AS that this handle corresponds
+                           //!< to, this can also be in the nvdrv tmem
 
         Handle(u64 size, Id id);
 
@@ -110,9 +123,9 @@ public:
     /**
      * @brief Creates an unallocated handle of the given size
      */
-    [[nodiscard]] NvResult CreateHandle(u64 size, Handle::Id& out_handle);
+    [[nodiscard]] NvResult CreateHandle(u64 size, std::shared_ptr<NvMap::Handle>& result_out);
 
-    std::optional<std::reference_wrapper<Handle>> GetHandle(Handle::Id handle);
+    std::shared_ptr<Handle> GetHandle(Handle::Id handle);
 
     DAddr GetHandleAddress(Handle::Id handle);
 
@@ -144,21 +157,20 @@ public:
 
     void UnmapAllHandles(NvCore::SessionId session_id);
 
-    std::list<Handle::Id> unmap_queue{};
-    /// Main owning map of handles
-#if BOOST_VERSION >= 109000
-    boost::unordered_node_map<Handle::Id, Handle> handles{};
-#else
-    std::unordered_map<Handle::Id, Handle> handles{};
-#endif
+private:
+    std::list<std::shared_ptr<Handle>> unmap_queue{};
     std::mutex unmap_queue_lock{}; //!< Protects access to `unmap_queue`
+
+    ankerl::unordered_dense::map<Handle::Id, std::shared_ptr<Handle>>
+        handles{};           //!< Main owning map of handles
     std::mutex handles_lock; //!< Protects access to `handles`
-    static constexpr u32 HandleIdIncrement{4}; //!< Each new handle ID is an increment of 4 from the previous
+
+    static constexpr u32 HandleIdIncrement{
+        4}; //!< Each new handle ID is an increment of 4 from the previous
     std::atomic<u32> next_handle_id{HandleIdIncrement};
     Tegra::Host1x::Host1x& host1x;
-    Container& core;
 
-    void AddHandle(Handle&& handle);
+    void AddHandle(std::shared_ptr<Handle> handle);
 
     /**
      * @brief Unmaps and frees the SMMU memory region a handle is mapped to
@@ -172,5 +184,7 @@ public:
      * @return If the handle was removed from the map
      */
     bool TryRemoveHandle(const Handle& handle_description);
+
+    Container& core;
 };
 } // namespace Service::Nvidia::NvCore

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

@@ -328,11 +328,10 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         }
     }
 
-    auto o = nvmap.GetHandle(params.handle);
-    if (!o) {
+    auto handle{nvmap.GetHandle(params.handle)};
+    if (!handle) {
         return NvResult::BadValue;
     }
-    auto handle = &o->get();
 
     DAddr device_address = DAddr(nvmap.PinHandle(params.handle, false) + params.buffer_offset);
     u64 size{params.mapping_size ? params.mapping_size : handle->orig_size};

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

@@ -8,6 +8,7 @@
 #include "common/assert.h"
 #include "common/logging.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
@@ -71,17 +72,23 @@ NvResult nvhost_nvdec::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
 
 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;
+    if (const auto* session = core.GetSession(session_id);
+        session != nullptr && session->process != nullptr) {
+        system.NotifyNVDECChannelOpen(session->process->GetId());
+    }
     host1x.StartDevice(fd, Tegra::Host1x::ChannelType::NvDec, channel_syncpoint);
 }
 
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
     host1x.StopDevice(fd, Tegra::Host1x::ChannelType::NvDec);
-    system.SetNVDECActive(false);
     auto it = sessions.find(fd);
     if (it != sessions.end()) {
+        if (const auto* session = core.GetSession(it->second);
+            session != nullptr && session->process != nullptr) {
+            system.NotifyNVDECChannelClose(session->process->GetId());
+        }
         sessions.erase(it);
     }
 }

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

@@ -103,13 +103,17 @@ NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, De
 
     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);
+        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;);
-        Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader, Core::Memory::GuestMemoryFlags::SafeRead> cmdlist(session->process->GetMemory(), object->get().address + cmd_buffer.offset, cmd_buffer.word_count);
+        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));
     }
 

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

@@ -83,14 +83,17 @@ void nvmap::OnClose(DeviceFD fd) {
 NvResult nvmap::IocCreate(IocCreateParams& params) {
     LOG_DEBUG(Service_NVDRV, "called, size={:#08x}", params.size);
 
-    NvCore::NvMap::Handle handle_description(0, 0);
-    // Orig size is the unaligned size, set the handle to that
-    auto result = file.CreateHandle(params.size, params.handle);
+    std::shared_ptr<NvCore::NvMap::Handle> handle_description{};
+    auto result =
+        file.CreateHandle(Common::AlignUp(params.size, YUZU_PAGESIZE), handle_description);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Failed to create Object");
         return result;
     }
-    LOG_DEBUG(Service_NVDRV, "handle: {}, size: {:#x}", params.handle, params.size);
+    handle_description->orig_size = params.size; // Orig size is the unaligned size
+    params.handle = handle_description->id;
+    LOG_DEBUG(Service_NVDRV, "handle: {}, size: {:#x}", handle_description->id, params.size);
+
     return NvResult::Success;
 }
 
@@ -112,27 +115,30 @@ NvResult nvmap::IocAlloc(IocAllocParams& params, DeviceFD fd) {
         params.align = YUZU_PAGESIZE;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.handle);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
         return NvResult::BadValue;
     }
 
-    auto handle_description = &o->get();
     if (handle_description->allocated) {
         LOG_CRITICAL(Service_NVDRV, "Object is already allocated, handle={:08X}", params.handle);
         return NvResult::InsufficientMemory;
     }
 
-    const auto result = handle_description->Alloc(params.flags, params.align, params.kind, params.address, sessions[fd]);
+    const auto result = handle_description->Alloc(params.flags, params.align, params.kind,
+                                                  params.address, sessions[fd]);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Object failed to allocate, handle={:08X}", params.handle);
         return result;
     }
     bool is_out_io{};
     auto process = container.GetSession(sessions[fd])->process;
-    ASSERT(process->GetPageTable().LockForMapDeviceAddressSpace(&is_out_io, handle_description->address, handle_description->size, Kernel::KMemoryPermission::None, true, false).IsSuccess());
+    ASSERT(process->GetPageTable()
+               .LockForMapDeviceAddressSpace(&is_out_io, handle_description->address,
+                                             handle_description->size,
+                                             Kernel::KMemoryPermission::None, true, false)
+               .IsSuccess());
     return result;
 }
 
@@ -145,13 +151,13 @@ NvResult nvmap::IocGetId(IocGetIdParams& params) {
         return NvResult::BadValue;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.handle);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Error!");
-        return NvResult::AccessDenied; // This will always return EPERM irrespective of if the handle exists or not
+        return NvResult::AccessDenied; // This will always return EPERM irrespective of if the
+                                       // handle exists or not
     }
-    auto handle_description = &o->get();
+
     params.id = handle_description->id;
     return NvResult::Success;
 }
@@ -168,14 +174,12 @@ NvResult nvmap::IocFromId(IocFromIdParams& params) {
         return NvResult::BadValue;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.id);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.id)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Unregistered handle!");
         return NvResult::BadValue;
     }
 
-    auto handle_description = &o->get();
     auto result = handle_description->Duplicate(false);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Could not duplicate handle!");
@@ -195,14 +199,12 @@ NvResult nvmap::IocParam(IocParamParams& params) {
         return NvResult::BadValue;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.handle);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Not registered handle!");
         return NvResult::BadValue;
     }
 
-    auto handle_description = &o->get();
     switch (params.param) {
     case HandleParameterType::Size:
         params.result = static_cast<u32_le>(handle_description->orig_size);

src/core/hle/service/server_manager.cpp

@@ -393,7 +393,7 @@ Result ServerManager::CompleteSyncRequest(Session* session) {
     }
 
     // Send the reply.
-    res = server_session->SendReplyHLE(m_system.Kernel());
+    res = server_session->SendReplyHLE(m_system.Kernel(), service_res == IPC::ResultSessionClosed);
 
     // If the session has been closed, we're done.
     if (res == Kernel::ResultSessionClosed || service_res == IPC::ResultSessionClosed) {

src/core/hle/service/service.cpp

@@ -4,12 +4,16 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <chrono>
 #include <fmt/ranges.h>
+#include <string_view>
+#include <thread>
 #include "common/assert.h"
 #include "common/logging.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/hle/ipc.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/service.h"
@@ -33,6 +37,7 @@ ServiceFrameworkBase::ServiceFrameworkBase(Core::System& system_, const char* se
     : SessionRequestHandler(system_.Kernel(), service_name_)
     , system{system_}
     , service_name{service_name_}
+    , is_i_storage{std::string_view{service_name_} == "IStorage"}
     , handler_invoker{handler_invoker_}
     , max_sessions{max_sessions_}
 {}
@@ -77,13 +82,22 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx,
 }
 
 void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
-    auto it = handlers.find(ctx.GetCommand());
+    const auto command = ctx.GetCommand();
+    auto it = handlers.find(command);
+    const bool is_cmd_read = command == 0;
     FunctionInfoBase const* info = it == handlers.end() ? nullptr : &it->second;
     if (info == nullptr || info->handler_callback == nullptr)
         return ReportUnimplementedFunction(ctx, info);
 
     LOG_TRACE(Service, "{}", MakeFunctionString(info->name, GetServiceName(), ctx.CommandBuffer()));
     handler_invoker(this, info->handler_callback, ctx);
+
+    if (is_i_storage && is_cmd_read) {
+        const auto* const process = ctx.GetThread().GetOwnerProcess();
+        if (process != nullptr && system.IsNVDECActiveForProcess(process->GetId())) {
+            std::this_thread::sleep_for(std::chrono::microseconds{600});
+        }
+    }
 }
 
 void ServiceFrameworkBase::InvokeRequestTipc(HLERequestContext& ctx) {

src/core/hle/service/service.h

@@ -107,6 +107,8 @@ protected:
     Core::System& system;
     /// Identifier string used to connect to the service.
     const char* service_name;
+    /// Whether this is the IStorage service.
+    const bool is_i_storage;
     /// Function used to safely up-cast pointers to the derived class before invoking a handler.
     InvokerFn* handler_invoker;
     /// Maximum number of concurrent sessions that this service can handle.