【nginx】nginx介绍-信号处理

nginx是通过master进程和worker进程进行工作提供服务的模式。master进程主要用来监听worker进程状态进行相应的重启、停止等操作；worker进程则进行具体的提供服务，接受和处理请求。那么既然提到master监听worker进程，就势必用到进程间通信。常见的进程间通信也无非那几种方式，内存，消息队列，socke，信号等。在nginx中是采用了共享内存，socket与信号三种方式。
在master和worker进程之间的通信则是通过套接字对的方式。而我们和nginx之间通信的方式则是信号。
在我们使用nginx过程中，我们可以直接通信的就是只有master进程，对于worker进程我们除了可以决定其个数之外是无法直接控制worker进程的。唯一控制worker进程的方式就是通过向master进程发出相应的信号，master进程通过不同的信号来对worker进程进行控制，依此种方式达到我们控制worker进程。
这篇文章就讲述我们在运维和使用nginx的时候，对于几种常用的信号nginx是如何处理的。

信号

在介绍master向worker通过socketpair发出控制信号的时候，就必须先提前介绍一下何为信号，还有在linux中是如何向一个进程发送信号的。
对于信号，其实是一种在软件进程层面对于硬中断的模拟。在软件层面无法进行中断的处理，但是可能也需要进程之间的通信和交互，这个时候信号就出现了。当进程接受到信号之后有几种不同的处理方式，可以忽略无视信号，但是有两种信号不能忽略，SIGKILL及SIGSTOP；定义处理函数，信号到达的时候调用处理函数进行处理；或者执行缺省操作。
在linux中和信号有关的主要操作函数有以下几个kill, raise, alarm和setitimer以及sigqueue函数。每个函数试用场合也不一样，功能上也不尽相同，在这里只对kill进行介绍，因为nginx中是使用的kill函数发送的信号。

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

参考man可以知道，kill可以向任何进程(pid)发送任何信号(sig)。根据pid的不同，kill发送的信号的范围也不一样，有兴趣者可以查看linux的系统函数，了解具体使用规范。

nginx信号处理

向master发信号的方式就是使用nginx提供的命令工具

nginx -s signal

现在nginx现在支持stop, quit, reopen, reload几种信号。每种信号的所代表的含义其实通过单词语义可以很好理解，在这里不进行详细解释。需要解释的是，当master接受到信号之后，nginx了做了哪些操作。
下面就以reload配置文件这个命令进行介绍。在你向nginx发出信号的前提就是nginx必须是已经启动起来的，这样它接受到信号的时候才可以执行相应操作，否则就会报错。因为它在执行信号处理相关逻辑的时候需要打开一些文件，而nginx不启动的时候这些文件是不存在的，就会导致打开文件错误。除此之外，也只有nginx在启动之后才可以一直监听具体接受到什么信号。如果不启动，系统根本不知如何处理。
因此既然要讲到nginx的信号处理，那么就必须稍微提起一下nginx的启动过程。在这篇文章不对nginx启动不作详细介绍，只对牵涉到nginx的信号处理的部分进行讲解。
nginx在启动main函数里面，进行相关的结构体初始化操作，然后会进行signals的初始化。

    if (ngx_init_signals(cycle->log) != NGX_OK) {
        return 1;
    }

该方法会接着调用ngx_process.c中ngx_init_signals，具体的方法体:

ngx_int_t ngx_init_signals(ngx_log_t *log)
{
    ngx_signal_t      *sig;
    struct sigaction   sa;

    for (sig = signals; sig->signo != 0; sig++) {
        ngx_memzero(&sa, sizeof(struct sigaction));
        sa.sa_handler = sig->handler;
        sigemptyset(&sa.sa_mask);
        if (sigaction(sig->signo, &sa, NULL) == -1){
            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "sigaction(%s) failed", sig->signame);
            return NGX_ERROR;
        }
    }
    return NGX_OK;
}

为了方便阅读，删除了非核心逻辑代码。从这里可以看到该方法主要是用来指明每一种信号的处理函数，通过sigaction指明了当每一种信号来的时候，应该调用哪一种方法来处理。其中signals是nginx定义的结构体的数组，每个数组对象是一个结构体，该结构体定义了该信号的名称、处理方法，具体代码如下：

typedef struct {
    int     signo;
    char   *signame;
    char   *name;
    void  (*handler)(int signo);
} ngx_signal_t;

在初始化信号相关操作结束之后，main函数继续执行，接下来会根据判断决定是进行master进程启动还是single worker的启动，对信号的处理是在master启动方法中处理的。

    if (ngx_process == NGX_PROCESS_SINGLE) { ngx_single_process_cycle(cycle); } else { ngx_master_process_cycle(cycle); }

