1#[repr(C)]
4#[derive(Default)]
5pub struct __IncompleteArrayField<T>(::core::marker::PhantomData<T>, [T; 0]);
6impl<T> __IncompleteArrayField<T> {
7 #[inline]
8 pub const fn new() -> Self {
9 __IncompleteArrayField(::core::marker::PhantomData, [])
10 }
11 #[inline]
12 pub fn as_ptr(&self) -> *const T {
13 self as *const _ as *const T
14 }
15 #[inline]
16 pub fn as_mut_ptr(&mut self) -> *mut T {
17 self as *mut _ as *mut T
18 }
19 #[inline]
20 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
21 ::core::slice::from_raw_parts(self.as_ptr(), len)
22 }
23 #[inline]
24 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
25 ::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
26 }
27}
28impl<T> ::core::fmt::Debug for __IncompleteArrayField<T> {
29 fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
30 fmt.write_str("__IncompleteArrayField")
31 }
32}
33#[repr(C)]
34pub struct __BindgenUnionField<T>(::core::marker::PhantomData<T>);
35impl<T> __BindgenUnionField<T> {
36 #[inline]
37 pub const fn new() -> Self {
38 __BindgenUnionField(::core::marker::PhantomData)
39 }
40 #[inline]
41 pub unsafe fn as_ref(&self) -> &T {
42 ::core::mem::transmute(self)
43 }
44 #[inline]
45 pub unsafe fn as_mut(&mut self) -> &mut T {
46 ::core::mem::transmute(self)
47 }
48}
49impl<T> ::core::default::Default for __BindgenUnionField<T> {
50 #[inline]
51 fn default() -> Self {
52 Self::new()
53 }
54}
55impl<T> ::core::clone::Clone for __BindgenUnionField<T> {
56 #[inline]
57 fn clone(&self) -> Self {
58 *self
59 }
60}
61impl<T> ::core::marker::Copy for __BindgenUnionField<T> {}
62impl<T> ::core::fmt::Debug for __BindgenUnionField<T> {
63 fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
64 fmt.write_str("__BindgenUnionField")
65 }
66}
67impl<T> ::core::hash::Hash for __BindgenUnionField<T> {
68 fn hash<H: ::core::hash::Hasher>(&self, _state: &mut H) {}
69}
70impl<T> ::core::cmp::PartialEq for __BindgenUnionField<T> {
71 fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
72 true
73 }
74}
75impl<T> ::core::cmp::Eq for __BindgenUnionField<T> {}
76pub const __NR_io_uring_setup: u32 = 425;
77pub const __NR_io_uring_enter: u32 = 426;
78pub const __NR_io_uring_register: u32 = 427;
79pub const IORING_RW_ATTR_FLAG_PI: u32 = 1;
80pub const IORING_FILE_INDEX_ALLOC: i32 = -1;
81pub const IORING_SETUP_IOPOLL: u32 = 1;
82pub const IORING_SETUP_SQPOLL: u32 = 2;
83pub const IORING_SETUP_SQ_AFF: u32 = 4;
84pub const IORING_SETUP_CQSIZE: u32 = 8;
85pub const IORING_SETUP_CLAMP: u32 = 16;
86pub const IORING_SETUP_ATTACH_WQ: u32 = 32;
87pub const IORING_SETUP_R_DISABLED: u32 = 64;
88pub const IORING_SETUP_SUBMIT_ALL: u32 = 128;
89pub const IORING_SETUP_COOP_TASKRUN: u32 = 256;
90pub const IORING_SETUP_TASKRUN_FLAG: u32 = 512;
91pub const IORING_SETUP_SQE128: u32 = 1024;
92pub const IORING_SETUP_CQE32: u32 = 2048;
93pub const IORING_SETUP_SINGLE_ISSUER: u32 = 4096;
94pub const IORING_SETUP_DEFER_TASKRUN: u32 = 8192;
95pub const IORING_SETUP_NO_MMAP: u32 = 16384;
96pub const IORING_SETUP_REGISTERED_FD_ONLY: u32 = 32768;
97pub const IORING_SETUP_NO_SQARRAY: u32 = 65536;
98pub const IORING_SETUP_HYBRID_IOPOLL: u32 = 131072;
99pub const IORING_URING_CMD_FIXED: u32 = 1;
100pub const IORING_URING_CMD_MASK: u32 = 1;
101pub const IORING_FSYNC_DATASYNC: u32 = 1;
102pub const IORING_TIMEOUT_ABS: u32 = 1;
103pub const IORING_TIMEOUT_UPDATE: u32 = 2;
104pub const IORING_TIMEOUT_BOOTTIME: u32 = 4;
105pub const IORING_TIMEOUT_REALTIME: u32 = 8;
106pub const IORING_LINK_TIMEOUT_UPDATE: u32 = 16;
107pub const IORING_TIMEOUT_ETIME_SUCCESS: u32 = 32;
108pub const IORING_TIMEOUT_MULTISHOT: u32 = 64;
109pub const IORING_TIMEOUT_CLOCK_MASK: u32 = 12;
110pub const IORING_TIMEOUT_UPDATE_MASK: u32 = 18;
111pub const SPLICE_F_FD_IN_FIXED: u32 = 2147483648;
112pub const IORING_POLL_ADD_MULTI: u32 = 1;
113pub const IORING_POLL_UPDATE_EVENTS: u32 = 2;
114pub const IORING_POLL_UPDATE_USER_DATA: u32 = 4;
115pub const IORING_POLL_ADD_LEVEL: u32 = 8;
116pub const IORING_ASYNC_CANCEL_ALL: u32 = 1;
117pub const IORING_ASYNC_CANCEL_FD: u32 = 2;
118pub const IORING_ASYNC_CANCEL_ANY: u32 = 4;
119pub const IORING_ASYNC_CANCEL_FD_FIXED: u32 = 8;
120pub const IORING_ASYNC_CANCEL_USERDATA: u32 = 16;
121pub const IORING_ASYNC_CANCEL_OP: u32 = 32;
122pub const IORING_RECVSEND_POLL_FIRST: u32 = 1;
123pub const IORING_RECV_MULTISHOT: u32 = 2;
124pub const IORING_RECVSEND_FIXED_BUF: u32 = 4;
125pub const IORING_SEND_ZC_REPORT_USAGE: u32 = 8;
126pub const IORING_RECVSEND_BUNDLE: u32 = 16;
127pub const IORING_NOTIF_USAGE_ZC_COPIED: u32 = 2147483648;
128pub const IORING_ACCEPT_MULTISHOT: u32 = 1;
129pub const IORING_ACCEPT_DONTWAIT: u32 = 2;
130pub const IORING_ACCEPT_POLL_FIRST: u32 = 4;
131pub const IORING_MSG_RING_CQE_SKIP: u32 = 1;
132pub const IORING_MSG_RING_FLAGS_PASS: u32 = 2;
133pub const IORING_FIXED_FD_NO_CLOEXEC: u32 = 1;
134pub const IORING_NOP_INJECT_RESULT: u32 = 1;
135pub const IORING_NOP_FILE: u32 = 2;
136pub const IORING_NOP_FIXED_FILE: u32 = 4;
137pub const IORING_NOP_FIXED_BUFFER: u32 = 8;
138pub const IORING_CQE_F_BUFFER: u32 = 1;
139pub const IORING_CQE_F_MORE: u32 = 2;
140pub const IORING_CQE_F_SOCK_NONEMPTY: u32 = 4;
141pub const IORING_CQE_F_NOTIF: u32 = 8;
142pub const IORING_CQE_F_BUF_MORE: u32 = 16;
143pub const IORING_CQE_BUFFER_SHIFT: u32 = 16;
144pub const IORING_OFF_SQ_RING: u32 = 0;
145pub const IORING_OFF_CQ_RING: u32 = 134217728;
146pub const IORING_OFF_SQES: u32 = 268435456;
147pub const IORING_OFF_PBUF_RING: u32 = 2147483648;
148pub const IORING_OFF_PBUF_SHIFT: u32 = 16;
149pub const IORING_OFF_MMAP_MASK: u32 = 4160749568;
150pub const IORING_SQ_NEED_WAKEUP: u32 = 1;
151pub const IORING_SQ_CQ_OVERFLOW: u32 = 2;
152pub const IORING_SQ_TASKRUN: u32 = 4;
153pub const IORING_CQ_EVENTFD_DISABLED: u32 = 1;
154pub const IORING_ENTER_GETEVENTS: u32 = 1;
155pub const IORING_ENTER_SQ_WAKEUP: u32 = 2;
156pub const IORING_ENTER_SQ_WAIT: u32 = 4;
157pub const IORING_ENTER_EXT_ARG: u32 = 8;
158pub const IORING_ENTER_REGISTERED_RING: u32 = 16;
159pub const IORING_ENTER_ABS_TIMER: u32 = 32;
160pub const IORING_ENTER_EXT_ARG_REG: u32 = 64;
161pub const IORING_ENTER_NO_IOWAIT: u32 = 128;
162pub const IORING_FEAT_SINGLE_MMAP: u32 = 1;
163pub const IORING_FEAT_NODROP: u32 = 2;
164pub const IORING_FEAT_SUBMIT_STABLE: u32 = 4;
165pub const IORING_FEAT_RW_CUR_POS: u32 = 8;
166pub const IORING_FEAT_CUR_PERSONALITY: u32 = 16;
167pub const IORING_FEAT_FAST_POLL: u32 = 32;
168pub const IORING_FEAT_POLL_32BITS: u32 = 64;
169pub const IORING_FEAT_SQPOLL_NONFIXED: u32 = 128;
170pub const IORING_FEAT_EXT_ARG: u32 = 256;
171pub const IORING_FEAT_NATIVE_WORKERS: u32 = 512;
172pub const IORING_FEAT_RSRC_TAGS: u32 = 1024;
173pub const IORING_FEAT_CQE_SKIP: u32 = 2048;
174pub const IORING_FEAT_LINKED_FILE: u32 = 4096;
175pub const IORING_FEAT_REG_REG_RING: u32 = 8192;
176pub const IORING_FEAT_RECVSEND_BUNDLE: u32 = 16384;
177pub const IORING_FEAT_MIN_TIMEOUT: u32 = 32768;
178pub const IORING_FEAT_RW_ATTR: u32 = 65536;
179pub const IORING_FEAT_NO_IOWAIT: u32 = 131072;
180pub const IORING_RSRC_REGISTER_SPARSE: u32 = 1;
181pub const IORING_REGISTER_FILES_SKIP: i32 = -2;
182pub const IO_URING_OP_SUPPORTED: u32 = 1;
183pub const IORING_ZCRX_AREA_SHIFT: u32 = 48;
184pub type __u8 = libc::c_uchar;
185pub type __u16 = libc::c_ushort;
186pub type __s32 = libc::c_int;
187pub type __u32 = libc::c_uint;
188pub type __u64 = libc::c_ulonglong;
189pub type __kernel_time64_t = libc::c_longlong;
190#[repr(C)]
191#[derive(Debug, Default, Copy, Clone)]
192pub struct __kernel_timespec {
193 pub tv_sec: __kernel_time64_t,
194 pub tv_nsec: libc::c_longlong,
195}
196#[test]
197fn bindgen_test_layout___kernel_timespec() {
198 const UNINIT: ::core::mem::MaybeUninit<__kernel_timespec> = ::core::mem::MaybeUninit::uninit();
199 let ptr = UNINIT.as_ptr();
200 assert_eq!(
201 ::core::mem::size_of::<__kernel_timespec>(),
202 16usize,
203 concat!("Size of: ", stringify!(__kernel_timespec))
204 );
205 assert_eq!(
206 ::core::mem::align_of::<__kernel_timespec>(),
207 8usize,
208 concat!("Alignment of ", stringify!(__kernel_timespec))
209 );
210 assert_eq!(
211 unsafe { ::core::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
212 0usize,
213 concat!(
214 "Offset of field: ",
215 stringify!(__kernel_timespec),
216 "::",
217 stringify!(tv_sec)
218 )
219 );
220 assert_eq!(
221 unsafe { ::core::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
222 8usize,
223 concat!(
224 "Offset of field: ",
225 stringify!(__kernel_timespec),
226 "::",
227 stringify!(tv_nsec)
228 )
229 );
230}
231#[repr(C)]
232#[derive(Debug, Default, Copy, Clone)]
233pub struct open_how {
234 pub flags: __u64,
235 pub mode: __u64,
236 pub resolve: __u64,
237}
238#[test]
239fn bindgen_test_layout_open_how() {
240 const UNINIT: ::core::mem::MaybeUninit<open_how> = ::core::mem::MaybeUninit::uninit();
241 let ptr = UNINIT.as_ptr();
242 assert_eq!(
243 ::core::mem::size_of::<open_how>(),
244 24usize,
245 concat!("Size of: ", stringify!(open_how))
246 );
247 assert_eq!(
248 ::core::mem::align_of::<open_how>(),
249 8usize,
250 concat!("Alignment of ", stringify!(open_how))
251 );
252 assert_eq!(
253 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
254 0usize,
255 concat!(
256 "Offset of field: ",
257 stringify!(open_how),
258 "::",
259 stringify!(flags)
260 )
261 );
262 assert_eq!(
263 unsafe { ::core::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
264 8usize,
265 concat!(
266 "Offset of field: ",
267 stringify!(open_how),
268 "::",
269 stringify!(mode)
270 )
271 );
272 assert_eq!(
273 unsafe { ::core::ptr::addr_of!((*ptr).resolve) as usize - ptr as usize },
274 16usize,
275 concat!(
276 "Offset of field: ",
277 stringify!(open_how),
278 "::",
279 stringify!(resolve)
280 )
281 );
282}
283#[repr(C)]
284pub struct io_uring_sqe {
285 pub opcode: __u8,
286 pub flags: __u8,
287 pub ioprio: __u16,
288 pub fd: __s32,
289 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1,
290 pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_2,
291 pub len: __u32,
292 pub __bindgen_anon_3: io_uring_sqe__bindgen_ty_3,
293 pub user_data: __u64,
294 pub __bindgen_anon_4: io_uring_sqe__bindgen_ty_4,
295 pub personality: __u16,
296 pub __bindgen_anon_5: io_uring_sqe__bindgen_ty_5,
297 pub __bindgen_anon_6: io_uring_sqe__bindgen_ty_6,
298}
299#[repr(C)]
300#[derive(Copy, Clone)]
301pub union io_uring_sqe__bindgen_ty_1 {
302 pub off: __u64,
303 pub addr2: __u64,
304 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1__bindgen_ty_1,
305}
306#[repr(C)]
307#[derive(Debug, Default, Copy, Clone)]
308pub struct io_uring_sqe__bindgen_ty_1__bindgen_ty_1 {
309 pub cmd_op: __u32,
310 pub __pad1: __u32,
311}
312#[test]
313fn bindgen_test_layout_io_uring_sqe__bindgen_ty_1__bindgen_ty_1() {
314 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_1__bindgen_ty_1> =
315 ::core::mem::MaybeUninit::uninit();
316 let ptr = UNINIT.as_ptr();
317 assert_eq!(
318 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_1__bindgen_ty_1>(),
319 8usize,
320 concat!(
321 "Size of: ",
322 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1)
323 )
324 );
325 assert_eq!(
326 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_1__bindgen_ty_1>(),
327 4usize,
328 concat!(
329 "Alignment of ",
330 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1)
331 )
332 );
333 assert_eq!(
334 unsafe { ::core::ptr::addr_of!((*ptr).cmd_op) as usize - ptr as usize },
335 0usize,
336 concat!(
337 "Offset of field: ",
338 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1),
339 "::",
340 stringify!(cmd_op)
341 )
342 );
343 assert_eq!(
344 unsafe { ::core::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
345 4usize,
346 concat!(
347 "Offset of field: ",
348 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1),
349 "::",
350 stringify!(__pad1)
351 )
352 );
353}
354#[test]
355fn bindgen_test_layout_io_uring_sqe__bindgen_ty_1() {
356 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_1> =
357 ::core::mem::MaybeUninit::uninit();
358 let ptr = UNINIT.as_ptr();
359 assert_eq!(
360 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_1>(),
361 8usize,
362 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_1))
363 );
364 assert_eq!(
365 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_1>(),
366 8usize,
367 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_1))
368 );
369 assert_eq!(
370 unsafe { ::core::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
371 0usize,
372 concat!(
373 "Offset of field: ",
374 stringify!(io_uring_sqe__bindgen_ty_1),
375 "::",
376 stringify!(off)
377 )
378 );
379 assert_eq!(
380 unsafe { ::core::ptr::addr_of!((*ptr).addr2) as usize - ptr as usize },
381 0usize,
382 concat!(
383 "Offset of field: ",
384 stringify!(io_uring_sqe__bindgen_ty_1),
385 "::",
386 stringify!(addr2)
387 )
388 );
389}
390impl Default for io_uring_sqe__bindgen_ty_1 {
391 fn default() -> Self {
392 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
393 unsafe {
394 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
395 s.assume_init()
396 }
397 }
398}
399#[repr(C)]
400#[derive(Copy, Clone)]
401pub union io_uring_sqe__bindgen_ty_2 {
402 pub addr: __u64,
403 pub splice_off_in: __u64,
404 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_2__bindgen_ty_1,
405}
406#[repr(C)]
407#[derive(Debug, Default, Copy, Clone)]
408pub struct io_uring_sqe__bindgen_ty_2__bindgen_ty_1 {
409 pub level: __u32,
410 pub optname: __u32,
411}
412#[test]
413fn bindgen_test_layout_io_uring_sqe__bindgen_ty_2__bindgen_ty_1() {
414 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_2__bindgen_ty_1> =
415 ::core::mem::MaybeUninit::uninit();
416 let ptr = UNINIT.as_ptr();
417 assert_eq!(
418 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_2__bindgen_ty_1>(),
419 8usize,
420 concat!(
421 "Size of: ",
422 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1)
423 )
424 );
425 assert_eq!(
426 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_2__bindgen_ty_1>(),
427 4usize,
428 concat!(
429 "Alignment of ",
430 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1)
431 )
432 );
433 assert_eq!(
434 unsafe { ::core::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
435 0usize,
436 concat!(
437 "Offset of field: ",
438 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1),
439 "::",
440 stringify!(level)
441 )
442 );
443 assert_eq!(
444 unsafe { ::core::ptr::addr_of!((*ptr).optname) as usize - ptr as usize },
445 4usize,
446 concat!(
447 "Offset of field: ",
448 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1),
449 "::",
450 stringify!(optname)
451 )
452 );
453}
454#[test]
455fn bindgen_test_layout_io_uring_sqe__bindgen_ty_2() {
456 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_2> =
457 ::core::mem::MaybeUninit::uninit();
458 let ptr = UNINIT.as_ptr();
459 assert_eq!(
460 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_2>(),
461 8usize,
462 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_2))
463 );
464 assert_eq!(
465 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_2>(),
466 8usize,
467 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_2))
468 );
469 assert_eq!(
470 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
471 0usize,
472 concat!(
473 "Offset of field: ",
474 stringify!(io_uring_sqe__bindgen_ty_2),
475 "::",
476 stringify!(addr)
477 )
478 );
479 assert_eq!(
480 unsafe { ::core::ptr::addr_of!((*ptr).splice_off_in) as usize - ptr as usize },
481 0usize,
482 concat!(
483 "Offset of field: ",
484 stringify!(io_uring_sqe__bindgen_ty_2),
485 "::",
486 stringify!(splice_off_in)
487 )
488 );
489}
490impl Default for io_uring_sqe__bindgen_ty_2 {
491 fn default() -> Self {
492 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
493 unsafe {
494 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
495 s.assume_init()
496 }
497 }
498}
499#[repr(C)]
500#[derive(Copy, Clone)]
501pub union io_uring_sqe__bindgen_ty_3 {
502 pub rw_flags: __u32,
503 pub fsync_flags: __u32,
504 pub poll_events: __u16,
505 pub poll32_events: __u32,
506 pub sync_range_flags: __u32,
507 pub msg_flags: __u32,
508 pub timeout_flags: __u32,
509 pub accept_flags: __u32,
510 pub cancel_flags: __u32,
511 pub open_flags: __u32,
512 pub statx_flags: __u32,
513 pub fadvise_advice: __u32,
514 pub splice_flags: __u32,
515 pub rename_flags: __u32,
516 pub unlink_flags: __u32,
517 pub hardlink_flags: __u32,
518 pub xattr_flags: __u32,
519 pub msg_ring_flags: __u32,
520 pub uring_cmd_flags: __u32,
521 pub waitid_flags: __u32,
522 pub futex_flags: __u32,
523 pub install_fd_flags: __u32,
524 pub nop_flags: __u32,
525 pub pipe_flags: __u32,
526}
527#[test]
528fn bindgen_test_layout_io_uring_sqe__bindgen_ty_3() {
529 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_3> =
530 ::core::mem::MaybeUninit::uninit();
531 let ptr = UNINIT.as_ptr();
532 assert_eq!(
533 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_3>(),
534 4usize,
535 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_3))
536 );
537 assert_eq!(
538 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_3>(),
539 4usize,
540 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_3))
541 );
542 assert_eq!(
543 unsafe { ::core::ptr::addr_of!((*ptr).rw_flags) as usize - ptr as usize },
544 0usize,
545 concat!(
546 "Offset of field: ",
547 stringify!(io_uring_sqe__bindgen_ty_3),
548 "::",
549 stringify!(rw_flags)
550 )
551 );
552 assert_eq!(
553 unsafe { ::core::ptr::addr_of!((*ptr).fsync_flags) as usize - ptr as usize },
554 0usize,
555 concat!(
556 "Offset of field: ",
557 stringify!(io_uring_sqe__bindgen_ty_3),
558 "::",
559 stringify!(fsync_flags)
560 )
561 );
562 assert_eq!(
563 unsafe { ::core::ptr::addr_of!((*ptr).poll_events) as usize - ptr as usize },
564 0usize,
565 concat!(
566 "Offset of field: ",
567 stringify!(io_uring_sqe__bindgen_ty_3),
568 "::",
569 stringify!(poll_events)
570 )
571 );
572 assert_eq!(
573 unsafe { ::core::ptr::addr_of!((*ptr).poll32_events) as usize - ptr as usize },
574 0usize,
575 concat!(
576 "Offset of field: ",
577 stringify!(io_uring_sqe__bindgen_ty_3),
578 "::",
579 stringify!(poll32_events)
580 )
581 );
582 assert_eq!(
583 unsafe { ::core::ptr::addr_of!((*ptr).sync_range_flags) as usize - ptr as usize },
584 0usize,
585 concat!(
586 "Offset of field: ",
587 stringify!(io_uring_sqe__bindgen_ty_3),
588 "::",
589 stringify!(sync_range_flags)
590 )
591 );
592 assert_eq!(
593 unsafe { ::core::ptr::addr_of!((*ptr).msg_flags) as usize - ptr as usize },
594 0usize,
595 concat!(
596 "Offset of field: ",
597 stringify!(io_uring_sqe__bindgen_ty_3),
598 "::",
599 stringify!(msg_flags)
600 )
601 );
602 assert_eq!(
603 unsafe { ::core::ptr::addr_of!((*ptr).timeout_flags) as usize - ptr as usize },
604 0usize,
605 concat!(
606 "Offset of field: ",
607 stringify!(io_uring_sqe__bindgen_ty_3),
608 "::",
609 stringify!(timeout_flags)
610 )
611 );
612 assert_eq!(
613 unsafe { ::core::ptr::addr_of!((*ptr).accept_flags) as usize - ptr as usize },
614 0usize,
615 concat!(
616 "Offset of field: ",
617 stringify!(io_uring_sqe__bindgen_ty_3),
618 "::",
619 stringify!(accept_flags)
620 )
621 );
622 assert_eq!(
623 unsafe { ::core::ptr::addr_of!((*ptr).cancel_flags) as usize - ptr as usize },
624 0usize,
625 concat!(
626 "Offset of field: ",
627 stringify!(io_uring_sqe__bindgen_ty_3),
628 "::",
629 stringify!(cancel_flags)
630 )
631 );
632 assert_eq!(
633 unsafe { ::core::ptr::addr_of!((*ptr).open_flags) as usize - ptr as usize },
634 0usize,
635 concat!(
636 "Offset of field: ",
637 stringify!(io_uring_sqe__bindgen_ty_3),
638 "::",
639 stringify!(open_flags)
640 )
641 );
642 assert_eq!(
643 unsafe { ::core::ptr::addr_of!((*ptr).statx_flags) as usize - ptr as usize },
644 0usize,
645 concat!(
646 "Offset of field: ",
647 stringify!(io_uring_sqe__bindgen_ty_3),
648 "::",
649 stringify!(statx_flags)
650 )
651 );
652 assert_eq!(
653 unsafe { ::core::ptr::addr_of!((*ptr).fadvise_advice) as usize - ptr as usize },
654 0usize,
655 concat!(
656 "Offset of field: ",
657 stringify!(io_uring_sqe__bindgen_ty_3),
658 "::",
659 stringify!(fadvise_advice)
660 )
661 );
662 assert_eq!(
663 unsafe { ::core::ptr::addr_of!((*ptr).splice_flags) as usize - ptr as usize },
664 0usize,
665 concat!(
666 "Offset of field: ",
667 stringify!(io_uring_sqe__bindgen_ty_3),
668 "::",
669 stringify!(splice_flags)
670 )
671 );
672 assert_eq!(
673 unsafe { ::core::ptr::addr_of!((*ptr).rename_flags) as usize - ptr as usize },
674 0usize,
675 concat!(
676 "Offset of field: ",
677 stringify!(io_uring_sqe__bindgen_ty_3),
678 "::",
679 stringify!(rename_flags)
680 )
681 );
682 assert_eq!(
683 unsafe { ::core::ptr::addr_of!((*ptr).unlink_flags) as usize - ptr as usize },
684 0usize,
685 concat!(
686 "Offset of field: ",
687 stringify!(io_uring_sqe__bindgen_ty_3),
688 "::",
689 stringify!(unlink_flags)
690 )
691 );
692 assert_eq!(
693 unsafe { ::core::ptr::addr_of!((*ptr).hardlink_flags) as usize - ptr as usize },
694 0usize,
695 concat!(
696 "Offset of field: ",
697 stringify!(io_uring_sqe__bindgen_ty_3),
698 "::",
699 stringify!(hardlink_flags)
700 )
701 );
702 assert_eq!(
703 unsafe { ::core::ptr::addr_of!((*ptr).xattr_flags) as usize - ptr as usize },
704 0usize,
705 concat!(
706 "Offset of field: ",
707 stringify!(io_uring_sqe__bindgen_ty_3),
708 "::",
709 stringify!(xattr_flags)
710 )
711 );
712 assert_eq!(
713 unsafe { ::core::ptr::addr_of!((*ptr).msg_ring_flags) as usize - ptr as usize },
714 0usize,
715 concat!(
716 "Offset of field: ",
717 stringify!(io_uring_sqe__bindgen_ty_3),
718 "::",
719 stringify!(msg_ring_flags)
720 )
721 );
722 assert_eq!(
723 unsafe { ::core::ptr::addr_of!((*ptr).uring_cmd_flags) as usize - ptr as usize },
724 0usize,
725 concat!(
726 "Offset of field: ",
727 stringify!(io_uring_sqe__bindgen_ty_3),
728 "::",
729 stringify!(uring_cmd_flags)
730 )
731 );
732 assert_eq!(
733 unsafe { ::core::ptr::addr_of!((*ptr).waitid_flags) as usize - ptr as usize },
734 0usize,
735 concat!(
736 "Offset of field: ",
737 stringify!(io_uring_sqe__bindgen_ty_3),
738 "::",
739 stringify!(waitid_flags)
740 )
741 );
742 assert_eq!(
743 unsafe { ::core::ptr::addr_of!((*ptr).futex_flags) as usize - ptr as usize },
744 0usize,
745 concat!(
746 "Offset of field: ",
747 stringify!(io_uring_sqe__bindgen_ty_3),
748 "::",
749 stringify!(futex_flags)
750 )
751 );
752 assert_eq!(
753 unsafe { ::core::ptr::addr_of!((*ptr).install_fd_flags) as usize - ptr as usize },
754 0usize,
755 concat!(
756 "Offset of field: ",
757 stringify!(io_uring_sqe__bindgen_ty_3),
758 "::",
759 stringify!(install_fd_flags)
760 )
761 );
762 assert_eq!(
763 unsafe { ::core::ptr::addr_of!((*ptr).nop_flags) as usize - ptr as usize },
764 0usize,
765 concat!(
766 "Offset of field: ",
767 stringify!(io_uring_sqe__bindgen_ty_3),
768 "::",
769 stringify!(nop_flags)
770 )
771 );
772 assert_eq!(
773 unsafe { ::core::ptr::addr_of!((*ptr).pipe_flags) as usize - ptr as usize },
774 0usize,
775 concat!(
776 "Offset of field: ",
777 stringify!(io_uring_sqe__bindgen_ty_3),
778 "::",
779 stringify!(pipe_flags)
780 )
781 );
782}
783impl Default for io_uring_sqe__bindgen_ty_3 {
784 fn default() -> Self {
785 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
786 unsafe {
787 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
788 s.assume_init()
789 }
790 }
791}
792#[repr(C, packed)]
793#[derive(Copy, Clone)]
794pub union io_uring_sqe__bindgen_ty_4 {
795 pub buf_index: __u16,
796 pub buf_group: __u16,
797}
798#[test]
799fn bindgen_test_layout_io_uring_sqe__bindgen_ty_4() {
800 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_4> =
801 ::core::mem::MaybeUninit::uninit();
802 let ptr = UNINIT.as_ptr();
803 assert_eq!(
804 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_4>(),
805 2usize,
806 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_4))
807 );
808 assert_eq!(
809 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_4>(),
810 1usize,
811 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_4))
812 );
813 assert_eq!(
814 unsafe { ::core::ptr::addr_of!((*ptr).buf_index) as usize - ptr as usize },
815 0usize,
816 concat!(
817 "Offset of field: ",
818 stringify!(io_uring_sqe__bindgen_ty_4),
819 "::",
820 stringify!(buf_index)
821 )
822 );
823 assert_eq!(
824 unsafe { ::core::ptr::addr_of!((*ptr).buf_group) as usize - ptr as usize },
825 0usize,
826 concat!(
827 "Offset of field: ",
828 stringify!(io_uring_sqe__bindgen_ty_4),
829 "::",
830 stringify!(buf_group)
831 )
832 );
833}
834impl Default for io_uring_sqe__bindgen_ty_4 {
835 fn default() -> Self {
836 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
837 unsafe {
838 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
839 s.assume_init()
840 }
841 }
842}
843#[repr(C)]
844#[derive(Copy, Clone)]
845pub union io_uring_sqe__bindgen_ty_5 {
846 pub splice_fd_in: __s32,
847 pub file_index: __u32,
848 pub zcrx_ifq_idx: __u32,
849 pub optlen: __u32,
850 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_5__bindgen_ty_1,
851 pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_5__bindgen_ty_2,
852}
853#[repr(C)]
854#[derive(Debug, Default, Copy, Clone)]
855pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_1 {
856 pub addr_len: __u16,
857 pub __pad3: [__u16; 1usize],
858}
859#[test]
860fn bindgen_test_layout_io_uring_sqe__bindgen_ty_5__bindgen_ty_1() {
861 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_5__bindgen_ty_1> =
862 ::core::mem::MaybeUninit::uninit();
863 let ptr = UNINIT.as_ptr();
864 assert_eq!(
865 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_5__bindgen_ty_1>(),
866 4usize,
867 concat!(
868 "Size of: ",
869 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1)
870 )
871 );
872 assert_eq!(
873 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_5__bindgen_ty_1>(),
874 2usize,
875 concat!(
876 "Alignment of ",
877 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1)
878 )
879 );
880 assert_eq!(
881 unsafe { ::core::ptr::addr_of!((*ptr).addr_len) as usize - ptr as usize },
882 0usize,
883 concat!(
884 "Offset of field: ",
885 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1),
886 "::",
887 stringify!(addr_len)
888 )
889 );
890 assert_eq!(
891 unsafe { ::core::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
892 2usize,
893 concat!(
894 "Offset of field: ",
895 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1),
896 "::",
897 stringify!(__pad3)
898 )
899 );
900}
901#[repr(C)]
902#[derive(Debug, Default, Copy, Clone)]
903pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_2 {
904 pub write_stream: __u8,
905 pub __pad4: [__u8; 3usize],
906}
907#[test]
908fn bindgen_test_layout_io_uring_sqe__bindgen_ty_5__bindgen_ty_2() {
909 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_5__bindgen_ty_2> =
910 ::core::mem::MaybeUninit::uninit();
911 let ptr = UNINIT.as_ptr();
912 assert_eq!(
913 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_5__bindgen_ty_2>(),
914 4usize,
915 concat!(
916 "Size of: ",
917 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_2)
918 )
919 );
920 assert_eq!(
921 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_5__bindgen_ty_2>(),
922 1usize,
923 concat!(
924 "Alignment of ",
925 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_2)
926 )
927 );
928 assert_eq!(
929 unsafe { ::core::ptr::addr_of!((*ptr).write_stream) as usize - ptr as usize },
930 0usize,
931 concat!(
932 "Offset of field: ",
933 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_2),
934 "::",
935 stringify!(write_stream)
936 )
937 );
938 assert_eq!(
939 unsafe { ::core::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
940 1usize,
941 concat!(
942 "Offset of field: ",
943 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_2),
944 "::",
945 stringify!(__pad4)
946 )
947 );
948}
949#[test]
950fn bindgen_test_layout_io_uring_sqe__bindgen_ty_5() {
951 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_5> =
952 ::core::mem::MaybeUninit::uninit();
953 let ptr = UNINIT.as_ptr();
954 assert_eq!(
955 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_5>(),
956 4usize,
957 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_5))
958 );
959 assert_eq!(
960 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_5>(),
961 4usize,
962 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_5))
963 );
964 assert_eq!(
965 unsafe { ::core::ptr::addr_of!((*ptr).splice_fd_in) as usize - ptr as usize },
966 0usize,
967 concat!(
968 "Offset of field: ",
969 stringify!(io_uring_sqe__bindgen_ty_5),
970 "::",
971 stringify!(splice_fd_in)
972 )
973 );
974 assert_eq!(
975 unsafe { ::core::ptr::addr_of!((*ptr).file_index) as usize - ptr as usize },
976 0usize,
977 concat!(
978 "Offset of field: ",
979 stringify!(io_uring_sqe__bindgen_ty_5),
980 "::",
981 stringify!(file_index)
982 )
983 );
984 assert_eq!(
985 unsafe { ::core::ptr::addr_of!((*ptr).zcrx_ifq_idx) as usize - ptr as usize },
986 0usize,
987 concat!(
988 "Offset of field: ",
989 stringify!(io_uring_sqe__bindgen_ty_5),
990 "::",
991 stringify!(zcrx_ifq_idx)
992 )
993 );
994 assert_eq!(
995 unsafe { ::core::ptr::addr_of!((*ptr).optlen) as usize - ptr as usize },
996 0usize,
997 concat!(
998 "Offset of field: ",
999 stringify!(io_uring_sqe__bindgen_ty_5),
1000 "::",
1001 stringify!(optlen)
1002 )
1003 );
1004}
1005impl Default for io_uring_sqe__bindgen_ty_5 {
1006 fn default() -> Self {
1007 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1008 unsafe {
1009 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1010 s.assume_init()
1011 }
1012 }
1013}
1014#[repr(C)]
1015pub struct io_uring_sqe__bindgen_ty_6 {
1016 pub __bindgen_anon_1: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>,
1017 pub __bindgen_anon_2: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_2>,
1018 pub optval: __BindgenUnionField<__u64>,
1019 pub cmd: __BindgenUnionField<[__u8; 0usize]>,
1020 pub bindgen_union_field: [u64; 2usize],
1021}
1022#[repr(C)]
1023#[derive(Debug, Default, Copy, Clone)]
1024pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_1 {
1025 pub addr3: __u64,
1026 pub __pad2: [__u64; 1usize],
1027}
1028#[test]
1029fn bindgen_test_layout_io_uring_sqe__bindgen_ty_6__bindgen_ty_1() {
1030 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_6__bindgen_ty_1> =
1031 ::core::mem::MaybeUninit::uninit();
1032 let ptr = UNINIT.as_ptr();
1033 assert_eq!(
1034 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>(),
1035 16usize,
1036 concat!(
1037 "Size of: ",
1038 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1)
1039 )
1040 );
1041 assert_eq!(
1042 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>(),
1043 8usize,
1044 concat!(
1045 "Alignment of ",
1046 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1)
1047 )
1048 );
1049 assert_eq!(
1050 unsafe { ::core::ptr::addr_of!((*ptr).addr3) as usize - ptr as usize },
1051 0usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1),
1055 "::",
1056 stringify!(addr3)
1057 )
1058 );
1059 assert_eq!(
1060 unsafe { ::core::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
1061 8usize,
1062 concat!(
1063 "Offset of field: ",
1064 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1),
1065 "::",
1066 stringify!(__pad2)
1067 )
1068 );
1069}
1070#[repr(C)]
1071#[derive(Debug, Default, Copy, Clone)]
1072pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_2 {
1073 pub attr_ptr: __u64,
1074 pub attr_type_mask: __u64,
1075}
1076#[test]
1077fn bindgen_test_layout_io_uring_sqe__bindgen_ty_6__bindgen_ty_2() {
1078 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_6__bindgen_ty_2> =
1079 ::core::mem::MaybeUninit::uninit();
1080 let ptr = UNINIT.as_ptr();
1081 assert_eq!(
1082 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_6__bindgen_ty_2>(),
1083 16usize,
1084 concat!(
1085 "Size of: ",
1086 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_2)
1087 )
1088 );
1089 assert_eq!(
1090 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_6__bindgen_ty_2>(),
1091 8usize,
1092 concat!(
1093 "Alignment of ",
1094 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_2)
1095 )
1096 );
1097 assert_eq!(
1098 unsafe { ::core::ptr::addr_of!((*ptr).attr_ptr) as usize - ptr as usize },
1099 0usize,
1100 concat!(
1101 "Offset of field: ",
1102 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_2),
1103 "::",
1104 stringify!(attr_ptr)
1105 )
1106 );
1107 assert_eq!(
1108 unsafe { ::core::ptr::addr_of!((*ptr).attr_type_mask) as usize - ptr as usize },
1109 8usize,
1110 concat!(
1111 "Offset of field: ",
1112 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_2),
1113 "::",
1114 stringify!(attr_type_mask)
1115 )
1116 );
1117}
1118#[test]
1119fn bindgen_test_layout_io_uring_sqe__bindgen_ty_6() {
1120 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_6> =
1121 ::core::mem::MaybeUninit::uninit();
1122 let ptr = UNINIT.as_ptr();
1123 assert_eq!(
1124 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_6>(),
1125 16usize,
1126 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_6))
1127 );
1128 assert_eq!(
1129 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_6>(),
1130 8usize,
1131 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_6))
1132 );
1133 assert_eq!(
1134 unsafe { ::core::ptr::addr_of!((*ptr).optval) as usize - ptr as usize },
1135 0usize,
1136 concat!(
1137 "Offset of field: ",
1138 stringify!(io_uring_sqe__bindgen_ty_6),
1139 "::",
1140 stringify!(optval)
1141 )
1142 );
1143 assert_eq!(
1144 unsafe { ::core::ptr::addr_of!((*ptr).cmd) as usize - ptr as usize },
1145 0usize,
1146 concat!(
1147 "Offset of field: ",
1148 stringify!(io_uring_sqe__bindgen_ty_6),
1149 "::",
1150 stringify!(cmd)
1151 )
1152 );
1153}
1154impl Default for io_uring_sqe__bindgen_ty_6 {
1155 fn default() -> Self {
1156 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1157 unsafe {
1158 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1159 s.assume_init()
1160 }
1161 }
1162}
1163#[test]
1164fn bindgen_test_layout_io_uring_sqe() {
1165 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe> = ::core::mem::MaybeUninit::uninit();
1166 let ptr = UNINIT.as_ptr();
1167 assert_eq!(
1168 ::core::mem::size_of::<io_uring_sqe>(),
1169 64usize,
1170 concat!("Size of: ", stringify!(io_uring_sqe))
1171 );
1172 assert_eq!(
1173 ::core::mem::align_of::<io_uring_sqe>(),
1174 8usize,
1175 concat!("Alignment of ", stringify!(io_uring_sqe))
1176 );
1177 assert_eq!(
1178 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
1179 0usize,
1180 concat!(
1181 "Offset of field: ",
1182 stringify!(io_uring_sqe),
1183 "::",
1184 stringify!(opcode)
1185 )
1186 );
1187 assert_eq!(
1188 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1189 1usize,
1190 concat!(
1191 "Offset of field: ",
1192 stringify!(io_uring_sqe),
1193 "::",
1194 stringify!(flags)
1195 )
1196 );
1197 assert_eq!(
1198 unsafe { ::core::ptr::addr_of!((*ptr).ioprio) as usize - ptr as usize },
1199 2usize,
1200 concat!(
1201 "Offset of field: ",
1202 stringify!(io_uring_sqe),
1203 "::",
1204 stringify!(ioprio)
1205 )
1206 );
1207 assert_eq!(
1208 unsafe { ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
1209 4usize,
1210 concat!(
1211 "Offset of field: ",
1212 stringify!(io_uring_sqe),
1213 "::",
1214 stringify!(fd)
1215 )
1216 );
1217 assert_eq!(
1218 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
1219 24usize,
1220 concat!(
1221 "Offset of field: ",
1222 stringify!(io_uring_sqe),
1223 "::",
1224 stringify!(len)
1225 )
1226 );
1227 assert_eq!(
1228 unsafe { ::core::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
1229 32usize,
1230 concat!(
1231 "Offset of field: ",
1232 stringify!(io_uring_sqe),
1233 "::",
1234 stringify!(user_data)
1235 )
1236 );
1237 assert_eq!(
1238 unsafe { ::core::ptr::addr_of!((*ptr).personality) as usize - ptr as usize },
1239 42usize,
1240 concat!(
1241 "Offset of field: ",
1242 stringify!(io_uring_sqe),
1243 "::",
1244 stringify!(personality)
1245 )
1246 );
1247}
1248impl Default for io_uring_sqe {
1249 fn default() -> Self {
1250 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1251 unsafe {
1252 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1253 s.assume_init()
1254 }
1255 }
1256}
1257#[repr(C)]
1258#[derive(Debug, Default, Copy, Clone)]
1259pub struct io_uring_attr_pi {
1260 pub flags: __u16,
1261 pub app_tag: __u16,
1262 pub len: __u32,
1263 pub addr: __u64,
1264 pub seed: __u64,
1265 pub rsvd: __u64,
1266}
1267#[test]
1268fn bindgen_test_layout_io_uring_attr_pi() {
1269 const UNINIT: ::core::mem::MaybeUninit<io_uring_attr_pi> = ::core::mem::MaybeUninit::uninit();
1270 let ptr = UNINIT.as_ptr();
1271 assert_eq!(
1272 ::core::mem::size_of::<io_uring_attr_pi>(),
1273 32usize,
1274 concat!("Size of: ", stringify!(io_uring_attr_pi))
1275 );
1276 assert_eq!(
1277 ::core::mem::align_of::<io_uring_attr_pi>(),
1278 8usize,
1279 concat!("Alignment of ", stringify!(io_uring_attr_pi))
1280 );
1281 assert_eq!(
1282 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1283 0usize,
1284 concat!(
1285 "Offset of field: ",
1286 stringify!(io_uring_attr_pi),
1287 "::",
1288 stringify!(flags)
1289 )
1290 );
1291 assert_eq!(
1292 unsafe { ::core::ptr::addr_of!((*ptr).app_tag) as usize - ptr as usize },
1293 2usize,
1294 concat!(
1295 "Offset of field: ",
1296 stringify!(io_uring_attr_pi),
1297 "::",
1298 stringify!(app_tag)
1299 )
1300 );
1301 assert_eq!(
1302 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
1303 4usize,
1304 concat!(
1305 "Offset of field: ",
1306 stringify!(io_uring_attr_pi),
1307 "::",
1308 stringify!(len)
1309 )
1310 );
1311 assert_eq!(
1312 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
1313 8usize,
1314 concat!(
1315 "Offset of field: ",
1316 stringify!(io_uring_attr_pi),
1317 "::",
1318 stringify!(addr)
1319 )
1320 );
1321 assert_eq!(
1322 unsafe { ::core::ptr::addr_of!((*ptr).seed) as usize - ptr as usize },
1323 16usize,
1324 concat!(
1325 "Offset of field: ",
1326 stringify!(io_uring_attr_pi),
1327 "::",
1328 stringify!(seed)
1329 )
1330 );
1331 assert_eq!(
1332 unsafe { ::core::ptr::addr_of!((*ptr).rsvd) as usize - ptr as usize },
1333 24usize,
1334 concat!(
1335 "Offset of field: ",
1336 stringify!(io_uring_attr_pi),
1337 "::",
1338 stringify!(rsvd)
1339 )
1340 );
1341}
1342pub const IOSQE_FIXED_FILE_BIT: io_uring_sqe_flags_bit = 0;
1343pub const IOSQE_IO_DRAIN_BIT: io_uring_sqe_flags_bit = 1;
1344pub const IOSQE_IO_LINK_BIT: io_uring_sqe_flags_bit = 2;
1345pub const IOSQE_IO_HARDLINK_BIT: io_uring_sqe_flags_bit = 3;
1346pub const IOSQE_ASYNC_BIT: io_uring_sqe_flags_bit = 4;
1347pub const IOSQE_BUFFER_SELECT_BIT: io_uring_sqe_flags_bit = 5;
1348pub const IOSQE_CQE_SKIP_SUCCESS_BIT: io_uring_sqe_flags_bit = 6;
1349pub type io_uring_sqe_flags_bit = libc::c_uint;
1350pub const IORING_OP_NOP: io_uring_op = 0;
1351pub const IORING_OP_READV: io_uring_op = 1;
1352pub const IORING_OP_WRITEV: io_uring_op = 2;
1353pub const IORING_OP_FSYNC: io_uring_op = 3;
1354pub const IORING_OP_READ_FIXED: io_uring_op = 4;
1355pub const IORING_OP_WRITE_FIXED: io_uring_op = 5;
1356pub const IORING_OP_POLL_ADD: io_uring_op = 6;
1357pub const IORING_OP_POLL_REMOVE: io_uring_op = 7;
1358pub const IORING_OP_SYNC_FILE_RANGE: io_uring_op = 8;
1359pub const IORING_OP_SENDMSG: io_uring_op = 9;
1360pub const IORING_OP_RECVMSG: io_uring_op = 10;
1361pub const IORING_OP_TIMEOUT: io_uring_op = 11;
1362pub const IORING_OP_TIMEOUT_REMOVE: io_uring_op = 12;
1363pub const IORING_OP_ACCEPT: io_uring_op = 13;
1364pub const IORING_OP_ASYNC_CANCEL: io_uring_op = 14;
1365pub const IORING_OP_LINK_TIMEOUT: io_uring_op = 15;
1366pub const IORING_OP_CONNECT: io_uring_op = 16;
1367pub const IORING_OP_FALLOCATE: io_uring_op = 17;
1368pub const IORING_OP_OPENAT: io_uring_op = 18;
1369pub const IORING_OP_CLOSE: io_uring_op = 19;
1370pub const IORING_OP_FILES_UPDATE: io_uring_op = 20;
1371pub const IORING_OP_STATX: io_uring_op = 21;
1372pub const IORING_OP_READ: io_uring_op = 22;
1373pub const IORING_OP_WRITE: io_uring_op = 23;
1374pub const IORING_OP_FADVISE: io_uring_op = 24;
1375pub const IORING_OP_MADVISE: io_uring_op = 25;
1376pub const IORING_OP_SEND: io_uring_op = 26;
1377pub const IORING_OP_RECV: io_uring_op = 27;
1378pub const IORING_OP_OPENAT2: io_uring_op = 28;
1379pub const IORING_OP_EPOLL_CTL: io_uring_op = 29;
1380pub const IORING_OP_SPLICE: io_uring_op = 30;
1381pub const IORING_OP_PROVIDE_BUFFERS: io_uring_op = 31;
1382pub const IORING_OP_REMOVE_BUFFERS: io_uring_op = 32;
1383pub const IORING_OP_TEE: io_uring_op = 33;
1384pub const IORING_OP_SHUTDOWN: io_uring_op = 34;
1385pub const IORING_OP_RENAMEAT: io_uring_op = 35;
1386pub const IORING_OP_UNLINKAT: io_uring_op = 36;
1387pub const IORING_OP_MKDIRAT: io_uring_op = 37;
1388pub const IORING_OP_SYMLINKAT: io_uring_op = 38;
1389pub const IORING_OP_LINKAT: io_uring_op = 39;
1390pub const IORING_OP_MSG_RING: io_uring_op = 40;
1391pub const IORING_OP_FSETXATTR: io_uring_op = 41;
1392pub const IORING_OP_SETXATTR: io_uring_op = 42;
1393pub const IORING_OP_FGETXATTR: io_uring_op = 43;
1394pub const IORING_OP_GETXATTR: io_uring_op = 44;
1395pub const IORING_OP_SOCKET: io_uring_op = 45;
1396pub const IORING_OP_URING_CMD: io_uring_op = 46;
1397pub const IORING_OP_SEND_ZC: io_uring_op = 47;
1398pub const IORING_OP_SENDMSG_ZC: io_uring_op = 48;
1399pub const IORING_OP_READ_MULTISHOT: io_uring_op = 49;
1400pub const IORING_OP_WAITID: io_uring_op = 50;
1401pub const IORING_OP_FUTEX_WAIT: io_uring_op = 51;
1402pub const IORING_OP_FUTEX_WAKE: io_uring_op = 52;
1403pub const IORING_OP_FUTEX_WAITV: io_uring_op = 53;
1404pub const IORING_OP_FIXED_FD_INSTALL: io_uring_op = 54;
1405pub const IORING_OP_FTRUNCATE: io_uring_op = 55;
1406pub const IORING_OP_BIND: io_uring_op = 56;
1407pub const IORING_OP_LISTEN: io_uring_op = 57;
1408pub const IORING_OP_RECV_ZC: io_uring_op = 58;
1409pub const IORING_OP_EPOLL_WAIT: io_uring_op = 59;
1410pub const IORING_OP_READV_FIXED: io_uring_op = 60;
1411pub const IORING_OP_WRITEV_FIXED: io_uring_op = 61;
1412pub const IORING_OP_PIPE: io_uring_op = 62;
1413pub const IORING_OP_LAST: io_uring_op = 63;
1414pub type io_uring_op = libc::c_uint;
1415pub const IORING_MSG_DATA: io_uring_msg_ring_flags = 0;
1416pub const IORING_MSG_SEND_FD: io_uring_msg_ring_flags = 1;
1417pub type io_uring_msg_ring_flags = libc::c_uint;
1418#[repr(C)]
1419#[derive(Debug, Default)]
1420pub struct io_uring_cqe {
1421 pub user_data: __u64,
1422 pub res: __s32,
1423 pub flags: __u32,
1424 pub big_cqe: __IncompleteArrayField<__u64>,
1425}
1426#[test]
1427fn bindgen_test_layout_io_uring_cqe() {
1428 const UNINIT: ::core::mem::MaybeUninit<io_uring_cqe> = ::core::mem::MaybeUninit::uninit();
1429 let ptr = UNINIT.as_ptr();
1430 assert_eq!(
1431 ::core::mem::size_of::<io_uring_cqe>(),
1432 16usize,
1433 concat!("Size of: ", stringify!(io_uring_cqe))
1434 );
1435 assert_eq!(
1436 ::core::mem::align_of::<io_uring_cqe>(),
1437 8usize,
1438 concat!("Alignment of ", stringify!(io_uring_cqe))
1439 );
1440 assert_eq!(
1441 unsafe { ::core::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
1442 0usize,
1443 concat!(
1444 "Offset of field: ",
1445 stringify!(io_uring_cqe),
1446 "::",
1447 stringify!(user_data)
1448 )
1449 );
1450 assert_eq!(
1451 unsafe { ::core::ptr::addr_of!((*ptr).res) as usize - ptr as usize },
1452 8usize,
1453 concat!(
1454 "Offset of field: ",
1455 stringify!(io_uring_cqe),
1456 "::",
1457 stringify!(res)
1458 )
1459 );
1460 assert_eq!(
1461 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1462 12usize,
1463 concat!(
1464 "Offset of field: ",
1465 stringify!(io_uring_cqe),
1466 "::",
1467 stringify!(flags)
1468 )
1469 );
1470 assert_eq!(
1471 unsafe { ::core::ptr::addr_of!((*ptr).big_cqe) as usize - ptr as usize },
1472 16usize,
1473 concat!(
1474 "Offset of field: ",
1475 stringify!(io_uring_cqe),
1476 "::",
1477 stringify!(big_cqe)
1478 )
1479 );
1480}
1481#[repr(C)]
1482#[derive(Debug, Default, Copy, Clone)]
1483pub struct io_sqring_offsets {
1484 pub head: __u32,
1485 pub tail: __u32,
1486 pub ring_mask: __u32,
1487 pub ring_entries: __u32,
1488 pub flags: __u32,
1489 pub dropped: __u32,
1490 pub array: __u32,
1491 pub resv1: __u32,
1492 pub user_addr: __u64,
1493}
1494#[test]
1495fn bindgen_test_layout_io_sqring_offsets() {
1496 const UNINIT: ::core::mem::MaybeUninit<io_sqring_offsets> = ::core::mem::MaybeUninit::uninit();
1497 let ptr = UNINIT.as_ptr();
1498 assert_eq!(
1499 ::core::mem::size_of::<io_sqring_offsets>(),
1500 40usize,
1501 concat!("Size of: ", stringify!(io_sqring_offsets))
1502 );
1503 assert_eq!(
1504 ::core::mem::align_of::<io_sqring_offsets>(),
1505 8usize,
1506 concat!("Alignment of ", stringify!(io_sqring_offsets))
1507 );
1508 assert_eq!(
1509 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
1510 0usize,
1511 concat!(
1512 "Offset of field: ",
1513 stringify!(io_sqring_offsets),
1514 "::",
1515 stringify!(head)
1516 )
1517 );
1518 assert_eq!(
1519 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
1520 4usize,
1521 concat!(
1522 "Offset of field: ",
1523 stringify!(io_sqring_offsets),
1524 "::",
1525 stringify!(tail)
1526 )
1527 );
1528 assert_eq!(
1529 unsafe { ::core::ptr::addr_of!((*ptr).ring_mask) as usize - ptr as usize },
1530 8usize,
1531 concat!(
1532 "Offset of field: ",
1533 stringify!(io_sqring_offsets),
1534 "::",
1535 stringify!(ring_mask)
1536 )
1537 );
1538 assert_eq!(
1539 unsafe { ::core::ptr::addr_of!((*ptr).ring_entries) as usize - ptr as usize },
1540 12usize,
1541 concat!(
1542 "Offset of field: ",
1543 stringify!(io_sqring_offsets),
1544 "::",
1545 stringify!(ring_entries)
1546 )
1547 );
1548 assert_eq!(
1549 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1550 16usize,
1551 concat!(
1552 "Offset of field: ",
1553 stringify!(io_sqring_offsets),
1554 "::",
1555 stringify!(flags)
1556 )
1557 );
1558 assert_eq!(
1559 unsafe { ::core::ptr::addr_of!((*ptr).dropped) as usize - ptr as usize },
1560 20usize,
1561 concat!(
1562 "Offset of field: ",
1563 stringify!(io_sqring_offsets),
1564 "::",
1565 stringify!(dropped)
1566 )
1567 );
1568 assert_eq!(
1569 unsafe { ::core::ptr::addr_of!((*ptr).array) as usize - ptr as usize },
1570 24usize,
1571 concat!(
1572 "Offset of field: ",
1573 stringify!(io_sqring_offsets),
1574 "::",
1575 stringify!(array)
1576 )
1577 );
1578 assert_eq!(
1579 unsafe { ::core::ptr::addr_of!((*ptr).resv1) as usize - ptr as usize },
1580 28usize,
1581 concat!(
1582 "Offset of field: ",
1583 stringify!(io_sqring_offsets),
1584 "::",
1585 stringify!(resv1)
1586 )
1587 );
1588 assert_eq!(
1589 unsafe { ::core::ptr::addr_of!((*ptr).user_addr) as usize - ptr as usize },
1590 32usize,
1591 concat!(
1592 "Offset of field: ",
1593 stringify!(io_sqring_offsets),
1594 "::",
1595 stringify!(user_addr)
1596 )
1597 );
1598}
1599#[repr(C)]
1600#[derive(Debug, Default, Copy, Clone)]
1601pub struct io_cqring_offsets {
1602 pub head: __u32,
1603 pub tail: __u32,
1604 pub ring_mask: __u32,
1605 pub ring_entries: __u32,
1606 pub overflow: __u32,
1607 pub cqes: __u32,
1608 pub flags: __u32,
1609 pub resv1: __u32,
1610 pub user_addr: __u64,
1611}
1612#[test]
1613fn bindgen_test_layout_io_cqring_offsets() {
1614 const UNINIT: ::core::mem::MaybeUninit<io_cqring_offsets> = ::core::mem::MaybeUninit::uninit();
1615 let ptr = UNINIT.as_ptr();
1616 assert_eq!(
1617 ::core::mem::size_of::<io_cqring_offsets>(),
1618 40usize,
1619 concat!("Size of: ", stringify!(io_cqring_offsets))
1620 );
1621 assert_eq!(
1622 ::core::mem::align_of::<io_cqring_offsets>(),
1623 8usize,
1624 concat!("Alignment of ", stringify!(io_cqring_offsets))
1625 );
1626 assert_eq!(
1627 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
1628 0usize,
1629 concat!(
1630 "Offset of field: ",
1631 stringify!(io_cqring_offsets),
1632 "::",
1633 stringify!(head)
1634 )
1635 );
1636 assert_eq!(
1637 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
1638 4usize,
1639 concat!(
1640 "Offset of field: ",
1641 stringify!(io_cqring_offsets),
1642 "::",
1643 stringify!(tail)
1644 )
1645 );
1646 assert_eq!(
1647 unsafe { ::core::ptr::addr_of!((*ptr).ring_mask) as usize - ptr as usize },
1648 8usize,
1649 concat!(
1650 "Offset of field: ",
1651 stringify!(io_cqring_offsets),
1652 "::",
1653 stringify!(ring_mask)
1654 )
1655 );
1656 assert_eq!(
1657 unsafe { ::core::ptr::addr_of!((*ptr).ring_entries) as usize - ptr as usize },
1658 12usize,
1659 concat!(
1660 "Offset of field: ",
1661 stringify!(io_cqring_offsets),
1662 "::",
1663 stringify!(ring_entries)
1664 )
1665 );
1666 assert_eq!(
1667 unsafe { ::core::ptr::addr_of!((*ptr).overflow) as usize - ptr as usize },
1668 16usize,
1669 concat!(
1670 "Offset of field: ",
1671 stringify!(io_cqring_offsets),
1672 "::",
1673 stringify!(overflow)
1674 )
1675 );
1676 assert_eq!(
1677 unsafe { ::core::ptr::addr_of!((*ptr).cqes) as usize - ptr as usize },
1678 20usize,
1679 concat!(
1680 "Offset of field: ",
1681 stringify!(io_cqring_offsets),
1682 "::",
1683 stringify!(cqes)
1684 )
1685 );
1686 assert_eq!(
1687 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1688 24usize,
1689 concat!(
1690 "Offset of field: ",
1691 stringify!(io_cqring_offsets),
1692 "::",
1693 stringify!(flags)
1694 )
1695 );
1696 assert_eq!(
1697 unsafe { ::core::ptr::addr_of!((*ptr).resv1) as usize - ptr as usize },
1698 28usize,
1699 concat!(
1700 "Offset of field: ",
1701 stringify!(io_cqring_offsets),
1702 "::",
1703 stringify!(resv1)
1704 )
1705 );
1706 assert_eq!(
1707 unsafe { ::core::ptr::addr_of!((*ptr).user_addr) as usize - ptr as usize },
1708 32usize,
1709 concat!(
1710 "Offset of field: ",
1711 stringify!(io_cqring_offsets),
1712 "::",
1713 stringify!(user_addr)
1714 )
1715 );
1716}
1717#[repr(C)]
1718#[derive(Debug, Default, Copy, Clone)]
1719pub struct io_uring_params {
1720 pub sq_entries: __u32,
1721 pub cq_entries: __u32,
1722 pub flags: __u32,
1723 pub sq_thread_cpu: __u32,
1724 pub sq_thread_idle: __u32,
1725 pub features: __u32,
1726 pub wq_fd: __u32,
1727 pub resv: [__u32; 3usize],
1728 pub sq_off: io_sqring_offsets,
1729 pub cq_off: io_cqring_offsets,
1730}
1731#[test]
1732fn bindgen_test_layout_io_uring_params() {
1733 const UNINIT: ::core::mem::MaybeUninit<io_uring_params> = ::core::mem::MaybeUninit::uninit();
1734 let ptr = UNINIT.as_ptr();
1735 assert_eq!(
1736 ::core::mem::size_of::<io_uring_params>(),
1737 120usize,
1738 concat!("Size of: ", stringify!(io_uring_params))
1739 );
1740 assert_eq!(
1741 ::core::mem::align_of::<io_uring_params>(),
1742 8usize,
1743 concat!("Alignment of ", stringify!(io_uring_params))
1744 );
1745 assert_eq!(
1746 unsafe { ::core::ptr::addr_of!((*ptr).sq_entries) as usize - ptr as usize },
1747 0usize,
1748 concat!(
1749 "Offset of field: ",
1750 stringify!(io_uring_params),
1751 "::",
1752 stringify!(sq_entries)
1753 )
1754 );
1755 assert_eq!(
1756 unsafe { ::core::ptr::addr_of!((*ptr).cq_entries) as usize - ptr as usize },
1757 4usize,
1758 concat!(
1759 "Offset of field: ",
1760 stringify!(io_uring_params),
1761 "::",
1762 stringify!(cq_entries)
1763 )
1764 );
1765 assert_eq!(
1766 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1767 8usize,
1768 concat!(
1769 "Offset of field: ",
1770 stringify!(io_uring_params),
1771 "::",
1772 stringify!(flags)
1773 )
1774 );
1775 assert_eq!(
1776 unsafe { ::core::ptr::addr_of!((*ptr).sq_thread_cpu) as usize - ptr as usize },
1777 12usize,
1778 concat!(
1779 "Offset of field: ",
1780 stringify!(io_uring_params),
1781 "::",
1782 stringify!(sq_thread_cpu)
1783 )
1784 );
1785 assert_eq!(
1786 unsafe { ::core::ptr::addr_of!((*ptr).sq_thread_idle) as usize - ptr as usize },
1787 16usize,
1788 concat!(
1789 "Offset of field: ",
1790 stringify!(io_uring_params),
1791 "::",
1792 stringify!(sq_thread_idle)
1793 )
1794 );
1795 assert_eq!(
1796 unsafe { ::core::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
1797 20usize,
1798 concat!(
1799 "Offset of field: ",
1800 stringify!(io_uring_params),
1801 "::",
1802 stringify!(features)
1803 )
1804 );
1805 assert_eq!(
1806 unsafe { ::core::ptr::addr_of!((*ptr).wq_fd) as usize - ptr as usize },
1807 24usize,
1808 concat!(
1809 "Offset of field: ",
1810 stringify!(io_uring_params),
1811 "::",
1812 stringify!(wq_fd)
1813 )
1814 );
1815 assert_eq!(
1816 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1817 28usize,
1818 concat!(
1819 "Offset of field: ",
1820 stringify!(io_uring_params),
1821 "::",
1822 stringify!(resv)
1823 )
1824 );
1825 assert_eq!(
1826 unsafe { ::core::ptr::addr_of!((*ptr).sq_off) as usize - ptr as usize },
1827 40usize,
1828 concat!(
1829 "Offset of field: ",
1830 stringify!(io_uring_params),
1831 "::",
1832 stringify!(sq_off)
1833 )
1834 );
1835 assert_eq!(
1836 unsafe { ::core::ptr::addr_of!((*ptr).cq_off) as usize - ptr as usize },
1837 80usize,
1838 concat!(
1839 "Offset of field: ",
1840 stringify!(io_uring_params),
1841 "::",
1842 stringify!(cq_off)
1843 )
1844 );
1845}
1846pub const IORING_REGISTER_BUFFERS: io_uring_register_op = 0;
1847pub const IORING_UNREGISTER_BUFFERS: io_uring_register_op = 1;
1848pub const IORING_REGISTER_FILES: io_uring_register_op = 2;
1849pub const IORING_UNREGISTER_FILES: io_uring_register_op = 3;
1850pub const IORING_REGISTER_EVENTFD: io_uring_register_op = 4;
1851pub const IORING_UNREGISTER_EVENTFD: io_uring_register_op = 5;
1852pub const IORING_REGISTER_FILES_UPDATE: io_uring_register_op = 6;
1853pub const IORING_REGISTER_EVENTFD_ASYNC: io_uring_register_op = 7;
1854pub const IORING_REGISTER_PROBE: io_uring_register_op = 8;
1855pub const IORING_REGISTER_PERSONALITY: io_uring_register_op = 9;
1856pub const IORING_UNREGISTER_PERSONALITY: io_uring_register_op = 10;
1857pub const IORING_REGISTER_RESTRICTIONS: io_uring_register_op = 11;
1858pub const IORING_REGISTER_ENABLE_RINGS: io_uring_register_op = 12;
1859pub const IORING_REGISTER_FILES2: io_uring_register_op = 13;
1860pub const IORING_REGISTER_FILES_UPDATE2: io_uring_register_op = 14;
1861pub const IORING_REGISTER_BUFFERS2: io_uring_register_op = 15;
1862pub const IORING_REGISTER_BUFFERS_UPDATE: io_uring_register_op = 16;
1863pub const IORING_REGISTER_IOWQ_AFF: io_uring_register_op = 17;
1864pub const IORING_UNREGISTER_IOWQ_AFF: io_uring_register_op = 18;
1865pub const IORING_REGISTER_IOWQ_MAX_WORKERS: io_uring_register_op = 19;
1866pub const IORING_REGISTER_RING_FDS: io_uring_register_op = 20;
1867pub const IORING_UNREGISTER_RING_FDS: io_uring_register_op = 21;
1868pub const IORING_REGISTER_PBUF_RING: io_uring_register_op = 22;
1869pub const IORING_UNREGISTER_PBUF_RING: io_uring_register_op = 23;
1870pub const IORING_REGISTER_SYNC_CANCEL: io_uring_register_op = 24;
1871pub const IORING_REGISTER_FILE_ALLOC_RANGE: io_uring_register_op = 25;
1872pub const IORING_REGISTER_PBUF_STATUS: io_uring_register_op = 26;
1873pub const IORING_REGISTER_NAPI: io_uring_register_op = 27;
1874pub const IORING_UNREGISTER_NAPI: io_uring_register_op = 28;
1875pub const IORING_REGISTER_CLOCK: io_uring_register_op = 29;
1876pub const IORING_REGISTER_CLONE_BUFFERS: io_uring_register_op = 30;
1877pub const IORING_REGISTER_SEND_MSG_RING: io_uring_register_op = 31;
1878pub const IORING_REGISTER_ZCRX_IFQ: io_uring_register_op = 32;
1879pub const IORING_REGISTER_RESIZE_RINGS: io_uring_register_op = 33;
1880pub const IORING_REGISTER_MEM_REGION: io_uring_register_op = 34;
1881pub const IORING_REGISTER_LAST: io_uring_register_op = 35;
1882pub const IORING_REGISTER_USE_REGISTERED_RING: io_uring_register_op = 2147483648;
1883pub type io_uring_register_op = libc::c_uint;
1884#[repr(C)]
1885#[derive(Debug, Default, Copy, Clone)]
1886pub struct io_uring_files_update {
1887 pub offset: __u32,
1888 pub resv: __u32,
1889 pub fds: __u64,
1890}
1891#[test]
1892fn bindgen_test_layout_io_uring_files_update() {
1893 const UNINIT: ::core::mem::MaybeUninit<io_uring_files_update> =
1894 ::core::mem::MaybeUninit::uninit();
1895 let ptr = UNINIT.as_ptr();
1896 assert_eq!(
1897 ::core::mem::size_of::<io_uring_files_update>(),
1898 16usize,
1899 concat!("Size of: ", stringify!(io_uring_files_update))
1900 );
1901 assert_eq!(
1902 ::core::mem::align_of::<io_uring_files_update>(),
1903 8usize,
1904 concat!("Alignment of ", stringify!(io_uring_files_update))
1905 );
1906 assert_eq!(
1907 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1908 0usize,
1909 concat!(
1910 "Offset of field: ",
1911 stringify!(io_uring_files_update),
1912 "::",
1913 stringify!(offset)
1914 )
1915 );
1916 assert_eq!(
1917 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1918 4usize,
1919 concat!(
1920 "Offset of field: ",
1921 stringify!(io_uring_files_update),
1922 "::",
1923 stringify!(resv)
1924 )
1925 );
1926 assert_eq!(
1927 unsafe { ::core::ptr::addr_of!((*ptr).fds) as usize - ptr as usize },
1928 8usize,
1929 concat!(
1930 "Offset of field: ",
1931 stringify!(io_uring_files_update),
1932 "::",
1933 stringify!(fds)
1934 )
1935 );
1936}
1937pub const IORING_MEM_REGION_TYPE_USER: _bindgen_ty_4 = 1;
1938pub type _bindgen_ty_4 = libc::c_uint;
1939#[repr(C)]
1940#[derive(Debug, Default, Copy, Clone)]
1941pub struct io_uring_region_desc {
1942 pub user_addr: __u64,
1943 pub size: __u64,
1944 pub flags: __u32,
1945 pub id: __u32,
1946 pub mmap_offset: __u64,
1947 pub __resv: [__u64; 4usize],
1948}
1949#[test]
1950fn bindgen_test_layout_io_uring_region_desc() {
1951 const UNINIT: ::core::mem::MaybeUninit<io_uring_region_desc> =
1952 ::core::mem::MaybeUninit::uninit();
1953 let ptr = UNINIT.as_ptr();
1954 assert_eq!(
1955 ::core::mem::size_of::<io_uring_region_desc>(),
1956 64usize,
1957 concat!("Size of: ", stringify!(io_uring_region_desc))
1958 );
1959 assert_eq!(
1960 ::core::mem::align_of::<io_uring_region_desc>(),
1961 8usize,
1962 concat!("Alignment of ", stringify!(io_uring_region_desc))
1963 );
1964 assert_eq!(
1965 unsafe { ::core::ptr::addr_of!((*ptr).user_addr) as usize - ptr as usize },
1966 0usize,
1967 concat!(
1968 "Offset of field: ",
1969 stringify!(io_uring_region_desc),
1970 "::",
1971 stringify!(user_addr)
1972 )
1973 );
1974 assert_eq!(
1975 unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1976 8usize,
1977 concat!(
1978 "Offset of field: ",
1979 stringify!(io_uring_region_desc),
1980 "::",
1981 stringify!(size)
1982 )
1983 );
1984 assert_eq!(
1985 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1986 16usize,
1987 concat!(
1988 "Offset of field: ",
1989 stringify!(io_uring_region_desc),
1990 "::",
1991 stringify!(flags)
1992 )
1993 );
1994 assert_eq!(
1995 unsafe { ::core::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
1996 20usize,
1997 concat!(
1998 "Offset of field: ",
1999 stringify!(io_uring_region_desc),
2000 "::",
2001 stringify!(id)
2002 )
2003 );
2004 assert_eq!(
2005 unsafe { ::core::ptr::addr_of!((*ptr).mmap_offset) as usize - ptr as usize },
2006 24usize,
2007 concat!(
2008 "Offset of field: ",
2009 stringify!(io_uring_region_desc),
2010 "::",
2011 stringify!(mmap_offset)
2012 )
2013 );
2014 assert_eq!(
2015 unsafe { ::core::ptr::addr_of!((*ptr).__resv) as usize - ptr as usize },
2016 32usize,
2017 concat!(
2018 "Offset of field: ",
2019 stringify!(io_uring_region_desc),
2020 "::",
2021 stringify!(__resv)
2022 )
2023 );
2024}
2025pub const IORING_MEM_REGION_REG_WAIT_ARG: _bindgen_ty_5 = 1;
2026pub type _bindgen_ty_5 = libc::c_uint;
2027#[repr(C)]
2028#[derive(Debug, Default, Copy, Clone)]
2029pub struct io_uring_mem_region_reg {
2030 pub region_uptr: __u64,
2031 pub flags: __u64,
2032 pub __resv: [__u64; 2usize],
2033}
2034#[test]
2035fn bindgen_test_layout_io_uring_mem_region_reg() {
2036 const UNINIT: ::core::mem::MaybeUninit<io_uring_mem_region_reg> =
2037 ::core::mem::MaybeUninit::uninit();
2038 let ptr = UNINIT.as_ptr();
2039 assert_eq!(
2040 ::core::mem::size_of::<io_uring_mem_region_reg>(),
2041 32usize,
2042 concat!("Size of: ", stringify!(io_uring_mem_region_reg))
2043 );
2044 assert_eq!(
2045 ::core::mem::align_of::<io_uring_mem_region_reg>(),
2046 8usize,
2047 concat!("Alignment of ", stringify!(io_uring_mem_region_reg))
2048 );
2049 assert_eq!(
2050 unsafe { ::core::ptr::addr_of!((*ptr).region_uptr) as usize - ptr as usize },
2051 0usize,
2052 concat!(
2053 "Offset of field: ",
2054 stringify!(io_uring_mem_region_reg),
2055 "::",
2056 stringify!(region_uptr)
2057 )
2058 );
2059 assert_eq!(
2060 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2061 8usize,
2062 concat!(
2063 "Offset of field: ",
2064 stringify!(io_uring_mem_region_reg),
2065 "::",
2066 stringify!(flags)
2067 )
2068 );
2069 assert_eq!(
2070 unsafe { ::core::ptr::addr_of!((*ptr).__resv) as usize - ptr as usize },
2071 16usize,
2072 concat!(
2073 "Offset of field: ",
2074 stringify!(io_uring_mem_region_reg),
2075 "::",
2076 stringify!(__resv)
2077 )
2078 );
2079}
2080#[repr(C)]
2081#[derive(Debug, Default, Copy, Clone)]
2082pub struct io_uring_rsrc_register {
2083 pub nr: __u32,
2084 pub flags: __u32,
2085 pub resv2: __u64,
2086 pub data: __u64,
2087 pub tags: __u64,
2088}
2089#[test]
2090fn bindgen_test_layout_io_uring_rsrc_register() {
2091 const UNINIT: ::core::mem::MaybeUninit<io_uring_rsrc_register> =
2092 ::core::mem::MaybeUninit::uninit();
2093 let ptr = UNINIT.as_ptr();
2094 assert_eq!(
2095 ::core::mem::size_of::<io_uring_rsrc_register>(),
2096 32usize,
2097 concat!("Size of: ", stringify!(io_uring_rsrc_register))
2098 );
2099 assert_eq!(
2100 ::core::mem::align_of::<io_uring_rsrc_register>(),
2101 8usize,
2102 concat!("Alignment of ", stringify!(io_uring_rsrc_register))
2103 );
2104 assert_eq!(
2105 unsafe { ::core::ptr::addr_of!((*ptr).nr) as usize - ptr as usize },
2106 0usize,
2107 concat!(
2108 "Offset of field: ",
2109 stringify!(io_uring_rsrc_register),
2110 "::",
2111 stringify!(nr)
2112 )
2113 );
2114 assert_eq!(
2115 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2116 4usize,
2117 concat!(
2118 "Offset of field: ",
2119 stringify!(io_uring_rsrc_register),
2120 "::",
2121 stringify!(flags)
2122 )
2123 );
2124 assert_eq!(
2125 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2126 8usize,
2127 concat!(
2128 "Offset of field: ",
2129 stringify!(io_uring_rsrc_register),
2130 "::",
2131 stringify!(resv2)
2132 )
2133 );
2134 assert_eq!(
2135 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2136 16usize,
2137 concat!(
2138 "Offset of field: ",
2139 stringify!(io_uring_rsrc_register),
2140 "::",
2141 stringify!(data)
2142 )
2143 );
2144 assert_eq!(
2145 unsafe { ::core::ptr::addr_of!((*ptr).tags) as usize - ptr as usize },
2146 24usize,
2147 concat!(
2148 "Offset of field: ",
2149 stringify!(io_uring_rsrc_register),
2150 "::",
2151 stringify!(tags)
2152 )
2153 );
2154}
2155#[repr(C)]
2156#[derive(Debug, Default, Copy, Clone)]
2157pub struct io_uring_rsrc_update {
2158 pub offset: __u32,
2159 pub resv: __u32,
2160 pub data: __u64,
2161}
2162#[test]
2163fn bindgen_test_layout_io_uring_rsrc_update() {
2164 const UNINIT: ::core::mem::MaybeUninit<io_uring_rsrc_update> =
2165 ::core::mem::MaybeUninit::uninit();
2166 let ptr = UNINIT.as_ptr();
2167 assert_eq!(
2168 ::core::mem::size_of::<io_uring_rsrc_update>(),
2169 16usize,
2170 concat!("Size of: ", stringify!(io_uring_rsrc_update))
2171 );
2172 assert_eq!(
2173 ::core::mem::align_of::<io_uring_rsrc_update>(),
2174 8usize,
2175 concat!("Alignment of ", stringify!(io_uring_rsrc_update))
2176 );
2177 assert_eq!(
2178 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
2179 0usize,
2180 concat!(
2181 "Offset of field: ",
2182 stringify!(io_uring_rsrc_update),
2183 "::",
2184 stringify!(offset)
2185 )
2186 );
2187 assert_eq!(
2188 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2189 4usize,
2190 concat!(
2191 "Offset of field: ",
2192 stringify!(io_uring_rsrc_update),
2193 "::",
2194 stringify!(resv)
2195 )
2196 );
2197 assert_eq!(
2198 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2199 8usize,
2200 concat!(
2201 "Offset of field: ",
2202 stringify!(io_uring_rsrc_update),
2203 "::",
2204 stringify!(data)
2205 )
2206 );
2207}
2208#[repr(C)]
2209#[derive(Debug, Default, Copy, Clone)]
2210pub struct io_uring_rsrc_update2 {
2211 pub offset: __u32,
2212 pub resv: __u32,
2213 pub data: __u64,
2214 pub tags: __u64,
2215 pub nr: __u32,
2216 pub resv2: __u32,
2217}
2218#[test]
2219fn bindgen_test_layout_io_uring_rsrc_update2() {
2220 const UNINIT: ::core::mem::MaybeUninit<io_uring_rsrc_update2> =
2221 ::core::mem::MaybeUninit::uninit();
2222 let ptr = UNINIT.as_ptr();
2223 assert_eq!(
2224 ::core::mem::size_of::<io_uring_rsrc_update2>(),
2225 32usize,
2226 concat!("Size of: ", stringify!(io_uring_rsrc_update2))
2227 );
2228 assert_eq!(
2229 ::core::mem::align_of::<io_uring_rsrc_update2>(),
2230 8usize,
2231 concat!("Alignment of ", stringify!(io_uring_rsrc_update2))
2232 );
2233 assert_eq!(
2234 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
2235 0usize,
2236 concat!(
2237 "Offset of field: ",
2238 stringify!(io_uring_rsrc_update2),
2239 "::",
2240 stringify!(offset)
2241 )
2242 );
2243 assert_eq!(
2244 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2245 4usize,
2246 concat!(
2247 "Offset of field: ",
2248 stringify!(io_uring_rsrc_update2),
2249 "::",
2250 stringify!(resv)
2251 )
2252 );
2253 assert_eq!(
2254 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2255 8usize,
2256 concat!(
2257 "Offset of field: ",
2258 stringify!(io_uring_rsrc_update2),
2259 "::",
2260 stringify!(data)
2261 )
2262 );
2263 assert_eq!(
2264 unsafe { ::core::ptr::addr_of!((*ptr).tags) as usize - ptr as usize },
2265 16usize,
2266 concat!(
2267 "Offset of field: ",
2268 stringify!(io_uring_rsrc_update2),
2269 "::",
2270 stringify!(tags)
2271 )
2272 );
2273 assert_eq!(
2274 unsafe { ::core::ptr::addr_of!((*ptr).nr) as usize - ptr as usize },
2275 24usize,
2276 concat!(
2277 "Offset of field: ",
2278 stringify!(io_uring_rsrc_update2),
2279 "::",
2280 stringify!(nr)
2281 )
2282 );
2283 assert_eq!(
2284 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2285 28usize,
2286 concat!(
2287 "Offset of field: ",
2288 stringify!(io_uring_rsrc_update2),
2289 "::",
2290 stringify!(resv2)
2291 )
2292 );
2293}
2294#[repr(C)]
2295#[derive(Debug, Default, Copy, Clone)]
2296pub struct io_uring_probe_op {
2297 pub op: __u8,
2298 pub resv: __u8,
2299 pub flags: __u16,
2300 pub resv2: __u32,
2301}
2302#[test]
2303fn bindgen_test_layout_io_uring_probe_op() {
2304 const UNINIT: ::core::mem::MaybeUninit<io_uring_probe_op> = ::core::mem::MaybeUninit::uninit();
2305 let ptr = UNINIT.as_ptr();
2306 assert_eq!(
2307 ::core::mem::size_of::<io_uring_probe_op>(),
2308 8usize,
2309 concat!("Size of: ", stringify!(io_uring_probe_op))
2310 );
2311 assert_eq!(
2312 ::core::mem::align_of::<io_uring_probe_op>(),
2313 4usize,
2314 concat!("Alignment of ", stringify!(io_uring_probe_op))
2315 );
2316 assert_eq!(
2317 unsafe { ::core::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
2318 0usize,
2319 concat!(
2320 "Offset of field: ",
2321 stringify!(io_uring_probe_op),
2322 "::",
2323 stringify!(op)
2324 )
2325 );
2326 assert_eq!(
2327 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2328 1usize,
2329 concat!(
2330 "Offset of field: ",
2331 stringify!(io_uring_probe_op),
2332 "::",
2333 stringify!(resv)
2334 )
2335 );
2336 assert_eq!(
2337 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2338 2usize,
2339 concat!(
2340 "Offset of field: ",
2341 stringify!(io_uring_probe_op),
2342 "::",
2343 stringify!(flags)
2344 )
2345 );
2346 assert_eq!(
2347 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2348 4usize,
2349 concat!(
2350 "Offset of field: ",
2351 stringify!(io_uring_probe_op),
2352 "::",
2353 stringify!(resv2)
2354 )
2355 );
2356}
2357#[repr(C)]
2358#[derive(Debug, Default)]
2359pub struct io_uring_probe {
2360 pub last_op: __u8,
2361 pub ops_len: __u8,
2362 pub resv: __u16,
2363 pub resv2: [__u32; 3usize],
2364 pub ops: __IncompleteArrayField<io_uring_probe_op>,
2365}
2366#[test]
2367fn bindgen_test_layout_io_uring_probe() {
2368 const UNINIT: ::core::mem::MaybeUninit<io_uring_probe> = ::core::mem::MaybeUninit::uninit();
2369 let ptr = UNINIT.as_ptr();
2370 assert_eq!(
2371 ::core::mem::size_of::<io_uring_probe>(),
2372 16usize,
2373 concat!("Size of: ", stringify!(io_uring_probe))
2374 );
2375 assert_eq!(
2376 ::core::mem::align_of::<io_uring_probe>(),
2377 4usize,
2378 concat!("Alignment of ", stringify!(io_uring_probe))
2379 );
2380 assert_eq!(
2381 unsafe { ::core::ptr::addr_of!((*ptr).last_op) as usize - ptr as usize },
2382 0usize,
2383 concat!(
2384 "Offset of field: ",
2385 stringify!(io_uring_probe),
2386 "::",
2387 stringify!(last_op)
2388 )
2389 );
2390 assert_eq!(
2391 unsafe { ::core::ptr::addr_of!((*ptr).ops_len) as usize - ptr as usize },
2392 1usize,
2393 concat!(
2394 "Offset of field: ",
2395 stringify!(io_uring_probe),
2396 "::",
2397 stringify!(ops_len)
2398 )
2399 );
2400 assert_eq!(
2401 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2402 2usize,
2403 concat!(
2404 "Offset of field: ",
2405 stringify!(io_uring_probe),
2406 "::",
2407 stringify!(resv)
2408 )
2409 );
2410 assert_eq!(
2411 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2412 4usize,
2413 concat!(
2414 "Offset of field: ",
2415 stringify!(io_uring_probe),
2416 "::",
2417 stringify!(resv2)
2418 )
2419 );
2420 assert_eq!(
2421 unsafe { ::core::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
2422 16usize,
2423 concat!(
2424 "Offset of field: ",
2425 stringify!(io_uring_probe),
2426 "::",
2427 stringify!(ops)
2428 )
2429 );
2430}
2431#[repr(C)]
2432#[derive(Copy, Clone)]
2433pub struct io_uring_restriction {
2434 pub opcode: __u16,
2435 pub __bindgen_anon_1: io_uring_restriction__bindgen_ty_1,
2436 pub resv: __u8,
2437 pub resv2: [__u32; 3usize],
2438}
2439#[repr(C)]
2440#[derive(Copy, Clone)]
2441pub union io_uring_restriction__bindgen_ty_1 {
2442 pub register_op: __u8,
2443 pub sqe_op: __u8,
2444 pub sqe_flags: __u8,
2445}
2446#[test]
2447fn bindgen_test_layout_io_uring_restriction__bindgen_ty_1() {
2448 const UNINIT: ::core::mem::MaybeUninit<io_uring_restriction__bindgen_ty_1> =
2449 ::core::mem::MaybeUninit::uninit();
2450 let ptr = UNINIT.as_ptr();
2451 assert_eq!(
2452 ::core::mem::size_of::<io_uring_restriction__bindgen_ty_1>(),
2453 1usize,
2454 concat!("Size of: ", stringify!(io_uring_restriction__bindgen_ty_1))
2455 );
2456 assert_eq!(
2457 ::core::mem::align_of::<io_uring_restriction__bindgen_ty_1>(),
2458 1usize,
2459 concat!(
2460 "Alignment of ",
2461 stringify!(io_uring_restriction__bindgen_ty_1)
2462 )
2463 );
2464 assert_eq!(
2465 unsafe { ::core::ptr::addr_of!((*ptr).register_op) as usize - ptr as usize },
2466 0usize,
2467 concat!(
2468 "Offset of field: ",
2469 stringify!(io_uring_restriction__bindgen_ty_1),
2470 "::",
2471 stringify!(register_op)
2472 )
2473 );
2474 assert_eq!(
2475 unsafe { ::core::ptr::addr_of!((*ptr).sqe_op) as usize - ptr as usize },
2476 0usize,
2477 concat!(
2478 "Offset of field: ",
2479 stringify!(io_uring_restriction__bindgen_ty_1),
2480 "::",
2481 stringify!(sqe_op)
2482 )
2483 );
2484 assert_eq!(
2485 unsafe { ::core::ptr::addr_of!((*ptr).sqe_flags) as usize - ptr as usize },
2486 0usize,
2487 concat!(
2488 "Offset of field: ",
2489 stringify!(io_uring_restriction__bindgen_ty_1),
2490 "::",
2491 stringify!(sqe_flags)
2492 )
2493 );
2494}
2495impl Default for io_uring_restriction__bindgen_ty_1 {
2496 fn default() -> Self {
2497 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2498 unsafe {
2499 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2500 s.assume_init()
2501 }
2502 }
2503}
2504#[test]
2505fn bindgen_test_layout_io_uring_restriction() {
2506 const UNINIT: ::core::mem::MaybeUninit<io_uring_restriction> =
2507 ::core::mem::MaybeUninit::uninit();
2508 let ptr = UNINIT.as_ptr();
2509 assert_eq!(
2510 ::core::mem::size_of::<io_uring_restriction>(),
2511 16usize,
2512 concat!("Size of: ", stringify!(io_uring_restriction))
2513 );
2514 assert_eq!(
2515 ::core::mem::align_of::<io_uring_restriction>(),
2516 4usize,
2517 concat!("Alignment of ", stringify!(io_uring_restriction))
2518 );
2519 assert_eq!(
2520 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
2521 0usize,
2522 concat!(
2523 "Offset of field: ",
2524 stringify!(io_uring_restriction),
2525 "::",
2526 stringify!(opcode)
2527 )
2528 );
2529 assert_eq!(
2530 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2531 3usize,
2532 concat!(
2533 "Offset of field: ",
2534 stringify!(io_uring_restriction),
2535 "::",
2536 stringify!(resv)
2537 )
2538 );
2539 assert_eq!(
2540 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2541 4usize,
2542 concat!(
2543 "Offset of field: ",
2544 stringify!(io_uring_restriction),
2545 "::",
2546 stringify!(resv2)
2547 )
2548 );
2549}
2550impl Default for io_uring_restriction {
2551 fn default() -> Self {
2552 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2553 unsafe {
2554 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2555 s.assume_init()
2556 }
2557 }
2558}
2559#[repr(C)]
2560#[derive(Debug, Default, Copy, Clone)]
2561pub struct io_uring_clock_register {
2562 pub clockid: __u32,
2563 pub __resv: [__u32; 3usize],
2564}
2565#[test]
2566fn bindgen_test_layout_io_uring_clock_register() {
2567 const UNINIT: ::core::mem::MaybeUninit<io_uring_clock_register> =
2568 ::core::mem::MaybeUninit::uninit();
2569 let ptr = UNINIT.as_ptr();
2570 assert_eq!(
2571 ::core::mem::size_of::<io_uring_clock_register>(),
2572 16usize,
2573 concat!("Size of: ", stringify!(io_uring_clock_register))
2574 );
2575 assert_eq!(
2576 ::core::mem::align_of::<io_uring_clock_register>(),
2577 4usize,
2578 concat!("Alignment of ", stringify!(io_uring_clock_register))
2579 );
2580 assert_eq!(
2581 unsafe { ::core::ptr::addr_of!((*ptr).clockid) as usize - ptr as usize },
2582 0usize,
2583 concat!(
2584 "Offset of field: ",
2585 stringify!(io_uring_clock_register),
2586 "::",
2587 stringify!(clockid)
2588 )
2589 );
2590 assert_eq!(
2591 unsafe { ::core::ptr::addr_of!((*ptr).__resv) as usize - ptr as usize },
2592 4usize,
2593 concat!(
2594 "Offset of field: ",
2595 stringify!(io_uring_clock_register),
2596 "::",
2597 stringify!(__resv)
2598 )
2599 );
2600}
2601pub const IORING_REGISTER_SRC_REGISTERED: _bindgen_ty_6 = 1;
2602pub const IORING_REGISTER_DST_REPLACE: _bindgen_ty_6 = 2;
2603pub type _bindgen_ty_6 = libc::c_uint;
2604#[repr(C)]
2605#[derive(Debug, Default, Copy, Clone)]
2606pub struct io_uring_clone_buffers {
2607 pub src_fd: __u32,
2608 pub flags: __u32,
2609 pub src_off: __u32,
2610 pub dst_off: __u32,
2611 pub nr: __u32,
2612 pub pad: [__u32; 3usize],
2613}
2614#[test]
2615fn bindgen_test_layout_io_uring_clone_buffers() {
2616 const UNINIT: ::core::mem::MaybeUninit<io_uring_clone_buffers> =
2617 ::core::mem::MaybeUninit::uninit();
2618 let ptr = UNINIT.as_ptr();
2619 assert_eq!(
2620 ::core::mem::size_of::<io_uring_clone_buffers>(),
2621 32usize,
2622 concat!("Size of: ", stringify!(io_uring_clone_buffers))
2623 );
2624 assert_eq!(
2625 ::core::mem::align_of::<io_uring_clone_buffers>(),
2626 4usize,
2627 concat!("Alignment of ", stringify!(io_uring_clone_buffers))
2628 );
2629 assert_eq!(
2630 unsafe { ::core::ptr::addr_of!((*ptr).src_fd) as usize - ptr as usize },
2631 0usize,
2632 concat!(
2633 "Offset of field: ",
2634 stringify!(io_uring_clone_buffers),
2635 "::",
2636 stringify!(src_fd)
2637 )
2638 );
2639 assert_eq!(
2640 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2641 4usize,
2642 concat!(
2643 "Offset of field: ",
2644 stringify!(io_uring_clone_buffers),
2645 "::",
2646 stringify!(flags)
2647 )
2648 );
2649 assert_eq!(
2650 unsafe { ::core::ptr::addr_of!((*ptr).src_off) as usize - ptr as usize },
2651 8usize,
2652 concat!(
2653 "Offset of field: ",
2654 stringify!(io_uring_clone_buffers),
2655 "::",
2656 stringify!(src_off)
2657 )
2658 );
2659 assert_eq!(
2660 unsafe { ::core::ptr::addr_of!((*ptr).dst_off) as usize - ptr as usize },
2661 12usize,
2662 concat!(
2663 "Offset of field: ",
2664 stringify!(io_uring_clone_buffers),
2665 "::",
2666 stringify!(dst_off)
2667 )
2668 );
2669 assert_eq!(
2670 unsafe { ::core::ptr::addr_of!((*ptr).nr) as usize - ptr as usize },
2671 16usize,
2672 concat!(
2673 "Offset of field: ",
2674 stringify!(io_uring_clone_buffers),
2675 "::",
2676 stringify!(nr)
2677 )
2678 );
2679 assert_eq!(
2680 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
2681 20usize,
2682 concat!(
2683 "Offset of field: ",
2684 stringify!(io_uring_clone_buffers),
2685 "::",
2686 stringify!(pad)
2687 )
2688 );
2689}
2690#[repr(C)]
2691#[derive(Debug, Default, Copy, Clone)]
2692pub struct io_uring_buf {
2693 pub addr: __u64,
2694 pub len: __u32,
2695 pub bid: __u16,
2696 pub resv: __u16,
2697}
2698#[test]
2699fn bindgen_test_layout_io_uring_buf() {
2700 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf> = ::core::mem::MaybeUninit::uninit();
2701 let ptr = UNINIT.as_ptr();
2702 assert_eq!(
2703 ::core::mem::size_of::<io_uring_buf>(),
2704 16usize,
2705 concat!("Size of: ", stringify!(io_uring_buf))
2706 );
2707 assert_eq!(
2708 ::core::mem::align_of::<io_uring_buf>(),
2709 8usize,
2710 concat!("Alignment of ", stringify!(io_uring_buf))
2711 );
2712 assert_eq!(
2713 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
2714 0usize,
2715 concat!(
2716 "Offset of field: ",
2717 stringify!(io_uring_buf),
2718 "::",
2719 stringify!(addr)
2720 )
2721 );
2722 assert_eq!(
2723 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
2724 8usize,
2725 concat!(
2726 "Offset of field: ",
2727 stringify!(io_uring_buf),
2728 "::",
2729 stringify!(len)
2730 )
2731 );
2732 assert_eq!(
2733 unsafe { ::core::ptr::addr_of!((*ptr).bid) as usize - ptr as usize },
2734 12usize,
2735 concat!(
2736 "Offset of field: ",
2737 stringify!(io_uring_buf),
2738 "::",
2739 stringify!(bid)
2740 )
2741 );
2742 assert_eq!(
2743 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2744 14usize,
2745 concat!(
2746 "Offset of field: ",
2747 stringify!(io_uring_buf),
2748 "::",
2749 stringify!(resv)
2750 )
2751 );
2752}
2753#[repr(C)]
2754pub struct io_uring_buf_ring {
2755 pub __bindgen_anon_1: io_uring_buf_ring__bindgen_ty_1,
2756}
2757#[repr(C)]
2758pub struct io_uring_buf_ring__bindgen_ty_1 {
2759 pub __bindgen_anon_1: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>,
2760 pub __bindgen_anon_2: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>,
2761 pub bindgen_union_field: [u64; 2usize],
2762}
2763#[repr(C)]
2764#[derive(Debug, Default, Copy, Clone)]
2765pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1 {
2766 pub resv1: __u64,
2767 pub resv2: __u32,
2768 pub resv3: __u16,
2769 pub tail: __u16,
2770}
2771#[test]
2772fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1() {
2773 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1> =
2774 ::core::mem::MaybeUninit::uninit();
2775 let ptr = UNINIT.as_ptr();
2776 assert_eq!(
2777 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>(),
2778 16usize,
2779 concat!(
2780 "Size of: ",
2781 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1)
2782 )
2783 );
2784 assert_eq!(
2785 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>(),
2786 8usize,
2787 concat!(
2788 "Alignment of ",
2789 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1)
2790 )
2791 );
2792 assert_eq!(
2793 unsafe { ::core::ptr::addr_of!((*ptr).resv1) as usize - ptr as usize },
2794 0usize,
2795 concat!(
2796 "Offset of field: ",
2797 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2798 "::",
2799 stringify!(resv1)
2800 )
2801 );
2802 assert_eq!(
2803 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2804 8usize,
2805 concat!(
2806 "Offset of field: ",
2807 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2808 "::",
2809 stringify!(resv2)
2810 )
2811 );
2812 assert_eq!(
2813 unsafe { ::core::ptr::addr_of!((*ptr).resv3) as usize - ptr as usize },
2814 12usize,
2815 concat!(
2816 "Offset of field: ",
2817 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2818 "::",
2819 stringify!(resv3)
2820 )
2821 );
2822 assert_eq!(
2823 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
2824 14usize,
2825 concat!(
2826 "Offset of field: ",
2827 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2828 "::",
2829 stringify!(tail)
2830 )
2831 );
2832}
2833#[repr(C)]
2834#[derive(Debug, Default)]
2835pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2 {
2836 pub __empty_bufs: io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
2837 pub bufs: __IncompleteArrayField<io_uring_buf>,
2838}
2839#[repr(C)]
2840#[derive(Debug, Default, Copy, Clone)]
2841pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {}
2842#[test]
2843fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1() {
2844 assert_eq!(
2845 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(),
2846 0usize,
2847 concat!(
2848 "Size of: ",
2849 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1)
2850 )
2851 );
2852 assert_eq!(
2853 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(),
2854 1usize,
2855 concat!(
2856 "Alignment of ",
2857 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1)
2858 )
2859 );
2860}
2861#[test]
2862fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2() {
2863 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2> =
2864 ::core::mem::MaybeUninit::uninit();
2865 let ptr = UNINIT.as_ptr();
2866 assert_eq!(
2867 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>(),
2868 0usize,
2869 concat!(
2870 "Size of: ",
2871 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2)
2872 )
2873 );
2874 assert_eq!(
2875 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>(),
2876 8usize,
2877 concat!(
2878 "Alignment of ",
2879 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2)
2880 )
2881 );
2882 assert_eq!(
2883 unsafe { ::core::ptr::addr_of!((*ptr).__empty_bufs) as usize - ptr as usize },
2884 0usize,
2885 concat!(
2886 "Offset of field: ",
2887 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2),
2888 "::",
2889 stringify!(__empty_bufs)
2890 )
2891 );
2892 assert_eq!(
2893 unsafe { ::core::ptr::addr_of!((*ptr).bufs) as usize - ptr as usize },
2894 0usize,
2895 concat!(
2896 "Offset of field: ",
2897 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2),
2898 "::",
2899 stringify!(bufs)
2900 )
2901 );
2902}
2903#[test]
2904fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1() {
2905 assert_eq!(
2906 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1>(),
2907 16usize,
2908 concat!("Size of: ", stringify!(io_uring_buf_ring__bindgen_ty_1))
2909 );
2910 assert_eq!(
2911 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1>(),
2912 8usize,
2913 concat!("Alignment of ", stringify!(io_uring_buf_ring__bindgen_ty_1))
2914 );
2915}
2916impl Default for io_uring_buf_ring__bindgen_ty_1 {
2917 fn default() -> Self {
2918 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2919 unsafe {
2920 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2921 s.assume_init()
2922 }
2923 }
2924}
2925#[test]
2926fn bindgen_test_layout_io_uring_buf_ring() {
2927 assert_eq!(
2928 ::core::mem::size_of::<io_uring_buf_ring>(),
2929 16usize,
2930 concat!("Size of: ", stringify!(io_uring_buf_ring))
2931 );
2932 assert_eq!(
2933 ::core::mem::align_of::<io_uring_buf_ring>(),
2934 8usize,
2935 concat!("Alignment of ", stringify!(io_uring_buf_ring))
2936 );
2937}
2938impl Default for io_uring_buf_ring {
2939 fn default() -> Self {
2940 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2941 unsafe {
2942 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2943 s.assume_init()
2944 }
2945 }
2946}
2947pub const IOU_PBUF_RING_MMAP: io_uring_register_pbuf_ring_flags = 1;
2948pub const IOU_PBUF_RING_INC: io_uring_register_pbuf_ring_flags = 2;
2949pub type io_uring_register_pbuf_ring_flags = libc::c_uint;
2950#[repr(C)]
2951#[derive(Debug, Default, Copy, Clone)]
2952pub struct io_uring_buf_reg {
2953 pub ring_addr: __u64,
2954 pub ring_entries: __u32,
2955 pub bgid: __u16,
2956 pub flags: __u16,
2957 pub resv: [__u64; 3usize],
2958}
2959#[test]
2960fn bindgen_test_layout_io_uring_buf_reg() {
2961 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_reg> = ::core::mem::MaybeUninit::uninit();
2962 let ptr = UNINIT.as_ptr();
2963 assert_eq!(
2964 ::core::mem::size_of::<io_uring_buf_reg>(),
2965 40usize,
2966 concat!("Size of: ", stringify!(io_uring_buf_reg))
2967 );
2968 assert_eq!(
2969 ::core::mem::align_of::<io_uring_buf_reg>(),
2970 8usize,
2971 concat!("Alignment of ", stringify!(io_uring_buf_reg))
2972 );
2973 assert_eq!(
2974 unsafe { ::core::ptr::addr_of!((*ptr).ring_addr) as usize - ptr as usize },
2975 0usize,
2976 concat!(
2977 "Offset of field: ",
2978 stringify!(io_uring_buf_reg),
2979 "::",
2980 stringify!(ring_addr)
2981 )
2982 );
2983 assert_eq!(
2984 unsafe { ::core::ptr::addr_of!((*ptr).ring_entries) as usize - ptr as usize },
2985 8usize,
2986 concat!(
2987 "Offset of field: ",
2988 stringify!(io_uring_buf_reg),
2989 "::",
2990 stringify!(ring_entries)
2991 )
2992 );
2993 assert_eq!(
2994 unsafe { ::core::ptr::addr_of!((*ptr).bgid) as usize - ptr as usize },
2995 12usize,
2996 concat!(
2997 "Offset of field: ",
2998 stringify!(io_uring_buf_reg),
2999 "::",
3000 stringify!(bgid)
3001 )
3002 );
3003 assert_eq!(
3004 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3005 14usize,
3006 concat!(
3007 "Offset of field: ",
3008 stringify!(io_uring_buf_reg),
3009 "::",
3010 stringify!(flags)
3011 )
3012 );
3013 assert_eq!(
3014 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
3015 16usize,
3016 concat!(
3017 "Offset of field: ",
3018 stringify!(io_uring_buf_reg),
3019 "::",
3020 stringify!(resv)
3021 )
3022 );
3023}
3024#[repr(C)]
3025#[derive(Debug, Default, Copy, Clone)]
3026pub struct io_uring_buf_status {
3027 pub buf_group: __u32,
3028 pub head: __u32,
3029 pub resv: [__u32; 8usize],
3030}
3031#[test]
3032fn bindgen_test_layout_io_uring_buf_status() {
3033 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_status> =
3034 ::core::mem::MaybeUninit::uninit();
3035 let ptr = UNINIT.as_ptr();
3036 assert_eq!(
3037 ::core::mem::size_of::<io_uring_buf_status>(),
3038 40usize,
3039 concat!("Size of: ", stringify!(io_uring_buf_status))
3040 );
3041 assert_eq!(
3042 ::core::mem::align_of::<io_uring_buf_status>(),
3043 4usize,
3044 concat!("Alignment of ", stringify!(io_uring_buf_status))
3045 );
3046 assert_eq!(
3047 unsafe { ::core::ptr::addr_of!((*ptr).buf_group) as usize - ptr as usize },
3048 0usize,
3049 concat!(
3050 "Offset of field: ",
3051 stringify!(io_uring_buf_status),
3052 "::",
3053 stringify!(buf_group)
3054 )
3055 );
3056 assert_eq!(
3057 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
3058 4usize,
3059 concat!(
3060 "Offset of field: ",
3061 stringify!(io_uring_buf_status),
3062 "::",
3063 stringify!(head)
3064 )
3065 );
3066 assert_eq!(
3067 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
3068 8usize,
3069 concat!(
3070 "Offset of field: ",
3071 stringify!(io_uring_buf_status),
3072 "::",
3073 stringify!(resv)
3074 )
3075 );
3076}
3077pub const IO_URING_NAPI_REGISTER_OP: io_uring_napi_op = 0;
3078pub const IO_URING_NAPI_STATIC_ADD_ID: io_uring_napi_op = 1;
3079pub const IO_URING_NAPI_STATIC_DEL_ID: io_uring_napi_op = 2;
3080pub type io_uring_napi_op = libc::c_uint;
3081pub const IO_URING_NAPI_TRACKING_DYNAMIC: io_uring_napi_tracking_strategy = 0;
3082pub const IO_URING_NAPI_TRACKING_STATIC: io_uring_napi_tracking_strategy = 1;
3083pub const IO_URING_NAPI_TRACKING_INACTIVE: io_uring_napi_tracking_strategy = 255;
3084pub type io_uring_napi_tracking_strategy = libc::c_uint;
3085#[repr(C)]
3086#[derive(Debug, Default, Copy, Clone)]
3087pub struct io_uring_napi {
3088 pub busy_poll_to: __u32,
3089 pub prefer_busy_poll: __u8,
3090 pub opcode: __u8,
3091 pub pad: [__u8; 2usize],
3092 pub op_param: __u32,
3093 pub resv: __u32,
3094}
3095#[test]
3096fn bindgen_test_layout_io_uring_napi() {
3097 const UNINIT: ::core::mem::MaybeUninit<io_uring_napi> = ::core::mem::MaybeUninit::uninit();
3098 let ptr = UNINIT.as_ptr();
3099 assert_eq!(
3100 ::core::mem::size_of::<io_uring_napi>(),
3101 16usize,
3102 concat!("Size of: ", stringify!(io_uring_napi))
3103 );
3104 assert_eq!(
3105 ::core::mem::align_of::<io_uring_napi>(),
3106 4usize,
3107 concat!("Alignment of ", stringify!(io_uring_napi))
3108 );
3109 assert_eq!(
3110 unsafe { ::core::ptr::addr_of!((*ptr).busy_poll_to) as usize - ptr as usize },
3111 0usize,
3112 concat!(
3113 "Offset of field: ",
3114 stringify!(io_uring_napi),
3115 "::",
3116 stringify!(busy_poll_to)
3117 )
3118 );
3119 assert_eq!(
3120 unsafe { ::core::ptr::addr_of!((*ptr).prefer_busy_poll) as usize - ptr as usize },
3121 4usize,
3122 concat!(
3123 "Offset of field: ",
3124 stringify!(io_uring_napi),
3125 "::",
3126 stringify!(prefer_busy_poll)
3127 )
3128 );
3129 assert_eq!(
3130 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
3131 5usize,
3132 concat!(
3133 "Offset of field: ",
3134 stringify!(io_uring_napi),
3135 "::",
3136 stringify!(opcode)
3137 )
3138 );
3139 assert_eq!(
3140 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
3141 6usize,
3142 concat!(
3143 "Offset of field: ",
3144 stringify!(io_uring_napi),
3145 "::",
3146 stringify!(pad)
3147 )
3148 );
3149 assert_eq!(
3150 unsafe { ::core::ptr::addr_of!((*ptr).op_param) as usize - ptr as usize },
3151 8usize,
3152 concat!(
3153 "Offset of field: ",
3154 stringify!(io_uring_napi),
3155 "::",
3156 stringify!(op_param)
3157 )
3158 );
3159 assert_eq!(
3160 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
3161 12usize,
3162 concat!(
3163 "Offset of field: ",
3164 stringify!(io_uring_napi),
3165 "::",
3166 stringify!(resv)
3167 )
3168 );
3169}
3170pub const IORING_RESTRICTION_REGISTER_OP: io_uring_register_restriction_op = 0;
3171pub const IORING_RESTRICTION_SQE_OP: io_uring_register_restriction_op = 1;
3172pub const IORING_RESTRICTION_SQE_FLAGS_ALLOWED: io_uring_register_restriction_op = 2;
3173pub const IORING_RESTRICTION_SQE_FLAGS_REQUIRED: io_uring_register_restriction_op = 3;
3174pub const IORING_RESTRICTION_LAST: io_uring_register_restriction_op = 4;
3175pub type io_uring_register_restriction_op = libc::c_uint;
3176pub const IORING_REG_WAIT_TS: _bindgen_ty_7 = 1;
3177pub type _bindgen_ty_7 = libc::c_uint;
3178#[repr(C)]
3179#[derive(Debug, Default, Copy, Clone)]
3180pub struct io_uring_reg_wait {
3181 pub ts: __kernel_timespec,
3182 pub min_wait_usec: __u32,
3183 pub flags: __u32,
3184 pub sigmask: __u64,
3185 pub sigmask_sz: __u32,
3186 pub pad: [__u32; 3usize],
3187 pub pad2: [__u64; 2usize],
3188}
3189#[test]
3190fn bindgen_test_layout_io_uring_reg_wait() {
3191 const UNINIT: ::core::mem::MaybeUninit<io_uring_reg_wait> = ::core::mem::MaybeUninit::uninit();
3192 let ptr = UNINIT.as_ptr();
3193 assert_eq!(
3194 ::core::mem::size_of::<io_uring_reg_wait>(),
3195 64usize,
3196 concat!("Size of: ", stringify!(io_uring_reg_wait))
3197 );
3198 assert_eq!(
3199 ::core::mem::align_of::<io_uring_reg_wait>(),
3200 8usize,
3201 concat!("Alignment of ", stringify!(io_uring_reg_wait))
3202 );
3203 assert_eq!(
3204 unsafe { ::core::ptr::addr_of!((*ptr).ts) as usize - ptr as usize },
3205 0usize,
3206 concat!(
3207 "Offset of field: ",
3208 stringify!(io_uring_reg_wait),
3209 "::",
3210 stringify!(ts)
3211 )
3212 );
3213 assert_eq!(
3214 unsafe { ::core::ptr::addr_of!((*ptr).min_wait_usec) as usize - ptr as usize },
3215 16usize,
3216 concat!(
3217 "Offset of field: ",
3218 stringify!(io_uring_reg_wait),
3219 "::",
3220 stringify!(min_wait_usec)
3221 )
3222 );
3223 assert_eq!(
3224 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3225 20usize,
3226 concat!(
3227 "Offset of field: ",
3228 stringify!(io_uring_reg_wait),
3229 "::",
3230 stringify!(flags)
3231 )
3232 );
3233 assert_eq!(
3234 unsafe { ::core::ptr::addr_of!((*ptr).sigmask) as usize - ptr as usize },
3235 24usize,
3236 concat!(
3237 "Offset of field: ",
3238 stringify!(io_uring_reg_wait),
3239 "::",
3240 stringify!(sigmask)
3241 )
3242 );
3243 assert_eq!(
3244 unsafe { ::core::ptr::addr_of!((*ptr).sigmask_sz) as usize - ptr as usize },
3245 32usize,
3246 concat!(
3247 "Offset of field: ",
3248 stringify!(io_uring_reg_wait),
3249 "::",
3250 stringify!(sigmask_sz)
3251 )
3252 );
3253 assert_eq!(
3254 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
3255 36usize,
3256 concat!(
3257 "Offset of field: ",
3258 stringify!(io_uring_reg_wait),
3259 "::",
3260 stringify!(pad)
3261 )
3262 );
3263 assert_eq!(
3264 unsafe { ::core::ptr::addr_of!((*ptr).pad2) as usize - ptr as usize },
3265 48usize,
3266 concat!(
3267 "Offset of field: ",
3268 stringify!(io_uring_reg_wait),
3269 "::",
3270 stringify!(pad2)
3271 )
3272 );
3273}
3274#[repr(C)]
3275#[derive(Debug, Default, Copy, Clone)]
3276pub struct io_uring_getevents_arg {
3277 pub sigmask: __u64,
3278 pub sigmask_sz: __u32,
3279 pub min_wait_usec: __u32,
3280 pub ts: __u64,
3281}
3282#[test]
3283fn bindgen_test_layout_io_uring_getevents_arg() {
3284 const UNINIT: ::core::mem::MaybeUninit<io_uring_getevents_arg> =
3285 ::core::mem::MaybeUninit::uninit();
3286 let ptr = UNINIT.as_ptr();
3287 assert_eq!(
3288 ::core::mem::size_of::<io_uring_getevents_arg>(),
3289 24usize,
3290 concat!("Size of: ", stringify!(io_uring_getevents_arg))
3291 );
3292 assert_eq!(
3293 ::core::mem::align_of::<io_uring_getevents_arg>(),
3294 8usize,
3295 concat!("Alignment of ", stringify!(io_uring_getevents_arg))
3296 );
3297 assert_eq!(
3298 unsafe { ::core::ptr::addr_of!((*ptr).sigmask) as usize - ptr as usize },
3299 0usize,
3300 concat!(
3301 "Offset of field: ",
3302 stringify!(io_uring_getevents_arg),
3303 "::",
3304 stringify!(sigmask)
3305 )
3306 );
3307 assert_eq!(
3308 unsafe { ::core::ptr::addr_of!((*ptr).sigmask_sz) as usize - ptr as usize },
3309 8usize,
3310 concat!(
3311 "Offset of field: ",
3312 stringify!(io_uring_getevents_arg),
3313 "::",
3314 stringify!(sigmask_sz)
3315 )
3316 );
3317 assert_eq!(
3318 unsafe { ::core::ptr::addr_of!((*ptr).min_wait_usec) as usize - ptr as usize },
3319 12usize,
3320 concat!(
3321 "Offset of field: ",
3322 stringify!(io_uring_getevents_arg),
3323 "::",
3324 stringify!(min_wait_usec)
3325 )
3326 );
3327 assert_eq!(
3328 unsafe { ::core::ptr::addr_of!((*ptr).ts) as usize - ptr as usize },
3329 16usize,
3330 concat!(
3331 "Offset of field: ",
3332 stringify!(io_uring_getevents_arg),
3333 "::",
3334 stringify!(ts)
3335 )
3336 );
3337}
3338#[repr(C)]
3339#[derive(Debug, Default, Copy, Clone)]
3340pub struct io_uring_sync_cancel_reg {
3341 pub addr: __u64,
3342 pub fd: __s32,
3343 pub flags: __u32,
3344 pub timeout: __kernel_timespec,
3345 pub opcode: __u8,
3346 pub pad: [__u8; 7usize],
3347 pub pad2: [__u64; 3usize],
3348}
3349#[test]
3350fn bindgen_test_layout_io_uring_sync_cancel_reg() {
3351 const UNINIT: ::core::mem::MaybeUninit<io_uring_sync_cancel_reg> =
3352 ::core::mem::MaybeUninit::uninit();
3353 let ptr = UNINIT.as_ptr();
3354 assert_eq!(
3355 ::core::mem::size_of::<io_uring_sync_cancel_reg>(),
3356 64usize,
3357 concat!("Size of: ", stringify!(io_uring_sync_cancel_reg))
3358 );
3359 assert_eq!(
3360 ::core::mem::align_of::<io_uring_sync_cancel_reg>(),
3361 8usize,
3362 concat!("Alignment of ", stringify!(io_uring_sync_cancel_reg))
3363 );
3364 assert_eq!(
3365 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
3366 0usize,
3367 concat!(
3368 "Offset of field: ",
3369 stringify!(io_uring_sync_cancel_reg),
3370 "::",
3371 stringify!(addr)
3372 )
3373 );
3374 assert_eq!(
3375 unsafe { ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
3376 8usize,
3377 concat!(
3378 "Offset of field: ",
3379 stringify!(io_uring_sync_cancel_reg),
3380 "::",
3381 stringify!(fd)
3382 )
3383 );
3384 assert_eq!(
3385 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3386 12usize,
3387 concat!(
3388 "Offset of field: ",
3389 stringify!(io_uring_sync_cancel_reg),
3390 "::",
3391 stringify!(flags)
3392 )
3393 );
3394 assert_eq!(
3395 unsafe { ::core::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
3396 16usize,
3397 concat!(
3398 "Offset of field: ",
3399 stringify!(io_uring_sync_cancel_reg),
3400 "::",
3401 stringify!(timeout)
3402 )
3403 );
3404 assert_eq!(
3405 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
3406 32usize,
3407 concat!(
3408 "Offset of field: ",
3409 stringify!(io_uring_sync_cancel_reg),
3410 "::",
3411 stringify!(opcode)
3412 )
3413 );
3414 assert_eq!(
3415 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
3416 33usize,
3417 concat!(
3418 "Offset of field: ",
3419 stringify!(io_uring_sync_cancel_reg),
3420 "::",
3421 stringify!(pad)
3422 )
3423 );
3424 assert_eq!(
3425 unsafe { ::core::ptr::addr_of!((*ptr).pad2) as usize - ptr as usize },
3426 40usize,
3427 concat!(
3428 "Offset of field: ",
3429 stringify!(io_uring_sync_cancel_reg),
3430 "::",
3431 stringify!(pad2)
3432 )
3433 );
3434}
3435#[repr(C)]
3436#[derive(Debug, Default, Copy, Clone)]
3437pub struct io_uring_file_index_range {
3438 pub off: __u32,
3439 pub len: __u32,
3440 pub resv: __u64,
3441}
3442#[test]
3443fn bindgen_test_layout_io_uring_file_index_range() {
3444 const UNINIT: ::core::mem::MaybeUninit<io_uring_file_index_range> =
3445 ::core::mem::MaybeUninit::uninit();
3446 let ptr = UNINIT.as_ptr();
3447 assert_eq!(
3448 ::core::mem::size_of::<io_uring_file_index_range>(),
3449 16usize,
3450 concat!("Size of: ", stringify!(io_uring_file_index_range))
3451 );
3452 assert_eq!(
3453 ::core::mem::align_of::<io_uring_file_index_range>(),
3454 8usize,
3455 concat!("Alignment of ", stringify!(io_uring_file_index_range))
3456 );
3457 assert_eq!(
3458 unsafe { ::core::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
3459 0usize,
3460 concat!(
3461 "Offset of field: ",
3462 stringify!(io_uring_file_index_range),
3463 "::",
3464 stringify!(off)
3465 )
3466 );
3467 assert_eq!(
3468 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
3469 4usize,
3470 concat!(
3471 "Offset of field: ",
3472 stringify!(io_uring_file_index_range),
3473 "::",
3474 stringify!(len)
3475 )
3476 );
3477 assert_eq!(
3478 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
3479 8usize,
3480 concat!(
3481 "Offset of field: ",
3482 stringify!(io_uring_file_index_range),
3483 "::",
3484 stringify!(resv)
3485 )
3486 );
3487}
3488#[repr(C)]
3489#[derive(Debug, Default, Copy, Clone)]
3490pub struct io_uring_recvmsg_out {
3491 pub namelen: __u32,
3492 pub controllen: __u32,
3493 pub payloadlen: __u32,
3494 pub flags: __u32,
3495}
3496#[test]
3497fn bindgen_test_layout_io_uring_recvmsg_out() {
3498 const UNINIT: ::core::mem::MaybeUninit<io_uring_recvmsg_out> =
3499 ::core::mem::MaybeUninit::uninit();
3500 let ptr = UNINIT.as_ptr();
3501 assert_eq!(
3502 ::core::mem::size_of::<io_uring_recvmsg_out>(),
3503 16usize,
3504 concat!("Size of: ", stringify!(io_uring_recvmsg_out))
3505 );
3506 assert_eq!(
3507 ::core::mem::align_of::<io_uring_recvmsg_out>(),
3508 4usize,
3509 concat!("Alignment of ", stringify!(io_uring_recvmsg_out))
3510 );
3511 assert_eq!(
3512 unsafe { ::core::ptr::addr_of!((*ptr).namelen) as usize - ptr as usize },
3513 0usize,
3514 concat!(
3515 "Offset of field: ",
3516 stringify!(io_uring_recvmsg_out),
3517 "::",
3518 stringify!(namelen)
3519 )
3520 );
3521 assert_eq!(
3522 unsafe { ::core::ptr::addr_of!((*ptr).controllen) as usize - ptr as usize },
3523 4usize,
3524 concat!(
3525 "Offset of field: ",
3526 stringify!(io_uring_recvmsg_out),
3527 "::",
3528 stringify!(controllen)
3529 )
3530 );
3531 assert_eq!(
3532 unsafe { ::core::ptr::addr_of!((*ptr).payloadlen) as usize - ptr as usize },
3533 8usize,
3534 concat!(
3535 "Offset of field: ",
3536 stringify!(io_uring_recvmsg_out),
3537 "::",
3538 stringify!(payloadlen)
3539 )
3540 );
3541 assert_eq!(
3542 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3543 12usize,
3544 concat!(
3545 "Offset of field: ",
3546 stringify!(io_uring_recvmsg_out),
3547 "::",
3548 stringify!(flags)
3549 )
3550 );
3551}
3552pub const SOCKET_URING_OP_SIOCINQ: io_uring_socket_op = 0;
3553pub const SOCKET_URING_OP_SIOCOUTQ: io_uring_socket_op = 1;
3554pub const SOCKET_URING_OP_GETSOCKOPT: io_uring_socket_op = 2;
3555pub const SOCKET_URING_OP_SETSOCKOPT: io_uring_socket_op = 3;
3556pub type io_uring_socket_op = libc::c_uint;
3557#[repr(C)]
3558#[derive(Debug, Default, Copy, Clone)]
3559pub struct io_uring_zcrx_rqe {
3560 pub off: __u64,
3561 pub len: __u32,
3562 pub __pad: __u32,
3563}
3564#[test]
3565fn bindgen_test_layout_io_uring_zcrx_rqe() {
3566 const UNINIT: ::core::mem::MaybeUninit<io_uring_zcrx_rqe> = ::core::mem::MaybeUninit::uninit();
3567 let ptr = UNINIT.as_ptr();
3568 assert_eq!(
3569 ::core::mem::size_of::<io_uring_zcrx_rqe>(),
3570 16usize,
3571 concat!("Size of: ", stringify!(io_uring_zcrx_rqe))
3572 );
3573 assert_eq!(
3574 ::core::mem::align_of::<io_uring_zcrx_rqe>(),
3575 8usize,
3576 concat!("Alignment of ", stringify!(io_uring_zcrx_rqe))
3577 );
3578 assert_eq!(
3579 unsafe { ::core::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
3580 0usize,
3581 concat!(
3582 "Offset of field: ",
3583 stringify!(io_uring_zcrx_rqe),
3584 "::",
3585 stringify!(off)
3586 )
3587 );
3588 assert_eq!(
3589 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
3590 8usize,
3591 concat!(
3592 "Offset of field: ",
3593 stringify!(io_uring_zcrx_rqe),
3594 "::",
3595 stringify!(len)
3596 )
3597 );
3598 assert_eq!(
3599 unsafe { ::core::ptr::addr_of!((*ptr).__pad) as usize - ptr as usize },
3600 12usize,
3601 concat!(
3602 "Offset of field: ",
3603 stringify!(io_uring_zcrx_rqe),
3604 "::",
3605 stringify!(__pad)
3606 )
3607 );
3608}
3609#[repr(C)]
3610#[derive(Debug, Default, Copy, Clone)]
3611pub struct io_uring_zcrx_cqe {
3612 pub off: __u64,
3613 pub __pad: __u64,
3614}
3615#[test]
3616fn bindgen_test_layout_io_uring_zcrx_cqe() {
3617 const UNINIT: ::core::mem::MaybeUninit<io_uring_zcrx_cqe> = ::core::mem::MaybeUninit::uninit();
3618 let ptr = UNINIT.as_ptr();
3619 assert_eq!(
3620 ::core::mem::size_of::<io_uring_zcrx_cqe>(),
3621 16usize,
3622 concat!("Size of: ", stringify!(io_uring_zcrx_cqe))
3623 );
3624 assert_eq!(
3625 ::core::mem::align_of::<io_uring_zcrx_cqe>(),
3626 8usize,
3627 concat!("Alignment of ", stringify!(io_uring_zcrx_cqe))
3628 );
3629 assert_eq!(
3630 unsafe { ::core::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
3631 0usize,
3632 concat!(
3633 "Offset of field: ",
3634 stringify!(io_uring_zcrx_cqe),
3635 "::",
3636 stringify!(off)
3637 )
3638 );
3639 assert_eq!(
3640 unsafe { ::core::ptr::addr_of!((*ptr).__pad) as usize - ptr as usize },
3641 8usize,
3642 concat!(
3643 "Offset of field: ",
3644 stringify!(io_uring_zcrx_cqe),
3645 "::",
3646 stringify!(__pad)
3647 )
3648 );
3649}
3650#[repr(C)]
3651#[derive(Debug, Default, Copy, Clone)]
3652pub struct io_uring_zcrx_offsets {
3653 pub head: __u32,
3654 pub tail: __u32,
3655 pub rqes: __u32,
3656 pub __resv2: __u32,
3657 pub __resv: [__u64; 2usize],
3658}
3659#[test]
3660fn bindgen_test_layout_io_uring_zcrx_offsets() {
3661 const UNINIT: ::core::mem::MaybeUninit<io_uring_zcrx_offsets> =
3662 ::core::mem::MaybeUninit::uninit();
3663 let ptr = UNINIT.as_ptr();
3664 assert_eq!(
3665 ::core::mem::size_of::<io_uring_zcrx_offsets>(),
3666 32usize,
3667 concat!("Size of: ", stringify!(io_uring_zcrx_offsets))
3668 );
3669 assert_eq!(
3670 ::core::mem::align_of::<io_uring_zcrx_offsets>(),
3671 8usize,
3672 concat!("Alignment of ", stringify!(io_uring_zcrx_offsets))
3673 );
3674 assert_eq!(
3675 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
3676 0usize,
3677 concat!(
3678 "Offset of field: ",
3679 stringify!(io_uring_zcrx_offsets),
3680 "::",
3681 stringify!(head)
3682 )
3683 );
3684 assert_eq!(
3685 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
3686 4usize,
3687 concat!(
3688 "Offset of field: ",
3689 stringify!(io_uring_zcrx_offsets),
3690 "::",
3691 stringify!(tail)
3692 )
3693 );
3694 assert_eq!(
3695 unsafe { ::core::ptr::addr_of!((*ptr).rqes) as usize - ptr as usize },
3696 8usize,
3697 concat!(
3698 "Offset of field: ",
3699 stringify!(io_uring_zcrx_offsets),
3700 "::",
3701 stringify!(rqes)
3702 )
3703 );
3704 assert_eq!(
3705 unsafe { ::core::ptr::addr_of!((*ptr).__resv2) as usize - ptr as usize },
3706 12usize,
3707 concat!(
3708 "Offset of field: ",
3709 stringify!(io_uring_zcrx_offsets),
3710 "::",
3711 stringify!(__resv2)
3712 )
3713 );
3714 assert_eq!(
3715 unsafe { ::core::ptr::addr_of!((*ptr).__resv) as usize - ptr as usize },
3716 16usize,
3717 concat!(
3718 "Offset of field: ",
3719 stringify!(io_uring_zcrx_offsets),
3720 "::",
3721 stringify!(__resv)
3722 )
3723 );
3724}
3725pub const IORING_ZCRX_AREA_DMABUF: io_uring_zcrx_area_flags = 1;
3726pub type io_uring_zcrx_area_flags = libc::c_uint;
3727#[repr(C)]
3728#[derive(Debug, Default, Copy, Clone)]
3729pub struct io_uring_zcrx_area_reg {
3730 pub addr: __u64,
3731 pub len: __u64,
3732 pub rq_area_token: __u64,
3733 pub flags: __u32,
3734 pub dmabuf_fd: __u32,
3735 pub __resv2: [__u64; 2usize],
3736}
3737#[test]
3738fn bindgen_test_layout_io_uring_zcrx_area_reg() {
3739 const UNINIT: ::core::mem::MaybeUninit<io_uring_zcrx_area_reg> =
3740 ::core::mem::MaybeUninit::uninit();
3741 let ptr = UNINIT.as_ptr();
3742 assert_eq!(
3743 ::core::mem::size_of::<io_uring_zcrx_area_reg>(),
3744 48usize,
3745 concat!("Size of: ", stringify!(io_uring_zcrx_area_reg))
3746 );
3747 assert_eq!(
3748 ::core::mem::align_of::<io_uring_zcrx_area_reg>(),
3749 8usize,
3750 concat!("Alignment of ", stringify!(io_uring_zcrx_area_reg))
3751 );
3752 assert_eq!(
3753 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
3754 0usize,
3755 concat!(
3756 "Offset of field: ",
3757 stringify!(io_uring_zcrx_area_reg),
3758 "::",
3759 stringify!(addr)
3760 )
3761 );
3762 assert_eq!(
3763 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
3764 8usize,
3765 concat!(
3766 "Offset of field: ",
3767 stringify!(io_uring_zcrx_area_reg),
3768 "::",
3769 stringify!(len)
3770 )
3771 );
3772 assert_eq!(
3773 unsafe { ::core::ptr::addr_of!((*ptr).rq_area_token) as usize - ptr as usize },
3774 16usize,
3775 concat!(
3776 "Offset of field: ",
3777 stringify!(io_uring_zcrx_area_reg),
3778 "::",
3779 stringify!(rq_area_token)
3780 )
3781 );
3782 assert_eq!(
3783 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3784 24usize,
3785 concat!(
3786 "Offset of field: ",
3787 stringify!(io_uring_zcrx_area_reg),
3788 "::",
3789 stringify!(flags)
3790 )
3791 );
3792 assert_eq!(
3793 unsafe { ::core::ptr::addr_of!((*ptr).dmabuf_fd) as usize - ptr as usize },
3794 28usize,
3795 concat!(
3796 "Offset of field: ",
3797 stringify!(io_uring_zcrx_area_reg),
3798 "::",
3799 stringify!(dmabuf_fd)
3800 )
3801 );
3802 assert_eq!(
3803 unsafe { ::core::ptr::addr_of!((*ptr).__resv2) as usize - ptr as usize },
3804 32usize,
3805 concat!(
3806 "Offset of field: ",
3807 stringify!(io_uring_zcrx_area_reg),
3808 "::",
3809 stringify!(__resv2)
3810 )
3811 );
3812}
3813#[repr(C)]
3814#[derive(Debug, Default, Copy, Clone)]
3815pub struct io_uring_zcrx_ifq_reg {
3816 pub if_idx: __u32,
3817 pub if_rxq: __u32,
3818 pub rq_entries: __u32,
3819 pub flags: __u32,
3820 pub area_ptr: __u64,
3821 pub region_ptr: __u64,
3822 pub offsets: io_uring_zcrx_offsets,
3823 pub zcrx_id: __u32,
3824 pub __resv2: __u32,
3825 pub __resv: [__u64; 3usize],
3826}
3827#[test]
3828fn bindgen_test_layout_io_uring_zcrx_ifq_reg() {
3829 const UNINIT: ::core::mem::MaybeUninit<io_uring_zcrx_ifq_reg> =
3830 ::core::mem::MaybeUninit::uninit();
3831 let ptr = UNINIT.as_ptr();
3832 assert_eq!(
3833 ::core::mem::size_of::<io_uring_zcrx_ifq_reg>(),
3834 96usize,
3835 concat!("Size of: ", stringify!(io_uring_zcrx_ifq_reg))
3836 );
3837 assert_eq!(
3838 ::core::mem::align_of::<io_uring_zcrx_ifq_reg>(),
3839 8usize,
3840 concat!("Alignment of ", stringify!(io_uring_zcrx_ifq_reg))
3841 );
3842 assert_eq!(
3843 unsafe { ::core::ptr::addr_of!((*ptr).if_idx) as usize - ptr as usize },
3844 0usize,
3845 concat!(
3846 "Offset of field: ",
3847 stringify!(io_uring_zcrx_ifq_reg),
3848 "::",
3849 stringify!(if_idx)
3850 )
3851 );
3852 assert_eq!(
3853 unsafe { ::core::ptr::addr_of!((*ptr).if_rxq) as usize - ptr as usize },
3854 4usize,
3855 concat!(
3856 "Offset of field: ",
3857 stringify!(io_uring_zcrx_ifq_reg),
3858 "::",
3859 stringify!(if_rxq)
3860 )
3861 );
3862 assert_eq!(
3863 unsafe { ::core::ptr::addr_of!((*ptr).rq_entries) as usize - ptr as usize },
3864 8usize,
3865 concat!(
3866 "Offset of field: ",
3867 stringify!(io_uring_zcrx_ifq_reg),
3868 "::",
3869 stringify!(rq_entries)
3870 )
3871 );
3872 assert_eq!(
3873 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3874 12usize,
3875 concat!(
3876 "Offset of field: ",
3877 stringify!(io_uring_zcrx_ifq_reg),
3878 "::",
3879 stringify!(flags)
3880 )
3881 );
3882 assert_eq!(
3883 unsafe { ::core::ptr::addr_of!((*ptr).area_ptr) as usize - ptr as usize },
3884 16usize,
3885 concat!(
3886 "Offset of field: ",
3887 stringify!(io_uring_zcrx_ifq_reg),
3888 "::",
3889 stringify!(area_ptr)
3890 )
3891 );
3892 assert_eq!(
3893 unsafe { ::core::ptr::addr_of!((*ptr).region_ptr) as usize - ptr as usize },
3894 24usize,
3895 concat!(
3896 "Offset of field: ",
3897 stringify!(io_uring_zcrx_ifq_reg),
3898 "::",
3899 stringify!(region_ptr)
3900 )
3901 );
3902 assert_eq!(
3903 unsafe { ::core::ptr::addr_of!((*ptr).offsets) as usize - ptr as usize },
3904 32usize,
3905 concat!(
3906 "Offset of field: ",
3907 stringify!(io_uring_zcrx_ifq_reg),
3908 "::",
3909 stringify!(offsets)
3910 )
3911 );
3912 assert_eq!(
3913 unsafe { ::core::ptr::addr_of!((*ptr).zcrx_id) as usize - ptr as usize },
3914 64usize,
3915 concat!(
3916 "Offset of field: ",
3917 stringify!(io_uring_zcrx_ifq_reg),
3918 "::",
3919 stringify!(zcrx_id)
3920 )
3921 );
3922 assert_eq!(
3923 unsafe { ::core::ptr::addr_of!((*ptr).__resv2) as usize - ptr as usize },
3924 68usize,
3925 concat!(
3926 "Offset of field: ",
3927 stringify!(io_uring_zcrx_ifq_reg),
3928 "::",
3929 stringify!(__resv2)
3930 )
3931 );
3932 assert_eq!(
3933 unsafe { ::core::ptr::addr_of!((*ptr).__resv) as usize - ptr as usize },
3934 72usize,
3935 concat!(
3936 "Offset of field: ",
3937 stringify!(io_uring_zcrx_ifq_reg),
3938 "::",
3939 stringify!(__resv)
3940 )
3941 );
3942}
3943#[doc = " struct futex_waitv - A waiter for vectorized wait\n @val:\tExpected value at uaddr\n @uaddr:\tUser address to wait on\n @flags:\tFlags for this waiter\n @__reserved:\tReserved member to preserve data alignment. Should be 0."]
3944#[repr(C)]
3945#[derive(Debug, Default, Copy, Clone)]
3946pub struct futex_waitv {
3947 pub val: __u64,
3948 pub uaddr: __u64,
3949 pub flags: __u32,
3950 pub __reserved: __u32,
3951}
3952#[test]
3953fn bindgen_test_layout_futex_waitv() {
3954 const UNINIT: ::core::mem::MaybeUninit<futex_waitv> = ::core::mem::MaybeUninit::uninit();
3955 let ptr = UNINIT.as_ptr();
3956 assert_eq!(
3957 ::core::mem::size_of::<futex_waitv>(),
3958 24usize,
3959 concat!("Size of: ", stringify!(futex_waitv))
3960 );
3961 assert_eq!(
3962 ::core::mem::align_of::<futex_waitv>(),
3963 8usize,
3964 concat!("Alignment of ", stringify!(futex_waitv))
3965 );
3966 assert_eq!(
3967 unsafe { ::core::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
3968 0usize,
3969 concat!(
3970 "Offset of field: ",
3971 stringify!(futex_waitv),
3972 "::",
3973 stringify!(val)
3974 )
3975 );
3976 assert_eq!(
3977 unsafe { ::core::ptr::addr_of!((*ptr).uaddr) as usize - ptr as usize },
3978 8usize,
3979 concat!(
3980 "Offset of field: ",
3981 stringify!(futex_waitv),
3982 "::",
3983 stringify!(uaddr)
3984 )
3985 );
3986 assert_eq!(
3987 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3988 16usize,
3989 concat!(
3990 "Offset of field: ",
3991 stringify!(futex_waitv),
3992 "::",
3993 stringify!(flags)
3994 )
3995 );
3996 assert_eq!(
3997 unsafe { ::core::ptr::addr_of!((*ptr).__reserved) as usize - ptr as usize },
3998 20usize,
3999 concat!(
4000 "Offset of field: ",
4001 stringify!(futex_waitv),
4002 "::",
4003 stringify!(__reserved)
4004 )
4005 );
4006}