From fd3eb7437d75a9940b1a25e1eb23107520ae4fba Mon Sep 17 00:00:00 2001 From: Ayush Ranjan Date: Tue, 14 May 2024 14:06:05 -0700 Subject: [PATCH] nvproxy: Expand HasRMCtrlFD idea to frontend ioctl and control commands. This is helpful for handling parameter types that have one field for frontend FD that needs to be translated (and are simple apart from that). Avoids repetitive code. Rename HasRMCtrlFD->HasFrontendFD so it can have a broader meaning. Implement generic handlers for frontend ioctl and control commands. Updates #10413. PiperOrigin-RevId: 633700330 --- pkg/abi/nvgpu/ctrl.go | 10 ++++ pkg/abi/nvgpu/frontend.go | 28 +++++++++ pkg/abi/nvgpu/uvm.go | 38 ++++++------ pkg/sentry/devices/nvproxy/frontend.go | 83 ++++++++------------------ pkg/sentry/devices/nvproxy/nvproxy.go | 5 ++ pkg/sentry/devices/nvproxy/uvm.go | 27 ++++----- pkg/sentry/devices/nvproxy/version.go | 16 ++--- 7 files changed, 106 insertions(+), 101 deletions(-) diff --git a/pkg/abi/nvgpu/ctrl.go b/pkg/abi/nvgpu/ctrl.go index e29928f84..6d56811f9 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 b8e52af51..2a5e838ee 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 4689ab5fe..4beefd225 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 d6bd0af52..16637b529 100644 --- a/pkg/sentry/devices/nvproxy/frontend.go +++ b/pkg/sentry/devices/nvproxy/frontend.go @@ -268,15 +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)) + + origFD := (PtrParams)(&ioctlParams).GetFrontendFD() + eventFileGeneric, _ := fi.t.FDTable().Get(origFD) if eventFileGeneric == nil { return 0, linuxerr.EINVAL } @@ -286,51 +288,15 @@ func rmAllocOSEvent(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 -} - -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)) - 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 } @@ -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 fd007addd..7c12dd0c2 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 aa94d3114..241910dd3 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 bf16403df..8523ef0e4 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)