os/exec: cmd.Wait does not return after process termination when stdin is attached

[sykesm]

The following code terminates with a deadlock error when run in isolation. If we replace the usage of io.Pipe with cmd.StdinPipe(), the program terminates normally with the expected error from cmd.Wait().

This is on Darwin 14.1.0 with go 1.4.2.

package main

import (
    "fmt"
    "io"
    "syscall"
)

import "os/exec"

func main() {
    pr, pw := io.Pipe()

    cmd := exec.Command("/bin/bash", "-c", "cat")
    cmd.Stdin = pr

    started := make(chan error)
    done := make(chan error)
    go func() {
        started <- cmd.Start()
        done <- cmd.Wait()
    }()

    <-started
    println("Started")
    pw.Write([]byte("hello"))

    cmd.Process.Signal(syscall.SIGTERM)

    err := <-done
    println("Done")
    if err != nil {
        fmt.Printf("wait err: %s\n", err.Error())
    }
}

[zombiezen]

The root cause is that Wait blocks for all io.Copy operations to complete. This is correct, but in the test case here, the deadlock is on io.pipe.rwait. Adding a pw.Close after pw.Write will remove the deadlock. stdout/stderr won't have this problem since they will receive the broken pipe error.

Fixing this isn't straightforward. Ideally, there would be a way to interrupt the read call in stdin()'s copy goroutine. It could be emulated with a select and an interrupt channel, but then that can leak a copy goroutine. I'm unsure of a clean way of fixing this.

[rsc]

Will document. Note that if you use os.Pipe this does not happen.