fix and update tests

Author: LorrensP-2158466

tests/pass-dep/concurrency/freebsd-futex.rs

@@ -1,15 +1,53 @@
 //@only-target: freebsd
-//@compile-flags: -Zmiri-preemption-rate=0
+//@compile-flags: -Zmiri-preemption-rate=0 -Zmiri-disable-isolation
 
-use std::mem::MaybeUninit;
+use std::mem::{self, MaybeUninit};
 use std::ptr::{self, addr_of};
 use std::sync::atomic::AtomicU32;
 use std::time::{Duration, Instant};
 use std::{io, thread};
 
 fn wake_nobody() {
-    // TODO: _umtx_op does not return how many threads were woken up
-    // How do i test this?
+    // Current thread waits on futex
+    // New thread wakes up 0 threads waiting on that futex
+    // Current thread should time out
+    static mut FUTEX: u32 = 0;
+
+    let waker = thread::spawn(|| {
+        thread::sleep(Duration::from_millis(200));
+
+        unsafe {
+            assert_eq!(
+                libc::_umtx_op(
+                    addr_of!(FUTEX) as *mut _,
+                    libc::UMTX_OP_WAKE_PRIVATE,
+                    0, // wake up 0 waiters
+                    ptr::null_mut::<libc::c_void>(),
+                    ptr::null_mut::<libc::c_void>(),
+                ),
+                0
+            );
+        }
+    });
+    let mut timeout = libc::timespec { tv_sec: 0, tv_nsec: 400_000_000 };
+    let timeout_size_arg =
+        ptr::without_provenance_mut::<libc::c_void>(mem::size_of::<libc::timespec>());
+    unsafe {
+        assert_eq!(
+            libc::_umtx_op(
+                addr_of!(FUTEX) as *mut _,
+                libc::UMTX_OP_WAIT_UINT_PRIVATE,
+                0,
+                timeout_size_arg,
+                &mut timeout as *mut _ as _,
+            ),
+            -1
+        );
+        // main thread did not get woken up, so it timed out
+        assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::ETIMEDOUT);
+    }
+
+    waker.join().unwrap();
 }
 
 fn wake_dangling() {
@@ -36,6 +74,7 @@ fn wake_dangling() {
 fn wait_wrong_val() {
     let futex: u32 = 123;
 
+    // Wait with a wrong value just returns 0
     unsafe {
         assert_eq!(
             libc::_umtx_op(
@@ -45,35 +84,69 @@ fn wait_wrong_val() {
                 ptr::null_mut::<libc::c_void>(),
                 ptr::null_mut::<libc::c_void>(),
             ),
-            -1
+            0
         );
-        // man page doesn't document but we set EINVAL for consistency?
-        assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::EINVAL);
     }
 }
 
 fn wait_relative_timeout() {
-    let start = Instant::now();
+    fn without_timespec() {
+        let start = Instant::now();
 
-    let futex: u32 = 123;
+        let futex: u32 = 123;
 
-    // Wait for 200ms, with nobody waking us up early
-    unsafe {
-        assert_eq!(
-            libc::_umtx_op(
-                ptr::from_ref(&futex).cast_mut().cast(),
-                libc::UMTX_OP_WAIT_UINT_PRIVATE,
-                123,
-                &mut libc::timespec { tv_sec: 0, tv_nsec: 200_000_000 } as *mut _ as *mut _,
-                ptr::null_mut::<libc::c_void>(),
-            ),
-            -1
-        );
-        // man page doesn't document but we set EINVAL for consistency
-        assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::ETIMEDOUT);
+        let mut timeout = libc::timespec { tv_sec: 0, tv_nsec: 200_000_000 };
+        let timeout_size_arg =
+            ptr::without_provenance_mut::<libc::c_void>(mem::size_of::<libc::timespec>());
+        // Wait for 200ms, with nobody waking us up early
+        unsafe {
+            assert_eq!(
+                libc::_umtx_op(
+                    ptr::from_ref(&futex).cast_mut().cast(),
+                    libc::UMTX_OP_WAIT_UINT_PRIVATE,
+                    123,
+                    timeout_size_arg,
+                    &mut timeout as *mut _ as _,
+                ),
+                -1
+            );
+            assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::ETIMEDOUT);
+        }
+
+        assert!((200..1000).contains(&start.elapsed().as_millis()));
     }
 
-    assert!((200..1000).contains(&start.elapsed().as_millis()));
+    fn with_timespec() {
+        let futex: u32 = 123;
+        let mut timeout = libc::_umtx_time {
+            _timeout: libc::timespec { tv_sec: 0, tv_nsec: 200_000_000 },
+            _flags: 0,
+            _clockid: libc::CLOCK_MONOTONIC as u32,
+        };
+        let timeout_size_arg =
+            ptr::without_provenance_mut::<libc::c_void>(mem::size_of::<libc::_umtx_time>());
+
+        let start = Instant::now();
+
+        // Wait for 200ms, with nobody waking us up early
+        unsafe {
+            assert_eq!(
+                libc::_umtx_op(
+                    ptr::from_ref(&futex).cast_mut().cast(),
+                    libc::UMTX_OP_WAIT_UINT_PRIVATE,
+                    123,
+                    timeout_size_arg,
+                    &mut timeout as *mut _ as _,
+                ),
+                -1
+            );
+            assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::ETIMEDOUT);
+        }
+        assert!((200..1000).contains(&start.elapsed().as_millis()));
+    }
+
+    without_timespec();
+    with_timespec();
 }
 
 fn wait_absolute_timeout() {
@@ -93,14 +166,14 @@ fn wait_absolute_timeout() {
         timeout.tv_sec += 1;
     }
 
-    // Create umtx_timeout struct
+    // Create umtx_timeout struct with that absolute timeout.
     let umtx_timeout = libc::_umtx_time {
         _timeout: timeout,
         _flags: libc::UMTX_ABSTIME,
         _clockid: libc::CLOCK_MONOTONIC as u32,
     };
     let umtx_timeout_ptr = &umtx_timeout as *const _;
-    let umtx_timeout_size = std::mem::size_of_val(&umtx_timeout);
+    let umtx_timeout_size = ptr::without_provenance_mut(mem::size_of_val(&umtx_timeout));
 
     let futex: u32 = 123;
 
@@ -111,55 +184,70 @@ fn wait_absolute_timeout() {
                 ptr::from_ref(&futex).cast_mut().cast(),
                 libc::UMTX_OP_WAIT_UINT_PRIVATE,
                 123,
-                ptr::without_provenance_mut(umtx_timeout_size),
+                umtx_timeout_size,
                 umtx_timeout_ptr as *mut _,
             ),
             -1
         );
