Nginx原始碼分析——master行程與worker行程（二）-有解無憂

一、說明

在前面一章，我們大致了解了nginx行程的啟動，沒有深入的去看行程到底做做了些什么事情，本章我們就看看master行程作業到底在做什么，

二、函式分析

./src/os/unix/ngx_process_cycle.c>ngx_master_process_cycle(ngx_cycle_t *)

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

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: %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");

    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));
        ngx_close_listening_sockets(cycle);

        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));
    }
}

老規矩，還是一段一段分析吧，不過這塊代碼看起來還是比較好懂的，

if (delay) {
    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");
    }
}

setitimer是指經過指定時間之后，內核將發送SIGALRM信號給本行程，指定的時間就是itv，接收到指令之后，ngx_sigalrm就會變成1，當delay不為0的時候，會不斷的翻倍，delay用來等待worker行程退出的時間，master行程接收到信號之后，會發信號給worker行程進行退出，worker行程退出需要時間，delay就是等待的時間，

sigsuspend(&set);

這個時候master行程會被掛起，當行程接受到新的信號之后，將會回傳繼續只是，同時將這個信號完成，上文提到過，處理與發起信號是通過ngx_init_signals執行ngx_signal_handler中的SIGALRM信號，ngx_signal_handler函式中就會將根據輸入

設定下面的狀態

ngx_time_update();

master行程處理資訊的時候，更新快取時間，

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

在上面提到過，行程掛起的時候，會監聽對應的信號，這里當收到SIGCHLD信號的時候，進入這個邏輯，SIGCHLD信號是在子行程終止的時候向父行程發的信號，

ngx_reap_children函式會遍歷ngx_process陣列，檢查每一個子行程的狀態，對于例外退出的行程重新拉起，只有當子行程全部正常退出的時候，live才會是0，其他的時候回傳的live為1，意思就是如果是例外退出，這里會將行程重新拉起，如果是有接收到退出命令的，那么就正常退出，

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

如果live為0就是子行程全部正常退出，并且根據輸入的命令，如果是stop，就執行退出master行程的操作，

master退出的時候，會將pid的檔案刪掉，釋放鏈接、釋放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;
}

進行終止的時候，之前提到先設定delay超時時間，如果沒有超時就執行

ngx_signal_worker_processes(cycle,ngx_signal_value(NGX_TERMINATE_SIGNAL));

發出TERM信號，正常退出worker行程

如果退出超時就執行，強制退出

ngx_signal_worker_processes(cycle, SIGKILL);

并且通過stop關閉的時候，就不關系是不是還有請求在處理，就直接關閉了，這樣就會有quit命令，//TODO ngx_signal_worker_processes函式做了什么后面去填這個坑，至于什么時候，，隨緣吧，，

if (ngx_quit) {
    ngx_signal_worker_processes(cycle,
                                ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
    ngx_close_listening_sockets(cycle);
    continue;
}

這個就是quit命令，相對上面就是沒有業務之后，才會去關閉socket,比較優雅，

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));
}

這個對應的就是reload命令，重新讀取組態檔，

ngx_new_binary這個標志位先不去看，直接看下面的，后續的動作就比較明顯了，初始化ngx_cycle_t結構體，重新讀取組態檔，啟動新的worker行程跟Cache行程，然后等待啟動完成，然后退去原來老的worker行程，

這里先不按照代碼順序講，先說ngx_change_binary狀態

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);
}

處理的信號是USR2，

nginx提供了平滑升級的能力，平滑啟動之后，ngx_new_binary中保存的就是pid，所以上面的reload的時候ngx_new_binary判定是執行不到的，

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

這個簡單就是重啟，沒有對應的信號，就是在處理邏輯里面設定了ngx_restart就進行處理，

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));
}

就是對應的命令reopen,重新設定日志檔案，

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

所有的行程不在接收請求，進行從容關閉行程，

三、總結

這塊很多要去解決的問題就是行程之前信號通信的問題，之前對這塊也不是特別的了解，所有很多都是一知半解，也希望后面對這塊有更深的了解，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/298336.html

標籤：其他

上一篇：K8S 基本概念和術語

下一篇：網路基礎——分層與常見協議