Implement support for synchronization primitives.

Author: Vytautas Astrauskas

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::ExecuteCallback => {
+                    assert!(ecx.machine.communicate,
+                        "scheduler callbacks require disabled isolation, but the code \
+                        that created the callback did not check it");
+                    ecx.run_scheduler_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/machine.rs

@@ -5,7 +5,7 @@ use std::borrow::Cow;
 use std::cell::RefCell;
 use std::num::NonZeroU64;
 use std::rc::Rc;
-use std::time::Instant;
+use std::time::{Instant, SystemTime};
 use std::fmt;
 
 use log::trace;
@@ -251,6 +251,11 @@ pub struct Evaluator<'mir, 'tcx> {
     /// The "time anchor" for this machine's monotone clock (for `Instant` simulation).
     pub(crate) time_anchor: Instant,
 
+    /// The approximate system time when "time anchor" was created. This is used
+    /// for converting system time to monotone time so that we can simplify the
+    /// thread scheduler to deal only with a single representation of time.
+    pub(crate) time_anchor_timestamp: SystemTime,
+
     /// The set of threads.
     pub(crate) threads: ThreadManager<'mir, 'tcx>,
 
@@ -281,6 +286,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             dir_handler: Default::default(),
             panic_payload: None,
             time_anchor: Instant::now(),
+            time_anchor_timestamp: SystemTime::now(),
             layouts,
             threads: ThreadManager::default(),
         }

src/shims/foreign_items/posix.rs

@@ -330,6 +330,45 @@ 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 result = this.pthread_condattr_init(args[0])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_condattr_setclock" => {
+                let result = this.pthread_condattr_setclock(args[0], args[1])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_condattr_getclock" => {
+                let result = this.pthread_condattr_getclock(args[0], args[1])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_condattr_destroy" => {
+                let result = this.pthread_condattr_destroy(args[0])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_init" => {
+                let result = this.pthread_cond_init(args[0], args[1])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_signal" => {
+                let result = this.pthread_cond_signal(args[0])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_broadcast" => {
+                let result = this.pthread_cond_broadcast(args[0])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_wait" => {
+                let result = this.pthread_cond_wait(args[0], args[1])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "pthread_cond_timedwait" => {
+                this.pthread_cond_timedwait(args[0], args[1], args[2], dest)?;
+            }
+            "pthread_cond_destroy" => {
+                let result = this.pthread_cond_destroy(args[0])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
 
             // Threading
             "pthread_create" => {
@@ -391,16 +430,7 @@ 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)?;