proc &{Pid:1084700 handle:0 isdone:0 sigMu:{w:{state:0 sema:0} writerSem:0 readerSem:0 readerCount:0 readerWait:0}}
child log: child run

child log: read: "hello"

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"time"
)

func getData(r io.Reader) ([]byte, error) {
	raw, err := ioutil.ReadAll(r)
	return raw, err
}

func main() {
	log := os.NewFile(uintptr(3), "")

	fmt.Fprintf(log, "child run\n")
	raw, err := getData(os.Stdin)
	if err != nil {
		fmt.Fprintf(log, "%s", err)
	}

	fmt.Fprintf(log, "read: %s\n", raw)

	time.Sleep(10 * time.Second)
	os.Exit(0)
}

	// Read child error status from pipe.
	Close(p[1])
	for {
		n, err = readlen(p[0], (*byte)(unsafe.Pointer(&err1)), int(unsafe.Sizeof(err1)))
		if err != EINTR {
			break
		}
	}
	Close(p[0])
	err = EINVAL

package main                                                                                                                                                                                  
                                                                                                                                                                                              
import (                                                                                                                                                                                      
        "bufio"                                                                                                                                                                               
        "bytes"                                                                                                                                                                               
        "encoding/json"                                                                                                                                                                       
        "fmt"                                                                                                                                                                                 
        "io"                                                                                                                                                                                  
        "os"                                                                                                                                                                                  
        "os/exec"                                                                                                                                                                             
        "time"                                                                                                                                                                                
)                                                                                                                                                                                             
                                                                                                                                                                                              
func forwardLog(fd io.Reader) {                                                                                                                                                               
        reader := bufio.NewReader(fd)                                                                                                                                                         
        for {                                                                                                                                                                                 
                line, err := reader.ReadBytes('\n')                                                                                                                                           
                if err == io.EOF {                                                                                                                                                            
                        fmt.Println("end of read child log")                                                                                                                                  
                        return                                                                                                                                                                
                                                                                                                                                                                              
                }                                                                                                                                                                             
                                                                                                                                                                                              
                if err != nil {                                                                                                                                                               
                        fmt.Printf("failed to read child log: %s\n", err)
                        return
                }

                fmt.Printf("child log: %s\n", line)

        }
}

func main() {
        r, w, err := os.Pipe()
        go forwardLog(r)
        data := "hello"
        raw, err := json.Marshal(data)
        if err != nil {
                panic(err)
        }

        cmd := exec.Command("/home/ace/go/src/test/cmd-start-hang/read")
        cmd.ExtraFiles = append(cmd.ExtraFiles, w)
        cmd.Stdin = bytes.NewReader(raw)

        if err := cmd.Start(); err != nil {
                panic(err)

        }

        fmt.Printf("proc %+v\n", cmd.Process)

        if err := cmd.Wait(); err != nil {
                panic(err)
        }

        time.Sleep(10 * time.Second)

}