Add sync primitives

src/eval.rs

@@ -210,6 +210,12 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
                 SchedulingAction::ExecuteStep => {
                     assert!(ecx.step()?, "a terminated thread was scheduled for execution");
                 }
+                SchedulingAction::ExecuteTimeoutCallback => {
+                    assert!(ecx.machine.communicate,
+                        "scheduler callbacks require disabled isolation, but the code \
+                        that created the callback did not check it");
+                    ecx.run_timeout_callback()?;
+                }
                 SchedulingAction::ExecuteDtors => {
                     // This will either enable the thread again (so we go back
                     // to `ExecuteStep`), or determine that this thread is done

src/lib.rs

@@ -31,6 +31,7 @@ mod operator;
 mod range_map;
 mod shims;
 mod stacked_borrows;
+mod sync;
 mod thread;
 
 // Make all those symbols available in the same place as our own.
@@ -45,7 +46,7 @@ pub use crate::shims::fs::{DirHandler, EvalContextExt as FileEvalContextExt, Fil
 pub use crate::shims::intrinsics::EvalContextExt as IntrinsicsEvalContextExt;
 pub use crate::shims::os_str::EvalContextExt as OsStrEvalContextExt;
 pub use crate::shims::panic::{CatchUnwindData, EvalContextExt as PanicEvalContextExt};
-pub use crate::shims::sync::{EvalContextExt as SyncEvalContextExt};
+pub use crate::shims::sync::{EvalContextExt as SyncShimsEvalContextExt};
 pub use crate::shims::thread::EvalContextExt as ThreadShimsEvalContextExt;
 pub use crate::shims::time::EvalContextExt as TimeEvalContextExt;
 pub use crate::shims::tls::{EvalContextExt as TlsEvalContextExt, TlsData};
@@ -70,6 +71,9 @@ pub use crate::stacked_borrows::{
 pub use crate::thread::{
     EvalContextExt as ThreadsEvalContextExt, SchedulingAction, ThreadId, ThreadManager, ThreadState,
 };
+pub use crate::sync::{
+    EvalContextExt as SyncEvalContextExt, CondvarId, MutexId, RwLockId
+};
 
 /// Insert rustc arguments at the beginning of the argument list that Miri wants to be
 /// set per default, for maximal validation power.

src/shims/foreign_items/posix.rs

@@ -330,6 +330,55 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let result = this.pthread_rwlock_destroy(rwlock)?;
                 this.write_scalar(Scalar::from_i32(result), dest)?;
             }
+            "pthread_condattr_init" => {
+                let &[attr] = check_arg_count(args)?;
+                let result = this.pthread_condattr_init(attr)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_condattr_setclock" => {
+                let &[attr, clock_id] = check_arg_count(args)?;
+                let result = this.pthread_condattr_setclock(attr, clock_id)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_condattr_getclock" => {
+                let &[attr, clock_id] = check_arg_count(args)?;
+                let result = this.pthread_condattr_getclock(attr, clock_id)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_condattr_destroy" => {
+                let &[attr] = check_arg_count(args)?;
+                let result = this.pthread_condattr_destroy(attr)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_init" => {
+                let &[cond, attr] = check_arg_count(args)?;
+                let result = this.pthread_cond_init(cond, attr)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_signal" => {
+                let &[cond] = check_arg_count(args)?;
+                let result = this.pthread_cond_signal(cond)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_broadcast" => {
+                let &[cond] = check_arg_count(args)?;
+                let result = this.pthread_cond_broadcast(cond)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_wait" => {
+                let &[cond, mutex] = check_arg_count(args)?;
+                let result = this.pthread_cond_wait(cond, mutex)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_timedwait" => {
+                let &[cond, mutex, abstime] = check_arg_count(args)?;
+                this.pthread_cond_timedwait(cond, mutex, abstime, dest)?;
+            }
+            "pthread_cond_destroy" => {
+                let &[cond] = check_arg_count(args)?;
+                let result = this.pthread_cond_destroy(cond)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
 
             // Threading
             "pthread_create" => {
@@ -391,16 +440,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
             | "pthread_attr_init"
             | "pthread_attr_destroy"
-            | "pthread_condattr_init"
-            | "pthread_condattr_destroy"
-            | "pthread_cond_destroy"
             if this.frame().instance.to_string().starts_with("std::sys::unix::") => {
                 let &[_] = check_arg_count(args)?;
                 this.write_null(dest)?;
             }
-            | "pthread_cond_init"
             | "pthread_attr_setstacksize"
-            | "pthread_condattr_setclock"
             if this.frame().instance.to_string().starts_with("std::sys::unix::") => {
                 let &[_, _] = check_arg_count(args)?;
                 this.write_null(dest)?;