One Level Up Top Level

src/os/unix/ngx_process_cycle.c - nginx-1.7.10

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, ngx_channel_t *ch);
  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. #if (NGX_THREADS)
  27. static void ngx_wakeup_worker_threads(ngx_cycle_t *cycle);
  28. static ngx_thread_value_t ngx_worker_thread_cycle(void *data);
  29. #endif
  30. static void ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data);
  31. static void ngx_cache_manager_process_handler(ngx_event_t *ev);
  32. static void ngx_cache_loader_process_handler(ngx_event_t *ev);


  35. ‌ngx_uint_t    ngx_process;
  36. ‌ngx_pid_t     ngx_pid;
  37. ‌ngx_uint_t    ngx_threaded;

  39. ‌sig_atomic_t  ngx_reap;
  40. ‌sig_atomic_t  ngx_sigio;
  41. ‌sig_atomic_t  ngx_sigalrm;
  42. ‌sig_atomic_t  ngx_terminate;
  43. ‌sig_atomic_t  ngx_quit;
  44. ‌sig_atomic_t  ngx_debug_quit;
  45. ‌ngx_uint_t    ngx_exiting;
  46. ‌sig_atomic_t  ngx_reconfigure;
  47. ‌sig_atomic_t  ngx_reopen;

  49. ‌sig_atomic_t  ngx_change_binary;
  50. ‌ngx_pid_t     ngx_new_binary;
  51. ‌ngx_uint_t    ngx_inherited;
  52. ‌ngx_uint_t    ngx_daemonized;

  54. ‌sig_atomic_t  ngx_noaccept;
  55. ‌ngx_uint_t    ngx_noaccepting;
  56. ‌ngx_uint_t    ngx_restart;


  59. #if (NGX_THREADS)
  60. ‌volatile ngx_thread_t  ngx_threads[NGX_MAX_THREADS];
  61. ‌ngx_int_t              ngx_threads_n;
  62. #endif


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


  68. ‌static ngx_cache_manager_ctx_t  ngx_cache_manager_ctx = {
  69.     ngx_cache_manager_process_handler, "cache manager process", 0
  70. };

  72. ‌static ngx_cache_manager_ctx_t  ngx_cache_loader_ctx = {
  73.     ngx_cache_loader_process_handler, "cache loader process", 60000
  74. };


  77. ‌static ngx_cycle_t      ngx_exit_cycle;
  78. ‌static ngx_log_t        ngx_exit_log;
  79. ‌static ngx_open_file_t  ngx_exit_log_file;


  82. void
  83. ‌ngx_master_process_cycle(ngx_cycle_t *cycle)
  84. {
  85.     char              *title;
  86.     u_char            *p;
  87.     size_t             size;
  88.     ngx_int_t          i;
  89.     ngx_uint_t         n, sigio;
  90.     sigset_t           set;
  91.     struct itimerval   itv;
  92.     ngx_uint_t         live;
  93.     ngx_msec_t         delay;
  94.     ngx_listening_t   *ls;
  95.     ngx_core_conf_t   *ccf;

  97.     sigemptyset(&set);
  98.     sigaddset(&set, SIGCHLD);
  99.     sigaddset(&set, SIGALRM);
  100.     sigaddset(&set, SIGIO);
  101.     sigaddset(&set, SIGINT);
  102.     sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
  103.     sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
  104.     sigaddset(&set, ngx_signal_value(NGX_NOACCEPT_SIGNAL));
  105.     sigaddset(&set, ngx_signal_value(NGX_TERMINATE_SIGNAL));
  106.     sigaddset(&set, ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  107.     sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));

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

  114.     sigemptyset(&set);


  117.     size = sizeof(master_process);

  119.     for (i = 0; i < ngx_argc; i++) {
  120.         size += ngx_strlen(ngx_argv[i]) + 1;
  121.     }

  123.     title = ngx_pnalloc(cycle->pool, size);
  124.     if (title == NULL) {
  125.         /* fatal */
  126.         exit(2);
  127.     }

  129.     p = ngx_cpymem(title, master_process, sizeof(master_process) - 1);
  130.     for (i = 0; i < ngx_argc; i++) {
  131.         *p++ = ' ';
  132.         p = ngx_cpystrn(p, (u_char *) ngx_argv[i], size);
  133.     }

  135.     ngx_setproctitle(title);


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

  140.     ngx_start_worker_processes(cycle, ccf->worker_processes,
  141.                                NGX_PROCESS_RESPAWN);
  142.     ngx_start_cache_manager_processes(cycle, 0);

  144.     ngx_new_binary = 0;
  145.     delay = 0;
  146.     sigio = 0;
  147.     live = 1;

  149.     for ( ;; ) {
  150.         if (delay) {
  151.             if (ngx_sigalrm) {
  152.                 sigio = 0;
  153.                 delay *= 2;
  154.                 ngx_sigalrm = 0;
  155.             }

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

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

  165.             if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
  166.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  167.                               "setitimer() failed");
  168.             }
  169.         }

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

  173.         sigsuspend(&set);

  175.         ngx_time_update();

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

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

  184.             live = ngx_reap_children(cycle);
  185.         }

  187.         if (!live && (ngx_terminate || ngx_quit)) {
  188.             ngx_master_process_exit(cycle);
  189.         }

  191.         if (ngx_terminate) {
  192.             if (delay == 0) {
  193.                 delay = 50;
  194.             }

  196.             if (sigio) {
  197.                 sigio--;
  198.                 continue;
  199.             }

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

  203.             if (delay > 1000) {
  204.                 ngx_signal_worker_processes(cycle, SIGKILL);
  205.             } else {
  206.                 ngx_signal_worker_processes(cycle,
  207.                                        ngx_signal_value(NGX_TERMINATE_SIGNAL));
  208.             }

  210.             continue;
  211.         }

  213.         if (ngx_quit) {
  214.             ngx_signal_worker_processes(cycle,
  215.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));

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

  227.             continue;
  228.         }

  230.         if (ngx_reconfigure) {
  231.             ngx_reconfigure = 0;

  233.             if (ngx_new_binary) {
  234.                 ngx_start_worker_processes(cycle, ccf->worker_processes,
  235.                                            NGX_PROCESS_RESPAWN);
  236.                 ngx_start_cache_manager_processes(cycle, 0);
  237.                 ngx_noaccepting = 0;

  239.                 continue;
  240.             }

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

  244.             cycle = ngx_init_cycle(cycle);
  245.             if (cycle == NULL) {
  246.                 cycle = (ngx_cycle_t *) ngx_cycle;
  247.                 continue;
  248.             }

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

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

  260.             live = 1;
  261.             ngx_signal_worker_processes(cycle,
  262.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  263.         }

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

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

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

  287.         if (ngx_noaccept) {
  288.             ngx_noaccept = 0;
  289.             ngx_noaccepting = 1;
  290.             ngx_signal_worker_processes(cycle,
  291.                                         ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
  292.         }
  293.     }
  294. }


  297. void
  298. ‌ngx_single_process_cycle(ngx_cycle_t *cycle)
  299. {
  300.     ngx_uint_t  i;

  302.     if (ngx_set_environment(cycle, NULL) == NULL) {
  303.         /* fatal */
  304.         exit(2);
  305.     }

  307.     for (i = 0; ngx_modules[i]; i++) {
  308.         if (ngx_modules[i]->init_process) {
  309.             if (ngx_modules[i]->init_process(cycle) == NGX_ERROR) {
  310.                 /* fatal */
  311.                 exit(2);
  312.             }
  313.         }
  314.     }

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

  319.         ngx_process_events_and_timers(cycle);

  321.         if (ngx_terminate || ngx_quit) {

  323.             for (i = 0; ngx_modules[i]; i++) {
  324.                 if (ngx_modules[i]->exit_process) {
  325.                     ngx_modules[i]->exit_process(cycle);
  326.                 }
  327.             }

  329.             ngx_master_process_exit(cycle);
  330.         }

  332.         if (ngx_reconfigure) {
  333.             ngx_reconfigure = 0;
  334.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");

  336.             cycle = ngx_init_cycle(cycle);
  337.             if (cycle == NULL) {
  338.                 cycle = (ngx_cycle_t *) ngx_cycle;
  339.                 continue;
  340.             }

  342.             ngx_cycle = cycle;
  343.         }

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


  354. static void
  355. ‌ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n, ngx_int_t type)
  356. {
  357.     ngx_int_t      i;
  358.     ngx_channel_t  ch;

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

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

  364.     ch.command = NGX_CMD_OPEN_CHANNEL;

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

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

  371.         ch.pid = ngx_processes[ngx_process_slot].pid;
  372.         ch.slot = ngx_process_slot;
  373.         ch.fd = ngx_processes[ngx_process_slot].channel[0];

  375.         ngx_pass_open_channel(cycle, &ch);
  376.     }
  377. }


  380. static void
  381. ‌ngx_start_cache_manager_processes(ngx_cycle_t *cycle, ngx_uint_t respawn)
  382. {
  383.     ngx_uint_t       i, manager, loader;
  384.     ngx_path_t     **path;
  385.     ngx_channel_t    ch;

  387.     manager = 0;
  388.     loader = 0;

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

  393.         if (path[i]->manager) {
  394.             manager = 1;
  395.         }

  397.         if (path[i]->loader) {
  398.             loader = 1;
  399.         }
  400.     }

  402.     if (manager == 0) {
  403.         return;
  404.     }

  406.     ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
  407.                       &ngx_cache_manager_ctx, "cache manager process",
  408.                       respawn ? NGX_PROCESS_JUST_RESPAWN : NGX_PROCESS_RESPAWN);

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

  412.     ch.command = NGX_CMD_OPEN_CHANNEL;
  413.     ch.pid = ngx_processes[ngx_process_slot].pid;
  414.     ch.slot = ngx_process_slot;
  415.     ch.fd = ngx_processes[ngx_process_slot].channel[0];

  417.     ngx_pass_open_channel(cycle, &ch);

  419.     if (loader == 0) {
  420.         return;
  421.     }

  423.     ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
  424.                       &ngx_cache_loader_ctx, "cache loader process",
  425.                       respawn ? NGX_PROCESS_JUST_SPAWN : NGX_PROCESS_NORESPAWN);

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

  432.     ngx_pass_open_channel(cycle, &ch);
  433. }


  436. static void
  437. ‌ngx_pass_open_channel(ngx_cycle_t *cycle, ngx_channel_t *ch)
  438. {
  439.     ngx_int_t  i;

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

  443.         if (i == ngx_process_slot
  444.             || ngx_processes[i].pid == -1
  445.             || ngx_processes[i].channel[0] == -1)
  446.         {
  447.             continue;
  448.         }

  450.         ngx_log_debug6(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  451.                       "pass channel s:%d pid:%P fd:%d to s:%i pid:%P fd:%d",
  452.                       ch->slot, ch->pid, ch->fd,
  453.                       i, ngx_processes[i].pid,
  454.                       ngx_processes[i].channel[0]);

  456.         /* TODO: NGX_AGAIN */

  458.         ngx_write_channel(ngx_processes[i].channel[0],
  459.                           ch, sizeof(ngx_channel_t), cycle->log);
  460.     }
  461. }


  464. static void
  465. ‌ngx_signal_worker_processes(ngx_cycle_t *cycle, int signo)
  466. {
  467.     ngx_int_t      i;
  468.     ngx_err_t      err;
  469.     ngx_channel_t  ch;

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

  473. #if (NGX_BROKEN_SCM_RIGHTS)

  475.     ch.command = 0;

  477. #else

  479.     switch (signo) {

  481.     case ngx_signal_value(NGX_SHUTDOWN_SIGNAL):
  482.         ch.command = NGX_CMD_QUIT;
  483.         break;

  485.     case ngx_signal_value(NGX_TERMINATE_SIGNAL):
  486.         ch.command = NGX_CMD_TERMINATE;
  487.         break;

  489.     case ngx_signal_value(NGX_REOPEN_SIGNAL):
  490.         ch.command = NGX_CMD_REOPEN;
  491.         break;

  493.     default:
  494.         ch.command = 0;
  495.     }

  497. #endif

  499.     ch.fd = -1;


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

  504.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  505.                        "child: %d %P e:%d t:%d d:%d r:%d j:%d",
  506.                        i,
  507.                        ngx_processes[i].pid,
  508.                        ngx_processes[i].exiting,
  509.                        ngx_processes[i].exited,
  510.                        ngx_processes[i].detached,
  511.                        ngx_processes[i].respawn,
  512.                        ngx_processes[i].just_spawn);

  514.         if (ngx_processes[i].detached || ngx_processes[i].pid == -1) {
  515.             continue;
  516.         }

  518.         if (ngx_processes[i].just_spawn) {
  519.             ngx_processes[i].just_spawn = 0;
  520.             continue;
  521.         }

  523.         if (ngx_processes[i].exiting
  524.             && signo == ngx_signal_value(NGX_SHUTDOWN_SIGNAL))
  525.         {
  526.             continue;
  527.         }

  529.         if (ch.command) {
  530.             if (ngx_write_channel(ngx_processes[i].channel[0],
  531.                                   &ch, sizeof(ngx_channel_t), cycle->log)
  532.                 == NGX_OK)
  533.             {
  534.                 if (signo != ngx_signal_value(NGX_REOPEN_SIGNAL)) {
  535.                     ngx_processes[i].exiting = 1;
  536.                 }

  538.                 continue;
  539.             }
  540.         }

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

  545.         if (kill(ngx_processes[i].pid, signo) == -1) {
  546.             err = ngx_errno;
  547.             ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  548.                           "kill(%P, %d) failed", ngx_processes[i].pid, signo);

  550.             if (err == NGX_ESRCH) {
  551.                 ngx_processes[i].exited = 1;
  552.                 ngx_processes[i].exiting = 0;
  553.                 ngx_reap = 1;
  554.             }

  556.             continue;
  557.         }

  559.         if (signo != ngx_signal_value(NGX_REOPEN_SIGNAL)) {
  560.             ngx_processes[i].exiting = 1;
  561.         }
  562.     }
  563. }


  566. static ngx_uint_t
  567. ‌ngx_reap_children(ngx_cycle_t *cycle)
  568. {
  569.     ngx_int_t         i, n;
  570.     ngx_uint_t        live;
  571.     ngx_channel_t     ch;
  572.     ngx_core_conf_t  *ccf;

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

  576.     ch.command = NGX_CMD_CLOSE_CHANNEL;
  577.     ch.fd = -1;

  579.     live = 0;
  580.     for (i = 0; i < ngx_last_process; i++) {

  582.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  583.                        "child: %d %P e:%d t:%d d:%d r:%d j:%d",
  584.                        i,
  585.                        ngx_processes[i].pid,
  586.                        ngx_processes[i].exiting,
  587.                        ngx_processes[i].exited,
  588.                        ngx_processes[i].detached,
  589.                        ngx_processes[i].respawn,
  590.                        ngx_processes[i].just_spawn);

  592.         if (ngx_processes[i].pid == -1) {
  593.             continue;
  594.         }

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

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

  601.                 ngx_processes[i].channel[0] = -1;
  602.                 ngx_processes[i].channel[1] = -1;

  604.                 ch.pid = ngx_processes[i].pid;
  605.                 ch.slot = i;

  607.                 for (n = 0; n < ngx_last_process; n++) {
  608.                     if (ngx_processes[n].exited
  609.                         || ngx_processes[n].pid == -1
  610.                         || ngx_processes[n].channel[0] == -1)
  611.                     {
  612.                         continue;
  613.                     }

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

  619.                     /* TODO: NGX_AGAIN */

  621.                     ngx_write_channel(ngx_processes[n].channel[0],
  622.                                       &ch, sizeof(ngx_channel_t), cycle->log);
  623.                 }
  624.             }

  626.             if (ngx_processes[i].respawn
  627.                 && !ngx_processes[i].exiting
  628.                 && !ngx_terminate
  629.                 && !ngx_quit)
  630.             {
  631.                 if (ngx_spawn_process(cycle, ngx_processes[i].proc,
  632.                                       ngx_processes[i].data,
  633.                                       ngx_processes[i].name, i)
  634.                     == NGX_INVALID_PID)
  635.                 {
  636.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  637.                                   "could not respawn %s",
  638.                                   ngx_processes[i].name);
  639.                     continue;
  640.                 }


  643.                 ch.command = NGX_CMD_OPEN_CHANNEL;
  644.                 ch.pid = ngx_processes[ngx_process_slot].pid;
  645.                 ch.slot = ngx_process_slot;
  646.                 ch.fd = ngx_processes[ngx_process_slot].channel[0];

  648.                 ngx_pass_open_channel(cycle, &ch);

  650.                 live = 1;

  652.                 continue;
  653.             }

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

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

  660.                 if (ngx_rename_file((char *) ccf->oldpid.data,
  661.                                     (char *) ccf->pid.data)
  662.                     == NGX_FILE_ERROR)
  663.                 {
  664.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  665.                                   ngx_rename_file_n " %s back to %s failed "
  666.                                   "after the new binary process \"%s\" exited",
  667.                                   ccf->oldpid.data, ccf->pid.data, ngx_argv[0]);
  668.                 }

  670.                 ngx_new_binary = 0;
  671.                 if (ngx_noaccepting) {
  672.                     ngx_restart = 1;
  673.                     ngx_noaccepting = 0;
  674.                 }
  675.             }

  677.             if (i == ngx_last_process - 1) {
  678.                 ngx_last_process--;

  680.             } else {
  681.                 ngx_processes[i].pid = -1;
  682.             }

  684.         } else if (ngx_processes[i].exiting || !ngx_processes[i].detached) {
  685.             live = 1;
  686.         }
  687.     }

  689.     return live;
  690. }


  693. static void
  694. ‌ngx_master_process_exit(ngx_cycle_t *cycle)
  695. {
  696.     ngx_uint_t  i;

  698.     ngx_delete_pidfile(cycle);

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

  702.     for (i = 0; ngx_modules[i]; i++) {
  703.         if (ngx_modules[i]->exit_master) {
  704.             ngx_modules[i]->exit_master(cycle);
  705.         }
  706.     }

  708.     ngx_close_listening_sockets(cycle);

  710.     /*
  711.      * Copy ngx_cycle->log related data to the special static exit cycle,
  712.      * log, and log file structures enough to allow a signal handler to log.
  713.      * The handler may be called when standard ngx_cycle->log allocated from
  714.      * ngx_cycle->pool is already destroyed.
  715.      */


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

  720.     ngx_exit_log_file.fd = ngx_exit_log.file->fd;
  721.     ngx_exit_log.file = &ngx_exit_log_file;
  722.     ngx_exit_log.next = NULL;
  723.     ngx_exit_log.writer = NULL;

  725.     ngx_exit_cycle.log = &ngx_exit_log;
  726.     ngx_exit_cycle.files = ngx_cycle->files;
  727.     ngx_exit_cycle.files_n = ngx_cycle->files_n;
  728.     ngx_cycle = &ngx_exit_cycle;

  730.     ngx_destroy_pool(cycle->pool);

  732.     exit(0);
  733. }


  736. static void
  737. ‌ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
  738. {
  739.     ngx_int_t worker = (intptr_t) data;

  741.     ngx_uint_t         i;
  742.     ngx_connection_t  *c;

  744.     ngx_process = NGX_PROCESS_WORKER;

  746.     ngx_worker_process_init(cycle, worker);

  748.     ngx_setproctitle("worker process");

  750. #if (NGX_THREADS)
  751.     {
  752.     ngx_int_t         n;
  753.     ngx_err_t         err;
  754.     ngx_core_conf_t  *ccf;

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

  758.     if (ngx_threads_n) {
  759.         if (ngx_init_threads(ngx_threads_n, ccf->thread_stack_size, cycle)
  760.             == NGX_ERROR)
  761.         {
  762.             /* fatal */
  763.             exit(2);
  764.         }

  766.         err = ngx_thread_key_create(&ngx_core_tls_key);
  767.         if (err != 0) {
  768.             ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  769.                           ngx_thread_key_create_n " failed");
  770.             /* fatal */
  771.             exit(2);
  772.         }

  774.         for (n = 0; n < ngx_threads_n; n++) {

  776.             ngx_threads[n].cv = ngx_cond_init(cycle->log);

  778.             if (ngx_threads[n].cv == NULL) {
  779.                 /* fatal */
  780.                 exit(2);
  781.             }

  783.             if (ngx_create_thread((ngx_tid_t *) &ngx_threads[n].tid,
  784.                                   ngx_worker_thread_cycle,
  785.                                   (void *) &ngx_threads[n], cycle->log)
  786.                 != 0)
  787.             {
  788.                 /* fatal */
  789.                 exit(2);
  790.             }
  791.         }
  792.     }
  793.     }
  794. #endif

  796.     for ( ;; ) {

  798.         if (ngx_exiting) {

  800.             c = cycle->connections;

  802.             for (i = 0; i < cycle->connection_n; i++) {

  804.                 /* THREAD: lock */

  806.                 if (c[i].fd != -1 && c[i].idle) {
  807.                     c[i].close = 1;
  808.                     c[i].read->handler(c[i].read);
  809.                 }
  810.             }

  812.             ngx_event_cancel_timers();

  814.             if (ngx_event_timer_rbtree.root == ngx_event_timer_rbtree.sentinel)
  815.             {
  816.                 ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");

  818.                 ngx_worker_process_exit(cycle);
  819.             }
  820.         }

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

  824.         ngx_process_events_and_timers(cycle);

  826.         if (ngx_terminate) {
  827.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");

  829.             ngx_worker_process_exit(cycle);
  830.         }

  832.         if (ngx_quit) {
  833.             ngx_quit = 0;
  834.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
  835.                           "gracefully shutting down");
  836.             ngx_setproctitle("worker process is shutting down");

  838.             if (!ngx_exiting) {
  839.                 ngx_close_listening_sockets(cycle);
  840.                 ngx_exiting = 1;
  841.             }
  842.         }

  844.         if (ngx_reopen) {
  845.             ngx_reopen = 0;
  846.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
  847.             ngx_reopen_files(cycle, -1);
  848.         }
  849.     }
  850. }


  853. static void
  854. ‌ngx_worker_process_init(ngx_cycle_t *cycle, ngx_int_t worker)
  855. {
  856.     sigset_t          set;
  857.     uint64_t          cpu_affinity;
  858.     ngx_int_t         n;
  859.     ngx_uint_t        i;
  860.     struct rlimit     rlmt;
  861.     ngx_core_conf_t  *ccf;
  862.     ngx_listening_t  *ls;

  864.     if (ngx_set_environment(cycle, NULL) == NULL) {
  865.         /* fatal */
  866.         exit(2);
  867.     }

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

  871.     if (worker >= 0 && ccf->priority != 0) {
  872.         if (setpriority(PRIO_PROCESS, 0, ccf->priority) == -1) {
  873.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  874.                           "setpriority(%d) failed", ccf->priority);
  875.         }
  876.     }

  878.     if (ccf->rlimit_nofile != NGX_CONF_UNSET) {
  879.         rlmt.rlim_cur = (rlim_t) ccf->rlimit_nofile;
  880.         rlmt.rlim_max = (rlim_t) ccf->rlimit_nofile;

  882.         if (setrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  883.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  884.                           "setrlimit(RLIMIT_NOFILE, %i) failed",
  885.                           ccf->rlimit_nofile);
  886.         }
  887.     }

  889.     if (ccf->rlimit_core != NGX_CONF_UNSET) {
  890.         rlmt.rlim_cur = (rlim_t) ccf->rlimit_core;
  891.         rlmt.rlim_max = (rlim_t) ccf->rlimit_core;

  893.         if (setrlimit(RLIMIT_CORE, &rlmt) == -1) {
  894.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  895.                           "setrlimit(RLIMIT_CORE, %O) failed",
  896.                           ccf->rlimit_core);
  897.         }
  898.     }

  900. #ifdef RLIMIT_SIGPENDING
  901.     if (ccf->rlimit_sigpending != NGX_CONF_UNSET) {
  902.         rlmt.rlim_cur = (rlim_t) ccf->rlimit_sigpending;
  903.         rlmt.rlim_max = (rlim_t) ccf->rlimit_sigpending;

  905.         if (setrlimit(RLIMIT_SIGPENDING, &rlmt) == -1) {
  906.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  907.                           "setrlimit(RLIMIT_SIGPENDING, %i) failed",
  908.                           ccf->rlimit_sigpending);
  909.         }
  910.     }
  911. #endif

  913.     if (geteuid() == 0) {
  914.         if (setgid(ccf->group) == -1) {
  915.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  916.                           "setgid(%d) failed", ccf->group);
  917.             /* fatal */
  918.             exit(2);
  919.         }

  921.         if (initgroups(ccf->username, ccf->group) == -1) {
  922.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  923.                           "initgroups(%s, %d) failed",
  924.                           ccf->username, ccf->group);
  925.         }

  927.         if (setuid(ccf->user) == -1) {
  928.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  929.                           "setuid(%d) failed", ccf->user);
  930.             /* fatal */
  931.             exit(2);
  932.         }
  933.     }

  935.     if (worker >= 0) {
  936.         cpu_affinity = ngx_get_cpu_affinity(worker);

  938.         if (cpu_affinity) {
  939.             ngx_setaffinity(cpu_affinity, cycle->log);
  940.         }
  941.     }

  943. #if (NGX_HAVE_PR_SET_DUMPABLE)

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

  947.     if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1) {
  948.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  949.                       "prctl(PR_SET_DUMPABLE) failed");
  950.     }

  952. #endif

  954.     if (ccf->working_directory.len) {
  955.         if (chdir((char *) ccf->working_directory.data) == -1) {
  956.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  957.                           "chdir(\"%s\") failed", ccf->working_directory.data);
  958.             /* fatal */
  959.             exit(2);
  960.         }
  961.     }

  963.     sigemptyset(&set);

  965.     if (sigprocmask(SIG_SETMASK, &set, NULL) == -1) {
  966.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  967.                       "sigprocmask() failed");
  968.     }

  970.     srandom((ngx_pid << 16) ^ ngx_time());

  972.     /*
  973.      * disable deleting previous events for the listening sockets because
  974.      * in the worker processes there are no events at all at this point
  975.      */
  976.     ls = cycle->listening.elts;
  977.     for (i = 0; i < cycle->listening.nelts; i++) {
  978.         ls[i].previous = NULL;
  979.     }

  981.     for (i = 0; ngx_modules[i]; i++) {
  982.         if (ngx_modules[i]->init_process) {
  983.             if (ngx_modules[i]->init_process(cycle) == NGX_ERROR) {
  984.                 /* fatal */
  985.                 exit(2);
  986.             }
  987.         }
  988.     }

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

  992.         if (ngx_processes[n].pid == -1) {
  993.             continue;
  994.         }

  996.         if (n == ngx_process_slot) {
  997.             continue;
  998.         }

  1000.         if (ngx_processes[n].channel[1] == -1) {
  1001.             continue;
  1002.         }

  1004.         if (close(ngx_processes[n].channel[1]) == -1) {
  1005.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  1006.                           "close() channel failed");
  1007.         }
  1008.     }

  1010.     if (close(ngx_processes[ngx_process_slot].channel[0]) == -1) {
  1011.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  1012.                       "close() channel failed");
  1013.     }

  1015. #if 0
  1016.     ngx_last_process = 0;
  1017. #endif

  1019.     if (ngx_add_channel_event(cycle, ngx_channel, NGX_READ_EVENT,
  1020.                               ngx_channel_handler)
  1021.         == NGX_ERROR)
  1022.     {
  1023.         /* fatal */
  1024.         exit(2);
  1025.     }
  1026. }


  1029. static void
  1030. ‌ngx_worker_process_exit(ngx_cycle_t *cycle)
  1031. {
  1032.     ngx_uint_t         i;
  1033.     ngx_connection_t  *c;

  1035. #if (NGX_THREADS)
  1036.     ngx_terminate = 1;

  1038.     ngx_wakeup_worker_threads(cycle);
  1039. #endif

  1041.     for (i = 0; ngx_modules[i]; i++) {
  1042.         if (ngx_modules[i]->exit_process) {
  1043.             ngx_modules[i]->exit_process(cycle);
  1044.         }
  1045.     }

  1047.     if (ngx_exiting) {
  1048.         c = cycle->connections;
  1049.         for (i = 0; i < cycle->connection_n; i++) {
  1050.             if (c[i].fd != -1
  1051.                 && c[i].read
  1052.                 && !c[i].read->accept
  1053.                 && !c[i].read->channel
  1054.                 && !c[i].read->resolver)
  1055.             {
  1056.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  1057.                               "*%uA open socket #%d left in connection %ui",
  1058.                               c[i].number, c[i].fd, i);
  1059.                 ngx_debug_quit = 1;
  1060.             }
  1061.         }

  1063.         if (ngx_debug_quit) {
  1064.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "aborting");
  1065.             ngx_debug_point();
  1066.         }
  1067.     }

  1069.     /*
  1070.      * Copy ngx_cycle->log related data to the special static exit cycle,
  1071.      * log, and log file structures enough to allow a signal handler to log.
  1072.      * The handler may be called when standard ngx_cycle->log allocated from
  1073.      * ngx_cycle->pool is already destroyed.
  1074.      */

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

  1078.     ngx_exit_log_file.fd = ngx_exit_log.file->fd;
  1079.     ngx_exit_log.file = &ngx_exit_log_file;
  1080.     ngx_exit_log.next = NULL;
  1081.     ngx_exit_log.writer = NULL;

  1083.     ngx_exit_cycle.log = &ngx_exit_log;
  1084.     ngx_exit_cycle.files = ngx_cycle->files;
  1085.     ngx_exit_cycle.files_n = ngx_cycle->files_n;
  1086.     ngx_cycle = &ngx_exit_cycle;

  1088.     ngx_destroy_pool(cycle->pool);

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

  1092.     exit(0);
  1093. }


  1096. static void
  1097. ‌ngx_channel_handler(ngx_event_t *ev)
  1098. {
  1099.     ngx_int_t          n;
  1100.     ngx_channel_t      ch;
  1101.     ngx_connection_t  *c;

  1103.     if (ev->timedout) {
  1104.         ev->timedout = 0;
  1105.         return;
  1106.     }

  1108.     c = ev->data;

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

  1112.     for ( ;; ) {

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

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

  1118.         if (n == NGX_ERROR) {

  1120.             if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {
  1121.                 ngx_del_conn(c, 0);
  1122.             }

  1124.             ngx_close_connection(c);
  1125.             return;
  1126.         }

  1128.         if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {
  1129.             if (ngx_add_event(ev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  1130.                 return;
  1131.             }
  1132.         }

  1134.         if (n == NGX_AGAIN) {
  1135.             return;
  1136.         }

  1138.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,
  1139.                        "channel command: %d", ch.command);

  1141.         switch (ch.command) {

  1143.         case NGX_CMD_QUIT:
  1144.             ngx_quit = 1;
  1145.             break;

  1147.         case NGX_CMD_TERMINATE:
  1148.             ngx_terminate = 1;
  1149.             break;

  1151.         case NGX_CMD_REOPEN:
  1152.             ngx_reopen = 1;
  1153.             break;

  1155.         case NGX_CMD_OPEN_CHANNEL:

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

  1161.             ngx_processes[ch.slot].pid = ch.pid;
  1162.             ngx_processes[ch.slot].channel[0] = ch.fd;
  1163.             break;

  1165.         case NGX_CMD_CLOSE_CHANNEL:

  1167.             ngx_log_debug4(NGX_LOG_DEBUG_CORE, ev->log, 0,
  1168.                            "close channel s:%i pid:%P our:%P fd:%d",
  1169.                            ch.slot, ch.pid, ngx_processes[ch.slot].pid,
  1170.                            ngx_processes[ch.slot].channel[0]);

  1172.             if (close(ngx_processes[ch.slot].channel[0]) == -1) {
  1173.                 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  1174.                               "close() channel failed");
  1175.             }

  1177.             ngx_processes[ch.slot].channel[0] = -1;
  1178.             break;
  1179.         }
  1180.     }
  1181. }


  1184. #if (NGX_THREADS)

  1186. static void
  1187. ‌ngx_wakeup_worker_threads(ngx_cycle_t *cycle)
  1188. {
  1189.     ngx_int_t   i;
  1190.     ngx_uint_t  live;

  1192.     for ( ;; ) {

  1194.         live = 0;

  1196.         for (i = 0; i < ngx_threads_n; i++) {
  1197.             if (ngx_threads[i].state < NGX_THREAD_EXIT) {
  1198.                 if (ngx_cond_signal(ngx_threads[i].cv) == NGX_ERROR) {
  1199.                     ngx_threads[i].state = NGX_THREAD_DONE;

  1201.                 } else {
  1202.                     live = 1;
  1203.                 }
  1204.             }

  1206.             if (ngx_threads[i].state == NGX_THREAD_EXIT) {
  1207.                 ngx_thread_join(ngx_threads[i].tid, NULL);
  1208.                 ngx_threads[i].state = NGX_THREAD_DONE;
  1209.             }
  1210.         }

  1212.         if (live == 0) {
  1213.             ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  1214.                            "all worker threads are joined");

  1216.             /* STUB */
  1217.             ngx_done_events(cycle);

  1219.             return;
  1220.         }

  1222.         ngx_sched_yield();
  1223.     }
  1224. }


  1227. static ngx_thread_value_t
  1228. ‌ngx_worker_thread_cycle(void *data)
  1229. {
  1230.     ngx_thread_t  *thr = data;

  1232.     sigset_t          set;
  1233.     ngx_err_t         err;
  1234.     ngx_core_tls_t   *tls;
  1235.     ngx_cycle_t      *cycle;

  1237.     cycle = (ngx_cycle_t *) ngx_cycle;

  1239.     sigemptyset(&set);
  1240.     sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
  1241.     sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
  1242.     sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));

  1244.     err = ngx_thread_sigmask(SIG_BLOCK, &set, NULL);
  1245.     if (err) {
  1246.         ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  1247.                       ngx_thread_sigmask_n " failed");
  1248.         return (ngx_thread_value_t) 1;
  1249.     }

  1251.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  1252.                    "thread " NGX_TID_T_FMT " started", ngx_thread_self());

  1254.     ngx_setthrtitle("worker thread");

  1256.     tls = ngx_calloc(sizeof(ngx_core_tls_t), cycle->log);
  1257.     if (tls == NULL) {
  1258.         return (ngx_thread_value_t) 1;
  1259.     }

  1261.     err = ngx_thread_set_tls(ngx_core_tls_key, tls);
  1262.     if (err != 0) {
  1263.         ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  1264.                       ngx_thread_set_tls_n " failed");
  1265.         return (ngx_thread_value_t) 1;
  1266.     }

  1268.     for ( ;; ) {
  1269.         thr->state = NGX_THREAD_FREE;

  1271. #if 0
  1272.         if (ngx_cond_wait(thr->cv, ngx_posted_events_mutex) == NGX_ERROR) {
  1273.             return (ngx_thread_value_t) 1;
  1274.         }
  1275. #endif

  1277.         if (ngx_terminate) {
  1278.             thr->state = NGX_THREAD_EXIT;

  1280.             ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
  1281.                            "thread " NGX_TID_T_FMT " is done",
  1282.                            ngx_thread_self());

  1284.             return (ngx_thread_value_t) 0;
  1285.         }

  1287.         thr->state = NGX_THREAD_BUSY;

  1289. #if 0
  1290.         if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
  1291.             return (ngx_thread_value_t) 1;
  1292.         }

  1294.         if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
  1295.             return (ngx_thread_value_t) 1;
  1296.         }
  1297. #endif

  1299.         if (ngx_process_changes) {
  1300.             if (ngx_process_changes(cycle, 1) == NGX_ERROR) {
  1301.                 return (ngx_thread_value_t) 1;
  1302.             }
  1303.         }
  1304.     }
  1305. }

  1307. #endif


  1310. static void
  1311. ‌ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data)
  1312. {
  1313.     ngx_cache_manager_ctx_t *ctx = data;

  1315.     void         *ident[4];
  1316.     ngx_event_t   ev;

  1318.     /*
  1319.      * Set correct process type since closing listening Unix domain socket
  1320.      * in a master process also removes the Unix domain socket file.
  1321.      */
  1322.     ngx_process = NGX_PROCESS_HELPER;

  1324.     ngx_close_listening_sockets(cycle);

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

  1329.     ngx_worker_process_init(cycle, -1);

  1331.     ngx_memzero(&ev, sizeof(ngx_event_t));
  1332.     ev.handler = ctx->handler;
  1333.     ev.data = ident;
  1334.     ev.log = cycle->log;
  1335.     ident[3] = (void *) -1;

  1337.     ngx_use_accept_mutex = 0;

  1339.     ngx_setproctitle(ctx->name);

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

  1343.     for ( ;; ) {

  1345.         if (ngx_terminate || ngx_quit) {
  1346.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
  1347.             exit(0);
  1348.         }

  1350.         if (ngx_reopen) {
  1351.             ngx_reopen = 0;
  1352.             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
  1353.             ngx_reopen_files(cycle, -1);
  1354.         }

  1356.         ngx_process_events_and_timers(cycle);
  1357.     }
  1358. }


  1361. static void
  1362. ‌ngx_cache_manager_process_handler(ngx_event_t *ev)
  1363. {
  1364.     time_t        next, n;
  1365.     ngx_uint_t    i;
  1366.     ngx_path_t  **path;

  1368.     next = 60 * 60;

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

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

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

  1378.             ngx_time_update();
  1379.         }
  1380.     }

  1382.     if (next == 0) {
  1383.         next = 1;
  1384.     }

  1386.     ngx_add_timer(ev, next * 1000);
  1387. }


  1390. static void
  1391. ‌ngx_cache_loader_process_handler(ngx_event_t *ev)
  1392. {
  1393.     ngx_uint_t     i;
  1394.     ngx_path_t   **path;
  1395.     ngx_cycle_t   *cycle;

  1397.     cycle = (ngx_cycle_t *) ngx_cycle;

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

  1402.         if (ngx_terminate || ngx_quit) {
  1403.             break;
  1404.         }

  1406.         if (path[i]->loader) {
  1407.             path[i]->loader(path[i]->data);
  1408.             ngx_time_update();
  1409.         }
  1410.     }

  1412.     exit(0);
  1413. }

One Level Up Top Level