php-fpm-signals

int fpm_signals_init_child()
{
    struct sigaction act, act_dfl;

    memset(&act, 0, sizeof(act));
    memset(&act_dfl, 0, sizeof(act_dfl));

    act.sa_handler = &sig_soft_quit;//设置了一个信号处理回调函数
    act.sa_flags |= SA_RESTART;

    act_dfl.sa_handler = SIG_DFL;//按系统默认的处理方法处理信号

    //和fpm主进程不一样，直接关闭socket对，不使用socket对进行通信
    close(sp[0]);
    close(sp[1]);

    //设置了相关需要关注的信号
    if (0 > sigaction(SIGTERM,  &act_dfl,  0) ||
        0 > sigaction(SIGINT,   &act_dfl,  0) ||
        0 > sigaction(SIGUSR1,  &act_dfl,  0) ||
        0 > sigaction(SIGUSR2,  &act_dfl,  0) ||
        0 > sigaction(SIGCHLD,  &act_dfl,  0) ||
        0 > sigaction(SIGQUIT,  &act,      0)) {

        zlog(ZLOG_SYSERROR, "failed to init child signals: sigaction()");
        return -1;
    }
    return 0;
}

static void sig_soft_quit(int signo)
{
    int saved_errno = errno;

    //closing fastcgi listening socket will force fcgi_accept() exit immediately
    close(0);
    if (0 > socket(AF_UNIX, SOCK_STREAM, 0)) {
        zlog(ZLOG_WARNING, "failed to create a new socket");
    }
    fpm_php_soft_quit(); // fpm_php_soft_quit() ==> in_shutdown = 1
    errno = saved_errno;
}

static int sp[2];

int fpm_signals_init_main()
{
    struct sigaction act;

    if (0 > socketpair(AF_UNIX, SOCK_STREAM, 0, sp)) {//建立socket对，通过这个把信号事件转换为socket事件，然后在fpm_events里通过io复用获取事件然后处理
        zlog(ZLOG_SYSERROR, "failed to init signals: socketpair()");
        return -1;
    }

    if (0 > fd_set_blocked(sp[0], 0) || 0 > fd_set_blocked(sp[1], 0)) {//设置成非阻塞
        zlog(ZLOG_SYSERROR, "failed to init signals: fd_set_blocked()");
        return -1;
    }

    //使在子进程中，此描述符并不关闭，仍可使用，但实际上子进程把这对socket关闭了
    if (0 > fcntl(sp[0], F_SETFD, FD_CLOEXEC) || 0 > fcntl(sp[1], F_SETFD, FD_CLOEXEC)) {
        zlog(ZLOG_SYSERROR, "falied to init signals: fcntl(F_SETFD, FD_CLOEXEC)");
        return -1;
    }

    memset(&act, 0, sizeof(act));
    act.sa_handler = sig_handler;//设置了信号处理回调函数，很重要
    sigfillset(&act.sa_mask);

    //设置了需要关注的信号
    if (0 > sigaction(SIGTERM,  &act, 0) ||
        0 > sigaction(SIGINT,   &act, 0) ||
        0 > sigaction(SIGUSR1,  &act, 0) ||
        0 > sigaction(SIGUSR2,  &act, 0) ||
        0 > sigaction(SIGCHLD,  &act, 0) ||
        0 > sigaction(SIGQUIT,  &act, 0)) {

        zlog(ZLOG_SYSERROR, "failed to init signals: sigaction()");
        return -1;
    }
    return 0;
}

static void sig_handler(int signo)
{
    static const char sig_chars[NSIG + 1] = {
        [SIGTERM] = 'T',
        [SIGINT]  = 'I',
        [SIGUSR1] = '1',
        [SIGUSR2] = '2',
        [SIGQUIT] = 'Q',
        [SIGCHLD] = 'C'
    };
    char s;
    int saved_errno;

    if (fpm_globals.parent_pid != getpid()) {
        //prevent a signal race condition when child process have not set up it's own signal handler yet
        return;
    }

    saved_errno = errno;
    s = sig_chars[signo];
    write(sp[1], &s, sizeof(s));//向socket对里写上该信号的标记，完美的把信号转换为socket事件，由fpm_events从sp[0] 这个socket里读取数据，然后处理
    errno = saved_errno;
}

void fpm_event_loop(int err)
{
    static struct fpm_event_s signal_fd_event;

    //fpm_signals_get_fd() ==> sp[0]
    //设置了对socket sp[0]的可读监控，如果可读，则回调函数为fpm_got_signal
    fpm_event_set(&signal_fd_event, fpm_signals_get_fd(), FPM_EV_READ, &fpm_got_signal, NULL);
    fpm_event_add(&signal_fd_event, 0);

    while (1) {
        //................
        ret = module->wait(fpm_event_queue_fd, timeout);//sp[0] socket可读，则执行函数 fpm_got_signal
        //................
    }
}

