Make io_uring_enter more ergonomic. (#1345)

* Make `io_uring_enter` more ergonomic.

Define a `Sigset` type which fully encapsulates the `linux_raw_sys`
type, and change `io_uring_enter`'s `arg`/`size` arguments to a `&T`
argument where `T` must either be `Sigset` or `io_uring_getevents_arg`
(with `IoringEnterFlags::EXT_ARG` set accordingly).

Supporting this, also define a `KernelSigSet` type, and define our
own versions of `KernelSigaction` and friends.

* Define the `check_renamed_struct` macro.

* Fix FFI type imports.

Author: sunfishcode

CHANGES.md

@@ -230,6 +230,12 @@ advice applies to the end of the file. To convert an arbitrary `u64` value to
 
 [`rustix::fs::fadvise`]: https://docs.rs/rustix/1.0.0/rustix/fs/fn.fadvise.html
 
+[`rustix::io_uring::io_uring_enter`] has a new signature; instead of `arg` and
+`size` providing a raw `*mut c_void` and `usize`, it now takes any `&T` and
+infers the size.
+
+[`rustix::io_uring::io_uring_enter`]: https://docs.rs/rustix/1.0.0/rustix/io_uring/fn.io_uring_enter.html
+
 The [`sigmask`] and [`ts`] fields of [`rustix::io_uring::getevents_arg`]
 changed from `u64` to [`rustix::io_uring::io_uring_ptr`], to better preserve
 pointer provenance.

Cargo.toml

@@ -83,7 +83,7 @@ name = "mod"
 harness = false
 
 [package.metadata.docs.rs]
-features = ["all-apis", "use-libc-sigrt"]
+features = ["all-apis"]
 targets = [
     "x86_64-unknown-linux-gnu",
     "i686-unknown-linux-gnu",
@@ -196,9 +196,6 @@ all-apis = [
     "time",
 ]
 
-# Enable `Signal::rt` and related features, which depend on libc.
-use-libc-sigrt = []
-
 # When using the linux_raw backend, should we use libc for reading the aux
 # vectors, instead of reading them ourselves from /proc/self/auxv?
 use-libc-auxv = []

src/check_types.rs

@@ -106,3 +106,26 @@ macro_rules! check_struct {
         $(check_struct_field!($name, $field));*
     };
 }
+
+/// For the case of renaming, check all fields of a struct.
+macro_rules! check_renamed_struct {
+    ($to_struct:ident, $from_struct:ident, $($field:ident),*) => {
+        // Check the size and alignment.
+        check_renamed_type!($to_struct, $from_struct);
+
+        // Check that we have all the fields.
+        if false {
+            #[allow(unreachable_code)]
+            let _test = $to_struct {
+                $($field: panic!()),*
+            };
+            #[allow(unreachable_code)]
+            let _test = c::$from_struct {
+                $($field: panic!()),*
+            };
+        }
+
+        // Check that the fields have the right sizes and offsets.
+        $(check_renamed_struct_field!($to_struct, $from_struct, $field));*
+    };
+}

src/io_uring/mod.rs

@@ -27,12 +27,13 @@
 mod bindgen_types;
 
 use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
+use crate::utils::option_as_ptr;
 use crate::{backend, io};
 use bindgen_types::*;
 use core::cmp::Ordering;
 use core::ffi::c_void;
 use core::hash::{Hash, Hasher};
-use core::mem::MaybeUninit;
+use core::mem::{size_of, MaybeUninit};
 use core::ptr::{null_mut, write_bytes};
 use linux_raw_sys::net;
 
@@ -47,12 +48,12 @@ pub use crate::fs::{
 };
 pub use crate::io::ReadWriteFlags;
 pub use crate::net::{RecvFlags, SendFlags, SocketFlags};
+pub use crate::sigset::SigSet;
 pub use crate::thread::futex::{
     Wait as FutexWait, WaitFlags as FutexWaitFlags, WaitPtr as FutexWaitPtr,
     WaitvFlags as FutexWaitvFlags,
 };
 pub use crate::timespec::{Nsecs, Secs, Timespec};
-pub use linux_raw_sys::general::sigset_t;
 
 pub use net::{__kernel_sockaddr_storage as sockaddr_storage, msghdr, sockaddr, socklen_t};
 
@@ -123,35 +124,48 @@ pub unsafe fn io_uring_register_with<Fd: AsFd>(
     backend::io_uring::syscalls::io_uring_register_with(fd.as_fd(), opcode, flags, arg, nr_args)
 }
 
-/// `io_uring_enter(fd, to_submit, min_complete, flags, arg, size)`—Initiate
-/// and/or complete asynchronous I/O.
+/// `io_uring_enter2(fd, to_submit, min_complete, flags, arg,
+/// size_of_val(arg))`—Initiate and/or complete asynchronous I/O.
 ///
 /// # Safety
 ///
 /// io_uring operates on raw pointers and raw file descriptors. Users are
 /// responsible for ensuring that memory and resources are only accessed in
 /// valid ways.
 ///
+/// And, `arg` must either be a [`SigSet`] or a [`io_uring_getevents_arg`], and
+/// `flags` must contain [`IoringEnterFlags::EXT_ARG`] if and only if it's a
+/// `io_uring_getevents_arg`.
+///
 /// # References
 ///  - [Linux]
 ///
 /// [Linux]: https://www.man7.org/linux/man-pages/man2/io_uring_enter.2.html
+#[doc(alias = "io_uring_enter2")]
 #[inline]
-pub unsafe fn io_uring_enter<Fd: AsFd>(
+pub unsafe fn io_uring_enter<Fd: AsFd, T>(
     fd: Fd,
     to_submit: u32,
     min_complete: u32,
     flags: IoringEnterFlags,
-    arg: *const c_void,
-    size: usize,
+    arg: Option<&T>,
 ) -> io::Result<u32> {
+    debug_assert!(
+        size_of::<T>() == size_of::<SigSet>()
+            || size_of::<T>() == size_of::<io_uring_getevents_arg>()
+    );
+    debug_assert!(
+        (size_of::<T>() == size_of::<io_uring_getevents_arg>())
+            == (flags.contains(IoringEnterFlags::EXT_ARG))
+    );
+
     backend::io_uring::syscalls::io_uring_enter(
         fd.as_fd(),
         to_submit,
         min_complete,
         flags,
-        arg,
-        size,
+        option_as_ptr(arg).cast::<c_void>(),
+        size_of::<T>(),
     )
 }