Add flags to control user visibility of dummy ops in isolation

For the ops which are not supported in isolation mode (e.g. `getcwd`),
miri produces a dummy error. By default, a warning is printed to let
the user know about this decision. This change adds a couple of flags
to control the level of details in such messages as per user
requirement.
`-Zmiri-ignore-dummy-op` -- stops generating warnings
`-Zmiri-track-dummy-op` -- generates a note with a backtrace per line
running dummy op

Author: atsmtat

src/bin/miri.rs

@@ -236,6 +236,12 @@ fn main() {
                 "-Zmiri-track-raw-pointers" => {
                     miri_config.track_raw = true;
                 }
+                "-Zmiri-track-dummy-op" => {
+                    miri_config.dummy_op_visibility = miri::DummyOpVisibility::Track;
+                }
+                "-Zmiri-ignore-dummy-op" => {
+                    miri_config.dummy_op_visibility = miri::DummyOpVisibility::Hide;
+                }
                 "--" => {
                     after_dashdash = true;
                 }

src/diagnostics.rs

@@ -40,6 +40,7 @@ pub enum NonHaltingDiagnostic {
     CreatedCallId(CallId),
     CreatedAlloc(AllocId),
     FreedAlloc(AllocId),
+    DummyOpInIsolation(String),
 }
 
 /// Emit a custom diagnostic without going through the miri-engine machinery
@@ -279,6 +280,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     CreatedCallId(id) => format!("function call with id {}", id),
                     CreatedAlloc(AllocId(id)) => format!("created allocation with id {}", id),
                     FreedAlloc(AllocId(id)) => format!("freed allocation with id {}", id),
+                    DummyOpInIsolation(op) => format!("produced dummy error for `{}`", op),
                 };
                 report_msg(
                     *this.tcx,

src/eval.rs

@@ -22,6 +22,16 @@ pub enum AlignmentCheck {
     Int,
 }
 
+#[derive(Copy, Clone, Debug)]
+pub enum DummyOpVisibility {
+    /// Do not report a dummy op
+    Hide,
+    /// Print a warning without a backtrace, once per dummy op
+    Warn,
+    /// Print a note with a backtrace, once per line calling dummy op
+    Track,
+}
+
 /// Configuration needed to spawn a Miri instance.
 #[derive(Clone)]
 pub struct MiriConfig {
@@ -54,6 +64,8 @@ pub struct MiriConfig {
     /// Rate of spurious failures for compare_exchange_weak atomic operations,
     /// between 0.0 and 1.0, defaulting to 0.8 (80% chance of failure).
     pub cmpxchg_weak_failure_rate: f64,
+    /// Visibility level of a dummy op performed in isolation mode
+    pub dummy_op_visibility: DummyOpVisibility,
 }
 
 impl Default for MiriConfig {
@@ -73,6 +85,7 @@ impl Default for MiriConfig {
             track_raw: false,
             data_race_detector: true,
             cmpxchg_weak_failure_rate: 0.8,
+            dummy_op_visibility: DummyOpVisibility::Warn,
         }
     }
 }
@@ -92,7 +105,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
         tcx,
         rustc_span::source_map::DUMMY_SP,
         param_env,
-        Evaluator::new(config.communicate, config.validate, layout_cx),
+        Evaluator::new(&config, layout_cx),
         MemoryExtra::new(&config),
     );
     // Complete initialization.

src/helpers.rs

@@ -397,12 +397,24 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         Ok(())
     }
 