-        // man page doesn't document but we set EINVAL for consistency
         assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::ETIMEDOUT);
     }
     assert!((200..1000).contains(&start.elapsed().as_millis()));
 }
 
 fn wait_wake() {
-    let start = Instant::now();
-
     static mut FUTEX: u32 = 0;
 
-    let t = thread::spawn(move || {
-        thread::sleep(Duration::from_millis(200));
+    let t1 = thread::spawn(move || {
+        let mut timeout = libc::timespec { tv_sec: 0, tv_nsec: 500_000_000 };
+        let timeout_size_arg =
+            ptr::without_provenance_mut::<libc::c_void>(mem::size_of::<libc::timespec>());
         unsafe {
-            assert_eq!(
-                libc::_umtx_op(
-                    addr_of!(FUTEX) as *mut _,
-                    libc::UMTX_OP_WAKE_PRIVATE,
-                    10, // Wake up 10 threads, but we can't check that we woken up 1.
-                    ptr::null_mut::<libc::c_void>(),
-                    ptr::null_mut::<libc::c_void>(),
-                ),
-                0
+            libc::_umtx_op(
+                addr_of!(FUTEX) as *mut _,
+                libc::UMTX_OP_WAIT_UINT_PRIVATE,
+                0, // FUTEX is 0
+                timeout_size_arg,
+                &mut timeout as *mut _ as _,
+            );
+            io::Error::last_os_error().raw_os_error().unwrap() == libc::ETIMEDOUT
+        }
+    });
+    let t2 = thread::spawn(move || {
+        let mut timeout = libc::timespec { tv_sec: 0, tv_nsec: 500_000_000 };
+        let timeout_size_arg =
+            ptr::without_provenance_mut::<libc::c_void>(mem::size_of::<libc::timespec>());
+        unsafe {
+            libc::_umtx_op(
+                addr_of!(FUTEX) as *mut _,
+                libc::UMTX_OP_WAIT_UINT_PRIVATE,
+                0, // FUTEX is 0
+                // make sure the threads still exit
+                timeout_size_arg,
+                &mut timeout as *mut _ as _,
             );
+            io::Error::last_os_error().raw_os_error().unwrap() == libc::ETIMEDOUT
         }
     });
 
+    // Wake up 1 thread and make sure the other is still waiting
+    thread::sleep(Duration::from_millis(200));
     unsafe {
         assert_eq!(
             libc::_umtx_op(
                 addr_of!(FUTEX) as *mut _,
-                libc::UMTX_OP_WAIT_UINT_PRIVATE,
-                0, // FUTEX is 0
+                libc::UMTX_OP_WAKE_PRIVATE,
+                1,
                 ptr::null_mut::<libc::c_void>(),
                 ptr::null_mut::<libc::c_void>(),
             ),
             0
         );
     }
-
-    // When running this in stress-gc mode, things can take quite long.
-    // So the timeout is 3000 ms.
-    assert!((200..3000).contains(&start.elapsed().as_millis()));
-    t.join().unwrap();
+    // Wait a bit more for good measure.
+    thread::sleep(Duration::from_millis(100));
+    let t1_woke_up = t1.join().unwrap();
+    let t2_woke_up = t2.join().unwrap();
+    assert!(!(t1_woke_up && t2_woke_up), "Expected only 1 thread to wake up");
 }
 
 fn main() {