Fix compatibility with older 32-bit kernels (#1374)

* Fix handling of negative timestamps in `stat` on Linux.

Some Linux `stat64` structs are defined with `st_atime`, `st_mtime`, and
`st_ctime` fields using unsigned types, even though they hold signed
values. Convert them to signed before converting them to `i64`, so that
they're signed-extended.

This fixes test failures on old 32-bit Linux platforms which lack
`statx`.

* Fix select fallback for 32-bit platforms.

* Add a "linux_5_1" feature for specializing for Linux >= 5.1.

* Fix `test_vdso` to handle older kernel versions on x86 and powerpc.

* Fix poll, select, epoll_wait, and futex for 32-bit platforms.

Handle kernel versions that lack _time64 syscalls. And change all
timeouts to `Option<&Timepsec>`, for efficiency and consistency.

* Use `opt_ref` for passing optional references to syscalls.

* Fix `Timespec` layout on Windows to match `Nsecs`.

* Convert kernel_sigtimedwait to use timeouts like poll/etc.

Author: sunfishcode

CHANGES.md

@@ -140,6 +140,22 @@ fields are `tv_sec` which holds seconds and `tv_nsec` which holds nanoseconds.
 [`rustix::event::epoll`]: https://docs.rs/rustix/1.0.0/rustix/event/epoll/index.html
 [`Timespec`]: https://docs.rs/rustix/1.0.0/rustix/time/struct.Timespec.html
 
+The timeout argument in [`rustix::thread::futex::wait`],
+[`rustix::thread::futex::lock_pi`], [`rustix::thread::futex::wait_bitset`],
+[`rustix::thread::futex::wait_requeue_pi`], and
+[`rustix::thread::futex::lock_pi2`] changed from `Option<Timespec>` to
+`Option<&Timespec>`, for consistency with the rest of rustix's API, and for
+low-level efficiency, as it means the implementation doesn't need to make a
+copy of the `Timespec` to take its address. An easy way to convert an
+`Option<Timespec>` to an `Option<&Timespec> is to use [`Option::as_ref`].
+
+[`rustix::thread::futex::wait`]: https://docs.rs/rustix/1.0.0/rustix/thread/futex/fn.wait.html
+[`rustix::thread::futex::lock_pi`]: https://docs.rs/rustix/1.0.0/rustix/thread/futex/fn.lock_pi.html
+[`rustix::thread::futex::wait_bitset`]: https://docs.rs/rustix/1.0.0/rustix/thread/futex/fn.wait_bitset.html
+[`rustix::thread::futex::wait_requeue_pi`]: https://docs.rs/rustix/1.0.0/rustix/thread/futex/fn.wait_requeue_pi.html
+[`rustix::thread::futex::lock_pi2`]: https://docs.rs/rustix/1.0.0/rustix/thread/futex/fn.lock_pi2.html
+[`Option::as_ref`]: https://doc.rust-lang.org/stable/std/option/enum.Option.html#method.as_ref
+
 Functions in [`rustix::event::port`] are renamed to remove the redundant
 `port_*` prefix.
 

Cargo.toml

@@ -211,8 +211,11 @@ use-explicitly-provided-auxv = []
 # Specialize for Linux 4.11 or later
 linux_4_11 = []
 
+# Specialize for Linux 5.1 or later
+linux_5_1 = ["linux_4_11"]
+
 # Specialize for Linux 5.11 or later
-linux_5_11 = ["linux_4_11"]
+linux_5_11 = ["linux_5_1"]
 
 # Enable all specializations for the latest Linux versions.
 linux_latest = ["linux_5_11"]

src/backend/libc/event/syscalls.rs

@@ -572,14 +572,12 @@ pub(crate) unsafe fn epoll_wait(
     // If we're on Linux >= 5.11, use `epoll_pwait2` via `libc::syscall`.
     #[cfg(all(linux_kernel, feature = "linux_5_11"))]
     {
-        use linux_raw_sys::general::__kernel_timespec as timespec;
-
         syscall! {
             fn epoll_pwait2(
                 epfd: c::c_int,
                 events: *mut c::epoll_event,
                 maxevents: c::c_int,
-                timeout: *const timespec,
+                timeout: *const Timespec,
                 sigmask: *const c::sigset_t
             ) via SYS_epoll_pwait2 -> c::c_int
         }

src/backend/libc/thread/syscalls.rs

@@ -505,7 +505,7 @@ pub(crate) unsafe fn futex_val2(
                 uaddr: *const AtomicU32,
                 futex_op: c::c_int,
                 val: u32,
-                timeout: *const linux_raw_sys::general::__kernel_timespec,
+                timeout: *const Timespec,
                 uaddr2: *const AtomicU32,
                 val3: u32
             ) via SYS_futex -> c::c_long
@@ -531,7 +531,7 @@ pub(crate) unsafe fn futex_timeout(
     op: super::futex::Operation,
     flags: futex::Flags,
     val: u32,
-    timeout: *const Timespec,
+    timeout: Option<&Timespec>,
     uaddr2: *const AtomicU32,
     val3: u32,
 ) -> io::Result<usize> {
@@ -559,7 +559,7 @@ pub(crate) unsafe fn futex_timeout(
             uaddr,
             op as i32 | flags.bits() as i32,
             val,
-            timeout,
+            option_as_ptr(timeout),
             uaddr2,
             val3,
         ))
@@ -584,7 +584,7 @@ pub(crate) unsafe fn futex_timeout(
                 uaddr: *const AtomicU32,
                 futex_op: c::c_int,
                 val: u32,
-                timeout: *const linux_raw_sys::general::__kernel_timespec,
+                timeout: *const Timespec,
                 uaddr2: *const AtomicU32,
                 val3: u32
             ) via SYS_futex -> c::c_long
@@ -594,7 +594,7 @@ pub(crate) unsafe fn futex_timeout(
             uaddr,
             op as i32 | flags.bits() as i32,
             val,
-            timeout.cast(),
+            option_as_ptr(timeout).cast(),
             uaddr2,
             val3,
         ) as isize)
@@ -614,7 +614,7 @@ unsafe fn futex_old_timespec(
     op: super::futex::Operation,
     flags: futex::Flags,
     val: u32,
-    timeout: *const Timespec,
+    timeout: Option<&Timespec>,
     uaddr2: *const AtomicU32,
     val3: u32,
 ) -> io::Result<usize> {
@@ -629,16 +629,16 @@ unsafe fn futex_old_timespec(
         ) via SYS_futex -> c::c_long
     }
 
-    let old_timeout = if timeout.is_null() {
-        None
-    } else {
+    let old_timeout = if let Some(timeout) = timeout {
         Some(linux_raw_sys::general::__kernel_old_timespec {
             tv_sec: (*timeout).tv_sec.try_into().map_err(|_| io::Errno::INVAL)?,
             tv_nsec: (*timeout)
                 .tv_nsec
                 .try_into()
                 .map_err(|_| io::Errno::INVAL)?,
         })
+    } else {
+        None
     };
     ret_usize(futex(
         uaddr,
@@ -658,22 +658,19 @@ pub(crate) fn futex_waitv(
     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};
+    use linux_raw_sys::general::__kernel_clockid_t as clockid_t;
     syscall! {
         fn futex_waitv(
             waiters: *const FutexWait,
             nr_futexes: c::c_uint,
             flags: c::c_uint,
-            timeout: *const timespec,
+            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(),

src/backend/libc/winsock_c.rs

@@ -62,6 +62,6 @@ pub(crate) use WinSock::{
 // in its public API. So define one, and we'll convert it internally.
 pub struct timespec {
     pub tv_sec: time_t,
-    pub tv_nsec: i64,
+    pub tv_nsec: crate::ffi::c_long,
 }
 pub type time_t = i64;