make sleep work with isolation enabled

pvdrz · pvdrz · commit bd504d03e72c · 2022-08-23T13:55:30.000-05:00
diff --git a/src/concurrency/thread.rs b/src/concurrency/thread.rs
@@ -3,11 +3,14 @@
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::num::TryFromIntError;
+use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
 use log::trace;
 
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::sync::Ordering;
 use rustc_hir::def_id::DefId;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_middle::mir::Mutability;
@@ -16,6 +19,7 @@ use rustc_target::spec::abi::Abi;
 
 use crate::concurrency::data_race;
 use crate::concurrency::sync::SynchronizationState;
+use crate::shims::time::TimeAnchor;
 use crate::*;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -184,6 +188,7 @@ impl<'mir, 'tcx> Thread<'mir, 'tcx> {
 #[derive(Debug)]
 pub enum Time {
     Monotonic(Instant),
+    Virtual(u64, Arc<AtomicU64>),
     RealTime(SystemTime),
 }
 
@@ -192,6 +197,8 @@ impl Time {
     fn get_wait_time(&self) -> Duration {
         match self {
             Time::Monotonic(instant) => instant.saturating_duration_since(Instant::now()),
+            Time::Virtual(nanoseconds, now) =>
+                Duration::from_nanos(nanoseconds - now.load(Ordering::Relaxed)),
             Time::RealTime(time) =>
                 time.duration_since(SystemTime::now()).unwrap_or(Duration::new(0, 0)),
         }
@@ -234,6 +241,8 @@ pub struct ThreadManager<'mir, 'tcx> {
     yield_active_thread: bool,
     /// Callbacks that are called once the specified time passes.
     timeout_callbacks: FxHashMap<ThreadId, TimeoutCallbackInfo<'mir, 'tcx>>,
+    /// The "time anchor" for this machine's monotone clock (for `Instant` simulation).
+    pub(crate) time_anchor: TimeAnchor,
 }
 
 impl<'mir, 'tcx> Default for ThreadManager<'mir, 'tcx> {
@@ -248,6 +257,7 @@ impl<'mir, 'tcx> Default for ThreadManager<'mir, 'tcx> {
             thread_local_alloc_ids: Default::default(),
             yield_active_thread: false,
             timeout_callbacks: FxHashMap::default(),
+            time_anchor: TimeAnchor::new(false),
         }
     }
 }
@@ -258,6 +268,8 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
             // The main thread can *not* be joined on except on windows.
             ecx.machine.threads.threads[ThreadId::new(0)].join_status = ThreadJoinStatus::Detached;
         }
+
+        ecx.machine.threads.time_anchor = TimeAnchor::new(ecx.machine.communicate());
     }
 
     /// Check if we have an allocation for the given thread local static for the
@@ -611,7 +623,8 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
             // All threads are currently blocked, but we have unexecuted
             // timeout_callbacks, which may unblock some of the threads. Hence,
             // sleep until the first callback.
