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