#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align> {
storage: Storage,
align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage, align: [] }
}
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub fn as_ptr(&self) -> *const T {
self as *const _ as *const T
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self as *mut _ as *mut T
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
#[repr(C)]
pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
impl<T> __BindgenUnionField<T> {
#[inline]
pub const fn new() -> Self {
__BindgenUnionField(::std::marker::PhantomData)
}
#[inline]
pub unsafe fn as_ref(&self) -> &T {
::std::mem::transmute(self)
}
#[inline]
pub unsafe fn as_mut(&mut self) -> &mut T {
::std::mem::transmute(self)
}
}
impl<T> ::std::default::Default for __BindgenUnionField<T> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
#[inline]
fn clone(&self) -> Self {
Self::new()
}
}
impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__BindgenUnionField")
}
}
impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
}
impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
true
}
}
impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
pub const _ENDIAN_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 31;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const _BITS_BYTESWAP_H: u32 = 1;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
pub const _STDINT_H: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const __BITS_PER_LONG: u32 = 64;
pub const SCOUTFS_INTEROP_VERSION: u32 = 0;
pub const SCOUTFS_SUPER_MAGIC: u32 = 1431257939;
pub const SCOUTFS_BLOCK_MAGIC_SUPER: u32 = 272384651;
pub const SCOUTFS_BLOCK_MAGIC_BTREE: u32 = 3851942253;
pub const SCOUTFS_BLOCK_MAGIC_BLOOM: u32 = 832132612;
pub const SCOUTFS_BLOCK_MAGIC_SRCH_BLOCK: u32 = 2306755197;
pub const SCOUTFS_BLOCK_MAGIC_SRCH_PARENT: u32 = 2990156293;
pub const SCOUTFS_BLOCK_MAGIC_ALLOC_LIST: u32 = 2324933763;
pub const SCOUTFS_BLOCK_SM_SHIFT: u32 = 12;
pub const SCOUTFS_BLOCK_SM_SIZE: u32 = 4096;
pub const SCOUTFS_BLOCK_SM_MASK: u32 = 4095;
pub const SCOUTFS_BLOCK_SM_SECTOR_SHIFT: u32 = 3;
pub const SCOUTFS_BLOCK_SM_SECTORS: u32 = 8;
pub const SCOUTFS_BLOCK_LG_SHIFT: u32 = 16;
pub const SCOUTFS_BLOCK_LG_SIZE: u32 = 65536;
pub const SCOUTFS_BLOCK_LG_MASK: u32 = 65535;
pub const SCOUTFS_BLOCK_LG_SECTOR_SHIFT: u32 = 7;
pub const SCOUTFS_BLOCK_LG_SECTORS: u32 = 128;
pub const SCOUTFS_BLOCK_SM_LG_SHIFT: u32 = 4;
pub const SCOUTFS_SUPER_BLKNO: u32 = 16;
pub const SCOUTFS_QUORUM_BLKNO: u32 = 64;
pub const SCOUTFS_QUORUM_BLOCKS: u32 = 64;
pub const SCOUTFS_DATA_DEV_START_BLKNO: u32 = 64;
pub const SCOUTFS_UNIQUE_NAME_MAX_BYTES: u32 = 64;
pub const SCOUTFS_BTREE_MAX_VAL_LEN: u32 = 896;
pub const SCOUTFS_BTREE_MAX_HEIGHT: u32 = 20;
pub const SCOUTFS_BTREE_VALUE_ALIGN: u32 = 8;
pub const SCOUTFS_ALLOC_OWNER_NONE: u32 = 0;
pub const SCOUTFS_ALLOC_OWNER_SERVER: u32 = 1;
pub const SCOUTFS_ALLOC_OWNER_MOUNT: u32 = 2;
pub const SCOUTFS_ALLOC_OWNER_SRCH: u32 = 3;
pub const SCOUTFS_MOUNTED_CLIENT_VOTER: u32 = 1;
pub const SCOUTFS_SRCH_LOG_BLOCK_LIMIT: u32 = 16;
pub const SCOUTFS_SRCH_COMPACT_ORDER: u32 = 2;
pub const SCOUTFS_SRCH_COMPACT_NR: u32 = 4;
pub const SCOUTFS_SRCH_COMPACT_FLAG_LOG: u32 = 1;
pub const SCOUTFS_SRCH_COMPACT_FLAG_SORTED: u32 = 2;
pub const SCOUTFS_SRCH_COMPACT_FLAG_DELETE: u32 = 4;
pub const SCOUTFS_SRCH_COMPACT_FLAG_DONE: u32 = 16;
pub const SCOUTFS_SRCH_COMPACT_FLAG_ERROR: u32 = 32;
pub const SCOUTFS_LOG_ITEM_FLAG_DELETION: u32 = 1;
pub const SCOUTFS_FOREST_BLOOM_NRS: u32 = 3;
pub const SCOUTFS_FOREST_BLOOM_FUNC_BITS: u32 = 19;
pub const SCOUTFS_INODE_INDEX_ZONE: u32 = 1;
pub const SCOUTFS_RID_ZONE: u32 = 2;
pub const SCOUTFS_FS_ZONE: u32 = 3;
pub const SCOUTFS_LOCK_ZONE: u32 = 4;
pub const SCOUTFS_LOG_TREES_ZONE: u32 = 6;
pub const SCOUTFS_LOCK_CLIENTS_ZONE: u32 = 7;
pub const SCOUTFS_TRANS_SEQ_ZONE: u32 = 8;
pub const SCOUTFS_MOUNTED_CLIENT_ZONE: u32 = 9;
pub const SCOUTFS_SRCH_ZONE: u32 = 10;
pub const SCOUTFS_FREE_EXTENT_ZONE: u32 = 11;
pub const SCOUTFS_INODE_INDEX_META_SEQ_TYPE: u32 = 1;
pub const SCOUTFS_INODE_INDEX_DATA_SEQ_TYPE: u32 = 2;
pub const SCOUTFS_INODE_INDEX_NR: u32 = 3;
pub const SCOUTFS_ORPHAN_TYPE: u32 = 1;
pub const SCOUTFS_INODE_TYPE: u32 = 1;
pub const SCOUTFS_XATTR_TYPE: u32 = 2;
pub const SCOUTFS_DIRENT_TYPE: u32 = 3;
pub const SCOUTFS_READDIR_TYPE: u32 = 4;
pub const SCOUTFS_LINK_BACKREF_TYPE: u32 = 5;
pub const SCOUTFS_SYMLINK_TYPE: u32 = 6;
pub const SCOUTFS_DATA_EXTENT_TYPE: u32 = 7;
pub const SCOUTFS_RENAME_TYPE: u32 = 1;
pub const SCOUTFS_SRCH_LOG_TYPE: u32 = 1;
pub const SCOUTFS_SRCH_BLOCKS_TYPE: u32 = 2;
pub const SCOUTFS_SRCH_PENDING_TYPE: u32 = 3;
pub const SCOUTFS_SRCH_BUSY_TYPE: u32 = 4;
pub const SCOUTFS_FREE_EXTENT_BLKNO_TYPE: u32 = 1;
pub const SCOUTFS_FREE_EXTENT_LEN_TYPE: u32 = 2;
pub const SEF_OFFLINE: u32 = 1;
pub const SEF_UNWRITTEN: u32 = 2;
pub const SCOUTFS_UUID_BYTES: u32 = 16;
pub const SCOUTFS_QUORUM_MAX_COUNT: u32 = 9;
pub const SCOUTFS_QUORUM_CYCLE_LO_MS: u32 = 10;
pub const SCOUTFS_QUORUM_CYCLE_HI_MS: u32 = 20;
pub const SCOUTFS_QUORUM_TERM_LO_MS: u32 = 250;
pub const SCOUTFS_QUORUM_TERM_HI_MS: u32 = 500;
pub const SCOUTFS_QUORUM_ELECTED_LOG_CYCLES: u32 = 10;
pub const SCOUTFS_FLAG_IS_META_BDEV: u32 = 1;
pub const SCOUTFS_ROOT_INO: u32 = 1;
pub const SCOUTFS_INO_FLAG_TRUNCATE: u32 = 1;
pub const SCOUTFS_SYMLINK_MAX_SIZE: u32 = 4096;
pub const SCOUTFS_NAME_LEN: u32 = 255;
pub const SCOUTFS_DIRENT_FIRST_POS: u32 = 2;
pub const SCOUTFS_XATTR_MAX_NAME_LEN: u32 = 255;
pub const SCOUTFS_XATTR_MAX_VAL_LEN: u32 = 65535;
pub const SCOUTFS_LOCK_INODE_GROUP_NR: u32 = 1024;
pub const SCOUTFS_LOCK_INODE_GROUP_MASK: u32 = 1023;
pub const SCOUTFS_LOCK_SEQ_GROUP_MASK: u32 = 1023;
pub const SCOUTFS_NET_GREETING_FLAG_FAREWELL: u32 = 1;
pub const SCOUTFS_NET_GREETING_FLAG_VOTER: u32 = 2;
pub const SCOUTFS_NET_FLAG_RESPONSE: u32 = 1;
pub const SCOUTFS_NET_MAX_DATA_LEN: u32 = 1100;
pub const FILEID_SCOUTFS: u32 = 129;
pub const FILEID_SCOUTFS_WITH_PARENT: u32 = 130;
pub const SCOUTFS_IOCTL_MAGIC: u8 = 115u8;
pub const SCOUTFS_IOC_DWO_READ: u32 = 1;
pub const SCOUTFS_IOC_DWO_WRITE: u32 = 2;
pub const SCOUTFS_IOC_DWO_CHANGE_SIZE: u32 = 4;
pub const SCOUTFS_IOC_SETATTR_MORE_OFFLINE: u32 = 1;
pub const SCOUTFS_SEARCH_XATTRS_OFLAG_END: u32 = 1;
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type __s8 = ::std::os::raw::c_schar;
pub type __u8 = ::std::os::raw::c_uchar;
pub type __s16 = ::std::os::raw::c_short;
pub type __u16 = ::std::os::raw::c_ushort;
pub type __s32 = ::std::os::raw::c_int;
pub type __u32 = ::std::os::raw::c_uint;
pub type __s64 = ::std::os::raw::c_longlong;
pub type __u64 = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __kernel_fd_set {
pub fds_bits: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___kernel_fd_set() {
assert_eq!(
::std::mem::size_of::<__kernel_fd_set>(),
128usize,
concat!("Size of: ", stringify!(__kernel_fd_set))
);
assert_eq!(
::std::mem::align_of::<__kernel_fd_set>(),
8usize,
concat!("Alignment of ", stringify!(__kernel_fd_set))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__kernel_fd_set>())).fds_bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__kernel_fd_set),
"::",
stringify!(fds_bits)
)
);
}
pub type __kernel_sighandler_t =
::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
pub type __kernel_key_t = ::std::os::raw::c_int;
pub type __kernel_mqd_t = ::std::os::raw::c_int;
pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
pub type __kernel_long_t = ::std::os::raw::c_long;
pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
pub type __kernel_ino_t = __kernel_ulong_t;
pub type __kernel_mode_t = ::std::os::raw::c_uint;
pub type __kernel_pid_t = ::std::os::raw::c_int;
pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
pub type __kernel_uid_t = ::std::os::raw::c_uint;
pub type __kernel_gid_t = ::std::os::raw::c_uint;
pub type __kernel_suseconds_t = __kernel_long_t;
pub type __kernel_daddr_t = ::std::os::raw::c_int;
pub type __kernel_uid32_t = ::std::os::raw::c_uint;
pub type __kernel_gid32_t = ::std::os::raw::c_uint;
pub type __kernel_size_t = __kernel_ulong_t;
pub type __kernel_ssize_t = __kernel_long_t;
pub type __kernel_ptrdiff_t = __kernel_long_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __kernel_fsid_t {
pub val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___kernel_fsid_t() {
assert_eq!(
::std::mem::size_of::<__kernel_fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__kernel_fsid_t))
);
assert_eq!(
::std::mem::align_of::<__kernel_fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__kernel_fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__kernel_fsid_t>())).val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__kernel_fsid_t),
"::",
stringify!(val)
)
);
}
pub type __kernel_off_t = __kernel_long_t;
pub type __kernel_loff_t = ::std::os::raw::c_longlong;
pub type __kernel_time_t = __kernel_long_t;
pub type __kernel_time64_t = ::std::os::raw::c_longlong;
pub type __kernel_clock_t = __kernel_long_t;
pub type __kernel_timer_t = ::std::os::raw::c_int;
pub type __kernel_clockid_t = ::std::os::raw::c_int;
pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
pub type __le16 = __u16;
pub type __be16 = __u16;
pub type __le32 = __u32;
pub type __be32 = __u32;
pub type __le64 = __u64;
pub type __be64 = __u64;
pub type __sum16 = __u16;
pub type __wsum = __u32;
pub type __poll_t = ::std::os::raw::c_uint;
pub type u8_ = ::std::os::raw::c_uchar;
pub type u16_ = ::std::os::raw::c_ushort;
pub type u32_ = ::std::os::raw::c_uint;
pub type s32 = ::std::os::raw::c_int;
pub type u64_ = ::std::os::raw::c_ulonglong;
pub type s64 = ::std::os::raw::c_longlong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_timespec {
pub sec: __le64,
pub nsec: __le32,
pub __pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_timespec() {
assert_eq!(
::std::mem::size_of::<scoutfs_timespec>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_timespec))
);
assert_eq!(
::std::mem::align_of::<scoutfs_timespec>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_timespec))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_timespec>())).sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_timespec),
"::",
stringify!(sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_timespec>())).nsec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_timespec),
"::",
stringify!(nsec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_timespec>())).__pad as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_timespec),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_inet_addr {
pub addr: __le32,
pub port: __le16,
pub __pad: [__u8; 2usize],
}
#[test]
fn bindgen_test_layout_scoutfs_inet_addr() {
assert_eq!(
::std::mem::size_of::<scoutfs_inet_addr>(),
8usize,
concat!("Size of: ", stringify!(scoutfs_inet_addr))
);
assert_eq!(
::std::mem::align_of::<scoutfs_inet_addr>(),
4usize,
concat!("Alignment of ", stringify!(scoutfs_inet_addr))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inet_addr>())).addr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inet_addr),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inet_addr>())).port as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inet_addr),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inet_addr>())).__pad as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inet_addr),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_block_header {
pub crc: __le32,
pub magic: __le32,
pub fsid: __le64,
pub seq: __le64,
pub blkno: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_block_header() {
assert_eq!(
::std::mem::size_of::<scoutfs_block_header>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_block_header))
);
assert_eq!(
::std::mem::align_of::<scoutfs_block_header>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_block_header))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).crc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_block_header),
"::",
stringify!(crc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).magic as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_block_header),
"::",
stringify!(magic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).fsid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_block_header),
"::",
stringify!(fsid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).seq as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_block_header),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_block_header>())).blkno as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_block_header),
"::",
stringify!(blkno)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_key {
pub _sk_first: __le64,
pub _sk_second: __le64,
pub _sk_third: __le64,
pub _sk_fourth: __u8,
pub sk_zone: __u8,
pub sk_type: __u8,
pub __pad: [__u8; 5usize],
}
#[test]
fn bindgen_test_layout_scoutfs_key() {
assert_eq!(
::std::mem::size_of::<scoutfs_key>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_key))
);
assert_eq!(
::std::mem::align_of::<scoutfs_key>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_key))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(_sk_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_second as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(_sk_second)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_third as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(_sk_third)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>()))._sk_fourth as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(_sk_fourth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>())).sk_zone as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(sk_zone)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>())).sk_type as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(sk_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_key>())).__pad as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_key),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
pub struct scoutfs_radix_block {
pub hdr: scoutfs_block_header,
pub __bindgen_anon_1: scoutfs_radix_block__bindgen_ty_1,
}
#[repr(C)]
pub struct scoutfs_radix_block__bindgen_ty_1 {
pub refs: __BindgenUnionField<[scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref; 0usize]>,
pub bits: __BindgenUnionField<[__le64; 0usize]>,
pub bindgen_union_field: [u64; 0usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref {
pub blkno: __le64,
pub seq: __le64,
pub sm_total: __le64,
pub lg_total: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref() {
assert_eq!(
::std::mem::size_of::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>(),
32usize,
concat!(
"Size of: ",
stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref)
)
);
assert_eq!(
::std::mem::align_of::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>(),
8usize,
concat!(
"Alignment of ",
stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).blkno
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
"::",
stringify!(blkno)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).seq
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).sm_total
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
"::",
stringify!(sm_total)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref>())).lg_total
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block__bindgen_ty_1_scoutfs_radix_ref),
"::",
stringify!(lg_total)
)
);
}
#[test]
fn bindgen_test_layout_scoutfs_radix_block__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<scoutfs_radix_block__bindgen_ty_1>(),
0usize,
concat!("Size of: ", stringify!(scoutfs_radix_block__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<scoutfs_radix_block__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(scoutfs_radix_block__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1>())).refs as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block__bindgen_ty_1),
"::",
stringify!(refs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_radix_block__bindgen_ty_1>())).bits as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block__bindgen_ty_1),
"::",
stringify!(bits)
)
);
}
impl Default for scoutfs_radix_block__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_scoutfs_radix_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_radix_block>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_radix_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_radix_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_radix_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_radix_block>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_radix_block),
"::",
stringify!(hdr)
)
);
}
impl Default for scoutfs_radix_block {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_avl_root {
pub node: __le16,
}
#[test]
fn bindgen_test_layout_scoutfs_avl_root() {
assert_eq!(
::std::mem::size_of::<scoutfs_avl_root>(),
2usize,
concat!("Size of: ", stringify!(scoutfs_avl_root))
);
assert_eq!(
::std::mem::align_of::<scoutfs_avl_root>(),
2usize,
concat!("Alignment of ", stringify!(scoutfs_avl_root))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_avl_root>())).node as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_avl_root),
"::",
stringify!(node)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_avl_node {
pub parent: __le16,
pub left: __le16,
pub right: __le16,
pub height: __u8,
pub __pad: [__u8; 1usize],
}
#[test]
fn bindgen_test_layout_scoutfs_avl_node() {
assert_eq!(
::std::mem::size_of::<scoutfs_avl_node>(),
8usize,
concat!("Size of: ", stringify!(scoutfs_avl_node))
);
assert_eq!(
::std::mem::align_of::<scoutfs_avl_node>(),
2usize,
concat!("Alignment of ", stringify!(scoutfs_avl_node))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).parent as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_avl_node),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).left as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_avl_node),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).right as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_avl_node),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).height as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_avl_node),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_avl_node>())).__pad as *const _ as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_avl_node),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_btree_ref {
pub blkno: __le64,
pub seq: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_btree_ref() {
assert_eq!(
::std::mem::size_of::<scoutfs_btree_ref>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_btree_ref))
);
assert_eq!(
::std::mem::align_of::<scoutfs_btree_ref>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_btree_ref))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_ref>())).blkno as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_ref),
"::",
stringify!(blkno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_ref>())).seq as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_ref),
"::",
stringify!(seq)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_btree_root {
pub ref_: scoutfs_btree_ref,
pub height: __u8,
pub __pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_btree_root() {
assert_eq!(
::std::mem::size_of::<scoutfs_btree_root>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_btree_root))
);
assert_eq!(
::std::mem::align_of::<scoutfs_btree_root>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_btree_root))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_root>())).ref_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_root),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_root>())).height as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_root),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_root>())).__pad as *const _ as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_root),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_btree_item {
pub node: scoutfs_avl_node,
pub key: scoutfs_key,
pub val_off: __le16,
pub val_len: __le16,
pub __pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_btree_item() {
assert_eq!(
::std::mem::size_of::<scoutfs_btree_item>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_btree_item))
);
assert_eq!(
::std::mem::align_of::<scoutfs_btree_item>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_btree_item))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).node as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_item),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).key as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_item),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).val_off as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_item),
"::",
stringify!(val_off)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).val_len as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_item),
"::",
stringify!(val_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_item>())).__pad as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_item),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_btree_block {
pub hdr: scoutfs_block_header,
pub item_root: scoutfs_avl_root,
pub nr_items: __le16,
pub total_item_bytes: __le16,
pub mid_free_len: __le16,
pub level: __u8,
pub __pad: [__u8; 7usize],
pub items: __IncompleteArrayField<scoutfs_btree_item>,
}
#[test]
fn bindgen_test_layout_scoutfs_btree_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_btree_block>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_btree_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_btree_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_btree_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).item_root as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(item_root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).nr_items as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(nr_items)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_btree_block>())).total_item_bytes as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(total_item_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_btree_block>())).mid_free_len as *const _ as usize
},
38usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(mid_free_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).level as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).__pad as *const _ as usize },
41usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_btree_block>())).items as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_btree_block),
"::",
stringify!(items)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_alloc_list_ref {
pub blkno: __le64,
pub seq: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_list_ref() {
assert_eq!(
::std::mem::size_of::<scoutfs_alloc_list_ref>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_alloc_list_ref))
);
assert_eq!(
::std::mem::align_of::<scoutfs_alloc_list_ref>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_alloc_list_ref))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_ref>())).blkno as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_ref),
"::",
stringify!(blkno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_ref>())).seq as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_ref),
"::",
stringify!(seq)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_alloc_list_head {
pub ref_: scoutfs_alloc_list_ref,
pub total_nr: __le64,
pub first_nr: __le32,
pub __pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_list_head() {
assert_eq!(
::std::mem::size_of::<scoutfs_alloc_list_head>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_alloc_list_head))
);
assert_eq!(
::std::mem::align_of::<scoutfs_alloc_list_head>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_alloc_list_head))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_head>())).ref_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_head),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_alloc_list_head>())).total_nr as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_head),
"::",
stringify!(total_nr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_alloc_list_head>())).first_nr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_head),
"::",
stringify!(first_nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_head>())).__pad as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_head),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_alloc_list_block {
pub hdr: scoutfs_block_header,
pub next: scoutfs_alloc_list_ref,
pub start: __le32,
pub nr: __le32,
pub blknos: __IncompleteArrayField<__le64>,
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_list_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_alloc_list_block>(),
56usize,
concat!("Size of: ", stringify!(scoutfs_alloc_list_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_alloc_list_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_alloc_list_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_block),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).next as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_block),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).start as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_block),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).nr as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_block),
"::",
stringify!(nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_list_block>())).blknos as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_list_block),
"::",
stringify!(blknos)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_alloc_root {
pub total_len: __le64,
pub root: scoutfs_btree_root,
}
#[test]
fn bindgen_test_layout_scoutfs_alloc_root() {
assert_eq!(
::std::mem::size_of::<scoutfs_alloc_root>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_alloc_root))
);
assert_eq!(
::std::mem::align_of::<scoutfs_alloc_root>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_alloc_root))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_root>())).total_len as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_root),
"::",
stringify!(total_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_alloc_root>())).root as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_alloc_root),
"::",
stringify!(root)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_mounted_client_btree_val {
pub flags: __u8,
}
#[test]
fn bindgen_test_layout_scoutfs_mounted_client_btree_val() {
assert_eq!(
::std::mem::size_of::<scoutfs_mounted_client_btree_val>(),
1usize,
concat!("Size of: ", stringify!(scoutfs_mounted_client_btree_val))
);
assert_eq!(
::std::mem::align_of::<scoutfs_mounted_client_btree_val>(),
1usize,
concat!(
"Alignment of ",
stringify!(scoutfs_mounted_client_btree_val)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_mounted_client_btree_val>())).flags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_mounted_client_btree_val),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_entry {
pub hash: __le64,
pub ino: __le64,
pub id: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_entry() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_entry>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_srch_entry))
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_entry>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_srch_entry))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_entry>())).hash as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_entry),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_entry>())).ino as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_entry),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_entry>())).id as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_entry),
"::",
stringify!(id)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_ref {
pub blkno: __le64,
pub seq: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_ref() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_ref>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_srch_ref))
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_ref>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_srch_ref))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_ref>())).blkno as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_ref),
"::",
stringify!(blkno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_ref>())).seq as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_ref),
"::",
stringify!(seq)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_file {
pub first: scoutfs_srch_entry,
pub last: scoutfs_srch_entry,
pub ref_: scoutfs_srch_ref,
pub blocks: __le64,
pub entries: __le64,
pub height: __u8,
pub __pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_srch_file() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_file>(),
88usize,
concat!("Size of: ", stringify!(scoutfs_srch_file))
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_file>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_srch_file))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).last as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).ref_ as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).blocks as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(blocks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).entries as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(entries)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).height as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_file>())).__pad as *const _ as usize },
81usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_file),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_srch_parent {
pub hdr: scoutfs_block_header,
pub refs: __IncompleteArrayField<scoutfs_srch_ref>,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_parent() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_parent>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_srch_parent))
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_parent>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_srch_parent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_parent>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_parent),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_parent>())).refs as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_parent),
"::",
stringify!(refs)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_srch_block {
pub hdr: scoutfs_block_header,
pub first: scoutfs_srch_entry,
pub last: scoutfs_srch_entry,
pub tail: scoutfs_srch_entry,
pub entry_nr: __le32,
pub entry_bytes: __le32,
pub entries: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_block>(),
112usize,
concat!("Size of: ", stringify!(scoutfs_srch_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_srch_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).first as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).last as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).tail as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(tail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).entry_nr as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(entry_nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).entry_bytes as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(entry_bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_block>())).entries as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_block),
"::",
stringify!(entries)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_compact {
pub meta_avail: scoutfs_alloc_list_head,
pub meta_freed: scoutfs_alloc_list_head,
pub id: __le64,
pub nr: __u8,
pub flags: __u8,
pub __pad: [__u8; 6usize],
pub out: scoutfs_srch_file,
pub in_: [scoutfs_srch_compact_scoutfs_srch_compact_input; 4usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_srch_compact_scoutfs_srch_compact_input {
pub sfl: scoutfs_srch_file,
pub blk: __le64,
pub pos: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_srch_compact_scoutfs_srch_compact_input() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_compact_scoutfs_srch_compact_input>(),
104usize,
concat!(
"Size of: ",
stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input)
)
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_compact_scoutfs_srch_compact_input>(),
8usize,
concat!(
"Alignment of ",
stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_srch_compact_scoutfs_srch_compact_input>())).sfl
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input),
"::",
stringify!(sfl)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_srch_compact_scoutfs_srch_compact_input>())).blk
as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input),
"::",
stringify!(blk)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_srch_compact_scoutfs_srch_compact_input>())).pos
as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact_scoutfs_srch_compact_input),
"::",
stringify!(pos)
)
);
}
#[test]
fn bindgen_test_layout_scoutfs_srch_compact() {
assert_eq!(
::std::mem::size_of::<scoutfs_srch_compact>(),
584usize,
concat!("Size of: ", stringify!(scoutfs_srch_compact))
);
assert_eq!(
::std::mem::align_of::<scoutfs_srch_compact>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_srch_compact))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).meta_avail as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(meta_avail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).meta_freed as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(meta_freed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).id as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).nr as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).flags as *const _ as usize },
73usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).__pad as *const _ as usize },
74usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).out as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(out)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_srch_compact>())).in_ as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_srch_compact),
"::",
stringify!(in_)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_log_trees {
pub meta_avail: scoutfs_alloc_list_head,
pub meta_freed: scoutfs_alloc_list_head,
pub item_root: scoutfs_btree_root,
pub bloom_ref: scoutfs_btree_ref,
pub data_avail: scoutfs_alloc_root,
pub data_freed: scoutfs_alloc_root,
pub srch_file: scoutfs_srch_file,
pub max_item_vers: __le64,
pub rid: __le64,
pub nr: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_log_trees() {
assert_eq!(
::std::mem::size_of::<scoutfs_log_trees>(),
280usize,
concat!("Size of: ", stringify!(scoutfs_log_trees))
);
assert_eq!(
::std::mem::align_of::<scoutfs_log_trees>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_log_trees))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).meta_avail as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(meta_avail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).meta_freed as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(meta_freed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).item_root as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(item_root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).bloom_ref as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(bloom_ref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).data_avail as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(data_avail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).data_freed as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(data_freed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).srch_file as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(srch_file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).max_item_vers as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(max_item_vers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).rid as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(rid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_trees>())).nr as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_trees),
"::",
stringify!(nr)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_log_item_value {
pub vers: __le64,
pub flags: __u8,
pub __pad: [__u8; 7usize],
pub data: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_log_item_value() {
assert_eq!(
::std::mem::size_of::<scoutfs_log_item_value>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_log_item_value))
);
assert_eq!(
::std::mem::align_of::<scoutfs_log_item_value>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_log_item_value))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).vers as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_item_value),
"::",
stringify!(vers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_item_value),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).__pad as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_item_value),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_log_item_value>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_log_item_value),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_bloom_block {
pub hdr: scoutfs_block_header,
pub total_set: __le64,
pub bits: __IncompleteArrayField<__le64>,
}
#[test]
fn bindgen_test_layout_scoutfs_bloom_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_bloom_block>(),
40usize,
concat!("Size of: ", stringify!(scoutfs_bloom_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_bloom_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_bloom_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_bloom_block>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_bloom_block),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_bloom_block>())).total_set as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_bloom_block),
"::",
stringify!(total_set)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_bloom_block>())).bits as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_bloom_block),
"::",
stringify!(bits)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_data_extent_val {
pub blkno: __le64,
pub flags: __u8,
pub __pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_data_extent_val() {
assert_eq!(
::std::mem::size_of::<scoutfs_data_extent_val>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_data_extent_val))
);
assert_eq!(
::std::mem::align_of::<scoutfs_data_extent_val>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_data_extent_val))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_data_extent_val>())).blkno as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_data_extent_val),
"::",
stringify!(blkno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_data_extent_val>())).flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_data_extent_val),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_data_extent_val>())).__pad as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_data_extent_val),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_xattr {
pub val_len: __le16,
pub name_len: __u8,
pub __pad: [__u8; 5usize],
pub name: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_xattr() {
assert_eq!(
::std::mem::size_of::<scoutfs_xattr>(),
8usize,
concat!("Size of: ", stringify!(scoutfs_xattr))
);
assert_eq!(
::std::mem::align_of::<scoutfs_xattr>(),
2usize,
concat!("Alignment of ", stringify!(scoutfs_xattr))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).val_len as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_xattr),
"::",
stringify!(val_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).name_len as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_xattr),
"::",
stringify!(name_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).__pad as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_xattr),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_xattr>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_xattr),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_quorum_block {
pub fsid: __le64,
pub blkno: __le64,
pub term: __le64,
pub write_nr: __le64,
pub voter_rid: __le64,
pub vote_for_rid: __le64,
pub crc: __le32,
pub log_nr: __u8,
pub __pad: [__u8; 3usize],
pub log: __IncompleteArrayField<scoutfs_quorum_block_scoutfs_quorum_log>,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_quorum_block_scoutfs_quorum_log {
pub term: __le64,
pub rid: __le64,
pub addr: scoutfs_inet_addr,
}
#[test]
fn bindgen_test_layout_scoutfs_quorum_block_scoutfs_quorum_log() {
assert_eq!(
::std::mem::size_of::<scoutfs_quorum_block_scoutfs_quorum_log>(),
24usize,
concat!(
"Size of: ",
stringify!(scoutfs_quorum_block_scoutfs_quorum_log)
)
);
assert_eq!(
::std::mem::align_of::<scoutfs_quorum_block_scoutfs_quorum_log>(),
8usize,
concat!(
"Alignment of ",
stringify!(scoutfs_quorum_block_scoutfs_quorum_log)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_quorum_block_scoutfs_quorum_log>())).term as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block_scoutfs_quorum_log),
"::",
stringify!(term)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_quorum_block_scoutfs_quorum_log>())).rid as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block_scoutfs_quorum_log),
"::",
stringify!(rid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_quorum_block_scoutfs_quorum_log>())).addr as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block_scoutfs_quorum_log),
"::",
stringify!(addr)
)
);
}
#[test]
fn bindgen_test_layout_scoutfs_quorum_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_quorum_block>(),
56usize,
concat!("Size of: ", stringify!(scoutfs_quorum_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_quorum_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_quorum_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).fsid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(fsid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).blkno as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(blkno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).term as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(term)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).write_nr as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(write_nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).voter_rid as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(voter_rid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_quorum_block>())).vote_for_rid as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(vote_for_rid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).crc as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(crc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).log_nr as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(log_nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).__pad as *const _ as usize },
53usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_quorum_block>())).log as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_quorum_block),
"::",
stringify!(log)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_super_block {
pub hdr: scoutfs_block_header,
pub id: __le64,
pub version: __le64,
pub flags: __le64,
pub uuid: [__u8; 16usize],
pub next_ino: __le64,
pub next_trans_seq: __le64,
pub total_meta_blocks: __le64,
pub first_meta_blkno: __le64,
pub last_meta_blkno: __le64,
pub total_data_blocks: __le64,
pub first_data_blkno: __le64,
pub last_data_blkno: __le64,
pub quorum_fenced_term: __le64,
pub quorum_server_term: __le64,
pub unmount_barrier: __le64,
pub quorum_count: __u8,
pub __pad: [__u8; 7usize],
pub server_addr: scoutfs_inet_addr,
pub meta_alloc: [scoutfs_alloc_root; 2usize],
pub data_alloc: scoutfs_alloc_root,
pub server_meta_avail: [scoutfs_alloc_list_head; 2usize],
pub server_meta_freed: [scoutfs_alloc_list_head; 2usize],
pub fs_root: scoutfs_btree_root,
pub logs_root: scoutfs_btree_root,
pub lock_clients: scoutfs_btree_root,
pub trans_seqs: scoutfs_btree_root,
pub mounted_clients: scoutfs_btree_root,
pub srch_root: scoutfs_btree_root,
}
#[test]
fn bindgen_test_layout_scoutfs_super_block() {
assert_eq!(
::std::mem::size_of::<scoutfs_super_block>(),
544usize,
concat!("Size of: ", stringify!(scoutfs_super_block))
);
assert_eq!(
::std::mem::align_of::<scoutfs_super_block>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_super_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).hdr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).id as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).version as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).flags as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).uuid as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(uuid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).next_ino as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(next_ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).next_trans_seq as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(next_trans_seq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).total_meta_blocks as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(total_meta_blocks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).first_meta_blkno as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(first_meta_blkno)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).last_meta_blkno as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(last_meta_blkno)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).total_data_blocks as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(total_data_blocks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).first_data_blkno as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(first_data_blkno)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).last_data_blkno as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(last_data_blkno)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).quorum_fenced_term as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(quorum_fenced_term)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).quorum_server_term as *const _ as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(quorum_server_term)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).unmount_barrier as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(unmount_barrier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).quorum_count as *const _ as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(quorum_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).__pad as *const _ as usize },
161usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).server_addr as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(server_addr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).meta_alloc as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(meta_alloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).data_alloc as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(data_alloc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).server_meta_avail as *const _ as usize
},
272usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(server_meta_avail)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).server_meta_freed as *const _ as usize
},
336usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(server_meta_freed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).fs_root as *const _ as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(fs_root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).logs_root as *const _ as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(logs_root)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).lock_clients as *const _ as usize
},
448usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(lock_clients)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).trans_seqs as *const _ as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(trans_seqs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_super_block>())).mounted_clients as *const _ as usize
},
496usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(mounted_clients)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_super_block>())).srch_root as *const _ as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_super_block),
"::",
stringify!(srch_root)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_inode {
pub size: __le64,
pub meta_seq: __le64,
pub data_seq: __le64,
pub data_version: __le64,
pub online_blocks: __le64,
pub offline_blocks: __le64,
pub next_readdir_pos: __le64,
pub next_xattr_id: __le64,
pub nlink: __le32,
pub uid: __le32,
pub gid: __le32,
pub mode: __le32,
pub rdev: __le32,
pub flags: __le32,
pub atime: scoutfs_timespec,
pub ctime: scoutfs_timespec,
pub mtime: scoutfs_timespec,
}
#[test]
fn bindgen_test_layout_scoutfs_inode() {
assert_eq!(
::std::mem::size_of::<scoutfs_inode>(),
136usize,
concat!("Size of: ", stringify!(scoutfs_inode))
);
assert_eq!(
::std::mem::align_of::<scoutfs_inode>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_inode))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).meta_seq as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(meta_seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).data_seq as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(data_seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).data_version as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(data_version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).online_blocks as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(online_blocks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).offline_blocks as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(offline_blocks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).next_readdir_pos as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(next_readdir_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).next_xattr_id as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(next_xattr_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).nlink as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).uid as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).gid as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).mode as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).rdev as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(rdev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).flags as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).atime as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).ctime as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(ctime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_inode>())).mtime as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_inode),
"::",
stringify!(mtime)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_dirent {
pub ino: __le64,
pub hash: __le64,
pub pos: __le64,
pub type_: __u8,
pub __pad: [__u8; 7usize],
pub name: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_dirent() {
assert_eq!(
::std::mem::size_of::<scoutfs_dirent>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_dirent))
);
assert_eq!(
::std::mem::align_of::<scoutfs_dirent>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_dirent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).ino as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_dirent),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).hash as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_dirent),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).pos as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_dirent),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).type_ as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_dirent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).__pad as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_dirent),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_dirent>())).name as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_dirent),
"::",
stringify!(name)
)
);
}
pub const scoutfs_dentry_type_SCOUTFS_DT_FIFO: scoutfs_dentry_type = 0;
pub const scoutfs_dentry_type_SCOUTFS_DT_CHR: scoutfs_dentry_type = 1;
pub const scoutfs_dentry_type_SCOUTFS_DT_DIR: scoutfs_dentry_type = 2;
pub const scoutfs_dentry_type_SCOUTFS_DT_BLK: scoutfs_dentry_type = 3;
pub const scoutfs_dentry_type_SCOUTFS_DT_REG: scoutfs_dentry_type = 4;
pub const scoutfs_dentry_type_SCOUTFS_DT_LNK: scoutfs_dentry_type = 5;
pub const scoutfs_dentry_type_SCOUTFS_DT_SOCK: scoutfs_dentry_type = 6;
pub const scoutfs_dentry_type_SCOUTFS_DT_WHT: scoutfs_dentry_type = 7;
pub type scoutfs_dentry_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_greeting {
pub fsid: __le64,
pub version: __le64,
pub server_term: __le64,
pub unmount_barrier: __le64,
pub rid: __le64,
pub flags: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_net_greeting() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_greeting>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_net_greeting))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_greeting>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_greeting))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).fsid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_greeting),
"::",
stringify!(fsid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).version as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_greeting),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_net_greeting>())).server_term as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_greeting),
"::",
stringify!(server_term)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_net_greeting>())).unmount_barrier as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_greeting),
"::",
stringify!(unmount_barrier)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).rid as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_greeting),
"::",
stringify!(rid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_greeting>())).flags as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_greeting),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_net_header {
pub clock_sync_id: __le64,
pub seq: __le64,
pub recv_seq: __le64,
pub id: __le64,
pub data_len: __le16,
pub cmd: __u8,
pub flags: __u8,
pub error: __u8,
pub __pad: [__u8; 3usize],
pub data: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_net_header() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_header>(),
40usize,
concat!("Size of: ", stringify!(scoutfs_net_header))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_header>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_header))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_net_header>())).clock_sync_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(clock_sync_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).seq as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).recv_seq as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(recv_seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).id as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).data_len as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(data_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).cmd as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(cmd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).flags as *const _ as usize },
35usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).error as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).__pad as *const _ as usize },
37usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_header>())).data as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_header),
"::",
stringify!(data)
)
);
}
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GREETING: scoutfs_net_cmd = 0;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_ALLOC_INODES: scoutfs_net_cmd = 1;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GET_LOG_TREES: scoutfs_net_cmd = 2;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_COMMIT_LOG_TREES: scoutfs_net_cmd = 3;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GET_ROOTS: scoutfs_net_cmd = 4;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_ADVANCE_SEQ: scoutfs_net_cmd = 5;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_GET_LAST_SEQ: scoutfs_net_cmd = 6;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_LOCK: scoutfs_net_cmd = 7;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_LOCK_RECOVER: scoutfs_net_cmd = 8;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_SRCH_GET_COMPACT: scoutfs_net_cmd = 9;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_SRCH_COMMIT_COMPACT: scoutfs_net_cmd = 10;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_FAREWELL: scoutfs_net_cmd = 11;
pub const scoutfs_net_cmd_SCOUTFS_NET_CMD_UNKNOWN: scoutfs_net_cmd = 12;
pub type scoutfs_net_cmd = ::std::os::raw::c_uint;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_NONE: scoutfs_net_errors = 0;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_ENOENT: scoutfs_net_errors = 1;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_ENOMEM: scoutfs_net_errors = 2;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_EIO: scoutfs_net_errors = 3;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_ENOSPC: scoutfs_net_errors = 4;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_EINVAL: scoutfs_net_errors = 5;
pub const scoutfs_net_errors_SCOUTFS_NET_ERR_UNKNOWN: scoutfs_net_errors = 6;
pub type scoutfs_net_errors = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_inode_alloc {
pub ino: __le64,
pub nr: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_net_inode_alloc() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_inode_alloc>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_net_inode_alloc))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_inode_alloc>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_inode_alloc))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_inode_alloc>())).ino as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_inode_alloc),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_inode_alloc>())).nr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_inode_alloc),
"::",
stringify!(nr)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_roots {
pub fs_root: scoutfs_btree_root,
pub logs_root: scoutfs_btree_root,
pub srch_root: scoutfs_btree_root,
}
#[test]
fn bindgen_test_layout_scoutfs_net_roots() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_roots>(),
72usize,
concat!("Size of: ", stringify!(scoutfs_net_roots))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_roots>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_roots))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_roots>())).fs_root as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_roots),
"::",
stringify!(fs_root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_roots>())).logs_root as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_roots),
"::",
stringify!(logs_root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_roots>())).srch_root as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_roots),
"::",
stringify!(srch_root)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_lock {
pub key: scoutfs_key,
pub write_version: __le64,
pub old_mode: __u8,
pub new_mode: __u8,
pub __pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_net_lock() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_lock>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_net_lock))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_lock>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_lock))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).write_version as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock),
"::",
stringify!(write_version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).old_mode as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock),
"::",
stringify!(old_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).new_mode as *const _ as usize },
41usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock),
"::",
stringify!(new_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock>())).__pad as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock),
"::",
stringify!(__pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_net_lock_grant_response {
pub nl: scoutfs_net_lock,
pub roots: scoutfs_net_roots,
}
#[test]
fn bindgen_test_layout_scoutfs_net_lock_grant_response() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_lock_grant_response>(),
120usize,
concat!("Size of: ", stringify!(scoutfs_net_lock_grant_response))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_lock_grant_response>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_lock_grant_response))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_net_lock_grant_response>())).nl as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock_grant_response),
"::",
stringify!(nl)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_net_lock_grant_response>())).roots as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock_grant_response),
"::",
stringify!(roots)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_net_lock_recover {
pub nr: __le16,
pub __pad: [__u8; 6usize],
pub locks: __IncompleteArrayField<scoutfs_net_lock>,
}
#[test]
fn bindgen_test_layout_scoutfs_net_lock_recover() {
assert_eq!(
::std::mem::size_of::<scoutfs_net_lock_recover>(),
8usize,
concat!("Size of: ", stringify!(scoutfs_net_lock_recover))
);
assert_eq!(
::std::mem::align_of::<scoutfs_net_lock_recover>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_net_lock_recover))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock_recover>())).nr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock_recover),
"::",
stringify!(nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock_recover>())).__pad as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock_recover),
"::",
stringify!(__pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_net_lock_recover>())).locks as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_net_lock_recover),
"::",
stringify!(locks)
)
);
}
pub const scoutfs_lock_trace_SLT_CLIENT: scoutfs_lock_trace = 0;
pub const scoutfs_lock_trace_SLT_SERVER: scoutfs_lock_trace = 1;
pub const scoutfs_lock_trace_SLT_GRANT: scoutfs_lock_trace = 2;
pub const scoutfs_lock_trace_SLT_INVALIDATE: scoutfs_lock_trace = 3;
pub const scoutfs_lock_trace_SLT_REQUEST: scoutfs_lock_trace = 4;
pub const scoutfs_lock_trace_SLT_RESPONSE: scoutfs_lock_trace = 5;
pub type scoutfs_lock_trace = ::std::os::raw::c_uint;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_NULL: scoutfs_lock_mode = 0;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_READ: scoutfs_lock_mode = 1;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_WRITE: scoutfs_lock_mode = 2;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_WRITE_ONLY: scoutfs_lock_mode = 3;
pub const scoutfs_lock_mode_SCOUTFS_LOCK_INVALID: scoutfs_lock_mode = 4;
pub type scoutfs_lock_mode = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_fid {
pub ino: __le64,
pub parent_ino: __le64,
}
#[test]
fn bindgen_test_layout_scoutfs_fid() {
assert_eq!(
::std::mem::size_of::<scoutfs_fid>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_fid))
);
assert_eq!(
::std::mem::align_of::<scoutfs_fid>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_fid))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_fid>())).ino as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_fid),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_fid>())).parent_ino as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_fid),
"::",
stringify!(parent_ino)
)
);
}
pub const scoutfs_corruption_sources_SC_DIRENT_NAME_LEN: scoutfs_corruption_sources = 0;
pub const scoutfs_corruption_sources_SC_DIRENT_BACKREF_NAME_LEN: scoutfs_corruption_sources = 1;
pub const scoutfs_corruption_sources_SC_DIRENT_READDIR_NAME_LEN: scoutfs_corruption_sources = 2;
pub const scoutfs_corruption_sources_SC_SYMLINK_INODE_SIZE: scoutfs_corruption_sources = 3;
pub const scoutfs_corruption_sources_SC_SYMLINK_MISSING_ITEM: scoutfs_corruption_sources = 4;
pub const scoutfs_corruption_sources_SC_SYMLINK_NOT_NULL_TERM: scoutfs_corruption_sources = 5;
pub const scoutfs_corruption_sources_SC_BTREE_BLOCK_LEVEL: scoutfs_corruption_sources = 6;
pub const scoutfs_corruption_sources_SC_BTREE_NO_CHILD_REF: scoutfs_corruption_sources = 7;
pub const scoutfs_corruption_sources_SC_INODE_BLOCK_COUNTS: scoutfs_corruption_sources = 8;
pub const scoutfs_corruption_sources_SC_NR_SOURCES: scoutfs_corruption_sources = 9;
pub type scoutfs_corruption_sources = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_key {
pub _sk_first: __le64,
pub _sk_second: __le64,
pub _sk_third: __le64,
pub _sk_fourth: __u8,
pub sk_type: __u8,
pub sk_zone: __u8,
pub _pad: [__u8; 5usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_key() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_key>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_key))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_key>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_key))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(_sk_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_second as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(_sk_second)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_third as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(_sk_third)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._sk_fourth as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(_sk_fourth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>())).sk_type as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(sk_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>())).sk_zone as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(sk_zone)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_key>()))._pad as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_key),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_walk_inodes_entry {
pub major: __u64,
pub ino: __u64,
pub minor: __u32,
pub _pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_walk_inodes_entry() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_walk_inodes_entry>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_walk_inodes_entry))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_walk_inodes_entry>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_walk_inodes_entry))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>())).major as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes_entry),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>())).ino as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes_entry),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>())).minor as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes_entry),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes_entry>()))._pad as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes_entry),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_walk_inodes {
pub first: scoutfs_ioctl_walk_inodes_entry,
pub last: scoutfs_ioctl_walk_inodes_entry,
pub entries_ptr: __u64,
pub nr_entries: __u32,
pub index: __u8,
pub _pad: [__u8; 11usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_walk_inodes() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_walk_inodes>(),
72usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_walk_inodes))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_walk_inodes>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_walk_inodes))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes),
"::",
stringify!(first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).last as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).entries_ptr as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes),
"::",
stringify!(entries_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).nr_entries as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes),
"::",
stringify!(nr_entries)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>())).index as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_walk_inodes>()))._pad as *const _ as usize },
61usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_walk_inodes),
"::",
stringify!(_pad)
)
);
}
pub const scoutfs_ino_walk_seq_type_SCOUTFS_IOC_WALK_INODES_META_SEQ: scoutfs_ino_walk_seq_type = 0;
pub const scoutfs_ino_walk_seq_type_SCOUTFS_IOC_WALK_INODES_DATA_SEQ: scoutfs_ino_walk_seq_type = 1;
pub const scoutfs_ino_walk_seq_type_SCOUTFS_IOC_WALK_INODES_UNKNOWN: scoutfs_ino_walk_seq_type = 2;
pub type scoutfs_ino_walk_seq_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_ino_path {
pub ino: __u64,
pub dir_ino: __u64,
pub dir_pos: __u64,
pub result_ptr: __u64,
pub result_bytes: __u16,
pub _pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_ino_path() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_ino_path>(),
40usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_ino_path))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_ino_path>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_ino_path))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).ino as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).dir_ino as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path),
"::",
stringify!(dir_ino)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).dir_pos as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path),
"::",
stringify!(dir_pos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).result_ptr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path),
"::",
stringify!(result_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path>())).result_bytes as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path),
"::",
stringify!(result_bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_ino_path>()))._pad as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default)]
pub struct scoutfs_ioctl_ino_path_result {
pub dir_ino: __u64,
pub dir_pos: __u64,
pub path_bytes: __u16,
pub _pad: [__u8; 6usize],
pub path: __IncompleteArrayField<__u8>,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_ino_path_result() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_ino_path_result>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_ino_path_result))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_ino_path_result>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_ino_path_result))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).dir_ino as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path_result),
"::",
stringify!(dir_ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).dir_pos as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path_result),
"::",
stringify!(dir_pos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).path_bytes as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path_result),
"::",
stringify!(path_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>()))._pad as *const _ as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path_result),
"::",
stringify!(_pad)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_ino_path_result>())).path as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_ino_path_result),
"::",
stringify!(path)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_release {
pub offset: __u64,
pub length: __u64,
pub data_version: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_release() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_release>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_release))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_release>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_release))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_release>())).offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_release),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_release>())).length as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_release),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_release>())).data_version as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_release),
"::",
stringify!(data_version)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_stage {
pub data_version: __u64,
pub buf_ptr: __u64,
pub offset: __u64,
pub length: __s32,
pub _pad: __u32,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_stage() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_stage>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_stage))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_stage>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_stage))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stage>())).data_version as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stage),
"::",
stringify!(data_version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).buf_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stage),
"::",
stringify!(buf_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).offset as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stage),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>())).length as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stage),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_stage>()))._pad as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stage),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_stat_more {
pub valid_bytes: __u64,
pub meta_seq: __u64,
pub data_seq: __u64,
pub data_version: __u64,
pub online_blocks: __u64,
pub offline_blocks: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_stat_more() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_stat_more>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_stat_more))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_stat_more>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_stat_more))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).valid_bytes as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stat_more),
"::",
stringify!(valid_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).meta_seq as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stat_more),
"::",
stringify!(meta_seq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).data_seq as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stat_more),
"::",
stringify!(data_seq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).data_version as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stat_more),
"::",
stringify!(data_version)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).online_blocks as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stat_more),
"::",
stringify!(online_blocks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_stat_more>())).offline_blocks as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_stat_more),
"::",
stringify!(offline_blocks)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_data_waiting_entry {
pub ino: __u64,
pub iblock: __u64,
pub op: __u8,
pub _pad: [__u8; 7usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_data_waiting_entry() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_data_waiting_entry>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_data_waiting_entry))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_data_waiting_entry>(),
8usize,
concat!(
"Alignment of ",
stringify!(scoutfs_ioctl_data_waiting_entry)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>())).ino as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting_entry),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>())).iblock as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting_entry),
"::",
stringify!(iblock)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>())).op as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting_entry),
"::",
stringify!(op)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting_entry>()))._pad as *const _ as usize
},
17usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting_entry),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_data_waiting {
pub flags: __u64,
pub after_ino: __u64,
pub after_iblock: __u64,
pub ents_ptr: __u64,
pub ents_nr: __u16,
pub _pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_data_waiting() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_data_waiting>(),
40usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_data_waiting))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_data_waiting>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_data_waiting))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).flags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).after_ino as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting),
"::",
stringify!(after_ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).after_iblock as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting),
"::",
stringify!(after_iblock)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).ents_ptr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting),
"::",
stringify!(ents_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>())).ents_nr as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting),
"::",
stringify!(ents_nr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_waiting>()))._pad as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_waiting),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_setattr_more {
pub data_version: __u64,
pub i_size: __u64,
pub flags: __u64,
pub ctime_sec: __u64,
pub ctime_nsec: __u32,
pub _pad: [__u8; 4usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_setattr_more() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_setattr_more>(),
40usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_setattr_more))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_setattr_more>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_setattr_more))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).data_version as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_setattr_more),
"::",
stringify!(data_version)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).i_size as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_setattr_more),
"::",
stringify!(i_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).flags as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_setattr_more),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).ctime_sec as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_setattr_more),
"::",
stringify!(ctime_sec)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>())).ctime_nsec as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_setattr_more),
"::",
stringify!(ctime_nsec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_setattr_more>()))._pad as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_setattr_more),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_listxattr_hidden {
pub id_pos: __u64,
pub buf_ptr: __u64,
pub buf_bytes: __u32,
pub hash_pos: __u32,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_listxattr_hidden() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_listxattr_hidden>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_listxattr_hidden))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_listxattr_hidden>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_listxattr_hidden))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).id_pos as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_listxattr_hidden),
"::",
stringify!(id_pos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).buf_ptr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_listxattr_hidden),
"::",
stringify!(buf_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).buf_bytes as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_listxattr_hidden),
"::",
stringify!(buf_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_listxattr_hidden>())).hash_pos as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_listxattr_hidden),
"::",
stringify!(hash_pos)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_search_xattrs {
pub next_ino: __u64,
pub last_ino: __u64,
pub name_ptr: __u64,
pub inodes_ptr: __u64,
pub output_flags: __u64,
pub nr_inodes: __u64,
pub name_bytes: __u16,
pub _pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_search_xattrs() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_search_xattrs>(),
56usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_search_xattrs))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_search_xattrs>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_search_xattrs))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).next_ino as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(next_ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).last_ino as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(last_ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).name_ptr as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(name_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).inodes_ptr as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(inodes_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).output_flags as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(output_flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).nr_inodes as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(nr_inodes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>())).name_bytes as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(name_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_search_xattrs>()))._pad as *const _ as usize
},
50usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_search_xattrs),
"::",
stringify!(_pad)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_statfs_more {
pub valid_bytes: __u64,
pub fsid: __u64,
pub rid: __u64,
pub committed_seq: __u64,
pub total_meta_blocks: __u64,
pub total_data_blocks: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_statfs_more() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_statfs_more>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_statfs_more))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_statfs_more>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_statfs_more))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).valid_bytes as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_statfs_more),
"::",
stringify!(valid_bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).fsid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_statfs_more),
"::",
stringify!(fsid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).rid as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_statfs_more),
"::",
stringify!(rid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).committed_seq as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_statfs_more),
"::",
stringify!(committed_seq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).total_meta_blocks as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_statfs_more),
"::",
stringify!(total_meta_blocks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_statfs_more>())).total_data_blocks as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_statfs_more),
"::",
stringify!(total_data_blocks)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_data_wait_err {
pub ino: __u64,
pub data_version: __u64,
pub offset: __u64,
pub count: __u64,
pub op: __u64,
pub err: __s64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_data_wait_err() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_data_wait_err>(),
48usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_data_wait_err))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_data_wait_err>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_data_wait_err))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).ino as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_wait_err),
"::",
stringify!(ino)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).data_version as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_wait_err),
"::",
stringify!(data_version)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).offset as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_wait_err),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).count as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_wait_err),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).op as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_wait_err),
"::",
stringify!(op)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_data_wait_err>())).err as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_data_wait_err),
"::",
stringify!(err)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_alloc_detail {
pub entries_ptr: __u64,
pub entries_nr: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_alloc_detail() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_alloc_detail>(),
16usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_alloc_detail))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_alloc_detail>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_alloc_detail))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail>())).entries_ptr as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_alloc_detail),
"::",
stringify!(entries_ptr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail>())).entries_nr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_alloc_detail),
"::",
stringify!(entries_nr)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_alloc_detail_entry {
pub id: __u64,
pub blocks: __u64,
pub type_: __u8,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub __pad: [__u8; 6usize],
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_alloc_detail_entry() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_alloc_detail_entry>(),
24usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_alloc_detail_entry))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_alloc_detail_entry>(),
8usize,
concat!(
"Alignment of ",
stringify!(scoutfs_ioctl_alloc_detail_entry)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_alloc_detail_entry),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).blocks as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_alloc_detail_entry),
"::",
stringify!(blocks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).type_ as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_alloc_detail_entry),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_alloc_detail_entry>())).__pad as *const _ as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_alloc_detail_entry),
"::",
stringify!(__pad)
)
);
}
impl scoutfs_ioctl_alloc_detail_entry {
#[inline]
pub fn meta(&self) -> __u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_meta(&mut self, val: __u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn avail(&self) -> __u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_avail(&mut self, val: __u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn __bit_pad(&self) -> __u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
}
#[inline]
pub fn set___bit_pad(&mut self, val: __u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 6u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
meta: __u8,
avail: __u8,
__bit_pad: __u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let meta: u8 = unsafe { ::std::mem::transmute(meta) };
meta as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let avail: u8 = unsafe { ::std::mem::transmute(avail) };
avail as u64
});
__bindgen_bitfield_unit.set(2usize, 6u8, {
let __bit_pad: u8 = unsafe { ::std::mem::transmute(__bit_pad) };
__bit_pad as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct scoutfs_ioctl_move_blocks {
pub from_fd: __u64,
pub from_off: __u64,
pub len: __u64,
pub to_off: __u64,
}
#[test]
fn bindgen_test_layout_scoutfs_ioctl_move_blocks() {
assert_eq!(
::std::mem::size_of::<scoutfs_ioctl_move_blocks>(),
32usize,
concat!("Size of: ", stringify!(scoutfs_ioctl_move_blocks))
);
assert_eq!(
::std::mem::align_of::<scoutfs_ioctl_move_blocks>(),
8usize,
concat!("Alignment of ", stringify!(scoutfs_ioctl_move_blocks))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).from_fd as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_move_blocks),
"::",
stringify!(from_fd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).from_off as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_move_blocks),
"::",
stringify!(from_off)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).len as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_move_blocks),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<scoutfs_ioctl_move_blocks>())).to_off as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(scoutfs_ioctl_move_blocks),
"::",
stringify!(to_off)
)
);
}