diff options
Diffstat (limited to 'vendor/rustix/src/io_uring.rs')
| -rw-r--r-- | vendor/rustix/src/io_uring.rs | 511 |
1 files changed, 402 insertions, 109 deletions
diff --git a/vendor/rustix/src/io_uring.rs b/vendor/rustix/src/io_uring.rs index 2f67107ba..0a7dc0872 100644 --- a/vendor/rustix/src/io_uring.rs +++ b/vendor/rustix/src/io_uring.rs @@ -14,9 +14,11 @@ //! //! # 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}; @@ -56,7 +58,7 @@ pub unsafe fn io_uring_register<Fd: AsFd>( 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) } @@ -178,6 +180,24 @@ pub enum IoringRegisterOp { /// `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`]. @@ -186,124 +206,151 @@ pub enum IoringRegisterOp { #[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 { @@ -338,6 +385,19 @@ impl Default for IoringRestrictionOp { } } +/// `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)] @@ -362,6 +422,27 @@ bitflags::bitflags! { /// `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; } } @@ -386,6 +467,9 @@ bitflags::bitflags! { /// `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; } } @@ -398,6 +482,12 @@ bitflags::bitflags! { /// `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 _; } } @@ -451,6 +541,33 @@ bitflags::bitflags! { } 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)] pub struct IoringFeatureFlags: u32 { @@ -489,6 +606,9 @@ bitflags::bitflags! { /// `IORING_FEAT_SUBMIT_STABLE` const SUBMIT_STABLE = sys::IORING_FEAT_SUBMIT_STABLE; + + /// `IORING_FEAT_LINKED_FILE` + const LINKED_FILE = sys::IORING_FEAT_LINKED_FILE; } } @@ -502,6 +622,15 @@ bitflags::bitflags! { } 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)] pub struct IoringSqFlags: u32 { @@ -510,6 +639,9 @@ bitflags::bitflags! { /// `IORING_SQ_CQ_OVERFLOW` const CQ_OVERFLOW = sys::IORING_SQ_CQ_OVERFLOW; + + /// `IORING_SQ_TASKRUN` + const TASKRUN = sys::IORING_SQ_TASKRUN; } } @@ -534,11 +666,84 @@ bitflags::bitflags! { /// `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)] @@ -554,12 +759,15 @@ pub const IORING_OFF_SQES: u64 = sys::IORING_OFF_SQES as _; 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 @@ -626,7 +834,7 @@ impl io_uring_user_data { /// 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_ } } @@ -639,7 +847,7 @@ impl io_uring_user_data { /// 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 } @@ -656,7 +864,7 @@ impl Default for io_uring_user_data { #[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() @@ -666,7 +874,7 @@ impl Default for io_uring_user_data { 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) } } @@ -679,17 +887,51 @@ impl core::fmt::Debug for io_uring_user_data { 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)] @@ -698,6 +940,16 @@ pub struct io_uring_sqe { 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)] @@ -706,6 +958,8 @@ pub union off_or_addr2_union { 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)] @@ -725,14 +979,15 @@ pub union op_flags_union { 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)] @@ -861,7 +1116,7 @@ pub struct io_uring_files_update { #[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, @@ -900,6 +1155,16 @@ pub struct io_uring_getevents_arg { #[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 struct iovec { pub iov_base: *mut c_void, @@ -923,75 +1188,96 @@ pub struct open_how { 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>() } } } @@ -1012,9 +1298,9 @@ fn io_uring_layouts() { }; } - // 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>()), @@ -1035,9 +1321,9 @@ fn io_uring_layouts() { }; } - // 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)); @@ -1052,7 +1338,7 @@ fn io_uring_layouts() { // 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() }),* }; @@ -1061,34 +1347,38 @@ fn io_uring_layouts() { }; } - 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 @@ -1134,13 +1424,16 @@ fn io_uring_layouts() { 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); } |