Deprecate -Zmiri-disable-isolation flag

Replaced all the instances of it with new option
`-Zmiri-isolated-op=allow`.

Replaced `communicate` member in machine with a helper method to check
for isolation.

Author: atsmtat

README.md

@@ -164,10 +164,10 @@ doesn't expose any environment to the program, so running
 `RUST_BACKTRACE=1 cargo miri test` will not do what you expect.
 
 To get a backtrace, you need to disable isolation
-[using `-Zmiri-disable-isolation`][miri-flags]:
+[using `-Zmiri-isolated-op=allow`][miri-flags]:
 
 ```sh
-RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-disable-isolation" cargo miri test
+RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-isolated-op=allow" cargo miri test
 ```
 
 #### "found possibly newer version of crate `std` which `<dependency>` depends on"
@@ -214,9 +214,13 @@ environment variable:
   as out-of-bounds accesses) first.  Setting this flag means Miri can miss bugs
   in your program.  However, this can also help to make Miri run faster.  Using
   this flag is **unsound**.
-* `-Zmiri-disable-isolation` disables host isolation.  As a consequence,
-  the program has access to host resources such as environment variables, file
-  systems, and randomness.
+* `-Zmiri-isolated-op=<action>` sets machine behaviour for ops which require
+  communication with the host. Action can be `hide`, `warn`, `warn-nobacktrace`,
+  or `allow`. By default, miri returns an error about isolation and prints a 
+  warning without backtrace (`warn-nobacktrace`). To trace call sites, use
+  `warn`, which enables backtraces. `hide` suppresses warning. `allow` disables
+  isolation. As a consequence, the program has access to host resources such as
+  environment variables, file systems, and randomness.
 * `-Zmiri-env-exclude=<var>` keeps the `var` environment variable isolated from
   the host so that it cannot be accessed by the program.  Can be used multiple
   times to exclude several variables.  On Windows, the `TERM` environment

src/bin/miri.rs

