Implements miri shims for FUTEX_LOCK_PI, FUTEX_UNLOCK_PI

Author: ruihe774

src/tools/miri/src/shims/unix/linux/sync.rs

@@ -1,4 +1,5 @@
 use crate::*;
+use crate::shims::unix::env::EvalContextExt;
 
 /// Implementation of the SYS_futex syscall.
 /// `args` is the arguments *after* the syscall number.
@@ -15,19 +16,18 @@ pub fn futex<'tcx>(
     // may or may not be left out from the `syscall()` call.
     // Therefore we don't use `check_arg_count` here, but only check for the
     // number of arguments to fall within a range.
-    let [addr, op, val, ..] = args else {
+    let [addr, op, ..] = args else {
         throw_ub_format!(
             "incorrect number of arguments for `futex` syscall: got {}, expected at least 3",
             args.len()
         );
     };
 
-    // The first three arguments (after the syscall number itself) are the same to all futex operations:
-    //     (int *addr, int op, int val).
+    // The first two arguments (after the syscall number itself) are the same to all futex operations:
+    //     (int *addr, int op).
     // We checked above that these definitely exist.
     let addr = this.read_pointer(addr)?;
     let op = this.read_scalar(op)?.to_i32()?;
-    let val = this.read_scalar(val)?.to_i32()?;
 
     // This is a vararg function so we have to bring our own type for this pointer.
     let addr = this.ptr_to_mplace(addr, this.machine.layouts.i32);
@@ -39,6 +39,9 @@ pub fn futex<'tcx>(
     let futex_wake = this.eval_libc_i32("FUTEX_WAKE");
     let futex_wake_bitset = this.eval_libc_i32("FUTEX_WAKE_BITSET");
     let futex_realtime = this.eval_libc_i32("FUTEX_CLOCK_REALTIME");
+    let futex_lock_pi = this.eval_libc_i32("FUTEX_LOCK_PI");
+    let futex_unlock_pi = this.eval_libc_i32("FUTEX_UNLOCK_PI");
+    let futex_waiters = this.eval_libc_u32("FUTEX_WAITERS");
 
     // FUTEX_PRIVATE enables an optimization that stops it from working across processes.
     // Miri doesn't support that anyway, so we ignore that flag.
@@ -51,7 +54,7 @@ pub fn futex<'tcx>(
         // This is identical to FUTEX_WAIT, except:
         //  - The timeout is absolute rather than relative.
         //  - You can specify the bitset to selecting what WAKE operations to respond to.
-        op if op & !futex_realtime == futex_wait || op & !futex_realtime == futex_wait_bitset => {
+        op if op & !futex_realtime == futex_wait || op & !futex_realtime == futex_wait_bitset || op == futex_lock_pi => {
             let wait_bitset = op & !futex_realtime == futex_wait_bitset;
 
             let bitset = if wait_bitset {
@@ -74,6 +77,9 @@ pub fn futex<'tcx>(
                 u32::MAX
             };
 
+
+            let val = this.read_scalar(&args[2])?.to_u32()?;
+
             if bitset == 0 {
                 this.set_last_error(LibcError("EINVAL"))?;
                 this.write_scalar(Scalar::from_target_isize(-1, this), dest)?;
@@ -152,12 +158,16 @@ pub fn futex<'tcx>(
             //
             // Thankfully, preemptions cannot happen inside a Miri shim, so we do not need to
             // do anything special to guarantee fence-load-comparison atomicity.
-            this.atomic_fence(AtomicFenceOrd::SeqCst)?;
-            // Read an `i32` through the pointer, regardless of any wrapper types.
-            // It's not uncommon for `addr` to be passed as another type than `*mut i32`, such as `*const AtomicI32`.
-            let futex_val = this.read_scalar_atomic(&addr, AtomicReadOrd::Relaxed)?.to_i32()?;
-            if val == futex_val {
+            let futex_val = this.read_scalar_atomic(&addr, AtomicReadOrd::SeqCst)?.to_u32()?;
+            if if op == futex_lock_pi {
+                futex_val != 0
+            } else {
+                futex_val == val
+            } {
                 // The value still matches, so we block the thread and make it wait for FUTEX_WAKE.
+                if op == futex_lock_pi {
+                    this.write_scalar_atomic(Scalar::from_u32(val | futex_waiters), &addr , AtomicWriteOrd::SeqCst)?;
+                }
                 this.futex_wait(
                     addr_usize,
                     bitset,
@@ -167,6 +177,10 @@ pub fn futex<'tcx>(
                     dest.clone(),
                     this.eval_libc("ETIMEDOUT"),
                 );
+            } else if op == futex_lock_pi {
+                let tid = this.linux_gettid()?;
+                this.write_scalar_atomic(tid, &addr, AtomicWriteOrd::SeqCst)?;
+                this.write_scalar(Scalar::from_target_isize(0, this), dest)?;
             } else {
                 // The futex value doesn't match the expected value, so we return failure
                 // right away without sleeping: -1 and errno set to EAGAIN.
@@ -181,7 +195,9 @@ pub fn futex<'tcx>(
         // Does not access the futex value at *addr.
         // FUTEX_WAKE_BITSET: (int *addr, int op = FUTEX_WAKE, int val, const timespect *_unused, int *_unused, unsigned int bitset)
         // Same as FUTEX_WAKE, but allows you to specify a bitset to select which threads to wake up.
-        op if op == futex_wake || op == futex_wake_bitset => {
+        op if op == futex_wake || op == futex_wake_bitset || op == futex_unlock_pi => {
+            let val = if op == futex_unlock_pi { 1 } else { this.read_scalar(&args[2])?.to_i32()? };
+
             let bitset = if op == futex_wake_bitset {
                 let [_, _, _, timeout, uaddr2, bitset, ..] = args else {
                     throw_ub_format!(
@@ -203,7 +219,11 @@ pub fn futex<'tcx>(
             // Together with the SeqCst fence in futex_wait, this makes sure that futex_wait
             // will see the latest value on addr which could be changed by our caller
             // before doing the syscall.
-            this.atomic_fence(AtomicFenceOrd::SeqCst)?;
+            if op == futex_unlock_pi {
+                this.write_scalar_atomic(Scalar::from_u32(0), &addr, AtomicWriteOrd::SeqCst)?;
+            } else {
+                this.atomic_fence(AtomicFenceOrd::SeqCst)?;
+            }
             let mut n = 0;
             #[allow(clippy::arithmetic_side_effects)]
             for _ in 0..val {
@@ -213,7 +233,7 @@ pub fn futex<'tcx>(
                     break;
                 }
             }
-            this.write_scalar(Scalar::from_target_isize(n, this), dest)?;
+            this.write_scalar(Scalar::from_target_isize(if op != futex_unlock_pi { n } else { 0 }, this), dest)?;
         }
         op => throw_unsup_format!("Miri does not support `futex` syscall with op={}", op),
     }