从源码角度剖析 golang 如何fork一个进程

创建一个新进程分为两个步骤，一个是fork系统调用，一个是execve 系统调用，fork调用会复用父进程的堆栈，而execve直接覆盖当前进程的堆栈，并且将下一条执行指令指向新的可执行文件。

在分析源码之前，我们先来看看golang fork一个子进程该如何写。(👉严格的讲是先fork再execve创建一个子进程)

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

上述代码将fork一个子进程，然后子进程将会调用execve系统调用，使用新的可执行文件/bin/sh代替当前子进程的程序。并且当前的标准输入输出也传递给了子进程。

我们将着重看下golang是如何创建和将父进程的文件描述符传递给子进程的。

cmd.Run() 会调用到cmd.Start 方法，里面有一段逻辑和标准输入输出流的传递相关，我们来看看。

// /usr/local/go/src/os/exec/exec.go:625 
func (c *Cmd) Start() error {
......
childFiles := make([]*os.File, 0, 3+len(c.ExtraFiles))
   // 创建子进程的stdin 标准输入
	stdin, err := c.childStdin()
	if err != nil {
		return err
	}
	childFiles = append(childFiles, stdin)
	// 创建子进程的stdout 标准输出
	stdout, err := c.childStdout()
	if err != nil {
		return err
	}
	childFiles = append(childFiles, stdout)
	// 创建子进程的stderr 标准错误输出
	stderr, err := c.childStderr(stdout)
	if err != nil {
		return err
	}
	// 此时childFiles 已经包含了上述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,
	})
	.....
}

如上所述，cmd.Start 会分别调用childStdin，childStdout,childStderr创建用于子进程的标准输入输出。来看看其中一个childStdin实现原理，其余childStdout,childStderr 实现原理也是和它类似的。

// /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 写入的数据 来源于 c.Stdin  父进程会启动一个协程复制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
}

childStdin 实际上是创建了一个管道，管道有返回值 pw,pr , 由pw写入的数据可以由pr进行读取，w 写入的数据 来源于 c.Stdin 父进程会启动一个协程复制c.Stdin 到 pw ，而c.Stdin 在我们最开的演示代码那里赋值为了标准输入。

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

而pr 则返回由父进程通过os.StartProcess的childFiles 传递给了子进程，并作为子进程的标准输入，当子进程启动后将会从pr中获取标准输入终端的数据。

看到这里，你应该能明白了，子进程是如何获取获取父进程的终端信息的了，通过建立了一个管道，然后将管道的一端传递给了子进程便能让父子进程进行通信了。

让我们再回到创建进程的主流程上，刚刚仅仅是分析出了，父进程将会为子进程创建它自己的标准输入输出流，虽然是通过管道包装的，但还没详细分析出os.StartProcess 方法究竟通过了哪些手段来让父进程的文件描述符传递给子进程。

注意下，golang中 fork 和execve 创建子进程 的过程 被封装成了一个统一的方法forkExec，它能够控制子进程，只继承特定的文件描述符，而对其他文件描述符则进行关闭。而内核fork系统调用则是会对父进程的所有文件描述符进行复制，那么golang又是如何做到只继承特定的文件描述符的呢？这个也是接下来分析的重点

接下来，让我们深入os.StartProcess 方法，看看golang是如何办到只继承父进程通过childFiles传递过来的文件描述符进行fork和execve调用的。

os.StartProcess 底层会调用到 forkAndExecInChild1 方法，由于代码比较长，我这里只列出了关键步骤，并对其进行了注释。

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 调用前 会将attr.Files 里的数据复制到fd数组，我们传递给子进程的是childFiles，当代码执行到这里的时候，childFiles已经转化成了文件描述符存到attr.Files了。nextfd是为了后续再进行复制文件描述符时，不会对子进程要用到的文件描述符进行覆盖，会在接下来步骤1进行详细说明
    nextfd = len(attr.Files)
	for i, ufd := range attr.Files {
		if nextfd < int(ufd) {
			nextfd = int(ufd)
		}
		fd[i] = int(ufd)
	}
	nextfd++
   .....
   // 这里便进行了fork调用创建新进程了，不过可以看到这里用的是clone系统调用，其实它和fork类似，不过区别在于clone系统调用可以通过flags指定新进程 对于 父进程的哪些属性需要继承，哪些属性不需要继承，比如子进程需要新的网络命名空间，则需要指定flags为syscall.CLONE_NEWNS
   r1, err1 = rawVforkSyscall(SYS_CLONE, flags, 0)
   ....
   
   // 步骤1： 总之经过上面clone系统调用，已经产生了子进程了，下面两个步骤都是子进程才会进行的步骤，父进程在上述clone系统调用后，通过判断err1 != 0 || r1 != 0  便返回了。
  //  这里将fd[i] < i 的文件描述符 通过dup 系统调用复制到了一个新的文件描述符，因为后续步骤2里我们需要将复制 fd[i] 到第i个文件描述符 ，如果fd[i] < i ，那么将会导致复制的fd[i] 是子进程已经产生复制行为的文件描述符，而不是父进程真正传递过来的文件描述符，所以要通过nextfd将这样的文件描述符复制到fd数组外，并且设置O_CLOEXEC，这样在后续的execve系统调用后，将会对它进行自动关闭。
     	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 系统调用
	_, _, err1 = RawSyscall(SYS_EXECVE,
		uintptr(unsafe.Pointer(argv0)),
		uintptr(unsafe.Pointer(&argv[0])),
		uintptr(unsafe.Pointer(&envv[0])))
}

可以看出，golang在execve前， 通过dup系统调用达到了继承父进程文件描述符的目的，最终达到的效果是继承attr.Files 参数里的文件描述符，期间由于dup的使用 产生的多余的文件描述符也标记为了O_CLOEXEC，在SYS_EXECVE 系统调用时，便会关闭掉。

但是仅仅看到这里，并不能说明golang会对attr.Files外的文件描述符也进行关闭，因为fork系统调用时，子进程会自动继承父进程的所有文件描述符，这些继承的文件描述符会在execve后自动关闭吗? 答案是默认是会的。

golang的 os.open 函数底层会调用下面的代码对文件进行打开操作，可以看到打开时固定设置了syscall.O_CLOEXEC flag，所以，子进程进行execve时变会自动对这些文件描述符进行关闭了。

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 {

监听的socket文件也是默认开启了syscall.SOCK_NONBLOCK参数

// 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
}