Merge pull request #6102 from ogniK5377/fd-pass

nvdrv: Pass device fd and handle device create methods for device opening and closing

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

@@ -31,7 +31,7 @@ public:
      * @param output A buffer where the output data will be written to.
      * @returns The result code of the ioctl.
      */
-    virtual NvResult Ioctl1(Ioctl command, const std::vector<u8>& input,
+    virtual NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                             std::vector<u8>& output) = 0;
 
     /**
@@ -42,7 +42,7 @@ public:
      * @param output A buffer where the output data will be written to.
      * @returns The result code of the ioctl.
      */
-    virtual NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+    virtual NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                             const std::vector<u8>& inline_input, std::vector<u8>& output) = 0;
 
     /**
@@ -53,8 +53,20 @@ public:
      * @param inline_output A buffer where the inlined output data will be written to.
      * @returns The result code of the ioctl.
      */
-    virtual NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    virtual NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                            std::vector<u8>& inline_output) = 0;
+                            std::vector<u8>& output, std::vector<u8>& inline_output) = 0;
+
+    /**
+     * Called once a device is openned
+     * @param fd The device fd
+     */
+    virtual void OnOpen(DeviceFD fd) = 0;
+
+    /**
+     * Called once a device is closed
+     * @param fd The device fd
+     */
+    virtual void OnClose(DeviceFD fd) = 0;
 
 protected:
     Core::System& system;

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

@@ -18,24 +18,27 @@ nvdisp_disp0::nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_de
     : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvdisp_disp0 ::~nvdisp_disp0() = default;
 
