//!
//! # References
//! - [Linux]
+//! - [io_uring header]
//!
//! [Linux]: https://man.archlinux.org/man/io_uring.7.en
//! [io_uring]: https://en.wikipedia.org/wiki/Io_uring
+//! [io_uring header]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/io_uring.h
#![allow(unsafe_code)]
use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
opcode: IoringRegisterOp,
arg: *const c_void,
nr_args: u32,
-) -> io::Result<()> {
+) -> io::Result<u32> {
backend::io_uring::syscalls::io_uring_register(fd.as_fd(), opcode, arg, nr_args)
}
/// `IORING_REGISTER_IOWQ_MAX_WORKERS`
RegisterIowqMaxWorkers = sys::IORING_REGISTER_IOWQ_MAX_WORKERS as _,
+
+ /// `IORING_REGISTER_RING_FDS`
+ RegisterRingFds = sys::IORING_REGISTER_RING_FDS as _,
+
+ /// `IORING_UNREGISTER_RING_FDS`
+ UnregisterRingFds = sys::IORING_UNREGISTER_RING_FDS as _,
+
+ /// `IORING_REGISTER_PBUF_RING`
+ RegisterPbufRing = sys::IORING_REGISTER_PBUF_RING as _,
+
+ /// `IORING_UNREGISTER_PBUF_RING`
+ UnregisterPbufRing = sys::IORING_UNREGISTER_PBUF_RING as _,
+
+ /// `IORING_REGISTER_SYNC_CANCEL`
+ RegisterSyncCancel = sys::IORING_REGISTER_SYNC_CANCEL as _,
+
+ /// `IORING_REGISTER_FILE_ALLOC_RANGE`
+ RegisterFileAllocRange = sys::IORING_REGISTER_FILE_ALLOC_RANGE as _,
}
/// `IORING_OP_*` constants for use with [`io_uring_sqe`].
#[non_exhaustive]
pub enum IoringOp {
/// `IORING_OP_NOP`
- Nop = sys::IORING_OP_NOP as _,
+ Nop = sys::io_uring_op::IORING_OP_NOP as _,
/// `IORING_OP_ACCEPT`
- Accept = sys::IORING_OP_ACCEPT as _,
+ Accept = sys::io_uring_op::IORING_OP_ACCEPT as _,
/// `IORING_OP_ASYNC_CANCEL`
- AsyncCancel = sys::IORING_OP_ASYNC_CANCEL as _,
+ AsyncCancel = sys::io_uring_op::IORING_OP_ASYNC_CANCEL as _,
/// `IORING_OP_CLOSE`
- Close = sys::IORING_OP_CLOSE as _,
+ Close = sys::io_uring_op::IORING_OP_CLOSE as _,
/// `IORING_OP_CONNECT`
- Connect = sys::IORING_OP_CONNECT as _,
+ Connect = sys::io_uring_op::IORING_OP_CONNECT as _,
/// `IORING_OP_EPOLL_CTL`
- EpollCtl = sys::IORING_OP_EPOLL_CTL as _,
+ EpollCtl = sys::io_uring_op::IORING_OP_EPOLL_CTL as _,
/// `IORING_OP_FADVISE`
- Fadvise = sys::IORING_OP_FADVISE as _,
+ Fadvise = sys::io_uring_op::IORING_OP_FADVISE as _,
/// `IORING_OP_FALLOCATE`
- Fallocate = sys::IORING_OP_FALLOCATE as _,
+ Fallocate = sys::io_uring_op::IORING_OP_FALLOCATE as _,
/// `IORING_OP_FILES_UPDATE`
- FilesUpdate = sys::IORING_OP_FILES_UPDATE as _,
+ FilesUpdate = sys::io_uring_op::IORING_OP_FILES_UPDATE as _,
/// `IORING_OP_FSYNC`
- Fsync = sys::IORING_OP_FSYNC as _,
+ Fsync = sys::io_uring_op::IORING_OP_FSYNC as _,
/// `IORING_OP_LINKAT`
- Linkat = sys::IORING_OP_LINKAT as _,
+ Linkat = sys::io_uring_op::IORING_OP_LINKAT as _,
/// `IORING_OP_LINK_TIMEOUT`
- LinkTimeout = sys::IORING_OP_LINK_TIMEOUT as _,
+ LinkTimeout = sys::io_uring_op::IORING_OP_LINK_TIMEOUT as _,
/// `IORING_OP_MADVISE`
- Madvise = sys::IORING_OP_MADVISE as _,
+ Madvise = sys::io_uring_op::IORING_OP_MADVISE as _,
/// `IORING_OP_MKDIRAT`
- Mkdirat = sys::IORING_OP_MKDIRAT as _,
+ Mkdirat = sys::io_uring_op::IORING_OP_MKDIRAT as _,
/// `IORING_OP_OPENAT`
- Openat = sys::IORING_OP_OPENAT as _,
+ Openat = sys::io_uring_op::IORING_OP_OPENAT as _,
/// `IORING_OP_OPENAT2`
- Openat2 = sys::IORING_OP_OPENAT2 as _,
+ Openat2 = sys::io_uring_op::IORING_OP_OPENAT2 as _,
/// `IORING_OP_POLL_ADD`
- PollAdd = sys::IORING_OP_POLL_ADD as _,
+ PollAdd = sys::io_uring_op::IORING_OP_POLL_ADD as _,
/// `IORING_OP_POLL_REMOVE`
- PollRemove = sys::IORING_OP_POLL_REMOVE as _,
+ PollRemove = sys::io_uring_op::IORING_OP_POLL_REMOVE as _,
/// `IORING_OP_PROVIDE_BUFFERS`
- ProvideBuffers = sys::IORING_OP_PROVIDE_BUFFERS as _,
+ ProvideBuffers = sys::io_uring_op::IORING_OP_PROVIDE_BUFFERS as _,
/// `IORING_OP_READ`
- Read = sys::IORING_OP_READ as _,
+ Read = sys::io_uring_op::IORING_OP_READ as _,
/// `IORING_OP_READV`
- Readv = sys::IORING_OP_READV as _,
+ Readv = sys::io_uring_op::IORING_OP_READV as _,
/// `IORING_OP_READ_FIXED`
- ReadFixed = sys::IORING_OP_READ_FIXED as _,
+ ReadFixed = sys::io_uring_op::IORING_OP_READ_FIXED as _,
/// `IORING_OP_RECV`
- Recv = sys::IORING_OP_RECV as _,
+ Recv = sys::io_uring_op::IORING_OP_RECV as _,
/// `IORING_OP_RECVMSG`
- Recvmsg = sys::IORING_OP_RECVMSG as _,
+ Recvmsg = sys::io_uring_op::IORING_OP_RECVMSG as _,
/// `IORING_OP_REMOVE_BUFFERS`
- RemoveBuffers = sys::IORING_OP_REMOVE_BUFFERS as _,
+ RemoveBuffers = sys::io_uring_op::IORING_OP_REMOVE_BUFFERS as _,
/// `IORING_OP_RENAMEAT`
- Renameat = sys::IORING_OP_RENAMEAT as _,
+ Renameat = sys::io_uring_op::IORING_OP_RENAMEAT as _,
/// `IORING_OP_SEND`
- Send = sys::IORING_OP_SEND as _,
+ Send = sys::io_uring_op::IORING_OP_SEND as _,
/// `IORING_OP_SENDMSG`
- Sendmsg = sys::IORING_OP_SENDMSG as _,
+ Sendmsg = sys::io_uring_op::IORING_OP_SENDMSG as _,
/// `IORING_OP_SHUTDOWN`
- Shutdown = sys::IORING_OP_SHUTDOWN as _,
+ Shutdown = sys::io_uring_op::IORING_OP_SHUTDOWN as _,
/// `IORING_OP_SPLICE`
- Splice = sys::IORING_OP_SPLICE as _,
+ Splice = sys::io_uring_op::IORING_OP_SPLICE as _,
/// `IORING_OP_STATX`
- Statx = sys::IORING_OP_STATX as _,
+ Statx = sys::io_uring_op::IORING_OP_STATX as _,
/// `IORING_OP_SYMLINKAT`
- Symlinkat = sys::IORING_OP_SYMLINKAT as _,
+ Symlinkat = sys::io_uring_op::IORING_OP_SYMLINKAT as _,
/// `IORING_OP_SYNC_FILE_RANGE`
- SyncFileRange = sys::IORING_OP_SYNC_FILE_RANGE as _,
+ SyncFileRange = sys::io_uring_op::IORING_OP_SYNC_FILE_RANGE as _,
/// `IORING_OP_TEE`
- Tee = sys::IORING_OP_TEE as _,
+ Tee = sys::io_uring_op::IORING_OP_TEE as _,
/// `IORING_OP_TIMEOUT`
- Timeout = sys::IORING_OP_TIMEOUT as _,
+ Timeout = sys::io_uring_op::IORING_OP_TIMEOUT as _,
/// `IORING_OP_TIMEOUT_REMOVE`
- TimeoutRemove = sys::IORING_OP_TIMEOUT_REMOVE as _,
+ TimeoutRemove = sys::io_uring_op::IORING_OP_TIMEOUT_REMOVE as _,
/// `IORING_OP_UNLINKAT`
- Unlinkat = sys::IORING_OP_UNLINKAT as _,
+ Unlinkat = sys::io_uring_op::IORING_OP_UNLINKAT as _,
/// `IORING_OP_WRITE`
- Write = sys::IORING_OP_WRITE as _,
+ Write = sys::io_uring_op::IORING_OP_WRITE as _,
/// `IORING_OP_WRITEV`
- Writev = sys::IORING_OP_WRITEV as _,
+ Writev = sys::io_uring_op::IORING_OP_WRITEV as _,
/// `IORING_OP_WRITE_FIXED`
- WriteFixed = sys::IORING_OP_WRITE_FIXED as _,
+ WriteFixed = sys::io_uring_op::IORING_OP_WRITE_FIXED as _,
+
+ /// `IORING_OP_MSG_RING`
+ MsgRing = sys::io_uring_op::IORING_OP_MSG_RING as _,
+
+ /// `IORING_OP_FSETXATTR`
+ Fsetxattr = sys::io_uring_op::IORING_OP_FSETXATTR as _,
+
+ /// `IORING_OP_SETXATTR`
+ Setxattr = sys::io_uring_op::IORING_OP_SETXATTR as _,
+
+ /// `IORING_OP_FGETXATTR`
+ Fgetxattr = sys::io_uring_op::IORING_OP_FGETXATTR as _,
+
+ /// `IORING_OP_GETXATTR`
+ Getxattr = sys::io_uring_op::IORING_OP_GETXATTR as _,
+
+ /// `IORING_OP_SOCKET`
+ Socket = sys::io_uring_op::IORING_OP_SOCKET as _,
+
+ /// `IORING_OP_URING_CMD`
+ UringCmd = sys::io_uring_op::IORING_OP_URING_CMD as _,
+
+ /// `IORING_OP_SEND_ZC`
+ SendZc = sys::io_uring_op::IORING_OP_SEND_ZC as _,
+
+ /// `IORING_OP_SENDMSG_ZC`
+ SendmsgZc = sys::io_uring_op::IORING_OP_SENDMSG_ZC as _,
}
impl Default for IoringOp {
}
}
+/// `IORING_MSG_*` constants which represent commands for use with
+/// [`IoringOp::MsgRing`], (`seq.addr`)
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[repr(u64)]
+#[non_exhaustive]
+pub enum IoringMsgringCmds {
+ /// `IORING_MSG_DATA`
+ Data = sys::IORING_MSG_DATA as _,
+
+ /// `IORING_MSG_SEND_FD`
+ SendFd = sys::IORING_MSG_SEND_FD as _,
+}
+
bitflags::bitflags! {
/// `IORING_SETUP_*` flags for use with [`io_uring_params`].
#[derive(Default)]
/// `IORING_SETUP_SQ_AFF`
const SQ_AFF = sys::IORING_SETUP_SQ_AFF;
+
+ /// `IORING_SETUP_SQE128`
+ const SQE128 = sys::IORING_SETUP_SQE128;
+
+ /// `IORING_SETUP_CQE32`
+ const CQE32 = sys::IORING_SETUP_CQE32;
+
+ /// `IORING_SETUP_SUBMIT_ALL`
+ const SUBMIT_ALL = sys::IORING_SETUP_SUBMIT_ALL;
+
+ /// `IORING_SETUP_COOP_TRASKRUN`
+ const COOP_TASKRUN = sys::IORING_SETUP_COOP_TASKRUN;
+
+ /// `IORING_SETUP_TASKRUN_FLAG`
+ const TASKRUN_FLAG = sys::IORING_SETUP_TASKRUN_FLAG;
+
+ /// `IORING_SETUP_SINGLE_ISSUER`
+ const SINGLE_ISSUER = sys::IORING_SETUP_SINGLE_ISSUER;
+
+ /// `IORING_SETUP_DEFER_TASKRUN`
+ const DEFER_TASKRUN = sys::IORING_SETUP_DEFER_TASKRUN;
}
}
/// `1 << IOSQE_IO_LINK_BIT`
const IO_LINK = 1 << sys::IOSQE_IO_LINK_BIT as u8;
+
+ /// `1 << IOSQE_CQE_SKIP_SUCCESS_BIT`
+ const CQE_SKIP_SUCCESS = 1 << sys::IOSQE_CQE_SKIP_SUCCESS_BIT as u8;
}
}
/// `IORING_CQE_F_MORE`
const MORE = sys::IORING_CQE_F_MORE as _;
+
+ /// `IORING_CQE_F_SOCK_NONEMPTY`
+ const SOCK_NONEMPTY = sys::IORING_CQE_F_SOCK_NONEMPTY as _;
+
+ /// `IORING_CQE_F_NOTIF`
+ const NOTIF = sys::IORING_CQE_F_NOTIF as _;
}
}
}
}
+bitflags::bitflags! {
+ /// `IORING_MSG_RING_*` flags for use with [`io_uring_sqe`].
+ #[derive(Default)]
+ pub struct IoringMsgringFlags: u32 {
+ /// `IORING_MSG_RING_CQE_SKIP`
+ const CQE_SKIP = sys::IORING_MSG_RING_CQE_SKIP;
+ }
+}
+
+bitflags::bitflags! {
+ /// `IORING_ASYNC_CANCEL_*` flags for use with [`io_uring_sqe`].
+ #[derive(Default)]
+ pub struct IoringAsyncCancelFlags: u32 {
+ /// `IORING_ASYNC_CANCEL_ALL`
+ const ALL = sys::IORING_ASYNC_CANCEL_ALL;
+
+ /// `IORING_ASYNC_CANCEL_FD`
+ const FD = sys::IORING_ASYNC_CANCEL_FD;
+
+ /// `IORING_ASYNC_CANCEL_FD`
+ const ANY = sys::IORING_ASYNC_CANCEL_ANY;
+
+ /// `IORING_ASYNC_CANCEL_FD`
+ const FD_FIXED = sys::IORING_ASYNC_CANCEL_FD_FIXED;
+ }
+}
+
bitflags::bitflags! {
/// `IORING_FEAT_*` flags for use with [`io_uring_params`].
#[derive(Default)]
/// `IORING_FEAT_SUBMIT_STABLE`
const SUBMIT_STABLE = sys::IORING_FEAT_SUBMIT_STABLE;
+
+ /// `IORING_FEAT_LINKED_FILE`
+ const LINKED_FILE = sys::IORING_FEAT_LINKED_FILE;
}
}
}
}
+bitflags::bitflags! {
+ /// `IORING_RSRC_*` flags for use with [`io_uring_rsrc_register`].
+ #[derive(Default)]
+ pub struct IoringRsrcFlags: u32 {
+ /// `IORING_RSRC_REGISTER_SPARSE`
+ const REGISTER_SPARSE = sys::IORING_RSRC_REGISTER_SPARSE as _;
+ }
+}
+
bitflags::bitflags! {
/// `IORING_SQ_*` flags.
#[derive(Default)]
/// `IORING_SQ_CQ_OVERFLOW`
const CQ_OVERFLOW = sys::IORING_SQ_CQ_OVERFLOW;
+
+ /// `IORING_SQ_TASKRUN`
+ const TASKRUN = sys::IORING_SQ_TASKRUN;
}
}
/// `IORING_POLL_UPDATE_USER_DATA`
const UPDATE_USER_DATA = sys::IORING_POLL_UPDATE_USER_DATA;
+
+ /// `IORING_POLL_ADD_LEVEL`
+ const ADD_LEVEL = sys::IORING_POLL_ADD_LEVEL;
+ }
+}
+
+bitflags::bitflags! {
+ /// send/sendmsg flags (`sqe.ioprio`)
+ #[derive(Default)]
+ pub struct IoringSendFlags: u16 {
+ /// `IORING_RECVSEND_POLL_FIRST`.
+ ///
+ /// See also [`IoringRecvFlags::POLL_FIRST`].
+ const POLL_FIRST = sys::IORING_RECVSEND_POLL_FIRST as _;
+
+ /// `IORING_RECVSEND_FIXED_BUF`
+ ///
+ /// See also [`IoringRecvFlags::FIXED_BUF`].
+ const FIXED_BUF = sys::IORING_RECVSEND_FIXED_BUF as _;
+
+ /// `IORING_SEND_ZC_REPORT_USAGE` (since Linux 6.2)
+ const ZC_REPORT_USAGE = sys::IORING_SEND_ZC_REPORT_USAGE as _;
+ }
+}
+
+bitflags::bitflags! {
+ /// recv/recvmsg flags (`sqe.ioprio`)
+ #[derive(Default)]
+ pub struct IoringRecvFlags: u16 {
+ /// `IORING_RECVSEND_POLL_FIRST`
+ ///
+ /// See also [`IoringSendFlags::POLL_FIRST`].
+ const POLL_FIRST = sys::IORING_RECVSEND_POLL_FIRST as _;
+
+ /// `IORING_RECV_MULTISHOT`
+ const MULTISHOT = sys::IORING_RECV_MULTISHOT as _;
+
+ /// `IORING_RECVSEND_FIXED_BUF`
+ ///
+ /// See also [`IoringSendFlags::FIXED_BUF`].
+ const FIXED_BUF = sys::IORING_RECVSEND_FIXED_BUF as _;
+ }
+}
+
+bitflags::bitflags! {
+ /// accept flags (`sqe.ioprio`)
+ #[derive(Default)]
+ pub struct IoringAcceptFlags: u16 {
+ /// `IORING_ACCEPT_MULTISHOT`
+ const MULTISHOT = sys::IORING_ACCEPT_MULTISHOT as _;
+ }
+}
+
+bitflags::bitflags! {
+ /// recvmsg out flags
+ #[derive(Default)]
+ pub struct RecvmsgOutFlags: u32 {
+ /// `MSG_EOR`
+ const EOR = sys::MSG_EOR;
+
+ /// `MSG_TRUNC`
+ const TRUNC = sys::MSG_TRUNC;
+
+ /// `MSG_CTRUNC`
+ const CTRUNC = sys::MSG_CTRUNC;
+
+ /// `MSG_OOB`
+ const OOB = sys::MSG_OOB;
+
+ /// `MSG_ERRQUEUE`
+ const ERRQUEUE = sys::MSG_ERRQUEUE;
}
}
#[allow(missing_docs)]
pub const IORING_CQE_BUFFER_SHIFT: u32 = sys::IORING_CQE_BUFFER_SHIFT as _;
+#[allow(missing_docs)]
+pub const IORING_FILE_INDEX_ALLOC: i32 = sys::IORING_FILE_INDEX_ALLOC as _;
// Re-export these as `u64`, which is the `offset` type in `rustix::io::mmap`.
#[allow(missing_docs)]
pub const fn io_uring_register_files_skip() -> BorrowedFd<'static> {
let files_skip = sys::IORING_REGISTER_FILES_SKIP as RawFd;
- // Safety: `IORING_REGISTER_FILES_SKIP` is a reserved value that is never
+ // SAFETY: `IORING_REGISTER_FILES_SKIP` is a reserved value that is never
// dynamically allocated, so it'll remain valid for the duration of
// `'static`.
unsafe { BorrowedFd::<'static>::borrow_raw(files_skip) }
}
+/// `IORING_NOTIF_USAGE_ZC_COPIED` (since Linux 6.2)
+pub const IORING_NOTIF_USAGE_ZC_COPIED: i32 = sys::IORING_NOTIF_USAGE_ZC_COPIED as _;
+
/// A pointer in the io_uring API.
///
/// `io_uring`'s native API represents pointers as `u64` values. In order to
/// Return the `u64` value.
#[inline]
pub fn u64_(self) -> u64 {
- // Safety: All the fields have the same underlying representation.
+ // SAFETY: All the fields have the same underlying representation.
unsafe { self.u64_ }
}
/// Return the `ptr` pointer value.
#[inline]
pub fn ptr(self) -> *mut c_void {
- // Safety: All the fields have the same underlying representation.
+ // SAFETY: All the fields have the same underlying representation.
unsafe { self.ptr }.ptr
}
#[inline]
fn default() -> Self {
let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
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 {
- // Safety: Just format as a `u64`, since formatting doesn't preserve
+ // SAFETY: Just format as a `u64`, since formatting doesn't preserve
// provenance, and we don't have a discriminant.
unsafe { self.u64_.fmt(fmt) }
}
pub struct io_uring_sqe {
pub opcode: IoringOp,
pub flags: IoringSqeFlags,
- pub ioprio: u16,
+ pub ioprio: ioprio_union,
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 len: len_union,
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],
+ pub addr3_or_cmd: addr3_or_cmd_union,
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ioprio_union {
+ pub recv_flags: IoringRecvFlags,
+ pub send_flags: IoringSendFlags,
+ pub accept_flags: IoringAcceptFlags,
+ pub ioprio: u16,
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union len_union {
+ pub poll_flags: IoringPollFlags,
+ pub len: u32,
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union addr3_or_cmd_union {
+ pub addr3: addr3_struct,
+ pub cmd: [u8; 0],
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct addr3_struct {
+ pub addr3: u64,
+ pub __pad2: [u64; 1],
}
#[allow(missing_docs)]
pub union off_or_addr2_union {
pub off: u64,
pub addr2: io_uring_ptr,
+ pub cmd_op: cmd_op_struct,
+ pub user_data: io_uring_user_data,
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct cmd_op_struct {
+ pub cmd_op: u32,
+ pub __pad1: u32,
}
#[allow(missing_docs)]
pub union addr_or_splice_off_in_union {
pub addr: io_uring_ptr,
pub splice_off_in: u64,
+ pub msgring_cmd: IoringMsgringCmds,
+ pub user_data: io_uring_user_data,
}
#[allow(missing_docs)]
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 cancel_flags: IoringAsyncCancelFlags,
+ pub open_flags: crate::fs::OFlags,
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,
+ pub msg_ring_flags: IoringMsgringFlags,
}
#[allow(missing_docs)]
#[derive(Debug, Copy, Clone, Default)]
pub struct io_uring_rsrc_register {
pub nr: u32,
- pub resv: u32,
+ pub flags: IoringRsrcFlags,
pub resv2: u64,
pub data: u64,
pub tags: u64,
pub ts: u64,
}
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct io_uring_recvmsg_out {
+ pub namelen: u32,
+ pub controllen: u32,
+ pub payloadlen: u32,
+ pub flags: RecvmsgOutFlags,
+}
+
#[allow(missing_docs)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub resolve: crate::fs::ResolveFlags,
}
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Default)]
+pub struct io_uring_buf_reg {
+ pub ring_addr: u64,
+ pub ring_entries: u32,
+ pub bgid: u16,
+ pub pad: u16,
+ pub resv: [u64; 3_usize],
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, Default)]
+pub struct io_uring_buf {
+ pub addr: u64,
+ pub len: u32,
+ pub bid: u16,
+ pub resv: u16,
+}
+
+impl Default for ioprio_union {
+ #[inline]
+ fn default() -> Self {
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
+ }
+}
+
+impl Default for len_union {
+ #[inline]
+ fn default() -> Self {
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
+ }
+}
+
impl Default for off_or_addr2_union {
#[inline]
fn default() -> Self {
- let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
- unsafe {
- ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
- s.assume_init()
- }
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
}
}
impl Default for addr_or_splice_off_in_union {
#[inline]
fn default() -> Self {
- let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
- unsafe {
- ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
- s.assume_init()
- }
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
+ }
+}
+
+impl Default for addr3_or_cmd_union {
+ #[inline]
+ fn default() -> Self {
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
}
}
impl Default for op_flags_union {
#[inline]
fn default() -> Self {
- let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
- unsafe {
- ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
- s.assume_init()
- }
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
}
}
impl Default for buf_union {
#[inline]
fn default() -> Self {
- let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
- unsafe {
- ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
- s.assume_init()
- }
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
}
}
impl Default for splice_fd_in_or_file_index_union {
#[inline]
fn default() -> Self {
- let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
- unsafe {
- ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
- s.assume_init()
- }
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
}
}
impl Default for register_or_sqe_op_or_sqe_flags_union {
#[inline]
fn default() -> Self {
- let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
- // Safety: All of Linux's io_uring structs may be zero-initialized.
- unsafe {
- ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
- s.assume_init()
- }
+ // SAFETY: All of Linux's io_uring structs may be zero-initialized.
+ unsafe { ::core::mem::zeroed::<Self>() }
}
}
};
}
- // The same as `check_type`, but for unions we've renamed to avoid having
- // types like "bindgen_ty_1" in the API.
- macro_rules! check_renamed_union {
+ // The same as `check_type`, but for unions and anonymous structs we've
+ // renamed to avoid having types like "bindgen_ty_1" in the API.
+ macro_rules! check_renamed_type {
($to:ident, $from:ident) => {
assert_eq!(
(size_of::<$to>(), align_of::<$to>()),
};
}
- // The same as `check_struct_field`, but for unions we've renamed to avoid
- // having types like "bindgen_ty_1" in the API.
- macro_rules! check_struct_renamed_union_field {
+ // The same as `check_struct_field`, but for unions and anonymous structs
+ // we've renamed to avoid having types like "bindgen_ty_1" in the API.
+ macro_rules! check_struct_renamed_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));
// Check that we have all the fields.
let _test = $name {
- // Safety: All of io_uring's types can be zero-initialized.
+ // SAFETY: All of io_uring's types can be zero-initialized.
$($field: unsafe { core::mem::zeroed() }),*
};
};
}
- 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!(
+ check_renamed_type!(off_or_addr2_union, io_uring_sqe__bindgen_ty_1);
+ check_renamed_type!(addr_or_splice_off_in_union, io_uring_sqe__bindgen_ty_2);
+ check_renamed_type!(addr3_or_cmd_union, io_uring_sqe__bindgen_ty_6);
+ check_renamed_type!(op_flags_union, io_uring_sqe__bindgen_ty_3);
+ check_renamed_type!(buf_union, io_uring_sqe__bindgen_ty_4);
+ check_renamed_type!(splice_fd_in_or_file_index_union, io_uring_sqe__bindgen_ty_5);
+ check_renamed_type!(
register_or_sqe_op_or_sqe_flags_union,
io_uring_restriction__bindgen_ty_1
);
+ check_renamed_type!(addr3_struct, io_uring_sqe__bindgen_ty_6__bindgen_ty_1);
+ check_renamed_type!(cmd_op_struct, io_uring_sqe__bindgen_ty_1__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_renamed_field!(io_uring_sqe, off_or_addr2, __bindgen_anon_1);
+ check_struct_renamed_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_renamed_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_renamed_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_struct_renamed_field!(io_uring_sqe, splice_fd_in_or_file_index, __bindgen_anon_5);
+ check_struct_renamed_field!(io_uring_sqe, addr3_or_cmd, __bindgen_anon_6);
check_type!(io_uring_restriction);
check_struct_field!(io_uring_restriction, opcode);
- check_struct_renamed_union_field!(
+ check_struct_renamed_field!(
io_uring_restriction,
register_or_sqe_op_or_sqe_flags,
__bindgen_anon_1
resv1,
resv2
);
+ check_struct!(io_uring_recvmsg_out, namelen, controllen, payloadlen, flags);
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_register, nr, flags, 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);
+ check_struct!(io_uring_buf_reg, ring_addr, ring_entries, bgid, pad, resv);
+ check_struct!(io_uring_buf, addr, len, bid, resv);
}
projects / rustc.git / blobdiff