Mercurial > hg > nginx

comparison src/event/modules/ngx_kqueue_module.c @ 306:6b91bfbc4123

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.3-2004-04-05-00:32:09 import
author Igor Sysoev <igor@sysoev.ru>
date Sun, 04 Apr 2004 20:32:09 +0000
parents 4b1a3a4acc60
children ce375c313e96
comparison
equal deleted inserted replaced
305:4b1a3a4acc60 306:6b91bfbc4123
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_cycle_t *cycle); 24 static int ngx_kqueue_process_events(ngx_cycle_t *cycle);
25 #if (NGX_THREADS)
26 static void ngx_kqueue_thread_handler(ngx_event_t *ev);
27 #endif
28 25
29 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle); 26 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
30 static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf); 27 static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf);
31 28
32 29
69 ngx_kqueue_add_event, /* enable an event */ 66 ngx_kqueue_add_event, /* enable an event */
70 ngx_kqueue_del_event, /* disable an event */ 67 ngx_kqueue_del_event, /* disable an event */
71 NULL, /* add an connection */ 68 NULL, /* add an connection */
72 NULL, /* delete an connection */ 69 NULL, /* delete an connection */
73 ngx_kqueue_process_events, /* process the events */ 70 ngx_kqueue_process_events, /* process the events */
74 #if (NGX_THREADS0)
75 ngx_kqueue_thread_handler, /* process an event by thread */
76 #endif
77 ngx_kqueue_init, /* init the events */ 71 ngx_kqueue_init, /* init the events */
78 ngx_kqueue_done /* done the events */ 72 ngx_kqueue_done /* done the events */
79 } 73 }
80 74
81 }; 75 };
159 |NGX_USE_LEVEL_EVENT 153 |NGX_USE_LEVEL_EVENT
160 #endif 154 #endif
161 #if (HAVE_LOWAT_EVENT) 155 #if (HAVE_LOWAT_EVENT)
162 |NGX_HAVE_LOWAT_EVENT 156 |NGX_HAVE_LOWAT_EVENT
163 #endif 157 #endif
158 |NGX_HAVE_INSTANCE_EVENT
164 |NGX_HAVE_KQUEUE_EVENT; 159 |NGX_HAVE_KQUEUE_EVENT;
165 160
166 return NGX_OK; 161 return NGX_OK;
167 } 162 }
168 163
344 339
345 340
346 static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle) 341 static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle)
347 { 342 {
348 int events; 343 int events;
349 ngx_int_t i; 344 ngx_int_t i, instance;
350 ngx_uint_t instance; 345 ngx_uint_t lock, expire;
351 ngx_err_t err; 346 ngx_err_t err;
352 ngx_msec_t timer; 347 ngx_msec_t timer;
353 ngx_event_t *ev; 348 ngx_event_t *ev;
354 ngx_epoch_msec_t delta; 349 ngx_epoch_msec_t delta;
355 struct timeval tv; 350 struct timeval tv;
362 return NGX_ERROR; 357 return NGX_ERROR;
363 } 358 }
364 359
365 /* 360 /*
366 * TODO: if timer is 0 and any worker thread is still busy 361 * TODO: if timer is 0 and any worker thread is still busy
367 * then set 1 second timeout 362 * then set 500 ms timeout
368 */ 363 */
369 364
370 #endif 365 #endif
371 366
372 ngx_old_elapsed_msec = ngx_elapsed_msec; 367 ngx_old_elapsed_msec = ngx_elapsed_msec;
368 expire = 1;
373 369
374 if (ngx_accept_mutex) { 370 if (ngx_accept_mutex) {
375 if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) { 371 if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
376 return NGX_ERROR; 372 return NGX_ERROR;
377 } 373 }
378 374
379 #if 1 375 if (ngx_accept_mutex_held == 0
380 if (ngx_accept_mutex_held == 0 && timer == 0) { 376 && (timer == 0 || timer > ngx_accept_mutex_delay))
381 /* STUB */ timer = 500; 377 {
382 } 378 timer = ngx_accept_mutex_delay;
383 #endif 379 expire = 0;
380 }
384 } 381 }
385 382
386 if (timer) { 383 if (timer) {
387 ts.tv_sec = timer / 1000; 384 ts.tv_sec = timer / 1000;
388 ts.tv_nsec = (timer % 1000) * 1000000; 385 ts.tv_nsec = (timer % 1000) * 1000000;
389 tp = &ts; 386 tp = &ts;
390 387
391 } else { 388 } else {
392 tp = NULL; 389 tp = NULL;
390 expire = 0;
393 } 391 }
394 392
395 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 393 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
396 "kevent timer: %d", timer); 394 "kevent timer: %d", timer);
397 395
439 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { 437 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
440 ngx_accept_mutex_unlock(); 438 ngx_accept_mutex_unlock();
441 return NGX_ERROR; 439 return NGX_ERROR;
442 } 440 }
443 441
442 lock = 1;
443
444 for (i = 0; i < events; i++) { 444 for (i = 0; i < events; i++) {
445 445
446 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 446 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
447 447
448 (event_list[i].ident > 0x8000000 448 (event_list[i].ident > 0x8000000
515 "unexpected kevent() filter %d", 515 "unexpected kevent() filter %d",
516 event_list[i].filter); 516 event_list[i].filter);
517 continue; 517 continue;
518 } 518 }
519 519
520 520 if (!ngx_threaded && !ngx_accept_mutex_held) {
521 if (ngx_threaded || ngx_accept_mutex_held) { 521 ev->event_handler(ev);
522
523 if (ev->accept) {
524 ngx_mutex_unlock(ngx_posted_events_mutex);
525
526 ev->event_handler(ev);
527
528 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
529 ngx_accept_mutex_unlock();
530 return NGX_ERROR;
531 }
532
533 } else {
534 ev->next = (ngx_event_t *) ngx_posted_events;
535 ngx_posted_events = ev;
536 }
537
538 continue; 522 continue;
539 } 523 }
540 524
525 if (!ev->accept) {
526 ngx_post_event(ev);
527 continue;
528 }
529
530 ngx_mutex_unlock(ngx_posted_events_mutex);
531
541 ev->event_handler(ev); 532 ev->event_handler(ev);
542 } 533
543 534 if (i + 1 == events) {
544 ngx_mutex_unlock(ngx_posted_events_mutex); 535 lock = 0;
536 break;
537 }
538
539 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
540 ngx_accept_mutex_unlock();
541 return NGX_ERROR;
542 }
543 }
544
545 if (lock) {
546 ngx_mutex_unlock(ngx_posted_events_mutex);
547 }
545 548
546 ngx_accept_mutex_unlock(); 549 ngx_accept_mutex_unlock();
547 550
548 if (timer && delta) { 551 if (expire && delta) {
549 ngx_event_expire_timers((ngx_msec_t) delta); 552 ngx_event_expire_timers((ngx_msec_t) delta);
550 } 553 }
551 554
552 if (ngx_threaded) { 555 if (!ngx_threaded) {
553 return NGX_OK; 556 ngx_event_process_posted(cycle);
554 }
555
556 for ( ;; ) {
557
558 ev = (ngx_event_t *) ngx_posted_events;
559
560 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
561 "kevent: posted event " PTR_FMT, ev);
562
563 if (ev == NULL) {
564 break;
565 }
566
567 ngx_posted_events = ev->next;
568
569 if ((!ev->posted && !ev->active)
570 || ev->instance != ev->returned_instance)
571 {
572 /*
573 * the stale event from a file descriptor
574 * that was just closed in this iteration
575 */
576
577 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
578 "kevent: stale event " PTR_FMT, ev);
579 continue;
580 }
581
582 if (ev->posted) {
583 ev->posted = 0;
584 }
585
586 ev->event_handler(ev);
587 } 557 }
588 558
589 return NGX_OK; 559 return NGX_OK;
590 } 560 }
591
592
593 #if (NGX_THREADS)
594
595 static void ngx_kqueue_thread_handler(ngx_event_t *ev)
596 {
597 if ((!ev->posted && !ev->active)
598 || ev->instance != ev->returned_instance)
599 {
600 /*
601 * the stale event from a file descriptor
602 * that was just closed in this iteration
603 */
604
605 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
606 "kevent: stale event " PTR_FMT, ev);
607 return;
608 }
609
610 if (ev->posted) {
611 ev->posted = 0;
612 }
613
614 ev->event_handler(ev);
615 }
616
617 #endif
618 561
619 562
620 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle) 563 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle)
621 { 564 {
622 ngx_kqueue_conf_t *kcf; 565 ngx_kqueue_conf_t *kcf;