nvidia(ctrla082): sync vGPU 19.x (R580) fields

- There were a large number of changes that are backwards incompatible
  which necessitated separate structures to track these changes.

- Thank you @rbqvq with
  2b08855f80
  for an initial version of this work!
  (#50)

src/lib.rs

@@ -56,7 +56,8 @@ use crate::nvidia::ctrla081::{
     NVA081_CTRL_CMD_VGPU_CONFIG_GET_MIGRATION_CAP, NVA081_CTRL_CMD_VGPU_CONFIG_GET_VGPU_TYPE_INFO,
 };
 use crate::nvidia::ctrla082::{
-    NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams,
+    NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525,
+    NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580,
     NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO,
 };
 use crate::nvidia::error::{
@@ -150,7 +151,7 @@ macro_rules! impl_trait_fn_aligned {
     };
 }
 
-impl VgpuConfigLike for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
+impl VgpuConfigLike for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525 {
     impl_trait_fn!(vgpu_type, u32);
     impl_trait_fn!(vgpu_name, [u8; ..]);
     impl_trait_fn!(vgpu_class, [u8; ..]);
@@ -188,6 +189,44 @@ impl VgpuConfigLike for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
     //impl_trait_fn!(vgpu_extra_params, [u8]);
 }
 
+impl VgpuConfigLike for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580 {
+    impl_trait_fn!(vgpu_type, u32);
+    impl_trait_fn!(vgpu_name, [u8; ..]);
+    impl_trait_fn!(vgpu_class, [u8; ..]);
+    //impl_trait_fn!(vgpu_signature, [u8; 128]);
+    impl_trait_fn!(license, [u8; 128]);
+    impl_trait_fn!(max_instance, u32);
+    impl_trait_fn!(num_heads, u32);
+    impl_trait_fn!(max_resolution_x, u32);
+    impl_trait_fn!(max_resolution_y, u32);
+    impl_trait_fn!(max_pixels, u32);
+    impl_trait_fn!(frl_config, u32);
+    impl_trait_fn!(cuda_enabled, u32);
+    impl_trait_fn!(ecc_supported, u32);
+    impl_trait_fn!(gpu_instance_size => mig_instance_size, u32);
+    impl_trait_fn!(multi_vgpu_supported, u32);
+    impl_trait_fn!(vdev_id, u64);
+    impl_trait_fn!(pdev_id, u64);
+
+    /*
+    fn profile_size(&mut self) -> Option<&mut u64> {
+        None
+    }
+    */
+
+    impl_trait_fn!(fb_length, u64);
+    impl_trait_fn!(mappable_video_size, u64);
+    impl_trait_fn!(fb_reservation, u64);
+    impl_trait_fn!(encoder_capacity, u32);
+    impl_trait_fn!(bar1_length, u64);
+    impl_trait_fn!(frl_enable, u32);
+    impl_trait_fn!(adapter_name, [u8; 64]);
+    impl_trait_fn!(adapter_name_unicode, [u16; 64]);
+    impl_trait_fn!(short_gpu_name_string, [u8; 64]);
+    impl_trait_fn!(licensed_product_name, [u8; 128]);
+    //impl_trait_fn!(vgpu_extra_params, [u8]);
+}
+
 impl VgpuConfigLike for NvA081CtrlVgpuInfoV525 {
     impl_trait_fn!(vgpu_type, u32);
     impl_trait_fn!(vgpu_name, [u8; ..]);
@@ -585,19 +624,34 @@ pub unsafe extern "C" fn ioctl(fd: RawFd, request: c_ulong, argp: *mut c_void) -
                     };
                 }
             }