static void fpm_got_signal(struct fpm_event_s * ev, short which, void * arg)
{
    char c;
    int res, ret;
    int fd = ev->fd;//这个fd就是sp[0]

    do {
        do {
            res = read(fd, &c, 1);//读取信号处理回调函数sig_handler向sp[1]写入的那个信号标记
        } while (res == -1 && errno == EINTR);

        if (res <= 0) { //没有信号标记了，则退出
            if (res < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
                zlog(ZLOG_SYSERROR, "unable to read from the signal pipe");
            }
            return;
        }

        //信号处理回调函数sig_handler里信号量和信号标记的映射关系
        //static const char sig_chars[NSIG + 1] = {
        //    [SIGTERM] = 'T',
        //    [SIGINT]  = 'I',
        //    [SIGUSR1] = '1',
        //    [SIGUSR2] = '2',
        //    [SIGQUIT] = 'Q',
        //    [SIGCHLD] = 'C'
        //};
        switch (c) {
            case 'C' :                  // SIGCHLD ，收到子进程的终止或者暂停的信号
                zlog(ZLOG_DEBUG, "received SIGCHLD");
                fpm_children_bury();
                break;
            case 'I' :                  // SIGINT，收到终止进程的信号
                zlog(ZLOG_NOTICE, "Terminating ...");
                fpm_pctl(FPM_PCTL_STATE_TERMINATING, FPM_PCTL_ACTION_SET);
                break;
            case 'T' :                  // SIGTERM，收到终止进程的信号
                zlog(ZLOG_NOTICE, "Terminating ...");
                fpm_pctl(FPM_PCTL_STATE_TERMINATING, FPM_PCTL_ACTION_SET);
                break;
            case 'Q' :                  // SIGQUIT，收到进程退出的信号
                zlog(ZLOG_NOTICE, "Finishing ...");
                fpm_pctl(FPM_PCTL_STATE_FINISHING, FPM_PCTL_ACTION_SET);
                break;
            case '1' :                  // SIGUSR1, 收到重新打开日志的信号
                fpm_stdio_open_error_log(1);
                fpm_log_open(1);
                break;
            case '2' :                  // SIGUSR2，收到reload的信号
                zlog(ZLOG_NOTICE, "Reloading in progress ...");
                fpm_pctl(FPM_PCTL_STATE_RELOADING, FPM_PCTL_ACTION_SET);
                break;
        }

        if (fpm_globals.is_child) {
            break;
        }
    } while (1);
    return;
}

static void fpm_pctl_check_request_timeout(struct timeval* now)
{
    struct fpm_worker_pool_s* wp;

    for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
        int terminate_timeout = wp->config->request_terminate_timeout;
        int slowlog_timeout = wp->config->request_slowlog_timeout;
        struct fpm_child_s* child;

        if (terminate_timeout || slowlog_timeout) {
            for (child = wp->children; child; child = child->next) {
                fpm_request_check_timed_out(child, now, terminate_timeout, slowlog_timeout);
            }
        }
    }
}

void fpm_request_check_timed_out(struct fpm_child_s* child, struct timeva* now, int terminate_timeout, int slowlog_timeout)
{
    struct fpm_scoreboard_proc_s proc, * proc_p;

    proc_p = fpm_scoreboard_proc_acquire(child->wp->scoreboard, child->scoreboard_i, 1);
    if (!proc_p) {
        zlog(ZLOG_WARNING, "failed to acquire scoreboard");
        return;
    }

    proc = * proc_p;
    fpm_scoreboard_proc_release(proc_p);

#if HAVE_FPM_TRACE
    if (child->slow_logged.tv_sec) {
        if (child->slow_logged.tv_sec != proc.accepted.tv_sec || child->slow_logged.tv_usec != proc.accepted.tv_usec) {
            child->slow_logged.tv_sec = 0;
            child->slow_logged.tv_usec = 0;
        }
    }
#endif

    if (proc.request_stage > FPM_REQUEST_ACCEPTING && proc.request_stage < FPM_REQUEST_END) { //这个条件设置的太小了，会导致php 出现fin包丢失而hang住的
        char purified_script_filename[sizeof(proc.script_filename)];
        struct timeval tv;

        timersub(now, &proc.accepted, &tv);

#if HAVE_FPM_TRACE
        if (child->slow_logged.tv_sec == 0 && slowlog_timeout &&
                proc.request_stage == FPM_REQUEST_EXECUTING && tv.tv_sec >= slowlog_timeout) {

            str_purify_filename(purified_script_filename, proc.script_filename, sizeof(proc.script_filename));

            child->slow_logged = proc.accepted;
            child->tracer = fpm_php_trace; //设置了暂停后的回调函数，当子进程暂停后，会发信号SIGCHLD给主进程，主进程会调用child->tracer这个回调函数的

            fpm_trace_signal(child->pid);//在fpm_trace_signal里会发一个SIGSTOP信号给子进程，让子进程暂停

            zlog(ZLOG_WARNING, "[pool %s] child %d, script '%s' (request: \"%s %s\") executing too slow (%d.%06d sec), logging",
                child->wp->config->name, (int) child->pid, purified_script_filename, proc.request_method, proc.request_uri,
                (int) tv.tv_sec, (int) tv.tv_usec);
        }
        else
#endif
        if (terminate_timeout && tv.tv_sec >= terminate_timeout) {
            str_purify_filename(purified_script_filename, proc.script_filename, sizeof(proc.script_filename));
            fpm_pctl_kill(child->pid, FPM_PCTL_TERM);//发一个SIGTERM信号给子进程，子进程收到后又会发一个SIGCHLD给主进程，主进程会重新fork子进程

            zlog(ZLOG_WARNING, "[pool %s] child %d, script '%s' (request: \"%s %s\") execution timed out (%d.%06d sec), terminating",
                child->wp->config->name, (int) child->pid, purified_script_filename, proc.request_method, proc.request_uri,
                (int) tv.tv_sec, (int) tv.tv_usec);
        }
    }
}