func runErr(c *Config) error {
    //os not supported
    if !supported {
        return fmt.Errorf("os (%s) not supported", runtime.GOOS)
    }
    //配置检查
    if err := validate(c); err != nil {
        return err
    }
    //环境变量合法性检查
    if sanityCheck() {
        return nil
    }
    //run either in master or slave mode
    if os.Getenv(envIsSlave) == "1" {
        currentProcess = &slave{Config: c}
    } else {
        currentProcess = &master{Config: c}//第一次启动会执行此分支
    }
    //master/slave 分别实现了currentProcess此接口
    return currentProcess.run()
}

func (mp *master) run() error {
    mp.debugf("run")
    if err := mp.checkBinary(); err != nil {
        return err
    }
    if mp.Config.Fetcher != nil {
        if err := mp.Config.Fetcher.Init(); err != nil {
            mp.warnf("fetcher init failed (%s). fetcher disabled.", err)
            mp.Config.Fetcher = nil
        }
    }
    //处理信号，开启协程，对应的信号调用其对应的处理函数
    mp.setupSignalling()
    //处理监听套接字，监听请求到来
    if err := mp.retreiveFileDescriptors(); err != nil {
        return err
    }
    if mp.Config.Fetcher != nil {
        mp.printCheckUpdate = true
        mp.fetch()
        go mp.fetchLoop()
    }
    return mp.forkLoop()
}

//not a real fork
func (mp *master) forkLoop() error {
    //loop, restart command
    for {
        if err := mp.fork(); err != nil {
            return err
        }
    }
}

func (mp *master) fork() error {
    mp.debugf("starting %s", mp.binPath)
    cmd := exec.Command(mp.binPath)
    //mark this new process as the "active" slave process.
    //this process is assumed to be holding the socket files.
    mp.slaveCmd = cmd
    mp.slaveID++
    //provide the slave process with some state
    e := os.Environ()
    e = append(e, envBinID+"="+hex.EncodeToString(mp.binHash))
    e = append(e, envBinPath+"="+mp.binPath)
    e = append(e, envSlaveID+"="+strconv.Itoa(mp.slaveID))
    e = append(e, envIsSlave+"=1")//标记为子进程
    e = append(e, envNumFDs+"="+strconv.Itoa(len(mp.slaveExtraFiles)))
    cmd.Env = e
    //inherit master args/stdfiles
    cmd.Args = os.Args
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    //include socket files
    cmd.ExtraFiles = mp.slaveExtraFiles
    if err := cmd.Start(); err != nil {//fork子进程，执行bin文件
        return fmt.Errorf("Failed to start slave process: %s", err)
    }
    //was scheduled to restart, notify success
    if mp.restarting {
        mp.restartedAt = time.Now()
        mp.restarting = false
        mp.restarted <- true
    }
    //convert wait into channel
    cmdwait := make(chan error)
    go func() {
        cmdwait <- cmd.Wait()
    }()
    //wait....
    select {
    case err := <-cmdwait:
        //program exited before releasing descriptors
        //proxy exit code out to master
        code := 0
        if err != nil {
            code = 1
            if exiterr, ok := err.(*exec.ExitError); ok {
                if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
                    code = status.ExitStatus()
                }
            }
        }
        mp.debugf("prog exited with %d", code)
        //if a restarts are disabled or if it was an
        //unexpected crash, proxy this exit straight
        //through to the main process
        if mp.NoRestart || !mp.restarting {
            os.Exit(code)
        }
    case <-mp.descriptorsReleased://子进程收到SIGUSR2腿出后，会给master发信号，master收到信号会置此变量，然后返回nil，重新fork
        //if descriptors are released, the program
        //has yielded control of its sockets and
        //a parallel instance of the program can be
        //started safely. it should serve state.Listeners
        //to ensure downtime is kept at <1sec. The previous
        //cmd.Wait() will still be consumed though the
        //result will be discarded.
    }
    return nil
}

func (mp *master) setupSignalling() {
    //updater-forker comms
    mp.restarted = make(chan bool)
    mp.descriptorsReleased = make(chan bool)
    //read all master process signals
    signals := make(chan os.Signal)
    signal.Notify(signals)//master接受所有信号
    go func() {
        for s := range signals {
            mp.handleSignal(s)//执行对应信号处理程序
        }
    }()
}

func (mp *master) handleSignal(s os.Signal) {
    if s == mp.RestartSignal {
        //user initiated manual restart
        go mp.triggerRestart()//此信号为自定义信号，在调用处可指定，一般用SIGUSR2
    } else if s.String() == "child exited" {
        // will occur on every restart, ignore it
    } else
    //**during a restart** a SIGUSR1 signals
    //to the master process that, the file
    //descriptors have been released
    if mp.awaitingUSR1 && s == SIGUSR1 {//slave进程退出时发送SIGUSR1给master，master收到后设置descriptorsReleased标记后，master的fork中阻塞的select返回nil，重新fork
        mp.debugf("signaled, sockets ready")
        mp.awaitingUSR1 = false
        mp.descriptorsReleased <- true
    } else
    //while the slave process is running, proxy
    //all signals through
    if mp.slaveCmd != nil && mp.slaveCmd.Process != nil {
        mp.debugf("proxy signal (%s)", s)
        mp.sendSignal(s)
    } else
    //otherwise if not running, kill on CTRL+c
    if s == os.Interrupt {
        mp.debugf("interupt with no slave")
        os.Exit(1)
    } else {
        mp.debugf("signal discarded (%s), no slave process", s)
    }
}

func (mp *master) triggerRestart() {
    if mp.restarting {
        mp.debugf("already graceful restarting")
        return //skip
    } else if mp.slaveCmd == nil || mp.restarting {
        mp.debugf("no slave process")
        return //skip
    }
    mp.debugf("graceful restart triggered")
    mp.restarting = true
    mp.awaitingUSR1 = true
    mp.signalledAt = time.Now()
    mp.sendSignal(mp.Config.RestartSignal) //ask nicely to terminate//向slave发送停止信号
    select {
    case <-mp.restarted:
        //success
        mp.debugf("restart success")
    case <-time.After(mp.TerminateTimeout):
        //times up mr. process, we did ask nicely!
        mp.debugf("graceful timeout, forcing exit")
        mp.sendSignal(os.Kill)
    }
}