Implement futex_waitv. (#1329)

Implement the new `futex_waitv` syscall, as well as the corresponding
io_uring support.

Author: sunfishcode

Cargo.toml

@@ -123,7 +123,7 @@ event = []
 fs = []
 
 # Enable `rustix::io_uring::*` (on platforms that support it).
-io_uring = ["event", "fs", "net", "linux-raw-sys/io_uring"]
+io_uring = ["event", "fs", "net", "thread", "linux-raw-sys/io_uring"]
 
 # Enable `rustix::mount::*`.
 mount = []

src/backend/libc/thread/futex.rs

@@ -11,6 +11,42 @@ bitflags::bitflags! {
         const PRIVATE = bitcast!(c::FUTEX_PRIVATE_FLAG);
         /// `FUTEX_CLOCK_REALTIME`
         const CLOCK_REALTIME = bitcast!(c::FUTEX_CLOCK_REALTIME);
+
+        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
+        const _ = !0;
+    }
+}
+
+bitflags::bitflags! {
+    /// `FUTEX2_*` flags for use with the functions in [`Waitv`].
+    ///
+    /// Not to be confused with [`WaitvFlags`], which is passed as an argument
+    /// to the `waitv` function.
+    ///
+    /// [`Waitv`]: crate::thread::futex::Waitv
+    /// [`WaitvFlags`]: crate::thread::futex::WaitvFlags
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct WaitFlags: u32 {
+        /// `FUTEX_U8`
+        const SIZE_U8 = linux_raw_sys::general::FUTEX2_SIZE_U8;
+        /// `FUTEX_U16`
+        const SIZE_U16 = linux_raw_sys::general::FUTEX2_SIZE_U16;
+        /// `FUTEX_U32`
+        const SIZE_U32 = linux_raw_sys::general::FUTEX2_SIZE_U32;
+        /// `FUTEX_U64`
+        const SIZE_U64 = linux_raw_sys::general::FUTEX2_SIZE_U64;
+        /// `FUTEX_SIZE_MASK`
+        const SIZE_MASK = linux_raw_sys::general::FUTEX2_SIZE_MASK;
+
+        /// `FUTEX2_NUMA`
+        const NUMA = linux_raw_sys::general::FUTEX2_NUMA;
+
+        /// `FUTEX2_PRIVATE`
+        const PRIVATE = linux_raw_sys::general::FUTEX2_PRIVATE;
+
+        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
+        const _ = !0;
     }
 }
 

src/backend/libc/thread/syscalls.rs

@@ -27,11 +27,7 @@ use crate::thread::{NanosleepRelativeResult, Timespec};
 use crate::timespec::LibcTimespec;
 #[cfg(not(fix_y2038))]
 use crate::timespec::{as_libc_timespec_mut_ptr, as_libc_timespec_ptr};
-#[cfg(all(
-    linux_kernel,
-    target_pointer_width = "32",
-    not(any(target_arch = "aarch64", target_arch = "x86_64"))
-))]
+#[cfg(linux_kernel)]
 use crate::utils::option_as_ptr;
 use core::mem::MaybeUninit;
 #[cfg(linux_kernel)]
@@ -653,6 +649,42 @@ unsafe fn futex_old_timespec(
     ) as isize)
 }
 
+#[cfg(linux_kernel)]
+pub(crate) fn futex_waitv(
+    waiters: &[futex::Wait],
+    flags: futex::WaitvFlags,
+    timeout: Option<&Timespec>,
+    clockid: ClockId,
+) -> io::Result<usize> {
+    use futex::Wait as FutexWait;
+    use linux_raw_sys::general::{__kernel_clockid_t as clockid_t, __kernel_timespec as timespec};
+    syscall! {
+        fn futex_waitv(
+            waiters: *const FutexWait,
+            nr_futexes: c::c_uint,
+            flags: c::c_uint,
+            timeout: *const timespec,
+            clockid: clockid_t
+        ) via SYS_futex_waitv -> c::c_int
+    }
+
+    let nr_futexes: c::c_uint = waiters.len().try_into().map_err(|_| io::Errno::INVAL)?;
+
+    #[cfg(test)]
+    assert_eq_size!(timespec, Timespec);
+
+    unsafe {
+        ret_c_int(futex_waitv(
+            waiters.as_ptr(),
+            nr_futexes,
+            flags.bits(),
+            option_as_ptr(timeout).cast(),
+            clockid as _,
+        ))
+        .map(|n| n as usize)
+    }
+}
+
 #[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn setgroups_thread(groups: &[crate::ugid::Gid]) -> io::Result<()> {