-            std::thread::sleep(sleep_time);
+
+            self.time_anchor.sleep(sleep_time);
             Ok(SchedulingAction::ExecuteTimeoutCallback)
         } else {
             throw_machine_stop!(TerminationInfo::Deadlock);
diff --git a/src/eval.rs b/src/eval.rs
@@ -344,11 +344,6 @@ pub fn eval_entry<'tcx>(
                     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 => {
diff --git a/src/machine.rs b/src/machine.rs
@@ -4,7 +4,6 @@
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::fmt;
-use std::time::Instant;
 
 use rand::rngs::StdRng;
 use rand::SeedableRng;
@@ -294,9 +293,6 @@ pub struct Evaluator<'mir, 'tcx> {
     /// The table of directory descriptors.
     pub(crate) dir_handler: shims::unix::DirHandler,
 
-    /// The "time anchor" for this machine's monotone clock (for `Instant` simulation).
-    pub(crate) time_anchor: Instant,
-
     /// The set of threads.
     pub(crate) threads: ThreadManager<'mir, 'tcx>,
 
@@ -392,7 +388,6 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             enforce_abi: config.check_abi,
             file_handler: FileHandler::new(config.mute_stdout_stderr),
             dir_handler: Default::default(),
-            time_anchor: Instant::now(),
             layouts,
             threads: ThreadManager::default(),
             static_roots: Vec::new(),
@@ -961,6 +956,9 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         }
         // These are our preemption points.
         ecx.maybe_preempt_active_thread();
+
+        ecx.machine.threads.time_anchor.tick();
+
         Ok(())
     }
 
diff --git a/src/shims/time.rs b/src/shims/time.rs
@@ -1,8 +1,68 @@
+use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
+use rustc_data_structures::sync::Ordering;
+
 use crate::concurrency::thread::Time;
 use crate::*;
 
+#[derive(Debug)]
+pub enum TimeAnchor {
+    Host(Instant),
+    Virtual(Arc<AtomicU64>),
+}
+
+impl TimeAnchor {
+    pub fn new(communicate: bool) -> Self {
+        if communicate { Self::Host(Instant::now()) } else { Self::Virtual(Arc::new(0.into())) }
+    }
+
+    pub fn get(&self) -> Duration {
+        match self {
+            Self::Host(instant) => Instant::now().saturating_duration_since(*instant),
+            Self::Virtual(nanoseconds) => Duration::from_nanos(nanoseconds.load(Ordering::Relaxed)),
+        }
+    }
+
+    pub fn tick(&self) {
+        match self {
+            Self::Host(_) => (),
+            Self::Virtual(nanoseconds) => {
+                nanoseconds.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+    }
+
+    pub fn sleep(&self, duration: Duration) {
+        match self {
+            Self::Host(_) => std::thread::sleep(duration),
+            Self::Virtual(nanoseconds) => {
+                nanoseconds.fetch_add(duration.as_nanos().try_into().unwrap(), Ordering::Relaxed);
+            }
+        }
+    }
+
+    pub fn checked_add_since_now(&self, duration: Duration) -> Option<Time> {
+        match self {
+            Self::Host(_) => Instant::now().checked_add(duration).map(Time::Monotonic),
+            Self::Virtual(nanoseconds) =>
+                nanoseconds
+                    .load(Ordering::Relaxed)
+                    .checked_add(duration.as_nanos().try_into().unwrap())
+                    .map(|duration| Time::Virtual(duration, nanoseconds.clone())),
+        }
+    }
+
+    pub fn checked_add_since_start(&self, duration: Duration) -> Option<Time> {
+        match self {
+            Self::Host(instant) => instant.checked_add(duration).map(Time::Monotonic),
+            Self::Virtual(now) =>
+                Some(Time::Virtual(duration.as_nanos().try_into().unwrap(), now.clone())),
+        }
+    }
+}
+
 /// Returns the time elapsed between the provided time and the unix epoch as a `Duration`.
 pub fn system_time_to_duration<'tcx>(time: &SystemTime) -> InterpResult<'tcx, Duration> {
     time.duration_since(SystemTime::UNIX_EPOCH)
@@ -23,7 +83,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let this = self.eval_context_mut();
 
         this.assert_target_os("linux", "clock_gettime");
-        this.check_no_isolation("`clock_gettime`")?;
 
         let clk_id = this.read_scalar(clk_id_op)?.to_i32()?;
 
@@ -40,9 +99,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             [this.eval_libc_i32("CLOCK_MONOTONIC")?, this.eval_libc_i32("CLOCK_MONOTONIC_COARSE")?];
 
         let duration = if absolute_clocks.contains(&clk_id) {
+            this.check_no_isolation("`clock_gettime` with real time clocks")?;
             system_time_to_duration(&SystemTime::now())?
         } else if relative_clocks.contains(&clk_id) {
-            Instant::now().duration_since(this.machine.time_anchor)
+            this.machine.threads.time_anchor.get()
         } else {
             let einval = this.eval_libc("EINVAL")?;
             this.set_last_error(einval)?;
@@ -127,7 +187,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // QueryPerformanceCounter uses a hardware counter as its basis.
         // Miri will emulate a counter with a resolution of 1 nanosecond.
-        let duration = Instant::now().duration_since(this.machine.time_anchor);
+        let duration = this.machine.threads.time_anchor.get();
         let qpc = i64::try_from(duration.as_nanos()).map_err(|_| {
             err_unsup_format!("programs running longer than 2^63 nanoseconds are not supported")
         })?;
@@ -168,7 +228,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // This returns a u64, with time units determined dynamically by `mach_timebase_info`.
         // We return plain nanoseconds.
-        let duration = Instant::now().duration_since(this.machine.time_anchor);
+        let duration = this.machine.threads.time_anchor.get();
         let res = u64::try_from(duration.as_nanos()).map_err(|_| {
             err_unsup_format!("programs running longer than 2^64 nanoseconds are not supported")
         })?;
@@ -202,7 +262,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let this = self.eval_context_mut();
 
         this.assert_target_os_is_unix("nanosleep");
-        this.check_no_isolation("`nanosleep`")?;
 
         let duration = match this.read_timespec(&this.deref_operand(req_op)?)? {
             Some(duration) => duration,
@@ -213,10 +272,14 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
         };
         // If adding the duration overflows, let's just sleep for an hour. Waking up early is always acceptable.
-        let timeout_time = Instant::now()
-            .checked_add(duration)
-            .unwrap_or_else(|| Instant::now().checked_add(Duration::from_secs(3600)).unwrap());
-        let timeout_time = Time::Monotonic(timeout_time);
+        let timeout_time =
+            this.machine.threads.time_anchor.checked_add_since_now(duration).unwrap_or_else(|| {
+                this.machine
+                    .threads
+                    .time_anchor
+                    .checked_add_since_now(Duration::from_secs(3600))
+                    .unwrap()
+            });
 
         let active_thread = this.get_active_thread();
         this.block_thread(active_thread);
@@ -238,12 +301,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let this = self.eval_context_mut();
 
         this.assert_target_os("windows", "Sleep");
-        this.check_no_isolation("`Sleep`")?;
 
         let timeout_ms = this.read_scalar(timeout)?.to_u32()?;
 
         let duration = Duration::from_millis(timeout_ms.into());
-        let timeout_time = Time::Monotonic(Instant::now().checked_add(duration).unwrap());
+        let timeout_time =
+            this.machine.threads.time_anchor.checked_add_since_now(duration).unwrap();
 
         let active_thread = this.get_active_thread();
         this.block_thread(active_thread);
diff --git a/src/shims/unix/linux/sync.rs b/src/shims/unix/linux/sync.rs
@@ -1,7 +1,7 @@
 use crate::concurrency::thread::Time;
 use crate::*;
 use rustc_target::abi::{Align, Size};
-use std::time::{Instant, SystemTime};
+use std::time::SystemTime;
 
 /// Implementation of the SYS_futex syscall.
 /// `args` is the arguments *after* the syscall number.
@@ -106,14 +106,14 @@ pub fn futex<'tcx>(
                     if op & futex_realtime != 0 {
                         Time::RealTime(SystemTime::UNIX_EPOCH.checked_add(duration).unwrap())
                     } else {
-                        Time::Monotonic(this.machine.time_anchor.checked_add(duration).unwrap())
+                        this.machine.threads.time_anchor.checked_add_since_start(duration).unwrap()
                     }
                 } else {
                     // FUTEX_WAIT uses a relative timestamp.
                     if op & futex_realtime != 0 {
                         Time::RealTime(SystemTime::now().checked_add(duration).unwrap())
                     } else {
-                        Time::Monotonic(Instant::now().checked_add(duration).unwrap())
+                        this.machine.threads.time_anchor.checked_add_since_now(duration).unwrap()
                     }
                 })
             };
diff --git a/src/shims/unix/sync.rs b/src/shims/unix/sync.rs
@@ -859,7 +859,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let timeout_time = if clock_id == this.eval_libc_i32("CLOCK_REALTIME")? {
             Time::RealTime(SystemTime::UNIX_EPOCH.checked_add(duration).unwrap())
         } else if clock_id == this.eval_libc_i32("CLOCK_MONOTONIC")? {
-            Time::Monotonic(this.machine.time_anchor.checked_add(duration).unwrap())
+            this.machine.threads.time_anchor.checked_add_since_start(duration).unwrap()
         } else {
             throw_unsup_format!("unsupported clock id: {}", clock_id);
         };

Original file line number	Diff line number	Diff line change
`@@ -344,11 +344,6 @@ pub fn eval_entry<'tcx>(`
`344`	`344`	`assert!(ecx.step()?, "a terminated thread was scheduled for execution");`
`345`	`345`	`}`
`346`	`346`	`SchedulingAction::ExecuteTimeoutCallback => {`
`347`		`- assert!(`
`348`		`- ecx.machine.communicate(),`
`349`		`- "scheduler callbacks require disabled isolation, but the code \`
`350`		`- that created the callback did not check it"`
`351`		`- );`
`352`	`347`	`ecx.run_timeout_callback()?;`
`353`	`348`	`}`
`354`	`349`	`SchedulingAction::ExecuteDtors => {`