-            NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO
-                if check_size!(
-                    NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO,
-                    NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams
-                ) =>
-            {
-                let params: &mut NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams =
-                    &mut *io_data.params.cast();
-                info!("{:#?}", params);
+            NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO => {
+                if check_size_raw!(NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525) {
+                    let params: &mut NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525 =
+                        &mut *io_data.params.cast();
+                    info!("{:#?}", params);
 
-                if !handle_profile_override(params) {
-                    error!("Failed to apply profile override");
-                    return -1;
+                    if !handle_profile_override(params) {
+                        error!("Failed to apply profile override");
+                        return -1;
+                    }
+                } else if check_size_raw!(NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580) {
+                    let params: &mut NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580 =
+                        &mut *io_data.params.cast();
+                    info!("{:#?}", params);
+
+                    if !handle_profile_override(params) {
+                        error!("Failed to apply profile override");
+                        return -1;
+                    }
+                } else {
+                    check_size_log! {
+                        name: NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO,
+                        types: [
+                            NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525,
+                            NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580,
+                        ],
+                        other: [],
+                    };
                 }
             }
             _ => {}

src/nvidia/ctrla082.rs

@@ -1,18 +1,23 @@
 use std::fmt;
 
-use crate::format::{CStrFormat, HexFormat, HexFormatSlice, WideCharFormat};
+use super::ctrl2080gpu::{NV2080_GPU_MAX_NAME_STRING_LENGTH, NV_GRID_LICENSE_INFO_MAX_LENGTH};
+use super::ctrla081::{
+    NVA081_EXTRA_PARAMETERS_SIZE, NVA081_MAX_VGPU_PER_PGPU_V580, NVA081_VGPU_SIGNATURE_SIZE,
+    NVA081_VGPU_STRING_BUFFER_SIZE_V525, NVA081_VGPU_STRING_BUFFER_SIZE_V580,
+};
+use crate::format::{CStrFormat, HexFormat, HexFormatSlice, StraightFormat, WideCharFormat};
 
 /// Inferred based on `NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO_PARAMS`
 pub const NVA082_CTRL_CMD_HOST_VGPU_DEVICE_GET_VGPU_TYPE_INFO: u32 = 0xa0820102;
 
 /// Pulled from a comment in [`NVA081_CTRL_VGPU_INFO`](https://github.com/NVIDIA/open-gpu-kernel-modules/blob/758b4ee8189c5198504cb1c3c5bc29027a9118a3/src/common/sdk/nvidia/inc/ctrl/ctrla081.h#L82)
 #[repr(C)]
-pub struct NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
+pub struct NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525 {
     pub vgpu_type: u32,
-    pub vgpu_name: [u8; 32],
-    pub vgpu_class: [u8; 32],
-    pub vgpu_signature: [u8; 128],
-    pub license: [u8; 128],
+    pub vgpu_name: [u8; NVA081_VGPU_STRING_BUFFER_SIZE_V525],
+    pub vgpu_class: [u8; NVA081_VGPU_STRING_BUFFER_SIZE_V525],
+    pub vgpu_signature: [u8; NVA081_VGPU_SIGNATURE_SIZE],
+    pub license: [u8; NV_GRID_LICENSE_INFO_MAX_LENGTH],
     pub max_instance: u32,
     pub num_heads: u32,
     pub max_resolution_x: u32,
@@ -33,15 +38,61 @@ pub struct NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
     pub encoder_capacity: u32,
     pub bar1_length: u64,
     pub frl_enable: u32,
-    pub adapter_name: [u8; 64],
-    pub adapter_name_unicode: [u16; 64],
-    pub short_gpu_name_string: [u8; 64],
-    pub licensed_product_name: [u8; 128],
-    pub vgpu_extra_params: [u8; 1024],
+    pub adapter_name: [u8; NV2080_GPU_MAX_NAME_STRING_LENGTH],
+    pub adapter_name_unicode: [u16; NV2080_GPU_MAX_NAME_STRING_LENGTH],
+    pub short_gpu_name_string: [u8; NV2080_GPU_MAX_NAME_STRING_LENGTH],
+    pub licensed_product_name: [u8; NV_GRID_LICENSE_INFO_MAX_LENGTH],
+    pub vgpu_extra_params: [u8; NVA081_EXTRA_PARAMETERS_SIZE],
     unknown_end: [u8; 8],
 }
 
-impl fmt::Debug for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
+/// Pulled from a comment in [`NVA081_CTRL_VGPU_INFO`](https://github.com/NVIDIA/open-gpu-kernel-modules/blob/307159f2623d3bf45feb9177bd2da52ffbc5ddf9/src/common/sdk/nvidia/inc/ctrl/ctrla081.h#L89)
+#[repr(C)]
+pub struct NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580 {
+    pub vgpu_type: u32,
+    pub vgpu_name: [u8; NVA081_VGPU_STRING_BUFFER_SIZE_V580],
+    pub vgpu_class: [u8; NVA081_VGPU_STRING_BUFFER_SIZE_V580],
+    pub vgpu_signature: [u8; NVA081_VGPU_SIGNATURE_SIZE],
+    pub license: [u8; NV_GRID_LICENSE_INFO_MAX_LENGTH],
+    pub max_instance: u32,
+    pub num_heads: u32,
+    pub max_resolution_x: u32,
+    pub max_resolution_y: u32,
+    pub max_pixels: u32,
+    pub frl_config: u32,
+    pub cuda_enabled: u32,
+    pub ecc_supported: u32,
+    pub gpu_instance_size: u32,
+    pub multi_vgpu_supported: u32,
+    pub vdev_id: u64,
+    pub pdev_id: u64,
+    pub fb_length: u64,
+    pub mappable_video_size: u64,
+    pub fb_reservation: u64,
+    pub encoder_capacity: u32,
+    pub bar1_length: u64,
+    pub frl_enable: u32,
+    pub adapter_name: [u8; NV2080_GPU_MAX_NAME_STRING_LENGTH],
+    pub adapter_name_unicode: [u16; NV2080_GPU_MAX_NAME_STRING_LENGTH],
+    pub short_gpu_name_string: [u8; NV2080_GPU_MAX_NAME_STRING_LENGTH],
+    pub licensed_product_name: [u8; NV_GRID_LICENSE_INFO_MAX_LENGTH],
+    pub vgpu_extra_params: [u8; NVA081_EXTRA_PARAMETERS_SIZE],
+    pub ftrace_enable: u32,
+    pub gpu_direct_supported: u32,
+    pub nvlink_p2p_supported: u32,
+    pub max_instance_per_gi: u32,
+    pub multi_vgpu_exclusive: u32,
+    pub exclusive_type: u32,
+    pub exclusive_size: u32,
+    pub gpu_instance_profile_id: u32,
+    pub placement_size: u32,
+    pub homogeneous_placement_count: u32,
+    pub homogeneous_placement_ids: [u32; NVA081_MAX_VGPU_PER_PGPU_V580],
+    pub heterogeneous_placement_count: u32,
+    pub heterogeneous_placement_ids: [u32; NVA081_MAX_VGPU_PER_PGPU_V580],
+}
+
+impl fmt::Debug for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let vgpu_signature = if self.vgpu_signature[..].iter().any(|&x| x != 0) {
             &self.vgpu_signature[..]
@@ -54,7 +105,7 @@ impl fmt::Debug for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
             &[]
         };
 
-        f.debug_struct("NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams")
+        f.debug_struct("NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525")
             .field("vgpu_type", &self.vgpu_type)
             .field("vgpu_name", &CStrFormat(&self.vgpu_name))
             .field("vgpu_class", &CStrFormat(&self.vgpu_class))
@@ -96,17 +147,103 @@ impl fmt::Debug for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams {
     }
 }
 
+impl fmt::Debug for NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580 {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let vgpu_signature = if self.vgpu_signature[..].iter().any(|&x| x != 0) {
+            &self.vgpu_signature[..]
+        } else {
+            &[]
+        };
+        let vgpu_extra_params = if self.vgpu_extra_params[..].iter().any(|&x| x != 0) {
+            &self.vgpu_extra_params[..]
+        } else {
+            &[]
+        };
+
+        f.debug_struct("NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580")
+            .field("vgpu_type", &self.vgpu_type)
+            .field("vgpu_name", &CStrFormat(&self.vgpu_name))
+            .field("vgpu_class", &CStrFormat(&self.vgpu_class))
+            .field("vgpu_signature", &HexFormatSlice(vgpu_signature))
+            .field("license", &CStrFormat(&self.license))
+            .field("max_instance", &self.max_instance)
+            .field("num_heads", &self.num_heads)
+            .field("max_resolution_x", &self.max_resolution_x)
+            .field("max_resolution_y", &self.max_resolution_y)
+            .field("max_pixels", &self.max_pixels)
+            .field("frl_config", &self.frl_config)
+            .field("cuda_enabled", &self.cuda_enabled)
+            .field("ecc_supported", &self.ecc_supported)
+            .field("gpu_instance_size", &self.gpu_instance_size)
+            .field("multi_vgpu_supported", &self.multi_vgpu_supported)
+            .field("vdev_id", &HexFormat(self.vdev_id))
+            .field("pdev_id", &HexFormat(self.pdev_id))
+            .field("fb_length", &HexFormat(self.fb_length))
+            .field("mappable_video_size", &HexFormat(self.mappable_video_size))
+            .field("fb_reservation", &HexFormat(self.fb_reservation))
+            .field("encoder_capacity", &HexFormat(self.encoder_capacity))
+            .field("bar1_length", &HexFormat(self.bar1_length))
+            .field("frl_enable", &self.frl_enable)
+            .field("adapter_name", &CStrFormat(&self.adapter_name))
+            .field(
+                "adapter_name_unicode",
+                &WideCharFormat(&self.adapter_name_unicode),
+            )
+            .field(
+                "short_gpu_name_string",
+                &CStrFormat(&self.short_gpu_name_string),
+            )
+            .field(
+                "licensed_product_name",
+                &CStrFormat(&self.licensed_product_name),
+            )
+            .field("vgpu_extra_params", &HexFormatSlice(vgpu_extra_params))
+            .field("ftrace_enable", &self.ftrace_enable)
+            .field("gpu_direct_supported", &self.gpu_direct_supported)
+            .field("nvlink_p2p_supported", &self.nvlink_p2p_supported)
+            .field("max_instance_per_gi", &self.max_instance_per_gi)
+            .field("multi_vgpu_exclusive", &self.multi_vgpu_exclusive)
+            .field("exclusive_type", &self.exclusive_type)
+            .field("exclusive_size", &self.exclusive_size)
+            .field("gpu_instance_profile_id", &self.gpu_instance_profile_id)
+            .field(
+                "homogeneous_placement_count",
+                &self.homogeneous_placement_count,
+            )
+            .field(
+                "homogeneous_placement_ids",
+                &StraightFormat(&self.homogeneous_placement_ids[..]),
+            )
+            .field(
+                "heterogeneous_placement_count",
+                &self.heterogeneous_placement_count,
+            )
+            .field(
+                "heterogeneous_placement_ids",
+                &StraightFormat(&self.heterogeneous_placement_ids[..]),
+            )
+            .finish()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::mem;
 
-    use super::NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams;
+    use super::{
+        NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525,
+        NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580,
+    };
 
     #[test]
     fn verify_sizes() {
         assert_eq!(
-            mem::size_of::<NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParams>(),
+            mem::size_of::<NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV525>(),
             0x738
         );
+        assert_eq!(
+            mem::size_of::<NvA082CtrlCmdHostVgpuDeviceGetVgpuTypeInfoParamsV580>(),
+            0x918
+        );
     }
 }