cmd := exec.Command("/bin/sh")
		cmd.Env = os.Environ()
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		err = cmd.Run()

// /usr/local/go/src/os/exec/exec.go:625 
func (c *Cmd) Start() error {
......
childFiles := make([]*os.File, 0, 3+len(c.ExtraFiles))
   // 創(chuàng)建子進程的stdin 標準輸入
	stdin, err := c.childStdin()
	if err != nil {
		return err
	}
	childFiles = append(childFiles, stdin)
	// 創(chuàng)建子進程的stdout 標準輸出
	stdout, err := c.childStdout()
	if err != nil {
		return err
	}
	childFiles = append(childFiles, stdout)
	// 創(chuàng)建子進程的stderr 標準錯誤輸出
	stderr, err := c.childStderr(stdout)
	if err != nil {
		return err
	}
	// 此時childFiles 已經(jīng)包含了上述3個標準輸入輸出流
	childFiles = append(childFiles, stderr)
	childFiles = append(childFiles, c.ExtraFiles...)

	env, err := c.environ()
	if err != nil {
		return err
	}
   // os.StartProcess 將會啟動一個子進程并從childFiles繼承父進程的放入其中的文件描述符
	c.Process, err = os.StartProcess(c.Path, c.argv(), &os.ProcAttr{
		Dir:   c.Dir,
		Files: childFiles,
		Env:   env,
		Sys:   c.SysProcAttr,
	})
	.....
}

// /usr/local/go/src/os/exec/exec.go:489
func (c *Cmd) childStdin() (*os.File, error) {
	
	.....
	
	pr, pw, err := os.Pipe()
	if err != nil {
		return nil, err
	}

	c.childIOFiles = append(c.childIOFiles, pr)
	c.parentIOPipes = append(c.parentIOPipes, pw)
	// pw 寫入的數(shù)據(jù) 來源于 c.Stdin  父進程會啟動一個協(xié)程復制c.Stdin 到 pw
	c.goroutine = append(c.goroutine, func() error {
		_, err := io.Copy(pw, c.Stdin)
		if skipStdinCopyError(err) {
			err = nil
		}
		if err1 := pw.Close(); err == nil {
			err = err1
		}
		return err
	})
	....
	return pr, nil
}

cmd := exec.Command("/bin/sh")
		cmd.Env = os.Environ()
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		err = cmd.Run()

func forkAndExecInChild1(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr *ProcAttr, sys *SysProcAttr, pipe int) (r1 uintptr, err1 Errno, p [2]int, locked bool) {
    ...
    //  fork 調(diào)用前 會將attr.Files 里的數(shù)據(jù)復制到fd數(shù)組，我們傳遞給子進程的是childFiles，當代碼執(zhí)行到這里的時候，childFiles已經(jīng)轉(zhuǎn)化成了文件描述符存到attr.Files了。nextfd是為了后續(xù)再進行復制文件描述符時，不會對子進程要用到的文件描述符進行覆蓋，會在接下來步驟1進行詳細說明
    nextfd = len(attr.Files)
	for i, ufd := range attr.Files {
		if nextfd < int(ufd) {
			nextfd = int(ufd)
		}
		fd[i] = int(ufd)
	}
	nextfd++
   .....
   // 這里便進行了fork調(diào)用創(chuàng)建新進程了，不過可以看到這里用的是clone系統(tǒng)調(diào)用，其實它和fork類似，不過區(qū)別在于clone系統(tǒng)調(diào)用可以通過flags指定新進程 對于 父進程的哪些屬性需要繼承，哪些屬性不需要繼承，比如子進程需要新的網(wǎng)絡命名空間，則需要指定flags為syscall.CLONE_NEWNS
   r1, err1 = rawVforkSyscall(SYS_CLONE, flags, 0)
   ....
   
   // 步驟1： 總之經(jīng)過上面clone系統(tǒng)調(diào)用，已經(jīng)產(chǎn)生了子進程了，下面兩個步驟都是子進程才會進行的步驟，父進程在上述clone系統(tǒng)調(diào)用后，通過判斷err1 != 0 || r1 != 0  便返回了。
  //  這里將fd[i] < i 的文件描述符 通過dup 系統(tǒng)調(diào)用復制到了一個新的文件描述符，因為后續(xù)步驟2里我們需要將復制 fd[i] 到第i個文件描述符 ，如果fd[i] < i ，那么將會導致復制的fd[i] 是子進程已經(jīng)產(chǎn)生復制行為的文件描述符，而不是父進程真正傳遞過來的文件描述符，所以要通過nextfd將這樣的文件描述符復制到fd數(shù)組外，并且設置O_CLOEXEC，這樣在后續(xù)的execve系統(tǒng)調(diào)用后，將會對它進行自動關閉。
     	for i = 0; i < len(fd); i++ {
		if fd[i] >= 0 && fd[i] < i {
			....
			_, _, err1 = RawSyscall(SYS_DUP3, uintptr(fd[i]), uintptr(nextfd), O_CLOEXEC)
			if err1 != 0 {
				goto childerror
			}
			fd[i] = nextfd
			nextfd++
		}
	}
   ....
   // 步驟2 : 遍歷fd 讓 子進程fd[i] 個文件描述符復制給第i個文件描述符 ，注意這里就沒有設置O_CLOEXEC了，因為這里的文件描述符我們希望execve后還存在
	for i = 0; i < len(fd); i++ {
		....
		_, _, err1 = RawSyscall(SYS_DUP3, uintptr(fd[i]), uintptr(i), 0)
		if err1 != 0 {
			goto childerror
		}
	} 
	
	....
    // 進行execve 系統(tǒng)調(diào)用
	_, _, err1 = RawSyscall(SYS_EXECVE,
		uintptr(unsafe.Pointer(argv0)),
		uintptr(unsafe.Pointer(&argv[0])),
		uintptr(unsafe.Pointer(&envv[0])))
}

func openFileNolog(name string, flag int, perm FileMode) (*File, error) {
	setSticky := false
	if !supportsCreateWithStickyBit && flag&O_CREATE != 0 && perm&ModeSticky != 0 {
		if _, err := Stat(name); IsNotExist(err) {
			setSticky = true
		}
	}
	var r int
	for {
		var e error
		r, e = syscall.Open(name, flag|syscall.O_CLOEXEC, syscallMode(perm))
		if e == nil {

// descriptor as nonblocking and close-on-exec.
func sysSocket(family, sotype, proto int) (int, error) {
	s, err := socketFunc(family, sotype|syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC, proto)
	if err != nil {
		return -1, os.NewSyscallError("socket", err)
	}
	return s, nil
}