-NvResult nvdisp_disp0::Ioctl1(Ioctl command, const std::vector<u8>& input,
+NvResult nvdisp_disp0::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvdisp_disp0::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvdisp_disp0::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvdisp_disp0::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvdisp_disp0::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                              std::vector<u8>& inline_output) {
+                              std::vector<u8>& output, std::vector<u8>& inline_output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvdisp_disp0::OnOpen(DeviceFD fd) {}
+void nvdisp_disp0::OnClose(DeviceFD fd) {}
+
 void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
                         u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform,
                         const Common::Rectangle<int>& crop_rect) {

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

@@ -20,11 +20,15 @@ public:
     explicit nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvdisp_disp0() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
     /// Performs a screen flip, drawing the buffer pointed to by the handle.
     void flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height, u32 stride,

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

@@ -21,7 +21,7 @@ nvhost_as_gpu::nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_
     : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_as_gpu::~nvhost_as_gpu() = default;
 
-NvResult nvhost_as_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_as_gpu::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                                std::vector<u8>& output) {
     switch (command.group) {
     case 'A':
@@ -54,14 +54,14 @@ NvResult nvhost_as_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input,
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_as_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_as_gpu::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                                const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_as_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvhost_as_gpu::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                               std::vector<u8>& inline_output) {
+                               std::vector<u8>& output, std::vector<u8>& inline_output) {
     switch (command.group) {
     case 'A':
         switch (command.cmd) {
@@ -78,6 +78,9 @@ NvResult nvhost_as_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input, std:
     return NvResult::NotImplemented;
 }
 
+void nvhost_as_gpu::OnOpen(DeviceFD fd) {}
+void nvhost_as_gpu::OnClose(DeviceFD fd) {}
+
 NvResult nvhost_as_gpu::AllocAsEx(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlAllocAsEx params{};
     std::memcpy(&params, input.data(), input.size());

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

@@ -33,11 +33,15 @@ public:
     explicit nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_as_gpu() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
 private:
     class BufferMap final {

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

@@ -20,7 +20,8 @@ nvhost_ctrl::nvhost_ctrl(Core::System& system, EventInterface& events_interface,
     : nvdevice(system), events_interface{events_interface}, syncpoint_manager{syncpoint_manager} {}
 nvhost_ctrl::~nvhost_ctrl() = default;
 
-NvResult nvhost_ctrl::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+NvResult nvhost_ctrl::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
+                             std::vector<u8>& output) {
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
@@ -46,18 +47,21 @@ NvResult nvhost_ctrl::Ioctl1(Ioctl command, const std::vector<u8>& input, std::v
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_ctrl::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_ctrl::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                              const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_ctrl::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvhost_ctrl::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                             std::vector<u8>& inline_outpu) {
+                             std::vector<u8>& output, std::vector<u8>& inline_outpu) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvhost_ctrl::OnOpen(DeviceFD fd) {}
+void nvhost_ctrl::OnClose(DeviceFD fd) {}
+
 NvResult nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
     IocGetConfigParams params{};
     std::memcpy(&params, input.data(), sizeof(params));

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

@@ -18,11 +18,15 @@ public:
                          SyncpointManager& syncpoint_manager);
     ~nvhost_ctrl() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
 private:
     struct IocSyncptReadParams {

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

@@ -15,7 +15,7 @@ namespace Service::Nvidia::Devices {
 nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system) : nvdevice(system) {}
 nvhost_ctrl_gpu::~nvhost_ctrl_gpu() = default;
 
-NvResult nvhost_ctrl_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_ctrl_gpu::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                                  std::vector<u8>& output) {
     switch (command.group) {
     case 'G':
@@ -47,13 +47,13 @@ NvResult nvhost_ctrl_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input,
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_ctrl_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_ctrl_gpu::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                                  const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_ctrl_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_ctrl_gpu::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                                  std::vector<u8>& output, std::vector<u8>& inline_output) {
     switch (command.group) {
     case 'G':
@@ -73,6 +73,9 @@ NvResult nvhost_ctrl_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input,
     return NvResult::NotImplemented;
 }
 
+void nvhost_ctrl_gpu::OnOpen(DeviceFD fd) {}
+void nvhost_ctrl_gpu::OnClose(DeviceFD fd) {}
+
 NvResult nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input,
                                              std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called");

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

@@ -16,11 +16,15 @@ public:
     explicit nvhost_ctrl_gpu(Core::System& system);
     ~nvhost_ctrl_gpu() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
 private:
     struct IoctlGpuCharacteristics {

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

@@ -23,7 +23,8 @@ nvhost_gpu::nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
 
 nvhost_gpu::~nvhost_gpu() = default;
 
-NvResult nvhost_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
+                            std::vector<u8>& output) {
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
@@ -74,7 +75,7 @@ NvResult nvhost_gpu::Ioctl1(Ioctl command, const std::vector<u8>& input, std::ve
     return NvResult::NotImplemented;
 };
 
-NvResult nvhost_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_gpu::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                             const std::vector<u8>& inline_input, std::vector<u8>& output) {
     switch (command.group) {
     case 'H':
@@ -88,12 +89,15 @@ NvResult nvhost_gpu::Ioctl2(Ioctl command, const std::vector<u8>& input,
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_gpu::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvhost_gpu::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                            std::vector<u8>& inline_output) {
+                            std::vector<u8>& output, std::vector<u8>& inline_output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvhost_gpu::OnOpen(DeviceFD fd) {}
+void nvhost_gpu::OnClose(DeviceFD fd) {}
+
 NvResult nvhost_gpu::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSetNvmapFD params{};
     std::memcpy(&params, input.data(), input.size());

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

@@ -26,11 +26,15 @@ public:
                         SyncpointManager& syncpoint_manager);
     ~nvhost_gpu() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
 private:
     enum class CtxObjects : u32_le {

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

@@ -16,7 +16,7 @@ nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_de
     : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {}
 nvhost_nvdec::~nvhost_nvdec() = default;
 
-NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               std::vector<u8>& output) {
     switch (command.group) {
     case 0x0:
@@ -57,16 +57,19 @@ NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_nvdec::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_nvdec::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_nvdec::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvhost_nvdec::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                              std::vector<u8>& inline_output) {
+                              std::vector<u8>& output, std::vector<u8>& inline_output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvhost_nvdec::OnOpen(DeviceFD fd) {}
+void nvhost_nvdec::OnClose(DeviceFD fd) {}
+
 } // namespace Service::Nvidia::Devices

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

@@ -15,11 +15,15 @@ public:
                           SyncpointManager& syncpoint_manager);
     ~nvhost_nvdec() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 };
 
 } // namespace Service::Nvidia::Devices

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

@@ -13,7 +13,7 @@ namespace Service::Nvidia::Devices {
 nvhost_nvjpg::nvhost_nvjpg(Core::System& system) : nvdevice(system) {}
 nvhost_nvjpg::~nvhost_nvjpg() = default;
 
-NvResult nvhost_nvjpg::Ioctl1(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_nvjpg::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               std::vector<u8>& output) {
     switch (command.group) {
     case 'H':
@@ -32,18 +32,21 @@ NvResult nvhost_nvjpg::Ioctl1(Ioctl command, const std::vector<u8>& input,
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_nvjpg::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_nvjpg::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                               const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_nvjpg::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvhost_nvjpg::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                              std::vector<u8>& inline_output) {
+                              std::vector<u8>& output, std::vector<u8>& inline_output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvhost_nvjpg::OnOpen(DeviceFD fd) {}
+void nvhost_nvjpg::OnClose(DeviceFD fd) {}
+
 NvResult nvhost_nvjpg::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSetNvmapFD params{};
     std::memcpy(&params, input.data(), input.size());

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

@@ -16,11 +16,15 @@ public:
     explicit nvhost_nvjpg(Core::System& system);
     ~nvhost_nvjpg() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
 private:
     struct IoctlSetNvmapFD {

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

@@ -16,7 +16,8 @@ nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
 
 nvhost_vic::~nvhost_vic() = default;
 
-NvResult nvhost_vic::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
+                            std::vector<u8>& output) {
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
@@ -55,16 +56,19 @@ NvResult nvhost_vic::Ioctl1(Ioctl command, const std::vector<u8>& input, std::ve
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_vic::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvhost_vic::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                             const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvhost_vic::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvhost_vic::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                            std::vector<u8>& inline_output) {
+                            std::vector<u8>& output, std::vector<u8>& inline_output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvhost_vic::OnOpen(DeviceFD fd) {}
+void nvhost_vic::OnClose(DeviceFD fd) {}
+
 } // namespace Service::Nvidia::Devices

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

@@ -14,10 +14,14 @@ public:
                         SyncpointManager& syncpoint_manager);
     ~nvhost_vic();
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 };
 } // namespace Service::Nvidia::Devices

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

@@ -19,7 +19,8 @@ nvmap::nvmap(Core::System& system) : nvdevice(system) {
 
 nvmap::~nvmap() = default;
 
-NvResult nvmap::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
+NvResult nvmap::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
+                       std::vector<u8>& output) {
     switch (command.group) {
     case 0x1:
         switch (command.cmd) {
@@ -47,18 +48,21 @@ NvResult nvmap::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<
     return NvResult::NotImplemented;
 }
 
-NvResult nvmap::Ioctl2(Ioctl command, const std::vector<u8>& input,
+NvResult nvmap::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                        const std::vector<u8>& inline_input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
-NvResult nvmap::Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+NvResult nvmap::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                       std::vector<u8>& inline_output) {
+                       std::vector<u8>& output, std::vector<u8>& inline_output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl={:08X}", command.raw);
     return NvResult::NotImplemented;
 }
 
+void nvmap::OnOpen(DeviceFD fd) {}
+void nvmap::OnClose(DeviceFD fd) {}
+
 VAddr nvmap::GetObjectAddress(u32 handle) const {
     auto object = GetObject(handle);
     ASSERT(object);

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

@@ -19,11 +19,15 @@ public:
     explicit nvmap(Core::System& system);
     ~nvmap() override;
 
-    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
+    NvResult Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-    NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
+                    std::vector<u8>& output) override;
+    NvResult Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
                     const std::vector<u8>& inline_input, std::vector<u8>& output) override;
-    NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
+    NvResult Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
-                    std::vector<u8>& inline_output) override;
+                    std::vector<u8>& output, std::vector<u8>& inline_output) override;
+
+    void OnOpen(DeviceFD fd) override;
+    void OnClose(DeviceFD fd) override;
 
     /// Returns the allocated address of an nvmap object given its handle.
     VAddr GetObjectAddress(u32 handle) const;

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

@@ -89,6 +89,8 @@ DeviceFD Module::Open(const std::string& device_name) {
     auto device = devices[device_name];
     const DeviceFD fd = next_fd++;
 
+    device->OnOpen(fd);
+
     open_files[fd] = std::move(device);
 
     return fd;
@@ -108,7 +110,7 @@ NvResult Module::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input
         return NvResult::NotImplemented;
     }
 
-    return itr->second->Ioctl1(command, input, output);
+    return itr->second->Ioctl1(fd, command, input, output);
 }
 
 NvResult Module::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
@@ -125,7 +127,7 @@ NvResult Module::Ioctl2(DeviceFD fd, Ioctl command, const std::vector<u8>& input
         return NvResult::NotImplemented;
     }
 
-    return itr->second->Ioctl2(command, input, inline_input, output);
+    return itr->second->Ioctl2(fd, command, input, inline_input, output);
 }
 
 NvResult Module::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input,
@@ -142,7 +144,7 @@ NvResult Module::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& input
         return NvResult::NotImplemented;
     }
 
-    return itr->second->Ioctl3(command, input, output, inline_output);
+    return itr->second->Ioctl3(fd, command, input, output, inline_output);
 }
 
 NvResult Module::Close(DeviceFD fd) {
@@ -158,6 +160,8 @@ NvResult Module::Close(DeviceFD fd) {
         return NvResult::NotImplemented;
     }
 
+    itr->second->OnClose(fd);
+
     open_files.erase(itr);
 
     return NvResult::Success;