#![allow(unsafe_code)]
use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
use crate::{backend, io};
use core::ffi::c_void;
use core::ptr::null_mut;
use linux_raw_sys::general as sys;
#[inline]
pub fn io_uring_setup(entries: u32, params: &mut io_uring_params) -> io::Result<OwnedFd> {
backend::io_uring::syscalls::io_uring_setup(entries, params)
}
#[inline]
pub unsafe fn io_uring_register<Fd: AsFd>(
fd: Fd,
opcode: IoringRegisterOp,
arg: *const c_void,
nr_args: u32,
) -> io::Result<()> {
backend::io_uring::syscalls::io_uring_register(fd.as_fd(), opcode, arg, nr_args)
}
#[inline]
pub unsafe fn io_uring_enter<Fd: AsFd>(
fd: Fd,
to_submit: u32,
min_complete: u32,
flags: IoringEnterFlags,
arg: *const c_void,
size: usize,
) -> io::Result<u32> {
backend::io_uring::syscalls::io_uring_enter(
fd.as_fd(),
to_submit,
min_complete,
flags,
arg,
size,
)
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringEnterFlags: u32 {
const GETEVENTS = sys::IORING_ENTER_GETEVENTS;
const SQ_WAKEUP = sys::IORING_ENTER_SQ_WAKEUP;
const SQ_WAIT = sys::IORING_ENTER_SQ_WAIT;
const EXT_ARG = sys::IORING_ENTER_EXT_ARG;
}
}
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
#[repr(u8)]
#[non_exhaustive]
pub enum IoringRegisterOp {
RegisterBuffers = sys::IORING_REGISTER_BUFFERS as _,
UnregisterBuffers = sys::IORING_UNREGISTER_BUFFERS as _,
RegisterFiles = sys::IORING_REGISTER_FILES as _,
UnregisterFiles = sys::IORING_UNREGISTER_FILES as _,
RegisterEventfd = sys::IORING_REGISTER_EVENTFD as _,
UnregisterEventfd = sys::IORING_UNREGISTER_EVENTFD as _,
RegisterFilesUpdate = sys::IORING_REGISTER_FILES_UPDATE as _,
RegisterEventfdAsync = sys::IORING_REGISTER_EVENTFD_ASYNC as _,
RegisterProbe = sys::IORING_REGISTER_PROBE as _,
RegisterPersonality = sys::IORING_REGISTER_PERSONALITY as _,
UnregisterPersonality = sys::IORING_UNREGISTER_PERSONALITY as _,
RegisterRestrictions = sys::IORING_REGISTER_RESTRICTIONS as _,
RegisterEnableRings = sys::IORING_REGISTER_ENABLE_RINGS as _,
RegisterBuffers2 = sys::IORING_REGISTER_BUFFERS2 as _,
RegisterBuffersUpdate = sys::IORING_REGISTER_BUFFERS_UPDATE as _,
RegisterFiles2 = sys::IORING_REGISTER_FILES2 as _,
RegisterFilesSkip = sys::IORING_REGISTER_FILES_SKIP as _,
RegisterFilesUpdate2 = sys::IORING_REGISTER_FILES_UPDATE2 as _,
RegisterIowqAff = sys::IORING_REGISTER_IOWQ_AFF as _,
UnregisterIowqAff = sys::IORING_UNREGISTER_IOWQ_AFF as _,
RegisterIowqMaxWorkers = sys::IORING_REGISTER_IOWQ_MAX_WORKERS as _,
}
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
#[repr(u8)]
#[non_exhaustive]
pub enum IoringOp {
Nop = sys::IORING_OP_NOP as _,
Accept = sys::IORING_OP_ACCEPT as _,
AsyncCancel = sys::IORING_OP_ASYNC_CANCEL as _,
Close = sys::IORING_OP_CLOSE as _,
Connect = sys::IORING_OP_CONNECT as _,
EpollCtl = sys::IORING_OP_EPOLL_CTL as _,
Fadvise = sys::IORING_OP_FADVISE as _,
Fallocate = sys::IORING_OP_FALLOCATE as _,
FilesUpdate = sys::IORING_OP_FILES_UPDATE as _,
Fsync = sys::IORING_OP_FSYNC as _,
Linkat = sys::IORING_OP_LINKAT as _,
LinkTimeout = sys::IORING_OP_LINK_TIMEOUT as _,
Madvise = sys::IORING_OP_MADVISE as _,
Mkdirat = sys::IORING_OP_MKDIRAT as _,
Openat = sys::IORING_OP_OPENAT as _,
Openat2 = sys::IORING_OP_OPENAT2 as _,
PollAdd = sys::IORING_OP_POLL_ADD as _,
PollRemove = sys::IORING_OP_POLL_REMOVE as _,
ProvideBuffers = sys::IORING_OP_PROVIDE_BUFFERS as _,
Read = sys::IORING_OP_READ as _,
Readv = sys::IORING_OP_READV as _,
ReadFixed = sys::IORING_OP_READ_FIXED as _,
Recv = sys::IORING_OP_RECV as _,
Recvmsg = sys::IORING_OP_RECVMSG as _,
RemoveBuffers = sys::IORING_OP_REMOVE_BUFFERS as _,
Renameat = sys::IORING_OP_RENAMEAT as _,
Send = sys::IORING_OP_SEND as _,
Sendmsg = sys::IORING_OP_SENDMSG as _,
Shutdown = sys::IORING_OP_SHUTDOWN as _,
Splice = sys::IORING_OP_SPLICE as _,
Statx = sys::IORING_OP_STATX as _,
Symlinkat = sys::IORING_OP_SYMLINKAT as _,
SyncFileRange = sys::IORING_OP_SYNC_FILE_RANGE as _,
Tee = sys::IORING_OP_TEE as _,
Timeout = sys::IORING_OP_TIMEOUT as _,
TimeoutRemove = sys::IORING_OP_TIMEOUT_REMOVE as _,
Unlinkat = sys::IORING_OP_UNLINKAT as _,
Write = sys::IORING_OP_WRITE as _,
Writev = sys::IORING_OP_WRITEV as _,
WriteFixed = sys::IORING_OP_WRITE_FIXED as _,
}
impl Default for IoringOp {
#[inline]
fn default() -> Self {
Self::Nop
}
}
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
#[repr(u16)]
#[non_exhaustive]
pub enum IoringRestrictionOp {
RegisterOp = sys::IORING_RESTRICTION_REGISTER_OP as _,
SqeFlagsAllowed = sys::IORING_RESTRICTION_SQE_FLAGS_ALLOWED as _,
SqeFlagsRequired = sys::IORING_RESTRICTION_SQE_FLAGS_REQUIRED as _,
SqeOp = sys::IORING_RESTRICTION_SQE_OP as _,
}
impl Default for IoringRestrictionOp {
#[inline]
fn default() -> Self {
Self::RegisterOp
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringSetupFlags: u32 {
const ATTACH_WQ = sys::IORING_SETUP_ATTACH_WQ;
const CLAMP = sys::IORING_SETUP_CLAMP;
const CQSIZE = sys::IORING_SETUP_CQSIZE;
const IOPOLL = sys::IORING_SETUP_IOPOLL;
const R_DISABLED = sys::IORING_SETUP_R_DISABLED;
const SQPOLL = sys::IORING_SETUP_SQPOLL;
const SQ_AFF = sys::IORING_SETUP_SQ_AFF;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringSqeFlags: u8 {
const ASYNC = 1 << sys::IOSQE_ASYNC_BIT as u8;
const BUFFER_SELECT = 1 << sys::IOSQE_BUFFER_SELECT_BIT as u8;
const FIXED_FILE = 1 << sys::IOSQE_FIXED_FILE_BIT as u8;
const IO_DRAIN = 1 << sys::IOSQE_IO_DRAIN_BIT as u8;
const IO_HARDLINK = 1 << sys::IOSQE_IO_HARDLINK_BIT as u8;
const IO_LINK = 1 << sys::IOSQE_IO_LINK_BIT as u8;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringCqeFlags: u32 {
const BUFFER = sys::IORING_CQE_F_BUFFER as _;
const MORE = sys::IORING_CQE_F_MORE as _;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringFsyncFlags: u32 {
const DATASYNC = sys::IORING_FSYNC_DATASYNC;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringTimeoutFlags: u32 {
const ABS = sys::IORING_TIMEOUT_ABS;
const UPDATE = sys::IORING_TIMEOUT_UPDATE;
const BOOTTIME = sys::IORING_TIMEOUT_BOOTTIME;
const ETIME_SUCCESS = sys::IORING_TIMEOUT_ETIME_SUCCESS;
const REALTIME = sys::IORING_TIMEOUT_REALTIME;
const CLOCK_MASK = sys::IORING_TIMEOUT_CLOCK_MASK;
const UPDATE_MASK = sys::IORING_TIMEOUT_UPDATE_MASK;
const LINK_TIMEOUT_UPDATE = sys::IORING_LINK_TIMEOUT_UPDATE;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct SpliceFlags: u32 {
const FD_IN_FIXED = sys::SPLICE_F_FD_IN_FIXED;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringFeatureFlags: u32 {
const CQE_SKIP = sys::IORING_FEAT_CQE_SKIP;
const CUR_PERSONALITY = sys::IORING_FEAT_CUR_PERSONALITY;
const EXT_ARG = sys::IORING_FEAT_EXT_ARG;
const FAST_POLL = sys::IORING_FEAT_FAST_POLL;
const NATIVE_WORKERS = sys::IORING_FEAT_NATIVE_WORKERS;
const NODROP = sys::IORING_FEAT_NODROP;
const POLL_32BITS = sys::IORING_FEAT_POLL_32BITS;
const RSRC_TAGS = sys::IORING_FEAT_RSRC_TAGS;
const RW_CUR_POS = sys::IORING_FEAT_RW_CUR_POS;
const SINGLE_MMAP = sys::IORING_FEAT_SINGLE_MMAP;
const SQPOLL_NONFIXED = sys::IORING_FEAT_SQPOLL_NONFIXED;
const SUBMIT_STABLE = sys::IORING_FEAT_SUBMIT_STABLE;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringOpFlags: u16 {
const SUPPORTED = sys::IO_URING_OP_SUPPORTED as _;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringSqFlags: u32 {
const NEED_WAKEUP = sys::IORING_SQ_NEED_WAKEUP;
const CQ_OVERFLOW = sys::IORING_SQ_CQ_OVERFLOW;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringCqFlags: u32 {
const EVENTFD_DISABLED = sys::IORING_CQ_EVENTFD_DISABLED;
}
}
bitflags::bitflags! {
#[derive(Default)]
pub struct IoringPollFlags: u32 {
const ADD_MULTI = sys::IORING_POLL_ADD_MULTI;
const UPDATE_EVENTS = sys::IORING_POLL_UPDATE_EVENTS;
const UPDATE_USER_DATA = sys::IORING_POLL_UPDATE_USER_DATA;
}
}
#[allow(missing_docs)]
pub const IORING_CQE_BUFFER_SHIFT: u32 = sys::IORING_CQE_BUFFER_SHIFT as _;
#[allow(missing_docs)]
pub const IORING_OFF_SQ_RING: u64 = sys::IORING_OFF_SQ_RING as _;
#[allow(missing_docs)]
pub const IORING_OFF_CQ_RING: u64 = sys::IORING_OFF_CQ_RING as _;
#[allow(missing_docs)]
pub const IORING_OFF_SQES: u64 = sys::IORING_OFF_SQES as _;
#[inline]
#[doc(alias = "IORING_REGISTER_FILES_SKIP")]
pub const fn io_uring_register_files_skip() -> BorrowedFd<'static> {
let files_skip = sys::IORING_REGISTER_FILES_SKIP as RawFd;
unsafe { BorrowedFd::<'static>::borrow_raw(files_skip) }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct io_uring_ptr {
#[cfg(all(target_pointer_width = "32", target_endian = "big"))]
#[doc(hidden)]
pub __pad32: u32,
#[cfg(all(target_pointer_width = "16", target_endian = "big"))]
#[doc(hidden)]
pub __pad16: u16,
pub ptr: *mut c_void,
#[cfg(all(target_pointer_width = "16", target_endian = "little"))]
#[doc(hidden)]
pub __pad16: u16,
#[cfg(all(target_pointer_width = "32", target_endian = "little"))]
#[doc(hidden)]
pub __pad32: u32,
}
impl From<*mut c_void> for io_uring_ptr {
#[inline]
fn from(ptr: *mut c_void) -> Self {
Self {
ptr,
#[cfg(target_pointer_width = "16")]
__pad16: Default::default(),
#[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
__pad32: Default::default(),
}
}
}
impl Default for io_uring_ptr {
#[inline]
fn default() -> Self {
Self::from(null_mut())
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union io_uring_user_data {
pub u64_: u64,
pub ptr: io_uring_ptr,
}
impl io_uring_user_data {
#[inline]
pub fn u64_(self) -> u64 {
unsafe { self.u64_ }
}
#[inline]
pub fn from_u64(u64_: u64) -> Self {
Self { u64_ }
}
#[inline]
pub fn ptr(self) -> *mut c_void {
unsafe { self.ptr }.ptr
}
#[inline]
pub fn from_ptr(ptr: *mut c_void) -> Self {
Self {
ptr: io_uring_ptr::from(ptr),
}
}
}
impl Default for io_uring_user_data {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl core::fmt::Debug for io_uring_user_data {
fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
unsafe { self.u64_.fmt(fmt) }
}
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone, Default)]
pub struct io_uring_sqe {
pub opcode: IoringOp,
pub flags: IoringSqeFlags,
pub ioprio: u16,
pub fd: RawFd,
pub off_or_addr2: off_or_addr2_union,
pub addr_or_splice_off_in: addr_or_splice_off_in_union,
pub len: u32,
pub op_flags: op_flags_union,
pub user_data: io_uring_user_data,
pub buf: buf_union,
pub personality: u16,
pub splice_fd_in_or_file_index: splice_fd_in_or_file_index_union,
pub __pad2: [u64; 2],
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union off_or_addr2_union {
pub off: u64,
pub addr2: io_uring_ptr,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union addr_or_splice_off_in_union {
pub addr: io_uring_ptr,
pub splice_off_in: u64,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union op_flags_union {
pub rw_flags: crate::io::ReadWriteFlags,
pub fsync_flags: IoringFsyncFlags,
pub poll_events: u16,
pub poll32_events: u32,
pub sync_range_flags: u32,
#[doc(alias = "msg_flags")]
pub send_flags: crate::net::SendFlags,
#[doc(alias = "msg_flags")]
pub recv_flags: crate::net::RecvFlags,
pub timeout_flags: IoringTimeoutFlags,
pub accept_flags: crate::net::AcceptFlags,
pub cancel_flags: u32,
pub open_flags: crate::fs::AtFlags,
pub statx_flags: crate::fs::AtFlags,
pub fadvise_advice: crate::fs::Advice,
pub splice_flags: SpliceFlags,
pub rename_flags: crate::fs::RenameFlags,
pub unlink_flags: crate::fs::AtFlags,
pub hardlink_flags: crate::fs::AtFlags,
}
#[allow(missing_docs)]
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union buf_union {
pub buf_index: u16,
pub buf_group: u16,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union splice_fd_in_or_file_index_union {
pub splice_fd_in: i32,
pub file_index: u32,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_cqe {
pub user_data: io_uring_user_data,
pub res: i32,
pub flags: IoringCqeFlags,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone, Default)]
pub struct io_uring_restriction {
pub opcode: IoringRestrictionOp,
pub register_or_sqe_op_or_sqe_flags: register_or_sqe_op_or_sqe_flags_union,
pub resv: u8,
pub resv2: [u32; 3],
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Copy, Clone)]
pub union register_or_sqe_op_or_sqe_flags_union {
pub register_op: IoringRegisterOp,
pub sqe_op: IoringOp,
pub sqe_flags: IoringSqeFlags,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_params {
pub sq_entries: u32,
pub cq_entries: u32,
pub flags: IoringSetupFlags,
pub sq_thread_cpu: u32,
pub sq_thread_idle: u32,
pub features: IoringFeatureFlags,
pub wq_fd: u32,
pub resv: [u32; 3],
pub sq_off: io_sqring_offsets,
pub cq_off: io_cqring_offsets,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_sqring_offsets {
pub head: u32,
pub tail: u32,
pub ring_mask: u32,
pub ring_entries: u32,
pub flags: u32,
pub dropped: u32,
pub array: u32,
pub resv1: u32,
pub resv2: u64,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_cqring_offsets {
pub head: u32,
pub tail: u32,
pub ring_mask: u32,
pub ring_entries: u32,
pub overflow: u32,
pub cqes: u32,
pub flags: u32,
pub resv1: u32,
pub resv2: u64,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Default)]
pub struct io_uring_probe {
pub last_op: IoringOp,
pub ops_len: u8,
pub resv: u16,
pub resv2: [u32; 3],
pub ops: sys::__IncompleteArrayField<io_uring_probe_op>,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_probe_op {
pub op: IoringOp,
pub resv: u8,
pub flags: IoringOpFlags,
pub resv2: u32,
}
#[allow(missing_docs)]
#[repr(C, align(8))]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_files_update {
pub offset: u32,
pub resv: u32,
pub fds: u64,
}
#[allow(missing_docs)]
#[repr(C, align(8))]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_rsrc_register {
pub nr: u32,
pub resv: u32,
pub resv2: u64,
pub data: u64,
pub tags: u64,
}
#[allow(missing_docs)]
#[repr(C, align(8))]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_rsrc_update {
pub offset: u32,
pub resv: u32,
pub data: u64,
}
#[allow(missing_docs)]
#[repr(C, align(8))]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_rsrc_update2 {
pub offset: u32,
pub resv: u32,
pub data: u64,
pub tags: u64,
pub nr: u32,
pub resv2: u32,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_getevents_arg {
pub sigmask: u64,
pub sigmask_sz: u32,
pub pad: u32,
pub ts: u64,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iovec {
pub iov_base: *mut c_void,
pub iov_len: usize,
}
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone, Default)]
pub struct open_how {
pub flags: u64,
pub mode: u64,
pub resolve: crate::fs::ResolveFlags,
}
impl Default for off_or_addr2_union {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for addr_or_splice_off_in_union {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for op_flags_union {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for buf_union {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for splice_fd_in_or_file_index_union {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for register_or_sqe_op_or_sqe_flags_union {
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
unsafe {
::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[test]
fn io_uring_layouts() {
use core::mem::{align_of, size_of};
use memoffset::{offset_of, span_of};
macro_rules! check_type {
($struct:ident) => {
assert_eq!(
(size_of::<$struct>(), align_of::<$struct>()),
(size_of::<sys::$struct>(), align_of::<sys::$struct>())
);
};
}
macro_rules! check_renamed_union {
($to:ident, $from:ident) => {
assert_eq!(
(size_of::<$to>(), align_of::<$to>()),
(size_of::<sys::$from>(), align_of::<sys::$from>())
);
};
}
macro_rules! check_struct_field {
($struct:ident, $field:ident) => {
assert_eq!(
offset_of!($struct, $field),
offset_of!(sys::$struct, $field)
);
assert_eq!(span_of!($struct, $field), span_of!(sys::$struct, $field));
};
}
macro_rules! check_struct_renamed_union_field {
($struct:ident, $to:ident, $from:ident) => {
assert_eq!(offset_of!($struct, $to), offset_of!(sys::$struct, $from));
assert_eq!(span_of!($struct, $to), span_of!(sys::$struct, $from));
};
}
macro_rules! check_struct {
($name:ident, $($field:ident),*) => {
check_type!($name);
let _test = $name {
$($field: unsafe { core::mem::zeroed() }),*
};
$(check_struct_field!($name, $field));*
};
}
check_renamed_union!(off_or_addr2_union, io_uring_sqe__bindgen_ty_1);
check_renamed_union!(addr_or_splice_off_in_union, io_uring_sqe__bindgen_ty_2);
check_renamed_union!(op_flags_union, io_uring_sqe__bindgen_ty_3);
check_renamed_union!(buf_union, io_uring_sqe__bindgen_ty_4);
check_renamed_union!(splice_fd_in_or_file_index_union, io_uring_sqe__bindgen_ty_5);
check_renamed_union!(
register_or_sqe_op_or_sqe_flags_union,
io_uring_restriction__bindgen_ty_1
);
check_type!(io_uring_sqe);
check_struct_field!(io_uring_sqe, opcode);
check_struct_field!(io_uring_sqe, flags);
check_struct_field!(io_uring_sqe, ioprio);
check_struct_field!(io_uring_sqe, fd);
check_struct_renamed_union_field!(io_uring_sqe, off_or_addr2, __bindgen_anon_1);
check_struct_renamed_union_field!(io_uring_sqe, addr_or_splice_off_in, __bindgen_anon_2);
check_struct_field!(io_uring_sqe, len);
check_struct_renamed_union_field!(io_uring_sqe, op_flags, __bindgen_anon_3);
check_struct_field!(io_uring_sqe, user_data);
check_struct_renamed_union_field!(io_uring_sqe, buf, __bindgen_anon_4);
check_struct_field!(io_uring_sqe, personality);
check_struct_renamed_union_field!(io_uring_sqe, splice_fd_in_or_file_index, __bindgen_anon_5);
check_struct_field!(io_uring_sqe, __pad2);
check_type!(io_uring_restriction);
check_struct_field!(io_uring_restriction, opcode);
check_struct_renamed_union_field!(
io_uring_restriction,
register_or_sqe_op_or_sqe_flags,
__bindgen_anon_1
);
check_struct_field!(io_uring_restriction, resv);
check_struct_field!(io_uring_restriction, resv2);
check_struct!(io_uring_cqe, user_data, res, flags);
check_struct!(
io_uring_params,
sq_entries,
cq_entries,
flags,
sq_thread_cpu,
sq_thread_idle,
features,
wq_fd,
resv,
sq_off,
cq_off
);
check_struct!(
io_sqring_offsets,
head,
tail,
ring_mask,
ring_entries,
flags,
dropped,
array,
resv1,
resv2
);
check_struct!(
io_cqring_offsets,
head,
tail,
ring_mask,
ring_entries,
overflow,
cqes,
flags,
resv1,
resv2
);
check_struct!(io_uring_probe, last_op, ops_len, resv, resv2, ops);
check_struct!(io_uring_probe_op, op, resv, flags, resv2);
check_struct!(io_uring_files_update, offset, resv, fds);
check_struct!(io_uring_rsrc_register, nr, resv, resv2, data, tags);
check_struct!(io_uring_rsrc_update, offset, resv, data);
check_struct!(io_uring_rsrc_update2, offset, resv, data, tags, nr, resv2);
check_struct!(io_uring_getevents_arg, sigmask, sigmask_sz, pad, ts);
check_struct!(iovec, iov_base, iov_len);
check_struct!(open_how, flags, mode, resolve);
}