src/backend/linux_raw/c.rs

@@ -12,6 +12,8 @@ pub(crate) use linux_raw_sys::errno::{EBADF, EINVAL};
 pub(crate) use linux_raw_sys::general::{__kernel_fd_set as fd_set, __FD_SETSIZE as FD_SETSIZE};
 pub(crate) use linux_raw_sys::ioctl::{FIONBIO, FIONREAD};
 // Import the kernel's `uid_t` and `gid_t` if they're 32-bit.
+#[cfg(feature = "thread")]
+pub(crate) use linux_raw_sys::general::futex_waitv;
 #[cfg(not(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86")))]
 pub(crate) use linux_raw_sys::general::{__kernel_gid_t as gid_t, __kernel_uid_t as uid_t};
 pub(crate) use linux_raw_sys::general::{

src/backend/linux_raw/thread/futex.rs

@@ -10,9 +10,41 @@ bitflags::bitflags! {
         /// `FUTEX_CLOCK_REALTIME`
         const CLOCK_REALTIME = linux_raw_sys::general::FUTEX_CLOCK_REALTIME;
 
-        // This deliberately lacks a `const _ = !0`, so that users can use
-        // `from_bits_truncate` to extract the `SocketFlags` from a flags
-        // value that also includes a `SocketType`.
+        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
+        const _ = !0;
+    }
+}
+
+bitflags::bitflags! {
+    /// `FUTEX2_*` flags for use with the functions in [`Waitv`].
+    ///
+    /// Not to be confused with [`WaitvFlags`], which is passed as an argument
+    /// to the `waitv` function.
+    ///
+    /// [`Waitv`]: crate::thread::futex::Waitv
+    /// [`WaitvFlags`]: crate::thread::futex::WaitvFlags
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct WaitFlags: u32 {
+        /// `FUTEX_U8`
+        const SIZE_U8 = linux_raw_sys::general::FUTEX2_SIZE_U8;
+        /// `FUTEX_U16`
+        const SIZE_U16 = linux_raw_sys::general::FUTEX2_SIZE_U16;
+        /// `FUTEX_U32`
+        const SIZE_U32 = linux_raw_sys::general::FUTEX2_SIZE_U32;
+        /// `FUTEX_U64`
+        const SIZE_U64 = linux_raw_sys::general::FUTEX2_SIZE_U64;
+        /// `FUTEX_SIZE_MASK`
+        const SIZE_MASK = linux_raw_sys::general::FUTEX2_SIZE_MASK;
+
+        /// `FUTEX2_NUMA`
+        const NUMA = linux_raw_sys::general::FUTEX2_NUMA;
+
+        /// `FUTEX2_PRIVATE`
+        const PRIVATE = linux_raw_sys::general::FUTEX2_PRIVATE;
+
+        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
+        const _ = !0;
     }
 }
 

src/backend/linux_raw/thread/syscalls.rs

@@ -17,12 +17,12 @@ use crate::pid::Pid;
 use crate::thread::{
     futex, ClockId, Cpuid, MembarrierCommand, MembarrierQuery, NanosleepRelativeResult, Timespec,
 };
-use crate::utils::as_mut_ptr;
+use crate::utils::{as_mut_ptr, option_as_ptr};
 use core::mem::MaybeUninit;
 use core::sync::atomic::AtomicU32;
-use linux_raw_sys::general::{membarrier_cmd, membarrier_cmd_flag, TIMER_ABSTIME};
 #[cfg(target_pointer_width = "32")]
