Mercurial > hg > nginx-ranges

comparison src/event/modules/ngx_rtsig_module.c @ 112:408f195b3482 NGINX_0_3_3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx 0.3.3 *) Change: the "bl" and "af" parameters of the "listen" directive was renamed to the "backlog" and "accept_filter". *) Feature: the "rcvbuf" and "sndbuf" parameters of the "listen" directive. *) Change: the "$msec" log parameter does not require now the additional the gettimeofday() system call. *) Feature: the -t switch now tests the "listen" directives. *) Bugfix: if the invalid address was specified in the "listen" directive, then after the -HUP signal nginx left an open socket in the CLOSED state. *) Bugfix: the mime type may be incorrectly set to default value for index file with variable in the name; bug appeared in 0.3.0. *) Feature: the "timer_resolution" directive. *) Feature: the millisecond "$upstream_response_time" log parameter. *) Bugfix: a temporary file with client request body now is removed just after the response header was transferred to a client. *) Bugfix: OpenSSL 0.9.6 compatibility. *) Bugfix: the SSL certificate and key file paths could not be relative. *) Bugfix: the "ssl_prefer_server_ciphers" directive did not work in the ngx_imap_ssl_module. *) Bugfix: the "ssl_protocols" directive allowed to specify the single protocol only.
author Igor Sysoev <http://sysoev.ru>
date Wed, 19 Oct 2005 00:00:00 +0400
parents cf3d6edb3ad6
children e38f51cd0905
comparison
equal deleted inserted replaced
111:a175b609c76d 112:408f195b3482
36 } ngx_rtsig_conf_t; 36 } ngx_rtsig_conf_t;
37 37
38 38
39 extern ngx_event_module_t ngx_poll_module_ctx; 39 extern ngx_event_module_t ngx_poll_module_ctx;
40 40
41 static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle); 41 static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer);
42 static void ngx_rtsig_done(ngx_cycle_t *cycle); 42 static void ngx_rtsig_done(ngx_cycle_t *cycle);
43 static ngx_int_t ngx_rtsig_add_connection(ngx_connection_t *c); 43 static ngx_int_t ngx_rtsig_add_connection(ngx_connection_t *c);
44 static ngx_int_t ngx_rtsig_del_connection(ngx_connection_t *c, u_int flags); 44 static ngx_int_t ngx_rtsig_del_connection(ngx_connection_t *c, u_int flags);
45 static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle); 45 static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle,
46 static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle); 46 ngx_msec_t timer, ngx_uint_t flags);
47 static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle,
48 ngx_msec_t timer, ngx_uint_t flags);
47 49
48 static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle); 50 static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle);
49 static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf); 51 static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf);
50 static char *ngx_check_ngx_overflow_threshold_bounds(ngx_conf_t *cf, 52 static char *ngx_check_ngx_overflow_threshold_bounds(ngx_conf_t *cf,
51 void *post, void *data); 53 void *post, void *data);
132 NGX_MODULE_V1_PADDING 134 NGX_MODULE_V1_PADDING
133 }; 135 };
134 136
135 137
136 static ngx_int_t 138 static ngx_int_t
137 ngx_rtsig_init(ngx_cycle_t *cycle) 139 ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer)
138 { 140 {
139 ngx_rtsig_conf_t *rtscf; 141 ngx_rtsig_conf_t *rtscf;
140 142
141 rtscf = ngx_event_get_conf(cycle->conf_ctx, ngx_rtsig_module); 143 rtscf = ngx_event_get_conf(cycle->conf_ctx, ngx_rtsig_module);
142 144
143 sigemptyset(&set); 145 sigemptyset(&set);
144 sigaddset(&set, rtscf->signo); 146 sigaddset(&set, rtscf->signo);
145 sigaddset(&set, rtscf->signo + 1); 147 sigaddset(&set, rtscf->signo + 1);
146 sigaddset(&set, SIGIO); 148 sigaddset(&set, SIGIO);
149 sigaddset(&set, SIGALRM);
147 150
148 if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) { 151 if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
149 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno, 152 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
150 "sigprocmask() failed"); 153 "sigprocmask() failed");
151 return NGX_ERROR; 154 return NGX_ERROR;
277 return NGX_OK; 280 return NGX_OK;
278 } 281 }
279 282
280 283
281 static ngx_int_t 284 static ngx_int_t
282 ngx_rtsig_process_events(ngx_cycle_t *cycle) 285 ngx_rtsig_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
283 { 286 {
284 int signo; 287 int signo;
285 ngx_int_t instance; 288 ngx_int_t instance;
286 ngx_msec_t timer, delta; 289 ngx_msec_t delta;
287 ngx_err_t err; 290 ngx_err_t err;
288 siginfo_t si; 291 siginfo_t si;
289 ngx_event_t *rev, *wev; 292 ngx_event_t *rev, *wev;
290 struct timeval tv;
291 struct timespec ts, *tp; 293 struct timespec ts, *tp;
292 struct sigaction sa; 294 struct sigaction sa;
293 ngx_connection_t *c; 295 ngx_connection_t *c;
294 ngx_rtsig_conf_t *rtscf; 296 ngx_rtsig_conf_t *rtscf;
295 297
296 if (overflow) {
297 timer = 0;
298
299 } else {
300 timer = ngx_event_find_timer();
301
302 #if (NGX_THREADS)
303
304 if (timer == NGX_TIMER_ERROR) {
305 return NGX_ERROR;
306 }
307
308 if (timer == NGX_TIMER_INFINITE || timer > 500) {
309 timer = 500;
310 }
311
312 #endif
313
314 if (ngx_accept_mutex) {
315 if (ngx_accept_disabled > 0) {
316 ngx_accept_disabled--;
317
318 } else {
319 ngx_accept_mutex_held = 0;
320
321 if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
322 return NGX_ERROR;
323 }
324
325 if (ngx_accept_mutex_held == 0
326 && (timer == NGX_TIMER_INFINITE
327 || timer > ngx_accept_mutex_delay))
328 {
329 timer = ngx_accept_mutex_delay;
330 }
331 }
332 }
333 }
334
335 if (timer == NGX_TIMER_INFINITE) { 298 if (timer == NGX_TIMER_INFINITE) {
336 tp = NULL; 299 tp = NULL;
337 300
338 } else { 301 } else {
339 ts.tv_sec = timer / 1000; 302 ts.tv_sec = timer / 1000;
355 "rtsig signo:%d", signo); 318 "rtsig signo:%d", signo);
356 319
357 if (err == NGX_EAGAIN) { 320 if (err == NGX_EAGAIN) {
358 321
359 if (timer == NGX_TIMER_INFINITE) { 322 if (timer == NGX_TIMER_INFINITE) {
360 ngx_accept_mutex_unlock();
361 ngx_log_error(NGX_LOG_ALERT, cycle->log, err, 323 ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
362 "sigtimedwait() returned EAGAIN without timeout"); 324 "sigtimedwait() returned EAGAIN without timeout");
363 return NGX_ERROR; 325 return NGX_ERROR;
364 } 326 }
365 327
371 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 333 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
372 "rtsig signo:%d fd:%d band:%04Xd", 334 "rtsig signo:%d fd:%d band:%04Xd",
373 signo, si.si_fd, si.si_band); 335 signo, si.si_fd, si.si_band);
374 } 336 }
375 337
376 ngx_gettimeofday(&tv); 338 delta = ngx_current_msec;
377 ngx_time_update(tv.tv_sec); 339
378 340 if (flags & NGX_UPDATE_TIME) {
379 delta = ngx_current_time; 341 ngx_time_update(0, 0);
380 ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000; 342 }
381 343
382 if (err) { 344 if (err) {
383 ngx_accept_mutex_unlock();
384 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT, 345 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
385 cycle->log, err, "sigtimedwait() failed"); 346 cycle->log, err, "sigtimedwait() failed");
386 return NGX_ERROR; 347 return NGX_ERROR;
387 } 348 }
388 349
389 if (timer != NGX_TIMER_INFINITE) { 350 if (timer != NGX_TIMER_INFINITE) {
390 delta = ngx_current_time - delta; 351 delta = ngx_current_msec - delta;
391 352
392 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 353 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
393 "rtsig timer: %M, delta: %M", timer, delta); 354 "rtsig timer: %M, delta: %M", timer, delta);
394 } 355 }
395 356
402 } 363 }
403 364
404 c = ngx_cycle->files[si.si_fd]; 365 c = ngx_cycle->files[si.si_fd];
405 366
406 if (c == NULL) { 367 if (c == NULL) {
368
407 /* the stale event */ 369 /* the stale event */
408 370
409 ngx_accept_mutex_unlock();
410
411 return NGX_OK; 371 return NGX_OK;
412 } 372 }
413 373
414 instance = signo - rtscf->signo; 374 instance = signo - rtscf->signo;
415 375
416 rev = c->read; 376 rev = c->read;
417 377
418 if (c->read->instance != instance) { 378 if (rev->instance != instance) {
419 379
420 /* 380 /*
421 * the stale event from a file descriptor 381 * the stale event from a file descriptor
422 * that was just closed in this iteration 382 * that was just closed in this iteration
423 */ 383 */
424 384
425 ngx_accept_mutex_unlock();
426
427 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 385 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
428 "rtsig: stale event %p", c); 386 "rtsig: stale event %p", c);
429 387
430 return NGX_OK; 388 return NGX_OK;
431 } 389 }
432 390
433 if (si.si_band & (POLLIN|POLLHUP|POLLERR)) { 391 if ((si.si_band & (POLLIN|POLLHUP|POLLERR)) && rev->active) {
434 if (rev->active) { 392 rev->ready = 1;
435 393 rev->handler(rev);
436 if (ngx_threaded && !rev->accept) {
437 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
438 ngx_accept_mutex_unlock();
439 return NGX_ERROR;
440 }
441
442 rev->posted_ready = 1;
443 ngx_post_event(rev);
444
445 ngx_mutex_unlock(ngx_posted_events_mutex);
446
447 } else {
448 rev->ready = 1;
449
450 if (!ngx_threaded && !ngx_accept_mutex_held) {
451 rev->handler(rev);
452
453 } else if (rev->accept) {
454 if (ngx_accept_disabled <= 0) {
455 rev->handler(rev);
456 }
457
458 } else {
459 ngx_post_event(rev);
460 }
461 }
462 }
463 } 394 }
464 395
465 wev = c->write; 396 wev = c->write;
466 397
467 if (si.si_band & (POLLOUT|POLLHUP|POLLERR)) { 398 if ((si.si_band & (POLLOUT|POLLHUP|POLLERR)) && wev->active) {
468 if (wev->active) { 399 wev->ready = 1;
469 400 wev->handler(wev);
470 if (ngx_threaded) { 401 }
471 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { 402
472 ngx_accept_mutex_unlock(); 403 } else if (signo == SIGALRM) {
473 return NGX_ERROR; 404
474 } 405 return NGX_OK;
475
476 wev->posted_ready = 1;
477 ngx_post_event(wev);
478
479 ngx_mutex_unlock(ngx_posted_events_mutex);
480
481 } else {
482 wev->ready = 1;
483
484 if (!ngx_threaded && !ngx_accept_mutex_held) {
485 wev->handler(wev);
486
487 } else {
488 ngx_post_event(wev);
489 }
490 }
491 }
492 }
493 406
494 } else if (signo == SIGIO) { 407 } else if (signo == SIGIO) {
495 ngx_accept_mutex_unlock();
496 408
497 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, 409 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
498 "rt signal queue overflowed"); 410 "rt signal queue overflowed");
499 411
500 /* flush the RT signal queue */ 412 /* flush the RT signal queue */
518 ngx_event_actions.process_events = ngx_rtsig_process_overflow; 430 ngx_event_actions.process_events = ngx_rtsig_process_overflow;
519 431
520 return NGX_ERROR; 432 return NGX_ERROR;
521 433
522 } else if (signo != -1) { 434 } else if (signo != -1) {
523 ngx_accept_mutex_unlock();
524
525 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, 435 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
526 "sigtimedwait() returned unexpected signal: %d", signo); 436 "sigtimedwait() returned unexpected signal: %d", signo);
527 437
528 return NGX_ERROR; 438 return NGX_ERROR;
529 } 439 }
530 440
531 ngx_accept_mutex_unlock(); 441 if (signo != -1) {
532
533 ngx_event_expire_timers();
534
535 if (ngx_posted_events) {
536 if (ngx_threaded) {
537 ngx_wakeup_worker_thread(cycle);
538
539 } else {
540 ngx_event_process_posted(cycle);
541 }
542 }
543
544 if (signo == -1) {
545 return NGX_AGAIN;
546 } else {
547 return NGX_OK; 442 return NGX_OK;
548 } 443 }
549 } 444
550 445 return NGX_AGAIN;
551 446 }
552 /* TODO: old cylces */ 447
553 448
554 static ngx_int_t 449 static ngx_int_t
555 ngx_rtsig_process_overflow(ngx_cycle_t *cycle) 450 ngx_rtsig_process_overflow(ngx_cycle_t *cycle, ngx_msec_t timer,
451 ngx_uint_t flags)
556 { 452 {
557 int name[2], rtsig_max, rtsig_nr, events, ready; 453 int name[2], rtsig_max, rtsig_nr, events, ready;
558 size_t len; 454 size_t len;
559 ngx_int_t tested, n, i; 455 ngx_int_t tested, n, i;
560 ngx_err_t err; 456 ngx_err_t err;
561 ngx_event_t *rev, *wev; 457 ngx_event_t *rev, *wev, **queue;
562 ngx_connection_t *c; 458 ngx_connection_t *c;
563 ngx_rtsig_conf_t *rtscf; 459 ngx_rtsig_conf_t *rtscf;
460
461 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
462 "rtsig process overflow");
564 463
565 rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module); 464 rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
566 465
567 tested = 0; 466 tested = 0;
568 467
605 break; 504 break;
606 } 505 }
607 506
608 for ( ;; ) { 507 for ( ;; ) {
609 ready = poll(overflow_list, n, 0); 508 ready = poll(overflow_list, n, 0);
509
510 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
511 "rtsig overflow poll:%d", ready);
610 512
611 if (ready == -1) { 513 if (ready == -1) {
612 err = ngx_errno; 514 err = ngx_errno;
613 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT, 515 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
614 cycle->log, 0, 516 cycle->log, 0,
624 526
625 if (ready <= 0) { 527 if (ready <= 0) {
626 continue; 528 continue;
627 } 529 }
628 530
629 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { 531 ngx_mutex_lock(ngx_posted_events_mutex);
630 return NGX_ERROR;
631 }
632 532
633 for (i = 0; i < n; i++) { 533 for (i = 0; i < n; i++) {
634 c = cycle->files[overflow_list[i].fd]; 534 c = cycle->files[overflow_list[i].fd];
635 535
636 if (c == NULL) { 536 if (c == NULL) {
645 && (overflow_list[i].revents 545 && (overflow_list[i].revents
646 & (POLLIN|POLLERR|POLLHUP|POLLNVAL))) 546 & (POLLIN|POLLERR|POLLHUP|POLLNVAL)))
647 { 547 {
648 tested++; 548 tested++;
649 549
650 if (ngx_threaded) { 550 if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
651 rev->posted_ready = 1; 551 rev->posted_ready = 1;
652 ngx_post_event(rev);
653 552
654 } else { 553 } else {
655 rev->ready = 1; 554 rev->ready = 1;
656 rev->handler(rev); 555 }
556
557 if (flags & NGX_POST_EVENTS) {
558 queue = (ngx_event_t **) (rev->accept ?
559 &ngx_posted_accept_events : &ngx_posted_events);
560
561 ngx_locked_post_event(rev, queue);
562
563 } else {
564 rev->handler(rev);
657 } 565 }
658 } 566 }
659 567
660 wev = c->write; 568 wev = c->write;
661 569
665 && (overflow_list[i].revents 573 && (overflow_list[i].revents
666 & (POLLOUT|POLLERR|POLLHUP|POLLNVAL))) 574 & (POLLOUT|POLLERR|POLLHUP|POLLNVAL)))
667 { 575 {
668 tested++; 576 tested++;
669 577
670 if (ngx_threaded) { 578 if (flags & NGX_POST_THREAD_EVENTS) {
671 wev->posted_ready = 1; 579 wev->posted_ready = 1;
672 ngx_post_event(wev);
673 580
674 } else { 581 } else {
675 wev->ready = 1; 582 wev->ready = 1;
676 wev->handler(wev); 583 }
584
585 if (flags & NGX_POST_EVENTS) {
586 ngx_locked_post_event(wev, &ngx_posted_events);
587
588 } else {
589 wev->handler(wev);
677 } 590 }
678 } 591 }
679 } 592 }
680 593
681 ngx_mutex_unlock(ngx_posted_events_mutex); 594 ngx_mutex_unlock(ngx_posted_events_mutex);
686 599
687 /* 600 /*
688 * Check the current rt queue length to prevent 601 * Check the current rt queue length to prevent
689 * the new overflow. 602 * the new overflow.
690 * 603 *
691 * Learn the /proc/sys/kernel/rtsig-max value because 604 * learn the "/proc/sys/kernel/rtsig-max" value because
692 * it can be changed since the last checking. 605 * it can be changed since the last checking
693 */ 606 */
694 607
695 name[0] = CTL_KERN; 608 name[0] = CTL_KERN;
696 name[1] = KERN_RTSIGMAX; 609 name[1] = KERN_RTSIGMAX;
697 len = sizeof(rtsig_max); 610 len = sizeof(rtsig_max);
711 "sysctl(KERN_RTSIGNR) failed"); 624 "sysctl(KERN_RTSIGNR) failed");
712 return NGX_ERROR; 625 return NGX_ERROR;
713 } 626 }
714 627
715 /* 628 /*
716 * drain the rt signal queue if the /proc/sys/kernel/rtsig-nr 629 * drain the rt signal queue if the /"proc/sys/kernel/rtsig-nr"
717 * is bigger than 630 * is bigger than
718 * /proc/sys/kernel/rtsig-max / rtsig_overflow_threshold 631 * "/proc/sys/kernel/rtsig-max" / "rtsig_overflow_threshold"
719 */ 632 */
720 633
721 if (rtsig_max / rtscf->overflow_threshold < rtsig_nr) { 634 if (rtsig_max / rtscf->overflow_threshold < rtsig_nr) {
722 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 635 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
723 "rtsig queue state: %d/%d", 636 "rtsig queue state: %d/%d",
724 rtsig_nr, rtsig_max); 637 rtsig_nr, rtsig_max);
725 while (ngx_rtsig_process_events(cycle) == NGX_OK) { 638 while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK)
639 {
726 /* void */ 640 /* void */
727 } 641 }
728 } 642 }
729 643
730 } else { 644 } else {
732 /* 646 /*
733 * Linux has not KERN_RTSIGMAX since 2.6.6-mm2 647 * Linux has not KERN_RTSIGMAX since 2.6.6-mm2
734 * so drain the rt signal queue unconditionally 648 * so drain the rt signal queue unconditionally
735 */ 649 */
736 650
737 while (ngx_rtsig_process_events(cycle) == NGX_OK) { /* void */ } 651 while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK) {
652 /* void */
653 }
738 } 654 }
739 655
740 tested = 0; 656 tested = 0;
741 } 657 }
742 } 658 }
743 659
744 if (ngx_posted_events) { 660 if (flags & NGX_UPDATE_TIME) {
745 if (ngx_threaded) { 661 ngx_time_update(0, 0);
746 ngx_wakeup_worker_thread(cycle);
747
748 } else {
749 ngx_event_process_posted(cycle);
750 }
751 } 662 }
752 663
753 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, 664 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
754 "rt signal queue overflow recovered"); 665 "rt signal queue overflow recovered");
755 666