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_FILE_INDEX_ALLOC: i32 = -1;
80pub const IORING_SETUP_IOPOLL: u32 = 1;
81pub const IORING_SETUP_SQPOLL: u32 = 2;
82pub const IORING_SETUP_SQ_AFF: u32 = 4;
83pub const IORING_SETUP_CQSIZE: u32 = 8;
84pub const IORING_SETUP_CLAMP: u32 = 16;
85pub const IORING_SETUP_ATTACH_WQ: u32 = 32;
86pub const IORING_SETUP_R_DISABLED: u32 = 64;
87pub const IORING_SETUP_SUBMIT_ALL: u32 = 128;
88pub const IORING_SETUP_COOP_TASKRUN: u32 = 256;
89pub const IORING_SETUP_TASKRUN_FLAG: u32 = 512;
90pub const IORING_SETUP_SQE128: u32 = 1024;
91pub const IORING_SETUP_CQE32: u32 = 2048;
92pub const IORING_SETUP_SINGLE_ISSUER: u32 = 4096;
93pub const IORING_SETUP_DEFER_TASKRUN: u32 = 8192;
94pub const IORING_SETUP_NO_MMAP: u32 = 16384;
95pub const IORING_SETUP_REGISTERED_FD_ONLY: u32 = 32768;
96pub const IORING_SETUP_NO_SQARRAY: u32 = 65536;
97pub const IORING_URING_CMD_FIXED: u32 = 1;
98pub const IORING_URING_CMD_MASK: u32 = 1;
99pub const IORING_FSYNC_DATASYNC: u32 = 1;
100pub const IORING_TIMEOUT_ABS: u32 = 1;
101pub const IORING_TIMEOUT_UPDATE: u32 = 2;
102pub const IORING_TIMEOUT_BOOTTIME: u32 = 4;
103pub const IORING_TIMEOUT_REALTIME: u32 = 8;
104pub const IORING_LINK_TIMEOUT_UPDATE: u32 = 16;
105pub const IORING_TIMEOUT_ETIME_SUCCESS: u32 = 32;
106pub const IORING_TIMEOUT_MULTISHOT: u32 = 64;
107pub const IORING_TIMEOUT_CLOCK_MASK: u32 = 12;
108pub const IORING_TIMEOUT_UPDATE_MASK: u32 = 18;
109pub const SPLICE_F_FD_IN_FIXED: u32 = 2147483648;
110pub const IORING_POLL_ADD_MULTI: u32 = 1;
111pub const IORING_POLL_UPDATE_EVENTS: u32 = 2;
112pub const IORING_POLL_UPDATE_USER_DATA: u32 = 4;
113pub const IORING_POLL_ADD_LEVEL: u32 = 8;
114pub const IORING_ASYNC_CANCEL_ALL: u32 = 1;
115pub const IORING_ASYNC_CANCEL_FD: u32 = 2;
116pub const IORING_ASYNC_CANCEL_ANY: u32 = 4;
117pub const IORING_ASYNC_CANCEL_FD_FIXED: u32 = 8;
118pub const IORING_ASYNC_CANCEL_USERDATA: u32 = 16;
119pub const IORING_ASYNC_CANCEL_OP: u32 = 32;
120pub const IORING_RECVSEND_POLL_FIRST: u32 = 1;
121pub const IORING_RECV_MULTISHOT: u32 = 2;
122pub const IORING_RECVSEND_FIXED_BUF: u32 = 4;
123pub const IORING_SEND_ZC_REPORT_USAGE: u32 = 8;
124pub const IORING_RECVSEND_BUNDLE: u32 = 16;
125pub const IORING_NOTIF_USAGE_ZC_COPIED: u32 = 2147483648;
126pub const IORING_ACCEPT_MULTISHOT: u32 = 1;
127pub const IORING_ACCEPT_DONTWAIT: u32 = 2;
128pub const IORING_ACCEPT_POLL_FIRST: u32 = 4;
129pub const IORING_MSG_RING_CQE_SKIP: u32 = 1;
130pub const IORING_MSG_RING_FLAGS_PASS: u32 = 2;
131pub const IORING_FIXED_FD_NO_CLOEXEC: u32 = 1;
132pub const IORING_NOP_INJECT_RESULT: u32 = 1;
133pub const IORING_CQE_F_BUFFER: u32 = 1;
134pub const IORING_CQE_F_MORE: u32 = 2;
135pub const IORING_CQE_F_SOCK_NONEMPTY: u32 = 4;
136pub const IORING_CQE_F_NOTIF: u32 = 8;
137pub const IORING_CQE_BUFFER_SHIFT: u32 = 16;
138pub const IORING_OFF_SQ_RING: u32 = 0;
139pub const IORING_OFF_CQ_RING: u32 = 134217728;
140pub const IORING_OFF_SQES: u32 = 268435456;
141pub const IORING_OFF_PBUF_RING: u32 = 2147483648;
142pub const IORING_OFF_PBUF_SHIFT: u32 = 16;
143pub const IORING_OFF_MMAP_MASK: u32 = 4160749568;
144pub const IORING_SQ_NEED_WAKEUP: u32 = 1;
145pub const IORING_SQ_CQ_OVERFLOW: u32 = 2;
146pub const IORING_SQ_TASKRUN: u32 = 4;
147pub const IORING_CQ_EVENTFD_DISABLED: u32 = 1;
148pub const IORING_ENTER_GETEVENTS: u32 = 1;
149pub const IORING_ENTER_SQ_WAKEUP: u32 = 2;
150pub const IORING_ENTER_SQ_WAIT: u32 = 4;
151pub const IORING_ENTER_EXT_ARG: u32 = 8;
152pub const IORING_ENTER_REGISTERED_RING: u32 = 16;
153pub const IORING_FEAT_SINGLE_MMAP: u32 = 1;
154pub const IORING_FEAT_NODROP: u32 = 2;
155pub const IORING_FEAT_SUBMIT_STABLE: u32 = 4;
156pub const IORING_FEAT_RW_CUR_POS: u32 = 8;
157pub const IORING_FEAT_CUR_PERSONALITY: u32 = 16;
158pub const IORING_FEAT_FAST_POLL: u32 = 32;
159pub const IORING_FEAT_POLL_32BITS: u32 = 64;
160pub const IORING_FEAT_SQPOLL_NONFIXED: u32 = 128;
161pub const IORING_FEAT_EXT_ARG: u32 = 256;
162pub const IORING_FEAT_NATIVE_WORKERS: u32 = 512;
163pub const IORING_FEAT_RSRC_TAGS: u32 = 1024;
164pub const IORING_FEAT_CQE_SKIP: u32 = 2048;
165pub const IORING_FEAT_LINKED_FILE: u32 = 4096;
166pub const IORING_FEAT_REG_REG_RING: u32 = 8192;
167pub const IORING_FEAT_RECVSEND_BUNDLE: u32 = 16384;
168pub const IORING_RSRC_REGISTER_SPARSE: u32 = 1;
169pub const IORING_REGISTER_FILES_SKIP: i32 = -2;
170pub const IO_URING_OP_SUPPORTED: u32 = 1;
171pub type __u8 = libc::c_uchar;
172pub type __u16 = libc::c_ushort;
173pub type __s32 = libc::c_int;
174pub type __u32 = libc::c_uint;
175pub type __u64 = libc::c_ulonglong;
176pub type __kernel_time64_t = libc::c_longlong;
177#[repr(C)]
178#[derive(Debug, Default, Copy, Clone)]
179pub struct __kernel_timespec {
180 pub tv_sec: __kernel_time64_t,
181 pub tv_nsec: libc::c_longlong,
182}
183#[test]
184fn bindgen_test_layout___kernel_timespec() {
185 const UNINIT: ::core::mem::MaybeUninit<__kernel_timespec> = ::core::mem::MaybeUninit::uninit();
186 let ptr = UNINIT.as_ptr();
187 assert_eq!(
188 ::core::mem::size_of::<__kernel_timespec>(),
189 16usize,
190 concat!("Size of: ", stringify!(__kernel_timespec))
191 );
192 assert_eq!(
193 ::core::mem::align_of::<__kernel_timespec>(),
194 8usize,
195 concat!("Alignment of ", stringify!(__kernel_timespec))
196 );
197 assert_eq!(
198 unsafe { ::core::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
199 0usize,
200 concat!(
201 "Offset of field: ",
202 stringify!(__kernel_timespec),
203 "::",
204 stringify!(tv_sec)
205 )
206 );
207 assert_eq!(
208 unsafe { ::core::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
209 8usize,
210 concat!(
211 "Offset of field: ",
212 stringify!(__kernel_timespec),
213 "::",
214 stringify!(tv_nsec)
215 )
216 );
217}
218#[repr(C)]
219#[derive(Debug, Default, Copy, Clone)]
220pub struct open_how {
221 pub flags: __u64,
222 pub mode: __u64,
223 pub resolve: __u64,
224}
225#[test]
226fn bindgen_test_layout_open_how() {
227 const UNINIT: ::core::mem::MaybeUninit<open_how> = ::core::mem::MaybeUninit::uninit();
228 let ptr = UNINIT.as_ptr();
229 assert_eq!(
230 ::core::mem::size_of::<open_how>(),
231 24usize,
232 concat!("Size of: ", stringify!(open_how))
233 );
234 assert_eq!(
235 ::core::mem::align_of::<open_how>(),
236 8usize,
237 concat!("Alignment of ", stringify!(open_how))
238 );
239 assert_eq!(
240 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
241 0usize,
242 concat!(
243 "Offset of field: ",
244 stringify!(open_how),
245 "::",
246 stringify!(flags)
247 )
248 );
249 assert_eq!(
250 unsafe { ::core::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
251 8usize,
252 concat!(
253 "Offset of field: ",
254 stringify!(open_how),
255 "::",
256 stringify!(mode)
257 )
258 );
259 assert_eq!(
260 unsafe { ::core::ptr::addr_of!((*ptr).resolve) as usize - ptr as usize },
261 16usize,
262 concat!(
263 "Offset of field: ",
264 stringify!(open_how),
265 "::",
266 stringify!(resolve)
267 )
268 );
269}
270pub type __kernel_rwf_t = libc::c_int;
271#[repr(C)]
272pub struct io_uring_sqe {
273 pub opcode: __u8,
274 pub flags: __u8,
275 pub ioprio: __u16,
276 pub fd: __s32,
277 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1,
278 pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_2,
279 pub len: __u32,
280 pub __bindgen_anon_3: io_uring_sqe__bindgen_ty_3,
281 pub user_data: __u64,
282 pub __bindgen_anon_4: io_uring_sqe__bindgen_ty_4,
283 pub personality: __u16,
284 pub __bindgen_anon_5: io_uring_sqe__bindgen_ty_5,
285 pub __bindgen_anon_6: io_uring_sqe__bindgen_ty_6,
286}
287#[repr(C)]
288#[derive(Copy, Clone)]
289pub union io_uring_sqe__bindgen_ty_1 {
290 pub off: __u64,
291 pub addr2: __u64,
292 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1__bindgen_ty_1,
293}
294#[repr(C)]
295#[derive(Debug, Default, Copy, Clone)]
296pub struct io_uring_sqe__bindgen_ty_1__bindgen_ty_1 {
297 pub cmd_op: __u32,
298 pub __pad1: __u32,
299}
300#[test]
301fn bindgen_test_layout_io_uring_sqe__bindgen_ty_1__bindgen_ty_1() {
302 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_1__bindgen_ty_1> =
303 ::core::mem::MaybeUninit::uninit();
304 let ptr = UNINIT.as_ptr();
305 assert_eq!(
306 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_1__bindgen_ty_1>(),
307 8usize,
308 concat!(
309 "Size of: ",
310 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1)
311 )
312 );
313 assert_eq!(
314 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_1__bindgen_ty_1>(),
315 4usize,
316 concat!(
317 "Alignment of ",
318 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1)
319 )
320 );
321 assert_eq!(
322 unsafe { ::core::ptr::addr_of!((*ptr).cmd_op) as usize - ptr as usize },
323 0usize,
324 concat!(
325 "Offset of field: ",
326 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1),
327 "::",
328 stringify!(cmd_op)
329 )
330 );
331 assert_eq!(
332 unsafe { ::core::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
333 4usize,
334 concat!(
335 "Offset of field: ",
336 stringify!(io_uring_sqe__bindgen_ty_1__bindgen_ty_1),
337 "::",
338 stringify!(__pad1)
339 )
340 );
341}
342#[test]
343fn bindgen_test_layout_io_uring_sqe__bindgen_ty_1() {
344 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_1> =
345 ::core::mem::MaybeUninit::uninit();
346 let ptr = UNINIT.as_ptr();
347 assert_eq!(
348 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_1>(),
349 8usize,
350 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_1))
351 );
352 assert_eq!(
353 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_1>(),
354 8usize,
355 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_1))
356 );
357 assert_eq!(
358 unsafe { ::core::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
359 0usize,
360 concat!(
361 "Offset of field: ",
362 stringify!(io_uring_sqe__bindgen_ty_1),
363 "::",
364 stringify!(off)
365 )
366 );
367 assert_eq!(
368 unsafe { ::core::ptr::addr_of!((*ptr).addr2) as usize - ptr as usize },
369 0usize,
370 concat!(
371 "Offset of field: ",
372 stringify!(io_uring_sqe__bindgen_ty_1),
373 "::",
374 stringify!(addr2)
375 )
376 );
377}
378impl Default for io_uring_sqe__bindgen_ty_1 {
379 fn default() -> Self {
380 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
381 unsafe {
382 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
383 s.assume_init()
384 }
385 }
386}
387#[repr(C)]
388#[derive(Copy, Clone)]
389pub union io_uring_sqe__bindgen_ty_2 {
390 pub addr: __u64,
391 pub splice_off_in: __u64,
392 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_2__bindgen_ty_1,
393}
394#[repr(C)]
395#[derive(Debug, Default, Copy, Clone)]
396pub struct io_uring_sqe__bindgen_ty_2__bindgen_ty_1 {
397 pub level: __u32,
398 pub optname: __u32,
399}
400#[test]
401fn bindgen_test_layout_io_uring_sqe__bindgen_ty_2__bindgen_ty_1() {
402 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_2__bindgen_ty_1> =
403 ::core::mem::MaybeUninit::uninit();
404 let ptr = UNINIT.as_ptr();
405 assert_eq!(
406 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_2__bindgen_ty_1>(),
407 8usize,
408 concat!(
409 "Size of: ",
410 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1)
411 )
412 );
413 assert_eq!(
414 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_2__bindgen_ty_1>(),
415 4usize,
416 concat!(
417 "Alignment of ",
418 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1)
419 )
420 );
421 assert_eq!(
422 unsafe { ::core::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
423 0usize,
424 concat!(
425 "Offset of field: ",
426 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1),
427 "::",
428 stringify!(level)
429 )
430 );
431 assert_eq!(
432 unsafe { ::core::ptr::addr_of!((*ptr).optname) as usize - ptr as usize },
433 4usize,
434 concat!(
435 "Offset of field: ",
436 stringify!(io_uring_sqe__bindgen_ty_2__bindgen_ty_1),
437 "::",
438 stringify!(optname)
439 )
440 );
441}
442#[test]
443fn bindgen_test_layout_io_uring_sqe__bindgen_ty_2() {
444 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_2> =
445 ::core::mem::MaybeUninit::uninit();
446 let ptr = UNINIT.as_ptr();
447 assert_eq!(
448 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_2>(),
449 8usize,
450 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_2))
451 );
452 assert_eq!(
453 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_2>(),
454 8usize,
455 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_2))
456 );
457 assert_eq!(
458 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
459 0usize,
460 concat!(
461 "Offset of field: ",
462 stringify!(io_uring_sqe__bindgen_ty_2),
463 "::",
464 stringify!(addr)
465 )
466 );
467 assert_eq!(
468 unsafe { ::core::ptr::addr_of!((*ptr).splice_off_in) as usize - ptr as usize },
469 0usize,
470 concat!(
471 "Offset of field: ",
472 stringify!(io_uring_sqe__bindgen_ty_2),
473 "::",
474 stringify!(splice_off_in)
475 )
476 );
477}
478impl Default for io_uring_sqe__bindgen_ty_2 {
479 fn default() -> Self {
480 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
481 unsafe {
482 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
483 s.assume_init()
484 }
485 }
486}
487#[repr(C)]
488#[derive(Copy, Clone)]
489pub union io_uring_sqe__bindgen_ty_3 {
490 pub rw_flags: __kernel_rwf_t,
491 pub fsync_flags: __u32,
492 pub poll_events: __u16,
493 pub poll32_events: __u32,
494 pub sync_range_flags: __u32,
495 pub msg_flags: __u32,
496 pub timeout_flags: __u32,
497 pub accept_flags: __u32,
498 pub cancel_flags: __u32,
499 pub open_flags: __u32,
500 pub statx_flags: __u32,
501 pub fadvise_advice: __u32,
502 pub splice_flags: __u32,
503 pub rename_flags: __u32,
504 pub unlink_flags: __u32,
505 pub hardlink_flags: __u32,
506 pub xattr_flags: __u32,
507 pub msg_ring_flags: __u32,
508 pub uring_cmd_flags: __u32,
509 pub waitid_flags: __u32,
510 pub futex_flags: __u32,
511 pub install_fd_flags: __u32,
512 pub nop_flags: __u32,
513}
514#[test]
515fn bindgen_test_layout_io_uring_sqe__bindgen_ty_3() {
516 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_3> =
517 ::core::mem::MaybeUninit::uninit();
518 let ptr = UNINIT.as_ptr();
519 assert_eq!(
520 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_3>(),
521 4usize,
522 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_3))
523 );
524 assert_eq!(
525 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_3>(),
526 4usize,
527 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_3))
528 );
529 assert_eq!(
530 unsafe { ::core::ptr::addr_of!((*ptr).rw_flags) as usize - ptr as usize },
531 0usize,
532 concat!(
533 "Offset of field: ",
534 stringify!(io_uring_sqe__bindgen_ty_3),
535 "::",
536 stringify!(rw_flags)
537 )
538 );
539 assert_eq!(
540 unsafe { ::core::ptr::addr_of!((*ptr).fsync_flags) as usize - ptr as usize },
541 0usize,
542 concat!(
543 "Offset of field: ",
544 stringify!(io_uring_sqe__bindgen_ty_3),
545 "::",
546 stringify!(fsync_flags)
547 )
548 );
549 assert_eq!(
550 unsafe { ::core::ptr::addr_of!((*ptr).poll_events) as usize - ptr as usize },
551 0usize,
552 concat!(
553 "Offset of field: ",
554 stringify!(io_uring_sqe__bindgen_ty_3),
555 "::",
556 stringify!(poll_events)
557 )
558 );
559 assert_eq!(
560 unsafe { ::core::ptr::addr_of!((*ptr).poll32_events) as usize - ptr as usize },
561 0usize,
562 concat!(
563 "Offset of field: ",
564 stringify!(io_uring_sqe__bindgen_ty_3),
565 "::",
566 stringify!(poll32_events)
567 )
568 );
569 assert_eq!(
570 unsafe { ::core::ptr::addr_of!((*ptr).sync_range_flags) as usize - ptr as usize },
571 0usize,
572 concat!(
573 "Offset of field: ",
574 stringify!(io_uring_sqe__bindgen_ty_3),
575 "::",
576 stringify!(sync_range_flags)
577 )
578 );
579 assert_eq!(
580 unsafe { ::core::ptr::addr_of!((*ptr).msg_flags) as usize - ptr as usize },
581 0usize,
582 concat!(
583 "Offset of field: ",
584 stringify!(io_uring_sqe__bindgen_ty_3),
585 "::",
586 stringify!(msg_flags)
587 )
588 );
589 assert_eq!(
590 unsafe { ::core::ptr::addr_of!((*ptr).timeout_flags) as usize - ptr as usize },
591 0usize,
592 concat!(
593 "Offset of field: ",
594 stringify!(io_uring_sqe__bindgen_ty_3),
595 "::",
596 stringify!(timeout_flags)
597 )
598 );
599 assert_eq!(
600 unsafe { ::core::ptr::addr_of!((*ptr).accept_flags) as usize - ptr as usize },
601 0usize,
602 concat!(
603 "Offset of field: ",
604 stringify!(io_uring_sqe__bindgen_ty_3),
605 "::",
606 stringify!(accept_flags)
607 )
608 );
609 assert_eq!(
610 unsafe { ::core::ptr::addr_of!((*ptr).cancel_flags) as usize - ptr as usize },
611 0usize,
612 concat!(
613 "Offset of field: ",
614 stringify!(io_uring_sqe__bindgen_ty_3),
615 "::",
616 stringify!(cancel_flags)
617 )
618 );
619 assert_eq!(
620 unsafe { ::core::ptr::addr_of!((*ptr).open_flags) as usize - ptr as usize },
621 0usize,
622 concat!(
623 "Offset of field: ",
624 stringify!(io_uring_sqe__bindgen_ty_3),
625 "::",
626 stringify!(open_flags)
627 )
628 );
629 assert_eq!(
630 unsafe { ::core::ptr::addr_of!((*ptr).statx_flags) as usize - ptr as usize },
631 0usize,
632 concat!(
633 "Offset of field: ",
634 stringify!(io_uring_sqe__bindgen_ty_3),
635 "::",
636 stringify!(statx_flags)
637 )
638 );
639 assert_eq!(
640 unsafe { ::core::ptr::addr_of!((*ptr).fadvise_advice) as usize - ptr as usize },
641 0usize,
642 concat!(
643 "Offset of field: ",
644 stringify!(io_uring_sqe__bindgen_ty_3),
645 "::",
646 stringify!(fadvise_advice)
647 )
648 );
649 assert_eq!(
650 unsafe { ::core::ptr::addr_of!((*ptr).splice_flags) as usize - ptr as usize },
651 0usize,
652 concat!(
653 "Offset of field: ",
654 stringify!(io_uring_sqe__bindgen_ty_3),
655 "::",
656 stringify!(splice_flags)
657 )
658 );
659 assert_eq!(
660 unsafe { ::core::ptr::addr_of!((*ptr).rename_flags) as usize - ptr as usize },
661 0usize,
662 concat!(
663 "Offset of field: ",
664 stringify!(io_uring_sqe__bindgen_ty_3),
665 "::",
666 stringify!(rename_flags)
667 )
668 );
669 assert_eq!(
670 unsafe { ::core::ptr::addr_of!((*ptr).unlink_flags) as usize - ptr as usize },
671 0usize,
672 concat!(
673 "Offset of field: ",
674 stringify!(io_uring_sqe__bindgen_ty_3),
675 "::",
676 stringify!(unlink_flags)
677 )
678 );
679 assert_eq!(
680 unsafe { ::core::ptr::addr_of!((*ptr).hardlink_flags) as usize - ptr as usize },
681 0usize,
682 concat!(
683 "Offset of field: ",
684 stringify!(io_uring_sqe__bindgen_ty_3),
685 "::",
686 stringify!(hardlink_flags)
687 )
688 );
689 assert_eq!(
690 unsafe { ::core::ptr::addr_of!((*ptr).xattr_flags) as usize - ptr as usize },
691 0usize,
692 concat!(
693 "Offset of field: ",
694 stringify!(io_uring_sqe__bindgen_ty_3),
695 "::",
696 stringify!(xattr_flags)
697 )
698 );
699 assert_eq!(
700 unsafe { ::core::ptr::addr_of!((*ptr).msg_ring_flags) as usize - ptr as usize },
701 0usize,
702 concat!(
703 "Offset of field: ",
704 stringify!(io_uring_sqe__bindgen_ty_3),
705 "::",
706 stringify!(msg_ring_flags)
707 )
708 );
709 assert_eq!(
710 unsafe { ::core::ptr::addr_of!((*ptr).uring_cmd_flags) as usize - ptr as usize },
711 0usize,
712 concat!(
713 "Offset of field: ",
714 stringify!(io_uring_sqe__bindgen_ty_3),
715 "::",
716 stringify!(uring_cmd_flags)
717 )
718 );
719 assert_eq!(
720 unsafe { ::core::ptr::addr_of!((*ptr).waitid_flags) as usize - ptr as usize },
721 0usize,
722 concat!(
723 "Offset of field: ",
724 stringify!(io_uring_sqe__bindgen_ty_3),
725 "::",
726 stringify!(waitid_flags)
727 )
728 );
729 assert_eq!(
730 unsafe { ::core::ptr::addr_of!((*ptr).futex_flags) as usize - ptr as usize },
731 0usize,
732 concat!(
733 "Offset of field: ",
734 stringify!(io_uring_sqe__bindgen_ty_3),
735 "::",
736 stringify!(futex_flags)
737 )
738 );
739 assert_eq!(
740 unsafe { ::core::ptr::addr_of!((*ptr).install_fd_flags) as usize - ptr as usize },
741 0usize,
742 concat!(
743 "Offset of field: ",
744 stringify!(io_uring_sqe__bindgen_ty_3),
745 "::",
746 stringify!(install_fd_flags)
747 )
748 );
749 assert_eq!(
750 unsafe { ::core::ptr::addr_of!((*ptr).nop_flags) as usize - ptr as usize },
751 0usize,
752 concat!(
753 "Offset of field: ",
754 stringify!(io_uring_sqe__bindgen_ty_3),
755 "::",
756 stringify!(nop_flags)
757 )
758 );
759}
760impl Default for io_uring_sqe__bindgen_ty_3 {
761 fn default() -> Self {
762 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
763 unsafe {
764 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
765 s.assume_init()
766 }
767 }
768}
769#[repr(C, packed)]
770#[derive(Copy, Clone)]
771pub union io_uring_sqe__bindgen_ty_4 {
772 pub buf_index: __u16,
773 pub buf_group: __u16,
774}
775#[test]
776fn bindgen_test_layout_io_uring_sqe__bindgen_ty_4() {
777 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_4> =
778 ::core::mem::MaybeUninit::uninit();
779 let ptr = UNINIT.as_ptr();
780 assert_eq!(
781 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_4>(),
782 2usize,
783 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_4))
784 );
785 assert_eq!(
786 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_4>(),
787 1usize,
788 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_4))
789 );
790 assert_eq!(
791 unsafe { ::core::ptr::addr_of!((*ptr).buf_index) as usize - ptr as usize },
792 0usize,
793 concat!(
794 "Offset of field: ",
795 stringify!(io_uring_sqe__bindgen_ty_4),
796 "::",
797 stringify!(buf_index)
798 )
799 );
800 assert_eq!(
801 unsafe { ::core::ptr::addr_of!((*ptr).buf_group) as usize - ptr as usize },
802 0usize,
803 concat!(
804 "Offset of field: ",
805 stringify!(io_uring_sqe__bindgen_ty_4),
806 "::",
807 stringify!(buf_group)
808 )
809 );
810}
811impl Default for io_uring_sqe__bindgen_ty_4 {
812 fn default() -> Self {
813 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
814 unsafe {
815 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
816 s.assume_init()
817 }
818 }
819}
820#[repr(C)]
821#[derive(Copy, Clone)]
822pub union io_uring_sqe__bindgen_ty_5 {
823 pub splice_fd_in: __s32,
824 pub file_index: __u32,
825 pub optlen: __u32,
826 pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_5__bindgen_ty_1,
827}
828#[repr(C)]
829#[derive(Debug, Default, Copy, Clone)]
830pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_1 {
831 pub addr_len: __u16,
832 pub __pad3: [__u16; 1usize],
833}
834#[test]
835fn bindgen_test_layout_io_uring_sqe__bindgen_ty_5__bindgen_ty_1() {
836 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_5__bindgen_ty_1> =
837 ::core::mem::MaybeUninit::uninit();
838 let ptr = UNINIT.as_ptr();
839 assert_eq!(
840 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_5__bindgen_ty_1>(),
841 4usize,
842 concat!(
843 "Size of: ",
844 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1)
845 )
846 );
847 assert_eq!(
848 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_5__bindgen_ty_1>(),
849 2usize,
850 concat!(
851 "Alignment of ",
852 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1)
853 )
854 );
855 assert_eq!(
856 unsafe { ::core::ptr::addr_of!((*ptr).addr_len) as usize - ptr as usize },
857 0usize,
858 concat!(
859 "Offset of field: ",
860 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1),
861 "::",
862 stringify!(addr_len)
863 )
864 );
865 assert_eq!(
866 unsafe { ::core::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
867 2usize,
868 concat!(
869 "Offset of field: ",
870 stringify!(io_uring_sqe__bindgen_ty_5__bindgen_ty_1),
871 "::",
872 stringify!(__pad3)
873 )
874 );
875}
876#[test]
877fn bindgen_test_layout_io_uring_sqe__bindgen_ty_5() {
878 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_5> =
879 ::core::mem::MaybeUninit::uninit();
880 let ptr = UNINIT.as_ptr();
881 assert_eq!(
882 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_5>(),
883 4usize,
884 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_5))
885 );
886 assert_eq!(
887 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_5>(),
888 4usize,
889 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_5))
890 );
891 assert_eq!(
892 unsafe { ::core::ptr::addr_of!((*ptr).splice_fd_in) as usize - ptr as usize },
893 0usize,
894 concat!(
895 "Offset of field: ",
896 stringify!(io_uring_sqe__bindgen_ty_5),
897 "::",
898 stringify!(splice_fd_in)
899 )
900 );
901 assert_eq!(
902 unsafe { ::core::ptr::addr_of!((*ptr).file_index) as usize - ptr as usize },
903 0usize,
904 concat!(
905 "Offset of field: ",
906 stringify!(io_uring_sqe__bindgen_ty_5),
907 "::",
908 stringify!(file_index)
909 )
910 );
911 assert_eq!(
912 unsafe { ::core::ptr::addr_of!((*ptr).optlen) as usize - ptr as usize },
913 0usize,
914 concat!(
915 "Offset of field: ",
916 stringify!(io_uring_sqe__bindgen_ty_5),
917 "::",
918 stringify!(optlen)
919 )
920 );
921}
922impl Default for io_uring_sqe__bindgen_ty_5 {
923 fn default() -> Self {
924 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
925 unsafe {
926 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
927 s.assume_init()
928 }
929 }
930}
931#[repr(C)]
932pub struct io_uring_sqe__bindgen_ty_6 {
933 pub __bindgen_anon_1: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>,
934 pub optval: __BindgenUnionField<__u64>,
935 pub cmd: __BindgenUnionField<[__u8; 0usize]>,
936 pub bindgen_union_field: [u64; 2usize],
937}
938#[repr(C)]
939#[derive(Debug, Default, Copy, Clone)]
940pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_1 {
941 pub addr3: __u64,
942 pub __pad2: [__u64; 1usize],
943}
944#[test]
945fn bindgen_test_layout_io_uring_sqe__bindgen_ty_6__bindgen_ty_1() {
946 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_6__bindgen_ty_1> =
947 ::core::mem::MaybeUninit::uninit();
948 let ptr = UNINIT.as_ptr();
949 assert_eq!(
950 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>(),
951 16usize,
952 concat!(
953 "Size of: ",
954 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1)
955 )
956 );
957 assert_eq!(
958 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>(),
959 8usize,
960 concat!(
961 "Alignment of ",
962 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1)
963 )
964 );
965 assert_eq!(
966 unsafe { ::core::ptr::addr_of!((*ptr).addr3) as usize - ptr as usize },
967 0usize,
968 concat!(
969 "Offset of field: ",
970 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1),
971 "::",
972 stringify!(addr3)
973 )
974 );
975 assert_eq!(
976 unsafe { ::core::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
977 8usize,
978 concat!(
979 "Offset of field: ",
980 stringify!(io_uring_sqe__bindgen_ty_6__bindgen_ty_1),
981 "::",
982 stringify!(__pad2)
983 )
984 );
985}
986#[test]
987fn bindgen_test_layout_io_uring_sqe__bindgen_ty_6() {
988 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe__bindgen_ty_6> =
989 ::core::mem::MaybeUninit::uninit();
990 let ptr = UNINIT.as_ptr();
991 assert_eq!(
992 ::core::mem::size_of::<io_uring_sqe__bindgen_ty_6>(),
993 16usize,
994 concat!("Size of: ", stringify!(io_uring_sqe__bindgen_ty_6))
995 );
996 assert_eq!(
997 ::core::mem::align_of::<io_uring_sqe__bindgen_ty_6>(),
998 8usize,
999 concat!("Alignment of ", stringify!(io_uring_sqe__bindgen_ty_6))
1000 );
1001 assert_eq!(
1002 unsafe { ::core::ptr::addr_of!((*ptr).optval) as usize - ptr as usize },
1003 0usize,
1004 concat!(
1005 "Offset of field: ",
1006 stringify!(io_uring_sqe__bindgen_ty_6),
1007 "::",
1008 stringify!(optval)
1009 )
1010 );
1011 assert_eq!(
1012 unsafe { ::core::ptr::addr_of!((*ptr).cmd) as usize - ptr as usize },
1013 0usize,
1014 concat!(
1015 "Offset of field: ",
1016 stringify!(io_uring_sqe__bindgen_ty_6),
1017 "::",
1018 stringify!(cmd)
1019 )
1020 );
1021}
1022impl Default for io_uring_sqe__bindgen_ty_6 {
1023 fn default() -> Self {
1024 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1025 unsafe {
1026 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1027 s.assume_init()
1028 }
1029 }
1030}
1031#[test]
1032fn bindgen_test_layout_io_uring_sqe() {
1033 const UNINIT: ::core::mem::MaybeUninit<io_uring_sqe> = ::core::mem::MaybeUninit::uninit();
1034 let ptr = UNINIT.as_ptr();
1035 assert_eq!(
1036 ::core::mem::size_of::<io_uring_sqe>(),
1037 64usize,
1038 concat!("Size of: ", stringify!(io_uring_sqe))
1039 );
1040 assert_eq!(
1041 ::core::mem::align_of::<io_uring_sqe>(),
1042 8usize,
1043 concat!("Alignment of ", stringify!(io_uring_sqe))
1044 );
1045 assert_eq!(
1046 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
1047 0usize,
1048 concat!(
1049 "Offset of field: ",
1050 stringify!(io_uring_sqe),
1051 "::",
1052 stringify!(opcode)
1053 )
1054 );
1055 assert_eq!(
1056 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1057 1usize,
1058 concat!(
1059 "Offset of field: ",
1060 stringify!(io_uring_sqe),
1061 "::",
1062 stringify!(flags)
1063 )
1064 );
1065 assert_eq!(
1066 unsafe { ::core::ptr::addr_of!((*ptr).ioprio) as usize - ptr as usize },
1067 2usize,
1068 concat!(
1069 "Offset of field: ",
1070 stringify!(io_uring_sqe),
1071 "::",
1072 stringify!(ioprio)
1073 )
1074 );
1075 assert_eq!(
1076 unsafe { ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
1077 4usize,
1078 concat!(
1079 "Offset of field: ",
1080 stringify!(io_uring_sqe),
1081 "::",
1082 stringify!(fd)
1083 )
1084 );
1085 assert_eq!(
1086 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
1087 24usize,
1088 concat!(
1089 "Offset of field: ",
1090 stringify!(io_uring_sqe),
1091 "::",
1092 stringify!(len)
1093 )
1094 );
1095 assert_eq!(
1096 unsafe { ::core::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
1097 32usize,
1098 concat!(
1099 "Offset of field: ",
1100 stringify!(io_uring_sqe),
1101 "::",
1102 stringify!(user_data)
1103 )
1104 );
1105 assert_eq!(
1106 unsafe { ::core::ptr::addr_of!((*ptr).personality) as usize - ptr as usize },
1107 42usize,
1108 concat!(
1109 "Offset of field: ",
1110 stringify!(io_uring_sqe),
1111 "::",
1112 stringify!(personality)
1113 )
1114 );
1115}
1116impl Default for io_uring_sqe {
1117 fn default() -> Self {
1118 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1119 unsafe {
1120 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1121 s.assume_init()
1122 }
1123 }
1124}
1125pub const IOSQE_FIXED_FILE_BIT: io_uring_sqe_flags_bit = 0;
1126pub const IOSQE_IO_DRAIN_BIT: io_uring_sqe_flags_bit = 1;
1127pub const IOSQE_IO_LINK_BIT: io_uring_sqe_flags_bit = 2;
1128pub const IOSQE_IO_HARDLINK_BIT: io_uring_sqe_flags_bit = 3;
1129pub const IOSQE_ASYNC_BIT: io_uring_sqe_flags_bit = 4;
1130pub const IOSQE_BUFFER_SELECT_BIT: io_uring_sqe_flags_bit = 5;
1131pub const IOSQE_CQE_SKIP_SUCCESS_BIT: io_uring_sqe_flags_bit = 6;
1132pub type io_uring_sqe_flags_bit = libc::c_uint;
1133pub const IORING_OP_NOP: io_uring_op = 0;
1134pub const IORING_OP_READV: io_uring_op = 1;
1135pub const IORING_OP_WRITEV: io_uring_op = 2;
1136pub const IORING_OP_FSYNC: io_uring_op = 3;
1137pub const IORING_OP_READ_FIXED: io_uring_op = 4;
1138pub const IORING_OP_WRITE_FIXED: io_uring_op = 5;
1139pub const IORING_OP_POLL_ADD: io_uring_op = 6;
1140pub const IORING_OP_POLL_REMOVE: io_uring_op = 7;
1141pub const IORING_OP_SYNC_FILE_RANGE: io_uring_op = 8;
1142pub const IORING_OP_SENDMSG: io_uring_op = 9;
1143pub const IORING_OP_RECVMSG: io_uring_op = 10;
1144pub const IORING_OP_TIMEOUT: io_uring_op = 11;
1145pub const IORING_OP_TIMEOUT_REMOVE: io_uring_op = 12;
1146pub const IORING_OP_ACCEPT: io_uring_op = 13;
1147pub const IORING_OP_ASYNC_CANCEL: io_uring_op = 14;
1148pub const IORING_OP_LINK_TIMEOUT: io_uring_op = 15;
1149pub const IORING_OP_CONNECT: io_uring_op = 16;
1150pub const IORING_OP_FALLOCATE: io_uring_op = 17;
1151pub const IORING_OP_OPENAT: io_uring_op = 18;
1152pub const IORING_OP_CLOSE: io_uring_op = 19;
1153pub const IORING_OP_FILES_UPDATE: io_uring_op = 20;
1154pub const IORING_OP_STATX: io_uring_op = 21;
1155pub const IORING_OP_READ: io_uring_op = 22;
1156pub const IORING_OP_WRITE: io_uring_op = 23;
1157pub const IORING_OP_FADVISE: io_uring_op = 24;
1158pub const IORING_OP_MADVISE: io_uring_op = 25;
1159pub const IORING_OP_SEND: io_uring_op = 26;
1160pub const IORING_OP_RECV: io_uring_op = 27;
1161pub const IORING_OP_OPENAT2: io_uring_op = 28;
1162pub const IORING_OP_EPOLL_CTL: io_uring_op = 29;
1163pub const IORING_OP_SPLICE: io_uring_op = 30;
1164pub const IORING_OP_PROVIDE_BUFFERS: io_uring_op = 31;
1165pub const IORING_OP_REMOVE_BUFFERS: io_uring_op = 32;
1166pub const IORING_OP_TEE: io_uring_op = 33;
1167pub const IORING_OP_SHUTDOWN: io_uring_op = 34;
1168pub const IORING_OP_RENAMEAT: io_uring_op = 35;
1169pub const IORING_OP_UNLINKAT: io_uring_op = 36;
1170pub const IORING_OP_MKDIRAT: io_uring_op = 37;
1171pub const IORING_OP_SYMLINKAT: io_uring_op = 38;
1172pub const IORING_OP_LINKAT: io_uring_op = 39;
1173pub const IORING_OP_MSG_RING: io_uring_op = 40;
1174pub const IORING_OP_FSETXATTR: io_uring_op = 41;
1175pub const IORING_OP_SETXATTR: io_uring_op = 42;
1176pub const IORING_OP_FGETXATTR: io_uring_op = 43;
1177pub const IORING_OP_GETXATTR: io_uring_op = 44;
1178pub const IORING_OP_SOCKET: io_uring_op = 45;
1179pub const IORING_OP_URING_CMD: io_uring_op = 46;
1180pub const IORING_OP_SEND_ZC: io_uring_op = 47;
1181pub const IORING_OP_SENDMSG_ZC: io_uring_op = 48;
1182pub const IORING_OP_READ_MULTISHOT: io_uring_op = 49;
1183pub const IORING_OP_WAITID: io_uring_op = 50;
1184pub const IORING_OP_FUTEX_WAIT: io_uring_op = 51;
1185pub const IORING_OP_FUTEX_WAKE: io_uring_op = 52;
1186pub const IORING_OP_FUTEX_WAITV: io_uring_op = 53;
1187pub const IORING_OP_FIXED_FD_INSTALL: io_uring_op = 54;
1188pub const IORING_OP_FTRUNCATE: io_uring_op = 55;
1189pub const IORING_OP_LAST: io_uring_op = 56;
1190pub type io_uring_op = libc::c_uint;
1191pub const IORING_MSG_DATA: io_uring_msg_ring_flags = 0;
1192pub const IORING_MSG_SEND_FD: io_uring_msg_ring_flags = 1;
1193pub type io_uring_msg_ring_flags = libc::c_uint;
1194#[repr(C)]
1195#[derive(Debug, Default)]
1196pub struct io_uring_cqe {
1197 pub user_data: __u64,
1198 pub res: __s32,
1199 pub flags: __u32,
1200 pub big_cqe: __IncompleteArrayField<__u64>,
1201}
1202#[test]
1203fn bindgen_test_layout_io_uring_cqe() {
1204 const UNINIT: ::core::mem::MaybeUninit<io_uring_cqe> = ::core::mem::MaybeUninit::uninit();
1205 let ptr = UNINIT.as_ptr();
1206 assert_eq!(
1207 ::core::mem::size_of::<io_uring_cqe>(),
1208 16usize,
1209 concat!("Size of: ", stringify!(io_uring_cqe))
1210 );
1211 assert_eq!(
1212 ::core::mem::align_of::<io_uring_cqe>(),
1213 8usize,
1214 concat!("Alignment of ", stringify!(io_uring_cqe))
1215 );
1216 assert_eq!(
1217 unsafe { ::core::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
1218 0usize,
1219 concat!(
1220 "Offset of field: ",
1221 stringify!(io_uring_cqe),
1222 "::",
1223 stringify!(user_data)
1224 )
1225 );
1226 assert_eq!(
1227 unsafe { ::core::ptr::addr_of!((*ptr).res) as usize - ptr as usize },
1228 8usize,
1229 concat!(
1230 "Offset of field: ",
1231 stringify!(io_uring_cqe),
1232 "::",
1233 stringify!(res)
1234 )
1235 );
1236 assert_eq!(
1237 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1238 12usize,
1239 concat!(
1240 "Offset of field: ",
1241 stringify!(io_uring_cqe),
1242 "::",
1243 stringify!(flags)
1244 )
1245 );
1246 assert_eq!(
1247 unsafe { ::core::ptr::addr_of!((*ptr).big_cqe) as usize - ptr as usize },
1248 16usize,
1249 concat!(
1250 "Offset of field: ",
1251 stringify!(io_uring_cqe),
1252 "::",
1253 stringify!(big_cqe)
1254 )
1255 );
1256}
1257#[repr(C)]
1258#[derive(Debug, Default, Copy, Clone)]
1259pub struct io_sqring_offsets {
1260 pub head: __u32,
1261 pub tail: __u32,
1262 pub ring_mask: __u32,
1263 pub ring_entries: __u32,
1264 pub flags: __u32,
1265 pub dropped: __u32,
1266 pub array: __u32,
1267 pub resv1: __u32,
1268 pub user_addr: __u64,
1269}
1270#[test]
1271fn bindgen_test_layout_io_sqring_offsets() {
1272 const UNINIT: ::core::mem::MaybeUninit<io_sqring_offsets> = ::core::mem::MaybeUninit::uninit();
1273 let ptr = UNINIT.as_ptr();
1274 assert_eq!(
1275 ::core::mem::size_of::<io_sqring_offsets>(),
1276 40usize,
1277 concat!("Size of: ", stringify!(io_sqring_offsets))
1278 );
1279 assert_eq!(
1280 ::core::mem::align_of::<io_sqring_offsets>(),
1281 8usize,
1282 concat!("Alignment of ", stringify!(io_sqring_offsets))
1283 );
1284 assert_eq!(
1285 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
1286 0usize,
1287 concat!(
1288 "Offset of field: ",
1289 stringify!(io_sqring_offsets),
1290 "::",
1291 stringify!(head)
1292 )
1293 );
1294 assert_eq!(
1295 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
1296 4usize,
1297 concat!(
1298 "Offset of field: ",
1299 stringify!(io_sqring_offsets),
1300 "::",
1301 stringify!(tail)
1302 )
1303 );
1304 assert_eq!(
1305 unsafe { ::core::ptr::addr_of!((*ptr).ring_mask) as usize - ptr as usize },
1306 8usize,
1307 concat!(
1308 "Offset of field: ",
1309 stringify!(io_sqring_offsets),
1310 "::",
1311 stringify!(ring_mask)
1312 )
1313 );
1314 assert_eq!(
1315 unsafe { ::core::ptr::addr_of!((*ptr).ring_entries) as usize - ptr as usize },
1316 12usize,
1317 concat!(
1318 "Offset of field: ",
1319 stringify!(io_sqring_offsets),
1320 "::",
1321 stringify!(ring_entries)
1322 )
1323 );
1324 assert_eq!(
1325 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1326 16usize,
1327 concat!(
1328 "Offset of field: ",
1329 stringify!(io_sqring_offsets),
1330 "::",
1331 stringify!(flags)
1332 )
1333 );
1334 assert_eq!(
1335 unsafe { ::core::ptr::addr_of!((*ptr).dropped) as usize - ptr as usize },
1336 20usize,
1337 concat!(
1338 "Offset of field: ",
1339 stringify!(io_sqring_offsets),
1340 "::",
1341 stringify!(dropped)
1342 )
1343 );
1344 assert_eq!(
1345 unsafe { ::core::ptr::addr_of!((*ptr).array) as usize - ptr as usize },
1346 24usize,
1347 concat!(
1348 "Offset of field: ",
1349 stringify!(io_sqring_offsets),
1350 "::",
1351 stringify!(array)
1352 )
1353 );
1354 assert_eq!(
1355 unsafe { ::core::ptr::addr_of!((*ptr).resv1) as usize - ptr as usize },
1356 28usize,
1357 concat!(
1358 "Offset of field: ",
1359 stringify!(io_sqring_offsets),
1360 "::",
1361 stringify!(resv1)
1362 )
1363 );
1364 assert_eq!(
1365 unsafe { ::core::ptr::addr_of!((*ptr).user_addr) as usize - ptr as usize },
1366 32usize,
1367 concat!(
1368 "Offset of field: ",
1369 stringify!(io_sqring_offsets),
1370 "::",
1371 stringify!(user_addr)
1372 )
1373 );
1374}
1375#[repr(C)]
1376#[derive(Debug, Default, Copy, Clone)]
1377pub struct io_cqring_offsets {
1378 pub head: __u32,
1379 pub tail: __u32,
1380 pub ring_mask: __u32,
1381 pub ring_entries: __u32,
1382 pub overflow: __u32,
1383 pub cqes: __u32,
1384 pub flags: __u32,
1385 pub resv1: __u32,
1386 pub user_addr: __u64,
1387}
1388#[test]
1389fn bindgen_test_layout_io_cqring_offsets() {
1390 const UNINIT: ::core::mem::MaybeUninit<io_cqring_offsets> = ::core::mem::MaybeUninit::uninit();
1391 let ptr = UNINIT.as_ptr();
1392 assert_eq!(
1393 ::core::mem::size_of::<io_cqring_offsets>(),
1394 40usize,
1395 concat!("Size of: ", stringify!(io_cqring_offsets))
1396 );
1397 assert_eq!(
1398 ::core::mem::align_of::<io_cqring_offsets>(),
1399 8usize,
1400 concat!("Alignment of ", stringify!(io_cqring_offsets))
1401 );
1402 assert_eq!(
1403 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
1404 0usize,
1405 concat!(
1406 "Offset of field: ",
1407 stringify!(io_cqring_offsets),
1408 "::",
1409 stringify!(head)
1410 )
1411 );
1412 assert_eq!(
1413 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
1414 4usize,
1415 concat!(
1416 "Offset of field: ",
1417 stringify!(io_cqring_offsets),
1418 "::",
1419 stringify!(tail)
1420 )
1421 );
1422 assert_eq!(
1423 unsafe { ::core::ptr::addr_of!((*ptr).ring_mask) as usize - ptr as usize },
1424 8usize,
1425 concat!(
1426 "Offset of field: ",
1427 stringify!(io_cqring_offsets),
1428 "::",
1429 stringify!(ring_mask)
1430 )
1431 );
1432 assert_eq!(
1433 unsafe { ::core::ptr::addr_of!((*ptr).ring_entries) as usize - ptr as usize },
1434 12usize,
1435 concat!(
1436 "Offset of field: ",
1437 stringify!(io_cqring_offsets),
1438 "::",
1439 stringify!(ring_entries)
1440 )
1441 );
1442 assert_eq!(
1443 unsafe { ::core::ptr::addr_of!((*ptr).overflow) as usize - ptr as usize },
1444 16usize,
1445 concat!(
1446 "Offset of field: ",
1447 stringify!(io_cqring_offsets),
1448 "::",
1449 stringify!(overflow)
1450 )
1451 );
1452 assert_eq!(
1453 unsafe { ::core::ptr::addr_of!((*ptr).cqes) as usize - ptr as usize },
1454 20usize,
1455 concat!(
1456 "Offset of field: ",
1457 stringify!(io_cqring_offsets),
1458 "::",
1459 stringify!(cqes)
1460 )
1461 );
1462 assert_eq!(
1463 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1464 24usize,
1465 concat!(
1466 "Offset of field: ",
1467 stringify!(io_cqring_offsets),
1468 "::",
1469 stringify!(flags)
1470 )
1471 );
1472 assert_eq!(
1473 unsafe { ::core::ptr::addr_of!((*ptr).resv1) as usize - ptr as usize },
1474 28usize,
1475 concat!(
1476 "Offset of field: ",
1477 stringify!(io_cqring_offsets),
1478 "::",
1479 stringify!(resv1)
1480 )
1481 );
1482 assert_eq!(
1483 unsafe { ::core::ptr::addr_of!((*ptr).user_addr) as usize - ptr as usize },
1484 32usize,
1485 concat!(
1486 "Offset of field: ",
1487 stringify!(io_cqring_offsets),
1488 "::",
1489 stringify!(user_addr)
1490 )
1491 );
1492}
1493#[repr(C)]
1494#[derive(Debug, Default, Copy, Clone)]
1495pub struct io_uring_params {
1496 pub sq_entries: __u32,
1497 pub cq_entries: __u32,
1498 pub flags: __u32,
1499 pub sq_thread_cpu: __u32,
1500 pub sq_thread_idle: __u32,
1501 pub features: __u32,
1502 pub wq_fd: __u32,
1503 pub resv: [__u32; 3usize],
1504 pub sq_off: io_sqring_offsets,
1505 pub cq_off: io_cqring_offsets,
1506}
1507#[test]
1508fn bindgen_test_layout_io_uring_params() {
1509 const UNINIT: ::core::mem::MaybeUninit<io_uring_params> = ::core::mem::MaybeUninit::uninit();
1510 let ptr = UNINIT.as_ptr();
1511 assert_eq!(
1512 ::core::mem::size_of::<io_uring_params>(),
1513 120usize,
1514 concat!("Size of: ", stringify!(io_uring_params))
1515 );
1516 assert_eq!(
1517 ::core::mem::align_of::<io_uring_params>(),
1518 8usize,
1519 concat!("Alignment of ", stringify!(io_uring_params))
1520 );
1521 assert_eq!(
1522 unsafe { ::core::ptr::addr_of!((*ptr).sq_entries) as usize - ptr as usize },
1523 0usize,
1524 concat!(
1525 "Offset of field: ",
1526 stringify!(io_uring_params),
1527 "::",
1528 stringify!(sq_entries)
1529 )
1530 );
1531 assert_eq!(
1532 unsafe { ::core::ptr::addr_of!((*ptr).cq_entries) as usize - ptr as usize },
1533 4usize,
1534 concat!(
1535 "Offset of field: ",
1536 stringify!(io_uring_params),
1537 "::",
1538 stringify!(cq_entries)
1539 )
1540 );
1541 assert_eq!(
1542 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1543 8usize,
1544 concat!(
1545 "Offset of field: ",
1546 stringify!(io_uring_params),
1547 "::",
1548 stringify!(flags)
1549 )
1550 );
1551 assert_eq!(
1552 unsafe { ::core::ptr::addr_of!((*ptr).sq_thread_cpu) as usize - ptr as usize },
1553 12usize,
1554 concat!(
1555 "Offset of field: ",
1556 stringify!(io_uring_params),
1557 "::",
1558 stringify!(sq_thread_cpu)
1559 )
1560 );
1561 assert_eq!(
1562 unsafe { ::core::ptr::addr_of!((*ptr).sq_thread_idle) as usize - ptr as usize },
1563 16usize,
1564 concat!(
1565 "Offset of field: ",
1566 stringify!(io_uring_params),
1567 "::",
1568 stringify!(sq_thread_idle)
1569 )
1570 );
1571 assert_eq!(
1572 unsafe { ::core::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
1573 20usize,
1574 concat!(
1575 "Offset of field: ",
1576 stringify!(io_uring_params),
1577 "::",
1578 stringify!(features)
1579 )
1580 );
1581 assert_eq!(
1582 unsafe { ::core::ptr::addr_of!((*ptr).wq_fd) as usize - ptr as usize },
1583 24usize,
1584 concat!(
1585 "Offset of field: ",
1586 stringify!(io_uring_params),
1587 "::",
1588 stringify!(wq_fd)
1589 )
1590 );
1591 assert_eq!(
1592 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1593 28usize,
1594 concat!(
1595 "Offset of field: ",
1596 stringify!(io_uring_params),
1597 "::",
1598 stringify!(resv)
1599 )
1600 );
1601 assert_eq!(
1602 unsafe { ::core::ptr::addr_of!((*ptr).sq_off) as usize - ptr as usize },
1603 40usize,
1604 concat!(
1605 "Offset of field: ",
1606 stringify!(io_uring_params),
1607 "::",
1608 stringify!(sq_off)
1609 )
1610 );
1611 assert_eq!(
1612 unsafe { ::core::ptr::addr_of!((*ptr).cq_off) as usize - ptr as usize },
1613 80usize,
1614 concat!(
1615 "Offset of field: ",
1616 stringify!(io_uring_params),
1617 "::",
1618 stringify!(cq_off)
1619 )
1620 );
1621}
1622pub const IORING_REGISTER_BUFFERS: io_uring_register_op = 0;
1623pub const IORING_UNREGISTER_BUFFERS: io_uring_register_op = 1;
1624pub const IORING_REGISTER_FILES: io_uring_register_op = 2;
1625pub const IORING_UNREGISTER_FILES: io_uring_register_op = 3;
1626pub const IORING_REGISTER_EVENTFD: io_uring_register_op = 4;
1627pub const IORING_UNREGISTER_EVENTFD: io_uring_register_op = 5;
1628pub const IORING_REGISTER_FILES_UPDATE: io_uring_register_op = 6;
1629pub const IORING_REGISTER_EVENTFD_ASYNC: io_uring_register_op = 7;
1630pub const IORING_REGISTER_PROBE: io_uring_register_op = 8;
1631pub const IORING_REGISTER_PERSONALITY: io_uring_register_op = 9;
1632pub const IORING_UNREGISTER_PERSONALITY: io_uring_register_op = 10;
1633pub const IORING_REGISTER_RESTRICTIONS: io_uring_register_op = 11;
1634pub const IORING_REGISTER_ENABLE_RINGS: io_uring_register_op = 12;
1635pub const IORING_REGISTER_FILES2: io_uring_register_op = 13;
1636pub const IORING_REGISTER_FILES_UPDATE2: io_uring_register_op = 14;
1637pub const IORING_REGISTER_BUFFERS2: io_uring_register_op = 15;
1638pub const IORING_REGISTER_BUFFERS_UPDATE: io_uring_register_op = 16;
1639pub const IORING_REGISTER_IOWQ_AFF: io_uring_register_op = 17;
1640pub const IORING_UNREGISTER_IOWQ_AFF: io_uring_register_op = 18;
1641pub const IORING_REGISTER_IOWQ_MAX_WORKERS: io_uring_register_op = 19;
1642pub const IORING_REGISTER_RING_FDS: io_uring_register_op = 20;
1643pub const IORING_UNREGISTER_RING_FDS: io_uring_register_op = 21;
1644pub const IORING_REGISTER_PBUF_RING: io_uring_register_op = 22;
1645pub const IORING_UNREGISTER_PBUF_RING: io_uring_register_op = 23;
1646pub const IORING_REGISTER_SYNC_CANCEL: io_uring_register_op = 24;
1647pub const IORING_REGISTER_FILE_ALLOC_RANGE: io_uring_register_op = 25;
1648pub const IORING_REGISTER_PBUF_STATUS: io_uring_register_op = 26;
1649pub const IORING_REGISTER_NAPI: io_uring_register_op = 27;
1650pub const IORING_UNREGISTER_NAPI: io_uring_register_op = 28;
1651pub const IORING_REGISTER_LAST: io_uring_register_op = 29;
1652pub const IORING_REGISTER_USE_REGISTERED_RING: io_uring_register_op = 2147483648;
1653pub type io_uring_register_op = libc::c_uint;
1654#[repr(C)]
1655#[derive(Debug, Default, Copy, Clone)]
1656pub struct io_uring_files_update {
1657 pub offset: __u32,
1658 pub resv: __u32,
1659 pub fds: __u64,
1660}
1661#[test]
1662fn bindgen_test_layout_io_uring_files_update() {
1663 const UNINIT: ::core::mem::MaybeUninit<io_uring_files_update> =
1664 ::core::mem::MaybeUninit::uninit();
1665 let ptr = UNINIT.as_ptr();
1666 assert_eq!(
1667 ::core::mem::size_of::<io_uring_files_update>(),
1668 16usize,
1669 concat!("Size of: ", stringify!(io_uring_files_update))
1670 );
1671 assert_eq!(
1672 ::core::mem::align_of::<io_uring_files_update>(),
1673 8usize,
1674 concat!("Alignment of ", stringify!(io_uring_files_update))
1675 );
1676 assert_eq!(
1677 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1678 0usize,
1679 concat!(
1680 "Offset of field: ",
1681 stringify!(io_uring_files_update),
1682 "::",
1683 stringify!(offset)
1684 )
1685 );
1686 assert_eq!(
1687 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1688 4usize,
1689 concat!(
1690 "Offset of field: ",
1691 stringify!(io_uring_files_update),
1692 "::",
1693 stringify!(resv)
1694 )
1695 );
1696 assert_eq!(
1697 unsafe { ::core::ptr::addr_of!((*ptr).fds) as usize - ptr as usize },
1698 8usize,
1699 concat!(
1700 "Offset of field: ",
1701 stringify!(io_uring_files_update),
1702 "::",
1703 stringify!(fds)
1704 )
1705 );
1706}
1707#[repr(C)]
1708#[derive(Debug, Default, Copy, Clone)]
1709pub struct io_uring_rsrc_register {
1710 pub nr: __u32,
1711 pub flags: __u32,
1712 pub resv2: __u64,
1713 pub data: __u64,
1714 pub tags: __u64,
1715}
1716#[test]
1717fn bindgen_test_layout_io_uring_rsrc_register() {
1718 const UNINIT: ::core::mem::MaybeUninit<io_uring_rsrc_register> =
1719 ::core::mem::MaybeUninit::uninit();
1720 let ptr = UNINIT.as_ptr();
1721 assert_eq!(
1722 ::core::mem::size_of::<io_uring_rsrc_register>(),
1723 32usize,
1724 concat!("Size of: ", stringify!(io_uring_rsrc_register))
1725 );
1726 assert_eq!(
1727 ::core::mem::align_of::<io_uring_rsrc_register>(),
1728 8usize,
1729 concat!("Alignment of ", stringify!(io_uring_rsrc_register))
1730 );
1731 assert_eq!(
1732 unsafe { ::core::ptr::addr_of!((*ptr).nr) as usize - ptr as usize },
1733 0usize,
1734 concat!(
1735 "Offset of field: ",
1736 stringify!(io_uring_rsrc_register),
1737 "::",
1738 stringify!(nr)
1739 )
1740 );
1741 assert_eq!(
1742 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1743 4usize,
1744 concat!(
1745 "Offset of field: ",
1746 stringify!(io_uring_rsrc_register),
1747 "::",
1748 stringify!(flags)
1749 )
1750 );
1751 assert_eq!(
1752 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
1753 8usize,
1754 concat!(
1755 "Offset of field: ",
1756 stringify!(io_uring_rsrc_register),
1757 "::",
1758 stringify!(resv2)
1759 )
1760 );
1761 assert_eq!(
1762 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1763 16usize,
1764 concat!(
1765 "Offset of field: ",
1766 stringify!(io_uring_rsrc_register),
1767 "::",
1768 stringify!(data)
1769 )
1770 );
1771 assert_eq!(
1772 unsafe { ::core::ptr::addr_of!((*ptr).tags) as usize - ptr as usize },
1773 24usize,
1774 concat!(
1775 "Offset of field: ",
1776 stringify!(io_uring_rsrc_register),
1777 "::",
1778 stringify!(tags)
1779 )
1780 );
1781}
1782#[repr(C)]
1783#[derive(Debug, Default, Copy, Clone)]
1784pub struct io_uring_rsrc_update {
1785 pub offset: __u32,
1786 pub resv: __u32,
1787 pub data: __u64,
1788}
1789#[test]
1790fn bindgen_test_layout_io_uring_rsrc_update() {
1791 const UNINIT: ::core::mem::MaybeUninit<io_uring_rsrc_update> =
1792 ::core::mem::MaybeUninit::uninit();
1793 let ptr = UNINIT.as_ptr();
1794 assert_eq!(
1795 ::core::mem::size_of::<io_uring_rsrc_update>(),
1796 16usize,
1797 concat!("Size of: ", stringify!(io_uring_rsrc_update))
1798 );
1799 assert_eq!(
1800 ::core::mem::align_of::<io_uring_rsrc_update>(),
1801 8usize,
1802 concat!("Alignment of ", stringify!(io_uring_rsrc_update))
1803 );
1804 assert_eq!(
1805 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1806 0usize,
1807 concat!(
1808 "Offset of field: ",
1809 stringify!(io_uring_rsrc_update),
1810 "::",
1811 stringify!(offset)
1812 )
1813 );
1814 assert_eq!(
1815 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1816 4usize,
1817 concat!(
1818 "Offset of field: ",
1819 stringify!(io_uring_rsrc_update),
1820 "::",
1821 stringify!(resv)
1822 )
1823 );
1824 assert_eq!(
1825 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1826 8usize,
1827 concat!(
1828 "Offset of field: ",
1829 stringify!(io_uring_rsrc_update),
1830 "::",
1831 stringify!(data)
1832 )
1833 );
1834}
1835#[repr(C)]
1836#[derive(Debug, Default, Copy, Clone)]
1837pub struct io_uring_rsrc_update2 {
1838 pub offset: __u32,
1839 pub resv: __u32,
1840 pub data: __u64,
1841 pub tags: __u64,
1842 pub nr: __u32,
1843 pub resv2: __u32,
1844}
1845#[test]
1846fn bindgen_test_layout_io_uring_rsrc_update2() {
1847 const UNINIT: ::core::mem::MaybeUninit<io_uring_rsrc_update2> =
1848 ::core::mem::MaybeUninit::uninit();
1849 let ptr = UNINIT.as_ptr();
1850 assert_eq!(
1851 ::core::mem::size_of::<io_uring_rsrc_update2>(),
1852 32usize,
1853 concat!("Size of: ", stringify!(io_uring_rsrc_update2))
1854 );
1855 assert_eq!(
1856 ::core::mem::align_of::<io_uring_rsrc_update2>(),
1857 8usize,
1858 concat!("Alignment of ", stringify!(io_uring_rsrc_update2))
1859 );
1860 assert_eq!(
1861 unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1862 0usize,
1863 concat!(
1864 "Offset of field: ",
1865 stringify!(io_uring_rsrc_update2),
1866 "::",
1867 stringify!(offset)
1868 )
1869 );
1870 assert_eq!(
1871 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1872 4usize,
1873 concat!(
1874 "Offset of field: ",
1875 stringify!(io_uring_rsrc_update2),
1876 "::",
1877 stringify!(resv)
1878 )
1879 );
1880 assert_eq!(
1881 unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1882 8usize,
1883 concat!(
1884 "Offset of field: ",
1885 stringify!(io_uring_rsrc_update2),
1886 "::",
1887 stringify!(data)
1888 )
1889 );
1890 assert_eq!(
1891 unsafe { ::core::ptr::addr_of!((*ptr).tags) as usize - ptr as usize },
1892 16usize,
1893 concat!(
1894 "Offset of field: ",
1895 stringify!(io_uring_rsrc_update2),
1896 "::",
1897 stringify!(tags)
1898 )
1899 );
1900 assert_eq!(
1901 unsafe { ::core::ptr::addr_of!((*ptr).nr) as usize - ptr as usize },
1902 24usize,
1903 concat!(
1904 "Offset of field: ",
1905 stringify!(io_uring_rsrc_update2),
1906 "::",
1907 stringify!(nr)
1908 )
1909 );
1910 assert_eq!(
1911 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
1912 28usize,
1913 concat!(
1914 "Offset of field: ",
1915 stringify!(io_uring_rsrc_update2),
1916 "::",
1917 stringify!(resv2)
1918 )
1919 );
1920}
1921#[repr(C)]
1922#[derive(Debug, Default, Copy, Clone)]
1923pub struct io_uring_probe_op {
1924 pub op: __u8,
1925 pub resv: __u8,
1926 pub flags: __u16,
1927 pub resv2: __u32,
1928}
1929#[test]
1930fn bindgen_test_layout_io_uring_probe_op() {
1931 const UNINIT: ::core::mem::MaybeUninit<io_uring_probe_op> = ::core::mem::MaybeUninit::uninit();
1932 let ptr = UNINIT.as_ptr();
1933 assert_eq!(
1934 ::core::mem::size_of::<io_uring_probe_op>(),
1935 8usize,
1936 concat!("Size of: ", stringify!(io_uring_probe_op))
1937 );
1938 assert_eq!(
1939 ::core::mem::align_of::<io_uring_probe_op>(),
1940 4usize,
1941 concat!("Alignment of ", stringify!(io_uring_probe_op))
1942 );
1943 assert_eq!(
1944 unsafe { ::core::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
1945 0usize,
1946 concat!(
1947 "Offset of field: ",
1948 stringify!(io_uring_probe_op),
1949 "::",
1950 stringify!(op)
1951 )
1952 );
1953 assert_eq!(
1954 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
1955 1usize,
1956 concat!(
1957 "Offset of field: ",
1958 stringify!(io_uring_probe_op),
1959 "::",
1960 stringify!(resv)
1961 )
1962 );
1963 assert_eq!(
1964 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1965 2usize,
1966 concat!(
1967 "Offset of field: ",
1968 stringify!(io_uring_probe_op),
1969 "::",
1970 stringify!(flags)
1971 )
1972 );
1973 assert_eq!(
1974 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
1975 4usize,
1976 concat!(
1977 "Offset of field: ",
1978 stringify!(io_uring_probe_op),
1979 "::",
1980 stringify!(resv2)
1981 )
1982 );
1983}
1984#[repr(C)]
1985#[derive(Debug, Default)]
1986pub struct io_uring_probe {
1987 pub last_op: __u8,
1988 pub ops_len: __u8,
1989 pub resv: __u16,
1990 pub resv2: [__u32; 3usize],
1991 pub ops: __IncompleteArrayField<io_uring_probe_op>,
1992}
1993#[test]
1994fn bindgen_test_layout_io_uring_probe() {
1995 const UNINIT: ::core::mem::MaybeUninit<io_uring_probe> = ::core::mem::MaybeUninit::uninit();
1996 let ptr = UNINIT.as_ptr();
1997 assert_eq!(
1998 ::core::mem::size_of::<io_uring_probe>(),
1999 16usize,
2000 concat!("Size of: ", stringify!(io_uring_probe))
2001 );
2002 assert_eq!(
2003 ::core::mem::align_of::<io_uring_probe>(),
2004 4usize,
2005 concat!("Alignment of ", stringify!(io_uring_probe))
2006 );
2007 assert_eq!(
2008 unsafe { ::core::ptr::addr_of!((*ptr).last_op) as usize - ptr as usize },
2009 0usize,
2010 concat!(
2011 "Offset of field: ",
2012 stringify!(io_uring_probe),
2013 "::",
2014 stringify!(last_op)
2015 )
2016 );
2017 assert_eq!(
2018 unsafe { ::core::ptr::addr_of!((*ptr).ops_len) as usize - ptr as usize },
2019 1usize,
2020 concat!(
2021 "Offset of field: ",
2022 stringify!(io_uring_probe),
2023 "::",
2024 stringify!(ops_len)
2025 )
2026 );
2027 assert_eq!(
2028 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2029 2usize,
2030 concat!(
2031 "Offset of field: ",
2032 stringify!(io_uring_probe),
2033 "::",
2034 stringify!(resv)
2035 )
2036 );
2037 assert_eq!(
2038 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2039 4usize,
2040 concat!(
2041 "Offset of field: ",
2042 stringify!(io_uring_probe),
2043 "::",
2044 stringify!(resv2)
2045 )
2046 );
2047 assert_eq!(
2048 unsafe { ::core::ptr::addr_of!((*ptr).ops) as usize - ptr as usize },
2049 16usize,
2050 concat!(
2051 "Offset of field: ",
2052 stringify!(io_uring_probe),
2053 "::",
2054 stringify!(ops)
2055 )
2056 );
2057}
2058#[repr(C)]
2059#[derive(Copy, Clone)]
2060pub struct io_uring_restriction {
2061 pub opcode: __u16,
2062 pub __bindgen_anon_1: io_uring_restriction__bindgen_ty_1,
2063 pub resv: __u8,
2064 pub resv2: [__u32; 3usize],
2065}
2066#[repr(C)]
2067#[derive(Copy, Clone)]
2068pub union io_uring_restriction__bindgen_ty_1 {
2069 pub register_op: __u8,
2070 pub sqe_op: __u8,
2071 pub sqe_flags: __u8,
2072}
2073#[test]
2074fn bindgen_test_layout_io_uring_restriction__bindgen_ty_1() {
2075 const UNINIT: ::core::mem::MaybeUninit<io_uring_restriction__bindgen_ty_1> =
2076 ::core::mem::MaybeUninit::uninit();
2077 let ptr = UNINIT.as_ptr();
2078 assert_eq!(
2079 ::core::mem::size_of::<io_uring_restriction__bindgen_ty_1>(),
2080 1usize,
2081 concat!("Size of: ", stringify!(io_uring_restriction__bindgen_ty_1))
2082 );
2083 assert_eq!(
2084 ::core::mem::align_of::<io_uring_restriction__bindgen_ty_1>(),
2085 1usize,
2086 concat!(
2087 "Alignment of ",
2088 stringify!(io_uring_restriction__bindgen_ty_1)
2089 )
2090 );
2091 assert_eq!(
2092 unsafe { ::core::ptr::addr_of!((*ptr).register_op) as usize - ptr as usize },
2093 0usize,
2094 concat!(
2095 "Offset of field: ",
2096 stringify!(io_uring_restriction__bindgen_ty_1),
2097 "::",
2098 stringify!(register_op)
2099 )
2100 );
2101 assert_eq!(
2102 unsafe { ::core::ptr::addr_of!((*ptr).sqe_op) as usize - ptr as usize },
2103 0usize,
2104 concat!(
2105 "Offset of field: ",
2106 stringify!(io_uring_restriction__bindgen_ty_1),
2107 "::",
2108 stringify!(sqe_op)
2109 )
2110 );
2111 assert_eq!(
2112 unsafe { ::core::ptr::addr_of!((*ptr).sqe_flags) as usize - ptr as usize },
2113 0usize,
2114 concat!(
2115 "Offset of field: ",
2116 stringify!(io_uring_restriction__bindgen_ty_1),
2117 "::",
2118 stringify!(sqe_flags)
2119 )
2120 );
2121}
2122impl Default for io_uring_restriction__bindgen_ty_1 {
2123 fn default() -> Self {
2124 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2125 unsafe {
2126 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2127 s.assume_init()
2128 }
2129 }
2130}
2131#[test]
2132fn bindgen_test_layout_io_uring_restriction() {
2133 const UNINIT: ::core::mem::MaybeUninit<io_uring_restriction> =
2134 ::core::mem::MaybeUninit::uninit();
2135 let ptr = UNINIT.as_ptr();
2136 assert_eq!(
2137 ::core::mem::size_of::<io_uring_restriction>(),
2138 16usize,
2139 concat!("Size of: ", stringify!(io_uring_restriction))
2140 );
2141 assert_eq!(
2142 ::core::mem::align_of::<io_uring_restriction>(),
2143 4usize,
2144 concat!("Alignment of ", stringify!(io_uring_restriction))
2145 );
2146 assert_eq!(
2147 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
2148 0usize,
2149 concat!(
2150 "Offset of field: ",
2151 stringify!(io_uring_restriction),
2152 "::",
2153 stringify!(opcode)
2154 )
2155 );
2156 assert_eq!(
2157 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2158 3usize,
2159 concat!(
2160 "Offset of field: ",
2161 stringify!(io_uring_restriction),
2162 "::",
2163 stringify!(resv)
2164 )
2165 );
2166 assert_eq!(
2167 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2168 4usize,
2169 concat!(
2170 "Offset of field: ",
2171 stringify!(io_uring_restriction),
2172 "::",
2173 stringify!(resv2)
2174 )
2175 );
2176}
2177impl Default for io_uring_restriction {
2178 fn default() -> Self {
2179 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2180 unsafe {
2181 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2182 s.assume_init()
2183 }
2184 }
2185}
2186#[repr(C)]
2187#[derive(Debug, Default, Copy, Clone)]
2188pub struct io_uring_buf {
2189 pub addr: __u64,
2190 pub len: __u32,
2191 pub bid: __u16,
2192 pub resv: __u16,
2193}
2194#[test]
2195fn bindgen_test_layout_io_uring_buf() {
2196 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf> = ::core::mem::MaybeUninit::uninit();
2197 let ptr = UNINIT.as_ptr();
2198 assert_eq!(
2199 ::core::mem::size_of::<io_uring_buf>(),
2200 16usize,
2201 concat!("Size of: ", stringify!(io_uring_buf))
2202 );
2203 assert_eq!(
2204 ::core::mem::align_of::<io_uring_buf>(),
2205 8usize,
2206 concat!("Alignment of ", stringify!(io_uring_buf))
2207 );
2208 assert_eq!(
2209 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
2210 0usize,
2211 concat!(
2212 "Offset of field: ",
2213 stringify!(io_uring_buf),
2214 "::",
2215 stringify!(addr)
2216 )
2217 );
2218 assert_eq!(
2219 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
2220 8usize,
2221 concat!(
2222 "Offset of field: ",
2223 stringify!(io_uring_buf),
2224 "::",
2225 stringify!(len)
2226 )
2227 );
2228 assert_eq!(
2229 unsafe { ::core::ptr::addr_of!((*ptr).bid) as usize - ptr as usize },
2230 12usize,
2231 concat!(
2232 "Offset of field: ",
2233 stringify!(io_uring_buf),
2234 "::",
2235 stringify!(bid)
2236 )
2237 );
2238 assert_eq!(
2239 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2240 14usize,
2241 concat!(
2242 "Offset of field: ",
2243 stringify!(io_uring_buf),
2244 "::",
2245 stringify!(resv)
2246 )
2247 );
2248}
2249#[repr(C)]
2250pub struct io_uring_buf_ring {
2251 pub __bindgen_anon_1: io_uring_buf_ring__bindgen_ty_1,
2252}
2253#[repr(C)]
2254pub struct io_uring_buf_ring__bindgen_ty_1 {
2255 pub __bindgen_anon_1: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>,
2256 pub __bindgen_anon_2: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>,
2257 pub bindgen_union_field: [u64; 2usize],
2258}
2259#[repr(C)]
2260#[derive(Debug, Default, Copy, Clone)]
2261pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1 {
2262 pub resv1: __u64,
2263 pub resv2: __u32,
2264 pub resv3: __u16,
2265 pub tail: __u16,
2266}
2267#[test]
2268fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1() {
2269 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1> =
2270 ::core::mem::MaybeUninit::uninit();
2271 let ptr = UNINIT.as_ptr();
2272 assert_eq!(
2273 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>(),
2274 16usize,
2275 concat!(
2276 "Size of: ",
2277 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1)
2278 )
2279 );
2280 assert_eq!(
2281 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>(),
2282 8usize,
2283 concat!(
2284 "Alignment of ",
2285 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1)
2286 )
2287 );
2288 assert_eq!(
2289 unsafe { ::core::ptr::addr_of!((*ptr).resv1) as usize - ptr as usize },
2290 0usize,
2291 concat!(
2292 "Offset of field: ",
2293 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2294 "::",
2295 stringify!(resv1)
2296 )
2297 );
2298 assert_eq!(
2299 unsafe { ::core::ptr::addr_of!((*ptr).resv2) as usize - ptr as usize },
2300 8usize,
2301 concat!(
2302 "Offset of field: ",
2303 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2304 "::",
2305 stringify!(resv2)
2306 )
2307 );
2308 assert_eq!(
2309 unsafe { ::core::ptr::addr_of!((*ptr).resv3) as usize - ptr as usize },
2310 12usize,
2311 concat!(
2312 "Offset of field: ",
2313 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2314 "::",
2315 stringify!(resv3)
2316 )
2317 );
2318 assert_eq!(
2319 unsafe { ::core::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
2320 14usize,
2321 concat!(
2322 "Offset of field: ",
2323 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1),
2324 "::",
2325 stringify!(tail)
2326 )
2327 );
2328}
2329#[repr(C)]
2330#[derive(Debug, Default)]
2331pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2 {
2332 pub __empty_bufs: io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
2333 pub bufs: __IncompleteArrayField<io_uring_buf>,
2334}
2335#[repr(C)]
2336#[derive(Debug, Default, Copy, Clone)]
2337pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {}
2338#[test]
2339fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1() {
2340 assert_eq!(
2341 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(),
2342 0usize,
2343 concat!(
2344 "Size of: ",
2345 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1)
2346 )
2347 );
2348 assert_eq!(
2349 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1>(),
2350 1usize,
2351 concat!(
2352 "Alignment of ",
2353 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1)
2354 )
2355 );
2356}
2357#[test]
2358fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2() {
2359 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2> =
2360 ::core::mem::MaybeUninit::uninit();
2361 let ptr = UNINIT.as_ptr();
2362 assert_eq!(
2363 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>(),
2364 0usize,
2365 concat!(
2366 "Size of: ",
2367 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2)
2368 )
2369 );
2370 assert_eq!(
2371 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>(),
2372 8usize,
2373 concat!(
2374 "Alignment of ",
2375 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2)
2376 )
2377 );
2378 assert_eq!(
2379 unsafe { ::core::ptr::addr_of!((*ptr).__empty_bufs) as usize - ptr as usize },
2380 0usize,
2381 concat!(
2382 "Offset of field: ",
2383 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2),
2384 "::",
2385 stringify!(__empty_bufs)
2386 )
2387 );
2388 assert_eq!(
2389 unsafe { ::core::ptr::addr_of!((*ptr).bufs) as usize - ptr as usize },
2390 0usize,
2391 concat!(
2392 "Offset of field: ",
2393 stringify!(io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2),
2394 "::",
2395 stringify!(bufs)
2396 )
2397 );
2398}
2399#[test]
2400fn bindgen_test_layout_io_uring_buf_ring__bindgen_ty_1() {
2401 assert_eq!(
2402 ::core::mem::size_of::<io_uring_buf_ring__bindgen_ty_1>(),
2403 16usize,
2404 concat!("Size of: ", stringify!(io_uring_buf_ring__bindgen_ty_1))
2405 );
2406 assert_eq!(
2407 ::core::mem::align_of::<io_uring_buf_ring__bindgen_ty_1>(),
2408 8usize,
2409 concat!("Alignment of ", stringify!(io_uring_buf_ring__bindgen_ty_1))
2410 );
2411}
2412impl Default for io_uring_buf_ring__bindgen_ty_1 {
2413 fn default() -> Self {
2414 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2415 unsafe {
2416 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2417 s.assume_init()
2418 }
2419 }
2420}
2421#[test]
2422fn bindgen_test_layout_io_uring_buf_ring() {
2423 assert_eq!(
2424 ::core::mem::size_of::<io_uring_buf_ring>(),
2425 16usize,
2426 concat!("Size of: ", stringify!(io_uring_buf_ring))
2427 );
2428 assert_eq!(
2429 ::core::mem::align_of::<io_uring_buf_ring>(),
2430 8usize,
2431 concat!("Alignment of ", stringify!(io_uring_buf_ring))
2432 );
2433}
2434impl Default for io_uring_buf_ring {
2435 fn default() -> Self {
2436 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
2437 unsafe {
2438 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2439 s.assume_init()
2440 }
2441 }
2442}
2443pub const IOU_PBUF_RING_MMAP: io_uring_register_pbuf_ring_flags = 1;
2444pub type io_uring_register_pbuf_ring_flags = libc::c_uint;
2445#[repr(C)]
2446#[derive(Debug, Default, Copy, Clone)]
2447pub struct io_uring_buf_reg {
2448 pub ring_addr: __u64,
2449 pub ring_entries: __u32,
2450 pub bgid: __u16,
2451 pub flags: __u16,
2452 pub resv: [__u64; 3usize],
2453}
2454#[test]
2455fn bindgen_test_layout_io_uring_buf_reg() {
2456 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_reg> = ::core::mem::MaybeUninit::uninit();
2457 let ptr = UNINIT.as_ptr();
2458 assert_eq!(
2459 ::core::mem::size_of::<io_uring_buf_reg>(),
2460 40usize,
2461 concat!("Size of: ", stringify!(io_uring_buf_reg))
2462 );
2463 assert_eq!(
2464 ::core::mem::align_of::<io_uring_buf_reg>(),
2465 8usize,
2466 concat!("Alignment of ", stringify!(io_uring_buf_reg))
2467 );
2468 assert_eq!(
2469 unsafe { ::core::ptr::addr_of!((*ptr).ring_addr) as usize - ptr as usize },
2470 0usize,
2471 concat!(
2472 "Offset of field: ",
2473 stringify!(io_uring_buf_reg),
2474 "::",
2475 stringify!(ring_addr)
2476 )
2477 );
2478 assert_eq!(
2479 unsafe { ::core::ptr::addr_of!((*ptr).ring_entries) as usize - ptr as usize },
2480 8usize,
2481 concat!(
2482 "Offset of field: ",
2483 stringify!(io_uring_buf_reg),
2484 "::",
2485 stringify!(ring_entries)
2486 )
2487 );
2488 assert_eq!(
2489 unsafe { ::core::ptr::addr_of!((*ptr).bgid) as usize - ptr as usize },
2490 12usize,
2491 concat!(
2492 "Offset of field: ",
2493 stringify!(io_uring_buf_reg),
2494 "::",
2495 stringify!(bgid)
2496 )
2497 );
2498 assert_eq!(
2499 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2500 14usize,
2501 concat!(
2502 "Offset of field: ",
2503 stringify!(io_uring_buf_reg),
2504 "::",
2505 stringify!(flags)
2506 )
2507 );
2508 assert_eq!(
2509 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2510 16usize,
2511 concat!(
2512 "Offset of field: ",
2513 stringify!(io_uring_buf_reg),
2514 "::",
2515 stringify!(resv)
2516 )
2517 );
2518}
2519#[repr(C)]
2520#[derive(Debug, Default, Copy, Clone)]
2521pub struct io_uring_buf_status {
2522 pub buf_group: __u32,
2523 pub head: __u32,
2524 pub resv: [__u32; 8usize],
2525}
2526#[test]
2527fn bindgen_test_layout_io_uring_buf_status() {
2528 const UNINIT: ::core::mem::MaybeUninit<io_uring_buf_status> =
2529 ::core::mem::MaybeUninit::uninit();
2530 let ptr = UNINIT.as_ptr();
2531 assert_eq!(
2532 ::core::mem::size_of::<io_uring_buf_status>(),
2533 40usize,
2534 concat!("Size of: ", stringify!(io_uring_buf_status))
2535 );
2536 assert_eq!(
2537 ::core::mem::align_of::<io_uring_buf_status>(),
2538 4usize,
2539 concat!("Alignment of ", stringify!(io_uring_buf_status))
2540 );
2541 assert_eq!(
2542 unsafe { ::core::ptr::addr_of!((*ptr).buf_group) as usize - ptr as usize },
2543 0usize,
2544 concat!(
2545 "Offset of field: ",
2546 stringify!(io_uring_buf_status),
2547 "::",
2548 stringify!(buf_group)
2549 )
2550 );
2551 assert_eq!(
2552 unsafe { ::core::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
2553 4usize,
2554 concat!(
2555 "Offset of field: ",
2556 stringify!(io_uring_buf_status),
2557 "::",
2558 stringify!(head)
2559 )
2560 );
2561 assert_eq!(
2562 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2563 8usize,
2564 concat!(
2565 "Offset of field: ",
2566 stringify!(io_uring_buf_status),
2567 "::",
2568 stringify!(resv)
2569 )
2570 );
2571}
2572#[repr(C)]
2573#[derive(Debug, Default, Copy, Clone)]
2574pub struct io_uring_napi {
2575 pub busy_poll_to: __u32,
2576 pub prefer_busy_poll: __u8,
2577 pub pad: [__u8; 3usize],
2578 pub resv: __u64,
2579}
2580#[test]
2581fn bindgen_test_layout_io_uring_napi() {
2582 const UNINIT: ::core::mem::MaybeUninit<io_uring_napi> = ::core::mem::MaybeUninit::uninit();
2583 let ptr = UNINIT.as_ptr();
2584 assert_eq!(
2585 ::core::mem::size_of::<io_uring_napi>(),
2586 16usize,
2587 concat!("Size of: ", stringify!(io_uring_napi))
2588 );
2589 assert_eq!(
2590 ::core::mem::align_of::<io_uring_napi>(),
2591 8usize,
2592 concat!("Alignment of ", stringify!(io_uring_napi))
2593 );
2594 assert_eq!(
2595 unsafe { ::core::ptr::addr_of!((*ptr).busy_poll_to) as usize - ptr as usize },
2596 0usize,
2597 concat!(
2598 "Offset of field: ",
2599 stringify!(io_uring_napi),
2600 "::",
2601 stringify!(busy_poll_to)
2602 )
2603 );
2604 assert_eq!(
2605 unsafe { ::core::ptr::addr_of!((*ptr).prefer_busy_poll) as usize - ptr as usize },
2606 4usize,
2607 concat!(
2608 "Offset of field: ",
2609 stringify!(io_uring_napi),
2610 "::",
2611 stringify!(prefer_busy_poll)
2612 )
2613 );
2614 assert_eq!(
2615 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
2616 5usize,
2617 concat!(
2618 "Offset of field: ",
2619 stringify!(io_uring_napi),
2620 "::",
2621 stringify!(pad)
2622 )
2623 );
2624 assert_eq!(
2625 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2626 8usize,
2627 concat!(
2628 "Offset of field: ",
2629 stringify!(io_uring_napi),
2630 "::",
2631 stringify!(resv)
2632 )
2633 );
2634}
2635pub const IORING_RESTRICTION_REGISTER_OP: io_uring_register_restriction_op = 0;
2636pub const IORING_RESTRICTION_SQE_OP: io_uring_register_restriction_op = 1;
2637pub const IORING_RESTRICTION_SQE_FLAGS_ALLOWED: io_uring_register_restriction_op = 2;
2638pub const IORING_RESTRICTION_SQE_FLAGS_REQUIRED: io_uring_register_restriction_op = 3;
2639pub const IORING_RESTRICTION_LAST: io_uring_register_restriction_op = 4;
2640pub type io_uring_register_restriction_op = libc::c_uint;
2641#[repr(C)]
2642#[derive(Debug, Default, Copy, Clone)]
2643pub struct io_uring_getevents_arg {
2644 pub sigmask: __u64,
2645 pub sigmask_sz: __u32,
2646 pub pad: __u32,
2647 pub ts: __u64,
2648}
2649#[test]
2650fn bindgen_test_layout_io_uring_getevents_arg() {
2651 const UNINIT: ::core::mem::MaybeUninit<io_uring_getevents_arg> =
2652 ::core::mem::MaybeUninit::uninit();
2653 let ptr = UNINIT.as_ptr();
2654 assert_eq!(
2655 ::core::mem::size_of::<io_uring_getevents_arg>(),
2656 24usize,
2657 concat!("Size of: ", stringify!(io_uring_getevents_arg))
2658 );
2659 assert_eq!(
2660 ::core::mem::align_of::<io_uring_getevents_arg>(),
2661 8usize,
2662 concat!("Alignment of ", stringify!(io_uring_getevents_arg))
2663 );
2664 assert_eq!(
2665 unsafe { ::core::ptr::addr_of!((*ptr).sigmask) as usize - ptr as usize },
2666 0usize,
2667 concat!(
2668 "Offset of field: ",
2669 stringify!(io_uring_getevents_arg),
2670 "::",
2671 stringify!(sigmask)
2672 )
2673 );
2674 assert_eq!(
2675 unsafe { ::core::ptr::addr_of!((*ptr).sigmask_sz) as usize - ptr as usize },
2676 8usize,
2677 concat!(
2678 "Offset of field: ",
2679 stringify!(io_uring_getevents_arg),
2680 "::",
2681 stringify!(sigmask_sz)
2682 )
2683 );
2684 assert_eq!(
2685 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
2686 12usize,
2687 concat!(
2688 "Offset of field: ",
2689 stringify!(io_uring_getevents_arg),
2690 "::",
2691 stringify!(pad)
2692 )
2693 );
2694 assert_eq!(
2695 unsafe { ::core::ptr::addr_of!((*ptr).ts) as usize - ptr as usize },
2696 16usize,
2697 concat!(
2698 "Offset of field: ",
2699 stringify!(io_uring_getevents_arg),
2700 "::",
2701 stringify!(ts)
2702 )
2703 );
2704}
2705#[repr(C)]
2706#[derive(Debug, Default, Copy, Clone)]
2707pub struct io_uring_sync_cancel_reg {
2708 pub addr: __u64,
2709 pub fd: __s32,
2710 pub flags: __u32,
2711 pub timeout: __kernel_timespec,
2712 pub opcode: __u8,
2713 pub pad: [__u8; 7usize],
2714 pub pad2: [__u64; 3usize],
2715}
2716#[test]
2717fn bindgen_test_layout_io_uring_sync_cancel_reg() {
2718 const UNINIT: ::core::mem::MaybeUninit<io_uring_sync_cancel_reg> =
2719 ::core::mem::MaybeUninit::uninit();
2720 let ptr = UNINIT.as_ptr();
2721 assert_eq!(
2722 ::core::mem::size_of::<io_uring_sync_cancel_reg>(),
2723 64usize,
2724 concat!("Size of: ", stringify!(io_uring_sync_cancel_reg))
2725 );
2726 assert_eq!(
2727 ::core::mem::align_of::<io_uring_sync_cancel_reg>(),
2728 8usize,
2729 concat!("Alignment of ", stringify!(io_uring_sync_cancel_reg))
2730 );
2731 assert_eq!(
2732 unsafe { ::core::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
2733 0usize,
2734 concat!(
2735 "Offset of field: ",
2736 stringify!(io_uring_sync_cancel_reg),
2737 "::",
2738 stringify!(addr)
2739 )
2740 );
2741 assert_eq!(
2742 unsafe { ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
2743 8usize,
2744 concat!(
2745 "Offset of field: ",
2746 stringify!(io_uring_sync_cancel_reg),
2747 "::",
2748 stringify!(fd)
2749 )
2750 );
2751 assert_eq!(
2752 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2753 12usize,
2754 concat!(
2755 "Offset of field: ",
2756 stringify!(io_uring_sync_cancel_reg),
2757 "::",
2758 stringify!(flags)
2759 )
2760 );
2761 assert_eq!(
2762 unsafe { ::core::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
2763 16usize,
2764 concat!(
2765 "Offset of field: ",
2766 stringify!(io_uring_sync_cancel_reg),
2767 "::",
2768 stringify!(timeout)
2769 )
2770 );
2771 assert_eq!(
2772 unsafe { ::core::ptr::addr_of!((*ptr).opcode) as usize - ptr as usize },
2773 32usize,
2774 concat!(
2775 "Offset of field: ",
2776 stringify!(io_uring_sync_cancel_reg),
2777 "::",
2778 stringify!(opcode)
2779 )
2780 );
2781 assert_eq!(
2782 unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
2783 33usize,
2784 concat!(
2785 "Offset of field: ",
2786 stringify!(io_uring_sync_cancel_reg),
2787 "::",
2788 stringify!(pad)
2789 )
2790 );
2791 assert_eq!(
2792 unsafe { ::core::ptr::addr_of!((*ptr).pad2) as usize - ptr as usize },
2793 40usize,
2794 concat!(
2795 "Offset of field: ",
2796 stringify!(io_uring_sync_cancel_reg),
2797 "::",
2798 stringify!(pad2)
2799 )
2800 );
2801}
2802#[repr(C)]
2803#[derive(Debug, Default, Copy, Clone)]
2804pub struct io_uring_file_index_range {
2805 pub off: __u32,
2806 pub len: __u32,
2807 pub resv: __u64,
2808}
2809#[test]
2810fn bindgen_test_layout_io_uring_file_index_range() {
2811 const UNINIT: ::core::mem::MaybeUninit<io_uring_file_index_range> =
2812 ::core::mem::MaybeUninit::uninit();
2813 let ptr = UNINIT.as_ptr();
2814 assert_eq!(
2815 ::core::mem::size_of::<io_uring_file_index_range>(),
2816 16usize,
2817 concat!("Size of: ", stringify!(io_uring_file_index_range))
2818 );
2819 assert_eq!(
2820 ::core::mem::align_of::<io_uring_file_index_range>(),
2821 8usize,
2822 concat!("Alignment of ", stringify!(io_uring_file_index_range))
2823 );
2824 assert_eq!(
2825 unsafe { ::core::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
2826 0usize,
2827 concat!(
2828 "Offset of field: ",
2829 stringify!(io_uring_file_index_range),
2830 "::",
2831 stringify!(off)
2832 )
2833 );
2834 assert_eq!(
2835 unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
2836 4usize,
2837 concat!(
2838 "Offset of field: ",
2839 stringify!(io_uring_file_index_range),
2840 "::",
2841 stringify!(len)
2842 )
2843 );
2844 assert_eq!(
2845 unsafe { ::core::ptr::addr_of!((*ptr).resv) as usize - ptr as usize },
2846 8usize,
2847 concat!(
2848 "Offset of field: ",
2849 stringify!(io_uring_file_index_range),
2850 "::",
2851 stringify!(resv)
2852 )
2853 );
2854}
2855#[repr(C)]
2856#[derive(Debug, Default, Copy, Clone)]
2857pub struct io_uring_recvmsg_out {
2858 pub namelen: __u32,
2859 pub controllen: __u32,
2860 pub payloadlen: __u32,
2861 pub flags: __u32,
2862}
2863#[test]
2864fn bindgen_test_layout_io_uring_recvmsg_out() {
2865 const UNINIT: ::core::mem::MaybeUninit<io_uring_recvmsg_out> =
2866 ::core::mem::MaybeUninit::uninit();
2867 let ptr = UNINIT.as_ptr();
2868 assert_eq!(
2869 ::core::mem::size_of::<io_uring_recvmsg_out>(),
2870 16usize,
2871 concat!("Size of: ", stringify!(io_uring_recvmsg_out))
2872 );
2873 assert_eq!(
2874 ::core::mem::align_of::<io_uring_recvmsg_out>(),
2875 4usize,
2876 concat!("Alignment of ", stringify!(io_uring_recvmsg_out))
2877 );
2878 assert_eq!(
2879 unsafe { ::core::ptr::addr_of!((*ptr).namelen) as usize - ptr as usize },
2880 0usize,
2881 concat!(
2882 "Offset of field: ",
2883 stringify!(io_uring_recvmsg_out),
2884 "::",
2885 stringify!(namelen)
2886 )
2887 );
2888 assert_eq!(
2889 unsafe { ::core::ptr::addr_of!((*ptr).controllen) as usize - ptr as usize },
2890 4usize,
2891 concat!(
2892 "Offset of field: ",
2893 stringify!(io_uring_recvmsg_out),
2894 "::",
2895 stringify!(controllen)
2896 )
2897 );
2898 assert_eq!(
2899 unsafe { ::core::ptr::addr_of!((*ptr).payloadlen) as usize - ptr as usize },
2900 8usize,
2901 concat!(
2902 "Offset of field: ",
2903 stringify!(io_uring_recvmsg_out),
2904 "::",
2905 stringify!(payloadlen)
2906 )
2907 );
2908 assert_eq!(
2909 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2910 12usize,
2911 concat!(
2912 "Offset of field: ",
2913 stringify!(io_uring_recvmsg_out),
2914 "::",
2915 stringify!(flags)
2916 )
2917 );
2918}
2919pub const SOCKET_URING_OP_SIOCINQ: io_uring_socket_op = 0;
2920pub const SOCKET_URING_OP_SIOCOUTQ: io_uring_socket_op = 1;
2921pub const SOCKET_URING_OP_GETSOCKOPT: io_uring_socket_op = 2;
2922pub const SOCKET_URING_OP_SETSOCKOPT: io_uring_socket_op = 3;
2923pub type io_uring_socket_op = libc::c_uint;
2924#[repr(C)]
2925#[derive(Debug, Default, Copy, Clone)]
2926pub struct futex_waitv {
2927 pub val: __u64,
2928 pub uaddr: __u64,
2929 pub flags: __u32,
2930 pub __reserved: __u32,
2931}
2932#[test]
2933fn bindgen_test_layout_futex_waitv() {
2934 const UNINIT: ::core::mem::MaybeUninit<futex_waitv> = ::core::mem::MaybeUninit::uninit();
2935 let ptr = UNINIT.as_ptr();
2936 assert_eq!(
2937 ::core::mem::size_of::<futex_waitv>(),
2938 24usize,
2939 concat!("Size of: ", stringify!(futex_waitv))
2940 );
2941 assert_eq!(
2942 ::core::mem::align_of::<futex_waitv>(),
2943 8usize,
2944 concat!("Alignment of ", stringify!(futex_waitv))
2945 );
2946 assert_eq!(
2947 unsafe { ::core::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
2948 0usize,
2949 concat!(
2950 "Offset of field: ",
2951 stringify!(futex_waitv),
2952 "::",
2953 stringify!(val)
2954 )
2955 );
2956 assert_eq!(
2957 unsafe { ::core::ptr::addr_of!((*ptr).uaddr) as usize - ptr as usize },
2958 8usize,
2959 concat!(
2960 "Offset of field: ",
2961 stringify!(futex_waitv),
2962 "::",
2963 stringify!(uaddr)
2964 )
2965 );
2966 assert_eq!(
2967 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2968 16usize,
2969 concat!(
2970 "Offset of field: ",
2971 stringify!(futex_waitv),
2972 "::",
2973 stringify!(flags)
2974 )
2975 );
2976 assert_eq!(
2977 unsafe { ::core::ptr::addr_of!((*ptr).__reserved) as usize - ptr as usize },
2978 20usize,
2979 concat!(
2980 "Offset of field: ",
2981 stringify!(futex_waitv),
2982 "::",
2983 stringify!(__reserved)
2984 )
2985 );
2986}