pipe by writing input to a file then setting that file as stdin

Author: saethlin

cargo-miri/Cargo.lock

@@ -17,7 +17,6 @@ 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

@@ -271,32 +271,28 @@ fn exec(mut cmd: Command) -> ! {
 
 /// Execute the `Command`, where possible by replacing the current process with a new process
 /// described by the `Command`. Then exit this process with the exit code of the new process.
-/// `input` is also piped to the new process's stdin.
-fn exec_with_pipe(mut cmd: Command, input: &[u8]) -> ! {
+/// `input` is also piped to the new process's stdin, on cfg(unix) platforms by writing its
+/// contents to `path` first, then setting stdin to that file.
+fn exec_with_pipe<P>(mut cmd: Command, input: &[u8], path: P) -> !
+where
+    P: AsRef<Path>,
+{
     #[cfg(unix)]
     {
-        use std::os::unix::io::FromRawFd;
-        use std::process::Stdio;
+        // Write the bytes we want to send to stdin out to a file
+        std::fs::write(&path, input).unwrap();
 
-        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");
+        // Open the file for reading, and set our new stdin to it
+        let stdin = File::open(&path).unwrap();
+        cmd.stdin(stdin);
 
-        // SAFETY: Both elements of fds are open file descriptors, because pipe 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");
-
-        // Close the writing part of the pipe in the parent process
-        drop(src);
-
-        cmd.stdin(dst);
+        // Unlink the file so that it is fully cleaned up as soon as the new process exits
+        std::fs::remove_file(&path).unwrap();
         exec(cmd)
     }
     #[cfg(not(unix))]
     {
+        drop(path); // We don't need the path, we can pipe the bytes directly
         cmd.stdin(process::Stdio::piped());
         let mut child = cmd.spawn().expect("failed to spawn process");
         {
@@ -943,7 +939,7 @@ fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
                 eprintln!("[cargo-miri rustc inside rustdoc] going to run:\n{:?}", cmd);
             }
 
-            exec_with_pipe(cmd, &env.stdin);
+            exec_with_pipe(cmd, &env.stdin, format!("{}.stdin", out_filename("", "").display()));
         }
 
         return;
@@ -1143,7 +1139,7 @@ fn phase_runner(mut binary_args: impl Iterator<Item = String>, phase: RunnerPhas
     // Run it.
     debug_cmd("[cargo-miri runner]", verbose, &cmd);
     match phase {
-        RunnerPhase::Rustdoc => exec_with_pipe(cmd, &info.stdin),
+        RunnerPhase::Rustdoc => exec_with_pipe(cmd, &info.stdin, format!("{}.stdin", binary)),
         RunnerPhase::Cargo => exec(cmd),
     }
 }