#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub unsafe fn as_ptr(&self) -> *const T {
::std::mem::transmute(self)
}
#[inline]
pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
::std::mem::transmute(self)
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
impl<T> ::std::clone::Clone for __IncompleteArrayField<T> {
#[inline]
fn clone(&self) -> Self {
Self::new()
}
}
pub const __BITS_PER_LONG: u32 = 64;
pub const __FD_SETSIZE: u32 = 1024;
pub const _IOC_NRBITS: u32 = 8;
pub const _IOC_TYPEBITS: u32 = 8;
pub const _IOC_SIZEBITS: u32 = 14;
pub const _IOC_DIRBITS: u32 = 2;
pub const _IOC_NRMASK: u32 = 255;
pub const _IOC_TYPEMASK: u32 = 255;
pub const _IOC_SIZEMASK: u32 = 16383;
pub const _IOC_DIRMASK: u32 = 3;
pub const _IOC_NRSHIFT: u32 = 0;
pub const _IOC_TYPESHIFT: u32 = 8;
pub const _IOC_SIZESHIFT: u32 = 16;
pub const _IOC_DIRSHIFT: u32 = 30;
pub const _IOC_NONE: u32 = 0;
pub const _IOC_WRITE: u32 = 1;
pub const _IOC_READ: u32 = 2;
pub const IOC_IN: u32 = 1073741824;
pub const IOC_OUT: u32 = 2147483648;
pub const IOC_INOUT: u32 = 3221225472;
pub const IOCSIZE_MASK: u32 = 1073676288;
pub const IOCSIZE_SHIFT: u32 = 16;
pub const VFIO_API_VERSION: u32 = 0;
pub const VFIO_TYPE1_IOMMU: u32 = 1;
pub const VFIO_SPAPR_TCE_IOMMU: u32 = 2;
pub const VFIO_TYPE1v2_IOMMU: u32 = 3;
pub const VFIO_DMA_CC_IOMMU: u32 = 4;
pub const VFIO_EEH: u32 = 5;
pub const VFIO_TYPE1_NESTING_IOMMU: u32 = 6;
pub const VFIO_SPAPR_TCE_v2_IOMMU: u32 = 7;
pub const VFIO_NOIOMMU_IOMMU: u32 = 8;
pub const VFIO_TYPE: u32 = 59;
pub const VFIO_BASE: u32 = 100;
pub const VFIO_GROUP_FLAGS_VIABLE: u32 = 1;
pub const VFIO_GROUP_FLAGS_CONTAINER_SET: u32 = 2;
pub const VFIO_DEVICE_FLAGS_RESET: u32 = 1;
pub const VFIO_DEVICE_FLAGS_PCI: u32 = 2;
pub const VFIO_DEVICE_FLAGS_PLATFORM: u32 = 4;
pub const VFIO_DEVICE_FLAGS_AMBA: u32 = 8;
pub const VFIO_DEVICE_FLAGS_CCW: u32 = 16;
pub const VFIO_DEVICE_FLAGS_AP: u32 = 32;
pub const VFIO_DEVICE_API_PCI_STRING: &'static [u8; 9usize] = b"vfio-pci\0";
pub const VFIO_DEVICE_API_PLATFORM_STRING: &'static [u8; 14usize] = b"vfio-platform\0";
pub const VFIO_DEVICE_API_AMBA_STRING: &'static [u8; 10usize] = b"vfio-amba\0";
pub const VFIO_DEVICE_API_CCW_STRING: &'static [u8; 9usize] = b"vfio-ccw\0";
pub const VFIO_DEVICE_API_AP_STRING: &'static [u8; 8usize] = b"vfio-ap\0";
pub const VFIO_REGION_INFO_FLAG_READ: u32 = 1;
pub const VFIO_REGION_INFO_FLAG_WRITE: u32 = 2;
pub const VFIO_REGION_INFO_FLAG_MMAP: u32 = 4;
pub const VFIO_REGION_INFO_FLAG_CAPS: u32 = 8;
pub const VFIO_REGION_INFO_CAP_SPARSE_MMAP: u32 = 1;
pub const VFIO_REGION_INFO_CAP_TYPE: u32 = 2;
pub const VFIO_REGION_TYPE_PCI_VENDOR_TYPE: u32 = 2147483648;
pub const VFIO_REGION_TYPE_PCI_VENDOR_MASK: u32 = 65535;
pub const VFIO_REGION_SUBTYPE_INTEL_IGD_OPREGION: u32 = 1;
pub const VFIO_REGION_SUBTYPE_INTEL_IGD_HOST_CFG: u32 = 2;
pub const VFIO_REGION_SUBTYPE_INTEL_IGD_LPC_CFG: u32 = 3;
pub const VFIO_REGION_TYPE_GFX: u32 = 1;
pub const VFIO_REGION_SUBTYPE_GFX_EDID: u32 = 1;
pub const VFIO_DEVICE_GFX_LINK_STATE_UP: u32 = 1;
pub const VFIO_DEVICE_GFX_LINK_STATE_DOWN: u32 = 2;
pub const VFIO_REGION_SUBTYPE_NVIDIA_NVLINK2_RAM: u32 = 1;
pub const VFIO_REGION_SUBTYPE_IBM_NVLINK2_ATSD: u32 = 1;
pub const VFIO_REGION_INFO_CAP_MSIX_MAPPABLE: u32 = 3;
pub const VFIO_REGION_INFO_CAP_NVLINK2_SSATGT: u32 = 4;
pub const VFIO_REGION_INFO_CAP_NVLINK2_LNKSPD: u32 = 5;
pub const VFIO_IRQ_INFO_EVENTFD: u32 = 1;
pub const VFIO_IRQ_INFO_MASKABLE: u32 = 2;
pub const VFIO_IRQ_INFO_AUTOMASKED: u32 = 4;
pub const VFIO_IRQ_INFO_NORESIZE: u32 = 8;
pub const VFIO_IRQ_SET_DATA_NONE: u32 = 1;
pub const VFIO_IRQ_SET_DATA_BOOL: u32 = 2;
pub const VFIO_IRQ_SET_DATA_EVENTFD: u32 = 4;
pub const VFIO_IRQ_SET_ACTION_MASK: u32 = 8;
pub const VFIO_IRQ_SET_ACTION_UNMASK: u32 = 16;
pub const VFIO_IRQ_SET_ACTION_TRIGGER: u32 = 32;
pub const VFIO_IRQ_SET_DATA_TYPE_MASK: u32 = 7;
pub const VFIO_IRQ_SET_ACTION_TYPE_MASK: u32 = 56;
pub const VFIO_GFX_PLANE_TYPE_PROBE: u32 = 1;
pub const VFIO_GFX_PLANE_TYPE_DMABUF: u32 = 2;
pub const VFIO_GFX_PLANE_TYPE_REGION: u32 = 4;
pub const VFIO_DEVICE_IOEVENTFD_8: u32 = 1;
pub const VFIO_DEVICE_IOEVENTFD_16: u32 = 2;
pub const VFIO_DEVICE_IOEVENTFD_32: u32 = 4;
pub const VFIO_DEVICE_IOEVENTFD_64: u32 = 8;
pub const VFIO_DEVICE_IOEVENTFD_SIZE_MASK: u32 = 15;
pub const VFIO_IOMMU_INFO_PGSIZES: u32 = 1;
pub const VFIO_DMA_MAP_FLAG_READ: u32 = 1;
pub const VFIO_DMA_MAP_FLAG_WRITE: u32 = 2;
pub const VFIO_IOMMU_SPAPR_INFO_DDW: u32 = 1;
pub const VFIO_EEH_PE_DISABLE: u32 = 0;
pub const VFIO_EEH_PE_ENABLE: u32 = 1;
pub const VFIO_EEH_PE_UNFREEZE_IO: u32 = 2;
pub const VFIO_EEH_PE_UNFREEZE_DMA: u32 = 3;
pub const VFIO_EEH_PE_GET_STATE: u32 = 4;
pub const VFIO_EEH_PE_STATE_NORMAL: u32 = 0;
pub const VFIO_EEH_PE_STATE_RESET: u32 = 1;
pub const VFIO_EEH_PE_STATE_STOPPED: u32 = 2;
pub const VFIO_EEH_PE_STATE_STOPPED_DMA: u32 = 4;
pub const VFIO_EEH_PE_STATE_UNAVAIL: u32 = 5;
pub const VFIO_EEH_PE_RESET_DEACTIVATE: u32 = 5;
pub const VFIO_EEH_PE_RESET_HOT: u32 = 6;
pub const VFIO_EEH_PE_RESET_FUNDAMENTAL: u32 = 7;
pub const VFIO_EEH_PE_CONFIGURE: u32 = 8;
pub const VFIO_EEH_PE_INJECT_ERR: u32 = 9;
pub type __s8 = ::std::os::raw::c_schar;
pub type __u8 = ::std::os::raw::c_uchar;
pub type __s16 = ::std::os::raw::c_short;
pub type __u16 = ::std::os::raw::c_ushort;
pub type __s32 = ::std::os::raw::c_int;
pub type __u32 = ::std::os::raw::c_uint;
pub type __s64 = ::std::os::raw::c_longlong;
pub type __u64 = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct __kernel_fd_set {
pub fds_bits: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___kernel_fd_set() {
assert_eq!(
::std::mem::size_of::<__kernel_fd_set>(),
128usize,
concat!("Size of: ", stringify!(__kernel_fd_set))
);
assert_eq!(
::std::mem::align_of::<__kernel_fd_set>(),
8usize,
concat!("Alignment of ", stringify!(__kernel_fd_set))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__kernel_fd_set>())).fds_bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__kernel_fd_set),
"::",
stringify!(fds_bits)
)
);
}
pub type __kernel_sighandler_t =
::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
pub type __kernel_key_t = ::std::os::raw::c_int;
pub type __kernel_mqd_t = ::std::os::raw::c_int;
pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
pub type __kernel_long_t = ::std::os::raw::c_long;
pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
pub type __kernel_ino_t = __kernel_ulong_t;
pub type __kernel_mode_t = ::std::os::raw::c_uint;
pub type __kernel_pid_t = ::std::os::raw::c_int;
pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
pub type __kernel_uid_t = ::std::os::raw::c_uint;
pub type __kernel_gid_t = ::std::os::raw::c_uint;
pub type __kernel_suseconds_t = __kernel_long_t;
pub type __kernel_daddr_t = ::std::os::raw::c_int;
pub type __kernel_uid32_t = ::std::os::raw::c_uint;
pub type __kernel_gid32_t = ::std::os::raw::c_uint;
pub type __kernel_size_t = __kernel_ulong_t;
pub type __kernel_ssize_t = __kernel_long_t;
pub type __kernel_ptrdiff_t = __kernel_long_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct __kernel_fsid_t {
pub val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___kernel_fsid_t() {
assert_eq!(
::std::mem::size_of::<__kernel_fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__kernel_fsid_t))
);
assert_eq!(
::std::mem::align_of::<__kernel_fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__kernel_fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__kernel_fsid_t>())).val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__kernel_fsid_t),
"::",
stringify!(val)
)
);
}
pub type __kernel_off_t = __kernel_long_t;
pub type __kernel_loff_t = ::std::os::raw::c_longlong;
pub type __kernel_time_t = __kernel_long_t;
pub type __kernel_time64_t = ::std::os::raw::c_longlong;
pub type __kernel_clock_t = __kernel_long_t;
pub type __kernel_timer_t = ::std::os::raw::c_int;
pub type __kernel_clockid_t = ::std::os::raw::c_int;
pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
pub type __le16 = __u16;
pub type __be16 = __u16;
pub type __le32 = __u32;
pub type __be32 = __u32;
pub type __le64 = __u64;
pub type __be64 = __u64;
pub type __sum16 = __u16;
pub type __wsum = __u32;
pub type __poll_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_info_cap_header {
pub id: __u16,
pub version: __u16,
pub next: __u32,
}
#[test]
fn bindgen_test_layout_vfio_info_cap_header() {
assert_eq!(
::std::mem::size_of::<vfio_info_cap_header>(),
8usize,
concat!("Size of: ", stringify!(vfio_info_cap_header))
);
assert_eq!(
::std::mem::align_of::<vfio_info_cap_header>(),
4usize,
concat!("Alignment of ", stringify!(vfio_info_cap_header))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_info_cap_header>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_info_cap_header),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_info_cap_header>())).version as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(vfio_info_cap_header),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_info_cap_header>())).next as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_info_cap_header),
"::",
stringify!(next)
)
);
}
#[doc = " VFIO_GROUP_GET_STATUS - _IOR(VFIO_TYPE, VFIO_BASE + 3,"]
#[doc = "\t\t\t\t\t\tstruct vfio_group_status)"]
#[doc = ""]
#[doc = " Retrieve information about the group. Fills in provided"]
#[doc = " struct vfio_group_info. Caller sets argsz."]
#[doc = " Return: 0 on succes, -errno on failure."]
#[doc = " Availability: Always"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_group_status {
pub argsz: __u32,
pub flags: __u32,
}
#[test]
fn bindgen_test_layout_vfio_group_status() {
assert_eq!(
::std::mem::size_of::<vfio_group_status>(),
8usize,
concat!("Size of: ", stringify!(vfio_group_status))
);
assert_eq!(
::std::mem::align_of::<vfio_group_status>(),
4usize,
concat!("Alignment of ", stringify!(vfio_group_status))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_group_status>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_group_status),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_group_status>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_group_status),
"::",
stringify!(flags)
)
);
}
#[doc = " VFIO_DEVICE_GET_INFO - _IOR(VFIO_TYPE, VFIO_BASE + 7,"]
#[doc = "\t\t\t\t\t\tstruct vfio_device_info)"]
#[doc = ""]
#[doc = " Retrieve information about the device. Fills in provided"]
#[doc = " struct vfio_device_info. Caller sets argsz."]
#[doc = " Return: 0 on success, -errno on failure."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_device_info {
pub argsz: __u32,
pub flags: __u32,
pub num_regions: __u32,
pub num_irqs: __u32,
}
#[test]
fn bindgen_test_layout_vfio_device_info() {
assert_eq!(
::std::mem::size_of::<vfio_device_info>(),
16usize,
concat!("Size of: ", stringify!(vfio_device_info))
);
assert_eq!(
::std::mem::align_of::<vfio_device_info>(),
4usize,
concat!("Alignment of ", stringify!(vfio_device_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_info>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_info),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_info>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_info>())).num_regions as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_info),
"::",
stringify!(num_regions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_info>())).num_irqs as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_info),
"::",
stringify!(num_irqs)
)
);
}
#[doc = " VFIO_DEVICE_GET_REGION_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 8,"]
#[doc = "\t\t\t\t struct vfio_region_info)"]
#[doc = ""]
#[doc = " Retrieve information about a device region. Caller provides"]
#[doc = " struct vfio_region_info with index value set. Caller sets argsz."]
#[doc = " Implementation of region mapping is bus driver specific. This is"]
#[doc = " intended to describe MMIO, I/O port, as well as bus specific"]
#[doc = " regions (ex. PCI config space). Zero sized regions may be used"]
#[doc = " to describe unimplemented regions (ex. unimplemented PCI BARs)."]
#[doc = " Return: 0 on success, -errno on failure."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_region_info {
pub argsz: __u32,
pub flags: __u32,
pub index: __u32,
pub cap_offset: __u32,
pub size: __u64,
pub offset: __u64,
}
#[test]
fn bindgen_test_layout_vfio_region_info() {
assert_eq!(
::std::mem::size_of::<vfio_region_info>(),
32usize,
concat!("Size of: ", stringify!(vfio_region_info))
);
assert_eq!(
::std::mem::align_of::<vfio_region_info>(),
8usize,
concat!("Alignment of ", stringify!(vfio_region_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info>())).index as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info>())).cap_offset as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info),
"::",
stringify!(cap_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info>())).offset as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info),
"::",
stringify!(offset)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_region_sparse_mmap_area {
pub offset: __u64,
pub size: __u64,
}
#[test]
fn bindgen_test_layout_vfio_region_sparse_mmap_area() {
assert_eq!(
::std::mem::size_of::<vfio_region_sparse_mmap_area>(),
16usize,
concat!("Size of: ", stringify!(vfio_region_sparse_mmap_area))
);
assert_eq!(
::std::mem::align_of::<vfio_region_sparse_mmap_area>(),
8usize,
concat!("Alignment of ", stringify!(vfio_region_sparse_mmap_area))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_sparse_mmap_area>())).offset as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_sparse_mmap_area),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_sparse_mmap_area>())).size as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_sparse_mmap_area),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct vfio_region_info_cap_sparse_mmap {
pub header: vfio_info_cap_header,
pub nr_areas: __u32,
pub reserved: __u32,
pub areas: __IncompleteArrayField<vfio_region_sparse_mmap_area>,
}
#[test]
fn bindgen_test_layout_vfio_region_info_cap_sparse_mmap() {
assert_eq!(
::std::mem::size_of::<vfio_region_info_cap_sparse_mmap>(),
16usize,
concat!("Size of: ", stringify!(vfio_region_info_cap_sparse_mmap))
);
assert_eq!(
::std::mem::align_of::<vfio_region_info_cap_sparse_mmap>(),
8usize,
concat!(
"Alignment of ",
stringify!(vfio_region_info_cap_sparse_mmap)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_region_info_cap_type {
pub header: vfio_info_cap_header,
pub type_: __u32,
pub subtype: __u32,
}
#[test]
fn bindgen_test_layout_vfio_region_info_cap_type() {
assert_eq!(
::std::mem::size_of::<vfio_region_info_cap_type>(),
16usize,
concat!("Size of: ", stringify!(vfio_region_info_cap_type))
);
assert_eq!(
::std::mem::align_of::<vfio_region_info_cap_type>(),
4usize,
concat!("Alignment of ", stringify!(vfio_region_info_cap_type))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_type>())).header as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_type),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_info_cap_type>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_type),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_type>())).subtype as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_type),
"::",
stringify!(subtype)
)
);
}
#[doc = " struct vfio_region_gfx_edid - EDID region layout."]
#[doc = ""]
#[doc = " Set display link state and EDID blob."]
#[doc = ""]
#[doc = " The EDID blob has monitor information such as brand, name, serial"]
#[doc = " number, physical size, supported video modes and more."]
#[doc = ""]
#[doc = " This special region allows userspace (typically qemu) set a virtual"]
#[doc = " EDID for the virtual monitor, which allows a flexible display"]
#[doc = " configuration."]
#[doc = ""]
#[doc = " For the edid blob spec look here:"]
#[doc = " https://en.wikipedia.org/wiki/Extended_Display_Identification_Data"]
#[doc = ""]
#[doc = " On linux systems you can find the EDID blob in sysfs:"]
#[doc = " /sys/class/drm/${card}/${connector}/edid"]
#[doc = ""]
#[doc = " You can use the edid-decode ulility (comes with xorg-x11-utils) to"]
#[doc = " decode the EDID blob."]
#[doc = ""]
#[doc = " @edid_offset: location of the edid blob, relative to the"]
#[doc = " start of the region (readonly)."]
#[doc = " @edid_max_size: max size of the edid blob (readonly)."]
#[doc = " @edid_size: actual edid size (read/write)."]
#[doc = " @link_state: display link state (read/write)."]
#[doc = " VFIO_DEVICE_GFX_LINK_STATE_UP: Monitor is turned on."]
#[doc = " VFIO_DEVICE_GFX_LINK_STATE_DOWN: Monitor is turned off."]
#[doc = " @max_xres: max display width (0 == no limitation, readonly)."]
#[doc = " @max_yres: max display height (0 == no limitation, readonly)."]
#[doc = ""]
#[doc = " EDID update protocol:"]
#[doc = " (1) set link-state to down."]
#[doc = " (2) update edid blob and size."]
#[doc = " (3) set link-state to up."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_region_gfx_edid {
pub edid_offset: __u32,
pub edid_max_size: __u32,
pub edid_size: __u32,
pub max_xres: __u32,
pub max_yres: __u32,
pub link_state: __u32,
}
#[test]
fn bindgen_test_layout_vfio_region_gfx_edid() {
assert_eq!(
::std::mem::size_of::<vfio_region_gfx_edid>(),
24usize,
concat!("Size of: ", stringify!(vfio_region_gfx_edid))
);
assert_eq!(
::std::mem::align_of::<vfio_region_gfx_edid>(),
4usize,
concat!("Alignment of ", stringify!(vfio_region_gfx_edid))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_gfx_edid>())).edid_offset as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_gfx_edid),
"::",
stringify!(edid_offset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_gfx_edid>())).edid_max_size as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_gfx_edid),
"::",
stringify!(edid_max_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_gfx_edid>())).edid_size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_gfx_edid),
"::",
stringify!(edid_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_gfx_edid>())).max_xres as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_gfx_edid),
"::",
stringify!(max_xres)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_gfx_edid>())).max_yres as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_gfx_edid),
"::",
stringify!(max_yres)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_region_gfx_edid>())).link_state as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_gfx_edid),
"::",
stringify!(link_state)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_region_info_cap_nvlink2_ssatgt {
pub header: vfio_info_cap_header,
pub tgt: __u64,
}
#[test]
fn bindgen_test_layout_vfio_region_info_cap_nvlink2_ssatgt() {
assert_eq!(
::std::mem::size_of::<vfio_region_info_cap_nvlink2_ssatgt>(),
16usize,
concat!("Size of: ", stringify!(vfio_region_info_cap_nvlink2_ssatgt))
);
assert_eq!(
::std::mem::align_of::<vfio_region_info_cap_nvlink2_ssatgt>(),
8usize,
concat!(
"Alignment of ",
stringify!(vfio_region_info_cap_nvlink2_ssatgt)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_nvlink2_ssatgt>())).header as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_nvlink2_ssatgt),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_nvlink2_ssatgt>())).tgt as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_nvlink2_ssatgt),
"::",
stringify!(tgt)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_region_info_cap_nvlink2_lnkspd {
pub header: vfio_info_cap_header,
pub link_speed: __u32,
pub __pad: __u32,
}
#[test]
fn bindgen_test_layout_vfio_region_info_cap_nvlink2_lnkspd() {
assert_eq!(
::std::mem::size_of::<vfio_region_info_cap_nvlink2_lnkspd>(),
16usize,
concat!("Size of: ", stringify!(vfio_region_info_cap_nvlink2_lnkspd))
);
assert_eq!(
::std::mem::align_of::<vfio_region_info_cap_nvlink2_lnkspd>(),
4usize,
concat!(
"Alignment of ",
stringify!(vfio_region_info_cap_nvlink2_lnkspd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_nvlink2_lnkspd>())).header as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_nvlink2_lnkspd),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_nvlink2_lnkspd>())).link_speed as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_nvlink2_lnkspd),
"::",
stringify!(link_speed)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_region_info_cap_nvlink2_lnkspd>())).__pad as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_region_info_cap_nvlink2_lnkspd),
"::",
stringify!(__pad)
)
);
}
#[doc = " VFIO_DEVICE_GET_IRQ_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 9,"]
#[doc = "\t\t\t\t struct vfio_irq_info)"]
#[doc = ""]
#[doc = " Retrieve information about a device IRQ. Caller provides"]
#[doc = " struct vfio_irq_info with index value set. Caller sets argsz."]
#[doc = " Implementation of IRQ mapping is bus driver specific. Indexes"]
#[doc = " using multiple IRQs are primarily intended to support MSI-like"]
#[doc = " interrupt blocks. Zero count irq blocks may be used to describe"]
#[doc = " unimplemented interrupt types."]
#[doc = ""]
#[doc = " The EVENTFD flag indicates the interrupt index supports eventfd based"]
#[doc = " signaling."]
#[doc = ""]
#[doc = " The MASKABLE flags indicates the index supports MASK and UNMASK"]
#[doc = " actions described below."]
#[doc = ""]
#[doc = " AUTOMASKED indicates that after signaling, the interrupt line is"]
#[doc = " automatically masked by VFIO and the user needs to unmask the line"]
#[doc = " to receive new interrupts. This is primarily intended to distinguish"]
#[doc = " level triggered interrupts."]
#[doc = ""]
#[doc = " The NORESIZE flag indicates that the interrupt lines within the index"]
#[doc = " are setup as a set and new subindexes cannot be enabled without first"]
#[doc = " disabling the entire index. This is used for interrupts like PCI MSI"]
#[doc = " and MSI-X where the driver may only use a subset of the available"]
#[doc = " indexes, but VFIO needs to enable a specific number of vectors"]
#[doc = " upfront. In the case of MSI-X, where the user can enable MSI-X and"]
#[doc = " then add and unmask vectors, it's up to userspace to make the decision"]
#[doc = " whether to allocate the maximum supported number of vectors or tear"]
#[doc = " down setup and incrementally increase the vectors as each is enabled."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_irq_info {
pub argsz: __u32,
pub flags: __u32,
pub index: __u32,
pub count: __u32,
}
#[test]
fn bindgen_test_layout_vfio_irq_info() {
assert_eq!(
::std::mem::size_of::<vfio_irq_info>(),
16usize,
concat!("Size of: ", stringify!(vfio_irq_info))
);
assert_eq!(
::std::mem::align_of::<vfio_irq_info>(),
4usize,
concat!("Alignment of ", stringify!(vfio_irq_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_irq_info>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_irq_info),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_irq_info>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_irq_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_irq_info>())).index as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_irq_info),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_irq_info>())).count as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_irq_info),
"::",
stringify!(count)
)
);
}
#[doc = " VFIO_DEVICE_SET_IRQS - _IOW(VFIO_TYPE, VFIO_BASE + 10, struct vfio_irq_set)"]
#[doc = ""]
#[doc = " Set signaling, masking, and unmasking of interrupts. Caller provides"]
#[doc = " struct vfio_irq_set with all fields set. 'start' and 'count' indicate"]
#[doc = " the range of subindexes being specified."]
#[doc = ""]
#[doc = " The DATA flags specify the type of data provided. If DATA_NONE, the"]
#[doc = " operation performs the specified action immediately on the specified"]
#[doc = " interrupt(s). For example, to unmask AUTOMASKED interrupt [0,0]:"]
#[doc = " flags = (DATA_NONE|ACTION_UNMASK), index = 0, start = 0, count = 1."]
#[doc = ""]
#[doc = " DATA_BOOL allows sparse support for the same on arrays of interrupts."]
#[doc = " For example, to mask interrupts [0,1] and [0,3] (but not [0,2]):"]
#[doc = " flags = (DATA_BOOL|ACTION_MASK), index = 0, start = 1, count = 3,"]
#[doc = " data = {1,0,1}"]
#[doc = ""]
#[doc = " DATA_EVENTFD binds the specified ACTION to the provided __s32 eventfd."]
#[doc = " A value of -1 can be used to either de-assign interrupts if already"]
#[doc = " assigned or skip un-assigned interrupts. For example, to set an eventfd"]
#[doc = " to be trigger for interrupts [0,0] and [0,2]:"]
#[doc = " flags = (DATA_EVENTFD|ACTION_TRIGGER), index = 0, start = 0, count = 3,"]
#[doc = " data = {fd1, -1, fd2}"]
#[doc = " If index [0,1] is previously set, two count = 1 ioctls calls would be"]
#[doc = " required to set [0,0] and [0,2] without changing [0,1]."]
#[doc = ""]
#[doc = " Once a signaling mechanism is set, DATA_BOOL or DATA_NONE can be used"]
#[doc = " with ACTION_TRIGGER to perform kernel level interrupt loopback testing"]
#[doc = " from userspace (ie. simulate hardware triggering)."]
#[doc = ""]
#[doc = " Setting of an event triggering mechanism to userspace for ACTION_TRIGGER"]
#[doc = " enables the interrupt index for the device. Individual subindex interrupts"]
#[doc = " can be disabled using the -1 value for DATA_EVENTFD or the index can be"]
#[doc = " disabled as a whole with: flags = (DATA_NONE|ACTION_TRIGGER), count = 0."]
#[doc = ""]
#[doc = " Note that ACTION_[UN]MASK specify user->kernel signaling (irqfds) while"]
#[doc = " ACTION_TRIGGER specifies kernel->user signaling."]
#[repr(C)]
#[derive(Debug, Default)]
pub struct vfio_irq_set {
pub argsz: __u32,
pub flags: __u32,
pub index: __u32,
pub start: __u32,
pub count: __u32,
pub data: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_vfio_irq_set() {
assert_eq!(
::std::mem::size_of::<vfio_irq_set>(),
20usize,
concat!("Size of: ", stringify!(vfio_irq_set))
);
assert_eq!(
::std::mem::align_of::<vfio_irq_set>(),
4usize,
concat!("Alignment of ", stringify!(vfio_irq_set))
);
}
pub const VFIO_PCI_BAR0_REGION_INDEX: _bindgen_ty_1 = 0;
pub const VFIO_PCI_BAR1_REGION_INDEX: _bindgen_ty_1 = 1;
pub const VFIO_PCI_BAR2_REGION_INDEX: _bindgen_ty_1 = 2;
pub const VFIO_PCI_BAR3_REGION_INDEX: _bindgen_ty_1 = 3;
pub const VFIO_PCI_BAR4_REGION_INDEX: _bindgen_ty_1 = 4;
pub const VFIO_PCI_BAR5_REGION_INDEX: _bindgen_ty_1 = 5;
pub const VFIO_PCI_ROM_REGION_INDEX: _bindgen_ty_1 = 6;
pub const VFIO_PCI_CONFIG_REGION_INDEX: _bindgen_ty_1 = 7;
pub const VFIO_PCI_VGA_REGION_INDEX: _bindgen_ty_1 = 8;
pub const VFIO_PCI_NUM_REGIONS: _bindgen_ty_1 = 9;
pub type _bindgen_ty_1 = u32;
pub const VFIO_PCI_INTX_IRQ_INDEX: _bindgen_ty_2 = 0;
pub const VFIO_PCI_MSI_IRQ_INDEX: _bindgen_ty_2 = 1;
pub const VFIO_PCI_MSIX_IRQ_INDEX: _bindgen_ty_2 = 2;
pub const VFIO_PCI_ERR_IRQ_INDEX: _bindgen_ty_2 = 3;
pub const VFIO_PCI_REQ_IRQ_INDEX: _bindgen_ty_2 = 4;
pub const VFIO_PCI_NUM_IRQS: _bindgen_ty_2 = 5;
pub type _bindgen_ty_2 = u32;
pub const VFIO_CCW_CONFIG_REGION_INDEX: _bindgen_ty_3 = 0;
pub const VFIO_CCW_NUM_REGIONS: _bindgen_ty_3 = 1;
pub type _bindgen_ty_3 = u32;
pub const VFIO_CCW_IO_IRQ_INDEX: _bindgen_ty_4 = 0;
pub const VFIO_CCW_NUM_IRQS: _bindgen_ty_4 = 1;
pub type _bindgen_ty_4 = u32;
#[doc = " VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IORW(VFIO_TYPE, VFIO_BASE + 12,"]
#[doc = "\t\t\t\t\t struct vfio_pci_hot_reset_info)"]
#[doc = ""]
#[doc = " Return: 0 on success, -errno on failure:"]
#[doc = "\t-enospc = insufficient buffer, -enodev = unsupported for device."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_pci_dependent_device {
pub group_id: __u32,
pub segment: __u16,
pub bus: __u8,
pub devfn: __u8,
}
#[test]
fn bindgen_test_layout_vfio_pci_dependent_device() {
assert_eq!(
::std::mem::size_of::<vfio_pci_dependent_device>(),
8usize,
concat!("Size of: ", stringify!(vfio_pci_dependent_device))
);
assert_eq!(
::std::mem::align_of::<vfio_pci_dependent_device>(),
4usize,
concat!("Alignment of ", stringify!(vfio_pci_dependent_device))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_pci_dependent_device>())).group_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_pci_dependent_device),
"::",
stringify!(group_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_pci_dependent_device>())).segment as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_pci_dependent_device),
"::",
stringify!(segment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_pci_dependent_device>())).bus as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(vfio_pci_dependent_device),
"::",
stringify!(bus)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_pci_dependent_device>())).devfn as *const _ as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(vfio_pci_dependent_device),
"::",
stringify!(devfn)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct vfio_pci_hot_reset_info {
pub argsz: __u32,
pub flags: __u32,
pub count: __u32,
pub devices: __IncompleteArrayField<vfio_pci_dependent_device>,
}
#[test]
fn bindgen_test_layout_vfio_pci_hot_reset_info() {
assert_eq!(
::std::mem::size_of::<vfio_pci_hot_reset_info>(),
12usize,
concat!("Size of: ", stringify!(vfio_pci_hot_reset_info))
);
assert_eq!(
::std::mem::align_of::<vfio_pci_hot_reset_info>(),
4usize,
concat!("Alignment of ", stringify!(vfio_pci_hot_reset_info))
);
}
#[doc = " VFIO_DEVICE_PCI_HOT_RESET - _IOW(VFIO_TYPE, VFIO_BASE + 13,"]
#[doc = "\t\t\t\t struct vfio_pci_hot_reset)"]
#[doc = ""]
#[doc = " Return: 0 on success, -errno on failure."]
#[repr(C)]
#[derive(Debug, Default)]
pub struct vfio_pci_hot_reset {
pub argsz: __u32,
pub flags: __u32,
pub count: __u32,
pub group_fds: __IncompleteArrayField<__s32>,
}
#[test]
fn bindgen_test_layout_vfio_pci_hot_reset() {
assert_eq!(
::std::mem::size_of::<vfio_pci_hot_reset>(),
12usize,
concat!("Size of: ", stringify!(vfio_pci_hot_reset))
);
assert_eq!(
::std::mem::align_of::<vfio_pci_hot_reset>(),
4usize,
concat!("Alignment of ", stringify!(vfio_pci_hot_reset))
);
}
#[doc = " VFIO_DEVICE_QUERY_GFX_PLANE - _IOW(VFIO_TYPE, VFIO_BASE + 14,"]
#[doc = " struct vfio_device_query_gfx_plane)"]
#[doc = ""]
#[doc = " Set the drm_plane_type and flags, then retrieve the gfx plane info."]
#[doc = ""]
#[doc = " flags supported:"]
#[doc = " - VFIO_GFX_PLANE_TYPE_PROBE and VFIO_GFX_PLANE_TYPE_DMABUF are set"]
#[doc = " to ask if the mdev supports dma-buf. 0 on support, -EINVAL on no"]
#[doc = " support for dma-buf."]
#[doc = " - VFIO_GFX_PLANE_TYPE_PROBE and VFIO_GFX_PLANE_TYPE_REGION are set"]
#[doc = " to ask if the mdev supports region. 0 on support, -EINVAL on no"]
#[doc = " support for region."]
#[doc = " - VFIO_GFX_PLANE_TYPE_DMABUF or VFIO_GFX_PLANE_TYPE_REGION is set"]
#[doc = " with each call to query the plane info."]
#[doc = " - Others are invalid and return -EINVAL."]
#[doc = ""]
#[doc = " Note:"]
#[doc = " 1. Plane could be disabled by guest. In that case, success will be"]
#[doc = " returned with zero-initialized drm_format, size, width and height"]
#[doc = " fields."]
#[doc = " 2. x_hot/y_hot is set to 0xFFFFFFFF if no hotspot information available"]
#[doc = ""]
#[doc = " Return: 0 on success, -errno on other failure."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct vfio_device_gfx_plane_info {
pub argsz: __u32,
pub flags: __u32,
pub drm_plane_type: __u32,
pub drm_format: __u32,
pub drm_format_mod: __u64,
pub width: __u32,
pub height: __u32,
pub stride: __u32,
pub size: __u32,
pub x_pos: __u32,
pub y_pos: __u32,
pub x_hot: __u32,
pub y_hot: __u32,
pub __bindgen_anon_1: vfio_device_gfx_plane_info__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vfio_device_gfx_plane_info__bindgen_ty_1 {
pub region_index: __u32,
pub dmabuf_id: __u32,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_vfio_device_gfx_plane_info__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<vfio_device_gfx_plane_info__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(vfio_device_gfx_plane_info__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<vfio_device_gfx_plane_info__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(vfio_device_gfx_plane_info__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info__bindgen_ty_1>())).region_index
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info__bindgen_ty_1),
"::",
stringify!(region_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info__bindgen_ty_1>())).dmabuf_id
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info__bindgen_ty_1),
"::",
stringify!(dmabuf_id)
)
);
}
impl Default for vfio_device_gfx_plane_info__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_vfio_device_gfx_plane_info() {
assert_eq!(
::std::mem::size_of::<vfio_device_gfx_plane_info>(),
64usize,
concat!("Size of: ", stringify!(vfio_device_gfx_plane_info))
);
assert_eq!(
::std::mem::align_of::<vfio_device_gfx_plane_info>(),
8usize,
concat!("Alignment of ", stringify!(vfio_device_gfx_plane_info))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).argsz as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).flags as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).drm_plane_type as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(drm_plane_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).drm_format as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(drm_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).drm_format_mod as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(drm_format_mod)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).width as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).height as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).stride as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).size as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).x_pos as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(x_pos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).y_pos as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(y_pos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).x_hot as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(x_hot)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_device_gfx_plane_info>())).y_hot as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_gfx_plane_info),
"::",
stringify!(y_hot)
)
);
}
impl Default for vfio_device_gfx_plane_info {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " VFIO_DEVICE_IOEVENTFD - _IOW(VFIO_TYPE, VFIO_BASE + 16,"]
#[doc = " struct vfio_device_ioeventfd)"]
#[doc = ""]
#[doc = " Perform a write to the device at the specified device fd offset, with"]
#[doc = " the specified data and width when the provided eventfd is triggered."]
#[doc = " vfio bus drivers may not support this for all regions, for all widths,"]
#[doc = " or at all. vfio-pci currently only enables support for BAR regions,"]
#[doc = " excluding the MSI-X vector table."]
#[doc = ""]
#[doc = " Return: 0 on success, -errno on failure."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_device_ioeventfd {
pub argsz: __u32,
pub flags: __u32,
pub offset: __u64,
pub data: __u64,
pub fd: __s32,
}
#[test]
fn bindgen_test_layout_vfio_device_ioeventfd() {
assert_eq!(
::std::mem::size_of::<vfio_device_ioeventfd>(),
32usize,
concat!("Size of: ", stringify!(vfio_device_ioeventfd))
);
assert_eq!(
::std::mem::align_of::<vfio_device_ioeventfd>(),
8usize,
concat!("Alignment of ", stringify!(vfio_device_ioeventfd))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_ioeventfd>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_ioeventfd),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_ioeventfd>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_ioeventfd),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_ioeventfd>())).offset as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_ioeventfd),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_ioeventfd>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_ioeventfd),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_device_ioeventfd>())).fd as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(vfio_device_ioeventfd),
"::",
stringify!(fd)
)
);
}
#[doc = " VFIO_IOMMU_GET_INFO - _IOR(VFIO_TYPE, VFIO_BASE + 12, struct vfio_iommu_info)"]
#[doc = ""]
#[doc = " Retrieve information about the IOMMU object. Fills in provided"]
#[doc = " struct vfio_iommu_info. Caller sets argsz."]
#[doc = ""]
#[doc = " XXX Should we do these by CHECK_EXTENSION too?"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_type1_info {
pub argsz: __u32,
pub flags: __u32,
pub iova_pgsizes: __u64,
}
#[test]
fn bindgen_test_layout_vfio_iommu_type1_info() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_type1_info>(),
16usize,
concat!("Size of: ", stringify!(vfio_iommu_type1_info))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_type1_info>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_type1_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_info>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_info),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_info>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_type1_info>())).iova_pgsizes as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_info),
"::",
stringify!(iova_pgsizes)
)
);
}
#[doc = " VFIO_IOMMU_MAP_DMA - _IOW(VFIO_TYPE, VFIO_BASE + 13, struct vfio_dma_map)"]
#[doc = ""]
#[doc = " Map process virtual addresses to IO virtual addresses using the"]
#[doc = " provided struct vfio_dma_map. Caller sets argsz. READ &/ WRITE required."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_type1_dma_map {
pub argsz: __u32,
pub flags: __u32,
pub vaddr: __u64,
pub iova: __u64,
pub size: __u64,
}
#[test]
fn bindgen_test_layout_vfio_iommu_type1_dma_map() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_type1_dma_map>(),
32usize,
concat!("Size of: ", stringify!(vfio_iommu_type1_dma_map))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_type1_dma_map>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_type1_dma_map))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_map>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_map),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_map>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_map),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_map>())).vaddr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_map),
"::",
stringify!(vaddr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_map>())).iova as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_map),
"::",
stringify!(iova)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_map>())).size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_map),
"::",
stringify!(size)
)
);
}
#[doc = " VFIO_IOMMU_UNMAP_DMA - _IOWR(VFIO_TYPE, VFIO_BASE + 14,"]
#[doc = "\t\t\t\t\t\t\tstruct vfio_dma_unmap)"]
#[doc = ""]
#[doc = " Unmap IO virtual addresses using the provided struct vfio_dma_unmap."]
#[doc = " Caller sets argsz. The actual unmapped size is returned in the size"]
#[doc = " field. No guarantee is made to the user that arbitrary unmaps of iova"]
#[doc = " or size different from those used in the original mapping call will"]
#[doc = " succeed."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_type1_dma_unmap {
pub argsz: __u32,
pub flags: __u32,
pub iova: __u64,
pub size: __u64,
}
#[test]
fn bindgen_test_layout_vfio_iommu_type1_dma_unmap() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_type1_dma_unmap>(),
24usize,
concat!("Size of: ", stringify!(vfio_iommu_type1_dma_unmap))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_type1_dma_unmap>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_type1_dma_unmap))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_type1_dma_unmap>())).argsz as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_unmap),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_type1_dma_unmap>())).flags as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_unmap),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_unmap>())).iova as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_unmap),
"::",
stringify!(iova)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_type1_dma_unmap>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_type1_dma_unmap),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_spapr_tce_ddw_info {
pub pgsizes: __u64,
pub max_dynamic_windows_supported: __u32,
pub levels: __u32,
}
#[test]
fn bindgen_test_layout_vfio_iommu_spapr_tce_ddw_info() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_spapr_tce_ddw_info>(),
16usize,
concat!("Size of: ", stringify!(vfio_iommu_spapr_tce_ddw_info))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_spapr_tce_ddw_info>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_spapr_tce_ddw_info))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_ddw_info>())).pgsizes as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_ddw_info),
"::",
stringify!(pgsizes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_ddw_info>())).max_dynamic_windows_supported
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_ddw_info),
"::",
stringify!(max_dynamic_windows_supported)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_ddw_info>())).levels as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_ddw_info),
"::",
stringify!(levels)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_spapr_tce_info {
pub argsz: __u32,
pub flags: __u32,
pub dma32_window_start: __u32,
pub dma32_window_size: __u32,
pub ddw: vfio_iommu_spapr_tce_ddw_info,
}
#[test]
fn bindgen_test_layout_vfio_iommu_spapr_tce_info() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_spapr_tce_info>(),
32usize,
concat!("Size of: ", stringify!(vfio_iommu_spapr_tce_info))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_spapr_tce_info>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_spapr_tce_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_spapr_tce_info>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_info),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_spapr_tce_info>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_info>())).dma32_window_start as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_info),
"::",
stringify!(dma32_window_start)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_info>())).dma32_window_size as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_info),
"::",
stringify!(dma32_window_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_iommu_spapr_tce_info>())).ddw as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_info),
"::",
stringify!(ddw)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_eeh_pe_err {
pub type_: __u32,
pub func: __u32,
pub addr: __u64,
pub mask: __u64,
}
#[test]
fn bindgen_test_layout_vfio_eeh_pe_err() {
assert_eq!(
::std::mem::size_of::<vfio_eeh_pe_err>(),
24usize,
concat!("Size of: ", stringify!(vfio_eeh_pe_err))
);
assert_eq!(
::std::mem::align_of::<vfio_eeh_pe_err>(),
8usize,
concat!("Alignment of ", stringify!(vfio_eeh_pe_err))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_err>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_err),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_err>())).func as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_err),
"::",
stringify!(func)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_err>())).addr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_err),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_err>())).mask as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_err),
"::",
stringify!(mask)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct vfio_eeh_pe_op {
pub argsz: __u32,
pub flags: __u32,
pub op: __u32,
pub __bindgen_anon_1: vfio_eeh_pe_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union vfio_eeh_pe_op__bindgen_ty_1 {
pub err: vfio_eeh_pe_err,
_bindgen_union_align: [u64; 3usize],
}
#[test]
fn bindgen_test_layout_vfio_eeh_pe_op__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<vfio_eeh_pe_op__bindgen_ty_1>(),
24usize,
concat!("Size of: ", stringify!(vfio_eeh_pe_op__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<vfio_eeh_pe_op__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(vfio_eeh_pe_op__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_eeh_pe_op__bindgen_ty_1>())).err as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_op__bindgen_ty_1),
"::",
stringify!(err)
)
);
}
impl Default for vfio_eeh_pe_op__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_vfio_eeh_pe_op() {
assert_eq!(
::std::mem::size_of::<vfio_eeh_pe_op>(),
40usize,
concat!("Size of: ", stringify!(vfio_eeh_pe_op))
);
assert_eq!(
::std::mem::align_of::<vfio_eeh_pe_op>(),
8usize,
concat!("Alignment of ", stringify!(vfio_eeh_pe_op))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_op>())).argsz as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_op),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_op>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_op),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<vfio_eeh_pe_op>())).op as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_eeh_pe_op),
"::",
stringify!(op)
)
);
}
impl Default for vfio_eeh_pe_op {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " VFIO_IOMMU_SPAPR_REGISTER_MEMORY - _IOW(VFIO_TYPE, VFIO_BASE + 17, struct vfio_iommu_spapr_register_memory)"]
#[doc = ""]
#[doc = " Registers user space memory where DMA is allowed. It pins"]
#[doc = " user pages and does the locked memory accounting so"]
#[doc = " subsequent VFIO_IOMMU_MAP_DMA/VFIO_IOMMU_UNMAP_DMA calls"]
#[doc = " get faster."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_spapr_register_memory {
pub argsz: __u32,
pub flags: __u32,
pub vaddr: __u64,
pub size: __u64,
}
#[test]
fn bindgen_test_layout_vfio_iommu_spapr_register_memory() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_spapr_register_memory>(),
24usize,
concat!("Size of: ", stringify!(vfio_iommu_spapr_register_memory))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_spapr_register_memory>(),
8usize,
concat!(
"Alignment of ",
stringify!(vfio_iommu_spapr_register_memory)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_register_memory>())).argsz as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_register_memory),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_register_memory>())).flags as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_register_memory),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_register_memory>())).vaddr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_register_memory),
"::",
stringify!(vaddr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_register_memory>())).size as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_register_memory),
"::",
stringify!(size)
)
);
}
#[doc = " VFIO_IOMMU_SPAPR_TCE_CREATE - _IOWR(VFIO_TYPE, VFIO_BASE + 19, struct vfio_iommu_spapr_tce_create)"]
#[doc = ""]
#[doc = " Creates an additional TCE table and programs it (sets a new DMA window)"]
#[doc = " to every IOMMU group in the container. It receives page shift, window"]
#[doc = " size and number of levels in the TCE table being created."]
#[doc = ""]
#[doc = " It allocates and returns an offset on a PCI bus of the new DMA window."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_spapr_tce_create {
pub argsz: __u32,
pub flags: __u32,
pub page_shift: __u32,
pub __resv1: __u32,
pub window_size: __u64,
pub levels: __u32,
pub __resv2: __u32,
pub start_addr: __u64,
}
#[test]
fn bindgen_test_layout_vfio_iommu_spapr_tce_create() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_spapr_tce_create>(),
40usize,
concat!("Size of: ", stringify!(vfio_iommu_spapr_tce_create))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_spapr_tce_create>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_spapr_tce_create))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).argsz as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).flags as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).page_shift as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(page_shift)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).__resv1 as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(__resv1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).window_size as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(window_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).levels as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(levels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).__resv2 as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(__resv2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_create>())).start_addr as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_create),
"::",
stringify!(start_addr)
)
);
}
#[doc = " VFIO_IOMMU_SPAPR_TCE_REMOVE - _IOW(VFIO_TYPE, VFIO_BASE + 20, struct vfio_iommu_spapr_tce_remove)"]
#[doc = ""]
#[doc = " Unprograms a TCE table from all groups in the container and destroys it."]
#[doc = " It receives a PCI bus offset as a window id."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct vfio_iommu_spapr_tce_remove {
pub argsz: __u32,
pub flags: __u32,
pub start_addr: __u64,
}
#[test]
fn bindgen_test_layout_vfio_iommu_spapr_tce_remove() {
assert_eq!(
::std::mem::size_of::<vfio_iommu_spapr_tce_remove>(),
16usize,
concat!("Size of: ", stringify!(vfio_iommu_spapr_tce_remove))
);
assert_eq!(
::std::mem::align_of::<vfio_iommu_spapr_tce_remove>(),
8usize,
concat!("Alignment of ", stringify!(vfio_iommu_spapr_tce_remove))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_remove>())).argsz as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_remove),
"::",
stringify!(argsz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_remove>())).flags as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_remove),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<vfio_iommu_spapr_tce_remove>())).start_addr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(vfio_iommu_spapr_tce_remove),
"::",
stringify!(start_addr)
)
);
}