nginx启动分析-ngx_master_process_cycle

最新推荐文章于 2024-08-21 12:00:00 发布

bing激凌~

最新推荐文章于 2024-08-21 12:00:00 发布

阅读量740

点赞数

分类专栏： nginx C++ 文章标签： nginx ngx_master_process_cycle 初始化信号

本文链接：https://blog.csdn.net/LT_lover/article/details/98475063

版权

C++ 同时被 2 个专栏收录

15 篇文章 1 订阅

订阅专栏

nginx

6 篇文章 0 订阅

订阅专栏

nginx在开启master-worker工作模式时，会调用ngx_master_process_cycle函数进行master、worker进程的相关初始化操作，然后会进入一个无限循环处理nginx感兴趣的相关信号，主要是用来管理worker进程相关。

下面看一下函数的初始化相关代码，代码主要设置nginx需要监听的信号，设置master进程名称，根据配置初始化指定数量的worker进程，然后就进入无限循环等待信号发生，执行响应的操作：

其中 SIGUSR2、SIGWINCH相关信号和nginx待的热更新相关，包括ngx_reap_children中的相关操作。

（热更新参考链接：https://ialloc.org/blog/ngx-notes-manipulation/#_7）

void
ngx_master_process_cycle(ngx_cycle_t *cycle)
{
    char              *title;
    u_char            *p;
    size_t             size;
    ngx_int_t          i;
    ngx_uint_t         n, sigio;
    sigset_t           set;
    struct itimerval   itv;
    ngx_uint_t         live;
    ngx_msec_t         delay;
    ngx_listening_t   *ls;
    ngx_core_conf_t   *ccf;

    // 阻塞nginx master进程感兴趣的所有信号
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);       // 子进程退出信号
    sigaddset(&set, SIGALRM);       // 定时器信号
    sigaddset(&set, SIGIO);         // 异步IO信号
    sigaddset(&set, SIGINT);        // ctrl+c信号
    sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));      // SIGHUP   重新读取配置信号
    sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));           // SIGUSR1  重新打开所有已经打开的文件
    sigaddset(&set, ngx_signal_value(NGX_NOACCEPT_SIGNAL));         // SIGWINCH debug
    sigaddset(&set, ngx_signal_value(NGX_TERMINATE_SIGNAL));        // SIGTERM  程序终止
    sigaddset(&set, ngx_signal_value(NGX_SHUTDOWN_SIGNAL));         // SIGQUIT  优雅退出程序
    sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));        // SIGUSR2  替换新的二进制文件

    if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "sigprocmask() failed");
    }

    sigemptyset(&set);


    // ... 省略设置master进程名称代码


    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

    // 根据配置 开启指定数量的worker进程
    ngx_start_worker_processes(cycle, ccf->worker_processes,
                               NGX_PROCESS_RESPAWN);
    ngx_start_cache_manager_processes(cycle, 0);

    
    ngx_new_binary = 0;
    delay = 0;
    sigio = 0;
    live = 1;

    for ( ;; ) {
        // ...见下面代码块
    }
}

然后就是函数最重要的部分，等待最开始添加的信号发生，进行相应的操作，下面是相关代码：

for ( ;; ) {
        if (delay) {
            /*
                接收到SIGINT信号后 需要退出
                发送信号给worker进程后 需要等待worker进程退出
            */
            if (ngx_sigalrm) {
                sigio = 0;
                delay *= 2;
                ngx_sigalrm = 0;
            }

            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                           "termination cycle: %M", 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");

        // 等待nginx感兴趣的信号发生
        sigsuspend(&set);

        ngx_time_update();

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

        if (ngx_reap) {
            // 收到了SIGCHLD信号 有子进程退出（热更新时 也可能是新master进程退出 新master进程也是老master进程的子进程）
            ngx_reap = 0;
            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children");

            // 遍历所有worker子进程状态 异常退出的进行重启 如果所有worker子进程全部退出即返回0
            live = ngx_reap_children(cycle);
        }

        // 如果没有worker子进程 并且 收到了terminate或者quit信号  退出即可
        if (!live && (ngx_terminate || ngx_quit)) {
            ngx_master_process_exit(cycle);
        }

        if (ngx_terminate) {
            // 收到了SIGINT信号  设置一段时间  需要完全退出
            if (delay == 0) {
                delay = 50;
            }

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

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

            if (delay > 1000) {
                // 过长时间worker进程没有退出 给所有worker进程发送SIGKILL信号
                ngx_signal_worker_processes(cycle, SIGKILL);
            } else {
                // 给所有worker进程发送SIGTERM信号
                ngx_signal_worker_processes(cycle,
                                       ngx_signal_value(NGX_TERMINATE_SIGNAL));
            }

            continue;
        }

        if (ngx_quit) {
            // 收到了SIGQUIT信号  优雅退出  给所有worker进程发送SIGQUIT信号
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));

            // 关闭监听socket  不再接受新连接
            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) {
            // 收到SIGHUP信号
            ngx_reconfigure = 0;

            if (ngx_new_binary) {
                // 有新的二进制程序  但仍想使用老的二进制程序  启动老master的worker进程
                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;
            }

            // 重新加载配置成功  重启所有worker进程
            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;
            // 关闭所有老的worker进程
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
        }

        if (ngx_restart) {
            // 当ngx_noaccepting为1时  ngx_restart为1  重启所有worker进程
            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) {
            // 收到SIGUSR1信号  重新打开所有文件（切割access文件可以使用到）
            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));
        }

        // 下面SIGWINCH和进程热更新相关
        /*
            下面说下nginx热更新  和很多信号相关
            步骤1：kill -s SIGUSR2 <master pid>  
                   发送SIGUSR2信号给master进程  进行进程热更新  新老master进程同时存在  处理请求（新master进程为老master进程子进程）

            步骤2：kill -s SIGWINCH <master pid>
                   发送SIGWINCH信号给老master进程  平滑关闭老master进程的所有worker进程  老进程不再接受新请求

            步骤3：kill -9 <master pid>
                   关闭老master进程

            注意：
                   在上述步骤中  如果新master进程启动后异常退出  在ngx_reap_children()函数中会重启老worker进程  以便整个nginx可以正常工作（ngx_reap_children函数的ngx_processes[i].pid == ngx_new_binary分支）
                   在上述步骤中  如果新master进程正常启动  但是仍想使用老master进程  
                                    步骤1：需要发送SIGHUP信号给老master进程  让其启动worker进程工作（ngx_reconfigure中的ngx_new_binary分支）    
                                    步骤2：发送SIGQUIT信号给新master进程  让其正常退出
        */

        if (ngx_change_binary) {
            // 收到SIGUSR2信号  进程热更新  重新打开新的程序
            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) {
            // 收到SIGWINCH信号  不再接受请求  worker进程退出  master进程不退出（热更新时 旧master进程收到此信号）
            ngx_noaccept = 0;
            ngx_noaccepting = 1;
            // 向所有worker进程发送SIGQUIT信号  进行优雅退出
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
        }
    }

下面是ngx_master_process_cycle函数的总体流程图：