nvdrv: use static typing for SessionId, smmu Asid types

src/core/device_memory_manager.h

@@ -28,6 +28,10 @@ class Memory;
 template <typename DTraits>
 struct DeviceMemoryManagerAllocator;
 
+struct Asid {
+    size_t id;
+};
+
 template <typename Traits>
 class DeviceMemoryManager {
     using DeviceInterface = typename Traits::DeviceInterface;
@@ -43,15 +47,14 @@ public:
     void AllocateFixed(DAddr start, size_t size);
     void Free(DAddr start, size_t size);
 
-    void Map(DAddr address, VAddr virtual_address, size_t size, size_t process_id,
+    void Map(DAddr address, VAddr virtual_address, size_t size, Asid asid, bool track = false);
-             bool track = false);
 
     void Unmap(DAddr address, size_t size);
 
-    void TrackContinuityImpl(DAddr address, VAddr virtual_address, size_t size, size_t process_id);
+    void TrackContinuityImpl(DAddr address, VAddr virtual_address, size_t size, Asid asid);
-    void TrackContinuity(DAddr address, VAddr virtual_address, size_t size, size_t process_id) {
+    void TrackContinuity(DAddr address, VAddr virtual_address, size_t size, Asid asid) {
         std::scoped_lock lk(mapping_guard);
-        TrackContinuityImpl(address, virtual_address, size, process_id);
+        TrackContinuityImpl(address, virtual_address, size, asid);
     }
 
     // Write / Read
@@ -105,8 +108,8 @@ public:
     void WriteBlock(DAddr address, const void* src_pointer, size_t size);
     void WriteBlockUnsafe(DAddr address, const void* src_pointer, size_t size);
 
-    size_t RegisterProcess(Memory::Memory* memory);
+    Asid RegisterProcess(Memory::Memory* memory);
-    void UnregisterProcess(size_t id);
+    void UnregisterProcess(Asid id);
 
     void UpdatePagesCachedCount(DAddr addr, size_t size, s32 delta);
 
@@ -163,17 +166,17 @@ private:
     static constexpr size_t guest_max_as_bits = 39;
     static constexpr size_t guest_as_size = 1ULL << guest_max_as_bits;
     static constexpr size_t guest_mask = guest_as_size - 1ULL;
-    static constexpr size_t process_id_start_bit = guest_max_as_bits;
+    static constexpr size_t asid_start_bit = guest_max_as_bits;
 
-    std::pair<size_t, VAddr> ExtractCPUBacking(size_t page_index) {
+    std::pair<Asid, VAddr> ExtractCPUBacking(size_t page_index) {
         auto content = cpu_backing_address[page_index];
         const VAddr address = content & guest_mask;
-        const size_t process_id = static_cast<size_t>(content >> process_id_start_bit);
+        const Asid asid{static_cast<size_t>(content >> asid_start_bit)};
-        return std::make_pair(process_id, address);
+        return std::make_pair(asid, address);
     }
 
-    void InsertCPUBacking(size_t page_index, VAddr address, size_t process_id) {
+    void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
-        cpu_backing_address[page_index] = address | (process_id << process_id_start_bit);
+        cpu_backing_address[page_index] = address | (asid.id << asid_start_bit);
     }
 
     Common::VirtualBuffer<VAddr> cpu_backing_address;

src/core/device_memory_manager.inc

@@ -215,8 +215,8 @@ void DeviceMemoryManager<Traits>::Free(DAddr start, size_t size) {
 
 template <typename Traits>
 void DeviceMemoryManager<Traits>::Map(DAddr address, VAddr virtual_address, size_t size,
-                                      size_t process_id, bool track) {
+                                      Asid asid, bool track) {
-    Core::Memory::Memory* process_memory = registered_processes[process_id];
+    Core::Memory::Memory* process_memory = registered_processes[asid.id];
     size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     std::scoped_lock lk(mapping_guard);
@@ -229,7 +229,7 @@ void DeviceMemoryManager<Traits>::Map(DAddr address, VAddr virtual_address, size
         }
         auto phys_addr = static_cast<u32>(GetRawPhysicalAddr(ptr) >> Memory::YUZU_PAGEBITS) + 1U;
         compressed_physical_ptr[start_page_d + i] = phys_addr;
-        InsertCPUBacking(start_page_d + i, new_vaddress, process_id);
+        InsertCPUBacking(start_page_d + i, new_vaddress, asid);
         const u32 base_dev = compressed_device_addr[phys_addr - 1U];
         const u32 new_dev = static_cast<u32>(start_page_d + i);
         if (base_dev == 0) [[likely]] {
@@ -244,7 +244,7 @@ void DeviceMemoryManager<Traits>::Map(DAddr address, VAddr virtual_address, size
         impl->multi_dev_address.Register(new_dev, start_id);
     }
     if (track) {
-        TrackContinuityImpl(address, virtual_address, size, process_id);
+        TrackContinuityImpl(address, virtual_address, size, asid);
     }
 }
 
@@ -277,8 +277,8 @@ void DeviceMemoryManager<Traits>::Unmap(DAddr address, size_t size) {
 }
 template <typename Traits>
 void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtual_address,
-                                                      size_t size, size_t process_id) {
+                                                      size_t size, Asid asid) {
-    Core::Memory::Memory* process_memory = registered_processes[process_id];
+    Core::Memory::Memory* process_memory = registered_processes[asid.id];
     size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     uintptr_t last_ptr = 0;
@@ -488,8 +488,8 @@ void DeviceMemoryManager<Traits>::WriteBlockUnsafe(DAddr address, const void* sr
 }
 
 template <typename Traits>
-size_t DeviceMemoryManager<Traits>::RegisterProcess(Memory::Memory* memory_device_inter) {
+Asid DeviceMemoryManager<Traits>::RegisterProcess(Memory::Memory* memory_device_inter) {
-    size_t new_id;
+    size_t new_id{};
     if (!id_pool.empty()) {
         new_id = id_pool.front();
         id_pool.pop_front();
@@ -498,13 +498,13 @@ size_t DeviceMemoryManager<Traits>::RegisterProcess(Memory::Memory* memory_devic
         registered_processes.emplace_back(memory_device_inter);
         new_id = registered_processes.size() - 1U;
     }
-    return new_id;
+    return Asid{new_id};
 }
 
 template <typename Traits>
-void DeviceMemoryManager<Traits>::UnregisterProcess(size_t id) {
+void DeviceMemoryManager<Traits>::UnregisterProcess(Asid asid) {
-    registered_processes[id] = nullptr;
+    registered_processes[asid.id] = nullptr;
-    id_pool.push_front(id);
+    id_pool.push_front(asid.id);
 }
 
 template <typename Traits>
@@ -530,9 +530,9 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
     std::atomic_thread_fence(std::memory_order_acquire);
     const size_t page_end = Common::DivCeil(addr + size, Memory::YUZU_PAGESIZE);
     size_t page = addr >> Memory::YUZU_PAGEBITS;
-    auto [process_id, base_vaddress] = ExtractCPUBacking(page);
+    auto [asid, base_vaddress] = ExtractCPUBacking(page);
     size_t vpage = base_vaddress >> Memory::YUZU_PAGEBITS;
-    auto* memory_device_inter = registered_processes[process_id];
+    auto* memory_device_inter = registered_processes[asid.id];
     for (; page != page_end; ++page) {
         std::atomic_uint8_t& count = cached_pages->at(page >> 3).Count(page);
 

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

@@ -16,9 +16,8 @@
 
 namespace Service::Nvidia::NvCore {
 
-Session::Session(size_t id_, Kernel::KProcess* process_, size_t smmu_id_)
+Session::Session(SessionId id_, Kernel::KProcess* process_, Core::Asid asid_)
-    : id{id_}, process{process_}, smmu_id{smmu_id_},
+    : id{id_}, process{process_}, asid{asid_}, has_preallocated_area{}, mapper{}, is_active{} {}
-      has_preallocated_area{}, mapper{}, is_active{} {}
 
 Session::~Session() = default;
 
@@ -41,7 +40,7 @@ Container::Container(Tegra::Host1x::Host1x& host1x_) {
 
 Container::~Container() = default;
 
-size_t Container::OpenSession(Kernel::KProcess* process) {
+SessionId Container::OpenSession(Kernel::KProcess* process) {
     std::scoped_lock lk(impl->session_guard);
     for (auto& session : impl->sessions) {
         if (!session.is_active) {
@@ -54,14 +53,14 @@ size_t Container::OpenSession(Kernel::KProcess* process) {
     size_t new_id{};
     auto* memory_interface = &process->GetMemory();
     auto& smmu = impl->host1x.MemoryManager();
-    auto smmu_id = smmu.RegisterProcess(memory_interface);
+    auto asid = smmu.RegisterProcess(memory_interface);
     if (!impl->id_pool.empty()) {
         new_id = impl->id_pool.front();
         impl->id_pool.pop_front();
-        impl->sessions[new_id] = Session{new_id, process, smmu_id};
+        impl->sessions[new_id] = Session{SessionId{new_id}, process, asid};
     } else {
         new_id = impl->new_ids++;
-        impl->sessions.emplace_back(new_id, process, smmu_id);
+        impl->sessions.emplace_back(SessionId{new_id}, process, asid);
     }
     auto& session = impl->sessions[new_id];
     session.is_active = true;
@@ -100,18 +99,18 @@ size_t Container::OpenSession(Kernel::KProcess* process) {
         auto start_region = (region_size >> 15) >= 1024 ? smmu.Allocate(region_size) : 0;
         if (start_region != 0) {
             session.mapper = std::make_unique<HeapMapper>(region_start, start_region, region_size,
-                                                          smmu_id, impl->host1x);
+                                                          asid, impl->host1x);
-            smmu.TrackContinuity(start_region, region_start, region_size, smmu_id);
+            smmu.TrackContinuity(start_region, region_start, region_size, asid);
             session.has_preallocated_area = true;
             LOG_CRITICAL(Debug, "Preallocation created!");
         }
     }
-    return new_id;
+    return SessionId{new_id};
 }
 
-void Container::CloseSession(size_t id) {
+void Container::CloseSession(SessionId session_id) {
     std::scoped_lock lk(impl->session_guard);
-    auto& session = impl->sessions[id];
+    auto& session = impl->sessions[session_id.id];
     auto& smmu = impl->host1x.MemoryManager();
     if (session.has_preallocated_area) {
         const DAddr region_start = session.mapper->GetRegionStart();
@@ -121,13 +120,13 @@ void Container::CloseSession(size_t id) {
         session.has_preallocated_area = false;
     }
     session.is_active = false;
-    smmu.UnregisterProcess(impl->sessions[id].smmu_id);
+    smmu.UnregisterProcess(impl->sessions[session_id.id].asid);
-    impl->id_pool.emplace_front(id);
+    impl->id_pool.emplace_front(session_id.id);
 }
 
-Session* Container::GetSession(size_t id) {
+Session* Container::GetSession(SessionId session_id) {
     std::atomic_thread_fence(std::memory_order_acquire);
-    return &impl->sessions[id];
+    return &impl->sessions[session_id.id];
 }
 
 NvMap& Container::GetNvMapFile() {

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

@@ -8,6 +8,7 @@
 #include <memory>
 #include <unordered_map>
 
+#include "core/device_memory_manager.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Kernel {
@@ -26,8 +27,12 @@ class SyncpointManager;
 
 struct ContainerImpl;
 
+struct SessionId {
+    size_t id;
+};
+
 struct Session {
-    Session(size_t id_, Kernel::KProcess* process_, size_t smmu_id_);
+    Session(SessionId id_, Kernel::KProcess* process_, Core::Asid asid_);
     ~Session();
 
     Session(const Session&) = delete;
@@ -35,9 +40,9 @@ struct Session {
     Session(Session&&) = default;
     Session& operator=(Session&&) = default;
 
-    size_t id;
+    SessionId id;
     Kernel::KProcess* process;
-    size_t smmu_id;
+    Core::Asid asid;
     bool has_preallocated_area{};
     std::unique_ptr<HeapMapper> mapper{};
     bool is_active{};
@@ -48,10 +53,10 @@ public:
     explicit Container(Tegra::Host1x::Host1x& host1x);
     ~Container();
 
-    size_t OpenSession(Kernel::KProcess* process);
+    SessionId OpenSession(Kernel::KProcess* process);
-    void CloseSession(size_t id);
+    void CloseSession(SessionId id);
 
-    Session* GetSession(size_t id);
+    Session* GetSession(SessionId id);
 
     NvMap& GetNvMapFile();
 

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

@@ -109,9 +109,9 @@ struct HeapMapper::HeapMapperInternal {
     std::mutex guard;
 };
 
-HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, size_t smmu_id,
+HeapMapper::HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, Core::Asid asid,
                        Tegra::Host1x::Host1x& host1x)
-    : m_vaddress{start_vaddress}, m_daddress{start_daddress}, m_size{size}, m_smmu_id{smmu_id} {
+    : m_vaddress{start_vaddress}, m_daddress{start_daddress}, m_size{size}, m_asid{asid} {
     m_internal = std::make_unique<HeapMapperInternal>(host1x);
 }
 
@@ -138,7 +138,7 @@ DAddr HeapMapper::Map(VAddr start, size_t size) {
             const size_t offset = inter_addr - m_vaddress;
             const size_t sub_size = inter_addr_end - inter_addr;
             m_internal->device_memory.Map(m_daddress + offset, m_vaddress + offset, sub_size,
-                                          m_smmu_id);
+                                          m_asid);
         }
     }
     m_internal->mapping_overlaps += std::make_pair(interval, 1);

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

@@ -6,6 +6,7 @@
 #include <memory>
 
 #include "common/common_types.h"
+#include "core/device_memory_manager.h"
 
 namespace Tegra::Host1x {
 class Host1x;
@@ -15,7 +16,7 @@ namespace Service::Nvidia::NvCore {
 
 class HeapMapper {
 public:
-    HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, size_t smmu_id,
+    HeapMapper(VAddr start_vaddress, DAddr start_daddress, size_t size, Core::Asid asid,
                Tegra::Host1x::Host1x& host1x);
     ~HeapMapper();
 
@@ -41,7 +42,7 @@ private:
     VAddr m_vaddress;
     DAddr m_daddress;
     size_t m_size;
-    size_t m_smmu_id;
+    Core::Asid m_asid;
     std::unique_ptr<HeapMapperInternal> m_internal;
 };
 

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

@@ -22,7 +22,8 @@ NvMap::Handle::Handle(u64 size_, Id id_)
     flags.raw = 0;
 }
 
-NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress, size_t 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) {
@@ -223,7 +224,7 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
             }
 
             handle_description->d_address = address;
-            smmu.Map(address, vaddress, map_size, session->smmu_id, true);
+            smmu.Map(address, vaddress, map_size, session->asid, true);
             handle_description->in_heap = false;
         }
     }

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

@@ -14,6 +14,7 @@
 
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Tegra {
@@ -71,7 +72,7 @@ public:
         u8 kind{};        //!< Used for memory compression
         bool allocated{}; //!< If the handle has been allocated with `Alloc`
         bool in_heap{};
-        size_t session_id{};
+        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
@@ -83,7 +84,7 @@ public:
          * if a 0 address is passed
          */
         [[nodiscard]] NvResult Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress,
-                                     size_t pSessionId);
+                                     NvCore::SessionId pSessionId);
 
         /**
          * @brief Increases the dupe counter of the handle for the given session

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

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "common/common_types.h"
+#include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Core {
@@ -62,7 +63,7 @@ public:
      * Called once a device is opened
      * @param fd The device fd
      */
-    virtual void OnOpen(size_t session_id, DeviceFD fd) = 0;
+    virtual void OnOpen(NvCore::SessionId session_id, DeviceFD fd) = 0;
 
     /**
      * Called once a device is closed

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

@@ -35,7 +35,7 @@ NvResult nvdisp_disp0::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
     return NvResult::NotImplemented;
 }
 
-void nvdisp_disp0::OnOpen(size_t session_id, DeviceFD fd) {}
+void nvdisp_disp0::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvdisp_disp0::OnClose(DeviceFD fd) {}
 
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, android::PixelFormat format, u32 width,

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

@@ -32,7 +32,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     /// Performs a screen flip, drawing the buffer pointed to by the handle.

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

@@ -86,7 +86,7 @@ NvResult nvhost_as_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> i
     return NvResult::NotImplemented;
 }
 
-void nvhost_as_gpu::OnOpen(size_t session_id, DeviceFD fd) {}
+void nvhost_as_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvhost_as_gpu::OnClose(DeviceFD fd) {}
 
 NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {

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

@@ -55,7 +55,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;

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

@@ -76,7 +76,7 @@ NvResult nvhost_ctrl::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inp
     return NvResult::NotImplemented;
 }
 
-void nvhost_ctrl::OnOpen(size_t session_id, DeviceFD fd) {}
+void nvhost_ctrl::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 
 void nvhost_ctrl::OnClose(DeviceFD fd) {}
 

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

@@ -32,7 +32,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;

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

@@ -82,7 +82,7 @@ NvResult nvhost_ctrl_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8>
     return NvResult::NotImplemented;
 }
 
-void nvhost_ctrl_gpu::OnOpen(size_t session_id, DeviceFD fd) {}
+void nvhost_ctrl_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvhost_ctrl_gpu::OnClose(DeviceFD fd) {}
 
 NvResult nvhost_ctrl_gpu::GetCharacteristics1(IoctlCharacteristics& params) {

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

@@ -28,7 +28,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;

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

@@ -120,7 +120,7 @@ NvResult nvhost_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     return NvResult::NotImplemented;
 }
 
-void nvhost_gpu::OnOpen(size_t session_id, DeviceFD fd) {}
+void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvhost_gpu::OnClose(DeviceFD fd) {}
 
 NvResult nvhost_gpu::SetNVMAPfd(IoctlSetNvmapFD& params) {

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

@@ -47,7 +47,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;

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

@@ -68,7 +68,7 @@ NvResult nvhost_nvdec::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
     return NvResult::NotImplemented;
 }
 
-void nvhost_nvdec::OnOpen(size_t session_id, DeviceFD fd) {
+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;

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

@@ -20,7 +20,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 };
 

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

@@ -127,7 +127,7 @@ protected:
     NvCore::NvMap& nvmap;
     NvCore::ChannelType channel_type;
     std::array<u32, MaxSyncPoints> device_syncpoints{};
-    std::unordered_map<DeviceFD, size_t> sessions;
+    std::unordered_map<DeviceFD, NvCore::SessionId> sessions;
 };
 }; // namespace Devices
 } // namespace Service::Nvidia

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

@@ -44,7 +44,7 @@ NvResult nvhost_nvjpg::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
     return NvResult::NotImplemented;
 }
 
-void nvhost_nvjpg::OnOpen(size_t session_id, DeviceFD fd) {}
+void nvhost_nvjpg::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
 void nvhost_nvjpg::OnClose(DeviceFD fd) {}
 
 NvResult nvhost_nvjpg::SetNVMAPfd(IoctlSetNvmapFD& params) {

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

@@ -22,7 +22,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
 private:

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

@@ -68,7 +68,7 @@ NvResult nvhost_vic::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     return NvResult::NotImplemented;
 }
 
-void nvhost_vic::OnOpen(size_t session_id, DeviceFD fd) {
+void nvhost_vic::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     sessions[fd] = session_id;
 }
 

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

@@ -19,7 +19,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 };
 } // namespace Service::Nvidia::Devices

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

@@ -67,7 +67,7 @@ NvResult nvmap::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, st
     return NvResult::NotImplemented;
 }
 
-void nvmap::OnOpen(size_t session_id, DeviceFD fd) {
+void nvmap::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     sessions[fd] = session_id;
 }
 void nvmap::OnClose(DeviceFD fd) {

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

@@ -33,7 +33,7 @@ public:
     NvResult Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output,
                     std::span<u8> inline_output) override;
 
-    void OnOpen(size_t session_id, DeviceFD fd) override;
+    void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
 
     enum class HandleParameterType : u32_le {
@@ -115,7 +115,7 @@ private:
 
     NvCore::Container& container;
     NvCore::NvMap& file;
-    std::unordered_map<DeviceFD, size_t> sessions;
+    std::unordered_map<DeviceFD, NvCore::SessionId> sessions;
 };
 
 } // namespace Service::Nvidia::Devices

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

@@ -122,7 +122,7 @@ NvResult Module::VerifyFD(DeviceFD fd) const {
     return NvResult::Success;
 }
 
-DeviceFD Module::Open(const std::string& device_name, size_t session_id) {
+DeviceFD Module::Open(const std::string& device_name, NvCore::SessionId session_id) {
     auto it = builders.find(device_name);
     if (it == builders.end()) {
         LOG_ERROR(Service_NVDRV, "Trying to open unknown device {}", device_name);

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

@@ -77,7 +77,7 @@ public:
     NvResult VerifyFD(DeviceFD fd) const;
 
     /// Opens a device node and returns a file descriptor to it.
-    DeviceFD Open(const std::string& device_name, size_t session_id);
+    DeviceFD Open(const std::string& device_name, NvCore::SessionId session_id);
 
     /// Sends an ioctl command to the specified file descriptor.
     NvResult Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> input, std::span<u8> output);

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

@@ -35,7 +35,7 @@ private:
 
     u64 pid{};
     bool is_initialized{};
-    size_t session_id{};
+    NvCore::SessionId session_id{};
     Common::ScratchBuffer<u8> output_buffer;
     Common::ScratchBuffer<u8> inline_output_buffer;
 };

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

@@ -4,6 +4,7 @@
 #pragma once
 
 #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/nvnflinger.h"
 #include "core/hle/service/nvnflinger/ui/fence.h"
@@ -55,7 +56,7 @@ private:
     u32 m_buffer_nvmap_handle = 0;
     SharedMemoryPoolLayout m_pool_layout = {};
     Nvidia::DeviceFD m_nvmap_fd = {};
-    size_t m_session_id = {};
+    Nvidia::NvCore::SessionId m_session_id = {};
     std::unique_ptr<Kernel::KPageGroup> m_buffer_page_group;
 
     std::mutex m_guard;

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

@@ -126,7 +126,7 @@ void Nvnflinger::ShutdownLayers() {
 
 void Nvnflinger::SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance) {
     nvdrv = std::move(instance);
-    disp_fd = nvdrv->Open("/dev/nvdisp_disp0", 0);
+    disp_fd = nvdrv->Open("/dev/nvdisp_disp0", {});
 }
 
 std::optional<u64> Nvnflinger::OpenDisplay(std::string_view name) {