-use {crate::utils::option_as_ptr, linux_raw_sys::general::timespec as __kernel_old_timespec};
+use linux_raw_sys::general::timespec as __kernel_old_timespec;
+use linux_raw_sys::general::{membarrier_cmd, membarrier_cmd_flag, TIMER_ABSTIME};
 
 #[inline]
 pub(crate) fn clock_nanosleep_relative(id: ClockId, req: &Timespec) -> NanosleepRelativeResult {
@@ -327,6 +327,27 @@ unsafe fn futex_old_timespec(
         c_uint(val3)
     ))
 }
+
+#[inline]
+pub(crate) fn futex_waitv(
+    waiters: &[futex::Wait],
+    flags: futex::WaitvFlags,
+    timeout: Option<&Timespec>,
+    clockid: ClockId,
+) -> io::Result<usize> {
+    let (waiters_addr, waiters_len) = slice(waiters);
+    unsafe {
+        ret_usize(syscall!(
+            __NR_futex_waitv,
+            waiters_addr,
+            waiters_len,
+            c_uint(flags.bits()),
+            option_as_ptr(timeout),
+            clockid
+        ))
+    }
+}
+
 #[inline]
 pub(crate) fn setns(fd: BorrowedFd<'_>, nstype: c::c_int) -> io::Result<c::c_int> {
     unsafe { ret_c_int(syscall_readonly!(__NR_setns, fd, c_int(nstype))) }

src/io_uring/mod.rs

@@ -35,6 +35,7 @@ use core::ptr::{null_mut, write_bytes};
 use linux_raw_sys::net;
 
 // Export types used in io_uring APIs.
+pub use crate::clockid::ClockId;
 pub use crate::event::epoll::{
     Event as EpollEvent, EventData as EpollEventData, EventFlags as EpollEventFlags,
 };
@@ -44,6 +45,10 @@ pub use crate::fs::{
 };
 pub use crate::io::ReadWriteFlags;
 pub use crate::net::{RecvFlags, SendFlags, SocketFlags};
+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;
 
@@ -420,6 +425,15 @@ pub enum IoringOp {
 
     /// `IORING_OP_SENDMSG_ZC`
     SendmsgZc = sys::io_uring_op::IORING_OP_SENDMSG_ZC as _,
+
+    /// `IORING_OP_FUTEX_WAIT`
+    FutexWait = sys::io_uring_op::IORING_OP_FUTEX_WAIT as _,
+
+    /// `IORING_OP_FUTEX_WAKE`
+    FutexWake = sys::io_uring_op::IORING_OP_FUTEX_WAKE as _,
+
+    /// `IORING_OP_FUTEX_WAITV`
+    FutexWaitv = sys::io_uring_op::IORING_OP_FUTEX_WAITV as _,
 }
 
 impl Default for IoringOp {
@@ -660,6 +674,22 @@ bitflags::bitflags! {
     }
 }
 
+bitflags::bitflags! {
+    /// `IORING_URING_CMD_*` flags for use with [`io_uring_sqe`].
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct IoringUringCmdFlags: u32 {
+        /// `IORING_URING_CMD_FIXED`
+        const FIXED = sys::IORING_URING_CMD_FIXED;
+
+        /// `IORING_URING_CMD_MASK`
+        const MASK = sys::IORING_URING_CMD_MASK;
+
+        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
+        const _ = !0;
+    }
+}
+
 bitflags::bitflags! {
     /// `IORING_ASYNC_CANCEL_*` flags for use with [`io_uring_sqe`].
     #[repr(transparent)]
@@ -969,6 +999,12 @@ impl Default for io_uring_ptr {
     }
 }
 
+impl core::fmt::Debug for io_uring_ptr {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.ptr.fmt(f)
+    }
+}
+
 /// User data in the io_uring API.
 ///
 /// `io_uring`'s native API represents `user_data` fields as `u64` values. In
@@ -1147,6 +1183,8 @@ pub union op_flags_union {
     pub hardlink_flags: AtFlags,
     pub xattr_flags: XattrFlags,
     pub msg_ring_flags: IoringMsgringFlags,
+    pub uring_cmd_flags: IoringUringCmdFlags,
+    pub futex_flags: FutexWaitvFlags,
 }
 
 #[allow(missing_docs)]