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