pub type __time_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<timespec>(),
8usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
4usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __atomic_wide_counter {
pub __value64: ::std::os::raw::c_ulonglong,
pub __value32: __atomic_wide_counter__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __atomic_wide_counter__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__atomic_wide_counter__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___atomic_wide_counter() {
const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__atomic_wide_counter>(),
8usize,
concat!("Size of: ", stringify!(__atomic_wide_counter))
);
assert_eq!(
::std::mem::align_of::<__atomic_wide_counter>(),
4usize,
concat!("Alignment of ", stringify!(__atomic_wide_counter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter),
"::",
stringify!(__value64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__atomic_wide_counter),
"::",
stringify!(__value32)
)
);
}
impl Default for __atomic_wide_counter {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_slist {
pub __next: *mut __pthread_internal_slist,
}
#[test]
fn bindgen_test_layout___pthread_internal_slist() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_internal_slist>(),
4usize,
concat!("Size of: ", stringify!(__pthread_internal_slist))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_slist>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_internal_slist))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_slist),
"::",
stringify!(__next)
)
);
}
impl Default for __pthread_internal_slist {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type __pthread_slist_t = __pthread_internal_slist;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __kind: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __bindgen_anon_1: __pthread_mutex_s__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_mutex_s__bindgen_ty_1 {
pub __elision_data: __pthread_mutex_s__bindgen_ty_1__bindgen_ty_1,
pub __list: __pthread_slist_t,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __pthread_mutex_s__bindgen_ty_1__bindgen_ty_1 {
pub __espins: ::std::os::raw::c_short,
pub __eelision: ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Alignment of ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__espins) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__espins)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__eelision) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__eelision)
)
);
}
#[test]
fn bindgen_test_layout___pthread_mutex_s__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(__pthread_mutex_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__elision_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1),
"::",
stringify!(__elision_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s__bindgen_ty_1),
"::",
stringify!(__list)
)
);
}
impl Default for __pthread_mutex_s__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
24usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
}
impl Default for __pthread_mutex_s {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __wseq: __atomic_wide_counter,
pub __g1_start: __atomic_wide_counter,
pub __g_refs: [::std::os::raw::c_uint; 2usize],
pub __g_size: [::std::os::raw::c_uint; 2usize],
pub __g1_orig_size: ::std::os::raw::c_uint,
pub __wrefs: ::std::os::raw::c_uint,
pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s>(),
4usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
impl Default for __pthread_cond_s {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 24usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
24usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_mutex_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [::std::os::raw::c_char; 48usize],
pub __align: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<pthread_cond_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_cond_t {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type __u16 = ::std::os::raw::c_ushort;
pub type __u32 = ::std::os::raw::c_uint;
pub type __u64 = ::std::os::raw::c_ulonglong;
pub type __be16 = __u16;
pub type __be32 = __u32;
pub type __be64 = __u64;
pub const IB_UVERBS_FLOW_ACTION_ESP_KEYMAT_AES_GCM: ib_uverbs_flow_action_esp_keymat = 0;
pub type ib_uverbs_flow_action_esp_keymat = ::std::os::raw::c_uint;
pub const IB_UVERBS_FLOW_ACTION_ESP_REPLAY_NONE: ib_uverbs_flow_action_esp_replay = 0;
pub const IB_UVERBS_FLOW_ACTION_ESP_REPLAY_BMP: ib_uverbs_flow_action_esp_replay = 1;
pub type ib_uverbs_flow_action_esp_replay = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ib_uverbs_flow_action_esp_encap {
pub __bindgen_anon_1: ib_uverbs_flow_action_esp_encap__bindgen_ty_1,
pub __bindgen_anon_2: ib_uverbs_flow_action_esp_encap__bindgen_ty_2,
pub len: __u16,
pub type_: __u16,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union ib_uverbs_flow_action_esp_encap__bindgen_ty_1 {
pub __bindgen_anon_1: ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1,
pub val_ptr_data_u64: __u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1 {
pub val_ptr: *mut ::std::os::raw::c_void,
pub val_ptr_reserved: __u32,
}
#[test]
fn bindgen_test_layout_ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<
ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1,
> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val_ptr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(val_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val_ptr_reserved) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(val_ptr_reserved)
)
);
}
impl Default for ib_uverbs_flow_action_esp_encap__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ib_uverbs_flow_action_esp_encap__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ib_uverbs_flow_action_esp_encap__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val_ptr_data_u64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_1),
"::",
stringify!(val_ptr_data_u64)
)
);
}
impl Default for ib_uverbs_flow_action_esp_encap__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub union ib_uverbs_flow_action_esp_encap__bindgen_ty_2 {
pub __bindgen_anon_1: ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1,
pub next_ptr_data_u64: __u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1 {
pub next_ptr: *mut ib_uverbs_flow_action_esp_encap,
pub next_ptr_reserved: __u32,
}
#[test]
fn bindgen_test_layout_ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<
ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1,
> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_ptr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(next_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_ptr_reserved) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(next_ptr_reserved)
)
);
}
impl Default for ib_uverbs_flow_action_esp_encap__bindgen_ty_2__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ib_uverbs_flow_action_esp_encap__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ib_uverbs_flow_action_esp_encap__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_2>(),
8usize,
concat!(
"Size of: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ib_uverbs_flow_action_esp_encap__bindgen_ty_2>(),
8usize,
concat!(
"Alignment of ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_ptr_data_u64) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap__bindgen_ty_2),
"::",
stringify!(next_ptr_data_u64)
)
);
}
impl Default for ib_uverbs_flow_action_esp_encap__bindgen_ty_2 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ib_uverbs_flow_action_esp_encap() {
const UNINIT: ::std::mem::MaybeUninit<ib_uverbs_flow_action_esp_encap> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ib_uverbs_flow_action_esp_encap>(),
24usize,
concat!("Size of: ", stringify!(ib_uverbs_flow_action_esp_encap))
);
assert_eq!(
::std::mem::align_of::<ib_uverbs_flow_action_esp_encap>(),
8usize,
concat!("Alignment of ", stringify!(ib_uverbs_flow_action_esp_encap))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp_encap),
"::",
stringify!(type_)
)
);
}
impl Default for ib_uverbs_flow_action_esp_encap {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct ib_uverbs_flow_action_esp {
pub spi: __u32,
pub seq: __u32,
pub tfc_pad: __u32,
pub flags: __u32,
pub hard_limit_pkts: __u64,
}
#[test]
fn bindgen_test_layout_ib_uverbs_flow_action_esp() {
const UNINIT: ::std::mem::MaybeUninit<ib_uverbs_flow_action_esp> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ib_uverbs_flow_action_esp>(),
24usize,
concat!("Size of: ", stringify!(ib_uverbs_flow_action_esp))
);
assert_eq!(
::std::mem::align_of::<ib_uverbs_flow_action_esp>(),
8usize,
concat!("Alignment of ", stringify!(ib_uverbs_flow_action_esp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).spi) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp),
"::",
stringify!(spi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).seq) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tfc_pad) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp),
"::",
stringify!(tfc_pad)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hard_limit_pkts) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ib_uverbs_flow_action_esp),
"::",
stringify!(hard_limit_pkts)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_gid {
pub raw: [u8; 16usize],
pub global: ibv_gid__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_gid__bindgen_ty_1 {
pub subnet_prefix: __be64,
pub interface_id: __be64,
}
#[test]
fn bindgen_test_layout_ibv_gid__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_gid__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_gid__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(ibv_gid__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_gid__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_gid__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subnet_prefix) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid__bindgen_ty_1),
"::",
stringify!(subnet_prefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).interface_id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid__bindgen_ty_1),
"::",
stringify!(interface_id)
)
);
}
#[test]
fn bindgen_test_layout_ibv_gid() {
const UNINIT: ::std::mem::MaybeUninit<ibv_gid> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_gid>(),
16usize,
concat!("Size of: ", stringify!(ibv_gid))
);
assert_eq!(
::std::mem::align_of::<ibv_gid>(),
4usize,
concat!("Alignment of ", stringify!(ibv_gid))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid),
"::",
stringify!(raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).global) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid),
"::",
stringify!(global)
)
);
}
impl Default for ibv_gid {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_GID_TYPE_IB: ibv_gid_type = 0;
pub const IBV_GID_TYPE_ROCE_V1: ibv_gid_type = 1;
pub const IBV_GID_TYPE_ROCE_V2: ibv_gid_type = 2;
pub type ibv_gid_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_gid_entry {
pub gid: ibv_gid,
pub gid_index: u32,
pub port_num: u32,
pub gid_type: u32,
pub ndev_ifindex: u32,
}
#[test]
fn bindgen_test_layout_ibv_gid_entry() {
const UNINIT: ::std::mem::MaybeUninit<ibv_gid_entry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_gid_entry>(),
32usize,
concat!("Size of: ", stringify!(ibv_gid_entry))
);
assert_eq!(
::std::mem::align_of::<ibv_gid_entry>(),
4usize,
concat!("Alignment of ", stringify!(ibv_gid_entry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gid) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid_entry),
"::",
stringify!(gid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gid_index) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid_entry),
"::",
stringify!(gid_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port_num) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid_entry),
"::",
stringify!(port_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gid_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid_entry),
"::",
stringify!(gid_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ndev_ifindex) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_gid_entry),
"::",
stringify!(ndev_ifindex)
)
);
}
impl Default for ibv_gid_entry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_NODE_UNKNOWN: ibv_node_type = -1;
pub const IBV_NODE_CA: ibv_node_type = 1;
pub const IBV_NODE_SWITCH: ibv_node_type = 2;
pub const IBV_NODE_ROUTER: ibv_node_type = 3;
pub const IBV_NODE_RNIC: ibv_node_type = 4;
pub const IBV_NODE_USNIC: ibv_node_type = 5;
pub const IBV_NODE_USNIC_UDP: ibv_node_type = 6;
pub const IBV_NODE_UNSPECIFIED: ibv_node_type = 7;
pub type ibv_node_type = ::std::os::raw::c_int;
pub const IBV_TRANSPORT_UNKNOWN: ibv_transport_type = -1;
pub const IBV_TRANSPORT_IB: ibv_transport_type = 0;
pub const IBV_TRANSPORT_IWARP: ibv_transport_type = 1;
pub const IBV_TRANSPORT_USNIC: ibv_transport_type = 2;
pub const IBV_TRANSPORT_USNIC_UDP: ibv_transport_type = 3;
pub const IBV_TRANSPORT_UNSPECIFIED: ibv_transport_type = 4;
pub type ibv_transport_type = ::std::os::raw::c_int;
pub const IBV_DEVICE_RESIZE_MAX_WR: ibv_device_cap_flags = 1;
pub const IBV_DEVICE_BAD_PKEY_CNTR: ibv_device_cap_flags = 2;
pub const IBV_DEVICE_BAD_QKEY_CNTR: ibv_device_cap_flags = 4;
pub const IBV_DEVICE_RAW_MULTI: ibv_device_cap_flags = 8;
pub const IBV_DEVICE_AUTO_PATH_MIG: ibv_device_cap_flags = 16;
pub const IBV_DEVICE_CHANGE_PHY_PORT: ibv_device_cap_flags = 32;
pub const IBV_DEVICE_UD_AV_PORT_ENFORCE: ibv_device_cap_flags = 64;
pub const IBV_DEVICE_CURR_QP_STATE_MOD: ibv_device_cap_flags = 128;
pub const IBV_DEVICE_SHUTDOWN_PORT: ibv_device_cap_flags = 256;
pub const IBV_DEVICE_INIT_TYPE: ibv_device_cap_flags = 512;
pub const IBV_DEVICE_PORT_ACTIVE_EVENT: ibv_device_cap_flags = 1024;
pub const IBV_DEVICE_SYS_IMAGE_GUID: ibv_device_cap_flags = 2048;
pub const IBV_DEVICE_RC_RNR_NAK_GEN: ibv_device_cap_flags = 4096;
pub const IBV_DEVICE_SRQ_RESIZE: ibv_device_cap_flags = 8192;
pub const IBV_DEVICE_N_NOTIFY_CQ: ibv_device_cap_flags = 16384;
pub const IBV_DEVICE_MEM_WINDOW: ibv_device_cap_flags = 131072;
pub const IBV_DEVICE_UD_IP_CSUM: ibv_device_cap_flags = 262144;
pub const IBV_DEVICE_XRC: ibv_device_cap_flags = 1048576;
pub const IBV_DEVICE_MEM_MGT_EXTENSIONS: ibv_device_cap_flags = 2097152;
pub const IBV_DEVICE_MEM_WINDOW_TYPE_2A: ibv_device_cap_flags = 8388608;
pub const IBV_DEVICE_MEM_WINDOW_TYPE_2B: ibv_device_cap_flags = 16777216;
pub const IBV_DEVICE_RC_IP_CSUM: ibv_device_cap_flags = 33554432;
pub const IBV_DEVICE_RAW_IP_CSUM: ibv_device_cap_flags = 67108864;
pub const IBV_DEVICE_MANAGED_FLOW_STEERING: ibv_device_cap_flags = 536870912;
pub type ibv_device_cap_flags = ::std::os::raw::c_uint;
pub const IBV_ATOMIC_NONE: ibv_atomic_cap = 0;
pub const IBV_ATOMIC_HCA: ibv_atomic_cap = 1;
pub const IBV_ATOMIC_GLOB: ibv_atomic_cap = 2;
pub type ibv_atomic_cap = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_alloc_dm_attr {
pub length: usize,
pub log_align_req: u32,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_alloc_dm_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_alloc_dm_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_alloc_dm_attr>(),
12usize,
concat!("Size of: ", stringify!(ibv_alloc_dm_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_alloc_dm_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_alloc_dm_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_alloc_dm_attr),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).log_align_req) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_alloc_dm_attr),
"::",
stringify!(log_align_req)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_alloc_dm_attr),
"::",
stringify!(comp_mask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_dm {
pub context: *mut ibv_context,
pub memcpy_to_dm: ::std::option::Option<
unsafe extern "C" fn(
dm: *mut ibv_dm,
dm_offset: u64,
host_addr: *const ::std::os::raw::c_void,
length: usize,
) -> ::std::os::raw::c_int,
>,
pub memcpy_from_dm: ::std::option::Option<
unsafe extern "C" fn(
host_addr: *mut ::std::os::raw::c_void,
dm: *mut ibv_dm,
dm_offset: u64,
length: usize,
) -> ::std::os::raw::c_int,
>,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_dm() {
const UNINIT: ::std::mem::MaybeUninit<ibv_dm> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_dm>(),
16usize,
concat!("Size of: ", stringify!(ibv_dm))
);
assert_eq!(
::std::mem::align_of::<ibv_dm>(),
4usize,
concat!("Alignment of ", stringify!(ibv_dm))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_dm),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).memcpy_to_dm) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_dm),
"::",
stringify!(memcpy_to_dm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).memcpy_from_dm) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_dm),
"::",
stringify!(memcpy_from_dm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_dm),
"::",
stringify!(comp_mask)
)
);
}
impl Default for ibv_dm {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_device_attr {
pub fw_ver: [::std::os::raw::c_char; 64usize],
pub node_guid: __be64,
pub sys_image_guid: __be64,
pub max_mr_size: u64,
pub page_size_cap: u64,
pub vendor_id: u32,
pub vendor_part_id: u32,
pub hw_ver: u32,
pub max_qp: ::std::os::raw::c_int,
pub max_qp_wr: ::std::os::raw::c_int,
pub device_cap_flags: ::std::os::raw::c_uint,
pub max_sge: ::std::os::raw::c_int,
pub max_sge_rd: ::std::os::raw::c_int,
pub max_cq: ::std::os::raw::c_int,
pub max_cqe: ::std::os::raw::c_int,
pub max_mr: ::std::os::raw::c_int,
pub max_pd: ::std::os::raw::c_int,
pub max_qp_rd_atom: ::std::os::raw::c_int,
pub max_ee_rd_atom: ::std::os::raw::c_int,
pub max_res_rd_atom: ::std::os::raw::c_int,
pub max_qp_init_rd_atom: ::std::os::raw::c_int,
pub max_ee_init_rd_atom: ::std::os::raw::c_int,
pub atomic_cap: ibv_atomic_cap,
pub max_ee: ::std::os::raw::c_int,
pub max_rdd: ::std::os::raw::c_int,
pub max_mw: ::std::os::raw::c_int,
pub max_raw_ipv6_qp: ::std::os::raw::c_int,
pub max_raw_ethy_qp: ::std::os::raw::c_int,
pub max_mcast_grp: ::std::os::raw::c_int,
pub max_mcast_qp_attach: ::std::os::raw::c_int,
pub max_total_mcast_qp_attach: ::std::os::raw::c_int,
pub max_ah: ::std::os::raw::c_int,
pub max_fmr: ::std::os::raw::c_int,
pub max_map_per_fmr: ::std::os::raw::c_int,
pub max_srq: ::std::os::raw::c_int,
pub max_srq_wr: ::std::os::raw::c_int,
pub max_srq_sge: ::std::os::raw::c_int,
pub max_pkeys: u16,
pub local_ca_ack_delay: u8,
pub phys_port_cnt: u8,
}
#[test]
fn bindgen_test_layout_ibv_device_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_device_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_device_attr>(),
228usize,
concat!("Size of: ", stringify!(ibv_device_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_device_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_device_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fw_ver) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(fw_ver)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node_guid) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(node_guid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sys_image_guid) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(sys_image_guid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_mr_size) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_mr_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).page_size_cap) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(page_size_cap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vendor_id) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(vendor_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vendor_part_id) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(vendor_part_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hw_ver) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(hw_ver)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_qp) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_qp_wr) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_qp_wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device_cap_flags) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(device_cap_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_sge) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_sge_rd) as usize - ptr as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_sge_rd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_cq) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_cqe) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_cqe)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_mr) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_mr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_pd) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_qp_rd_atom) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_qp_rd_atom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_ee_rd_atom) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_ee_rd_atom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_res_rd_atom) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_res_rd_atom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_qp_init_rd_atom) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_qp_init_rd_atom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_ee_init_rd_atom) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_ee_init_rd_atom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).atomic_cap) as usize - ptr as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(atomic_cap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_ee) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_ee)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_rdd) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_rdd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_mw) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_raw_ipv6_qp) as usize - ptr as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_raw_ipv6_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_raw_ethy_qp) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_raw_ethy_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_mcast_grp) as usize - ptr as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_mcast_grp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_mcast_qp_attach) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_mcast_qp_attach)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_total_mcast_qp_attach) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_total_mcast_qp_attach)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_ah) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_ah)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_fmr) as usize - ptr as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_fmr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_map_per_fmr) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_map_per_fmr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_srq) as usize - ptr as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_srq_wr) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_srq_wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_srq_sge) as usize - ptr as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_srq_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_pkeys) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(max_pkeys)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).local_ca_ack_delay) as usize - ptr as usize },
226usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(local_ca_ack_delay)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).phys_port_cnt) as usize - ptr as usize },
227usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr),
"::",
stringify!(phys_port_cnt)
)
);
}
impl Default for ibv_device_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_query_device_ex_input {
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_query_device_ex_input() {
const UNINIT: ::std::mem::MaybeUninit<ibv_query_device_ex_input> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_query_device_ex_input>(),
4usize,
concat!("Size of: ", stringify!(ibv_query_device_ex_input))
);
assert_eq!(
::std::mem::align_of::<ibv_query_device_ex_input>(),
4usize,
concat!("Alignment of ", stringify!(ibv_query_device_ex_input))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_query_device_ex_input),
"::",
stringify!(comp_mask)
)
);
}
pub const IBV_ODP_SUPPORT_SEND: ibv_odp_transport_cap_bits = 1;
pub const IBV_ODP_SUPPORT_RECV: ibv_odp_transport_cap_bits = 2;
pub const IBV_ODP_SUPPORT_WRITE: ibv_odp_transport_cap_bits = 4;
pub const IBV_ODP_SUPPORT_READ: ibv_odp_transport_cap_bits = 8;
pub const IBV_ODP_SUPPORT_ATOMIC: ibv_odp_transport_cap_bits = 16;
pub const IBV_ODP_SUPPORT_SRQ_RECV: ibv_odp_transport_cap_bits = 32;
pub type ibv_odp_transport_cap_bits = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_odp_caps {
pub general_caps: u64,
pub per_transport_caps: ibv_odp_caps__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_odp_caps__bindgen_ty_1 {
pub rc_odp_caps: u32,
pub uc_odp_caps: u32,
pub ud_odp_caps: u32,
}
#[test]
fn bindgen_test_layout_ibv_odp_caps__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_odp_caps__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_odp_caps__bindgen_ty_1>(),
12usize,
concat!("Size of: ", stringify!(ibv_odp_caps__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_odp_caps__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_odp_caps__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rc_odp_caps) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_odp_caps__bindgen_ty_1),
"::",
stringify!(rc_odp_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).uc_odp_caps) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_odp_caps__bindgen_ty_1),
"::",
stringify!(uc_odp_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ud_odp_caps) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_odp_caps__bindgen_ty_1),
"::",
stringify!(ud_odp_caps)
)
);
}
#[test]
fn bindgen_test_layout_ibv_odp_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_odp_caps> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_odp_caps>(),
20usize,
concat!("Size of: ", stringify!(ibv_odp_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_odp_caps>(),
4usize,
concat!("Alignment of ", stringify!(ibv_odp_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).general_caps) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_odp_caps),
"::",
stringify!(general_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).per_transport_caps) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_odp_caps),
"::",
stringify!(per_transport_caps)
)
);
}
pub const IBV_ODP_SUPPORT: ibv_odp_general_caps = 1;
pub const IBV_ODP_SUPPORT_IMPLICIT: ibv_odp_general_caps = 2;
pub type ibv_odp_general_caps = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_tso_caps {
pub max_tso: u32,
pub supported_qpts: u32,
}
#[test]
fn bindgen_test_layout_ibv_tso_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_tso_caps> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_tso_caps>(),
8usize,
concat!("Size of: ", stringify!(ibv_tso_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_tso_caps>(),
4usize,
concat!("Alignment of ", stringify!(ibv_tso_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_tso) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_tso_caps),
"::",
stringify!(max_tso)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).supported_qpts) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_tso_caps),
"::",
stringify!(supported_qpts)
)
);
}
pub const IBV_RX_HASH_FUNC_TOEPLITZ: ibv_rx_hash_function_flags = 1;
pub type ibv_rx_hash_function_flags = ::std::os::raw::c_uint;
pub const IBV_RX_HASH_SRC_IPV4: ibv_rx_hash_fields = 1;
pub const IBV_RX_HASH_DST_IPV4: ibv_rx_hash_fields = 2;
pub const IBV_RX_HASH_SRC_IPV6: ibv_rx_hash_fields = 4;
pub const IBV_RX_HASH_DST_IPV6: ibv_rx_hash_fields = 8;
pub const IBV_RX_HASH_SRC_PORT_TCP: ibv_rx_hash_fields = 16;
pub const IBV_RX_HASH_DST_PORT_TCP: ibv_rx_hash_fields = 32;
pub const IBV_RX_HASH_SRC_PORT_UDP: ibv_rx_hash_fields = 64;
pub const IBV_RX_HASH_DST_PORT_UDP: ibv_rx_hash_fields = 128;
pub const IBV_RX_HASH_IPSEC_SPI: ibv_rx_hash_fields = 256;
pub const IBV_RX_HASH_INNER: ibv_rx_hash_fields = 2147483648;
pub type ibv_rx_hash_fields = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_rss_caps {
pub supported_qpts: u32,
pub max_rwq_indirection_tables: u32,
pub max_rwq_indirection_table_size: u32,
pub rx_hash_fields_mask: u64,
pub rx_hash_function: u8,
}
#[test]
fn bindgen_test_layout_ibv_rss_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_rss_caps> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_rss_caps>(),
24usize,
concat!("Size of: ", stringify!(ibv_rss_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_rss_caps>(),
4usize,
concat!("Alignment of ", stringify!(ibv_rss_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).supported_qpts) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_rss_caps),
"::",
stringify!(supported_qpts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_rwq_indirection_tables) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_rss_caps),
"::",
stringify!(max_rwq_indirection_tables)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).max_rwq_indirection_table_size) as usize - ptr as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_rss_caps),
"::",
stringify!(max_rwq_indirection_table_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_fields_mask) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_rss_caps),
"::",
stringify!(rx_hash_fields_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_function) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_rss_caps),
"::",
stringify!(rx_hash_function)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_packet_pacing_caps {
pub qp_rate_limit_min: u32,
pub qp_rate_limit_max: u32,
pub supported_qpts: u32,
}
#[test]
fn bindgen_test_layout_ibv_packet_pacing_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_packet_pacing_caps> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_packet_pacing_caps>(),
12usize,
concat!("Size of: ", stringify!(ibv_packet_pacing_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_packet_pacing_caps>(),
4usize,
concat!("Alignment of ", stringify!(ibv_packet_pacing_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_rate_limit_min) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_packet_pacing_caps),
"::",
stringify!(qp_rate_limit_min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_rate_limit_max) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_packet_pacing_caps),
"::",
stringify!(qp_rate_limit_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).supported_qpts) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_packet_pacing_caps),
"::",
stringify!(supported_qpts)
)
);
}
pub const IBV_RAW_PACKET_CAP_CVLAN_STRIPPING: ibv_raw_packet_caps = 1;
pub const IBV_RAW_PACKET_CAP_SCATTER_FCS: ibv_raw_packet_caps = 2;
pub const IBV_RAW_PACKET_CAP_IP_CSUM: ibv_raw_packet_caps = 4;
pub const IBV_RAW_PACKET_CAP_DELAY_DROP: ibv_raw_packet_caps = 8;
pub type ibv_raw_packet_caps = ::std::os::raw::c_uint;
pub const IBV_TM_CAP_RC: ibv_tm_cap_flags = 1;
pub type ibv_tm_cap_flags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_tm_caps {
pub max_rndv_hdr_size: u32,
pub max_num_tags: u32,
pub flags: u32,
pub max_ops: u32,
pub max_sge: u32,
}
#[test]
fn bindgen_test_layout_ibv_tm_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_tm_caps> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_tm_caps>(),
20usize,
concat!("Size of: ", stringify!(ibv_tm_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_tm_caps>(),
4usize,
concat!("Alignment of ", stringify!(ibv_tm_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_rndv_hdr_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_caps),
"::",
stringify!(max_rndv_hdr_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_num_tags) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_caps),
"::",
stringify!(max_num_tags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_caps),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_ops) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_caps),
"::",
stringify!(max_ops)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_sge) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_caps),
"::",
stringify!(max_sge)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_cq_moderation_caps {
pub max_cq_count: u16,
pub max_cq_period: u16,
}
#[test]
fn bindgen_test_layout_ibv_cq_moderation_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_cq_moderation_caps> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_cq_moderation_caps>(),
4usize,
concat!("Size of: ", stringify!(ibv_cq_moderation_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_cq_moderation_caps>(),
2usize,
concat!("Alignment of ", stringify!(ibv_cq_moderation_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_cq_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_moderation_caps),
"::",
stringify!(max_cq_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_cq_period) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_moderation_caps),
"::",
stringify!(max_cq_period)
)
);
}
pub const IBV_PCI_ATOMIC_OPERATION_4_BYTE_SIZE_SUP: ibv_pci_atomic_op_size = 1;
pub const IBV_PCI_ATOMIC_OPERATION_8_BYTE_SIZE_SUP: ibv_pci_atomic_op_size = 2;
pub const IBV_PCI_ATOMIC_OPERATION_16_BYTE_SIZE_SUP: ibv_pci_atomic_op_size = 4;
pub type ibv_pci_atomic_op_size = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_pci_atomic_caps {
pub fetch_add: u16,
pub swap: u16,
pub compare_swap: u16,
}
#[test]
fn bindgen_test_layout_ibv_pci_atomic_caps() {
const UNINIT: ::std::mem::MaybeUninit<ibv_pci_atomic_caps> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_pci_atomic_caps>(),
6usize,
concat!("Size of: ", stringify!(ibv_pci_atomic_caps))
);
assert_eq!(
::std::mem::align_of::<ibv_pci_atomic_caps>(),
2usize,
concat!("Alignment of ", stringify!(ibv_pci_atomic_caps))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fetch_add) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_pci_atomic_caps),
"::",
stringify!(fetch_add)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).swap) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ibv_pci_atomic_caps),
"::",
stringify!(swap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compare_swap) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_pci_atomic_caps),
"::",
stringify!(compare_swap)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_device_attr_ex {
pub orig_attr: ibv_device_attr,
pub comp_mask: u32,
pub odp_caps: ibv_odp_caps,
pub completion_timestamp_mask: u64,
pub hca_core_clock: u64,
pub device_cap_flags_ex: u64,
pub tso_caps: ibv_tso_caps,
pub rss_caps: ibv_rss_caps,
pub max_wq_type_rq: u32,
pub packet_pacing_caps: ibv_packet_pacing_caps,
pub raw_packet_caps: u32,
pub tm_caps: ibv_tm_caps,
pub cq_mod_caps: ibv_cq_moderation_caps,
pub max_dm_size: u64,
pub pci_atomic_caps: ibv_pci_atomic_caps,
pub xrc_odp_caps: u32,
}
#[test]
fn bindgen_test_layout_ibv_device_attr_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_device_attr_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_device_attr_ex>(),
372usize,
concat!("Size of: ", stringify!(ibv_device_attr_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_device_attr_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_device_attr_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).orig_attr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(orig_attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
228usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).odp_caps) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(odp_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).completion_timestamp_mask) as usize - ptr as usize },
252usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(completion_timestamp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hca_core_clock) as usize - ptr as usize },
260usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(hca_core_clock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device_cap_flags_ex) as usize - ptr as usize },
268usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(device_cap_flags_ex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tso_caps) as usize - ptr as usize },
276usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(tso_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rss_caps) as usize - ptr as usize },
284usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(rss_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_wq_type_rq) as usize - ptr as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(max_wq_type_rq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).packet_pacing_caps) as usize - ptr as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(packet_pacing_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw_packet_caps) as usize - ptr as usize },
324usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(raw_packet_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_caps) as usize - ptr as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(tm_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq_mod_caps) as usize - ptr as usize },
348usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(cq_mod_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_dm_size) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(max_dm_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pci_atomic_caps) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(pci_atomic_caps)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xrc_odp_caps) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(ibv_device_attr_ex),
"::",
stringify!(xrc_odp_caps)
)
);
}
impl Default for ibv_device_attr_ex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_MTU_256: ibv_mtu = 1;
pub const IBV_MTU_512: ibv_mtu = 2;
pub const IBV_MTU_1024: ibv_mtu = 3;
pub const IBV_MTU_2048: ibv_mtu = 4;
pub const IBV_MTU_4096: ibv_mtu = 5;
pub type ibv_mtu = ::std::os::raw::c_uint;
pub mod ibv_port_state {
pub type Type = ::std::os::raw::c_uint;
pub const IBV_PORT_NOP: Type = 0;
pub const IBV_PORT_DOWN: Type = 1;
pub const IBV_PORT_INIT: Type = 2;
pub const IBV_PORT_ARMED: Type = 3;
pub const IBV_PORT_ACTIVE: Type = 4;
pub const IBV_PORT_ACTIVE_DEFER: Type = 5;
}
impl ibv_port_cap_flags {
pub const IBV_PORT_SM: ibv_port_cap_flags = ibv_port_cap_flags(2);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_NOTICE_SUP: ibv_port_cap_flags = ibv_port_cap_flags(4);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_TRAP_SUP: ibv_port_cap_flags = ibv_port_cap_flags(8);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_OPT_IPD_SUP: ibv_port_cap_flags = ibv_port_cap_flags(16);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_AUTO_MIGR_SUP: ibv_port_cap_flags = ibv_port_cap_flags(32);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_SL_MAP_SUP: ibv_port_cap_flags = ibv_port_cap_flags(64);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_MKEY_NVRAM: ibv_port_cap_flags = ibv_port_cap_flags(128);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_PKEY_NVRAM: ibv_port_cap_flags = ibv_port_cap_flags(256);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_LED_INFO_SUP: ibv_port_cap_flags = ibv_port_cap_flags(512);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_SYS_IMAGE_GUID_SUP: ibv_port_cap_flags = ibv_port_cap_flags(2048);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_PKEY_SW_EXT_PORT_TRAP_SUP: ibv_port_cap_flags = ibv_port_cap_flags(4096);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_EXTENDED_SPEEDS_SUP: ibv_port_cap_flags = ibv_port_cap_flags(16384);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_CAP_MASK2_SUP: ibv_port_cap_flags = ibv_port_cap_flags(32768);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_CM_SUP: ibv_port_cap_flags = ibv_port_cap_flags(65536);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_SNMP_TUNNEL_SUP: ibv_port_cap_flags = ibv_port_cap_flags(131072);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_REINIT_SUP: ibv_port_cap_flags = ibv_port_cap_flags(262144);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_DEVICE_MGMT_SUP: ibv_port_cap_flags = ibv_port_cap_flags(524288);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_VENDOR_CLASS_SUP: ibv_port_cap_flags = ibv_port_cap_flags(1048576);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_DR_NOTICE_SUP: ibv_port_cap_flags = ibv_port_cap_flags(2097152);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_CAP_MASK_NOTICE_SUP: ibv_port_cap_flags = ibv_port_cap_flags(4194304);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_BOOT_MGMT_SUP: ibv_port_cap_flags = ibv_port_cap_flags(8388608);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_LINK_LATENCY_SUP: ibv_port_cap_flags = ibv_port_cap_flags(16777216);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_CLIENT_REG_SUP: ibv_port_cap_flags = ibv_port_cap_flags(33554432);
}
impl ibv_port_cap_flags {
pub const IBV_PORT_IP_BASED_GIDS: ibv_port_cap_flags = ibv_port_cap_flags(67108864);
}
impl ::std::ops::BitOr<ibv_port_cap_flags> for ibv_port_cap_flags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
ibv_port_cap_flags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for ibv_port_cap_flags {
#[inline]
fn bitor_assign(&mut self, rhs: ibv_port_cap_flags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<ibv_port_cap_flags> for ibv_port_cap_flags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
ibv_port_cap_flags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for ibv_port_cap_flags {
#[inline]
fn bitand_assign(&mut self, rhs: ibv_port_cap_flags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ibv_port_cap_flags(pub ::std::os::raw::c_uint);
pub const IBV_PORT_SET_NODE_DESC_SUP: ibv_port_cap_flags2 = 1;
pub const IBV_PORT_INFO_EXT_SUP: ibv_port_cap_flags2 = 2;
pub const IBV_PORT_VIRT_SUP: ibv_port_cap_flags2 = 4;
pub const IBV_PORT_SWITCH_PORT_STATE_TABLE_SUP: ibv_port_cap_flags2 = 8;
pub const IBV_PORT_LINK_WIDTH_2X_SUP: ibv_port_cap_flags2 = 16;
pub const IBV_PORT_LINK_SPEED_HDR_SUP: ibv_port_cap_flags2 = 32;
pub type ibv_port_cap_flags2 = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_port_attr {
pub state: ibv_port_state::Type,
pub max_mtu: ibv_mtu,
pub active_mtu: ibv_mtu,
pub gid_tbl_len: ::std::os::raw::c_int,
pub port_cap_flags: u32,
pub max_msg_sz: u32,
pub bad_pkey_cntr: u32,
pub qkey_viol_cntr: u32,
pub pkey_tbl_len: u16,
pub lid: u16,
pub sm_lid: u16,
pub lmc: u8,
pub max_vl_num: u8,
pub sm_sl: u8,
pub subnet_timeout: u8,
pub init_type_reply: u8,
pub active_width: u8,
pub active_speed: u8,
pub phys_state: u8,
pub link_layer: u8,
pub flags: u8,
pub port_cap_flags2: u16,
}
#[test]
fn bindgen_test_layout_ibv_port_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_port_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_port_attr>(),
52usize,
concat!("Size of: ", stringify!(ibv_port_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_port_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_port_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_mtu) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(max_mtu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_mtu) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(active_mtu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gid_tbl_len) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(gid_tbl_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port_cap_flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(port_cap_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_msg_sz) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(max_msg_sz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bad_pkey_cntr) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(bad_pkey_cntr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qkey_viol_cntr) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(qkey_viol_cntr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pkey_tbl_len) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(pkey_tbl_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lid) as usize - ptr as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(lid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sm_lid) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(sm_lid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lmc) as usize - ptr as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(lmc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_vl_num) as usize - ptr as usize },
39usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(max_vl_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sm_sl) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(sm_sl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subnet_timeout) as usize - ptr as usize },
41usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(subnet_timeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).init_type_reply) as usize - ptr as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(init_type_reply)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_width) as usize - ptr as usize },
43usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(active_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_speed) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(active_speed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).phys_state) as usize - ptr as usize },
45usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(phys_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).link_layer) as usize - ptr as usize },
46usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(link_layer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
47usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port_cap_flags2) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ibv_port_attr),
"::",
stringify!(port_cap_flags2)
)
);
}
impl Default for ibv_port_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_EVENT_CQ_ERR: ibv_event_type = 0;
pub const IBV_EVENT_QP_FATAL: ibv_event_type = 1;
pub const IBV_EVENT_QP_REQ_ERR: ibv_event_type = 2;
pub const IBV_EVENT_QP_ACCESS_ERR: ibv_event_type = 3;
pub const IBV_EVENT_COMM_EST: ibv_event_type = 4;
pub const IBV_EVENT_SQ_DRAINED: ibv_event_type = 5;
pub const IBV_EVENT_PATH_MIG: ibv_event_type = 6;
pub const IBV_EVENT_PATH_MIG_ERR: ibv_event_type = 7;
pub const IBV_EVENT_DEVICE_FATAL: ibv_event_type = 8;
pub const IBV_EVENT_PORT_ACTIVE: ibv_event_type = 9;
pub const IBV_EVENT_PORT_ERR: ibv_event_type = 10;
pub const IBV_EVENT_LID_CHANGE: ibv_event_type = 11;
pub const IBV_EVENT_PKEY_CHANGE: ibv_event_type = 12;
pub const IBV_EVENT_SM_CHANGE: ibv_event_type = 13;
pub const IBV_EVENT_SRQ_ERR: ibv_event_type = 14;
pub const IBV_EVENT_SRQ_LIMIT_REACHED: ibv_event_type = 15;
pub const IBV_EVENT_QP_LAST_WQE_REACHED: ibv_event_type = 16;
pub const IBV_EVENT_CLIENT_REREGISTER: ibv_event_type = 17;
pub const IBV_EVENT_GID_CHANGE: ibv_event_type = 18;
pub const IBV_EVENT_WQ_FATAL: ibv_event_type = 19;
pub type ibv_event_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_async_event {
pub element: ibv_async_event__bindgen_ty_1,
pub event_type: ibv_event_type,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_async_event__bindgen_ty_1 {
pub cq: *mut ibv_cq,
pub qp: *mut ibv_qp,
pub srq: *mut ibv_srq,
pub wq: *mut ibv_wq,
pub port_num: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ibv_async_event__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_async_event__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_async_event__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ibv_async_event__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_async_event__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_async_event__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event__bindgen_ty_1),
"::",
stringify!(cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event__bindgen_ty_1),
"::",
stringify!(qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event__bindgen_ty_1),
"::",
stringify!(srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event__bindgen_ty_1),
"::",
stringify!(wq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port_num) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event__bindgen_ty_1),
"::",
stringify!(port_num)
)
);
}
impl Default for ibv_async_event__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_async_event() {
const UNINIT: ::std::mem::MaybeUninit<ibv_async_event> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_async_event>(),
8usize,
concat!("Size of: ", stringify!(ibv_async_event))
);
assert_eq!(
::std::mem::align_of::<ibv_async_event>(),
4usize,
concat!("Alignment of ", stringify!(ibv_async_event))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).element) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event),
"::",
stringify!(element)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).event_type) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_async_event),
"::",
stringify!(event_type)
)
);
}
impl Default for ibv_async_event {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub mod ibv_wc_status {
pub type Type = ::std::os::raw::c_uint;
pub const IBV_WC_SUCCESS: Type = 0;
pub const IBV_WC_LOC_LEN_ERR: Type = 1;
pub const IBV_WC_LOC_QP_OP_ERR: Type = 2;
pub const IBV_WC_LOC_EEC_OP_ERR: Type = 3;
pub const IBV_WC_LOC_PROT_ERR: Type = 4;
pub const IBV_WC_WR_FLUSH_ERR: Type = 5;
pub const IBV_WC_MW_BIND_ERR: Type = 6;
pub const IBV_WC_BAD_RESP_ERR: Type = 7;
pub const IBV_WC_LOC_ACCESS_ERR: Type = 8;
pub const IBV_WC_REM_INV_REQ_ERR: Type = 9;
pub const IBV_WC_REM_ACCESS_ERR: Type = 10;
pub const IBV_WC_REM_OP_ERR: Type = 11;
pub const IBV_WC_RETRY_EXC_ERR: Type = 12;
pub const IBV_WC_RNR_RETRY_EXC_ERR: Type = 13;
pub const IBV_WC_LOC_RDD_VIOL_ERR: Type = 14;
pub const IBV_WC_REM_INV_RD_REQ_ERR: Type = 15;
pub const IBV_WC_REM_ABORT_ERR: Type = 16;
pub const IBV_WC_INV_EECN_ERR: Type = 17;
pub const IBV_WC_INV_EEC_STATE_ERR: Type = 18;
pub const IBV_WC_FATAL_ERR: Type = 19;
pub const IBV_WC_RESP_TIMEOUT_ERR: Type = 20;
pub const IBV_WC_GENERAL_ERR: Type = 21;
pub const IBV_WC_TM_ERR: Type = 22;
pub const IBV_WC_TM_RNDV_INCOMPLETE: Type = 23;
}
extern "C" {
pub fn ibv_wc_status_str(status: ibv_wc_status::Type) -> *const ::std::os::raw::c_char;
}
pub mod ibv_wc_opcode {
pub type Type = ::std::os::raw::c_uint;
pub const IBV_WC_SEND: Type = 0;
pub const IBV_WC_RDMA_WRITE: Type = 1;
pub const IBV_WC_RDMA_READ: Type = 2;
pub const IBV_WC_COMP_SWAP: Type = 3;
pub const IBV_WC_FETCH_ADD: Type = 4;
pub const IBV_WC_BIND_MW: Type = 5;
pub const IBV_WC_LOCAL_INV: Type = 6;
pub const IBV_WC_TSO: Type = 7;
pub const IBV_WC_RECV: Type = 128;
pub const IBV_WC_RECV_RDMA_WITH_IMM: Type = 129;
pub const IBV_WC_TM_ADD: Type = 130;
pub const IBV_WC_TM_DEL: Type = 131;
pub const IBV_WC_TM_SYNC: Type = 132;
pub const IBV_WC_TM_RECV: Type = 133;
pub const IBV_WC_TM_NO_TAG: Type = 134;
pub const IBV_WC_DRIVER1: Type = 135;
}
pub const IBV_WC_EX_WITH_BYTE_LEN: ibv_create_cq_wc_flags = 1;
pub const IBV_WC_EX_WITH_IMM: ibv_create_cq_wc_flags = 2;
pub const IBV_WC_EX_WITH_QP_NUM: ibv_create_cq_wc_flags = 4;
pub const IBV_WC_EX_WITH_SRC_QP: ibv_create_cq_wc_flags = 8;
pub const IBV_WC_EX_WITH_SLID: ibv_create_cq_wc_flags = 16;
pub const IBV_WC_EX_WITH_SL: ibv_create_cq_wc_flags = 32;
pub const IBV_WC_EX_WITH_DLID_PATH_BITS: ibv_create_cq_wc_flags = 64;
pub const IBV_WC_EX_WITH_COMPLETION_TIMESTAMP: ibv_create_cq_wc_flags = 128;
pub const IBV_WC_EX_WITH_CVLAN: ibv_create_cq_wc_flags = 256;
pub const IBV_WC_EX_WITH_FLOW_TAG: ibv_create_cq_wc_flags = 512;
pub const IBV_WC_EX_WITH_TM_INFO: ibv_create_cq_wc_flags = 1024;
pub const IBV_WC_EX_WITH_COMPLETION_TIMESTAMP_WALLCLOCK: ibv_create_cq_wc_flags = 2048;
pub type ibv_create_cq_wc_flags = ::std::os::raw::c_uint;
impl ibv_wc_flags {
pub const IBV_WC_GRH: ibv_wc_flags = ibv_wc_flags(1);
}
impl ibv_wc_flags {
pub const IBV_WC_WITH_IMM: ibv_wc_flags = ibv_wc_flags(2);
}
impl ibv_wc_flags {
pub const IBV_WC_IP_CSUM_OK: ibv_wc_flags = ibv_wc_flags(4);
}
impl ibv_wc_flags {
pub const IBV_WC_WITH_INV: ibv_wc_flags = ibv_wc_flags(8);
}
impl ibv_wc_flags {
pub const IBV_WC_TM_SYNC_REQ: ibv_wc_flags = ibv_wc_flags(16);
}
impl ibv_wc_flags {
pub const IBV_WC_TM_MATCH: ibv_wc_flags = ibv_wc_flags(32);
}
impl ibv_wc_flags {
pub const IBV_WC_TM_DATA_VALID: ibv_wc_flags = ibv_wc_flags(64);
}
impl ::std::ops::BitOr<ibv_wc_flags> for ibv_wc_flags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
ibv_wc_flags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for ibv_wc_flags {
#[inline]
fn bitor_assign(&mut self, rhs: ibv_wc_flags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<ibv_wc_flags> for ibv_wc_flags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
ibv_wc_flags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for ibv_wc_flags {
#[inline]
fn bitand_assign(&mut self, rhs: ibv_wc_flags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ibv_wc_flags(pub ::std::os::raw::c_uint);
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_wc__bindgen_ty_1 {
pub imm_data: __be32,
pub invalidated_rkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_wc__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_wc__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_wc__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ibv_wc__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_wc__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_wc__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).imm_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_wc__bindgen_ty_1),
"::",
stringify!(imm_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).invalidated_rkey) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_wc__bindgen_ty_1),
"::",
stringify!(invalidated_rkey)
)
);
}
impl Default for ibv_wc__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl ibv_access_flags {
pub const IBV_ACCESS_LOCAL_WRITE: ibv_access_flags = ibv_access_flags(1);
}
impl ibv_access_flags {
pub const IBV_ACCESS_REMOTE_WRITE: ibv_access_flags = ibv_access_flags(2);
}
impl ibv_access_flags {
pub const IBV_ACCESS_REMOTE_READ: ibv_access_flags = ibv_access_flags(4);
}
impl ibv_access_flags {
pub const IBV_ACCESS_REMOTE_ATOMIC: ibv_access_flags = ibv_access_flags(8);
}
impl ibv_access_flags {
pub const IBV_ACCESS_MW_BIND: ibv_access_flags = ibv_access_flags(16);
}
impl ibv_access_flags {
pub const IBV_ACCESS_ZERO_BASED: ibv_access_flags = ibv_access_flags(32);
}
impl ibv_access_flags {
pub const IBV_ACCESS_ON_DEMAND: ibv_access_flags = ibv_access_flags(64);
}
impl ibv_access_flags {
pub const IBV_ACCESS_HUGETLB: ibv_access_flags = ibv_access_flags(128);
}
impl ibv_access_flags {
pub const IBV_ACCESS_RELAXED_ORDERING: ibv_access_flags = ibv_access_flags(1048576);
}
impl ::std::ops::BitOr<ibv_access_flags> for ibv_access_flags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
ibv_access_flags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for ibv_access_flags {
#[inline]
fn bitor_assign(&mut self, rhs: ibv_access_flags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<ibv_access_flags> for ibv_access_flags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
ibv_access_flags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for ibv_access_flags {
#[inline]
fn bitand_assign(&mut self, rhs: ibv_access_flags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ibv_access_flags(pub ::std::os::raw::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_mw_bind_info {
pub mr: *mut ibv_mr,
pub addr: u64,
pub length: u64,
pub mw_access_flags: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_ibv_mw_bind_info() {
const UNINIT: ::std::mem::MaybeUninit<ibv_mw_bind_info> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_mw_bind_info>(),
24usize,
concat!("Size of: ", stringify!(ibv_mw_bind_info))
);
assert_eq!(
::std::mem::align_of::<ibv_mw_bind_info>(),
4usize,
concat!("Alignment of ", stringify!(ibv_mw_bind_info))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind_info),
"::",
stringify!(mr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind_info),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind_info),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mw_access_flags) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind_info),
"::",
stringify!(mw_access_flags)
)
);
}
impl Default for ibv_mw_bind_info {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_pd {
pub context: *mut ibv_context,
pub handle: u32,
}
#[test]
fn bindgen_test_layout_ibv_pd() {
const UNINIT: ::std::mem::MaybeUninit<ibv_pd> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_pd>(),
8usize,
concat!("Size of: ", stringify!(ibv_pd))
);
assert_eq!(
::std::mem::align_of::<ibv_pd>(),
4usize,
concat!("Alignment of ", stringify!(ibv_pd))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_pd),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_pd),
"::",
stringify!(handle)
)
);
}
impl Default for ibv_pd {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_td_init_attr {
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_td_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_td_init_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_td_init_attr>(),
4usize,
concat!("Size of: ", stringify!(ibv_td_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_td_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_td_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_td_init_attr),
"::",
stringify!(comp_mask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_td {
pub context: *mut ibv_context,
}
#[test]
fn bindgen_test_layout_ibv_td() {
const UNINIT: ::std::mem::MaybeUninit<ibv_td> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_td>(),
4usize,
concat!("Size of: ", stringify!(ibv_td))
);
assert_eq!(
::std::mem::align_of::<ibv_td>(),
4usize,
concat!("Alignment of ", stringify!(ibv_td))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_td),
"::",
stringify!(context)
)
);
}
impl Default for ibv_td {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_XRCD_INIT_ATTR_FD: ibv_xrcd_init_attr_mask = 1;
pub const IBV_XRCD_INIT_ATTR_OFLAGS: ibv_xrcd_init_attr_mask = 2;
pub const IBV_XRCD_INIT_ATTR_RESERVED: ibv_xrcd_init_attr_mask = 4;
pub type ibv_xrcd_init_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_xrcd_init_attr {
pub comp_mask: u32,
pub fd: ::std::os::raw::c_int,
pub oflags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ibv_xrcd_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_xrcd_init_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_xrcd_init_attr>(),
12usize,
concat!("Size of: ", stringify!(ibv_xrcd_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_xrcd_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_xrcd_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_xrcd_init_attr),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_xrcd_init_attr),
"::",
stringify!(fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).oflags) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_xrcd_init_attr),
"::",
stringify!(oflags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_xrcd {
pub context: *mut ibv_context,
}
#[test]
fn bindgen_test_layout_ibv_xrcd() {
const UNINIT: ::std::mem::MaybeUninit<ibv_xrcd> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_xrcd>(),
4usize,
concat!("Size of: ", stringify!(ibv_xrcd))
);
assert_eq!(
::std::mem::align_of::<ibv_xrcd>(),
4usize,
concat!("Alignment of ", stringify!(ibv_xrcd))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_xrcd),
"::",
stringify!(context)
)
);
}
impl Default for ibv_xrcd {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_REREG_MR_CHANGE_TRANSLATION: ibv_rereg_mr_flags = 1;
pub const IBV_REREG_MR_CHANGE_PD: ibv_rereg_mr_flags = 2;
pub const IBV_REREG_MR_CHANGE_ACCESS: ibv_rereg_mr_flags = 4;
pub const IBV_REREG_MR_FLAGS_SUPPORTED: ibv_rereg_mr_flags = 7;
pub type ibv_rereg_mr_flags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_mr {
pub context: *mut ibv_context,
pub pd: *mut ibv_pd,
pub addr: *mut ::std::os::raw::c_void,
pub length: usize,
pub handle: u32,
pub lkey: u32,
pub rkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_mr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_mr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_mr>(),
28usize,
concat!("Size of: ", stringify!(ibv_mr))
);
assert_eq!(
::std::mem::align_of::<ibv_mr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_mr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lkey) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(lkey)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rkey) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_mr),
"::",
stringify!(rkey)
)
);
}
impl Default for ibv_mr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_MW_TYPE_1: ibv_mw_type = 1;
pub const IBV_MW_TYPE_2: ibv_mw_type = 2;
pub type ibv_mw_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_mw {
pub context: *mut ibv_context,
pub pd: *mut ibv_pd,
pub rkey: u32,
pub handle: u32,
pub type_: ibv_mw_type,
}
#[test]
fn bindgen_test_layout_ibv_mw() {
const UNINIT: ::std::mem::MaybeUninit<ibv_mw> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_mw>(),
20usize,
concat!("Size of: ", stringify!(ibv_mw))
);
assert_eq!(
::std::mem::align_of::<ibv_mw>(),
4usize,
concat!("Alignment of ", stringify!(ibv_mw))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rkey) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw),
"::",
stringify!(rkey)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw),
"::",
stringify!(type_)
)
);
}
impl Default for ibv_mw {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_global_route {
pub dgid: ibv_gid,
pub flow_label: u32,
pub sgid_index: u8,
pub hop_limit: u8,
pub traffic_class: u8,
}
#[test]
fn bindgen_test_layout_ibv_global_route() {
const UNINIT: ::std::mem::MaybeUninit<ibv_global_route> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_global_route>(),
24usize,
concat!("Size of: ", stringify!(ibv_global_route))
);
assert_eq!(
::std::mem::align_of::<ibv_global_route>(),
4usize,
concat!("Alignment of ", stringify!(ibv_global_route))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dgid) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_global_route),
"::",
stringify!(dgid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flow_label) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_global_route),
"::",
stringify!(flow_label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sgid_index) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_global_route),
"::",
stringify!(sgid_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hop_limit) as usize - ptr as usize },
21usize,
concat!(
"Offset of field: ",
stringify!(ibv_global_route),
"::",
stringify!(hop_limit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).traffic_class) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(ibv_global_route),
"::",
stringify!(traffic_class)
)
);
}
impl Default for ibv_global_route {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_grh {
pub version_tclass_flow: __be32,
pub paylen: __be16,
pub next_hdr: u8,
pub hop_limit: u8,
pub sgid: ibv_gid,
pub dgid: ibv_gid,
}
#[test]
fn bindgen_test_layout_ibv_grh() {
const UNINIT: ::std::mem::MaybeUninit<ibv_grh> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_grh>(),
40usize,
concat!("Size of: ", stringify!(ibv_grh))
);
assert_eq!(
::std::mem::align_of::<ibv_grh>(),
4usize,
concat!("Alignment of ", stringify!(ibv_grh))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version_tclass_flow) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_grh),
"::",
stringify!(version_tclass_flow)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).paylen) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_grh),
"::",
stringify!(paylen)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_hdr) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ibv_grh),
"::",
stringify!(next_hdr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hop_limit) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(ibv_grh),
"::",
stringify!(hop_limit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sgid) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_grh),
"::",
stringify!(sgid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dgid) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_grh),
"::",
stringify!(dgid)
)
);
}
impl Default for ibv_grh {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_RATE_MAX: ibv_rate = 0;
pub const IBV_RATE_2_5_GBPS: ibv_rate = 2;
pub const IBV_RATE_5_GBPS: ibv_rate = 5;
pub const IBV_RATE_10_GBPS: ibv_rate = 3;
pub const IBV_RATE_20_GBPS: ibv_rate = 6;
pub const IBV_RATE_30_GBPS: ibv_rate = 4;
pub const IBV_RATE_40_GBPS: ibv_rate = 7;
pub const IBV_RATE_60_GBPS: ibv_rate = 8;
pub const IBV_RATE_80_GBPS: ibv_rate = 9;
pub const IBV_RATE_120_GBPS: ibv_rate = 10;
pub const IBV_RATE_14_GBPS: ibv_rate = 11;
pub const IBV_RATE_56_GBPS: ibv_rate = 12;
pub const IBV_RATE_112_GBPS: ibv_rate = 13;
pub const IBV_RATE_168_GBPS: ibv_rate = 14;
pub const IBV_RATE_25_GBPS: ibv_rate = 15;
pub const IBV_RATE_100_GBPS: ibv_rate = 16;
pub const IBV_RATE_200_GBPS: ibv_rate = 17;
pub const IBV_RATE_300_GBPS: ibv_rate = 18;
pub const IBV_RATE_28_GBPS: ibv_rate = 19;
pub const IBV_RATE_50_GBPS: ibv_rate = 20;
pub const IBV_RATE_400_GBPS: ibv_rate = 21;
pub const IBV_RATE_600_GBPS: ibv_rate = 22;
pub type ibv_rate = ::std::os::raw::c_uint;
extern "C" {
#[doc = " ibv_rate_to_mult - Convert the IB rate enum to a multiple of the\n base rate of 2.5 Gbit/sec. For example, IBV_RATE_5_GBPS will be\n converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.\n @rate: rate to convert."]
pub fn ibv_rate_to_mult(rate: ibv_rate) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_rate_to_mbps - Convert the IB rate enum to Mbit/sec.\n For example, IBV_RATE_5_GBPS will return the value 5000.\n @rate: rate to convert."]
pub fn ibv_rate_to_mbps(rate: ibv_rate) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_ah_attr {
pub grh: ibv_global_route,
pub dlid: u16,
pub sl: u8,
pub src_path_bits: u8,
pub static_rate: u8,
pub is_global: u8,
pub port_num: u8,
}
#[test]
fn bindgen_test_layout_ibv_ah_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_ah_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_ah_attr>(),
32usize,
concat!("Size of: ", stringify!(ibv_ah_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_ah_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_ah_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grh) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(grh)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dlid) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(dlid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sl) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(sl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).src_path_bits) as usize - ptr as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(src_path_bits)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).static_rate) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(static_rate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_global) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(is_global)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port_num) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah_attr),
"::",
stringify!(port_num)
)
);
}
impl Default for ibv_ah_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_SRQ_MAX_WR: ibv_srq_attr_mask = 1;
pub const IBV_SRQ_LIMIT: ibv_srq_attr_mask = 2;
pub type ibv_srq_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_srq_attr {
pub max_wr: u32,
pub max_sge: u32,
pub srq_limit: u32,
}
#[test]
fn bindgen_test_layout_ibv_srq_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_srq_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_srq_attr>(),
12usize,
concat!("Size of: ", stringify!(ibv_srq_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_srq_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_srq_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_wr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_attr),
"::",
stringify!(max_wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_sge) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_attr),
"::",
stringify!(max_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq_limit) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_attr),
"::",
stringify!(srq_limit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_srq_init_attr {
pub srq_context: *mut ::std::os::raw::c_void,
pub attr: ibv_srq_attr,
}
#[test]
fn bindgen_test_layout_ibv_srq_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_srq_init_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_srq_init_attr>(),
16usize,
concat!("Size of: ", stringify!(ibv_srq_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_srq_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_srq_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq_context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr),
"::",
stringify!(srq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr),
"::",
stringify!(attr)
)
);
}
impl Default for ibv_srq_init_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_SRQT_BASIC: ibv_srq_type = 0;
pub const IBV_SRQT_XRC: ibv_srq_type = 1;
pub const IBV_SRQT_TM: ibv_srq_type = 2;
pub type ibv_srq_type = ::std::os::raw::c_uint;
pub const IBV_SRQ_INIT_ATTR_TYPE: ibv_srq_init_attr_mask = 1;
pub const IBV_SRQ_INIT_ATTR_PD: ibv_srq_init_attr_mask = 2;
pub const IBV_SRQ_INIT_ATTR_XRCD: ibv_srq_init_attr_mask = 4;
pub const IBV_SRQ_INIT_ATTR_CQ: ibv_srq_init_attr_mask = 8;
pub const IBV_SRQ_INIT_ATTR_TM: ibv_srq_init_attr_mask = 16;
pub const IBV_SRQ_INIT_ATTR_RESERVED: ibv_srq_init_attr_mask = 32;
pub type ibv_srq_init_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_tm_cap {
pub max_num_tags: u32,
pub max_ops: u32,
}
#[test]
fn bindgen_test_layout_ibv_tm_cap() {
const UNINIT: ::std::mem::MaybeUninit<ibv_tm_cap> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_tm_cap>(),
8usize,
concat!("Size of: ", stringify!(ibv_tm_cap))
);
assert_eq!(
::std::mem::align_of::<ibv_tm_cap>(),
4usize,
concat!("Alignment of ", stringify!(ibv_tm_cap))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_num_tags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_cap),
"::",
stringify!(max_num_tags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_ops) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_tm_cap),
"::",
stringify!(max_ops)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_srq_init_attr_ex {
pub srq_context: *mut ::std::os::raw::c_void,
pub attr: ibv_srq_attr,
pub comp_mask: u32,
pub srq_type: ibv_srq_type,
pub pd: *mut ibv_pd,
pub xrcd: *mut ibv_xrcd,
pub cq: *mut ibv_cq,
pub tm_cap: ibv_tm_cap,
}
#[test]
fn bindgen_test_layout_ibv_srq_init_attr_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_srq_init_attr_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_srq_init_attr_ex>(),
44usize,
concat!("Size of: ", stringify!(ibv_srq_init_attr_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_srq_init_attr_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_srq_init_attr_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq_context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(srq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq_type) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(srq_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xrcd) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(xrcd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm_cap) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq_init_attr_ex),
"::",
stringify!(tm_cap)
)
);
}
impl Default for ibv_srq_init_attr_ex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_WQT_RQ: ibv_wq_type = 0;
pub type ibv_wq_type = ::std::os::raw::c_uint;
pub const IBV_WQ_INIT_ATTR_FLAGS: ibv_wq_init_attr_mask = 1;
pub const IBV_WQ_INIT_ATTR_RESERVED: ibv_wq_init_attr_mask = 2;
pub type ibv_wq_init_attr_mask = ::std::os::raw::c_uint;
pub const IBV_WQ_FLAGS_CVLAN_STRIPPING: ibv_wq_flags = 1;
pub const IBV_WQ_FLAGS_SCATTER_FCS: ibv_wq_flags = 2;
pub const IBV_WQ_FLAGS_DELAY_DROP: ibv_wq_flags = 4;
pub const IBV_WQ_FLAGS_PCI_WRITE_END_PADDING: ibv_wq_flags = 8;
pub const IBV_WQ_FLAGS_RESERVED: ibv_wq_flags = 16;
pub type ibv_wq_flags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_wq_init_attr {
pub wq_context: *mut ::std::os::raw::c_void,
pub wq_type: ibv_wq_type,
pub max_wr: u32,
pub max_sge: u32,
pub pd: *mut ibv_pd,
pub cq: *mut ibv_cq,
pub comp_mask: u32,
pub create_flags: u32,
}
#[test]
fn bindgen_test_layout_ibv_wq_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_wq_init_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_wq_init_attr>(),
32usize,
concat!("Size of: ", stringify!(ibv_wq_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_wq_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_wq_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq_context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(wq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq_type) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(wq_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_wr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(max_wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_sge) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(max_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).create_flags) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_init_attr),
"::",
stringify!(create_flags)
)
);
}
impl Default for ibv_wq_init_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_WQS_RESET: ibv_wq_state = 0;
pub const IBV_WQS_RDY: ibv_wq_state = 1;
pub const IBV_WQS_ERR: ibv_wq_state = 2;
pub const IBV_WQS_UNKNOWN: ibv_wq_state = 3;
pub type ibv_wq_state = ::std::os::raw::c_uint;
pub const IBV_WQ_ATTR_STATE: ibv_wq_attr_mask = 1;
pub const IBV_WQ_ATTR_CURR_STATE: ibv_wq_attr_mask = 2;
pub const IBV_WQ_ATTR_FLAGS: ibv_wq_attr_mask = 4;
pub const IBV_WQ_ATTR_RESERVED: ibv_wq_attr_mask = 8;
pub type ibv_wq_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_wq_attr {
pub attr_mask: u32,
pub wq_state: ibv_wq_state,
pub curr_wq_state: ibv_wq_state,
pub flags: u32,
pub flags_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_wq_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_wq_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_wq_attr>(),
20usize,
concat!("Size of: ", stringify!(ibv_wq_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_wq_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_wq_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_attr),
"::",
stringify!(attr_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq_state) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_attr),
"::",
stringify!(wq_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).curr_wq_state) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_attr),
"::",
stringify!(curr_wq_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_attr),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags_mask) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq_attr),
"::",
stringify!(flags_mask)
)
);
}
impl Default for ibv_wq_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_rwq_ind_table {
pub context: *mut ibv_context,
pub ind_tbl_handle: ::std::os::raw::c_int,
pub ind_tbl_num: ::std::os::raw::c_int,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_rwq_ind_table() {
const UNINIT: ::std::mem::MaybeUninit<ibv_rwq_ind_table> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_rwq_ind_table>(),
16usize,
concat!("Size of: ", stringify!(ibv_rwq_ind_table))
);
assert_eq!(
::std::mem::align_of::<ibv_rwq_ind_table>(),
4usize,
concat!("Alignment of ", stringify!(ibv_rwq_ind_table))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ind_tbl_handle) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table),
"::",
stringify!(ind_tbl_handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ind_tbl_num) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table),
"::",
stringify!(ind_tbl_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table),
"::",
stringify!(comp_mask)
)
);
}
impl Default for ibv_rwq_ind_table {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_CREATE_IND_TABLE_RESERVED: ibv_ind_table_init_attr_mask = 1;
pub type ibv_ind_table_init_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_rwq_ind_table_init_attr {
pub log_ind_tbl_size: u32,
pub ind_tbl: *mut *mut ibv_wq,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_rwq_ind_table_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_rwq_ind_table_init_attr> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_rwq_ind_table_init_attr>(),
12usize,
concat!("Size of: ", stringify!(ibv_rwq_ind_table_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_rwq_ind_table_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_rwq_ind_table_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).log_ind_tbl_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table_init_attr),
"::",
stringify!(log_ind_tbl_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ind_tbl) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table_init_attr),
"::",
stringify!(ind_tbl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_rwq_ind_table_init_attr),
"::",
stringify!(comp_mask)
)
);
}
impl Default for ibv_rwq_ind_table_init_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub mod ibv_qp_type {
pub type Type = ::std::os::raw::c_uint;
pub const IBV_QPT_RC: Type = 2;
pub const IBV_QPT_UC: Type = 3;
pub const IBV_QPT_UD: Type = 4;
pub const IBV_QPT_RAW_PACKET: Type = 8;
pub const IBV_QPT_XRC_SEND: Type = 9;
pub const IBV_QPT_XRC_RECV: Type = 10;
pub const IBV_QPT_DRIVER: Type = 255;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_qp_cap {
pub max_send_wr: u32,
pub max_recv_wr: u32,
pub max_send_sge: u32,
pub max_recv_sge: u32,
pub max_inline_data: u32,
}
#[test]
fn bindgen_test_layout_ibv_qp_cap() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_cap> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_cap>(),
20usize,
concat!("Size of: ", stringify!(ibv_qp_cap))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_cap>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_cap))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_send_wr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_cap),
"::",
stringify!(max_send_wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_recv_wr) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_cap),
"::",
stringify!(max_recv_wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_send_sge) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_cap),
"::",
stringify!(max_send_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_recv_sge) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_cap),
"::",
stringify!(max_recv_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_inline_data) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_cap),
"::",
stringify!(max_inline_data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_qp_init_attr {
pub qp_context: *mut ::std::os::raw::c_void,
pub send_cq: *mut ibv_cq,
pub recv_cq: *mut ibv_cq,
pub srq: *mut ibv_srq,
pub cap: ibv_qp_cap,
pub qp_type: ibv_qp_type::Type,
pub sq_sig_all: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ibv_qp_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_init_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_init_attr>(),
44usize,
concat!("Size of: ", stringify!(ibv_qp_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(qp_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_cq) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(send_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recv_cq) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(recv_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cap) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(cap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_type) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(qp_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sq_sig_all) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr),
"::",
stringify!(sq_sig_all)
)
);
}
impl Default for ibv_qp_init_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_QP_INIT_ATTR_PD: ibv_qp_init_attr_mask = 1;
pub const IBV_QP_INIT_ATTR_XRCD: ibv_qp_init_attr_mask = 2;
pub const IBV_QP_INIT_ATTR_CREATE_FLAGS: ibv_qp_init_attr_mask = 4;
pub const IBV_QP_INIT_ATTR_MAX_TSO_HEADER: ibv_qp_init_attr_mask = 8;
pub const IBV_QP_INIT_ATTR_IND_TABLE: ibv_qp_init_attr_mask = 16;
pub const IBV_QP_INIT_ATTR_RX_HASH: ibv_qp_init_attr_mask = 32;
pub const IBV_QP_INIT_ATTR_SEND_OPS_FLAGS: ibv_qp_init_attr_mask = 64;
pub type ibv_qp_init_attr_mask = ::std::os::raw::c_uint;
pub const IBV_QP_CREATE_BLOCK_SELF_MCAST_LB: ibv_qp_create_flags = 2;
pub const IBV_QP_CREATE_SCATTER_FCS: ibv_qp_create_flags = 256;
pub const IBV_QP_CREATE_CVLAN_STRIPPING: ibv_qp_create_flags = 512;
pub const IBV_QP_CREATE_SOURCE_QPN: ibv_qp_create_flags = 1024;
pub const IBV_QP_CREATE_PCI_WRITE_END_PADDING: ibv_qp_create_flags = 2048;
pub type ibv_qp_create_flags = ::std::os::raw::c_uint;
pub const IBV_QP_EX_WITH_RDMA_WRITE: ibv_qp_create_send_ops_flags = 1;
pub const IBV_QP_EX_WITH_RDMA_WRITE_WITH_IMM: ibv_qp_create_send_ops_flags = 2;
pub const IBV_QP_EX_WITH_SEND: ibv_qp_create_send_ops_flags = 4;
pub const IBV_QP_EX_WITH_SEND_WITH_IMM: ibv_qp_create_send_ops_flags = 8;
pub const IBV_QP_EX_WITH_RDMA_READ: ibv_qp_create_send_ops_flags = 16;
pub const IBV_QP_EX_WITH_ATOMIC_CMP_AND_SWP: ibv_qp_create_send_ops_flags = 32;
pub const IBV_QP_EX_WITH_ATOMIC_FETCH_AND_ADD: ibv_qp_create_send_ops_flags = 64;
pub const IBV_QP_EX_WITH_LOCAL_INV: ibv_qp_create_send_ops_flags = 128;
pub const IBV_QP_EX_WITH_BIND_MW: ibv_qp_create_send_ops_flags = 256;
pub const IBV_QP_EX_WITH_SEND_WITH_INV: ibv_qp_create_send_ops_flags = 512;
pub const IBV_QP_EX_WITH_TSO: ibv_qp_create_send_ops_flags = 1024;
pub type ibv_qp_create_send_ops_flags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_rx_hash_conf {
pub rx_hash_function: u8,
pub rx_hash_key_len: u8,
pub rx_hash_key: *mut u8,
pub rx_hash_fields_mask: u64,
}
#[test]
fn bindgen_test_layout_ibv_rx_hash_conf() {
const UNINIT: ::std::mem::MaybeUninit<ibv_rx_hash_conf> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_rx_hash_conf>(),
16usize,
concat!("Size of: ", stringify!(ibv_rx_hash_conf))
);
assert_eq!(
::std::mem::align_of::<ibv_rx_hash_conf>(),
4usize,
concat!("Alignment of ", stringify!(ibv_rx_hash_conf))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_function) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_rx_hash_conf),
"::",
stringify!(rx_hash_function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_key_len) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(ibv_rx_hash_conf),
"::",
stringify!(rx_hash_key_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_key) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_rx_hash_conf),
"::",
stringify!(rx_hash_key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_fields_mask) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_rx_hash_conf),
"::",
stringify!(rx_hash_fields_mask)
)
);
}
impl Default for ibv_rx_hash_conf {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_qp_init_attr_ex {
pub qp_context: *mut ::std::os::raw::c_void,
pub send_cq: *mut ibv_cq,
pub recv_cq: *mut ibv_cq,
pub srq: *mut ibv_srq,
pub cap: ibv_qp_cap,
pub qp_type: ibv_qp_type::Type,
pub sq_sig_all: ::std::os::raw::c_int,
pub comp_mask: u32,
pub pd: *mut ibv_pd,
pub xrcd: *mut ibv_xrcd,
pub create_flags: u32,
pub max_tso_header: u16,
pub rwq_ind_tbl: *mut ibv_rwq_ind_table,
pub rx_hash_conf: ibv_rx_hash_conf,
pub source_qpn: u32,
pub send_ops_flags: u64,
}
#[test]
fn bindgen_test_layout_ibv_qp_init_attr_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_init_attr_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_init_attr_ex>(),
96usize,
concat!("Size of: ", stringify!(ibv_qp_init_attr_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_init_attr_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_init_attr_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(qp_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_cq) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(send_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recv_cq) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(recv_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cap) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(cap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_type) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(qp_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sq_sig_all) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(sq_sig_all)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xrcd) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(xrcd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).create_flags) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(create_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_tso_header) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(max_tso_header)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rwq_ind_tbl) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(rwq_ind_tbl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rx_hash_conf) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(rx_hash_conf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_qpn) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(source_qpn)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_ops_flags) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_init_attr_ex),
"::",
stringify!(send_ops_flags)
)
);
}
impl Default for ibv_qp_init_attr_ex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_QP_OPEN_ATTR_NUM: ibv_qp_open_attr_mask = 1;
pub const IBV_QP_OPEN_ATTR_XRCD: ibv_qp_open_attr_mask = 2;
pub const IBV_QP_OPEN_ATTR_CONTEXT: ibv_qp_open_attr_mask = 4;
pub const IBV_QP_OPEN_ATTR_TYPE: ibv_qp_open_attr_mask = 8;
pub const IBV_QP_OPEN_ATTR_RESERVED: ibv_qp_open_attr_mask = 16;
pub type ibv_qp_open_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_qp_open_attr {
pub comp_mask: u32,
pub qp_num: u32,
pub xrcd: *mut ibv_xrcd,
pub qp_context: *mut ::std::os::raw::c_void,
pub qp_type: ibv_qp_type::Type,
}
#[test]
fn bindgen_test_layout_ibv_qp_open_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_open_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_open_attr>(),
20usize,
concat!("Size of: ", stringify!(ibv_qp_open_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_open_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_open_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_open_attr),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_num) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_open_attr),
"::",
stringify!(qp_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xrcd) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_open_attr),
"::",
stringify!(xrcd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_context) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_open_attr),
"::",
stringify!(qp_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_type) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_open_attr),
"::",
stringify!(qp_type)
)
);
}
impl Default for ibv_qp_open_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl ibv_qp_attr_mask {
pub const IBV_QP_STATE: ibv_qp_attr_mask = ibv_qp_attr_mask(1);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_CUR_STATE: ibv_qp_attr_mask = ibv_qp_attr_mask(2);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_EN_SQD_ASYNC_NOTIFY: ibv_qp_attr_mask = ibv_qp_attr_mask(4);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_ACCESS_FLAGS: ibv_qp_attr_mask = ibv_qp_attr_mask(8);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_PKEY_INDEX: ibv_qp_attr_mask = ibv_qp_attr_mask(16);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_PORT: ibv_qp_attr_mask = ibv_qp_attr_mask(32);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_QKEY: ibv_qp_attr_mask = ibv_qp_attr_mask(64);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_AV: ibv_qp_attr_mask = ibv_qp_attr_mask(128);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_PATH_MTU: ibv_qp_attr_mask = ibv_qp_attr_mask(256);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_TIMEOUT: ibv_qp_attr_mask = ibv_qp_attr_mask(512);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_RETRY_CNT: ibv_qp_attr_mask = ibv_qp_attr_mask(1024);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_RNR_RETRY: ibv_qp_attr_mask = ibv_qp_attr_mask(2048);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_RQ_PSN: ibv_qp_attr_mask = ibv_qp_attr_mask(4096);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_MAX_QP_RD_ATOMIC: ibv_qp_attr_mask = ibv_qp_attr_mask(8192);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_ALT_PATH: ibv_qp_attr_mask = ibv_qp_attr_mask(16384);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_MIN_RNR_TIMER: ibv_qp_attr_mask = ibv_qp_attr_mask(32768);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_SQ_PSN: ibv_qp_attr_mask = ibv_qp_attr_mask(65536);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_MAX_DEST_RD_ATOMIC: ibv_qp_attr_mask = ibv_qp_attr_mask(131072);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_PATH_MIG_STATE: ibv_qp_attr_mask = ibv_qp_attr_mask(262144);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_CAP: ibv_qp_attr_mask = ibv_qp_attr_mask(524288);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_DEST_QPN: ibv_qp_attr_mask = ibv_qp_attr_mask(1048576);
}
impl ibv_qp_attr_mask {
pub const IBV_QP_RATE_LIMIT: ibv_qp_attr_mask = ibv_qp_attr_mask(33554432);
}
impl ::std::ops::BitOr<ibv_qp_attr_mask> for ibv_qp_attr_mask {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
ibv_qp_attr_mask(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for ibv_qp_attr_mask {
#[inline]
fn bitor_assign(&mut self, rhs: ibv_qp_attr_mask) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<ibv_qp_attr_mask> for ibv_qp_attr_mask {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
ibv_qp_attr_mask(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for ibv_qp_attr_mask {
#[inline]
fn bitand_assign(&mut self, rhs: ibv_qp_attr_mask) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ibv_qp_attr_mask(pub ::std::os::raw::c_uint);
pub mod ibv_qp_state {
pub type Type = ::std::os::raw::c_uint;
pub const IBV_QPS_RESET: Type = 0;
pub const IBV_QPS_INIT: Type = 1;
pub const IBV_QPS_RTR: Type = 2;
pub const IBV_QPS_RTS: Type = 3;
pub const IBV_QPS_SQD: Type = 4;
pub const IBV_QPS_SQE: Type = 5;
pub const IBV_QPS_ERR: Type = 6;
pub const IBV_QPS_UNKNOWN: Type = 7;
}
pub const IBV_MIG_MIGRATED: ibv_mig_state = 0;
pub const IBV_MIG_REARM: ibv_mig_state = 1;
pub const IBV_MIG_ARMED: ibv_mig_state = 2;
pub type ibv_mig_state = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_qp_attr {
pub qp_state: ibv_qp_state::Type,
pub cur_qp_state: ibv_qp_state::Type,
pub path_mtu: ibv_mtu,
pub path_mig_state: ibv_mig_state,
pub qkey: u32,
pub rq_psn: u32,
pub sq_psn: u32,
pub dest_qp_num: u32,
pub qp_access_flags: ::std::os::raw::c_uint,
pub cap: ibv_qp_cap,
pub ah_attr: ibv_ah_attr,
pub alt_ah_attr: ibv_ah_attr,
pub pkey_index: u16,
pub alt_pkey_index: u16,
pub en_sqd_async_notify: u8,
pub sq_draining: u8,
pub max_rd_atomic: u8,
pub max_dest_rd_atomic: u8,
pub min_rnr_timer: u8,
pub port_num: u8,
pub timeout: u8,
pub retry_cnt: u8,
pub rnr_retry: u8,
pub alt_port_num: u8,
pub alt_timeout: u8,
pub rate_limit: u32,
}
#[test]
fn bindgen_test_layout_ibv_qp_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_attr>(),
140usize,
concat!("Size of: ", stringify!(ibv_qp_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_state) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(qp_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cur_qp_state) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(cur_qp_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).path_mtu) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(path_mtu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).path_mig_state) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(path_mig_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qkey) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(qkey)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rq_psn) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(rq_psn)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sq_psn) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(sq_psn)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dest_qp_num) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(dest_qp_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_access_flags) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(qp_access_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cap) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(cap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ah_attr) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(ah_attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt_ah_attr) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(alt_ah_attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pkey_index) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(pkey_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt_pkey_index) as usize - ptr as usize },
122usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(alt_pkey_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).en_sqd_async_notify) as usize - ptr as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(en_sqd_async_notify)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sq_draining) as usize - ptr as usize },
125usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(sq_draining)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_rd_atomic) as usize - ptr as usize },
126usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(max_rd_atomic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_dest_rd_atomic) as usize - ptr as usize },
127usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(max_dest_rd_atomic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_rnr_timer) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(min_rnr_timer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port_num) as usize - ptr as usize },
129usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(port_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(timeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).retry_cnt) as usize - ptr as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(retry_cnt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rnr_retry) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(rnr_retry)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt_port_num) as usize - ptr as usize },
133usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(alt_port_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alt_timeout) as usize - ptr as usize },
134usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(alt_timeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rate_limit) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_attr),
"::",
stringify!(rate_limit)
)
);
}
impl Default for ibv_qp_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_qp_rate_limit_attr {
pub rate_limit: u32,
pub max_burst_sz: u32,
pub typical_pkt_sz: u16,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_qp_rate_limit_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_rate_limit_attr> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_rate_limit_attr>(),
16usize,
concat!("Size of: ", stringify!(ibv_qp_rate_limit_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_rate_limit_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_rate_limit_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rate_limit) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_rate_limit_attr),
"::",
stringify!(rate_limit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_burst_sz) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_rate_limit_attr),
"::",
stringify!(max_burst_sz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typical_pkt_sz) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_rate_limit_attr),
"::",
stringify!(typical_pkt_sz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_rate_limit_attr),
"::",
stringify!(comp_mask)
)
);
}
pub mod ibv_wr_opcode {
pub type Type = ::std::os::raw::c_uint;
pub const IBV_WR_RDMA_WRITE: Type = 0;
pub const IBV_WR_RDMA_WRITE_WITH_IMM: Type = 1;
pub const IBV_WR_SEND: Type = 2;
pub const IBV_WR_SEND_WITH_IMM: Type = 3;
pub const IBV_WR_RDMA_READ: Type = 4;
pub const IBV_WR_ATOMIC_CMP_AND_SWP: Type = 5;
pub const IBV_WR_ATOMIC_FETCH_AND_ADD: Type = 6;
pub const IBV_WR_LOCAL_INV: Type = 7;
pub const IBV_WR_BIND_MW: Type = 8;
pub const IBV_WR_SEND_WITH_INV: Type = 9;
pub const IBV_WR_TSO: Type = 10;
pub const IBV_WR_DRIVER1: Type = 11;
}
impl ibv_send_flags {
pub const IBV_SEND_FENCE: ibv_send_flags = ibv_send_flags(1);
}
impl ibv_send_flags {
pub const IBV_SEND_SIGNALED: ibv_send_flags = ibv_send_flags(2);
}
impl ibv_send_flags {
pub const IBV_SEND_SOLICITED: ibv_send_flags = ibv_send_flags(4);
}
impl ibv_send_flags {
pub const IBV_SEND_INLINE: ibv_send_flags = ibv_send_flags(8);
}
impl ibv_send_flags {
pub const IBV_SEND_IP_CSUM: ibv_send_flags = ibv_send_flags(16);
}
impl ::std::ops::BitOr<ibv_send_flags> for ibv_send_flags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
ibv_send_flags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for ibv_send_flags {
#[inline]
fn bitor_assign(&mut self, rhs: ibv_send_flags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<ibv_send_flags> for ibv_send_flags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
ibv_send_flags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for ibv_send_flags {
#[inline]
fn bitand_assign(&mut self, rhs: ibv_send_flags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ibv_send_flags(pub ::std::os::raw::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_data_buf {
pub addr: *mut ::std::os::raw::c_void,
pub length: usize,
}
#[test]
fn bindgen_test_layout_ibv_data_buf() {
const UNINIT: ::std::mem::MaybeUninit<ibv_data_buf> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_data_buf>(),
8usize,
concat!("Size of: ", stringify!(ibv_data_buf))
);
assert_eq!(
::std::mem::align_of::<ibv_data_buf>(),
4usize,
concat!("Alignment of ", stringify!(ibv_data_buf))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_data_buf),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_data_buf),
"::",
stringify!(length)
)
);
}
impl Default for ibv_data_buf {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_sge {
pub addr: u64,
pub length: u32,
pub lkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_sge() {
const UNINIT: ::std::mem::MaybeUninit<ibv_sge> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_sge>(),
16usize,
concat!("Size of: ", stringify!(ibv_sge))
);
assert_eq!(
::std::mem::align_of::<ibv_sge>(),
4usize,
concat!("Alignment of ", stringify!(ibv_sge))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_sge),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_sge),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lkey) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_sge),
"::",
stringify!(lkey)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_send_wr {
pub wr_id: u64,
pub next: *mut ibv_send_wr,
pub sg_list: *mut ibv_sge,
pub num_sge: ::std::os::raw::c_int,
pub opcode: ibv_wr_opcode::Type,
pub send_flags: ::std::os::raw::c_uint,
pub __bindgen_anon_1: ibv_send_wr__bindgen_ty_1,
pub wr: ibv_send_wr__bindgen_ty_2,
pub qp_type: ibv_send_wr__bindgen_ty_3,
pub __bindgen_anon_2: ibv_send_wr__bindgen_ty_4,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_send_wr__bindgen_ty_1 {
pub imm_data: __be32,
pub invalidate_rkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ibv_send_wr__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_send_wr__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).imm_data) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_1),
"::",
stringify!(imm_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).invalidate_rkey) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_1),
"::",
stringify!(invalidate_rkey)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_send_wr__bindgen_ty_2 {
pub rdma: ibv_send_wr__bindgen_ty_2__bindgen_ty_1,
pub atomic: ibv_send_wr__bindgen_ty_2__bindgen_ty_2,
pub ud: ibv_send_wr__bindgen_ty_2__bindgen_ty_3,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_send_wr__bindgen_ty_2__bindgen_ty_1 {
pub remote_addr: u64,
pub rkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_2__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_2__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_2__bindgen_ty_1>(),
12usize,
concat!(
"Size of: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remote_addr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(remote_addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rkey) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(rkey)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_send_wr__bindgen_ty_2__bindgen_ty_2 {
pub remote_addr: u64,
pub compare_add: u64,
pub swap: u64,
pub rkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_2__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_2__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_2__bindgen_ty_2>(),
28usize,
concat!(
"Size of: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_2__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remote_addr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(remote_addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compare_add) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(compare_add)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).swap) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(swap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rkey) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(rkey)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_send_wr__bindgen_ty_2__bindgen_ty_3 {
pub ah: *mut ibv_ah,
pub remote_qpn: u32,
pub remote_qkey: u32,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_2__bindgen_ty_3() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_2__bindgen_ty_3> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_2__bindgen_ty_3>(),
12usize,
concat!(
"Size of: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_3)
)
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_2__bindgen_ty_3>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ah) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_3),
"::",
stringify!(ah)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remote_qpn) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_3),
"::",
stringify!(remote_qpn)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remote_qkey) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2__bindgen_ty_3),
"::",
stringify!(remote_qkey)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_2__bindgen_ty_3 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_2>(),
28usize,
concat!("Size of: ", stringify!(ibv_send_wr__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_2>(),
4usize,
concat!("Alignment of ", stringify!(ibv_send_wr__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rdma) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2),
"::",
stringify!(rdma)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).atomic) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2),
"::",
stringify!(atomic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ud) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_2),
"::",
stringify!(ud)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_2 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_send_wr__bindgen_ty_3 {
pub xrc: ibv_send_wr__bindgen_ty_3__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_send_wr__bindgen_ty_3__bindgen_ty_1 {
pub remote_srqn: u32,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_3__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_3__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_3__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(ibv_send_wr__bindgen_ty_3__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_3__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_send_wr__bindgen_ty_3__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).remote_srqn) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_3__bindgen_ty_1),
"::",
stringify!(remote_srqn)
)
);
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_3() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_3> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_3>(),
4usize,
concat!("Size of: ", stringify!(ibv_send_wr__bindgen_ty_3))
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_3>(),
4usize,
concat!("Alignment of ", stringify!(ibv_send_wr__bindgen_ty_3))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xrc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_3),
"::",
stringify!(xrc)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_3 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_send_wr__bindgen_ty_4 {
pub bind_mw: ibv_send_wr__bindgen_ty_4__bindgen_ty_1,
pub tso: ibv_send_wr__bindgen_ty_4__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_send_wr__bindgen_ty_4__bindgen_ty_1 {
pub mw: *mut ibv_mw,
pub rkey: u32,
pub bind_info: ibv_mw_bind_info,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_4__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_4__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_4__bindgen_ty_1>(),
32usize,
concat!(
"Size of: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_4__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mw) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_1),
"::",
stringify!(mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rkey) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_1),
"::",
stringify!(rkey)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bind_info) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_1),
"::",
stringify!(bind_info)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_4__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_send_wr__bindgen_ty_4__bindgen_ty_2 {
pub hdr: *mut ::std::os::raw::c_void,
pub hdr_sz: u16,
pub mss: u16,
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_4__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_4__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_4__bindgen_ty_2>(),
8usize,
concat!(
"Size of: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_4__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_2),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hdr_sz) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_2),
"::",
stringify!(hdr_sz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mss) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4__bindgen_ty_2),
"::",
stringify!(mss)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_4__bindgen_ty_2 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_send_wr__bindgen_ty_4() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr__bindgen_ty_4> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr__bindgen_ty_4>(),
32usize,
concat!("Size of: ", stringify!(ibv_send_wr__bindgen_ty_4))
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr__bindgen_ty_4>(),
4usize,
concat!("Alignment of ", stringify!(ibv_send_wr__bindgen_ty_4))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bind_mw) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4),
"::",
stringify!(bind_mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tso) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr__bindgen_ty_4),
"::",
stringify!(tso)
)
);
}
impl Default for ibv_send_wr__bindgen_ty_4 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_send_wr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_send_wr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_send_wr>(),
96usize,
concat!("Size of: ", stringify!(ibv_send_wr))
);
assert_eq!(
::std::mem::align_of::<ibv_send_wr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_send_wr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sg_list) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(sg_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_sge) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(num_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(opcode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_flags) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(send_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(wr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_type) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(ibv_send_wr),
"::",
stringify!(qp_type)
)
);
}
impl Default for ibv_send_wr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_recv_wr {
pub wr_id: u64,
pub next: *mut ibv_recv_wr,
pub sg_list: *mut ibv_sge,
pub num_sge: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ibv_recv_wr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_recv_wr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_recv_wr>(),
20usize,
concat!("Size of: ", stringify!(ibv_recv_wr))
);
assert_eq!(
::std::mem::align_of::<ibv_recv_wr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_recv_wr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_recv_wr),
"::",
stringify!(wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_recv_wr),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sg_list) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_recv_wr),
"::",
stringify!(sg_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_sge) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_recv_wr),
"::",
stringify!(num_sge)
)
);
}
impl Default for ibv_recv_wr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_WR_TAG_ADD: ibv_ops_wr_opcode = 0;
pub const IBV_WR_TAG_DEL: ibv_ops_wr_opcode = 1;
pub const IBV_WR_TAG_SYNC: ibv_ops_wr_opcode = 2;
pub type ibv_ops_wr_opcode = ::std::os::raw::c_uint;
pub const IBV_OPS_SIGNALED: ibv_ops_flags = 1;
pub const IBV_OPS_TM_SYNC: ibv_ops_flags = 2;
pub type ibv_ops_flags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_ops_wr {
pub wr_id: u64,
pub next: *mut ibv_ops_wr,
pub opcode: ibv_ops_wr_opcode,
pub flags: ::std::os::raw::c_int,
pub tm: ibv_ops_wr__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_ops_wr__bindgen_ty_1 {
pub unexpected_cnt: u32,
pub handle: u32,
pub add: ibv_ops_wr__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_ops_wr__bindgen_ty_1__bindgen_ty_1 {
pub recv_wr_id: u64,
pub sg_list: *mut ibv_sge,
pub num_sge: ::std::os::raw::c_int,
pub tag: u64,
pub mask: u64,
}
#[test]
fn bindgen_test_layout_ibv_ops_wr__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_ops_wr__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_ops_wr__bindgen_ty_1__bindgen_ty_1>(),
32usize,
concat!(
"Size of: ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ibv_ops_wr__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recv_wr_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(recv_wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sg_list) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(sg_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_sge) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(num_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tag) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(tag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_ops_wr__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_ops_wr__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_ops_wr__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_ops_wr__bindgen_ty_1>(),
40usize,
concat!("Size of: ", stringify!(ibv_ops_wr__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_ops_wr__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_ops_wr__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unexpected_cnt) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1),
"::",
stringify!(unexpected_cnt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).add) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr__bindgen_ty_1),
"::",
stringify!(add)
)
);
}
impl Default for ibv_ops_wr__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_ops_wr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_ops_wr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_ops_wr>(),
60usize,
concat!("Size of: ", stringify!(ibv_ops_wr))
);
assert_eq!(
::std::mem::align_of::<ibv_ops_wr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_ops_wr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr),
"::",
stringify!(wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr),
"::",
stringify!(opcode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_ops_wr),
"::",
stringify!(tm)
)
);
}
impl Default for ibv_ops_wr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_mw_bind {
pub wr_id: u64,
pub send_flags: ::std::os::raw::c_uint,
pub bind_info: ibv_mw_bind_info,
}
#[test]
fn bindgen_test_layout_ibv_mw_bind() {
const UNINIT: ::std::mem::MaybeUninit<ibv_mw_bind> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_mw_bind>(),
36usize,
concat!("Size of: ", stringify!(ibv_mw_bind))
);
assert_eq!(
::std::mem::align_of::<ibv_mw_bind>(),
4usize,
concat!("Alignment of ", stringify!(ibv_mw_bind))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind),
"::",
stringify!(wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_flags) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind),
"::",
stringify!(send_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bind_info) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_mw_bind),
"::",
stringify!(bind_info)
)
);
}
impl Default for ibv_mw_bind {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_srq {
pub context: *mut ibv_context,
pub srq_context: *mut ::std::os::raw::c_void,
pub pd: *mut ibv_pd,
pub handle: u32,
pub mutex: pthread_mutex_t,
pub cond: pthread_cond_t,
pub events_completed: u32,
}
#[test]
fn bindgen_test_layout_ibv_srq() {
const UNINIT: ::std::mem::MaybeUninit<ibv_srq> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_srq>(),
92usize,
concat!("Size of: ", stringify!(ibv_srq))
);
assert_eq!(
::std::mem::align_of::<ibv_srq>(),
4usize,
concat!("Alignment of ", stringify!(ibv_srq))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq_context) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(srq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mutex) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cond) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events_completed) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ibv_srq),
"::",
stringify!(events_completed)
)
);
}
impl Default for ibv_srq {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_wq {
pub context: *mut ibv_context,
pub wq_context: *mut ::std::os::raw::c_void,
pub pd: *mut ibv_pd,
pub cq: *mut ibv_cq,
pub wq_num: u32,
pub handle: u32,
pub state: ibv_wq_state,
pub wq_type: ibv_wq_type,
pub post_recv: ::std::option::Option<
unsafe extern "C" fn(
current: *mut ibv_wq,
recv_wr: *mut ibv_recv_wr,
bad_recv_wr: *mut *mut ibv_recv_wr,
) -> ::std::os::raw::c_int,
>,
pub mutex: pthread_mutex_t,
pub cond: pthread_cond_t,
pub events_completed: u32,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_wq() {
const UNINIT: ::std::mem::MaybeUninit<ibv_wq> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_wq>(),
116usize,
concat!("Size of: ", stringify!(ibv_wq))
);
assert_eq!(
::std::mem::align_of::<ibv_wq>(),
4usize,
concat!("Alignment of ", stringify!(ibv_wq))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq_context) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(wq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq_num) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(wq_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wq_type) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(wq_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).post_recv) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(post_recv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mutex) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cond) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events_completed) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(events_completed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ibv_wq),
"::",
stringify!(comp_mask)
)
);
}
impl Default for ibv_wq {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_qp {
pub context: *mut ibv_context,
pub qp_context: *mut ::std::os::raw::c_void,
pub pd: *mut ibv_pd,
pub send_cq: *mut ibv_cq,
pub recv_cq: *mut ibv_cq,
pub srq: *mut ibv_srq,
pub handle: u32,
pub qp_num: u32,
pub state: ibv_qp_state::Type,
pub qp_type: ibv_qp_type::Type,
pub mutex: pthread_mutex_t,
pub cond: pthread_cond_t,
pub events_completed: u32,
}
#[test]
fn bindgen_test_layout_ibv_qp() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp>(),
116usize,
concat!("Size of: ", stringify!(ibv_qp))
);
assert_eq!(
::std::mem::align_of::<ibv_qp>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_context) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(qp_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).send_cq) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(send_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recv_cq) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(recv_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).srq) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_num) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(qp_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_type) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(qp_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mutex) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cond) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).events_completed) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp),
"::",
stringify!(events_completed)
)
);
}
impl Default for ibv_qp {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_qp_ex {
pub qp_base: ibv_qp,
pub comp_mask: u64,
pub wr_id: u64,
pub wr_flags: ::std::os::raw::c_uint,
pub wr_atomic_cmp_swp: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp_ex,
rkey: u32,
remote_addr: u64,
compare: u64,
swap: u64,
),
>,
pub wr_atomic_fetch_add: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, rkey: u32, remote_addr: u64, add: u64),
>,
pub wr_bind_mw: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp_ex,
mw: *mut ibv_mw,
rkey: u32,
bind_info: *const ibv_mw_bind_info,
),
>,
pub wr_local_inv:
::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex, invalidate_rkey: u32)>,
pub wr_rdma_read: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, rkey: u32, remote_addr: u64),
>,
pub wr_rdma_write: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, rkey: u32, remote_addr: u64),
>,
pub wr_rdma_write_imm: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, rkey: u32, remote_addr: u64, imm_data: __be32),
>,
pub wr_send: ::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex)>,
pub wr_send_imm:
::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex, imm_data: __be32)>,
pub wr_send_inv:
::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex, invalidate_rkey: u32)>,
pub wr_send_tso: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp_ex,
hdr: *mut ::std::os::raw::c_void,
hdr_sz: u16,
mss: u16,
),
>,
pub wr_set_ud_addr: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp_ex,
ah: *mut ibv_ah,
remote_qpn: u32,
remote_qkey: u32,
),
>,
pub wr_set_xrc_srqn:
::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex, remote_srqn: u32)>,
pub wr_set_inline_data: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, addr: *mut ::std::os::raw::c_void, length: usize),
>,
pub wr_set_inline_data_list: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, num_buf: usize, buf_list: *const ibv_data_buf),
>,
pub wr_set_sge: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, lkey: u32, addr: u64, length: u32),
>,
pub wr_set_sge_list: ::std::option::Option<
unsafe extern "C" fn(qp: *mut ibv_qp_ex, num_sge: usize, sg_list: *const ibv_sge),
>,
pub wr_start: ::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex)>,
pub wr_complete:
::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex) -> ::std::os::raw::c_int>,
pub wr_abort: ::std::option::Option<unsafe extern "C" fn(qp: *mut ibv_qp_ex)>,
}
#[test]
fn bindgen_test_layout_ibv_qp_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_qp_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_qp_ex>(),
216usize,
concat!("Size of: ", stringify!(ibv_qp_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_qp_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_qp_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).qp_base) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(qp_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_id) as usize - ptr as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_flags) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_atomic_cmp_swp) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_atomic_cmp_swp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_atomic_fetch_add) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_atomic_fetch_add)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_bind_mw) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_bind_mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_local_inv) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_local_inv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_rdma_read) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_rdma_read)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_rdma_write) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_rdma_write)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_rdma_write_imm) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_rdma_write_imm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_send) as usize - ptr as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_send)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_send_imm) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_send_imm)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_send_inv) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_send_inv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_send_tso) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_send_tso)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_set_ud_addr) as usize - ptr as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_set_ud_addr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_set_xrc_srqn) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_set_xrc_srqn)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_set_inline_data) as usize - ptr as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_set_inline_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_set_inline_data_list) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_set_inline_data_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_set_sge) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_set_sge)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_set_sge_list) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_set_sge_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_start) as usize - ptr as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_complete) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_complete)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_abort) as usize - ptr as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(ibv_qp_ex),
"::",
stringify!(wr_abort)
)
);
}
impl Default for ibv_qp_ex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn ibv_qp_to_qp_ex(qp: *mut ibv_qp) -> *mut ibv_qp_ex;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_ece {
pub vendor_id: u32,
pub options: u32,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_ece() {
const UNINIT: ::std::mem::MaybeUninit<ibv_ece> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_ece>(),
12usize,
concat!("Size of: ", stringify!(ibv_ece))
);
assert_eq!(
::std::mem::align_of::<ibv_ece>(),
4usize,
concat!("Alignment of ", stringify!(ibv_ece))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vendor_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_ece),
"::",
stringify!(vendor_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_ece),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_ece),
"::",
stringify!(comp_mask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_comp_channel {
pub context: *mut ibv_context,
pub fd: ::std::os::raw::c_int,
pub refcnt: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_ibv_comp_channel() {
const UNINIT: ::std::mem::MaybeUninit<ibv_comp_channel> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_comp_channel>(),
12usize,
concat!("Size of: ", stringify!(ibv_comp_channel))
);
assert_eq!(
::std::mem::align_of::<ibv_comp_channel>(),
4usize,
concat!("Alignment of ", stringify!(ibv_comp_channel))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_comp_channel),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_comp_channel),
"::",
stringify!(fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refcnt) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_comp_channel),
"::",
stringify!(refcnt)
)
);
}
impl Default for ibv_comp_channel {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_cq {
pub context: *mut ibv_context,
pub channel: *mut ibv_comp_channel,
pub cq_context: *mut ::std::os::raw::c_void,
pub handle: u32,
pub cqe: ::std::os::raw::c_int,
pub mutex: pthread_mutex_t,
pub cond: pthread_cond_t,
pub comp_events_completed: u32,
pub async_events_completed: u32,
}
#[test]
fn bindgen_test_layout_ibv_cq() {
const UNINIT: ::std::mem::MaybeUninit<ibv_cq> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_cq>(),
100usize,
concat!("Size of: ", stringify!(ibv_cq))
);
assert_eq!(
::std::mem::align_of::<ibv_cq>(),
4usize,
concat!("Alignment of ", stringify!(ibv_cq))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).channel) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(channel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq_context) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(cq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cqe) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(cqe)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mutex) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cond) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_events_completed) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(comp_events_completed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).async_events_completed) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq),
"::",
stringify!(async_events_completed)
)
);
}
impl Default for ibv_cq {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_poll_cq_attr {
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_poll_cq_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_poll_cq_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_poll_cq_attr>(),
4usize,
concat!("Size of: ", stringify!(ibv_poll_cq_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_poll_cq_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_poll_cq_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_poll_cq_attr),
"::",
stringify!(comp_mask)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_wc_tm_info {
pub tag: u64,
pub priv_: u32,
}
#[test]
fn bindgen_test_layout_ibv_wc_tm_info() {
const UNINIT: ::std::mem::MaybeUninit<ibv_wc_tm_info> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_wc_tm_info>(),
12usize,
concat!("Size of: ", stringify!(ibv_wc_tm_info))
);
assert_eq!(
::std::mem::align_of::<ibv_wc_tm_info>(),
4usize,
concat!("Alignment of ", stringify!(ibv_wc_tm_info))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tag) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_wc_tm_info),
"::",
stringify!(tag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priv_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_wc_tm_info),
"::",
stringify!(priv_)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_cq_ex {
pub context: *mut ibv_context,
pub channel: *mut ibv_comp_channel,
pub cq_context: *mut ::std::os::raw::c_void,
pub handle: u32,
pub cqe: ::std::os::raw::c_int,
pub mutex: pthread_mutex_t,
pub cond: pthread_cond_t,
pub comp_events_completed: u32,
pub async_events_completed: u32,
pub comp_mask: u32,
pub status: ibv_wc_status::Type,
pub wr_id: u64,
pub start_poll: ::std::option::Option<
unsafe extern "C" fn(
current: *mut ibv_cq_ex,
attr: *mut ibv_poll_cq_attr,
) -> ::std::os::raw::c_int,
>,
pub next_poll: ::std::option::Option<
unsafe extern "C" fn(current: *mut ibv_cq_ex) -> ::std::os::raw::c_int,
>,
pub end_poll: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex)>,
pub read_opcode:
::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> ibv_wc_opcode::Type>,
pub read_vendor_err:
::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u32>,
pub read_byte_len: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u32>,
pub read_imm_data:
::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> __be32>,
pub read_qp_num: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u32>,
pub read_src_qp: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u32>,
pub read_wc_flags: ::std::option::Option<
unsafe extern "C" fn(current: *mut ibv_cq_ex) -> ::std::os::raw::c_uint,
>,
pub read_slid: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u32>,
pub read_sl: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u8>,
pub read_dlid_path_bits:
::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u8>,
pub read_completion_ts:
::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u64>,
pub read_cvlan: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u16>,
pub read_flow_tag: ::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u32>,
pub read_tm_info: ::std::option::Option<
unsafe extern "C" fn(current: *mut ibv_cq_ex, tm_info: *mut ibv_wc_tm_info),
>,
pub read_completion_wallclock_ns:
::std::option::Option<unsafe extern "C" fn(current: *mut ibv_cq_ex) -> u64>,
}
#[test]
fn bindgen_test_layout_ibv_cq_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_cq_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_cq_ex>(),
188usize,
concat!("Size of: ", stringify!(ibv_cq_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_cq_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_cq_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).channel) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(channel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq_context) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(cq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cqe) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(cqe)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mutex) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cond) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_events_completed) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(comp_events_completed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).async_events_completed) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(async_events_completed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wr_id) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(wr_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_poll) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(start_poll)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_poll) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(next_poll)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end_poll) as usize - ptr as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(end_poll)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_opcode) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_opcode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_vendor_err) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_vendor_err)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_byte_len) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_byte_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_imm_data) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_imm_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_qp_num) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_qp_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_src_qp) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_src_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_wc_flags) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_wc_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_slid) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_slid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_sl) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_sl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_dlid_path_bits) as usize - ptr as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_dlid_path_bits)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_completion_ts) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_completion_ts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_cvlan) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_cvlan)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_flow_tag) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_flow_tag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_tm_info) as usize - ptr as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_tm_info)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).read_completion_wallclock_ns) as usize - ptr as usize
},
184usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_ex),
"::",
stringify!(read_completion_wallclock_ns)
)
);
}
impl Default for ibv_cq_ex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_CQ_ATTR_MODERATE: ibv_cq_attr_mask = 1;
pub const IBV_CQ_ATTR_RESERVED: ibv_cq_attr_mask = 2;
pub type ibv_cq_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_moderate_cq {
pub cq_count: u16,
pub cq_period: u16,
}
#[test]
fn bindgen_test_layout_ibv_moderate_cq() {
const UNINIT: ::std::mem::MaybeUninit<ibv_moderate_cq> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_moderate_cq>(),
4usize,
concat!("Size of: ", stringify!(ibv_moderate_cq))
);
assert_eq!(
::std::mem::align_of::<ibv_moderate_cq>(),
2usize,
concat!("Alignment of ", stringify!(ibv_moderate_cq))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_moderate_cq),
"::",
stringify!(cq_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq_period) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ibv_moderate_cq),
"::",
stringify!(cq_period)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_modify_cq_attr {
pub attr_mask: u32,
pub moderate: ibv_moderate_cq,
}
#[test]
fn bindgen_test_layout_ibv_modify_cq_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_modify_cq_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_modify_cq_attr>(),
8usize,
concat!("Size of: ", stringify!(ibv_modify_cq_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_modify_cq_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_modify_cq_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_modify_cq_attr),
"::",
stringify!(attr_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).moderate) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_modify_cq_attr),
"::",
stringify!(moderate)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_ah {
pub context: *mut ibv_context,
pub pd: *mut ibv_pd,
pub handle: u32,
}
#[test]
fn bindgen_test_layout_ibv_ah() {
const UNINIT: ::std::mem::MaybeUninit<ibv_ah> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_ah>(),
12usize,
concat!("Size of: ", stringify!(ibv_ah))
);
assert_eq!(
::std::mem::align_of::<ibv_ah>(),
4usize,
concat!("Alignment of ", stringify!(ibv_ah))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_ah),
"::",
stringify!(handle)
)
);
}
impl Default for ibv_ah {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_FLOW_ATTR_FLAGS_DONT_TRAP: ibv_flow_flags = 2;
pub const IBV_FLOW_ATTR_FLAGS_EGRESS: ibv_flow_flags = 4;
pub type ibv_flow_flags = ::std::os::raw::c_uint;
pub const IBV_FLOW_ATTR_NORMAL: ibv_flow_attr_type = 0;
pub const IBV_FLOW_ATTR_ALL_DEFAULT: ibv_flow_attr_type = 1;
pub const IBV_FLOW_ATTR_MC_DEFAULT: ibv_flow_attr_type = 2;
pub const IBV_FLOW_ATTR_SNIFFER: ibv_flow_attr_type = 3;
pub type ibv_flow_attr_type = ::std::os::raw::c_uint;
pub const IBV_FLOW_SPEC_ETH: ibv_flow_spec_type = 32;
pub const IBV_FLOW_SPEC_IPV4: ibv_flow_spec_type = 48;
pub const IBV_FLOW_SPEC_IPV6: ibv_flow_spec_type = 49;
pub const IBV_FLOW_SPEC_IPV4_EXT: ibv_flow_spec_type = 50;
pub const IBV_FLOW_SPEC_ESP: ibv_flow_spec_type = 52;
pub const IBV_FLOW_SPEC_TCP: ibv_flow_spec_type = 64;
pub const IBV_FLOW_SPEC_UDP: ibv_flow_spec_type = 65;
pub const IBV_FLOW_SPEC_VXLAN_TUNNEL: ibv_flow_spec_type = 80;
pub const IBV_FLOW_SPEC_GRE: ibv_flow_spec_type = 81;
pub const IBV_FLOW_SPEC_MPLS: ibv_flow_spec_type = 96;
pub const IBV_FLOW_SPEC_INNER: ibv_flow_spec_type = 256;
pub const IBV_FLOW_SPEC_ACTION_TAG: ibv_flow_spec_type = 4096;
pub const IBV_FLOW_SPEC_ACTION_DROP: ibv_flow_spec_type = 4097;
pub const IBV_FLOW_SPEC_ACTION_HANDLE: ibv_flow_spec_type = 4098;
pub const IBV_FLOW_SPEC_ACTION_COUNT: ibv_flow_spec_type = 4099;
pub type ibv_flow_spec_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_eth_filter {
pub dst_mac: [u8; 6usize],
pub src_mac: [u8; 6usize],
pub ether_type: u16,
pub vlan_tag: u16,
}
#[test]
fn bindgen_test_layout_ibv_flow_eth_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_eth_filter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_eth_filter>(),
16usize,
concat!("Size of: ", stringify!(ibv_flow_eth_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_eth_filter>(),
2usize,
concat!("Alignment of ", stringify!(ibv_flow_eth_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dst_mac) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_eth_filter),
"::",
stringify!(dst_mac)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).src_mac) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_eth_filter),
"::",
stringify!(src_mac)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ether_type) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_eth_filter),
"::",
stringify!(ether_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vlan_tag) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_eth_filter),
"::",
stringify!(vlan_tag)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_eth {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_eth_filter,
pub mask: ibv_flow_eth_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_eth() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_eth> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_eth>(),
40usize,
concat!("Size of: ", stringify!(ibv_flow_spec_eth))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_eth>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_eth))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_eth),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_eth),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_eth),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_eth),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_eth {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_ipv4_filter {
pub src_ip: u32,
pub dst_ip: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_ipv4_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_ipv4_filter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_ipv4_filter>(),
8usize,
concat!("Size of: ", stringify!(ibv_flow_ipv4_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_ipv4_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_ipv4_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_filter),
"::",
stringify!(src_ip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_filter),
"::",
stringify!(dst_ip)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_ipv4 {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_ipv4_filter,
pub mask: ibv_flow_ipv4_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_ipv4() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_ipv4> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_ipv4>(),
24usize,
concat!("Size of: ", stringify!(ibv_flow_spec_ipv4))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_ipv4>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_ipv4))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_ipv4 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_ipv4_ext_filter {
pub src_ip: u32,
pub dst_ip: u32,
pub proto: u8,
pub tos: u8,
pub ttl: u8,
pub flags: u8,
}
#[test]
fn bindgen_test_layout_ibv_flow_ipv4_ext_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_ipv4_ext_filter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_ipv4_ext_filter>(),
12usize,
concat!("Size of: ", stringify!(ibv_flow_ipv4_ext_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_ipv4_ext_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_ipv4_ext_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_ext_filter),
"::",
stringify!(src_ip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_ext_filter),
"::",
stringify!(dst_ip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).proto) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_ext_filter),
"::",
stringify!(proto)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tos) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_ext_filter),
"::",
stringify!(tos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ttl) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_ext_filter),
"::",
stringify!(ttl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv4_ext_filter),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_ipv4_ext {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_ipv4_ext_filter,
pub mask: ibv_flow_ipv4_ext_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_ipv4_ext() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_ipv4_ext> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_ipv4_ext>(),
32usize,
concat!("Size of: ", stringify!(ibv_flow_spec_ipv4_ext))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_ipv4_ext>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_ipv4_ext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4_ext),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4_ext),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4_ext),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv4_ext),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_ipv4_ext {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_ipv6_filter {
pub src_ip: [u8; 16usize],
pub dst_ip: [u8; 16usize],
pub flow_label: u32,
pub next_hdr: u8,
pub traffic_class: u8,
pub hop_limit: u8,
}
#[test]
fn bindgen_test_layout_ibv_flow_ipv6_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_ipv6_filter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_ipv6_filter>(),
40usize,
concat!("Size of: ", stringify!(ibv_flow_ipv6_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_ipv6_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_ipv6_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).src_ip) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv6_filter),
"::",
stringify!(src_ip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dst_ip) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv6_filter),
"::",
stringify!(dst_ip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flow_label) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv6_filter),
"::",
stringify!(flow_label)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next_hdr) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv6_filter),
"::",
stringify!(next_hdr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).traffic_class) as usize - ptr as usize },
37usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv6_filter),
"::",
stringify!(traffic_class)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hop_limit) as usize - ptr as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_ipv6_filter),
"::",
stringify!(hop_limit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_ipv6 {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_ipv6_filter,
pub mask: ibv_flow_ipv6_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_ipv6() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_ipv6> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_ipv6>(),
88usize,
concat!("Size of: ", stringify!(ibv_flow_spec_ipv6))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_ipv6>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_ipv6))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv6),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv6),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv6),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_ipv6),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_ipv6 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_esp_filter {
pub spi: u32,
pub seq: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_esp_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_esp_filter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_esp_filter>(),
8usize,
concat!("Size of: ", stringify!(ibv_flow_esp_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_esp_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_esp_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).spi) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_esp_filter),
"::",
stringify!(spi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).seq) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_esp_filter),
"::",
stringify!(seq)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_esp {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_esp_filter,
pub mask: ibv_flow_esp_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_esp() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_esp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_esp>(),
24usize,
concat!("Size of: ", stringify!(ibv_flow_spec_esp))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_esp>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_esp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_esp),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_esp),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_esp),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_esp),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_esp {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_tcp_udp_filter {
pub dst_port: u16,
pub src_port: u16,
}
#[test]
fn bindgen_test_layout_ibv_flow_tcp_udp_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_tcp_udp_filter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_tcp_udp_filter>(),
4usize,
concat!("Size of: ", stringify!(ibv_flow_tcp_udp_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_tcp_udp_filter>(),
2usize,
concat!("Alignment of ", stringify!(ibv_flow_tcp_udp_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dst_port) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_tcp_udp_filter),
"::",
stringify!(dst_port)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).src_port) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_tcp_udp_filter),
"::",
stringify!(src_port)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_tcp_udp {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_tcp_udp_filter,
pub mask: ibv_flow_tcp_udp_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_tcp_udp() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_tcp_udp> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_tcp_udp>(),
16usize,
concat!("Size of: ", stringify!(ibv_flow_spec_tcp_udp))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_tcp_udp>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_tcp_udp))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tcp_udp),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tcp_udp),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tcp_udp),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tcp_udp),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_tcp_udp {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_gre_filter {
pub c_ks_res0_ver: u16,
pub protocol: u16,
pub key: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_gre_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_gre_filter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_gre_filter>(),
8usize,
concat!("Size of: ", stringify!(ibv_flow_gre_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_gre_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_gre_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).c_ks_res0_ver) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_gre_filter),
"::",
stringify!(c_ks_res0_ver)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).protocol) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_gre_filter),
"::",
stringify!(protocol)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_gre_filter),
"::",
stringify!(key)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_gre {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_gre_filter,
pub mask: ibv_flow_gre_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_gre() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_gre> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_gre>(),
24usize,
concat!("Size of: ", stringify!(ibv_flow_spec_gre))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_gre>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_gre))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_gre),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_gre),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_gre),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_gre),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_gre {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_mpls_filter {
pub label: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_mpls_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_mpls_filter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_mpls_filter>(),
4usize,
concat!("Size of: ", stringify!(ibv_flow_mpls_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_mpls_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_mpls_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_mpls_filter),
"::",
stringify!(label)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_mpls {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_mpls_filter,
pub mask: ibv_flow_mpls_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_mpls() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_mpls> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_mpls>(),
16usize,
concat!("Size of: ", stringify!(ibv_flow_spec_mpls))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_mpls>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_mpls))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_mpls),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_mpls),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_mpls),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_mpls),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_mpls {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_flow_tunnel_filter {
pub tunnel_id: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_tunnel_filter() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_tunnel_filter> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_tunnel_filter>(),
4usize,
concat!("Size of: ", stringify!(ibv_flow_tunnel_filter))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_tunnel_filter>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_tunnel_filter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tunnel_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_tunnel_filter),
"::",
stringify!(tunnel_id)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_tunnel {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub val: ibv_flow_tunnel_filter,
pub mask: ibv_flow_tunnel_filter,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_tunnel() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_tunnel> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_tunnel>(),
16usize,
concat!("Size of: ", stringify!(ibv_flow_spec_tunnel))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_tunnel>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_tunnel))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tunnel),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tunnel),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tunnel),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_tunnel),
"::",
stringify!(mask)
)
);
}
impl Default for ibv_flow_spec_tunnel {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_action_tag {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub tag_id: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_action_tag() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_action_tag> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_action_tag>(),
12usize,
concat!("Size of: ", stringify!(ibv_flow_spec_action_tag))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_action_tag>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_action_tag))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_tag),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_tag),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tag_id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_tag),
"::",
stringify!(tag_id)
)
);
}
impl Default for ibv_flow_spec_action_tag {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_action_drop {
pub type_: ibv_flow_spec_type,
pub size: u16,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_action_drop() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_action_drop> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_action_drop>(),
8usize,
concat!("Size of: ", stringify!(ibv_flow_spec_action_drop))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_action_drop>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_action_drop))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_drop),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_drop),
"::",
stringify!(size)
)
);
}
impl Default for ibv_flow_spec_action_drop {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_action_handle {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub action: *const ibv_flow_action,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_action_handle() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_action_handle> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_action_handle>(),
12usize,
concat!("Size of: ", stringify!(ibv_flow_spec_action_handle))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_action_handle>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_action_handle))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_handle),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_handle),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_action_handle),
"::",
stringify!(action)
)
);
}
impl Default for ibv_flow_spec_action_handle {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec_counter_action {
pub type_: ibv_flow_spec_type,
pub size: u16,
pub counters: *mut ibv_counters,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec_counter_action() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec_counter_action> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec_counter_action>(),
12usize,
concat!("Size of: ", stringify!(ibv_flow_spec_counter_action))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec_counter_action>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec_counter_action))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_counter_action),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_counter_action),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).counters) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec_counter_action),
"::",
stringify!(counters)
)
);
}
impl Default for ibv_flow_spec_counter_action {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_flow_spec {
pub __bindgen_anon_1: ibv_flow_spec__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ibv_flow_spec__bindgen_ty_1 {
pub hdr: ibv_flow_spec__bindgen_ty_1__bindgen_ty_1,
pub eth: ibv_flow_spec_eth,
pub ipv4: ibv_flow_spec_ipv4,
pub tcp_udp: ibv_flow_spec_tcp_udp,
pub ipv4_ext: ibv_flow_spec_ipv4_ext,
pub ipv6: ibv_flow_spec_ipv6,
pub esp: ibv_flow_spec_esp,
pub tunnel: ibv_flow_spec_tunnel,
pub gre: ibv_flow_spec_gre,
pub mpls: ibv_flow_spec_mpls,
pub flow_tag: ibv_flow_spec_action_tag,
pub drop: ibv_flow_spec_action_drop,
pub handle: ibv_flow_spec_action_handle,
pub flow_count: ibv_flow_spec_counter_action,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_spec__bindgen_ty_1__bindgen_ty_1 {
pub type_: ibv_flow_spec_type,
pub size: u16,
}
#[test]
fn bindgen_test_layout_ibv_flow_spec__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(ibv_flow_spec__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ibv_flow_spec__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(size)
)
);
}
impl Default for ibv_flow_spec__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_flow_spec__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_spec__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_spec__bindgen_ty_1>(),
88usize,
concat!("Size of: ", stringify!(ibv_flow_spec__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).eth) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(eth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ipv4) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(ipv4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tcp_udp) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(tcp_udp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ipv4_ext) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(ipv4_ext)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ipv6) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(ipv6)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).esp) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(esp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tunnel) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(tunnel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gre) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(gre)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mpls) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(mpls)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flow_tag) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(flow_tag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drop) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(drop)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flow_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_spec__bindgen_ty_1),
"::",
stringify!(flow_count)
)
);
}
impl Default for ibv_flow_spec__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn bindgen_test_layout_ibv_flow_spec() {
assert_eq!(
::std::mem::size_of::<ibv_flow_spec>(),
88usize,
concat!("Size of: ", stringify!(ibv_flow_spec))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_spec>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_spec))
);
}
impl Default for ibv_flow_spec {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_attr {
pub comp_mask: u32,
pub type_: ibv_flow_attr_type,
pub size: u16,
pub priority: u16,
pub num_of_specs: u8,
pub port: u8,
pub flags: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_attr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_attr>(),
20usize,
concat!("Size of: ", stringify!(ibv_flow_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).priority) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(priority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_of_specs) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(num_of_specs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_attr),
"::",
stringify!(flags)
)
);
}
impl Default for ibv_flow_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow {
pub comp_mask: u32,
pub context: *mut ibv_context,
pub handle: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow>(),
12usize,
concat!("Size of: ", stringify!(ibv_flow))
);
assert_eq!(
::std::mem::align_of::<ibv_flow>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow),
"::",
stringify!(handle)
)
);
}
impl Default for ibv_flow {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_action {
pub context: *mut ibv_context,
}
#[test]
fn bindgen_test_layout_ibv_flow_action() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_action> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_action>(),
4usize,
concat!("Size of: ", stringify!(ibv_flow_action))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_action>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_action))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action),
"::",
stringify!(context)
)
);
}
impl Default for ibv_flow_action {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_FLOW_ACTION_ESP_MASK_ESN: ibv_flow_action_esp_mask = 1;
pub type ibv_flow_action_esp_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_flow_action_esp_attr {
pub esp_attr: *mut ib_uverbs_flow_action_esp,
pub keymat_proto: ib_uverbs_flow_action_esp_keymat,
pub keymat_len: u16,
pub keymat_ptr: *mut ::std::os::raw::c_void,
pub replay_proto: ib_uverbs_flow_action_esp_replay,
pub replay_len: u16,
pub replay_ptr: *mut ::std::os::raw::c_void,
pub esp_encap: *mut ib_uverbs_flow_action_esp_encap,
pub comp_mask: u32,
pub esn: u32,
}
#[test]
fn bindgen_test_layout_ibv_flow_action_esp_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_flow_action_esp_attr> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_flow_action_esp_attr>(),
40usize,
concat!("Size of: ", stringify!(ibv_flow_action_esp_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_flow_action_esp_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_flow_action_esp_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).esp_attr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(esp_attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keymat_proto) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(keymat_proto)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keymat_len) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(keymat_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keymat_ptr) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(keymat_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).replay_proto) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(replay_proto)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).replay_len) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(replay_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).replay_ptr) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(replay_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).esp_encap) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(esp_encap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).esn) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_flow_action_esp_attr),
"::",
stringify!(esn)
)
);
}
impl Default for ibv_flow_action_esp_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _ibv_device_ops {
pub _dummy1: ::std::option::Option<
unsafe extern "C" fn(
device: *mut ibv_device,
cmd_fd: ::std::os::raw::c_int,
) -> *mut ibv_context,
>,
pub _dummy2: ::std::option::Option<unsafe extern "C" fn(context: *mut ibv_context)>,
}
#[test]
fn bindgen_test_layout__ibv_device_ops() {
const UNINIT: ::std::mem::MaybeUninit<_ibv_device_ops> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_ibv_device_ops>(),
8usize,
concat!("Size of: ", stringify!(_ibv_device_ops))
);
assert_eq!(
::std::mem::align_of::<_ibv_device_ops>(),
4usize,
concat!("Alignment of ", stringify!(_ibv_device_ops))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._dummy1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ibv_device_ops),
"::",
stringify!(_dummy1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._dummy2) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ibv_device_ops),
"::",
stringify!(_dummy2)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_device {
pub _ops: _ibv_device_ops,
pub node_type: ibv_node_type,
pub transport_type: ibv_transport_type,
pub name: [::std::os::raw::c_char; 64usize],
pub dev_name: [::std::os::raw::c_char; 64usize],
pub dev_path: [::std::os::raw::c_char; 256usize],
pub ibdev_path: [::std::os::raw::c_char; 256usize],
}
#[test]
fn bindgen_test_layout_ibv_device() {
const UNINIT: ::std::mem::MaybeUninit<ibv_device> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_device>(),
656usize,
concat!("Size of: ", stringify!(ibv_device))
);
assert_eq!(
::std::mem::align_of::<ibv_device>(),
4usize,
concat!("Alignment of ", stringify!(ibv_device))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._ops) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(_ops)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node_type) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(node_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).transport_type) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(transport_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dev_name) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(dev_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dev_path) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(dev_path)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ibdev_path) as usize - ptr as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(ibv_device),
"::",
stringify!(ibdev_path)
)
);
}
impl Default for ibv_device {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _compat_ibv_port_attr {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_context_ops {
pub _compat_query_device: ::std::option::Option<
unsafe extern "C" fn(
context: *mut ibv_context,
device_attr: *mut ibv_device_attr,
) -> ::std::os::raw::c_int,
>,
pub _compat_query_port: ::std::option::Option<
unsafe extern "C" fn(
context: *mut ibv_context,
port_num: u8,
port_attr: *mut _compat_ibv_port_attr,
) -> ::std::os::raw::c_int,
>,
pub _compat_alloc_pd:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_dealloc_pd:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_reg_mr:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_rereg_mr:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_dereg_mr:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub alloc_mw: ::std::option::Option<
unsafe extern "C" fn(pd: *mut ibv_pd, type_: ibv_mw_type) -> *mut ibv_mw,
>,
pub bind_mw: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp,
mw: *mut ibv_mw,
mw_bind: *mut ibv_mw_bind,
) -> ::std::os::raw::c_int,
>,
pub dealloc_mw:
::std::option::Option<unsafe extern "C" fn(mw: *mut ibv_mw) -> ::std::os::raw::c_int>,
pub _compat_create_cq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub poll_cq: ::std::option::Option<
unsafe extern "C" fn(
cq: *mut ibv_cq,
num_entries: ::std::os::raw::c_int,
wc: *mut ibv_wc,
) -> ::std::os::raw::c_int,
>,
pub req_notify_cq: ::std::option::Option<
unsafe extern "C" fn(
cq: *mut ibv_cq,
solicited_only: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
pub _compat_cq_event:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_resize_cq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_destroy_cq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_create_srq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_modify_srq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_query_srq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_destroy_srq:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub post_srq_recv: ::std::option::Option<
unsafe extern "C" fn(
srq: *mut ibv_srq,
recv_wr: *mut ibv_recv_wr,
bad_recv_wr: *mut *mut ibv_recv_wr,
) -> ::std::os::raw::c_int,
>,
pub _compat_create_qp:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_query_qp:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_modify_qp:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_destroy_qp:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub post_send: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp,
wr: *mut ibv_send_wr,
bad_wr: *mut *mut ibv_send_wr,
) -> ::std::os::raw::c_int,
>,
pub post_recv: ::std::option::Option<
unsafe extern "C" fn(
qp: *mut ibv_qp,
wr: *mut ibv_recv_wr,
bad_wr: *mut *mut ibv_recv_wr,
) -> ::std::os::raw::c_int,
>,
pub _compat_create_ah:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_destroy_ah:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_attach_mcast:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_detach_mcast:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
pub _compat_async_event:
::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>,
}
#[test]
fn bindgen_test_layout_ibv_context_ops() {
const UNINIT: ::std::mem::MaybeUninit<ibv_context_ops> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_context_ops>(),
128usize,
concat!("Size of: ", stringify!(ibv_context_ops))
);
assert_eq!(
::std::mem::align_of::<ibv_context_ops>(),
4usize,
concat!("Alignment of ", stringify!(ibv_context_ops))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_query_device) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_query_device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_query_port) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_query_port)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_alloc_pd) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_alloc_pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_dealloc_pd) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_dealloc_pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_reg_mr) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_reg_mr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_rereg_mr) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_rereg_mr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_dereg_mr) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_dereg_mr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc_mw) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(alloc_mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bind_mw) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(bind_mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dealloc_mw) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(dealloc_mw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_create_cq) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_create_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).poll_cq) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(poll_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).req_notify_cq) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(req_notify_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_cq_event) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_cq_event)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_resize_cq) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_resize_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_destroy_cq) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_destroy_cq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_create_srq) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_create_srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_modify_srq) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_modify_srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_query_srq) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_query_srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_destroy_srq) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_destroy_srq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).post_srq_recv) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(post_srq_recv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_create_qp) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_create_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_query_qp) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_query_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_modify_qp) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_modify_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_destroy_qp) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_destroy_qp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).post_send) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(post_send)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).post_recv) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(post_recv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_create_ah) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_create_ah)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_destroy_ah) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_destroy_ah)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_attach_mcast) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_attach_mcast)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_detach_mcast) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_detach_mcast)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._compat_async_event) as usize - ptr as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(ibv_context_ops),
"::",
stringify!(_compat_async_event)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ibv_context {
pub device: *mut ibv_device,
pub ops: ibv_context_ops,
pub cmd_fd: ::std::os::raw::c_int,
pub async_fd: ::std::os::raw::c_int,
pub num_comp_vectors: ::std::os::raw::c_int,
pub mutex: pthread_mutex_t,
pub abi_compat: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_ibv_context() {
const UNINIT: ::std::mem::MaybeUninit<ibv_context> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_context>(),
172usize,
concat!("Size of: ", stringify!(ibv_context))
);
assert_eq!(
::std::mem::align_of::<ibv_context>(),
4usize,
concat!("Alignment of ", stringify!(ibv_context))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).device) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(ops)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cmd_fd) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(cmd_fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).async_fd) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(async_fd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_comp_vectors) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(num_comp_vectors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mutex) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(mutex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).abi_compat) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(ibv_context),
"::",
stringify!(abi_compat)
)
);
}
impl Default for ibv_context {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_CQ_INIT_ATTR_MASK_FLAGS: ibv_cq_init_attr_mask = 1;
pub const IBV_CQ_INIT_ATTR_MASK_PD: ibv_cq_init_attr_mask = 2;
pub type ibv_cq_init_attr_mask = ::std::os::raw::c_uint;
pub const IBV_CREATE_CQ_ATTR_SINGLE_THREADED: ibv_create_cq_attr_flags = 1;
pub const IBV_CREATE_CQ_ATTR_IGNORE_OVERRUN: ibv_create_cq_attr_flags = 2;
pub type ibv_create_cq_attr_flags = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_cq_init_attr_ex {
pub cqe: u32,
pub cq_context: *mut ::std::os::raw::c_void,
pub channel: *mut ibv_comp_channel,
pub comp_vector: u32,
pub wc_flags: u64,
pub comp_mask: u32,
pub flags: u32,
pub parent_domain: *mut ibv_pd,
}
#[test]
fn bindgen_test_layout_ibv_cq_init_attr_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_cq_init_attr_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_cq_init_attr_ex>(),
36usize,
concat!("Size of: ", stringify!(ibv_cq_init_attr_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_cq_init_attr_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_cq_init_attr_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cqe) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(cqe)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cq_context) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(cq_context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).channel) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(channel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_vector) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(comp_vector)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wc_flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(wc_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent_domain) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ibv_cq_init_attr_ex),
"::",
stringify!(parent_domain)
)
);
}
impl Default for ibv_cq_init_attr_ex {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_PARENT_DOMAIN_INIT_ATTR_ALLOCATORS: ibv_parent_domain_init_attr_mask = 1;
pub const IBV_PARENT_DOMAIN_INIT_ATTR_PD_CONTEXT: ibv_parent_domain_init_attr_mask = 2;
pub type ibv_parent_domain_init_attr_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_parent_domain_init_attr {
pub pd: *mut ibv_pd,
pub td: *mut ibv_td,
pub comp_mask: u32,
pub alloc: ::std::option::Option<
unsafe extern "C" fn(
pd: *mut ibv_pd,
pd_context: *mut ::std::os::raw::c_void,
size: usize,
alignment: usize,
resource_type: u64,
) -> *mut ::std::os::raw::c_void,
>,
pub free: ::std::option::Option<
unsafe extern "C" fn(
pd: *mut ibv_pd,
pd_context: *mut ::std::os::raw::c_void,
ptr: *mut ::std::os::raw::c_void,
resource_type: u64,
),
>,
pub pd_context: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_ibv_parent_domain_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_parent_domain_init_attr> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_parent_domain_init_attr>(),
24usize,
concat!("Size of: ", stringify!(ibv_parent_domain_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_parent_domain_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_parent_domain_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_parent_domain_init_attr),
"::",
stringify!(pd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_parent_domain_init_attr),
"::",
stringify!(td)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_parent_domain_init_attr),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ibv_parent_domain_init_attr),
"::",
stringify!(alloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ibv_parent_domain_init_attr),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pd_context) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ibv_parent_domain_init_attr),
"::",
stringify!(pd_context)
)
);
}
impl Default for ibv_parent_domain_init_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_counters_init_attr {
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_counters_init_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_counters_init_attr> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_counters_init_attr>(),
4usize,
concat!("Size of: ", stringify!(ibv_counters_init_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_counters_init_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_counters_init_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_counters_init_attr),
"::",
stringify!(comp_mask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_counters {
pub context: *mut ibv_context,
}
#[test]
fn bindgen_test_layout_ibv_counters() {
const UNINIT: ::std::mem::MaybeUninit<ibv_counters> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_counters>(),
4usize,
concat!("Size of: ", stringify!(ibv_counters))
);
assert_eq!(
::std::mem::align_of::<ibv_counters>(),
4usize,
concat!("Alignment of ", stringify!(ibv_counters))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_counters),
"::",
stringify!(context)
)
);
}
impl Default for ibv_counters {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_COUNTER_PACKETS: ibv_counter_description = 0;
pub const IBV_COUNTER_BYTES: ibv_counter_description = 1;
pub type ibv_counter_description = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ibv_counter_attach_attr {
pub counter_desc: ibv_counter_description,
pub index: u32,
pub comp_mask: u32,
}
#[test]
fn bindgen_test_layout_ibv_counter_attach_attr() {
const UNINIT: ::std::mem::MaybeUninit<ibv_counter_attach_attr> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_counter_attach_attr>(),
12usize,
concat!("Size of: ", stringify!(ibv_counter_attach_attr))
);
assert_eq!(
::std::mem::align_of::<ibv_counter_attach_attr>(),
4usize,
concat!("Alignment of ", stringify!(ibv_counter_attach_attr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).counter_desc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_counter_attach_attr),
"::",
stringify!(counter_desc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_counter_attach_attr),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ibv_counter_attach_attr),
"::",
stringify!(comp_mask)
)
);
}
impl Default for ibv_counter_attach_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const IBV_READ_COUNTERS_ATTR_PREFER_CACHED: ibv_read_counters_flags = 1;
pub type ibv_read_counters_flags = ::std::os::raw::c_uint;
pub const IBV_VALUES_MASK_RAW_CLOCK: ibv_values_mask = 1;
pub const IBV_VALUES_MASK_RESERVED: ibv_values_mask = 2;
pub type ibv_values_mask = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ibv_values_ex {
pub comp_mask: u32,
pub raw_clock: timespec,
}
#[test]
fn bindgen_test_layout_ibv_values_ex() {
const UNINIT: ::std::mem::MaybeUninit<ibv_values_ex> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ibv_values_ex>(),
12usize,
concat!("Size of: ", stringify!(ibv_values_ex))
);
assert_eq!(
::std::mem::align_of::<ibv_values_ex>(),
4usize,
concat!("Alignment of ", stringify!(ibv_values_ex))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp_mask) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ibv_values_ex),
"::",
stringify!(comp_mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw_clock) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ibv_values_ex),
"::",
stringify!(raw_clock)
)
);
}
extern "C" {
#[doc = " ibv_get_device_list - Get list of IB devices currently available\n @num_devices: optional. if non-NULL, set to the number of devices\n returned in the array.\n\n Return a NULL-terminated array of IB devices. The array can be\n released with ibv_free_device_list()."]
pub fn ibv_get_device_list(num_devices: *mut ::std::os::raw::c_int) -> *mut *mut ibv_device;
}
extern "C" {
#[doc = " ibv_free_device_list - Free list from ibv_get_device_list()\n\n Free an array of devices returned from ibv_get_device_list(). Once\n the array is freed, pointers to devices that were not opened with\n ibv_open_device() are no longer valid. Client code must open all\n devices it intends to use before calling ibv_free_device_list()."]
pub fn ibv_free_device_list(list: *mut *mut ibv_device);
}
extern "C" {
#[doc = " ibv_get_device_name - Return kernel device name"]
pub fn ibv_get_device_name(device: *mut ibv_device) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " ibv_get_device_index - Return kernel device index\n\n Available for the kernel with support of IB device query\n over netlink interface. For the unsupported kernels, the\n relevant -1 will be returned."]
pub fn ibv_get_device_index(device: *mut ibv_device) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_get_device_guid - Return device's node GUID"]
pub fn ibv_get_device_guid(device: *mut ibv_device) -> __be64;
}
extern "C" {
#[doc = " ibv_open_device - Initialize device for use"]
pub fn ibv_open_device(device: *mut ibv_device) -> *mut ibv_context;
}
extern "C" {
#[doc = " ibv_close_device - Release device"]
pub fn ibv_close_device(context: *mut ibv_context) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_import_device - Import device"]
pub fn ibv_import_device(cmd_fd: ::std::os::raw::c_int) -> *mut ibv_context;
}
extern "C" {
#[doc = " ibv_import_pd - Import a protetion domain"]
pub fn ibv_import_pd(context: *mut ibv_context, pd_handle: u32) -> *mut ibv_pd;
}
extern "C" {
#[doc = " ibv_unimport_pd - Unimport a protetion domain"]
pub fn ibv_unimport_pd(pd: *mut ibv_pd);
}
extern "C" {
#[doc = " ibv_import_mr - Import a memory region"]
pub fn ibv_import_mr(pd: *mut ibv_pd, mr_handle: u32) -> *mut ibv_mr;
}
extern "C" {
#[doc = " ibv_unimport_mr - Unimport a memory region"]
pub fn ibv_unimport_mr(mr: *mut ibv_mr);
}
extern "C" {
#[doc = " ibv_get_async_event - Get next async event\n @event: Pointer to use to return async event\n\n All async events returned by ibv_get_async_event() must eventually\n be acknowledged with ibv_ack_async_event()."]
pub fn ibv_get_async_event(
context: *mut ibv_context,
event: *mut ibv_async_event,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_ack_async_event - Acknowledge an async event\n @event: Event to be acknowledged.\n\n All async events which are returned by ibv_get_async_event() must\n be acknowledged. To avoid races, destroying an object (CQ, SRQ or\n QP) will wait for all affiliated events to be acknowledged, so\n there should be a one-to-one correspondence between acks and\n successful gets."]
pub fn ibv_ack_async_event(event: *mut ibv_async_event);
}
extern "C" {
#[doc = " ibv_query_device - Get device properties"]
pub fn ibv_query_device(
context: *mut ibv_context,
device_attr: *mut ibv_device_attr,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_query_port - Get port properties"]
pub fn ibv_query_port(
context: *mut ibv_context,
port_num: u8,
port_attr: *mut _compat_ibv_port_attr,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_query_gid - Get a GID table entry"]
pub fn ibv_query_gid(
context: *mut ibv_context,
port_num: u8,
index: ::std::os::raw::c_int,
gid: *mut ibv_gid,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_query_pkey - Get a P_Key table entry"]
pub fn ibv_query_pkey(
context: *mut ibv_context,
port_num: u8,
index: ::std::os::raw::c_int,
pkey: *mut __be16,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_get_pkey_index - Translate a P_Key into a P_Key index"]
pub fn ibv_get_pkey_index(
context: *mut ibv_context,
port_num: u8,
pkey: __be16,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_alloc_pd - Allocate a protection domain"]
pub fn ibv_alloc_pd(context: *mut ibv_context) -> *mut ibv_pd;
}
extern "C" {
#[doc = " ibv_dealloc_pd - Free a protection domain"]
pub fn ibv_dealloc_pd(pd: *mut ibv_pd) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_reg_mr_iova2 - Register memory region with a virtual offset address\n\n This version will be called if ibv_reg_mr or ibv_reg_mr_iova were called\n with at least one potential access flag from the IBV_OPTIONAL_ACCESS_RANGE\n flags range The optional access flags will be masked if running over kernel\n that does not support passing them."]
pub fn ibv_reg_mr_iova2(
pd: *mut ibv_pd,
addr: *mut ::std::os::raw::c_void,
length: usize,
iova: u64,
access: ::std::os::raw::c_uint,
) -> *mut ibv_mr;
}
extern "C" {
#[doc = " ibv_reg_mr - Register a memory region"]
pub fn ibv_reg_mr(
pd: *mut ibv_pd,
addr: *mut ::std::os::raw::c_void,
length: usize,
access: ::std::os::raw::c_int,
) -> *mut ibv_mr;
}
extern "C" {
#[doc = " ibv_reg_mr_iova - Register a memory region with a virtual offset\n address"]
pub fn ibv_reg_mr_iova(
pd: *mut ibv_pd,
addr: *mut ::std::os::raw::c_void,
length: usize,
iova: u64,
access: ::std::os::raw::c_int,
) -> *mut ibv_mr;
}
extern "C" {
#[doc = " ibv_reg_dmabuf_mr - Register a dambuf-based memory region"]
pub fn ibv_reg_dmabuf_mr(
pd: *mut ibv_pd,
offset: u64,
length: usize,
iova: u64,
fd: ::std::os::raw::c_int,
access: ::std::os::raw::c_int,
) -> *mut ibv_mr;
}
pub const IBV_REREG_MR_ERR_INPUT: ibv_rereg_mr_err_code = -1;
pub const IBV_REREG_MR_ERR_DONT_FORK_NEW: ibv_rereg_mr_err_code = -2;
pub const IBV_REREG_MR_ERR_DO_FORK_OLD: ibv_rereg_mr_err_code = -3;
pub const IBV_REREG_MR_ERR_CMD: ibv_rereg_mr_err_code = -4;
pub const IBV_REREG_MR_ERR_CMD_AND_DO_FORK_NEW: ibv_rereg_mr_err_code = -5;
pub type ibv_rereg_mr_err_code = ::std::os::raw::c_int;
extern "C" {
#[doc = " ibv_rereg_mr - Re-Register a memory region"]
pub fn ibv_rereg_mr(
mr: *mut ibv_mr,
flags: ::std::os::raw::c_int,
pd: *mut ibv_pd,
addr: *mut ::std::os::raw::c_void,
length: usize,
access: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_dereg_mr - Deregister a memory region"]
pub fn ibv_dereg_mr(mr: *mut ibv_mr) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_create_comp_channel - Create a completion event channel"]
pub fn ibv_create_comp_channel(context: *mut ibv_context) -> *mut ibv_comp_channel;
}
extern "C" {
#[doc = " ibv_destroy_comp_channel - Destroy a completion event channel"]
pub fn ibv_destroy_comp_channel(channel: *mut ibv_comp_channel) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_create_cq - Create a completion queue\n @context - Context CQ will be attached to\n @cqe - Minimum number of entries required for CQ\n @cq_context - Consumer-supplied context returned for completion events\n @channel - Completion channel where completion events will be queued.\n May be NULL if completion events will not be used.\n @comp_vector - Completion vector used to signal completion events.\n Must be >= 0 and < context->num_comp_vectors."]
pub fn ibv_create_cq(
context: *mut ibv_context,
cqe: ::std::os::raw::c_int,
cq_context: *mut ::std::os::raw::c_void,
channel: *mut ibv_comp_channel,
comp_vector: ::std::os::raw::c_int,
) -> *mut ibv_cq;
}
extern "C" {
#[doc = " ibv_resize_cq - Modifies the capacity of the CQ.\n @cq: The CQ to resize.\n @cqe: The minimum size of the CQ.\n\n Users can examine the cq structure to determine the actual CQ size."]
pub fn ibv_resize_cq(cq: *mut ibv_cq, cqe: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_destroy_cq - Destroy a completion queue"]
pub fn ibv_destroy_cq(cq: *mut ibv_cq) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_get_cq_event - Read next CQ event\n @channel: Channel to get next event from.\n @cq: Used to return pointer to CQ.\n @cq_context: Used to return consumer-supplied CQ context.\n\n All completion events returned by ibv_get_cq_event() must\n eventually be acknowledged with ibv_ack_cq_events()."]
pub fn ibv_get_cq_event(
channel: *mut ibv_comp_channel,
cq: *mut *mut ibv_cq,
cq_context: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_ack_cq_events - Acknowledge CQ completion events\n @cq: CQ to acknowledge events for\n @nevents: Number of events to acknowledge.\n\n All completion events which are returned by ibv_get_cq_event() must\n be acknowledged. To avoid races, ibv_destroy_cq() will wait for\n all completion events to be acknowledged, so there should be a\n one-to-one correspondence between acks and successful gets. An\n application may accumulate multiple completion events and\n acknowledge them in a single call to ibv_ack_cq_events() by passing\n the number of events to ack in @nevents."]
pub fn ibv_ack_cq_events(cq: *mut ibv_cq, nevents: ::std::os::raw::c_uint);
}
extern "C" {
#[doc = " ibv_create_srq - Creates a SRQ associated with the specified protection\n domain.\n @pd: The protection domain associated with the SRQ.\n @srq_init_attr: A list of initial attributes required to create the SRQ.\n\n srq_attr->max_wr and srq_attr->max_sge are read the determine the\n requested size of the SRQ, and set to the actual values allocated\n on return. If ibv_create_srq() succeeds, then max_wr and max_sge\n will always be at least as large as the requested values."]
pub fn ibv_create_srq(pd: *mut ibv_pd, srq_init_attr: *mut ibv_srq_init_attr) -> *mut ibv_srq;
}
extern "C" {
#[doc = " ibv_modify_srq - Modifies the attributes for the specified SRQ.\n @srq: The SRQ to modify.\n @srq_attr: On input, specifies the SRQ attributes to modify. On output,\n the current values of selected SRQ attributes are returned.\n @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ\n are being modified.\n\n The mask may contain IBV_SRQ_MAX_WR to resize the SRQ and/or\n IBV_SRQ_LIMIT to set the SRQ's limit and request notification when\n the number of receives queued drops below the limit."]
pub fn ibv_modify_srq(
srq: *mut ibv_srq,
srq_attr: *mut ibv_srq_attr,
srq_attr_mask: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_query_srq - Returns the attribute list and current values for the\n specified SRQ.\n @srq: The SRQ to query.\n @srq_attr: The attributes of the specified SRQ."]
pub fn ibv_query_srq(srq: *mut ibv_srq, srq_attr: *mut ibv_srq_attr) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_destroy_srq - Destroys the specified SRQ.\n @srq: The SRQ to destroy."]
pub fn ibv_destroy_srq(srq: *mut ibv_srq) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_create_qp - Create a queue pair."]
pub fn ibv_create_qp(pd: *mut ibv_pd, qp_init_attr: *mut ibv_qp_init_attr) -> *mut ibv_qp;
}
extern "C" {
#[doc = " ibv_modify_qp - Modify a queue pair."]
pub fn ibv_modify_qp(
qp: *mut ibv_qp,
attr: *mut ibv_qp_attr,
attr_mask: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_query_qp - Returns the attribute list and current values for the\n specified QP.\n @qp: The QP to query.\n @attr: The attributes of the specified QP.\n @attr_mask: A bit-mask used to select specific attributes to query.\n @init_attr: Additional attributes of the selected QP.\n\n The qp_attr_mask may be used to limit the query to gathering only the\n selected attributes."]
pub fn ibv_query_qp(
qp: *mut ibv_qp,
attr: *mut ibv_qp_attr,
attr_mask: ::std::os::raw::c_int,
init_attr: *mut ibv_qp_init_attr,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_destroy_qp - Destroy a queue pair."]
pub fn ibv_destroy_qp(qp: *mut ibv_qp) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_create_ah - Create an address handle."]
pub fn ibv_create_ah(pd: *mut ibv_pd, attr: *mut ibv_ah_attr) -> *mut ibv_ah;
}
extern "C" {
#[doc = " ibv_init_ah_from_wc - Initializes address handle attributes from a\n work completion.\n @context: Device context on which the received message arrived.\n @port_num: Port on which the received message arrived.\n @wc: Work completion associated with the received message.\n @grh: References the received global route header. This parameter is\n ignored unless the work completion indicates that the GRH is valid.\n @ah_attr: Returned attributes that can be used when creating an address\n handle for replying to the message."]
pub fn ibv_init_ah_from_wc(
context: *mut ibv_context,
port_num: u8,
wc: *mut ibv_wc,
grh: *mut ibv_grh,
ah_attr: *mut ibv_ah_attr,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_create_ah_from_wc - Creates an address handle associated with the\n sender of the specified work completion.\n @pd: The protection domain associated with the address handle.\n @wc: Work completion information associated with a received message.\n @grh: References the received global route header. This parameter is\n ignored unless the work completion indicates that the GRH is valid.\n @port_num: The outbound port number to associate with the address.\n\n The address handle is used to reference a local or global destination\n in all UD QP post sends."]
pub fn ibv_create_ah_from_wc(
pd: *mut ibv_pd,
wc: *mut ibv_wc,
grh: *mut ibv_grh,
port_num: u8,
) -> *mut ibv_ah;
}
extern "C" {
#[doc = " ibv_destroy_ah - Destroy an address handle."]
pub fn ibv_destroy_ah(ah: *mut ibv_ah) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_attach_mcast - Attaches the specified QP to a multicast group.\n @qp: QP to attach to the multicast group. The QP must be a UD QP.\n @gid: Multicast group GID.\n @lid: Multicast group LID in host byte order.\n\n In order to route multicast packets correctly, subnet\n administration must have created the multicast group and configured\n the fabric appropriately. The port associated with the specified\n QP must also be a member of the multicast group."]
pub fn ibv_attach_mcast(
qp: *mut ibv_qp,
gid: *const ibv_gid,
lid: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_detach_mcast - Detaches the specified QP from a multicast group.\n @qp: QP to detach from the multicast group.\n @gid: Multicast group GID.\n @lid: Multicast group LID in host byte order."]
pub fn ibv_detach_mcast(
qp: *mut ibv_qp,
gid: *const ibv_gid,
lid: u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_fork_init - Prepare data structures so that fork() may be used\n safely. If this function is not called or returns a non-zero\n status, then libibverbs data structures are not fork()-safe and the\n effect of an application calling fork() is undefined."]
pub fn ibv_fork_init() -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_node_type_str - Return string describing node_type enum value"]
pub fn ibv_node_type_str(node_type: ibv_node_type) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " ibv_port_state_str - Return string describing port_state enum value"]
pub fn ibv_port_state_str(port_state: ibv_port_state::Type) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " ibv_event_type_str - Return string describing event_type enum value"]
pub fn ibv_event_type_str(event: ibv_event_type) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn ibv_resolve_eth_l2_from_gid(
context: *mut ibv_context,
attr: *mut ibv_ah_attr,
eth_mac: *mut u8,
vid: *mut u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_set_ece - Set ECE options"]
pub fn ibv_set_ece(qp: *mut ibv_qp, ece: *mut ibv_ece) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " ibv_query_ece - Get accepted ECE options"]
pub fn ibv_query_ece(qp: *mut ibv_qp, ece: *mut ibv_ece) -> ::std::os::raw::c_int;
}