Mercurial > hg > nginx-ranges

comparison src/core/ngx_cycle.c @ 0:f0b350454894 NGINX_0_1_0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx 0.1.0 *) The first public version.
author Igor Sysoev <http://sysoev.ru>
date Mon, 04 Oct 2004 00:00:00 +0400
parents
children cc9f381affaa
comparison
equal deleted inserted replaced
-1:000000000000 0:f0b350454894
1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9 #include <ngx_event.h>
10
11
12 static void ngx_clean_old_cycles(ngx_event_t *ev);
13
14
15 volatile ngx_cycle_t *ngx_cycle;
16 ngx_array_t ngx_old_cycles;
17
18 static ngx_pool_t *ngx_temp_pool;
19 static ngx_event_t ngx_cleaner_event;
20
21 ngx_uint_t ngx_test_config;
22
23 #if (NGX_THREADS)
24 ngx_tls_key_t ngx_core_tls_key;
25 #endif
26
27
28 /* STUB NAME */
29 static ngx_connection_t dumb;
30 /* STUB */
31
32 #ifdef NGX_ERROR_LOG_PATH
33 static ngx_str_t error_log = ngx_string(NGX_ERROR_LOG_PATH);
34 #else
35 static ngx_str_t error_log = ngx_null_string;
36 #endif
37
38
39 ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
40 {
41 void *rv;
42 ngx_uint_t i, n, failed;
43 ngx_log_t *log;
44 ngx_conf_t conf;
45 ngx_pool_t *pool;
46 ngx_cycle_t *cycle, **old;
47 ngx_socket_t fd;
48 ngx_list_part_t *part;
49 ngx_open_file_t *file;
50 ngx_listening_t *ls, *nls;
51 ngx_core_module_t *module;
52
53 log = old_cycle->log;
54
55 if (!(pool = ngx_create_pool(16 * 1024, log))) {
56 return NULL;
57 }
58 pool->log = log;
59
60 if (!(cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t)))) {
61 ngx_destroy_pool(pool);
62 return NULL;
63 }
64 cycle->pool = pool;
65 cycle->log = log;
66 cycle->old_cycle = old_cycle;
67 cycle->conf_file = old_cycle->conf_file;
68 cycle->root.len = sizeof(NGX_PREFIX) - 1;
69 cycle->root.data = (u_char *) NGX_PREFIX;
70
71
72 n = old_cycle->pathes.nelts ? old_cycle->pathes.nelts : 10;
73 if (!(cycle->pathes.elts = ngx_pcalloc(pool, n * sizeof(ngx_path_t *)))) {
74 ngx_destroy_pool(pool);
75 return NULL;
76 }
77 cycle->pathes.nelts = 0;
78 cycle->pathes.size = sizeof(ngx_path_t *);
79 cycle->pathes.nalloc = n;
80 cycle->pathes.pool = pool;
81
82
83 if (old_cycle->open_files.part.nelts) {
84 n = old_cycle->open_files.part.nelts;
85 for (part = old_cycle->open_files.part.next; part; part = part->next) {
86 n += part->nelts;
87 }
88
89 } else {
90 n = 20;
91 }
92
93 if (ngx_list_init(&cycle->open_files, pool, n, sizeof(ngx_open_file_t))
94 == NGX_ERROR)
95 {
96 ngx_destroy_pool(pool);
97 return NULL;
98 }
99
100
101 if (!(cycle->new_log = ngx_log_create_errlog(cycle, NULL))) {
102 ngx_destroy_pool(pool);
103 return NULL;
104 }
105
106 cycle->new_log->file->name = error_log;
107
108
109 n = old_cycle->listening.nelts ? old_cycle->listening.nelts : 10;
110 cycle->listening.elts = ngx_pcalloc(pool, n * sizeof(ngx_listening_t));
111 if (cycle->listening.elts == NULL) {
112 ngx_destroy_pool(pool);
113 return NULL;
114 }
115 cycle->listening.nelts = 0;
116 cycle->listening.size = sizeof(ngx_listening_t);
117 cycle->listening.nalloc = n;
118 cycle->listening.pool = pool;
119
120
121 cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));
122 if (cycle->conf_ctx == NULL) {
123 ngx_destroy_pool(pool);
124 return NULL;
125 }
126
127
128 for (i = 0; ngx_modules[i]; i++) {
129 if (ngx_modules[i]->type != NGX_CORE_MODULE) {
130 continue;
131 }
132
133 module = ngx_modules[i]->ctx;
134
135 if (module->create_conf) {
136 rv = module->create_conf(cycle);
137 if (rv == NGX_CONF_ERROR) {
138 ngx_destroy_pool(pool);
139 return NULL;
140 }
141 cycle->conf_ctx[ngx_modules[i]->index] = rv;
142 }
143 }
144
145
146 ngx_memzero(&conf, sizeof(ngx_conf_t));
147 /* STUB: init array ? */
148 conf.args = ngx_create_array(pool, 10, sizeof(ngx_str_t));
149 if (conf.args == NULL) {
150 ngx_destroy_pool(pool);
151 return NULL;
152 }
153
154 conf.ctx = cycle->conf_ctx;
155 conf.cycle = cycle;
156 conf.pool = pool;
157 conf.log = log;
158 conf.module_type = NGX_CORE_MODULE;
159 conf.cmd_type = NGX_MAIN_CONF;
160
161
162 if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {
163 ngx_destroy_pool(pool);
164 return NULL;
165 }
166
167 if (ngx_test_config) {
168 ngx_log_error(NGX_LOG_INFO, log, 0,
169 "the configuration file %s syntax is ok",
170 cycle->conf_file.data);
171 }
172
173
174 for (i = 0; ngx_modules[i]; i++) {
175 if (ngx_modules[i]->type != NGX_CORE_MODULE) {
176 continue;
177 }
178
179 module = ngx_modules[i]->ctx;
180
181 if (module->init_conf) {
182 if (module->init_conf(cycle, cycle->conf_ctx[ngx_modules[i]->index])
183 == NGX_CONF_ERROR)
184 {
185 ngx_destroy_pool(pool);
186 return NULL;
187 }
188 }
189 }
190
191
192 failed = 0;
193
194
195 #if !(WIN32)
196 if (ngx_create_pidfile(cycle, old_cycle) == NGX_ERROR) {
197 failed = 1;
198 }
199 #endif
200
201
202 if (!failed) {
203
204 part = &cycle->open_files.part;
205 file = part->elts;
206
207 for (i = 0; /* void */ ; i++) {
208
209 if (i >= part->nelts) {
210 if (part->next == NULL) {
211 break;
212 }
213 part = part->next;
214 file = part->elts;
215 i = 0;
216 }
217
218 if (file[i].name.data == NULL) {
219 continue;
220 }
221
222 file[i].fd = ngx_open_file(file[i].name.data,
223 NGX_FILE_RDWR,
224 NGX_FILE_CREATE_OR_OPEN|NGX_FILE_APPEND);
225
226 #if 0
227 log->log_level = NGX_LOG_DEBUG_ALL;
228 #endif
229 ngx_log_debug3(NGX_LOG_DEBUG_CORE, log, 0,
230 "log: %0X %d \"%s\"",
231 &file[i], file[i].fd, file[i].name.data);
232
233 if (file[i].fd == NGX_INVALID_FILE) {
234 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
235 ngx_open_file_n " \"%s\" failed",
236 file[i].name.data);
237 failed = 1;
238 break;
239 }
240
241 #if (WIN32)
242 if (ngx_file_append_mode(file[i].fd) == NGX_ERROR) {
243 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
244 ngx_file_append_mode_n " \"%s\" failed",
245 file[i].name.data);
246 failed = 1;
247 break;
248 }
249 #else
250 if (fcntl(file[i].fd, F_SETFD, FD_CLOEXEC) == -1) {
251 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
252 "fcntl(FD_CLOEXEC) \"%s\" failed",
253 file[i].name.data);
254 failed = 1;
255 break;
256 }
257 #endif
258 }
259 }
260
261 cycle->log = cycle->new_log;
262 pool->log = cycle->new_log;
263
264 if (cycle->log->log_level == 0) {
265 cycle->log->log_level = NGX_LOG_ERR;
266 }
267
268 if (!failed) {
269 if (old_cycle->listening.nelts) {
270 ls = old_cycle->listening.elts;
271 for (i = 0; i < old_cycle->listening.nelts; i++) {
272 ls[i].remain = 0;
273 }
274
275 nls = cycle->listening.elts;
276 for (n = 0; n < cycle->listening.nelts; n++) {
277 for (i = 0; i < old_cycle->listening.nelts; i++) {
278 if (ls[i].ignore) {
279 continue;
280 }
281
282 if (ngx_memcmp(nls[n].sockaddr,
283 ls[i].sockaddr, ls[i].socklen) == 0)
284 {
285 fd = ls[i].fd;
286 #if (WIN32)
287 /*
288 * Winsock assignes a socket number divisible by 4 so
289 * to find a connection we divide a socket number by 4.
290 */
291
292 fd /= 4;
293 #endif
294 if (fd >= (ngx_socket_t) cycle->connection_n) {
295 ngx_log_error(NGX_LOG_EMERG, log, 0,
296 "%d connections is not enough to hold "
297 "an open listening socket on %s, "
298 "required at least %d connections",
299 cycle->connection_n,
300 ls[i].addr_text.data, fd);
301 failed = 1;
302 break;
303 }
304
305 nls[n].fd = ls[i].fd;
306 nls[i].remain = 1;
307 ls[i].remain = 1;
308 break;
309 }
310 }
311
312 if (nls[n].fd == -1) {
313 nls[n].new = 1;
314 }
315 }
316
317 } else {
318 ls = cycle->listening.elts;
319 for (i = 0; i < cycle->listening.nelts; i++) {
320 ls[i].new = 1;
321 }
322 }
323
324 if (!ngx_test_config && !failed) {
325 if (ngx_open_listening_sockets(cycle) == NGX_ERROR) {
326 failed = 1;
327 }
328 }
329 }
330
331 if (failed) {
332
333 /* rollback the new cycle configuration */
334
335 part = &cycle->open_files.part;
336 file = part->elts;
337
338 for (i = 0; /* void */ ; i++) {
339
340 if (i >= part->nelts) {
341 if (part->next == NULL) {
342 break;
343 }
344 part = part->next;
345 file = part->elts;
346 i = 0;
347 }
348
349 if (file[i].fd == NGX_INVALID_FILE
350 || file[i].fd == ngx_stderr_fileno)
351 {
352 continue;
353 }
354
355 if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
356 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
357 ngx_close_file_n " \"%s\" failed",
358 file[i].name.data);
359 }
360 }
361
362 if (ngx_test_config) {
363 ngx_destroy_pool(pool);
364 return NULL;
365 }
366
367 ls = cycle->listening.elts;
368 for (i = 0; i < cycle->listening.nelts; i++) {
369 if (ls[i].fd == -1 || !ls[i].new) {
370 continue;
371 }
372
373 if (ngx_close_socket(ls[i].fd) == -1) {
374 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
375 ngx_close_socket_n " %s failed",
376 ls[i].addr_text.data);
377 }
378 }
379
380 ngx_destroy_pool(pool);
381 return NULL;
382 }
383
384
385 /* commit the new cycle configuration */
386
387 #if !(WIN32)
388
389 if (!ngx_test_config && cycle->log->file->fd != STDERR_FILENO) {
390
391 ngx_log_debug3(NGX_LOG_DEBUG_CORE, log, 0,
392 "dup2: %0X %d \"%s\"",
393 cycle->log->file,
394 cycle->log->file->fd, cycle->log->file->name.data);
395
396 if (dup2(cycle->log->file->fd, STDERR_FILENO) == NGX_ERROR) {
397 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
398 "dup2(STDERR) failed");
399 /* fatal */
400 exit(1);
401 }
402 }
403
404 #endif
405
406 pool->log = cycle->log;
407
408 for (i = 0; ngx_modules[i]; i++) {
409 if (ngx_modules[i]->init_module) {
410 if (ngx_modules[i]->init_module(cycle) == NGX_ERROR) {
411 /* fatal */
412 exit(1);
413 }
414 }
415 }
416
417 /* close and delete stuff that lefts from an old cycle */
418
419 /* close the unneeded listening sockets */
420
421 ls = old_cycle->listening.elts;
422 for (i = 0; i < old_cycle->listening.nelts; i++) {
423 if (ls[i].remain) {
424 continue;
425 }
426
427 if (ngx_close_socket(ls[i].fd) == -1) {
428 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
429 ngx_close_socket_n " %s failed",
430 ls[i].addr_text.data);
431 }
432 }
433
434
435 /* close the unneeded open files */
436
437 part = &old_cycle->open_files.part;
438 file = part->elts;
439
440 for (i = 0; /* void */ ; i++) {
441
442 if (i >= part->nelts) {
443 if (part->next == NULL) {
444 break;
445 }
446 part = part->next;
447 file = part->elts;
448 i = 0;
449 }
450
451 if (file[i].fd == NGX_INVALID_FILE || file[i].fd == ngx_stderr_fileno) {
452 continue;
453 }
454
455 if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
456 ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
457 ngx_close_file_n " \"%s\" failed",
458 file[i].name.data);
459 }
460 }
461
462 if (old_cycle->connections == NULL) {
463 /* an old cycle is an init cycle */
464 ngx_destroy_pool(old_cycle->pool);
465 return cycle;
466 }
467
468 if (ngx_process == NGX_PROCESS_MASTER) {
469 ngx_destroy_pool(old_cycle->pool);
470 return cycle;
471 }
472
473 if (ngx_temp_pool == NULL) {
474 ngx_temp_pool = ngx_create_pool(128, cycle->log);
475 if (ngx_temp_pool == NULL) {
476 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
477 "can not create ngx_temp_pool");
478 exit(1);
479 }
480
481 n = 10;
482 ngx_old_cycles.elts = ngx_pcalloc(ngx_temp_pool,
483 n * sizeof(ngx_cycle_t *));
484 if (ngx_old_cycles.elts == NULL) {
485 exit(1);
486 }
487 ngx_old_cycles.nelts = 0;
488 ngx_old_cycles.size = sizeof(ngx_cycle_t *);
489 ngx_old_cycles.nalloc = n;
490 ngx_old_cycles.pool = ngx_temp_pool;
491
492 ngx_cleaner_event.event_handler = ngx_clean_old_cycles;
493 ngx_cleaner_event.log = cycle->log;
494 ngx_cleaner_event.data = &dumb;
495 dumb.fd = (ngx_socket_t) -1;
496 }
497
498 ngx_temp_pool->log = cycle->log;
499
500 old = ngx_push_array(&ngx_old_cycles);
501 if (old == NULL) {
502 exit(1);
503 }
504 *old = old_cycle;
505
506 if (!ngx_cleaner_event.timer_set) {
507 ngx_add_timer(&ngx_cleaner_event, 30000);
508 ngx_cleaner_event.timer_set = 1;
509 }
510
511 return cycle;
512 }
513
514
515 #if !(WIN32)
516
517 ngx_int_t ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle)
518 {
519 ngx_uint_t trunc;
520 size_t len;
521 u_char *name, pid[NGX_INT64_LEN + 1];
522 ngx_file_t file;
523 ngx_core_conf_t *ccf, *old_ccf;
524
525 if (!ngx_test_config && old_cycle && old_cycle->conf_ctx == NULL) {
526
527 /*
528 * do not create the pid file in the first ngx_init_cycle() call
529 * because we need to write the demonized process pid
530 */
531
532 return NGX_OK;
533 }
534
535 ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
536
537 if (!ngx_test_config && old_cycle) {
538 old_ccf = (ngx_core_conf_t *) ngx_get_conf(old_cycle->conf_ctx,
539 ngx_core_module);
540
541 if (ccf->pid.len == old_ccf->pid.len
542 && ngx_strcmp(ccf->pid.data, old_ccf->pid.data) == 0)
543 {
544
545 /* pid file name is the same */
546
547 return NGX_OK;
548 }
549 }
550
551 len = ngx_snprintf((char *) pid, NGX_INT64_LEN + 1, PID_T_FMT, ngx_pid);
552
553 ngx_memzero(&file, sizeof(ngx_file_t));
554 file.name = (ngx_inherited && getppid() > 1) ? ccf->newpid : ccf->pid;
555 file.log = cycle->log;
556
557 trunc = ngx_test_config ? 0: NGX_FILE_TRUNCATE;
558
559 file.fd = ngx_open_file(file.name.data, NGX_FILE_RDWR,
560 NGX_FILE_CREATE_OR_OPEN|trunc);
561
562 if (file.fd == NGX_INVALID_FILE) {
563 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
564 ngx_open_file_n " \"%s\" failed", file.name.data);
565 return NGX_ERROR;
566 }
567
568 if (!ngx_test_config) {
569 if (ngx_write_file(&file, pid, len, 0) == NGX_ERROR) {
570 return NGX_ERROR;
571 }
572 }
573
574 if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
575 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
576 ngx_close_file_n " \"%s\" failed", file.name.data);
577 }
578
579 ngx_delete_pidfile(old_cycle);
580
581 return NGX_OK;
582 }
583
584
585 void ngx_delete_pidfile(ngx_cycle_t *cycle)
586 {
587 u_char *name;
588 ngx_core_conf_t *ccf;
589
590 if (cycle == NULL || cycle->conf_ctx == NULL) {
591 return;
592 }
593
594 ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
595
596 if (ngx_inherited && getppid() > 1) {
597 name = ccf->newpid.data;
598
599 } else {
600 name = ccf->pid.data;
601 }
602
603 if (ngx_delete_file(name) == NGX_FILE_ERROR) {
604 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
605 ngx_delete_file_n " \"%s\" failed", name);
606 }
607 }
608
609 #endif
610
611
612 void ngx_reopen_files(ngx_cycle_t *cycle, ngx_uid_t user)
613 {
614 ngx_fd_t fd;
615 ngx_uint_t i;
616 ngx_list_part_t *part;
617 ngx_open_file_t *file;
618
619 part = &cycle->open_files.part;
620 file = part->elts;
621
622 for (i = 0; /* void */ ; i++) {
623
624 if (i >= part->nelts) {
625 if (part->next == NULL) {
626 break;
627 }
628 part = part->next;
629 i = 0;
630 }
631
632 if (file[i].name.data == NULL) {
633 continue;
634 }
635
636 fd = ngx_open_file(file[i].name.data, NGX_FILE_RDWR,
637 NGX_FILE_CREATE_OR_OPEN|NGX_FILE_APPEND);
638
639 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
640 "reopen file \"%s\", old:%d new:%d",
641 file[i].name.data, file[i].fd, fd);
642
643 if (fd == NGX_INVALID_FILE) {
644 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
645 ngx_open_file_n " \"%s\" failed", file[i].name.data);
646 continue;
647 }
648
649 #if (WIN32)
650 if (ngx_file_append_mode(fd) == NGX_ERROR) {
651 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
652 ngx_file_append_mode_n " \"%s\" failed",
653 file[i].name.data);
654
655 if (ngx_close_file(fd) == NGX_FILE_ERROR) {
656 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
657 ngx_close_file_n " \"%s\" failed",
658 file[i].name.data);
659 }
660
661 continue;
662 }
663 #else
664 if (user != (ngx_uid_t) -1) {
665 if (chown((const char *) file[i].name.data, user, -1) == -1) {
666 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
667 "chown \"%s\" failed", file[i].name.data);
668
669 if (ngx_close_file(fd) == NGX_FILE_ERROR) {
670 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
671 ngx_close_file_n " \"%s\" failed",
672 file[i].name.data);
673 }
674 }
675 }
676
677 if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
678 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
679 "fcntl(FD_CLOEXEC) \"%s\" failed",
680 file[i].name.data);
681
682 if (ngx_close_file(fd) == NGX_FILE_ERROR) {
683 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
684 ngx_close_file_n " \"%s\" failed",
685 file[i].name.data);
686 }
687
688 continue;
689 }
690 #endif
691
692 if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
693 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
694 ngx_close_file_n " \"%s\" failed",
695 file[i].name.data);
696 }
697
698 file[i].fd = fd;
699 }
700
701 #if !(WIN32)
702
703 if (cycle->log->file->fd != STDERR_FILENO) {
704 if (dup2(cycle->log->file->fd, STDERR_FILENO) == -1) {
705 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
706 "dup2(STDERR) failed");
707 }
708 }
709
710 #endif
711 }
712
713
714 static void ngx_clean_old_cycles(ngx_event_t *ev)
715 {
716 ngx_uint_t i, n, found, live;
717 ngx_log_t *log;
718 ngx_cycle_t **cycle;
719
720 log = ngx_cycle->log;
721 ngx_temp_pool->log = log;
722
723 ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, 0, "clean old cycles");
724
725 live = 0;
726
727 cycle = ngx_old_cycles.elts;
728 for (i = 0; i < ngx_old_cycles.nelts; i++) {
729
730 if (cycle[i] == NULL) {
731 continue;
732 }
733
734 found = 0;
735
736 for (n = 0; n < cycle[i]->connection_n; n++) {
737 if (cycle[i]->connections[n].fd != (ngx_socket_t) -1) {
738 found = 1;
739
740 ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0, "live fd:%d", n);
741
742 break;
743 }
744 }
745
746 if (found) {
747 live = 1;
748 continue;
749 }
750
751 ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0, "clean old cycle: %d", i);
752
753 ngx_destroy_pool(cycle[i]->pool);
754 cycle[i] = NULL;
755 }
756
757 ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0, "old cycles status: %d", live);
758
759 if (live) {
760 ngx_add_timer(ev, 30000);
761
762 } else {
763 ngx_destroy_pool(ngx_temp_pool);
764 ngx_temp_pool = NULL;
765 ngx_old_cycles.nelts = 0;
766 }
767 }