pub const HAVE_SYS_TYPES_H: u32 = 1;
pub const EXT2_DEFAULT_PREALLOC_BLOCKS: u32 = 8;
pub const EXT2FS_DATE: &[u8; 9usize] = b"95/08/09\0";
pub const EXT2FS_VERSION: &[u8; 5usize] = b"0.5b\0";
pub const EXT2_BAD_INO: u32 = 1;
pub const EXT2_ROOT_INO: u32 = 2;
pub const EXT4_USR_QUOTA_INO: u32 = 3;
pub const EXT4_GRP_QUOTA_INO: u32 = 4;
pub const EXT2_BOOT_LOADER_INO: u32 = 5;
pub const EXT2_UNDEL_DIR_INO: u32 = 6;
pub const EXT2_RESIZE_INO: u32 = 7;
pub const EXT2_JOURNAL_INO: u32 = 8;
pub const EXT2_EXCLUDE_INO: u32 = 9;
pub const EXT4_REPLICA_INO: u32 = 10;
pub const EXT2_GOOD_OLD_FIRST_INO: u32 = 11;
pub const EXT2_SUPER_MAGIC: u32 = 61267;
pub const EXT2_LINK_MAX: u32 = 65000;
pub const EXT2_MIN_BLOCK_LOG_SIZE: u32 = 10;
pub const EXT2_MAX_BLOCK_LOG_SIZE: u32 = 16;
pub const EXT2_MIN_BLOCK_SIZE: u32 = 1024;
pub const EXT2_MAX_BLOCK_SIZE: u32 = 65536;
pub const EXT2_MIN_CLUSTER_LOG_SIZE: u32 = 10;
pub const EXT2_MAX_CLUSTER_LOG_SIZE: u32 = 29;
pub const EXT2_MIN_CLUSTER_SIZE: u32 = 1024;
pub const EXT2_MAX_CLUSTER_SIZE: u32 = 536870912;
pub const EXT2_MIN_FRAG_SIZE: u32 = 1024;
pub const EXT2_MAX_FRAG_SIZE: u32 = 65536;
pub const EXT2_MIN_FRAG_LOG_SIZE: u32 = 10;
pub const EXT2_BG_INODE_UNINIT: u32 = 1;
pub const EXT2_BG_BLOCK_UNINIT: u32 = 2;
pub const EXT2_BG_INODE_ZEROED: u32 = 4;
pub const EXT2_HASH_LEGACY: u32 = 0;
pub const EXT2_HASH_HALF_MD4: u32 = 1;
pub const EXT2_HASH_TEA: u32 = 2;
pub const EXT2_HASH_LEGACY_UNSIGNED: u32 = 3;
pub const EXT2_HASH_HALF_MD4_UNSIGNED: u32 = 4;
pub const EXT2_HASH_TEA_UNSIGNED: u32 = 5;
pub const EXT2_HASH_SIPHASH: u32 = 6;
pub const EXT2_HASH_FLAG_INCOMPAT: u32 = 1;
pub const EXT4_DX_BLOCK_MASK: u32 = 268435455;
pub const EXT2_MIN_DESC_SIZE: u32 = 32;
pub const EXT2_MIN_DESC_SIZE_64BIT: u32 = 64;
pub const EXT2_MAX_DESC_SIZE: u32 = 1024;
pub const EXT2_NDIR_BLOCKS: u32 = 12;
pub const EXT2_IND_BLOCK: u32 = 12;
pub const EXT2_DIND_BLOCK: u32 = 13;
pub const EXT2_TIND_BLOCK: u32 = 14;
pub const EXT2_N_BLOCKS: u32 = 15;
pub const EXT2_SECRM_FL: u32 = 1;
pub const EXT2_UNRM_FL: u32 = 2;
pub const EXT2_COMPR_FL: u32 = 4;
pub const EXT2_SYNC_FL: u32 = 8;
pub const EXT2_IMMUTABLE_FL: u32 = 16;
pub const EXT2_APPEND_FL: u32 = 32;
pub const EXT2_NODUMP_FL: u32 = 64;
pub const EXT2_NOATIME_FL: u32 = 128;
pub const EXT2_DIRTY_FL: u32 = 256;
pub const EXT2_COMPRBLK_FL: u32 = 512;
pub const EXT2_NOCOMPR_FL: u32 = 1024;
pub const EXT4_ENCRYPT_FL: u32 = 2048;
pub const EXT2_BTREE_FL: u32 = 4096;
pub const EXT2_INDEX_FL: u32 = 4096;
pub const EXT2_IMAGIC_FL: u32 = 8192;
pub const EXT3_JOURNAL_DATA_FL: u32 = 16384;
pub const EXT2_NOTAIL_FL: u32 = 32768;
pub const EXT2_DIRSYNC_FL: u32 = 65536;
pub const EXT2_TOPDIR_FL: u32 = 131072;
pub const EXT4_HUGE_FILE_FL: u32 = 262144;
pub const EXT4_EXTENTS_FL: u32 = 524288;
pub const EXT4_VERITY_FL: u32 = 1048576;
pub const EXT4_EA_INODE_FL: u32 = 2097152;
pub const FS_NOCOW_FL: u32 = 8388608;
pub const EXT4_SNAPFILE_FL: u32 = 16777216;
pub const FS_DAX_FL: u32 = 33554432;
pub const EXT4_SNAPFILE_DELETED_FL: u32 = 67108864;
pub const EXT4_SNAPFILE_SHRUNK_FL: u32 = 134217728;
pub const EXT4_INLINE_DATA_FL: u32 = 268435456;
pub const EXT4_PROJINHERIT_FL: u32 = 536870912;
pub const EXT4_CASEFOLD_FL: u32 = 1073741824;
pub const EXT2_RESERVED_FL: u32 = 2147483648;
pub const EXT2_FL_USER_VISIBLE: u32 = 1615585279;
pub const EXT2_FL_USER_MODIFIABLE: u32 = 1615560959;
pub const EXT4_EPOCH_BITS: u32 = 2;
pub const EXT4_EPOCH_MASK: u32 = 3;
pub const EXT2_VALID_FS: u32 = 1;
pub const EXT2_ERROR_FS: u32 = 2;
pub const EXT3_ORPHAN_FS: u32 = 4;
pub const EXT4_FC_REPLAY: u32 = 32;
pub const EXT2_FLAGS_SIGNED_HASH: u32 = 1;
pub const EXT2_FLAGS_UNSIGNED_HASH: u32 = 2;
pub const EXT2_FLAGS_TEST_FILESYS: u32 = 4;
pub const EXT2_FLAGS_IS_SNAPSHOT: u32 = 16;
pub const EXT2_FLAGS_FIX_SNAPSHOT: u32 = 32;
pub const EXT2_FLAGS_FIX_EXCLUDE: u32 = 64;
pub const EXT2_MOUNT_CHECK: u32 = 1;
pub const EXT2_MOUNT_GRPID: u32 = 4;
pub const EXT2_MOUNT_DEBUG: u32 = 8;
pub const EXT2_MOUNT_ERRORS_CONT: u32 = 16;
pub const EXT2_MOUNT_ERRORS_RO: u32 = 32;
pub const EXT2_MOUNT_ERRORS_PANIC: u32 = 64;
pub const EXT2_MOUNT_MINIX_DF: u32 = 128;
pub const EXT2_MOUNT_NO_UID32: u32 = 512;
pub const EXT2_DFL_MAX_MNT_COUNT: u32 = 20;
pub const EXT2_DFL_CHECKINTERVAL: u32 = 0;
pub const EXT2_ERRORS_CONTINUE: u32 = 1;
pub const EXT2_ERRORS_RO: u32 = 2;
pub const EXT2_ERRORS_PANIC: u32 = 3;
pub const EXT2_ERRORS_DEFAULT: u32 = 1;
pub const EXT2_CRC32C_CHKSUM: u32 = 1;
pub const EXT4_ENCRYPTION_MODE_INVALID: u32 = 0;
pub const EXT4_ENCRYPTION_MODE_AES_256_XTS: u32 = 1;
pub const EXT4_ENCRYPTION_MODE_AES_256_GCM: u32 = 2;
pub const EXT4_ENCRYPTION_MODE_AES_256_CBC: u32 = 3;
pub const EXT4_ENCRYPTION_MODE_AES_256_CTS: u32 = 4;
pub const EXT4_AES_256_XTS_KEY_SIZE: u32 = 64;
pub const EXT4_AES_256_GCM_KEY_SIZE: u32 = 32;
pub const EXT4_AES_256_CBC_KEY_SIZE: u32 = 32;
pub const EXT4_AES_256_CTS_KEY_SIZE: u32 = 32;
pub const EXT4_MAX_KEY_SIZE: u32 = 64;
pub const EXT4_KEY_DESCRIPTOR_SIZE: u32 = 8;
pub const EXT4_CRYPTO_BLOCK_SIZE: u32 = 16;
pub const EXT4_MAX_PASSPHRASE_SIZE: u32 = 1024;
pub const EXT4_MAX_SALT_SIZE: u32 = 256;
pub const EXT4_PBKDF2_ITERATIONS: u32 = 65535;
pub const EXT2_LABEL_LEN: u32 = 16;
pub const EXT2_OS_LINUX: u32 = 0;
pub const EXT2_OS_HURD: u32 = 1;
pub const EXT2_OBSO_OS_MASIX: u32 = 2;
pub const EXT2_OS_FREEBSD: u32 = 3;
pub const EXT2_OS_LITES: u32 = 4;
pub const EXT2_GOOD_OLD_REV: u32 = 0;
pub const EXT2_DYNAMIC_REV: u32 = 1;
pub const EXT2_CURRENT_REV: u32 = 0;
pub const EXT2_MAX_SUPP_REV: u32 = 1;
pub const EXT2_GOOD_OLD_INODE_SIZE: u32 = 128;
pub const EXT3_JNL_BACKUP_BLOCKS: u32 = 1;
pub const EXT2_FEATURE_COMPAT_DIR_PREALLOC: u32 = 1;
pub const EXT2_FEATURE_COMPAT_IMAGIC_INODES: u32 = 2;
pub const EXT3_FEATURE_COMPAT_HAS_JOURNAL: u32 = 4;
pub const EXT2_FEATURE_COMPAT_EXT_ATTR: u32 = 8;
pub const EXT2_FEATURE_COMPAT_RESIZE_INODE: u32 = 16;
pub const EXT2_FEATURE_COMPAT_DIR_INDEX: u32 = 32;
pub const EXT2_FEATURE_COMPAT_LAZY_BG: u32 = 64;
pub const EXT2_FEATURE_COMPAT_EXCLUDE_BITMAP: u32 = 256;
pub const EXT4_FEATURE_COMPAT_SPARSE_SUPER2: u32 = 512;
pub const EXT4_FEATURE_COMPAT_FAST_COMMIT: u32 = 1024;
pub const EXT4_FEATURE_COMPAT_STABLE_INODES: u32 = 2048;
pub const EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER: u32 = 1;
pub const EXT2_FEATURE_RO_COMPAT_LARGE_FILE: u32 = 2;
pub const EXT4_FEATURE_RO_COMPAT_HUGE_FILE: u32 = 8;
pub const EXT4_FEATURE_RO_COMPAT_GDT_CSUM: u32 = 16;
pub const EXT4_FEATURE_RO_COMPAT_DIR_NLINK: u32 = 32;
pub const EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE: u32 = 64;
pub const EXT4_FEATURE_RO_COMPAT_HAS_SNAPSHOT: u32 = 128;
pub const EXT4_FEATURE_RO_COMPAT_QUOTA: u32 = 256;
pub const EXT4_FEATURE_RO_COMPAT_BIGALLOC: u32 = 512;
pub const EXT4_FEATURE_RO_COMPAT_METADATA_CSUM: u32 = 1024;
pub const EXT4_FEATURE_RO_COMPAT_REPLICA: u32 = 2048;
pub const EXT4_FEATURE_RO_COMPAT_READONLY: u32 = 4096;
pub const EXT4_FEATURE_RO_COMPAT_PROJECT: u32 = 8192;
pub const EXT4_FEATURE_RO_COMPAT_SHARED_BLOCKS: u32 = 16384;
pub const EXT4_FEATURE_RO_COMPAT_VERITY: u32 = 32768;
pub const EXT2_FEATURE_INCOMPAT_COMPRESSION: u32 = 1;
pub const EXT2_FEATURE_INCOMPAT_FILETYPE: u32 = 2;
pub const EXT3_FEATURE_INCOMPAT_RECOVER: u32 = 4;
pub const EXT3_FEATURE_INCOMPAT_JOURNAL_DEV: u32 = 8;
pub const EXT2_FEATURE_INCOMPAT_META_BG: u32 = 16;
pub const EXT3_FEATURE_INCOMPAT_EXTENTS: u32 = 64;
pub const EXT4_FEATURE_INCOMPAT_64BIT: u32 = 128;
pub const EXT4_FEATURE_INCOMPAT_MMP: u32 = 256;
pub const EXT4_FEATURE_INCOMPAT_FLEX_BG: u32 = 512;
pub const EXT4_FEATURE_INCOMPAT_EA_INODE: u32 = 1024;
pub const EXT4_FEATURE_INCOMPAT_DIRDATA: u32 = 4096;
pub const EXT4_FEATURE_INCOMPAT_CSUM_SEED: u32 = 8192;
pub const EXT4_FEATURE_INCOMPAT_LARGEDIR: u32 = 16384;
pub const EXT4_FEATURE_INCOMPAT_INLINE_DATA: u32 = 32768;
pub const EXT4_FEATURE_INCOMPAT_ENCRYPT: u32 = 65536;
pub const EXT4_FEATURE_INCOMPAT_CASEFOLD: u32 = 131072;
pub const EXT2_FEATURE_COMPAT_SUPP: u32 = 0;
pub const EXT2_FEATURE_INCOMPAT_SUPP: u32 = 17666;
pub const EXT2_DEF_RESUID: u32 = 0;
pub const EXT2_DEF_RESGID: u32 = 0;
pub const EXT2_DEFM_DEBUG: u32 = 1;
pub const EXT2_DEFM_BSDGROUPS: u32 = 2;
pub const EXT2_DEFM_XATTR_USER: u32 = 4;
pub const EXT2_DEFM_ACL: u32 = 8;
pub const EXT2_DEFM_UID16: u32 = 16;
pub const EXT3_DEFM_JMODE: u32 = 96;
pub const EXT3_DEFM_JMODE_DATA: u32 = 32;
pub const EXT3_DEFM_JMODE_ORDERED: u32 = 64;
pub const EXT3_DEFM_JMODE_WBACK: u32 = 96;
pub const EXT4_DEFM_NOBARRIER: u32 = 256;
pub const EXT4_DEFM_BLOCK_VALIDITY: u32 = 512;
pub const EXT4_DEFM_DISCARD: u32 = 1024;
pub const EXT4_DEFM_NODELALLOC: u32 = 2048;
pub const EXT2_NAME_LEN: u32 = 255;
pub const EXT2_FT_UNKNOWN: u32 = 0;
pub const EXT2_FT_REG_FILE: u32 = 1;
pub const EXT2_FT_DIR: u32 = 2;
pub const EXT2_FT_CHRDEV: u32 = 3;
pub const EXT2_FT_BLKDEV: u32 = 4;
pub const EXT2_FT_FIFO: u32 = 5;
pub const EXT2_FT_SOCK: u32 = 6;
pub const EXT2_FT_SYMLINK: u32 = 7;
pub const EXT2_FT_MAX: u32 = 8;
pub const EXT2_DIR_NAME_LEN_CSUM: u32 = 56832;
pub const EXT2_DIR_ENTRY_HEADER_LEN: u32 = 8;
pub const EXT2_DIR_ENTRY_HASH_LEN: u32 = 8;
pub const EXT2_DIR_PAD: u32 = 4;
pub const EXT2_DIR_ROUND: u32 = 3;
pub const EXT4_NSEC_MASK: i32 = -4;
pub const EXT4_MMP_MAGIC: u32 = 5066064;
pub const EXT4_MMP_SEQ_CLEAN: u32 = 4283256144;
pub const EXT4_MMP_SEQ_FSCK: u32 = 3796716880;
pub const EXT4_MMP_SEQ_MAX: u32 = 3796716879;
pub const EXT4_MMP_UPDATE_INTERVAL: u32 = 5;
pub const EXT4_MMP_MAX_UPDATE_INTERVAL: u32 = 300;
pub const EXT4_MMP_MIN_CHECK_INTERVAL: u32 = 5;
pub const EXT4_INLINE_DATA_DOTDOT_SIZE: u32 = 4;
pub const EXT4_ENC_UTF8_12_1: u32 = 1;
pub const EXT4_ENC_STRICT_MODE_FL: u32 = 1;
pub const E2P_FEATURE_COMPAT: u32 = 0;
pub const E2P_FEATURE_INCOMPAT: u32 = 1;
pub const E2P_FEATURE_RO_INCOMPAT: u32 = 2;
pub const E2P_FEATURE_TYPE_MASK: u32 = 3;
pub const E2P_FEATURE_NEGATE_FLAG: u32 = 128;
pub const E2P_FS_FEATURE: u32 = 0;
pub const E2P_JOURNAL_FEATURE: u32 = 1;
pub const PFOPT_LONG: u32 = 1;
pub const E2P_LIST_JOURNAL_FLAG_FC: u32 = 1;
pub type __ino_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 FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: usize,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dirent {
pub d_ino: __ino_t,
pub d_off: __off_t,
pub d_reclen: ::std::os::raw::c_ushort,
pub d_type: ::std::os::raw::c_uchar,
pub d_name: [::std::os::raw::c_char; 256usize],
}
#[test]
fn bindgen_test_layout_dirent() {
const UNINIT: ::std::mem::MaybeUninit<dirent> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<dirent>(),
280usize,
concat!("Size of: ", stringify!(dirent))
);
assert_eq!(
::std::mem::align_of::<dirent>(),
8usize,
concat!("Alignment of ", stringify!(dirent))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d_ino) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dirent),
"::",
stringify!(d_ino)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d_off) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dirent),
"::",
stringify!(d_off)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d_reclen) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dirent),
"::",
stringify!(d_reclen)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d_type) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(dirent),
"::",
stringify!(d_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).d_name) as usize - ptr as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(dirent),
"::",
stringify!(d_name)
)
);
}
pub type __u8 = ::std::os::raw::c_uchar;
pub type __s8 = ::std::os::raw::c_schar;
pub type __u16 = ::std::os::raw::c_ushort;
pub type __s16 = ::std::os::raw::c_short;
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;
pub type __le16 = __u16;
pub type __le32 = __u32;
pub type __le64 = __u64;
pub type __be16 = __u16;
pub type __be32 = __u32;
pub type __be64 = __u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_acl_header {
pub aclh_size: __u32,
pub aclh_file_count: __u32,
pub aclh_acle_count: __u32,
pub aclh_first_acle: __u32,
}
#[test]
fn bindgen_test_layout_ext2_acl_header() {
const UNINIT: ::std::mem::MaybeUninit<ext2_acl_header> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_acl_header>(),
16usize,
concat!("Size of: ", stringify!(ext2_acl_header))
);
assert_eq!(
::std::mem::align_of::<ext2_acl_header>(),
4usize,
concat!("Alignment of ", stringify!(ext2_acl_header))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).aclh_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_header),
"::",
stringify!(aclh_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).aclh_file_count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_header),
"::",
stringify!(aclh_file_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).aclh_acle_count) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_header),
"::",
stringify!(aclh_acle_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).aclh_first_acle) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_header),
"::",
stringify!(aclh_first_acle)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_acl_entry {
pub acle_size: __u32,
pub acle_perms: __u16,
pub acle_type: __u16,
pub acle_tag: __u16,
pub acle_pad1: __u16,
pub acle_next: __u32,
}
#[test]
fn bindgen_test_layout_ext2_acl_entry() {
const UNINIT: ::std::mem::MaybeUninit<ext2_acl_entry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_acl_entry>(),
16usize,
concat!("Size of: ", stringify!(ext2_acl_entry))
);
assert_eq!(
::std::mem::align_of::<ext2_acl_entry>(),
4usize,
concat!("Alignment of ", stringify!(ext2_acl_entry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).acle_size) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_entry),
"::",
stringify!(acle_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).acle_perms) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_entry),
"::",
stringify!(acle_perms)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).acle_type) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_entry),
"::",
stringify!(acle_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).acle_tag) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_entry),
"::",
stringify!(acle_tag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).acle_pad1) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_entry),
"::",
stringify!(acle_pad1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).acle_next) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_acl_entry),
"::",
stringify!(acle_next)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_group_desc {
pub bg_block_bitmap: __u32,
pub bg_inode_bitmap: __u32,
pub bg_inode_table: __u32,
pub bg_free_blocks_count: __u16,
pub bg_free_inodes_count: __u16,
pub bg_used_dirs_count: __u16,
pub bg_flags: __u16,
pub bg_exclude_bitmap_lo: __u32,
pub bg_block_bitmap_csum_lo: __u16,
pub bg_inode_bitmap_csum_lo: __u16,
pub bg_itable_unused: __u16,
pub bg_checksum: __u16,
}
#[test]
fn bindgen_test_layout_ext2_group_desc() {
const UNINIT: ::std::mem::MaybeUninit<ext2_group_desc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_group_desc>(),
32usize,
concat!("Size of: ", stringify!(ext2_group_desc))
);
assert_eq!(
::std::mem::align_of::<ext2_group_desc>(),
4usize,
concat!("Alignment of ", stringify!(ext2_group_desc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_block_bitmap) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_block_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_bitmap) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_inode_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_table) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_inode_table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_free_blocks_count) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_free_blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_free_inodes_count) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_free_inodes_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_used_dirs_count) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_used_dirs_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_flags) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_exclude_bitmap_lo) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_exclude_bitmap_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_block_bitmap_csum_lo) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_block_bitmap_csum_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_bitmap_csum_lo) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_inode_bitmap_csum_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_itable_unused) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_itable_unused)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_checksum) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(ext2_group_desc),
"::",
stringify!(bg_checksum)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext4_group_desc {
pub bg_block_bitmap: __u32,
pub bg_inode_bitmap: __u32,
pub bg_inode_table: __u32,
pub bg_free_blocks_count: __u16,
pub bg_free_inodes_count: __u16,
pub bg_used_dirs_count: __u16,
pub bg_flags: __u16,
pub bg_exclude_bitmap_lo: __u32,
pub bg_block_bitmap_csum_lo: __u16,
pub bg_inode_bitmap_csum_lo: __u16,
pub bg_itable_unused: __u16,
pub bg_checksum: __u16,
pub bg_block_bitmap_hi: __u32,
pub bg_inode_bitmap_hi: __u32,
pub bg_inode_table_hi: __u32,
pub bg_free_blocks_count_hi: __u16,
pub bg_free_inodes_count_hi: __u16,
pub bg_used_dirs_count_hi: __u16,
pub bg_itable_unused_hi: __u16,
pub bg_exclude_bitmap_hi: __u32,
pub bg_block_bitmap_csum_hi: __u16,
pub bg_inode_bitmap_csum_hi: __u16,
pub bg_reserved: __u32,
}
#[test]
fn bindgen_test_layout_ext4_group_desc() {
const UNINIT: ::std::mem::MaybeUninit<ext4_group_desc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext4_group_desc>(),
64usize,
concat!("Size of: ", stringify!(ext4_group_desc))
);
assert_eq!(
::std::mem::align_of::<ext4_group_desc>(),
4usize,
concat!("Alignment of ", stringify!(ext4_group_desc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_block_bitmap) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_block_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_bitmap) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_inode_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_table) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_inode_table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_free_blocks_count) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_free_blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_free_inodes_count) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_free_inodes_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_used_dirs_count) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_used_dirs_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_flags) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_exclude_bitmap_lo) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_exclude_bitmap_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_block_bitmap_csum_lo) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_block_bitmap_csum_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_bitmap_csum_lo) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_inode_bitmap_csum_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_itable_unused) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_itable_unused)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_checksum) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_checksum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_block_bitmap_hi) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_block_bitmap_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_bitmap_hi) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_inode_bitmap_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_table_hi) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_inode_table_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_free_blocks_count_hi) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_free_blocks_count_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_free_inodes_count_hi) as usize - ptr as usize },
46usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_free_inodes_count_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_used_dirs_count_hi) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_used_dirs_count_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_itable_unused_hi) as usize - ptr as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_itable_unused_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_exclude_bitmap_hi) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_exclude_bitmap_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_block_bitmap_csum_hi) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_block_bitmap_csum_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_inode_bitmap_csum_hi) as usize - ptr as usize },
58usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_inode_bitmap_csum_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_reserved) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(ext4_group_desc),
"::",
stringify!(bg_reserved)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dx_root_info {
pub reserved_zero: __u32,
pub hash_version: __u8,
pub info_length: __u8,
pub indirect_levels: __u8,
pub unused_flags: __u8,
}
#[test]
fn bindgen_test_layout_ext2_dx_root_info() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dx_root_info> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dx_root_info>(),
8usize,
concat!("Size of: ", stringify!(ext2_dx_root_info))
);
assert_eq!(
::std::mem::align_of::<ext2_dx_root_info>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dx_root_info))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reserved_zero) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_root_info),
"::",
stringify!(reserved_zero)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash_version) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_root_info),
"::",
stringify!(hash_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).info_length) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_root_info),
"::",
stringify!(info_length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).indirect_levels) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_root_info),
"::",
stringify!(indirect_levels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unused_flags) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_root_info),
"::",
stringify!(unused_flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dx_entry {
pub hash: __le32,
pub block: __le32,
}
#[test]
fn bindgen_test_layout_ext2_dx_entry() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dx_entry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dx_entry>(),
8usize,
concat!("Size of: ", stringify!(ext2_dx_entry))
);
assert_eq!(
::std::mem::align_of::<ext2_dx_entry>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dx_entry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_entry),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).block) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_entry),
"::",
stringify!(block)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dx_countlimit {
pub limit: __le16,
pub count: __le16,
}
#[test]
fn bindgen_test_layout_ext2_dx_countlimit() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dx_countlimit> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dx_countlimit>(),
4usize,
concat!("Size of: ", stringify!(ext2_dx_countlimit))
);
assert_eq!(
::std::mem::align_of::<ext2_dx_countlimit>(),
2usize,
concat!("Alignment of ", stringify!(ext2_dx_countlimit))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_countlimit),
"::",
stringify!(limit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_countlimit),
"::",
stringify!(count)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dx_tail {
pub dt_reserved: __le32,
pub dt_checksum: __le32,
}
#[test]
fn bindgen_test_layout_ext2_dx_tail() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dx_tail> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dx_tail>(),
8usize,
concat!("Size of: ", stringify!(ext2_dx_tail))
);
assert_eq!(
::std::mem::align_of::<ext2_dx_tail>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dx_tail))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dt_reserved) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_tail),
"::",
stringify!(dt_reserved)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dt_checksum) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dx_tail),
"::",
stringify!(dt_checksum)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_new_group_input {
pub group: __u32,
pub block_bitmap: __u32,
pub inode_bitmap: __u32,
pub inode_table: __u32,
pub blocks_count: __u32,
pub reserved_blocks: __u16,
pub unused: __u16,
}
#[test]
fn bindgen_test_layout_ext2_new_group_input() {
const UNINIT: ::std::mem::MaybeUninit<ext2_new_group_input> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_new_group_input>(),
24usize,
concat!("Size of: ", stringify!(ext2_new_group_input))
);
assert_eq!(
::std::mem::align_of::<ext2_new_group_input>(),
4usize,
concat!("Alignment of ", stringify!(ext2_new_group_input))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).group) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).block_bitmap) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(block_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inode_bitmap) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(inode_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inode_table) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(inode_table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).blocks_count) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reserved_blocks) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(reserved_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(ext2_new_group_input),
"::",
stringify!(unused)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext4_new_group_input {
pub group: __u32,
pub block_bitmap: __u64,
pub inode_bitmap: __u64,
pub inode_table: __u64,
pub blocks_count: __u32,
pub reserved_blocks: __u16,
pub unused: __u16,
}
#[test]
fn bindgen_test_layout_ext4_new_group_input() {
const UNINIT: ::std::mem::MaybeUninit<ext4_new_group_input> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext4_new_group_input>(),
40usize,
concat!("Size of: ", stringify!(ext4_new_group_input))
);
assert_eq!(
::std::mem::align_of::<ext4_new_group_input>(),
8usize,
concat!("Alignment of ", stringify!(ext4_new_group_input))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).group) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).block_bitmap) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(block_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inode_bitmap) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(inode_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inode_table) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(inode_table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).blocks_count) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reserved_blocks) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(reserved_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(ext4_new_group_input),
"::",
stringify!(unused)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ext2_inode {
pub i_mode: __u16,
pub i_uid: __u16,
pub i_size: __u32,
pub i_atime: __u32,
pub i_ctime: __u32,
pub i_mtime: __u32,
pub i_dtime: __u32,
pub i_gid: __u16,
pub i_links_count: __u16,
pub i_blocks: __u32,
pub i_flags: __u32,
pub osd1: ext2_inode__bindgen_ty_1,
pub i_block: [__u32; 15usize],
pub i_generation: __u32,
pub i_file_acl: __u32,
pub i_size_high: __u32,
pub i_faddr: __u32,
pub osd2: ext2_inode__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ext2_inode__bindgen_ty_1 {
pub linux1: ext2_inode__bindgen_ty_1__bindgen_ty_1,
pub hurd1: ext2_inode__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode__bindgen_ty_1__bindgen_ty_1 {
pub l_i_version: __u32,
}
#[test]
fn bindgen_test_layout_ext2_inode__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(ext2_inode__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ext2_inode__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_version) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(l_i_version)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode__bindgen_ty_1__bindgen_ty_2 {
pub h_i_translator: __u32,
}
#[test]
fn bindgen_test_layout_ext2_inode__bindgen_ty_1__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode__bindgen_ty_1__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Size of: ",
stringify!(ext2_inode__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(ext2_inode__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_translator) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(h_i_translator)
)
);
}
#[test]
fn bindgen_test_layout_ext2_inode__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ext2_inode__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ext2_inode__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ext2_inode__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).linux1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_1),
"::",
stringify!(linux1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hurd1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_1),
"::",
stringify!(hurd1)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ext2_inode__bindgen_ty_2 {
pub linux2: ext2_inode__bindgen_ty_2__bindgen_ty_1,
pub hurd2: ext2_inode__bindgen_ty_2__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode__bindgen_ty_2__bindgen_ty_1 {
pub l_i_blocks_hi: __u16,
pub l_i_file_acl_high: __u16,
pub l_i_uid_high: __u16,
pub l_i_gid_high: __u16,
pub l_i_checksum_lo: __u16,
pub l_i_reserved: __u16,
}
#[test]
fn bindgen_test_layout_ext2_inode__bindgen_ty_2__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode__bindgen_ty_2__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode__bindgen_ty_2__bindgen_ty_1>(),
12usize,
concat!(
"Size of: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Alignment of ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_blocks_hi) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_blocks_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_file_acl_high) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_file_acl_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_uid_high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_uid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_gid_high) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_gid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_checksum_lo) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_checksum_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_reserved) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_reserved)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode__bindgen_ty_2__bindgen_ty_2 {
pub h_i_frag: __u8,
pub h_i_fsize: __u8,
pub h_i_mode_high: __u16,
pub h_i_uid_high: __u16,
pub h_i_gid_high: __u16,
pub h_i_author: __u32,
}
#[test]
fn bindgen_test_layout_ext2_inode__bindgen_ty_2__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode__bindgen_ty_2__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode__bindgen_ty_2__bindgen_ty_2>(),
12usize,
concat!(
"Size of: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode__bindgen_ty_2__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_frag) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_frag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_fsize) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_fsize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_mode_high) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_mode_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_uid_high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_uid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_gid_high) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_gid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_author) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_author)
)
);
}
#[test]
fn bindgen_test_layout_ext2_inode__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode__bindgen_ty_2>(),
12usize,
concat!("Size of: ", stringify!(ext2_inode__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<ext2_inode__bindgen_ty_2>(),
4usize,
concat!("Alignment of ", stringify!(ext2_inode__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).linux2) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2),
"::",
stringify!(linux2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hurd2) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode__bindgen_ty_2),
"::",
stringify!(hurd2)
)
);
}
#[test]
fn bindgen_test_layout_ext2_inode() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode>(),
128usize,
concat!("Size of: ", stringify!(ext2_inode))
);
assert_eq!(
::std::mem::align_of::<ext2_inode>(),
4usize,
concat!("Alignment of ", stringify!(ext2_inode))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_uid) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_uid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_atime) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_atime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_ctime) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_ctime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_mtime) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_mtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_dtime) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_dtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_gid) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_gid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_links_count) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_links_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_blocks) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_flags) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).osd1) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(osd1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_block) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_generation) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_generation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_file_acl) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_file_acl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_size_high) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_size_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_faddr) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(i_faddr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).osd2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode),
"::",
stringify!(osd2)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ext2_inode_large {
pub i_mode: __u16,
pub i_uid: __u16,
pub i_size: __u32,
pub i_atime: __u32,
pub i_ctime: __u32,
pub i_mtime: __u32,
pub i_dtime: __u32,
pub i_gid: __u16,
pub i_links_count: __u16,
pub i_blocks: __u32,
pub i_flags: __u32,
pub osd1: ext2_inode_large__bindgen_ty_1,
pub i_block: [__u32; 15usize],
pub i_generation: __u32,
pub i_file_acl: __u32,
pub i_size_high: __u32,
pub i_faddr: __u32,
pub osd2: ext2_inode_large__bindgen_ty_2,
pub i_extra_isize: __u16,
pub i_checksum_hi: __u16,
pub i_ctime_extra: __u32,
pub i_mtime_extra: __u32,
pub i_atime_extra: __u32,
pub i_crtime: __u32,
pub i_crtime_extra: __u32,
pub i_version_hi: __u32,
pub i_projid: __u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ext2_inode_large__bindgen_ty_1 {
pub linux1: ext2_inode_large__bindgen_ty_1__bindgen_ty_1,
pub hurd1: ext2_inode_large__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode_large__bindgen_ty_1__bindgen_ty_1 {
pub l_i_version: __u32,
}
#[test]
fn bindgen_test_layout_ext2_inode_large__bindgen_ty_1__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large__bindgen_ty_1__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(ext2_inode_large__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(ext2_inode_large__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_version) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(l_i_version)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode_large__bindgen_ty_1__bindgen_ty_2 {
pub h_i_translator: __u32,
}
#[test]
fn bindgen_test_layout_ext2_inode_large__bindgen_ty_1__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large__bindgen_ty_1__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Size of: ",
stringify!(ext2_inode_large__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(ext2_inode_large__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_translator) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(h_i_translator)
)
);
}
#[test]
fn bindgen_test_layout_ext2_inode_large__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(ext2_inode_large__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(ext2_inode_large__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).linux1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_1),
"::",
stringify!(linux1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hurd1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_1),
"::",
stringify!(hurd1)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ext2_inode_large__bindgen_ty_2 {
pub linux2: ext2_inode_large__bindgen_ty_2__bindgen_ty_1,
pub hurd2: ext2_inode_large__bindgen_ty_2__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode_large__bindgen_ty_2__bindgen_ty_1 {
pub l_i_blocks_hi: __u16,
pub l_i_file_acl_high: __u16,
pub l_i_uid_high: __u16,
pub l_i_gid_high: __u16,
pub l_i_checksum_lo: __u16,
pub l_i_reserved: __u16,
}
#[test]
fn bindgen_test_layout_ext2_inode_large__bindgen_ty_2__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large__bindgen_ty_2__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large__bindgen_ty_2__bindgen_ty_1>(),
12usize,
concat!(
"Size of: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Alignment of ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_blocks_hi) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_blocks_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_file_acl_high) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_file_acl_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_uid_high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_uid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_gid_high) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_gid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_checksum_lo) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_checksum_lo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).l_i_reserved) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(l_i_reserved)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_inode_large__bindgen_ty_2__bindgen_ty_2 {
pub h_i_frag: __u8,
pub h_i_fsize: __u8,
pub h_i_mode_high: __u16,
pub h_i_uid_high: __u16,
pub h_i_gid_high: __u16,
pub h_i_author: __u32,
}
#[test]
fn bindgen_test_layout_ext2_inode_large__bindgen_ty_2__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large__bindgen_ty_2__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large__bindgen_ty_2__bindgen_ty_2>(),
12usize,
concat!(
"Size of: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large__bindgen_ty_2__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_frag) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_frag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_fsize) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_fsize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_mode_high) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_mode_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_uid_high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_uid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_gid_high) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_gid_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).h_i_author) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2__bindgen_ty_2),
"::",
stringify!(h_i_author)
)
);
}
#[test]
fn bindgen_test_layout_ext2_inode_large__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large__bindgen_ty_2>(),
12usize,
concat!("Size of: ", stringify!(ext2_inode_large__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large__bindgen_ty_2>(),
4usize,
concat!("Alignment of ", stringify!(ext2_inode_large__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).linux2) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2),
"::",
stringify!(linux2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hurd2) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large__bindgen_ty_2),
"::",
stringify!(hurd2)
)
);
}
#[test]
fn bindgen_test_layout_ext2_inode_large() {
const UNINIT: ::std::mem::MaybeUninit<ext2_inode_large> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_inode_large>(),
160usize,
concat!("Size of: ", stringify!(ext2_inode_large))
);
assert_eq!(
::std::mem::align_of::<ext2_inode_large>(),
4usize,
concat!("Alignment of ", stringify!(ext2_inode_large))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_uid) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_uid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_size) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_atime) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_atime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_ctime) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_ctime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_mtime) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_mtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_dtime) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_dtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_gid) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_gid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_links_count) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_links_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_blocks) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_flags) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).osd1) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(osd1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_block) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_generation) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_generation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_file_acl) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_file_acl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_size_high) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_size_high)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_faddr) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_faddr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).osd2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(osd2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_extra_isize) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_extra_isize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_checksum_hi) as usize - ptr as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_checksum_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_ctime_extra) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_ctime_extra)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_mtime_extra) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_mtime_extra)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_atime_extra) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_atime_extra)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_crtime) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_crtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_crtime_extra) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_crtime_extra)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_version_hi) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_version_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).i_projid) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(ext2_inode_large),
"::",
stringify!(i_projid)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct ext4_encryption_policy {
pub version: ::std::os::raw::c_char,
pub contents_encryption_mode: ::std::os::raw::c_char,
pub filenames_encryption_mode: ::std::os::raw::c_char,
pub flags: ::std::os::raw::c_char,
pub master_key_descriptor: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout_ext4_encryption_policy() {
const UNINIT: ::std::mem::MaybeUninit<ext4_encryption_policy> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext4_encryption_policy>(),
12usize,
concat!("Size of: ", stringify!(ext4_encryption_policy))
);
assert_eq!(
::std::mem::align_of::<ext4_encryption_policy>(),
1usize,
concat!("Alignment of ", stringify!(ext4_encryption_policy))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_policy),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contents_encryption_mode) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_policy),
"::",
stringify!(contents_encryption_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filenames_encryption_mode) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_policy),
"::",
stringify!(filenames_encryption_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_policy),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).master_key_descriptor) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_policy),
"::",
stringify!(master_key_descriptor)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct ext4_encryption_key {
pub mode: __u32,
pub raw: [::std::os::raw::c_char; 64usize],
pub size: __u32,
}
#[test]
fn bindgen_test_layout_ext4_encryption_key() {
const UNINIT: ::std::mem::MaybeUninit<ext4_encryption_key> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext4_encryption_key>(),
72usize,
concat!("Size of: ", stringify!(ext4_encryption_key))
);
assert_eq!(
::std::mem::align_of::<ext4_encryption_key>(),
1usize,
concat!("Alignment of ", stringify!(ext4_encryption_key))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_key),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_key),
"::",
stringify!(raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(ext4_encryption_key),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_super_block {
pub s_inodes_count: __u32,
pub s_blocks_count: __u32,
pub s_r_blocks_count: __u32,
pub s_free_blocks_count: __u32,
pub s_free_inodes_count: __u32,
pub s_first_data_block: __u32,
pub s_log_block_size: __u32,
pub s_log_cluster_size: __u32,
pub s_blocks_per_group: __u32,
pub s_clusters_per_group: __u32,
pub s_inodes_per_group: __u32,
pub s_mtime: __u32,
pub s_wtime: __u32,
pub s_mnt_count: __u16,
pub s_max_mnt_count: __s16,
pub s_magic: __u16,
pub s_state: __u16,
pub s_errors: __u16,
pub s_minor_rev_level: __u16,
pub s_lastcheck: __u32,
pub s_checkinterval: __u32,
pub s_creator_os: __u32,
pub s_rev_level: __u32,
pub s_def_resuid: __u16,
pub s_def_resgid: __u16,
pub s_first_ino: __u32,
pub s_inode_size: __u16,
pub s_block_group_nr: __u16,
pub s_feature_compat: __u32,
pub s_feature_incompat: __u32,
pub s_feature_ro_compat: __u32,
pub s_uuid: [__u8; 16usize],
pub s_volume_name: [__u8; 16usize],
pub s_last_mounted: [__u8; 64usize],
pub s_algorithm_usage_bitmap: __u32,
pub s_prealloc_blocks: __u8,
pub s_prealloc_dir_blocks: __u8,
pub s_reserved_gdt_blocks: __u16,
pub s_journal_uuid: [__u8; 16usize],
pub s_journal_inum: __u32,
pub s_journal_dev: __u32,
pub s_last_orphan: __u32,
pub s_hash_seed: [__u32; 4usize],
pub s_def_hash_version: __u8,
pub s_jnl_backup_type: __u8,
pub s_desc_size: __u16,
pub s_default_mount_opts: __u32,
pub s_first_meta_bg: __u32,
pub s_mkfs_time: __u32,
pub s_jnl_blocks: [__u32; 17usize],
pub s_blocks_count_hi: __u32,
pub s_r_blocks_count_hi: __u32,
pub s_free_blocks_hi: __u32,
pub s_min_extra_isize: __u16,
pub s_want_extra_isize: __u16,
pub s_flags: __u32,
pub s_raid_stride: __u16,
pub s_mmp_update_interval: __u16,
pub s_mmp_block: __u64,
pub s_raid_stripe_width: __u32,
pub s_log_groups_per_flex: __u8,
pub s_checksum_type: __u8,
pub s_encryption_level: __u8,
pub s_reserved_pad: __u8,
pub s_kbytes_written: __u64,
pub s_snapshot_inum: __u32,
pub s_snapshot_id: __u32,
pub s_snapshot_r_blocks_count: __u64,
pub s_snapshot_list: __u32,
pub s_error_count: __u32,
pub s_first_error_time: __u32,
pub s_first_error_ino: __u32,
pub s_first_error_block: __u64,
pub s_first_error_func: [__u8; 32usize],
pub s_first_error_line: __u32,
pub s_last_error_time: __u32,
pub s_last_error_ino: __u32,
pub s_last_error_line: __u32,
pub s_last_error_block: __u64,
pub s_last_error_func: [__u8; 32usize],
pub s_mount_opts: [__u8; 64usize],
pub s_usr_quota_inum: __u32,
pub s_grp_quota_inum: __u32,
pub s_overhead_clusters: __u32,
pub s_backup_bgs: [__u32; 2usize],
pub s_encrypt_algos: [__u8; 4usize],
pub s_encrypt_pw_salt: [__u8; 16usize],
pub s_lpf_ino: __le32,
pub s_prj_quota_inum: __le32,
pub s_checksum_seed: __le32,
pub s_wtime_hi: __u8,
pub s_mtime_hi: __u8,
pub s_mkfs_time_hi: __u8,
pub s_lastcheck_hi: __u8,
pub s_first_error_time_hi: __u8,
pub s_last_error_time_hi: __u8,
pub s_first_error_errcode: __u8,
pub s_last_error_errcode: __u8,
pub s_encoding: __le16,
pub s_encoding_flags: __le16,
pub s_reserved: [__le32; 95usize],
pub s_checksum: __u32,
}
#[test]
fn bindgen_test_layout_ext2_super_block() {
const UNINIT: ::std::mem::MaybeUninit<ext2_super_block> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_super_block>(),
1024usize,
concat!("Size of: ", stringify!(ext2_super_block))
);
assert_eq!(
::std::mem::align_of::<ext2_super_block>(),
8usize,
concat!("Alignment of ", stringify!(ext2_super_block))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_inodes_count) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_inodes_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_blocks_count) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_r_blocks_count) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_r_blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_free_blocks_count) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_free_blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_free_inodes_count) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_free_inodes_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_data_block) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_data_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_log_block_size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_log_block_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_log_cluster_size) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_log_cluster_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_blocks_per_group) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_blocks_per_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_clusters_per_group) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_clusters_per_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_inodes_per_group) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_inodes_per_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mtime) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_wtime) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_wtime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mnt_count) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mnt_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_max_mnt_count) as usize - ptr as usize },
54usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_max_mnt_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_magic) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_magic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_state) as usize - ptr as usize },
58usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_state)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_errors) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_errors)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_minor_rev_level) as usize - ptr as usize },
62usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_minor_rev_level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_lastcheck) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_lastcheck)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_checkinterval) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_checkinterval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_creator_os) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_creator_os)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_rev_level) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_rev_level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_def_resuid) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_def_resuid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_def_resgid) as usize - ptr as usize },
82usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_def_resgid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_ino) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_ino)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_inode_size) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_inode_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_block_group_nr) as usize - ptr as usize },
90usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_block_group_nr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_feature_compat) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_feature_compat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_feature_incompat) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_feature_incompat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_feature_ro_compat) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_feature_ro_compat)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_uuid) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_uuid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_volume_name) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_volume_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_mounted) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_mounted)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_algorithm_usage_bitmap) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_algorithm_usage_bitmap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_prealloc_blocks) as usize - ptr as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_prealloc_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_prealloc_dir_blocks) as usize - ptr as usize },
205usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_prealloc_dir_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_reserved_gdt_blocks) as usize - ptr as usize },
206usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_reserved_gdt_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_journal_uuid) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_journal_uuid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_journal_inum) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_journal_inum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_journal_dev) as usize - ptr as usize },
228usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_journal_dev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_orphan) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_orphan)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_hash_seed) as usize - ptr as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_hash_seed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_def_hash_version) as usize - ptr as usize },
252usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_def_hash_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_jnl_backup_type) as usize - ptr as usize },
253usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_jnl_backup_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_desc_size) as usize - ptr as usize },
254usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_desc_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_default_mount_opts) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_default_mount_opts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_meta_bg) as usize - ptr as usize },
260usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_meta_bg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mkfs_time) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mkfs_time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_jnl_blocks) as usize - ptr as usize },
268usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_jnl_blocks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_blocks_count_hi) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_blocks_count_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_r_blocks_count_hi) as usize - ptr as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_r_blocks_count_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_free_blocks_hi) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_free_blocks_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_min_extra_isize) as usize - ptr as usize },
348usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_min_extra_isize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_want_extra_isize) as usize - ptr as usize },
350usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_want_extra_isize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_flags) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_raid_stride) as usize - ptr as usize },
356usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_raid_stride)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mmp_update_interval) as usize - ptr as usize },
358usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mmp_update_interval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mmp_block) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mmp_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_raid_stripe_width) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_raid_stripe_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_log_groups_per_flex) as usize - ptr as usize },
372usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_log_groups_per_flex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_checksum_type) as usize - ptr as usize },
373usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_checksum_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_encryption_level) as usize - ptr as usize },
374usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_encryption_level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_reserved_pad) as usize - ptr as usize },
375usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_reserved_pad)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_kbytes_written) as usize - ptr as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_kbytes_written)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_snapshot_inum) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_snapshot_inum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_snapshot_id) as usize - ptr as usize },
388usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_snapshot_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_snapshot_r_blocks_count) as usize - ptr as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_snapshot_r_blocks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_snapshot_list) as usize - ptr as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_snapshot_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_error_count) as usize - ptr as usize },
404usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_error_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_time) as usize - ptr as usize },
408usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_ino) as usize - ptr as usize },
412usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_ino)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_block) as usize - ptr as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_func) as usize - ptr as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_func)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_line) as usize - ptr as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_time) as usize - ptr as usize },
460usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_ino) as usize - ptr as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_ino)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_line) as usize - ptr as usize },
468usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_block) as usize - ptr as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_block)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_func) as usize - ptr as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_func)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mount_opts) as usize - ptr as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mount_opts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_usr_quota_inum) as usize - ptr as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_usr_quota_inum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_grp_quota_inum) as usize - ptr as usize },
580usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_grp_quota_inum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_overhead_clusters) as usize - ptr as usize },
584usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_overhead_clusters)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_backup_bgs) as usize - ptr as usize },
588usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_backup_bgs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_encrypt_algos) as usize - ptr as usize },
596usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_encrypt_algos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_encrypt_pw_salt) as usize - ptr as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_encrypt_pw_salt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_lpf_ino) as usize - ptr as usize },
616usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_lpf_ino)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_prj_quota_inum) as usize - ptr as usize },
620usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_prj_quota_inum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_checksum_seed) as usize - ptr as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_checksum_seed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_wtime_hi) as usize - ptr as usize },
628usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_wtime_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mtime_hi) as usize - ptr as usize },
629usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mtime_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_mkfs_time_hi) as usize - ptr as usize },
630usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_mkfs_time_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_lastcheck_hi) as usize - ptr as usize },
631usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_lastcheck_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_time_hi) as usize - ptr as usize },
632usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_time_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_time_hi) as usize - ptr as usize },
633usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_time_hi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_first_error_errcode) as usize - ptr as usize },
634usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_first_error_errcode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_last_error_errcode) as usize - ptr as usize },
635usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_last_error_errcode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_encoding) as usize - ptr as usize },
636usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_encoding)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_encoding_flags) as usize - ptr as usize },
638usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_encoding_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_reserved) as usize - ptr as usize },
640usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_reserved)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).s_checksum) as usize - ptr as usize },
1020usize,
concat!(
"Offset of field: ",
stringify!(ext2_super_block),
"::",
stringify!(s_checksum)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dir_entry {
pub inode: __u32,
pub rec_len: __u16,
pub name_len: __u16,
pub name: [::std::os::raw::c_char; 255usize],
}
#[test]
fn bindgen_test_layout_ext2_dir_entry() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dir_entry> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dir_entry>(),
264usize,
concat!("Size of: ", stringify!(ext2_dir_entry))
);
assert_eq!(
::std::mem::align_of::<ext2_dir_entry>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dir_entry))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry),
"::",
stringify!(inode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rec_len) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry),
"::",
stringify!(rec_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name_len) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry),
"::",
stringify!(name_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dir_entry_2 {
pub inode: __u32,
pub rec_len: __u16,
pub name_len: __u8,
pub file_type: __u8,
pub name: [::std::os::raw::c_char; 255usize],
}
#[test]
fn bindgen_test_layout_ext2_dir_entry_2() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dir_entry_2> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dir_entry_2>(),
264usize,
concat!("Size of: ", stringify!(ext2_dir_entry_2))
);
assert_eq!(
::std::mem::align_of::<ext2_dir_entry_2>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dir_entry_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inode) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_2),
"::",
stringify!(inode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rec_len) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_2),
"::",
stringify!(rec_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name_len) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_2),
"::",
stringify!(name_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file_type) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_2),
"::",
stringify!(file_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_2),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dir_entry_hash {
pub hash: __le32,
pub minor_hash: __le32,
}
#[test]
fn bindgen_test_layout_ext2_dir_entry_hash() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dir_entry_hash> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dir_entry_hash>(),
8usize,
concat!("Size of: ", stringify!(ext2_dir_entry_hash))
);
assert_eq!(
::std::mem::align_of::<ext2_dir_entry_hash>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dir_entry_hash))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_hash),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minor_hash) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_hash),
"::",
stringify!(minor_hash)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ext2_dir_entry_tail {
pub det_reserved_zero1: __u32,
pub det_rec_len: __u16,
pub det_reserved_name_len: __u16,
pub det_checksum: __u32,
}
#[test]
fn bindgen_test_layout_ext2_dir_entry_tail() {
const UNINIT: ::std::mem::MaybeUninit<ext2_dir_entry_tail> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<ext2_dir_entry_tail>(),
12usize,
concat!("Size of: ", stringify!(ext2_dir_entry_tail))
);
assert_eq!(
::std::mem::align_of::<ext2_dir_entry_tail>(),
4usize,
concat!("Alignment of ", stringify!(ext2_dir_entry_tail))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).det_reserved_zero1) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_tail),
"::",
stringify!(det_reserved_zero1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).det_rec_len) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_tail),
"::",
stringify!(det_rec_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).det_reserved_name_len) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_tail),
"::",
stringify!(det_reserved_name_len)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).det_checksum) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ext2_dir_entry_tail),
"::",
stringify!(det_checksum)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mmp_struct {
pub mmp_magic: __u32,
pub mmp_seq: __u32,
pub mmp_time: __u64,
pub mmp_nodename: [__u8; 64usize],
pub mmp_bdevname: [__u8; 32usize],
pub mmp_check_interval: __u16,
pub mmp_pad1: __u16,
pub mmp_pad2: [__u32; 226usize],
pub mmp_checksum: __u32,
}
#[test]
fn bindgen_test_layout_mmp_struct() {
const UNINIT: ::std::mem::MaybeUninit<mmp_struct> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<mmp_struct>(),
1024usize,
concat!("Size of: ", stringify!(mmp_struct))
);
assert_eq!(
::std::mem::align_of::<mmp_struct>(),
8usize,
concat!("Alignment of ", stringify!(mmp_struct))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_magic) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_magic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_seq) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_seq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_time) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_nodename) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_nodename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_bdevname) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_bdevname)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_check_interval) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_check_interval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_pad1) as usize - ptr as usize },
114usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_pad1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_pad2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_pad2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mmp_checksum) as usize - ptr as usize },
1020usize,
concat!(
"Offset of field: ",
stringify!(mmp_struct),
"::",
stringify!(mmp_checksum)
)
);
}
extern "C" {
pub fn fgetflags(
name: *const ::std::os::raw::c_char,
flags: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetversion(
name: *const ::std::os::raw::c_char,
version: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetflags(
name: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetversion(
name: *const ::std::os::raw::c_char,
version: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetproject(
name: *const ::std::os::raw::c_char,
project: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetproject(
name: *const ::std::os::raw::c_char,
project: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getflags(
fd: ::std::os::raw::c_int,
flags: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getversion(
fd: ::std::os::raw::c_int,
version: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn iterate_on_dir(
dir_name: *const ::std::os::raw::c_char,
func: ::std::option::Option<
unsafe extern "C" fn(
arg1: *const ::std::os::raw::c_char,
arg2: *mut dirent,
arg3: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
private_arg: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn list_super(s: *mut ext2_super_block);
}
extern "C" {
pub fn list_super2(s: *mut ext2_super_block, f: *mut FILE);
}
extern "C" {
pub fn print_fs_errors(f: *mut FILE, errors: ::std::os::raw::c_ushort);
}
extern "C" {
pub fn print_flags(
f: *mut FILE,
flags: ::std::os::raw::c_ulong,
options: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn print_fs_state(f: *mut FILE, state: ::std::os::raw::c_ushort);
}
extern "C" {
pub fn setflags(
fd: ::std::os::raw::c_int,
flags: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setversion(
fd: ::std::os::raw::c_int,
version: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_list_journal_super(
f: *mut FILE,
journal_sb_buf: *mut ::std::os::raw::c_char,
exp_block_size: ::std::os::raw::c_int,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn e2p_feature_to_string(
compat: ::std::os::raw::c_int,
mask: ::std::os::raw::c_uint,
buf: *mut ::std::os::raw::c_char,
buf_len: usize,
);
}
extern "C" {
pub fn e2p_feature2string(
compat: ::std::os::raw::c_int,
mask: ::std::os::raw::c_uint,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_jrnl_feature2string(
compat: ::std::os::raw::c_int,
mask: ::std::os::raw::c_uint,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_string2feature(
string: *mut ::std::os::raw::c_char,
compat: *mut ::std::os::raw::c_int,
mask: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_jrnl_string2feature(
string: *mut ::std::os::raw::c_char,
compat_type: *mut ::std::os::raw::c_int,
mask: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_edit_feature(
str_: *const ::std::os::raw::c_char,
compat_array: *mut __u32,
ok_array: *mut __u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_edit_feature2(
str_: *const ::std::os::raw::c_char,
compat_array: *mut __u32,
ok_array: *mut __u32,
clear_ok_array: *mut __u32,
type_err: *mut ::std::os::raw::c_int,
mask_err: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_is_null_uuid(uu: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_uuid_to_str(uu: *mut ::std::os::raw::c_void, out: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn e2p_uuid2str(uu: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_hash2string(num: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_string2hash(string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_mntopt2string(mask: ::std::os::raw::c_uint) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_string2mntopt(
string: *mut ::std::os::raw::c_char,
mask: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_edit_mntopts(
str_: *const ::std::os::raw::c_char,
mntopts: *mut __u32,
ok: __u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn parse_num_blocks(
arg: *const ::std::os::raw::c_char,
log_block_size: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn parse_num_blocks2(
arg: *const ::std::os::raw::c_char,
log_block_size: ::std::os::raw::c_int,
) -> ::std::os::raw::c_ulonglong;
}
extern "C" {
pub fn e2p_os2string(os_type: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_string2os(str_: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_percent(
percent: ::std::os::raw::c_int,
base: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn e2p_encmode2string(num: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_string2encmode(string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_str2encoding(string: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_encoding2str(encoding: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn e2p_get_encoding_flags(encoding: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_str2encoding_flags(
encoding: ::std::os::raw::c_int,
param: *mut ::std::os::raw::c_char,
flags: *mut __u16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn e2p_errcode2str(err: ::std::os::raw::c_uint) -> *const ::std::os::raw::c_char;
}