Add _umtx_op shim to freebsd

This fixes the `concurrent-panic.rs` test on freebsd

Signed-off-by: InfRandomness <[email protected]>

Author: b-NC

src/shims/unix/freebsd/foreign_items.rs

@@ -2,6 +2,7 @@ use rustc_middle::mir;
 use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
+use crate::shims::unix::freebsd::futex::futex;
 use crate::*;
 use shims::foreign_items::EmulateByNameResult;
 
@@ -32,6 +33,20 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 this.write_scalar(errno_place.to_ref(this).to_scalar()?, dest)?;
             }
 
+            // Futex, equivalent to Linux's SYS_futex syscall
+            "_umtx_op" => {
+                let [obj, op, val, uaddr, uaddr2] =
+                    this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+                futex(
+                    this,
+                    obj,
+                    this.read_scalar(op)?.to_i32()?,
+                    this.read_scalar(val)?.to_u64()?,
+                    uaddr,
+                    uaddr2,
+                );
+                this.write_scalar(Scalar::from_i32(1), dest)?;
+            }
             _ => return Ok(EmulateByNameResult::NotSupported),
         }
         Ok(EmulateByNameResult::NeedsJumping)

src/shims/unix/freebsd/futex.rs

@@ -0,0 +1,67 @@
+use crate::helpers::EvalContextExt as HEvalContext;
+use crate::sync::EvalContextExt as SEvalContext;
+use crate::thread::EvalContextExt as TEvalContext;
+use crate::InterpResult;
+use crate::OpTy;
+use crate::{MiriEvalContext, Tag};
+
+enum OpType {
+    UmtxOpWait = 2,
+    //TODO: other types
+}
+
+impl TryFrom<i32> for OpType {
+    type Error = &'static str;
+
+    fn try_from(value: i32) -> Result<Self, Self::Error> {
+        match value {
+            2 => Ok(OpType::UmtxOpWait),
+            _ => Err("Unsupported Futex operation"),
+        }
+    }
+}
+
+pub fn futex<'tcx>(
+    this: &mut MiriEvalContext<'_, 'tcx>,
+    obj: &OpTy<'tcx, Tag>,
+    op: i32,
+    val: u64,
+    uaddr: &OpTy<'tcx, Tag>,
+    uaddr2: &OpTy<'tcx, Tag>,
+) -> Option<InterpResult<'tcx>> {
+    // Object to operate on
+    let obj = obj;
+    // Operation type
+    let _op_type = op;
+    // Current value pointed to by `obj`
+    let val = val;
+    // Pointer that's purpose depends on the op_type
+    let _uaddr = this.read_pointer(uaddr).ok()?;
+    // Pointer that's purpose depends on the op_type
+    let _uaddr2 = this.read_pointer(uaddr2).ok()?;
+    match OpType::try_from(op) {
+        Ok(op) =>
+            match op {
+                OpType::UmtxOpWait =>
+                    if this.read_scalar(obj).ok()?.to_u64().ok()? == val {
+                        this.futex_wait(
+                            this.read_scalar(obj).ok()?.to_u64().ok()?,
+                            this.get_active_thread(),
+                            u32::MAX,
+                        );
+                        None
+                    } else {
+                        // The `val` value is invalid. Double check this against the manual.
+                        let einval = this.eval_libc("EINVAL").ok()?;
+                        this.set_last_error(einval).ok()?;
+                        None
+                    },
+            },
+        Err(_) => {
+            // The `op` value is invalid.
+            let einval = this.eval_libc("EINVAL").ok()?;
+            this.set_last_error(einval).ok()?;
+            None
+        }
+    }
+}

src/shims/unix/freebsd/mod.rs

@@ -1,2 +1,3 @@
 pub mod dlsym;
 pub mod foreign_items;
+pub mod futex;