1#![allow(non_upper_case_globals)]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4
5#[repr(C)]
8#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
9pub struct __BindgenBitfieldUnit<Storage> {
10 storage: Storage,
11}
12impl<Storage> __BindgenBitfieldUnit<Storage> {
13 #[inline]
14 pub const fn new(storage: Storage) -> Self {
15 Self { storage }
16 }
17}
18impl<Storage> __BindgenBitfieldUnit<Storage>
19where
20 Storage: AsRef<[u8]> + AsMut<[u8]>,
21{
22 #[inline]
23 pub fn get_bit(&self, index: usize) -> bool {
24 debug_assert!(index / 8 < self.storage.as_ref().len());
25 let byte_index = index / 8;
26 let byte = self.storage.as_ref()[byte_index];
27 let bit_index = if cfg!(target_endian = "big") {
28 7 - (index % 8)
29 } else {
30 index % 8
31 };
32 let mask = 1 << bit_index;
33 byte & mask == mask
34 }
35 #[inline]
36 pub fn set_bit(&mut self, index: usize, val: bool) {
37 debug_assert!(index / 8 < self.storage.as_ref().len());
38 let byte_index = index / 8;
39 let byte = &mut self.storage.as_mut()[byte_index];
40 let bit_index = if cfg!(target_endian = "big") {
41 7 - (index % 8)
42 } else {
43 index % 8
44 };
45 let mask = 1 << bit_index;
46 if val {
47 *byte |= mask;
48 } else {
49 *byte &= !mask;
50 }
51 }
52 #[inline]
53 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
54 debug_assert!(bit_width <= 64);
55 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
56 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
57 let mut val = 0;
58 for i in 0..(bit_width as usize) {
59 if self.get_bit(i + bit_offset) {
60 let index = if cfg!(target_endian = "big") {
61 bit_width as usize - 1 - i
62 } else {
63 i
64 };
65 val |= 1 << index;
66 }
67 }
68 val
69 }
70 #[inline]
71 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
72 debug_assert!(bit_width <= 64);
73 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
74 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
75 for i in 0..(bit_width as usize) {
76 let mask = 1 << i;
77 let val_bit_is_set = val & mask == mask;
78 let index = if cfg!(target_endian = "big") {
79 bit_width as usize - 1 - i
80 } else {
81 i
82 };
83 self.set_bit(index + bit_offset, val_bit_is_set);
84 }
85 }
86}
87pub const _BOOL_ALIGNMENT: u32 = 1;
88pub const _CHAR_ALIGNMENT: u32 = 1;
89pub const _SHORT_ALIGNMENT: u32 = 2;
90pub const _INT_ALIGNMENT: u32 = 4;
91pub const _FLOAT_ALIGNMENT: u32 = 4;
92pub const _FLOAT_COMPLEX_ALIGNMENT: u32 = 4;
93pub const _LONG_ALIGNMENT: u32 = 8;
94pub const _LONG_LONG_ALIGNMENT: u32 = 8;
95pub const _DOUBLE_ALIGNMENT: u32 = 8;
96pub const _DOUBLE_COMPLEX_ALIGNMENT: u32 = 8;
97pub const _LONG_DOUBLE_ALIGNMENT: u32 = 16;
98pub const _LONG_DOUBLE_COMPLEX_ALIGNMENT: u32 = 16;
99pub const _POINTER_ALIGNMENT: u32 = 8;
100pub const _MAX_ALIGNMENT: u32 = 16;
101pub const _ALIGNMENT_REQUIRED: u32 = 1;
102pub const _LONG_LONG_ALIGNMENT_32: u32 = 4;
103pub const _LARGEFILE64_SOURCE: u32 = 1;
104pub const _LARGEFILE_SOURCE: u32 = 1;
105pub const _FILE_OFFSET_BITS: u32 = 64;
106pub const _XOPEN_VERSION: u32 = 3;
107pub const __EXT1_VISIBLE: u32 = 0;
108pub const _DTRACE_VERSION: u32 = 1;
109pub const REG_LABEL_PC: u32 = 0;
110pub const REG_LABEL_SP: u32 = 1;
111pub const REG_LABEL_BP: u32 = 2;
112pub const REG_LABEL_RBX: u32 = 3;
113pub const REG_LABEL_R12: u32 = 4;
114pub const REG_LABEL_R13: u32 = 5;
115pub const REG_LABEL_R14: u32 = 6;
116pub const REG_LABEL_R15: u32 = 7;
117pub const REG_LABEL_MAX: u32 = 8;
118pub const _MUTEX_MAGIC: u32 = 19800;
119pub const _SEMA_MAGIC: u32 = 21325;
120pub const _COND_MAGIC: u32 = 17238;
121pub const _RWL_MAGIC: u32 = 21079;
122pub const P_MYID: i32 = -1;
123pub const __CLOCK_REALTIME0: u32 = 0;
124pub const CLOCK_VIRTUAL: u32 = 1;
125pub const CLOCK_THREAD_CPUTIME_ID: u32 = 2;
126pub const CLOCK_REALTIME: u32 = 3;
127pub const CLOCK_MONOTONIC: u32 = 4;
128pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 5;
129pub const CLOCK_HIGHRES: u32 = 4;
130pub const CLOCK_PROF: u32 = 2;
131pub const TIMER_RELTIME: u32 = 0;
132pub const TIMER_ABSTIME: u32 = 1;
133pub const DST_NONE: u32 = 0;
134pub const DST_USA: u32 = 1;
135pub const DST_AUST: u32 = 2;
136pub const DST_WET: u32 = 3;
137pub const DST_MET: u32 = 4;
138pub const DST_EET: u32 = 5;
139pub const DST_CAN: u32 = 6;
140pub const DST_GB: u32 = 7;
141pub const DST_RUM: u32 = 8;
142pub const DST_TUR: u32 = 9;
143pub const DST_AUSTALT: u32 = 10;
144pub const ITIMER_REAL: u32 = 0;
145pub const ITIMER_VIRTUAL: u32 = 1;
146pub const ITIMER_PROF: u32 = 2;
147pub const ITIMER_REALPROF: u32 = 3;
148pub const SEC: u32 = 1;
149pub const MILLISEC: u32 = 1000;
150pub const MICROSEC: u32 = 1000000;
151pub const NANOSEC: u32 = 1000000000;
152pub const CLOCKS_PER_SEC: u32 = 1000000;
153pub const TIME_UTC: u32 = 1;
154pub const FD_SETSIZE: u32 = 65536;
155pub const _NBBY: u32 = 8;
156pub const NBBY: u32 = 8;
157pub const UUID_LEN: u32 = 16;
158pub const UUID_PRINTABLE_STRING_LENGTH: u32 = 37;
159pub const EFI_LABEL_SIZE: u32 = 512;
160pub const EFI_SIGNATURE: u64 = 6075990659671082565;
161pub const EFI_MIN_ARRAY_SIZE: u32 = 16384;
162pub const EFI_PART_NAME_LEN: u32 = 36;
163pub const EFI_MIN_RESV_SIZE: u32 = 16384;
164pub const EFI_VERSION102: u32 = 65538;
165pub const EFI_VERSION100: u32 = 65536;
166pub const EFI_VERSION_CURRENT: u32 = 65536;
167pub const EFI_GPT_PRIMARY_CORRUPT: u32 = 1;
168pub const EFI_NUMPAR: u32 = 9;
169pub const DKL_MAGIC: u32 = 55998;
170pub const FKL_MAGIC: u32 = 255;
171pub const NDKMAP: u32 = 16;
172pub const DK_LABEL_LOC: u32 = 1;
173pub const LEN_DKL_ASCII: u32 = 128;
174pub const LEN_DKL_VVOL: u32 = 8;
175pub const DK_LABEL_SIZE: u32 = 512;
176pub const DK_MAX_BLOCKS: u32 = 2147483647;
177pub const DK_ACYL: u32 = 2;
178pub const DK_DEVID_BLKSIZE: u32 = 512;
179pub const DK_DEVID_REV_MSB: u32 = 0;
180pub const DK_DEVID_REV_LSB: u32 = 1;
181pub const V_NUMPAR: u32 = 16;
182pub const VTOC_SANE: u32 = 1611521774;
183pub const V_VERSION: u32 = 1;
184pub const V_EXTVERSION: u32 = 1;
185pub const V_UNASSIGNED: u32 = 0;
186pub const V_BOOT: u32 = 1;
187pub const V_ROOT: u32 = 2;
188pub const V_SWAP: u32 = 3;
189pub const V_USR: u32 = 4;
190pub const V_BACKUP: u32 = 5;
191pub const V_STAND: u32 = 6;
192pub const V_VAR: u32 = 7;
193pub const V_HOME: u32 = 8;
194pub const V_ALTSCTR: u32 = 9;
195pub const V_CACHE: u32 = 10;
196pub const V_RESERVED: u32 = 11;
197pub const V_SYSTEM: u32 = 12;
198pub const V_VXVM_PUB: u32 = 14;
199pub const V_VXVM_PRIV: u32 = 15;
200pub const V_BIOS_BOOT: u32 = 24;
201pub const V_NETBSD_FFS: u32 = 255;
202pub const V_FREEBSD_BOOT: u32 = 2304;
203pub const V_FREEBSD_SWAP: u32 = 2305;
204pub const V_FREEBSD_UFS: u32 = 2306;
205pub const V_FREEBSD_VINUM: u32 = 2307;
206pub const V_FREEBSD_ZFS: u32 = 2308;
207pub const V_FREEBSD_NANDFS: u32 = 2309;
208pub const V_UNKNOWN: u32 = 65535;
209pub const V_UNMNT: u32 = 1;
210pub const V_RONLY: u32 = 16;
211pub const VT_ERROR: i32 = -2;
212pub const VT_EIO: i32 = -3;
213pub const VT_EINVAL: i32 = -4;
214pub const VT_ENOTSUP: i32 = -5;
215pub const VT_ENOSPC: i32 = -6;
216pub const VT_EOVERFLOW: i32 = -7;
217pub const CK_CHECKSUM: u32 = 0;
218pub const CK_MAKESUM: u32 = 1;
219#[repr(C)]
220#[derive(Debug, Copy, Clone)]
221pub struct _label_t {
222 pub val: [::std::os::raw::c_long; 8usize],
223}
224#[test]
225fn bindgen_test_layout__label_t() {
226 const UNINIT: ::std::mem::MaybeUninit<_label_t> = ::std::mem::MaybeUninit::uninit();
227 let ptr = UNINIT.as_ptr();
228 assert_eq!(
229 ::std::mem::size_of::<_label_t>(),
230 64usize,
231 concat!("Size of: ", stringify!(_label_t))
232 );
233 assert_eq!(
234 ::std::mem::align_of::<_label_t>(),
235 8usize,
236 concat!("Alignment of ", stringify!(_label_t))
237 );
238 assert_eq!(
239 unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
240 0usize,
241 concat!(
242 "Offset of field: ",
243 stringify!(_label_t),
244 "::",
245 stringify!(val)
246 )
247 );
248}
249pub type label_t = _label_t;
250pub type lock_t = ::std::os::raw::c_uchar;
251pub type intmax_t = i64;
252pub type uintmax_t = u64;
253pub type int_fast8_t = ::std::os::raw::c_char;
254pub type int_fast16_t = ::std::os::raw::c_int;
255pub type int_fast32_t = ::std::os::raw::c_int;
256pub type int_fast64_t = ::std::os::raw::c_long;
257pub type uint_fast8_t = ::std::os::raw::c_uchar;
258pub type uint_fast16_t = ::std::os::raw::c_uint;
259pub type uint_fast32_t = ::std::os::raw::c_uint;
260pub type uint_fast64_t = ::std::os::raw::c_ulong;
261pub type int_least8_t = ::std::os::raw::c_char;
262pub type int_least16_t = ::std::os::raw::c_short;
263pub type int_least32_t = ::std::os::raw::c_int;
264pub type int_least64_t = ::std::os::raw::c_long;
265pub type uint_least8_t = ::std::os::raw::c_uchar;
266pub type uint_least16_t = ::std::os::raw::c_ushort;
267pub type uint_least32_t = ::std::os::raw::c_uint;
268pub type uint_least64_t = ::std::os::raw::c_ulong;
269pub type longlong_t = ::std::os::raw::c_longlong;
270pub type u_longlong_t = ::std::os::raw::c_ulonglong;
271pub type t_scalar_t = i32;
272pub type t_uscalar_t = u32;
273pub type uchar_t = ::std::os::raw::c_uchar;
274pub type ushort_t = ::std::os::raw::c_ushort;
275pub type uint_t = ::std::os::raw::c_uint;
276pub type ulong_t = ::std::os::raw::c_ulong;
277pub type caddr_t = *mut ::std::os::raw::c_char;
278pub type daddr_t = ::std::os::raw::c_long;
279pub type cnt_t = ::std::os::raw::c_short;
280pub type pfn_t = ulong_t;
281pub type pgcnt_t = ulong_t;
282pub type spgcnt_t = ::std::os::raw::c_long;
283pub type use_t = uchar_t;
284pub type sysid_t = ::std::os::raw::c_short;
285pub type index_t = ::std::os::raw::c_short;
286pub type timeout_id_t = *mut ::std::os::raw::c_void;
287pub type bufcall_id_t = *mut ::std::os::raw::c_void;
288pub type off_t = ::std::os::raw::c_long;
289pub type off64_t = off_t;
290pub type ino_t = ulong_t;
291pub type blkcnt_t = ::std::os::raw::c_long;
292pub type fsblkcnt_t = ulong_t;
293pub type fsfilcnt_t = ulong_t;
294pub type ino64_t = ino_t;
295pub type blkcnt64_t = blkcnt_t;
296pub type fsblkcnt64_t = fsblkcnt_t;
297pub type fsfilcnt64_t = fsfilcnt_t;
298pub type blksize_t = ::std::os::raw::c_int;
299pub const boolean_t_B_FALSE: boolean_t = 0;
300pub const boolean_t_B_TRUE: boolean_t = 1;
301pub const boolean_t__B_FALSE: boolean_t = 0;
302pub const boolean_t__B_TRUE: boolean_t = 1;
303pub type boolean_t = ::std::os::raw::c_uint;
304pub type pad64_t = i64;
305pub type upad64_t = u64;
306#[repr(C)]
307#[repr(align(16))]
308#[derive(Copy, Clone)]
309pub union pad128_t {
310 pub _q: u128,
311 pub _l: [i32; 4usize],
312}
313#[test]
314fn bindgen_test_layout_pad128_t() {
315 const UNINIT: ::std::mem::MaybeUninit<pad128_t> = ::std::mem::MaybeUninit::uninit();
316 let ptr = UNINIT.as_ptr();
317 assert_eq!(
318 ::std::mem::size_of::<pad128_t>(),
319 16usize,
320 concat!("Size of: ", stringify!(pad128_t))
321 );
322 assert_eq!(
323 ::std::mem::align_of::<pad128_t>(),
324 16usize,
325 concat!("Alignment of ", stringify!(pad128_t))
326 );
327 assert_eq!(
328 unsafe { ::std::ptr::addr_of!((*ptr)._q) as usize - ptr as usize },
329 0usize,
330 concat!(
331 "Offset of field: ",
332 stringify!(pad128_t),
333 "::",
334 stringify!(_q)
335 )
336 );
337 assert_eq!(
338 unsafe { ::std::ptr::addr_of!((*ptr)._l) as usize - ptr as usize },
339 0usize,
340 concat!(
341 "Offset of field: ",
342 stringify!(pad128_t),
343 "::",
344 stringify!(_l)
345 )
346 );
347}
348#[repr(C)]
349#[repr(align(16))]
350#[derive(Copy, Clone)]
351pub union upad128_t {
352 pub _q: u128,
353 pub _l: [u32; 4usize],
354}
355#[test]
356fn bindgen_test_layout_upad128_t() {
357 const UNINIT: ::std::mem::MaybeUninit<upad128_t> = ::std::mem::MaybeUninit::uninit();
358 let ptr = UNINIT.as_ptr();
359 assert_eq!(
360 ::std::mem::size_of::<upad128_t>(),
361 16usize,
362 concat!("Size of: ", stringify!(upad128_t))
363 );
364 assert_eq!(
365 ::std::mem::align_of::<upad128_t>(),
366 16usize,
367 concat!("Alignment of ", stringify!(upad128_t))
368 );
369 assert_eq!(
370 unsafe { ::std::ptr::addr_of!((*ptr)._q) as usize - ptr as usize },
371 0usize,
372 concat!(
373 "Offset of field: ",
374 stringify!(upad128_t),
375 "::",
376 stringify!(_q)
377 )
378 );
379 assert_eq!(
380 unsafe { ::std::ptr::addr_of!((*ptr)._l) as usize - ptr as usize },
381 0usize,
382 concat!(
383 "Offset of field: ",
384 stringify!(upad128_t),
385 "::",
386 stringify!(_l)
387 )
388 );
389}
390pub type offset_t = longlong_t;
391pub type u_offset_t = u_longlong_t;
392pub type len_t = u_longlong_t;
393pub type diskaddr_t = u_longlong_t;
394#[repr(C)]
395#[derive(Copy, Clone)]
396pub union lloff_t {
397 pub _f: offset_t,
398 pub _p: lloff_t__bindgen_ty_1,
399}
400#[repr(C)]
401#[derive(Debug, Copy, Clone)]
402pub struct lloff_t__bindgen_ty_1 {
403 pub _l: i32,
404 pub _u: i32,
405}
406#[test]
407fn bindgen_test_layout_lloff_t__bindgen_ty_1() {
408 const UNINIT: ::std::mem::MaybeUninit<lloff_t__bindgen_ty_1> =
409 ::std::mem::MaybeUninit::uninit();
410 let ptr = UNINIT.as_ptr();
411 assert_eq!(
412 ::std::mem::size_of::<lloff_t__bindgen_ty_1>(),
413 8usize,
414 concat!("Size of: ", stringify!(lloff_t__bindgen_ty_1))
415 );
416 assert_eq!(
417 ::std::mem::align_of::<lloff_t__bindgen_ty_1>(),
418 4usize,
419 concat!("Alignment of ", stringify!(lloff_t__bindgen_ty_1))
420 );
421 assert_eq!(
422 unsafe { ::std::ptr::addr_of!((*ptr)._l) as usize - ptr as usize },
423 0usize,
424 concat!(
425 "Offset of field: ",
426 stringify!(lloff_t__bindgen_ty_1),
427 "::",
428 stringify!(_l)
429 )
430 );
431 assert_eq!(
432 unsafe { ::std::ptr::addr_of!((*ptr)._u) as usize - ptr as usize },
433 4usize,
434 concat!(
435 "Offset of field: ",
436 stringify!(lloff_t__bindgen_ty_1),
437 "::",
438 stringify!(_u)
439 )
440 );
441}
442#[test]
443fn bindgen_test_layout_lloff_t() {
444 const UNINIT: ::std::mem::MaybeUninit<lloff_t> = ::std::mem::MaybeUninit::uninit();
445 let ptr = UNINIT.as_ptr();
446 assert_eq!(
447 ::std::mem::size_of::<lloff_t>(),
448 8usize,
449 concat!("Size of: ", stringify!(lloff_t))
450 );
451 assert_eq!(
452 ::std::mem::align_of::<lloff_t>(),
453 8usize,
454 concat!("Alignment of ", stringify!(lloff_t))
455 );
456 assert_eq!(
457 unsafe { ::std::ptr::addr_of!((*ptr)._f) as usize - ptr as usize },
458 0usize,
459 concat!(
460 "Offset of field: ",
461 stringify!(lloff_t),
462 "::",
463 stringify!(_f)
464 )
465 );
466 assert_eq!(
467 unsafe { ::std::ptr::addr_of!((*ptr)._p) as usize - ptr as usize },
468 0usize,
469 concat!(
470 "Offset of field: ",
471 stringify!(lloff_t),
472 "::",
473 stringify!(_p)
474 )
475 );
476}
477#[repr(C)]
478#[derive(Copy, Clone)]
479pub union lldaddr_t {
480 pub _f: longlong_t,
481 pub _p: lldaddr_t__bindgen_ty_1,
482}
483#[repr(C)]
484#[derive(Debug, Copy, Clone)]
485pub struct lldaddr_t__bindgen_ty_1 {
486 pub _l: i32,
487 pub _u: i32,
488}
489#[test]
490fn bindgen_test_layout_lldaddr_t__bindgen_ty_1() {
491 const UNINIT: ::std::mem::MaybeUninit<lldaddr_t__bindgen_ty_1> =
492 ::std::mem::MaybeUninit::uninit();
493 let ptr = UNINIT.as_ptr();
494 assert_eq!(
495 ::std::mem::size_of::<lldaddr_t__bindgen_ty_1>(),
496 8usize,
497 concat!("Size of: ", stringify!(lldaddr_t__bindgen_ty_1))
498 );
499 assert_eq!(
500 ::std::mem::align_of::<lldaddr_t__bindgen_ty_1>(),
501 4usize,
502 concat!("Alignment of ", stringify!(lldaddr_t__bindgen_ty_1))
503 );
504 assert_eq!(
505 unsafe { ::std::ptr::addr_of!((*ptr)._l) as usize - ptr as usize },
506 0usize,
507 concat!(
508 "Offset of field: ",
509 stringify!(lldaddr_t__bindgen_ty_1),
510 "::",
511 stringify!(_l)
512 )
513 );
514 assert_eq!(
515 unsafe { ::std::ptr::addr_of!((*ptr)._u) as usize - ptr as usize },
516 4usize,
517 concat!(
518 "Offset of field: ",
519 stringify!(lldaddr_t__bindgen_ty_1),
520 "::",
521 stringify!(_u)
522 )
523 );
524}
525#[test]
526fn bindgen_test_layout_lldaddr_t() {
527 const UNINIT: ::std::mem::MaybeUninit<lldaddr_t> = ::std::mem::MaybeUninit::uninit();
528 let ptr = UNINIT.as_ptr();
529 assert_eq!(
530 ::std::mem::size_of::<lldaddr_t>(),
531 8usize,
532 concat!("Size of: ", stringify!(lldaddr_t))
533 );
534 assert_eq!(
535 ::std::mem::align_of::<lldaddr_t>(),
536 8usize,
537 concat!("Alignment of ", stringify!(lldaddr_t))
538 );
539 assert_eq!(
540 unsafe { ::std::ptr::addr_of!((*ptr)._f) as usize - ptr as usize },
541 0usize,
542 concat!(
543 "Offset of field: ",
544 stringify!(lldaddr_t),
545 "::",
546 stringify!(_f)
547 )
548 );
549 assert_eq!(
550 unsafe { ::std::ptr::addr_of!((*ptr)._p) as usize - ptr as usize },
551 0usize,
552 concat!(
553 "Offset of field: ",
554 stringify!(lldaddr_t),
555 "::",
556 stringify!(_p)
557 )
558 );
559}
560pub type k_fltset_t = uint_t;
561pub type id_t = ::std::os::raw::c_int;
562pub type lgrp_id_t = id_t;
563pub type useconds_t = uint_t;
564pub type suseconds_t = ::std::os::raw::c_long;
565pub type major_t = uint_t;
566pub type minor_t = uint_t;
567pub type pri_t = ::std::os::raw::c_short;
568pub type cpu_flag_t = ushort_t;
569pub type o_mode_t = ushort_t;
570pub type o_dev_t = ::std::os::raw::c_short;
571pub type o_uid_t = ushort_t;
572pub type o_gid_t = o_uid_t;
573pub type o_nlink_t = ::std::os::raw::c_short;
574pub type o_pid_t = ::std::os::raw::c_short;
575pub type o_ino_t = ushort_t;
576pub type key_t = ::std::os::raw::c_int;
577pub type mode_t = uint_t;
578pub type uid_t = ::std::os::raw::c_uint;
579pub type gid_t = uid_t;
580pub type datalink_id_t = u32;
581pub type vrid_t = u32;
582pub type taskid_t = id_t;
583pub type projid_t = id_t;
584pub type poolid_t = id_t;
585pub type zoneid_t = id_t;
586pub type ctid_t = id_t;
587pub type pthread_t = uint_t;
588pub type pthread_key_t = uint_t;
589#[repr(C)]
590#[derive(Copy, Clone)]
591pub struct _pthread_mutex {
592 pub __pthread_mutex_flags: _pthread_mutex__bindgen_ty_1,
593 pub __pthread_mutex_lock: _pthread_mutex__bindgen_ty_2,
594 pub __pthread_mutex_data: upad64_t,
595}
596#[repr(C)]
597#[derive(Debug, Copy, Clone)]
598pub struct _pthread_mutex__bindgen_ty_1 {
599 pub __pthread_mutex_flag1: u16,
600 pub __pthread_mutex_flag2: u8,
601 pub __pthread_mutex_ceiling: u8,
602 pub __pthread_mutex_type: u16,
603 pub __pthread_mutex_magic: u16,
604}
605#[test]
606fn bindgen_test_layout__pthread_mutex__bindgen_ty_1() {
607 const UNINIT: ::std::mem::MaybeUninit<_pthread_mutex__bindgen_ty_1> =
608 ::std::mem::MaybeUninit::uninit();
609 let ptr = UNINIT.as_ptr();
610 assert_eq!(
611 ::std::mem::size_of::<_pthread_mutex__bindgen_ty_1>(),
612 8usize,
613 concat!("Size of: ", stringify!(_pthread_mutex__bindgen_ty_1))
614 );
615 assert_eq!(
616 ::std::mem::align_of::<_pthread_mutex__bindgen_ty_1>(),
617 2usize,
618 concat!("Alignment of ", stringify!(_pthread_mutex__bindgen_ty_1))
619 );
620 assert_eq!(
621 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_flag1) as usize - ptr as usize },
622 0usize,
623 concat!(
624 "Offset of field: ",
625 stringify!(_pthread_mutex__bindgen_ty_1),
626 "::",
627 stringify!(__pthread_mutex_flag1)
628 )
629 );
630 assert_eq!(
631 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_flag2) as usize - ptr as usize },
632 2usize,
633 concat!(
634 "Offset of field: ",
635 stringify!(_pthread_mutex__bindgen_ty_1),
636 "::",
637 stringify!(__pthread_mutex_flag2)
638 )
639 );
640 assert_eq!(
641 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_ceiling) as usize - ptr as usize },
642 3usize,
643 concat!(
644 "Offset of field: ",
645 stringify!(_pthread_mutex__bindgen_ty_1),
646 "::",
647 stringify!(__pthread_mutex_ceiling)
648 )
649 );
650 assert_eq!(
651 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_type) as usize - ptr as usize },
652 4usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(_pthread_mutex__bindgen_ty_1),
656 "::",
657 stringify!(__pthread_mutex_type)
658 )
659 );
660 assert_eq!(
661 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_magic) as usize - ptr as usize },
662 6usize,
663 concat!(
664 "Offset of field: ",
665 stringify!(_pthread_mutex__bindgen_ty_1),
666 "::",
667 stringify!(__pthread_mutex_magic)
668 )
669 );
670}
671#[repr(C)]
672#[derive(Copy, Clone)]
673pub union _pthread_mutex__bindgen_ty_2 {
674 pub __pthread_mutex_lock64: _pthread_mutex__bindgen_ty_2__bindgen_ty_1,
675 pub __pthread_mutex_lock32: _pthread_mutex__bindgen_ty_2__bindgen_ty_2,
676 pub __pthread_mutex_owner64: upad64_t,
677}
678#[repr(C)]
679#[derive(Debug, Copy, Clone)]
680pub struct _pthread_mutex__bindgen_ty_2__bindgen_ty_1 {
681 pub __pthread_mutex_pad: [u8; 8usize],
682}
683#[test]
684fn bindgen_test_layout__pthread_mutex__bindgen_ty_2__bindgen_ty_1() {
685 const UNINIT: ::std::mem::MaybeUninit<_pthread_mutex__bindgen_ty_2__bindgen_ty_1> =
686 ::std::mem::MaybeUninit::uninit();
687 let ptr = UNINIT.as_ptr();
688 assert_eq!(
689 ::std::mem::size_of::<_pthread_mutex__bindgen_ty_2__bindgen_ty_1>(),
690 8usize,
691 concat!(
692 "Size of: ",
693 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_1)
694 )
695 );
696 assert_eq!(
697 ::std::mem::align_of::<_pthread_mutex__bindgen_ty_2__bindgen_ty_1>(),
698 1usize,
699 concat!(
700 "Alignment of ",
701 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_1)
702 )
703 );
704 assert_eq!(
705 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_pad) as usize - ptr as usize },
706 0usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_1),
710 "::",
711 stringify!(__pthread_mutex_pad)
712 )
713 );
714}
715#[repr(C)]
716#[derive(Debug, Copy, Clone)]
717pub struct _pthread_mutex__bindgen_ty_2__bindgen_ty_2 {
718 pub __pthread_ownerpid: u32,
719 pub __pthread_lockword: u32,
720}
721#[test]
722fn bindgen_test_layout__pthread_mutex__bindgen_ty_2__bindgen_ty_2() {
723 const UNINIT: ::std::mem::MaybeUninit<_pthread_mutex__bindgen_ty_2__bindgen_ty_2> =
724 ::std::mem::MaybeUninit::uninit();
725 let ptr = UNINIT.as_ptr();
726 assert_eq!(
727 ::std::mem::size_of::<_pthread_mutex__bindgen_ty_2__bindgen_ty_2>(),
728 8usize,
729 concat!(
730 "Size of: ",
731 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_2)
732 )
733 );
734 assert_eq!(
735 ::std::mem::align_of::<_pthread_mutex__bindgen_ty_2__bindgen_ty_2>(),
736 4usize,
737 concat!(
738 "Alignment of ",
739 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_2)
740 )
741 );
742 assert_eq!(
743 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_ownerpid) as usize - ptr as usize },
744 0usize,
745 concat!(
746 "Offset of field: ",
747 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_2),
748 "::",
749 stringify!(__pthread_ownerpid)
750 )
751 );
752 assert_eq!(
753 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_lockword) as usize - ptr as usize },
754 4usize,
755 concat!(
756 "Offset of field: ",
757 stringify!(_pthread_mutex__bindgen_ty_2__bindgen_ty_2),
758 "::",
759 stringify!(__pthread_lockword)
760 )
761 );
762}
763#[test]
764fn bindgen_test_layout__pthread_mutex__bindgen_ty_2() {
765 const UNINIT: ::std::mem::MaybeUninit<_pthread_mutex__bindgen_ty_2> =
766 ::std::mem::MaybeUninit::uninit();
767 let ptr = UNINIT.as_ptr();
768 assert_eq!(
769 ::std::mem::size_of::<_pthread_mutex__bindgen_ty_2>(),
770 8usize,
771 concat!("Size of: ", stringify!(_pthread_mutex__bindgen_ty_2))
772 );
773 assert_eq!(
774 ::std::mem::align_of::<_pthread_mutex__bindgen_ty_2>(),
775 8usize,
776 concat!("Alignment of ", stringify!(_pthread_mutex__bindgen_ty_2))
777 );
778 assert_eq!(
779 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_lock64) as usize - ptr as usize },
780 0usize,
781 concat!(
782 "Offset of field: ",
783 stringify!(_pthread_mutex__bindgen_ty_2),
784 "::",
785 stringify!(__pthread_mutex_lock64)
786 )
787 );
788 assert_eq!(
789 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_lock32) as usize - ptr as usize },
790 0usize,
791 concat!(
792 "Offset of field: ",
793 stringify!(_pthread_mutex__bindgen_ty_2),
794 "::",
795 stringify!(__pthread_mutex_lock32)
796 )
797 );
798 assert_eq!(
799 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_owner64) as usize - ptr as usize },
800 0usize,
801 concat!(
802 "Offset of field: ",
803 stringify!(_pthread_mutex__bindgen_ty_2),
804 "::",
805 stringify!(__pthread_mutex_owner64)
806 )
807 );
808}
809#[test]
810fn bindgen_test_layout__pthread_mutex() {
811 const UNINIT: ::std::mem::MaybeUninit<_pthread_mutex> = ::std::mem::MaybeUninit::uninit();
812 let ptr = UNINIT.as_ptr();
813 assert_eq!(
814 ::std::mem::size_of::<_pthread_mutex>(),
815 24usize,
816 concat!("Size of: ", stringify!(_pthread_mutex))
817 );
818 assert_eq!(
819 ::std::mem::align_of::<_pthread_mutex>(),
820 8usize,
821 concat!("Alignment of ", stringify!(_pthread_mutex))
822 );
823 assert_eq!(
824 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_flags) as usize - ptr as usize },
825 0usize,
826 concat!(
827 "Offset of field: ",
828 stringify!(_pthread_mutex),
829 "::",
830 stringify!(__pthread_mutex_flags)
831 )
832 );
833 assert_eq!(
834 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_lock) as usize - ptr as usize },
835 8usize,
836 concat!(
837 "Offset of field: ",
838 stringify!(_pthread_mutex),
839 "::",
840 stringify!(__pthread_mutex_lock)
841 )
842 );
843 assert_eq!(
844 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutex_data) as usize - ptr as usize },
845 16usize,
846 concat!(
847 "Offset of field: ",
848 stringify!(_pthread_mutex),
849 "::",
850 stringify!(__pthread_mutex_data)
851 )
852 );
853}
854pub type pthread_mutex_t = _pthread_mutex;
855#[repr(C)]
856#[derive(Debug, Copy, Clone)]
857pub struct _pthread_cond {
858 pub __pthread_cond_flags: _pthread_cond__bindgen_ty_1,
859 pub __pthread_cond_data: upad64_t,
860}
861#[repr(C)]
862#[derive(Debug, Copy, Clone)]
863pub struct _pthread_cond__bindgen_ty_1 {
864 pub __pthread_cond_flag: [u8; 4usize],
865 pub __pthread_cond_type: u16,
866 pub __pthread_cond_magic: u16,
867}
868#[test]
869fn bindgen_test_layout__pthread_cond__bindgen_ty_1() {
870 const UNINIT: ::std::mem::MaybeUninit<_pthread_cond__bindgen_ty_1> =
871 ::std::mem::MaybeUninit::uninit();
872 let ptr = UNINIT.as_ptr();
873 assert_eq!(
874 ::std::mem::size_of::<_pthread_cond__bindgen_ty_1>(),
875 8usize,
876 concat!("Size of: ", stringify!(_pthread_cond__bindgen_ty_1))
877 );
878 assert_eq!(
879 ::std::mem::align_of::<_pthread_cond__bindgen_ty_1>(),
880 2usize,
881 concat!("Alignment of ", stringify!(_pthread_cond__bindgen_ty_1))
882 );
883 assert_eq!(
884 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_cond_flag) as usize - ptr as usize },
885 0usize,
886 concat!(
887 "Offset of field: ",
888 stringify!(_pthread_cond__bindgen_ty_1),
889 "::",
890 stringify!(__pthread_cond_flag)
891 )
892 );
893 assert_eq!(
894 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_cond_type) as usize - ptr as usize },
895 4usize,
896 concat!(
897 "Offset of field: ",
898 stringify!(_pthread_cond__bindgen_ty_1),
899 "::",
900 stringify!(__pthread_cond_type)
901 )
902 );
903 assert_eq!(
904 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_cond_magic) as usize - ptr as usize },
905 6usize,
906 concat!(
907 "Offset of field: ",
908 stringify!(_pthread_cond__bindgen_ty_1),
909 "::",
910 stringify!(__pthread_cond_magic)
911 )
912 );
913}
914#[test]
915fn bindgen_test_layout__pthread_cond() {
916 const UNINIT: ::std::mem::MaybeUninit<_pthread_cond> = ::std::mem::MaybeUninit::uninit();
917 let ptr = UNINIT.as_ptr();
918 assert_eq!(
919 ::std::mem::size_of::<_pthread_cond>(),
920 16usize,
921 concat!("Size of: ", stringify!(_pthread_cond))
922 );
923 assert_eq!(
924 ::std::mem::align_of::<_pthread_cond>(),
925 8usize,
926 concat!("Alignment of ", stringify!(_pthread_cond))
927 );
928 assert_eq!(
929 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_cond_flags) as usize - ptr as usize },
930 0usize,
931 concat!(
932 "Offset of field: ",
933 stringify!(_pthread_cond),
934 "::",
935 stringify!(__pthread_cond_flags)
936 )
937 );
938 assert_eq!(
939 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_cond_data) as usize - ptr as usize },
940 8usize,
941 concat!(
942 "Offset of field: ",
943 stringify!(_pthread_cond),
944 "::",
945 stringify!(__pthread_cond_data)
946 )
947 );
948}
949pub type pthread_cond_t = _pthread_cond;
950#[repr(C)]
951#[derive(Copy, Clone)]
952pub struct _pthread_rwlock {
953 pub __pthread_rwlock_readers: i32,
954 pub __pthread_rwlock_type: u16,
955 pub __pthread_rwlock_magic: u16,
956 pub __pthread_rwlock_mutex: pthread_mutex_t,
957 pub __pthread_rwlock_readercv: pthread_cond_t,
958 pub __pthread_rwlock_writercv: pthread_cond_t,
959}
960#[test]
961fn bindgen_test_layout__pthread_rwlock() {
962 const UNINIT: ::std::mem::MaybeUninit<_pthread_rwlock> = ::std::mem::MaybeUninit::uninit();
963 let ptr = UNINIT.as_ptr();
964 assert_eq!(
965 ::std::mem::size_of::<_pthread_rwlock>(),
966 64usize,
967 concat!("Size of: ", stringify!(_pthread_rwlock))
968 );
969 assert_eq!(
970 ::std::mem::align_of::<_pthread_rwlock>(),
971 8usize,
972 concat!("Alignment of ", stringify!(_pthread_rwlock))
973 );
974 assert_eq!(
975 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlock_readers) as usize - ptr as usize },
976 0usize,
977 concat!(
978 "Offset of field: ",
979 stringify!(_pthread_rwlock),
980 "::",
981 stringify!(__pthread_rwlock_readers)
982 )
983 );
984 assert_eq!(
985 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlock_type) as usize - ptr as usize },
986 4usize,
987 concat!(
988 "Offset of field: ",
989 stringify!(_pthread_rwlock),
990 "::",
991 stringify!(__pthread_rwlock_type)
992 )
993 );
994 assert_eq!(
995 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlock_magic) as usize - ptr as usize },
996 6usize,
997 concat!(
998 "Offset of field: ",
999 stringify!(_pthread_rwlock),
1000 "::",
1001 stringify!(__pthread_rwlock_magic)
1002 )
1003 );
1004 assert_eq!(
1005 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlock_mutex) as usize - ptr as usize },
1006 8usize,
1007 concat!(
1008 "Offset of field: ",
1009 stringify!(_pthread_rwlock),
1010 "::",
1011 stringify!(__pthread_rwlock_mutex)
1012 )
1013 );
1014 assert_eq!(
1015 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlock_readercv) as usize - ptr as usize },
1016 32usize,
1017 concat!(
1018 "Offset of field: ",
1019 stringify!(_pthread_rwlock),
1020 "::",
1021 stringify!(__pthread_rwlock_readercv)
1022 )
1023 );
1024 assert_eq!(
1025 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlock_writercv) as usize - ptr as usize },
1026 48usize,
1027 concat!(
1028 "Offset of field: ",
1029 stringify!(_pthread_rwlock),
1030 "::",
1031 stringify!(__pthread_rwlock_writercv)
1032 )
1033 );
1034}
1035pub type pthread_rwlock_t = _pthread_rwlock;
1036#[repr(C)]
1037#[derive(Copy, Clone)]
1038pub struct pthread_barrier_t {
1039 pub __pthread_barrier_count: u32,
1040 pub __pthread_barrier_current: u32,
1041 pub __pthread_barrier_cycle: upad64_t,
1042 pub __pthread_barrier_reserved: upad64_t,
1043 pub __pthread_barrier_lock: pthread_mutex_t,
1044 pub __pthread_barrier_cond: pthread_cond_t,
1045}
1046#[test]
1047fn bindgen_test_layout_pthread_barrier_t() {
1048 const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
1049 let ptr = UNINIT.as_ptr();
1050 assert_eq!(
1051 ::std::mem::size_of::<pthread_barrier_t>(),
1052 64usize,
1053 concat!("Size of: ", stringify!(pthread_barrier_t))
1054 );
1055 assert_eq!(
1056 ::std::mem::align_of::<pthread_barrier_t>(),
1057 8usize,
1058 concat!("Alignment of ", stringify!(pthread_barrier_t))
1059 );
1060 assert_eq!(
1061 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrier_count) as usize - ptr as usize },
1062 0usize,
1063 concat!(
1064 "Offset of field: ",
1065 stringify!(pthread_barrier_t),
1066 "::",
1067 stringify!(__pthread_barrier_count)
1068 )
1069 );
1070 assert_eq!(
1071 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrier_current) as usize - ptr as usize },
1072 4usize,
1073 concat!(
1074 "Offset of field: ",
1075 stringify!(pthread_barrier_t),
1076 "::",
1077 stringify!(__pthread_barrier_current)
1078 )
1079 );
1080 assert_eq!(
1081 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrier_cycle) as usize - ptr as usize },
1082 8usize,
1083 concat!(
1084 "Offset of field: ",
1085 stringify!(pthread_barrier_t),
1086 "::",
1087 stringify!(__pthread_barrier_cycle)
1088 )
1089 );
1090 assert_eq!(
1091 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrier_reserved) as usize - ptr as usize },
1092 16usize,
1093 concat!(
1094 "Offset of field: ",
1095 stringify!(pthread_barrier_t),
1096 "::",
1097 stringify!(__pthread_barrier_reserved)
1098 )
1099 );
1100 assert_eq!(
1101 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrier_lock) as usize - ptr as usize },
1102 24usize,
1103 concat!(
1104 "Offset of field: ",
1105 stringify!(pthread_barrier_t),
1106 "::",
1107 stringify!(__pthread_barrier_lock)
1108 )
1109 );
1110 assert_eq!(
1111 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrier_cond) as usize - ptr as usize },
1112 48usize,
1113 concat!(
1114 "Offset of field: ",
1115 stringify!(pthread_barrier_t),
1116 "::",
1117 stringify!(__pthread_barrier_cond)
1118 )
1119 );
1120}
1121pub type pthread_spinlock_t = pthread_mutex_t;
1122#[repr(C)]
1123#[derive(Debug, Copy, Clone)]
1124pub struct _pthread_attr {
1125 pub __pthread_attrp: *mut ::std::os::raw::c_void,
1126}
1127#[test]
1128fn bindgen_test_layout__pthread_attr() {
1129 const UNINIT: ::std::mem::MaybeUninit<_pthread_attr> = ::std::mem::MaybeUninit::uninit();
1130 let ptr = UNINIT.as_ptr();
1131 assert_eq!(
1132 ::std::mem::size_of::<_pthread_attr>(),
1133 8usize,
1134 concat!("Size of: ", stringify!(_pthread_attr))
1135 );
1136 assert_eq!(
1137 ::std::mem::align_of::<_pthread_attr>(),
1138 8usize,
1139 concat!("Alignment of ", stringify!(_pthread_attr))
1140 );
1141 assert_eq!(
1142 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_attrp) as usize - ptr as usize },
1143 0usize,
1144 concat!(
1145 "Offset of field: ",
1146 stringify!(_pthread_attr),
1147 "::",
1148 stringify!(__pthread_attrp)
1149 )
1150 );
1151}
1152pub type pthread_attr_t = _pthread_attr;
1153#[repr(C)]
1154#[derive(Debug, Copy, Clone)]
1155pub struct _pthread_mutexattr {
1156 pub __pthread_mutexattrp: *mut ::std::os::raw::c_void,
1157}
1158#[test]
1159fn bindgen_test_layout__pthread_mutexattr() {
1160 const UNINIT: ::std::mem::MaybeUninit<_pthread_mutexattr> = ::std::mem::MaybeUninit::uninit();
1161 let ptr = UNINIT.as_ptr();
1162 assert_eq!(
1163 ::std::mem::size_of::<_pthread_mutexattr>(),
1164 8usize,
1165 concat!("Size of: ", stringify!(_pthread_mutexattr))
1166 );
1167 assert_eq!(
1168 ::std::mem::align_of::<_pthread_mutexattr>(),
1169 8usize,
1170 concat!("Alignment of ", stringify!(_pthread_mutexattr))
1171 );
1172 assert_eq!(
1173 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_mutexattrp) as usize - ptr as usize },
1174 0usize,
1175 concat!(
1176 "Offset of field: ",
1177 stringify!(_pthread_mutexattr),
1178 "::",
1179 stringify!(__pthread_mutexattrp)
1180 )
1181 );
1182}
1183pub type pthread_mutexattr_t = _pthread_mutexattr;
1184#[repr(C)]
1185#[derive(Debug, Copy, Clone)]
1186pub struct _pthread_condattr {
1187 pub __pthread_condattrp: *mut ::std::os::raw::c_void,
1188}
1189#[test]
1190fn bindgen_test_layout__pthread_condattr() {
1191 const UNINIT: ::std::mem::MaybeUninit<_pthread_condattr> = ::std::mem::MaybeUninit::uninit();
1192 let ptr = UNINIT.as_ptr();
1193 assert_eq!(
1194 ::std::mem::size_of::<_pthread_condattr>(),
1195 8usize,
1196 concat!("Size of: ", stringify!(_pthread_condattr))
1197 );
1198 assert_eq!(
1199 ::std::mem::align_of::<_pthread_condattr>(),
1200 8usize,
1201 concat!("Alignment of ", stringify!(_pthread_condattr))
1202 );
1203 assert_eq!(
1204 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_condattrp) as usize - ptr as usize },
1205 0usize,
1206 concat!(
1207 "Offset of field: ",
1208 stringify!(_pthread_condattr),
1209 "::",
1210 stringify!(__pthread_condattrp)
1211 )
1212 );
1213}
1214pub type pthread_condattr_t = _pthread_condattr;
1215#[repr(C)]
1216#[derive(Debug, Copy, Clone)]
1217pub struct _once {
1218 pub __pthread_once_pad: [upad64_t; 4usize],
1219}
1220#[test]
1221fn bindgen_test_layout__once() {
1222 const UNINIT: ::std::mem::MaybeUninit<_once> = ::std::mem::MaybeUninit::uninit();
1223 let ptr = UNINIT.as_ptr();
1224 assert_eq!(
1225 ::std::mem::size_of::<_once>(),
1226 32usize,
1227 concat!("Size of: ", stringify!(_once))
1228 );
1229 assert_eq!(
1230 ::std::mem::align_of::<_once>(),
1231 8usize,
1232 concat!("Alignment of ", stringify!(_once))
1233 );
1234 assert_eq!(
1235 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_once_pad) as usize - ptr as usize },
1236 0usize,
1237 concat!(
1238 "Offset of field: ",
1239 stringify!(_once),
1240 "::",
1241 stringify!(__pthread_once_pad)
1242 )
1243 );
1244}
1245pub type pthread_once_t = _once;
1246#[repr(C)]
1247#[derive(Debug, Copy, Clone)]
1248pub struct _pthread_rwlockattr {
1249 pub __pthread_rwlockattrp: *mut ::std::os::raw::c_void,
1250}
1251#[test]
1252fn bindgen_test_layout__pthread_rwlockattr() {
1253 const UNINIT: ::std::mem::MaybeUninit<_pthread_rwlockattr> = ::std::mem::MaybeUninit::uninit();
1254 let ptr = UNINIT.as_ptr();
1255 assert_eq!(
1256 ::std::mem::size_of::<_pthread_rwlockattr>(),
1257 8usize,
1258 concat!("Size of: ", stringify!(_pthread_rwlockattr))
1259 );
1260 assert_eq!(
1261 ::std::mem::align_of::<_pthread_rwlockattr>(),
1262 8usize,
1263 concat!("Alignment of ", stringify!(_pthread_rwlockattr))
1264 );
1265 assert_eq!(
1266 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_rwlockattrp) as usize - ptr as usize },
1267 0usize,
1268 concat!(
1269 "Offset of field: ",
1270 stringify!(_pthread_rwlockattr),
1271 "::",
1272 stringify!(__pthread_rwlockattrp)
1273 )
1274 );
1275}
1276pub type pthread_rwlockattr_t = _pthread_rwlockattr;
1277#[repr(C)]
1278#[derive(Debug, Copy, Clone)]
1279pub struct pthread_barrierattr_t {
1280 pub __pthread_barrierattrp: *mut ::std::os::raw::c_void,
1281}
1282#[test]
1283fn bindgen_test_layout_pthread_barrierattr_t() {
1284 const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
1285 ::std::mem::MaybeUninit::uninit();
1286 let ptr = UNINIT.as_ptr();
1287 assert_eq!(
1288 ::std::mem::size_of::<pthread_barrierattr_t>(),
1289 8usize,
1290 concat!("Size of: ", stringify!(pthread_barrierattr_t))
1291 );
1292 assert_eq!(
1293 ::std::mem::align_of::<pthread_barrierattr_t>(),
1294 8usize,
1295 concat!("Alignment of ", stringify!(pthread_barrierattr_t))
1296 );
1297 assert_eq!(
1298 unsafe { ::std::ptr::addr_of!((*ptr).__pthread_barrierattrp) as usize - ptr as usize },
1299 0usize,
1300 concat!(
1301 "Offset of field: ",
1302 stringify!(pthread_barrierattr_t),
1303 "::",
1304 stringify!(__pthread_barrierattrp)
1305 )
1306 );
1307}
1308pub type dev_t = ulong_t;
1309pub type nlink_t = uint_t;
1310pub type pid_t = ::std::os::raw::c_int;
1311pub type time_t = ::std::os::raw::c_long;
1312pub type clock_t = ::std::os::raw::c_long;
1313pub type clockid_t = ::std::os::raw::c_int;
1314pub type timer_t = ::std::os::raw::c_int;
1315pub type unchar = ::std::os::raw::c_uchar;
1316pub type ushort = ::std::os::raw::c_ushort;
1317pub type uint = ::std::os::raw::c_uint;
1318pub type ulong = ::std::os::raw::c_ulong;
1319pub type u_char = ::std::os::raw::c_uchar;
1320pub type u_short = ::std::os::raw::c_ushort;
1321pub type u_int = ::std::os::raw::c_uint;
1322pub type u_long = ::std::os::raw::c_ulong;
1323#[repr(C)]
1324#[derive(Debug, Copy, Clone)]
1325pub struct _quad {
1326 pub val: [::std::os::raw::c_int; 2usize],
1327}
1328#[test]
1329fn bindgen_test_layout__quad() {
1330 const UNINIT: ::std::mem::MaybeUninit<_quad> = ::std::mem::MaybeUninit::uninit();
1331 let ptr = UNINIT.as_ptr();
1332 assert_eq!(
1333 ::std::mem::size_of::<_quad>(),
1334 8usize,
1335 concat!("Size of: ", stringify!(_quad))
1336 );
1337 assert_eq!(
1338 ::std::mem::align_of::<_quad>(),
1339 4usize,
1340 concat!("Alignment of ", stringify!(_quad))
1341 );
1342 assert_eq!(
1343 unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
1344 0usize,
1345 concat!(
1346 "Offset of field: ",
1347 stringify!(_quad),
1348 "::",
1349 stringify!(val)
1350 )
1351 );
1352}
1353pub type quad_t = _quad;
1354pub type quad = quad_t;
1355#[repr(C)]
1356#[derive(Debug, Copy, Clone)]
1357pub struct timespec {
1358 pub tv_sec: time_t,
1359 pub tv_nsec: ::std::os::raw::c_long,
1360}
1361#[test]
1362fn bindgen_test_layout_timespec() {
1363 const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
1364 let ptr = UNINIT.as_ptr();
1365 assert_eq!(
1366 ::std::mem::size_of::<timespec>(),
1367 16usize,
1368 concat!("Size of: ", stringify!(timespec))
1369 );
1370 assert_eq!(
1371 ::std::mem::align_of::<timespec>(),
1372 8usize,
1373 concat!("Alignment of ", stringify!(timespec))
1374 );
1375 assert_eq!(
1376 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
1377 0usize,
1378 concat!(
1379 "Offset of field: ",
1380 stringify!(timespec),
1381 "::",
1382 stringify!(tv_sec)
1383 )
1384 );
1385 assert_eq!(
1386 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
1387 8usize,
1388 concat!(
1389 "Offset of field: ",
1390 stringify!(timespec),
1391 "::",
1392 stringify!(tv_nsec)
1393 )
1394 );
1395}
1396pub type timespec_t = timespec;
1397pub type timestruc_t = timespec;
1398#[repr(C)]
1399#[derive(Debug, Copy, Clone)]
1400pub struct itimerspec {
1401 pub it_interval: timespec,
1402 pub it_value: timespec,
1403}
1404#[test]
1405fn bindgen_test_layout_itimerspec() {
1406 const UNINIT: ::std::mem::MaybeUninit<itimerspec> = ::std::mem::MaybeUninit::uninit();
1407 let ptr = UNINIT.as_ptr();
1408 assert_eq!(
1409 ::std::mem::size_of::<itimerspec>(),
1410 32usize,
1411 concat!("Size of: ", stringify!(itimerspec))
1412 );
1413 assert_eq!(
1414 ::std::mem::align_of::<itimerspec>(),
1415 8usize,
1416 concat!("Alignment of ", stringify!(itimerspec))
1417 );
1418 assert_eq!(
1419 unsafe { ::std::ptr::addr_of!((*ptr).it_interval) as usize - ptr as usize },
1420 0usize,
1421 concat!(
1422 "Offset of field: ",
1423 stringify!(itimerspec),
1424 "::",
1425 stringify!(it_interval)
1426 )
1427 );
1428 assert_eq!(
1429 unsafe { ::std::ptr::addr_of!((*ptr).it_value) as usize - ptr as usize },
1430 16usize,
1431 concat!(
1432 "Offset of field: ",
1433 stringify!(itimerspec),
1434 "::",
1435 stringify!(it_value)
1436 )
1437 );
1438}
1439pub type itimerspec_t = itimerspec;
1440#[repr(C)]
1441#[derive(Debug, Copy, Clone)]
1442pub struct timeval {
1443 pub tv_sec: time_t,
1444 pub tv_usec: suseconds_t,
1445}
1446#[test]
1447fn bindgen_test_layout_timeval() {
1448 const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
1449 let ptr = UNINIT.as_ptr();
1450 assert_eq!(
1451 ::std::mem::size_of::<timeval>(),
1452 16usize,
1453 concat!("Size of: ", stringify!(timeval))
1454 );
1455 assert_eq!(
1456 ::std::mem::align_of::<timeval>(),
1457 8usize,
1458 concat!("Alignment of ", stringify!(timeval))
1459 );
1460 assert_eq!(
1461 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
1462 0usize,
1463 concat!(
1464 "Offset of field: ",
1465 stringify!(timeval),
1466 "::",
1467 stringify!(tv_sec)
1468 )
1469 );
1470 assert_eq!(
1471 unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
1472 8usize,
1473 concat!(
1474 "Offset of field: ",
1475 stringify!(timeval),
1476 "::",
1477 stringify!(tv_usec)
1478 )
1479 );
1480}
1481#[repr(C)]
1482#[derive(Debug, Copy, Clone)]
1483pub struct timezone {
1484 pub tz_minuteswest: ::std::os::raw::c_int,
1485 pub tz_dsttime: ::std::os::raw::c_int,
1486}
1487#[test]
1488fn bindgen_test_layout_timezone() {
1489 const UNINIT: ::std::mem::MaybeUninit<timezone> = ::std::mem::MaybeUninit::uninit();
1490 let ptr = UNINIT.as_ptr();
1491 assert_eq!(
1492 ::std::mem::size_of::<timezone>(),
1493 8usize,
1494 concat!("Size of: ", stringify!(timezone))
1495 );
1496 assert_eq!(
1497 ::std::mem::align_of::<timezone>(),
1498 4usize,
1499 concat!("Alignment of ", stringify!(timezone))
1500 );
1501 assert_eq!(
1502 unsafe { ::std::ptr::addr_of!((*ptr).tz_minuteswest) as usize - ptr as usize },
1503 0usize,
1504 concat!(
1505 "Offset of field: ",
1506 stringify!(timezone),
1507 "::",
1508 stringify!(tz_minuteswest)
1509 )
1510 );
1511 assert_eq!(
1512 unsafe { ::std::ptr::addr_of!((*ptr).tz_dsttime) as usize - ptr as usize },
1513 4usize,
1514 concat!(
1515 "Offset of field: ",
1516 stringify!(timezone),
1517 "::",
1518 stringify!(tz_dsttime)
1519 )
1520 );
1521}
1522#[repr(C)]
1523#[derive(Debug, Copy, Clone)]
1524pub struct itimerval {
1525 pub it_interval: timeval,
1526 pub it_value: timeval,
1527}
1528#[test]
1529fn bindgen_test_layout_itimerval() {
1530 const UNINIT: ::std::mem::MaybeUninit<itimerval> = ::std::mem::MaybeUninit::uninit();
1531 let ptr = UNINIT.as_ptr();
1532 assert_eq!(
1533 ::std::mem::size_of::<itimerval>(),
1534 32usize,
1535 concat!("Size of: ", stringify!(itimerval))
1536 );
1537 assert_eq!(
1538 ::std::mem::align_of::<itimerval>(),
1539 8usize,
1540 concat!("Alignment of ", stringify!(itimerval))
1541 );
1542 assert_eq!(
1543 unsafe { ::std::ptr::addr_of!((*ptr).it_interval) as usize - ptr as usize },
1544 0usize,
1545 concat!(
1546 "Offset of field: ",
1547 stringify!(itimerval),
1548 "::",
1549 stringify!(it_interval)
1550 )
1551 );
1552 assert_eq!(
1553 unsafe { ::std::ptr::addr_of!((*ptr).it_value) as usize - ptr as usize },
1554 16usize,
1555 concat!(
1556 "Offset of field: ",
1557 stringify!(itimerval),
1558 "::",
1559 stringify!(it_value)
1560 )
1561 );
1562}
1563pub type hrtime_t = longlong_t;
1564extern "C" {
1565 pub fn adjtime(arg1: *mut timeval, arg2: *mut timeval) -> ::std::os::raw::c_int;
1566}
1567extern "C" {
1568 pub fn futimesat(
1569 arg1: ::std::os::raw::c_int,
1570 arg2: *const ::std::os::raw::c_char,
1571 arg3: *const timeval,
1572 ) -> ::std::os::raw::c_int;
1573}
1574extern "C" {
1575 pub fn getitimer(arg1: ::std::os::raw::c_int, arg2: *mut itimerval) -> ::std::os::raw::c_int;
1576}
1577extern "C" {
1578 pub fn utimes(
1579 arg1: *const ::std::os::raw::c_char,
1580 arg2: *const timeval,
1581 ) -> ::std::os::raw::c_int;
1582}
1583extern "C" {
1584 pub fn setitimer(
1585 arg1: ::std::os::raw::c_int,
1586 arg2: *mut itimerval,
1587 arg3: *mut itimerval,
1588 ) -> ::std::os::raw::c_int;
1589}
1590extern "C" {
1591 pub fn futimes(arg1: ::std::os::raw::c_int, arg2: *const timeval) -> ::std::os::raw::c_int;
1592}
1593extern "C" {
1594 pub fn lutimes(
1595 arg1: *const ::std::os::raw::c_char,
1596 arg2: *const timeval,
1597 ) -> ::std::os::raw::c_int;
1598}
1599extern "C" {
1600 pub fn settimeofday(
1601 arg1: *mut timeval,
1602 arg2: *mut ::std::os::raw::c_void,
1603 ) -> ::std::os::raw::c_int;
1604}
1605extern "C" {
1606 pub fn gethrtime() -> hrtime_t;
1607}
1608extern "C" {
1609 pub fn gethrvtime() -> hrtime_t;
1610}
1611extern "C" {
1612 pub fn gettimeofday(
1613 arg1: *mut timeval,
1614 arg2: *mut ::std::os::raw::c_void,
1615 ) -> ::std::os::raw::c_int;
1616}
1617#[repr(C)]
1618#[derive(Debug, Copy, Clone)]
1619pub struct tm {
1620 pub tm_sec: ::std::os::raw::c_int,
1621 pub tm_min: ::std::os::raw::c_int,
1622 pub tm_hour: ::std::os::raw::c_int,
1623 pub tm_mday: ::std::os::raw::c_int,
1624 pub tm_mon: ::std::os::raw::c_int,
1625 pub tm_year: ::std::os::raw::c_int,
1626 pub tm_wday: ::std::os::raw::c_int,
1627 pub tm_yday: ::std::os::raw::c_int,
1628 pub tm_isdst: ::std::os::raw::c_int,
1629}
1630#[test]
1631fn bindgen_test_layout_tm() {
1632 const UNINIT: ::std::mem::MaybeUninit<tm> = ::std::mem::MaybeUninit::uninit();
1633 let ptr = UNINIT.as_ptr();
1634 assert_eq!(
1635 ::std::mem::size_of::<tm>(),
1636 36usize,
1637 concat!("Size of: ", stringify!(tm))
1638 );
1639 assert_eq!(
1640 ::std::mem::align_of::<tm>(),
1641 4usize,
1642 concat!("Alignment of ", stringify!(tm))
1643 );
1644 assert_eq!(
1645 unsafe { ::std::ptr::addr_of!((*ptr).tm_sec) as usize - ptr as usize },
1646 0usize,
1647 concat!(
1648 "Offset of field: ",
1649 stringify!(tm),
1650 "::",
1651 stringify!(tm_sec)
1652 )
1653 );
1654 assert_eq!(
1655 unsafe { ::std::ptr::addr_of!((*ptr).tm_min) as usize - ptr as usize },
1656 4usize,
1657 concat!(
1658 "Offset of field: ",
1659 stringify!(tm),
1660 "::",
1661 stringify!(tm_min)
1662 )
1663 );
1664 assert_eq!(
1665 unsafe { ::std::ptr::addr_of!((*ptr).tm_hour) as usize - ptr as usize },
1666 8usize,
1667 concat!(
1668 "Offset of field: ",
1669 stringify!(tm),
1670 "::",
1671 stringify!(tm_hour)
1672 )
1673 );
1674 assert_eq!(
1675 unsafe { ::std::ptr::addr_of!((*ptr).tm_mday) as usize - ptr as usize },
1676 12usize,
1677 concat!(
1678 "Offset of field: ",
1679 stringify!(tm),
1680 "::",
1681 stringify!(tm_mday)
1682 )
1683 );
1684 assert_eq!(
1685 unsafe { ::std::ptr::addr_of!((*ptr).tm_mon) as usize - ptr as usize },
1686 16usize,
1687 concat!(
1688 "Offset of field: ",
1689 stringify!(tm),
1690 "::",
1691 stringify!(tm_mon)
1692 )
1693 );
1694 assert_eq!(
1695 unsafe { ::std::ptr::addr_of!((*ptr).tm_year) as usize - ptr as usize },
1696 20usize,
1697 concat!(
1698 "Offset of field: ",
1699 stringify!(tm),
1700 "::",
1701 stringify!(tm_year)
1702 )
1703 );
1704 assert_eq!(
1705 unsafe { ::std::ptr::addr_of!((*ptr).tm_wday) as usize - ptr as usize },
1706 24usize,
1707 concat!(
1708 "Offset of field: ",
1709 stringify!(tm),
1710 "::",
1711 stringify!(tm_wday)
1712 )
1713 );
1714 assert_eq!(
1715 unsafe { ::std::ptr::addr_of!((*ptr).tm_yday) as usize - ptr as usize },
1716 28usize,
1717 concat!(
1718 "Offset of field: ",
1719 stringify!(tm),
1720 "::",
1721 stringify!(tm_yday)
1722 )
1723 );
1724 assert_eq!(
1725 unsafe { ::std::ptr::addr_of!((*ptr).tm_isdst) as usize - ptr as usize },
1726 32usize,
1727 concat!(
1728 "Offset of field: ",
1729 stringify!(tm),
1730 "::",
1731 stringify!(tm_isdst)
1732 )
1733 );
1734}
1735extern "C" {
1736 pub fn asctime(arg1: *const tm) -> *mut ::std::os::raw::c_char;
1737}
1738extern "C" {
1739 pub fn clock() -> clock_t;
1740}
1741extern "C" {
1742 pub fn ctime(arg1: *const time_t) -> *mut ::std::os::raw::c_char;
1743}
1744extern "C" {
1745 pub fn difftime(arg1: time_t, arg2: time_t) -> f64;
1746}
1747extern "C" {
1748 pub fn gmtime(arg1: *const time_t) -> *mut tm;
1749}
1750extern "C" {
1751 pub fn localtime(arg1: *const time_t) -> *mut tm;
1752}
1753extern "C" {
1754 pub fn mktime(arg1: *mut tm) -> time_t;
1755}
1756extern "C" {
1757 pub fn time(arg1: *mut time_t) -> time_t;
1758}
1759extern "C" {
1760 pub fn strftime(
1761 arg1: *mut ::std::os::raw::c_char,
1762 arg2: usize,
1763 arg3: *const ::std::os::raw::c_char,
1764 arg4: *const tm,
1765 ) -> usize;
1766}
1767extern "C" {
1768 pub fn gmtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm;
1769}
1770extern "C" {
1771 pub fn localtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm;
1772}
1773extern "C" {
1774 pub fn strptime(
1775 arg1: *const ::std::os::raw::c_char,
1776 arg2: *const ::std::os::raw::c_char,
1777 arg3: *mut tm,
1778 ) -> *mut ::std::os::raw::c_char;
1779}
1780#[repr(C)]
1781#[derive(Copy, Clone)]
1782pub union sigval {
1783 pub sival_int: ::std::os::raw::c_int,
1784 pub sival_ptr: *mut ::std::os::raw::c_void,
1785}
1786#[test]
1787fn bindgen_test_layout_sigval() {
1788 const UNINIT: ::std::mem::MaybeUninit<sigval> = ::std::mem::MaybeUninit::uninit();
1789 let ptr = UNINIT.as_ptr();
1790 assert_eq!(
1791 ::std::mem::size_of::<sigval>(),
1792 8usize,
1793 concat!("Size of: ", stringify!(sigval))
1794 );
1795 assert_eq!(
1796 ::std::mem::align_of::<sigval>(),
1797 8usize,
1798 concat!("Alignment of ", stringify!(sigval))
1799 );
1800 assert_eq!(
1801 unsafe { ::std::ptr::addr_of!((*ptr).sival_int) as usize - ptr as usize },
1802 0usize,
1803 concat!(
1804 "Offset of field: ",
1805 stringify!(sigval),
1806 "::",
1807 stringify!(sival_int)
1808 )
1809 );
1810 assert_eq!(
1811 unsafe { ::std::ptr::addr_of!((*ptr).sival_ptr) as usize - ptr as usize },
1812 0usize,
1813 concat!(
1814 "Offset of field: ",
1815 stringify!(sigval),
1816 "::",
1817 stringify!(sival_ptr)
1818 )
1819 );
1820}
1821#[repr(C)]
1822#[derive(Copy, Clone)]
1823pub struct sigevent {
1824 pub sigev_notify: ::std::os::raw::c_int,
1825 pub sigev_signo: ::std::os::raw::c_int,
1826 pub sigev_value: sigval,
1827 pub sigev_notify_function: ::std::option::Option<unsafe extern "C" fn(arg1: sigval)>,
1828 pub sigev_notify_attributes: *mut pthread_attr_t,
1829 pub __sigev_pad2: ::std::os::raw::c_int,
1830}
1831#[test]
1832fn bindgen_test_layout_sigevent() {
1833 const UNINIT: ::std::mem::MaybeUninit<sigevent> = ::std::mem::MaybeUninit::uninit();
1834 let ptr = UNINIT.as_ptr();
1835 assert_eq!(
1836 ::std::mem::size_of::<sigevent>(),
1837 40usize,
1838 concat!("Size of: ", stringify!(sigevent))
1839 );
1840 assert_eq!(
1841 ::std::mem::align_of::<sigevent>(),
1842 8usize,
1843 concat!("Alignment of ", stringify!(sigevent))
1844 );
1845 assert_eq!(
1846 unsafe { ::std::ptr::addr_of!((*ptr).sigev_notify) as usize - ptr as usize },
1847 0usize,
1848 concat!(
1849 "Offset of field: ",
1850 stringify!(sigevent),
1851 "::",
1852 stringify!(sigev_notify)
1853 )
1854 );
1855 assert_eq!(
1856 unsafe { ::std::ptr::addr_of!((*ptr).sigev_signo) as usize - ptr as usize },
1857 4usize,
1858 concat!(
1859 "Offset of field: ",
1860 stringify!(sigevent),
1861 "::",
1862 stringify!(sigev_signo)
1863 )
1864 );
1865 assert_eq!(
1866 unsafe { ::std::ptr::addr_of!((*ptr).sigev_value) as usize - ptr as usize },
1867 8usize,
1868 concat!(
1869 "Offset of field: ",
1870 stringify!(sigevent),
1871 "::",
1872 stringify!(sigev_value)
1873 )
1874 );
1875 assert_eq!(
1876 unsafe { ::std::ptr::addr_of!((*ptr).sigev_notify_function) as usize - ptr as usize },
1877 16usize,
1878 concat!(
1879 "Offset of field: ",
1880 stringify!(sigevent),
1881 "::",
1882 stringify!(sigev_notify_function)
1883 )
1884 );
1885 assert_eq!(
1886 unsafe { ::std::ptr::addr_of!((*ptr).sigev_notify_attributes) as usize - ptr as usize },
1887 24usize,
1888 concat!(
1889 "Offset of field: ",
1890 stringify!(sigevent),
1891 "::",
1892 stringify!(sigev_notify_attributes)
1893 )
1894 );
1895 assert_eq!(
1896 unsafe { ::std::ptr::addr_of!((*ptr).__sigev_pad2) as usize - ptr as usize },
1897 32usize,
1898 concat!(
1899 "Offset of field: ",
1900 stringify!(sigevent),
1901 "::",
1902 stringify!(__sigev_pad2)
1903 )
1904 );
1905}
1906extern "C" {
1907 pub fn clock_getres(arg1: clockid_t, arg2: *mut timespec) -> ::std::os::raw::c_int;
1908}
1909extern "C" {
1910 pub fn clock_gettime(arg1: clockid_t, arg2: *mut timespec) -> ::std::os::raw::c_int;
1911}
1912extern "C" {
1913 pub fn clock_settime(arg1: clockid_t, arg2: *const timespec) -> ::std::os::raw::c_int;
1914}
1915extern "C" {
1916 pub fn timer_create(
1917 arg1: clockid_t,
1918 arg2: *mut sigevent,
1919 arg3: *mut timer_t,
1920 ) -> ::std::os::raw::c_int;
1921}
1922extern "C" {
1923 pub fn timer_delete(arg1: timer_t) -> ::std::os::raw::c_int;
1924}
1925extern "C" {
1926 pub fn timer_getoverrun(arg1: timer_t) -> ::std::os::raw::c_int;
1927}
1928extern "C" {
1929 pub fn timer_gettime(arg1: timer_t, arg2: *mut itimerspec) -> ::std::os::raw::c_int;
1930}
1931extern "C" {
1932 pub fn timer_settime(
1933 arg1: timer_t,
1934 arg2: ::std::os::raw::c_int,
1935 arg3: *const itimerspec,
1936 arg4: *mut itimerspec,
1937 ) -> ::std::os::raw::c_int;
1938}
1939extern "C" {
1940 pub fn nanosleep(arg1: *const timespec, arg2: *mut timespec) -> ::std::os::raw::c_int;
1941}
1942extern "C" {
1943 pub fn clock_nanosleep(
1944 arg1: clockid_t,
1945 arg2: ::std::os::raw::c_int,
1946 arg3: *const timespec,
1947 arg4: *mut timespec,
1948 ) -> ::std::os::raw::c_int;
1949}
1950extern "C" {
1951 pub fn tzset();
1952}
1953extern "C" {
1954 pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize];
1955}
1956extern "C" {
1957 pub fn _sysconf(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_long;
1958}
1959extern "C" {
1960 pub static mut timezone: ::std::os::raw::c_long;
1961}
1962extern "C" {
1963 pub static mut daylight: ::std::os::raw::c_int;
1964}
1965extern "C" {
1966 pub fn timegm(arg1: *mut tm) -> time_t;
1967}
1968extern "C" {
1969 pub fn cftime(
1970 arg1: *mut ::std::os::raw::c_char,
1971 arg2: *mut ::std::os::raw::c_char,
1972 arg3: *const time_t,
1973 ) -> ::std::os::raw::c_int;
1974}
1975extern "C" {
1976 pub fn ascftime(
1977 arg1: *mut ::std::os::raw::c_char,
1978 arg2: *const ::std::os::raw::c_char,
1979 arg3: *const tm,
1980 ) -> ::std::os::raw::c_int;
1981}
1982extern "C" {
1983 pub static mut altzone: ::std::os::raw::c_long;
1984}
1985extern "C" {
1986 pub fn getdate(arg1: *const ::std::os::raw::c_char) -> *mut tm;
1987}
1988extern "C" {
1989 pub static mut getdate_err: ::std::os::raw::c_int;
1990}
1991extern "C" {
1992 pub fn asctime_r(
1993 arg1: *const tm,
1994 arg2: *mut ::std::os::raw::c_char,
1995 arg3: ::std::os::raw::c_int,
1996 ) -> *mut ::std::os::raw::c_char;
1997}
1998extern "C" {
1999 pub fn ctime_r(
2000 arg1: *const time_t,
2001 arg2: *mut ::std::os::raw::c_char,
2002 arg3: ::std::os::raw::c_int,
2003 ) -> *mut ::std::os::raw::c_char;
2004}
2005#[repr(C)]
2006#[derive(Debug, Copy, Clone)]
2007pub struct _locale {
2008 _unused: [u8; 0],
2009}
2010pub type locale_t = *mut _locale;
2011extern "C" {
2012 pub fn strftime_l(
2013 arg1: *mut ::std::os::raw::c_char,
2014 arg2: usize,
2015 arg3: *const ::std::os::raw::c_char,
2016 arg4: *const tm,
2017 arg5: locale_t,
2018 ) -> usize;
2019}
2020extern "C" {
2021 pub fn timespec_get(arg1: *mut timespec, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2022}
2023#[repr(C)]
2024#[derive(Debug, Copy, Clone)]
2025pub struct sigset_t {
2026 pub __sigbits: [::std::os::raw::c_uint; 4usize],
2027}
2028#[test]
2029fn bindgen_test_layout_sigset_t() {
2030 const UNINIT: ::std::mem::MaybeUninit<sigset_t> = ::std::mem::MaybeUninit::uninit();
2031 let ptr = UNINIT.as_ptr();
2032 assert_eq!(
2033 ::std::mem::size_of::<sigset_t>(),
2034 16usize,
2035 concat!("Size of: ", stringify!(sigset_t))
2036 );
2037 assert_eq!(
2038 ::std::mem::align_of::<sigset_t>(),
2039 4usize,
2040 concat!("Alignment of ", stringify!(sigset_t))
2041 );
2042 assert_eq!(
2043 unsafe { ::std::ptr::addr_of!((*ptr).__sigbits) as usize - ptr as usize },
2044 0usize,
2045 concat!(
2046 "Offset of field: ",
2047 stringify!(sigset_t),
2048 "::",
2049 stringify!(__sigbits)
2050 )
2051 );
2052}
2053pub type fd_mask = ::std::os::raw::c_long;
2054pub type fds_mask = ::std::os::raw::c_long;
2055#[repr(C)]
2056#[derive(Debug, Copy, Clone)]
2057pub struct fd_set {
2058 pub fds_bits: [::std::os::raw::c_long; 1024usize],
2059}
2060#[test]
2061fn bindgen_test_layout_fd_set() {
2062 const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
2063 let ptr = UNINIT.as_ptr();
2064 assert_eq!(
2065 ::std::mem::size_of::<fd_set>(),
2066 8192usize,
2067 concat!("Size of: ", stringify!(fd_set))
2068 );
2069 assert_eq!(
2070 ::std::mem::align_of::<fd_set>(),
2071 8usize,
2072 concat!("Alignment of ", stringify!(fd_set))
2073 );
2074 assert_eq!(
2075 unsafe { ::std::ptr::addr_of!((*ptr).fds_bits) as usize - ptr as usize },
2076 0usize,
2077 concat!(
2078 "Offset of field: ",
2079 stringify!(fd_set),
2080 "::",
2081 stringify!(fds_bits)
2082 )
2083 );
2084}
2085extern "C" {
2086 pub fn select(
2087 arg1: ::std::os::raw::c_int,
2088 arg2: *mut fd_set,
2089 arg3: *mut fd_set,
2090 arg4: *mut fd_set,
2091 arg5: *mut timeval,
2092 ) -> ::std::os::raw::c_int;
2093}
2094extern "C" {
2095 pub fn pselect(
2096 arg1: ::std::os::raw::c_int,
2097 arg2: *mut fd_set,
2098 arg3: *mut fd_set,
2099 arg4: *mut fd_set,
2100 arg5: *const timespec,
2101 arg6: *const sigset_t,
2102 ) -> ::std::os::raw::c_int;
2103}
2104pub type in_port_t = u16;
2105pub type in_addr_t = u32;
2106extern "C" {
2107 pub fn htonl(arg1: u32) -> u32;
2108}
2109extern "C" {
2110 pub fn htons(arg1: u16) -> u16;
2111}
2112extern "C" {
2113 pub fn ntohl(arg1: u32) -> u32;
2114}
2115extern "C" {
2116 pub fn ntohs(arg1: u16) -> u16;
2117}
2118extern "C" {
2119 pub fn htonll(arg1: u64) -> u64;
2120}
2121extern "C" {
2122 pub fn ntohll(arg1: u64) -> u64;
2123}
2124#[repr(C)]
2125#[derive(Debug, Copy, Clone)]
2126pub struct uuid_node_t {
2127 pub nodeID: [u8; 6usize],
2128}
2129#[test]
2130fn bindgen_test_layout_uuid_node_t() {
2131 const UNINIT: ::std::mem::MaybeUninit<uuid_node_t> = ::std::mem::MaybeUninit::uninit();
2132 let ptr = UNINIT.as_ptr();
2133 assert_eq!(
2134 ::std::mem::size_of::<uuid_node_t>(),
2135 6usize,
2136 concat!("Size of: ", stringify!(uuid_node_t))
2137 );
2138 assert_eq!(
2139 ::std::mem::align_of::<uuid_node_t>(),
2140 1usize,
2141 concat!("Alignment of ", stringify!(uuid_node_t))
2142 );
2143 assert_eq!(
2144 unsafe { ::std::ptr::addr_of!((*ptr).nodeID) as usize - ptr as usize },
2145 0usize,
2146 concat!(
2147 "Offset of field: ",
2148 stringify!(uuid_node_t),
2149 "::",
2150 stringify!(nodeID)
2151 )
2152 );
2153}
2154#[repr(C)]
2155#[derive(Debug, Copy, Clone)]
2156pub struct uuid {
2157 pub time_low: u32,
2158 pub time_mid: u16,
2159 pub time_hi_and_version: u16,
2160 pub clock_seq_hi_and_reserved: u8,
2161 pub clock_seq_low: u8,
2162 pub node_addr: [u8; 6usize],
2163}
2164#[test]
2165fn bindgen_test_layout_uuid() {
2166 const UNINIT: ::std::mem::MaybeUninit<uuid> = ::std::mem::MaybeUninit::uninit();
2167 let ptr = UNINIT.as_ptr();
2168 assert_eq!(
2169 ::std::mem::size_of::<uuid>(),
2170 16usize,
2171 concat!("Size of: ", stringify!(uuid))
2172 );
2173 assert_eq!(
2174 ::std::mem::align_of::<uuid>(),
2175 4usize,
2176 concat!("Alignment of ", stringify!(uuid))
2177 );
2178 assert_eq!(
2179 unsafe { ::std::ptr::addr_of!((*ptr).time_low) as usize - ptr as usize },
2180 0usize,
2181 concat!(
2182 "Offset of field: ",
2183 stringify!(uuid),
2184 "::",
2185 stringify!(time_low)
2186 )
2187 );
2188 assert_eq!(
2189 unsafe { ::std::ptr::addr_of!((*ptr).time_mid) as usize - ptr as usize },
2190 4usize,
2191 concat!(
2192 "Offset of field: ",
2193 stringify!(uuid),
2194 "::",
2195 stringify!(time_mid)
2196 )
2197 );
2198 assert_eq!(
2199 unsafe { ::std::ptr::addr_of!((*ptr).time_hi_and_version) as usize - ptr as usize },
2200 6usize,
2201 concat!(
2202 "Offset of field: ",
2203 stringify!(uuid),
2204 "::",
2205 stringify!(time_hi_and_version)
2206 )
2207 );
2208 assert_eq!(
2209 unsafe { ::std::ptr::addr_of!((*ptr).clock_seq_hi_and_reserved) as usize - ptr as usize },
2210 8usize,
2211 concat!(
2212 "Offset of field: ",
2213 stringify!(uuid),
2214 "::",
2215 stringify!(clock_seq_hi_and_reserved)
2216 )
2217 );
2218 assert_eq!(
2219 unsafe { ::std::ptr::addr_of!((*ptr).clock_seq_low) as usize - ptr as usize },
2220 9usize,
2221 concat!(
2222 "Offset of field: ",
2223 stringify!(uuid),
2224 "::",
2225 stringify!(clock_seq_low)
2226 )
2227 );
2228 assert_eq!(
2229 unsafe { ::std::ptr::addr_of!((*ptr).node_addr) as usize - ptr as usize },
2230 10usize,
2231 concat!(
2232 "Offset of field: ",
2233 stringify!(uuid),
2234 "::",
2235 stringify!(node_addr)
2236 )
2237 );
2238}
2239pub type uuid_t = [uchar_t; 16usize];
2240#[repr(C)]
2241#[derive(Debug, Copy, Clone)]
2242pub struct efi_gpt {
2243 pub efi_gpt_Signature: u64,
2244 pub efi_gpt_Revision: uint_t,
2245 pub efi_gpt_HeaderSize: uint_t,
2246 pub efi_gpt_HeaderCRC32: uint_t,
2247 pub efi_gpt_Reserved1: uint_t,
2248 pub efi_gpt_MyLBA: diskaddr_t,
2249 pub efi_gpt_AlternateLBA: diskaddr_t,
2250 pub efi_gpt_FirstUsableLBA: diskaddr_t,
2251 pub efi_gpt_LastUsableLBA: diskaddr_t,
2252 pub efi_gpt_DiskGUID: uuid,
2253 pub efi_gpt_PartitionEntryLBA: diskaddr_t,
2254 pub efi_gpt_NumberOfPartitionEntries: uint_t,
2255 pub efi_gpt_SizeOfPartitionEntry: uint_t,
2256 pub efi_gpt_PartitionEntryArrayCRC32: uint_t,
2257 pub efi_gpt_Reserved2: [::std::os::raw::c_char; 420usize],
2258}
2259#[test]
2260fn bindgen_test_layout_efi_gpt() {
2261 const UNINIT: ::std::mem::MaybeUninit<efi_gpt> = ::std::mem::MaybeUninit::uninit();
2262 let ptr = UNINIT.as_ptr();
2263 assert_eq!(
2264 ::std::mem::size_of::<efi_gpt>(),
2265 512usize,
2266 concat!("Size of: ", stringify!(efi_gpt))
2267 );
2268 assert_eq!(
2269 ::std::mem::align_of::<efi_gpt>(),
2270 8usize,
2271 concat!("Alignment of ", stringify!(efi_gpt))
2272 );
2273 assert_eq!(
2274 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_Signature) as usize - ptr as usize },
2275 0usize,
2276 concat!(
2277 "Offset of field: ",
2278 stringify!(efi_gpt),
2279 "::",
2280 stringify!(efi_gpt_Signature)
2281 )
2282 );
2283 assert_eq!(
2284 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_Revision) as usize - ptr as usize },
2285 8usize,
2286 concat!(
2287 "Offset of field: ",
2288 stringify!(efi_gpt),
2289 "::",
2290 stringify!(efi_gpt_Revision)
2291 )
2292 );
2293 assert_eq!(
2294 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_HeaderSize) as usize - ptr as usize },
2295 12usize,
2296 concat!(
2297 "Offset of field: ",
2298 stringify!(efi_gpt),
2299 "::",
2300 stringify!(efi_gpt_HeaderSize)
2301 )
2302 );
2303 assert_eq!(
2304 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_HeaderCRC32) as usize - ptr as usize },
2305 16usize,
2306 concat!(
2307 "Offset of field: ",
2308 stringify!(efi_gpt),
2309 "::",
2310 stringify!(efi_gpt_HeaderCRC32)
2311 )
2312 );
2313 assert_eq!(
2314 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_Reserved1) as usize - ptr as usize },
2315 20usize,
2316 concat!(
2317 "Offset of field: ",
2318 stringify!(efi_gpt),
2319 "::",
2320 stringify!(efi_gpt_Reserved1)
2321 )
2322 );
2323 assert_eq!(
2324 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_MyLBA) as usize - ptr as usize },
2325 24usize,
2326 concat!(
2327 "Offset of field: ",
2328 stringify!(efi_gpt),
2329 "::",
2330 stringify!(efi_gpt_MyLBA)
2331 )
2332 );
2333 assert_eq!(
2334 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_AlternateLBA) as usize - ptr as usize },
2335 32usize,
2336 concat!(
2337 "Offset of field: ",
2338 stringify!(efi_gpt),
2339 "::",
2340 stringify!(efi_gpt_AlternateLBA)
2341 )
2342 );
2343 assert_eq!(
2344 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_FirstUsableLBA) as usize - ptr as usize },
2345 40usize,
2346 concat!(
2347 "Offset of field: ",
2348 stringify!(efi_gpt),
2349 "::",
2350 stringify!(efi_gpt_FirstUsableLBA)
2351 )
2352 );
2353 assert_eq!(
2354 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_LastUsableLBA) as usize - ptr as usize },
2355 48usize,
2356 concat!(
2357 "Offset of field: ",
2358 stringify!(efi_gpt),
2359 "::",
2360 stringify!(efi_gpt_LastUsableLBA)
2361 )
2362 );
2363 assert_eq!(
2364 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_DiskGUID) as usize - ptr as usize },
2365 56usize,
2366 concat!(
2367 "Offset of field: ",
2368 stringify!(efi_gpt),
2369 "::",
2370 stringify!(efi_gpt_DiskGUID)
2371 )
2372 );
2373 assert_eq!(
2374 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_PartitionEntryLBA) as usize - ptr as usize },
2375 72usize,
2376 concat!(
2377 "Offset of field: ",
2378 stringify!(efi_gpt),
2379 "::",
2380 stringify!(efi_gpt_PartitionEntryLBA)
2381 )
2382 );
2383 assert_eq!(
2384 unsafe {
2385 ::std::ptr::addr_of!((*ptr).efi_gpt_NumberOfPartitionEntries) as usize - ptr as usize
2386 },
2387 80usize,
2388 concat!(
2389 "Offset of field: ",
2390 stringify!(efi_gpt),
2391 "::",
2392 stringify!(efi_gpt_NumberOfPartitionEntries)
2393 )
2394 );
2395 assert_eq!(
2396 unsafe {
2397 ::std::ptr::addr_of!((*ptr).efi_gpt_SizeOfPartitionEntry) as usize - ptr as usize
2398 },
2399 84usize,
2400 concat!(
2401 "Offset of field: ",
2402 stringify!(efi_gpt),
2403 "::",
2404 stringify!(efi_gpt_SizeOfPartitionEntry)
2405 )
2406 );
2407 assert_eq!(
2408 unsafe {
2409 ::std::ptr::addr_of!((*ptr).efi_gpt_PartitionEntryArrayCRC32) as usize - ptr as usize
2410 },
2411 88usize,
2412 concat!(
2413 "Offset of field: ",
2414 stringify!(efi_gpt),
2415 "::",
2416 stringify!(efi_gpt_PartitionEntryArrayCRC32)
2417 )
2418 );
2419 assert_eq!(
2420 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpt_Reserved2) as usize - ptr as usize },
2421 92usize,
2422 concat!(
2423 "Offset of field: ",
2424 stringify!(efi_gpt),
2425 "::",
2426 stringify!(efi_gpt_Reserved2)
2427 )
2428 );
2429}
2430pub type efi_gpt_t = efi_gpt;
2431#[repr(C)]
2432#[repr(align(4))]
2433#[derive(Debug, Copy, Clone)]
2434pub struct efi_gpe_Attrs {
2435 pub _bitfield_align_1: [u32; 0],
2436 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2437}
2438#[test]
2439fn bindgen_test_layout_efi_gpe_Attrs() {
2440 assert_eq!(
2441 ::std::mem::size_of::<efi_gpe_Attrs>(),
2442 8usize,
2443 concat!("Size of: ", stringify!(efi_gpe_Attrs))
2444 );
2445 assert_eq!(
2446 ::std::mem::align_of::<efi_gpe_Attrs>(),
2447 4usize,
2448 concat!("Alignment of ", stringify!(efi_gpe_Attrs))
2449 );
2450}
2451impl efi_gpe_Attrs {
2452 #[inline]
2453 pub fn PartitionAttrs(&self) -> u32 {
2454 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
2455 }
2456 #[inline]
2457 pub fn set_PartitionAttrs(&mut self, val: u32) {
2458 unsafe {
2459 let val: u32 = ::std::mem::transmute(val);
2460 self._bitfield_1.set(0usize, 16u8, val as u64)
2461 }
2462 }
2463 #[inline]
2464 pub fn Reserved2(&self) -> u32 {
2465 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
2466 }
2467 #[inline]
2468 pub fn set_Reserved2(&mut self, val: u32) {
2469 unsafe {
2470 let val: u32 = ::std::mem::transmute(val);
2471 self._bitfield_1.set(16usize, 16u8, val as u64)
2472 }
2473 }
2474 #[inline]
2475 pub fn Reserved1(&self) -> u32 {
2476 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 31u8) as u32) }
2477 }
2478 #[inline]
2479 pub fn set_Reserved1(&mut self, val: u32) {
2480 unsafe {
2481 let val: u32 = ::std::mem::transmute(val);
2482 self._bitfield_1.set(32usize, 31u8, val as u64)
2483 }
2484 }
2485 #[inline]
2486 pub fn RequiredPartition(&self) -> u32 {
2487 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u32) }
2488 }
2489 #[inline]
2490 pub fn set_RequiredPartition(&mut self, val: u32) {
2491 unsafe {
2492 let val: u32 = ::std::mem::transmute(val);
2493 self._bitfield_1.set(63usize, 1u8, val as u64)
2494 }
2495 }
2496 #[inline]
2497 pub fn new_bitfield_1(
2498 PartitionAttrs: u32,
2499 Reserved2: u32,
2500 Reserved1: u32,
2501 RequiredPartition: u32,
2502 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2503 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2504 __bindgen_bitfield_unit.set(0usize, 16u8, {
2505 let PartitionAttrs: u32 = unsafe { ::std::mem::transmute(PartitionAttrs) };
2506 PartitionAttrs as u64
2507 });
2508 __bindgen_bitfield_unit.set(16usize, 16u8, {
2509 let Reserved2: u32 = unsafe { ::std::mem::transmute(Reserved2) };
2510 Reserved2 as u64
2511 });
2512 __bindgen_bitfield_unit.set(32usize, 31u8, {
2513 let Reserved1: u32 = unsafe { ::std::mem::transmute(Reserved1) };
2514 Reserved1 as u64
2515 });
2516 __bindgen_bitfield_unit.set(63usize, 1u8, {
2517 let RequiredPartition: u32 = unsafe { ::std::mem::transmute(RequiredPartition) };
2518 RequiredPartition as u64
2519 });
2520 __bindgen_bitfield_unit
2521 }
2522}
2523pub type efi_gpe_Attrs_t = efi_gpe_Attrs;
2524#[repr(C)]
2525#[derive(Debug, Copy, Clone)]
2526pub struct efi_gpe {
2527 pub efi_gpe_PartitionTypeGUID: uuid,
2528 pub efi_gpe_UniquePartitionGUID: uuid,
2529 pub efi_gpe_StartingLBA: diskaddr_t,
2530 pub efi_gpe_EndingLBA: diskaddr_t,
2531 pub efi_gpe_Attributes: efi_gpe_Attrs_t,
2532 pub efi_gpe_PartitionName: [ushort_t; 36usize],
2533}
2534#[test]
2535fn bindgen_test_layout_efi_gpe() {
2536 const UNINIT: ::std::mem::MaybeUninit<efi_gpe> = ::std::mem::MaybeUninit::uninit();
2537 let ptr = UNINIT.as_ptr();
2538 assert_eq!(
2539 ::std::mem::size_of::<efi_gpe>(),
2540 128usize,
2541 concat!("Size of: ", stringify!(efi_gpe))
2542 );
2543 assert_eq!(
2544 ::std::mem::align_of::<efi_gpe>(),
2545 8usize,
2546 concat!("Alignment of ", stringify!(efi_gpe))
2547 );
2548 assert_eq!(
2549 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpe_PartitionTypeGUID) as usize - ptr as usize },
2550 0usize,
2551 concat!(
2552 "Offset of field: ",
2553 stringify!(efi_gpe),
2554 "::",
2555 stringify!(efi_gpe_PartitionTypeGUID)
2556 )
2557 );
2558 assert_eq!(
2559 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpe_UniquePartitionGUID) as usize - ptr as usize },
2560 16usize,
2561 concat!(
2562 "Offset of field: ",
2563 stringify!(efi_gpe),
2564 "::",
2565 stringify!(efi_gpe_UniquePartitionGUID)
2566 )
2567 );
2568 assert_eq!(
2569 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpe_StartingLBA) as usize - ptr as usize },
2570 32usize,
2571 concat!(
2572 "Offset of field: ",
2573 stringify!(efi_gpe),
2574 "::",
2575 stringify!(efi_gpe_StartingLBA)
2576 )
2577 );
2578 assert_eq!(
2579 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpe_EndingLBA) as usize - ptr as usize },
2580 40usize,
2581 concat!(
2582 "Offset of field: ",
2583 stringify!(efi_gpe),
2584 "::",
2585 stringify!(efi_gpe_EndingLBA)
2586 )
2587 );
2588 assert_eq!(
2589 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpe_Attributes) as usize - ptr as usize },
2590 48usize,
2591 concat!(
2592 "Offset of field: ",
2593 stringify!(efi_gpe),
2594 "::",
2595 stringify!(efi_gpe_Attributes)
2596 )
2597 );
2598 assert_eq!(
2599 unsafe { ::std::ptr::addr_of!((*ptr).efi_gpe_PartitionName) as usize - ptr as usize },
2600 56usize,
2601 concat!(
2602 "Offset of field: ",
2603 stringify!(efi_gpe),
2604 "::",
2605 stringify!(efi_gpe_PartitionName)
2606 )
2607 );
2608}
2609pub type efi_gpe_t = efi_gpe;
2610#[repr(C)]
2611#[derive(Debug, Copy, Clone)]
2612pub struct dk_part {
2613 pub p_start: diskaddr_t,
2614 pub p_size: diskaddr_t,
2615 pub p_guid: uuid,
2616 pub p_tag: ushort_t,
2617 pub p_flag: ushort_t,
2618 pub p_name: [::std::os::raw::c_char; 36usize],
2619 pub p_uguid: uuid,
2620 pub p_resv: [uint_t; 8usize],
2621}
2622#[test]
2623fn bindgen_test_layout_dk_part() {
2624 const UNINIT: ::std::mem::MaybeUninit<dk_part> = ::std::mem::MaybeUninit::uninit();
2625 let ptr = UNINIT.as_ptr();
2626 assert_eq!(
2627 ::std::mem::size_of::<dk_part>(),
2628 120usize,
2629 concat!("Size of: ", stringify!(dk_part))
2630 );
2631 assert_eq!(
2632 ::std::mem::align_of::<dk_part>(),
2633 8usize,
2634 concat!("Alignment of ", stringify!(dk_part))
2635 );
2636 assert_eq!(
2637 unsafe { ::std::ptr::addr_of!((*ptr).p_start) as usize - ptr as usize },
2638 0usize,
2639 concat!(
2640 "Offset of field: ",
2641 stringify!(dk_part),
2642 "::",
2643 stringify!(p_start)
2644 )
2645 );
2646 assert_eq!(
2647 unsafe { ::std::ptr::addr_of!((*ptr).p_size) as usize - ptr as usize },
2648 8usize,
2649 concat!(
2650 "Offset of field: ",
2651 stringify!(dk_part),
2652 "::",
2653 stringify!(p_size)
2654 )
2655 );
2656 assert_eq!(
2657 unsafe { ::std::ptr::addr_of!((*ptr).p_guid) as usize - ptr as usize },
2658 16usize,
2659 concat!(
2660 "Offset of field: ",
2661 stringify!(dk_part),
2662 "::",
2663 stringify!(p_guid)
2664 )
2665 );
2666 assert_eq!(
2667 unsafe { ::std::ptr::addr_of!((*ptr).p_tag) as usize - ptr as usize },
2668 32usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(dk_part),
2672 "::",
2673 stringify!(p_tag)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe { ::std::ptr::addr_of!((*ptr).p_flag) as usize - ptr as usize },
2678 34usize,
2679 concat!(
2680 "Offset of field: ",
2681 stringify!(dk_part),
2682 "::",
2683 stringify!(p_flag)
2684 )
2685 );
2686 assert_eq!(
2687 unsafe { ::std::ptr::addr_of!((*ptr).p_name) as usize - ptr as usize },
2688 36usize,
2689 concat!(
2690 "Offset of field: ",
2691 stringify!(dk_part),
2692 "::",
2693 stringify!(p_name)
2694 )
2695 );
2696 assert_eq!(
2697 unsafe { ::std::ptr::addr_of!((*ptr).p_uguid) as usize - ptr as usize },
2698 72usize,
2699 concat!(
2700 "Offset of field: ",
2701 stringify!(dk_part),
2702 "::",
2703 stringify!(p_uguid)
2704 )
2705 );
2706 assert_eq!(
2707 unsafe { ::std::ptr::addr_of!((*ptr).p_resv) as usize - ptr as usize },
2708 88usize,
2709 concat!(
2710 "Offset of field: ",
2711 stringify!(dk_part),
2712 "::",
2713 stringify!(p_resv)
2714 )
2715 );
2716}
2717pub type dk_part_t = dk_part;
2718#[repr(C)]
2719#[derive(Debug, Copy, Clone)]
2720pub struct dk_gpt {
2721 pub efi_version: uint_t,
2722 pub efi_nparts: uint_t,
2723 pub efi_part_size: uint_t,
2724 pub efi_lbasize: uint_t,
2725 pub efi_last_lba: diskaddr_t,
2726 pub efi_first_u_lba: diskaddr_t,
2727 pub efi_last_u_lba: diskaddr_t,
2728 pub efi_disk_uguid: uuid,
2729 pub efi_flags: uint_t,
2730 pub efi_reserved1: uint_t,
2731 pub efi_altern_lba: diskaddr_t,
2732 pub efi_reserved: [uint_t; 12usize],
2733 pub efi_parts: [dk_part; 1usize],
2734}
2735#[test]
2736fn bindgen_test_layout_dk_gpt() {
2737 const UNINIT: ::std::mem::MaybeUninit<dk_gpt> = ::std::mem::MaybeUninit::uninit();
2738 let ptr = UNINIT.as_ptr();
2739 assert_eq!(
2740 ::std::mem::size_of::<dk_gpt>(),
2741 240usize,
2742 concat!("Size of: ", stringify!(dk_gpt))
2743 );
2744 assert_eq!(
2745 ::std::mem::align_of::<dk_gpt>(),
2746 8usize,
2747 concat!("Alignment of ", stringify!(dk_gpt))
2748 );
2749 assert_eq!(
2750 unsafe { ::std::ptr::addr_of!((*ptr).efi_version) as usize - ptr as usize },
2751 0usize,
2752 concat!(
2753 "Offset of field: ",
2754 stringify!(dk_gpt),
2755 "::",
2756 stringify!(efi_version)
2757 )
2758 );
2759 assert_eq!(
2760 unsafe { ::std::ptr::addr_of!((*ptr).efi_nparts) as usize - ptr as usize },
2761 4usize,
2762 concat!(
2763 "Offset of field: ",
2764 stringify!(dk_gpt),
2765 "::",
2766 stringify!(efi_nparts)
2767 )
2768 );
2769 assert_eq!(
2770 unsafe { ::std::ptr::addr_of!((*ptr).efi_part_size) as usize - ptr as usize },
2771 8usize,
2772 concat!(
2773 "Offset of field: ",
2774 stringify!(dk_gpt),
2775 "::",
2776 stringify!(efi_part_size)
2777 )
2778 );
2779 assert_eq!(
2780 unsafe { ::std::ptr::addr_of!((*ptr).efi_lbasize) as usize - ptr as usize },
2781 12usize,
2782 concat!(
2783 "Offset of field: ",
2784 stringify!(dk_gpt),
2785 "::",
2786 stringify!(efi_lbasize)
2787 )
2788 );
2789 assert_eq!(
2790 unsafe { ::std::ptr::addr_of!((*ptr).efi_last_lba) as usize - ptr as usize },
2791 16usize,
2792 concat!(
2793 "Offset of field: ",
2794 stringify!(dk_gpt),
2795 "::",
2796 stringify!(efi_last_lba)
2797 )
2798 );
2799 assert_eq!(
2800 unsafe { ::std::ptr::addr_of!((*ptr).efi_first_u_lba) as usize - ptr as usize },
2801 24usize,
2802 concat!(
2803 "Offset of field: ",
2804 stringify!(dk_gpt),
2805 "::",
2806 stringify!(efi_first_u_lba)
2807 )
2808 );
2809 assert_eq!(
2810 unsafe { ::std::ptr::addr_of!((*ptr).efi_last_u_lba) as usize - ptr as usize },
2811 32usize,
2812 concat!(
2813 "Offset of field: ",
2814 stringify!(dk_gpt),
2815 "::",
2816 stringify!(efi_last_u_lba)
2817 )
2818 );
2819 assert_eq!(
2820 unsafe { ::std::ptr::addr_of!((*ptr).efi_disk_uguid) as usize - ptr as usize },
2821 40usize,
2822 concat!(
2823 "Offset of field: ",
2824 stringify!(dk_gpt),
2825 "::",
2826 stringify!(efi_disk_uguid)
2827 )
2828 );
2829 assert_eq!(
2830 unsafe { ::std::ptr::addr_of!((*ptr).efi_flags) as usize - ptr as usize },
2831 56usize,
2832 concat!(
2833 "Offset of field: ",
2834 stringify!(dk_gpt),
2835 "::",
2836 stringify!(efi_flags)
2837 )
2838 );
2839 assert_eq!(
2840 unsafe { ::std::ptr::addr_of!((*ptr).efi_reserved1) as usize - ptr as usize },
2841 60usize,
2842 concat!(
2843 "Offset of field: ",
2844 stringify!(dk_gpt),
2845 "::",
2846 stringify!(efi_reserved1)
2847 )
2848 );
2849 assert_eq!(
2850 unsafe { ::std::ptr::addr_of!((*ptr).efi_altern_lba) as usize - ptr as usize },
2851 64usize,
2852 concat!(
2853 "Offset of field: ",
2854 stringify!(dk_gpt),
2855 "::",
2856 stringify!(efi_altern_lba)
2857 )
2858 );
2859 assert_eq!(
2860 unsafe { ::std::ptr::addr_of!((*ptr).efi_reserved) as usize - ptr as usize },
2861 72usize,
2862 concat!(
2863 "Offset of field: ",
2864 stringify!(dk_gpt),
2865 "::",
2866 stringify!(efi_reserved)
2867 )
2868 );
2869 assert_eq!(
2870 unsafe { ::std::ptr::addr_of!((*ptr).efi_parts) as usize - ptr as usize },
2871 120usize,
2872 concat!(
2873 "Offset of field: ",
2874 stringify!(dk_gpt),
2875 "::",
2876 stringify!(efi_parts)
2877 )
2878 );
2879}
2880pub type dk_gpt_t = dk_gpt;
2881#[repr(C)]
2882#[derive(Copy, Clone)]
2883pub struct dk_efi {
2884 pub dki_lba: diskaddr_t,
2885 pub dki_length: len_t,
2886 pub dki_un: dk_efi__bindgen_ty_1,
2887}
2888#[repr(C)]
2889#[derive(Copy, Clone)]
2890pub union dk_efi__bindgen_ty_1 {
2891 pub _dki_data: *mut efi_gpt_t,
2892 pub _dki_data_64: u64,
2893}
2894#[test]
2895fn bindgen_test_layout_dk_efi__bindgen_ty_1() {
2896 const UNINIT: ::std::mem::MaybeUninit<dk_efi__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit();
2897 let ptr = UNINIT.as_ptr();
2898 assert_eq!(
2899 ::std::mem::size_of::<dk_efi__bindgen_ty_1>(),
2900 8usize,
2901 concat!("Size of: ", stringify!(dk_efi__bindgen_ty_1))
2902 );
2903 assert_eq!(
2904 ::std::mem::align_of::<dk_efi__bindgen_ty_1>(),
2905 8usize,
2906 concat!("Alignment of ", stringify!(dk_efi__bindgen_ty_1))
2907 );
2908 assert_eq!(
2909 unsafe { ::std::ptr::addr_of!((*ptr)._dki_data) as usize - ptr as usize },
2910 0usize,
2911 concat!(
2912 "Offset of field: ",
2913 stringify!(dk_efi__bindgen_ty_1),
2914 "::",
2915 stringify!(_dki_data)
2916 )
2917 );
2918 assert_eq!(
2919 unsafe { ::std::ptr::addr_of!((*ptr)._dki_data_64) as usize - ptr as usize },
2920 0usize,
2921 concat!(
2922 "Offset of field: ",
2923 stringify!(dk_efi__bindgen_ty_1),
2924 "::",
2925 stringify!(_dki_data_64)
2926 )
2927 );
2928}
2929#[test]
2930fn bindgen_test_layout_dk_efi() {
2931 const UNINIT: ::std::mem::MaybeUninit<dk_efi> = ::std::mem::MaybeUninit::uninit();
2932 let ptr = UNINIT.as_ptr();
2933 assert_eq!(
2934 ::std::mem::size_of::<dk_efi>(),
2935 24usize,
2936 concat!("Size of: ", stringify!(dk_efi))
2937 );
2938 assert_eq!(
2939 ::std::mem::align_of::<dk_efi>(),
2940 8usize,
2941 concat!("Alignment of ", stringify!(dk_efi))
2942 );
2943 assert_eq!(
2944 unsafe { ::std::ptr::addr_of!((*ptr).dki_lba) as usize - ptr as usize },
2945 0usize,
2946 concat!(
2947 "Offset of field: ",
2948 stringify!(dk_efi),
2949 "::",
2950 stringify!(dki_lba)
2951 )
2952 );
2953 assert_eq!(
2954 unsafe { ::std::ptr::addr_of!((*ptr).dki_length) as usize - ptr as usize },
2955 8usize,
2956 concat!(
2957 "Offset of field: ",
2958 stringify!(dk_efi),
2959 "::",
2960 stringify!(dki_length)
2961 )
2962 );
2963 assert_eq!(
2964 unsafe { ::std::ptr::addr_of!((*ptr).dki_un) as usize - ptr as usize },
2965 16usize,
2966 concat!(
2967 "Offset of field: ",
2968 stringify!(dk_efi),
2969 "::",
2970 stringify!(dki_un)
2971 )
2972 );
2973}
2974pub type dk_efi_t = dk_efi;
2975#[repr(C)]
2976#[derive(Debug, Copy, Clone)]
2977pub struct partition64 {
2978 pub p_type: uuid,
2979 pub p_partno: uint_t,
2980 pub p_resv1: uint_t,
2981 pub p_start: diskaddr_t,
2982 pub p_size: diskaddr_t,
2983}
2984#[test]
2985fn bindgen_test_layout_partition64() {
2986 const UNINIT: ::std::mem::MaybeUninit<partition64> = ::std::mem::MaybeUninit::uninit();
2987 let ptr = UNINIT.as_ptr();
2988 assert_eq!(
2989 ::std::mem::size_of::<partition64>(),
2990 40usize,
2991 concat!("Size of: ", stringify!(partition64))
2992 );
2993 assert_eq!(
2994 ::std::mem::align_of::<partition64>(),
2995 8usize,
2996 concat!("Alignment of ", stringify!(partition64))
2997 );
2998 assert_eq!(
2999 unsafe { ::std::ptr::addr_of!((*ptr).p_type) as usize - ptr as usize },
3000 0usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(partition64),
3004 "::",
3005 stringify!(p_type)
3006 )
3007 );
3008 assert_eq!(
3009 unsafe { ::std::ptr::addr_of!((*ptr).p_partno) as usize - ptr as usize },
3010 16usize,
3011 concat!(
3012 "Offset of field: ",
3013 stringify!(partition64),
3014 "::",
3015 stringify!(p_partno)
3016 )
3017 );
3018 assert_eq!(
3019 unsafe { ::std::ptr::addr_of!((*ptr).p_resv1) as usize - ptr as usize },
3020 20usize,
3021 concat!(
3022 "Offset of field: ",
3023 stringify!(partition64),
3024 "::",
3025 stringify!(p_resv1)
3026 )
3027 );
3028 assert_eq!(
3029 unsafe { ::std::ptr::addr_of!((*ptr).p_start) as usize - ptr as usize },
3030 24usize,
3031 concat!(
3032 "Offset of field: ",
3033 stringify!(partition64),
3034 "::",
3035 stringify!(p_start)
3036 )
3037 );
3038 assert_eq!(
3039 unsafe { ::std::ptr::addr_of!((*ptr).p_size) as usize - ptr as usize },
3040 32usize,
3041 concat!(
3042 "Offset of field: ",
3043 stringify!(partition64),
3044 "::",
3045 stringify!(p_size)
3046 )
3047 );
3048}
3049extern "C" {
3050 pub fn efi_reserved_sectors(arg1: *mut dk_gpt) -> uint_t;
3051}
3052extern "C" {
3053 pub fn efi_alloc_and_init(
3054 arg1: ::std::os::raw::c_int,
3055 arg2: u32,
3056 arg3: *mut *mut dk_gpt,
3057 ) -> ::std::os::raw::c_int;
3058}
3059extern "C" {
3060 pub fn efi_alloc_and_read(
3061 arg1: ::std::os::raw::c_int,
3062 arg2: *mut *mut dk_gpt,
3063 ) -> ::std::os::raw::c_int;
3064}
3065extern "C" {
3066 pub fn efi_write(arg1: ::std::os::raw::c_int, arg2: *mut dk_gpt) -> ::std::os::raw::c_int;
3067}
3068extern "C" {
3069 pub fn efi_free(arg1: *mut dk_gpt);
3070}
3071extern "C" {
3072 pub fn efi_type(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3073}
3074extern "C" {
3075 pub fn efi_err_check(arg1: *mut dk_gpt);
3076}
3077extern "C" {
3078 pub fn efi_auto_sense(
3079 fd: ::std::os::raw::c_int,
3080 arg1: *mut *mut dk_gpt,
3081 ) -> ::std::os::raw::c_int;
3082}
3083extern "C" {
3084 pub fn efi_use_whole_disk(fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3085}
3086pub type caddr32_t = u32;
3087pub type daddr32_t = i32;
3088pub type off32_t = i32;
3089pub type ino32_t = u32;
3090pub type blkcnt32_t = i32;
3091pub type fsblkcnt32_t = u32;
3092pub type fsfilcnt32_t = u32;
3093pub type id32_t = i32;
3094pub type major32_t = u32;
3095pub type minor32_t = u32;
3096pub type key32_t = i32;
3097pub type mode32_t = u32;
3098pub type uid32_t = u32;
3099pub type gid32_t = u32;
3100pub type nlink32_t = u32;
3101pub type dev32_t = u32;
3102pub type pid32_t = i32;
3103pub type size32_t = u32;
3104pub type ssize32_t = i32;
3105pub type time32_t = i32;
3106pub type clock32_t = i32;
3107pub type uintptr32_t = u32;
3108pub type intptr32_t = i32;
3109#[repr(C)]
3110#[derive(Debug, Copy, Clone)]
3111pub struct timeval32 {
3112 pub tv_sec: time32_t,
3113 pub tv_usec: i32,
3114}
3115#[test]
3116fn bindgen_test_layout_timeval32() {
3117 const UNINIT: ::std::mem::MaybeUninit<timeval32> = ::std::mem::MaybeUninit::uninit();
3118 let ptr = UNINIT.as_ptr();
3119 assert_eq!(
3120 ::std::mem::size_of::<timeval32>(),
3121 8usize,
3122 concat!("Size of: ", stringify!(timeval32))
3123 );
3124 assert_eq!(
3125 ::std::mem::align_of::<timeval32>(),
3126 4usize,
3127 concat!("Alignment of ", stringify!(timeval32))
3128 );
3129 assert_eq!(
3130 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
3131 0usize,
3132 concat!(
3133 "Offset of field: ",
3134 stringify!(timeval32),
3135 "::",
3136 stringify!(tv_sec)
3137 )
3138 );
3139 assert_eq!(
3140 unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
3141 4usize,
3142 concat!(
3143 "Offset of field: ",
3144 stringify!(timeval32),
3145 "::",
3146 stringify!(tv_usec)
3147 )
3148 );
3149}
3150#[repr(C)]
3151#[derive(Debug, Copy, Clone)]
3152pub struct timespec32 {
3153 pub tv_sec: time32_t,
3154 pub tv_nsec: i32,
3155}
3156#[test]
3157fn bindgen_test_layout_timespec32() {
3158 const UNINIT: ::std::mem::MaybeUninit<timespec32> = ::std::mem::MaybeUninit::uninit();
3159 let ptr = UNINIT.as_ptr();
3160 assert_eq!(
3161 ::std::mem::size_of::<timespec32>(),
3162 8usize,
3163 concat!("Size of: ", stringify!(timespec32))
3164 );
3165 assert_eq!(
3166 ::std::mem::align_of::<timespec32>(),
3167 4usize,
3168 concat!("Alignment of ", stringify!(timespec32))
3169 );
3170 assert_eq!(
3171 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
3172 0usize,
3173 concat!(
3174 "Offset of field: ",
3175 stringify!(timespec32),
3176 "::",
3177 stringify!(tv_sec)
3178 )
3179 );
3180 assert_eq!(
3181 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
3182 4usize,
3183 concat!(
3184 "Offset of field: ",
3185 stringify!(timespec32),
3186 "::",
3187 stringify!(tv_nsec)
3188 )
3189 );
3190}
3191pub type timespec32_t = timespec32;
3192pub type timestruc32_t = timespec32;
3193#[repr(C)]
3194#[derive(Debug, Copy, Clone)]
3195pub struct itimerspec32 {
3196 pub it_interval: timespec32,
3197 pub it_value: timespec32,
3198}
3199#[test]
3200fn bindgen_test_layout_itimerspec32() {
3201 const UNINIT: ::std::mem::MaybeUninit<itimerspec32> = ::std::mem::MaybeUninit::uninit();
3202 let ptr = UNINIT.as_ptr();
3203 assert_eq!(
3204 ::std::mem::size_of::<itimerspec32>(),
3205 16usize,
3206 concat!("Size of: ", stringify!(itimerspec32))
3207 );
3208 assert_eq!(
3209 ::std::mem::align_of::<itimerspec32>(),
3210 4usize,
3211 concat!("Alignment of ", stringify!(itimerspec32))
3212 );
3213 assert_eq!(
3214 unsafe { ::std::ptr::addr_of!((*ptr).it_interval) as usize - ptr as usize },
3215 0usize,
3216 concat!(
3217 "Offset of field: ",
3218 stringify!(itimerspec32),
3219 "::",
3220 stringify!(it_interval)
3221 )
3222 );
3223 assert_eq!(
3224 unsafe { ::std::ptr::addr_of!((*ptr).it_value) as usize - ptr as usize },
3225 8usize,
3226 concat!(
3227 "Offset of field: ",
3228 stringify!(itimerspec32),
3229 "::",
3230 stringify!(it_value)
3231 )
3232 );
3233}
3234pub type itimerspec32_t = itimerspec32;
3235pub type blkaddr_t = daddr_t;
3236pub type blkaddr32_t = daddr32_t;
3237#[repr(C)]
3238#[derive(Debug, Copy, Clone)]
3239pub struct dk_map {
3240 pub dkl_cylno: blkaddr_t,
3241 pub dkl_nblk: blkaddr_t,
3242}
3243#[test]
3244fn bindgen_test_layout_dk_map() {
3245 const UNINIT: ::std::mem::MaybeUninit<dk_map> = ::std::mem::MaybeUninit::uninit();
3246 let ptr = UNINIT.as_ptr();
3247 assert_eq!(
3248 ::std::mem::size_of::<dk_map>(),
3249 16usize,
3250 concat!("Size of: ", stringify!(dk_map))
3251 );
3252 assert_eq!(
3253 ::std::mem::align_of::<dk_map>(),
3254 8usize,
3255 concat!("Alignment of ", stringify!(dk_map))
3256 );
3257 assert_eq!(
3258 unsafe { ::std::ptr::addr_of!((*ptr).dkl_cylno) as usize - ptr as usize },
3259 0usize,
3260 concat!(
3261 "Offset of field: ",
3262 stringify!(dk_map),
3263 "::",
3264 stringify!(dkl_cylno)
3265 )
3266 );
3267 assert_eq!(
3268 unsafe { ::std::ptr::addr_of!((*ptr).dkl_nblk) as usize - ptr as usize },
3269 8usize,
3270 concat!(
3271 "Offset of field: ",
3272 stringify!(dk_map),
3273 "::",
3274 stringify!(dkl_nblk)
3275 )
3276 );
3277}
3278#[repr(C)]
3279#[derive(Debug, Copy, Clone)]
3280pub struct dk_map32 {
3281 pub dkl_cylno: blkaddr32_t,
3282 pub dkl_nblk: blkaddr32_t,
3283}
3284#[test]
3285fn bindgen_test_layout_dk_map32() {
3286 const UNINIT: ::std::mem::MaybeUninit<dk_map32> = ::std::mem::MaybeUninit::uninit();
3287 let ptr = UNINIT.as_ptr();
3288 assert_eq!(
3289 ::std::mem::size_of::<dk_map32>(),
3290 8usize,
3291 concat!("Size of: ", stringify!(dk_map32))
3292 );
3293 assert_eq!(
3294 ::std::mem::align_of::<dk_map32>(),
3295 4usize,
3296 concat!("Alignment of ", stringify!(dk_map32))
3297 );
3298 assert_eq!(
3299 unsafe { ::std::ptr::addr_of!((*ptr).dkl_cylno) as usize - ptr as usize },
3300 0usize,
3301 concat!(
3302 "Offset of field: ",
3303 stringify!(dk_map32),
3304 "::",
3305 stringify!(dkl_cylno)
3306 )
3307 );
3308 assert_eq!(
3309 unsafe { ::std::ptr::addr_of!((*ptr).dkl_nblk) as usize - ptr as usize },
3310 4usize,
3311 concat!(
3312 "Offset of field: ",
3313 stringify!(dk_map32),
3314 "::",
3315 stringify!(dkl_nblk)
3316 )
3317 );
3318}
3319#[repr(C)]
3320#[derive(Debug, Copy, Clone)]
3321pub struct dk_map2 {
3322 pub p_tag: u16,
3323 pub p_flag: u16,
3324}
3325#[test]
3326fn bindgen_test_layout_dk_map2() {
3327 const UNINIT: ::std::mem::MaybeUninit<dk_map2> = ::std::mem::MaybeUninit::uninit();
3328 let ptr = UNINIT.as_ptr();
3329 assert_eq!(
3330 ::std::mem::size_of::<dk_map2>(),
3331 4usize,
3332 concat!("Size of: ", stringify!(dk_map2))
3333 );
3334 assert_eq!(
3335 ::std::mem::align_of::<dk_map2>(),
3336 2usize,
3337 concat!("Alignment of ", stringify!(dk_map2))
3338 );
3339 assert_eq!(
3340 unsafe { ::std::ptr::addr_of!((*ptr).p_tag) as usize - ptr as usize },
3341 0usize,
3342 concat!(
3343 "Offset of field: ",
3344 stringify!(dk_map2),
3345 "::",
3346 stringify!(p_tag)
3347 )
3348 );
3349 assert_eq!(
3350 unsafe { ::std::ptr::addr_of!((*ptr).p_flag) as usize - ptr as usize },
3351 2usize,
3352 concat!(
3353 "Offset of field: ",
3354 stringify!(dk_map2),
3355 "::",
3356 stringify!(p_flag)
3357 )
3358 );
3359}
3360#[repr(C)]
3361#[derive(Debug, Copy, Clone)]
3362pub struct dkl_partition {
3363 pub p_tag: u16,
3364 pub p_flag: u16,
3365 pub p_start: blkaddr32_t,
3366 pub p_size: blkaddr32_t,
3367}
3368#[test]
3369fn bindgen_test_layout_dkl_partition() {
3370 const UNINIT: ::std::mem::MaybeUninit<dkl_partition> = ::std::mem::MaybeUninit::uninit();
3371 let ptr = UNINIT.as_ptr();
3372 assert_eq!(
3373 ::std::mem::size_of::<dkl_partition>(),
3374 12usize,
3375 concat!("Size of: ", stringify!(dkl_partition))
3376 );
3377 assert_eq!(
3378 ::std::mem::align_of::<dkl_partition>(),
3379 4usize,
3380 concat!("Alignment of ", stringify!(dkl_partition))
3381 );
3382 assert_eq!(
3383 unsafe { ::std::ptr::addr_of!((*ptr).p_tag) as usize - ptr as usize },
3384 0usize,
3385 concat!(
3386 "Offset of field: ",
3387 stringify!(dkl_partition),
3388 "::",
3389 stringify!(p_tag)
3390 )
3391 );
3392 assert_eq!(
3393 unsafe { ::std::ptr::addr_of!((*ptr).p_flag) as usize - ptr as usize },
3394 2usize,
3395 concat!(
3396 "Offset of field: ",
3397 stringify!(dkl_partition),
3398 "::",
3399 stringify!(p_flag)
3400 )
3401 );
3402 assert_eq!(
3403 unsafe { ::std::ptr::addr_of!((*ptr).p_start) as usize - ptr as usize },
3404 4usize,
3405 concat!(
3406 "Offset of field: ",
3407 stringify!(dkl_partition),
3408 "::",
3409 stringify!(p_start)
3410 )
3411 );
3412 assert_eq!(
3413 unsafe { ::std::ptr::addr_of!((*ptr).p_size) as usize - ptr as usize },
3414 8usize,
3415 concat!(
3416 "Offset of field: ",
3417 stringify!(dkl_partition),
3418 "::",
3419 stringify!(p_size)
3420 )
3421 );
3422}
3423#[repr(C)]
3424#[derive(Debug, Copy, Clone)]
3425pub struct dk_vtoc {
3426 pub v_bootinfo: [u32; 3usize],
3427 pub v_sanity: u32,
3428 pub v_version: u32,
3429 pub v_volume: [::std::os::raw::c_char; 8usize],
3430 pub v_sectorsz: u16,
3431 pub v_nparts: u16,
3432 pub v_reserved: [u32; 10usize],
3433 pub v_part: [dkl_partition; 16usize],
3434 pub timestamp: [time32_t; 16usize],
3435 pub v_asciilabel: [::std::os::raw::c_char; 128usize],
3436}
3437#[test]
3438fn bindgen_test_layout_dk_vtoc() {
3439 const UNINIT: ::std::mem::MaybeUninit<dk_vtoc> = ::std::mem::MaybeUninit::uninit();
3440 let ptr = UNINIT.as_ptr();
3441 assert_eq!(
3442 ::std::mem::size_of::<dk_vtoc>(),
3443 456usize,
3444 concat!("Size of: ", stringify!(dk_vtoc))
3445 );
3446 assert_eq!(
3447 ::std::mem::align_of::<dk_vtoc>(),
3448 4usize,
3449 concat!("Alignment of ", stringify!(dk_vtoc))
3450 );
3451 assert_eq!(
3452 unsafe { ::std::ptr::addr_of!((*ptr).v_bootinfo) as usize - ptr as usize },
3453 0usize,
3454 concat!(
3455 "Offset of field: ",
3456 stringify!(dk_vtoc),
3457 "::",
3458 stringify!(v_bootinfo)
3459 )
3460 );
3461 assert_eq!(
3462 unsafe { ::std::ptr::addr_of!((*ptr).v_sanity) as usize - ptr as usize },
3463 12usize,
3464 concat!(
3465 "Offset of field: ",
3466 stringify!(dk_vtoc),
3467 "::",
3468 stringify!(v_sanity)
3469 )
3470 );
3471 assert_eq!(
3472 unsafe { ::std::ptr::addr_of!((*ptr).v_version) as usize - ptr as usize },
3473 16usize,
3474 concat!(
3475 "Offset of field: ",
3476 stringify!(dk_vtoc),
3477 "::",
3478 stringify!(v_version)
3479 )
3480 );
3481 assert_eq!(
3482 unsafe { ::std::ptr::addr_of!((*ptr).v_volume) as usize - ptr as usize },
3483 20usize,
3484 concat!(
3485 "Offset of field: ",
3486 stringify!(dk_vtoc),
3487 "::",
3488 stringify!(v_volume)
3489 )
3490 );
3491 assert_eq!(
3492 unsafe { ::std::ptr::addr_of!((*ptr).v_sectorsz) as usize - ptr as usize },
3493 28usize,
3494 concat!(
3495 "Offset of field: ",
3496 stringify!(dk_vtoc),
3497 "::",
3498 stringify!(v_sectorsz)
3499 )
3500 );
3501 assert_eq!(
3502 unsafe { ::std::ptr::addr_of!((*ptr).v_nparts) as usize - ptr as usize },
3503 30usize,
3504 concat!(
3505 "Offset of field: ",
3506 stringify!(dk_vtoc),
3507 "::",
3508 stringify!(v_nparts)
3509 )
3510 );
3511 assert_eq!(
3512 unsafe { ::std::ptr::addr_of!((*ptr).v_reserved) as usize - ptr as usize },
3513 32usize,
3514 concat!(
3515 "Offset of field: ",
3516 stringify!(dk_vtoc),
3517 "::",
3518 stringify!(v_reserved)
3519 )
3520 );
3521 assert_eq!(
3522 unsafe { ::std::ptr::addr_of!((*ptr).v_part) as usize - ptr as usize },
3523 72usize,
3524 concat!(
3525 "Offset of field: ",
3526 stringify!(dk_vtoc),
3527 "::",
3528 stringify!(v_part)
3529 )
3530 );
3531 assert_eq!(
3532 unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
3533 264usize,
3534 concat!(
3535 "Offset of field: ",
3536 stringify!(dk_vtoc),
3537 "::",
3538 stringify!(timestamp)
3539 )
3540 );
3541 assert_eq!(
3542 unsafe { ::std::ptr::addr_of!((*ptr).v_asciilabel) as usize - ptr as usize },
3543 328usize,
3544 concat!(
3545 "Offset of field: ",
3546 stringify!(dk_vtoc),
3547 "::",
3548 stringify!(v_asciilabel)
3549 )
3550 );
3551}
3552#[repr(C)]
3553#[derive(Debug, Copy, Clone)]
3554pub struct dk_label {
3555 pub dkl_vtoc: dk_vtoc,
3556 pub dkl_pcyl: u32,
3557 pub dkl_ncyl: u32,
3558 pub dkl_acyl: u16,
3559 pub dkl_bcyl: u16,
3560 pub dkl_nhead: u32,
3561 pub dkl_nsect: u32,
3562 pub dkl_intrlv: u16,
3563 pub dkl_skew: u16,
3564 pub dkl_apc: u16,
3565 pub dkl_rpm: u16,
3566 pub dkl_write_reinstruct: u16,
3567 pub dkl_read_reinstruct: u16,
3568 pub dkl_extra: [u16; 4usize],
3569 pub dkl_pad: [::std::os::raw::c_char; 12usize],
3570 pub dkl_magic: u16,
3571 pub dkl_cksum: u16,
3572}
3573#[test]
3574fn bindgen_test_layout_dk_label() {
3575 const UNINIT: ::std::mem::MaybeUninit<dk_label> = ::std::mem::MaybeUninit::uninit();
3576 let ptr = UNINIT.as_ptr();
3577 assert_eq!(
3578 ::std::mem::size_of::<dk_label>(),
3579 512usize,
3580 concat!("Size of: ", stringify!(dk_label))
3581 );
3582 assert_eq!(
3583 ::std::mem::align_of::<dk_label>(),
3584 4usize,
3585 concat!("Alignment of ", stringify!(dk_label))
3586 );
3587 assert_eq!(
3588 unsafe { ::std::ptr::addr_of!((*ptr).dkl_vtoc) as usize - ptr as usize },
3589 0usize,
3590 concat!(
3591 "Offset of field: ",
3592 stringify!(dk_label),
3593 "::",
3594 stringify!(dkl_vtoc)
3595 )
3596 );
3597 assert_eq!(
3598 unsafe { ::std::ptr::addr_of!((*ptr).dkl_pcyl) as usize - ptr as usize },
3599 456usize,
3600 concat!(
3601 "Offset of field: ",
3602 stringify!(dk_label),
3603 "::",
3604 stringify!(dkl_pcyl)
3605 )
3606 );
3607 assert_eq!(
3608 unsafe { ::std::ptr::addr_of!((*ptr).dkl_ncyl) as usize - ptr as usize },
3609 460usize,
3610 concat!(
3611 "Offset of field: ",
3612 stringify!(dk_label),
3613 "::",
3614 stringify!(dkl_ncyl)
3615 )
3616 );
3617 assert_eq!(
3618 unsafe { ::std::ptr::addr_of!((*ptr).dkl_acyl) as usize - ptr as usize },
3619 464usize,
3620 concat!(
3621 "Offset of field: ",
3622 stringify!(dk_label),
3623 "::",
3624 stringify!(dkl_acyl)
3625 )
3626 );
3627 assert_eq!(
3628 unsafe { ::std::ptr::addr_of!((*ptr).dkl_bcyl) as usize - ptr as usize },
3629 466usize,
3630 concat!(
3631 "Offset of field: ",
3632 stringify!(dk_label),
3633 "::",
3634 stringify!(dkl_bcyl)
3635 )
3636 );
3637 assert_eq!(
3638 unsafe { ::std::ptr::addr_of!((*ptr).dkl_nhead) as usize - ptr as usize },
3639 468usize,
3640 concat!(
3641 "Offset of field: ",
3642 stringify!(dk_label),
3643 "::",
3644 stringify!(dkl_nhead)
3645 )
3646 );
3647 assert_eq!(
3648 unsafe { ::std::ptr::addr_of!((*ptr).dkl_nsect) as usize - ptr as usize },
3649 472usize,
3650 concat!(
3651 "Offset of field: ",
3652 stringify!(dk_label),
3653 "::",
3654 stringify!(dkl_nsect)
3655 )
3656 );
3657 assert_eq!(
3658 unsafe { ::std::ptr::addr_of!((*ptr).dkl_intrlv) as usize - ptr as usize },
3659 476usize,
3660 concat!(
3661 "Offset of field: ",
3662 stringify!(dk_label),
3663 "::",
3664 stringify!(dkl_intrlv)
3665 )
3666 );
3667 assert_eq!(
3668 unsafe { ::std::ptr::addr_of!((*ptr).dkl_skew) as usize - ptr as usize },
3669 478usize,
3670 concat!(
3671 "Offset of field: ",
3672 stringify!(dk_label),
3673 "::",
3674 stringify!(dkl_skew)
3675 )
3676 );
3677 assert_eq!(
3678 unsafe { ::std::ptr::addr_of!((*ptr).dkl_apc) as usize - ptr as usize },
3679 480usize,
3680 concat!(
3681 "Offset of field: ",
3682 stringify!(dk_label),
3683 "::",
3684 stringify!(dkl_apc)
3685 )
3686 );
3687 assert_eq!(
3688 unsafe { ::std::ptr::addr_of!((*ptr).dkl_rpm) as usize - ptr as usize },
3689 482usize,
3690 concat!(
3691 "Offset of field: ",
3692 stringify!(dk_label),
3693 "::",
3694 stringify!(dkl_rpm)
3695 )
3696 );
3697 assert_eq!(
3698 unsafe { ::std::ptr::addr_of!((*ptr).dkl_write_reinstruct) as usize - ptr as usize },
3699 484usize,
3700 concat!(
3701 "Offset of field: ",
3702 stringify!(dk_label),
3703 "::",
3704 stringify!(dkl_write_reinstruct)
3705 )
3706 );
3707 assert_eq!(
3708 unsafe { ::std::ptr::addr_of!((*ptr).dkl_read_reinstruct) as usize - ptr as usize },
3709 486usize,
3710 concat!(
3711 "Offset of field: ",
3712 stringify!(dk_label),
3713 "::",
3714 stringify!(dkl_read_reinstruct)
3715 )
3716 );
3717 assert_eq!(
3718 unsafe { ::std::ptr::addr_of!((*ptr).dkl_extra) as usize - ptr as usize },
3719 488usize,
3720 concat!(
3721 "Offset of field: ",
3722 stringify!(dk_label),
3723 "::",
3724 stringify!(dkl_extra)
3725 )
3726 );
3727 assert_eq!(
3728 unsafe { ::std::ptr::addr_of!((*ptr).dkl_pad) as usize - ptr as usize },
3729 496usize,
3730 concat!(
3731 "Offset of field: ",
3732 stringify!(dk_label),
3733 "::",
3734 stringify!(dkl_pad)
3735 )
3736 );
3737 assert_eq!(
3738 unsafe { ::std::ptr::addr_of!((*ptr).dkl_magic) as usize - ptr as usize },
3739 508usize,
3740 concat!(
3741 "Offset of field: ",
3742 stringify!(dk_label),
3743 "::",
3744 stringify!(dkl_magic)
3745 )
3746 );
3747 assert_eq!(
3748 unsafe { ::std::ptr::addr_of!((*ptr).dkl_cksum) as usize - ptr as usize },
3749 510usize,
3750 concat!(
3751 "Offset of field: ",
3752 stringify!(dk_label),
3753 "::",
3754 stringify!(dkl_cksum)
3755 )
3756 );
3757}
3758#[repr(C)]
3759#[derive(Debug, Copy, Clone)]
3760pub struct fk_label {
3761 pub fkl_type: uchar_t,
3762 pub fkl_magich: uchar_t,
3763 pub fkl_magicl: uchar_t,
3764 pub filler: uchar_t,
3765}
3766#[test]
3767fn bindgen_test_layout_fk_label() {
3768 const UNINIT: ::std::mem::MaybeUninit<fk_label> = ::std::mem::MaybeUninit::uninit();
3769 let ptr = UNINIT.as_ptr();
3770 assert_eq!(
3771 ::std::mem::size_of::<fk_label>(),
3772 4usize,
3773 concat!("Size of: ", stringify!(fk_label))
3774 );
3775 assert_eq!(
3776 ::std::mem::align_of::<fk_label>(),
3777 1usize,
3778 concat!("Alignment of ", stringify!(fk_label))
3779 );
3780 assert_eq!(
3781 unsafe { ::std::ptr::addr_of!((*ptr).fkl_type) as usize - ptr as usize },
3782 0usize,
3783 concat!(
3784 "Offset of field: ",
3785 stringify!(fk_label),
3786 "::",
3787 stringify!(fkl_type)
3788 )
3789 );
3790 assert_eq!(
3791 unsafe { ::std::ptr::addr_of!((*ptr).fkl_magich) as usize - ptr as usize },
3792 1usize,
3793 concat!(
3794 "Offset of field: ",
3795 stringify!(fk_label),
3796 "::",
3797 stringify!(fkl_magich)
3798 )
3799 );
3800 assert_eq!(
3801 unsafe { ::std::ptr::addr_of!((*ptr).fkl_magicl) as usize - ptr as usize },
3802 2usize,
3803 concat!(
3804 "Offset of field: ",
3805 stringify!(fk_label),
3806 "::",
3807 stringify!(fkl_magicl)
3808 )
3809 );
3810 assert_eq!(
3811 unsafe { ::std::ptr::addr_of!((*ptr).filler) as usize - ptr as usize },
3812 3usize,
3813 concat!(
3814 "Offset of field: ",
3815 stringify!(fk_label),
3816 "::",
3817 stringify!(filler)
3818 )
3819 );
3820}
3821#[repr(C)]
3822#[derive(Debug, Copy, Clone)]
3823pub struct dk_devid {
3824 pub dkd_rev_hi: uchar_t,
3825 pub dkd_rev_lo: uchar_t,
3826 pub dkd_flags: uchar_t,
3827 pub dkd_devid: [uchar_t; 505usize],
3828 pub dkd_checksum3: uchar_t,
3829 pub dkd_checksum2: uchar_t,
3830 pub dkd_checksum1: uchar_t,
3831 pub dkd_checksum0: uchar_t,
3832}
3833#[test]
3834fn bindgen_test_layout_dk_devid() {
3835 const UNINIT: ::std::mem::MaybeUninit<dk_devid> = ::std::mem::MaybeUninit::uninit();
3836 let ptr = UNINIT.as_ptr();
3837 assert_eq!(
3838 ::std::mem::size_of::<dk_devid>(),
3839 512usize,
3840 concat!("Size of: ", stringify!(dk_devid))
3841 );
3842 assert_eq!(
3843 ::std::mem::align_of::<dk_devid>(),
3844 1usize,
3845 concat!("Alignment of ", stringify!(dk_devid))
3846 );
3847 assert_eq!(
3848 unsafe { ::std::ptr::addr_of!((*ptr).dkd_rev_hi) as usize - ptr as usize },
3849 0usize,
3850 concat!(
3851 "Offset of field: ",
3852 stringify!(dk_devid),
3853 "::",
3854 stringify!(dkd_rev_hi)
3855 )
3856 );
3857 assert_eq!(
3858 unsafe { ::std::ptr::addr_of!((*ptr).dkd_rev_lo) as usize - ptr as usize },
3859 1usize,
3860 concat!(
3861 "Offset of field: ",
3862 stringify!(dk_devid),
3863 "::",
3864 stringify!(dkd_rev_lo)
3865 )
3866 );
3867 assert_eq!(
3868 unsafe { ::std::ptr::addr_of!((*ptr).dkd_flags) as usize - ptr as usize },
3869 2usize,
3870 concat!(
3871 "Offset of field: ",
3872 stringify!(dk_devid),
3873 "::",
3874 stringify!(dkd_flags)
3875 )
3876 );
3877 assert_eq!(
3878 unsafe { ::std::ptr::addr_of!((*ptr).dkd_devid) as usize - ptr as usize },
3879 3usize,
3880 concat!(
3881 "Offset of field: ",
3882 stringify!(dk_devid),
3883 "::",
3884 stringify!(dkd_devid)
3885 )
3886 );
3887 assert_eq!(
3888 unsafe { ::std::ptr::addr_of!((*ptr).dkd_checksum3) as usize - ptr as usize },
3889 508usize,
3890 concat!(
3891 "Offset of field: ",
3892 stringify!(dk_devid),
3893 "::",
3894 stringify!(dkd_checksum3)
3895 )
3896 );
3897 assert_eq!(
3898 unsafe { ::std::ptr::addr_of!((*ptr).dkd_checksum2) as usize - ptr as usize },
3899 509usize,
3900 concat!(
3901 "Offset of field: ",
3902 stringify!(dk_devid),
3903 "::",
3904 stringify!(dkd_checksum2)
3905 )
3906 );
3907 assert_eq!(
3908 unsafe { ::std::ptr::addr_of!((*ptr).dkd_checksum1) as usize - ptr as usize },
3909 510usize,
3910 concat!(
3911 "Offset of field: ",
3912 stringify!(dk_devid),
3913 "::",
3914 stringify!(dkd_checksum1)
3915 )
3916 );
3917 assert_eq!(
3918 unsafe { ::std::ptr::addr_of!((*ptr).dkd_checksum0) as usize - ptr as usize },
3919 511usize,
3920 concat!(
3921 "Offset of field: ",
3922 stringify!(dk_devid),
3923 "::",
3924 stringify!(dkd_checksum0)
3925 )
3926 );
3927}
3928#[repr(C)]
3929#[derive(Debug, Copy, Clone)]
3930pub struct partition {
3931 pub p_tag: ushort_t,
3932 pub p_flag: ushort_t,
3933 pub p_start: daddr_t,
3934 pub p_size: ::std::os::raw::c_long,
3935}
3936#[test]
3937fn bindgen_test_layout_partition() {
3938 const UNINIT: ::std::mem::MaybeUninit<partition> = ::std::mem::MaybeUninit::uninit();
3939 let ptr = UNINIT.as_ptr();
3940 assert_eq!(
3941 ::std::mem::size_of::<partition>(),
3942 24usize,
3943 concat!("Size of: ", stringify!(partition))
3944 );
3945 assert_eq!(
3946 ::std::mem::align_of::<partition>(),
3947 8usize,
3948 concat!("Alignment of ", stringify!(partition))
3949 );
3950 assert_eq!(
3951 unsafe { ::std::ptr::addr_of!((*ptr).p_tag) as usize - ptr as usize },
3952 0usize,
3953 concat!(
3954 "Offset of field: ",
3955 stringify!(partition),
3956 "::",
3957 stringify!(p_tag)
3958 )
3959 );
3960 assert_eq!(
3961 unsafe { ::std::ptr::addr_of!((*ptr).p_flag) as usize - ptr as usize },
3962 2usize,
3963 concat!(
3964 "Offset of field: ",
3965 stringify!(partition),
3966 "::",
3967 stringify!(p_flag)
3968 )
3969 );
3970 assert_eq!(
3971 unsafe { ::std::ptr::addr_of!((*ptr).p_start) as usize - ptr as usize },
3972 8usize,
3973 concat!(
3974 "Offset of field: ",
3975 stringify!(partition),
3976 "::",
3977 stringify!(p_start)
3978 )
3979 );
3980 assert_eq!(
3981 unsafe { ::std::ptr::addr_of!((*ptr).p_size) as usize - ptr as usize },
3982 16usize,
3983 concat!(
3984 "Offset of field: ",
3985 stringify!(partition),
3986 "::",
3987 stringify!(p_size)
3988 )
3989 );
3990}
3991#[repr(C)]
3992#[derive(Debug, Copy, Clone)]
3993pub struct vtoc {
3994 pub v_bootinfo: [::std::os::raw::c_ulong; 3usize],
3995 pub v_sanity: ::std::os::raw::c_ulong,
3996 pub v_version: ::std::os::raw::c_ulong,
3997 pub v_volume: [::std::os::raw::c_char; 8usize],
3998 pub v_sectorsz: ushort_t,
3999 pub v_nparts: ushort_t,
4000 pub v_reserved: [::std::os::raw::c_ulong; 10usize],
4001 pub v_part: [partition; 16usize],
4002 pub timestamp: [time_t; 16usize],
4003 pub v_asciilabel: [::std::os::raw::c_char; 128usize],
4004}
4005#[test]
4006fn bindgen_test_layout_vtoc() {
4007 const UNINIT: ::std::mem::MaybeUninit<vtoc> = ::std::mem::MaybeUninit::uninit();
4008 let ptr = UNINIT.as_ptr();
4009 assert_eq!(
4010 ::std::mem::size_of::<vtoc>(),
4011 776usize,
4012 concat!("Size of: ", stringify!(vtoc))
4013 );
4014 assert_eq!(
4015 ::std::mem::align_of::<vtoc>(),
4016 8usize,
4017 concat!("Alignment of ", stringify!(vtoc))
4018 );
4019 assert_eq!(
4020 unsafe { ::std::ptr::addr_of!((*ptr).v_bootinfo) as usize - ptr as usize },
4021 0usize,
4022 concat!(
4023 "Offset of field: ",
4024 stringify!(vtoc),
4025 "::",
4026 stringify!(v_bootinfo)
4027 )
4028 );
4029 assert_eq!(
4030 unsafe { ::std::ptr::addr_of!((*ptr).v_sanity) as usize - ptr as usize },
4031 24usize,
4032 concat!(
4033 "Offset of field: ",
4034 stringify!(vtoc),
4035 "::",
4036 stringify!(v_sanity)
4037 )
4038 );
4039 assert_eq!(
4040 unsafe { ::std::ptr::addr_of!((*ptr).v_version) as usize - ptr as usize },
4041 32usize,
4042 concat!(
4043 "Offset of field: ",
4044 stringify!(vtoc),
4045 "::",
4046 stringify!(v_version)
4047 )
4048 );
4049 assert_eq!(
4050 unsafe { ::std::ptr::addr_of!((*ptr).v_volume) as usize - ptr as usize },
4051 40usize,
4052 concat!(
4053 "Offset of field: ",
4054 stringify!(vtoc),
4055 "::",
4056 stringify!(v_volume)
4057 )
4058 );
4059 assert_eq!(
4060 unsafe { ::std::ptr::addr_of!((*ptr).v_sectorsz) as usize - ptr as usize },
4061 48usize,
4062 concat!(
4063 "Offset of field: ",
4064 stringify!(vtoc),
4065 "::",
4066 stringify!(v_sectorsz)
4067 )
4068 );
4069 assert_eq!(
4070 unsafe { ::std::ptr::addr_of!((*ptr).v_nparts) as usize - ptr as usize },
4071 50usize,
4072 concat!(
4073 "Offset of field: ",
4074 stringify!(vtoc),
4075 "::",
4076 stringify!(v_nparts)
4077 )
4078 );
4079 assert_eq!(
4080 unsafe { ::std::ptr::addr_of!((*ptr).v_reserved) as usize - ptr as usize },
4081 56usize,
4082 concat!(
4083 "Offset of field: ",
4084 stringify!(vtoc),
4085 "::",
4086 stringify!(v_reserved)
4087 )
4088 );
4089 assert_eq!(
4090 unsafe { ::std::ptr::addr_of!((*ptr).v_part) as usize - ptr as usize },
4091 136usize,
4092 concat!(
4093 "Offset of field: ",
4094 stringify!(vtoc),
4095 "::",
4096 stringify!(v_part)
4097 )
4098 );
4099 assert_eq!(
4100 unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
4101 520usize,
4102 concat!(
4103 "Offset of field: ",
4104 stringify!(vtoc),
4105 "::",
4106 stringify!(timestamp)
4107 )
4108 );
4109 assert_eq!(
4110 unsafe { ::std::ptr::addr_of!((*ptr).v_asciilabel) as usize - ptr as usize },
4111 648usize,
4112 concat!(
4113 "Offset of field: ",
4114 stringify!(vtoc),
4115 "::",
4116 stringify!(v_asciilabel)
4117 )
4118 );
4119}
4120#[repr(C)]
4121#[derive(Debug, Copy, Clone)]
4122pub struct extpartition {
4123 pub p_tag: ushort_t,
4124 pub p_flag: ushort_t,
4125 pub p_pad: [ushort_t; 2usize],
4126 pub p_start: diskaddr_t,
4127 pub p_size: diskaddr_t,
4128}
4129#[test]
4130fn bindgen_test_layout_extpartition() {
4131 const UNINIT: ::std::mem::MaybeUninit<extpartition> = ::std::mem::MaybeUninit::uninit();
4132 let ptr = UNINIT.as_ptr();
4133 assert_eq!(
4134 ::std::mem::size_of::<extpartition>(),
4135 24usize,
4136 concat!("Size of: ", stringify!(extpartition))
4137 );
4138 assert_eq!(
4139 ::std::mem::align_of::<extpartition>(),
4140 8usize,
4141 concat!("Alignment of ", stringify!(extpartition))
4142 );
4143 assert_eq!(
4144 unsafe { ::std::ptr::addr_of!((*ptr).p_tag) as usize - ptr as usize },
4145 0usize,
4146 concat!(
4147 "Offset of field: ",
4148 stringify!(extpartition),
4149 "::",
4150 stringify!(p_tag)
4151 )
4152 );
4153 assert_eq!(
4154 unsafe { ::std::ptr::addr_of!((*ptr).p_flag) as usize - ptr as usize },
4155 2usize,
4156 concat!(
4157 "Offset of field: ",
4158 stringify!(extpartition),
4159 "::",
4160 stringify!(p_flag)
4161 )
4162 );
4163 assert_eq!(
4164 unsafe { ::std::ptr::addr_of!((*ptr).p_pad) as usize - ptr as usize },
4165 4usize,
4166 concat!(
4167 "Offset of field: ",
4168 stringify!(extpartition),
4169 "::",
4170 stringify!(p_pad)
4171 )
4172 );
4173 assert_eq!(
4174 unsafe { ::std::ptr::addr_of!((*ptr).p_start) as usize - ptr as usize },
4175 8usize,
4176 concat!(
4177 "Offset of field: ",
4178 stringify!(extpartition),
4179 "::",
4180 stringify!(p_start)
4181 )
4182 );
4183 assert_eq!(
4184 unsafe { ::std::ptr::addr_of!((*ptr).p_size) as usize - ptr as usize },
4185 16usize,
4186 concat!(
4187 "Offset of field: ",
4188 stringify!(extpartition),
4189 "::",
4190 stringify!(p_size)
4191 )
4192 );
4193}
4194#[repr(C)]
4195#[derive(Debug, Copy, Clone)]
4196pub struct extvtoc {
4197 pub v_bootinfo: [u64; 3usize],
4198 pub v_sanity: u64,
4199 pub v_version: u64,
4200 pub v_volume: [::std::os::raw::c_char; 8usize],
4201 pub v_sectorsz: ushort_t,
4202 pub v_nparts: ushort_t,
4203 pub pad: [ushort_t; 2usize],
4204 pub v_reserved: [u64; 10usize],
4205 pub v_part: [extpartition; 16usize],
4206 pub timestamp: [u64; 16usize],
4207 pub v_asciilabel: [::std::os::raw::c_char; 128usize],
4208}
4209#[test]
4210fn bindgen_test_layout_extvtoc() {
4211 const UNINIT: ::std::mem::MaybeUninit<extvtoc> = ::std::mem::MaybeUninit::uninit();
4212 let ptr = UNINIT.as_ptr();
4213 assert_eq!(
4214 ::std::mem::size_of::<extvtoc>(),
4215 776usize,
4216 concat!("Size of: ", stringify!(extvtoc))
4217 );
4218 assert_eq!(
4219 ::std::mem::align_of::<extvtoc>(),
4220 8usize,
4221 concat!("Alignment of ", stringify!(extvtoc))
4222 );
4223 assert_eq!(
4224 unsafe { ::std::ptr::addr_of!((*ptr).v_bootinfo) as usize - ptr as usize },
4225 0usize,
4226 concat!(
4227 "Offset of field: ",
4228 stringify!(extvtoc),
4229 "::",
4230 stringify!(v_bootinfo)
4231 )
4232 );
4233 assert_eq!(
4234 unsafe { ::std::ptr::addr_of!((*ptr).v_sanity) as usize - ptr as usize },
4235 24usize,
4236 concat!(
4237 "Offset of field: ",
4238 stringify!(extvtoc),
4239 "::",
4240 stringify!(v_sanity)
4241 )
4242 );
4243 assert_eq!(
4244 unsafe { ::std::ptr::addr_of!((*ptr).v_version) as usize - ptr as usize },
4245 32usize,
4246 concat!(
4247 "Offset of field: ",
4248 stringify!(extvtoc),
4249 "::",
4250 stringify!(v_version)
4251 )
4252 );
4253 assert_eq!(
4254 unsafe { ::std::ptr::addr_of!((*ptr).v_volume) as usize - ptr as usize },
4255 40usize,
4256 concat!(
4257 "Offset of field: ",
4258 stringify!(extvtoc),
4259 "::",
4260 stringify!(v_volume)
4261 )
4262 );
4263 assert_eq!(
4264 unsafe { ::std::ptr::addr_of!((*ptr).v_sectorsz) as usize - ptr as usize },
4265 48usize,
4266 concat!(
4267 "Offset of field: ",
4268 stringify!(extvtoc),
4269 "::",
4270 stringify!(v_sectorsz)
4271 )
4272 );
4273 assert_eq!(
4274 unsafe { ::std::ptr::addr_of!((*ptr).v_nparts) as usize - ptr as usize },
4275 50usize,
4276 concat!(
4277 "Offset of field: ",
4278 stringify!(extvtoc),
4279 "::",
4280 stringify!(v_nparts)
4281 )
4282 );
4283 assert_eq!(
4284 unsafe { ::std::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
4285 52usize,
4286 concat!(
4287 "Offset of field: ",
4288 stringify!(extvtoc),
4289 "::",
4290 stringify!(pad)
4291 )
4292 );
4293 assert_eq!(
4294 unsafe { ::std::ptr::addr_of!((*ptr).v_reserved) as usize - ptr as usize },
4295 56usize,
4296 concat!(
4297 "Offset of field: ",
4298 stringify!(extvtoc),
4299 "::",
4300 stringify!(v_reserved)
4301 )
4302 );
4303 assert_eq!(
4304 unsafe { ::std::ptr::addr_of!((*ptr).v_part) as usize - ptr as usize },
4305 136usize,
4306 concat!(
4307 "Offset of field: ",
4308 stringify!(extvtoc),
4309 "::",
4310 stringify!(v_part)
4311 )
4312 );
4313 assert_eq!(
4314 unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
4315 520usize,
4316 concat!(
4317 "Offset of field: ",
4318 stringify!(extvtoc),
4319 "::",
4320 stringify!(timestamp)
4321 )
4322 );
4323 assert_eq!(
4324 unsafe { ::std::ptr::addr_of!((*ptr).v_asciilabel) as usize - ptr as usize },
4325 648usize,
4326 concat!(
4327 "Offset of field: ",
4328 stringify!(extvtoc),
4329 "::",
4330 stringify!(v_asciilabel)
4331 )
4332 );
4333}
4334extern "C" {
4335 pub fn read_vtoc(arg1: ::std::os::raw::c_int, arg2: *mut vtoc) -> ::std::os::raw::c_int;
4336}
4337extern "C" {
4338 pub fn write_vtoc(arg1: ::std::os::raw::c_int, arg2: *mut vtoc) -> ::std::os::raw::c_int;
4339}
4340extern "C" {
4341 pub fn read_extvtoc(arg1: ::std::os::raw::c_int, arg2: *mut extvtoc) -> ::std::os::raw::c_int;
4342}
4343extern "C" {
4344 pub fn write_extvtoc(arg1: ::std::os::raw::c_int, arg2: *mut extvtoc) -> ::std::os::raw::c_int;
4345}