1#![allow(improper_ctypes)]
18#![allow(non_snake_case)]
19#![allow(non_camel_case_types)]
20#![allow(non_upper_case_globals)]
21#![cfg_attr(test, allow(deref_nullptr))]
22
23#[repr(C)]
24#[derive(Default)]
25pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
26impl<T> __IncompleteArrayField<T> {
27 #[inline]
28 pub const fn new() -> Self {
29 __IncompleteArrayField(::std::marker::PhantomData, [])
30 }
31 #[inline]
32 pub fn as_ptr(&self) -> *const T {
33 self as *const _ as *const T
34 }
35 #[inline]
36 pub fn as_mut_ptr(&mut self) -> *mut T {
37 self as *mut _ as *mut T
38 }
39 #[inline]
40 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
41 ::std::slice::from_raw_parts(self.as_ptr(), len)
42 }
43 #[inline]
44 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
45 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
46 }
47}
48impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
49 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
50 fmt.write_str("__IncompleteArrayField")
51 }
52}
53pub const __BITS_PER_LONG: u32 = 64;
54pub const __FD_SETSIZE: u32 = 1024;
55pub const _IOC_NRBITS: u32 = 8;
56pub const _IOC_TYPEBITS: u32 = 8;
57pub const _IOC_SIZEBITS: u32 = 14;
58pub const _IOC_DIRBITS: u32 = 2;
59pub const _IOC_NRMASK: u32 = 255;
60pub const _IOC_TYPEMASK: u32 = 255;
61pub const _IOC_SIZEMASK: u32 = 16383;
62pub const _IOC_DIRMASK: u32 = 3;
63pub const _IOC_NRSHIFT: u32 = 0;
64pub const _IOC_TYPESHIFT: u32 = 8;
65pub const _IOC_SIZESHIFT: u32 = 16;
66pub const _IOC_DIRSHIFT: u32 = 30;
67pub const _IOC_NONE: u32 = 0;
68pub const _IOC_WRITE: u32 = 1;
69pub const _IOC_READ: u32 = 2;
70pub const IOC_IN: u32 = 1073741824;
71pub const IOC_OUT: u32 = 2147483648;
72pub const IOC_INOUT: u32 = 3221225472;
73pub const IOCSIZE_MASK: u32 = 1073676288;
74pub const IOCSIZE_SHIFT: u32 = 16;
75pub const BTRFS_IOCTL_MAGIC: u32 = 148;
76pub const BTRFS_VOL_NAME_MAX: u32 = 255;
77pub const BTRFS_LABEL_SIZE: u32 = 256;
78pub const BTRFS_PATH_NAME_MAX: u32 = 4087;
79pub const BTRFS_DEVICE_PATH_NAME_MAX: u32 = 1024;
80pub const BTRFS_SUBVOL_NAME_MAX: u32 = 4039;
81pub const BTRFS_SUBVOL_CREATE_ASYNC: u32 = 1;
82pub const BTRFS_SUBVOL_RDONLY: u32 = 2;
83pub const BTRFS_SUBVOL_QGROUP_INHERIT: u32 = 4;
84pub const BTRFS_DEVICE_SPEC_BY_ID: u32 = 8;
85pub const BTRFS_VOL_ARG_V2_FLAGS_SUPPORTED: u32 = 15;
86pub const BTRFS_FSID_SIZE: u32 = 16;
87pub const BTRFS_UUID_SIZE: u32 = 16;
88pub const BTRFS_UUID_UNPARSED_SIZE: u32 = 37;
89pub const BTRFS_QGROUP_LIMIT_MAX_RFER: u32 = 1;
90pub const BTRFS_QGROUP_LIMIT_MAX_EXCL: u32 = 2;
91pub const BTRFS_QGROUP_LIMIT_RSV_RFER: u32 = 4;
92pub const BTRFS_QGROUP_LIMIT_RSV_EXCL: u32 = 8;
93pub const BTRFS_QGROUP_LIMIT_RFER_CMPR: u32 = 16;
94pub const BTRFS_QGROUP_LIMIT_EXCL_CMPR: u32 = 32;
95pub const BTRFS_QGROUP_INHERIT_SET_LIMITS: u32 = 1;
96pub const BTRFS_SCRUB_READONLY: u32 = 1;
97pub const BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS: u32 = 0;
98pub const BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID: u32 = 1;
99pub const BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED: u32 = 0;
100pub const BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED: u32 = 1;
101pub const BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED: u32 = 2;
102pub const BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED: u32 = 3;
103pub const BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED: u32 = 4;
104pub const BTRFS_IOCTL_DEV_REPLACE_CMD_START: u32 = 0;
105pub const BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS: u32 = 1;
106pub const BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL: u32 = 2;
107pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR: u32 = 0;
108pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED: u32 = 1;
109pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED: u32 = 2;
110pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS: u32 = 3;
111pub const BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE: u32 = 1;
112pub const BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID: u32 = 2;
113pub const BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF: u32 = 1;
114pub const BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL: u32 = 2;
115pub const BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS: u32 = 4;
116pub const BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO: u32 = 8;
117pub const BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD: u32 = 16;
118pub const BTRFS_FEATURE_INCOMPAT_BIG_METADATA: u32 = 32;
119pub const BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF: u32 = 64;
120pub const BTRFS_FEATURE_INCOMPAT_RAID56: u32 = 128;
121pub const BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA: u32 = 256;
122pub const BTRFS_FEATURE_INCOMPAT_NO_HOLES: u32 = 512;
123pub const BTRFS_BALANCE_CTL_PAUSE: u32 = 1;
124pub const BTRFS_BALANCE_CTL_CANCEL: u32 = 2;
125pub const BTRFS_BALANCE_DATA: u32 = 1;
126pub const BTRFS_BALANCE_SYSTEM: u32 = 2;
127pub const BTRFS_BALANCE_METADATA: u32 = 4;
128pub const BTRFS_BALANCE_TYPE_MASK: u32 = 7;
129pub const BTRFS_BALANCE_FORCE: u32 = 8;
130pub const BTRFS_BALANCE_RESUME: u32 = 16;
131pub const BTRFS_BALANCE_ARGS_PROFILES: u32 = 1;
132pub const BTRFS_BALANCE_ARGS_USAGE: u32 = 2;
133pub const BTRFS_BALANCE_ARGS_DEVID: u32 = 4;
134pub const BTRFS_BALANCE_ARGS_DRANGE: u32 = 8;
135pub const BTRFS_BALANCE_ARGS_VRANGE: u32 = 16;
136pub const BTRFS_BALANCE_ARGS_LIMIT: u32 = 32;
137pub const BTRFS_BALANCE_ARGS_LIMIT_RANGE: u32 = 64;
138pub const BTRFS_BALANCE_ARGS_STRIPES_RANGE: u32 = 128;
139pub const BTRFS_BALANCE_ARGS_USAGE_RANGE: u32 = 1024;
140pub const BTRFS_BALANCE_ARGS_MASK: u32 = 1279;
141pub const BTRFS_BALANCE_ARGS_CONVERT: u32 = 256;
142pub const BTRFS_BALANCE_ARGS_SOFT: u32 = 512;
143pub const BTRFS_BALANCE_STATE_RUNNING: u32 = 1;
144pub const BTRFS_BALANCE_STATE_PAUSE_REQ: u32 = 2;
145pub const BTRFS_BALANCE_STATE_CANCEL_REQ: u32 = 4;
146pub const BTRFS_INO_LOOKUP_PATH_MAX: u32 = 4080;
147pub const BTRFS_DEFRAG_RANGE_COMPRESS: u32 = 1;
148pub const BTRFS_DEFRAG_RANGE_START_IO: u32 = 2;
149pub const BTRFS_SAME_DATA_DIFFERS: u32 = 1;
150pub const BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET: u32 = 1;
151pub const BTRFS_DEV_STATS_RESET: u32 = 1;
152pub const BTRFS_QUOTA_CTL_ENABLE: u32 = 1;
153pub const BTRFS_QUOTA_CTL_DISABLE: u32 = 2;
154pub const BTRFS_QUOTA_CTL_RESCAN__NOTUSED: u32 = 3;
155pub const BTRFS_SEND_FLAG_NO_FILE_DATA: u32 = 1;
156pub const BTRFS_SEND_FLAG_OMIT_STREAM_HEADER: u32 = 2;
157pub const BTRFS_SEND_FLAG_OMIT_END_CMD: u32 = 4;
158pub const BTRFS_SEND_FLAG_MASK: u32 = 7;
159pub const BTRFS_ROOT_TREE_OBJECTID: u32 = 1;
160pub const BTRFS_EXTENT_TREE_OBJECTID: u32 = 2;
161pub const BTRFS_CHUNK_TREE_OBJECTID: u32 = 3;
162pub const BTRFS_DEV_TREE_OBJECTID: u32 = 4;
163pub const BTRFS_FS_TREE_OBJECTID: u32 = 5;
164pub const BTRFS_ROOT_TREE_DIR_OBJECTID: u32 = 6;
165pub const BTRFS_CSUM_TREE_OBJECTID: u32 = 7;
166pub const BTRFS_QUOTA_TREE_OBJECTID: u32 = 8;
167pub const BTRFS_UUID_TREE_OBJECTID: u32 = 9;
168pub const BTRFS_FREE_SPACE_TREE_OBJECTID: u32 = 10;
169pub const BTRFS_DEV_STATS_OBJECTID: u32 = 0;
170pub const BTRFS_BALANCE_OBJECTID: i32 = -4;
171pub const BTRFS_ORPHAN_OBJECTID: i32 = -5;
172pub const BTRFS_TREE_LOG_OBJECTID: i32 = -6;
173pub const BTRFS_TREE_LOG_FIXUP_OBJECTID: i32 = -7;
174pub const BTRFS_TREE_RELOC_OBJECTID: i32 = -8;
175pub const BTRFS_DATA_RELOC_TREE_OBJECTID: i32 = -9;
176pub const BTRFS_EXTENT_CSUM_OBJECTID: i32 = -10;
177pub const BTRFS_FREE_SPACE_OBJECTID: i32 = -11;
178pub const BTRFS_FREE_INO_OBJECTID: i32 = -12;
179pub const BTRFS_MULTIPLE_OBJECTIDS: i32 = -255;
180pub const BTRFS_FIRST_FREE_OBJECTID: u32 = 256;
181pub const BTRFS_LAST_FREE_OBJECTID: i32 = -256;
182pub const BTRFS_FIRST_CHUNK_TREE_OBJECTID: u32 = 256;
183pub const BTRFS_DEV_ITEMS_OBJECTID: u32 = 1;
184pub const BTRFS_BTREE_INODE_OBJECTID: u32 = 1;
185pub const BTRFS_EMPTY_SUBVOL_DIR_OBJECTID: u32 = 2;
186pub const BTRFS_DEV_REPLACE_DEVID: u32 = 0;
187pub const BTRFS_INODE_ITEM_KEY: u32 = 1;
188pub const BTRFS_INODE_REF_KEY: u32 = 12;
189pub const BTRFS_INODE_EXTREF_KEY: u32 = 13;
190pub const BTRFS_XATTR_ITEM_KEY: u32 = 24;
191pub const BTRFS_ORPHAN_ITEM_KEY: u32 = 48;
192pub const BTRFS_DIR_LOG_ITEM_KEY: u32 = 60;
193pub const BTRFS_DIR_LOG_INDEX_KEY: u32 = 72;
194pub const BTRFS_DIR_ITEM_KEY: u32 = 84;
195pub const BTRFS_DIR_INDEX_KEY: u32 = 96;
196pub const BTRFS_EXTENT_DATA_KEY: u32 = 108;
197pub const BTRFS_EXTENT_CSUM_KEY: u32 = 128;
198pub const BTRFS_ROOT_ITEM_KEY: u32 = 132;
199pub const BTRFS_ROOT_BACKREF_KEY: u32 = 144;
200pub const BTRFS_ROOT_REF_KEY: u32 = 156;
201pub const BTRFS_EXTENT_ITEM_KEY: u32 = 168;
202pub const BTRFS_METADATA_ITEM_KEY: u32 = 169;
203pub const BTRFS_TREE_BLOCK_REF_KEY: u32 = 176;
204pub const BTRFS_EXTENT_DATA_REF_KEY: u32 = 178;
205pub const BTRFS_EXTENT_REF_V0_KEY: u32 = 180;
206pub const BTRFS_SHARED_BLOCK_REF_KEY: u32 = 182;
207pub const BTRFS_SHARED_DATA_REF_KEY: u32 = 184;
208pub const BTRFS_BLOCK_GROUP_ITEM_KEY: u32 = 192;
209pub const BTRFS_FREE_SPACE_INFO_KEY: u32 = 198;
210pub const BTRFS_FREE_SPACE_EXTENT_KEY: u32 = 199;
211pub const BTRFS_FREE_SPACE_BITMAP_KEY: u32 = 200;
212pub const BTRFS_DEV_EXTENT_KEY: u32 = 204;
213pub const BTRFS_DEV_ITEM_KEY: u32 = 216;
214pub const BTRFS_CHUNK_ITEM_KEY: u32 = 228;
215pub const BTRFS_QGROUP_STATUS_KEY: u32 = 240;
216pub const BTRFS_QGROUP_INFO_KEY: u32 = 242;
217pub const BTRFS_QGROUP_LIMIT_KEY: u32 = 244;
218pub const BTRFS_QGROUP_RELATION_KEY: u32 = 246;
219pub const BTRFS_BALANCE_ITEM_KEY: u32 = 248;
220pub const BTRFS_TEMPORARY_ITEM_KEY: u32 = 248;
221pub const BTRFS_DEV_STATS_KEY: u32 = 249;
222pub const BTRFS_PERSISTENT_ITEM_KEY: u32 = 249;
223pub const BTRFS_DEV_REPLACE_KEY: u32 = 250;
224pub const BTRFS_UUID_KEY_SUBVOL: u32 = 251;
225pub const BTRFS_UUID_KEY_RECEIVED_SUBVOL: u32 = 252;
226pub const BTRFS_STRING_ITEM_KEY: u32 = 253;
227pub const BTRFS_CSUM_SIZE: u32 = 32;
228pub const BTRFS_CSUM_TYPE_CRC32: u32 = 0;
229pub const BTRFS_FT_UNKNOWN: u32 = 0;
230pub const BTRFS_FT_REG_FILE: u32 = 1;
231pub const BTRFS_FT_DIR: u32 = 2;
232pub const BTRFS_FT_CHRDEV: u32 = 3;
233pub const BTRFS_FT_BLKDEV: u32 = 4;
234pub const BTRFS_FT_FIFO: u32 = 5;
235pub const BTRFS_FT_SOCK: u32 = 6;
236pub const BTRFS_FT_SYMLINK: u32 = 7;
237pub const BTRFS_FT_XATTR: u32 = 8;
238pub const BTRFS_FT_MAX: u32 = 9;
239pub const BTRFS_FREE_SPACE_EXTENT: u32 = 1;
240pub const BTRFS_FREE_SPACE_BITMAP: u32 = 2;
241pub const BTRFS_HEADER_FLAG_WRITTEN: u32 = 1;
242pub const BTRFS_HEADER_FLAG_RELOC: u32 = 2;
243pub const BTRFS_SUPER_FLAG_ERROR: u32 = 4;
244pub const BTRFS_SUPER_FLAG_SEEDING: u64 = 4294967296;
245pub const BTRFS_SUPER_FLAG_METADUMP: u64 = 8589934592;
246pub const BTRFS_SUPER_FLAG_METADUMP_V2: u64 = 17179869184;
247pub const BTRFS_SUPER_FLAG_CHANGING_FSID: u64 = 34359738368;
248pub const BTRFS_EXTENT_FLAG_DATA: u32 = 1;
249pub const BTRFS_EXTENT_FLAG_TREE_BLOCK: u32 = 2;
250pub const BTRFS_BLOCK_FLAG_FULL_BACKREF: u32 = 256;
251pub const BTRFS_EXTENT_FLAG_SUPER: u64 = 281474976710656;
252pub const BTRFS_ROOT_SUBVOL_RDONLY: u32 = 1;
253pub const BTRFS_ROOT_SUBVOL_DEAD: u64 = 281474976710656;
254pub const BTRFS_FILE_EXTENT_INLINE: u32 = 0;
255pub const BTRFS_FILE_EXTENT_REG: u32 = 1;
256pub const BTRFS_FILE_EXTENT_PREALLOC: u32 = 2;
257pub const BTRFS_FILE_EXTENT_TYPES: u32 = 2;
258pub const BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS: u32 = 0;
259pub const BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID: u32 = 1;
260pub const BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED: u32 = 0;
261pub const BTRFS_DEV_REPLACE_ITEM_STATE_STARTED: u32 = 1;
262pub const BTRFS_DEV_REPLACE_ITEM_STATE_SUSPENDED: u32 = 2;
263pub const BTRFS_DEV_REPLACE_ITEM_STATE_FINISHED: u32 = 3;
264pub const BTRFS_DEV_REPLACE_ITEM_STATE_CANCELED: u32 = 4;
265pub const BTRFS_BLOCK_GROUP_DATA: u32 = 1;
266pub const BTRFS_BLOCK_GROUP_SYSTEM: u32 = 2;
267pub const BTRFS_BLOCK_GROUP_METADATA: u32 = 4;
268pub const BTRFS_BLOCK_GROUP_RAID0: u32 = 8;
269pub const BTRFS_BLOCK_GROUP_RAID1: u32 = 16;
270pub const BTRFS_BLOCK_GROUP_DUP: u32 = 32;
271pub const BTRFS_BLOCK_GROUP_RAID10: u32 = 64;
272pub const BTRFS_BLOCK_GROUP_RAID5: u32 = 128;
273pub const BTRFS_BLOCK_GROUP_RAID6: u32 = 256;
274pub const BTRFS_BLOCK_GROUP_TYPE_MASK: u32 = 7;
275pub const BTRFS_BLOCK_GROUP_PROFILE_MASK: u32 = 504;
276pub const BTRFS_BLOCK_GROUP_RAID56_MASK: u32 = 384;
277pub const BTRFS_AVAIL_ALLOC_BIT_SINGLE: u64 = 281474976710656;
278pub const BTRFS_SPACE_INFO_GLOBAL_RSV: u64 = 562949953421312;
279pub const BTRFS_EXTENDED_PROFILE_MASK: u64 = 281474976711160;
280pub const BTRFS_FREE_SPACE_USING_BITMAPS: u32 = 1;
281pub const BTRFS_QGROUP_LEVEL_SHIFT: u32 = 48;
282pub const BTRFS_QGROUP_STATUS_FLAG_ON: u32 = 1;
283pub const BTRFS_QGROUP_STATUS_FLAG_RESCAN: u32 = 2;
284pub const BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT: u32 = 4;
285pub const BTRFS_QGROUP_STATUS_VERSION: u32 = 1;
286pub type __s8 = ::std::os::raw::c_schar;
287pub type __u8 = ::std::os::raw::c_uchar;
288pub type __s16 = ::std::os::raw::c_short;
289pub type __u16 = ::std::os::raw::c_ushort;
290pub type __s32 = ::std::os::raw::c_int;
291pub type __u32 = ::std::os::raw::c_uint;
292pub type __s64 = ::std::os::raw::c_longlong;
293pub type __u64 = ::std::os::raw::c_ulonglong;
294#[repr(C)]
295#[derive(Debug, Copy, Clone)]
296pub struct __kernel_fd_set {
297 pub fds_bits: [::std::os::raw::c_ulong; 16usize],
298}
299#[test]
300fn bindgen_test_layout___kernel_fd_set() {
301 assert_eq!(
302 ::std::mem::size_of::<__kernel_fd_set>(),
303 128usize,
304 concat!("Size of: ", stringify!(__kernel_fd_set))
305 );
306 assert_eq!(
307 ::std::mem::align_of::<__kernel_fd_set>(),
308 8usize,
309 concat!("Alignment of ", stringify!(__kernel_fd_set))
310 );
311 fn test_field_fds_bits() {
312 assert_eq!(
313 unsafe {
314 let uninit = ::std::mem::MaybeUninit::<__kernel_fd_set>::uninit();
315 let ptr = uninit.as_ptr();
316 ::std::ptr::addr_of!((*ptr).fds_bits) as usize - ptr as usize
317 },
318 0usize,
319 concat!(
320 "Offset of field: ",
321 stringify!(__kernel_fd_set),
322 "::",
323 stringify!(fds_bits)
324 )
325 );
326 }
327 test_field_fds_bits();
328}
329pub type __kernel_sighandler_t =
330 ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
331pub type __kernel_key_t = ::std::os::raw::c_int;
332pub type __kernel_mqd_t = ::std::os::raw::c_int;
333pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
334pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
335pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
336pub type __kernel_long_t = ::std::os::raw::c_long;
337pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
338pub type __kernel_ino_t = __kernel_ulong_t;
339pub type __kernel_mode_t = ::std::os::raw::c_uint;
340pub type __kernel_pid_t = ::std::os::raw::c_int;
341pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
342pub type __kernel_uid_t = ::std::os::raw::c_uint;
343pub type __kernel_gid_t = ::std::os::raw::c_uint;
344pub type __kernel_suseconds_t = __kernel_long_t;
345pub type __kernel_daddr_t = ::std::os::raw::c_int;
346pub type __kernel_uid32_t = ::std::os::raw::c_uint;
347pub type __kernel_gid32_t = ::std::os::raw::c_uint;
348pub type __kernel_size_t = __kernel_ulong_t;
349pub type __kernel_ssize_t = __kernel_long_t;
350pub type __kernel_ptrdiff_t = __kernel_long_t;
351#[repr(C)]
352#[derive(Debug, Copy, Clone)]
353pub struct __kernel_fsid_t {
354 pub val: [::std::os::raw::c_int; 2usize],
355}
356#[test]
357fn bindgen_test_layout___kernel_fsid_t() {
358 assert_eq!(
359 ::std::mem::size_of::<__kernel_fsid_t>(),
360 8usize,
361 concat!("Size of: ", stringify!(__kernel_fsid_t))
362 );
363 assert_eq!(
364 ::std::mem::align_of::<__kernel_fsid_t>(),
365 4usize,
366 concat!("Alignment of ", stringify!(__kernel_fsid_t))
367 );
368 fn test_field_val() {
369 assert_eq!(
370 unsafe {
371 let uninit = ::std::mem::MaybeUninit::<__kernel_fsid_t>::uninit();
372 let ptr = uninit.as_ptr();
373 ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize
374 },
375 0usize,
376 concat!(
377 "Offset of field: ",
378 stringify!(__kernel_fsid_t),
379 "::",
380 stringify!(val)
381 )
382 );
383 }
384 test_field_val();
385}
386pub type __kernel_off_t = __kernel_long_t;
387pub type __kernel_loff_t = ::std::os::raw::c_longlong;
388pub type __kernel_time_t = __kernel_long_t;
389pub type __kernel_clock_t = __kernel_long_t;
390pub type __kernel_timer_t = ::std::os::raw::c_int;
391pub type __kernel_clockid_t = ::std::os::raw::c_int;
392pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
393pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
394pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
395pub type __le16 = __u16;
396pub type __be16 = __u16;
397pub type __le32 = __u32;
398pub type __be32 = __u32;
399pub type __le64 = __u64;
400pub type __be64 = __u64;
401pub type __sum16 = __u16;
402pub type __wsum = __u32;
403pub type __poll_t = ::std::os::raw::c_uint;
404#[repr(C)]
405#[derive(Debug, Copy, Clone)]
406pub struct btrfs_ioctl_vol_args {
407 pub fd: __s64,
408 pub name: [::std::os::raw::c_char; 4088usize],
409}
410#[test]
411fn bindgen_test_layout_btrfs_ioctl_vol_args() {
412 assert_eq!(
413 ::std::mem::size_of::<btrfs_ioctl_vol_args>(),
414 4096usize,
415 concat!("Size of: ", stringify!(btrfs_ioctl_vol_args))
416 );
417 assert_eq!(
418 ::std::mem::align_of::<btrfs_ioctl_vol_args>(),
419 8usize,
420 concat!("Alignment of ", stringify!(btrfs_ioctl_vol_args))
421 );
422 fn test_field_fd() {
423 assert_eq!(
424 unsafe {
425 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args>::uninit();
426 let ptr = uninit.as_ptr();
427 ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize
428 },
429 0usize,
430 concat!(
431 "Offset of field: ",
432 stringify!(btrfs_ioctl_vol_args),
433 "::",
434 stringify!(fd)
435 )
436 );
437 }
438 test_field_fd();
439 fn test_field_name() {
440 assert_eq!(
441 unsafe {
442 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args>::uninit();
443 let ptr = uninit.as_ptr();
444 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
445 },
446 8usize,
447 concat!(
448 "Offset of field: ",
449 stringify!(btrfs_ioctl_vol_args),
450 "::",
451 stringify!(name)
452 )
453 );
454 }
455 test_field_name();
456}
457#[repr(C)]
458#[derive(Debug, Copy, Clone)]
459pub struct btrfs_qgroup_limit {
460 pub flags: __u64,
461 pub max_rfer: __u64,
462 pub max_excl: __u64,
463 pub rsv_rfer: __u64,
464 pub rsv_excl: __u64,
465}
466#[test]
467fn bindgen_test_layout_btrfs_qgroup_limit() {
468 assert_eq!(
469 ::std::mem::size_of::<btrfs_qgroup_limit>(),
470 40usize,
471 concat!("Size of: ", stringify!(btrfs_qgroup_limit))
472 );
473 assert_eq!(
474 ::std::mem::align_of::<btrfs_qgroup_limit>(),
475 8usize,
476 concat!("Alignment of ", stringify!(btrfs_qgroup_limit))
477 );
478 fn test_field_flags() {
479 assert_eq!(
480 unsafe {
481 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit>::uninit();
482 let ptr = uninit.as_ptr();
483 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
484 },
485 0usize,
486 concat!(
487 "Offset of field: ",
488 stringify!(btrfs_qgroup_limit),
489 "::",
490 stringify!(flags)
491 )
492 );
493 }
494 test_field_flags();
495 fn test_field_max_rfer() {
496 assert_eq!(
497 unsafe {
498 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit>::uninit();
499 let ptr = uninit.as_ptr();
500 ::std::ptr::addr_of!((*ptr).max_rfer) as usize - ptr as usize
501 },
502 8usize,
503 concat!(
504 "Offset of field: ",
505 stringify!(btrfs_qgroup_limit),
506 "::",
507 stringify!(max_rfer)
508 )
509 );
510 }
511 test_field_max_rfer();
512 fn test_field_max_excl() {
513 assert_eq!(
514 unsafe {
515 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit>::uninit();
516 let ptr = uninit.as_ptr();
517 ::std::ptr::addr_of!((*ptr).max_excl) as usize - ptr as usize
518 },
519 16usize,
520 concat!(
521 "Offset of field: ",
522 stringify!(btrfs_qgroup_limit),
523 "::",
524 stringify!(max_excl)
525 )
526 );
527 }
528 test_field_max_excl();
529 fn test_field_rsv_rfer() {
530 assert_eq!(
531 unsafe {
532 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit>::uninit();
533 let ptr = uninit.as_ptr();
534 ::std::ptr::addr_of!((*ptr).rsv_rfer) as usize - ptr as usize
535 },
536 24usize,
537 concat!(
538 "Offset of field: ",
539 stringify!(btrfs_qgroup_limit),
540 "::",
541 stringify!(rsv_rfer)
542 )
543 );
544 }
545 test_field_rsv_rfer();
546 fn test_field_rsv_excl() {
547 assert_eq!(
548 unsafe {
549 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit>::uninit();
550 let ptr = uninit.as_ptr();
551 ::std::ptr::addr_of!((*ptr).rsv_excl) as usize - ptr as usize
552 },
553 32usize,
554 concat!(
555 "Offset of field: ",
556 stringify!(btrfs_qgroup_limit),
557 "::",
558 stringify!(rsv_excl)
559 )
560 );
561 }
562 test_field_rsv_excl();
563}
564#[repr(C)]
565#[derive(Debug)]
566pub struct btrfs_qgroup_inherit {
567 pub flags: __u64,
568 pub num_qgroups: __u64,
569 pub num_ref_copies: __u64,
570 pub num_excl_copies: __u64,
571 pub lim: btrfs_qgroup_limit,
572 pub qgroups: __IncompleteArrayField<__u64>,
573}
574#[test]
575fn bindgen_test_layout_btrfs_qgroup_inherit() {
576 assert_eq!(
577 ::std::mem::size_of::<btrfs_qgroup_inherit>(),
578 72usize,
579 concat!("Size of: ", stringify!(btrfs_qgroup_inherit))
580 );
581 assert_eq!(
582 ::std::mem::align_of::<btrfs_qgroup_inherit>(),
583 8usize,
584 concat!("Alignment of ", stringify!(btrfs_qgroup_inherit))
585 );
586 fn test_field_flags() {
587 assert_eq!(
588 unsafe {
589 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_inherit>::uninit();
590 let ptr = uninit.as_ptr();
591 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
592 },
593 0usize,
594 concat!(
595 "Offset of field: ",
596 stringify!(btrfs_qgroup_inherit),
597 "::",
598 stringify!(flags)
599 )
600 );
601 }
602 test_field_flags();
603 fn test_field_num_qgroups() {
604 assert_eq!(
605 unsafe {
606 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_inherit>::uninit();
607 let ptr = uninit.as_ptr();
608 ::std::ptr::addr_of!((*ptr).num_qgroups) as usize - ptr as usize
609 },
610 8usize,
611 concat!(
612 "Offset of field: ",
613 stringify!(btrfs_qgroup_inherit),
614 "::",
615 stringify!(num_qgroups)
616 )
617 );
618 }
619 test_field_num_qgroups();
620 fn test_field_num_ref_copies() {
621 assert_eq!(
622 unsafe {
623 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_inherit>::uninit();
624 let ptr = uninit.as_ptr();
625 ::std::ptr::addr_of!((*ptr).num_ref_copies) as usize - ptr as usize
626 },
627 16usize,
628 concat!(
629 "Offset of field: ",
630 stringify!(btrfs_qgroup_inherit),
631 "::",
632 stringify!(num_ref_copies)
633 )
634 );
635 }
636 test_field_num_ref_copies();
637 fn test_field_num_excl_copies() {
638 assert_eq!(
639 unsafe {
640 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_inherit>::uninit();
641 let ptr = uninit.as_ptr();
642 ::std::ptr::addr_of!((*ptr).num_excl_copies) as usize - ptr as usize
643 },
644 24usize,
645 concat!(
646 "Offset of field: ",
647 stringify!(btrfs_qgroup_inherit),
648 "::",
649 stringify!(num_excl_copies)
650 )
651 );
652 }
653 test_field_num_excl_copies();
654 fn test_field_lim() {
655 assert_eq!(
656 unsafe {
657 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_inherit>::uninit();
658 let ptr = uninit.as_ptr();
659 ::std::ptr::addr_of!((*ptr).lim) as usize - ptr as usize
660 },
661 32usize,
662 concat!(
663 "Offset of field: ",
664 stringify!(btrfs_qgroup_inherit),
665 "::",
666 stringify!(lim)
667 )
668 );
669 }
670 test_field_lim();
671 fn test_field_qgroups() {
672 assert_eq!(
673 unsafe {
674 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_inherit>::uninit();
675 let ptr = uninit.as_ptr();
676 ::std::ptr::addr_of!((*ptr).qgroups) as usize - ptr as usize
677 },
678 72usize,
679 concat!(
680 "Offset of field: ",
681 stringify!(btrfs_qgroup_inherit),
682 "::",
683 stringify!(qgroups)
684 )
685 );
686 }
687 test_field_qgroups();
688}
689#[repr(C)]
690#[derive(Debug, Copy, Clone)]
691pub struct btrfs_ioctl_qgroup_limit_args {
692 pub qgroupid: __u64,
693 pub lim: btrfs_qgroup_limit,
694}
695#[test]
696fn bindgen_test_layout_btrfs_ioctl_qgroup_limit_args() {
697 assert_eq!(
698 ::std::mem::size_of::<btrfs_ioctl_qgroup_limit_args>(),
699 48usize,
700 concat!("Size of: ", stringify!(btrfs_ioctl_qgroup_limit_args))
701 );
702 assert_eq!(
703 ::std::mem::align_of::<btrfs_ioctl_qgroup_limit_args>(),
704 8usize,
705 concat!("Alignment of ", stringify!(btrfs_ioctl_qgroup_limit_args))
706 );
707 fn test_field_qgroupid() {
708 assert_eq!(
709 unsafe {
710 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_limit_args>::uninit();
711 let ptr = uninit.as_ptr();
712 ::std::ptr::addr_of!((*ptr).qgroupid) as usize - ptr as usize
713 },
714 0usize,
715 concat!(
716 "Offset of field: ",
717 stringify!(btrfs_ioctl_qgroup_limit_args),
718 "::",
719 stringify!(qgroupid)
720 )
721 );
722 }
723 test_field_qgroupid();
724 fn test_field_lim() {
725 assert_eq!(
726 unsafe {
727 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_limit_args>::uninit();
728 let ptr = uninit.as_ptr();
729 ::std::ptr::addr_of!((*ptr).lim) as usize - ptr as usize
730 },
731 8usize,
732 concat!(
733 "Offset of field: ",
734 stringify!(btrfs_ioctl_qgroup_limit_args),
735 "::",
736 stringify!(lim)
737 )
738 );
739 }
740 test_field_lim();
741}
742#[repr(C)]
743#[derive(Copy, Clone)]
744pub struct btrfs_ioctl_vol_args_v2 {
745 pub fd: __s64,
746 pub transid: __u64,
747 pub flags: __u64,
748 pub __bindgen_anon_1: btrfs_ioctl_vol_args_v2__bindgen_ty_1,
749 pub __bindgen_anon_2: btrfs_ioctl_vol_args_v2__bindgen_ty_2,
750}
751#[repr(C)]
752#[derive(Copy, Clone)]
753pub union btrfs_ioctl_vol_args_v2__bindgen_ty_1 {
754 pub __bindgen_anon_1: btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1,
755 pub unused: [__u64; 4usize],
756}
757#[repr(C)]
758#[derive(Debug, Copy, Clone)]
759pub struct btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1 {
760 pub size: __u64,
761 pub qgroup_inherit: *mut btrfs_qgroup_inherit,
762}
763#[test]
764fn bindgen_test_layout_btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1() {
765 assert_eq!(
766 ::std::mem::size_of::<btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1>(),
767 16usize,
768 concat!(
769 "Size of: ",
770 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1)
771 )
772 );
773 assert_eq!(
774 ::std::mem::align_of::<btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1>(),
775 8usize,
776 concat!(
777 "Alignment of ",
778 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1)
779 )
780 );
781 fn test_field_size() {
782 assert_eq!(
783 unsafe {
784 let uninit = ::std::mem::MaybeUninit::<
785 btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1,
786 >::uninit();
787 let ptr = uninit.as_ptr();
788 ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
789 },
790 0usize,
791 concat!(
792 "Offset of field: ",
793 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1),
794 "::",
795 stringify!(size)
796 )
797 );
798 }
799 test_field_size();
800 fn test_field_qgroup_inherit() {
801 assert_eq!(
802 unsafe {
803 let uninit = ::std::mem::MaybeUninit::<
804 btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1,
805 >::uninit();
806 let ptr = uninit.as_ptr();
807 ::std::ptr::addr_of!((*ptr).qgroup_inherit) as usize - ptr as usize
808 },
809 8usize,
810 concat!(
811 "Offset of field: ",
812 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1),
813 "::",
814 stringify!(qgroup_inherit)
815 )
816 );
817 }
818 test_field_qgroup_inherit();
819}
820#[test]
821fn bindgen_test_layout_btrfs_ioctl_vol_args_v2__bindgen_ty_1() {
822 assert_eq!(
823 ::std::mem::size_of::<btrfs_ioctl_vol_args_v2__bindgen_ty_1>(),
824 32usize,
825 concat!(
826 "Size of: ",
827 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1)
828 )
829 );
830 assert_eq!(
831 ::std::mem::align_of::<btrfs_ioctl_vol_args_v2__bindgen_ty_1>(),
832 8usize,
833 concat!(
834 "Alignment of ",
835 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1)
836 )
837 );
838 fn test_field_unused() {
839 assert_eq!(
840 unsafe {
841 let uninit =
842 ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args_v2__bindgen_ty_1>::uninit();
843 let ptr = uninit.as_ptr();
844 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
845 },
846 0usize,
847 concat!(
848 "Offset of field: ",
849 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_1),
850 "::",
851 stringify!(unused)
852 )
853 );
854 }
855 test_field_unused();
856}
857#[repr(C)]
858#[derive(Copy, Clone)]
859pub union btrfs_ioctl_vol_args_v2__bindgen_ty_2 {
860 pub name: [::std::os::raw::c_char; 4040usize],
861 pub devid: __u64,
862}
863#[test]
864fn bindgen_test_layout_btrfs_ioctl_vol_args_v2__bindgen_ty_2() {
865 assert_eq!(
866 ::std::mem::size_of::<btrfs_ioctl_vol_args_v2__bindgen_ty_2>(),
867 4040usize,
868 concat!(
869 "Size of: ",
870 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_2)
871 )
872 );
873 assert_eq!(
874 ::std::mem::align_of::<btrfs_ioctl_vol_args_v2__bindgen_ty_2>(),
875 8usize,
876 concat!(
877 "Alignment of ",
878 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_2)
879 )
880 );
881 fn test_field_name() {
882 assert_eq!(
883 unsafe {
884 let uninit =
885 ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args_v2__bindgen_ty_2>::uninit();
886 let ptr = uninit.as_ptr();
887 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
888 },
889 0usize,
890 concat!(
891 "Offset of field: ",
892 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_2),
893 "::",
894 stringify!(name)
895 )
896 );
897 }
898 test_field_name();
899 fn test_field_devid() {
900 assert_eq!(
901 unsafe {
902 let uninit =
903 ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args_v2__bindgen_ty_2>::uninit();
904 let ptr = uninit.as_ptr();
905 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
906 },
907 0usize,
908 concat!(
909 "Offset of field: ",
910 stringify!(btrfs_ioctl_vol_args_v2__bindgen_ty_2),
911 "::",
912 stringify!(devid)
913 )
914 );
915 }
916 test_field_devid();
917}
918#[test]
919fn bindgen_test_layout_btrfs_ioctl_vol_args_v2() {
920 assert_eq!(
921 ::std::mem::size_of::<btrfs_ioctl_vol_args_v2>(),
922 4096usize,
923 concat!("Size of: ", stringify!(btrfs_ioctl_vol_args_v2))
924 );
925 assert_eq!(
926 ::std::mem::align_of::<btrfs_ioctl_vol_args_v2>(),
927 8usize,
928 concat!("Alignment of ", stringify!(btrfs_ioctl_vol_args_v2))
929 );
930 fn test_field_fd() {
931 assert_eq!(
932 unsafe {
933 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args_v2>::uninit();
934 let ptr = uninit.as_ptr();
935 ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize
936 },
937 0usize,
938 concat!(
939 "Offset of field: ",
940 stringify!(btrfs_ioctl_vol_args_v2),
941 "::",
942 stringify!(fd)
943 )
944 );
945 }
946 test_field_fd();
947 fn test_field_transid() {
948 assert_eq!(
949 unsafe {
950 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args_v2>::uninit();
951 let ptr = uninit.as_ptr();
952 ::std::ptr::addr_of!((*ptr).transid) as usize - ptr as usize
953 },
954 8usize,
955 concat!(
956 "Offset of field: ",
957 stringify!(btrfs_ioctl_vol_args_v2),
958 "::",
959 stringify!(transid)
960 )
961 );
962 }
963 test_field_transid();
964 fn test_field_flags() {
965 assert_eq!(
966 unsafe {
967 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_vol_args_v2>::uninit();
968 let ptr = uninit.as_ptr();
969 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
970 },
971 16usize,
972 concat!(
973 "Offset of field: ",
974 stringify!(btrfs_ioctl_vol_args_v2),
975 "::",
976 stringify!(flags)
977 )
978 );
979 }
980 test_field_flags();
981}
982#[repr(C)]
983#[derive(Debug, Copy, Clone)]
984pub struct btrfs_scrub_progress {
985 pub data_extents_scrubbed: __u64,
986 pub tree_extents_scrubbed: __u64,
987 pub data_bytes_scrubbed: __u64,
988 pub tree_bytes_scrubbed: __u64,
989 pub read_errors: __u64,
990 pub csum_errors: __u64,
991 pub verify_errors: __u64,
992 pub no_csum: __u64,
993 pub csum_discards: __u64,
994 pub super_errors: __u64,
995 pub malloc_errors: __u64,
996 pub uncorrectable_errors: __u64,
997 pub corrected_errors: __u64,
998 pub last_physical: __u64,
999 pub unverified_errors: __u64,
1000}
1001#[test]
1002fn bindgen_test_layout_btrfs_scrub_progress() {
1003 assert_eq!(
1004 ::std::mem::size_of::<btrfs_scrub_progress>(),
1005 120usize,
1006 concat!("Size of: ", stringify!(btrfs_scrub_progress))
1007 );
1008 assert_eq!(
1009 ::std::mem::align_of::<btrfs_scrub_progress>(),
1010 8usize,
1011 concat!("Alignment of ", stringify!(btrfs_scrub_progress))
1012 );
1013 fn test_field_data_extents_scrubbed() {
1014 assert_eq!(
1015 unsafe {
1016 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1017 let ptr = uninit.as_ptr();
1018 ::std::ptr::addr_of!((*ptr).data_extents_scrubbed) as usize - ptr as usize
1019 },
1020 0usize,
1021 concat!(
1022 "Offset of field: ",
1023 stringify!(btrfs_scrub_progress),
1024 "::",
1025 stringify!(data_extents_scrubbed)
1026 )
1027 );
1028 }
1029 test_field_data_extents_scrubbed();
1030 fn test_field_tree_extents_scrubbed() {
1031 assert_eq!(
1032 unsafe {
1033 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1034 let ptr = uninit.as_ptr();
1035 ::std::ptr::addr_of!((*ptr).tree_extents_scrubbed) as usize - ptr as usize
1036 },
1037 8usize,
1038 concat!(
1039 "Offset of field: ",
1040 stringify!(btrfs_scrub_progress),
1041 "::",
1042 stringify!(tree_extents_scrubbed)
1043 )
1044 );
1045 }
1046 test_field_tree_extents_scrubbed();
1047 fn test_field_data_bytes_scrubbed() {
1048 assert_eq!(
1049 unsafe {
1050 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1051 let ptr = uninit.as_ptr();
1052 ::std::ptr::addr_of!((*ptr).data_bytes_scrubbed) as usize - ptr as usize
1053 },
1054 16usize,
1055 concat!(
1056 "Offset of field: ",
1057 stringify!(btrfs_scrub_progress),
1058 "::",
1059 stringify!(data_bytes_scrubbed)
1060 )
1061 );
1062 }
1063 test_field_data_bytes_scrubbed();
1064 fn test_field_tree_bytes_scrubbed() {
1065 assert_eq!(
1066 unsafe {
1067 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1068 let ptr = uninit.as_ptr();
1069 ::std::ptr::addr_of!((*ptr).tree_bytes_scrubbed) as usize - ptr as usize
1070 },
1071 24usize,
1072 concat!(
1073 "Offset of field: ",
1074 stringify!(btrfs_scrub_progress),
1075 "::",
1076 stringify!(tree_bytes_scrubbed)
1077 )
1078 );
1079 }
1080 test_field_tree_bytes_scrubbed();
1081 fn test_field_read_errors() {
1082 assert_eq!(
1083 unsafe {
1084 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1085 let ptr = uninit.as_ptr();
1086 ::std::ptr::addr_of!((*ptr).read_errors) as usize - ptr as usize
1087 },
1088 32usize,
1089 concat!(
1090 "Offset of field: ",
1091 stringify!(btrfs_scrub_progress),
1092 "::",
1093 stringify!(read_errors)
1094 )
1095 );
1096 }
1097 test_field_read_errors();
1098 fn test_field_csum_errors() {
1099 assert_eq!(
1100 unsafe {
1101 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1102 let ptr = uninit.as_ptr();
1103 ::std::ptr::addr_of!((*ptr).csum_errors) as usize - ptr as usize
1104 },
1105 40usize,
1106 concat!(
1107 "Offset of field: ",
1108 stringify!(btrfs_scrub_progress),
1109 "::",
1110 stringify!(csum_errors)
1111 )
1112 );
1113 }
1114 test_field_csum_errors();
1115 fn test_field_verify_errors() {
1116 assert_eq!(
1117 unsafe {
1118 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1119 let ptr = uninit.as_ptr();
1120 ::std::ptr::addr_of!((*ptr).verify_errors) as usize - ptr as usize
1121 },
1122 48usize,
1123 concat!(
1124 "Offset of field: ",
1125 stringify!(btrfs_scrub_progress),
1126 "::",
1127 stringify!(verify_errors)
1128 )
1129 );
1130 }
1131 test_field_verify_errors();
1132 fn test_field_no_csum() {
1133 assert_eq!(
1134 unsafe {
1135 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1136 let ptr = uninit.as_ptr();
1137 ::std::ptr::addr_of!((*ptr).no_csum) as usize - ptr as usize
1138 },
1139 56usize,
1140 concat!(
1141 "Offset of field: ",
1142 stringify!(btrfs_scrub_progress),
1143 "::",
1144 stringify!(no_csum)
1145 )
1146 );
1147 }
1148 test_field_no_csum();
1149 fn test_field_csum_discards() {
1150 assert_eq!(
1151 unsafe {
1152 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1153 let ptr = uninit.as_ptr();
1154 ::std::ptr::addr_of!((*ptr).csum_discards) as usize - ptr as usize
1155 },
1156 64usize,
1157 concat!(
1158 "Offset of field: ",
1159 stringify!(btrfs_scrub_progress),
1160 "::",
1161 stringify!(csum_discards)
1162 )
1163 );
1164 }
1165 test_field_csum_discards();
1166 fn test_field_super_errors() {
1167 assert_eq!(
1168 unsafe {
1169 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1170 let ptr = uninit.as_ptr();
1171 ::std::ptr::addr_of!((*ptr).super_errors) as usize - ptr as usize
1172 },
1173 72usize,
1174 concat!(
1175 "Offset of field: ",
1176 stringify!(btrfs_scrub_progress),
1177 "::",
1178 stringify!(super_errors)
1179 )
1180 );
1181 }
1182 test_field_super_errors();
1183 fn test_field_malloc_errors() {
1184 assert_eq!(
1185 unsafe {
1186 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1187 let ptr = uninit.as_ptr();
1188 ::std::ptr::addr_of!((*ptr).malloc_errors) as usize - ptr as usize
1189 },
1190 80usize,
1191 concat!(
1192 "Offset of field: ",
1193 stringify!(btrfs_scrub_progress),
1194 "::",
1195 stringify!(malloc_errors)
1196 )
1197 );
1198 }
1199 test_field_malloc_errors();
1200 fn test_field_uncorrectable_errors() {
1201 assert_eq!(
1202 unsafe {
1203 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1204 let ptr = uninit.as_ptr();
1205 ::std::ptr::addr_of!((*ptr).uncorrectable_errors) as usize - ptr as usize
1206 },
1207 88usize,
1208 concat!(
1209 "Offset of field: ",
1210 stringify!(btrfs_scrub_progress),
1211 "::",
1212 stringify!(uncorrectable_errors)
1213 )
1214 );
1215 }
1216 test_field_uncorrectable_errors();
1217 fn test_field_corrected_errors() {
1218 assert_eq!(
1219 unsafe {
1220 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1221 let ptr = uninit.as_ptr();
1222 ::std::ptr::addr_of!((*ptr).corrected_errors) as usize - ptr as usize
1223 },
1224 96usize,
1225 concat!(
1226 "Offset of field: ",
1227 stringify!(btrfs_scrub_progress),
1228 "::",
1229 stringify!(corrected_errors)
1230 )
1231 );
1232 }
1233 test_field_corrected_errors();
1234 fn test_field_last_physical() {
1235 assert_eq!(
1236 unsafe {
1237 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1238 let ptr = uninit.as_ptr();
1239 ::std::ptr::addr_of!((*ptr).last_physical) as usize - ptr as usize
1240 },
1241 104usize,
1242 concat!(
1243 "Offset of field: ",
1244 stringify!(btrfs_scrub_progress),
1245 "::",
1246 stringify!(last_physical)
1247 )
1248 );
1249 }
1250 test_field_last_physical();
1251 fn test_field_unverified_errors() {
1252 assert_eq!(
1253 unsafe {
1254 let uninit = ::std::mem::MaybeUninit::<btrfs_scrub_progress>::uninit();
1255 let ptr = uninit.as_ptr();
1256 ::std::ptr::addr_of!((*ptr).unverified_errors) as usize - ptr as usize
1257 },
1258 112usize,
1259 concat!(
1260 "Offset of field: ",
1261 stringify!(btrfs_scrub_progress),
1262 "::",
1263 stringify!(unverified_errors)
1264 )
1265 );
1266 }
1267 test_field_unverified_errors();
1268}
1269#[repr(C)]
1270#[derive(Debug, Copy, Clone)]
1271pub struct btrfs_ioctl_scrub_args {
1272 pub devid: __u64,
1273 pub start: __u64,
1274 pub end: __u64,
1275 pub flags: __u64,
1276 pub progress: btrfs_scrub_progress,
1277 pub unused: [__u64; 109usize],
1278}
1279#[test]
1280fn bindgen_test_layout_btrfs_ioctl_scrub_args() {
1281 assert_eq!(
1282 ::std::mem::size_of::<btrfs_ioctl_scrub_args>(),
1283 1024usize,
1284 concat!("Size of: ", stringify!(btrfs_ioctl_scrub_args))
1285 );
1286 assert_eq!(
1287 ::std::mem::align_of::<btrfs_ioctl_scrub_args>(),
1288 8usize,
1289 concat!("Alignment of ", stringify!(btrfs_ioctl_scrub_args))
1290 );
1291 fn test_field_devid() {
1292 assert_eq!(
1293 unsafe {
1294 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_scrub_args>::uninit();
1295 let ptr = uninit.as_ptr();
1296 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
1297 },
1298 0usize,
1299 concat!(
1300 "Offset of field: ",
1301 stringify!(btrfs_ioctl_scrub_args),
1302 "::",
1303 stringify!(devid)
1304 )
1305 );
1306 }
1307 test_field_devid();
1308 fn test_field_start() {
1309 assert_eq!(
1310 unsafe {
1311 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_scrub_args>::uninit();
1312 let ptr = uninit.as_ptr();
1313 ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize
1314 },
1315 8usize,
1316 concat!(
1317 "Offset of field: ",
1318 stringify!(btrfs_ioctl_scrub_args),
1319 "::",
1320 stringify!(start)
1321 )
1322 );
1323 }
1324 test_field_start();
1325 fn test_field_end() {
1326 assert_eq!(
1327 unsafe {
1328 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_scrub_args>::uninit();
1329 let ptr = uninit.as_ptr();
1330 ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize
1331 },
1332 16usize,
1333 concat!(
1334 "Offset of field: ",
1335 stringify!(btrfs_ioctl_scrub_args),
1336 "::",
1337 stringify!(end)
1338 )
1339 );
1340 }
1341 test_field_end();
1342 fn test_field_flags() {
1343 assert_eq!(
1344 unsafe {
1345 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_scrub_args>::uninit();
1346 let ptr = uninit.as_ptr();
1347 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
1348 },
1349 24usize,
1350 concat!(
1351 "Offset of field: ",
1352 stringify!(btrfs_ioctl_scrub_args),
1353 "::",
1354 stringify!(flags)
1355 )
1356 );
1357 }
1358 test_field_flags();
1359 fn test_field_progress() {
1360 assert_eq!(
1361 unsafe {
1362 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_scrub_args>::uninit();
1363 let ptr = uninit.as_ptr();
1364 ::std::ptr::addr_of!((*ptr).progress) as usize - ptr as usize
1365 },
1366 32usize,
1367 concat!(
1368 "Offset of field: ",
1369 stringify!(btrfs_ioctl_scrub_args),
1370 "::",
1371 stringify!(progress)
1372 )
1373 );
1374 }
1375 test_field_progress();
1376 fn test_field_unused() {
1377 assert_eq!(
1378 unsafe {
1379 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_scrub_args>::uninit();
1380 let ptr = uninit.as_ptr();
1381 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
1382 },
1383 152usize,
1384 concat!(
1385 "Offset of field: ",
1386 stringify!(btrfs_ioctl_scrub_args),
1387 "::",
1388 stringify!(unused)
1389 )
1390 );
1391 }
1392 test_field_unused();
1393}
1394#[repr(C)]
1395#[derive(Debug, Copy, Clone)]
1396pub struct btrfs_ioctl_dev_replace_start_params {
1397 pub srcdevid: __u64,
1398 pub cont_reading_from_srcdev_mode: __u64,
1399 pub srcdev_name: [__u8; 1025usize],
1400 pub tgtdev_name: [__u8; 1025usize],
1401}
1402#[test]
1403fn bindgen_test_layout_btrfs_ioctl_dev_replace_start_params() {
1404 assert_eq!(
1405 ::std::mem::size_of::<btrfs_ioctl_dev_replace_start_params>(),
1406 2072usize,
1407 concat!(
1408 "Size of: ",
1409 stringify!(btrfs_ioctl_dev_replace_start_params)
1410 )
1411 );
1412 assert_eq!(
1413 ::std::mem::align_of::<btrfs_ioctl_dev_replace_start_params>(),
1414 8usize,
1415 concat!(
1416 "Alignment of ",
1417 stringify!(btrfs_ioctl_dev_replace_start_params)
1418 )
1419 );
1420 fn test_field_srcdevid() {
1421 assert_eq!(
1422 unsafe {
1423 let uninit =
1424 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_start_params>::uninit();
1425 let ptr = uninit.as_ptr();
1426 ::std::ptr::addr_of!((*ptr).srcdevid) as usize - ptr as usize
1427 },
1428 0usize,
1429 concat!(
1430 "Offset of field: ",
1431 stringify!(btrfs_ioctl_dev_replace_start_params),
1432 "::",
1433 stringify!(srcdevid)
1434 )
1435 );
1436 }
1437 test_field_srcdevid();
1438 fn test_field_cont_reading_from_srcdev_mode() {
1439 assert_eq!(
1440 unsafe {
1441 let uninit =
1442 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_start_params>::uninit();
1443 let ptr = uninit.as_ptr();
1444 ::std::ptr::addr_of!((*ptr).cont_reading_from_srcdev_mode) as usize - ptr as usize
1445 },
1446 8usize,
1447 concat!(
1448 "Offset of field: ",
1449 stringify!(btrfs_ioctl_dev_replace_start_params),
1450 "::",
1451 stringify!(cont_reading_from_srcdev_mode)
1452 )
1453 );
1454 }
1455 test_field_cont_reading_from_srcdev_mode();
1456 fn test_field_srcdev_name() {
1457 assert_eq!(
1458 unsafe {
1459 let uninit =
1460 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_start_params>::uninit();
1461 let ptr = uninit.as_ptr();
1462 ::std::ptr::addr_of!((*ptr).srcdev_name) as usize - ptr as usize
1463 },
1464 16usize,
1465 concat!(
1466 "Offset of field: ",
1467 stringify!(btrfs_ioctl_dev_replace_start_params),
1468 "::",
1469 stringify!(srcdev_name)
1470 )
1471 );
1472 }
1473 test_field_srcdev_name();
1474 fn test_field_tgtdev_name() {
1475 assert_eq!(
1476 unsafe {
1477 let uninit =
1478 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_start_params>::uninit();
1479 let ptr = uninit.as_ptr();
1480 ::std::ptr::addr_of!((*ptr).tgtdev_name) as usize - ptr as usize
1481 },
1482 1041usize,
1483 concat!(
1484 "Offset of field: ",
1485 stringify!(btrfs_ioctl_dev_replace_start_params),
1486 "::",
1487 stringify!(tgtdev_name)
1488 )
1489 );
1490 }
1491 test_field_tgtdev_name();
1492}
1493#[repr(C)]
1494#[derive(Debug, Copy, Clone)]
1495pub struct btrfs_ioctl_dev_replace_status_params {
1496 pub replace_state: __u64,
1497 pub progress_1000: __u64,
1498 pub time_started: __u64,
1499 pub time_stopped: __u64,
1500 pub num_write_errors: __u64,
1501 pub num_uncorrectable_read_errors: __u64,
1502}
1503#[test]
1504fn bindgen_test_layout_btrfs_ioctl_dev_replace_status_params() {
1505 assert_eq!(
1506 ::std::mem::size_of::<btrfs_ioctl_dev_replace_status_params>(),
1507 48usize,
1508 concat!(
1509 "Size of: ",
1510 stringify!(btrfs_ioctl_dev_replace_status_params)
1511 )
1512 );
1513 assert_eq!(
1514 ::std::mem::align_of::<btrfs_ioctl_dev_replace_status_params>(),
1515 8usize,
1516 concat!(
1517 "Alignment of ",
1518 stringify!(btrfs_ioctl_dev_replace_status_params)
1519 )
1520 );
1521 fn test_field_replace_state() {
1522 assert_eq!(
1523 unsafe {
1524 let uninit =
1525 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_status_params>::uninit();
1526 let ptr = uninit.as_ptr();
1527 ::std::ptr::addr_of!((*ptr).replace_state) as usize - ptr as usize
1528 },
1529 0usize,
1530 concat!(
1531 "Offset of field: ",
1532 stringify!(btrfs_ioctl_dev_replace_status_params),
1533 "::",
1534 stringify!(replace_state)
1535 )
1536 );
1537 }
1538 test_field_replace_state();
1539 fn test_field_progress_1000() {
1540 assert_eq!(
1541 unsafe {
1542 let uninit =
1543 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_status_params>::uninit();
1544 let ptr = uninit.as_ptr();
1545 ::std::ptr::addr_of!((*ptr).progress_1000) as usize - ptr as usize
1546 },
1547 8usize,
1548 concat!(
1549 "Offset of field: ",
1550 stringify!(btrfs_ioctl_dev_replace_status_params),
1551 "::",
1552 stringify!(progress_1000)
1553 )
1554 );
1555 }
1556 test_field_progress_1000();
1557 fn test_field_time_started() {
1558 assert_eq!(
1559 unsafe {
1560 let uninit =
1561 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_status_params>::uninit();
1562 let ptr = uninit.as_ptr();
1563 ::std::ptr::addr_of!((*ptr).time_started) as usize - ptr as usize
1564 },
1565 16usize,
1566 concat!(
1567 "Offset of field: ",
1568 stringify!(btrfs_ioctl_dev_replace_status_params),
1569 "::",
1570 stringify!(time_started)
1571 )
1572 );
1573 }
1574 test_field_time_started();
1575 fn test_field_time_stopped() {
1576 assert_eq!(
1577 unsafe {
1578 let uninit =
1579 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_status_params>::uninit();
1580 let ptr = uninit.as_ptr();
1581 ::std::ptr::addr_of!((*ptr).time_stopped) as usize - ptr as usize
1582 },
1583 24usize,
1584 concat!(
1585 "Offset of field: ",
1586 stringify!(btrfs_ioctl_dev_replace_status_params),
1587 "::",
1588 stringify!(time_stopped)
1589 )
1590 );
1591 }
1592 test_field_time_stopped();
1593 fn test_field_num_write_errors() {
1594 assert_eq!(
1595 unsafe {
1596 let uninit =
1597 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_status_params>::uninit();
1598 let ptr = uninit.as_ptr();
1599 ::std::ptr::addr_of!((*ptr).num_write_errors) as usize - ptr as usize
1600 },
1601 32usize,
1602 concat!(
1603 "Offset of field: ",
1604 stringify!(btrfs_ioctl_dev_replace_status_params),
1605 "::",
1606 stringify!(num_write_errors)
1607 )
1608 );
1609 }
1610 test_field_num_write_errors();
1611 fn test_field_num_uncorrectable_read_errors() {
1612 assert_eq!(
1613 unsafe {
1614 let uninit =
1615 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_status_params>::uninit();
1616 let ptr = uninit.as_ptr();
1617 ::std::ptr::addr_of!((*ptr).num_uncorrectable_read_errors) as usize - ptr as usize
1618 },
1619 40usize,
1620 concat!(
1621 "Offset of field: ",
1622 stringify!(btrfs_ioctl_dev_replace_status_params),
1623 "::",
1624 stringify!(num_uncorrectable_read_errors)
1625 )
1626 );
1627 }
1628 test_field_num_uncorrectable_read_errors();
1629}
1630#[repr(C)]
1631#[derive(Copy, Clone)]
1632pub struct btrfs_ioctl_dev_replace_args {
1633 pub cmd: __u64,
1634 pub result: __u64,
1635 pub __bindgen_anon_1: btrfs_ioctl_dev_replace_args__bindgen_ty_1,
1636 pub spare: [__u64; 64usize],
1637}
1638#[repr(C)]
1639#[derive(Copy, Clone)]
1640pub union btrfs_ioctl_dev_replace_args__bindgen_ty_1 {
1641 pub start: btrfs_ioctl_dev_replace_start_params,
1642 pub status: btrfs_ioctl_dev_replace_status_params,
1643}
1644#[test]
1645fn bindgen_test_layout_btrfs_ioctl_dev_replace_args__bindgen_ty_1() {
1646 assert_eq!(
1647 ::std::mem::size_of::<btrfs_ioctl_dev_replace_args__bindgen_ty_1>(),
1648 2072usize,
1649 concat!(
1650 "Size of: ",
1651 stringify!(btrfs_ioctl_dev_replace_args__bindgen_ty_1)
1652 )
1653 );
1654 assert_eq!(
1655 ::std::mem::align_of::<btrfs_ioctl_dev_replace_args__bindgen_ty_1>(),
1656 8usize,
1657 concat!(
1658 "Alignment of ",
1659 stringify!(btrfs_ioctl_dev_replace_args__bindgen_ty_1)
1660 )
1661 );
1662 fn test_field_start() {
1663 assert_eq!(
1664 unsafe {
1665 let uninit =
1666 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_args__bindgen_ty_1>::uninit();
1667 let ptr = uninit.as_ptr();
1668 ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize
1669 },
1670 0usize,
1671 concat!(
1672 "Offset of field: ",
1673 stringify!(btrfs_ioctl_dev_replace_args__bindgen_ty_1),
1674 "::",
1675 stringify!(start)
1676 )
1677 );
1678 }
1679 test_field_start();
1680 fn test_field_status() {
1681 assert_eq!(
1682 unsafe {
1683 let uninit =
1684 ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_args__bindgen_ty_1>::uninit();
1685 let ptr = uninit.as_ptr();
1686 ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize
1687 },
1688 0usize,
1689 concat!(
1690 "Offset of field: ",
1691 stringify!(btrfs_ioctl_dev_replace_args__bindgen_ty_1),
1692 "::",
1693 stringify!(status)
1694 )
1695 );
1696 }
1697 test_field_status();
1698}
1699#[test]
1700fn bindgen_test_layout_btrfs_ioctl_dev_replace_args() {
1701 assert_eq!(
1702 ::std::mem::size_of::<btrfs_ioctl_dev_replace_args>(),
1703 2600usize,
1704 concat!("Size of: ", stringify!(btrfs_ioctl_dev_replace_args))
1705 );
1706 assert_eq!(
1707 ::std::mem::align_of::<btrfs_ioctl_dev_replace_args>(),
1708 8usize,
1709 concat!("Alignment of ", stringify!(btrfs_ioctl_dev_replace_args))
1710 );
1711 fn test_field_cmd() {
1712 assert_eq!(
1713 unsafe {
1714 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_args>::uninit();
1715 let ptr = uninit.as_ptr();
1716 ::std::ptr::addr_of!((*ptr).cmd) as usize - ptr as usize
1717 },
1718 0usize,
1719 concat!(
1720 "Offset of field: ",
1721 stringify!(btrfs_ioctl_dev_replace_args),
1722 "::",
1723 stringify!(cmd)
1724 )
1725 );
1726 }
1727 test_field_cmd();
1728 fn test_field_result() {
1729 assert_eq!(
1730 unsafe {
1731 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_args>::uninit();
1732 let ptr = uninit.as_ptr();
1733 ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize
1734 },
1735 8usize,
1736 concat!(
1737 "Offset of field: ",
1738 stringify!(btrfs_ioctl_dev_replace_args),
1739 "::",
1740 stringify!(result)
1741 )
1742 );
1743 }
1744 test_field_result();
1745 fn test_field_spare() {
1746 assert_eq!(
1747 unsafe {
1748 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_replace_args>::uninit();
1749 let ptr = uninit.as_ptr();
1750 ::std::ptr::addr_of!((*ptr).spare) as usize - ptr as usize
1751 },
1752 2088usize,
1753 concat!(
1754 "Offset of field: ",
1755 stringify!(btrfs_ioctl_dev_replace_args),
1756 "::",
1757 stringify!(spare)
1758 )
1759 );
1760 }
1761 test_field_spare();
1762}
1763#[repr(C)]
1764#[derive(Debug, Copy, Clone)]
1765pub struct btrfs_ioctl_dev_info_args {
1766 pub devid: __u64,
1767 pub uuid: [__u8; 16usize],
1768 pub bytes_used: __u64,
1769 pub total_bytes: __u64,
1770 pub unused: [__u64; 379usize],
1771 pub path: [__u8; 1024usize],
1772}
1773#[test]
1774fn bindgen_test_layout_btrfs_ioctl_dev_info_args() {
1775 assert_eq!(
1776 ::std::mem::size_of::<btrfs_ioctl_dev_info_args>(),
1777 4096usize,
1778 concat!("Size of: ", stringify!(btrfs_ioctl_dev_info_args))
1779 );
1780 assert_eq!(
1781 ::std::mem::align_of::<btrfs_ioctl_dev_info_args>(),
1782 8usize,
1783 concat!("Alignment of ", stringify!(btrfs_ioctl_dev_info_args))
1784 );
1785 fn test_field_devid() {
1786 assert_eq!(
1787 unsafe {
1788 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_info_args>::uninit();
1789 let ptr = uninit.as_ptr();
1790 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
1791 },
1792 0usize,
1793 concat!(
1794 "Offset of field: ",
1795 stringify!(btrfs_ioctl_dev_info_args),
1796 "::",
1797 stringify!(devid)
1798 )
1799 );
1800 }
1801 test_field_devid();
1802 fn test_field_uuid() {
1803 assert_eq!(
1804 unsafe {
1805 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_info_args>::uninit();
1806 let ptr = uninit.as_ptr();
1807 ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize
1808 },
1809 8usize,
1810 concat!(
1811 "Offset of field: ",
1812 stringify!(btrfs_ioctl_dev_info_args),
1813 "::",
1814 stringify!(uuid)
1815 )
1816 );
1817 }
1818 test_field_uuid();
1819 fn test_field_bytes_used() {
1820 assert_eq!(
1821 unsafe {
1822 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_info_args>::uninit();
1823 let ptr = uninit.as_ptr();
1824 ::std::ptr::addr_of!((*ptr).bytes_used) as usize - ptr as usize
1825 },
1826 24usize,
1827 concat!(
1828 "Offset of field: ",
1829 stringify!(btrfs_ioctl_dev_info_args),
1830 "::",
1831 stringify!(bytes_used)
1832 )
1833 );
1834 }
1835 test_field_bytes_used();
1836 fn test_field_total_bytes() {
1837 assert_eq!(
1838 unsafe {
1839 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_info_args>::uninit();
1840 let ptr = uninit.as_ptr();
1841 ::std::ptr::addr_of!((*ptr).total_bytes) as usize - ptr as usize
1842 },
1843 32usize,
1844 concat!(
1845 "Offset of field: ",
1846 stringify!(btrfs_ioctl_dev_info_args),
1847 "::",
1848 stringify!(total_bytes)
1849 )
1850 );
1851 }
1852 test_field_total_bytes();
1853 fn test_field_unused() {
1854 assert_eq!(
1855 unsafe {
1856 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_info_args>::uninit();
1857 let ptr = uninit.as_ptr();
1858 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
1859 },
1860 40usize,
1861 concat!(
1862 "Offset of field: ",
1863 stringify!(btrfs_ioctl_dev_info_args),
1864 "::",
1865 stringify!(unused)
1866 )
1867 );
1868 }
1869 test_field_unused();
1870 fn test_field_path() {
1871 assert_eq!(
1872 unsafe {
1873 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_dev_info_args>::uninit();
1874 let ptr = uninit.as_ptr();
1875 ::std::ptr::addr_of!((*ptr).path) as usize - ptr as usize
1876 },
1877 3072usize,
1878 concat!(
1879 "Offset of field: ",
1880 stringify!(btrfs_ioctl_dev_info_args),
1881 "::",
1882 stringify!(path)
1883 )
1884 );
1885 }
1886 test_field_path();
1887}
1888#[repr(C)]
1889#[derive(Debug, Copy, Clone)]
1890pub struct btrfs_ioctl_fs_info_args {
1891 pub max_id: __u64,
1892 pub num_devices: __u64,
1893 pub fsid: [__u8; 16usize],
1894 pub nodesize: __u32,
1895 pub sectorsize: __u32,
1896 pub clone_alignment: __u32,
1897 pub reserved32: __u32,
1898 pub reserved: [__u64; 122usize],
1899}
1900#[test]
1901fn bindgen_test_layout_btrfs_ioctl_fs_info_args() {
1902 assert_eq!(
1903 ::std::mem::size_of::<btrfs_ioctl_fs_info_args>(),
1904 1024usize,
1905 concat!("Size of: ", stringify!(btrfs_ioctl_fs_info_args))
1906 );
1907 assert_eq!(
1908 ::std::mem::align_of::<btrfs_ioctl_fs_info_args>(),
1909 8usize,
1910 concat!("Alignment of ", stringify!(btrfs_ioctl_fs_info_args))
1911 );
1912 fn test_field_max_id() {
1913 assert_eq!(
1914 unsafe {
1915 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
1916 let ptr = uninit.as_ptr();
1917 ::std::ptr::addr_of!((*ptr).max_id) as usize - ptr as usize
1918 },
1919 0usize,
1920 concat!(
1921 "Offset of field: ",
1922 stringify!(btrfs_ioctl_fs_info_args),
1923 "::",
1924 stringify!(max_id)
1925 )
1926 );
1927 }
1928 test_field_max_id();
1929 fn test_field_num_devices() {
1930 assert_eq!(
1931 unsafe {
1932 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
1933 let ptr = uninit.as_ptr();
1934 ::std::ptr::addr_of!((*ptr).num_devices) as usize - ptr as usize
1935 },
1936 8usize,
1937 concat!(
1938 "Offset of field: ",
1939 stringify!(btrfs_ioctl_fs_info_args),
1940 "::",
1941 stringify!(num_devices)
1942 )
1943 );
1944 }
1945 test_field_num_devices();
1946 fn test_field_fsid() {
1947 assert_eq!(
1948 unsafe {
1949 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
1950 let ptr = uninit.as_ptr();
1951 ::std::ptr::addr_of!((*ptr).fsid) as usize - ptr as usize
1952 },
1953 16usize,
1954 concat!(
1955 "Offset of field: ",
1956 stringify!(btrfs_ioctl_fs_info_args),
1957 "::",
1958 stringify!(fsid)
1959 )
1960 );
1961 }
1962 test_field_fsid();
1963 fn test_field_nodesize() {
1964 assert_eq!(
1965 unsafe {
1966 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
1967 let ptr = uninit.as_ptr();
1968 ::std::ptr::addr_of!((*ptr).nodesize) as usize - ptr as usize
1969 },
1970 32usize,
1971 concat!(
1972 "Offset of field: ",
1973 stringify!(btrfs_ioctl_fs_info_args),
1974 "::",
1975 stringify!(nodesize)
1976 )
1977 );
1978 }
1979 test_field_nodesize();
1980 fn test_field_sectorsize() {
1981 assert_eq!(
1982 unsafe {
1983 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
1984 let ptr = uninit.as_ptr();
1985 ::std::ptr::addr_of!((*ptr).sectorsize) as usize - ptr as usize
1986 },
1987 36usize,
1988 concat!(
1989 "Offset of field: ",
1990 stringify!(btrfs_ioctl_fs_info_args),
1991 "::",
1992 stringify!(sectorsize)
1993 )
1994 );
1995 }
1996 test_field_sectorsize();
1997 fn test_field_clone_alignment() {
1998 assert_eq!(
1999 unsafe {
2000 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
2001 let ptr = uninit.as_ptr();
2002 ::std::ptr::addr_of!((*ptr).clone_alignment) as usize - ptr as usize
2003 },
2004 40usize,
2005 concat!(
2006 "Offset of field: ",
2007 stringify!(btrfs_ioctl_fs_info_args),
2008 "::",
2009 stringify!(clone_alignment)
2010 )
2011 );
2012 }
2013 test_field_clone_alignment();
2014 fn test_field_reserved32() {
2015 assert_eq!(
2016 unsafe {
2017 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
2018 let ptr = uninit.as_ptr();
2019 ::std::ptr::addr_of!((*ptr).reserved32) as usize - ptr as usize
2020 },
2021 44usize,
2022 concat!(
2023 "Offset of field: ",
2024 stringify!(btrfs_ioctl_fs_info_args),
2025 "::",
2026 stringify!(reserved32)
2027 )
2028 );
2029 }
2030 test_field_reserved32();
2031 fn test_field_reserved() {
2032 assert_eq!(
2033 unsafe {
2034 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_fs_info_args>::uninit();
2035 let ptr = uninit.as_ptr();
2036 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
2037 },
2038 48usize,
2039 concat!(
2040 "Offset of field: ",
2041 stringify!(btrfs_ioctl_fs_info_args),
2042 "::",
2043 stringify!(reserved)
2044 )
2045 );
2046 }
2047 test_field_reserved();
2048}
2049#[repr(C)]
2050#[derive(Debug, Copy, Clone)]
2051pub struct btrfs_ioctl_feature_flags {
2052 pub compat_flags: __u64,
2053 pub compat_ro_flags: __u64,
2054 pub incompat_flags: __u64,
2055}
2056#[test]
2057fn bindgen_test_layout_btrfs_ioctl_feature_flags() {
2058 assert_eq!(
2059 ::std::mem::size_of::<btrfs_ioctl_feature_flags>(),
2060 24usize,
2061 concat!("Size of: ", stringify!(btrfs_ioctl_feature_flags))
2062 );
2063 assert_eq!(
2064 ::std::mem::align_of::<btrfs_ioctl_feature_flags>(),
2065 8usize,
2066 concat!("Alignment of ", stringify!(btrfs_ioctl_feature_flags))
2067 );
2068 fn test_field_compat_flags() {
2069 assert_eq!(
2070 unsafe {
2071 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_feature_flags>::uninit();
2072 let ptr = uninit.as_ptr();
2073 ::std::ptr::addr_of!((*ptr).compat_flags) as usize - ptr as usize
2074 },
2075 0usize,
2076 concat!(
2077 "Offset of field: ",
2078 stringify!(btrfs_ioctl_feature_flags),
2079 "::",
2080 stringify!(compat_flags)
2081 )
2082 );
2083 }
2084 test_field_compat_flags();
2085 fn test_field_compat_ro_flags() {
2086 assert_eq!(
2087 unsafe {
2088 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_feature_flags>::uninit();
2089 let ptr = uninit.as_ptr();
2090 ::std::ptr::addr_of!((*ptr).compat_ro_flags) as usize - ptr as usize
2091 },
2092 8usize,
2093 concat!(
2094 "Offset of field: ",
2095 stringify!(btrfs_ioctl_feature_flags),
2096 "::",
2097 stringify!(compat_ro_flags)
2098 )
2099 );
2100 }
2101 test_field_compat_ro_flags();
2102 fn test_field_incompat_flags() {
2103 assert_eq!(
2104 unsafe {
2105 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_feature_flags>::uninit();
2106 let ptr = uninit.as_ptr();
2107 ::std::ptr::addr_of!((*ptr).incompat_flags) as usize - ptr as usize
2108 },
2109 16usize,
2110 concat!(
2111 "Offset of field: ",
2112 stringify!(btrfs_ioctl_feature_flags),
2113 "::",
2114 stringify!(incompat_flags)
2115 )
2116 );
2117 }
2118 test_field_incompat_flags();
2119}
2120#[repr(C, packed)]
2121#[derive(Copy, Clone)]
2122pub struct btrfs_balance_args {
2123 pub profiles: __u64,
2124 pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_1,
2125 pub devid: __u64,
2126 pub pstart: __u64,
2127 pub pend: __u64,
2128 pub vstart: __u64,
2129 pub vend: __u64,
2130 pub target: __u64,
2131 pub flags: __u64,
2132 pub __bindgen_anon_2: btrfs_balance_args__bindgen_ty_2,
2133 pub stripes_min: __u32,
2134 pub stripes_max: __u32,
2135 pub unused: [__u64; 6usize],
2136}
2137#[repr(C)]
2138#[derive(Copy, Clone)]
2139pub union btrfs_balance_args__bindgen_ty_1 {
2140 pub usage: __u64,
2141 pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_1__bindgen_ty_1,
2142}
2143#[repr(C)]
2144#[derive(Debug, Copy, Clone)]
2145pub struct btrfs_balance_args__bindgen_ty_1__bindgen_ty_1 {
2146 pub usage_min: __u32,
2147 pub usage_max: __u32,
2148}
2149#[test]
2150fn bindgen_test_layout_btrfs_balance_args__bindgen_ty_1__bindgen_ty_1() {
2151 assert_eq!(
2152 ::std::mem::size_of::<btrfs_balance_args__bindgen_ty_1__bindgen_ty_1>(),
2153 8usize,
2154 concat!(
2155 "Size of: ",
2156 stringify!(btrfs_balance_args__bindgen_ty_1__bindgen_ty_1)
2157 )
2158 );
2159 assert_eq!(
2160 ::std::mem::align_of::<btrfs_balance_args__bindgen_ty_1__bindgen_ty_1>(),
2161 4usize,
2162 concat!(
2163 "Alignment of ",
2164 stringify!(btrfs_balance_args__bindgen_ty_1__bindgen_ty_1)
2165 )
2166 );
2167 fn test_field_usage_min() {
2168 assert_eq!(
2169 unsafe {
2170 let uninit = ::std::mem::MaybeUninit::<
2171 btrfs_balance_args__bindgen_ty_1__bindgen_ty_1,
2172 >::uninit();
2173 let ptr = uninit.as_ptr();
2174 ::std::ptr::addr_of!((*ptr).usage_min) as usize - ptr as usize
2175 },
2176 0usize,
2177 concat!(
2178 "Offset of field: ",
2179 stringify!(btrfs_balance_args__bindgen_ty_1__bindgen_ty_1),
2180 "::",
2181 stringify!(usage_min)
2182 )
2183 );
2184 }
2185 test_field_usage_min();
2186 fn test_field_usage_max() {
2187 assert_eq!(
2188 unsafe {
2189 let uninit = ::std::mem::MaybeUninit::<
2190 btrfs_balance_args__bindgen_ty_1__bindgen_ty_1,
2191 >::uninit();
2192 let ptr = uninit.as_ptr();
2193 ::std::ptr::addr_of!((*ptr).usage_max) as usize - ptr as usize
2194 },
2195 4usize,
2196 concat!(
2197 "Offset of field: ",
2198 stringify!(btrfs_balance_args__bindgen_ty_1__bindgen_ty_1),
2199 "::",
2200 stringify!(usage_max)
2201 )
2202 );
2203 }
2204 test_field_usage_max();
2205}
2206#[test]
2207fn bindgen_test_layout_btrfs_balance_args__bindgen_ty_1() {
2208 assert_eq!(
2209 ::std::mem::size_of::<btrfs_balance_args__bindgen_ty_1>(),
2210 8usize,
2211 concat!("Size of: ", stringify!(btrfs_balance_args__bindgen_ty_1))
2212 );
2213 assert_eq!(
2214 ::std::mem::align_of::<btrfs_balance_args__bindgen_ty_1>(),
2215 8usize,
2216 concat!(
2217 "Alignment of ",
2218 stringify!(btrfs_balance_args__bindgen_ty_1)
2219 )
2220 );
2221 fn test_field_usage() {
2222 assert_eq!(
2223 unsafe {
2224 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args__bindgen_ty_1>::uninit();
2225 let ptr = uninit.as_ptr();
2226 ::std::ptr::addr_of!((*ptr).usage) as usize - ptr as usize
2227 },
2228 0usize,
2229 concat!(
2230 "Offset of field: ",
2231 stringify!(btrfs_balance_args__bindgen_ty_1),
2232 "::",
2233 stringify!(usage)
2234 )
2235 );
2236 }
2237 test_field_usage();
2238}
2239#[repr(C)]
2240#[derive(Copy, Clone)]
2241pub union btrfs_balance_args__bindgen_ty_2 {
2242 pub limit: __u64,
2243 pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_2__bindgen_ty_1,
2244}
2245#[repr(C)]
2246#[derive(Debug, Copy, Clone)]
2247pub struct btrfs_balance_args__bindgen_ty_2__bindgen_ty_1 {
2248 pub limit_min: __u32,
2249 pub limit_max: __u32,
2250}
2251#[test]
2252fn bindgen_test_layout_btrfs_balance_args__bindgen_ty_2__bindgen_ty_1() {
2253 assert_eq!(
2254 ::std::mem::size_of::<btrfs_balance_args__bindgen_ty_2__bindgen_ty_1>(),
2255 8usize,
2256 concat!(
2257 "Size of: ",
2258 stringify!(btrfs_balance_args__bindgen_ty_2__bindgen_ty_1)
2259 )
2260 );
2261 assert_eq!(
2262 ::std::mem::align_of::<btrfs_balance_args__bindgen_ty_2__bindgen_ty_1>(),
2263 4usize,
2264 concat!(
2265 "Alignment of ",
2266 stringify!(btrfs_balance_args__bindgen_ty_2__bindgen_ty_1)
2267 )
2268 );
2269 fn test_field_limit_min() {
2270 assert_eq!(
2271 unsafe {
2272 let uninit = ::std::mem::MaybeUninit::<
2273 btrfs_balance_args__bindgen_ty_2__bindgen_ty_1,
2274 >::uninit();
2275 let ptr = uninit.as_ptr();
2276 ::std::ptr::addr_of!((*ptr).limit_min) as usize - ptr as usize
2277 },
2278 0usize,
2279 concat!(
2280 "Offset of field: ",
2281 stringify!(btrfs_balance_args__bindgen_ty_2__bindgen_ty_1),
2282 "::",
2283 stringify!(limit_min)
2284 )
2285 );
2286 }
2287 test_field_limit_min();
2288 fn test_field_limit_max() {
2289 assert_eq!(
2290 unsafe {
2291 let uninit = ::std::mem::MaybeUninit::<
2292 btrfs_balance_args__bindgen_ty_2__bindgen_ty_1,
2293 >::uninit();
2294 let ptr = uninit.as_ptr();
2295 ::std::ptr::addr_of!((*ptr).limit_max) as usize - ptr as usize
2296 },
2297 4usize,
2298 concat!(
2299 "Offset of field: ",
2300 stringify!(btrfs_balance_args__bindgen_ty_2__bindgen_ty_1),
2301 "::",
2302 stringify!(limit_max)
2303 )
2304 );
2305 }
2306 test_field_limit_max();
2307}
2308#[test]
2309fn bindgen_test_layout_btrfs_balance_args__bindgen_ty_2() {
2310 assert_eq!(
2311 ::std::mem::size_of::<btrfs_balance_args__bindgen_ty_2>(),
2312 8usize,
2313 concat!("Size of: ", stringify!(btrfs_balance_args__bindgen_ty_2))
2314 );
2315 assert_eq!(
2316 ::std::mem::align_of::<btrfs_balance_args__bindgen_ty_2>(),
2317 8usize,
2318 concat!(
2319 "Alignment of ",
2320 stringify!(btrfs_balance_args__bindgen_ty_2)
2321 )
2322 );
2323 fn test_field_limit() {
2324 assert_eq!(
2325 unsafe {
2326 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args__bindgen_ty_2>::uninit();
2327 let ptr = uninit.as_ptr();
2328 ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize
2329 },
2330 0usize,
2331 concat!(
2332 "Offset of field: ",
2333 stringify!(btrfs_balance_args__bindgen_ty_2),
2334 "::",
2335 stringify!(limit)
2336 )
2337 );
2338 }
2339 test_field_limit();
2340}
2341#[test]
2342fn bindgen_test_layout_btrfs_balance_args() {
2343 assert_eq!(
2344 ::std::mem::size_of::<btrfs_balance_args>(),
2345 136usize,
2346 concat!("Size of: ", stringify!(btrfs_balance_args))
2347 );
2348 assert_eq!(
2349 ::std::mem::align_of::<btrfs_balance_args>(),
2350 1usize,
2351 concat!("Alignment of ", stringify!(btrfs_balance_args))
2352 );
2353 fn test_field_profiles() {
2354 assert_eq!(
2355 unsafe {
2356 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2357 let ptr = uninit.as_ptr();
2358 ::std::ptr::addr_of!((*ptr).profiles) as usize - ptr as usize
2359 },
2360 0usize,
2361 concat!(
2362 "Offset of field: ",
2363 stringify!(btrfs_balance_args),
2364 "::",
2365 stringify!(profiles)
2366 )
2367 );
2368 }
2369 test_field_profiles();
2370 fn test_field_devid() {
2371 assert_eq!(
2372 unsafe {
2373 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2374 let ptr = uninit.as_ptr();
2375 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
2376 },
2377 16usize,
2378 concat!(
2379 "Offset of field: ",
2380 stringify!(btrfs_balance_args),
2381 "::",
2382 stringify!(devid)
2383 )
2384 );
2385 }
2386 test_field_devid();
2387 fn test_field_pstart() {
2388 assert_eq!(
2389 unsafe {
2390 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2391 let ptr = uninit.as_ptr();
2392 ::std::ptr::addr_of!((*ptr).pstart) as usize - ptr as usize
2393 },
2394 24usize,
2395 concat!(
2396 "Offset of field: ",
2397 stringify!(btrfs_balance_args),
2398 "::",
2399 stringify!(pstart)
2400 )
2401 );
2402 }
2403 test_field_pstart();
2404 fn test_field_pend() {
2405 assert_eq!(
2406 unsafe {
2407 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2408 let ptr = uninit.as_ptr();
2409 ::std::ptr::addr_of!((*ptr).pend) as usize - ptr as usize
2410 },
2411 32usize,
2412 concat!(
2413 "Offset of field: ",
2414 stringify!(btrfs_balance_args),
2415 "::",
2416 stringify!(pend)
2417 )
2418 );
2419 }
2420 test_field_pend();
2421 fn test_field_vstart() {
2422 assert_eq!(
2423 unsafe {
2424 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2425 let ptr = uninit.as_ptr();
2426 ::std::ptr::addr_of!((*ptr).vstart) as usize - ptr as usize
2427 },
2428 40usize,
2429 concat!(
2430 "Offset of field: ",
2431 stringify!(btrfs_balance_args),
2432 "::",
2433 stringify!(vstart)
2434 )
2435 );
2436 }
2437 test_field_vstart();
2438 fn test_field_vend() {
2439 assert_eq!(
2440 unsafe {
2441 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2442 let ptr = uninit.as_ptr();
2443 ::std::ptr::addr_of!((*ptr).vend) as usize - ptr as usize
2444 },
2445 48usize,
2446 concat!(
2447 "Offset of field: ",
2448 stringify!(btrfs_balance_args),
2449 "::",
2450 stringify!(vend)
2451 )
2452 );
2453 }
2454 test_field_vend();
2455 fn test_field_target() {
2456 assert_eq!(
2457 unsafe {
2458 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2459 let ptr = uninit.as_ptr();
2460 ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize
2461 },
2462 56usize,
2463 concat!(
2464 "Offset of field: ",
2465 stringify!(btrfs_balance_args),
2466 "::",
2467 stringify!(target)
2468 )
2469 );
2470 }
2471 test_field_target();
2472 fn test_field_flags() {
2473 assert_eq!(
2474 unsafe {
2475 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2476 let ptr = uninit.as_ptr();
2477 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
2478 },
2479 64usize,
2480 concat!(
2481 "Offset of field: ",
2482 stringify!(btrfs_balance_args),
2483 "::",
2484 stringify!(flags)
2485 )
2486 );
2487 }
2488 test_field_flags();
2489 fn test_field_stripes_min() {
2490 assert_eq!(
2491 unsafe {
2492 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2493 let ptr = uninit.as_ptr();
2494 ::std::ptr::addr_of!((*ptr).stripes_min) as usize - ptr as usize
2495 },
2496 80usize,
2497 concat!(
2498 "Offset of field: ",
2499 stringify!(btrfs_balance_args),
2500 "::",
2501 stringify!(stripes_min)
2502 )
2503 );
2504 }
2505 test_field_stripes_min();
2506 fn test_field_stripes_max() {
2507 assert_eq!(
2508 unsafe {
2509 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2510 let ptr = uninit.as_ptr();
2511 ::std::ptr::addr_of!((*ptr).stripes_max) as usize - ptr as usize
2512 },
2513 84usize,
2514 concat!(
2515 "Offset of field: ",
2516 stringify!(btrfs_balance_args),
2517 "::",
2518 stringify!(stripes_max)
2519 )
2520 );
2521 }
2522 test_field_stripes_max();
2523 fn test_field_unused() {
2524 assert_eq!(
2525 unsafe {
2526 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_args>::uninit();
2527 let ptr = uninit.as_ptr();
2528 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
2529 },
2530 88usize,
2531 concat!(
2532 "Offset of field: ",
2533 stringify!(btrfs_balance_args),
2534 "::",
2535 stringify!(unused)
2536 )
2537 );
2538 }
2539 test_field_unused();
2540}
2541#[repr(C)]
2542#[derive(Debug, Copy, Clone)]
2543pub struct btrfs_balance_progress {
2544 pub expected: __u64,
2545 pub considered: __u64,
2546 pub completed: __u64,
2547}
2548#[test]
2549fn bindgen_test_layout_btrfs_balance_progress() {
2550 assert_eq!(
2551 ::std::mem::size_of::<btrfs_balance_progress>(),
2552 24usize,
2553 concat!("Size of: ", stringify!(btrfs_balance_progress))
2554 );
2555 assert_eq!(
2556 ::std::mem::align_of::<btrfs_balance_progress>(),
2557 8usize,
2558 concat!("Alignment of ", stringify!(btrfs_balance_progress))
2559 );
2560 fn test_field_expected() {
2561 assert_eq!(
2562 unsafe {
2563 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_progress>::uninit();
2564 let ptr = uninit.as_ptr();
2565 ::std::ptr::addr_of!((*ptr).expected) as usize - ptr as usize
2566 },
2567 0usize,
2568 concat!(
2569 "Offset of field: ",
2570 stringify!(btrfs_balance_progress),
2571 "::",
2572 stringify!(expected)
2573 )
2574 );
2575 }
2576 test_field_expected();
2577 fn test_field_considered() {
2578 assert_eq!(
2579 unsafe {
2580 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_progress>::uninit();
2581 let ptr = uninit.as_ptr();
2582 ::std::ptr::addr_of!((*ptr).considered) as usize - ptr as usize
2583 },
2584 8usize,
2585 concat!(
2586 "Offset of field: ",
2587 stringify!(btrfs_balance_progress),
2588 "::",
2589 stringify!(considered)
2590 )
2591 );
2592 }
2593 test_field_considered();
2594 fn test_field_completed() {
2595 assert_eq!(
2596 unsafe {
2597 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_progress>::uninit();
2598 let ptr = uninit.as_ptr();
2599 ::std::ptr::addr_of!((*ptr).completed) as usize - ptr as usize
2600 },
2601 16usize,
2602 concat!(
2603 "Offset of field: ",
2604 stringify!(btrfs_balance_progress),
2605 "::",
2606 stringify!(completed)
2607 )
2608 );
2609 }
2610 test_field_completed();
2611}
2612#[repr(C)]
2613#[derive(Copy, Clone)]
2614pub struct btrfs_ioctl_balance_args {
2615 pub flags: __u64,
2616 pub state: __u64,
2617 pub data: btrfs_balance_args,
2618 pub meta: btrfs_balance_args,
2619 pub sys: btrfs_balance_args,
2620 pub stat: btrfs_balance_progress,
2621 pub unused: [__u64; 72usize],
2622}
2623#[test]
2624fn bindgen_test_layout_btrfs_ioctl_balance_args() {
2625 assert_eq!(
2626 ::std::mem::size_of::<btrfs_ioctl_balance_args>(),
2627 1024usize,
2628 concat!("Size of: ", stringify!(btrfs_ioctl_balance_args))
2629 );
2630 assert_eq!(
2631 ::std::mem::align_of::<btrfs_ioctl_balance_args>(),
2632 8usize,
2633 concat!("Alignment of ", stringify!(btrfs_ioctl_balance_args))
2634 );
2635 fn test_field_flags() {
2636 assert_eq!(
2637 unsafe {
2638 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2639 let ptr = uninit.as_ptr();
2640 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
2641 },
2642 0usize,
2643 concat!(
2644 "Offset of field: ",
2645 stringify!(btrfs_ioctl_balance_args),
2646 "::",
2647 stringify!(flags)
2648 )
2649 );
2650 }
2651 test_field_flags();
2652 fn test_field_state() {
2653 assert_eq!(
2654 unsafe {
2655 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2656 let ptr = uninit.as_ptr();
2657 ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize
2658 },
2659 8usize,
2660 concat!(
2661 "Offset of field: ",
2662 stringify!(btrfs_ioctl_balance_args),
2663 "::",
2664 stringify!(state)
2665 )
2666 );
2667 }
2668 test_field_state();
2669 fn test_field_data() {
2670 assert_eq!(
2671 unsafe {
2672 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2673 let ptr = uninit.as_ptr();
2674 ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
2675 },
2676 16usize,
2677 concat!(
2678 "Offset of field: ",
2679 stringify!(btrfs_ioctl_balance_args),
2680 "::",
2681 stringify!(data)
2682 )
2683 );
2684 }
2685 test_field_data();
2686 fn test_field_meta() {
2687 assert_eq!(
2688 unsafe {
2689 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2690 let ptr = uninit.as_ptr();
2691 ::std::ptr::addr_of!((*ptr).meta) as usize - ptr as usize
2692 },
2693 152usize,
2694 concat!(
2695 "Offset of field: ",
2696 stringify!(btrfs_ioctl_balance_args),
2697 "::",
2698 stringify!(meta)
2699 )
2700 );
2701 }
2702 test_field_meta();
2703 fn test_field_sys() {
2704 assert_eq!(
2705 unsafe {
2706 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2707 let ptr = uninit.as_ptr();
2708 ::std::ptr::addr_of!((*ptr).sys) as usize - ptr as usize
2709 },
2710 288usize,
2711 concat!(
2712 "Offset of field: ",
2713 stringify!(btrfs_ioctl_balance_args),
2714 "::",
2715 stringify!(sys)
2716 )
2717 );
2718 }
2719 test_field_sys();
2720 fn test_field_stat() {
2721 assert_eq!(
2722 unsafe {
2723 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2724 let ptr = uninit.as_ptr();
2725 ::std::ptr::addr_of!((*ptr).stat) as usize - ptr as usize
2726 },
2727 424usize,
2728 concat!(
2729 "Offset of field: ",
2730 stringify!(btrfs_ioctl_balance_args),
2731 "::",
2732 stringify!(stat)
2733 )
2734 );
2735 }
2736 test_field_stat();
2737 fn test_field_unused() {
2738 assert_eq!(
2739 unsafe {
2740 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_balance_args>::uninit();
2741 let ptr = uninit.as_ptr();
2742 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
2743 },
2744 448usize,
2745 concat!(
2746 "Offset of field: ",
2747 stringify!(btrfs_ioctl_balance_args),
2748 "::",
2749 stringify!(unused)
2750 )
2751 );
2752 }
2753 test_field_unused();
2754}
2755#[repr(C)]
2756#[derive(Debug, Copy, Clone)]
2757pub struct btrfs_ioctl_ino_lookup_args {
2758 pub treeid: __u64,
2759 pub objectid: __u64,
2760 pub name: [::std::os::raw::c_char; 4080usize],
2761}
2762#[test]
2763fn bindgen_test_layout_btrfs_ioctl_ino_lookup_args() {
2764 assert_eq!(
2765 ::std::mem::size_of::<btrfs_ioctl_ino_lookup_args>(),
2766 4096usize,
2767 concat!("Size of: ", stringify!(btrfs_ioctl_ino_lookup_args))
2768 );
2769 assert_eq!(
2770 ::std::mem::align_of::<btrfs_ioctl_ino_lookup_args>(),
2771 8usize,
2772 concat!("Alignment of ", stringify!(btrfs_ioctl_ino_lookup_args))
2773 );
2774 fn test_field_treeid() {
2775 assert_eq!(
2776 unsafe {
2777 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_lookup_args>::uninit();
2778 let ptr = uninit.as_ptr();
2779 ::std::ptr::addr_of!((*ptr).treeid) as usize - ptr as usize
2780 },
2781 0usize,
2782 concat!(
2783 "Offset of field: ",
2784 stringify!(btrfs_ioctl_ino_lookup_args),
2785 "::",
2786 stringify!(treeid)
2787 )
2788 );
2789 }
2790 test_field_treeid();
2791 fn test_field_objectid() {
2792 assert_eq!(
2793 unsafe {
2794 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_lookup_args>::uninit();
2795 let ptr = uninit.as_ptr();
2796 ::std::ptr::addr_of!((*ptr).objectid) as usize - ptr as usize
2797 },
2798 8usize,
2799 concat!(
2800 "Offset of field: ",
2801 stringify!(btrfs_ioctl_ino_lookup_args),
2802 "::",
2803 stringify!(objectid)
2804 )
2805 );
2806 }
2807 test_field_objectid();
2808 fn test_field_name() {
2809 assert_eq!(
2810 unsafe {
2811 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_lookup_args>::uninit();
2812 let ptr = uninit.as_ptr();
2813 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
2814 },
2815 16usize,
2816 concat!(
2817 "Offset of field: ",
2818 stringify!(btrfs_ioctl_ino_lookup_args),
2819 "::",
2820 stringify!(name)
2821 )
2822 );
2823 }
2824 test_field_name();
2825}
2826#[repr(C)]
2827#[derive(Debug, Copy, Clone)]
2828pub struct btrfs_ioctl_search_key {
2829 pub tree_id: __u64,
2830 pub min_objectid: __u64,
2831 pub max_objectid: __u64,
2832 pub min_offset: __u64,
2833 pub max_offset: __u64,
2834 pub min_transid: __u64,
2835 pub max_transid: __u64,
2836 pub min_type: __u32,
2837 pub max_type: __u32,
2838 pub nr_items: __u32,
2839 pub unused: __u32,
2840 pub unused1: __u64,
2841 pub unused2: __u64,
2842 pub unused3: __u64,
2843 pub unused4: __u64,
2844}
2845#[test]
2846fn bindgen_test_layout_btrfs_ioctl_search_key() {
2847 assert_eq!(
2848 ::std::mem::size_of::<btrfs_ioctl_search_key>(),
2849 104usize,
2850 concat!("Size of: ", stringify!(btrfs_ioctl_search_key))
2851 );
2852 assert_eq!(
2853 ::std::mem::align_of::<btrfs_ioctl_search_key>(),
2854 8usize,
2855 concat!("Alignment of ", stringify!(btrfs_ioctl_search_key))
2856 );
2857 fn test_field_tree_id() {
2858 assert_eq!(
2859 unsafe {
2860 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2861 let ptr = uninit.as_ptr();
2862 ::std::ptr::addr_of!((*ptr).tree_id) as usize - ptr as usize
2863 },
2864 0usize,
2865 concat!(
2866 "Offset of field: ",
2867 stringify!(btrfs_ioctl_search_key),
2868 "::",
2869 stringify!(tree_id)
2870 )
2871 );
2872 }
2873 test_field_tree_id();
2874 fn test_field_min_objectid() {
2875 assert_eq!(
2876 unsafe {
2877 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2878 let ptr = uninit.as_ptr();
2879 ::std::ptr::addr_of!((*ptr).min_objectid) as usize - ptr as usize
2880 },
2881 8usize,
2882 concat!(
2883 "Offset of field: ",
2884 stringify!(btrfs_ioctl_search_key),
2885 "::",
2886 stringify!(min_objectid)
2887 )
2888 );
2889 }
2890 test_field_min_objectid();
2891 fn test_field_max_objectid() {
2892 assert_eq!(
2893 unsafe {
2894 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2895 let ptr = uninit.as_ptr();
2896 ::std::ptr::addr_of!((*ptr).max_objectid) as usize - ptr as usize
2897 },
2898 16usize,
2899 concat!(
2900 "Offset of field: ",
2901 stringify!(btrfs_ioctl_search_key),
2902 "::",
2903 stringify!(max_objectid)
2904 )
2905 );
2906 }
2907 test_field_max_objectid();
2908 fn test_field_min_offset() {
2909 assert_eq!(
2910 unsafe {
2911 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2912 let ptr = uninit.as_ptr();
2913 ::std::ptr::addr_of!((*ptr).min_offset) as usize - ptr as usize
2914 },
2915 24usize,
2916 concat!(
2917 "Offset of field: ",
2918 stringify!(btrfs_ioctl_search_key),
2919 "::",
2920 stringify!(min_offset)
2921 )
2922 );
2923 }
2924 test_field_min_offset();
2925 fn test_field_max_offset() {
2926 assert_eq!(
2927 unsafe {
2928 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2929 let ptr = uninit.as_ptr();
2930 ::std::ptr::addr_of!((*ptr).max_offset) as usize - ptr as usize
2931 },
2932 32usize,
2933 concat!(
2934 "Offset of field: ",
2935 stringify!(btrfs_ioctl_search_key),
2936 "::",
2937 stringify!(max_offset)
2938 )
2939 );
2940 }
2941 test_field_max_offset();
2942 fn test_field_min_transid() {
2943 assert_eq!(
2944 unsafe {
2945 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2946 let ptr = uninit.as_ptr();
2947 ::std::ptr::addr_of!((*ptr).min_transid) as usize - ptr as usize
2948 },
2949 40usize,
2950 concat!(
2951 "Offset of field: ",
2952 stringify!(btrfs_ioctl_search_key),
2953 "::",
2954 stringify!(min_transid)
2955 )
2956 );
2957 }
2958 test_field_min_transid();
2959 fn test_field_max_transid() {
2960 assert_eq!(
2961 unsafe {
2962 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2963 let ptr = uninit.as_ptr();
2964 ::std::ptr::addr_of!((*ptr).max_transid) as usize - ptr as usize
2965 },
2966 48usize,
2967 concat!(
2968 "Offset of field: ",
2969 stringify!(btrfs_ioctl_search_key),
2970 "::",
2971 stringify!(max_transid)
2972 )
2973 );
2974 }
2975 test_field_max_transid();
2976 fn test_field_min_type() {
2977 assert_eq!(
2978 unsafe {
2979 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2980 let ptr = uninit.as_ptr();
2981 ::std::ptr::addr_of!((*ptr).min_type) as usize - ptr as usize
2982 },
2983 56usize,
2984 concat!(
2985 "Offset of field: ",
2986 stringify!(btrfs_ioctl_search_key),
2987 "::",
2988 stringify!(min_type)
2989 )
2990 );
2991 }
2992 test_field_min_type();
2993 fn test_field_max_type() {
2994 assert_eq!(
2995 unsafe {
2996 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
2997 let ptr = uninit.as_ptr();
2998 ::std::ptr::addr_of!((*ptr).max_type) as usize - ptr as usize
2999 },
3000 60usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(btrfs_ioctl_search_key),
3004 "::",
3005 stringify!(max_type)
3006 )
3007 );
3008 }
3009 test_field_max_type();
3010 fn test_field_nr_items() {
3011 assert_eq!(
3012 unsafe {
3013 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
3014 let ptr = uninit.as_ptr();
3015 ::std::ptr::addr_of!((*ptr).nr_items) as usize - ptr as usize
3016 },
3017 64usize,
3018 concat!(
3019 "Offset of field: ",
3020 stringify!(btrfs_ioctl_search_key),
3021 "::",
3022 stringify!(nr_items)
3023 )
3024 );
3025 }
3026 test_field_nr_items();
3027 fn test_field_unused() {
3028 assert_eq!(
3029 unsafe {
3030 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
3031 let ptr = uninit.as_ptr();
3032 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
3033 },
3034 68usize,
3035 concat!(
3036 "Offset of field: ",
3037 stringify!(btrfs_ioctl_search_key),
3038 "::",
3039 stringify!(unused)
3040 )
3041 );
3042 }
3043 test_field_unused();
3044 fn test_field_unused1() {
3045 assert_eq!(
3046 unsafe {
3047 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
3048 let ptr = uninit.as_ptr();
3049 ::std::ptr::addr_of!((*ptr).unused1) as usize - ptr as usize
3050 },
3051 72usize,
3052 concat!(
3053 "Offset of field: ",
3054 stringify!(btrfs_ioctl_search_key),
3055 "::",
3056 stringify!(unused1)
3057 )
3058 );
3059 }
3060 test_field_unused1();
3061 fn test_field_unused2() {
3062 assert_eq!(
3063 unsafe {
3064 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
3065 let ptr = uninit.as_ptr();
3066 ::std::ptr::addr_of!((*ptr).unused2) as usize - ptr as usize
3067 },
3068 80usize,
3069 concat!(
3070 "Offset of field: ",
3071 stringify!(btrfs_ioctl_search_key),
3072 "::",
3073 stringify!(unused2)
3074 )
3075 );
3076 }
3077 test_field_unused2();
3078 fn test_field_unused3() {
3079 assert_eq!(
3080 unsafe {
3081 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
3082 let ptr = uninit.as_ptr();
3083 ::std::ptr::addr_of!((*ptr).unused3) as usize - ptr as usize
3084 },
3085 88usize,
3086 concat!(
3087 "Offset of field: ",
3088 stringify!(btrfs_ioctl_search_key),
3089 "::",
3090 stringify!(unused3)
3091 )
3092 );
3093 }
3094 test_field_unused3();
3095 fn test_field_unused4() {
3096 assert_eq!(
3097 unsafe {
3098 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_key>::uninit();
3099 let ptr = uninit.as_ptr();
3100 ::std::ptr::addr_of!((*ptr).unused4) as usize - ptr as usize
3101 },
3102 96usize,
3103 concat!(
3104 "Offset of field: ",
3105 stringify!(btrfs_ioctl_search_key),
3106 "::",
3107 stringify!(unused4)
3108 )
3109 );
3110 }
3111 test_field_unused4();
3112}
3113#[repr(C)]
3114#[derive(Debug, Copy, Clone)]
3115pub struct btrfs_ioctl_search_header {
3116 pub transid: __u64,
3117 pub objectid: __u64,
3118 pub offset: __u64,
3119 pub type_: __u32,
3120 pub len: __u32,
3121}
3122#[test]
3123fn bindgen_test_layout_btrfs_ioctl_search_header() {
3124 assert_eq!(
3125 ::std::mem::size_of::<btrfs_ioctl_search_header>(),
3126 32usize,
3127 concat!("Size of: ", stringify!(btrfs_ioctl_search_header))
3128 );
3129 assert_eq!(
3130 ::std::mem::align_of::<btrfs_ioctl_search_header>(),
3131 8usize,
3132 concat!("Alignment of ", stringify!(btrfs_ioctl_search_header))
3133 );
3134 fn test_field_transid() {
3135 assert_eq!(
3136 unsafe {
3137 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_header>::uninit();
3138 let ptr = uninit.as_ptr();
3139 ::std::ptr::addr_of!((*ptr).transid) as usize - ptr as usize
3140 },
3141 0usize,
3142 concat!(
3143 "Offset of field: ",
3144 stringify!(btrfs_ioctl_search_header),
3145 "::",
3146 stringify!(transid)
3147 )
3148 );
3149 }
3150 test_field_transid();
3151 fn test_field_objectid() {
3152 assert_eq!(
3153 unsafe {
3154 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_header>::uninit();
3155 let ptr = uninit.as_ptr();
3156 ::std::ptr::addr_of!((*ptr).objectid) as usize - ptr as usize
3157 },
3158 8usize,
3159 concat!(
3160 "Offset of field: ",
3161 stringify!(btrfs_ioctl_search_header),
3162 "::",
3163 stringify!(objectid)
3164 )
3165 );
3166 }
3167 test_field_objectid();
3168 fn test_field_offset() {
3169 assert_eq!(
3170 unsafe {
3171 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_header>::uninit();
3172 let ptr = uninit.as_ptr();
3173 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
3174 },
3175 16usize,
3176 concat!(
3177 "Offset of field: ",
3178 stringify!(btrfs_ioctl_search_header),
3179 "::",
3180 stringify!(offset)
3181 )
3182 );
3183 }
3184 test_field_offset();
3185 fn test_field_type() {
3186 assert_eq!(
3187 unsafe {
3188 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_header>::uninit();
3189 let ptr = uninit.as_ptr();
3190 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
3191 },
3192 24usize,
3193 concat!(
3194 "Offset of field: ",
3195 stringify!(btrfs_ioctl_search_header),
3196 "::",
3197 stringify!(type_)
3198 )
3199 );
3200 }
3201 test_field_type();
3202 fn test_field_len() {
3203 assert_eq!(
3204 unsafe {
3205 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_header>::uninit();
3206 let ptr = uninit.as_ptr();
3207 ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize
3208 },
3209 28usize,
3210 concat!(
3211 "Offset of field: ",
3212 stringify!(btrfs_ioctl_search_header),
3213 "::",
3214 stringify!(len)
3215 )
3216 );
3217 }
3218 test_field_len();
3219}
3220#[repr(C)]
3221#[derive(Debug, Copy, Clone)]
3222pub struct btrfs_ioctl_search_args {
3223 pub key: btrfs_ioctl_search_key,
3224 pub buf: [::std::os::raw::c_char; 3992usize],
3225}
3226#[test]
3227fn bindgen_test_layout_btrfs_ioctl_search_args() {
3228 assert_eq!(
3229 ::std::mem::size_of::<btrfs_ioctl_search_args>(),
3230 4096usize,
3231 concat!("Size of: ", stringify!(btrfs_ioctl_search_args))
3232 );
3233 assert_eq!(
3234 ::std::mem::align_of::<btrfs_ioctl_search_args>(),
3235 8usize,
3236 concat!("Alignment of ", stringify!(btrfs_ioctl_search_args))
3237 );
3238 fn test_field_key() {
3239 assert_eq!(
3240 unsafe {
3241 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_args>::uninit();
3242 let ptr = uninit.as_ptr();
3243 ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize
3244 },
3245 0usize,
3246 concat!(
3247 "Offset of field: ",
3248 stringify!(btrfs_ioctl_search_args),
3249 "::",
3250 stringify!(key)
3251 )
3252 );
3253 }
3254 test_field_key();
3255 fn test_field_buf() {
3256 assert_eq!(
3257 unsafe {
3258 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_args>::uninit();
3259 let ptr = uninit.as_ptr();
3260 ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize
3261 },
3262 104usize,
3263 concat!(
3264 "Offset of field: ",
3265 stringify!(btrfs_ioctl_search_args),
3266 "::",
3267 stringify!(buf)
3268 )
3269 );
3270 }
3271 test_field_buf();
3272}
3273#[repr(C)]
3274#[derive(Debug)]
3275pub struct btrfs_ioctl_search_args_v2 {
3276 pub key: btrfs_ioctl_search_key,
3277 pub buf_size: __u64,
3278 pub buf: __IncompleteArrayField<__u64>,
3279}
3280#[test]
3281fn bindgen_test_layout_btrfs_ioctl_search_args_v2() {
3282 assert_eq!(
3283 ::std::mem::size_of::<btrfs_ioctl_search_args_v2>(),
3284 112usize,
3285 concat!("Size of: ", stringify!(btrfs_ioctl_search_args_v2))
3286 );
3287 assert_eq!(
3288 ::std::mem::align_of::<btrfs_ioctl_search_args_v2>(),
3289 8usize,
3290 concat!("Alignment of ", stringify!(btrfs_ioctl_search_args_v2))
3291 );
3292 fn test_field_key() {
3293 assert_eq!(
3294 unsafe {
3295 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_args_v2>::uninit();
3296 let ptr = uninit.as_ptr();
3297 ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize
3298 },
3299 0usize,
3300 concat!(
3301 "Offset of field: ",
3302 stringify!(btrfs_ioctl_search_args_v2),
3303 "::",
3304 stringify!(key)
3305 )
3306 );
3307 }
3308 test_field_key();
3309 fn test_field_buf_size() {
3310 assert_eq!(
3311 unsafe {
3312 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_args_v2>::uninit();
3313 let ptr = uninit.as_ptr();
3314 ::std::ptr::addr_of!((*ptr).buf_size) as usize - ptr as usize
3315 },
3316 104usize,
3317 concat!(
3318 "Offset of field: ",
3319 stringify!(btrfs_ioctl_search_args_v2),
3320 "::",
3321 stringify!(buf_size)
3322 )
3323 );
3324 }
3325 test_field_buf_size();
3326 fn test_field_buf() {
3327 assert_eq!(
3328 unsafe {
3329 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_search_args_v2>::uninit();
3330 let ptr = uninit.as_ptr();
3331 ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize
3332 },
3333 112usize,
3334 concat!(
3335 "Offset of field: ",
3336 stringify!(btrfs_ioctl_search_args_v2),
3337 "::",
3338 stringify!(buf)
3339 )
3340 );
3341 }
3342 test_field_buf();
3343}
3344#[repr(C)]
3345#[derive(Debug, Copy, Clone)]
3346pub struct btrfs_ioctl_clone_range_args {
3347 pub src_fd: __s64,
3348 pub src_offset: __u64,
3349 pub src_length: __u64,
3350 pub dest_offset: __u64,
3351}
3352#[test]
3353fn bindgen_test_layout_btrfs_ioctl_clone_range_args() {
3354 assert_eq!(
3355 ::std::mem::size_of::<btrfs_ioctl_clone_range_args>(),
3356 32usize,
3357 concat!("Size of: ", stringify!(btrfs_ioctl_clone_range_args))
3358 );
3359 assert_eq!(
3360 ::std::mem::align_of::<btrfs_ioctl_clone_range_args>(),
3361 8usize,
3362 concat!("Alignment of ", stringify!(btrfs_ioctl_clone_range_args))
3363 );
3364 fn test_field_src_fd() {
3365 assert_eq!(
3366 unsafe {
3367 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_clone_range_args>::uninit();
3368 let ptr = uninit.as_ptr();
3369 ::std::ptr::addr_of!((*ptr).src_fd) as usize - ptr as usize
3370 },
3371 0usize,
3372 concat!(
3373 "Offset of field: ",
3374 stringify!(btrfs_ioctl_clone_range_args),
3375 "::",
3376 stringify!(src_fd)
3377 )
3378 );
3379 }
3380 test_field_src_fd();
3381 fn test_field_src_offset() {
3382 assert_eq!(
3383 unsafe {
3384 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_clone_range_args>::uninit();
3385 let ptr = uninit.as_ptr();
3386 ::std::ptr::addr_of!((*ptr).src_offset) as usize - ptr as usize
3387 },
3388 8usize,
3389 concat!(
3390 "Offset of field: ",
3391 stringify!(btrfs_ioctl_clone_range_args),
3392 "::",
3393 stringify!(src_offset)
3394 )
3395 );
3396 }
3397 test_field_src_offset();
3398 fn test_field_src_length() {
3399 assert_eq!(
3400 unsafe {
3401 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_clone_range_args>::uninit();
3402 let ptr = uninit.as_ptr();
3403 ::std::ptr::addr_of!((*ptr).src_length) as usize - ptr as usize
3404 },
3405 16usize,
3406 concat!(
3407 "Offset of field: ",
3408 stringify!(btrfs_ioctl_clone_range_args),
3409 "::",
3410 stringify!(src_length)
3411 )
3412 );
3413 }
3414 test_field_src_length();
3415 fn test_field_dest_offset() {
3416 assert_eq!(
3417 unsafe {
3418 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_clone_range_args>::uninit();
3419 let ptr = uninit.as_ptr();
3420 ::std::ptr::addr_of!((*ptr).dest_offset) as usize - ptr as usize
3421 },
3422 24usize,
3423 concat!(
3424 "Offset of field: ",
3425 stringify!(btrfs_ioctl_clone_range_args),
3426 "::",
3427 stringify!(dest_offset)
3428 )
3429 );
3430 }
3431 test_field_dest_offset();
3432}
3433#[repr(C)]
3434#[derive(Debug, Copy, Clone)]
3435pub struct btrfs_ioctl_defrag_range_args {
3436 pub start: __u64,
3437 pub len: __u64,
3438 pub flags: __u64,
3439 pub extent_thresh: __u32,
3440 pub compress_type: __u32,
3441 pub unused: [__u32; 4usize],
3442}
3443#[test]
3444fn bindgen_test_layout_btrfs_ioctl_defrag_range_args() {
3445 assert_eq!(
3446 ::std::mem::size_of::<btrfs_ioctl_defrag_range_args>(),
3447 48usize,
3448 concat!("Size of: ", stringify!(btrfs_ioctl_defrag_range_args))
3449 );
3450 assert_eq!(
3451 ::std::mem::align_of::<btrfs_ioctl_defrag_range_args>(),
3452 8usize,
3453 concat!("Alignment of ", stringify!(btrfs_ioctl_defrag_range_args))
3454 );
3455 fn test_field_start() {
3456 assert_eq!(
3457 unsafe {
3458 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_defrag_range_args>::uninit();
3459 let ptr = uninit.as_ptr();
3460 ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize
3461 },
3462 0usize,
3463 concat!(
3464 "Offset of field: ",
3465 stringify!(btrfs_ioctl_defrag_range_args),
3466 "::",
3467 stringify!(start)
3468 )
3469 );
3470 }
3471 test_field_start();
3472 fn test_field_len() {
3473 assert_eq!(
3474 unsafe {
3475 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_defrag_range_args>::uninit();
3476 let ptr = uninit.as_ptr();
3477 ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize
3478 },
3479 8usize,
3480 concat!(
3481 "Offset of field: ",
3482 stringify!(btrfs_ioctl_defrag_range_args),
3483 "::",
3484 stringify!(len)
3485 )
3486 );
3487 }
3488 test_field_len();
3489 fn test_field_flags() {
3490 assert_eq!(
3491 unsafe {
3492 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_defrag_range_args>::uninit();
3493 let ptr = uninit.as_ptr();
3494 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
3495 },
3496 16usize,
3497 concat!(
3498 "Offset of field: ",
3499 stringify!(btrfs_ioctl_defrag_range_args),
3500 "::",
3501 stringify!(flags)
3502 )
3503 );
3504 }
3505 test_field_flags();
3506 fn test_field_extent_thresh() {
3507 assert_eq!(
3508 unsafe {
3509 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_defrag_range_args>::uninit();
3510 let ptr = uninit.as_ptr();
3511 ::std::ptr::addr_of!((*ptr).extent_thresh) as usize - ptr as usize
3512 },
3513 24usize,
3514 concat!(
3515 "Offset of field: ",
3516 stringify!(btrfs_ioctl_defrag_range_args),
3517 "::",
3518 stringify!(extent_thresh)
3519 )
3520 );
3521 }
3522 test_field_extent_thresh();
3523 fn test_field_compress_type() {
3524 assert_eq!(
3525 unsafe {
3526 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_defrag_range_args>::uninit();
3527 let ptr = uninit.as_ptr();
3528 ::std::ptr::addr_of!((*ptr).compress_type) as usize - ptr as usize
3529 },
3530 28usize,
3531 concat!(
3532 "Offset of field: ",
3533 stringify!(btrfs_ioctl_defrag_range_args),
3534 "::",
3535 stringify!(compress_type)
3536 )
3537 );
3538 }
3539 test_field_compress_type();
3540 fn test_field_unused() {
3541 assert_eq!(
3542 unsafe {
3543 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_defrag_range_args>::uninit();
3544 let ptr = uninit.as_ptr();
3545 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
3546 },
3547 32usize,
3548 concat!(
3549 "Offset of field: ",
3550 stringify!(btrfs_ioctl_defrag_range_args),
3551 "::",
3552 stringify!(unused)
3553 )
3554 );
3555 }
3556 test_field_unused();
3557}
3558#[repr(C)]
3559#[derive(Debug, Copy, Clone)]
3560pub struct btrfs_ioctl_same_extent_info {
3561 pub fd: __s64,
3562 pub logical_offset: __u64,
3563 pub bytes_deduped: __u64,
3564 pub status: __s32,
3565 pub reserved: __u32,
3566}
3567#[test]
3568fn bindgen_test_layout_btrfs_ioctl_same_extent_info() {
3569 assert_eq!(
3570 ::std::mem::size_of::<btrfs_ioctl_same_extent_info>(),
3571 32usize,
3572 concat!("Size of: ", stringify!(btrfs_ioctl_same_extent_info))
3573 );
3574 assert_eq!(
3575 ::std::mem::align_of::<btrfs_ioctl_same_extent_info>(),
3576 8usize,
3577 concat!("Alignment of ", stringify!(btrfs_ioctl_same_extent_info))
3578 );
3579 fn test_field_fd() {
3580 assert_eq!(
3581 unsafe {
3582 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_extent_info>::uninit();
3583 let ptr = uninit.as_ptr();
3584 ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize
3585 },
3586 0usize,
3587 concat!(
3588 "Offset of field: ",
3589 stringify!(btrfs_ioctl_same_extent_info),
3590 "::",
3591 stringify!(fd)
3592 )
3593 );
3594 }
3595 test_field_fd();
3596 fn test_field_logical_offset() {
3597 assert_eq!(
3598 unsafe {
3599 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_extent_info>::uninit();
3600 let ptr = uninit.as_ptr();
3601 ::std::ptr::addr_of!((*ptr).logical_offset) as usize - ptr as usize
3602 },
3603 8usize,
3604 concat!(
3605 "Offset of field: ",
3606 stringify!(btrfs_ioctl_same_extent_info),
3607 "::",
3608 stringify!(logical_offset)
3609 )
3610 );
3611 }
3612 test_field_logical_offset();
3613 fn test_field_bytes_deduped() {
3614 assert_eq!(
3615 unsafe {
3616 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_extent_info>::uninit();
3617 let ptr = uninit.as_ptr();
3618 ::std::ptr::addr_of!((*ptr).bytes_deduped) as usize - ptr as usize
3619 },
3620 16usize,
3621 concat!(
3622 "Offset of field: ",
3623 stringify!(btrfs_ioctl_same_extent_info),
3624 "::",
3625 stringify!(bytes_deduped)
3626 )
3627 );
3628 }
3629 test_field_bytes_deduped();
3630 fn test_field_status() {
3631 assert_eq!(
3632 unsafe {
3633 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_extent_info>::uninit();
3634 let ptr = uninit.as_ptr();
3635 ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize
3636 },
3637 24usize,
3638 concat!(
3639 "Offset of field: ",
3640 stringify!(btrfs_ioctl_same_extent_info),
3641 "::",
3642 stringify!(status)
3643 )
3644 );
3645 }
3646 test_field_status();
3647 fn test_field_reserved() {
3648 assert_eq!(
3649 unsafe {
3650 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_extent_info>::uninit();
3651 let ptr = uninit.as_ptr();
3652 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
3653 },
3654 28usize,
3655 concat!(
3656 "Offset of field: ",
3657 stringify!(btrfs_ioctl_same_extent_info),
3658 "::",
3659 stringify!(reserved)
3660 )
3661 );
3662 }
3663 test_field_reserved();
3664}
3665#[repr(C)]
3666#[derive(Debug)]
3667pub struct btrfs_ioctl_same_args {
3668 pub logical_offset: __u64,
3669 pub length: __u64,
3670 pub dest_count: __u16,
3671 pub reserved1: __u16,
3672 pub reserved2: __u32,
3673 pub info: __IncompleteArrayField<btrfs_ioctl_same_extent_info>,
3674}
3675#[test]
3676fn bindgen_test_layout_btrfs_ioctl_same_args() {
3677 assert_eq!(
3678 ::std::mem::size_of::<btrfs_ioctl_same_args>(),
3679 24usize,
3680 concat!("Size of: ", stringify!(btrfs_ioctl_same_args))
3681 );
3682 assert_eq!(
3683 ::std::mem::align_of::<btrfs_ioctl_same_args>(),
3684 8usize,
3685 concat!("Alignment of ", stringify!(btrfs_ioctl_same_args))
3686 );
3687 fn test_field_logical_offset() {
3688 assert_eq!(
3689 unsafe {
3690 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_args>::uninit();
3691 let ptr = uninit.as_ptr();
3692 ::std::ptr::addr_of!((*ptr).logical_offset) as usize - ptr as usize
3693 },
3694 0usize,
3695 concat!(
3696 "Offset of field: ",
3697 stringify!(btrfs_ioctl_same_args),
3698 "::",
3699 stringify!(logical_offset)
3700 )
3701 );
3702 }
3703 test_field_logical_offset();
3704 fn test_field_length() {
3705 assert_eq!(
3706 unsafe {
3707 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_args>::uninit();
3708 let ptr = uninit.as_ptr();
3709 ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize
3710 },
3711 8usize,
3712 concat!(
3713 "Offset of field: ",
3714 stringify!(btrfs_ioctl_same_args),
3715 "::",
3716 stringify!(length)
3717 )
3718 );
3719 }
3720 test_field_length();
3721 fn test_field_dest_count() {
3722 assert_eq!(
3723 unsafe {
3724 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_args>::uninit();
3725 let ptr = uninit.as_ptr();
3726 ::std::ptr::addr_of!((*ptr).dest_count) as usize - ptr as usize
3727 },
3728 16usize,
3729 concat!(
3730 "Offset of field: ",
3731 stringify!(btrfs_ioctl_same_args),
3732 "::",
3733 stringify!(dest_count)
3734 )
3735 );
3736 }
3737 test_field_dest_count();
3738 fn test_field_reserved1() {
3739 assert_eq!(
3740 unsafe {
3741 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_args>::uninit();
3742 let ptr = uninit.as_ptr();
3743 ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize
3744 },
3745 18usize,
3746 concat!(
3747 "Offset of field: ",
3748 stringify!(btrfs_ioctl_same_args),
3749 "::",
3750 stringify!(reserved1)
3751 )
3752 );
3753 }
3754 test_field_reserved1();
3755 fn test_field_reserved2() {
3756 assert_eq!(
3757 unsafe {
3758 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_args>::uninit();
3759 let ptr = uninit.as_ptr();
3760 ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize
3761 },
3762 20usize,
3763 concat!(
3764 "Offset of field: ",
3765 stringify!(btrfs_ioctl_same_args),
3766 "::",
3767 stringify!(reserved2)
3768 )
3769 );
3770 }
3771 test_field_reserved2();
3772 fn test_field_info() {
3773 assert_eq!(
3774 unsafe {
3775 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_same_args>::uninit();
3776 let ptr = uninit.as_ptr();
3777 ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize
3778 },
3779 24usize,
3780 concat!(
3781 "Offset of field: ",
3782 stringify!(btrfs_ioctl_same_args),
3783 "::",
3784 stringify!(info)
3785 )
3786 );
3787 }
3788 test_field_info();
3789}
3790#[repr(C)]
3791#[derive(Debug, Copy, Clone)]
3792pub struct btrfs_ioctl_space_info {
3793 pub flags: __u64,
3794 pub total_bytes: __u64,
3795 pub used_bytes: __u64,
3796}
3797#[test]
3798fn bindgen_test_layout_btrfs_ioctl_space_info() {
3799 assert_eq!(
3800 ::std::mem::size_of::<btrfs_ioctl_space_info>(),
3801 24usize,
3802 concat!("Size of: ", stringify!(btrfs_ioctl_space_info))
3803 );
3804 assert_eq!(
3805 ::std::mem::align_of::<btrfs_ioctl_space_info>(),
3806 8usize,
3807 concat!("Alignment of ", stringify!(btrfs_ioctl_space_info))
3808 );
3809 fn test_field_flags() {
3810 assert_eq!(
3811 unsafe {
3812 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_space_info>::uninit();
3813 let ptr = uninit.as_ptr();
3814 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
3815 },
3816 0usize,
3817 concat!(
3818 "Offset of field: ",
3819 stringify!(btrfs_ioctl_space_info),
3820 "::",
3821 stringify!(flags)
3822 )
3823 );
3824 }
3825 test_field_flags();
3826 fn test_field_total_bytes() {
3827 assert_eq!(
3828 unsafe {
3829 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_space_info>::uninit();
3830 let ptr = uninit.as_ptr();
3831 ::std::ptr::addr_of!((*ptr).total_bytes) as usize - ptr as usize
3832 },
3833 8usize,
3834 concat!(
3835 "Offset of field: ",
3836 stringify!(btrfs_ioctl_space_info),
3837 "::",
3838 stringify!(total_bytes)
3839 )
3840 );
3841 }
3842 test_field_total_bytes();
3843 fn test_field_used_bytes() {
3844 assert_eq!(
3845 unsafe {
3846 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_space_info>::uninit();
3847 let ptr = uninit.as_ptr();
3848 ::std::ptr::addr_of!((*ptr).used_bytes) as usize - ptr as usize
3849 },
3850 16usize,
3851 concat!(
3852 "Offset of field: ",
3853 stringify!(btrfs_ioctl_space_info),
3854 "::",
3855 stringify!(used_bytes)
3856 )
3857 );
3858 }
3859 test_field_used_bytes();
3860}
3861#[repr(C)]
3862#[derive(Debug)]
3863pub struct btrfs_ioctl_space_args {
3864 pub space_slots: __u64,
3865 pub total_spaces: __u64,
3866 pub spaces: __IncompleteArrayField<btrfs_ioctl_space_info>,
3867}
3868#[test]
3869fn bindgen_test_layout_btrfs_ioctl_space_args() {
3870 assert_eq!(
3871 ::std::mem::size_of::<btrfs_ioctl_space_args>(),
3872 16usize,
3873 concat!("Size of: ", stringify!(btrfs_ioctl_space_args))
3874 );
3875 assert_eq!(
3876 ::std::mem::align_of::<btrfs_ioctl_space_args>(),
3877 8usize,
3878 concat!("Alignment of ", stringify!(btrfs_ioctl_space_args))
3879 );
3880 fn test_field_space_slots() {
3881 assert_eq!(
3882 unsafe {
3883 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_space_args>::uninit();
3884 let ptr = uninit.as_ptr();
3885 ::std::ptr::addr_of!((*ptr).space_slots) as usize - ptr as usize
3886 },
3887 0usize,
3888 concat!(
3889 "Offset of field: ",
3890 stringify!(btrfs_ioctl_space_args),
3891 "::",
3892 stringify!(space_slots)
3893 )
3894 );
3895 }
3896 test_field_space_slots();
3897 fn test_field_total_spaces() {
3898 assert_eq!(
3899 unsafe {
3900 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_space_args>::uninit();
3901 let ptr = uninit.as_ptr();
3902 ::std::ptr::addr_of!((*ptr).total_spaces) as usize - ptr as usize
3903 },
3904 8usize,
3905 concat!(
3906 "Offset of field: ",
3907 stringify!(btrfs_ioctl_space_args),
3908 "::",
3909 stringify!(total_spaces)
3910 )
3911 );
3912 }
3913 test_field_total_spaces();
3914 fn test_field_spaces() {
3915 assert_eq!(
3916 unsafe {
3917 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_space_args>::uninit();
3918 let ptr = uninit.as_ptr();
3919 ::std::ptr::addr_of!((*ptr).spaces) as usize - ptr as usize
3920 },
3921 16usize,
3922 concat!(
3923 "Offset of field: ",
3924 stringify!(btrfs_ioctl_space_args),
3925 "::",
3926 stringify!(spaces)
3927 )
3928 );
3929 }
3930 test_field_spaces();
3931}
3932#[repr(C)]
3933#[derive(Debug)]
3934pub struct btrfs_data_container {
3935 pub bytes_left: __u32,
3936 pub bytes_missing: __u32,
3937 pub elem_cnt: __u32,
3938 pub elem_missed: __u32,
3939 pub val: __IncompleteArrayField<__u64>,
3940}
3941#[test]
3942fn bindgen_test_layout_btrfs_data_container() {
3943 assert_eq!(
3944 ::std::mem::size_of::<btrfs_data_container>(),
3945 16usize,
3946 concat!("Size of: ", stringify!(btrfs_data_container))
3947 );
3948 assert_eq!(
3949 ::std::mem::align_of::<btrfs_data_container>(),
3950 8usize,
3951 concat!("Alignment of ", stringify!(btrfs_data_container))
3952 );
3953 fn test_field_bytes_left() {
3954 assert_eq!(
3955 unsafe {
3956 let uninit = ::std::mem::MaybeUninit::<btrfs_data_container>::uninit();
3957 let ptr = uninit.as_ptr();
3958 ::std::ptr::addr_of!((*ptr).bytes_left) as usize - ptr as usize
3959 },
3960 0usize,
3961 concat!(
3962 "Offset of field: ",
3963 stringify!(btrfs_data_container),
3964 "::",
3965 stringify!(bytes_left)
3966 )
3967 );
3968 }
3969 test_field_bytes_left();
3970 fn test_field_bytes_missing() {
3971 assert_eq!(
3972 unsafe {
3973 let uninit = ::std::mem::MaybeUninit::<btrfs_data_container>::uninit();
3974 let ptr = uninit.as_ptr();
3975 ::std::ptr::addr_of!((*ptr).bytes_missing) as usize - ptr as usize
3976 },
3977 4usize,
3978 concat!(
3979 "Offset of field: ",
3980 stringify!(btrfs_data_container),
3981 "::",
3982 stringify!(bytes_missing)
3983 )
3984 );
3985 }
3986 test_field_bytes_missing();
3987 fn test_field_elem_cnt() {
3988 assert_eq!(
3989 unsafe {
3990 let uninit = ::std::mem::MaybeUninit::<btrfs_data_container>::uninit();
3991 let ptr = uninit.as_ptr();
3992 ::std::ptr::addr_of!((*ptr).elem_cnt) as usize - ptr as usize
3993 },
3994 8usize,
3995 concat!(
3996 "Offset of field: ",
3997 stringify!(btrfs_data_container),
3998 "::",
3999 stringify!(elem_cnt)
4000 )
4001 );
4002 }
4003 test_field_elem_cnt();
4004 fn test_field_elem_missed() {
4005 assert_eq!(
4006 unsafe {
4007 let uninit = ::std::mem::MaybeUninit::<btrfs_data_container>::uninit();
4008 let ptr = uninit.as_ptr();
4009 ::std::ptr::addr_of!((*ptr).elem_missed) as usize - ptr as usize
4010 },
4011 12usize,
4012 concat!(
4013 "Offset of field: ",
4014 stringify!(btrfs_data_container),
4015 "::",
4016 stringify!(elem_missed)
4017 )
4018 );
4019 }
4020 test_field_elem_missed();
4021 fn test_field_val() {
4022 assert_eq!(
4023 unsafe {
4024 let uninit = ::std::mem::MaybeUninit::<btrfs_data_container>::uninit();
4025 let ptr = uninit.as_ptr();
4026 ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize
4027 },
4028 16usize,
4029 concat!(
4030 "Offset of field: ",
4031 stringify!(btrfs_data_container),
4032 "::",
4033 stringify!(val)
4034 )
4035 );
4036 }
4037 test_field_val();
4038}
4039#[repr(C)]
4040#[derive(Debug, Copy, Clone)]
4041pub struct btrfs_ioctl_ino_path_args {
4042 pub inum: __u64,
4043 pub size: __u64,
4044 pub reserved: [__u64; 4usize],
4045 pub fspath: __u64,
4046}
4047#[test]
4048fn bindgen_test_layout_btrfs_ioctl_ino_path_args() {
4049 assert_eq!(
4050 ::std::mem::size_of::<btrfs_ioctl_ino_path_args>(),
4051 56usize,
4052 concat!("Size of: ", stringify!(btrfs_ioctl_ino_path_args))
4053 );
4054 assert_eq!(
4055 ::std::mem::align_of::<btrfs_ioctl_ino_path_args>(),
4056 8usize,
4057 concat!("Alignment of ", stringify!(btrfs_ioctl_ino_path_args))
4058 );
4059 fn test_field_inum() {
4060 assert_eq!(
4061 unsafe {
4062 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_path_args>::uninit();
4063 let ptr = uninit.as_ptr();
4064 ::std::ptr::addr_of!((*ptr).inum) as usize - ptr as usize
4065 },
4066 0usize,
4067 concat!(
4068 "Offset of field: ",
4069 stringify!(btrfs_ioctl_ino_path_args),
4070 "::",
4071 stringify!(inum)
4072 )
4073 );
4074 }
4075 test_field_inum();
4076 fn test_field_size() {
4077 assert_eq!(
4078 unsafe {
4079 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_path_args>::uninit();
4080 let ptr = uninit.as_ptr();
4081 ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
4082 },
4083 8usize,
4084 concat!(
4085 "Offset of field: ",
4086 stringify!(btrfs_ioctl_ino_path_args),
4087 "::",
4088 stringify!(size)
4089 )
4090 );
4091 }
4092 test_field_size();
4093 fn test_field_reserved() {
4094 assert_eq!(
4095 unsafe {
4096 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_path_args>::uninit();
4097 let ptr = uninit.as_ptr();
4098 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
4099 },
4100 16usize,
4101 concat!(
4102 "Offset of field: ",
4103 stringify!(btrfs_ioctl_ino_path_args),
4104 "::",
4105 stringify!(reserved)
4106 )
4107 );
4108 }
4109 test_field_reserved();
4110 fn test_field_fspath() {
4111 assert_eq!(
4112 unsafe {
4113 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_ino_path_args>::uninit();
4114 let ptr = uninit.as_ptr();
4115 ::std::ptr::addr_of!((*ptr).fspath) as usize - ptr as usize
4116 },
4117 48usize,
4118 concat!(
4119 "Offset of field: ",
4120 stringify!(btrfs_ioctl_ino_path_args),
4121 "::",
4122 stringify!(fspath)
4123 )
4124 );
4125 }
4126 test_field_fspath();
4127}
4128#[repr(C)]
4129#[derive(Debug, Copy, Clone)]
4130pub struct btrfs_ioctl_logical_ino_args {
4131 pub logical: __u64,
4132 pub size: __u64,
4133 pub reserved: [__u64; 3usize],
4134 pub flags: __u64,
4135 pub inodes: __u64,
4136}
4137#[test]
4138fn bindgen_test_layout_btrfs_ioctl_logical_ino_args() {
4139 assert_eq!(
4140 ::std::mem::size_of::<btrfs_ioctl_logical_ino_args>(),
4141 56usize,
4142 concat!("Size of: ", stringify!(btrfs_ioctl_logical_ino_args))
4143 );
4144 assert_eq!(
4145 ::std::mem::align_of::<btrfs_ioctl_logical_ino_args>(),
4146 8usize,
4147 concat!("Alignment of ", stringify!(btrfs_ioctl_logical_ino_args))
4148 );
4149 fn test_field_logical() {
4150 assert_eq!(
4151 unsafe {
4152 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_logical_ino_args>::uninit();
4153 let ptr = uninit.as_ptr();
4154 ::std::ptr::addr_of!((*ptr).logical) as usize - ptr as usize
4155 },
4156 0usize,
4157 concat!(
4158 "Offset of field: ",
4159 stringify!(btrfs_ioctl_logical_ino_args),
4160 "::",
4161 stringify!(logical)
4162 )
4163 );
4164 }
4165 test_field_logical();
4166 fn test_field_size() {
4167 assert_eq!(
4168 unsafe {
4169 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_logical_ino_args>::uninit();
4170 let ptr = uninit.as_ptr();
4171 ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
4172 },
4173 8usize,
4174 concat!(
4175 "Offset of field: ",
4176 stringify!(btrfs_ioctl_logical_ino_args),
4177 "::",
4178 stringify!(size)
4179 )
4180 );
4181 }
4182 test_field_size();
4183 fn test_field_reserved() {
4184 assert_eq!(
4185 unsafe {
4186 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_logical_ino_args>::uninit();
4187 let ptr = uninit.as_ptr();
4188 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
4189 },
4190 16usize,
4191 concat!(
4192 "Offset of field: ",
4193 stringify!(btrfs_ioctl_logical_ino_args),
4194 "::",
4195 stringify!(reserved)
4196 )
4197 );
4198 }
4199 test_field_reserved();
4200 fn test_field_flags() {
4201 assert_eq!(
4202 unsafe {
4203 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_logical_ino_args>::uninit();
4204 let ptr = uninit.as_ptr();
4205 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
4206 },
4207 40usize,
4208 concat!(
4209 "Offset of field: ",
4210 stringify!(btrfs_ioctl_logical_ino_args),
4211 "::",
4212 stringify!(flags)
4213 )
4214 );
4215 }
4216 test_field_flags();
4217 fn test_field_inodes() {
4218 assert_eq!(
4219 unsafe {
4220 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_logical_ino_args>::uninit();
4221 let ptr = uninit.as_ptr();
4222 ::std::ptr::addr_of!((*ptr).inodes) as usize - ptr as usize
4223 },
4224 48usize,
4225 concat!(
4226 "Offset of field: ",
4227 stringify!(btrfs_ioctl_logical_ino_args),
4228 "::",
4229 stringify!(inodes)
4230 )
4231 );
4232 }
4233 test_field_inodes();
4234}
4235pub const btrfs_dev_stat_values_BTRFS_DEV_STAT_WRITE_ERRS: btrfs_dev_stat_values = 0;
4236pub const btrfs_dev_stat_values_BTRFS_DEV_STAT_READ_ERRS: btrfs_dev_stat_values = 1;
4237pub const btrfs_dev_stat_values_BTRFS_DEV_STAT_FLUSH_ERRS: btrfs_dev_stat_values = 2;
4238pub const btrfs_dev_stat_values_BTRFS_DEV_STAT_CORRUPTION_ERRS: btrfs_dev_stat_values = 3;
4239pub const btrfs_dev_stat_values_BTRFS_DEV_STAT_GENERATION_ERRS: btrfs_dev_stat_values = 4;
4240pub const btrfs_dev_stat_values_BTRFS_DEV_STAT_VALUES_MAX: btrfs_dev_stat_values = 5;
4241pub type btrfs_dev_stat_values = ::std::os::raw::c_uint;
4242#[repr(C)]
4243#[derive(Debug, Copy, Clone)]
4244pub struct btrfs_ioctl_get_dev_stats {
4245 pub devid: __u64,
4246 pub nr_items: __u64,
4247 pub flags: __u64,
4248 pub values: [__u64; 5usize],
4249 pub unused: [__u64; 121usize],
4250}
4251#[test]
4252fn bindgen_test_layout_btrfs_ioctl_get_dev_stats() {
4253 assert_eq!(
4254 ::std::mem::size_of::<btrfs_ioctl_get_dev_stats>(),
4255 1032usize,
4256 concat!("Size of: ", stringify!(btrfs_ioctl_get_dev_stats))
4257 );
4258 assert_eq!(
4259 ::std::mem::align_of::<btrfs_ioctl_get_dev_stats>(),
4260 8usize,
4261 concat!("Alignment of ", stringify!(btrfs_ioctl_get_dev_stats))
4262 );
4263 fn test_field_devid() {
4264 assert_eq!(
4265 unsafe {
4266 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_dev_stats>::uninit();
4267 let ptr = uninit.as_ptr();
4268 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
4269 },
4270 0usize,
4271 concat!(
4272 "Offset of field: ",
4273 stringify!(btrfs_ioctl_get_dev_stats),
4274 "::",
4275 stringify!(devid)
4276 )
4277 );
4278 }
4279 test_field_devid();
4280 fn test_field_nr_items() {
4281 assert_eq!(
4282 unsafe {
4283 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_dev_stats>::uninit();
4284 let ptr = uninit.as_ptr();
4285 ::std::ptr::addr_of!((*ptr).nr_items) as usize - ptr as usize
4286 },
4287 8usize,
4288 concat!(
4289 "Offset of field: ",
4290 stringify!(btrfs_ioctl_get_dev_stats),
4291 "::",
4292 stringify!(nr_items)
4293 )
4294 );
4295 }
4296 test_field_nr_items();
4297 fn test_field_flags() {
4298 assert_eq!(
4299 unsafe {
4300 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_dev_stats>::uninit();
4301 let ptr = uninit.as_ptr();
4302 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
4303 },
4304 16usize,
4305 concat!(
4306 "Offset of field: ",
4307 stringify!(btrfs_ioctl_get_dev_stats),
4308 "::",
4309 stringify!(flags)
4310 )
4311 );
4312 }
4313 test_field_flags();
4314 fn test_field_values() {
4315 assert_eq!(
4316 unsafe {
4317 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_dev_stats>::uninit();
4318 let ptr = uninit.as_ptr();
4319 ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize
4320 },
4321 24usize,
4322 concat!(
4323 "Offset of field: ",
4324 stringify!(btrfs_ioctl_get_dev_stats),
4325 "::",
4326 stringify!(values)
4327 )
4328 );
4329 }
4330 test_field_values();
4331 fn test_field_unused() {
4332 assert_eq!(
4333 unsafe {
4334 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_dev_stats>::uninit();
4335 let ptr = uninit.as_ptr();
4336 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
4337 },
4338 64usize,
4339 concat!(
4340 "Offset of field: ",
4341 stringify!(btrfs_ioctl_get_dev_stats),
4342 "::",
4343 stringify!(unused)
4344 )
4345 );
4346 }
4347 test_field_unused();
4348}
4349#[repr(C)]
4350#[derive(Debug, Copy, Clone)]
4351pub struct btrfs_ioctl_quota_ctl_args {
4352 pub cmd: __u64,
4353 pub status: __u64,
4354}
4355#[test]
4356fn bindgen_test_layout_btrfs_ioctl_quota_ctl_args() {
4357 assert_eq!(
4358 ::std::mem::size_of::<btrfs_ioctl_quota_ctl_args>(),
4359 16usize,
4360 concat!("Size of: ", stringify!(btrfs_ioctl_quota_ctl_args))
4361 );
4362 assert_eq!(
4363 ::std::mem::align_of::<btrfs_ioctl_quota_ctl_args>(),
4364 8usize,
4365 concat!("Alignment of ", stringify!(btrfs_ioctl_quota_ctl_args))
4366 );
4367 fn test_field_cmd() {
4368 assert_eq!(
4369 unsafe {
4370 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_quota_ctl_args>::uninit();
4371 let ptr = uninit.as_ptr();
4372 ::std::ptr::addr_of!((*ptr).cmd) as usize - ptr as usize
4373 },
4374 0usize,
4375 concat!(
4376 "Offset of field: ",
4377 stringify!(btrfs_ioctl_quota_ctl_args),
4378 "::",
4379 stringify!(cmd)
4380 )
4381 );
4382 }
4383 test_field_cmd();
4384 fn test_field_status() {
4385 assert_eq!(
4386 unsafe {
4387 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_quota_ctl_args>::uninit();
4388 let ptr = uninit.as_ptr();
4389 ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize
4390 },
4391 8usize,
4392 concat!(
4393 "Offset of field: ",
4394 stringify!(btrfs_ioctl_quota_ctl_args),
4395 "::",
4396 stringify!(status)
4397 )
4398 );
4399 }
4400 test_field_status();
4401}
4402#[repr(C)]
4403#[derive(Debug, Copy, Clone)]
4404pub struct btrfs_ioctl_quota_rescan_args {
4405 pub flags: __u64,
4406 pub progress: __u64,
4407 pub reserved: [__u64; 6usize],
4408}
4409#[test]
4410fn bindgen_test_layout_btrfs_ioctl_quota_rescan_args() {
4411 assert_eq!(
4412 ::std::mem::size_of::<btrfs_ioctl_quota_rescan_args>(),
4413 64usize,
4414 concat!("Size of: ", stringify!(btrfs_ioctl_quota_rescan_args))
4415 );
4416 assert_eq!(
4417 ::std::mem::align_of::<btrfs_ioctl_quota_rescan_args>(),
4418 8usize,
4419 concat!("Alignment of ", stringify!(btrfs_ioctl_quota_rescan_args))
4420 );
4421 fn test_field_flags() {
4422 assert_eq!(
4423 unsafe {
4424 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_quota_rescan_args>::uninit();
4425 let ptr = uninit.as_ptr();
4426 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
4427 },
4428 0usize,
4429 concat!(
4430 "Offset of field: ",
4431 stringify!(btrfs_ioctl_quota_rescan_args),
4432 "::",
4433 stringify!(flags)
4434 )
4435 );
4436 }
4437 test_field_flags();
4438 fn test_field_progress() {
4439 assert_eq!(
4440 unsafe {
4441 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_quota_rescan_args>::uninit();
4442 let ptr = uninit.as_ptr();
4443 ::std::ptr::addr_of!((*ptr).progress) as usize - ptr as usize
4444 },
4445 8usize,
4446 concat!(
4447 "Offset of field: ",
4448 stringify!(btrfs_ioctl_quota_rescan_args),
4449 "::",
4450 stringify!(progress)
4451 )
4452 );
4453 }
4454 test_field_progress();
4455 fn test_field_reserved() {
4456 assert_eq!(
4457 unsafe {
4458 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_quota_rescan_args>::uninit();
4459 let ptr = uninit.as_ptr();
4460 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
4461 },
4462 16usize,
4463 concat!(
4464 "Offset of field: ",
4465 stringify!(btrfs_ioctl_quota_rescan_args),
4466 "::",
4467 stringify!(reserved)
4468 )
4469 );
4470 }
4471 test_field_reserved();
4472}
4473#[repr(C)]
4474#[derive(Debug, Copy, Clone)]
4475pub struct btrfs_ioctl_qgroup_assign_args {
4476 pub assign: __u64,
4477 pub src: __u64,
4478 pub dst: __u64,
4479}
4480#[test]
4481fn bindgen_test_layout_btrfs_ioctl_qgroup_assign_args() {
4482 assert_eq!(
4483 ::std::mem::size_of::<btrfs_ioctl_qgroup_assign_args>(),
4484 24usize,
4485 concat!("Size of: ", stringify!(btrfs_ioctl_qgroup_assign_args))
4486 );
4487 assert_eq!(
4488 ::std::mem::align_of::<btrfs_ioctl_qgroup_assign_args>(),
4489 8usize,
4490 concat!("Alignment of ", stringify!(btrfs_ioctl_qgroup_assign_args))
4491 );
4492 fn test_field_assign() {
4493 assert_eq!(
4494 unsafe {
4495 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_assign_args>::uninit();
4496 let ptr = uninit.as_ptr();
4497 ::std::ptr::addr_of!((*ptr).assign) as usize - ptr as usize
4498 },
4499 0usize,
4500 concat!(
4501 "Offset of field: ",
4502 stringify!(btrfs_ioctl_qgroup_assign_args),
4503 "::",
4504 stringify!(assign)
4505 )
4506 );
4507 }
4508 test_field_assign();
4509 fn test_field_src() {
4510 assert_eq!(
4511 unsafe {
4512 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_assign_args>::uninit();
4513 let ptr = uninit.as_ptr();
4514 ::std::ptr::addr_of!((*ptr).src) as usize - ptr as usize
4515 },
4516 8usize,
4517 concat!(
4518 "Offset of field: ",
4519 stringify!(btrfs_ioctl_qgroup_assign_args),
4520 "::",
4521 stringify!(src)
4522 )
4523 );
4524 }
4525 test_field_src();
4526 fn test_field_dst() {
4527 assert_eq!(
4528 unsafe {
4529 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_assign_args>::uninit();
4530 let ptr = uninit.as_ptr();
4531 ::std::ptr::addr_of!((*ptr).dst) as usize - ptr as usize
4532 },
4533 16usize,
4534 concat!(
4535 "Offset of field: ",
4536 stringify!(btrfs_ioctl_qgroup_assign_args),
4537 "::",
4538 stringify!(dst)
4539 )
4540 );
4541 }
4542 test_field_dst();
4543}
4544#[repr(C)]
4545#[derive(Debug, Copy, Clone)]
4546pub struct btrfs_ioctl_qgroup_create_args {
4547 pub create: __u64,
4548 pub qgroupid: __u64,
4549}
4550#[test]
4551fn bindgen_test_layout_btrfs_ioctl_qgroup_create_args() {
4552 assert_eq!(
4553 ::std::mem::size_of::<btrfs_ioctl_qgroup_create_args>(),
4554 16usize,
4555 concat!("Size of: ", stringify!(btrfs_ioctl_qgroup_create_args))
4556 );
4557 assert_eq!(
4558 ::std::mem::align_of::<btrfs_ioctl_qgroup_create_args>(),
4559 8usize,
4560 concat!("Alignment of ", stringify!(btrfs_ioctl_qgroup_create_args))
4561 );
4562 fn test_field_create() {
4563 assert_eq!(
4564 unsafe {
4565 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_create_args>::uninit();
4566 let ptr = uninit.as_ptr();
4567 ::std::ptr::addr_of!((*ptr).create) as usize - ptr as usize
4568 },
4569 0usize,
4570 concat!(
4571 "Offset of field: ",
4572 stringify!(btrfs_ioctl_qgroup_create_args),
4573 "::",
4574 stringify!(create)
4575 )
4576 );
4577 }
4578 test_field_create();
4579 fn test_field_qgroupid() {
4580 assert_eq!(
4581 unsafe {
4582 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_qgroup_create_args>::uninit();
4583 let ptr = uninit.as_ptr();
4584 ::std::ptr::addr_of!((*ptr).qgroupid) as usize - ptr as usize
4585 },
4586 8usize,
4587 concat!(
4588 "Offset of field: ",
4589 stringify!(btrfs_ioctl_qgroup_create_args),
4590 "::",
4591 stringify!(qgroupid)
4592 )
4593 );
4594 }
4595 test_field_qgroupid();
4596}
4597#[repr(C)]
4598#[derive(Debug, Copy, Clone)]
4599pub struct btrfs_ioctl_timespec {
4600 pub sec: __u64,
4601 pub nsec: __u32,
4602}
4603#[test]
4604fn bindgen_test_layout_btrfs_ioctl_timespec() {
4605 assert_eq!(
4606 ::std::mem::size_of::<btrfs_ioctl_timespec>(),
4607 16usize,
4608 concat!("Size of: ", stringify!(btrfs_ioctl_timespec))
4609 );
4610 assert_eq!(
4611 ::std::mem::align_of::<btrfs_ioctl_timespec>(),
4612 8usize,
4613 concat!("Alignment of ", stringify!(btrfs_ioctl_timespec))
4614 );
4615 fn test_field_sec() {
4616 assert_eq!(
4617 unsafe {
4618 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_timespec>::uninit();
4619 let ptr = uninit.as_ptr();
4620 ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize
4621 },
4622 0usize,
4623 concat!(
4624 "Offset of field: ",
4625 stringify!(btrfs_ioctl_timespec),
4626 "::",
4627 stringify!(sec)
4628 )
4629 );
4630 }
4631 test_field_sec();
4632 fn test_field_nsec() {
4633 assert_eq!(
4634 unsafe {
4635 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_timespec>::uninit();
4636 let ptr = uninit.as_ptr();
4637 ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize
4638 },
4639 8usize,
4640 concat!(
4641 "Offset of field: ",
4642 stringify!(btrfs_ioctl_timespec),
4643 "::",
4644 stringify!(nsec)
4645 )
4646 );
4647 }
4648 test_field_nsec();
4649}
4650#[repr(C)]
4651#[derive(Debug, Copy, Clone)]
4652pub struct btrfs_ioctl_received_subvol_args {
4653 pub uuid: [::std::os::raw::c_char; 16usize],
4654 pub stransid: __u64,
4655 pub rtransid: __u64,
4656 pub stime: btrfs_ioctl_timespec,
4657 pub rtime: btrfs_ioctl_timespec,
4658 pub flags: __u64,
4659 pub reserved: [__u64; 16usize],
4660}
4661#[test]
4662fn bindgen_test_layout_btrfs_ioctl_received_subvol_args() {
4663 assert_eq!(
4664 ::std::mem::size_of::<btrfs_ioctl_received_subvol_args>(),
4665 200usize,
4666 concat!("Size of: ", stringify!(btrfs_ioctl_received_subvol_args))
4667 );
4668 assert_eq!(
4669 ::std::mem::align_of::<btrfs_ioctl_received_subvol_args>(),
4670 8usize,
4671 concat!(
4672 "Alignment of ",
4673 stringify!(btrfs_ioctl_received_subvol_args)
4674 )
4675 );
4676 fn test_field_uuid() {
4677 assert_eq!(
4678 unsafe {
4679 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4680 let ptr = uninit.as_ptr();
4681 ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize
4682 },
4683 0usize,
4684 concat!(
4685 "Offset of field: ",
4686 stringify!(btrfs_ioctl_received_subvol_args),
4687 "::",
4688 stringify!(uuid)
4689 )
4690 );
4691 }
4692 test_field_uuid();
4693 fn test_field_stransid() {
4694 assert_eq!(
4695 unsafe {
4696 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4697 let ptr = uninit.as_ptr();
4698 ::std::ptr::addr_of!((*ptr).stransid) as usize - ptr as usize
4699 },
4700 16usize,
4701 concat!(
4702 "Offset of field: ",
4703 stringify!(btrfs_ioctl_received_subvol_args),
4704 "::",
4705 stringify!(stransid)
4706 )
4707 );
4708 }
4709 test_field_stransid();
4710 fn test_field_rtransid() {
4711 assert_eq!(
4712 unsafe {
4713 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4714 let ptr = uninit.as_ptr();
4715 ::std::ptr::addr_of!((*ptr).rtransid) as usize - ptr as usize
4716 },
4717 24usize,
4718 concat!(
4719 "Offset of field: ",
4720 stringify!(btrfs_ioctl_received_subvol_args),
4721 "::",
4722 stringify!(rtransid)
4723 )
4724 );
4725 }
4726 test_field_rtransid();
4727 fn test_field_stime() {
4728 assert_eq!(
4729 unsafe {
4730 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4731 let ptr = uninit.as_ptr();
4732 ::std::ptr::addr_of!((*ptr).stime) as usize - ptr as usize
4733 },
4734 32usize,
4735 concat!(
4736 "Offset of field: ",
4737 stringify!(btrfs_ioctl_received_subvol_args),
4738 "::",
4739 stringify!(stime)
4740 )
4741 );
4742 }
4743 test_field_stime();
4744 fn test_field_rtime() {
4745 assert_eq!(
4746 unsafe {
4747 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4748 let ptr = uninit.as_ptr();
4749 ::std::ptr::addr_of!((*ptr).rtime) as usize - ptr as usize
4750 },
4751 48usize,
4752 concat!(
4753 "Offset of field: ",
4754 stringify!(btrfs_ioctl_received_subvol_args),
4755 "::",
4756 stringify!(rtime)
4757 )
4758 );
4759 }
4760 test_field_rtime();
4761 fn test_field_flags() {
4762 assert_eq!(
4763 unsafe {
4764 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4765 let ptr = uninit.as_ptr();
4766 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
4767 },
4768 64usize,
4769 concat!(
4770 "Offset of field: ",
4771 stringify!(btrfs_ioctl_received_subvol_args),
4772 "::",
4773 stringify!(flags)
4774 )
4775 );
4776 }
4777 test_field_flags();
4778 fn test_field_reserved() {
4779 assert_eq!(
4780 unsafe {
4781 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_received_subvol_args>::uninit();
4782 let ptr = uninit.as_ptr();
4783 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
4784 },
4785 72usize,
4786 concat!(
4787 "Offset of field: ",
4788 stringify!(btrfs_ioctl_received_subvol_args),
4789 "::",
4790 stringify!(reserved)
4791 )
4792 );
4793 }
4794 test_field_reserved();
4795}
4796#[repr(C)]
4797#[derive(Debug, Copy, Clone)]
4798pub struct btrfs_ioctl_send_args {
4799 pub send_fd: __s64,
4800 pub clone_sources_count: __u64,
4801 pub clone_sources: *mut __u64,
4802 pub parent_root: __u64,
4803 pub flags: __u64,
4804 pub reserved: [__u64; 4usize],
4805}
4806#[test]
4807fn bindgen_test_layout_btrfs_ioctl_send_args() {
4808 assert_eq!(
4809 ::std::mem::size_of::<btrfs_ioctl_send_args>(),
4810 72usize,
4811 concat!("Size of: ", stringify!(btrfs_ioctl_send_args))
4812 );
4813 assert_eq!(
4814 ::std::mem::align_of::<btrfs_ioctl_send_args>(),
4815 8usize,
4816 concat!("Alignment of ", stringify!(btrfs_ioctl_send_args))
4817 );
4818 fn test_field_send_fd() {
4819 assert_eq!(
4820 unsafe {
4821 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_send_args>::uninit();
4822 let ptr = uninit.as_ptr();
4823 ::std::ptr::addr_of!((*ptr).send_fd) as usize - ptr as usize
4824 },
4825 0usize,
4826 concat!(
4827 "Offset of field: ",
4828 stringify!(btrfs_ioctl_send_args),
4829 "::",
4830 stringify!(send_fd)
4831 )
4832 );
4833 }
4834 test_field_send_fd();
4835 fn test_field_clone_sources_count() {
4836 assert_eq!(
4837 unsafe {
4838 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_send_args>::uninit();
4839 let ptr = uninit.as_ptr();
4840 ::std::ptr::addr_of!((*ptr).clone_sources_count) as usize - ptr as usize
4841 },
4842 8usize,
4843 concat!(
4844 "Offset of field: ",
4845 stringify!(btrfs_ioctl_send_args),
4846 "::",
4847 stringify!(clone_sources_count)
4848 )
4849 );
4850 }
4851 test_field_clone_sources_count();
4852 fn test_field_clone_sources() {
4853 assert_eq!(
4854 unsafe {
4855 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_send_args>::uninit();
4856 let ptr = uninit.as_ptr();
4857 ::std::ptr::addr_of!((*ptr).clone_sources) as usize - ptr as usize
4858 },
4859 16usize,
4860 concat!(
4861 "Offset of field: ",
4862 stringify!(btrfs_ioctl_send_args),
4863 "::",
4864 stringify!(clone_sources)
4865 )
4866 );
4867 }
4868 test_field_clone_sources();
4869 fn test_field_parent_root() {
4870 assert_eq!(
4871 unsafe {
4872 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_send_args>::uninit();
4873 let ptr = uninit.as_ptr();
4874 ::std::ptr::addr_of!((*ptr).parent_root) as usize - ptr as usize
4875 },
4876 24usize,
4877 concat!(
4878 "Offset of field: ",
4879 stringify!(btrfs_ioctl_send_args),
4880 "::",
4881 stringify!(parent_root)
4882 )
4883 );
4884 }
4885 test_field_parent_root();
4886 fn test_field_flags() {
4887 assert_eq!(
4888 unsafe {
4889 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_send_args>::uninit();
4890 let ptr = uninit.as_ptr();
4891 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
4892 },
4893 32usize,
4894 concat!(
4895 "Offset of field: ",
4896 stringify!(btrfs_ioctl_send_args),
4897 "::",
4898 stringify!(flags)
4899 )
4900 );
4901 }
4902 test_field_flags();
4903 fn test_field_reserved() {
4904 assert_eq!(
4905 unsafe {
4906 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_send_args>::uninit();
4907 let ptr = uninit.as_ptr();
4908 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
4909 },
4910 40usize,
4911 concat!(
4912 "Offset of field: ",
4913 stringify!(btrfs_ioctl_send_args),
4914 "::",
4915 stringify!(reserved)
4916 )
4917 );
4918 }
4919 test_field_reserved();
4920}
4921#[repr(C)]
4922#[derive(Debug, Copy, Clone)]
4923pub struct btrfs_ioctl_get_subvol_info_args {
4924 pub treeid: __u64,
4925 pub name: [::std::os::raw::c_char; 256usize],
4926 pub parent_id: __u64,
4927 pub dirid: __u64,
4928 pub generation: __u64,
4929 pub flags: __u64,
4930 pub uuid: [__u8; 16usize],
4931 pub parent_uuid: [__u8; 16usize],
4932 pub received_uuid: [__u8; 16usize],
4933 pub ctransid: __u64,
4934 pub otransid: __u64,
4935 pub stransid: __u64,
4936 pub rtransid: __u64,
4937 pub ctime: btrfs_ioctl_timespec,
4938 pub otime: btrfs_ioctl_timespec,
4939 pub stime: btrfs_ioctl_timespec,
4940 pub rtime: btrfs_ioctl_timespec,
4941 pub reserved: [__u64; 8usize],
4942}
4943#[test]
4944fn bindgen_test_layout_btrfs_ioctl_get_subvol_info_args() {
4945 assert_eq!(
4946 ::std::mem::size_of::<btrfs_ioctl_get_subvol_info_args>(),
4947 504usize,
4948 concat!("Size of: ", stringify!(btrfs_ioctl_get_subvol_info_args))
4949 );
4950 assert_eq!(
4951 ::std::mem::align_of::<btrfs_ioctl_get_subvol_info_args>(),
4952 8usize,
4953 concat!(
4954 "Alignment of ",
4955 stringify!(btrfs_ioctl_get_subvol_info_args)
4956 )
4957 );
4958 fn test_field_treeid() {
4959 assert_eq!(
4960 unsafe {
4961 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
4962 let ptr = uninit.as_ptr();
4963 ::std::ptr::addr_of!((*ptr).treeid) as usize - ptr as usize
4964 },
4965 0usize,
4966 concat!(
4967 "Offset of field: ",
4968 stringify!(btrfs_ioctl_get_subvol_info_args),
4969 "::",
4970 stringify!(treeid)
4971 )
4972 );
4973 }
4974 test_field_treeid();
4975 fn test_field_name() {
4976 assert_eq!(
4977 unsafe {
4978 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
4979 let ptr = uninit.as_ptr();
4980 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
4981 },
4982 8usize,
4983 concat!(
4984 "Offset of field: ",
4985 stringify!(btrfs_ioctl_get_subvol_info_args),
4986 "::",
4987 stringify!(name)
4988 )
4989 );
4990 }
4991 test_field_name();
4992 fn test_field_parent_id() {
4993 assert_eq!(
4994 unsafe {
4995 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
4996 let ptr = uninit.as_ptr();
4997 ::std::ptr::addr_of!((*ptr).parent_id) as usize - ptr as usize
4998 },
4999 264usize,
5000 concat!(
5001 "Offset of field: ",
5002 stringify!(btrfs_ioctl_get_subvol_info_args),
5003 "::",
5004 stringify!(parent_id)
5005 )
5006 );
5007 }
5008 test_field_parent_id();
5009 fn test_field_dirid() {
5010 assert_eq!(
5011 unsafe {
5012 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5013 let ptr = uninit.as_ptr();
5014 ::std::ptr::addr_of!((*ptr).dirid) as usize - ptr as usize
5015 },
5016 272usize,
5017 concat!(
5018 "Offset of field: ",
5019 stringify!(btrfs_ioctl_get_subvol_info_args),
5020 "::",
5021 stringify!(dirid)
5022 )
5023 );
5024 }
5025 test_field_dirid();
5026 fn test_field_generation() {
5027 assert_eq!(
5028 unsafe {
5029 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5030 let ptr = uninit.as_ptr();
5031 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
5032 },
5033 280usize,
5034 concat!(
5035 "Offset of field: ",
5036 stringify!(btrfs_ioctl_get_subvol_info_args),
5037 "::",
5038 stringify!(generation)
5039 )
5040 );
5041 }
5042 test_field_generation();
5043 fn test_field_flags() {
5044 assert_eq!(
5045 unsafe {
5046 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5047 let ptr = uninit.as_ptr();
5048 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
5049 },
5050 288usize,
5051 concat!(
5052 "Offset of field: ",
5053 stringify!(btrfs_ioctl_get_subvol_info_args),
5054 "::",
5055 stringify!(flags)
5056 )
5057 );
5058 }
5059 test_field_flags();
5060 fn test_field_uuid() {
5061 assert_eq!(
5062 unsafe {
5063 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5064 let ptr = uninit.as_ptr();
5065 ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize
5066 },
5067 296usize,
5068 concat!(
5069 "Offset of field: ",
5070 stringify!(btrfs_ioctl_get_subvol_info_args),
5071 "::",
5072 stringify!(uuid)
5073 )
5074 );
5075 }
5076 test_field_uuid();
5077 fn test_field_parent_uuid() {
5078 assert_eq!(
5079 unsafe {
5080 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5081 let ptr = uninit.as_ptr();
5082 ::std::ptr::addr_of!((*ptr).parent_uuid) as usize - ptr as usize
5083 },
5084 312usize,
5085 concat!(
5086 "Offset of field: ",
5087 stringify!(btrfs_ioctl_get_subvol_info_args),
5088 "::",
5089 stringify!(parent_uuid)
5090 )
5091 );
5092 }
5093 test_field_parent_uuid();
5094 fn test_field_received_uuid() {
5095 assert_eq!(
5096 unsafe {
5097 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5098 let ptr = uninit.as_ptr();
5099 ::std::ptr::addr_of!((*ptr).received_uuid) as usize - ptr as usize
5100 },
5101 328usize,
5102 concat!(
5103 "Offset of field: ",
5104 stringify!(btrfs_ioctl_get_subvol_info_args),
5105 "::",
5106 stringify!(received_uuid)
5107 )
5108 );
5109 }
5110 test_field_received_uuid();
5111 fn test_field_ctransid() {
5112 assert_eq!(
5113 unsafe {
5114 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5115 let ptr = uninit.as_ptr();
5116 ::std::ptr::addr_of!((*ptr).ctransid) as usize - ptr as usize
5117 },
5118 344usize,
5119 concat!(
5120 "Offset of field: ",
5121 stringify!(btrfs_ioctl_get_subvol_info_args),
5122 "::",
5123 stringify!(ctransid)
5124 )
5125 );
5126 }
5127 test_field_ctransid();
5128 fn test_field_otransid() {
5129 assert_eq!(
5130 unsafe {
5131 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5132 let ptr = uninit.as_ptr();
5133 ::std::ptr::addr_of!((*ptr).otransid) as usize - ptr as usize
5134 },
5135 352usize,
5136 concat!(
5137 "Offset of field: ",
5138 stringify!(btrfs_ioctl_get_subvol_info_args),
5139 "::",
5140 stringify!(otransid)
5141 )
5142 );
5143 }
5144 test_field_otransid();
5145 fn test_field_stransid() {
5146 assert_eq!(
5147 unsafe {
5148 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5149 let ptr = uninit.as_ptr();
5150 ::std::ptr::addr_of!((*ptr).stransid) as usize - ptr as usize
5151 },
5152 360usize,
5153 concat!(
5154 "Offset of field: ",
5155 stringify!(btrfs_ioctl_get_subvol_info_args),
5156 "::",
5157 stringify!(stransid)
5158 )
5159 );
5160 }
5161 test_field_stransid();
5162 fn test_field_rtransid() {
5163 assert_eq!(
5164 unsafe {
5165 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5166 let ptr = uninit.as_ptr();
5167 ::std::ptr::addr_of!((*ptr).rtransid) as usize - ptr as usize
5168 },
5169 368usize,
5170 concat!(
5171 "Offset of field: ",
5172 stringify!(btrfs_ioctl_get_subvol_info_args),
5173 "::",
5174 stringify!(rtransid)
5175 )
5176 );
5177 }
5178 test_field_rtransid();
5179 fn test_field_ctime() {
5180 assert_eq!(
5181 unsafe {
5182 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5183 let ptr = uninit.as_ptr();
5184 ::std::ptr::addr_of!((*ptr).ctime) as usize - ptr as usize
5185 },
5186 376usize,
5187 concat!(
5188 "Offset of field: ",
5189 stringify!(btrfs_ioctl_get_subvol_info_args),
5190 "::",
5191 stringify!(ctime)
5192 )
5193 );
5194 }
5195 test_field_ctime();
5196 fn test_field_otime() {
5197 assert_eq!(
5198 unsafe {
5199 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5200 let ptr = uninit.as_ptr();
5201 ::std::ptr::addr_of!((*ptr).otime) as usize - ptr as usize
5202 },
5203 392usize,
5204 concat!(
5205 "Offset of field: ",
5206 stringify!(btrfs_ioctl_get_subvol_info_args),
5207 "::",
5208 stringify!(otime)
5209 )
5210 );
5211 }
5212 test_field_otime();
5213 fn test_field_stime() {
5214 assert_eq!(
5215 unsafe {
5216 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5217 let ptr = uninit.as_ptr();
5218 ::std::ptr::addr_of!((*ptr).stime) as usize - ptr as usize
5219 },
5220 408usize,
5221 concat!(
5222 "Offset of field: ",
5223 stringify!(btrfs_ioctl_get_subvol_info_args),
5224 "::",
5225 stringify!(stime)
5226 )
5227 );
5228 }
5229 test_field_stime();
5230 fn test_field_rtime() {
5231 assert_eq!(
5232 unsafe {
5233 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5234 let ptr = uninit.as_ptr();
5235 ::std::ptr::addr_of!((*ptr).rtime) as usize - ptr as usize
5236 },
5237 424usize,
5238 concat!(
5239 "Offset of field: ",
5240 stringify!(btrfs_ioctl_get_subvol_info_args),
5241 "::",
5242 stringify!(rtime)
5243 )
5244 );
5245 }
5246 test_field_rtime();
5247 fn test_field_reserved() {
5248 assert_eq!(
5249 unsafe {
5250 let uninit = ::std::mem::MaybeUninit::<btrfs_ioctl_get_subvol_info_args>::uninit();
5251 let ptr = uninit.as_ptr();
5252 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
5253 },
5254 440usize,
5255 concat!(
5256 "Offset of field: ",
5257 stringify!(btrfs_ioctl_get_subvol_info_args),
5258 "::",
5259 stringify!(reserved)
5260 )
5261 );
5262 }
5263 test_field_reserved();
5264}
5265pub const btrfs_err_code_BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET: btrfs_err_code = 1;
5266pub const btrfs_err_code_BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET: btrfs_err_code = 2;
5267pub const btrfs_err_code_BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET: btrfs_err_code = 3;
5268pub const btrfs_err_code_BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET: btrfs_err_code = 4;
5269pub const btrfs_err_code_BTRFS_ERROR_DEV_TGT_REPLACE: btrfs_err_code = 5;
5270pub const btrfs_err_code_BTRFS_ERROR_DEV_MISSING_NOT_FOUND: btrfs_err_code = 6;
5271pub const btrfs_err_code_BTRFS_ERROR_DEV_ONLY_WRITABLE: btrfs_err_code = 7;
5272pub const btrfs_err_code_BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS: btrfs_err_code = 8;
5273pub type btrfs_err_code = ::std::os::raw::c_uint;
5274#[repr(C, packed)]
5275#[derive(Debug, Copy, Clone)]
5276pub struct btrfs_disk_key {
5277 pub objectid: __le64,
5278 pub type_: __u8,
5279 pub offset: __le64,
5280}
5281#[test]
5282fn bindgen_test_layout_btrfs_disk_key() {
5283 assert_eq!(
5284 ::std::mem::size_of::<btrfs_disk_key>(),
5285 17usize,
5286 concat!("Size of: ", stringify!(btrfs_disk_key))
5287 );
5288 assert_eq!(
5289 ::std::mem::align_of::<btrfs_disk_key>(),
5290 1usize,
5291 concat!("Alignment of ", stringify!(btrfs_disk_key))
5292 );
5293 fn test_field_objectid() {
5294 assert_eq!(
5295 unsafe {
5296 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_key>::uninit();
5297 let ptr = uninit.as_ptr();
5298 ::std::ptr::addr_of!((*ptr).objectid) as usize - ptr as usize
5299 },
5300 0usize,
5301 concat!(
5302 "Offset of field: ",
5303 stringify!(btrfs_disk_key),
5304 "::",
5305 stringify!(objectid)
5306 )
5307 );
5308 }
5309 test_field_objectid();
5310 fn test_field_type() {
5311 assert_eq!(
5312 unsafe {
5313 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_key>::uninit();
5314 let ptr = uninit.as_ptr();
5315 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
5316 },
5317 8usize,
5318 concat!(
5319 "Offset of field: ",
5320 stringify!(btrfs_disk_key),
5321 "::",
5322 stringify!(type_)
5323 )
5324 );
5325 }
5326 test_field_type();
5327 fn test_field_offset() {
5328 assert_eq!(
5329 unsafe {
5330 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_key>::uninit();
5331 let ptr = uninit.as_ptr();
5332 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
5333 },
5334 9usize,
5335 concat!(
5336 "Offset of field: ",
5337 stringify!(btrfs_disk_key),
5338 "::",
5339 stringify!(offset)
5340 )
5341 );
5342 }
5343 test_field_offset();
5344}
5345#[repr(C, packed)]
5346#[derive(Debug, Copy, Clone)]
5347pub struct btrfs_key {
5348 pub objectid: __u64,
5349 pub type_: __u8,
5350 pub offset: __u64,
5351}
5352#[test]
5353fn bindgen_test_layout_btrfs_key() {
5354 assert_eq!(
5355 ::std::mem::size_of::<btrfs_key>(),
5356 17usize,
5357 concat!("Size of: ", stringify!(btrfs_key))
5358 );
5359 assert_eq!(
5360 ::std::mem::align_of::<btrfs_key>(),
5361 1usize,
5362 concat!("Alignment of ", stringify!(btrfs_key))
5363 );
5364 fn test_field_objectid() {
5365 assert_eq!(
5366 unsafe {
5367 let uninit = ::std::mem::MaybeUninit::<btrfs_key>::uninit();
5368 let ptr = uninit.as_ptr();
5369 ::std::ptr::addr_of!((*ptr).objectid) as usize - ptr as usize
5370 },
5371 0usize,
5372 concat!(
5373 "Offset of field: ",
5374 stringify!(btrfs_key),
5375 "::",
5376 stringify!(objectid)
5377 )
5378 );
5379 }
5380 test_field_objectid();
5381 fn test_field_type() {
5382 assert_eq!(
5383 unsafe {
5384 let uninit = ::std::mem::MaybeUninit::<btrfs_key>::uninit();
5385 let ptr = uninit.as_ptr();
5386 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
5387 },
5388 8usize,
5389 concat!(
5390 "Offset of field: ",
5391 stringify!(btrfs_key),
5392 "::",
5393 stringify!(type_)
5394 )
5395 );
5396 }
5397 test_field_type();
5398 fn test_field_offset() {
5399 assert_eq!(
5400 unsafe {
5401 let uninit = ::std::mem::MaybeUninit::<btrfs_key>::uninit();
5402 let ptr = uninit.as_ptr();
5403 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
5404 },
5405 9usize,
5406 concat!(
5407 "Offset of field: ",
5408 stringify!(btrfs_key),
5409 "::",
5410 stringify!(offset)
5411 )
5412 );
5413 }
5414 test_field_offset();
5415}
5416#[repr(C, packed)]
5417#[derive(Debug, Copy, Clone)]
5418pub struct btrfs_dev_item {
5419 pub devid: __le64,
5420 pub total_bytes: __le64,
5421 pub bytes_used: __le64,
5422 pub io_align: __le32,
5423 pub io_width: __le32,
5424 pub sector_size: __le32,
5425 pub type_: __le64,
5426 pub generation: __le64,
5427 pub start_offset: __le64,
5428 pub dev_group: __le32,
5429 pub seek_speed: __u8,
5430 pub bandwidth: __u8,
5431 pub uuid: [__u8; 16usize],
5432 pub fsid: [__u8; 16usize],
5433}
5434#[test]
5435fn bindgen_test_layout_btrfs_dev_item() {
5436 assert_eq!(
5437 ::std::mem::size_of::<btrfs_dev_item>(),
5438 98usize,
5439 concat!("Size of: ", stringify!(btrfs_dev_item))
5440 );
5441 assert_eq!(
5442 ::std::mem::align_of::<btrfs_dev_item>(),
5443 1usize,
5444 concat!("Alignment of ", stringify!(btrfs_dev_item))
5445 );
5446 fn test_field_devid() {
5447 assert_eq!(
5448 unsafe {
5449 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5450 let ptr = uninit.as_ptr();
5451 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
5452 },
5453 0usize,
5454 concat!(
5455 "Offset of field: ",
5456 stringify!(btrfs_dev_item),
5457 "::",
5458 stringify!(devid)
5459 )
5460 );
5461 }
5462 test_field_devid();
5463 fn test_field_total_bytes() {
5464 assert_eq!(
5465 unsafe {
5466 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5467 let ptr = uninit.as_ptr();
5468 ::std::ptr::addr_of!((*ptr).total_bytes) as usize - ptr as usize
5469 },
5470 8usize,
5471 concat!(
5472 "Offset of field: ",
5473 stringify!(btrfs_dev_item),
5474 "::",
5475 stringify!(total_bytes)
5476 )
5477 );
5478 }
5479 test_field_total_bytes();
5480 fn test_field_bytes_used() {
5481 assert_eq!(
5482 unsafe {
5483 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5484 let ptr = uninit.as_ptr();
5485 ::std::ptr::addr_of!((*ptr).bytes_used) as usize - ptr as usize
5486 },
5487 16usize,
5488 concat!(
5489 "Offset of field: ",
5490 stringify!(btrfs_dev_item),
5491 "::",
5492 stringify!(bytes_used)
5493 )
5494 );
5495 }
5496 test_field_bytes_used();
5497 fn test_field_io_align() {
5498 assert_eq!(
5499 unsafe {
5500 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5501 let ptr = uninit.as_ptr();
5502 ::std::ptr::addr_of!((*ptr).io_align) as usize - ptr as usize
5503 },
5504 24usize,
5505 concat!(
5506 "Offset of field: ",
5507 stringify!(btrfs_dev_item),
5508 "::",
5509 stringify!(io_align)
5510 )
5511 );
5512 }
5513 test_field_io_align();
5514 fn test_field_io_width() {
5515 assert_eq!(
5516 unsafe {
5517 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5518 let ptr = uninit.as_ptr();
5519 ::std::ptr::addr_of!((*ptr).io_width) as usize - ptr as usize
5520 },
5521 28usize,
5522 concat!(
5523 "Offset of field: ",
5524 stringify!(btrfs_dev_item),
5525 "::",
5526 stringify!(io_width)
5527 )
5528 );
5529 }
5530 test_field_io_width();
5531 fn test_field_sector_size() {
5532 assert_eq!(
5533 unsafe {
5534 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5535 let ptr = uninit.as_ptr();
5536 ::std::ptr::addr_of!((*ptr).sector_size) as usize - ptr as usize
5537 },
5538 32usize,
5539 concat!(
5540 "Offset of field: ",
5541 stringify!(btrfs_dev_item),
5542 "::",
5543 stringify!(sector_size)
5544 )
5545 );
5546 }
5547 test_field_sector_size();
5548 fn test_field_type() {
5549 assert_eq!(
5550 unsafe {
5551 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5552 let ptr = uninit.as_ptr();
5553 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
5554 },
5555 36usize,
5556 concat!(
5557 "Offset of field: ",
5558 stringify!(btrfs_dev_item),
5559 "::",
5560 stringify!(type_)
5561 )
5562 );
5563 }
5564 test_field_type();
5565 fn test_field_generation() {
5566 assert_eq!(
5567 unsafe {
5568 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5569 let ptr = uninit.as_ptr();
5570 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
5571 },
5572 44usize,
5573 concat!(
5574 "Offset of field: ",
5575 stringify!(btrfs_dev_item),
5576 "::",
5577 stringify!(generation)
5578 )
5579 );
5580 }
5581 test_field_generation();
5582 fn test_field_start_offset() {
5583 assert_eq!(
5584 unsafe {
5585 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5586 let ptr = uninit.as_ptr();
5587 ::std::ptr::addr_of!((*ptr).start_offset) as usize - ptr as usize
5588 },
5589 52usize,
5590 concat!(
5591 "Offset of field: ",
5592 stringify!(btrfs_dev_item),
5593 "::",
5594 stringify!(start_offset)
5595 )
5596 );
5597 }
5598 test_field_start_offset();
5599 fn test_field_dev_group() {
5600 assert_eq!(
5601 unsafe {
5602 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5603 let ptr = uninit.as_ptr();
5604 ::std::ptr::addr_of!((*ptr).dev_group) as usize - ptr as usize
5605 },
5606 60usize,
5607 concat!(
5608 "Offset of field: ",
5609 stringify!(btrfs_dev_item),
5610 "::",
5611 stringify!(dev_group)
5612 )
5613 );
5614 }
5615 test_field_dev_group();
5616 fn test_field_seek_speed() {
5617 assert_eq!(
5618 unsafe {
5619 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5620 let ptr = uninit.as_ptr();
5621 ::std::ptr::addr_of!((*ptr).seek_speed) as usize - ptr as usize
5622 },
5623 64usize,
5624 concat!(
5625 "Offset of field: ",
5626 stringify!(btrfs_dev_item),
5627 "::",
5628 stringify!(seek_speed)
5629 )
5630 );
5631 }
5632 test_field_seek_speed();
5633 fn test_field_bandwidth() {
5634 assert_eq!(
5635 unsafe {
5636 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5637 let ptr = uninit.as_ptr();
5638 ::std::ptr::addr_of!((*ptr).bandwidth) as usize - ptr as usize
5639 },
5640 65usize,
5641 concat!(
5642 "Offset of field: ",
5643 stringify!(btrfs_dev_item),
5644 "::",
5645 stringify!(bandwidth)
5646 )
5647 );
5648 }
5649 test_field_bandwidth();
5650 fn test_field_uuid() {
5651 assert_eq!(
5652 unsafe {
5653 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5654 let ptr = uninit.as_ptr();
5655 ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize
5656 },
5657 66usize,
5658 concat!(
5659 "Offset of field: ",
5660 stringify!(btrfs_dev_item),
5661 "::",
5662 stringify!(uuid)
5663 )
5664 );
5665 }
5666 test_field_uuid();
5667 fn test_field_fsid() {
5668 assert_eq!(
5669 unsafe {
5670 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_item>::uninit();
5671 let ptr = uninit.as_ptr();
5672 ::std::ptr::addr_of!((*ptr).fsid) as usize - ptr as usize
5673 },
5674 82usize,
5675 concat!(
5676 "Offset of field: ",
5677 stringify!(btrfs_dev_item),
5678 "::",
5679 stringify!(fsid)
5680 )
5681 );
5682 }
5683 test_field_fsid();
5684}
5685#[repr(C, packed)]
5686#[derive(Debug, Copy, Clone)]
5687pub struct btrfs_stripe {
5688 pub devid: __le64,
5689 pub offset: __le64,
5690 pub dev_uuid: [__u8; 16usize],
5691}
5692#[test]
5693fn bindgen_test_layout_btrfs_stripe() {
5694 assert_eq!(
5695 ::std::mem::size_of::<btrfs_stripe>(),
5696 32usize,
5697 concat!("Size of: ", stringify!(btrfs_stripe))
5698 );
5699 assert_eq!(
5700 ::std::mem::align_of::<btrfs_stripe>(),
5701 1usize,
5702 concat!("Alignment of ", stringify!(btrfs_stripe))
5703 );
5704 fn test_field_devid() {
5705 assert_eq!(
5706 unsafe {
5707 let uninit = ::std::mem::MaybeUninit::<btrfs_stripe>::uninit();
5708 let ptr = uninit.as_ptr();
5709 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
5710 },
5711 0usize,
5712 concat!(
5713 "Offset of field: ",
5714 stringify!(btrfs_stripe),
5715 "::",
5716 stringify!(devid)
5717 )
5718 );
5719 }
5720 test_field_devid();
5721 fn test_field_offset() {
5722 assert_eq!(
5723 unsafe {
5724 let uninit = ::std::mem::MaybeUninit::<btrfs_stripe>::uninit();
5725 let ptr = uninit.as_ptr();
5726 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
5727 },
5728 8usize,
5729 concat!(
5730 "Offset of field: ",
5731 stringify!(btrfs_stripe),
5732 "::",
5733 stringify!(offset)
5734 )
5735 );
5736 }
5737 test_field_offset();
5738 fn test_field_dev_uuid() {
5739 assert_eq!(
5740 unsafe {
5741 let uninit = ::std::mem::MaybeUninit::<btrfs_stripe>::uninit();
5742 let ptr = uninit.as_ptr();
5743 ::std::ptr::addr_of!((*ptr).dev_uuid) as usize - ptr as usize
5744 },
5745 16usize,
5746 concat!(
5747 "Offset of field: ",
5748 stringify!(btrfs_stripe),
5749 "::",
5750 stringify!(dev_uuid)
5751 )
5752 );
5753 }
5754 test_field_dev_uuid();
5755}
5756#[repr(C, packed)]
5757#[derive(Debug, Copy, Clone)]
5758pub struct btrfs_chunk {
5759 pub length: __le64,
5760 pub owner: __le64,
5761 pub stripe_len: __le64,
5762 pub type_: __le64,
5763 pub io_align: __le32,
5764 pub io_width: __le32,
5765 pub sector_size: __le32,
5766 pub num_stripes: __le16,
5767 pub sub_stripes: __le16,
5768 pub stripe: btrfs_stripe,
5769}
5770#[test]
5771fn bindgen_test_layout_btrfs_chunk() {
5772 assert_eq!(
5773 ::std::mem::size_of::<btrfs_chunk>(),
5774 80usize,
5775 concat!("Size of: ", stringify!(btrfs_chunk))
5776 );
5777 assert_eq!(
5778 ::std::mem::align_of::<btrfs_chunk>(),
5779 1usize,
5780 concat!("Alignment of ", stringify!(btrfs_chunk))
5781 );
5782 fn test_field_length() {
5783 assert_eq!(
5784 unsafe {
5785 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5786 let ptr = uninit.as_ptr();
5787 ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize
5788 },
5789 0usize,
5790 concat!(
5791 "Offset of field: ",
5792 stringify!(btrfs_chunk),
5793 "::",
5794 stringify!(length)
5795 )
5796 );
5797 }
5798 test_field_length();
5799 fn test_field_owner() {
5800 assert_eq!(
5801 unsafe {
5802 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5803 let ptr = uninit.as_ptr();
5804 ::std::ptr::addr_of!((*ptr).owner) as usize - ptr as usize
5805 },
5806 8usize,
5807 concat!(
5808 "Offset of field: ",
5809 stringify!(btrfs_chunk),
5810 "::",
5811 stringify!(owner)
5812 )
5813 );
5814 }
5815 test_field_owner();
5816 fn test_field_stripe_len() {
5817 assert_eq!(
5818 unsafe {
5819 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5820 let ptr = uninit.as_ptr();
5821 ::std::ptr::addr_of!((*ptr).stripe_len) as usize - ptr as usize
5822 },
5823 16usize,
5824 concat!(
5825 "Offset of field: ",
5826 stringify!(btrfs_chunk),
5827 "::",
5828 stringify!(stripe_len)
5829 )
5830 );
5831 }
5832 test_field_stripe_len();
5833 fn test_field_type() {
5834 assert_eq!(
5835 unsafe {
5836 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5837 let ptr = uninit.as_ptr();
5838 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
5839 },
5840 24usize,
5841 concat!(
5842 "Offset of field: ",
5843 stringify!(btrfs_chunk),
5844 "::",
5845 stringify!(type_)
5846 )
5847 );
5848 }
5849 test_field_type();
5850 fn test_field_io_align() {
5851 assert_eq!(
5852 unsafe {
5853 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5854 let ptr = uninit.as_ptr();
5855 ::std::ptr::addr_of!((*ptr).io_align) as usize - ptr as usize
5856 },
5857 32usize,
5858 concat!(
5859 "Offset of field: ",
5860 stringify!(btrfs_chunk),
5861 "::",
5862 stringify!(io_align)
5863 )
5864 );
5865 }
5866 test_field_io_align();
5867 fn test_field_io_width() {
5868 assert_eq!(
5869 unsafe {
5870 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5871 let ptr = uninit.as_ptr();
5872 ::std::ptr::addr_of!((*ptr).io_width) as usize - ptr as usize
5873 },
5874 36usize,
5875 concat!(
5876 "Offset of field: ",
5877 stringify!(btrfs_chunk),
5878 "::",
5879 stringify!(io_width)
5880 )
5881 );
5882 }
5883 test_field_io_width();
5884 fn test_field_sector_size() {
5885 assert_eq!(
5886 unsafe {
5887 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5888 let ptr = uninit.as_ptr();
5889 ::std::ptr::addr_of!((*ptr).sector_size) as usize - ptr as usize
5890 },
5891 40usize,
5892 concat!(
5893 "Offset of field: ",
5894 stringify!(btrfs_chunk),
5895 "::",
5896 stringify!(sector_size)
5897 )
5898 );
5899 }
5900 test_field_sector_size();
5901 fn test_field_num_stripes() {
5902 assert_eq!(
5903 unsafe {
5904 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5905 let ptr = uninit.as_ptr();
5906 ::std::ptr::addr_of!((*ptr).num_stripes) as usize - ptr as usize
5907 },
5908 44usize,
5909 concat!(
5910 "Offset of field: ",
5911 stringify!(btrfs_chunk),
5912 "::",
5913 stringify!(num_stripes)
5914 )
5915 );
5916 }
5917 test_field_num_stripes();
5918 fn test_field_sub_stripes() {
5919 assert_eq!(
5920 unsafe {
5921 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5922 let ptr = uninit.as_ptr();
5923 ::std::ptr::addr_of!((*ptr).sub_stripes) as usize - ptr as usize
5924 },
5925 46usize,
5926 concat!(
5927 "Offset of field: ",
5928 stringify!(btrfs_chunk),
5929 "::",
5930 stringify!(sub_stripes)
5931 )
5932 );
5933 }
5934 test_field_sub_stripes();
5935 fn test_field_stripe() {
5936 assert_eq!(
5937 unsafe {
5938 let uninit = ::std::mem::MaybeUninit::<btrfs_chunk>::uninit();
5939 let ptr = uninit.as_ptr();
5940 ::std::ptr::addr_of!((*ptr).stripe) as usize - ptr as usize
5941 },
5942 48usize,
5943 concat!(
5944 "Offset of field: ",
5945 stringify!(btrfs_chunk),
5946 "::",
5947 stringify!(stripe)
5948 )
5949 );
5950 }
5951 test_field_stripe();
5952}
5953#[repr(C, packed)]
5954#[derive(Debug, Copy, Clone)]
5955pub struct btrfs_free_space_entry {
5956 pub offset: __le64,
5957 pub bytes: __le64,
5958 pub type_: __u8,
5959}
5960#[test]
5961fn bindgen_test_layout_btrfs_free_space_entry() {
5962 assert_eq!(
5963 ::std::mem::size_of::<btrfs_free_space_entry>(),
5964 17usize,
5965 concat!("Size of: ", stringify!(btrfs_free_space_entry))
5966 );
5967 assert_eq!(
5968 ::std::mem::align_of::<btrfs_free_space_entry>(),
5969 1usize,
5970 concat!("Alignment of ", stringify!(btrfs_free_space_entry))
5971 );
5972 fn test_field_offset() {
5973 assert_eq!(
5974 unsafe {
5975 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_entry>::uninit();
5976 let ptr = uninit.as_ptr();
5977 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
5978 },
5979 0usize,
5980 concat!(
5981 "Offset of field: ",
5982 stringify!(btrfs_free_space_entry),
5983 "::",
5984 stringify!(offset)
5985 )
5986 );
5987 }
5988 test_field_offset();
5989 fn test_field_bytes() {
5990 assert_eq!(
5991 unsafe {
5992 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_entry>::uninit();
5993 let ptr = uninit.as_ptr();
5994 ::std::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize
5995 },
5996 8usize,
5997 concat!(
5998 "Offset of field: ",
5999 stringify!(btrfs_free_space_entry),
6000 "::",
6001 stringify!(bytes)
6002 )
6003 );
6004 }
6005 test_field_bytes();
6006 fn test_field_type() {
6007 assert_eq!(
6008 unsafe {
6009 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_entry>::uninit();
6010 let ptr = uninit.as_ptr();
6011 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
6012 },
6013 16usize,
6014 concat!(
6015 "Offset of field: ",
6016 stringify!(btrfs_free_space_entry),
6017 "::",
6018 stringify!(type_)
6019 )
6020 );
6021 }
6022 test_field_type();
6023}
6024#[repr(C, packed)]
6025#[derive(Debug, Copy, Clone)]
6026pub struct btrfs_free_space_header {
6027 pub location: btrfs_disk_key,
6028 pub generation: __le64,
6029 pub num_entries: __le64,
6030 pub num_bitmaps: __le64,
6031}
6032#[test]
6033fn bindgen_test_layout_btrfs_free_space_header() {
6034 assert_eq!(
6035 ::std::mem::size_of::<btrfs_free_space_header>(),
6036 41usize,
6037 concat!("Size of: ", stringify!(btrfs_free_space_header))
6038 );
6039 assert_eq!(
6040 ::std::mem::align_of::<btrfs_free_space_header>(),
6041 1usize,
6042 concat!("Alignment of ", stringify!(btrfs_free_space_header))
6043 );
6044 fn test_field_location() {
6045 assert_eq!(
6046 unsafe {
6047 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_header>::uninit();
6048 let ptr = uninit.as_ptr();
6049 ::std::ptr::addr_of!((*ptr).location) as usize - ptr as usize
6050 },
6051 0usize,
6052 concat!(
6053 "Offset of field: ",
6054 stringify!(btrfs_free_space_header),
6055 "::",
6056 stringify!(location)
6057 )
6058 );
6059 }
6060 test_field_location();
6061 fn test_field_generation() {
6062 assert_eq!(
6063 unsafe {
6064 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_header>::uninit();
6065 let ptr = uninit.as_ptr();
6066 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
6067 },
6068 17usize,
6069 concat!(
6070 "Offset of field: ",
6071 stringify!(btrfs_free_space_header),
6072 "::",
6073 stringify!(generation)
6074 )
6075 );
6076 }
6077 test_field_generation();
6078 fn test_field_num_entries() {
6079 assert_eq!(
6080 unsafe {
6081 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_header>::uninit();
6082 let ptr = uninit.as_ptr();
6083 ::std::ptr::addr_of!((*ptr).num_entries) as usize - ptr as usize
6084 },
6085 25usize,
6086 concat!(
6087 "Offset of field: ",
6088 stringify!(btrfs_free_space_header),
6089 "::",
6090 stringify!(num_entries)
6091 )
6092 );
6093 }
6094 test_field_num_entries();
6095 fn test_field_num_bitmaps() {
6096 assert_eq!(
6097 unsafe {
6098 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_header>::uninit();
6099 let ptr = uninit.as_ptr();
6100 ::std::ptr::addr_of!((*ptr).num_bitmaps) as usize - ptr as usize
6101 },
6102 33usize,
6103 concat!(
6104 "Offset of field: ",
6105 stringify!(btrfs_free_space_header),
6106 "::",
6107 stringify!(num_bitmaps)
6108 )
6109 );
6110 }
6111 test_field_num_bitmaps();
6112}
6113#[repr(C, packed)]
6114#[derive(Debug, Copy, Clone)]
6115pub struct btrfs_extent_item {
6116 pub refs: __le64,
6117 pub generation: __le64,
6118 pub flags: __le64,
6119}
6120#[test]
6121fn bindgen_test_layout_btrfs_extent_item() {
6122 assert_eq!(
6123 ::std::mem::size_of::<btrfs_extent_item>(),
6124 24usize,
6125 concat!("Size of: ", stringify!(btrfs_extent_item))
6126 );
6127 assert_eq!(
6128 ::std::mem::align_of::<btrfs_extent_item>(),
6129 1usize,
6130 concat!("Alignment of ", stringify!(btrfs_extent_item))
6131 );
6132 fn test_field_refs() {
6133 assert_eq!(
6134 unsafe {
6135 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_item>::uninit();
6136 let ptr = uninit.as_ptr();
6137 ::std::ptr::addr_of!((*ptr).refs) as usize - ptr as usize
6138 },
6139 0usize,
6140 concat!(
6141 "Offset of field: ",
6142 stringify!(btrfs_extent_item),
6143 "::",
6144 stringify!(refs)
6145 )
6146 );
6147 }
6148 test_field_refs();
6149 fn test_field_generation() {
6150 assert_eq!(
6151 unsafe {
6152 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_item>::uninit();
6153 let ptr = uninit.as_ptr();
6154 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
6155 },
6156 8usize,
6157 concat!(
6158 "Offset of field: ",
6159 stringify!(btrfs_extent_item),
6160 "::",
6161 stringify!(generation)
6162 )
6163 );
6164 }
6165 test_field_generation();
6166 fn test_field_flags() {
6167 assert_eq!(
6168 unsafe {
6169 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_item>::uninit();
6170 let ptr = uninit.as_ptr();
6171 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
6172 },
6173 16usize,
6174 concat!(
6175 "Offset of field: ",
6176 stringify!(btrfs_extent_item),
6177 "::",
6178 stringify!(flags)
6179 )
6180 );
6181 }
6182 test_field_flags();
6183}
6184#[repr(C, packed)]
6185#[derive(Debug, Copy, Clone)]
6186pub struct btrfs_extent_item_v0 {
6187 pub refs: __le32,
6188}
6189#[test]
6190fn bindgen_test_layout_btrfs_extent_item_v0() {
6191 assert_eq!(
6192 ::std::mem::size_of::<btrfs_extent_item_v0>(),
6193 4usize,
6194 concat!("Size of: ", stringify!(btrfs_extent_item_v0))
6195 );
6196 assert_eq!(
6197 ::std::mem::align_of::<btrfs_extent_item_v0>(),
6198 1usize,
6199 concat!("Alignment of ", stringify!(btrfs_extent_item_v0))
6200 );
6201 fn test_field_refs() {
6202 assert_eq!(
6203 unsafe {
6204 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_item_v0>::uninit();
6205 let ptr = uninit.as_ptr();
6206 ::std::ptr::addr_of!((*ptr).refs) as usize - ptr as usize
6207 },
6208 0usize,
6209 concat!(
6210 "Offset of field: ",
6211 stringify!(btrfs_extent_item_v0),
6212 "::",
6213 stringify!(refs)
6214 )
6215 );
6216 }
6217 test_field_refs();
6218}
6219#[repr(C, packed)]
6220#[derive(Debug, Copy, Clone)]
6221pub struct btrfs_tree_block_info {
6222 pub key: btrfs_disk_key,
6223 pub level: __u8,
6224}
6225#[test]
6226fn bindgen_test_layout_btrfs_tree_block_info() {
6227 assert_eq!(
6228 ::std::mem::size_of::<btrfs_tree_block_info>(),
6229 18usize,
6230 concat!("Size of: ", stringify!(btrfs_tree_block_info))
6231 );
6232 assert_eq!(
6233 ::std::mem::align_of::<btrfs_tree_block_info>(),
6234 1usize,
6235 concat!("Alignment of ", stringify!(btrfs_tree_block_info))
6236 );
6237 fn test_field_key() {
6238 assert_eq!(
6239 unsafe {
6240 let uninit = ::std::mem::MaybeUninit::<btrfs_tree_block_info>::uninit();
6241 let ptr = uninit.as_ptr();
6242 ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize
6243 },
6244 0usize,
6245 concat!(
6246 "Offset of field: ",
6247 stringify!(btrfs_tree_block_info),
6248 "::",
6249 stringify!(key)
6250 )
6251 );
6252 }
6253 test_field_key();
6254 fn test_field_level() {
6255 assert_eq!(
6256 unsafe {
6257 let uninit = ::std::mem::MaybeUninit::<btrfs_tree_block_info>::uninit();
6258 let ptr = uninit.as_ptr();
6259 ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize
6260 },
6261 17usize,
6262 concat!(
6263 "Offset of field: ",
6264 stringify!(btrfs_tree_block_info),
6265 "::",
6266 stringify!(level)
6267 )
6268 );
6269 }
6270 test_field_level();
6271}
6272#[repr(C, packed)]
6273#[derive(Debug, Copy, Clone)]
6274pub struct btrfs_extent_data_ref {
6275 pub root: __le64,
6276 pub objectid: __le64,
6277 pub offset: __le64,
6278 pub count: __le32,
6279}
6280#[test]
6281fn bindgen_test_layout_btrfs_extent_data_ref() {
6282 assert_eq!(
6283 ::std::mem::size_of::<btrfs_extent_data_ref>(),
6284 28usize,
6285 concat!("Size of: ", stringify!(btrfs_extent_data_ref))
6286 );
6287 assert_eq!(
6288 ::std::mem::align_of::<btrfs_extent_data_ref>(),
6289 1usize,
6290 concat!("Alignment of ", stringify!(btrfs_extent_data_ref))
6291 );
6292 fn test_field_root() {
6293 assert_eq!(
6294 unsafe {
6295 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_data_ref>::uninit();
6296 let ptr = uninit.as_ptr();
6297 ::std::ptr::addr_of!((*ptr).root) as usize - ptr as usize
6298 },
6299 0usize,
6300 concat!(
6301 "Offset of field: ",
6302 stringify!(btrfs_extent_data_ref),
6303 "::",
6304 stringify!(root)
6305 )
6306 );
6307 }
6308 test_field_root();
6309 fn test_field_objectid() {
6310 assert_eq!(
6311 unsafe {
6312 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_data_ref>::uninit();
6313 let ptr = uninit.as_ptr();
6314 ::std::ptr::addr_of!((*ptr).objectid) as usize - ptr as usize
6315 },
6316 8usize,
6317 concat!(
6318 "Offset of field: ",
6319 stringify!(btrfs_extent_data_ref),
6320 "::",
6321 stringify!(objectid)
6322 )
6323 );
6324 }
6325 test_field_objectid();
6326 fn test_field_offset() {
6327 assert_eq!(
6328 unsafe {
6329 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_data_ref>::uninit();
6330 let ptr = uninit.as_ptr();
6331 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
6332 },
6333 16usize,
6334 concat!(
6335 "Offset of field: ",
6336 stringify!(btrfs_extent_data_ref),
6337 "::",
6338 stringify!(offset)
6339 )
6340 );
6341 }
6342 test_field_offset();
6343 fn test_field_count() {
6344 assert_eq!(
6345 unsafe {
6346 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_data_ref>::uninit();
6347 let ptr = uninit.as_ptr();
6348 ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
6349 },
6350 24usize,
6351 concat!(
6352 "Offset of field: ",
6353 stringify!(btrfs_extent_data_ref),
6354 "::",
6355 stringify!(count)
6356 )
6357 );
6358 }
6359 test_field_count();
6360}
6361#[repr(C, packed)]
6362#[derive(Debug, Copy, Clone)]
6363pub struct btrfs_shared_data_ref {
6364 pub count: __le32,
6365}
6366#[test]
6367fn bindgen_test_layout_btrfs_shared_data_ref() {
6368 assert_eq!(
6369 ::std::mem::size_of::<btrfs_shared_data_ref>(),
6370 4usize,
6371 concat!("Size of: ", stringify!(btrfs_shared_data_ref))
6372 );
6373 assert_eq!(
6374 ::std::mem::align_of::<btrfs_shared_data_ref>(),
6375 1usize,
6376 concat!("Alignment of ", stringify!(btrfs_shared_data_ref))
6377 );
6378 fn test_field_count() {
6379 assert_eq!(
6380 unsafe {
6381 let uninit = ::std::mem::MaybeUninit::<btrfs_shared_data_ref>::uninit();
6382 let ptr = uninit.as_ptr();
6383 ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
6384 },
6385 0usize,
6386 concat!(
6387 "Offset of field: ",
6388 stringify!(btrfs_shared_data_ref),
6389 "::",
6390 stringify!(count)
6391 )
6392 );
6393 }
6394 test_field_count();
6395}
6396#[repr(C, packed)]
6397#[derive(Debug, Copy, Clone)]
6398pub struct btrfs_extent_inline_ref {
6399 pub type_: __u8,
6400 pub offset: __le64,
6401}
6402#[test]
6403fn bindgen_test_layout_btrfs_extent_inline_ref() {
6404 assert_eq!(
6405 ::std::mem::size_of::<btrfs_extent_inline_ref>(),
6406 9usize,
6407 concat!("Size of: ", stringify!(btrfs_extent_inline_ref))
6408 );
6409 assert_eq!(
6410 ::std::mem::align_of::<btrfs_extent_inline_ref>(),
6411 1usize,
6412 concat!("Alignment of ", stringify!(btrfs_extent_inline_ref))
6413 );
6414 fn test_field_type() {
6415 assert_eq!(
6416 unsafe {
6417 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_inline_ref>::uninit();
6418 let ptr = uninit.as_ptr();
6419 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
6420 },
6421 0usize,
6422 concat!(
6423 "Offset of field: ",
6424 stringify!(btrfs_extent_inline_ref),
6425 "::",
6426 stringify!(type_)
6427 )
6428 );
6429 }
6430 test_field_type();
6431 fn test_field_offset() {
6432 assert_eq!(
6433 unsafe {
6434 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_inline_ref>::uninit();
6435 let ptr = uninit.as_ptr();
6436 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
6437 },
6438 1usize,
6439 concat!(
6440 "Offset of field: ",
6441 stringify!(btrfs_extent_inline_ref),
6442 "::",
6443 stringify!(offset)
6444 )
6445 );
6446 }
6447 test_field_offset();
6448}
6449#[repr(C, packed)]
6450#[derive(Debug, Copy, Clone)]
6451pub struct btrfs_extent_ref_v0 {
6452 pub root: __le64,
6453 pub generation: __le64,
6454 pub objectid: __le64,
6455 pub count: __le32,
6456}
6457#[test]
6458fn bindgen_test_layout_btrfs_extent_ref_v0() {
6459 assert_eq!(
6460 ::std::mem::size_of::<btrfs_extent_ref_v0>(),
6461 28usize,
6462 concat!("Size of: ", stringify!(btrfs_extent_ref_v0))
6463 );
6464 assert_eq!(
6465 ::std::mem::align_of::<btrfs_extent_ref_v0>(),
6466 1usize,
6467 concat!("Alignment of ", stringify!(btrfs_extent_ref_v0))
6468 );
6469 fn test_field_root() {
6470 assert_eq!(
6471 unsafe {
6472 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_ref_v0>::uninit();
6473 let ptr = uninit.as_ptr();
6474 ::std::ptr::addr_of!((*ptr).root) as usize - ptr as usize
6475 },
6476 0usize,
6477 concat!(
6478 "Offset of field: ",
6479 stringify!(btrfs_extent_ref_v0),
6480 "::",
6481 stringify!(root)
6482 )
6483 );
6484 }
6485 test_field_root();
6486 fn test_field_generation() {
6487 assert_eq!(
6488 unsafe {
6489 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_ref_v0>::uninit();
6490 let ptr = uninit.as_ptr();
6491 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
6492 },
6493 8usize,
6494 concat!(
6495 "Offset of field: ",
6496 stringify!(btrfs_extent_ref_v0),
6497 "::",
6498 stringify!(generation)
6499 )
6500 );
6501 }
6502 test_field_generation();
6503 fn test_field_objectid() {
6504 assert_eq!(
6505 unsafe {
6506 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_ref_v0>::uninit();
6507 let ptr = uninit.as_ptr();
6508 ::std::ptr::addr_of!((*ptr).objectid) as usize - ptr as usize
6509 },
6510 16usize,
6511 concat!(
6512 "Offset of field: ",
6513 stringify!(btrfs_extent_ref_v0),
6514 "::",
6515 stringify!(objectid)
6516 )
6517 );
6518 }
6519 test_field_objectid();
6520 fn test_field_count() {
6521 assert_eq!(
6522 unsafe {
6523 let uninit = ::std::mem::MaybeUninit::<btrfs_extent_ref_v0>::uninit();
6524 let ptr = uninit.as_ptr();
6525 ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
6526 },
6527 24usize,
6528 concat!(
6529 "Offset of field: ",
6530 stringify!(btrfs_extent_ref_v0),
6531 "::",
6532 stringify!(count)
6533 )
6534 );
6535 }
6536 test_field_count();
6537}
6538#[repr(C, packed)]
6539#[derive(Debug, Copy, Clone)]
6540pub struct btrfs_dev_extent {
6541 pub chunk_tree: __le64,
6542 pub chunk_objectid: __le64,
6543 pub chunk_offset: __le64,
6544 pub length: __le64,
6545 pub chunk_tree_uuid: [__u8; 16usize],
6546}
6547#[test]
6548fn bindgen_test_layout_btrfs_dev_extent() {
6549 assert_eq!(
6550 ::std::mem::size_of::<btrfs_dev_extent>(),
6551 48usize,
6552 concat!("Size of: ", stringify!(btrfs_dev_extent))
6553 );
6554 assert_eq!(
6555 ::std::mem::align_of::<btrfs_dev_extent>(),
6556 1usize,
6557 concat!("Alignment of ", stringify!(btrfs_dev_extent))
6558 );
6559 fn test_field_chunk_tree() {
6560 assert_eq!(
6561 unsafe {
6562 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_extent>::uninit();
6563 let ptr = uninit.as_ptr();
6564 ::std::ptr::addr_of!((*ptr).chunk_tree) as usize - ptr as usize
6565 },
6566 0usize,
6567 concat!(
6568 "Offset of field: ",
6569 stringify!(btrfs_dev_extent),
6570 "::",
6571 stringify!(chunk_tree)
6572 )
6573 );
6574 }
6575 test_field_chunk_tree();
6576 fn test_field_chunk_objectid() {
6577 assert_eq!(
6578 unsafe {
6579 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_extent>::uninit();
6580 let ptr = uninit.as_ptr();
6581 ::std::ptr::addr_of!((*ptr).chunk_objectid) as usize - ptr as usize
6582 },
6583 8usize,
6584 concat!(
6585 "Offset of field: ",
6586 stringify!(btrfs_dev_extent),
6587 "::",
6588 stringify!(chunk_objectid)
6589 )
6590 );
6591 }
6592 test_field_chunk_objectid();
6593 fn test_field_chunk_offset() {
6594 assert_eq!(
6595 unsafe {
6596 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_extent>::uninit();
6597 let ptr = uninit.as_ptr();
6598 ::std::ptr::addr_of!((*ptr).chunk_offset) as usize - ptr as usize
6599 },
6600 16usize,
6601 concat!(
6602 "Offset of field: ",
6603 stringify!(btrfs_dev_extent),
6604 "::",
6605 stringify!(chunk_offset)
6606 )
6607 );
6608 }
6609 test_field_chunk_offset();
6610 fn test_field_length() {
6611 assert_eq!(
6612 unsafe {
6613 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_extent>::uninit();
6614 let ptr = uninit.as_ptr();
6615 ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize
6616 },
6617 24usize,
6618 concat!(
6619 "Offset of field: ",
6620 stringify!(btrfs_dev_extent),
6621 "::",
6622 stringify!(length)
6623 )
6624 );
6625 }
6626 test_field_length();
6627 fn test_field_chunk_tree_uuid() {
6628 assert_eq!(
6629 unsafe {
6630 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_extent>::uninit();
6631 let ptr = uninit.as_ptr();
6632 ::std::ptr::addr_of!((*ptr).chunk_tree_uuid) as usize - ptr as usize
6633 },
6634 32usize,
6635 concat!(
6636 "Offset of field: ",
6637 stringify!(btrfs_dev_extent),
6638 "::",
6639 stringify!(chunk_tree_uuid)
6640 )
6641 );
6642 }
6643 test_field_chunk_tree_uuid();
6644}
6645#[repr(C, packed)]
6646#[derive(Debug, Copy, Clone)]
6647pub struct btrfs_inode_ref {
6648 pub index: __le64,
6649 pub name_len: __le16,
6650}
6651#[test]
6652fn bindgen_test_layout_btrfs_inode_ref() {
6653 assert_eq!(
6654 ::std::mem::size_of::<btrfs_inode_ref>(),
6655 10usize,
6656 concat!("Size of: ", stringify!(btrfs_inode_ref))
6657 );
6658 assert_eq!(
6659 ::std::mem::align_of::<btrfs_inode_ref>(),
6660 1usize,
6661 concat!("Alignment of ", stringify!(btrfs_inode_ref))
6662 );
6663 fn test_field_index() {
6664 assert_eq!(
6665 unsafe {
6666 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_ref>::uninit();
6667 let ptr = uninit.as_ptr();
6668 ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize
6669 },
6670 0usize,
6671 concat!(
6672 "Offset of field: ",
6673 stringify!(btrfs_inode_ref),
6674 "::",
6675 stringify!(index)
6676 )
6677 );
6678 }
6679 test_field_index();
6680 fn test_field_name_len() {
6681 assert_eq!(
6682 unsafe {
6683 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_ref>::uninit();
6684 let ptr = uninit.as_ptr();
6685 ::std::ptr::addr_of!((*ptr).name_len) as usize - ptr as usize
6686 },
6687 8usize,
6688 concat!(
6689 "Offset of field: ",
6690 stringify!(btrfs_inode_ref),
6691 "::",
6692 stringify!(name_len)
6693 )
6694 );
6695 }
6696 test_field_name_len();
6697}
6698#[repr(C, packed)]
6699pub struct btrfs_inode_extref {
6700 pub parent_objectid: __le64,
6701 pub index: __le64,
6702 pub name_len: __le16,
6703 pub name: __IncompleteArrayField<__u8>,
6704}
6705#[test]
6706fn bindgen_test_layout_btrfs_inode_extref() {
6707 assert_eq!(
6708 ::std::mem::size_of::<btrfs_inode_extref>(),
6709 18usize,
6710 concat!("Size of: ", stringify!(btrfs_inode_extref))
6711 );
6712 assert_eq!(
6713 ::std::mem::align_of::<btrfs_inode_extref>(),
6714 1usize,
6715 concat!("Alignment of ", stringify!(btrfs_inode_extref))
6716 );
6717 fn test_field_parent_objectid() {
6718 assert_eq!(
6719 unsafe {
6720 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_extref>::uninit();
6721 let ptr = uninit.as_ptr();
6722 ::std::ptr::addr_of!((*ptr).parent_objectid) as usize - ptr as usize
6723 },
6724 0usize,
6725 concat!(
6726 "Offset of field: ",
6727 stringify!(btrfs_inode_extref),
6728 "::",
6729 stringify!(parent_objectid)
6730 )
6731 );
6732 }
6733 test_field_parent_objectid();
6734 fn test_field_index() {
6735 assert_eq!(
6736 unsafe {
6737 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_extref>::uninit();
6738 let ptr = uninit.as_ptr();
6739 ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize
6740 },
6741 8usize,
6742 concat!(
6743 "Offset of field: ",
6744 stringify!(btrfs_inode_extref),
6745 "::",
6746 stringify!(index)
6747 )
6748 );
6749 }
6750 test_field_index();
6751 fn test_field_name_len() {
6752 assert_eq!(
6753 unsafe {
6754 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_extref>::uninit();
6755 let ptr = uninit.as_ptr();
6756 ::std::ptr::addr_of!((*ptr).name_len) as usize - ptr as usize
6757 },
6758 16usize,
6759 concat!(
6760 "Offset of field: ",
6761 stringify!(btrfs_inode_extref),
6762 "::",
6763 stringify!(name_len)
6764 )
6765 );
6766 }
6767 test_field_name_len();
6768 fn test_field_name() {
6769 assert_eq!(
6770 unsafe {
6771 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_extref>::uninit();
6772 let ptr = uninit.as_ptr();
6773 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
6774 },
6775 18usize,
6776 concat!(
6777 "Offset of field: ",
6778 stringify!(btrfs_inode_extref),
6779 "::",
6780 stringify!(name)
6781 )
6782 );
6783 }
6784 test_field_name();
6785}
6786#[repr(C, packed)]
6787#[derive(Debug, Copy, Clone)]
6788pub struct btrfs_timespec {
6789 pub sec: __le64,
6790 pub nsec: __le32,
6791}
6792#[test]
6793fn bindgen_test_layout_btrfs_timespec() {
6794 assert_eq!(
6795 ::std::mem::size_of::<btrfs_timespec>(),
6796 12usize,
6797 concat!("Size of: ", stringify!(btrfs_timespec))
6798 );
6799 assert_eq!(
6800 ::std::mem::align_of::<btrfs_timespec>(),
6801 1usize,
6802 concat!("Alignment of ", stringify!(btrfs_timespec))
6803 );
6804 fn test_field_sec() {
6805 assert_eq!(
6806 unsafe {
6807 let uninit = ::std::mem::MaybeUninit::<btrfs_timespec>::uninit();
6808 let ptr = uninit.as_ptr();
6809 ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize
6810 },
6811 0usize,
6812 concat!(
6813 "Offset of field: ",
6814 stringify!(btrfs_timespec),
6815 "::",
6816 stringify!(sec)
6817 )
6818 );
6819 }
6820 test_field_sec();
6821 fn test_field_nsec() {
6822 assert_eq!(
6823 unsafe {
6824 let uninit = ::std::mem::MaybeUninit::<btrfs_timespec>::uninit();
6825 let ptr = uninit.as_ptr();
6826 ::std::ptr::addr_of!((*ptr).nsec) as usize - ptr as usize
6827 },
6828 8usize,
6829 concat!(
6830 "Offset of field: ",
6831 stringify!(btrfs_timespec),
6832 "::",
6833 stringify!(nsec)
6834 )
6835 );
6836 }
6837 test_field_nsec();
6838}
6839#[repr(C, packed)]
6840#[derive(Debug, Copy, Clone)]
6841pub struct btrfs_inode_item {
6842 pub generation: __le64,
6843 pub transid: __le64,
6844 pub size: __le64,
6845 pub nbytes: __le64,
6846 pub block_group: __le64,
6847 pub nlink: __le32,
6848 pub uid: __le32,
6849 pub gid: __le32,
6850 pub mode: __le32,
6851 pub rdev: __le64,
6852 pub flags: __le64,
6853 pub sequence: __le64,
6854 pub reserved: [__le64; 4usize],
6855 pub atime: btrfs_timespec,
6856 pub ctime: btrfs_timespec,
6857 pub mtime: btrfs_timespec,
6858 pub otime: btrfs_timespec,
6859}
6860#[test]
6861fn bindgen_test_layout_btrfs_inode_item() {
6862 assert_eq!(
6863 ::std::mem::size_of::<btrfs_inode_item>(),
6864 160usize,
6865 concat!("Size of: ", stringify!(btrfs_inode_item))
6866 );
6867 assert_eq!(
6868 ::std::mem::align_of::<btrfs_inode_item>(),
6869 1usize,
6870 concat!("Alignment of ", stringify!(btrfs_inode_item))
6871 );
6872 fn test_field_generation() {
6873 assert_eq!(
6874 unsafe {
6875 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6876 let ptr = uninit.as_ptr();
6877 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
6878 },
6879 0usize,
6880 concat!(
6881 "Offset of field: ",
6882 stringify!(btrfs_inode_item),
6883 "::",
6884 stringify!(generation)
6885 )
6886 );
6887 }
6888 test_field_generation();
6889 fn test_field_transid() {
6890 assert_eq!(
6891 unsafe {
6892 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6893 let ptr = uninit.as_ptr();
6894 ::std::ptr::addr_of!((*ptr).transid) as usize - ptr as usize
6895 },
6896 8usize,
6897 concat!(
6898 "Offset of field: ",
6899 stringify!(btrfs_inode_item),
6900 "::",
6901 stringify!(transid)
6902 )
6903 );
6904 }
6905 test_field_transid();
6906 fn test_field_size() {
6907 assert_eq!(
6908 unsafe {
6909 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6910 let ptr = uninit.as_ptr();
6911 ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
6912 },
6913 16usize,
6914 concat!(
6915 "Offset of field: ",
6916 stringify!(btrfs_inode_item),
6917 "::",
6918 stringify!(size)
6919 )
6920 );
6921 }
6922 test_field_size();
6923 fn test_field_nbytes() {
6924 assert_eq!(
6925 unsafe {
6926 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6927 let ptr = uninit.as_ptr();
6928 ::std::ptr::addr_of!((*ptr).nbytes) as usize - ptr as usize
6929 },
6930 24usize,
6931 concat!(
6932 "Offset of field: ",
6933 stringify!(btrfs_inode_item),
6934 "::",
6935 stringify!(nbytes)
6936 )
6937 );
6938 }
6939 test_field_nbytes();
6940 fn test_field_block_group() {
6941 assert_eq!(
6942 unsafe {
6943 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6944 let ptr = uninit.as_ptr();
6945 ::std::ptr::addr_of!((*ptr).block_group) as usize - ptr as usize
6946 },
6947 32usize,
6948 concat!(
6949 "Offset of field: ",
6950 stringify!(btrfs_inode_item),
6951 "::",
6952 stringify!(block_group)
6953 )
6954 );
6955 }
6956 test_field_block_group();
6957 fn test_field_nlink() {
6958 assert_eq!(
6959 unsafe {
6960 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6961 let ptr = uninit.as_ptr();
6962 ::std::ptr::addr_of!((*ptr).nlink) as usize - ptr as usize
6963 },
6964 40usize,
6965 concat!(
6966 "Offset of field: ",
6967 stringify!(btrfs_inode_item),
6968 "::",
6969 stringify!(nlink)
6970 )
6971 );
6972 }
6973 test_field_nlink();
6974 fn test_field_uid() {
6975 assert_eq!(
6976 unsafe {
6977 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6978 let ptr = uninit.as_ptr();
6979 ::std::ptr::addr_of!((*ptr).uid) as usize - ptr as usize
6980 },
6981 44usize,
6982 concat!(
6983 "Offset of field: ",
6984 stringify!(btrfs_inode_item),
6985 "::",
6986 stringify!(uid)
6987 )
6988 );
6989 }
6990 test_field_uid();
6991 fn test_field_gid() {
6992 assert_eq!(
6993 unsafe {
6994 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
6995 let ptr = uninit.as_ptr();
6996 ::std::ptr::addr_of!((*ptr).gid) as usize - ptr as usize
6997 },
6998 48usize,
6999 concat!(
7000 "Offset of field: ",
7001 stringify!(btrfs_inode_item),
7002 "::",
7003 stringify!(gid)
7004 )
7005 );
7006 }
7007 test_field_gid();
7008 fn test_field_mode() {
7009 assert_eq!(
7010 unsafe {
7011 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7012 let ptr = uninit.as_ptr();
7013 ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize
7014 },
7015 52usize,
7016 concat!(
7017 "Offset of field: ",
7018 stringify!(btrfs_inode_item),
7019 "::",
7020 stringify!(mode)
7021 )
7022 );
7023 }
7024 test_field_mode();
7025 fn test_field_rdev() {
7026 assert_eq!(
7027 unsafe {
7028 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7029 let ptr = uninit.as_ptr();
7030 ::std::ptr::addr_of!((*ptr).rdev) as usize - ptr as usize
7031 },
7032 56usize,
7033 concat!(
7034 "Offset of field: ",
7035 stringify!(btrfs_inode_item),
7036 "::",
7037 stringify!(rdev)
7038 )
7039 );
7040 }
7041 test_field_rdev();
7042 fn test_field_flags() {
7043 assert_eq!(
7044 unsafe {
7045 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7046 let ptr = uninit.as_ptr();
7047 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
7048 },
7049 64usize,
7050 concat!(
7051 "Offset of field: ",
7052 stringify!(btrfs_inode_item),
7053 "::",
7054 stringify!(flags)
7055 )
7056 );
7057 }
7058 test_field_flags();
7059 fn test_field_sequence() {
7060 assert_eq!(
7061 unsafe {
7062 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7063 let ptr = uninit.as_ptr();
7064 ::std::ptr::addr_of!((*ptr).sequence) as usize - ptr as usize
7065 },
7066 72usize,
7067 concat!(
7068 "Offset of field: ",
7069 stringify!(btrfs_inode_item),
7070 "::",
7071 stringify!(sequence)
7072 )
7073 );
7074 }
7075 test_field_sequence();
7076 fn test_field_reserved() {
7077 assert_eq!(
7078 unsafe {
7079 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7080 let ptr = uninit.as_ptr();
7081 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
7082 },
7083 80usize,
7084 concat!(
7085 "Offset of field: ",
7086 stringify!(btrfs_inode_item),
7087 "::",
7088 stringify!(reserved)
7089 )
7090 );
7091 }
7092 test_field_reserved();
7093 fn test_field_atime() {
7094 assert_eq!(
7095 unsafe {
7096 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7097 let ptr = uninit.as_ptr();
7098 ::std::ptr::addr_of!((*ptr).atime) as usize - ptr as usize
7099 },
7100 112usize,
7101 concat!(
7102 "Offset of field: ",
7103 stringify!(btrfs_inode_item),
7104 "::",
7105 stringify!(atime)
7106 )
7107 );
7108 }
7109 test_field_atime();
7110 fn test_field_ctime() {
7111 assert_eq!(
7112 unsafe {
7113 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7114 let ptr = uninit.as_ptr();
7115 ::std::ptr::addr_of!((*ptr).ctime) as usize - ptr as usize
7116 },
7117 124usize,
7118 concat!(
7119 "Offset of field: ",
7120 stringify!(btrfs_inode_item),
7121 "::",
7122 stringify!(ctime)
7123 )
7124 );
7125 }
7126 test_field_ctime();
7127 fn test_field_mtime() {
7128 assert_eq!(
7129 unsafe {
7130 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7131 let ptr = uninit.as_ptr();
7132 ::std::ptr::addr_of!((*ptr).mtime) as usize - ptr as usize
7133 },
7134 136usize,
7135 concat!(
7136 "Offset of field: ",
7137 stringify!(btrfs_inode_item),
7138 "::",
7139 stringify!(mtime)
7140 )
7141 );
7142 }
7143 test_field_mtime();
7144 fn test_field_otime() {
7145 assert_eq!(
7146 unsafe {
7147 let uninit = ::std::mem::MaybeUninit::<btrfs_inode_item>::uninit();
7148 let ptr = uninit.as_ptr();
7149 ::std::ptr::addr_of!((*ptr).otime) as usize - ptr as usize
7150 },
7151 148usize,
7152 concat!(
7153 "Offset of field: ",
7154 stringify!(btrfs_inode_item),
7155 "::",
7156 stringify!(otime)
7157 )
7158 );
7159 }
7160 test_field_otime();
7161}
7162#[repr(C, packed)]
7163#[derive(Debug, Copy, Clone)]
7164pub struct btrfs_dir_log_item {
7165 pub end: __le64,
7166}
7167#[test]
7168fn bindgen_test_layout_btrfs_dir_log_item() {
7169 assert_eq!(
7170 ::std::mem::size_of::<btrfs_dir_log_item>(),
7171 8usize,
7172 concat!("Size of: ", stringify!(btrfs_dir_log_item))
7173 );
7174 assert_eq!(
7175 ::std::mem::align_of::<btrfs_dir_log_item>(),
7176 1usize,
7177 concat!("Alignment of ", stringify!(btrfs_dir_log_item))
7178 );
7179 fn test_field_end() {
7180 assert_eq!(
7181 unsafe {
7182 let uninit = ::std::mem::MaybeUninit::<btrfs_dir_log_item>::uninit();
7183 let ptr = uninit.as_ptr();
7184 ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize
7185 },
7186 0usize,
7187 concat!(
7188 "Offset of field: ",
7189 stringify!(btrfs_dir_log_item),
7190 "::",
7191 stringify!(end)
7192 )
7193 );
7194 }
7195 test_field_end();
7196}
7197#[repr(C, packed)]
7198#[derive(Debug, Copy, Clone)]
7199pub struct btrfs_dir_item {
7200 pub location: btrfs_disk_key,
7201 pub transid: __le64,
7202 pub data_len: __le16,
7203 pub name_len: __le16,
7204 pub type_: __u8,
7205}
7206#[test]
7207fn bindgen_test_layout_btrfs_dir_item() {
7208 assert_eq!(
7209 ::std::mem::size_of::<btrfs_dir_item>(),
7210 30usize,
7211 concat!("Size of: ", stringify!(btrfs_dir_item))
7212 );
7213 assert_eq!(
7214 ::std::mem::align_of::<btrfs_dir_item>(),
7215 1usize,
7216 concat!("Alignment of ", stringify!(btrfs_dir_item))
7217 );
7218 fn test_field_location() {
7219 assert_eq!(
7220 unsafe {
7221 let uninit = ::std::mem::MaybeUninit::<btrfs_dir_item>::uninit();
7222 let ptr = uninit.as_ptr();
7223 ::std::ptr::addr_of!((*ptr).location) as usize - ptr as usize
7224 },
7225 0usize,
7226 concat!(
7227 "Offset of field: ",
7228 stringify!(btrfs_dir_item),
7229 "::",
7230 stringify!(location)
7231 )
7232 );
7233 }
7234 test_field_location();
7235 fn test_field_transid() {
7236 assert_eq!(
7237 unsafe {
7238 let uninit = ::std::mem::MaybeUninit::<btrfs_dir_item>::uninit();
7239 let ptr = uninit.as_ptr();
7240 ::std::ptr::addr_of!((*ptr).transid) as usize - ptr as usize
7241 },
7242 17usize,
7243 concat!(
7244 "Offset of field: ",
7245 stringify!(btrfs_dir_item),
7246 "::",
7247 stringify!(transid)
7248 )
7249 );
7250 }
7251 test_field_transid();
7252 fn test_field_data_len() {
7253 assert_eq!(
7254 unsafe {
7255 let uninit = ::std::mem::MaybeUninit::<btrfs_dir_item>::uninit();
7256 let ptr = uninit.as_ptr();
7257 ::std::ptr::addr_of!((*ptr).data_len) as usize - ptr as usize
7258 },
7259 25usize,
7260 concat!(
7261 "Offset of field: ",
7262 stringify!(btrfs_dir_item),
7263 "::",
7264 stringify!(data_len)
7265 )
7266 );
7267 }
7268 test_field_data_len();
7269 fn test_field_name_len() {
7270 assert_eq!(
7271 unsafe {
7272 let uninit = ::std::mem::MaybeUninit::<btrfs_dir_item>::uninit();
7273 let ptr = uninit.as_ptr();
7274 ::std::ptr::addr_of!((*ptr).name_len) as usize - ptr as usize
7275 },
7276 27usize,
7277 concat!(
7278 "Offset of field: ",
7279 stringify!(btrfs_dir_item),
7280 "::",
7281 stringify!(name_len)
7282 )
7283 );
7284 }
7285 test_field_name_len();
7286 fn test_field_type() {
7287 assert_eq!(
7288 unsafe {
7289 let uninit = ::std::mem::MaybeUninit::<btrfs_dir_item>::uninit();
7290 let ptr = uninit.as_ptr();
7291 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
7292 },
7293 29usize,
7294 concat!(
7295 "Offset of field: ",
7296 stringify!(btrfs_dir_item),
7297 "::",
7298 stringify!(type_)
7299 )
7300 );
7301 }
7302 test_field_type();
7303}
7304#[repr(C, packed)]
7305#[derive(Debug, Copy, Clone)]
7306pub struct btrfs_root_item {
7307 pub inode: btrfs_inode_item,
7308 pub generation: __le64,
7309 pub root_dirid: __le64,
7310 pub bytenr: __le64,
7311 pub byte_limit: __le64,
7312 pub bytes_used: __le64,
7313 pub last_snapshot: __le64,
7314 pub flags: __le64,
7315 pub refs: __le32,
7316 pub drop_progress: btrfs_disk_key,
7317 pub drop_level: __u8,
7318 pub level: __u8,
7319 pub generation_v2: __le64,
7320 pub uuid: [__u8; 16usize],
7321 pub parent_uuid: [__u8; 16usize],
7322 pub received_uuid: [__u8; 16usize],
7323 pub ctransid: __le64,
7324 pub otransid: __le64,
7325 pub stransid: __le64,
7326 pub rtransid: __le64,
7327 pub ctime: btrfs_timespec,
7328 pub otime: btrfs_timespec,
7329 pub stime: btrfs_timespec,
7330 pub rtime: btrfs_timespec,
7331 pub reserved: [__le64; 8usize],
7332}
7333#[test]
7334fn bindgen_test_layout_btrfs_root_item() {
7335 assert_eq!(
7336 ::std::mem::size_of::<btrfs_root_item>(),
7337 439usize,
7338 concat!("Size of: ", stringify!(btrfs_root_item))
7339 );
7340 assert_eq!(
7341 ::std::mem::align_of::<btrfs_root_item>(),
7342 1usize,
7343 concat!("Alignment of ", stringify!(btrfs_root_item))
7344 );
7345 fn test_field_inode() {
7346 assert_eq!(
7347 unsafe {
7348 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7349 let ptr = uninit.as_ptr();
7350 ::std::ptr::addr_of!((*ptr).inode) as usize - ptr as usize
7351 },
7352 0usize,
7353 concat!(
7354 "Offset of field: ",
7355 stringify!(btrfs_root_item),
7356 "::",
7357 stringify!(inode)
7358 )
7359 );
7360 }
7361 test_field_inode();
7362 fn test_field_generation() {
7363 assert_eq!(
7364 unsafe {
7365 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7366 let ptr = uninit.as_ptr();
7367 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
7368 },
7369 160usize,
7370 concat!(
7371 "Offset of field: ",
7372 stringify!(btrfs_root_item),
7373 "::",
7374 stringify!(generation)
7375 )
7376 );
7377 }
7378 test_field_generation();
7379 fn test_field_root_dirid() {
7380 assert_eq!(
7381 unsafe {
7382 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7383 let ptr = uninit.as_ptr();
7384 ::std::ptr::addr_of!((*ptr).root_dirid) as usize - ptr as usize
7385 },
7386 168usize,
7387 concat!(
7388 "Offset of field: ",
7389 stringify!(btrfs_root_item),
7390 "::",
7391 stringify!(root_dirid)
7392 )
7393 );
7394 }
7395 test_field_root_dirid();
7396 fn test_field_bytenr() {
7397 assert_eq!(
7398 unsafe {
7399 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7400 let ptr = uninit.as_ptr();
7401 ::std::ptr::addr_of!((*ptr).bytenr) as usize - ptr as usize
7402 },
7403 176usize,
7404 concat!(
7405 "Offset of field: ",
7406 stringify!(btrfs_root_item),
7407 "::",
7408 stringify!(bytenr)
7409 )
7410 );
7411 }
7412 test_field_bytenr();
7413 fn test_field_byte_limit() {
7414 assert_eq!(
7415 unsafe {
7416 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7417 let ptr = uninit.as_ptr();
7418 ::std::ptr::addr_of!((*ptr).byte_limit) as usize - ptr as usize
7419 },
7420 184usize,
7421 concat!(
7422 "Offset of field: ",
7423 stringify!(btrfs_root_item),
7424 "::",
7425 stringify!(byte_limit)
7426 )
7427 );
7428 }
7429 test_field_byte_limit();
7430 fn test_field_bytes_used() {
7431 assert_eq!(
7432 unsafe {
7433 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7434 let ptr = uninit.as_ptr();
7435 ::std::ptr::addr_of!((*ptr).bytes_used) as usize - ptr as usize
7436 },
7437 192usize,
7438 concat!(
7439 "Offset of field: ",
7440 stringify!(btrfs_root_item),
7441 "::",
7442 stringify!(bytes_used)
7443 )
7444 );
7445 }
7446 test_field_bytes_used();
7447 fn test_field_last_snapshot() {
7448 assert_eq!(
7449 unsafe {
7450 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7451 let ptr = uninit.as_ptr();
7452 ::std::ptr::addr_of!((*ptr).last_snapshot) as usize - ptr as usize
7453 },
7454 200usize,
7455 concat!(
7456 "Offset of field: ",
7457 stringify!(btrfs_root_item),
7458 "::",
7459 stringify!(last_snapshot)
7460 )
7461 );
7462 }
7463 test_field_last_snapshot();
7464 fn test_field_flags() {
7465 assert_eq!(
7466 unsafe {
7467 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7468 let ptr = uninit.as_ptr();
7469 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
7470 },
7471 208usize,
7472 concat!(
7473 "Offset of field: ",
7474 stringify!(btrfs_root_item),
7475 "::",
7476 stringify!(flags)
7477 )
7478 );
7479 }
7480 test_field_flags();
7481 fn test_field_refs() {
7482 assert_eq!(
7483 unsafe {
7484 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7485 let ptr = uninit.as_ptr();
7486 ::std::ptr::addr_of!((*ptr).refs) as usize - ptr as usize
7487 },
7488 216usize,
7489 concat!(
7490 "Offset of field: ",
7491 stringify!(btrfs_root_item),
7492 "::",
7493 stringify!(refs)
7494 )
7495 );
7496 }
7497 test_field_refs();
7498 fn test_field_drop_progress() {
7499 assert_eq!(
7500 unsafe {
7501 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7502 let ptr = uninit.as_ptr();
7503 ::std::ptr::addr_of!((*ptr).drop_progress) as usize - ptr as usize
7504 },
7505 220usize,
7506 concat!(
7507 "Offset of field: ",
7508 stringify!(btrfs_root_item),
7509 "::",
7510 stringify!(drop_progress)
7511 )
7512 );
7513 }
7514 test_field_drop_progress();
7515 fn test_field_drop_level() {
7516 assert_eq!(
7517 unsafe {
7518 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7519 let ptr = uninit.as_ptr();
7520 ::std::ptr::addr_of!((*ptr).drop_level) as usize - ptr as usize
7521 },
7522 237usize,
7523 concat!(
7524 "Offset of field: ",
7525 stringify!(btrfs_root_item),
7526 "::",
7527 stringify!(drop_level)
7528 )
7529 );
7530 }
7531 test_field_drop_level();
7532 fn test_field_level() {
7533 assert_eq!(
7534 unsafe {
7535 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7536 let ptr = uninit.as_ptr();
7537 ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize
7538 },
7539 238usize,
7540 concat!(
7541 "Offset of field: ",
7542 stringify!(btrfs_root_item),
7543 "::",
7544 stringify!(level)
7545 )
7546 );
7547 }
7548 test_field_level();
7549 fn test_field_generation_v2() {
7550 assert_eq!(
7551 unsafe {
7552 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7553 let ptr = uninit.as_ptr();
7554 ::std::ptr::addr_of!((*ptr).generation_v2) as usize - ptr as usize
7555 },
7556 239usize,
7557 concat!(
7558 "Offset of field: ",
7559 stringify!(btrfs_root_item),
7560 "::",
7561 stringify!(generation_v2)
7562 )
7563 );
7564 }
7565 test_field_generation_v2();
7566 fn test_field_uuid() {
7567 assert_eq!(
7568 unsafe {
7569 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7570 let ptr = uninit.as_ptr();
7571 ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize
7572 },
7573 247usize,
7574 concat!(
7575 "Offset of field: ",
7576 stringify!(btrfs_root_item),
7577 "::",
7578 stringify!(uuid)
7579 )
7580 );
7581 }
7582 test_field_uuid();
7583 fn test_field_parent_uuid() {
7584 assert_eq!(
7585 unsafe {
7586 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7587 let ptr = uninit.as_ptr();
7588 ::std::ptr::addr_of!((*ptr).parent_uuid) as usize - ptr as usize
7589 },
7590 263usize,
7591 concat!(
7592 "Offset of field: ",
7593 stringify!(btrfs_root_item),
7594 "::",
7595 stringify!(parent_uuid)
7596 )
7597 );
7598 }
7599 test_field_parent_uuid();
7600 fn test_field_received_uuid() {
7601 assert_eq!(
7602 unsafe {
7603 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7604 let ptr = uninit.as_ptr();
7605 ::std::ptr::addr_of!((*ptr).received_uuid) as usize - ptr as usize
7606 },
7607 279usize,
7608 concat!(
7609 "Offset of field: ",
7610 stringify!(btrfs_root_item),
7611 "::",
7612 stringify!(received_uuid)
7613 )
7614 );
7615 }
7616 test_field_received_uuid();
7617 fn test_field_ctransid() {
7618 assert_eq!(
7619 unsafe {
7620 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7621 let ptr = uninit.as_ptr();
7622 ::std::ptr::addr_of!((*ptr).ctransid) as usize - ptr as usize
7623 },
7624 295usize,
7625 concat!(
7626 "Offset of field: ",
7627 stringify!(btrfs_root_item),
7628 "::",
7629 stringify!(ctransid)
7630 )
7631 );
7632 }
7633 test_field_ctransid();
7634 fn test_field_otransid() {
7635 assert_eq!(
7636 unsafe {
7637 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7638 let ptr = uninit.as_ptr();
7639 ::std::ptr::addr_of!((*ptr).otransid) as usize - ptr as usize
7640 },
7641 303usize,
7642 concat!(
7643 "Offset of field: ",
7644 stringify!(btrfs_root_item),
7645 "::",
7646 stringify!(otransid)
7647 )
7648 );
7649 }
7650 test_field_otransid();
7651 fn test_field_stransid() {
7652 assert_eq!(
7653 unsafe {
7654 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7655 let ptr = uninit.as_ptr();
7656 ::std::ptr::addr_of!((*ptr).stransid) as usize - ptr as usize
7657 },
7658 311usize,
7659 concat!(
7660 "Offset of field: ",
7661 stringify!(btrfs_root_item),
7662 "::",
7663 stringify!(stransid)
7664 )
7665 );
7666 }
7667 test_field_stransid();
7668 fn test_field_rtransid() {
7669 assert_eq!(
7670 unsafe {
7671 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7672 let ptr = uninit.as_ptr();
7673 ::std::ptr::addr_of!((*ptr).rtransid) as usize - ptr as usize
7674 },
7675 319usize,
7676 concat!(
7677 "Offset of field: ",
7678 stringify!(btrfs_root_item),
7679 "::",
7680 stringify!(rtransid)
7681 )
7682 );
7683 }
7684 test_field_rtransid();
7685 fn test_field_ctime() {
7686 assert_eq!(
7687 unsafe {
7688 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7689 let ptr = uninit.as_ptr();
7690 ::std::ptr::addr_of!((*ptr).ctime) as usize - ptr as usize
7691 },
7692 327usize,
7693 concat!(
7694 "Offset of field: ",
7695 stringify!(btrfs_root_item),
7696 "::",
7697 stringify!(ctime)
7698 )
7699 );
7700 }
7701 test_field_ctime();
7702 fn test_field_otime() {
7703 assert_eq!(
7704 unsafe {
7705 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7706 let ptr = uninit.as_ptr();
7707 ::std::ptr::addr_of!((*ptr).otime) as usize - ptr as usize
7708 },
7709 339usize,
7710 concat!(
7711 "Offset of field: ",
7712 stringify!(btrfs_root_item),
7713 "::",
7714 stringify!(otime)
7715 )
7716 );
7717 }
7718 test_field_otime();
7719 fn test_field_stime() {
7720 assert_eq!(
7721 unsafe {
7722 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7723 let ptr = uninit.as_ptr();
7724 ::std::ptr::addr_of!((*ptr).stime) as usize - ptr as usize
7725 },
7726 351usize,
7727 concat!(
7728 "Offset of field: ",
7729 stringify!(btrfs_root_item),
7730 "::",
7731 stringify!(stime)
7732 )
7733 );
7734 }
7735 test_field_stime();
7736 fn test_field_rtime() {
7737 assert_eq!(
7738 unsafe {
7739 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7740 let ptr = uninit.as_ptr();
7741 ::std::ptr::addr_of!((*ptr).rtime) as usize - ptr as usize
7742 },
7743 363usize,
7744 concat!(
7745 "Offset of field: ",
7746 stringify!(btrfs_root_item),
7747 "::",
7748 stringify!(rtime)
7749 )
7750 );
7751 }
7752 test_field_rtime();
7753 fn test_field_reserved() {
7754 assert_eq!(
7755 unsafe {
7756 let uninit = ::std::mem::MaybeUninit::<btrfs_root_item>::uninit();
7757 let ptr = uninit.as_ptr();
7758 ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
7759 },
7760 375usize,
7761 concat!(
7762 "Offset of field: ",
7763 stringify!(btrfs_root_item),
7764 "::",
7765 stringify!(reserved)
7766 )
7767 );
7768 }
7769 test_field_reserved();
7770}
7771#[repr(C, packed)]
7772#[derive(Debug, Copy, Clone)]
7773pub struct btrfs_root_ref {
7774 pub dirid: __le64,
7775 pub sequence: __le64,
7776 pub name_len: __le16,
7777}
7778#[test]
7779fn bindgen_test_layout_btrfs_root_ref() {
7780 assert_eq!(
7781 ::std::mem::size_of::<btrfs_root_ref>(),
7782 18usize,
7783 concat!("Size of: ", stringify!(btrfs_root_ref))
7784 );
7785 assert_eq!(
7786 ::std::mem::align_of::<btrfs_root_ref>(),
7787 1usize,
7788 concat!("Alignment of ", stringify!(btrfs_root_ref))
7789 );
7790 fn test_field_dirid() {
7791 assert_eq!(
7792 unsafe {
7793 let uninit = ::std::mem::MaybeUninit::<btrfs_root_ref>::uninit();
7794 let ptr = uninit.as_ptr();
7795 ::std::ptr::addr_of!((*ptr).dirid) as usize - ptr as usize
7796 },
7797 0usize,
7798 concat!(
7799 "Offset of field: ",
7800 stringify!(btrfs_root_ref),
7801 "::",
7802 stringify!(dirid)
7803 )
7804 );
7805 }
7806 test_field_dirid();
7807 fn test_field_sequence() {
7808 assert_eq!(
7809 unsafe {
7810 let uninit = ::std::mem::MaybeUninit::<btrfs_root_ref>::uninit();
7811 let ptr = uninit.as_ptr();
7812 ::std::ptr::addr_of!((*ptr).sequence) as usize - ptr as usize
7813 },
7814 8usize,
7815 concat!(
7816 "Offset of field: ",
7817 stringify!(btrfs_root_ref),
7818 "::",
7819 stringify!(sequence)
7820 )
7821 );
7822 }
7823 test_field_sequence();
7824 fn test_field_name_len() {
7825 assert_eq!(
7826 unsafe {
7827 let uninit = ::std::mem::MaybeUninit::<btrfs_root_ref>::uninit();
7828 let ptr = uninit.as_ptr();
7829 ::std::ptr::addr_of!((*ptr).name_len) as usize - ptr as usize
7830 },
7831 16usize,
7832 concat!(
7833 "Offset of field: ",
7834 stringify!(btrfs_root_ref),
7835 "::",
7836 stringify!(name_len)
7837 )
7838 );
7839 }
7840 test_field_name_len();
7841}
7842#[repr(C, packed)]
7843#[derive(Copy, Clone)]
7844pub struct btrfs_disk_balance_args {
7845 pub profiles: __le64,
7846 pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_1,
7847 pub devid: __le64,
7848 pub pstart: __le64,
7849 pub pend: __le64,
7850 pub vstart: __le64,
7851 pub vend: __le64,
7852 pub target: __le64,
7853 pub flags: __le64,
7854 pub __bindgen_anon_2: btrfs_disk_balance_args__bindgen_ty_2,
7855 pub stripes_min: __le32,
7856 pub stripes_max: __le32,
7857 pub unused: [__le64; 6usize],
7858}
7859#[repr(C)]
7860#[derive(Copy, Clone)]
7861pub union btrfs_disk_balance_args__bindgen_ty_1 {
7862 pub usage: __le64,
7863 pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1,
7864}
7865#[repr(C)]
7866#[derive(Debug, Copy, Clone)]
7867pub struct btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1 {
7868 pub usage_min: __le32,
7869 pub usage_max: __le32,
7870}
7871#[test]
7872fn bindgen_test_layout_btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1() {
7873 assert_eq!(
7874 ::std::mem::size_of::<btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1>(),
7875 8usize,
7876 concat!(
7877 "Size of: ",
7878 stringify!(btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1)
7879 )
7880 );
7881 assert_eq!(
7882 ::std::mem::align_of::<btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1>(),
7883 4usize,
7884 concat!(
7885 "Alignment of ",
7886 stringify!(btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1)
7887 )
7888 );
7889 fn test_field_usage_min() {
7890 assert_eq!(
7891 unsafe {
7892 let uninit = ::std::mem::MaybeUninit::<
7893 btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1,
7894 >::uninit();
7895 let ptr = uninit.as_ptr();
7896 ::std::ptr::addr_of!((*ptr).usage_min) as usize - ptr as usize
7897 },
7898 0usize,
7899 concat!(
7900 "Offset of field: ",
7901 stringify!(btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1),
7902 "::",
7903 stringify!(usage_min)
7904 )
7905 );
7906 }
7907 test_field_usage_min();
7908 fn test_field_usage_max() {
7909 assert_eq!(
7910 unsafe {
7911 let uninit = ::std::mem::MaybeUninit::<
7912 btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1,
7913 >::uninit();
7914 let ptr = uninit.as_ptr();
7915 ::std::ptr::addr_of!((*ptr).usage_max) as usize - ptr as usize
7916 },
7917 4usize,
7918 concat!(
7919 "Offset of field: ",
7920 stringify!(btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1),
7921 "::",
7922 stringify!(usage_max)
7923 )
7924 );
7925 }
7926 test_field_usage_max();
7927}
7928#[test]
7929fn bindgen_test_layout_btrfs_disk_balance_args__bindgen_ty_1() {
7930 assert_eq!(
7931 ::std::mem::size_of::<btrfs_disk_balance_args__bindgen_ty_1>(),
7932 8usize,
7933 concat!(
7934 "Size of: ",
7935 stringify!(btrfs_disk_balance_args__bindgen_ty_1)
7936 )
7937 );
7938 assert_eq!(
7939 ::std::mem::align_of::<btrfs_disk_balance_args__bindgen_ty_1>(),
7940 8usize,
7941 concat!(
7942 "Alignment of ",
7943 stringify!(btrfs_disk_balance_args__bindgen_ty_1)
7944 )
7945 );
7946 fn test_field_usage() {
7947 assert_eq!(
7948 unsafe {
7949 let uninit =
7950 ::std::mem::MaybeUninit::<btrfs_disk_balance_args__bindgen_ty_1>::uninit();
7951 let ptr = uninit.as_ptr();
7952 ::std::ptr::addr_of!((*ptr).usage) as usize - ptr as usize
7953 },
7954 0usize,
7955 concat!(
7956 "Offset of field: ",
7957 stringify!(btrfs_disk_balance_args__bindgen_ty_1),
7958 "::",
7959 stringify!(usage)
7960 )
7961 );
7962 }
7963 test_field_usage();
7964}
7965#[repr(C)]
7966#[derive(Copy, Clone)]
7967pub union btrfs_disk_balance_args__bindgen_ty_2 {
7968 pub limit: __le64,
7969 pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1,
7970}
7971#[repr(C)]
7972#[derive(Debug, Copy, Clone)]
7973pub struct btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1 {
7974 pub limit_min: __le32,
7975 pub limit_max: __le32,
7976}
7977#[test]
7978fn bindgen_test_layout_btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1() {
7979 assert_eq!(
7980 ::std::mem::size_of::<btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1>(),
7981 8usize,
7982 concat!(
7983 "Size of: ",
7984 stringify!(btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1)
7985 )
7986 );
7987 assert_eq!(
7988 ::std::mem::align_of::<btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1>(),
7989 4usize,
7990 concat!(
7991 "Alignment of ",
7992 stringify!(btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1)
7993 )
7994 );
7995 fn test_field_limit_min() {
7996 assert_eq!(
7997 unsafe {
7998 let uninit = ::std::mem::MaybeUninit::<
7999 btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1,
8000 >::uninit();
8001 let ptr = uninit.as_ptr();
8002 ::std::ptr::addr_of!((*ptr).limit_min) as usize - ptr as usize
8003 },
8004 0usize,
8005 concat!(
8006 "Offset of field: ",
8007 stringify!(btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1),
8008 "::",
8009 stringify!(limit_min)
8010 )
8011 );
8012 }
8013 test_field_limit_min();
8014 fn test_field_limit_max() {
8015 assert_eq!(
8016 unsafe {
8017 let uninit = ::std::mem::MaybeUninit::<
8018 btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1,
8019 >::uninit();
8020 let ptr = uninit.as_ptr();
8021 ::std::ptr::addr_of!((*ptr).limit_max) as usize - ptr as usize
8022 },
8023 4usize,
8024 concat!(
8025 "Offset of field: ",
8026 stringify!(btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1),
8027 "::",
8028 stringify!(limit_max)
8029 )
8030 );
8031 }
8032 test_field_limit_max();
8033}
8034#[test]
8035fn bindgen_test_layout_btrfs_disk_balance_args__bindgen_ty_2() {
8036 assert_eq!(
8037 ::std::mem::size_of::<btrfs_disk_balance_args__bindgen_ty_2>(),
8038 8usize,
8039 concat!(
8040 "Size of: ",
8041 stringify!(btrfs_disk_balance_args__bindgen_ty_2)
8042 )
8043 );
8044 assert_eq!(
8045 ::std::mem::align_of::<btrfs_disk_balance_args__bindgen_ty_2>(),
8046 8usize,
8047 concat!(
8048 "Alignment of ",
8049 stringify!(btrfs_disk_balance_args__bindgen_ty_2)
8050 )
8051 );
8052 fn test_field_limit() {
8053 assert_eq!(
8054 unsafe {
8055 let uninit =
8056 ::std::mem::MaybeUninit::<btrfs_disk_balance_args__bindgen_ty_2>::uninit();
8057 let ptr = uninit.as_ptr();
8058 ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize
8059 },
8060 0usize,
8061 concat!(
8062 "Offset of field: ",
8063 stringify!(btrfs_disk_balance_args__bindgen_ty_2),
8064 "::",
8065 stringify!(limit)
8066 )
8067 );
8068 }
8069 test_field_limit();
8070}
8071#[test]
8072fn bindgen_test_layout_btrfs_disk_balance_args() {
8073 assert_eq!(
8074 ::std::mem::size_of::<btrfs_disk_balance_args>(),
8075 136usize,
8076 concat!("Size of: ", stringify!(btrfs_disk_balance_args))
8077 );
8078 assert_eq!(
8079 ::std::mem::align_of::<btrfs_disk_balance_args>(),
8080 1usize,
8081 concat!("Alignment of ", stringify!(btrfs_disk_balance_args))
8082 );
8083 fn test_field_profiles() {
8084 assert_eq!(
8085 unsafe {
8086 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8087 let ptr = uninit.as_ptr();
8088 ::std::ptr::addr_of!((*ptr).profiles) as usize - ptr as usize
8089 },
8090 0usize,
8091 concat!(
8092 "Offset of field: ",
8093 stringify!(btrfs_disk_balance_args),
8094 "::",
8095 stringify!(profiles)
8096 )
8097 );
8098 }
8099 test_field_profiles();
8100 fn test_field_devid() {
8101 assert_eq!(
8102 unsafe {
8103 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8104 let ptr = uninit.as_ptr();
8105 ::std::ptr::addr_of!((*ptr).devid) as usize - ptr as usize
8106 },
8107 16usize,
8108 concat!(
8109 "Offset of field: ",
8110 stringify!(btrfs_disk_balance_args),
8111 "::",
8112 stringify!(devid)
8113 )
8114 );
8115 }
8116 test_field_devid();
8117 fn test_field_pstart() {
8118 assert_eq!(
8119 unsafe {
8120 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8121 let ptr = uninit.as_ptr();
8122 ::std::ptr::addr_of!((*ptr).pstart) as usize - ptr as usize
8123 },
8124 24usize,
8125 concat!(
8126 "Offset of field: ",
8127 stringify!(btrfs_disk_balance_args),
8128 "::",
8129 stringify!(pstart)
8130 )
8131 );
8132 }
8133 test_field_pstart();
8134 fn test_field_pend() {
8135 assert_eq!(
8136 unsafe {
8137 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8138 let ptr = uninit.as_ptr();
8139 ::std::ptr::addr_of!((*ptr).pend) as usize - ptr as usize
8140 },
8141 32usize,
8142 concat!(
8143 "Offset of field: ",
8144 stringify!(btrfs_disk_balance_args),
8145 "::",
8146 stringify!(pend)
8147 )
8148 );
8149 }
8150 test_field_pend();
8151 fn test_field_vstart() {
8152 assert_eq!(
8153 unsafe {
8154 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8155 let ptr = uninit.as_ptr();
8156 ::std::ptr::addr_of!((*ptr).vstart) as usize - ptr as usize
8157 },
8158 40usize,
8159 concat!(
8160 "Offset of field: ",
8161 stringify!(btrfs_disk_balance_args),
8162 "::",
8163 stringify!(vstart)
8164 )
8165 );
8166 }
8167 test_field_vstart();
8168 fn test_field_vend() {
8169 assert_eq!(
8170 unsafe {
8171 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8172 let ptr = uninit.as_ptr();
8173 ::std::ptr::addr_of!((*ptr).vend) as usize - ptr as usize
8174 },
8175 48usize,
8176 concat!(
8177 "Offset of field: ",
8178 stringify!(btrfs_disk_balance_args),
8179 "::",
8180 stringify!(vend)
8181 )
8182 );
8183 }
8184 test_field_vend();
8185 fn test_field_target() {
8186 assert_eq!(
8187 unsafe {
8188 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8189 let ptr = uninit.as_ptr();
8190 ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize
8191 },
8192 56usize,
8193 concat!(
8194 "Offset of field: ",
8195 stringify!(btrfs_disk_balance_args),
8196 "::",
8197 stringify!(target)
8198 )
8199 );
8200 }
8201 test_field_target();
8202 fn test_field_flags() {
8203 assert_eq!(
8204 unsafe {
8205 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8206 let ptr = uninit.as_ptr();
8207 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
8208 },
8209 64usize,
8210 concat!(
8211 "Offset of field: ",
8212 stringify!(btrfs_disk_balance_args),
8213 "::",
8214 stringify!(flags)
8215 )
8216 );
8217 }
8218 test_field_flags();
8219 fn test_field_stripes_min() {
8220 assert_eq!(
8221 unsafe {
8222 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8223 let ptr = uninit.as_ptr();
8224 ::std::ptr::addr_of!((*ptr).stripes_min) as usize - ptr as usize
8225 },
8226 80usize,
8227 concat!(
8228 "Offset of field: ",
8229 stringify!(btrfs_disk_balance_args),
8230 "::",
8231 stringify!(stripes_min)
8232 )
8233 );
8234 }
8235 test_field_stripes_min();
8236 fn test_field_stripes_max() {
8237 assert_eq!(
8238 unsafe {
8239 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8240 let ptr = uninit.as_ptr();
8241 ::std::ptr::addr_of!((*ptr).stripes_max) as usize - ptr as usize
8242 },
8243 84usize,
8244 concat!(
8245 "Offset of field: ",
8246 stringify!(btrfs_disk_balance_args),
8247 "::",
8248 stringify!(stripes_max)
8249 )
8250 );
8251 }
8252 test_field_stripes_max();
8253 fn test_field_unused() {
8254 assert_eq!(
8255 unsafe {
8256 let uninit = ::std::mem::MaybeUninit::<btrfs_disk_balance_args>::uninit();
8257 let ptr = uninit.as_ptr();
8258 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
8259 },
8260 88usize,
8261 concat!(
8262 "Offset of field: ",
8263 stringify!(btrfs_disk_balance_args),
8264 "::",
8265 stringify!(unused)
8266 )
8267 );
8268 }
8269 test_field_unused();
8270}
8271#[repr(C, packed)]
8272#[derive(Copy, Clone)]
8273pub struct btrfs_balance_item {
8274 pub flags: __le64,
8275 pub data: btrfs_disk_balance_args,
8276 pub meta: btrfs_disk_balance_args,
8277 pub sys: btrfs_disk_balance_args,
8278 pub unused: [__le64; 4usize],
8279}
8280#[test]
8281fn bindgen_test_layout_btrfs_balance_item() {
8282 assert_eq!(
8283 ::std::mem::size_of::<btrfs_balance_item>(),
8284 448usize,
8285 concat!("Size of: ", stringify!(btrfs_balance_item))
8286 );
8287 assert_eq!(
8288 ::std::mem::align_of::<btrfs_balance_item>(),
8289 1usize,
8290 concat!("Alignment of ", stringify!(btrfs_balance_item))
8291 );
8292 fn test_field_flags() {
8293 assert_eq!(
8294 unsafe {
8295 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_item>::uninit();
8296 let ptr = uninit.as_ptr();
8297 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
8298 },
8299 0usize,
8300 concat!(
8301 "Offset of field: ",
8302 stringify!(btrfs_balance_item),
8303 "::",
8304 stringify!(flags)
8305 )
8306 );
8307 }
8308 test_field_flags();
8309 fn test_field_data() {
8310 assert_eq!(
8311 unsafe {
8312 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_item>::uninit();
8313 let ptr = uninit.as_ptr();
8314 ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
8315 },
8316 8usize,
8317 concat!(
8318 "Offset of field: ",
8319 stringify!(btrfs_balance_item),
8320 "::",
8321 stringify!(data)
8322 )
8323 );
8324 }
8325 test_field_data();
8326 fn test_field_meta() {
8327 assert_eq!(
8328 unsafe {
8329 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_item>::uninit();
8330 let ptr = uninit.as_ptr();
8331 ::std::ptr::addr_of!((*ptr).meta) as usize - ptr as usize
8332 },
8333 144usize,
8334 concat!(
8335 "Offset of field: ",
8336 stringify!(btrfs_balance_item),
8337 "::",
8338 stringify!(meta)
8339 )
8340 );
8341 }
8342 test_field_meta();
8343 fn test_field_sys() {
8344 assert_eq!(
8345 unsafe {
8346 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_item>::uninit();
8347 let ptr = uninit.as_ptr();
8348 ::std::ptr::addr_of!((*ptr).sys) as usize - ptr as usize
8349 },
8350 280usize,
8351 concat!(
8352 "Offset of field: ",
8353 stringify!(btrfs_balance_item),
8354 "::",
8355 stringify!(sys)
8356 )
8357 );
8358 }
8359 test_field_sys();
8360 fn test_field_unused() {
8361 assert_eq!(
8362 unsafe {
8363 let uninit = ::std::mem::MaybeUninit::<btrfs_balance_item>::uninit();
8364 let ptr = uninit.as_ptr();
8365 ::std::ptr::addr_of!((*ptr).unused) as usize - ptr as usize
8366 },
8367 416usize,
8368 concat!(
8369 "Offset of field: ",
8370 stringify!(btrfs_balance_item),
8371 "::",
8372 stringify!(unused)
8373 )
8374 );
8375 }
8376 test_field_unused();
8377}
8378#[repr(C, packed)]
8379#[derive(Debug, Copy, Clone)]
8380pub struct btrfs_file_extent_item {
8381 pub generation: __le64,
8382 pub ram_bytes: __le64,
8383 pub compression: __u8,
8384 pub encryption: __u8,
8385 pub other_encoding: __le16,
8386 pub type_: __u8,
8387 pub disk_bytenr: __le64,
8388 pub disk_num_bytes: __le64,
8389 pub offset: __le64,
8390 pub num_bytes: __le64,
8391}
8392#[test]
8393fn bindgen_test_layout_btrfs_file_extent_item() {
8394 assert_eq!(
8395 ::std::mem::size_of::<btrfs_file_extent_item>(),
8396 53usize,
8397 concat!("Size of: ", stringify!(btrfs_file_extent_item))
8398 );
8399 assert_eq!(
8400 ::std::mem::align_of::<btrfs_file_extent_item>(),
8401 1usize,
8402 concat!("Alignment of ", stringify!(btrfs_file_extent_item))
8403 );
8404 fn test_field_generation() {
8405 assert_eq!(
8406 unsafe {
8407 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8408 let ptr = uninit.as_ptr();
8409 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
8410 },
8411 0usize,
8412 concat!(
8413 "Offset of field: ",
8414 stringify!(btrfs_file_extent_item),
8415 "::",
8416 stringify!(generation)
8417 )
8418 );
8419 }
8420 test_field_generation();
8421 fn test_field_ram_bytes() {
8422 assert_eq!(
8423 unsafe {
8424 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8425 let ptr = uninit.as_ptr();
8426 ::std::ptr::addr_of!((*ptr).ram_bytes) as usize - ptr as usize
8427 },
8428 8usize,
8429 concat!(
8430 "Offset of field: ",
8431 stringify!(btrfs_file_extent_item),
8432 "::",
8433 stringify!(ram_bytes)
8434 )
8435 );
8436 }
8437 test_field_ram_bytes();
8438 fn test_field_compression() {
8439 assert_eq!(
8440 unsafe {
8441 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8442 let ptr = uninit.as_ptr();
8443 ::std::ptr::addr_of!((*ptr).compression) as usize - ptr as usize
8444 },
8445 16usize,
8446 concat!(
8447 "Offset of field: ",
8448 stringify!(btrfs_file_extent_item),
8449 "::",
8450 stringify!(compression)
8451 )
8452 );
8453 }
8454 test_field_compression();
8455 fn test_field_encryption() {
8456 assert_eq!(
8457 unsafe {
8458 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8459 let ptr = uninit.as_ptr();
8460 ::std::ptr::addr_of!((*ptr).encryption) as usize - ptr as usize
8461 },
8462 17usize,
8463 concat!(
8464 "Offset of field: ",
8465 stringify!(btrfs_file_extent_item),
8466 "::",
8467 stringify!(encryption)
8468 )
8469 );
8470 }
8471 test_field_encryption();
8472 fn test_field_other_encoding() {
8473 assert_eq!(
8474 unsafe {
8475 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8476 let ptr = uninit.as_ptr();
8477 ::std::ptr::addr_of!((*ptr).other_encoding) as usize - ptr as usize
8478 },
8479 18usize,
8480 concat!(
8481 "Offset of field: ",
8482 stringify!(btrfs_file_extent_item),
8483 "::",
8484 stringify!(other_encoding)
8485 )
8486 );
8487 }
8488 test_field_other_encoding();
8489 fn test_field_type() {
8490 assert_eq!(
8491 unsafe {
8492 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8493 let ptr = uninit.as_ptr();
8494 ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize
8495 },
8496 20usize,
8497 concat!(
8498 "Offset of field: ",
8499 stringify!(btrfs_file_extent_item),
8500 "::",
8501 stringify!(type_)
8502 )
8503 );
8504 }
8505 test_field_type();
8506 fn test_field_disk_bytenr() {
8507 assert_eq!(
8508 unsafe {
8509 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8510 let ptr = uninit.as_ptr();
8511 ::std::ptr::addr_of!((*ptr).disk_bytenr) as usize - ptr as usize
8512 },
8513 21usize,
8514 concat!(
8515 "Offset of field: ",
8516 stringify!(btrfs_file_extent_item),
8517 "::",
8518 stringify!(disk_bytenr)
8519 )
8520 );
8521 }
8522 test_field_disk_bytenr();
8523 fn test_field_disk_num_bytes() {
8524 assert_eq!(
8525 unsafe {
8526 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8527 let ptr = uninit.as_ptr();
8528 ::std::ptr::addr_of!((*ptr).disk_num_bytes) as usize - ptr as usize
8529 },
8530 29usize,
8531 concat!(
8532 "Offset of field: ",
8533 stringify!(btrfs_file_extent_item),
8534 "::",
8535 stringify!(disk_num_bytes)
8536 )
8537 );
8538 }
8539 test_field_disk_num_bytes();
8540 fn test_field_offset() {
8541 assert_eq!(
8542 unsafe {
8543 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8544 let ptr = uninit.as_ptr();
8545 ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
8546 },
8547 37usize,
8548 concat!(
8549 "Offset of field: ",
8550 stringify!(btrfs_file_extent_item),
8551 "::",
8552 stringify!(offset)
8553 )
8554 );
8555 }
8556 test_field_offset();
8557 fn test_field_num_bytes() {
8558 assert_eq!(
8559 unsafe {
8560 let uninit = ::std::mem::MaybeUninit::<btrfs_file_extent_item>::uninit();
8561 let ptr = uninit.as_ptr();
8562 ::std::ptr::addr_of!((*ptr).num_bytes) as usize - ptr as usize
8563 },
8564 45usize,
8565 concat!(
8566 "Offset of field: ",
8567 stringify!(btrfs_file_extent_item),
8568 "::",
8569 stringify!(num_bytes)
8570 )
8571 );
8572 }
8573 test_field_num_bytes();
8574}
8575#[repr(C, packed)]
8576#[derive(Debug, Copy, Clone)]
8577pub struct btrfs_csum_item {
8578 pub csum: __u8,
8579}
8580#[test]
8581fn bindgen_test_layout_btrfs_csum_item() {
8582 assert_eq!(
8583 ::std::mem::size_of::<btrfs_csum_item>(),
8584 1usize,
8585 concat!("Size of: ", stringify!(btrfs_csum_item))
8586 );
8587 assert_eq!(
8588 ::std::mem::align_of::<btrfs_csum_item>(),
8589 1usize,
8590 concat!("Alignment of ", stringify!(btrfs_csum_item))
8591 );
8592 fn test_field_csum() {
8593 assert_eq!(
8594 unsafe {
8595 let uninit = ::std::mem::MaybeUninit::<btrfs_csum_item>::uninit();
8596 let ptr = uninit.as_ptr();
8597 ::std::ptr::addr_of!((*ptr).csum) as usize - ptr as usize
8598 },
8599 0usize,
8600 concat!(
8601 "Offset of field: ",
8602 stringify!(btrfs_csum_item),
8603 "::",
8604 stringify!(csum)
8605 )
8606 );
8607 }
8608 test_field_csum();
8609}
8610#[repr(C, packed)]
8611#[derive(Debug, Copy, Clone)]
8612pub struct btrfs_dev_stats_item {
8613 pub values: [__le64; 5usize],
8614}
8615#[test]
8616fn bindgen_test_layout_btrfs_dev_stats_item() {
8617 assert_eq!(
8618 ::std::mem::size_of::<btrfs_dev_stats_item>(),
8619 40usize,
8620 concat!("Size of: ", stringify!(btrfs_dev_stats_item))
8621 );
8622 assert_eq!(
8623 ::std::mem::align_of::<btrfs_dev_stats_item>(),
8624 1usize,
8625 concat!("Alignment of ", stringify!(btrfs_dev_stats_item))
8626 );
8627 fn test_field_values() {
8628 assert_eq!(
8629 unsafe {
8630 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_stats_item>::uninit();
8631 let ptr = uninit.as_ptr();
8632 ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize
8633 },
8634 0usize,
8635 concat!(
8636 "Offset of field: ",
8637 stringify!(btrfs_dev_stats_item),
8638 "::",
8639 stringify!(values)
8640 )
8641 );
8642 }
8643 test_field_values();
8644}
8645#[repr(C, packed)]
8646#[derive(Debug, Copy, Clone)]
8647pub struct btrfs_dev_replace_item {
8648 pub src_devid: __le64,
8649 pub cursor_left: __le64,
8650 pub cursor_right: __le64,
8651 pub cont_reading_from_srcdev_mode: __le64,
8652 pub replace_state: __le64,
8653 pub time_started: __le64,
8654 pub time_stopped: __le64,
8655 pub num_write_errors: __le64,
8656 pub num_uncorrectable_read_errors: __le64,
8657}
8658#[test]
8659fn bindgen_test_layout_btrfs_dev_replace_item() {
8660 assert_eq!(
8661 ::std::mem::size_of::<btrfs_dev_replace_item>(),
8662 72usize,
8663 concat!("Size of: ", stringify!(btrfs_dev_replace_item))
8664 );
8665 assert_eq!(
8666 ::std::mem::align_of::<btrfs_dev_replace_item>(),
8667 1usize,
8668 concat!("Alignment of ", stringify!(btrfs_dev_replace_item))
8669 );
8670 fn test_field_src_devid() {
8671 assert_eq!(
8672 unsafe {
8673 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8674 let ptr = uninit.as_ptr();
8675 ::std::ptr::addr_of!((*ptr).src_devid) as usize - ptr as usize
8676 },
8677 0usize,
8678 concat!(
8679 "Offset of field: ",
8680 stringify!(btrfs_dev_replace_item),
8681 "::",
8682 stringify!(src_devid)
8683 )
8684 );
8685 }
8686 test_field_src_devid();
8687 fn test_field_cursor_left() {
8688 assert_eq!(
8689 unsafe {
8690 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8691 let ptr = uninit.as_ptr();
8692 ::std::ptr::addr_of!((*ptr).cursor_left) as usize - ptr as usize
8693 },
8694 8usize,
8695 concat!(
8696 "Offset of field: ",
8697 stringify!(btrfs_dev_replace_item),
8698 "::",
8699 stringify!(cursor_left)
8700 )
8701 );
8702 }
8703 test_field_cursor_left();
8704 fn test_field_cursor_right() {
8705 assert_eq!(
8706 unsafe {
8707 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8708 let ptr = uninit.as_ptr();
8709 ::std::ptr::addr_of!((*ptr).cursor_right) as usize - ptr as usize
8710 },
8711 16usize,
8712 concat!(
8713 "Offset of field: ",
8714 stringify!(btrfs_dev_replace_item),
8715 "::",
8716 stringify!(cursor_right)
8717 )
8718 );
8719 }
8720 test_field_cursor_right();
8721 fn test_field_cont_reading_from_srcdev_mode() {
8722 assert_eq!(
8723 unsafe {
8724 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8725 let ptr = uninit.as_ptr();
8726 ::std::ptr::addr_of!((*ptr).cont_reading_from_srcdev_mode) as usize - ptr as usize
8727 },
8728 24usize,
8729 concat!(
8730 "Offset of field: ",
8731 stringify!(btrfs_dev_replace_item),
8732 "::",
8733 stringify!(cont_reading_from_srcdev_mode)
8734 )
8735 );
8736 }
8737 test_field_cont_reading_from_srcdev_mode();
8738 fn test_field_replace_state() {
8739 assert_eq!(
8740 unsafe {
8741 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8742 let ptr = uninit.as_ptr();
8743 ::std::ptr::addr_of!((*ptr).replace_state) as usize - ptr as usize
8744 },
8745 32usize,
8746 concat!(
8747 "Offset of field: ",
8748 stringify!(btrfs_dev_replace_item),
8749 "::",
8750 stringify!(replace_state)
8751 )
8752 );
8753 }
8754 test_field_replace_state();
8755 fn test_field_time_started() {
8756 assert_eq!(
8757 unsafe {
8758 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8759 let ptr = uninit.as_ptr();
8760 ::std::ptr::addr_of!((*ptr).time_started) as usize - ptr as usize
8761 },
8762 40usize,
8763 concat!(
8764 "Offset of field: ",
8765 stringify!(btrfs_dev_replace_item),
8766 "::",
8767 stringify!(time_started)
8768 )
8769 );
8770 }
8771 test_field_time_started();
8772 fn test_field_time_stopped() {
8773 assert_eq!(
8774 unsafe {
8775 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8776 let ptr = uninit.as_ptr();
8777 ::std::ptr::addr_of!((*ptr).time_stopped) as usize - ptr as usize
8778 },
8779 48usize,
8780 concat!(
8781 "Offset of field: ",
8782 stringify!(btrfs_dev_replace_item),
8783 "::",
8784 stringify!(time_stopped)
8785 )
8786 );
8787 }
8788 test_field_time_stopped();
8789 fn test_field_num_write_errors() {
8790 assert_eq!(
8791 unsafe {
8792 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8793 let ptr = uninit.as_ptr();
8794 ::std::ptr::addr_of!((*ptr).num_write_errors) as usize - ptr as usize
8795 },
8796 56usize,
8797 concat!(
8798 "Offset of field: ",
8799 stringify!(btrfs_dev_replace_item),
8800 "::",
8801 stringify!(num_write_errors)
8802 )
8803 );
8804 }
8805 test_field_num_write_errors();
8806 fn test_field_num_uncorrectable_read_errors() {
8807 assert_eq!(
8808 unsafe {
8809 let uninit = ::std::mem::MaybeUninit::<btrfs_dev_replace_item>::uninit();
8810 let ptr = uninit.as_ptr();
8811 ::std::ptr::addr_of!((*ptr).num_uncorrectable_read_errors) as usize - ptr as usize
8812 },
8813 64usize,
8814 concat!(
8815 "Offset of field: ",
8816 stringify!(btrfs_dev_replace_item),
8817 "::",
8818 stringify!(num_uncorrectable_read_errors)
8819 )
8820 );
8821 }
8822 test_field_num_uncorrectable_read_errors();
8823}
8824pub const btrfs_raid_types_BTRFS_RAID_RAID10: btrfs_raid_types = 0;
8825pub const btrfs_raid_types_BTRFS_RAID_RAID1: btrfs_raid_types = 1;
8826pub const btrfs_raid_types_BTRFS_RAID_DUP: btrfs_raid_types = 2;
8827pub const btrfs_raid_types_BTRFS_RAID_RAID0: btrfs_raid_types = 3;
8828pub const btrfs_raid_types_BTRFS_RAID_SINGLE: btrfs_raid_types = 4;
8829pub const btrfs_raid_types_BTRFS_RAID_RAID5: btrfs_raid_types = 5;
8830pub const btrfs_raid_types_BTRFS_RAID_RAID6: btrfs_raid_types = 6;
8831pub const btrfs_raid_types_BTRFS_NR_RAID_TYPES: btrfs_raid_types = 7;
8832pub type btrfs_raid_types = ::std::os::raw::c_uint;
8833#[repr(C, packed)]
8834#[derive(Debug, Copy, Clone)]
8835pub struct btrfs_block_group_item {
8836 pub used: __le64,
8837 pub chunk_objectid: __le64,
8838 pub flags: __le64,
8839}
8840#[test]
8841fn bindgen_test_layout_btrfs_block_group_item() {
8842 assert_eq!(
8843 ::std::mem::size_of::<btrfs_block_group_item>(),
8844 24usize,
8845 concat!("Size of: ", stringify!(btrfs_block_group_item))
8846 );
8847 assert_eq!(
8848 ::std::mem::align_of::<btrfs_block_group_item>(),
8849 1usize,
8850 concat!("Alignment of ", stringify!(btrfs_block_group_item))
8851 );
8852 fn test_field_used() {
8853 assert_eq!(
8854 unsafe {
8855 let uninit = ::std::mem::MaybeUninit::<btrfs_block_group_item>::uninit();
8856 let ptr = uninit.as_ptr();
8857 ::std::ptr::addr_of!((*ptr).used) as usize - ptr as usize
8858 },
8859 0usize,
8860 concat!(
8861 "Offset of field: ",
8862 stringify!(btrfs_block_group_item),
8863 "::",
8864 stringify!(used)
8865 )
8866 );
8867 }
8868 test_field_used();
8869 fn test_field_chunk_objectid() {
8870 assert_eq!(
8871 unsafe {
8872 let uninit = ::std::mem::MaybeUninit::<btrfs_block_group_item>::uninit();
8873 let ptr = uninit.as_ptr();
8874 ::std::ptr::addr_of!((*ptr).chunk_objectid) as usize - ptr as usize
8875 },
8876 8usize,
8877 concat!(
8878 "Offset of field: ",
8879 stringify!(btrfs_block_group_item),
8880 "::",
8881 stringify!(chunk_objectid)
8882 )
8883 );
8884 }
8885 test_field_chunk_objectid();
8886 fn test_field_flags() {
8887 assert_eq!(
8888 unsafe {
8889 let uninit = ::std::mem::MaybeUninit::<btrfs_block_group_item>::uninit();
8890 let ptr = uninit.as_ptr();
8891 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
8892 },
8893 16usize,
8894 concat!(
8895 "Offset of field: ",
8896 stringify!(btrfs_block_group_item),
8897 "::",
8898 stringify!(flags)
8899 )
8900 );
8901 }
8902 test_field_flags();
8903}
8904#[repr(C, packed)]
8905#[derive(Debug, Copy, Clone)]
8906pub struct btrfs_free_space_info {
8907 pub extent_count: __le32,
8908 pub flags: __le32,
8909}
8910#[test]
8911fn bindgen_test_layout_btrfs_free_space_info() {
8912 assert_eq!(
8913 ::std::mem::size_of::<btrfs_free_space_info>(),
8914 8usize,
8915 concat!("Size of: ", stringify!(btrfs_free_space_info))
8916 );
8917 assert_eq!(
8918 ::std::mem::align_of::<btrfs_free_space_info>(),
8919 1usize,
8920 concat!("Alignment of ", stringify!(btrfs_free_space_info))
8921 );
8922 fn test_field_extent_count() {
8923 assert_eq!(
8924 unsafe {
8925 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_info>::uninit();
8926 let ptr = uninit.as_ptr();
8927 ::std::ptr::addr_of!((*ptr).extent_count) as usize - ptr as usize
8928 },
8929 0usize,
8930 concat!(
8931 "Offset of field: ",
8932 stringify!(btrfs_free_space_info),
8933 "::",
8934 stringify!(extent_count)
8935 )
8936 );
8937 }
8938 test_field_extent_count();
8939 fn test_field_flags() {
8940 assert_eq!(
8941 unsafe {
8942 let uninit = ::std::mem::MaybeUninit::<btrfs_free_space_info>::uninit();
8943 let ptr = uninit.as_ptr();
8944 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
8945 },
8946 4usize,
8947 concat!(
8948 "Offset of field: ",
8949 stringify!(btrfs_free_space_info),
8950 "::",
8951 stringify!(flags)
8952 )
8953 );
8954 }
8955 test_field_flags();
8956}
8957#[repr(C, packed)]
8958#[derive(Debug, Copy, Clone)]
8959pub struct btrfs_qgroup_status_item {
8960 pub version: __le64,
8961 pub generation: __le64,
8962 pub flags: __le64,
8963 pub rescan: __le64,
8964}
8965#[test]
8966fn bindgen_test_layout_btrfs_qgroup_status_item() {
8967 assert_eq!(
8968 ::std::mem::size_of::<btrfs_qgroup_status_item>(),
8969 32usize,
8970 concat!("Size of: ", stringify!(btrfs_qgroup_status_item))
8971 );
8972 assert_eq!(
8973 ::std::mem::align_of::<btrfs_qgroup_status_item>(),
8974 1usize,
8975 concat!("Alignment of ", stringify!(btrfs_qgroup_status_item))
8976 );
8977 fn test_field_version() {
8978 assert_eq!(
8979 unsafe {
8980 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_status_item>::uninit();
8981 let ptr = uninit.as_ptr();
8982 ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize
8983 },
8984 0usize,
8985 concat!(
8986 "Offset of field: ",
8987 stringify!(btrfs_qgroup_status_item),
8988 "::",
8989 stringify!(version)
8990 )
8991 );
8992 }
8993 test_field_version();
8994 fn test_field_generation() {
8995 assert_eq!(
8996 unsafe {
8997 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_status_item>::uninit();
8998 let ptr = uninit.as_ptr();
8999 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
9000 },
9001 8usize,
9002 concat!(
9003 "Offset of field: ",
9004 stringify!(btrfs_qgroup_status_item),
9005 "::",
9006 stringify!(generation)
9007 )
9008 );
9009 }
9010 test_field_generation();
9011 fn test_field_flags() {
9012 assert_eq!(
9013 unsafe {
9014 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_status_item>::uninit();
9015 let ptr = uninit.as_ptr();
9016 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
9017 },
9018 16usize,
9019 concat!(
9020 "Offset of field: ",
9021 stringify!(btrfs_qgroup_status_item),
9022 "::",
9023 stringify!(flags)
9024 )
9025 );
9026 }
9027 test_field_flags();
9028 fn test_field_rescan() {
9029 assert_eq!(
9030 unsafe {
9031 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_status_item>::uninit();
9032 let ptr = uninit.as_ptr();
9033 ::std::ptr::addr_of!((*ptr).rescan) as usize - ptr as usize
9034 },
9035 24usize,
9036 concat!(
9037 "Offset of field: ",
9038 stringify!(btrfs_qgroup_status_item),
9039 "::",
9040 stringify!(rescan)
9041 )
9042 );
9043 }
9044 test_field_rescan();
9045}
9046#[repr(C, packed)]
9047#[derive(Debug, Copy, Clone)]
9048pub struct btrfs_qgroup_info_item {
9049 pub generation: __le64,
9050 pub rfer: __le64,
9051 pub rfer_cmpr: __le64,
9052 pub excl: __le64,
9053 pub excl_cmpr: __le64,
9054}
9055#[test]
9056fn bindgen_test_layout_btrfs_qgroup_info_item() {
9057 assert_eq!(
9058 ::std::mem::size_of::<btrfs_qgroup_info_item>(),
9059 40usize,
9060 concat!("Size of: ", stringify!(btrfs_qgroup_info_item))
9061 );
9062 assert_eq!(
9063 ::std::mem::align_of::<btrfs_qgroup_info_item>(),
9064 1usize,
9065 concat!("Alignment of ", stringify!(btrfs_qgroup_info_item))
9066 );
9067 fn test_field_generation() {
9068 assert_eq!(
9069 unsafe {
9070 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_info_item>::uninit();
9071 let ptr = uninit.as_ptr();
9072 ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
9073 },
9074 0usize,
9075 concat!(
9076 "Offset of field: ",
9077 stringify!(btrfs_qgroup_info_item),
9078 "::",
9079 stringify!(generation)
9080 )
9081 );
9082 }
9083 test_field_generation();
9084 fn test_field_rfer() {
9085 assert_eq!(
9086 unsafe {
9087 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_info_item>::uninit();
9088 let ptr = uninit.as_ptr();
9089 ::std::ptr::addr_of!((*ptr).rfer) as usize - ptr as usize
9090 },
9091 8usize,
9092 concat!(
9093 "Offset of field: ",
9094 stringify!(btrfs_qgroup_info_item),
9095 "::",
9096 stringify!(rfer)
9097 )
9098 );
9099 }
9100 test_field_rfer();
9101 fn test_field_rfer_cmpr() {
9102 assert_eq!(
9103 unsafe {
9104 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_info_item>::uninit();
9105 let ptr = uninit.as_ptr();
9106 ::std::ptr::addr_of!((*ptr).rfer_cmpr) as usize - ptr as usize
9107 },
9108 16usize,
9109 concat!(
9110 "Offset of field: ",
9111 stringify!(btrfs_qgroup_info_item),
9112 "::",
9113 stringify!(rfer_cmpr)
9114 )
9115 );
9116 }
9117 test_field_rfer_cmpr();
9118 fn test_field_excl() {
9119 assert_eq!(
9120 unsafe {
9121 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_info_item>::uninit();
9122 let ptr = uninit.as_ptr();
9123 ::std::ptr::addr_of!((*ptr).excl) as usize - ptr as usize
9124 },
9125 24usize,
9126 concat!(
9127 "Offset of field: ",
9128 stringify!(btrfs_qgroup_info_item),
9129 "::",
9130 stringify!(excl)
9131 )
9132 );
9133 }
9134 test_field_excl();
9135 fn test_field_excl_cmpr() {
9136 assert_eq!(
9137 unsafe {
9138 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_info_item>::uninit();
9139 let ptr = uninit.as_ptr();
9140 ::std::ptr::addr_of!((*ptr).excl_cmpr) as usize - ptr as usize
9141 },
9142 32usize,
9143 concat!(
9144 "Offset of field: ",
9145 stringify!(btrfs_qgroup_info_item),
9146 "::",
9147 stringify!(excl_cmpr)
9148 )
9149 );
9150 }
9151 test_field_excl_cmpr();
9152}
9153#[repr(C, packed)]
9154#[derive(Debug, Copy, Clone)]
9155pub struct btrfs_qgroup_limit_item {
9156 pub flags: __le64,
9157 pub max_rfer: __le64,
9158 pub max_excl: __le64,
9159 pub rsv_rfer: __le64,
9160 pub rsv_excl: __le64,
9161}
9162#[test]
9163fn bindgen_test_layout_btrfs_qgroup_limit_item() {
9164 assert_eq!(
9165 ::std::mem::size_of::<btrfs_qgroup_limit_item>(),
9166 40usize,
9167 concat!("Size of: ", stringify!(btrfs_qgroup_limit_item))
9168 );
9169 assert_eq!(
9170 ::std::mem::align_of::<btrfs_qgroup_limit_item>(),
9171 1usize,
9172 concat!("Alignment of ", stringify!(btrfs_qgroup_limit_item))
9173 );
9174 fn test_field_flags() {
9175 assert_eq!(
9176 unsafe {
9177 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit_item>::uninit();
9178 let ptr = uninit.as_ptr();
9179 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
9180 },
9181 0usize,
9182 concat!(
9183 "Offset of field: ",
9184 stringify!(btrfs_qgroup_limit_item),
9185 "::",
9186 stringify!(flags)
9187 )
9188 );
9189 }
9190 test_field_flags();
9191 fn test_field_max_rfer() {
9192 assert_eq!(
9193 unsafe {
9194 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit_item>::uninit();
9195 let ptr = uninit.as_ptr();
9196 ::std::ptr::addr_of!((*ptr).max_rfer) as usize - ptr as usize
9197 },
9198 8usize,
9199 concat!(
9200 "Offset of field: ",
9201 stringify!(btrfs_qgroup_limit_item),
9202 "::",
9203 stringify!(max_rfer)
9204 )
9205 );
9206 }
9207 test_field_max_rfer();
9208 fn test_field_max_excl() {
9209 assert_eq!(
9210 unsafe {
9211 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit_item>::uninit();
9212 let ptr = uninit.as_ptr();
9213 ::std::ptr::addr_of!((*ptr).max_excl) as usize - ptr as usize
9214 },
9215 16usize,
9216 concat!(
9217 "Offset of field: ",
9218 stringify!(btrfs_qgroup_limit_item),
9219 "::",
9220 stringify!(max_excl)
9221 )
9222 );
9223 }
9224 test_field_max_excl();
9225 fn test_field_rsv_rfer() {
9226 assert_eq!(
9227 unsafe {
9228 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit_item>::uninit();
9229 let ptr = uninit.as_ptr();
9230 ::std::ptr::addr_of!((*ptr).rsv_rfer) as usize - ptr as usize
9231 },
9232 24usize,
9233 concat!(
9234 "Offset of field: ",
9235 stringify!(btrfs_qgroup_limit_item),
9236 "::",
9237 stringify!(rsv_rfer)
9238 )
9239 );
9240 }
9241 test_field_rsv_rfer();
9242 fn test_field_rsv_excl() {
9243 assert_eq!(
9244 unsafe {
9245 let uninit = ::std::mem::MaybeUninit::<btrfs_qgroup_limit_item>::uninit();
9246 let ptr = uninit.as_ptr();
9247 ::std::ptr::addr_of!((*ptr).rsv_excl) as usize - ptr as usize
9248 },
9249 32usize,
9250 concat!(
9251 "Offset of field: ",
9252 stringify!(btrfs_qgroup_limit_item),
9253 "::",
9254 stringify!(rsv_excl)
9255 )
9256 );
9257 }
9258 test_field_rsv_excl();
9259}