Mercurial > hg > nginx

comparison src/event/modules/ngx_kqueue_module.c @ 301:744965ec6275

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.3-2004-03-31-19:26:46 import
author Igor Sysoev <igor@sysoev.ru>
date Wed, 31 Mar 2004 15:26:46 +0000
parents d4e65d74db9f
children 1526e7686b20
comparison
equal deleted inserted replaced
300:502b03d9d2a3 301:744965ec6275
19 static int ngx_kqueue_init(ngx_cycle_t *cycle); 19 static int ngx_kqueue_init(ngx_cycle_t *cycle);
20 static void ngx_kqueue_done(ngx_cycle_t *cycle); 20 static void ngx_kqueue_done(ngx_cycle_t *cycle);
21 static int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags); 21 static int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags);
22 static int ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags); 22 static int ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags);
23 static int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags); 23 static int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags);
24 static int ngx_kqueue_process_events(ngx_log_t *log); 24 static int ngx_kqueue_process_events(ngx_cycle_t *cycle);
25 #if (NGX_THREADS) 25 #if (NGX_THREADS)
26 static void ngx_kqueue_thread_handler(ngx_event_t *ev); 26 static void ngx_kqueue_thread_handler(ngx_event_t *ev);
27 #endif 27 #endif
28 28
29 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle); 29 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
341 341
342 return NGX_OK; 342 return NGX_OK;
343 } 343 }
344 344
345 345
346 static ngx_int_t ngx_kqueue_process_events(ngx_log_t *log) 346 static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle)
347 { 347 {
348 int events; 348 int events;
349 ngx_int_t instance, i; 349 ngx_int_t i, instance;
350 ngx_err_t err; 350 ngx_err_t err;
351 ngx_msec_t timer; 351 ngx_msec_t timer;
352 ngx_event_t *ev; 352 ngx_event_t *ev;
353 ngx_epoch_msec_t delta; 353 ngx_epoch_msec_t delta;
354 struct timeval tv; 354 struct timeval tv;
368 368
369 #endif 369 #endif
370 370
371 ngx_old_elapsed_msec = ngx_elapsed_msec; 371 ngx_old_elapsed_msec = ngx_elapsed_msec;
372 372
373 if (ngx_accept_mutex) {
374 if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
375 return NGX_ERROR;
376 }
377
378 #if 1
379 if (ngx_accept_token == 0 && timer == 0) {
380 /* STUB */ timer = 500;
381 }
382 #endif
383 }
384
373 if (timer) { 385 if (timer) {
374 ts.tv_sec = timer / 1000; 386 ts.tv_sec = timer / 1000;
375 ts.tv_nsec = (timer % 1000) * 1000000; 387 ts.tv_nsec = (timer % 1000) * 1000000;
376 tp = &ts; 388 tp = &ts;
377 389
378 } else { 390 } else {
379 tp = NULL; 391 tp = NULL;
380 } 392 }
381 393
382 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "kevent timer: %d", timer); 394 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
395 "kevent timer: %d", timer);
383 396
384 events = kevent(ngx_kqueue, change_list, nchanges, event_list, nevents, tp); 397 events = kevent(ngx_kqueue, change_list, nchanges, event_list, nevents, tp);
385 398
386 if (events == -1) { 399 if (events == -1) {
387 err = ngx_errno; 400 err = ngx_errno;
392 nchanges = 0; 405 nchanges = 0;
393 406
394 ngx_gettimeofday(&tv); 407 ngx_gettimeofday(&tv);
395 ngx_time_update(tv.tv_sec); 408 ngx_time_update(tv.tv_sec);
396 409
397 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "kevent events: %d", events); 410 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
411 "kevent events: %d", events);
398 412
399 delta = ngx_elapsed_msec; 413 delta = ngx_elapsed_msec;
400 ngx_elapsed_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000 - ngx_start_msec; 414 ngx_elapsed_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000 - ngx_start_msec;
401 415
402 if (err) { 416 if (err) {
403 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT, 417 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
404 log, err, "kevent() failed"); 418 cycle->log, err, "kevent() failed");
419
420 if (ngx_accept_token) {
421 *ngx_accept_mutex = 0;
422 }
423
405 return NGX_ERROR; 424 return NGX_ERROR;
406 } 425 }
407 426
408 if (timer) { 427 if (timer) {
409 delta = ngx_elapsed_msec - delta; 428 delta = ngx_elapsed_msec - delta;
410 429
411 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0, 430 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
412 "kevent timer: %d, delta: %d", timer, (int) delta); 431 "kevent timer: %d, delta: %d", timer, (int) delta);
413 432
414 } else { 433 } else {
415 if (events == 0) { 434 if (events == 0) {
416 ngx_log_error(NGX_LOG_ALERT, log, 0, 435 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
417 "kevent() returned no events without timeout"); 436 "kevent() returned no events without timeout");
437
438 if (ngx_accept_token) {
439 *ngx_accept_mutex = 0;
440 }
441
418 return NGX_ERROR; 442 return NGX_ERROR;
419 } 443 }
420 } 444 }
421 445
422 #if (NGX_THREADS0)
423 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { 446 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
447
448 if (ngx_accept_token) {
449 *ngx_accept_mutex = 0;
450 }
451
424 return NGX_ERROR; 452 return NGX_ERROR;
425 } 453 }
426 #endif
427 454
428 for (i = 0; i < events; i++) { 455 for (i = 0; i < events; i++) {
429 456
430 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0, 457 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
431 458
432 (event_list[i].ident > 0x8000000 459 (event_list[i].ident > 0x8000000
433 && event_list[i].ident != (unsigned) -1) ? 460 && event_list[i].ident != (unsigned) -1) ?
434 "kevent: " PTR_FMT ": ft:%d fl:%04X ff:%08X d:%d ud:" 461 "kevent: " PTR_FMT ": ft:%d fl:%04X ff:%08X d:%d ud:"
435 PTR_FMT: 462 PTR_FMT:
438 event_list[i].ident, event_list[i].filter, 465 event_list[i].ident, event_list[i].filter,
439 event_list[i].flags, event_list[i].fflags, 466 event_list[i].flags, event_list[i].fflags,
440 event_list[i].data, event_list[i].udata); 467 event_list[i].data, event_list[i].udata);
441 468
442 if (event_list[i].flags & EV_ERROR) { 469 if (event_list[i].flags & EV_ERROR) {
443 ngx_log_error(NGX_LOG_ALERT, log, event_list[i].data, 470 ngx_log_error(NGX_LOG_ALERT, cycle->log, event_list[i].data,
444 "kevent() error on %d", event_list[i].ident); 471 "kevent() error on %d", event_list[i].ident);
445 continue; 472 continue;
446 } 473 }
447 474
448 ev = (ngx_event_t *) event_list[i].udata; 475 ev = (ngx_event_t *) event_list[i].udata;
452 case EVFILT_READ: 479 case EVFILT_READ:
453 case EVFILT_WRITE: 480 case EVFILT_WRITE:
454 481
455 instance = (uintptr_t) ev & 1; 482 instance = (uintptr_t) ev & 1;
456 ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1); 483 ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);
457 484 ev->returned_instance = instance;
458 if (ev->active == 0 || ev->instance != instance) { 485
486 if (!ev->active || ev->instance != instance) {
459 487
460 /* 488 /*
461 * the stale event from a file descriptor 489 * the stale event from a file descriptor
462 * that was just closed in this iteration 490 * that was just closed in this iteration
463 */ 491 */
464 492
465 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, 493 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
466 "kevent: stale event " PTR_FMT, ev); 494 "kevent: stale event " PTR_FMT, ev);
467 continue; 495 continue;
468 } 496 }
469 497
470 ev->available = event_list[i].data; 498 ev->available = event_list[i].data;
492 ev->ready = 1; 520 ev->ready = 1;
493 521
494 break; 522 break;
495 523
496 default: 524 default:
497 ngx_log_error(NGX_LOG_ALERT, log, 0, 525 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
498 "unexpected kevent() filter %d", 526 "unexpected kevent() filter %d",
499 event_list[i].filter); 527 event_list[i].filter);
500 continue; 528 continue;
501 } 529 }
502 530
503 #if (NGX_THREADS0) 531
504 532 #if 0
505 if (ngx_threaded) { 533 if (ngx_threaded || ngx_accept_token) {
506 534 #endif
507 if (ev->light) { 535 if (ngx_accept_token) {
508 536
509 /* 537 if (ev->accept) {
510 * The light events are the accept event,
511 * or the event that waits in the mutex queue - we need to
512 * remove it from the mutex queue before the inserting into
513 * the posted events queue.
514 */
515
516 ngx_mutex_unlock(ngx_posted_events_mutex); 538 ngx_mutex_unlock(ngx_posted_events_mutex);
517 539
518 ev->event_handler(ev); 540 ev->event_handler(ev);
519 541
520 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { 542 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
543
544 if (ngx_accept_token) {
545 *ngx_accept_mutex = 0;
546 }
547
521 return NGX_ERROR; 548 return NGX_ERROR;
522 } 549 }
523 550
524 } else { 551 } else {
525 ev->next = ngx_posted_events; 552 ev->next = ngx_posted_events;
527 } 554 }
528 555
529 continue; 556 continue;
530 } 557 }
531 558
532 #endif
533
534 ev->event_handler(ev); 559 ev->event_handler(ev);
535 } 560 }
536 561
537 #if (NGX_THREADS0)
538 ngx_mutex_unlock(ngx_posted_events_mutex); 562 ngx_mutex_unlock(ngx_posted_events_mutex);
539 #endif 563
564 if (ngx_accept_token) {
565 *ngx_accept_mutex = 0;
566 }
540 567
541 if (timer && delta) { 568 if (timer && delta) {
542 ngx_event_expire_timers((ngx_msec_t) delta); 569 ngx_event_expire_timers((ngx_msec_t) delta);
543 } 570 }
544 571
545 #if (NGX_THREADS0) 572 #if (NGX_THREADS)
546 if (!ngx_threaded) { 573 if (ngx_threaded) {
547 } 574 return NGX_OK;
548 #endif 575 }
549 576 #endif
550 /* TODO: non-thread mode only */
551 577
552 for ( ;; ) { 578 for ( ;; ) {
553 579
554 ev = (ngx_event_t *) ngx_posted_events; 580 ev = (ngx_event_t *) ngx_posted_events;
581
582 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
583 "kevent: posted event " PTR_FMT, ev);
555 584
556 if (ev == NULL) { 585 if (ev == NULL) {
557 break; 586 break;
558 } 587 }
559 588
560 ngx_posted_events = ev->next; 589 ngx_posted_events = ev->next;
561 590
591 if ((!ev->posted && !ev->active)
592 || ev->instance != ev->returned_instance)
593 {
594 /*
595 * the stale event from a file descriptor
596 * that was just closed in this iteration
597 */
598
599 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
600 "kevent: stale event " PTR_FMT, ev);
601 continue;
602 }
603
604 if (ev->posted) {
605 ev->posted = 0;
606 }
607
562 ev->event_handler(ev); 608 ev->event_handler(ev);
563 } 609 }
564 610
565 return NGX_OK; 611 return NGX_OK;
566 } 612 }
573 ngx_int_t instance; 619 ngx_int_t instance;
574 620
575 instance = (uintptr_t) ev & 1; 621 instance = (uintptr_t) ev & 1;
576 ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1); 622 ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);
577 623
578 if (ev->active == 0 || ev->instance != instance) { 624 if ((!ev->posted && !ev->active)
579 625 || ev->instance != ev->returned_instance)
626 {
580 /* 627 /*
581 * the stale event from a file descriptor 628 * the stale event from a file descriptor
582 * that was just closed in this iteration 629 * that was just closed in this iteration
583 */ 630 */
584 631
585 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0, 632 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
586 "kevent: stale event " PTR_FMT, ev); 633 "kevent: stale event " PTR_FMT, ev);
587 return; 634 return;
588 } 635 }
589 636
637 if (ev->posted) {
638 ev->posted = 0;
639 }
640
590 ev->event_handler(ev); 641 ev->event_handler(ev);
591 } 642 }
592 643
593 #endif 644 #endif
594 645