1e18a033bSKonstantin Ananyev
2e18a033bSKonstantin Ananyev/*
3e18a033bSKonstantin Ananyev * Copyright (C) Igor Sysoev
4e18a033bSKonstantin Ananyev * Copyright (C) Nginx, Inc.
5e18a033bSKonstantin Ananyev */
6e18a033bSKonstantin Ananyev
7e18a033bSKonstantin Ananyev
8e18a033bSKonstantin Ananyev#include <ngx_config.h>
9e18a033bSKonstantin Ananyev#include <ngx_core.h>
10e18a033bSKonstantin Ananyev#include <ngx_event.h>
11e18a033bSKonstantin Ananyev#include <ngx_channel.h>
12e18a033bSKonstantin Ananyev
13e18a033bSKonstantin Ananyev
14e18a033bSKonstantin Ananyevstatic void ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n,
15e18a033bSKonstantin Ananyev    ngx_int_t type);
16e18a033bSKonstantin Ananyevstatic void ngx_start_cache_manager_processes(ngx_cycle_t *cycle,
17e18a033bSKonstantin Ananyev    ngx_uint_t respawn);
18e18a033bSKonstantin Ananyevstatic void ngx_pass_open_channel(ngx_cycle_t *cycle, ngx_channel_t *ch);
19e18a033bSKonstantin Ananyevstatic void ngx_signal_worker_processes(ngx_cycle_t *cycle, int signo);
20e18a033bSKonstantin Ananyevstatic ngx_uint_t ngx_reap_children(ngx_cycle_t *cycle);
21e18a033bSKonstantin Ananyevstatic void ngx_master_process_exit(ngx_cycle_t *cycle);
22e18a033bSKonstantin Ananyevstatic void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data);
23e18a033bSKonstantin Ananyevstatic void ngx_worker_process_init(ngx_cycle_t *cycle, ngx_int_t worker);
24e18a033bSKonstantin Ananyevstatic void ngx_worker_process_exit(ngx_cycle_t *cycle);
25e18a033bSKonstantin Ananyevstatic void ngx_channel_handler(ngx_event_t *ev);
26e18a033bSKonstantin Ananyevstatic void ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data);
27e18a033bSKonstantin Ananyevstatic void ngx_cache_manager_process_handler(ngx_event_t *ev);
28e18a033bSKonstantin Ananyevstatic void ngx_cache_loader_process_handler(ngx_event_t *ev);
29e18a033bSKonstantin Ananyev
30e18a033bSKonstantin Ananyev
31e18a033bSKonstantin Ananyevngx_uint_t    ngx_process;
32e18a033bSKonstantin Ananyevngx_uint_t    ngx_worker;
33e18a033bSKonstantin Ananyevngx_pid_t     ngx_pid;
34e18a033bSKonstantin Ananyev
35e18a033bSKonstantin Ananyevsig_atomic_t  ngx_reap;
36e18a033bSKonstantin Ananyevsig_atomic_t  ngx_sigio;
37e18a033bSKonstantin Ananyevsig_atomic_t  ngx_sigalrm;
38e18a033bSKonstantin Ananyevsig_atomic_t  ngx_terminate;
39e18a033bSKonstantin Ananyevsig_atomic_t  ngx_quit;
40e18a033bSKonstantin Ananyevsig_atomic_t  ngx_debug_quit;
41e18a033bSKonstantin Ananyevngx_uint_t    ngx_exiting;
42e18a033bSKonstantin Ananyevsig_atomic_t  ngx_reconfigure;
43e18a033bSKonstantin Ananyevsig_atomic_t  ngx_reopen;
44e18a033bSKonstantin Ananyev
45e18a033bSKonstantin Ananyevsig_atomic_t  ngx_change_binary;
46e18a033bSKonstantin Ananyevngx_pid_t     ngx_new_binary;
47e18a033bSKonstantin Ananyevngx_uint_t    ngx_inherited;
48e18a033bSKonstantin Ananyevngx_uint_t    ngx_daemonized;
49e18a033bSKonstantin Ananyev
50e18a033bSKonstantin Ananyevsig_atomic_t  ngx_noaccept;
51e18a033bSKonstantin Ananyevngx_uint_t    ngx_noaccepting;
52e18a033bSKonstantin Ananyevngx_uint_t    ngx_restart;
53e18a033bSKonstantin Ananyev
54e18a033bSKonstantin Ananyev
55e18a033bSKonstantin Ananyevstatic u_char  master_process[] = "master process";
56e18a033bSKonstantin Ananyev
57e18a033bSKonstantin Ananyev
58e18a033bSKonstantin Ananyevstatic ngx_cache_manager_ctx_t  ngx_cache_manager_ctx = {
59e18a033bSKonstantin Ananyev    ngx_cache_manager_process_handler, "cache manager process", 0
60e18a033bSKonstantin Ananyev};
61e18a033bSKonstantin Ananyev
62e18a033bSKonstantin Ananyevstatic ngx_cache_manager_ctx_t  ngx_cache_loader_ctx = {
63e18a033bSKonstantin Ananyev    ngx_cache_loader_process_handler, "cache loader process", 60000
64e18a033bSKonstantin Ananyev};
65e18a033bSKonstantin Ananyev
66e18a033bSKonstantin Ananyev
67e18a033bSKonstantin Ananyevstatic ngx_cycle_t      ngx_exit_cycle;
68e18a033bSKonstantin Ananyevstatic ngx_log_t        ngx_exit_log;
69e18a033bSKonstantin Ananyevstatic ngx_open_file_t  ngx_exit_log_file;
70e18a033bSKonstantin Ananyev
71e18a033bSKonstantin Ananyev
72e18a033bSKonstantin Ananyevvoid
73e18a033bSKonstantin Ananyevngx_master_process_cycle(ngx_cycle_t *cycle)
74e18a033bSKonstantin Ananyev{
75e18a033bSKonstantin Ananyev    char              *title;
76e18a033bSKonstantin Ananyev    u_char            *p;
77e18a033bSKonstantin Ananyev    size_t             size;
78e18a033bSKonstantin Ananyev    ngx_int_t          i;
79e18a033bSKonstantin Ananyev    ngx_uint_t         n, sigio;
80e18a033bSKonstantin Ananyev    sigset_t           set;
81e18a033bSKonstantin Ananyev    struct itimerval   itv;
82e18a033bSKonstantin Ananyev    ngx_uint_t         live;
83e18a033bSKonstantin Ananyev    ngx_msec_t         delay;
84e18a033bSKonstantin Ananyev    ngx_listening_t   *ls;
85e18a033bSKonstantin Ananyev    ngx_core_conf_t   *ccf;
86e18a033bSKonstantin Ananyev
87e18a033bSKonstantin Ananyev    sigemptyset(&set);
88e18a033bSKonstantin Ananyev    sigaddset(&set, SIGCHLD);
89e18a033bSKonstantin Ananyev    sigaddset(&set, SIGALRM);
90e18a033bSKonstantin Ananyev    sigaddset(&set, SIGIO);
91e18a033bSKonstantin Ananyev    sigaddset(&set, SIGINT);
92e18a033bSKonstantin Ananyev    sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
93e18a033bSKonstantin Ananyev    sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
94e18a033bSKonstantin Ananyev    sigaddset(&set, ngx_signal_value(NGX_NOACCEPT_SIGNAL));
95e18a033bSKonstantin Ananyev    sigaddset(&set, ngx_signal_value(NGX_TERMINATE_SIGNAL));
96e18a033bSKonstantin Ananyev    sigaddset(&set, ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
97e18a033bSKonstantin Ananyev    sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));
98e18a033bSKonstantin Ananyev
99e18a033bSKonstantin Ananyev    if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
100e18a033bSKonstantin Ananyev        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
101e18a033bSKonstantin Ananyev                      "sigprocmask() failed");
102e18a033bSKonstantin Ananyev    }
103e18a033bSKonstantin Ananyev
104e18a033bSKonstantin Ananyev    sigemptyset(&set);
105e18a033bSKonstantin Ananyev
106e18a033bSKonstantin Ananyev
107e18a033bSKonstantin Ananyev    size = sizeof(master_process);
108e18a033bSKonstantin Ananyev
109e18a033bSKonstantin Ananyev    for (i = 0; i < ngx_argc; i++) {
110e18a033bSKonstantin Ananyev        size += ngx_strlen(ngx_argv[i]) + 1;
111e18a033bSKonstantin Ananyev    }
112e18a033bSKonstantin Ananyev
113e18a033bSKonstantin Ananyev    title = ngx_pnalloc(cycle->pool, size);
114e18a033bSKonstantin Ananyev    if (title == NULL) {
115e18a033bSKonstantin Ananyev        /* fatal */
116e18a033bSKonstantin Ananyev        exit(2);
117e18a033bSKonstantin Ananyev    }
118e18a033bSKonstantin Ananyev
119e18a033bSKonstantin Ananyev    p = ngx_cpymem(title, master_process, sizeof(master_process) - 1);
120e18a033bSKonstantin Ananyev    for (i = 0; i < ngx_argc; i++) {
121e18a033bSKonstantin Ananyev        *p++ = ' ';
122e18a033bSKonstantin Ananyev        p = ngx_cpystrn(p, (u_char *) ngx_argv[i], size);
123e18a033bSKonstantin Ananyev    }
124e18a033bSKonstantin Ananyev
125e18a033bSKonstantin Ananyev    ngx_setproctitle(title);
126e18a033bSKonstantin Ananyev
127e18a033bSKonstantin Ananyev
128e18a033bSKonstantin Ananyev    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
129e18a033bSKonstantin Ananyev
130e18a033bSKonstantin Ananyev    ngx_start_worker_processes(cycle, ccf->worker_processes,
131e18a033bSKonstantin Ananyev                               NGX_PROCESS_RESPAWN);
132e18a033bSKonstantin Ananyev    ngx_start_cache_manager_processes(cycle, 0);
133e18a033bSKonstantin Ananyev
134e18a033bSKonstantin Ananyev    ngx_new_binary = 0;
135e18a033bSKonstantin Ananyev    delay = 0;
136e18a033bSKonstantin Ananyev    sigio = 0;
137e18a033bSKonstantin Ananyev    live = 1;
138e18a033bSKonstantin Ananyev
139e18a033bSKonstantin Ananyev    for ( ;; ) {
140e18a033bSKonstantin Ananyev        if (delay) {
141e18a033bSKonstantin Ananyev            if (ngx_sigalrm) {
142e18a033bSKonstantin Ananyev                sigio = 0;
143e18a033bSKonstantin Ananyev                delay *= 2;
144e18a033bSKonstantin Ananyev                ngx_sigalrm = 0;
145e18a033bSKonstantin Ananyev            }
146e18a033bSKonstantin Ananyev
147e18a033bSKonstantin Ananyev            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
148e18a033bSKonstantin Ananyev                           "termination cycle: %M", delay);
149e18a033bSKonstantin Ananyev
150e18a033bSKonstantin Ananyev            itv.it_interval.tv_sec = 0;
151e18a033bSKonstantin Ananyev            itv.it_interval.tv_usec = 0;
152e18a033bSKonstantin Ananyev            itv.it_value.tv_sec = delay / 1000;
153e18a033bSKonstantin Ananyev            itv.it_value.tv_usec = (delay % 1000 ) * 1000;
154e18a033bSKonstantin Ananyev
155e18a033bSKonstantin Ananyev            if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
156e18a033bSKonstantin Ananyev                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
157e18a033bSKonstantin Ananyev                              "setitimer() failed");
158e18a033bSKonstantin Ananyev            }
159e18a033bSKonstantin Ananyev        }
160e18a033bSKonstantin Ananyev
161e18a033bSKonstantin Ananyev        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "sigsuspend");
162e18a033bSKonstantin Ananyev
163e18a033bSKonstantin Ananyev        sigsuspend(&set);
164e18a033bSKonstantin Ananyev
165e18a033bSKonstantin Ananyev        ngx_time_update();
166e18a033bSKonstantin Ananyev
167e18a033bSKonstantin Ananyev        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
168e18a033bSKonstantin Ananyev                       "wake up, sigio %i", sigio);
169e18a033bSKonstantin Ananyev
170e18a033bSKonstantin Ananyev        if (ngx_reap) {
171e18a033bSKonstantin Ananyev            ngx_reap = 0;
172e18a033bSKonstantin Ananyev            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children");
173e18a033bSKonstantin Ananyev
174e18a033bSKonstantin Ananyev            live = ngx_reap_children(cycle);
175e18a033bSKonstantin Ananyev        }
176e18a033bSKonstantin Ananyev
177e18a033bSKonstantin Ananyev        if (!live && (ngx_terminate || ngx_quit)) {
178e18a033bSKonstantin Ananyev            ngx_master_process_exit(cycle);
179e18a033bSKonstantin Ananyev        }
180e18a033bSKonstantin Ananyev
181e18a033bSKonstantin Ananyev        if (ngx_terminate) {
182e18a033bSKonstantin Ananyev            if (delay == 0) {
183e18a033bSKonstantin Ananyev                delay = 50;
184e18a033bSKonstantin Ananyev            }
185e18a033bSKonstantin Ananyev
186e18a033bSKonstantin Ananyev            if (sigio) {
187e18a033bSKonstantin Ananyev                sigio--;
188e18a033bSKonstantin Ananyev                continue;
189e18a033bSKonstantin Ananyev            }
190e18a033bSKonstantin Ananyev
191e18a033bSKonstantin Ananyev            sigio = ccf->worker_processes + 2 /* cache processes */;
192e18a033bSKonstantin Ananyev
193e18a033bSKonstantin Ananyev            if (delay > 1000) {
194e18a033bSKonstantin Ananyev                ngx_signal_worker_processes(cycle, SIGKILL);
195e18a033bSKonstantin Ananyev            } else {
196e18a033bSKonstantin Ananyev                ngx_signal_worker_processes(cycle,
197e18a033bSKonstantin Ananyev                                       ngx_signal_value(NGX_TERMINATE_SIGNAL));
198e18a033bSKonstantin Ananyev            }
199e18a033bSKonstantin Ananyev
200e18a033bSKonstantin Ananyev            continue;
201e18a033bSKonstantin Ananyev        }
202e18a033bSKonstantin Ananyev
203e18a033bSKonstantin Ananyev        if (ngx_quit) {
204e18a033bSKonstantin Ananyev            ngx_signal_worker_processes(cycle,
205e18a033bSKonstantin Ananyev                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
206e18a033bSKonstantin Ananyev
207e18a033bSKonstantin Ananyev            ls = cycle->listening.elts;
208e18a033bSKonstantin Ananyev            for (n = 0; n < cycle->listening.nelts; n++) {
209e18a033bSKonstantin Ananyev                if (ngx_close_socket(ls[n].fd) == -1) {
210e18a033bSKonstantin Ananyev                    ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
211e18a033bSKonstantin Ananyev                                  ngx_close_socket_n " %V failed",
212e18a033bSKonstantin Ananyev                                  &ls[n].addr_text);
213e18a033bSKonstantin Ananyev                }
214e18a033bSKonstantin Ananyev            }
215e18a033bSKonstantin Ananyev            cycle->listening.nelts = 0;
216e18a033bSKonstantin Ananyev
217e18a033bSKonstantin Ananyev            continue;
218e18a033bSKonstantin Ananyev        }
219e18a033bSKonstantin Ananyev
220e18a033bSKonstantin Ananyev        if (ngx_reconfigure) {
221e18a033bSKonstantin Ananyev            ngx_reconfigure = 0;
222e18a033bSKonstantin Ananyev
223e18a033bSKonstantin Ananyev            if (ngx_new_binary) {
224e18a033bSKonstantin Ananyev                ngx_start_worker_processes(cycle, ccf->worker_processes,
225e18a033bSKonstantin Ananyev                                           NGX_PROCESS_RESPAWN);
226e18a033bSKonstantin Ananyev                ngx_start_cache_manager_processes(cycle, 0);
227e18a033bSKonstantin Ananyev                ngx_noaccepting = 0;
228e18a033bSKonstantin Ananyev
229e18a033bSKonstantin Ananyev                continue;
230e18a033bSKonstantin Ananyev            }
231e18a033bSKonstantin Ananyev
232e18a033bSKonstantin Ananyev            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");
233e18a033bSKonstantin Ananyev
234e18a033bSKonstantin Ananyev            cycle = ngx_init_cycle(cycle);
235e18a033bSKonstantin Ananyev            if (cycle == NULL) {
236e18a033bSKonstantin Ananyev                cycle = (ngx_cycle_t *) ngx_cycle;
237e18a033bSKonstantin Ananyev                continue;
238e18a033bSKonstantin Ananyev            }
239e18a033bSKonstantin Ananyev
240e18a033bSKonstantin Ananyev            ngx_cycle = cycle;
241e18a033bSKonstantin Ananyev            ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx,
242e18a033bSKonstantin Ananyev                                                   ngx_core_module);
243e18a033bSKonstantin Ananyev            ngx_start_worker_processes(cycle, ccf->worker_processes,
244e18a033bSKonstantin Ananyev                                       NGX_PROCESS_JUST_RESPAWN);
245e18a033bSKonstantin Ananyev            ngx_start_cache_manager_processes(cycle, 1);
246e18a033bSKonstantin Ananyev
247e18a033bSKonstantin Ananyev            /* allow new processes to start */
248e18a033bSKonstantin Ananyev            ngx_msleep(100);
249e18a033bSKonstantin Ananyev
250e18a033bSKonstantin Ananyev            live = 1;
251e18a033bSKonstantin Ananyev            ngx_signal_worker_processes(cycle,
252e18a033bSKonstantin Ananyev                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
253e18a033bSKonstantin Ananyev        }
254e18a033bSKonstantin Ananyev
255e18a033bSKonstantin Ananyev        if (ngx_restart) {
256e18a033bSKonstantin Ananyev            ngx_restart = 0;
257e18a033bSKonstantin Ananyev            ngx_start_worker_processes(cycle, ccf->worker_processes,
258e18a033bSKonstantin Ananyev                                       NGX_PROCESS_RESPAWN);
259e18a033bSKonstantin Ananyev            ngx_start_cache_manager_processes(cycle, 0);
260e18a033bSKonstantin Ananyev            live = 1;
261e18a033bSKonstantin Ananyev        }
262e18a033bSKonstantin Ananyev
263e18a033bSKonstantin Ananyev        if (ngx_reopen) {
264e18a033bSKonstantin Ananyev            ngx_reopen = 0;
265e18a033bSKonstantin Ananyev            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
266e18a033bSKonstantin Ananyev            ngx_reopen_files(cycle, ccf->user);
267e18a033bSKonstantin Ananyev            ngx_signal_worker_processes(cycle,
268e18a033bSKonstantin Ananyev                                        ngx_signal_value(NGX_REOPEN_SIGNAL));
269e18a033bSKonstantin Ananyev        }
270e18a033bSKonstantin Ananyev
271e18a033bSKonstantin Ananyev        if (ngx_change_binary) {
272e18a033bSKonstantin Ananyev            ngx_change_binary = 0;
273e18a033bSKonstantin Ananyev            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "changing binary");
274e18a033bSKonstantin Ananyev            ngx_new_binary = ngx_exec_new_binary(cycle, ngx_argv);
275e18a033bSKonstantin Ananyev        }
276e18a033bSKonstantin Ananyev
277e18a033bSKonstantin Ananyev        if (ngx_noaccept) {
278e18a033bSKonstantin Ananyev            ngx_noaccept = 0;
279e18a033bSKonstantin Ananyev            ngx_noaccepting = 1;
280e18a033bSKonstantin Ananyev            ngx_signal_worker_processes(cycle,
281e18a033bSKonstantin Ananyev                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
282e18a033bSKonstantin Ananyev        }
283e18a033bSKonstantin Ananyev    }
284e18a033bSKonstantin Ananyev}
285e18a033bSKonstantin Ananyev
286e18a033bSKonstantin Ananyev
287e18a033bSKonstantin Ananyevvoid
288e18a033bSKonstantin Ananyevngx_single_process_cycle(ngx_cycle_t *cycle)
289e18a033bSKonstantin Ananyev{
290e18a033bSKonstantin Ananyev    ngx_uint_t  i;
291e18a033bSKonstantin Ananyev
292e18a033bSKonstantin Ananyev    if (ngx_set_environment(cycle, NULL) == NULL) {
293e18a033bSKonstantin Ananyev        /* fatal */
294e18a033bSKonstantin Ananyev        exit(2);
295e18a033bSKonstantin Ananyev    }
296e18a033bSKonstantin Ananyev
297e18a033bSKonstantin Ananyev    for (i = 0; cycle->modules[i]; i++) {
298e18a033bSKonstantin Ananyev        if (cycle->modules[i]->init_process) {
299e18a033bSKonstantin Ananyev            if (cycle->modules[i]->init_process(cycle) == NGX_ERROR) {
300e18a033bSKonstantin Ananyev                /* fatal */
301e18a033bSKonstantin Ananyev                exit(2);
302e18a033bSKonstantin Ananyev            }
303e18a033bSKonstantin Ananyev        }
304e18a033bSKonstantin Ananyev    }
305e18a033bSKonstantin Ananyev
306e18a033bSKonstantin Ananyev    for ( ;; ) {
307e18a033bSKonstantin Ananyev        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
308e18a033bSKonstantin Ananyev
309e18a033bSKonstantin Ananyev        ngx_process_events_and_timers(cycle);
310e18a033bSKonstantin Ananyev
311e18a033bSKonstantin Ananyev        if (ngx_terminate || ngx_quit) {
312e18a033bSKonstantin Ananyev
313e18a033bSKonstantin Ananyev            for (i = 0; cycle->modules[i]; i++) {
314e18a033bSKonstantin Ananyev                if (cycle->modules[i]->exit_process) {
315e18a033bSKonstantin Ananyev                    cycle->modules[i]->exit_process(cycle);
316e18a033bSKonstantin Ananyev                }
317e18a033bSKonstantin Ananyev            }
318e18a033bSKonstantin Ananyev
319e18a033bSKonstantin Ananyev            ngx_master_process_exit(cycle);
320e18a033bSKonstantin Ananyev        }
321e18a033bSKonstantin Ananyev
322e18a033bSKonstantin Ananyev        if (ngx_reconfigure) {
323e18a033bSKonstantin Ananyev            ngx_reconfigure = 0;
324e18a033bSKonstantin Ananyev            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");
325e18a033bSKonstantin Ananyev
326e18a033bSKonstantin Ananyev            cycle = ngx_init_cycle(cycle);
327e18a033bSKonstantin Ananyev            if (cycle == NULL) {
328e18a033bSKonstantin Ananyev                cycle = (ngx_cycle_t *) ngx_cycle;
329e18a033bSKonstantin Ananyev                continue;
330e18a033bSKonstantin Ananyev            }
331e18a033bSKonstantin Ananyev
332e18a033bSKonstantin Ananyev            ngx_cycle = cycle;
333e18a033bSKonstantin Ananyev        }
334e18a033bSKonstantin Ananyev
335e18a033bSKonstantin Ananyev        if (ngx_reopen) {
336e18a033bSKonstantin Ananyev            ngx_reopen = 0;
337e18a033bSKonstantin Ananyev            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
338e18a033bSKonstantin Ananyev            ngx_reopen_files(cycle, (ngx_uid_t) -1);
339e18a033bSKonstantin Ananyev        }
340e18a033bSKonstantin Ananyev    }
341e18a033bSKonstantin Ananyev}
342e18a033bSKonstantin Ananyev
343e18a033bSKonstantin Ananyev
344e18a033bSKonstantin Ananyevstatic void
345e18a033bSKonstantin Ananyevngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n, ngx_int_t type)
346e18a033bSKonstantin Ananyev{
347e18a033bSKonstantin Ananyev    ngx_int_t      i;
348e18a033bSKonstantin Ananyev    ngx_channel_t  ch;
349e18a033bSKonstantin Ananyev
350e18a033bSKonstantin Ananyev    ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
351e18a033bSKonstantin Ananyev
352e18a033bSKonstantin Ananyev    ngx_memzero(&ch, sizeof(ngx_channel_t));
353e18a033bSKonstantin Ananyev
354e18a033bSKonstantin Ananyev    ch.command = NGX_CMD_OPEN_CHANNEL;
355e18a033bSKonstantin Ananyev
356e18a033bSKonstantin Ananyev    for (i = 0; i < n; i++) {
357e18a033bSKonstantin Ananyev
358e18a033bSKonstantin Ananyev        ngx_spawn_process(cycle, ngx_worker_process_cycle,
359e18a033bSKonstantin Ananyev                          (void *) (intptr_t) i, "worker process", type);
360e18a033bSKonstantin Ananyev
361e18a033bSKonstantin Ananyev        ch.pid = ngx_processes[ngx_process_slot].pid;
362e18a033bSKonstantin Ananyev        ch.slot = ngx_process_slot;
363e18a033bSKonstantin Ananyev        ch.fd = ngx_processes[ngx_process_slot].channel[0];
364e18a033bSKonstantin Ananyev
365e18a033bSKonstantin Ananyev        ngx_pass_open_channel(cycle, &ch);
366e18a033bSKonstantin Ananyev    }
367e18a033bSKonstantin Ananyev}
368e18a033bSKonstantin Ananyev
369e18a033bSKonstantin Ananyev
370e18a033bSKonstantin Ananyevstatic void
371e18a033bSKonstantin Ananyevngx_start_cache_manager_processes(ngx_cycle_t *cycle, ngx_uint_t respawn)
372e18a033bSKonstantin Ananyev{
373e18a033bSKonstantin Ananyev    ngx_uint_t       i, manager, loader;
374e18a033bSKonstantin Ananyev    ngx_path_t     **path;
375e18a033bSKonstantin Ananyev    ngx_channel_t    ch;
376e18a033bSKonstantin Ananyev
377e18a033bSKonstantin Ananyev    manager = 0;
378e18a033bSKonstantin Ananyev    loader = 0;
379e18a033bSKonstantin Ananyev
380e18a033bSKonstantin Ananyev    path = ngx_cycle->paths.elts;
381e18a033bSKonstantin Ananyev    for (i = 0; i < ngx_cycle->paths.nelts; i++) {
382e18a033bSKonstantin Ananyev
383e18a033bSKonstantin Ananyev        if (path[i]->manager) {
384e18a033bSKonstantin Ananyev            manager = 1;
385e18a033bSKonstantin Ananyev        }
386e18a033bSKonstantin Ananyev
387e18a033bSKonstantin Ananyev        if (path[i]->loader) {
388e18a033bSKonstantin Ananyev            loader = 1;
389e18a033bSKonstantin Ananyev        }
390e18a033bSKonstantin Ananyev    }
391e18a033bSKonstantin Ananyev
392e18a033bSKonstantin Ananyev    if (manager == 0) {
393e18a033bSKonstantin Ananyev        return;
394e18a033bSKonstantin Ananyev    }
395e18a033bSKonstantin Ananyev
396e18a033bSKonstantin Ananyev    ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
397e18a033bSKonstantin Ananyev                      &ngx_cache_manager_ctx, "cache manager process",
398e18a033bSKonstantin Ananyev                      respawn ? NGX_PROCESS_JUST_RESPAWN : NGX_PROCESS_RESPAWN);
399e18a033bSKonstantin Ananyev
400e18a033bSKonstantin Ananyev    ngx_memzero(&ch, sizeof(ngx_channel_t));
401e18a033bSKonstantin Ananyev
402e18a033bSKonstantin Ananyev    ch.command = NGX_CMD_OPEN_CHANNEL;
403e18a033bSKonstantin Ananyev    ch.pid = ngx_processes[ngx_process_slot].pid;
404e18a033bSKonstantin Ananyev    ch.slot = ngx_process_slot;
405e18a033bSKonstantin Ananyev    ch.fd = ngx_processes[ngx_process_slot].channel[0];
406e18a033bSKonstantin Ananyev
407e18a033bSKonstantin Ananyev    ngx_pass_open_channel(cycle, &ch);
408e18a033bSKonstantin Ananyev
409e18a033bSKonstantin Ananyev    if (loader == 0) {
410e18a033bSKonstantin Ananyev        return;
411e18a033bSKonstantin Ananyev    }
412e18a033bSKonstantin Ananyev
413e18a033bSKonstantin Ananyev    ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
414e18a033bSKonstantin Ananyev                      &ngx_cache_loader_ctx, "cache loader process",
415e18a033bSKonstantin Ananyev                      respawn ? NGX_PROCESS_JUST_SPAWN : NGX_PROCESS_NORESPAWN);
416e18a033bSKonstantin Ananyev
417