@@ -227,10 +227,6 @@ fn main() {
                 "-Zmiri-symbolic-alignment-check" => {
                     miri_config.check_alignment = miri::AlignmentCheck::Symbolic;
                 }
-                "-Zmiri-disable-isolation" => {
-                    miri_config.communicate = true;
-                    miri_config.isolated_op = miri::IsolatedOp::Allow;
-                }
                 "-Zmiri-ignore-leaks" => {
                     miri_config.ignore_leaks = true;
                 }

src/diagnostics.rs

@@ -71,7 +71,7 @@ pub fn report_error<'tcx, 'mir>(
             #[rustfmt::skip]
             let helps = match info {
                 UnsupportedInIsolation(_) =>
-                    vec![format!("pass the flag `-Zmiri-disable-isolation` to disable isolation")],
+                    vec![format!("pass the flag `-Zmiri-isolated-op=allow` to disable isolation")],
                 ExperimentalUb { url, .. } =>
                     vec![
                         format!("this indicates a potential bug in the program: it performed an invalid operation, but the rules it violated are still experimental"),

src/eval.rs

@@ -22,7 +22,7 @@ pub enum AlignmentCheck {
     Int,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum RejectOpWith {
     /// Do not print warning about rejected isolated op
     NoWarning,
@@ -34,7 +34,7 @@ pub enum RejectOpWith {
     WarningWithoutBacktrace,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum IsolatedOp {
     /// Reject op requiring communication with the host. Usually, miri
     /// generates a fake error for such op, and prints a warning
@@ -54,8 +54,6 @@ pub struct MiriConfig {
     pub stacked_borrows: bool,
     /// Controls alignment checking.
     pub check_alignment: AlignmentCheck,
-    /// Determines if communication with the host environment is enabled.
-    pub communicate: bool,
     /// Action for an op requiring communication with the host.
     pub isolated_op: IsolatedOp,
     /// Determines if memory leaks should be ignored.
@@ -87,7 +85,6 @@ impl Default for MiriConfig {
             validate: true,
             stacked_borrows: true,
             check_alignment: AlignmentCheck::Int,
-            communicate: false,
             isolated_op: IsolatedOp::Reject(RejectOpWith::WarningWithoutBacktrace),
             ignore_leaks: false,
             excluded_env_vars: vec![],
@@ -252,7 +249,7 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
                 }
                 SchedulingAction::ExecuteTimeoutCallback => {
                     assert!(
-                        ecx.machine.communicate,
+                        ecx.machine.communicate(),
                         "scheduler callbacks require disabled isolation, but the code \
                         that created the callback did not check it"
                     );

src/helpers.rs

@@ -140,7 +140,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         let mut data = vec![0; usize::try_from(len).unwrap()];
 
-        if this.machine.communicate {
+        if this.machine.communicate() {
             // Fill the buffer using the host's rng.
             getrandom::getrandom(&mut data)
                 .map_err(|err| err_unsup_format!("host getrandom failed: {}", err))?;
@@ -391,7 +391,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     /// disabled. It returns an error using the `name` of the foreign function if this is not the
     /// case.
     fn check_no_isolation(&self, name: &str) -> InterpResult<'tcx> {
-        if !self.eval_context_ref().machine.communicate {
+        if !self.eval_context_ref().machine.communicate() {
             isolation_error(name)?;
         }
         Ok(())

src/machine.rs

@@ -249,10 +249,6 @@ pub struct Evaluator<'mir, 'tcx> {
     /// TLS state.
     pub(crate) tls: TlsData<'tcx>,
 
-    /// If enabled, the `env_vars` field is populated with the host env vars during initialization
-    /// and random number generation is delegated to the host.
-    pub(crate) communicate: bool,
-
     /// What should Miri do when an op requires communicating with the host,
     /// such as accessing host env vars, random number generation, and
     /// file system access.
@@ -289,7 +285,6 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             argv: None,
             cmd_line: None,
             tls: TlsData::default(),
-            communicate: config.communicate,
             isolated_op: config.isolated_op,
             validate: config.validate,
             file_handler: Default::default(),
@@ -300,6 +295,10 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             static_roots: Vec::new(),
         }
     }
+
+    pub(crate) fn communicate(&self) -> bool {
+        self.isolated_op == IsolatedOp::Allow
+    }
 }
 
 /// A rustc InterpCx for Miri.

src/shims/env.rs

@@ -46,7 +46,7 @@ impl<'tcx> EnvVars<'tcx> {
             excluded_env_vars.push("TERM".to_owned());
         }
 
-        if ecx.machine.communicate {
+        if ecx.machine.communicate() {
             for (name, value) in env::vars() {
                 if !excluded_env_vars.contains(&name) {
                     let var_ptr = match target_os {

src/shims/posix/fs.rs

@@ -662,7 +662,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let fd = this.read_scalar(fd_op)?.to_i32()?;
 
         if let Some(file_descriptor) = this.machine.file_handler.handles.remove(&fd) {
-            let result = file_descriptor.close(this.machine.communicate)?;
+            let result = file_descriptor.close(this.machine.communicate())?;
             this.try_unwrap_io_result(result)
         } else {
             this.handle_not_found()
@@ -688,6 +688,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         // host's and target's `isize`. This saves us from having to handle overflows later.
         let count = count.min(this.machine_isize_max() as u64).min(isize::MAX as u64);
 
+        let communicate = this.machine.communicate();
         if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
             trace!("read: FD mapped to {:?}", file_descriptor);
             // We want to read at most `count` bytes. We are sure that `count` is not negative
@@ -697,7 +698,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             // `File::read` never returns a value larger than `count`,
             // so this cannot fail.
             let result = file_descriptor
-                .read(this.machine.communicate, &mut bytes)?
+                .read(communicate, &mut bytes)?
                 .map(|c| i64::try_from(c).unwrap());
 
             match result {
@@ -734,10 +735,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         // host's and target's `isize`. This saves us from having to handle overflows later.
         let count = count.min(this.machine_isize_max() as u64).min(isize::MAX as u64);
 
+        let communicate = this.machine.communicate();
         if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
             let bytes = this.memory.read_bytes(buf, Size::from_bytes(count))?;
             let result = file_descriptor
-                .write(this.machine.communicate, &bytes)?
+                .write(communicate, &bytes)?
                 .map(|c| i64::try_from(c).unwrap());
             this.try_unwrap_io_result(result)
         } else {
@@ -771,9 +773,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             return Ok(-1);
         };
 
+        let communicate = this.machine.communicate();
         if let Some(file_descriptor) = this.machine.file_handler.handles.get_mut(&fd) {
             let result = file_descriptor
-                .seek(this.machine.communicate, seek_from)?
+                .seek(communicate, seek_from)?
                 .map(|offset| i64::try_from(offset).unwrap());
             this.try_unwrap_io_result(result)
         } else {

test-cargo-miri/run-test.py

@@ -82,7 +82,7 @@ def test_cargo_miri_run():
         "run.default.stdout.ref", "run.default.stderr.ref",
         stdin=b'12\n21\n',
         env={
-            'MIRIFLAGS': "-Zmiri-disable-isolation",
+            'MIRIFLAGS': "-Zmiri-isolated-op=allow",
             'MIRITESTVAR': "wrongval", # make sure the build.rs value takes precedence
         },
     )
@@ -99,7 +99,7 @@ def test_cargo_miri_run():
     test("`cargo miri run` (subcrate, no ioslation)",
         cargo_miri("run") + ["-p", "subcrate"],
         "run.subcrate.stdout.ref", "run.subcrate.stderr.ref",
-        env={'MIRIFLAGS': "-Zmiri-disable-isolation"},
+        env={'MIRIFLAGS': "-Zmiri-isolated-op=allow"},
     )
 
 def test_cargo_miri_test():
@@ -116,7 +116,7 @@ def test_cargo_miri_test():
     test("`cargo miri test` (no isolation, no doctests)",
         cargo_miri("test") + ["--bins", "--tests"], # no `--lib`, we disabled that in `Cargo.toml`
         "test.cross-target.stdout.ref", "test.stderr-empty.ref",
-        env={'MIRIFLAGS': "-Zmiri-disable-isolation"},
+        env={'MIRIFLAGS': "-Zmiri-isolated-op=allow"},
     )
     test("`cargo miri test` (raw-ptr tracking)",
         cargo_miri("test"),
@@ -138,7 +138,7 @@ def test_cargo_miri_test():
     test("`cargo miri test` (subcrate, no isolation)",
         cargo_miri("test") + ["-p", "subcrate"],
         "test.subcrate.stdout.ref", "test.stderr-proc-macro.ref",
-        env={'MIRIFLAGS': "-Zmiri-disable-isolation"},
+        env={'MIRIFLAGS': "-Zmiri-isolated-op=allow"},
     )
 
 os.chdir(os.path.dirname(os.path.realpath(__file__)))

tests/compile-fail/data_race/dangling_thread_async_race.rs

@@ -1,5 +1,5 @@
 // ignore-windows: Concurrency on Windows is not supported yet.
-// compile-flags: -Zmiri-disable-isolation
+// compile-flags: -Zmiri-isolated-op=allow
 
 use std::thread::{spawn, sleep};
 use std::time::Duration;