Mercurial > hg > nginx
comparison src/event/modules/ngx_devpoll_module.c @ 316:a0beefedaf94
nginx-0.0.3-2004-04-15-00:34:05 import
author | Igor Sysoev <igor@sysoev.ru> |
---|---|
date | Wed, 14 Apr 2004 20:34:05 +0000 |
parents | 4b1a3a4acc60 |
children | 1308b98496a2 |
comparison
equal
deleted
inserted
replaced
315:39b6f2df45c0 | 316:a0beefedaf94 |
---|---|
234 if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) { | 234 if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) { |
235 return NGX_ERROR; | 235 return NGX_ERROR; |
236 } | 236 } |
237 | 237 |
238 ev->active = 0; | 238 ev->active = 0; |
239 ev->posted = 0; | |
239 | 240 |
240 if (flags & NGX_CLOSE_EVENT) { | 241 if (flags & NGX_CLOSE_EVENT) { |
241 return NGX_OK; | 242 return NGX_OK; |
242 } | 243 } |
243 | 244 |
310 | 311 |
311 int ngx_devpoll_process_events(ngx_cycle_t *cycle) | 312 int ngx_devpoll_process_events(ngx_cycle_t *cycle) |
312 { | 313 { |
313 int events; | 314 int events; |
314 ngx_int_t i; | 315 ngx_int_t i; |
315 ngx_uint_t j; | 316 ngx_uint_t j, lock, expire; |
316 size_t n; | 317 size_t n; |
317 ngx_msec_t timer; | 318 ngx_msec_t timer; |
318 ngx_err_t err; | 319 ngx_err_t err; |
319 ngx_cycle_t **old_cycle; | 320 ngx_cycle_t **old_cycle; |
320 ngx_connection_t *c; | 321 ngx_connection_t *c; |
321 ngx_epoch_msec_t delta; | 322 ngx_epoch_msec_t delta; |
322 struct dvpoll dvp; | 323 struct dvpoll dvp; |
323 struct timeval tv; | 324 struct timeval tv; |
324 | 325 |
325 timer = ngx_event_find_timer(); | 326 for ( ;; ) { |
327 timer = ngx_event_find_timer(); | |
328 | |
329 if (timer != 0) { | |
330 break; | |
331 } | |
332 | |
333 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | |
334 "devpoll expired timer"); | |
335 | |
336 ngx_event_expire_timers(0); | |
337 } | |
338 | |
339 /* NGX_TIMER_INFINITE == INFTIM */ | |
340 | |
341 if (timer == NGX_TIMER_INFINITE) { | |
342 expire = 0; | |
343 | |
344 } else { | |
345 expire = 1; | |
346 } | |
347 | |
348 if (ngx_accept_mutex) { | |
349 if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) { | |
350 return NGX_ERROR; | |
351 } | |
352 | |
353 if (ngx_accept_mutex_held == 0 | |
354 && (timer == NGX_TIMER_INFINITE || timer > ngx_accept_mutex_delay)) | |
355 { | |
356 timer = ngx_accept_mutex_delay; | |
357 expire = 0; | |
358 } | |
359 } | |
360 | |
326 ngx_old_elapsed_msec = ngx_elapsed_msec; | 361 ngx_old_elapsed_msec = ngx_elapsed_msec; |
327 | |
328 if (timer == 0) { | |
329 timer = (ngx_msec_t) INFTIM; | |
330 } | |
331 | 362 |
332 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | 363 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, |
333 "devpoll timer: %d", timer); | 364 "devpoll timer: %d", timer); |
334 | 365 |
335 if (nchanges) { | 366 if (nchanges) { |
336 n = nchanges * sizeof(struct pollfd); | 367 n = nchanges * sizeof(struct pollfd); |
337 if (write(dp, change_list, n) != (ssize_t) n) { | 368 if (write(dp, change_list, n) != (ssize_t) n) { |
338 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, | 369 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, |
339 "write(/dev/poll) failed"); | 370 "write(/dev/poll) failed"); |
371 ngx_accept_mutex_unlock(); | |
340 return NGX_ERROR; | 372 return NGX_ERROR; |
341 } | 373 } |
342 } | 374 } |
343 | 375 |
344 dvp.dp_fds = event_list; | 376 dvp.dp_fds = event_list; |
361 ngx_elapsed_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000 - ngx_start_msec; | 393 ngx_elapsed_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000 - ngx_start_msec; |
362 | 394 |
363 if (err) { | 395 if (err) { |
364 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT, | 396 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT, |
365 cycle->log, err, "ioctl(DP_POLL) failed"); | 397 cycle->log, err, "ioctl(DP_POLL) failed"); |
398 ngx_accept_mutex_unlock(); | |
366 return NGX_ERROR; | 399 return NGX_ERROR; |
367 } | 400 } |
368 | 401 |
369 if (timer != (ngx_msec_t) INFTIM) { | 402 if (timer != NGX_TIMER_INFINITE) { |
370 delta = ngx_elapsed_msec - delta; | 403 delta = ngx_elapsed_msec - delta; |
371 | 404 |
372 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0, | 405 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0, |
373 "devpoll timer: %d, delta: %d", timer, (int) delta); | 406 "devpoll timer: %d, delta: %d", timer, (int) delta); |
374 } else { | 407 } else { |
375 if (events == 0) { | 408 if (events == 0) { |
376 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, | 409 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, |
377 "ioctl(DP_POLL) returned no events without timeout"); | 410 "ioctl(DP_POLL) returned no events without timeout"); |
411 ngx_accept_mutex_unlock(); | |
378 return NGX_ERROR; | 412 return NGX_ERROR; |
379 } | 413 } |
380 } | 414 } |
415 | |
416 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { | |
417 ngx_accept_mutex_unlock(); | |
418 return NGX_ERROR; | |
419 } | |
420 | |
421 lock = 1; | |
381 | 422 |
382 for (i = 0; i < events; i++) { | 423 for (i = 0; i < events; i++) { |
383 c = &ngx_cycle->connections[event_list[i].fd]; | 424 c = &ngx_cycle->connections[event_list[i].fd]; |
384 | 425 |
385 if (c->fd == -1) { | 426 if (c->fd == -1) { |
419 "fd:%d ev:%04X rev:%04X", | 460 "fd:%d ev:%04X rev:%04X", |
420 event_list[i].fd, | 461 event_list[i].fd, |
421 event_list[i].events, event_list[i].revents); | 462 event_list[i].events, event_list[i].revents); |
422 } | 463 } |
423 | 464 |
465 if ((event_list[i].events & (POLLOUT|POLLERR|POLLHUP)) | |
466 && c->write->active) | |
467 { | |
468 c->write->ready = 1; | |
469 | |
470 if (!ngx_threaded && !ngx_accept_mutex_held) { | |
471 c->write->event_handler(c->write); | |
472 | |
473 } else { | |
474 ngx_post_event(c->write); | |
475 } | |
476 } | |
477 | |
478 /* | |
479 * POLLIN must be handled after POLLOUT because we use | |
480 * the optimization to avoid the unnecessary mutex locking/unlocking | |
481 * if the accept event is the last one. | |
482 */ | |
483 | |
424 if ((event_list[i].events & (POLLIN|POLLERR|POLLHUP)) | 484 if ((event_list[i].events & (POLLIN|POLLERR|POLLHUP)) |
425 && c->read->active) | 485 && c->read->active) |
426 { | 486 { |
427 c->read->ready = 1; | 487 c->read->ready = 1; |
428 c->read->event_handler(c->read); | 488 |
429 } | 489 if (!ngx_threaded && !ngx_accept_mutex_held) { |
430 | 490 c->read->event_handler(c->read); |
431 if ((event_list[i].events & (POLLOUT|POLLERR|POLLHUP)) | 491 |
432 && c->write->active) | 492 } else if (!c->read->accept) { |
433 { | 493 ngx_post_event(c->read); |
434 c->write->ready = 1; | 494 |
435 c->write->event_handler(c->write); | 495 } else { |
436 } | 496 ngx_mutex_unlock(ngx_posted_events_mutex); |
437 } | 497 |
438 | 498 c->read->event_handler(c->read); |
439 if (timer != (ngx_msec_t) INFTIM && delta) { | 499 |
500 if (i + 1 == events) { | |
501 lock = 0; | |
502 break; | |
503 } | |
504 | |
505 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) { | |
506 ngx_accept_mutex_unlock(); | |
507 return NGX_ERROR; | |
508 } | |
509 } | |
510 } | |
511 } | |
512 | |
513 if (lock) { | |
514 ngx_mutex_unlock(ngx_posted_events_mutex); | |
515 } | |
516 | |
517 ngx_accept_mutex_unlock(); | |
518 | |
519 if (expire && delta) { | |
440 ngx_event_expire_timers((ngx_msec_t) delta); | 520 ngx_event_expire_timers((ngx_msec_t) delta); |
521 } | |
522 | |
523 if (!ngx_threaded) { | |
524 ngx_event_process_posted(cycle); | |
441 } | 525 } |
442 | 526 |
443 return NGX_OK; | 527 return NGX_OK; |
444 } | 528 } |
445 | 529 |