One Level Up Top Level

src/os/unix/ngx_process_cycle.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>
  11. #include <ngx_channel.h>


  14. static void ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n,
  15.     ngx_int_t type);
  16. static void ngx_start_cache_manager_processes(ngx_cycle_t *cycle,
  17.     ngx_uint_t respawn);
  18. static void ngx_pass_open_channel(ngx_cycle_t *cycle);
  19. static void ngx_signal_worker_processes(ngx_cycle_t *cycle, int signo);
  20. static ngx_uint_t ngx_reap_children(ngx_cycle_t *cycle);
  21. static void ngx_master_process_exit(ngx_cycle_t *cycle);
  22. static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data);
  23. static void ngx_worker_process_init(ngx_cycle_t *cycle, ngx_int_t worker);
  24. static void ngx_worker_process_exit(ngx_cycle_t *cycle);
  25. static void ngx_channel_handler(ngx_event_t *ev);
  26. static void ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data);
  27. static void ngx_cache_manager_process_handler(ngx_event_t *ev);
  28. static void ngx_cache_loader_process_handler(ngx_event_t *ev);


  31. ‌ngx_uint_t    ngx_process;
  32. ‌ngx_uint_t    ngx_worker;
  33. ‌ngx_pid_t     ngx_pid;
  34. ‌ngx_pid_t     ngx_parent;

  36. ‌sig_atomic_t  ngx_reap;
  37. ‌sig_atomic_t  ngx_sigio;
  38. ‌sig_atomic_t  ngx_sigalrm;
  39. ‌sig_atomic_t  ngx_terminate;
  40. ‌sig_atomic_t  ngx_quit;
  41. ‌sig_atomic_t  ngx_debug_quit;
  42. ‌ngx_uint_t    ngx_exiting;
  43. ‌sig_atomic_t  ngx_reconfigure;
  44. ‌sig_atomic_t  ngx_reopen;

  46. ‌sig_atomic_t  ngx_change_binary;
  47. ‌ngx_pid_t     ngx_new_binary;
  48. ‌ngx_uint_t    ngx_inherited;
  49. ‌ngx_uint_t    ngx_daemonized;

  51. ‌sig_atomic_t  ngx_noaccept;
  52. ‌ngx_uint_t    ngx_noaccepting;
  53. ‌ngx_uint_t    ngx_restart;


  56. ‌static u_char  master_process[] = "master process";


  59. ‌static ngx_cache_manager_ctx_t  ngx_cache_manager_ctx = {
  60.     ngx_cache_manager_process_handler, "cache manager process", 0
  61. };

  63. ‌static ngx_cache_manager_ctx_t  ngx_cache_loader_ctx = {
  64.     ngx_cache_loader_process_handler, "cache loader process", 60000
  65. };


  68. ‌static ngx_cycle_t      ngx_exit_cycle;
  69. ‌static ngx_log_t        ngx_exit_log;
  70. ‌static ngx_open_file_t  ngx_exit_log_file;


  73. void
  74. ‌ngx_master_process_cycle(ngx_cycle_t *cycle)
  75. {
  76.     char              *title;
  77.     u_char            *p;
  78.     size_t             size;
  79.     ngx_int_t          i;
  80.     ngx_uint_t         sigio;
  81.     sigset_t           set;
  82.     struct itimerval   itv;
  83.     ngx_uint_t         live;
  84.     ngx_msec_t         delay;
  85.     ngx_core_conf_t   *ccf;

  87.     sigemptyset(&set);
  88.     sigaddset(&set, SIGCHLD);
  89.     sigaddset(&set, SIGALRM);
  90.     sigaddset(&set, SIGIO);
  91.     sigaddset(&set, SIGINT);
  92.     sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
  93.     sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
  94.     sigaddset(&set, ngx_signal_value(NGX_NOACCEPT_SIGNAL));
  95.     sigaddset(&set, ngx_signal_value(NGX_TERMINATE_SIGNAL));
  96.     sigaddset(&set, ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  97.     sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));

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

  104.     sigemptyset(&set);


  107.     size = sizeof(master_process);

  109.     for (i = 0; i < ngx_argc; i++) {
  110.         size += ngx_strlen(ngx_argv[i]) + 1;
  111.     }

  113.     title = ngx_pnalloc(cycle->pool, size);
  114.     if (title == NULL) {
  115.         /* fatal */
  116.         exit(2);
  117.     }

  119.     p = ngx_cpymem(title, master_process, sizeof(master_process) - 1);
  120.     for (i = 0; i < ngx_argc; i++) {
  121.         *p++ = ' ';
  122.         p = ngx_cpystrn(p, (u_char *) ngx_argv[i], size);
  123.     }

  125.     ngx_setproctitle(title);


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

  130.     ngx_start_worker_processes(cycle, ccf->worker_processes,
  131.                                NGX_PROCESS_RESPAWN);
  132.     ngx_start_cache_manager_processes(cycle, 0);

  134.     ngx_new_binary = 0;
  135.     delay = 0;
  136.     sigio = 0;
  137.     live = 1;

  139.     for ( ;; ) {
  140.         if (delay) {
  141.             if (ngx_sigalrm) {
  142.                 sigio = 0;
  143.                 delay *= 2;
  144.                 ngx_sigalrm = 0;
  145.             }

  147.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  148.                            "termination cycle: %M", delay);

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

  155.             if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
  156.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  157.                               "setitimer() failed");
  158.             }
  159.         }

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

  163.         sigsuspend(&set);

  165.         ngx_time_update();

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

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

  174.             live = ngx_reap_children(cycle);
  175.         }

  177. #if (NGX_CONTROL_API)
  178.         if (ngx_sigio) {
  179.             ngx_sigio = 0;

  181.             if (ngx_control_handle_events() == NGX_DONE) {
  182.                 cycle = (ngx_cycle_t *) ngx_cycle;
  183.                 ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx,
  184.                                                        ngx_core_module);
  185.                 ngx_start_worker_processes(cycle, ccf->worker_processes,
  186.                                            NGX_PROCESS_JUST_RESPAWN);
  187.                 ngx_start_cache_manager_processes(cycle, 1);

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

  192.                 live = 1;
  193.                 ngx_signal_worker_processes(cycle,
  194.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  195.             }
  196.         }
  197. #endif

  199.         if (!live && (ngx_terminate || ngx_quit)) {
  200.             ngx_master_process_exit(cycle);
  201.         }

  203.         if (ngx_terminate) {
  204.             if (delay == 0) {
  205.                 delay = 50;
  206.             }

  208.             if (sigio) {
  209.                 sigio--;
  210.                 continue;
  211.             }

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

  215.             if (delay > 1000) {
  216.                 ngx_signal_worker_processes(cycle, SIGKILL);
  217.             } else {
  218.                 ngx_signal_worker_processes(cycle,
  219.                                        ngx_signal_value(NGX_TERMINATE_SIGNAL));
  220.             }

  222.             continue;
  223.         }

  225.         if (ngx_quit) {
  226.             ngx_signal_worker_processes(cycle,
  227.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  228.             ngx_close_listening_sockets(cycle);

  230.             continue;
  231.         }

  233.         if (ngx_reconfigure) {
  234.             ngx_reconfigure = 0;

  236.             if (ngx_new_binary) {
  237.                 ngx_start_worker_processes(cycle, ccf->worker_processes,
  238.                                            NGX_PROCESS_RESPAWN);
  239.                 ngx_start_cache_manager_processes(cycle, 0);
  240.                 ngx_noaccepting = 0;

  242.                 continue;
  243.             }

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

  247.             cycle = ngx_init_cycle(cycle);
  248.             if (cycle == NULL) {
  249.                 cycle = (ngx_cycle_t *) ngx_cycle;
  250.                 continue;
  251.             }

  253.             ngx_cycle = cycle;
  254.             ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx,
  255.                                                    ngx_core_module);
  256.             ngx_start_worker_processes(cycle, ccf->worker_processes,
  257.                                        NGX_PROCESS_JUST_RESPAWN);
  258.             ngx_start_cache_manager_processes(cycle, 1);

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

  263.             live = 1;
  264.             ngx_signal_worker_processes(cycle,
  265.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  266.         }

  268.         if (ngx_restart) {
  269.             ngx_restart = 0;
  270.             ngx_start_worker_processes(cycle, ccf->worker_processes,
  271.                                        NGX_PROCESS_RESPAWN);
  272.             ngx_start_cache_manager_processes(cycle, 0);
  273.             live = 1;
  274.         }

  276.         if (ngx_reopen) {
  277.             ngx_reopen = 0;
  278.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
  279.             ngx_reopen_files(cycle, ccf->user);
  280.             ngx_signal_worker_processes(cycle,
  281.                                         ngx_signal_value(NGX_REOPEN_SIGNAL));
  282.         }

  284.         if (ngx_change_binary) {
  285.             ngx_change_binary = 0;
  286.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "changing binary");
  287.             ngx_new_binary = ngx_exec_new_binary(cycle, ngx_argv);
  288.         }

  290.         if (ngx_noaccept) {
  291.             ngx_noaccept = 0;
  292.             ngx_noaccepting = 1;
  293.             ngx_signal_worker_processes(cycle,
  294.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  295.         }
  296.     }
  297. }


  300. void
  301. ‌ngx_single_process_cycle(ngx_cycle_t *cycle)
  302. {
  303.     ngx_uint_t  i;

  305.     if (ngx_set_environment(cycle, NULL) == NULL) {
  306.         /* fatal */
  307.         exit(2);
  308.     }

  310.     for (i = 0; cycle->modules[i]; i++) {
  311.         if (cycle->modules[i]->init_process) {
  312.             if (cycle->modules[i]->init_process(cycle) == NGX_ERROR) {
  313.                 /* fatal */
  314.                 exit(2);
  315.             }
  316.         }
  317.     }

  319.     for ( ;; ) {
  320.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");

  322.         ngx_process_events_and_timers(cycle);

  324.         if (ngx_terminate || ngx_quit) {

  326.             for (i = 0; cycle->modules[i]; i++) {
  327.                 if (cycle->modules[i]->exit_process) {
  328.                     cycle->modules[i]->exit_process(cycle);
  329.                 }
  330.             }

  332.             ngx_master_process_exit(cycle);
  333.         }

  335.         if (ngx_reconfigure) {
  336.             ngx_reconfigure = 0;
  337.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");

  339.             cycle = ngx_init_cycle(cycle);
  340.             if (cycle == NULL) {
  341.                 cycle = (ngx_cycle_t *) ngx_cycle;
  342.                 continue;
  343.             }

  345.             ngx_cycle = cycle;
  346.         }

  348.         if (ngx_reopen) {
  349.             ngx_reopen = 0;
  350.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
  351.             ngx_reopen_files(cycle, (ngx_uid_t) -1);
  352.         }
  353.     }
  354. }


  357. static void
  358. ‌ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n, ngx_int_t type)
  359. {
  360.     ngx_int_t  i;

  362.     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");

  364.     for (i = 0; i < n; i++) {

  366.         ngx_spawn_process(cycle, ngx_worker_process_cycle,
  367.                           (void *) (intptr_t) i, "worker process", type);

  369.         ngx_pass_open_channel(cycle);
  370.     }
  371. }


  374. static void
  375. ‌ngx_start_cache_manager_processes(ngx_cycle_t *cycle, ngx_uint_t respawn)
  376. {
  377.     ngx_uint_t    i, manager, loader;
  378.     ngx_path_t  **path;

  380.     manager = 0;
  381.     loader = 0;

  383.     path = ngx_cycle->paths.elts;
  384.     for (i = 0; i < ngx_cycle->paths.nelts; i++) {

  386.         if (path[i]->manager) {
  387.             manager = 1;
  388.         }

  390.         if (path[i]->loader) {
  391.             loader = 1;
  392.         }
  393.     }

  395.     if (manager == 0) {
  396.         return;
  397.     }

  399.     ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
  400.                       &ngx_cache_manager_ctx, "cache manager process",
  401.                       respawn ? NGX_PROCESS_JUST_RESPAWN : NGX_PROCESS_RESPAWN);

  403.     ngx_pass_open_channel(cycle);

  405.     if (loader == 0) {
  406.         return;
  407.     }

  409.     ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
  410.                       &ngx_cache_loader_ctx, "cache loader process",
  411.                       respawn ? NGX_PROCESS_JUST_SPAWN : NGX_PROCESS_NORESPAWN);

  413.     ngx_pass_open_channel(cycle);
  414. }


  417. static void
  418. ‌ngx_pass_open_channel(ngx_cycle_t *cycle)
  419. {
  420.     ngx_int_t      i;
  421.     ngx_channel_t  ch;

  423.     ngx_memzero(&ch, sizeof(ngx_channel_t));

  425.     ch.command = NGX_CMD_OPEN_CHANNEL;
  426.     ch.pid = ngx_processes[ngx_process_slot].pid;
  427.     ch.slot = ngx_process_slot;
  428.     ch.fd = ngx_processes[ngx_process_slot].channel[0];

  430.     for (i = 0; i < ngx_last_process; i++) {

  432.         if (i == ngx_process_slot
  433.             || ngx_processes[i].pid == -1
  434.             || ngx_processes[i].channel[0] == -1)
  435.         {
  436.             continue;
  437.         }

  439.         ngx_log_debug6(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  440.                       "pass channel s:%i pid:%P fd:%d to s:%i pid:%P fd:%d",
  441.                       ch.slot, ch.pid, ch.fd,
  442.                       i, ngx_processes[i].pid,
  443.                       ngx_processes[i].channel[0]);

  445.         /* TODO: NGX_AGAIN */

  447.         ngx_write_channel(ngx_processes[i].channel[0],
  448.                           &ch, sizeof(ngx_channel_t), cycle->log);
  449.     }
  450. }


  453. static void
  454. ‌ngx_signal_worker_processes(ngx_cycle_t *cycle, int signo)
  455. {
  456.     ngx_int_t      i;
  457.     ngx_err_t      err;
  458.     ngx_channel_t  ch;

  460.     ngx_memzero(&ch, sizeof(ngx_channel_t));

  462. #if (NGX_BROKEN_SCM_RIGHTS)

  464.     ch.command = 0;

  466. #else

  468.     switch (signo) {

  470.     case ngx_signal_value(NGX_SHUTDOWN_SIGNAL):
  471.         ch.command = NGX_CMD_QUIT;
  472.         break;

  474.     case ngx_signal_value(NGX_TERMINATE_SIGNAL):
  475.         ch.command = NGX_CMD_TERMINATE;
  476.         break;

  478.     case ngx_signal_value(NGX_REOPEN_SIGNAL):
  479.         ch.command = NGX_CMD_REOPEN;
  480.         break;

  482.     default:
  483.         ch.command = 0;
  484.     }

  486. #endif

  488.     ch.fd = -1;


  491.     for (i = 0; i < ngx_last_process; i++) {

  493.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  494.                        "child: %i %P e:%d t:%d d:%d r:%d j:%d",
  495.                        i,
  496.                        ngx_processes[i].pid,
  497.                        ngx_processes[i].exiting,
  498.                        ngx_processes[i].exited,
  499.                        ngx_processes[i].detached,
  500.                        ngx_processes[i].respawn,
  501.                        ngx_processes[i].just_spawn);

  503.         if (ngx_processes[i].detached || ngx_processes[i].pid == -1) {
  504.             continue;
  505.         }

  507.         if (ngx_processes[i].just_spawn) {
  508.             ngx_processes[i].just_spawn = 0;
  509.             continue;
  510.         }

  512.         if (ngx_processes[i].exiting
  513.             && signo == ngx_signal_value(NGX_SHUTDOWN_SIGNAL))
  514.         {
  515.             continue;
  516.         }

  518.         if (ch.command) {
  519.             if (ngx_write_channel(ngx_processes[i].channel[0],
  520.                                   &ch, sizeof(ngx_channel_t), cycle->log)
  521.                 == NGX_OK)
  522.             {
  523.                 if (signo != ngx_signal_value(NGX_REOPEN_SIGNAL)) {
  524.                     ngx_processes[i].exiting = 1;
  525.                 }

  527.                 continue;
  528.             }
  529.         }

  531.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  532.                        "kill (%P, %d)", ngx_processes[i].pid, signo);

  534.         if (kill(ngx_processes[i].pid, signo) == -1) {
  535.             err = ngx_errno;
  536.             ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  537.                           "kill(%P, %d) failed", ngx_processes[i].pid, signo);

  539.             if (err == NGX_ESRCH) {
  540.                 ngx_processes[i].exited = 1;
  541.                 ngx_processes[i].exiting = 0;
  542.                 ngx_reap = 1;
  543.             }

  545.             continue;
  546.         }

  548.         if (signo != ngx_signal_value(NGX_REOPEN_SIGNAL)) {
  549.             ngx_processes[i].exiting = 1;
  550.         }
  551.     }
  552. }


  555. static ngx_uint_t
  556. ‌ngx_reap_children(ngx_cycle_t *cycle)
  557. {
  558.     ngx_int_t         i, n;
  559.     ngx_uint_t        live;
  560.     ngx_channel_t     ch;
  561.     ngx_core_conf_t  *ccf;

  563.     ngx_memzero(&ch, sizeof(ngx_channel_t));

  565.     ch.command = NGX_CMD_CLOSE_CHANNEL;
  566.     ch.fd = -1;

  568.     live = 0;
  569.     for (i = 0; i < ngx_last_process; i++) {

  571.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  572.                        "child: %i %P e:%d t:%d d:%d r:%d j:%d",
  573.                        i,
  574.                        ngx_processes[i].pid,
  575.                        ngx_processes[i].exiting,
  576.                        ngx_processes[i].exited,
  577.                        ngx_processes[i].detached,
  578.                        ngx_processes[i].respawn,
  579.                        ngx_processes[i].just_spawn);

  581.         if (ngx_processes[i].pid == -1) {
  582.             continue;
  583.         }

  585.         if (ngx_processes[i].exited) {

  587.             if (!ngx_processes[i].detached) {
  588.                 ngx_close_channel(ngx_processes[i].channel, cycle->log);

  590.                 ngx_processes[i].channel[0] = -1;
  591.                 ngx_processes[i].channel[1] = -1;

  593.                 ch.pid = ngx_processes[i].pid;
  594.                 ch.slot = i;

  596.                 for (n = 0; n < ngx_last_process; n++) {
  597.                     if (ngx_processes[n].exited
  598.                         || ngx_processes[n].pid == -1
  599.                         || ngx_processes[n].channel[0] == -1)
  600.                     {
  601.                         continue;
  602.                     }

  604.                     ngx_log_debug3(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  605.                                    "pass close channel s:%i pid:%P to:%P",
  606.                                    ch.slot, ch.pid, ngx_processes[n].pid);

  608.                     /* TODO: NGX_AGAIN */

  610.                     ngx_write_channel(ngx_processes[n].channel[0],
  611.                                       &ch, sizeof(ngx_channel_t), cycle->log);
  612.                 }
  613.             }

  615.             if (ngx_processes[i].respawn
  616.                 && !ngx_processes[i].exiting
  617.                 && !ngx_terminate
  618.                 && !ngx_quit)
  619.             {
  620.                 if (ngx_spawn_process(cycle, ngx_processes[i].proc,
  621.                                       ngx_processes[i].data,
  622.                                       ngx_processes[i].name, i)
  623.                     == NGX_INVALID_PID)
  624.                 {
  625.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  626.                                   "could not respawn %s",
  627.                                   ngx_processes[i].name);
  628.                     continue;
  629.                 }


  632.                 ngx_pass_open_channel(cycle);

  634.                 live = 1;

  636.                 continue;
  637.             }

  639.             if (ngx_processes[i].pid == ngx_new_binary) {

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

  644.                 if (ngx_rename_file((char *) ccf->oldpid.data,
  645.                                     (char *) ccf->pid.data)
  646.                     == NGX_FILE_ERROR)
  647.                 {
  648.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  649.                                   ngx_rename_file_n " %s back to %s failed "
  650.                                   "after the new binary process \"%s\" exited",
  651.                                   ccf->oldpid.data, ccf->pid.data, ngx_argv[0]);
  652.                 }

  654. #if (NGX_CONTROL_API)
  655.                 ngx_control_reown();
  656. #endif

  658.                 ngx_new_binary = 0;
  659.                 if (ngx_noaccepting) {
  660.                     ngx_restart = 1;
  661.                     ngx_noaccepting = 0;
  662.                 }
  663.             }

  665.             if (i == ngx_last_process - 1) {
  666.                 ngx_last_process--;

  668.             } else {
  669.                 ngx_processes[i].pid = -1;
  670.             }

  672.         } else if (ngx_processes[i].exiting || !ngx_processes[i].detached) {
  673.             live = 1;
  674.         }
  675.     }

  677.     return live;
  678. }


  681. static void
  682. ‌ngx_master_process_exit(ngx_cycle_t *cycle)
  683. {
  684.     ngx_uint_t  i;

  686.     ngx_delete_pidfile(cycle);

  688.     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exit");

  690.     for (i = 0; cycle->modules[i]; i++) {
  691.         if (cycle->modules[i]->exit_master) {
  692.             cycle->modules[i]->exit_master(cycle);
  693.         }
  694.     }

  696.     ngx_close_listening_sockets(cycle);

  698. #if (NGX_CONTROL_API)
  699.     ngx_control_uninit();
  700. #endif

  702.     /*
  703.      * Copy ngx_cycle->log related data to the special static exit cycle,
  704.      * log, and log file structures enough to allow a signal handler to log.
  705.      * The handler may be called when standard ngx_cycle->log allocated from
  706.      * ngx_cycle->pool is already destroyed.
  707.      */


  710.     ngx_exit_log = *ngx_log_get_file_log(ngx_cycle->log);

  712.     ngx_exit_log_file.fd = ngx_exit_log.file->fd;
  713.     ngx_exit_log.file = &ngx_exit_log_file;
  714.     ngx_exit_log.next = NULL;
  715.     ngx_exit_log.writer = NULL;

  717.     ngx_exit_cycle.log = &ngx_exit_log;
  718.     ngx_exit_cycle.files = ngx_cycle->files;
  719.     ngx_exit_cycle.files_n = ngx_cycle->files_n;
  720.     ngx_cycle = &ngx_exit_cycle;

  722.     ngx_destroy_pool(cycle->pool);

  724.     exit(0);
  725. }


  728. static void
  729. ‌ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
  730. {
  731.     ngx_int_t worker = (intptr_t) data;

  733.     ngx_process = NGX_PROCESS_WORKER;
  734.     ngx_worker = worker;

  736.     ngx_worker_process_init(cycle, worker);

  738.     ngx_setproctitle("worker process");

  740.     for ( ;; ) {

  742.         if (ngx_exiting) {
  743.             if (ngx_event_no_timers_left() == NGX_OK) {
  744.                 ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
  745.                 ngx_worker_process_exit(cycle);
  746.             }
  747.         }

  749.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");

  751.         ngx_process_events_and_timers(cycle);

  753.         if (ngx_terminate) {
  754.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
  755.             ngx_worker_process_exit(cycle);
  756.         }

  758.         if (ngx_quit) {
  759.             ngx_quit = 0;
  760.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
  761.                           "gracefully shutting down");
  762.             ngx_setproctitle("worker process is shutting down");

  764.             if (!ngx_exiting) {
  765.                 ngx_exiting = 1;
  766.                 ngx_set_shutdown_timer(cycle);
  767.                 ngx_close_listening_sockets(cycle);
  768.                 ngx_close_idle_connections(cycle);
  769.                 ngx_event_process_posted(cycle, &ngx_posted_events);
  770.             }
  771.         }

  773.         if (ngx_reopen) {
  774.             ngx_reopen = 0;
  775.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
  776.             ngx_reopen_files(cycle, -1);
  777.         }
  778.     }
  779. }


  782. static void
  783. ‌ngx_worker_process_init(ngx_cycle_t *cycle, ngx_int_t worker)
  784. {
  785.     sigset_t          set;
  786.     ngx_int_t         n;
  787.     ngx_time_t       *tp;
  788.     ngx_uint_t        i;
  789.     ngx_cpuset_t     *cpu_affinity;
  790.     struct rlimit     rlmt;
  791.     ngx_core_conf_t  *ccf;

  793. #if (NGX_CONTROL_API)
  794.     ngx_control_close_sockets();
  795. #endif

  797.     if (ngx_set_environment(cycle, NULL) == NULL) {
  798.         /* fatal */
  799.         exit(2);
  800.     }

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

  804.     if (worker >= 0 && ccf->priority != 0) {
  805.         if (setpriority(PRIO_PROCESS, 0, ccf->priority) == -1) {
  806.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  807.                           "setpriority(%d) failed", ccf->priority);
  808.         }
  809.     }

  811.     if (ccf->rlimit_nofile != NGX_CONF_UNSET) {
  812.         rlmt.rlim_cur = (rlim_t) ccf->rlimit_nofile;
  813.         rlmt.rlim_max = (rlim_t) ccf->rlimit_nofile;

  815.         if (setrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  816.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  817.                           "setrlimit(RLIMIT_NOFILE, %i) failed",
  818.                           ccf->rlimit_nofile);
  819.         }
  820.     }

  822.     if (ccf->rlimit_core != NGX_CONF_UNSET) {
  823.         rlmt.rlim_cur = (rlim_t) ccf->rlimit_core;
  824.         rlmt.rlim_max = (rlim_t) ccf->rlimit_core;

  826.         if (setrlimit(RLIMIT_CORE, &rlmt) == -1) {
  827.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  828.                           "setrlimit(RLIMIT_CORE, %O) failed",
  829.                           ccf->rlimit_core);
  830.         }
  831.     }

  833.     if (geteuid() == 0) {
  834.         if (setgid(ccf->group) == -1) {
  835.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  836.                           "setgid(%d) failed", ccf->group);
  837.             /* fatal */
  838.             exit(2);
  839.         }

  841.         if (initgroups(ccf->username, ccf->group) == -1) {
  842.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  843.                           "initgroups(%s, %d) failed",
  844.                           ccf->username, ccf->group);
  845.         }

  847. #if (NGX_HAVE_PR_SET_KEEPCAPS && NGX_HAVE_CAPABILITIES)
  848.         if (ccf->transparent && ccf->user) {
  849.             if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1) {
  850.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  851.                               "prctl(PR_SET_KEEPCAPS, 1) failed");
  852.                 /* fatal */
  853.                 exit(2);
  854.             }
  855.         }
  856. #endif

  858.         if (setuid(ccf->user) == -1) {
  859.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  860.                           "setuid(%d) failed", ccf->user);
  861.             /* fatal */
  862.             exit(2);
  863.         }

  865. #if (NGX_HAVE_CAPABILITIES)
  866.         if (ccf->transparent && ccf->user) {
  867.             struct __user_cap_data_struct    data;
  868.             struct __user_cap_header_struct  header;

  870.             ngx_memzero(&header, sizeof(struct __user_cap_header_struct));
  871.             ngx_memzero(&data, sizeof(struct __user_cap_data_struct));

  873.             header.version = _LINUX_CAPABILITY_VERSION_1;
  874.             data.effective = CAP_TO_MASK(CAP_NET_RAW);
  875.             data.permitted = data.effective;

  877.             if (syscall(SYS_capset, &header, &data) == -1) {
  878.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  879.                               "capset() failed");
  880.                 /* fatal */
  881.                 exit(2);
  882.             }
  883.         }
  884. #endif
  885.     }

  887.     if (worker >= 0) {
  888.         cpu_affinity = ngx_get_cpu_affinity(worker);

  890.         if (cpu_affinity) {
  891.             ngx_setaffinity(cpu_affinity, cycle->log);
  892.         }
  893.     }

  895. #if (NGX_HAVE_PR_SET_DUMPABLE)

  897.     /* allow coredump after setuid() in Linux 2.4.x */

  899.     if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1) {
  900.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  901.                       "prctl(PR_SET_DUMPABLE) failed");
  902.     }

  904. #endif

  906.     if (ccf->working_directory.len) {
  907.         if (chdir((char *) ccf->working_directory.data) == -1) {
  908.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  909.                           "chdir(\"%s\") failed", ccf->working_directory.data);
  910.             /* fatal */
  911.             exit(2);
  912.         }
  913.     }

  915.     sigemptyset(&set);

  917.     if (sigprocmask(SIG_SETMASK, &set, NULL) == -1) {
  918.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  919.                       "sigprocmask() failed");
  920.     }

  922.     tp = ngx_timeofday();
  923.     srandom(((unsigned) ngx_pid << 16) ^ tp->sec ^ tp->msec);

  925.     for (i = 0; cycle->modules[i]; i++) {
  926.         if (cycle->modules[i]->init_process) {
  927.             if (cycle->modules[i]->init_process(cycle) == NGX_ERROR) {
  928.                 /* fatal */
  929.                 exit(2);
  930.             }
  931.         }
  932.     }

  934.     for (n = 0; n < ngx_last_process; n++) {

  936.         if (ngx_processes[n].pid == -1) {
  937.             continue;
  938.         }

  940.         if (n == ngx_process_slot) {
  941.             continue;
  942.         }

  944.         if (ngx_processes[n].channel[1] == -1) {
  945.             continue;
  946.         }

  948.         if (close(ngx_processes[n].channel[1]) == -1) {
  949.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  950.                           "close() channel failed");
  951.         }
  952.     }

  954.     if (close(ngx_processes[ngx_process_slot].channel[0]) == -1) {
  955.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  956.                       "close() channel failed");
  957.     }

  959. #if 0
  960.     ngx_last_process = 0;
  961. #endif

  963.     if (ngx_add_channel_event(cycle, ngx_channel, NGX_READ_EVENT,
  964.                               ngx_channel_handler)
  965.         == NGX_ERROR)
  966.     {
  967.         /* fatal */
  968.         exit(2);
  969.     }
  970. }


  973. static void
  974. ‌ngx_worker_process_exit(ngx_cycle_t *cycle)
  975. {
  976.     ngx_uint_t         i;
  977.     ngx_connection_t  *c;

  979.     for (i = 0; cycle->modules[i]; i++) {
  980.         if (cycle->modules[i]->exit_process) {
  981.             cycle->modules[i]->exit_process(cycle);
  982.         }
  983.     }

  985.     if (ngx_exiting && !ngx_terminate) {
  986.         c = cycle->connections;
  987.         for (i = 0; i < cycle->connection_n; i++) {
  988.             if (c[i].fd != -1
  989.                 && c[i].read
  990.                 && !c[i].read->accept
  991.                 && !c[i].read->channel
  992.                 && !c[i].read->resolver)
  993.             {
  994.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  995.                               "*%uA open socket #%d left in connection %ui",
  996.                               c[i].number, c[i].fd, i);
  997.                 ngx_debug_quit = 1;
  998.             }
  999.         }
  1000.     }

  1002.     if (ngx_debug_quit) {
  1003.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "aborting");
  1004.         ngx_debug_point();
  1005.     }

  1007.     /*
  1008.      * Copy ngx_cycle->log related data to the special static exit cycle,
  1009.      * log, and log file structures enough to allow a signal handler to log.
  1010.      * The handler may be called when standard ngx_cycle->log allocated from
  1011.      * ngx_cycle->pool is already destroyed.
  1012.      */

  1014.     ngx_exit_log = *ngx_log_get_file_log(ngx_cycle->log);

  1016.     ngx_exit_log_file.fd = ngx_exit_log.file->fd;
  1017.     ngx_exit_log.file = &ngx_exit_log_file;
  1018.     ngx_exit_log.next = NULL;
  1019.     ngx_exit_log.writer = NULL;

  1021.     ngx_exit_cycle.log = &ngx_exit_log;
  1022.     ngx_exit_cycle.files = ngx_cycle->files;
  1023.     ngx_exit_cycle.files_n = ngx_cycle->files_n;
  1024.     ngx_cycle = &ngx_exit_cycle;

  1026.     ngx_destroy_pool(cycle->pool);

  1028.     ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0, "exit");

  1030.     exit(0);
  1031. }


  1034. static void
  1035. ‌ngx_channel_handler(ngx_event_t *ev)
  1036. {
  1037.     ngx_int_t          n;
  1038.     ngx_channel_t      ch;
  1039.     ngx_connection_t  *c;

  1041.     if (ev->timedout) {
  1042.         ev->timedout = 0;
  1043.         return;
  1044.     }

  1046.     c = ev->data;

  1048.     ngx_log_debug0(NGX_LOG_DEBUG_CORE, ev->log, 0, "channel handler");

  1050.     for ( ;; ) {

  1052.         n = ngx_read_channel(c->fd, &ch, sizeof(ngx_channel_t), ev->log);

  1054.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0, "channel: %i", n);

  1056.         if (n == NGX_ERROR) {

  1058.             if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {
  1059.                 ngx_del_conn(c, 0);
  1060.             }

  1062.             ngx_close_connection(c);
  1063.             return;
  1064.         }

  1066.         if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {
  1067.             if (ngx_add_event(ev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  1068.                 return;
  1069.             }
  1070.         }

  1072.         if (n == NGX_AGAIN) {
  1073.             return;
  1074.         }

  1076.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,
  1077.                        "channel command: %ui", ch.command);

  1079.         switch (ch.command) {

  1081.         case NGX_CMD_QUIT:
  1082.             ngx_quit = 1;
  1083.             break;

  1085.         case NGX_CMD_TERMINATE:
  1086.             ngx_terminate = 1;
  1087.             break;

  1089.         case NGX_CMD_REOPEN:
  1090.             ngx_reopen = 1;
  1091.             break;

  1093.         case NGX_CMD_OPEN_CHANNEL:

  1095.             ngx_log_debug3(NGX_LOG_DEBUG_CORE, ev->log, 0,
  1096.                            "get channel s:%i pid:%P fd:%d",
  1097.                            ch.slot, ch.pid, ch.fd);

  1099.             ngx_processes[ch.slot].pid = ch.pid;
  1100.             ngx_processes[ch.slot].channel[0] = ch.fd;
  1101.             break;

  1103.         case NGX_CMD_CLOSE_CHANNEL:

  1105.             ngx_log_debug4(NGX_LOG_DEBUG_CORE, ev->log, 0,
  1106.                            "close channel s:%i pid:%P our:%P fd:%d",
  1107.                            ch.slot, ch.pid, ngx_processes[ch.slot].pid,
  1108.                            ngx_processes[ch.slot].channel[0]);

  1110.             if (ngx_processes[ch.slot].channel[0] == -1
  1111.                 || ngx_processes[ch.slot].pid != ch.pid)
  1112.             {
  1113.                 break;
  1114.             }

  1116.             if (close(ngx_processes[ch.slot].channel[0]) == -1) {
  1117.                 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  1118.                               "close() channel failed");
  1119.             }

  1121.             ngx_processes[ch.slot].channel[0] = -1;
  1122.             break;
  1123.         }
  1124.     }
  1125. }


  1128. static void
  1129. ‌ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data)
  1130. {
  1131.     ngx_cache_manager_ctx_t *ctx = data;

  1133.     void         *ident[4];
  1134.     ngx_event_t   ev;

  1136.     /*
  1137.      * Set correct process type since closing listening Unix domain socket
  1138.      * in a master process also removes the Unix domain socket file.
  1139.      */
  1140.     ngx_process = NGX_PROCESS_HELPER;

  1142.     ngx_close_listening_sockets(cycle);

  1144.     /* Set a moderate number of connections for a helper process. */
  1145.     cycle->connection_n = 512;

  1147.     ngx_worker_process_init(cycle, -1);

  1149.     ngx_memzero(&ev, sizeof(ngx_event_t));
  1150.     ev.handler = ctx->handler;
  1151.     ev.data = ident;
  1152.     ev.log = cycle->log;
  1153.     ident[3] = (void *) -1;

  1155.     ngx_use_accept_mutex = 0;

  1157.     ngx_setproctitle(ctx->name);

  1159.     ngx_add_timer(&ev, ctx->delay);

  1161.     for ( ;; ) {

  1163.         if (ngx_terminate || ngx_quit) {
  1164.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
  1165.             exit(0);
  1166.         }

  1168.         if (ngx_reopen) {
  1169.             ngx_reopen = 0;
  1170.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
  1171.             ngx_reopen_files(cycle, -1);
  1172.         }

  1174.         ngx_process_events_and_timers(cycle);
  1175.     }
  1176. }


  1179. static void
  1180. ‌ngx_cache_manager_process_handler(ngx_event_t *ev)
  1181. {
  1182.     ngx_uint_t    i;
  1183.     ngx_msec_t    next, n;
  1184.     ngx_path_t  **path;

  1186.     next = 60 * 60 * 1000;

  1188.     path = ngx_cycle->paths.elts;
  1189.     for (i = 0; i < ngx_cycle->paths.nelts; i++) {

  1191.         if (path[i]->manager) {
  1192.             n = path[i]->manager(path[i]->data);

  1194.             next = (n <= next) ? n : next;

  1196.             ngx_time_update();
  1197.         }
  1198.     }

  1200.     if (next == 0) {
  1201.         next = 1;
  1202.     }

  1204.     ngx_add_timer(ev, next);
  1205. }


  1208. static void
  1209. ‌ngx_cache_loader_process_handler(ngx_event_t *ev)
  1210. {
  1211.     ngx_uint_t     i;
  1212.     ngx_path_t   **path;
  1213.     ngx_cycle_t   *cycle;

  1215.     cycle = (ngx_cycle_t *) ngx_cycle;

  1217.     path = cycle->paths.elts;
  1218.     for (i = 0; i < cycle->paths.nelts; i++) {

  1220.         if (ngx_terminate || ngx_quit) {
  1221.             break;
  1222.         }

  1224.         if (path[i]->loader) {
  1225.             path[i]->loader(path[i]->data);
  1226.             ngx_time_update();
  1227.         }
  1228.     }

  1230.     exit(0);
  1231. }

One Level Up Top Level