Use real exec on cfg(unix) targets

When cargo-miri is executed as a cargo test runner or rustdoc runtool,
external tools expect what they launch as the runner/runtool to be the
process actually running the test. But in the implementation, we launch
the Miri interpreter as a subprocess using std::process::Command. This
tends to confuse other tools (like nextest) and users (like the author).
What we really want is to call POSIX exec so that the cargo-miri process
becomes the interpreter.

So this implements just that; we call execve via a cfg(unix) extension
trait. Windows has no such mechanism, but it also doesn't have POSIX
signals, which is the primary tripping hazard this change fixes.

Author: saethlin

cargo-miri/Cargo.lock

@@ -17,6 +17,7 @@ doctest = false # and no doc tests
 directories = "3"
 rustc_version = "0.4"
 serde_json = "1.0.40"
+libc = "0.2"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.
 # See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`

cargo-miri/Cargo.toml

@@ -51,7 +51,7 @@ enum MiriCommand {
 }
 
 /// The information to run a crate with the given environment.
-#[derive(Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize)]
 struct CrateRunEnv {
     /// The command-line arguments.
     args: Vec<String>,
@@ -251,26 +251,72 @@ fn xargo_check() -> Command {
 
 /// Execute the command. If it fails, fail this process with the same exit code.
 /// Otherwise, continue.
-fn exec(mut cmd: Command) {
-    let exit_status = cmd.status().expect("failed to run command");
-    if exit_status.success().not() {
-        std::process::exit(exit_status.code().unwrap_or(-1))
+fn exec(mut cmd: Command) -> ! {
+    // On non-Unix imitate POSIX exec as closely as we can
+    #[cfg(not(unix))]
+    {
+        let exit_status = cmd.status().expect("failed to run command");
+        std::process::exit(exit_status.code().unwrap_or(-1));
+    }
+    // On Unix targets, actually exec
+    // If exec returns, process setup has failed. This is the same error condition as the expect in
+    // the non-Unix case.
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        let error = cmd.exec();
+        Err(error).expect("failed to run command")
     }
 }
 
 /// Execute the command and pipe `input` into its stdin.
 /// If it fails, fail this process with the same exit code.
 /// Otherwise, continue.
 fn exec_with_pipe(mut cmd: Command, input: &[u8]) {
-    cmd.stdin(process::Stdio::piped());
-    let mut child = cmd.spawn().expect("failed to spawn process");
+    #[cfg(unix)]
     {
-        let stdin = child.stdin.as_mut().expect("failed to open stdin");
-        stdin.write_all(input).expect("failed to write out test source");
+        use std::os::unix::io::FromRawFd;
+        use std::process::Stdio;
+
+        let mut fds: [libc::c_int; 2] = [0, 0];
+        // SAFETY: fds is an array of 2 libc::c_int
+        let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+        assert_eq!(res, 0, "failed to create pipe");
+
+        // We need to set close-on-exec, otherwise our pipe isn't readable after exec
+        // SAFETY: fcntl has no preconditions
+        unsafe {
+            for fd in &fds {
+                let res = libc::fcntl(
+                    *fd,
+                    libc::F_SETFD,
+                    libc::fcntl(*fd, libc::F_GETFD) | libc::FD_CLOEXEC,
+                );
+                assert_eq!(res, 0, "failed to set close-on-exec for pipe");
+            }
+        }
+
+        // SAFETY: Both elements of fds are open file descriptors, because pipe2 returned 0
+        let dst = unsafe { Stdio::from_raw_fd(fds[0]) };
+        let mut src = unsafe { File::from_raw_fd(fds[1]) };
+
+        src.write_all(input).expect("failed to write out test source");
+
+        cmd.stdin(dst);
+        exec(cmd)
     }
-    let exit_status = child.wait().expect("failed to run command");
-    if exit_status.success().not() {
-        std::process::exit(exit_status.code().unwrap_or(-1))
+    #[cfg(not(unix))]
+    {
+        cmd.stdin(process::Stdio::piped());
+        let mut child = cmd.spawn().expect("failed to spawn process");
+        {
+            let stdin = child.stdin.as_mut().expect("failed to open stdin");
+            stdin.write_all(input).expect("failed to write out test source");
+        }
+        let exit_status = child.wait().expect("failed to run command");
+        if exit_status.success().not() {
+            std::process::exit(exit_status.code().unwrap_or(-1))
+        }
     }
 }
 
@@ -872,6 +918,8 @@ fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
         // and environment variables; this is used when cargo calls us again in the CARGO_TARGET_RUNNER phase.
         let env = CrateRunEnv::collect(args, inside_rustdoc);
 
+        store_json(CrateRunInfo::RunWith(env.clone()));
+
         // Rustdoc expects us to exit with an error code if the test is marked as `compile_fail`,
         // just creating the JSON file is not enough: we need to detect syntax errors,
         // so we need to run Miri with `MIRI_BE_RUSTC` for a check-only build.
@@ -888,7 +936,14 @@ fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
                 cmd.arg("--emit=metadata");
             }
 
-            cmd.args(&env.args);
+            let mut args = env.args.clone();
+            for i in 0..args.len() {
+                if args[i] == "-o" {
+                    args[i + 1] = format!("{}_miri", args[i + 1]);
+                }
+            }
+
+            cmd.args(&args);
             cmd.env("MIRI_BE_RUSTC", "target");
 
             if verbose > 0 {
@@ -902,8 +957,6 @@ fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
             exec_with_pipe(cmd, &env.stdin);
         }
 
-        store_json(CrateRunInfo::RunWith(env));
-
         return;
     }
 
@@ -983,8 +1036,6 @@ fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
             "[cargo-miri rustc] target_crate={target_crate} runnable_crate={runnable_crate} print={print}"
         );
     }
-    debug_cmd("[cargo-miri rustc]", verbose, &cmd);
-    exec(cmd);
 
     // Create a stub .rlib file if "link" was requested by cargo.
     // This is necessary to prevent cargo from doing rebuilds all the time.
@@ -999,6 +1050,9 @@ fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
         File::create(out_filename("", ".dll")).expect("failed to create fake .dll file");
         File::create(out_filename("", ".lib")).expect("failed to create fake .lib file");
     }
+
+    debug_cmd("[cargo-miri rustc]", verbose, &cmd);
+    exec(cmd);
 }
 
 #[derive(Debug, Copy, Clone, PartialEq)]