pub const FIO_IOOPS_VERSION: i32 = 29;
pub type __uint8_t = cty::c_uchar;
pub type __uint16_t = cty::c_ushort;
pub type __uint32_t = cty::c_uint;
pub type __int64_t = cty::c_long;
pub type __uint64_t = cty::c_ulong;
pub type __off_t = cty::c_long;
pub type __off64_t = cty::c_long;
pub type __pid_t = cty::c_int;
pub type __time_t = cty::c_long;
pub type __suseconds_t = cty::c_long;
pub type __syscall_slong_t = cty::c_long;
pub type __intptr_t = cty::c_long;
pub type size_t = cty::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
assert_eq!(
::core::mem::size_of::<timespec>(),
16usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::core::mem::align_of::<timespec>(),
8usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<timespec>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
pub type pid_t = __pid_t;
pub type __cpu_mask = cty::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cpu_set_t {
pub __bits: [__cpu_mask; 16usize],
}
#[test]
fn bindgen_test_layout_cpu_set_t() {
assert_eq!(
::core::mem::size_of::<cpu_set_t>(),
128usize,
concat!("Size of: ", stringify!(cpu_set_t))
);
assert_eq!(
::core::mem::align_of::<cpu_set_t>(),
8usize,
concat!("Alignment of ", stringify!(cpu_set_t))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_set_t>())).__bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_set_t),
"::",
stringify!(__bits)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::core::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::core::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: cty::c_int,
pub __count: cty::c_uint,
pub __owner: cty::c_int,
pub __nusers: cty::c_uint,
pub __kind: cty::c_int,
pub __spins: cty::c_short,
pub __elision: cty::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::core::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::core::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
pub __g_refs: [cty::c_uint; 2usize],
pub __g_size: [cty::c_uint; 2usize],
pub __g1_orig_size: cty::c_uint,
pub __wrefs: cty::c_uint,
pub __g_signals: [cty::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
pub __wseq: cty::c_ulonglong,
pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
pub __low: cty::c_uint,
pub __high: cty::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq32)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
pub __g1_start: cty::c_ulonglong,
pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
pub __low: cty::c_uint,
pub __high: cty::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start32)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
assert_eq!(
::core::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::core::mem::align_of::<__pthread_cond_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
pub type pthread_t = cty::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [cty::c_char; 40usize],
pub __align: cty::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::core::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::core::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [cty::c_char; 48usize],
pub __align: cty::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
assert_eq!(
::core::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::core::mem::align_of::<pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
pub tv_sec: __time_t,
pub tv_usec: __suseconds_t,
}
#[test]
fn bindgen_test_layout_timeval() {
assert_eq!(
::core::mem::size_of::<timeval>(),
16usize,
concat!("Size of: ", stringify!(timeval))
);
assert_eq!(
::core::mem::align_of::<timeval>(),
8usize,
concat!("Alignment of ", stringify!(timeval))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<timeval>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<timeval>())).tv_usec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timeval),
"::",
stringify!(tv_usec)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct rusage {
pub ru_utime: timeval,
pub ru_stime: timeval,
pub __bindgen_anon_1: rusage__bindgen_ty_1,
pub __bindgen_anon_2: rusage__bindgen_ty_2,
pub __bindgen_anon_3: rusage__bindgen_ty_3,
pub __bindgen_anon_4: rusage__bindgen_ty_4,
pub __bindgen_anon_5: rusage__bindgen_ty_5,
pub __bindgen_anon_6: rusage__bindgen_ty_6,
pub __bindgen_anon_7: rusage__bindgen_ty_7,
pub __bindgen_anon_8: rusage__bindgen_ty_8,
pub __bindgen_anon_9: rusage__bindgen_ty_9,
pub __bindgen_anon_10: rusage__bindgen_ty_10,
pub __bindgen_anon_11: rusage__bindgen_ty_11,
pub __bindgen_anon_12: rusage__bindgen_ty_12,
pub __bindgen_anon_13: rusage__bindgen_ty_13,
pub __bindgen_anon_14: rusage__bindgen_ty_14,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_1 {
pub ru_maxrss: cty::c_long,
pub __ru_maxrss_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_1>())).ru_maxrss as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_1),
"::",
stringify!(ru_maxrss)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_1>())).__ru_maxrss_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_1),
"::",
stringify!(__ru_maxrss_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_2 {
pub ru_ixrss: cty::c_long,
pub __ru_ixrss_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_2>())).ru_ixrss as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_2),
"::",
stringify!(ru_ixrss)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_2>())).__ru_ixrss_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_2),
"::",
stringify!(__ru_ixrss_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_3 {
pub ru_idrss: cty::c_long,
pub __ru_idrss_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_3))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_3>())).ru_idrss as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_3),
"::",
stringify!(ru_idrss)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_3>())).__ru_idrss_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_3),
"::",
stringify!(__ru_idrss_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_4 {
pub ru_isrss: cty::c_long,
pub __ru_isrss_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_4() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_4>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_4))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_4>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_4))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_4>())).ru_isrss as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_4),
"::",
stringify!(ru_isrss)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_4>())).__ru_isrss_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_4),
"::",
stringify!(__ru_isrss_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_5 {
pub ru_minflt: cty::c_long,
pub __ru_minflt_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_5() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_5>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_5))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_5>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_5))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_5>())).ru_minflt as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_5),
"::",
stringify!(ru_minflt)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_5>())).__ru_minflt_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_5),
"::",
stringify!(__ru_minflt_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_6 {
pub ru_majflt: cty::c_long,
pub __ru_majflt_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_6() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_6>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_6))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_6>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_6))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_6>())).ru_majflt as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_6),
"::",
stringify!(ru_majflt)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_6>())).__ru_majflt_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_6),
"::",
stringify!(__ru_majflt_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_7 {
pub ru_nswap: cty::c_long,
pub __ru_nswap_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_7() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_7>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_7))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_7>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_7))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_7>())).ru_nswap as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_7),
"::",
stringify!(ru_nswap)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_7>())).__ru_nswap_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_7),
"::",
stringify!(__ru_nswap_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_8 {
pub ru_inblock: cty::c_long,
pub __ru_inblock_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_8() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_8>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_8))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_8>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_8))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_8>())).ru_inblock as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_8),
"::",
stringify!(ru_inblock)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_8>())).__ru_inblock_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_8),
"::",
stringify!(__ru_inblock_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_9 {
pub ru_oublock: cty::c_long,
pub __ru_oublock_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_9() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_9>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_9))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_9>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_9))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_9>())).ru_oublock as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_9),
"::",
stringify!(ru_oublock)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_9>())).__ru_oublock_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_9),
"::",
stringify!(__ru_oublock_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_10 {
pub ru_msgsnd: cty::c_long,
pub __ru_msgsnd_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_10() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_10>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_10))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_10>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_10))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_10>())).ru_msgsnd as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_10),
"::",
stringify!(ru_msgsnd)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_10>())).__ru_msgsnd_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_10),
"::",
stringify!(__ru_msgsnd_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_11 {
pub ru_msgrcv: cty::c_long,
pub __ru_msgrcv_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_11() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_11>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_11))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_11>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_11))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_11>())).ru_msgrcv as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_11),
"::",
stringify!(ru_msgrcv)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_11>())).__ru_msgrcv_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_11),
"::",
stringify!(__ru_msgrcv_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_12 {
pub ru_nsignals: cty::c_long,
pub __ru_nsignals_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_12() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_12>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_12))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_12>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_12))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_12>())).ru_nsignals as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_12),
"::",
stringify!(ru_nsignals)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_12>())).__ru_nsignals_word as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_12),
"::",
stringify!(__ru_nsignals_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_13 {
pub ru_nvcsw: cty::c_long,
pub __ru_nvcsw_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_13() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_13>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_13))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_13>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_13))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage__bindgen_ty_13>())).ru_nvcsw as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_13),
"::",
stringify!(ru_nvcsw)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_13>())).__ru_nvcsw_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_13),
"::",
stringify!(__ru_nvcsw_word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rusage__bindgen_ty_14 {
pub ru_nivcsw: cty::c_long,
pub __ru_nivcsw_word: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_rusage__bindgen_ty_14() {
assert_eq!(
::core::mem::size_of::<rusage__bindgen_ty_14>(),
8usize,
concat!("Size of: ", stringify!(rusage__bindgen_ty_14))
);
assert_eq!(
::core::mem::align_of::<rusage__bindgen_ty_14>(),
8usize,
concat!("Alignment of ", stringify!(rusage__bindgen_ty_14))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_14>())).ru_nivcsw as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_14),
"::",
stringify!(ru_nivcsw)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<rusage__bindgen_ty_14>())).__ru_nivcsw_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(rusage__bindgen_ty_14),
"::",
stringify!(__ru_nivcsw_word)
)
);
}
#[test]
fn bindgen_test_layout_rusage() {
assert_eq!(
::core::mem::size_of::<rusage>(),
144usize,
concat!("Size of: ", stringify!(rusage))
);
assert_eq!(
::core::mem::align_of::<rusage>(),
8usize,
concat!("Alignment of ", stringify!(rusage))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage>())).ru_utime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rusage),
"::",
stringify!(ru_utime)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rusage>())).ru_stime as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(rusage),
"::",
stringify!(ru_stime)
)
);
}
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = cty::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: cty::c_int,
pub _IO_read_ptr: *mut cty::c_char,
pub _IO_read_end: *mut cty::c_char,
pub _IO_read_base: *mut cty::c_char,
pub _IO_write_base: *mut cty::c_char,
pub _IO_write_ptr: *mut cty::c_char,
pub _IO_write_end: *mut cty::c_char,
pub _IO_buf_base: *mut cty::c_char,
pub _IO_buf_end: *mut cty::c_char,
pub _IO_save_base: *mut cty::c_char,
pub _IO_backup_base: *mut cty::c_char,
pub _IO_save_end: *mut cty::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: cty::c_int,
pub _flags2: cty::c_int,
pub _old_offset: __off_t,
pub _cur_column: cty::c_ushort,
pub _vtable_offset: cty::c_schar,
pub _shortbuf: [cty::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut cty::c_void,
pub __pad5: size_t,
pub _mode: cty::c_int,
pub _unused2: [cty::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::core::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::core::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type bool_ = cty::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sg_io_hdr {
pub interface_id: cty::c_int,
pub dxfer_direction: cty::c_int,
pub cmd_len: cty::c_uchar,
pub mx_sb_len: cty::c_uchar,
pub iovec_count: cty::c_ushort,
pub dxfer_len: cty::c_uint,
pub dxferp: *mut cty::c_void,
pub cmdp: *mut cty::c_uchar,
pub sbp: *mut cty::c_uchar,
pub timeout: cty::c_uint,
pub flags: cty::c_uint,
pub pack_id: cty::c_int,
pub usr_ptr: *mut cty::c_void,
pub status: cty::c_uchar,
pub masked_status: cty::c_uchar,
pub msg_status: cty::c_uchar,
pub sb_len_wr: cty::c_uchar,
pub host_status: cty::c_ushort,
pub driver_status: cty::c_ushort,
pub resid: cty::c_int,
pub duration: cty::c_uint,
pub info: cty::c_uint,
}
#[test]
fn bindgen_test_layout_sg_io_hdr() {
assert_eq!(
::core::mem::size_of::<sg_io_hdr>(),
88usize,
concat!("Size of: ", stringify!(sg_io_hdr))
);
assert_eq!(
::core::mem::align_of::<sg_io_hdr>(),
8usize,
concat!("Alignment of ", stringify!(sg_io_hdr))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).interface_id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(interface_id)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).dxfer_direction as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(dxfer_direction)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).cmd_len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(cmd_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).mx_sb_len as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(mx_sb_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).iovec_count as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(iovec_count)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).dxfer_len as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(dxfer_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).dxferp as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(dxferp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).cmdp as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(cmdp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).sbp as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(sbp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).timeout as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(timeout)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).flags as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).pack_id as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(pack_id)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).usr_ptr as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(usr_ptr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).status as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).masked_status as *const _ as usize },
65usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(masked_status)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).msg_status as *const _ as usize },
66usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(msg_status)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).sb_len_wr as *const _ as usize },
67usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(sb_len_wr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).host_status as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(host_status)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).driver_status as *const _ as usize },
70usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(driver_status)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).resid as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(resid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).duration as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(duration)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sg_io_hdr>())).info as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sg_io_hdr),
"::",
stringify!(info)
)
);
}
pub const DDIR_READ: fio_ddir = 0;
pub const DDIR_WRITE: fio_ddir = 1;
pub const DDIR_TRIM: fio_ddir = 2;
pub const DDIR_SYNC: fio_ddir = 3;
pub const DDIR_DATASYNC: fio_ddir = 4;
pub const DDIR_SYNC_FILE_RANGE: fio_ddir = 5;
pub const DDIR_WAIT: fio_ddir = 6;
pub const DDIR_LAST: fio_ddir = 7;
pub const DDIR_INVAL: fio_ddir = -1;
pub const DDIR_RWDIR_CNT: fio_ddir = 3;
pub const DDIR_RWDIR_SYNC_CNT: fio_ddir = 4;
pub type fio_ddir = cty::c_int;
pub const TD_DDIR_READ: td_ddir = 1;
pub const TD_DDIR_WRITE: td_ddir = 2;
pub const TD_DDIR_RAND: td_ddir = 4;
pub const TD_DDIR_TRIM: td_ddir = 8;
pub const TD_DDIR_RW: td_ddir = 3;
pub const TD_DDIR_RANDREAD: td_ddir = 5;
pub const TD_DDIR_RANDWRITE: td_ddir = 6;
pub const TD_DDIR_RANDRW: td_ddir = 7;
pub const TD_DDIR_RANDTRIM: td_ddir = 12;
pub const TD_DDIR_TRIMWRITE: td_ddir = 10;
pub type td_ddir = cty::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct flist_head {
pub next: *mut flist_head,
pub prev: *mut flist_head,
}
#[test]
fn bindgen_test_layout_flist_head() {
assert_eq!(
::core::mem::size_of::<flist_head>(),
16usize,
concat!("Size of: ", stringify!(flist_head))
);
assert_eq!(
::core::mem::align_of::<flist_head>(),
8usize,
concat!("Alignment of ", stringify!(flist_head))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<flist_head>())).next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(flist_head),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<flist_head>())).prev as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(flist_head),
"::",
stringify!(prev)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct taus88_state {
pub s1: cty::c_uint,
pub s2: cty::c_uint,
pub s3: cty::c_uint,
}
#[test]
fn bindgen_test_layout_taus88_state() {
assert_eq!(
::core::mem::size_of::<taus88_state>(),
12usize,
concat!("Size of: ", stringify!(taus88_state))
);
assert_eq!(
::core::mem::align_of::<taus88_state>(),
4usize,
concat!("Alignment of ", stringify!(taus88_state))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus88_state>())).s1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(taus88_state),
"::",
stringify!(s1)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus88_state>())).s2 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(taus88_state),
"::",
stringify!(s2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus88_state>())).s3 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(taus88_state),
"::",
stringify!(s3)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct taus258_state {
pub s1: u64,
pub s2: u64,
pub s3: u64,
pub s4: u64,
pub s5: u64,
}
#[test]
fn bindgen_test_layout_taus258_state() {
assert_eq!(
::core::mem::size_of::<taus258_state>(),
40usize,
concat!("Size of: ", stringify!(taus258_state))
);
assert_eq!(
::core::mem::align_of::<taus258_state>(),
8usize,
concat!("Alignment of ", stringify!(taus258_state))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus258_state>())).s1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(taus258_state),
"::",
stringify!(s1)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus258_state>())).s2 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(taus258_state),
"::",
stringify!(s2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus258_state>())).s3 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(taus258_state),
"::",
stringify!(s3)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus258_state>())).s4 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(taus258_state),
"::",
stringify!(s4)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<taus258_state>())).s5 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(taus258_state),
"::",
stringify!(s5)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct frand_state {
pub use64: cty::c_uint,
pub __bindgen_anon_1: frand_state__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union frand_state__bindgen_ty_1 {
pub state32: taus88_state,
pub state64: taus258_state,
}
#[test]
fn bindgen_test_layout_frand_state__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<frand_state__bindgen_ty_1>(),
40usize,
concat!("Size of: ", stringify!(frand_state__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<frand_state__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(frand_state__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<frand_state__bindgen_ty_1>())).state32 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(frand_state__bindgen_ty_1),
"::",
stringify!(state32)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<frand_state__bindgen_ty_1>())).state64 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(frand_state__bindgen_ty_1),
"::",
stringify!(state64)
)
);
}
#[test]
fn bindgen_test_layout_frand_state() {
assert_eq!(
::core::mem::size_of::<frand_state>(),
48usize,
concat!("Size of: ", stringify!(frand_state))
);
assert_eq!(
::core::mem::align_of::<frand_state>(),
8usize,
concat!("Alignment of ", stringify!(frand_state))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<frand_state>())).use64 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(frand_state),
"::",
stringify!(use64)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct zipf_state {
pub nranges: u64,
pub theta: f64,
pub zeta2: f64,
pub zetan: f64,
pub pareto_pow: f64,
pub rand: frand_state,
pub rand_off: u64,
pub disable_hash: bool_,
}
#[test]
fn bindgen_test_layout_zipf_state() {
assert_eq!(
::core::mem::size_of::<zipf_state>(),
104usize,
concat!("Size of: ", stringify!(zipf_state))
);
assert_eq!(
::core::mem::align_of::<zipf_state>(),
8usize,
concat!("Alignment of ", stringify!(zipf_state))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).nranges as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(nranges)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).theta as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(theta)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).zeta2 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(zeta2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).zetan as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(zetan)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).pareto_pow as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(pareto_pow)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).rand as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(rand)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).rand_off as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(rand_off)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zipf_state>())).disable_hash as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(zipf_state),
"::",
stringify!(disable_hash)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct axmap {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fio_lfsr {
pub xormask: u64,
pub last_val: u64,
pub cached_bit: u64,
pub max_val: u64,
pub num_vals: u64,
pub cycle_length: u64,
pub cached_cycle_length: u64,
pub spin: cty::c_uint,
}
#[test]
fn bindgen_test_layout_fio_lfsr() {
assert_eq!(
::core::mem::size_of::<fio_lfsr>(),
64usize,
concat!("Size of: ", stringify!(fio_lfsr))
);
assert_eq!(
::core::mem::align_of::<fio_lfsr>(),
8usize,
concat!("Alignment of ", stringify!(fio_lfsr))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).xormask as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(xormask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).last_val as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(last_val)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).cached_bit as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(cached_bit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).max_val as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(max_val)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).num_vals as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(num_vals)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).cycle_length as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(cycle_length)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).cached_cycle_length as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(cached_cycle_length)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_lfsr>())).spin as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(fio_lfsr),
"::",
stringify!(spin)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct gauss_state {
pub r: frand_state,
pub nranges: u64,
pub stddev: cty::c_uint,
pub rand_off: cty::c_uint,
pub disable_hash: bool_,
}
#[test]
fn bindgen_test_layout_gauss_state() {
assert_eq!(
::core::mem::size_of::<gauss_state>(),
72usize,
concat!("Size of: ", stringify!(gauss_state))
);
assert_eq!(
::core::mem::align_of::<gauss_state>(),
8usize,
concat!("Alignment of ", stringify!(gauss_state))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<gauss_state>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(gauss_state),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<gauss_state>())).nranges as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(gauss_state),
"::",
stringify!(nranges)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<gauss_state>())).stddev as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(gauss_state),
"::",
stringify!(stddev)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<gauss_state>())).rand_off as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(gauss_state),
"::",
stringify!(rand_off)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<gauss_state>())).disable_hash as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(gauss_state),
"::",
stringify!(disable_hash)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zoned_block_device_info {
_unused: [u8; 0],
}
pub const FIO_TYPE_FILE: fio_filetype = 1;
pub const FIO_TYPE_BLOCK: fio_filetype = 2;
pub const FIO_TYPE_CHAR: fio_filetype = 3;
pub const FIO_TYPE_PIPE: fio_filetype = 4;
pub type fio_filetype = cty::c_uint;
pub const FIO_FILE_open: fio_file_flags = 1;
pub const FIO_FILE_closing: fio_file_flags = 2;
pub const FIO_FILE_extend: fio_file_flags = 4;
pub const FIO_FILE_done: fio_file_flags = 8;
pub const FIO_FILE_size_known: fio_file_flags = 16;
pub const FIO_FILE_hashed: fio_file_flags = 32;
pub const FIO_FILE_partial_mmap: fio_file_flags = 64;
pub const FIO_FILE_axmap: fio_file_flags = 128;
pub const FIO_FILE_lfsr: fio_file_flags = 256;
pub const FIO_FILE_smalloc: fio_file_flags = 512;
pub type fio_file_flags = cty::c_uint;
pub const FILE_LOCK_NONE: file_lock_mode = 0;
pub const FILE_LOCK_EXCLUSIVE: file_lock_mode = 1;
pub const FILE_LOCK_READWRITE: file_lock_mode = 2;
pub type file_lock_mode = cty::c_uint;
pub const FIO_FALLOCATE_NONE: fio_fallocate_mode = 1;
pub const FIO_FALLOCATE_POSIX: fio_fallocate_mode = 2;
pub const FIO_FALLOCATE_KEEP_SIZE: fio_fallocate_mode = 3;
pub const FIO_FALLOCATE_NATIVE: fio_fallocate_mode = 4;
pub const FIO_FALLOCATE_TRUNCATE: fio_fallocate_mode = 5;
pub type fio_fallocate_mode = cty::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct fio_file {
pub hash_list: flist_head,
pub filetype: fio_filetype,
pub fd: cty::c_int,
pub shadow_fd: cty::c_int,
pub major: cty::c_uint,
pub minor: cty::c_uint,
pub fileno: cty::c_int,
pub file_name: *mut cty::c_char,
pub real_file_size: u64,
pub file_offset: u64,
pub io_size: u64,
pub zbd_info: *mut zoned_block_device_info,
pub min_zone: u32,
pub max_zone: u32,
pub last_pos: [u64; 3usize],
pub last_start: [u64; 3usize],
pub first_write: u64,
pub last_write: u64,
pub last_write_comp: *mut u64,
pub last_write_idx: cty::c_uint,
pub __bindgen_anon_1: fio_file__bindgen_ty_1,
pub __bindgen_anon_2: fio_file__bindgen_ty_2,
pub __bindgen_anon_3: fio_file__bindgen_ty_3,
pub __bindgen_anon_4: fio_file__bindgen_ty_4,
pub references: cty::c_int,
pub flags: fio_file_flags,
pub du: *mut disk_util,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union fio_file__bindgen_ty_1 {
pub engine_pos: u64,
pub engine_data: *mut cty::c_void,
}
#[test]
fn bindgen_test_layout_fio_file__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<fio_file__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(fio_file__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<fio_file__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(fio_file__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<fio_file__bindgen_ty_1>())).engine_pos as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_1),
"::",
stringify!(engine_pos)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<fio_file__bindgen_ty_1>())).engine_data as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_1),
"::",
stringify!(engine_data)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union fio_file__bindgen_ty_2 {
pub lock: *mut fio_sem,
pub rwlock: *mut fio_rwlock,
}
#[test]
fn bindgen_test_layout_fio_file__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<fio_file__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(fio_file__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<fio_file__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(fio_file__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file__bindgen_ty_2>())).lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_2),
"::",
stringify!(lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file__bindgen_ty_2>())).rwlock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_2),
"::",
stringify!(rwlock)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union fio_file__bindgen_ty_3 {
pub io_axmap: *mut axmap,
pub lfsr: fio_lfsr,
}
#[test]
fn bindgen_test_layout_fio_file__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<fio_file__bindgen_ty_3>(),
64usize,
concat!("Size of: ", stringify!(fio_file__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<fio_file__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(fio_file__bindgen_ty_3))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<fio_file__bindgen_ty_3>())).io_axmap as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_3),
"::",
stringify!(io_axmap)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file__bindgen_ty_3>())).lfsr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_3),
"::",
stringify!(lfsr)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union fio_file__bindgen_ty_4 {
pub zipf: zipf_state,
pub gauss: gauss_state,
}
#[test]
fn bindgen_test_layout_fio_file__bindgen_ty_4() {
assert_eq!(
::core::mem::size_of::<fio_file__bindgen_ty_4>(),
104usize,
concat!("Size of: ", stringify!(fio_file__bindgen_ty_4))
);
assert_eq!(
::core::mem::align_of::<fio_file__bindgen_ty_4>(),
8usize,
concat!("Alignment of ", stringify!(fio_file__bindgen_ty_4))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file__bindgen_ty_4>())).zipf as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_4),
"::",
stringify!(zipf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file__bindgen_ty_4>())).gauss as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file__bindgen_ty_4),
"::",
stringify!(gauss)
)
);
}
#[test]
fn bindgen_test_layout_fio_file() {
assert_eq!(
::core::mem::size_of::<fio_file>(),
368usize,
concat!("Size of: ", stringify!(fio_file))
);
assert_eq!(
::core::mem::align_of::<fio_file>(),
8usize,
concat!("Alignment of ", stringify!(fio_file))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).hash_list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(hash_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).filetype as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(filetype)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).fd as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(fd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).shadow_fd as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(shadow_fd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).major as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).minor as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).fileno as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(fileno)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).file_name as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(file_name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).real_file_size as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(real_file_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).file_offset as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(file_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).io_size as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(io_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).zbd_info as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(zbd_info)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).min_zone as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(min_zone)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).max_zone as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(max_zone)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).last_pos as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(last_pos)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).last_start as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(last_start)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).first_write as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(first_write)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).last_write as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(last_write)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).last_write_comp as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(last_write_comp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).last_write_idx as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(last_write_idx)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).references as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(references)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).flags as *const _ as usize },
356usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_file>())).du as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(fio_file),
"::",
stringify!(du)
)
);
}
pub type os_cpu_mask_t = cpu_set_t;
pub const FIO_OPT_INVALID: fio_opt_type = 0;
pub const FIO_OPT_STR: fio_opt_type = 1;
pub const FIO_OPT_STR_ULL: fio_opt_type = 2;
pub const FIO_OPT_STR_MULTI: fio_opt_type = 3;
pub const FIO_OPT_STR_VAL: fio_opt_type = 4;
pub const FIO_OPT_STR_VAL_TIME: fio_opt_type = 5;
pub const FIO_OPT_STR_STORE: fio_opt_type = 6;
pub const FIO_OPT_RANGE: fio_opt_type = 7;
pub const FIO_OPT_INT: fio_opt_type = 8;
pub const FIO_OPT_ULL: fio_opt_type = 9;
pub const FIO_OPT_BOOL: fio_opt_type = 10;
pub const FIO_OPT_FLOAT_LIST: fio_opt_type = 11;
pub const FIO_OPT_STR_SET: fio_opt_type = 12;
pub const FIO_OPT_STR_VAL_ZONE: fio_opt_type = 13;
pub const FIO_OPT_DEPRECATED: fio_opt_type = 14;
pub const FIO_OPT_SOFT_DEPRECATED: fio_opt_type = 15;
pub const FIO_OPT_UNSUPPORTED: fio_opt_type = 16;
pub type fio_opt_type = cty::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct value_pair {
pub ival: *const cty::c_char,
pub oval: cty::c_ulonglong,
pub help: *const cty::c_char,
pub orval: cty::c_int,
pub cb: *mut cty::c_void,
}
#[test]
fn bindgen_test_layout_value_pair() {
assert_eq!(
::core::mem::size_of::<value_pair>(),
40usize,
concat!("Size of: ", stringify!(value_pair))
);
assert_eq!(
::core::mem::align_of::<value_pair>(),
8usize,
concat!("Alignment of ", stringify!(value_pair))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<value_pair>())).ival as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(value_pair),
"::",
stringify!(ival)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<value_pair>())).oval as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(value_pair),
"::",
stringify!(oval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<value_pair>())).help as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(value_pair),
"::",
stringify!(help)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<value_pair>())).orval as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(value_pair),
"::",
stringify!(orval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<value_pair>())).cb as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(value_pair),
"::",
stringify!(cb)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fio_option {
pub name: *const cty::c_char,
pub lname: *const cty::c_char,
pub alias: *const cty::c_char,
pub type_: fio_opt_type,
pub off1: cty::c_uint,
pub off2: cty::c_uint,
pub off3: cty::c_uint,
pub off4: cty::c_uint,
pub off5: cty::c_uint,
pub off6: cty::c_uint,
pub maxval: cty::c_ulonglong,
pub minval: cty::c_int,
pub maxfp: f64,
pub minfp: f64,
pub interval: cty::c_uint,
pub maxlen: cty::c_uint,
pub neg: cty::c_int,
pub prio: cty::c_int,
pub cb: *mut cty::c_void,
pub help: *const cty::c_char,
pub def: *const cty::c_char,
pub posval: [value_pair; 32usize],
pub parent: *const cty::c_char,
pub hide: cty::c_int,
pub hide_on_set: cty::c_int,
pub inverse: *const cty::c_char,
pub inv_opt: *mut fio_option,
pub verify: ::core::option::Option<
unsafe extern "C" fn(arg1: *const fio_option, arg2: *mut cty::c_void) -> cty::c_int,
>,
pub prof_name: *const cty::c_char,
pub prof_opts: *mut cty::c_void,
pub category: u64,
pub group: u64,
pub gui_data: *mut cty::c_void,
pub is_seconds: cty::c_int,
pub is_time: cty::c_int,
pub no_warn_def: cty::c_int,
pub pow2: cty::c_int,
pub no_free: cty::c_int,
}
#[test]
fn bindgen_test_layout_fio_option() {
assert_eq!(
::core::mem::size_of::<fio_option>(),
1512usize,
concat!("Size of: ", stringify!(fio_option))
);
assert_eq!(
::core::mem::align_of::<fio_option>(),
8usize,
concat!("Alignment of ", stringify!(fio_option))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).lname as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(lname)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).alias as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(alias)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).type_ as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).off1 as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(off1)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).off2 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(off2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).off3 as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(off3)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).off4 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(off4)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).off5 as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(off5)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).off6 as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(off6)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).maxval as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(maxval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).minval as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(minval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).maxfp as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(maxfp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).minfp as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(minfp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).interval as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(interval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).maxlen as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(maxlen)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).neg as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(neg)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).prio as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(prio)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).cb as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(cb)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).help as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(help)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).def as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(def)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).posval as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(posval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).parent as *const _ as usize },
1408usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).hide as *const _ as usize },
1416usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(hide)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).hide_on_set as *const _ as usize },
1420usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(hide_on_set)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).inverse as *const _ as usize },
1424usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(inverse)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).inv_opt as *const _ as usize },
1432usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(inv_opt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).verify as *const _ as usize },
1440usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(verify)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).prof_name as *const _ as usize },
1448usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(prof_name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).prof_opts as *const _ as usize },
1456usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(prof_opts)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).category as *const _ as usize },
1464usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(category)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).group as *const _ as usize },
1472usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(group)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).gui_data as *const _ as usize },
1480usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(gui_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).is_seconds as *const _ as usize },
1488usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(is_seconds)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).is_time as *const _ as usize },
1492usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(is_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).no_warn_def as *const _ as usize },
1496usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(no_warn_def)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).pow2 as *const _ as usize },
1500usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(pow2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_option>())).no_free as *const _ as usize },
1504usize,
concat!(
"Offset of field: ",
stringify!(fio_option),
"::",
stringify!(no_free)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fio_rb_node {
pub rb_parent_color: isize,
pub rb_right: *mut fio_rb_node,
pub rb_left: *mut fio_rb_node,
}
#[test]
fn bindgen_test_layout_fio_rb_node() {
assert_eq!(
::core::mem::size_of::<fio_rb_node>(),
24usize,
concat!("Size of: ", stringify!(fio_rb_node))
);
assert_eq!(
::core::mem::align_of::<fio_rb_node>(),
8usize,
concat!("Alignment of ", stringify!(fio_rb_node))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_rb_node>())).rb_parent_color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_rb_node),
"::",
stringify!(rb_parent_color)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_rb_node>())).rb_right as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(fio_rb_node),
"::",
stringify!(rb_right)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_rb_node>())).rb_left as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(fio_rb_node),
"::",
stringify!(rb_left)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rb_root {
pub rb_node: *mut fio_rb_node,
}
#[test]
fn bindgen_test_layout_rb_root() {
assert_eq!(
::core::mem::size_of::<rb_root>(),
8usize,
concat!("Size of: ", stringify!(rb_root))
);
assert_eq!(
::core::mem::align_of::<rb_root>(),
8usize,
concat!("Alignment of ", stringify!(rb_root))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<rb_root>())).rb_node as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(rb_root),
"::",
stringify!(rb_node)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct fio_fp64 {
pub u: fio_fp64__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union fio_fp64__bindgen_ty_1 {
pub i: u64,
pub f: f64,
pub filler: [u8; 16usize],
}
#[test]
fn bindgen_test_layout_fio_fp64__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<fio_fp64__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(fio_fp64__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<fio_fp64__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(fio_fp64__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_fp64__bindgen_ty_1>())).i as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_fp64__bindgen_ty_1),
"::",
stringify!(i)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_fp64__bindgen_ty_1>())).f as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_fp64__bindgen_ty_1),
"::",
stringify!(f)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_fp64__bindgen_ty_1>())).filler as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_fp64__bindgen_ty_1),
"::",
stringify!(filler)
)
);
}
#[test]
fn bindgen_test_layout_fio_fp64() {
assert_eq!(
::core::mem::size_of::<fio_fp64>(),
16usize,
concat!("Size of: ", stringify!(fio_fp64))
);
assert_eq!(
::core::mem::align_of::<fio_fp64>(),
8usize,
concat!("Alignment of ", stringify!(fio_fp64))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_fp64>())).u as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_fp64),
"::",
stringify!(u)
)
);
}
pub type fio_fp64_t = fio_fp64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct workqueue_work {
pub list: flist_head,
}
#[test]
fn bindgen_test_layout_workqueue_work() {
assert_eq!(
::core::mem::size_of::<workqueue_work>(),
16usize,
concat!("Size of: ", stringify!(workqueue_work))
);
assert_eq!(
::core::mem::align_of::<workqueue_work>(),
8usize,
concat!("Alignment of ", stringify!(workqueue_work))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_work>())).list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(workqueue_work),
"::",
stringify!(list)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct submit_worker {
pub thread: pthread_t,
pub lock: pthread_mutex_t,
pub cond: pthread_cond_t,
pub work_list: flist_head,
pub flags: cty::c_uint,
pub index: cty::c_uint,
pub seq: u64,
pub wq: *mut workqueue,
pub priv_: *mut cty::c_void,
pub sk_out: *mut sk_out,
}
#[test]
fn bindgen_test_layout_submit_worker() {
assert_eq!(
::core::mem::size_of::<submit_worker>(),
152usize,
concat!("Size of: ", stringify!(submit_worker))
);
assert_eq!(
::core::mem::align_of::<submit_worker>(),
8usize,
concat!("Alignment of ", stringify!(submit_worker))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).thread as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(thread)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).lock as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).cond as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).work_list as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(work_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).flags as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).index as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).seq as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).wq as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(wq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).priv_ as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(priv_)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<submit_worker>())).sk_out as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(submit_worker),
"::",
stringify!(sk_out)
)
);
}
pub type workqueue_work_fn = ::core::option::Option<
unsafe extern "C" fn(arg1: *mut submit_worker, arg2: *mut workqueue_work) -> cty::c_int,
>;
pub type workqueue_pre_sleep_flush_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker) -> bool_>;
pub type workqueue_pre_sleep_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker)>;
pub type workqueue_alloc_worker_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker) -> cty::c_int>;
pub type workqueue_free_worker_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker)>;
pub type workqueue_init_worker_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker) -> cty::c_int>;
pub type workqueue_exit_worker_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker, arg2: *mut cty::c_uint)>;
pub type workqueue_update_acct_fn =
::core::option::Option<unsafe extern "C" fn(arg1: *mut submit_worker)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct workqueue_ops {
pub fn_: workqueue_work_fn,
pub pre_sleep_flush_fn: workqueue_pre_sleep_flush_fn,
pub pre_sleep_fn: workqueue_pre_sleep_fn,
pub update_acct_fn: workqueue_update_acct_fn,
pub alloc_worker_fn: workqueue_alloc_worker_fn,
pub free_worker_fn: workqueue_free_worker_fn,
pub init_worker_fn: workqueue_init_worker_fn,
pub exit_worker_fn: workqueue_exit_worker_fn,
pub nice: cty::c_uint,
}
#[test]
fn bindgen_test_layout_workqueue_ops() {
assert_eq!(
::core::mem::size_of::<workqueue_ops>(),
72usize,
concat!("Size of: ", stringify!(workqueue_ops))
);
assert_eq!(
::core::mem::align_of::<workqueue_ops>(),
8usize,
concat!("Alignment of ", stringify!(workqueue_ops))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).fn_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(fn_)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<workqueue_ops>())).pre_sleep_flush_fn as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(pre_sleep_flush_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).pre_sleep_fn as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(pre_sleep_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).update_acct_fn as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(update_acct_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).alloc_worker_fn as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(alloc_worker_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).free_worker_fn as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(free_worker_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).init_worker_fn as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(init_worker_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).exit_worker_fn as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(exit_worker_fn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue_ops>())).nice as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(workqueue_ops),
"::",
stringify!(nice)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct workqueue {
pub max_workers: cty::c_uint,
pub td: *mut thread_data,
pub ops: workqueue_ops,
pub work_seq: u64,
pub workers: *mut submit_worker,
pub next_free_worker: cty::c_uint,
pub flush_cond: pthread_cond_t,
pub flush_lock: pthread_mutex_t,
pub stat_lock: pthread_mutex_t,
pub wake_idle: cty::c_int,
}
#[test]
fn bindgen_test_layout_workqueue() {
assert_eq!(
::core::mem::size_of::<workqueue>(),
248usize,
concat!("Size of: ", stringify!(workqueue))
);
assert_eq!(
::core::mem::align_of::<workqueue>(),
8usize,
concat!("Alignment of ", stringify!(workqueue))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).max_workers as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(max_workers)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).td as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(td)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).ops as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(ops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).work_seq as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(work_seq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).workers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(workers)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).next_free_worker as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(next_free_worker)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).flush_cond as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(flush_cond)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).flush_lock as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(flush_lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).stat_lock as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(stat_lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<workqueue>())).wake_idle as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(workqueue),
"::",
stringify!(wake_idle)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct io_u {
pub start_time: timespec,
pub issue_time: timespec,
pub file: *mut fio_file,
pub flags: cty::c_uint,
pub ddir: fio_ddir,
pub acct_ddir: fio_ddir,
pub numberio: cty::c_ushort,
pub buflen: cty::c_ulonglong,
pub offset: cty::c_ulonglong,
pub verify_offset: cty::c_ulonglong,
pub buf: *mut cty::c_void,
pub rand_seed: u64,
pub xfer_buf: *mut cty::c_void,
pub xfer_buflen: cty::c_ulonglong,
pub buf_filled_len: cty::c_ulonglong,
pub ipo: *mut io_piece,
pub resid: cty::c_ulonglong,
pub error: cty::c_uint,
pub __bindgen_anon_1: io_u__bindgen_ty_1,
pub __bindgen_anon_2: io_u__bindgen_ty_2,
pub zbd_queue_io: ::core::option::Option<
unsafe extern "C" fn(td: *mut thread_data, arg1: *mut io_u, q: cty::c_int, success: bool_),
>,
pub zbd_put_io:
::core::option::Option<unsafe extern "C" fn(td: *mut thread_data, arg1: *const io_u)>,
pub end_io: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut *mut io_u) -> cty::c_int,
>,
pub __bindgen_anon_3: io_u__bindgen_ty_3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_u__bindgen_ty_1 {
pub index: cty::c_uint,
pub seen: cty::c_uint,
pub engine_data: *mut cty::c_void,
}
#[test]
fn bindgen_test_layout_io_u__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<io_u__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(io_u__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<io_u__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(io_u__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_1>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_1),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_1>())).seen as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_1),
"::",
stringify!(seen)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_1>())).engine_data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_1),
"::",
stringify!(engine_data)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_u__bindgen_ty_2 {
pub verify_list: flist_head,
pub work: workqueue_work,
}
#[test]
fn bindgen_test_layout_io_u__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<io_u__bindgen_ty_2>(),
16usize,
concat!("Size of: ", stringify!(io_u__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<io_u__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(io_u__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_2>())).verify_list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_2),
"::",
stringify!(verify_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_2>())).work as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_2),
"::",
stringify!(work)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_u__bindgen_ty_3 {
pub hdr: sg_io_hdr,
pub mmap_data: *mut cty::c_void,
}
#[test]
fn bindgen_test_layout_io_u__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<io_u__bindgen_ty_3>(),
88usize,
concat!("Size of: ", stringify!(io_u__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<io_u__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(io_u__bindgen_ty_3))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_3>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_3),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u__bindgen_ty_3>())).mmap_data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u__bindgen_ty_3),
"::",
stringify!(mmap_data)
)
);
}
#[test]
fn bindgen_test_layout_io_u() {
assert_eq!(
::core::mem::size_of::<io_u>(),
280usize,
concat!("Size of: ", stringify!(io_u))
);
assert_eq!(
::core::mem::align_of::<io_u>(),
8usize,
concat!("Alignment of ", stringify!(io_u))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).start_time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(start_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).issue_time as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(issue_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).file as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).flags as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).ddir as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(ddir)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).acct_ddir as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(acct_ddir)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).numberio as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(numberio)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).buflen as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(buflen)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).offset as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).verify_offset as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(verify_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).buf as *const _ as usize },
80usize,
concat!("Offset of field: ", stringify!(io_u), "::", stringify!(buf))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).rand_seed as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(rand_seed)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).xfer_buf as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(xfer_buf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).xfer_buflen as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(xfer_buflen)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).buf_filled_len as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(buf_filled_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).ipo as *const _ as usize },
120usize,
concat!("Offset of field: ", stringify!(io_u), "::", stringify!(ipo))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).resid as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(resid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).error as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).zbd_queue_io as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(zbd_queue_io)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).zbd_put_io as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(zbd_put_io)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u>())).end_io as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(io_u),
"::",
stringify!(end_io)
)
);
}
pub const ZBD_IGNORE: zbd_zoned_model = 0;
pub const ZBD_NONE: zbd_zoned_model = 1;
pub const ZBD_HOST_AWARE: zbd_zoned_model = 2;
pub const ZBD_HOST_MANAGED: zbd_zoned_model = 3;
pub type zbd_zoned_model = cty::c_uint;
pub const ZBD_ZONE_TYPE_CNV: zbd_zone_type = 1;
pub const ZBD_ZONE_TYPE_SWR: zbd_zone_type = 2;
pub const ZBD_ZONE_TYPE_SWP: zbd_zone_type = 3;
pub type zbd_zone_type = cty::c_uint;
pub const ZBD_ZONE_COND_NOT_WP: zbd_zone_cond = 0;
pub const ZBD_ZONE_COND_EMPTY: zbd_zone_cond = 1;
pub const ZBD_ZONE_COND_IMP_OPEN: zbd_zone_cond = 2;
pub const ZBD_ZONE_COND_EXP_OPEN: zbd_zone_cond = 3;
pub const ZBD_ZONE_COND_CLOSED: zbd_zone_cond = 4;
pub const ZBD_ZONE_COND_READONLY: zbd_zone_cond = 13;
pub const ZBD_ZONE_COND_FULL: zbd_zone_cond = 14;
pub const ZBD_ZONE_COND_OFFLINE: zbd_zone_cond = 15;
pub type zbd_zone_cond = cty::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zbd_zone {
pub start: u64,
pub wp: u64,
pub len: u64,
pub capacity: u64,
pub type_: zbd_zone_type,
pub cond: zbd_zone_cond,
}
#[test]
fn bindgen_test_layout_zbd_zone() {
assert_eq!(
::core::mem::size_of::<zbd_zone>(),
40usize,
concat!("Size of: ", stringify!(zbd_zone))
);
assert_eq!(
::core::mem::align_of::<zbd_zone>(),
8usize,
concat!("Alignment of ", stringify!(zbd_zone))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zbd_zone>())).start as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zbd_zone),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zbd_zone>())).wp as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zbd_zone),
"::",
stringify!(wp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zbd_zone>())).len as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(zbd_zone),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zbd_zone>())).capacity as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(zbd_zone),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zbd_zone>())).type_ as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(zbd_zone),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zbd_zone>())).cond as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(zbd_zone),
"::",
stringify!(cond)
)
);
}
pub const FIO_Q_COMPLETED: fio_q_status = 0;
pub const FIO_Q_QUEUED: fio_q_status = 1;
pub const FIO_Q_BUSY: fio_q_status = 2;
pub type fio_q_status = cty::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ioengine_ops {
pub list: flist_head,
pub name: *const cty::c_char,
pub version: cty::c_int,
pub flags: cty::c_int,
pub dlhandle: *mut cty::c_void,
pub setup: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data) -> cty::c_int>,
pub init: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data) -> cty::c_int>,
pub post_init:
::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data) -> cty::c_int>,
pub prep: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut io_u) -> cty::c_int,
>,
pub queue: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut io_u) -> fio_q_status,
>,
pub commit: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data) -> cty::c_int>,
pub getevents: ::core::option::Option<
unsafe extern "C" fn(
arg1: *mut thread_data,
arg2: cty::c_uint,
arg3: cty::c_uint,
arg4: *const timespec,
) -> cty::c_int,
>,
pub event: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: cty::c_int) -> *mut io_u,
>,
pub errdetails:
::core::option::Option<unsafe extern "C" fn(arg1: *mut io_u) -> *mut cty::c_char>,
pub cancel: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut io_u) -> cty::c_int,
>,
pub cleanup: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data)>,
pub open_file: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut fio_file) -> cty::c_int,
>,
pub close_file: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut fio_file) -> cty::c_int,
>,
pub invalidate: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut fio_file) -> cty::c_int,
>,
pub unlink_file: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut fio_file) -> cty::c_int,
>,
pub get_file_size: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut fio_file) -> cty::c_int,
>,
pub prepopulate_file: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut fio_file) -> cty::c_int,
>,
pub terminate: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data)>,
pub iomem_alloc: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: size_t) -> cty::c_int,
>,
pub iomem_free: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data)>,
pub io_u_init: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut io_u) -> cty::c_int,
>,
pub io_u_free:
::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data, arg2: *mut io_u)>,
pub get_zoned_model: ::core::option::Option<
unsafe extern "C" fn(
td: *mut thread_data,
f: *mut fio_file,
arg1: *mut zbd_zoned_model,
) -> cty::c_int,
>,
pub report_zones: ::core::option::Option<
unsafe extern "C" fn(
arg1: *mut thread_data,
arg2: *mut fio_file,
arg3: u64,
arg4: *mut zbd_zone,
arg5: cty::c_uint,
) -> cty::c_int,
>,
pub reset_wp: ::core::option::Option<
unsafe extern "C" fn(
arg1: *mut thread_data,
arg2: *mut fio_file,
arg3: u64,
arg4: u64,
) -> cty::c_int,
>,
pub option_struct_size: cty::c_int,
pub options: *mut fio_option,
}
#[test]
fn bindgen_test_layout_ioengine_ops() {
assert_eq!(
::core::mem::size_of::<ioengine_ops>(),
256usize,
concat!("Size of: ", stringify!(ioengine_ops))
);
assert_eq!(
::core::mem::align_of::<ioengine_ops>(),
8usize,
concat!("Alignment of ", stringify!(ioengine_ops))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).name as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).version as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).flags as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).dlhandle as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(dlhandle)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).setup as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(setup)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).init as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(init)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).post_init as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(post_init)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).prep as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(prep)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).queue as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(queue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).commit as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(commit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).getevents as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(getevents)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).event as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(event)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).errdetails as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(errdetails)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).cancel as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(cancel)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).cleanup as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(cleanup)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).open_file as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(open_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).close_file as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(close_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).invalidate as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(invalidate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).unlink_file as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(unlink_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).get_file_size as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(get_file_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).prepopulate_file as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(prepopulate_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).terminate as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(terminate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).iomem_alloc as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(iomem_alloc)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).iomem_free as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(iomem_free)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).io_u_init as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(io_u_init)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).io_u_free as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(io_u_free)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).get_zoned_model as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(get_zoned_model)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).report_zones as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(report_zones)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).reset_wp as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(reset_wp)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<ioengine_ops>())).option_struct_size as *const _ as usize
},
240usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(option_struct_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<ioengine_ops>())).options as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(ioengine_ops),
"::",
stringify!(options)
)
);
}
pub const FIO_SYNCIO: fio_ioengine_flags = 1;
pub const FIO_RAWIO: fio_ioengine_flags = 2;
pub const FIO_DISKLESSIO: fio_ioengine_flags = 4;
pub const FIO_NOEXTEND: fio_ioengine_flags = 8;
pub const FIO_NODISKUTIL: fio_ioengine_flags = 16;
pub const FIO_UNIDIR: fio_ioengine_flags = 32;
pub const FIO_NOIO: fio_ioengine_flags = 64;
pub const FIO_PIPEIO: fio_ioengine_flags = 128;
pub const FIO_BARRIER: fio_ioengine_flags = 256;
pub const FIO_MEMALIGN: fio_ioengine_flags = 512;
pub const FIO_BIT_BASED: fio_ioengine_flags = 1024;
pub const FIO_FAKEIO: fio_ioengine_flags = 2048;
pub const FIO_NOSTATS: fio_ioengine_flags = 4096;
pub const FIO_NOFILEHASH: fio_ioengine_flags = 8192;
pub const FIO_ASYNCIO_SYNC_TRIM: fio_ioengine_flags = 16384;
pub const FIO_NO_OFFLOAD: fio_ioengine_flags = 32768;
pub type fio_ioengine_flags = cty::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct io_stat {
pub max_val: u64,
pub min_val: u64,
pub samples: u64,
pub mean: fio_fp64_t,
pub S: fio_fp64_t,
}
#[test]
fn bindgen_test_layout_io_stat() {
assert_eq!(
::core::mem::size_of::<io_stat>(),
56usize,
concat!("Size of: ", stringify!(io_stat))
);
assert_eq!(
::core::mem::align_of::<io_stat>(),
8usize,
concat!("Alignment of ", stringify!(io_stat))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_stat>())).max_val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_stat),
"::",
stringify!(max_val)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_stat>())).min_val as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(io_stat),
"::",
stringify!(min_val)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_stat>())).samples as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(io_stat),
"::",
stringify!(samples)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_stat>())).mean as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(io_stat),
"::",
stringify!(mean)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_stat>())).S as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(io_stat),
"::",
stringify!(S)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct io_hist {
pub samples: u64,
pub hist_last: cty::c_ulong,
pub list: flist_head,
}
#[test]
fn bindgen_test_layout_io_hist() {
assert_eq!(
::core::mem::size_of::<io_hist>(),
32usize,
concat!("Size of: ", stringify!(io_hist))
);
assert_eq!(
::core::mem::align_of::<io_hist>(),
8usize,
concat!("Alignment of ", stringify!(io_hist))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_hist>())).samples as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_hist),
"::",
stringify!(samples)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_hist>())).hist_last as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(io_hist),
"::",
stringify!(hist_last)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_hist>())).list as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(io_hist),
"::",
stringify!(list)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct io_logs {
pub list: flist_head,
pub nr_samples: u64,
pub max_samples: u64,
pub log: *mut cty::c_void,
}
#[test]
fn bindgen_test_layout_io_logs() {
assert_eq!(
::core::mem::size_of::<io_logs>(),
40usize,
concat!("Size of: ", stringify!(io_logs))
);
assert_eq!(
::core::mem::align_of::<io_logs>(),
8usize,
concat!("Alignment of ", stringify!(io_logs))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_logs>())).list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_logs),
"::",
stringify!(list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_logs>())).nr_samples as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(io_logs),
"::",
stringify!(nr_samples)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_logs>())).max_samples as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(io_logs),
"::",
stringify!(max_samples)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_logs>())).log as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(io_logs),
"::",
stringify!(log)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct io_log {
pub io_logs: flist_head,
pub cur_log_max: u32,
pub pending: *mut io_logs,
pub log_ddir_mask: cty::c_uint,
pub filename: *mut cty::c_char,
pub td: *mut thread_data,
pub log_type: cty::c_uint,
pub disabled: bool_,
pub log_offset: cty::c_uint,
pub log_gz: cty::c_uint,
pub log_gz_store: cty::c_uint,
pub avg_window: [io_stat; 3usize],
pub avg_msec: cty::c_ulong,
pub avg_last: [cty::c_ulong; 3usize],
pub hist_window: [io_hist; 3usize],
pub hist_msec: cty::c_ulong,
pub hist_coarseness: cty::c_uint,
pub chunk_lock: pthread_mutex_t,
pub chunk_seq: cty::c_uint,
pub chunk_list: flist_head,
pub deferred_free_lock: pthread_mutex_t,
pub deferred_items: [*mut cty::c_void; 8usize],
pub deferred: cty::c_uint,
}
#[test]
fn bindgen_test_layout_io_log() {
assert_eq!(
::core::mem::size_of::<io_log>(),
568usize,
concat!("Size of: ", stringify!(io_log))
);
assert_eq!(
::core::mem::align_of::<io_log>(),
8usize,
concat!("Alignment of ", stringify!(io_log))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).io_logs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(io_logs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).cur_log_max as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(cur_log_max)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).pending as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(pending)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).log_ddir_mask as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(log_ddir_mask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).filename as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).td as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(td)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).log_type as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(log_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).disabled as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(disabled)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).log_offset as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(log_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).log_gz as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(log_gz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).log_gz_store as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(log_gz_store)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).avg_window as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(avg_window)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).avg_msec as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(avg_msec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).avg_last as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(avg_last)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).hist_window as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(hist_window)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).hist_msec as *const _ as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(hist_msec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).hist_coarseness as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(hist_coarseness)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).chunk_lock as *const _ as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(chunk_lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).chunk_seq as *const _ as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(chunk_seq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).chunk_list as *const _ as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(chunk_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).deferred_free_lock as *const _ as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(deferred_free_lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).deferred_items as *const _ as usize },
496usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(deferred_items)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_log>())).deferred as *const _ as usize },
560usize,
concat!(
"Offset of field: ",
stringify!(io_log),
"::",
stringify!(deferred)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct io_piece {
pub __bindgen_anon_1: io_piece__bindgen_ty_1,
pub trim_list: flist_head,
pub __bindgen_anon_2: io_piece__bindgen_ty_2,
pub offset: cty::c_ulonglong,
pub numberio: cty::c_ushort,
pub len: cty::c_ulong,
pub flags: cty::c_uint,
pub ddir: fio_ddir,
pub __bindgen_anon_3: io_piece__bindgen_ty_3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_piece__bindgen_ty_1 {
pub rb_node: fio_rb_node,
pub list: flist_head,
}
#[test]
fn bindgen_test_layout_io_piece__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<io_piece__bindgen_ty_1>(),
24usize,
concat!("Size of: ", stringify!(io_piece__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<io_piece__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(io_piece__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece__bindgen_ty_1>())).rb_node as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_piece__bindgen_ty_1),
"::",
stringify!(rb_node)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece__bindgen_ty_1>())).list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_piece__bindgen_ty_1),
"::",
stringify!(list)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_piece__bindgen_ty_2 {
pub fileno: cty::c_int,
pub file: *mut fio_file,
}
#[test]
fn bindgen_test_layout_io_piece__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<io_piece__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(io_piece__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<io_piece__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(io_piece__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece__bindgen_ty_2>())).fileno as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_piece__bindgen_ty_2),
"::",
stringify!(fileno)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece__bindgen_ty_2>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_piece__bindgen_ty_2),
"::",
stringify!(file)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_piece__bindgen_ty_3 {
pub delay: cty::c_ulong,
pub file_action: cty::c_uint,
}
#[test]
fn bindgen_test_layout_io_piece__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<io_piece__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(io_piece__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<io_piece__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(io_piece__bindgen_ty_3))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece__bindgen_ty_3>())).delay as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_piece__bindgen_ty_3),
"::",
stringify!(delay)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<io_piece__bindgen_ty_3>())).file_action as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(io_piece__bindgen_ty_3),
"::",
stringify!(file_action)
)
);
}
#[test]
fn bindgen_test_layout_io_piece() {
assert_eq!(
::core::mem::size_of::<io_piece>(),
88usize,
concat!("Size of: ", stringify!(io_piece))
);
assert_eq!(
::core::mem::align_of::<io_piece>(),
8usize,
concat!("Alignment of ", stringify!(io_piece))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece>())).trim_list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(io_piece),
"::",
stringify!(trim_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece>())).offset as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(io_piece),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece>())).numberio as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(io_piece),
"::",
stringify!(numberio)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece>())).len as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(io_piece),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece>())).flags as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(io_piece),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_piece>())).ddir as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(io_piece),
"::",
stringify!(ddir)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct fio_sem {
pub lock: pthread_mutex_t,
pub cond: pthread_cond_t,
pub value: cty::c_int,
pub waiters: cty::c_int,
pub magic: cty::c_int,
}
#[test]
fn bindgen_test_layout_fio_sem() {
assert_eq!(
::core::mem::size_of::<fio_sem>(),
104usize,
concat!("Size of: ", stringify!(fio_sem))
);
assert_eq!(
::core::mem::align_of::<fio_sem>(),
8usize,
concat!("Alignment of ", stringify!(fio_sem))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_sem>())).lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fio_sem),
"::",
stringify!(lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_sem>())).cond as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(fio_sem),
"::",
stringify!(cond)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_sem>())).value as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(fio_sem),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_sem>())).waiters as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(fio_sem),
"::",
stringify!(waiters)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<fio_sem>())).magic as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(fio_sem),
"::",
stringify!(magic)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct disk_util_stats {
pub ios: [u64; 2usize],
pub merges: [u64; 2usize],
pub sectors: [u64; 2usize],
pub ticks: [u64; 2usize],
pub io_ticks: u64,
pub time_in_queue: u64,
pub msec: u64,
}
#[test]
fn bindgen_test_layout_disk_util_stats() {
assert_eq!(
::core::mem::size_of::<disk_util_stats>(),
88usize,
concat!("Size of: ", stringify!(disk_util_stats))
);
assert_eq!(
::core::mem::align_of::<disk_util_stats>(),
8usize,
concat!("Alignment of ", stringify!(disk_util_stats))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).ios as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(ios)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).merges as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(merges)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).sectors as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(sectors)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).ticks as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(ticks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).io_ticks as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(io_ticks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).time_in_queue as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(time_in_queue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stats>())).msec as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stats),
"::",
stringify!(msec)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct disk_util_stat {
pub name: [u8; 64usize],
pub s: disk_util_stats,
}
#[test]
fn bindgen_test_layout_disk_util_stat() {
assert_eq!(
::core::mem::size_of::<disk_util_stat>(),
152usize,
concat!("Size of: ", stringify!(disk_util_stat))
);
assert_eq!(
::core::mem::align_of::<disk_util_stat>(),
8usize,
concat!("Alignment of ", stringify!(disk_util_stat))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stat>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stat),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_stat>())).s as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(disk_util_stat),
"::",
stringify!(s)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct disk_util_agg {
pub ios: [u64; 2usize],
pub merges: [u64; 2usize],
pub sectors: [u64; 2usize],
pub ticks: [u64; 2usize],
pub io_ticks: u64,
pub time_in_queue: u64,
pub slavecount: u32,
pub pad: u32,
pub max_util: fio_fp64_t,
}
#[test]
fn bindgen_test_layout_disk_util_agg() {
assert_eq!(
::core::mem::size_of::<disk_util_agg>(),
104usize,
concat!("Size of: ", stringify!(disk_util_agg))
);
assert_eq!(
::core::mem::align_of::<disk_util_agg>(),
8usize,
concat!("Alignment of ", stringify!(disk_util_agg))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).ios as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(ios)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).merges as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(merges)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).sectors as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(sectors)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).ticks as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(ticks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).io_ticks as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(io_ticks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).time_in_queue as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(time_in_queue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).slavecount as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(slavecount)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).pad as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(pad)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util_agg>())).max_util as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(disk_util_agg),
"::",
stringify!(max_util)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct disk_util {
pub list: flist_head,
pub slavelist: flist_head,
pub sysfs_root: *mut cty::c_char,
pub path: [cty::c_char; 4096usize],
pub major: cty::c_int,
pub minor: cty::c_int,
pub dus: disk_util_stat,
pub last_dus: disk_util_stat,
pub agg: disk_util_agg,
pub slaves: flist_head,
pub time: timespec,
pub lock: *mut fio_sem,
pub users: cty::c_ulong,
}
#[test]
fn bindgen_test_layout_disk_util() {
assert_eq!(
::core::mem::size_of::<disk_util>(),
4600usize,
concat!("Size of: ", stringify!(disk_util))
);
assert_eq!(
::core::mem::align_of::<disk_util>(),
8usize,
concat!("Alignment of ", stringify!(disk_util))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).slavelist as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(slavelist)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).sysfs_root as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(sysfs_root)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).path as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(path)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).major as *const _ as usize },
4136usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).minor as *const _ as usize },
4140usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).dus as *const _ as usize },
4144usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(dus)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).last_dus as *const _ as usize },
4296usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(last_dus)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).agg as *const _ as usize },
4448usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(agg)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).slaves as *const _ as usize },
4552usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(slaves)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).time as *const _ as usize },
4568usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).lock as *const _ as usize },
4584usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<disk_util>())).users as *const _ as usize },
4592usize,
concat!(
"Offset of field: ",
stringify!(disk_util),
"::",
stringify!(users)
)
);
}
#[repr(C, packed(8))]
#[derive(Copy, Clone)]
pub struct thread_stat {
pub name: [cty::c_char; 128usize],
pub verror: [cty::c_char; 128usize],
pub error: u32,
pub thread_number: u32,
pub groupid: u32,
pub pid: u32,
pub description: [cty::c_char; 256usize],
pub members: u32,
pub unified_rw_rep: u32,
pub sync_stat: io_stat,
pub clat_stat: [io_stat; 3usize],
pub slat_stat: [io_stat; 3usize],
pub lat_stat: [io_stat; 3usize],
pub bw_stat: [io_stat; 3usize],
pub iops_stat: [io_stat; 3usize],
pub usr_time: u64,
pub sys_time: u64,
pub ctx: u64,
pub minf: u64,
pub majf: u64,
pub clat_percentiles: u32,
pub lat_percentiles: u32,
pub slat_percentiles: u32,
pub pad: u32,
pub percentile_precision: u64,
pub percentile_list: [fio_fp64_t; 20usize],
pub io_u_map: [u64; 7usize],
pub io_u_submit: [u64; 7usize],
pub io_u_complete: [u64; 7usize],
pub io_u_lat_n: [u64; 10usize],
pub io_u_lat_u: [u64; 10usize],
pub io_u_lat_m: [u64; 12usize],
pub io_u_plat: [[[u64; 1856usize]; 3usize]; 3usize],
pub io_u_sync_plat: [u64; 1856usize],
pub total_io_u: [u64; 4usize],
pub short_io_u: [u64; 3usize],
pub drop_io_u: [u64; 3usize],
pub total_submit: u64,
pub total_complete: u64,
pub io_bytes: [u64; 3usize],
pub runtime: [u64; 3usize],
pub total_run_time: u64,
pub __bindgen_anon_1: thread_stat__bindgen_ty_1,
pub first_error: u32,
pub total_err_count: u64,
pub nr_zone_resets: u64,
pub nr_block_infos: u64,
pub block_infos: [u32; 8192usize],
pub kb_base: u32,
pub unit_base: u32,
pub latency_depth: u32,
pub pad3: u32,
pub latency_target: u64,
pub latency_percentile: fio_fp64_t,
pub latency_window: u64,
pub sig_figs: u32,
pub ss_dur: u64,
pub ss_state: u32,
pub ss_head: u32,
pub ss_limit: fio_fp64_t,
pub ss_slope: fio_fp64_t,
pub ss_deviation: fio_fp64_t,
pub ss_criterion: fio_fp64_t,
pub io_u_plat_high_prio: [[u64; 1856usize]; 3usize],
pub io_u_plat_low_prio: [[u64; 1856usize]; 3usize],
pub clat_high_prio_stat: [io_stat; 3usize],
pub clat_low_prio_stat: [io_stat; 3usize],
pub __bindgen_anon_2: thread_stat__bindgen_ty_2,
pub __bindgen_anon_3: thread_stat__bindgen_ty_3,
pub cachehit: u64,
pub cachemiss: u64,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union thread_stat__bindgen_ty_1 {
pub continue_on_error: u16,
pub pad2: u32,
}
#[test]
fn bindgen_test_layout_thread_stat__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<thread_stat__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(thread_stat__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<thread_stat__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(thread_stat__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_stat__bindgen_ty_1>())).continue_on_error as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat__bindgen_ty_1),
"::",
stringify!(continue_on_error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat__bindgen_ty_1>())).pad2 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat__bindgen_ty_1),
"::",
stringify!(pad2)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union thread_stat__bindgen_ty_2 {
pub ss_iops_data: *mut u64,
pub pad4: u64,
}
#[test]
fn bindgen_test_layout_thread_stat__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<thread_stat__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(thread_stat__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<thread_stat__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(thread_stat__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_stat__bindgen_ty_2>())).ss_iops_data as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat__bindgen_ty_2),
"::",
stringify!(ss_iops_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat__bindgen_ty_2>())).pad4 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat__bindgen_ty_2),
"::",
stringify!(pad4)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union thread_stat__bindgen_ty_3 {
pub ss_bw_data: *mut u64,
pub pad5: u64,
}
#[test]
fn bindgen_test_layout_thread_stat__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<thread_stat__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(thread_stat__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<thread_stat__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(thread_stat__bindgen_ty_3))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_stat__bindgen_ty_3>())).ss_bw_data as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat__bindgen_ty_3),
"::",
stringify!(ss_bw_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat__bindgen_ty_3>())).pad5 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat__bindgen_ty_3),
"::",
stringify!(pad5)
)
);
}
#[test]
fn bindgen_test_layout_thread_stat() {
assert_eq!(
::core::mem::size_of::<thread_stat>(),
273264usize,
concat!("Size of: ", stringify!(thread_stat))
);
assert_eq!(
::core::mem::align_of::<thread_stat>(),
8usize,
concat!("Alignment of ", stringify!(thread_stat))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).verror as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(verror)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).error as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).thread_number as *const _ as usize },
260usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(thread_number)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).groupid as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(groupid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).pid as *const _ as usize },
268usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(pid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).description as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).members as *const _ as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(members)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).unified_rw_rep as *const _ as usize },
532usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(unified_rw_rep)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).sync_stat as *const _ as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(sync_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).clat_stat as *const _ as usize },
592usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(clat_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).slat_stat as *const _ as usize },
760usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(slat_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).lat_stat as *const _ as usize },
928usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(lat_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).bw_stat as *const _ as usize },
1096usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(bw_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).iops_stat as *const _ as usize },
1264usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(iops_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).usr_time as *const _ as usize },
1432usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(usr_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).sys_time as *const _ as usize },
1440usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(sys_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ctx as *const _ as usize },
1448usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ctx)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).minf as *const _ as usize },
1456usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(minf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).majf as *const _ as usize },
1464usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(majf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).clat_percentiles as *const _ as usize },
1472usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(clat_percentiles)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).lat_percentiles as *const _ as usize },
1476usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(lat_percentiles)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).slat_percentiles as *const _ as usize },
1480usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(slat_percentiles)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).pad as *const _ as usize },
1484usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(pad)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_stat>())).percentile_precision as *const _ as usize
},
1488usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(percentile_precision)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).percentile_list as *const _ as usize },
1496usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(percentile_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_map as *const _ as usize },
1816usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_map)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_submit as *const _ as usize },
1872usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_submit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_complete as *const _ as usize },
1928usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_complete)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_lat_n as *const _ as usize },
1984usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_lat_n)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_lat_u as *const _ as usize },
2064usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_lat_u)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_lat_m as *const _ as usize },
2144usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_lat_m)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_plat as *const _ as usize },
2240usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_plat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_sync_plat as *const _ as usize },
135872usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_sync_plat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).total_io_u as *const _ as usize },
150720usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(total_io_u)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).short_io_u as *const _ as usize },
150752usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(short_io_u)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).drop_io_u as *const _ as usize },
150776usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(drop_io_u)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).total_submit as *const _ as usize },
150800usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(total_submit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).total_complete as *const _ as usize },
150808usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(total_complete)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_bytes as *const _ as usize },
150816usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).runtime as *const _ as usize },
150840usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(runtime)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).total_run_time as *const _ as usize },
150864usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(total_run_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).first_error as *const _ as usize },
150876usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(first_error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).total_err_count as *const _ as usize },
150880usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(total_err_count)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).nr_zone_resets as *const _ as usize },
150888usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(nr_zone_resets)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).nr_block_infos as *const _ as usize },
150896usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(nr_block_infos)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).block_infos as *const _ as usize },
150904usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(block_infos)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).kb_base as *const _ as usize },
183672usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(kb_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).unit_base as *const _ as usize },
183676usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(unit_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).latency_depth as *const _ as usize },
183680usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(latency_depth)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).pad3 as *const _ as usize },
183684usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(pad3)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).latency_target as *const _ as usize },
183688usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(latency_target)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).latency_percentile as *const _ as usize },
183696usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(latency_percentile)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).latency_window as *const _ as usize },
183712usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(latency_window)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).sig_figs as *const _ as usize },
183720usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(sig_figs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_dur as *const _ as usize },
183724usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_dur)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_state as *const _ as usize },
183732usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_head as *const _ as usize },
183736usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_head)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_limit as *const _ as usize },
183740usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_limit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_slope as *const _ as usize },
183756usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_slope)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_deviation as *const _ as usize },
183772usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_deviation)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).ss_criterion as *const _ as usize },
183788usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(ss_criterion)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_stat>())).io_u_plat_high_prio as *const _ as usize
},
183808usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_plat_high_prio)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).io_u_plat_low_prio as *const _ as usize },
228352usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(io_u_plat_low_prio)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_stat>())).clat_high_prio_stat as *const _ as usize
},
272896usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(clat_high_prio_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).clat_low_prio_stat as *const _ as usize },
273064usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(clat_low_prio_stat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).cachehit as *const _ as usize },
273248usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(cachehit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_stat>())).cachemiss as *const _ as usize },
273256usize,
concat!(
"Offset of field: ",
stringify!(thread_stat),
"::",
stringify!(cachemiss)
)
);
}
pub const CS_GTOD: fio_cs = 1;
pub const CS_CGETTIME: fio_cs = 2;
pub const CS_CPUCLOCK: fio_cs = 3;
pub const CS_INVAL: fio_cs = 4;
pub type fio_cs = cty::c_uint;
#[doc = " Pattern format description. The input for 'parse_pattern'."]
#[doc = " Describes format with its name and callback, which should"]
#[doc = " be called to paste something inside the buffer."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pattern_fmt_desc {
pub fmt: *const cty::c_char,
pub len: cty::c_uint,
pub paste: ::core::option::Option<
unsafe extern "C" fn(
buf: *mut cty::c_char,
len: cty::c_uint,
priv_: *mut cty::c_void,
) -> cty::c_int,
>,
}
#[test]
fn bindgen_test_layout_pattern_fmt_desc() {
assert_eq!(
::core::mem::size_of::<pattern_fmt_desc>(),
24usize,
concat!("Size of: ", stringify!(pattern_fmt_desc))
);
assert_eq!(
::core::mem::align_of::<pattern_fmt_desc>(),
8usize,
concat!("Alignment of ", stringify!(pattern_fmt_desc))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pattern_fmt_desc>())).fmt as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pattern_fmt_desc),
"::",
stringify!(fmt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pattern_fmt_desc>())).len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(pattern_fmt_desc),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pattern_fmt_desc>())).paste as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(pattern_fmt_desc),
"::",
stringify!(paste)
)
);
}
#[doc = " Pattern format. The output of 'parse_pattern'."]
#[doc = " Describes the exact position inside the xbuffer."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pattern_fmt {
pub off: cty::c_uint,
pub desc: *const pattern_fmt_desc,
}
#[test]
fn bindgen_test_layout_pattern_fmt() {
assert_eq!(
::core::mem::size_of::<pattern_fmt>(),
16usize,
concat!("Size of: ", stringify!(pattern_fmt))
);
assert_eq!(
::core::mem::align_of::<pattern_fmt>(),
8usize,
concat!("Alignment of ", stringify!(pattern_fmt))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pattern_fmt>())).off as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pattern_fmt),
"::",
stringify!(off)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<pattern_fmt>())).desc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(pattern_fmt),
"::",
stringify!(desc)
)
);
}
pub const ERROR_TYPE_NONE: error_type = 0;
pub const ERROR_TYPE_READ: error_type = 1;
pub const ERROR_TYPE_WRITE: error_type = 2;
pub const ERROR_TYPE_VERIFY: error_type = 4;
pub const ERROR_TYPE_ANY: error_type = 65535;
pub type error_type = cty::c_uint;
pub const ZONE_MODE_NOT_SPECIFIED: fio_zone_mode = 0;
pub const ZONE_MODE_NONE: fio_zone_mode = 1;
pub const ZONE_MODE_STRIDED: fio_zone_mode = 2;
pub const ZONE_MODE_ZBD: fio_zone_mode = 3;
pub type fio_zone_mode = cty::c_uint;
pub const MEM_MALLOC: fio_memtype = 0;
pub const MEM_SHM: fio_memtype = 1;
pub const MEM_SHMHUGE: fio_memtype = 2;
pub const MEM_MMAP: fio_memtype = 3;
pub const MEM_MMAPHUGE: fio_memtype = 4;
pub const MEM_MMAPSHARED: fio_memtype = 5;
pub const MEM_CUDA_MALLOC: fio_memtype = 6;
pub type fio_memtype = cty::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bssplit {
pub bs: u64,
pub perc: u32,
}
#[test]
fn bindgen_test_layout_bssplit() {
assert_eq!(
::core::mem::size_of::<bssplit>(),
16usize,
concat!("Size of: ", stringify!(bssplit))
);
assert_eq!(
::core::mem::align_of::<bssplit>(),
8usize,
concat!("Alignment of ", stringify!(bssplit))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<bssplit>())).bs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(bssplit),
"::",
stringify!(bs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<bssplit>())).perc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(bssplit),
"::",
stringify!(perc)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zone_split {
pub access_perc: u8,
pub size_perc: u8,
pub pad: [u8; 6usize],
pub size: u64,
}
#[test]
fn bindgen_test_layout_zone_split() {
assert_eq!(
::core::mem::size_of::<zone_split>(),
16usize,
concat!("Size of: ", stringify!(zone_split))
);
assert_eq!(
::core::mem::align_of::<zone_split>(),
8usize,
concat!("Alignment of ", stringify!(zone_split))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split>())).access_perc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zone_split),
"::",
stringify!(access_perc)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split>())).size_perc as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(zone_split),
"::",
stringify!(size_perc)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split>())).pad as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(zone_split),
"::",
stringify!(pad)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zone_split),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct thread_options {
pub magic: cty::c_int,
pub set_options: [u64; 8usize],
pub description: *mut cty::c_char,
pub name: *mut cty::c_char,
pub wait_for: *mut cty::c_char,
pub directory: *mut cty::c_char,
pub filename: *mut cty::c_char,
pub filename_format: *mut cty::c_char,
pub opendir: *mut cty::c_char,
pub ioengine: *mut cty::c_char,
pub ioengine_so_path: *mut cty::c_char,
pub mmapfile: *mut cty::c_char,
pub td_ddir: td_ddir,
pub rw_seq: cty::c_uint,
pub kb_base: cty::c_uint,
pub unit_base: cty::c_uint,
pub ddir_seq_nr: cty::c_uint,
pub ddir_seq_add: cty::c_longlong,
pub iodepth: cty::c_uint,
pub iodepth_low: cty::c_uint,
pub iodepth_batch: cty::c_uint,
pub iodepth_batch_complete_min: cty::c_uint,
pub iodepth_batch_complete_max: cty::c_uint,
pub serialize_overlap: cty::c_uint,
pub unique_filename: cty::c_uint,
pub size: cty::c_ulonglong,
pub io_size: cty::c_ulonglong,
pub size_percent: cty::c_uint,
pub size_nz: cty::c_uint,
pub io_size_percent: cty::c_uint,
pub io_size_nz: cty::c_uint,
pub fill_device: cty::c_uint,
pub file_append: cty::c_uint,
pub file_size_low: cty::c_ulonglong,
pub file_size_high: cty::c_ulonglong,
pub start_offset: cty::c_ulonglong,
pub start_offset_align: cty::c_ulonglong,
pub start_offset_nz: cty::c_uint,
pub bs: [cty::c_ulonglong; 3usize],
pub ba: [cty::c_ulonglong; 3usize],
pub min_bs: [cty::c_ulonglong; 3usize],
pub max_bs: [cty::c_ulonglong; 3usize],
pub bssplit: [*mut bssplit; 3usize],
pub bssplit_nr: [cty::c_uint; 3usize],
pub ignore_error: [*mut cty::c_int; 3usize],
pub ignore_error_nr: [cty::c_uint; 3usize],
pub error_dump: cty::c_uint,
pub nr_files: cty::c_uint,
pub open_files: cty::c_uint,
pub file_lock_mode: file_lock_mode,
pub odirect: cty::c_uint,
pub oatomic: cty::c_uint,
pub invalidate_cache: cty::c_uint,
pub create_serialize: cty::c_uint,
pub create_fsync: cty::c_uint,
pub create_on_open: cty::c_uint,
pub create_only: cty::c_uint,
pub end_fsync: cty::c_uint,
pub pre_read: cty::c_uint,
pub sync_io: cty::c_uint,
pub write_hint: cty::c_uint,
pub verify: cty::c_uint,
pub do_verify: cty::c_uint,
pub verify_interval: cty::c_uint,
pub verify_offset: cty::c_uint,
pub verify_pattern: [cty::c_char; 512usize],
pub verify_pattern_bytes: cty::c_uint,
pub verify_fmt: [pattern_fmt; 8usize],
pub verify_fmt_sz: cty::c_uint,
pub verify_fatal: cty::c_uint,
pub verify_dump: cty::c_uint,
pub verify_async: cty::c_uint,
pub verify_backlog: cty::c_ulonglong,
pub verify_batch: cty::c_uint,
pub experimental_verify: cty::c_uint,
pub verify_state: cty::c_uint,
pub verify_state_save: cty::c_uint,
pub use_thread: cty::c_uint,
pub unlink: cty::c_uint,
pub unlink_each_loop: cty::c_uint,
pub do_disk_util: cty::c_uint,
pub override_sync: cty::c_uint,
pub rand_repeatable: cty::c_uint,
pub allrand_repeatable: cty::c_uint,
pub rand_seed: cty::c_ulonglong,
pub log_avg_msec: cty::c_uint,
pub log_hist_msec: cty::c_uint,
pub log_hist_coarseness: cty::c_uint,
pub log_max: cty::c_uint,
pub log_offset: cty::c_uint,
pub log_gz: cty::c_uint,
pub log_gz_store: cty::c_uint,
pub log_unix_epoch: cty::c_uint,
pub norandommap: cty::c_uint,
pub softrandommap: cty::c_uint,
pub bs_unaligned: cty::c_uint,
pub fsync_on_close: cty::c_uint,
pub bs_is_seq_rand: cty::c_uint,
pub verify_only: cty::c_uint,
pub random_distribution: cty::c_uint,
pub exitall_error: cty::c_uint,
pub zone_split: [*mut zone_split; 3usize],
pub zone_split_nr: [cty::c_uint; 3usize],
pub zipf_theta: fio_fp64_t,
pub pareto_h: fio_fp64_t,
pub gauss_dev: fio_fp64_t,
pub random_center: fio_fp64_t,
pub random_generator: cty::c_uint,
pub perc_rand: [cty::c_uint; 3usize],
pub hugepage_size: cty::c_uint,
pub rw_min_bs: cty::c_ulonglong,
pub thinktime: cty::c_uint,
pub thinktime_spin: cty::c_uint,
pub thinktime_blocks: cty::c_uint,
pub thinktime_blocks_type: cty::c_uint,
pub fsync_blocks: cty::c_uint,
pub fdatasync_blocks: cty::c_uint,
pub barrier_blocks: cty::c_uint,
pub start_delay: cty::c_ulonglong,
pub start_delay_orig: cty::c_ulonglong,
pub start_delay_high: cty::c_ulonglong,
pub timeout: cty::c_ulonglong,
pub ramp_time: cty::c_ulonglong,
pub ss_state: cty::c_uint,
pub ss_limit: fio_fp64_t,
pub ss_dur: cty::c_ulonglong,
pub ss_ramp_time: cty::c_ulonglong,
pub overwrite: cty::c_uint,
pub bw_avg_time: cty::c_uint,
pub iops_avg_time: cty::c_uint,
pub loops: cty::c_uint,
pub zone_range: cty::c_ulonglong,
pub zone_size: cty::c_ulonglong,
pub zone_capacity: cty::c_ulonglong,
pub zone_skip: cty::c_ulonglong,
pub zone_skip_nz: u32,
pub zone_mode: fio_zone_mode,
pub lockmem: cty::c_ulonglong,
pub mem_type: fio_memtype,
pub mem_align: cty::c_uint,
pub max_latency: [cty::c_ulonglong; 3usize],
pub exit_what: cty::c_uint,
pub stonewall: cty::c_uint,
pub new_group: cty::c_uint,
pub numjobs: cty::c_uint,
pub cpumask: os_cpu_mask_t,
pub verify_cpumask: os_cpu_mask_t,
pub log_gz_cpumask: os_cpu_mask_t,
pub cpus_allowed_policy: cty::c_uint,
pub numa_cpunodes: *mut cty::c_char,
pub numa_mem_mode: cty::c_ushort,
pub numa_mem_prefer_node: cty::c_uint,
pub numa_memnodes: *mut cty::c_char,
pub gpu_dev_id: cty::c_uint,
pub start_offset_percent: cty::c_uint,
pub iolog: cty::c_uint,
pub rwmixcycle: cty::c_uint,
pub rwmix: [cty::c_uint; 3usize],
pub nice: cty::c_uint,
pub ioprio: cty::c_uint,
pub ioprio_class: cty::c_uint,
pub file_service_type: cty::c_uint,
pub group_reporting: cty::c_uint,
pub stats: cty::c_uint,
pub fadvise_hint: cty::c_uint,
pub fallocate_mode: fio_fallocate_mode,
pub zero_buffers: cty::c_uint,
pub refill_buffers: cty::c_uint,
pub scramble_buffers: cty::c_uint,
pub buffer_pattern: [cty::c_char; 512usize],
pub buffer_pattern_bytes: cty::c_uint,
pub compress_percentage: cty::c_uint,
pub compress_chunk: cty::c_uint,
pub dedupe_percentage: cty::c_uint,
pub time_based: cty::c_uint,
pub disable_lat: cty::c_uint,
pub disable_clat: cty::c_uint,
pub disable_slat: cty::c_uint,
pub disable_bw: cty::c_uint,
pub unified_rw_rep: cty::c_uint,
pub gtod_reduce: cty::c_uint,
pub gtod_cpu: cty::c_uint,
pub clocksource: fio_cs,
pub no_stall: cty::c_uint,
pub trim_percentage: cty::c_uint,
pub trim_batch: cty::c_uint,
pub trim_zero: cty::c_uint,
pub trim_backlog: cty::c_ulonglong,
pub clat_percentiles: cty::c_uint,
pub slat_percentiles: cty::c_uint,
pub lat_percentiles: cty::c_uint,
pub percentile_precision: cty::c_uint,
pub percentile_list: [fio_fp64_t; 20usize],
pub read_iolog_file: *mut cty::c_char,
pub read_iolog_chunked: bool_,
pub write_iolog_file: *mut cty::c_char,
pub merge_blktrace_file: *mut cty::c_char,
pub merge_blktrace_scalars: [fio_fp64_t; 20usize],
pub merge_blktrace_iters: [fio_fp64_t; 20usize],
pub write_bw_log: cty::c_uint,
pub write_lat_log: cty::c_uint,
pub write_iops_log: cty::c_uint,
pub write_hist_log: cty::c_uint,
pub bw_log_file: *mut cty::c_char,
pub lat_log_file: *mut cty::c_char,
pub iops_log_file: *mut cty::c_char,
pub hist_log_file: *mut cty::c_char,
pub replay_redirect: *mut cty::c_char,
pub exec_prerun: *mut cty::c_char,
pub exec_postrun: *mut cty::c_char,
pub rate: [u64; 3usize],
pub ratemin: [u64; 3usize],
pub ratecycle: cty::c_uint,
pub io_submit_mode: cty::c_uint,
pub rate_iops: [cty::c_uint; 3usize],
pub rate_iops_min: [cty::c_uint; 3usize],
pub rate_process: cty::c_uint,
pub rate_ign_think: cty::c_uint,
pub ioscheduler: *mut cty::c_char,
pub continue_on_error: error_type,
pub profile: *mut cty::c_char,
pub cgroup: *mut cty::c_char,
pub cgroup_weight: cty::c_uint,
pub cgroup_nodelete: cty::c_uint,
pub uid: cty::c_uint,
pub gid: cty::c_uint,
pub offset_increment_percent: cty::c_uint,
pub offset_increment_nz: cty::c_uint,
pub offset_increment: cty::c_ulonglong,
pub number_ios: cty::c_ulonglong,
pub sync_file_range: cty::c_uint,
pub latency_target: cty::c_ulonglong,
pub latency_window: cty::c_ulonglong,
pub latency_percentile: fio_fp64_t,
pub latency_run: u32,
pub flow_id: cty::c_int,
pub flow: cty::c_uint,
pub flow_sleep: cty::c_uint,
pub sig_figs: cty::c_uint,
pub block_error_hist: cty::c_uint,
pub replay_align: cty::c_uint,
pub replay_scale: cty::c_uint,
pub replay_time_scale: cty::c_uint,
pub replay_skip: cty::c_uint,
pub per_job_logs: cty::c_uint,
pub allow_create: cty::c_uint,
pub allow_mounted_write: cty::c_uint,
pub read_beyond_wp: cty::c_uint,
pub max_open_zones: cty::c_int,
pub job_max_open_zones: cty::c_uint,
pub zrt: fio_fp64_t,
pub zrf: fio_fp64_t,
}
#[test]
fn bindgen_test_layout_thread_options() {
assert_eq!(
::core::mem::size_of::<thread_options>(),
4152usize,
concat!("Size of: ", stringify!(thread_options))
);
assert_eq!(
::core::mem::align_of::<thread_options>(),
8usize,
concat!("Alignment of ", stringify!(thread_options))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).magic as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(magic)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).set_options as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(set_options)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).description as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).name as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).wait_for as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(wait_for)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).directory as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(directory)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).filename as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).filename_format as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(filename_format)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).opendir as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(opendir)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ioengine as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ioengine)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).ioengine_so_path as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ioengine_so_path)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).mmapfile as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(mmapfile)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).td_ddir as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(td_ddir)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rw_seq as *const _ as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rw_seq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).kb_base as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(kb_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).unit_base as *const _ as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(unit_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ddir_seq_nr as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ddir_seq_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ddir_seq_add as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ddir_seq_add)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).iodepth as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iodepth)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).iodepth_low as *const _ as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iodepth_low)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).iodepth_batch as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iodepth_batch)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).iodepth_batch_complete_min as *const _
as usize
},
196usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iodepth_batch_complete_min)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).iodepth_batch_complete_max as *const _
as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iodepth_batch_complete_max)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).serialize_overlap as *const _ as usize
},
204usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(serialize_overlap)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).unique_filename as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(unique_filename)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).size as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).io_size as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(io_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).size_percent as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(size_percent)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).size_nz as *const _ as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(size_nz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).io_size_percent as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(io_size_percent)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).io_size_nz as *const _ as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(io_size_nz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).fill_device as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(fill_device)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).file_append as *const _ as usize },
252usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(file_append)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).file_size_low as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(file_size_low)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).file_size_high as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(file_size_high)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).start_offset as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_offset)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).start_offset_align as *const _ as usize
},
280usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_offset_align)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).start_offset_nz as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_offset_nz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bs as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ba as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ba)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).min_bs as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(min_bs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).max_bs as *const _ as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(max_bs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bssplit as *const _ as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bssplit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bssplit_nr as *const _ as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bssplit_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ignore_error as *const _ as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ignore_error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ignore_error_nr as *const _ as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ignore_error_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).error_dump as *const _ as usize },
468usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(error_dump)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).nr_files as *const _ as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(nr_files)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).open_files as *const _ as usize },
476usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(open_files)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).file_lock_mode as *const _ as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(file_lock_mode)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).odirect as *const _ as usize },
484usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(odirect)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).oatomic as *const _ as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(oatomic)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).invalidate_cache as *const _ as usize
},
492usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(invalidate_cache)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).create_serialize as *const _ as usize
},
496usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(create_serialize)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).create_fsync as *const _ as usize },
500usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(create_fsync)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).create_on_open as *const _ as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(create_on_open)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).create_only as *const _ as usize },
508usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(create_only)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).end_fsync as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(end_fsync)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).pre_read as *const _ as usize },
516usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(pre_read)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).sync_io as *const _ as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(sync_io)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).write_hint as *const _ as usize },
524usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(write_hint)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify as *const _ as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).do_verify as *const _ as usize },
532usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(do_verify)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_interval as *const _ as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_interval)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_offset as *const _ as usize },
540usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_pattern as *const _ as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_pattern)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).verify_pattern_bytes as *const _ as usize
},
1056usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_pattern_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_fmt as *const _ as usize },
1064usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_fmt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_fmt_sz as *const _ as usize },
1192usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_fmt_sz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_fatal as *const _ as usize },
1196usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_fatal)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_dump as *const _ as usize },
1200usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_dump)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_async as *const _ as usize },
1204usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_async)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_backlog as *const _ as usize },
1208usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_backlog)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_batch as *const _ as usize },
1216usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_batch)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).experimental_verify as *const _ as usize
},
1220usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(experimental_verify)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_state as *const _ as usize },
1224usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_state)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).verify_state_save as *const _ as usize
},
1228usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_state_save)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).use_thread as *const _ as usize },
1232usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(use_thread)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).unlink as *const _ as usize },
1236usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(unlink)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).unlink_each_loop as *const _ as usize
},
1240usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(unlink_each_loop)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).do_disk_util as *const _ as usize },
1244usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(do_disk_util)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).override_sync as *const _ as usize },
1248usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(override_sync)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rand_repeatable as *const _ as usize },
1252usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rand_repeatable)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).allrand_repeatable as *const _ as usize
},
1256usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(allrand_repeatable)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rand_seed as *const _ as usize },
1264usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rand_seed)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_avg_msec as *const _ as usize },
1272usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_avg_msec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_hist_msec as *const _ as usize },
1276usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_hist_msec)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).log_hist_coarseness as *const _ as usize
},
1280usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_hist_coarseness)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_max as *const _ as usize },
1284usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_max)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_offset as *const _ as usize },
1288usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_gz as *const _ as usize },
1292usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_gz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_gz_store as *const _ as usize },
1296usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_gz_store)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_unix_epoch as *const _ as usize },
1300usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_unix_epoch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).norandommap as *const _ as usize },
1304usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(norandommap)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).softrandommap as *const _ as usize },
1308usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(softrandommap)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bs_unaligned as *const _ as usize },
1312usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bs_unaligned)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).fsync_on_close as *const _ as usize },
1316usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(fsync_on_close)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bs_is_seq_rand as *const _ as usize },
1320usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bs_is_seq_rand)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_only as *const _ as usize },
1324usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_only)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).random_distribution as *const _ as usize
},
1328usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(random_distribution)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).exitall_error as *const _ as usize },
1332usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(exitall_error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_split as *const _ as usize },
1336usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_split)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_split_nr as *const _ as usize },
1360usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_split_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zipf_theta as *const _ as usize },
1376usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zipf_theta)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).pareto_h as *const _ as usize },
1392usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(pareto_h)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).gauss_dev as *const _ as usize },
1408usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(gauss_dev)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).random_center as *const _ as usize },
1424usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(random_center)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).random_generator as *const _ as usize
},
1440usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(random_generator)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).perc_rand as *const _ as usize },
1444usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(perc_rand)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).hugepage_size as *const _ as usize },
1456usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(hugepage_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rw_min_bs as *const _ as usize },
1464usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rw_min_bs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).thinktime as *const _ as usize },
1472usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(thinktime)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).thinktime_spin as *const _ as usize },
1476usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(thinktime_spin)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).thinktime_blocks as *const _ as usize
},
1480usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(thinktime_blocks)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).thinktime_blocks_type as *const _ as usize
},
1484usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(thinktime_blocks_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).fsync_blocks as *const _ as usize },
1488usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(fsync_blocks)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).fdatasync_blocks as *const _ as usize
},
1492usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(fdatasync_blocks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).barrier_blocks as *const _ as usize },
1496usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(barrier_blocks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).start_delay as *const _ as usize },
1504usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_delay)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).start_delay_orig as *const _ as usize
},
1512usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_delay_orig)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).start_delay_high as *const _ as usize
},
1520usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_delay_high)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).timeout as *const _ as usize },
1528usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(timeout)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ramp_time as *const _ as usize },
1536usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ramp_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ss_state as *const _ as usize },
1544usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ss_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ss_limit as *const _ as usize },
1552usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ss_limit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ss_dur as *const _ as usize },
1568usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ss_dur)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ss_ramp_time as *const _ as usize },
1576usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ss_ramp_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).overwrite as *const _ as usize },
1584usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(overwrite)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bw_avg_time as *const _ as usize },
1588usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bw_avg_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).iops_avg_time as *const _ as usize },
1592usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iops_avg_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).loops as *const _ as usize },
1596usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(loops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_range as *const _ as usize },
1600usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_range)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_size as *const _ as usize },
1608usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_capacity as *const _ as usize },
1616usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_capacity)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_skip as *const _ as usize },
1624usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_skip)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_skip_nz as *const _ as usize },
1632usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_skip_nz)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zone_mode as *const _ as usize },
1636usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zone_mode)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).lockmem as *const _ as usize },
1640usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(lockmem)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).mem_type as *const _ as usize },
1648usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(mem_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).mem_align as *const _ as usize },
1652usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(mem_align)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).max_latency as *const _ as usize },
1656usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(max_latency)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).exit_what as *const _ as usize },
1680usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(exit_what)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).stonewall as *const _ as usize },
1684usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(stonewall)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).new_group as *const _ as usize },
1688usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(new_group)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).numjobs as *const _ as usize },
1692usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(numjobs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).cpumask as *const _ as usize },
1696usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(cpumask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).verify_cpumask as *const _ as usize },
1824usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(verify_cpumask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).log_gz_cpumask as *const _ as usize },
1952usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(log_gz_cpumask)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).cpus_allowed_policy as *const _ as usize
},
2080usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(cpus_allowed_policy)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).numa_cpunodes as *const _ as usize },
2088usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(numa_cpunodes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).numa_mem_mode as *const _ as usize },
2096usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(numa_mem_mode)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).numa_mem_prefer_node as *const _ as usize
},
2100usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(numa_mem_prefer_node)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).numa_memnodes as *const _ as usize },
2104usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(numa_memnodes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).gpu_dev_id as *const _ as usize },
2112usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(gpu_dev_id)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).start_offset_percent as *const _ as usize
},
2116usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(start_offset_percent)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).iolog as *const _ as usize },
2120usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iolog)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rwmixcycle as *const _ as usize },
2124usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rwmixcycle)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rwmix as *const _ as usize },
2128usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rwmix)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).nice as *const _ as usize },
2140usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(nice)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ioprio as *const _ as usize },
2144usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ioprio)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ioprio_class as *const _ as usize },
2148usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ioprio_class)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).file_service_type as *const _ as usize
},
2152usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(file_service_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).group_reporting as *const _ as usize },
2156usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(group_reporting)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).stats as *const _ as usize },
2160usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(stats)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).fadvise_hint as *const _ as usize },
2164usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(fadvise_hint)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).fallocate_mode as *const _ as usize },
2168usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(fallocate_mode)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zero_buffers as *const _ as usize },
2172usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zero_buffers)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).refill_buffers as *const _ as usize },
2176usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(refill_buffers)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).scramble_buffers as *const _ as usize
},
2180usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(scramble_buffers)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).buffer_pattern as *const _ as usize },
2184usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(buffer_pattern)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).buffer_pattern_bytes as *const _ as usize
},
2696usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(buffer_pattern_bytes)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).compress_percentage as *const _ as usize
},
2700usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(compress_percentage)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).compress_chunk as *const _ as usize },
2704usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(compress_chunk)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).dedupe_percentage as *const _ as usize
},
2708usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(dedupe_percentage)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).time_based as *const _ as usize },
2712usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(time_based)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).disable_lat as *const _ as usize },
2716usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(disable_lat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).disable_clat as *const _ as usize },
2720usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(disable_clat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).disable_slat as *const _ as usize },
2724usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(disable_slat)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).disable_bw as *const _ as usize },
2728usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(disable_bw)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).unified_rw_rep as *const _ as usize },
2732usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(unified_rw_rep)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).gtod_reduce as *const _ as usize },
2736usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(gtod_reduce)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).gtod_cpu as *const _ as usize },
2740usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(gtod_cpu)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).clocksource as *const _ as usize },
2744usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(clocksource)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).no_stall as *const _ as usize },
2748usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(no_stall)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).trim_percentage as *const _ as usize },
2752usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(trim_percentage)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).trim_batch as *const _ as usize },
2756usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(trim_batch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).trim_zero as *const _ as usize },
2760usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(trim_zero)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).trim_backlog as *const _ as usize },
2768usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(trim_backlog)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).clat_percentiles as *const _ as usize
},
2776usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(clat_percentiles)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).slat_percentiles as *const _ as usize
},
2780usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(slat_percentiles)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).lat_percentiles as *const _ as usize },
2784usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(lat_percentiles)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).percentile_precision as *const _ as usize
},
2788usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(percentile_precision)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).percentile_list as *const _ as usize },
2792usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(percentile_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).read_iolog_file as *const _ as usize },
3112usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(read_iolog_file)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).read_iolog_chunked as *const _ as usize
},
3120usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(read_iolog_chunked)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).write_iolog_file as *const _ as usize
},
3128usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(write_iolog_file)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).merge_blktrace_file as *const _ as usize
},
3136usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(merge_blktrace_file)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).merge_blktrace_scalars as *const _ as usize
},
3144usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(merge_blktrace_scalars)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).merge_blktrace_iters as *const _ as usize
},
3464usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(merge_blktrace_iters)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).write_bw_log as *const _ as usize },
3784usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(write_bw_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).write_lat_log as *const _ as usize },
3788usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(write_lat_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).write_iops_log as *const _ as usize },
3792usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(write_iops_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).write_hist_log as *const _ as usize },
3796usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(write_hist_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).bw_log_file as *const _ as usize },
3800usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(bw_log_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).lat_log_file as *const _ as usize },
3808usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(lat_log_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).iops_log_file as *const _ as usize },
3816usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(iops_log_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).hist_log_file as *const _ as usize },
3824usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(hist_log_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).replay_redirect as *const _ as usize },
3832usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(replay_redirect)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).exec_prerun as *const _ as usize },
3840usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(exec_prerun)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).exec_postrun as *const _ as usize },
3848usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(exec_postrun)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rate as *const _ as usize },
3856usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ratemin as *const _ as usize },
3880usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ratemin)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ratecycle as *const _ as usize },
3904usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ratecycle)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).io_submit_mode as *const _ as usize },
3908usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(io_submit_mode)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rate_iops as *const _ as usize },
3912usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rate_iops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rate_iops_min as *const _ as usize },
3924usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rate_iops_min)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rate_process as *const _ as usize },
3936usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rate_process)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).rate_ign_think as *const _ as usize },
3940usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(rate_ign_think)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).ioscheduler as *const _ as usize },
3944usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(ioscheduler)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).continue_on_error as *const _ as usize
},
3952usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(continue_on_error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).profile as *const _ as usize },
3960usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(profile)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).cgroup as *const _ as usize },
3968usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(cgroup)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).cgroup_weight as *const _ as usize },
3976usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(cgroup_weight)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).cgroup_nodelete as *const _ as usize },
3980usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(cgroup_nodelete)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).uid as *const _ as usize },
3984usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(uid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).gid as *const _ as usize },
3988usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(gid)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).offset_increment_percent as *const _
as usize
},
3992usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(offset_increment_percent)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).offset_increment_nz as *const _ as usize
},
3996usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(offset_increment_nz)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).offset_increment as *const _ as usize
},
4000usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(offset_increment)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).number_ios as *const _ as usize },
4008usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(number_ios)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).sync_file_range as *const _ as usize },
4016usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(sync_file_range)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).latency_target as *const _ as usize },
4024usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(latency_target)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).latency_window as *const _ as usize },
4032usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(latency_window)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).latency_percentile as *const _ as usize
},
4040usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(latency_percentile)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).latency_run as *const _ as usize },
4056usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(latency_run)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).flow_id as *const _ as usize },
4060usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(flow_id)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).flow as *const _ as usize },
4064usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(flow)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).flow_sleep as *const _ as usize },
4068usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(flow_sleep)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).sig_figs as *const _ as usize },
4072usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(sig_figs)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).block_error_hist as *const _ as usize
},
4076usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(block_error_hist)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).replay_align as *const _ as usize },
4080usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(replay_align)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).replay_scale as *const _ as usize },
4084usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(replay_scale)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).replay_time_scale as *const _ as usize
},
4088usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(replay_time_scale)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).replay_skip as *const _ as usize },
4092usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(replay_skip)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).per_job_logs as *const _ as usize },
4096usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(per_job_logs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).allow_create as *const _ as usize },
4100usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(allow_create)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).allow_mounted_write as *const _ as usize
},
4104usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(allow_mounted_write)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).read_beyond_wp as *const _ as usize },
4108usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(read_beyond_wp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).max_open_zones as *const _ as usize },
4112usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(max_open_zones)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_options>())).job_max_open_zones as *const _ as usize
},
4116usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(job_max_open_zones)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zrt as *const _ as usize },
4120usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zrt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_options>())).zrf as *const _ as usize },
4136usize,
concat!(
"Offset of field: ",
stringify!(thread_options),
"::",
stringify!(zrf)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct prof_io_ops {
pub td_init: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data) -> cty::c_int>,
pub td_exit: ::core::option::Option<unsafe extern "C" fn(arg1: *mut thread_data)>,
pub io_u_lat: ::core::option::Option<
unsafe extern "C" fn(arg1: *mut thread_data, arg2: u64) -> cty::c_int,
>,
}
#[test]
fn bindgen_test_layout_prof_io_ops() {
assert_eq!(
::core::mem::size_of::<prof_io_ops>(),
24usize,
concat!("Size of: ", stringify!(prof_io_ops))
);
assert_eq!(
::core::mem::align_of::<prof_io_ops>(),
8usize,
concat!("Alignment of ", stringify!(prof_io_ops))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<prof_io_ops>())).td_init as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(prof_io_ops),
"::",
stringify!(td_init)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<prof_io_ops>())).td_exit as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(prof_io_ops),
"::",
stringify!(td_exit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<prof_io_ops>())).io_u_lat as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(prof_io_ops),
"::",
stringify!(io_u_lat)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sk_out {
pub refs: cty::c_uint,
pub sk: cty::c_int,
pub lock: fio_sem,
pub list: flist_head,
pub wait: fio_sem,
pub xmit: fio_sem,
}
#[test]
fn bindgen_test_layout_sk_out() {
assert_eq!(
::core::mem::size_of::<sk_out>(),
336usize,
concat!("Size of: ", stringify!(sk_out))
);
assert_eq!(
::core::mem::align_of::<sk_out>(),
8usize,
concat!("Alignment of ", stringify!(sk_out))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sk_out>())).refs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sk_out),
"::",
stringify!(refs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sk_out>())).sk as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(sk_out),
"::",
stringify!(sk)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sk_out>())).lock as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sk_out),
"::",
stringify!(lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sk_out>())).list as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(sk_out),
"::",
stringify!(list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sk_out>())).wait as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sk_out),
"::",
stringify!(wait)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sk_out>())).xmit as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(sk_out),
"::",
stringify!(xmit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct io_u_queue {
pub io_us: *mut *mut io_u,
pub nr: cty::c_uint,
pub max: cty::c_uint,
}
#[test]
fn bindgen_test_layout_io_u_queue() {
assert_eq!(
::core::mem::size_of::<io_u_queue>(),
16usize,
concat!("Size of: ", stringify!(io_u_queue))
);
assert_eq!(
::core::mem::align_of::<io_u_queue>(),
8usize,
concat!("Alignment of ", stringify!(io_u_queue))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_queue>())).io_us as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u_queue),
"::",
stringify!(io_us)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_queue>())).nr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(io_u_queue),
"::",
stringify!(nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_queue>())).max as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(io_u_queue),
"::",
stringify!(max)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct io_u_ring {
pub head: cty::c_uint,
pub tail: cty::c_uint,
pub max: cty::c_uint,
pub ring: *mut *mut io_u,
}
#[test]
fn bindgen_test_layout_io_u_ring() {
assert_eq!(
::core::mem::size_of::<io_u_ring>(),
24usize,
concat!("Size of: ", stringify!(io_u_ring))
);
assert_eq!(
::core::mem::align_of::<io_u_ring>(),
8usize,
concat!("Alignment of ", stringify!(io_u_ring))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_ring>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(io_u_ring),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_ring>())).tail as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(io_u_ring),
"::",
stringify!(tail)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_ring>())).max as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(io_u_ring),
"::",
stringify!(max)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<io_u_ring>())).ring as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(io_u_ring),
"::",
stringify!(ring)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct steadystate_data {
pub limit: f64,
pub dur: cty::c_ulonglong,
pub ramp_time: cty::c_ulonglong,
pub state: u32,
pub head: cty::c_uint,
pub tail: cty::c_uint,
pub iops_data: *mut u64,
pub bw_data: *mut u64,
pub slope: f64,
pub deviation: f64,
pub criterion: f64,
pub sum_y: u64,
pub sum_x: u64,
pub sum_x_sq: u64,
pub sum_xy: u64,
pub oldest_y: u64,
pub prev_time: timespec,
pub prev_iops: u64,
pub prev_bytes: u64,
}
#[test]
fn bindgen_test_layout_steadystate_data() {
assert_eq!(
::core::mem::size_of::<steadystate_data>(),
152usize,
concat!("Size of: ", stringify!(steadystate_data))
);
assert_eq!(
::core::mem::align_of::<steadystate_data>(),
8usize,
concat!("Alignment of ", stringify!(steadystate_data))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).limit as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(limit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).dur as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(dur)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).ramp_time as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(ramp_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).state as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).head as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).tail as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(tail)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).iops_data as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(iops_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).bw_data as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(bw_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).slope as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(slope)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).deviation as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(deviation)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).criterion as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(criterion)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).sum_y as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(sum_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).sum_x as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(sum_x)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).sum_x_sq as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(sum_x_sq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).sum_xy as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(sum_xy)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).oldest_y as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(oldest_y)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).prev_time as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(prev_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).prev_iops as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(prev_iops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<steadystate_data>())).prev_bytes as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(steadystate_data),
"::",
stringify!(prev_bytes)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zone_split_index {
pub size_perc: u8,
pub size_perc_prev: u8,
pub size: u64,
pub size_prev: u64,
}
#[test]
fn bindgen_test_layout_zone_split_index() {
assert_eq!(
::core::mem::size_of::<zone_split_index>(),
24usize,
concat!("Size of: ", stringify!(zone_split_index))
);
assert_eq!(
::core::mem::align_of::<zone_split_index>(),
8usize,
concat!("Alignment of ", stringify!(zone_split_index))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split_index>())).size_perc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(zone_split_index),
"::",
stringify!(size_perc)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<zone_split_index>())).size_perc_prev as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(zone_split_index),
"::",
stringify!(size_perc_prev)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split_index>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(zone_split_index),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<zone_split_index>())).size_prev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(zone_split_index),
"::",
stringify!(size_prev)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct thread_data {
pub opt_list: flist_head,
pub flags: cty::c_ulong,
pub o: thread_options,
pub eo: *mut cty::c_void,
pub thread: pthread_t,
pub thread_number: cty::c_uint,
pub subjob_number: cty::c_uint,
pub groupid: cty::c_uint,
pub ts: thread_stat,
pub client_type: cty::c_int,
pub slat_log: *mut io_log,
pub clat_log: *mut io_log,
pub clat_hist_log: *mut io_log,
pub lat_log: *mut io_log,
pub bw_log: *mut io_log,
pub iops_log: *mut io_log,
pub log_compress_wq: workqueue,
pub parent: *mut thread_data,
pub stat_io_bytes: [u64; 3usize],
pub bw_sample_time: timespec,
pub stat_io_blocks: [u64; 3usize],
pub iops_sample_time: timespec,
pub update_rusage: cty::c_int,
pub rusage_sem: *mut fio_sem,
pub ru_start: rusage,
pub ru_end: rusage,
pub files: *mut *mut fio_file,
pub file_locks: *mut cty::c_uchar,
pub files_size: cty::c_uint,
pub files_index: cty::c_uint,
pub nr_open_files: cty::c_uint,
pub nr_done_files: cty::c_uint,
pub __bindgen_anon_1: thread_data__bindgen_ty_1,
pub __bindgen_anon_2: thread_data__bindgen_ty_2,
pub __bindgen_anon_3: thread_data__bindgen_ty_3,
pub random_center: f64,
pub error: cty::c_int,
pub sig: cty::c_int,
pub done: cty::c_int,
pub stop_io: cty::c_int,
pub pid: pid_t,
pub orig_buffer: *mut cty::c_char,
pub orig_buffer_size: size_t,
pub runstate: cty::c_int,
pub terminate: bool,
pub last_was_sync: bool,
pub last_ddir: fio_ddir,
pub mmapfd: cty::c_int,
pub iolog_buf: *mut cty::c_void,
pub iolog_f: *mut FILE,
pub rand_seeds: [u64; 20usize],
pub bsrange_state: [frand_state; 3usize],
pub verify_state: frand_state,
pub trim_state: frand_state,
pub delay_state: frand_state,
pub buf_state: frand_state,
pub buf_state_prev: frand_state,
pub dedupe_state: frand_state,
pub zone_state: frand_state,
pub prio_state: frand_state,
pub zone_state_index: *mut *mut zone_split_index,
pub num_open_zones: cty::c_uint,
pub verify_batch: cty::c_uint,
pub trim_batch: cty::c_uint,
pub vstate: *mut thread_io_list,
pub shm_id: cty::c_int,
pub io_ops: *mut ioengine_ops,
pub io_ops_init: cty::c_int,
pub io_ops_data: *mut cty::c_void,
pub cur_depth: cty::c_uint,
pub io_u_queued: cty::c_uint,
pub io_u_in_flight: cty::c_uint,
pub io_u_requeues: io_u_ring,
pub io_u_freelist: io_u_queue,
pub io_u_all: io_u_queue,
pub io_u_lock: pthread_mutex_t,
pub free_cond: pthread_cond_t,
pub verify_list: flist_head,
pub verify_threads: *mut pthread_t,
pub nr_verify_threads: cty::c_uint,
pub verify_cond: pthread_cond_t,
pub verify_thread_exit: cty::c_int,
pub rate_bps: [u64; 3usize],
pub rate_next_io_time: [u64; 3usize],
pub rate_bytes: [cty::c_ulonglong; 3usize],
pub rate_blocks: [cty::c_ulong; 3usize],
pub rate_io_issue_bytes: [cty::c_ulonglong; 3usize],
pub lastrate: [timespec; 3usize],
pub last_usec: [i64; 3usize],
pub poisson_state: [frand_state; 3usize],
pub io_wq: workqueue,
pub total_io_size: u64,
pub fill_device_size: u64,
pub io_issues: [u64; 3usize],
pub io_issue_bytes: [u64; 3usize],
pub loops: u64,
pub io_blocks: [u64; 3usize],
pub this_io_blocks: [u64; 3usize],
pub io_bytes: [u64; 3usize],
pub this_io_bytes: [u64; 3usize],
pub io_skip_bytes: u64,
pub zone_bytes: u64,
pub sem: *mut fio_sem,
pub bytes_done: [u64; 3usize],
pub thinktime_blocks_counter: *mut u64,
pub random_state: frand_state,
pub start: timespec,
pub epoch: timespec,
pub unix_epoch: cty::c_ulonglong,
pub last_issue: timespec,
pub time_offset: cty::c_long,
pub ts_cache: timespec,
pub terminate_time: timespec,
pub ts_cache_nr: cty::c_uint,
pub ts_cache_mask: cty::c_uint,
pub ramp_time_over: bool,
pub latency_ts: timespec,
pub latency_qd: cty::c_uint,
pub latency_qd_high: cty::c_uint,
pub latency_qd_low: cty::c_uint,
pub latency_failed: cty::c_uint,
pub latency_stable_count: cty::c_uint,
pub latency_ios: u64,
pub latency_end_run: cty::c_int,
pub rwmix_state: frand_state,
pub rwmix_issues: cty::c_ulong,
pub rwmix_ddir: fio_ddir,
pub ddir_seq_nr: cty::c_uint,
pub seq_rand_state: [frand_state; 3usize],
pub io_hist_tree: rb_root,
pub io_hist_list: flist_head,
pub io_hist_len: cty::c_ulong,
pub io_log_list: flist_head,
pub io_log_rfile: *mut FILE,
pub io_log_current: cty::c_uint,
pub io_log_checkmark: cty::c_uint,
pub io_log_highmark: cty::c_uint,
pub io_log_highmark_time: timespec,
pub trim_list: flist_head,
pub trim_entries: cty::c_ulong,
pub file_service_nr: cty::c_uint,
pub file_service_left: cty::c_uint,
pub file_service_file: *mut fio_file,
pub sync_file_range_nr: cty::c_uint,
pub file_size_state: frand_state,
pub total_err_count: cty::c_uint,
pub first_error: cty::c_int,
pub flow: *mut fio_flow,
pub flow_counter: cty::c_ulonglong,
pub prof_io_ops: prof_io_ops,
pub prof_data: *mut cty::c_void,
pub pinned_mem: *mut cty::c_void,
pub ss: steadystate_data,
pub verror: [cty::c_char; 128usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union thread_data__bindgen_ty_1 {
pub next_file: cty::c_uint,
pub next_file_state: frand_state,
}
#[test]
fn bindgen_test_layout_thread_data__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<thread_data__bindgen_ty_1>(),
48usize,
concat!("Size of: ", stringify!(thread_data__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<thread_data__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(thread_data__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_1>())).next_file as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_1),
"::",
stringify!(next_file)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_1>())).next_file_state as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_1),
"::",
stringify!(next_file_state)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union thread_data__bindgen_ty_2 {
pub next_file_zipf: zipf_state,
pub next_file_gauss: gauss_state,
}
#[test]
fn bindgen_test_layout_thread_data__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<thread_data__bindgen_ty_2>(),
104usize,
concat!("Size of: ", stringify!(thread_data__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<thread_data__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(thread_data__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_2>())).next_file_zipf as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_2),
"::",
stringify!(next_file_zipf)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_2>())).next_file_gauss as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_2),
"::",
stringify!(next_file_gauss)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union thread_data__bindgen_ty_3 {
pub zipf_theta: f64,
pub pareto_h: f64,
pub gauss_dev: f64,
}
#[test]
fn bindgen_test_layout_thread_data__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<thread_data__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(thread_data__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<thread_data__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(thread_data__bindgen_ty_3))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_3>())).zipf_theta as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_3),
"::",
stringify!(zipf_theta)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_3>())).pareto_h as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_3),
"::",
stringify!(pareto_h)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data__bindgen_ty_3>())).gauss_dev as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data__bindgen_ty_3),
"::",
stringify!(gauss_dev)
)
);
}
#[test]
fn bindgen_test_layout_thread_data() {
assert_eq!(
::core::mem::size_of::<thread_data>(),
281200usize,
concat!("Size of: ", stringify!(thread_data))
);
assert_eq!(
::core::mem::align_of::<thread_data>(),
8usize,
concat!("Alignment of ", stringify!(thread_data))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).opt_list as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(opt_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).o as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(o)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).eo as *const _ as usize },
4176usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(eo)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).thread as *const _ as usize },
4184usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(thread)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).thread_number as *const _ as usize },
4192usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(thread_number)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).subjob_number as *const _ as usize },
4196usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(subjob_number)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).groupid as *const _ as usize },
4200usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(groupid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ts as *const _ as usize },
4208usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ts)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).client_type as *const _ as usize },
277472usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(client_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).slat_log as *const _ as usize },
277480usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(slat_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).clat_log as *const _ as usize },
277488usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(clat_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).clat_hist_log as *const _ as usize },
277496usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(clat_hist_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).lat_log as *const _ as usize },
277504usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(lat_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).bw_log as *const _ as usize },
277512usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(bw_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).iops_log as *const _ as usize },
277520usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(iops_log)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).log_compress_wq as *const _ as usize },
277528usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(log_compress_wq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).parent as *const _ as usize },
277776usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).stat_io_bytes as *const _ as usize },
277784usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(stat_io_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).bw_sample_time as *const _ as usize },
277808usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(bw_sample_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).stat_io_blocks as *const _ as usize },
277824usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(stat_io_blocks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).iops_sample_time as *const _ as usize },
277848usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(iops_sample_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).update_rusage as *const _ as usize },
277864usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(update_rusage)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rusage_sem as *const _ as usize },
277872usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rusage_sem)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ru_start as *const _ as usize },
277880usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ru_start)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ru_end as *const _ as usize },
278024usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ru_end)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).files as *const _ as usize },
278168usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(files)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).file_locks as *const _ as usize },
278176usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(file_locks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).files_size as *const _ as usize },
278184usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(files_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).files_index as *const _ as usize },
278188usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(files_index)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).nr_open_files as *const _ as usize },
278192usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(nr_open_files)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).nr_done_files as *const _ as usize },
278196usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(nr_done_files)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).random_center as *const _ as usize },
278360usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(random_center)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).error as *const _ as usize },
278368usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).sig as *const _ as usize },
278372usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(sig)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).done as *const _ as usize },
278376usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(done)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).stop_io as *const _ as usize },
278380usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(stop_io)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).pid as *const _ as usize },
278384usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(pid)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).orig_buffer as *const _ as usize },
278392usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(orig_buffer)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).orig_buffer_size as *const _ as usize },
278400usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(orig_buffer_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).runstate as *const _ as usize },
278408usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(runstate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).terminate as *const _ as usize },
278412usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(terminate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).last_was_sync as *const _ as usize },
278413usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(last_was_sync)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).last_ddir as *const _ as usize },
278416usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(last_ddir)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).mmapfd as *const _ as usize },
278420usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(mmapfd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).iolog_buf as *const _ as usize },
278424usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(iolog_buf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).iolog_f as *const _ as usize },
278432usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(iolog_f)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rand_seeds as *const _ as usize },
278440usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rand_seeds)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).bsrange_state as *const _ as usize },
278600usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(bsrange_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verify_state as *const _ as usize },
278744usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verify_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).trim_state as *const _ as usize },
278792usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(trim_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).delay_state as *const _ as usize },
278840usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(delay_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).buf_state as *const _ as usize },
278888usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(buf_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).buf_state_prev as *const _ as usize },
278936usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(buf_state_prev)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).dedupe_state as *const _ as usize },
278984usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(dedupe_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).zone_state as *const _ as usize },
279032usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(zone_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).prio_state as *const _ as usize },
279080usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(prio_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).zone_state_index as *const _ as usize },
279128usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(zone_state_index)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).num_open_zones as *const _ as usize },
279136usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(num_open_zones)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verify_batch as *const _ as usize },
279140usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verify_batch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).trim_batch as *const _ as usize },
279144usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(trim_batch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).vstate as *const _ as usize },
279152usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(vstate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).shm_id as *const _ as usize },
279160usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(shm_id)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_ops as *const _ as usize },
279168usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_ops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_ops_init as *const _ as usize },
279176usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_ops_init)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_ops_data as *const _ as usize },
279184usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_ops_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).cur_depth as *const _ as usize },
279192usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(cur_depth)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_u_queued as *const _ as usize },
279196usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_u_queued)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_u_in_flight as *const _ as usize },
279200usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_u_in_flight)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_u_requeues as *const _ as usize },
279208usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_u_requeues)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_u_freelist as *const _ as usize },
279232usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_u_freelist)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_u_all as *const _ as usize },
279248usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_u_all)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_u_lock as *const _ as usize },
279264usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_u_lock)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).free_cond as *const _ as usize },
279304usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(free_cond)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verify_list as *const _ as usize },
279352usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verify_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verify_threads as *const _ as usize },
279368usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verify_threads)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).nr_verify_threads as *const _ as usize },
279376usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(nr_verify_threads)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verify_cond as *const _ as usize },
279384usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verify_cond)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verify_thread_exit as *const _ as usize },
279432usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verify_thread_exit)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rate_bps as *const _ as usize },
279440usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rate_bps)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rate_next_io_time as *const _ as usize },
279464usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rate_next_io_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rate_bytes as *const _ as usize },
279488usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rate_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rate_blocks as *const _ as usize },
279512usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rate_blocks)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data>())).rate_io_issue_bytes as *const _ as usize
},
279536usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rate_io_issue_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).lastrate as *const _ as usize },
279560usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(lastrate)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).last_usec as *const _ as usize },
279608usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(last_usec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).poisson_state as *const _ as usize },
279632usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(poisson_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_wq as *const _ as usize },
279776usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_wq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).total_io_size as *const _ as usize },
280024usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(total_io_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).fill_device_size as *const _ as usize },
280032usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(fill_device_size)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_issues as *const _ as usize },
280040usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_issues)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_issue_bytes as *const _ as usize },
280064usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_issue_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).loops as *const _ as usize },
280088usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(loops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_blocks as *const _ as usize },
280096usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_blocks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).this_io_blocks as *const _ as usize },
280120usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(this_io_blocks)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_bytes as *const _ as usize },
280144usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).this_io_bytes as *const _ as usize },
280168usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(this_io_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_skip_bytes as *const _ as usize },
280192usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_skip_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).zone_bytes as *const _ as usize },
280200usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(zone_bytes)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).sem as *const _ as usize },
280208usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(sem)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).bytes_done as *const _ as usize },
280216usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(bytes_done)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data>())).thinktime_blocks_counter as *const _ as usize
},
280240usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(thinktime_blocks_counter)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).random_state as *const _ as usize },
280248usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(random_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).start as *const _ as usize },
280296usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).epoch as *const _ as usize },
280312usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(epoch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).unix_epoch as *const _ as usize },
280328usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(unix_epoch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).last_issue as *const _ as usize },
280336usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(last_issue)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).time_offset as *const _ as usize },
280352usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(time_offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ts_cache as *const _ as usize },
280360usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ts_cache)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).terminate_time as *const _ as usize },
280376usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(terminate_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ts_cache_nr as *const _ as usize },
280392usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ts_cache_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ts_cache_mask as *const _ as usize },
280396usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ts_cache_mask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ramp_time_over as *const _ as usize },
280400usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ramp_time_over)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_ts as *const _ as usize },
280408usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_ts)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_qd as *const _ as usize },
280424usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_qd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_qd_high as *const _ as usize },
280428usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_qd_high)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_qd_low as *const _ as usize },
280432usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_qd_low)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_failed as *const _ as usize },
280436usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_failed)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data>())).latency_stable_count as *const _ as usize
},
280440usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_stable_count)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_ios as *const _ as usize },
280448usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_ios)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).latency_end_run as *const _ as usize },
280456usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(latency_end_run)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rwmix_state as *const _ as usize },
280464usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rwmix_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rwmix_issues as *const _ as usize },
280512usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rwmix_issues)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).rwmix_ddir as *const _ as usize },
280520usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(rwmix_ddir)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ddir_seq_nr as *const _ as usize },
280524usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ddir_seq_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).seq_rand_state as *const _ as usize },
280528usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(seq_rand_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_hist_tree as *const _ as usize },
280672usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_hist_tree)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_hist_list as *const _ as usize },
280680usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_hist_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_hist_len as *const _ as usize },
280696usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_hist_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_log_list as *const _ as usize },
280704usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_log_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_log_rfile as *const _ as usize },
280720usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_log_rfile)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_log_current as *const _ as usize },
280728usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_log_current)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_log_checkmark as *const _ as usize },
280732usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_log_checkmark)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).io_log_highmark as *const _ as usize },
280736usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_log_highmark)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<thread_data>())).io_log_highmark_time as *const _ as usize
},
280744usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(io_log_highmark_time)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).trim_list as *const _ as usize },
280760usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(trim_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).trim_entries as *const _ as usize },
280776usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(trim_entries)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).file_service_nr as *const _ as usize },
280784usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(file_service_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).file_service_left as *const _ as usize },
280788usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(file_service_left)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).file_service_file as *const _ as usize },
280792usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(file_service_file)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).sync_file_range_nr as *const _ as usize },
280800usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(sync_file_range_nr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).file_size_state as *const _ as usize },
280808usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(file_size_state)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).total_err_count as *const _ as usize },
280856usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(total_err_count)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).first_error as *const _ as usize },
280860usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(first_error)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).flow as *const _ as usize },
280864usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(flow)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).flow_counter as *const _ as usize },
280872usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(flow_counter)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).prof_io_ops as *const _ as usize },
280880usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(prof_io_ops)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).prof_data as *const _ as usize },
280904usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(prof_data)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).pinned_mem as *const _ as usize },
280912usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(pinned_mem)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).ss as *const _ as usize },
280920usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(ss)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<thread_data>())).verror as *const _ as usize },
281072usize,
concat!(
"Offset of field: ",
stringify!(thread_data),
"::",
stringify!(verror)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fio_rwlock {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct thread_io_list {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fio_flow {
pub _address: u8,
}