diff --git a/pkg/abi/nvgpu/ctrl.go b/pkg/abi/nvgpu/ctrl.go index e29928f848..6d56811f94 100644 --- a/pkg/abi/nvgpu/ctrl.go +++ b/pkg/abi/nvgpu/ctrl.go @@ -92,6 +92,16 @@ type NV0000_CTRL_OS_UNIX_EXPORT_OBJECT_TO_FD_PARAMS struct { Flags uint32 } +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *NV0000_CTRL_OS_UNIX_EXPORT_OBJECT_TO_FD_PARAMS) GetFrontendFD() int32 { + return p.FD +} + +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *NV0000_CTRL_OS_UNIX_EXPORT_OBJECT_TO_FD_PARAMS) SetFrontendFD(fd int32) { + p.FD = fd +} + // +marshal type NV0000_CTRL_SYSTEM_GET_BUILD_VERSION_PARAMS struct { SizeOfStrings uint32 diff --git a/pkg/abi/nvgpu/frontend.go b/pkg/abi/nvgpu/frontend.go index b8e52af511..2a5e838eee 100644 --- a/pkg/abi/nvgpu/frontend.go +++ b/pkg/abi/nvgpu/frontend.go @@ -74,6 +74,16 @@ type IoctlAllocOSEvent struct { Status uint32 } +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *IoctlAllocOSEvent) GetFrontendFD() int32 { + return int32(p.FD) +} + +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *IoctlAllocOSEvent) SetFrontendFD(fd int32) { + p.FD = uint32(fd) +} + // IoctlFreeOSEvent is nv_ioctl_free_os_event_t, the parameter type for // NV_ESC_FREE_OS_EVENT. // @@ -85,6 +95,16 @@ type IoctlFreeOSEvent struct { Status uint32 } +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *IoctlFreeOSEvent) GetFrontendFD() int32 { + return int32(p.FD) +} + +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *IoctlFreeOSEvent) SetFrontendFD(fd int32) { + p.FD = uint32(fd) +} + // RMAPIVersion is nv_rm_api_version_t, the parameter type for // NV_ESC_CHECK_VERSION_STR. // @@ -405,6 +425,14 @@ func (n *NVOS64Parameters) FromOS64(other NVOS64Parameters) { *n = other } // ToOS64 implements RmAllocParamType.ToOS64. func (n *NVOS64Parameters) ToOS64() NVOS64Parameters { return *n } +// HasFrontendFD is a type constraint for parameter structs containing a +// frontend FD field. This is necessary because, as of this writing (Go 1.20), +// there is no way to enable field access using a Go type constraint. +type HasFrontendFD interface { + GetFrontendFD() int32 + SetFrontendFD(int32) +} + // Frontend ioctl parameter struct sizes. var ( SizeofIoctlRegisterFD = uint32((*IoctlRegisterFD)(nil).SizeBytes()) diff --git a/pkg/abi/nvgpu/uvm.go b/pkg/abi/nvgpu/uvm.go index 4689ab5fe4..4beefd2250 100644 --- a/pkg/abi/nvgpu/uvm.go +++ b/pkg/abi/nvgpu/uvm.go @@ -14,14 +14,6 @@ package nvgpu -// HasRMCtrlFD is a type constraint for UVM parameter structs containing a -// RMCtrlFD field. This is necessary because, as of this writing (Go 1.20), -// there is no way to enable field access using a Go type constraint. -type HasRMCtrlFD interface { - GetRMCtrlFD() int32 - SetRMCtrlFD(int32) -} - // UVM ioctl commands. const ( // From kernel-open/nvidia-uvm/uvm_linux_ioctl.h: @@ -86,11 +78,13 @@ type UVM_REGISTER_GPU_VASPACE_PARAMS struct { RMStatus uint32 } -func (p *UVM_REGISTER_GPU_VASPACE_PARAMS) GetRMCtrlFD() int32 { +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *UVM_REGISTER_GPU_VASPACE_PARAMS) GetFrontendFD() int32 { return p.RMCtrlFD } -func (p *UVM_REGISTER_GPU_VASPACE_PARAMS) SetRMCtrlFD(fd int32) { +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *UVM_REGISTER_GPU_VASPACE_PARAMS) SetFrontendFD(fd int32) { p.RMCtrlFD = fd } @@ -113,11 +107,13 @@ type UVM_REGISTER_CHANNEL_PARAMS struct { Pad0 [4]byte } -func (p *UVM_REGISTER_CHANNEL_PARAMS) GetRMCtrlFD() int32 { +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *UVM_REGISTER_CHANNEL_PARAMS) GetFrontendFD() int32 { return p.RMCtrlFD } -func (p *UVM_REGISTER_CHANNEL_PARAMS) SetRMCtrlFD(fd int32) { +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *UVM_REGISTER_CHANNEL_PARAMS) SetFrontendFD(fd int32) { p.RMCtrlFD = fd } @@ -142,11 +138,13 @@ type UVM_MAP_EXTERNAL_ALLOCATION_PARAMS struct { RMStatus uint32 } -func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS) GetRMCtrlFD() int32 { +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS) GetFrontendFD() int32 { return p.RMCtrlFD } -func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS) SetRMCtrlFD(fd int32) { +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS) SetFrontendFD(fd int32) { p.RMCtrlFD = fd } @@ -163,11 +161,13 @@ type UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550 struct { RMStatus uint32 } -func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550) GetRMCtrlFD() int32 { +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550) GetFrontendFD() int32 { return p.RMCtrlFD } -func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550) SetRMCtrlFD(fd int32) { +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550) SetFrontendFD(fd int32) { p.RMCtrlFD = fd } @@ -191,11 +191,13 @@ type UVM_REGISTER_GPU_PARAMS struct { RMStatus uint32 } -func (p *UVM_REGISTER_GPU_PARAMS) GetRMCtrlFD() int32 { +// GetFrontendFD implements HasFrontendFD.GetFrontendFD. +func (p *UVM_REGISTER_GPU_PARAMS) GetFrontendFD() int32 { return p.RMCtrlFD } -func (p *UVM_REGISTER_GPU_PARAMS) SetRMCtrlFD(fd int32) { +// SetFrontendFD implements HasFrontendFD.SetFrontendFD. +func (p *UVM_REGISTER_GPU_PARAMS) SetFrontendFD(fd int32) { p.RMCtrlFD = fd } diff --git a/pkg/sentry/devices/nvproxy/frontend.go b/pkg/sentry/devices/nvproxy/frontend.go index d6bd0af526..16637b5296 100644 --- a/pkg/sentry/devices/nvproxy/frontend.go +++ b/pkg/sentry/devices/nvproxy/frontend.go @@ -268,48 +268,17 @@ func frontendRegisterFD(fi *frontendIoctlState) (uintptr, error) { return frontendIoctlInvoke(fi, &ioctlParams) } -func rmAllocOSEvent(fi *frontendIoctlState) (uintptr, error) { - var ioctlParams nvgpu.IoctlAllocOSEvent - if fi.ioctlParamsSize != nvgpu.SizeofIoctlAllocOSEvent { +func frontendIoctHasFD[Params any, PtrParams hasFrontendFDPtr[Params]](fi *frontendIoctlState) (uintptr, error) { + var ioctlParams Params + if int(fi.ioctlParamsSize) != (PtrParams)(&ioctlParams).SizeBytes() { return 0, linuxerr.EINVAL } - if _, err := ioctlParams.CopyIn(fi.t, fi.ioctlParamsAddr); err != nil { + if _, err := (PtrParams)(&ioctlParams).CopyIn(fi.t, fi.ioctlParamsAddr); err != nil { return 0, err } - eventFileGeneric, _ := fi.t.FDTable().Get(int32(ioctlParams.FD)) - if eventFileGeneric == nil { - return 0, linuxerr.EINVAL - } - defer eventFileGeneric.DecRef(fi.ctx) - eventFile, ok := eventFileGeneric.Impl().(*frontendFD) - if !ok { - return 0, linuxerr.EINVAL - } - origFD := ioctlParams.FD - ioctlParams.FD = uint32(eventFile.hostFD) - n, err := frontendIoctlInvoke(fi, &ioctlParams) - ioctlParams.FD = origFD - if err != nil { - return n, err - } - - if _, err := ioctlParams.CopyOut(fi.t, fi.ioctlParamsAddr); err != nil { - return n, err - } - - return n, nil -} - -func rmFreeOSEvent(fi *frontendIoctlState) (uintptr, error) { - var ioctlParams nvgpu.IoctlFreeOSEvent - if fi.ioctlParamsSize != nvgpu.SizeofIoctlFreeOSEvent { - return 0, linuxerr.EINVAL - } - if _, err := ioctlParams.CopyIn(fi.t, fi.ioctlParamsAddr); err != nil { - return 0, err - } - eventFileGeneric, _ := fi.t.FDTable().Get(int32(ioctlParams.FD)) + origFD := (PtrParams)(&ioctlParams).GetFrontendFD() + eventFileGeneric, _ := fi.t.FDTable().Get(origFD) if eventFileGeneric == nil { return 0, linuxerr.EINVAL } @@ -319,18 +288,15 @@ func rmFreeOSEvent(fi *frontendIoctlState) (uintptr, error) { return 0, linuxerr.EINVAL } - origFD := ioctlParams.FD - ioctlParams.FD = uint32(eventFile.hostFD) + (PtrParams)(&ioctlParams).SetFrontendFD(eventFile.hostFD) n, err := frontendIoctlInvoke(fi, &ioctlParams) - ioctlParams.FD = origFD + (PtrParams)(&ioctlParams).SetFrontendFD(origFD) if err != nil { return n, err } - - if _, err := ioctlParams.CopyOut(fi.t, fi.ioctlParamsAddr); err != nil { + if _, err := (PtrParams)(&ioctlParams).CopyOut(fi.t, fi.ioctlParamsAddr); err != nil { return n, err } - return n, nil } @@ -561,15 +527,17 @@ func ctrlCmdFailWithStatus(fi *frontendIoctlState, ioctlParams *nvgpu.NVOS54Para return err } -func ctrlExportObjectToFD(fi *frontendIoctlState, ioctlParams *nvgpu.NVOS54Parameters) (uintptr, error) { - var ctrlParams nvgpu.NV0000_CTRL_OS_UNIX_EXPORT_OBJECT_TO_FD_PARAMS - if ctrlParams.SizeBytes() != int(ioctlParams.ParamsSize) { +func ctrlHasFrontendFD[Params any, PtrParams hasFrontendFDPtr[Params]](fi *frontendIoctlState, ioctlParams *nvgpu.NVOS54Parameters) (uintptr, error) { + var ctrlParams Params + if (PtrParams)(&ctrlParams).SizeBytes() != int(ioctlParams.ParamsSize) { return 0, linuxerr.EINVAL } - if _, err := ctrlParams.CopyIn(fi.t, addrFromP64(ioctlParams.Params)); err != nil { + if _, err := (PtrParams)(&ctrlParams).CopyIn(fi.t, addrFromP64(ioctlParams.Params)); err != nil { return 0, err } - ctlFileGeneric, _ := fi.t.FDTable().Get(ctrlParams.FD) + + origFD := (PtrParams)(&ctrlParams).GetFrontendFD() + ctlFileGeneric, _ := fi.t.FDTable().Get(origFD) if ctlFileGeneric == nil { return 0, linuxerr.EINVAL } @@ -579,14 +547,13 @@ func ctrlExportObjectToFD(fi *frontendIoctlState, ioctlParams *nvgpu.NVOS54Param return 0, linuxerr.EINVAL } - origFD := ctrlParams.FD - ctrlParams.FD = ctlFile.hostFD + (PtrParams)(&ctrlParams).SetFrontendFD(ctlFile.hostFD) n, err := rmControlInvoke(fi, ioctlParams, &ctrlParams) - ctrlParams.FD = origFD + (PtrParams)(&ctrlParams).SetFrontendFD(origFD) if err != nil { return n, err } - if _, err := ctrlParams.CopyOut(fi.t, addrFromP64(ioctlParams.Params)); err != nil { + if _, err := (PtrParams)(&ctrlParams).CopyOut(fi.t, addrFromP64(ioctlParams.Params)); err != nil { return n, err } return n, nil @@ -767,8 +734,8 @@ func rmAlloc(fi *frontendIoctlState) (uintptr, error) { // // Unlike frontendIoctlSimple and rmControlSimple, rmAllocSimple requires the // parameter type since the parameter's size is otherwise unknown. -func rmAllocSimple[Params any, PParams marshalPtr[Params]](fi *frontendIoctlState, ioctlParams *nvgpu.NVOS64Parameters, isNVOS64 bool) (uintptr, error) { - return rmAllocSimpleParams[Params, PParams](fi, ioctlParams, isNVOS64, addSimpleObjDepParentLocked) +func rmAllocSimple[Params any, PtrParams marshalPtr[Params]](fi *frontendIoctlState, ioctlParams *nvgpu.NVOS64Parameters, isNVOS64 bool) (uintptr, error) { + return rmAllocSimpleParams[Params, PtrParams](fi, ioctlParams, isNVOS64, addSimpleObjDepParentLocked) } // addSimpleObjDepParentLocked implements rmAllocInvoke.addObjLocked for @@ -777,20 +744,20 @@ func addSimpleObjDepParentLocked[Params any](fi *frontendIoctlState, ioctlParams fi.fd.dev.nvp.objAdd(fi.ctx, ioctlParams.HRoot, ioctlParams.HObjectNew, ioctlParams.HClass, newRmAllocObject(fi.fd, ioctlParams, rightsRequested, allocParams), ioctlParams.HObjectParent) } -func rmAllocSimpleParams[Params any, PParams marshalPtr[Params]](fi *frontendIoctlState, ioctlParams *nvgpu.NVOS64Parameters, isNVOS64 bool, objAddLocked func(fi *frontendIoctlState, ioctlParams *nvgpu.NVOS64Parameters, rightsRequested nvgpu.RS_ACCESS_MASK, allocParams *Params)) (uintptr, error) { +func rmAllocSimpleParams[Params any, PtrParams marshalPtr[Params]](fi *frontendIoctlState, ioctlParams *nvgpu.NVOS64Parameters, isNVOS64 bool, objAddLocked func(fi *frontendIoctlState, ioctlParams *nvgpu.NVOS64Parameters, rightsRequested nvgpu.RS_ACCESS_MASK, allocParams *Params)) (uintptr, error) { if ioctlParams.PAllocParms == 0 { return rmAllocInvoke[Params](fi, ioctlParams, nil, isNVOS64, objAddLocked) } var allocParams Params - if _, err := (PParams)(&allocParams).CopyIn(fi.t, addrFromP64(ioctlParams.PAllocParms)); err != nil { + if _, err := (PtrParams)(&allocParams).CopyIn(fi.t, addrFromP64(ioctlParams.PAllocParms)); err != nil { return 0, err } n, err := rmAllocInvoke(fi, ioctlParams, &allocParams, isNVOS64, objAddLocked) if err != nil { return n, err } - if _, err := (PParams)(&allocParams).CopyOut(fi.t, addrFromP64(ioctlParams.PAllocParms)); err != nil { + if _, err := (PtrParams)(&allocParams).CopyOut(fi.t, addrFromP64(ioctlParams.PAllocParms)); err != nil { return n, err } return n, nil diff --git a/pkg/sentry/devices/nvproxy/nvproxy.go b/pkg/sentry/devices/nvproxy/nvproxy.go index fd007addd4..7c12dd0c28 100644 --- a/pkg/sentry/devices/nvproxy/nvproxy.go +++ b/pkg/sentry/devices/nvproxy/nvproxy.go @@ -95,3 +95,8 @@ type marshalPtr[T any] interface { func addrFromP64(p nvgpu.P64) hostarch.Addr { return hostarch.Addr(uintptr(uint64(p))) } + +type hasFrontendFDPtr[T any] interface { + marshalPtr[T] + nvgpu.HasFrontendFD +} diff --git a/pkg/sentry/devices/nvproxy/uvm.go b/pkg/sentry/devices/nvproxy/uvm.go index aa94d31141..241910dd33 100644 --- a/pkg/sentry/devices/nvproxy/uvm.go +++ b/pkg/sentry/devices/nvproxy/uvm.go @@ -25,7 +25,6 @@ import ( "gvisor.dev/gvisor/pkg/fdnotifier" "gvisor.dev/gvisor/pkg/hostarch" "gvisor.dev/gvisor/pkg/log" - "gvisor.dev/gvisor/pkg/marshal" "gvisor.dev/gvisor/pkg/sentry/arch" "gvisor.dev/gvisor/pkg/sentry/kernel" "gvisor.dev/gvisor/pkg/sentry/vfs" @@ -165,16 +164,16 @@ func uvmIoctlNoParams(ui *uvmIoctlState) (uintptr, error) { return uvmIoctlInvoke[byte](ui, nil) } -func uvmIoctlSimple[Params any, PParams marshalPtr[Params]](ui *uvmIoctlState) (uintptr, error) { +func uvmIoctlSimple[Params any, PtrParams marshalPtr[Params]](ui *uvmIoctlState) (uintptr, error) { var ioctlParams Params - if _, err := (PParams)(&ioctlParams).CopyIn(ui.t, ui.ioctlParamsAddr); err != nil { + if _, err := (PtrParams)(&ioctlParams).CopyIn(ui.t, ui.ioctlParamsAddr); err != nil { return 0, err } n, err := uvmIoctlInvoke(ui, &ioctlParams) if err != nil { return n, err } - if _, err := (PParams)(&ioctlParams).CopyOut(ui.t, ui.ioctlParamsAddr); err != nil { + if _, err := (PtrParams)(&ioctlParams).CopyOut(ui.t, ui.ioctlParamsAddr); err != nil { return n, err } return n, nil @@ -241,25 +240,19 @@ func uvmMMInitialize(ui *uvmIoctlState) (uintptr, error) { return n, nil } -type hasRMCtrlFDPtr[T any] interface { - *T - marshal.Marshallable - nvgpu.HasRMCtrlFD -} - -func uvmIoctlHasRMCtrlFD[Params any, PParams hasRMCtrlFDPtr[Params]](ui *uvmIoctlState) (uintptr, error) { +func uvmIoctlHasFrontendFD[Params any, PtrParams hasFrontendFDPtr[Params]](ui *uvmIoctlState) (uintptr, error) { var ioctlParams Params - if _, err := (PParams)(&ioctlParams).CopyIn(ui.t, ui.ioctlParamsAddr); err != nil { + if _, err := (PtrParams)(&ioctlParams).CopyIn(ui.t, ui.ioctlParamsAddr); err != nil { return 0, err } - rmCtrlFD := (PParams)(&ioctlParams).GetRMCtrlFD() + rmCtrlFD := (PtrParams)(&ioctlParams).GetFrontendFD() if rmCtrlFD < 0 { n, err := uvmIoctlInvoke(ui, &ioctlParams) if err != nil { return n, err } - if _, err := (PParams)(&ioctlParams).CopyOut(ui.t, ui.ioctlParamsAddr); err != nil { + if _, err := (PtrParams)(&ioctlParams).CopyOut(ui.t, ui.ioctlParamsAddr); err != nil { return n, err } return n, nil @@ -276,15 +269,15 @@ func uvmIoctlHasRMCtrlFD[Params any, PParams hasRMCtrlFDPtr[Params]](ui *uvmIoct } sentryIoctlParams := ioctlParams - (PParams)(&sentryIoctlParams).SetRMCtrlFD(ctlFile.hostFD) + (PtrParams)(&sentryIoctlParams).SetFrontendFD(ctlFile.hostFD) n, err := uvmIoctlInvoke(ui, &sentryIoctlParams) if err != nil { return n, err } outIoctlParams := sentryIoctlParams - (PParams)(&outIoctlParams).SetRMCtrlFD(rmCtrlFD) - if _, err := (PParams)(&outIoctlParams).CopyOut(ui.t, ui.ioctlParamsAddr); err != nil { + (PtrParams)(&outIoctlParams).SetFrontendFD(rmCtrlFD) + if _, err := (PtrParams)(&outIoctlParams).CopyOut(ui.t, ui.ioctlParamsAddr); err != nil { return n, err } diff --git a/pkg/sentry/devices/nvproxy/version.go b/pkg/sentry/devices/nvproxy/version.go index bf16403df0..8523ef0e44 100644 --- a/pkg/sentry/devices/nvproxy/version.go +++ b/pkg/sentry/devices/nvproxy/version.go @@ -163,8 +163,8 @@ func Init() { nvgpu.NV_ESC_RM_UNMAP_MEMORY: frontendIoctlSimple, // NVOS34_PARAMETERS nvgpu.NV_ESC_RM_UPDATE_DEVICE_MAPPING_INFO: frontendIoctlSimple, // NVOS56_PARAMETERS nvgpu.NV_ESC_REGISTER_FD: frontendRegisterFD, - nvgpu.NV_ESC_ALLOC_OS_EVENT: rmAllocOSEvent, - nvgpu.NV_ESC_FREE_OS_EVENT: rmFreeOSEvent, + nvgpu.NV_ESC_ALLOC_OS_EVENT: frontendIoctHasFD[nvgpu.IoctlAllocOSEvent], + nvgpu.NV_ESC_FREE_OS_EVENT: frontendIoctHasFD[nvgpu.IoctlFreeOSEvent], nvgpu.NV_ESC_NUMA_INFO: rmNumaInfo, nvgpu.NV_ESC_RM_ALLOC_MEMORY: rmAllocMemory, nvgpu.NV_ESC_RM_FREE: rmFree, @@ -178,13 +178,13 @@ func Init() { nvgpu.UVM_DEINITIALIZE: uvmIoctlNoParams, nvgpu.UVM_CREATE_RANGE_GROUP: uvmIoctlSimple[nvgpu.UVM_CREATE_RANGE_GROUP_PARAMS], nvgpu.UVM_DESTROY_RANGE_GROUP: uvmIoctlSimple[nvgpu.UVM_DESTROY_RANGE_GROUP_PARAMS], - nvgpu.UVM_REGISTER_GPU_VASPACE: uvmIoctlHasRMCtrlFD[nvgpu.UVM_REGISTER_GPU_VASPACE_PARAMS], + nvgpu.UVM_REGISTER_GPU_VASPACE: uvmIoctlHasFrontendFD[nvgpu.UVM_REGISTER_GPU_VASPACE_PARAMS], nvgpu.UVM_UNREGISTER_GPU_VASPACE: uvmIoctlSimple[nvgpu.UVM_UNREGISTER_GPU_VASPACE_PARAMS], - nvgpu.UVM_REGISTER_CHANNEL: uvmIoctlHasRMCtrlFD[nvgpu.UVM_REGISTER_CHANNEL_PARAMS], + nvgpu.UVM_REGISTER_CHANNEL: uvmIoctlHasFrontendFD[nvgpu.UVM_REGISTER_CHANNEL_PARAMS], nvgpu.UVM_UNREGISTER_CHANNEL: uvmIoctlSimple[nvgpu.UVM_UNREGISTER_CHANNEL_PARAMS], - nvgpu.UVM_MAP_EXTERNAL_ALLOCATION: uvmIoctlHasRMCtrlFD[nvgpu.UVM_MAP_EXTERNAL_ALLOCATION_PARAMS], + nvgpu.UVM_MAP_EXTERNAL_ALLOCATION: uvmIoctlHasFrontendFD[nvgpu.UVM_MAP_EXTERNAL_ALLOCATION_PARAMS], nvgpu.UVM_FREE: uvmIoctlSimple[nvgpu.UVM_FREE_PARAMS], - nvgpu.UVM_REGISTER_GPU: uvmIoctlHasRMCtrlFD[nvgpu.UVM_REGISTER_GPU_PARAMS], + nvgpu.UVM_REGISTER_GPU: uvmIoctlHasFrontendFD[nvgpu.UVM_REGISTER_GPU_PARAMS], nvgpu.UVM_UNREGISTER_GPU: uvmIoctlSimple[nvgpu.UVM_UNREGISTER_GPU_PARAMS], nvgpu.UVM_PAGEABLE_MEM_ACCESS: uvmIoctlSimple[nvgpu.UVM_PAGEABLE_MEM_ACCESS_PARAMS], nvgpu.UVM_SET_PREFERRED_LOCATION: uvmIoctlSimple[nvgpu.UVM_SET_PREFERRED_LOCATION_PARAMS], @@ -278,7 +278,7 @@ func Init() { nvgpu.NVA06F_CTRL_CMD_GPFIFO_SCHEDULE: rmControlSimple, nvgpu.NVC56F_CTRL_CMD_GET_KMB: rmControlSimple, nvgpu.NV0000_CTRL_CMD_SYSTEM_GET_BUILD_VERSION: ctrlClientSystemGetBuildVersion, - nvgpu.NV0000_CTRL_CMD_OS_UNIX_EXPORT_OBJECT_TO_FD: ctrlExportObjectToFD, + nvgpu.NV0000_CTRL_CMD_OS_UNIX_EXPORT_OBJECT_TO_FD: ctrlHasFrontendFD[nvgpu.NV0000_CTRL_OS_UNIX_EXPORT_OBJECT_TO_FD_PARAMS], nvgpu.NV0080_CTRL_CMD_FIFO_GET_CHANNELLIST: ctrlDevFIFOGetChannelList, nvgpu.NV0080_CTRL_CMD_GPU_GET_CLASSLIST: ctrlDevGpuGetClasslist, nvgpu.NV2080_CTRL_CMD_FIFO_DISABLE_CHANNELS: ctrlSubdevFIFODisableChannels, @@ -363,7 +363,7 @@ func Init() { v550_54_14 := addDriverABI(550, 54, 14, "8c497ff1cfc7c310fb875149bc30faa4fd26d2237b2cba6cd2e8b0780157cfe3", func() *driverABI { abi := v550_40_07() abi.uvmIoctl[nvgpu.UVM_ALLOC_SEMAPHORE_POOL] = uvmIoctlSimple[nvgpu.UVM_ALLOC_SEMAPHORE_POOL_PARAMS_V550] - abi.uvmIoctl[nvgpu.UVM_MAP_EXTERNAL_ALLOCATION] = uvmIoctlHasRMCtrlFD[nvgpu.UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550] + abi.uvmIoctl[nvgpu.UVM_MAP_EXTERNAL_ALLOCATION] = uvmIoctlHasFrontendFD[nvgpu.UVM_MAP_EXTERNAL_ALLOCATION_PARAMS_V550] return abi }) _ = addDriverABI(550, 54, 15, "2e859ae5f912a9a47aaa9b2d40a94a14f6f486b5d3b67c0ddf8b72c1c9650385", v550_54_14)