-    /// Helper function used inside the shims of foreign functions
-    /// which produce a dummy error when isolation is enabled. It is
-    /// used to print a warning informing this decision to the user.
-    fn warn_foreign_in_isolation(&self, name: &str) {
+    /// Helper function used inside the shims of foreign functions which produce a dummy error
+    /// when isolation is enabled. It is used to print a warning/backtrace, informing this
+    /// decision to the user.
+    fn report_dummy_in_isolation(&self, name: &str) {
         let this = self.eval_context_ref();
-        this.tcx.sess.warn(&format!("`{}` in isolation mode produced a dummy error", name));
+        match this.machine.dummy_op_visibility {
+            DummyOpVisibility::Warn => {
+                let msg = format!("`{}` in isolation mode produced a dummy error", name);
+                let mut warn = this.tcx.sess.struct_warn(&msg);
+                warn.note("run with -Zmiri-track-dummy-op to track with a backtrace");
+                warn.note("run with -Zmiri-ignore-dummy-op to ignore warning");
+                warn.emit();
+            }
+            DummyOpVisibility::Track => {
+                register_diagnostic(NonHaltingDiagnostic::DummyOpInIsolation(name.to_string()));
+            }
+            DummyOpVisibility::Hide => {} // no diagnostics
+        }
     }
 
     /// Helper function used inside the shims of foreign functions to assert that the target OS

src/lib.rs

@@ -57,7 +57,7 @@ pub use crate::diagnostics::{
     register_diagnostic, report_error, EvalContextExt as DiagnosticsEvalContextExt,
     NonHaltingDiagnostic, TerminationInfo,
 };
-pub use crate::eval::{create_ecx, eval_main, AlignmentCheck, MiriConfig};
+pub use crate::eval::{create_ecx, eval_main, AlignmentCheck, DummyOpVisibility, MiriConfig};
 pub use crate::helpers::EvalContextExt as HelpersEvalContextExt;
 pub use crate::machine::{
     AllocExtra, Evaluator, FrameData, MemoryExtra, MiriEvalContext, MiriEvalContextExt,

src/machine.rs

@@ -257,6 +257,9 @@ pub struct Evaluator<'mir, 'tcx> {
     /// and random number generation is delegated to the host.
     pub(crate) communicate: bool,
 
+    /// Level of user visibility to dummy ops run in isolation mode.
+    pub(crate) dummy_op_visibility: DummyOpVisibility,
+
     /// Whether to enforce the validity invariant.
     pub(crate) validate: bool,
 
@@ -278,8 +281,7 @@ pub struct Evaluator<'mir, 'tcx> {
 
 impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
     pub(crate) fn new(
-        communicate: bool,
-        validate: bool,
+        config: &MiriConfig,
         layout_cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
     ) -> Self {
         let layouts =
@@ -292,8 +294,9 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             argv: None,
             cmd_line: None,
             tls: TlsData::default(),
-            communicate,
-            validate,
+            communicate: config.communicate,
+            dummy_op_visibility: config.dummy_op_visibility,
+            validate: config.validate,
             file_handler: Default::default(),
             dir_handler: Default::default(),
             time_anchor: Instant::now(),

src/shims/env.rs

@@ -338,7 +338,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
         } else {
             // Return a dummy error in isolation mode, after printing a warning about it.
-            this.warn_foreign_in_isolation("getcwd");
+            this.report_dummy_in_isolation("getcwd");
             let err = Error::new(ErrorKind::NotFound, "dummy error in isolation mode");
             this.set_last_error_from_io_error(err)?;
         }
@@ -366,7 +366,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
         } else {
             // Return a dummy error in isolation mode, after printing a warning about it.
-            this.warn_foreign_in_isolation("GetCurrentDirectoryW");
+            this.report_dummy_in_isolation("GetCurrentDirectoryW");
             let err = Error::new(ErrorKind::NotFound, "dummy error in isolation mode");
             this.set_last_error_from_io_error(err)?;
         }
@@ -393,7 +393,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
         } else {
             // Return a dummy error in isolation mode, after printing a warning about it.
-            this.warn_foreign_in_isolation("chdir");
+            this.report_dummy_in_isolation("chdir");
             let err = Error::new(ErrorKind::NotFound, "dummy error in isolation mode");
             this.set_last_error_from_io_error(err)?;
 
@@ -423,7 +423,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
         } else {
             // Return a dummy error in isolation mode, after printing a warning about it.
-            this.warn_foreign_in_isolation("SetCurrentDirectoryW");
+            this.report_dummy_in_isolation("SetCurrentDirectoryW");
             let err = Error::new(ErrorKind::NotFound, "dummy error in isolation mode");
             this.set_last_error_from_io_error(err)?;
             Ok(0)

tests/run-pass/current_dir_with_isolation.rs

@@ -5,5 +5,12 @@ fn main() {
     // Test that current dir operations return the dummy error instead
     // of stopping the machine in isolation mode
     assert_eq!(env::current_dir().unwrap_err().kind(), ErrorKind::NotFound);
+    for _i in 0..3 {
+        assert_eq!(env::current_dir().unwrap_err().kind(), ErrorKind::NotFound);
+    }
+
     assert_eq!(env::set_current_dir("..").unwrap_err().kind(), ErrorKind::NotFound);
+    for _i in 0..3 {
+        assert_eq!(env::set_current_dir("..").unwrap_err().kind(), ErrorKind::NotFound);
+    }
 }