在启动master进程之前nginx已经执行了很多操作，包括配置文件的解析、核心结构体的初始化、日志的创建。因此在master启动方法中主要是执行了一些收尾的工作，比如设置进程名字、启动worker进程，然后进入for(;;)死循环。在死循环中，就不停的检查是否有信号和信号的种类，然后根据信号进行不同动作。
在nginx启动之后，当我们键入nginx -s reload的，nginx通过解析输入的参数发现是传递了一个信号，接下来执行ngx_signal_process方法，然后return。该方法接受nginx的生命周期结构体cycle(不知道该如何解释这个结构体)和信号的名字。该方法判断相应的逻辑之后会调用ngx_process.c中的方法ngx_os_signal_process。在nginx中所有对进程的操作都是在这个文件中，提供了生成、杀死进程相关的方法。对于上面这个方法，其实是调用了linux的系统调用kill，方法定义如下;

int kill(pid_t pid, int sig)

通过传入的nginx的pid和具体的信号，告诉master根据相应的信号执行指定的操作。核心逻辑代码如下，代码比较长，其实就是各种判定，根据不同的信号做不同的处理。

    for ( ;; ) {
        if (delay) {
            if (ngx_sigalrm) {
                sigio = 0;
                delay *= 2;
                ngx_sigalrm = 0;
            }

            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                           "termination cycle: %d", delay);

            itv.it_interval.tv_sec = 0;
            itv.it_interval.tv_usec = 0;
            itv.it_value.tv_sec = delay / 1000;
            itv.it_value.tv_usec = (delay % 1000 ) * 1000;

            if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                              "setitimer() failed");
            }
        }

        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "sigsuspend");

        sigsuspend(&set);

        ngx_time_update();

        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                       "wake up, sigio %i", sigio);

        if (ngx_reap) {
            ngx_reap = 0;
            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children");

            live = ngx_reap_children(cycle);
        }

        if (!live && (ngx_terminate || ngx_quit)) {
            ngx_master_process_exit(cycle);
        }

        if (ngx_terminate) {
            if (delay == 0) {
                delay = 50;
            }

            if (sigio) {
                sigio--;
                continue;
            }

            sigio = ccf->worker_processes + 2 /* cache processes */;

            if (delay > 1000) {
                ngx_signal_worker_processes(cycle, SIGKILL);
            } else {
                ngx_signal_worker_processes(cycle,
                                       ngx_signal_value(NGX_TERMINATE_SIGNAL));
            }

            continue;
        }

        if (ngx_quit) {
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));

            ls = cycle->listening.elts;
            for (n = 0; n < cycle->listening.nelts; n++) {
                if (ngx_close_socket(ls[n].fd) == -1) {
                    ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
                                  ngx_close_socket_n " %V failed",
                                  &ls[n].addr_text);
                }
            }
            cycle->listening.nelts = 0;

            continue;
        }

        if (ngx_reconfigure) {
            ngx_reconfigure = 0;

            if (ngx_new_binary) {
                ngx_start_worker_processes(cycle, ccf->worker_processes,
                                           NGX_PROCESS_RESPAWN);
                ngx_start_cache_manager_processes(cycle, 0);
                ngx_noaccepting = 0;

                continue;
            }

            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");

            cycle = ngx_init_cycle(cycle);
            if (cycle == NULL) {
                cycle = (ngx_cycle_t *) ngx_cycle;
                continue;
            }

            ngx_cycle = cycle;
            ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx,
                                                   ngx_core_module);
            ngx_start_worker_processes(cycle, ccf->worker_processes,
                                       NGX_PROCESS_JUST_RESPAWN);
            ngx_start_cache_manager_processes(cycle, 1);

            /* allow new processes to start */
            ngx_msleep(100);

            live = 1;
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
        }

        if (ngx_restart) {
            ngx_restart = 0;
            ngx_start_worker_processes(cycle, ccf->worker_processes,
                                       NGX_PROCESS_RESPAWN);
            ngx_start_cache_manager_processes(cycle, 0);
            live = 1;
        }

        if (ngx_reopen) {
            ngx_reopen = 0;
            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
            ngx_reopen_files(cycle, ccf->user);
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_REOPEN_SIGNAL));
        }

        if (ngx_change_binary) {
            ngx_change_binary = 0;
            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "changing binary");
            ngx_new_binary = ngx_exec_new_binary(cycle, ngx_argv);
        }

        if (ngx_noaccept) {
            ngx_noaccept = 0;
            ngx_noaccepting = 1;
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
        }
    }
}