nginx: src/event/modules/ngx_rtsig

comparison src/event/modules/ngx_rtsig_module.c @ 381:02a511569afb

nginx-0.0.7-2004-07-07-19:01:00 import

author	Igor Sysoev <igor@sysoev.ru>
date	Wed, 07 Jul 2004 15:01:00 +0000
parents	5ce6561246a5
children	449c4885dcd1

comparison

equal deleted inserted replaced

-:5ce6561246a5
+:02a511569afb
 ngx_io = ngx_os_io;
 ngx_event_actions = ngx_rtsig_module_ctx.actions;
-ngx_event_flags = NGX_USE_RTSIG_EVENT
+ngx_event_flags = NGX_USE_RTSIG_EVENT|NGX_HAVE_GREEDY_EVENT;
-|NGX_HAVE_GREEDY_EVENT
-|NGX_HAVE_INSTANCE_EVENT;
 return NGX_OK;
 }
 ngx_uint_t          expire;
 size_t              n;
 ngx_msec_t          timer;
 ngx_err_t           err;
 siginfo_t           si;
+ngx_event_t        *rev, *wev;
 struct timeval      tv;
 struct timespec     ts, *tp;
 struct sigaction    sa;
 ngx_epoch_msec_t    delta;
 ngx_connection_t   *c;
 } else {
 for ( ;; ) {
 timer = ngx_event_find_timer();
+#if (NGX_THREADS)
+if (timer == NGX_TIMER_ERROR) {
+return NGX_ERROR;
+}
+if (timer == NGX_TIMER_INFINITE || timer > 500) {
+timer = 500;
+break;
+}
+#endif
 if (timer != 0) {
 break;
 }
 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 "rtsig expired timer");
 ngx_event_expire_timers((ngx_msec_t)
 (ngx_elapsed_msec - ngx_old_elapsed_msec));
+if (ngx_posted_events && ngx_threaded) {
+ngx_wakeup_worker_thread(cycle);
+}
 }
 expire = 1;
 if (ngx_accept_mutex) {
 ngx_old_elapsed_msec = ngx_elapsed_msec;
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 "rtsig timer: %d", timer);
-/* Linux sigwaitinfo() is sigtimedwait() with the NULL timeout pointer */
+/* Linux's sigwaitinfo() is sigtimedwait() with the NULL timeout pointer */
 signo = sigtimedwait(&set, &si, tp);
 if (signo == -1) {
 err = ngx_errno;
 c = &ngx_cycle->connections[si.si_fd];
 instance = signo - rtscf->signo;
-if (si.si_band & POLLIN) {
+rev = c->read;
-c->read->returned_instance = instance;
-}
-if (si.si_band & POLLOUT) {
-c->write->returned_instance = instance;
-}
 if (c->read->instance != instance) {
 /*
 * the stale event from a file descriptor
 * that was just closed in this iteration
 return NGX_OK;
 }
 if (si.si_band & (POLLIN|POLLHUP|POLLERR)) {
-if (c->read->active) {
+if (rev->active) {
-c->read->ready = 1;
+if (ngx_threaded && !rev->accept) {
-if (!ngx_threaded && !ngx_accept_mutex_held) {
-c->read->event_handler(c->read);
-} else if (c->read->accept) {
-if (ngx_accept_disabled <= 0) {
-c->read->event_handler(c->read);
-}
-} else {
 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
 ngx_accept_mutex_unlock();
 return NGX_ERROR;
 }
-ngx_post_event(c->read);
+rev->posted_ready = 1;
+ngx_post_event(rev);
 ngx_mutex_unlock(ngx_posted_events_mutex);
+} else {
+rev->ready = 1;
+if (!ngx_threaded && !ngx_accept_mutex_held) {
+rev->event_handler(rev);
+} else if (rev->accept) {
+if (ngx_accept_disabled <= 0) {
+rev->event_handler(rev);
+}
+} else {
+ngx_post_event(rev);
+}
 }
 }
 }
+wev = c->write;
 if (si.si_band & (POLLOUT|POLLHUP|POLLERR)) {
-if (c->write->active) {
+if (wev->active) {
-c->write->ready = 1;
+if (ngx_threaded) {
-if (!ngx_threaded && !ngx_accept_mutex_held) {
-c->write->event_handler(c->write);
-} else {
 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
 ngx_accept_mutex_unlock();
 return NGX_ERROR;
 }
-ngx_post_event(c->write);
+wev->posted_ready = 1;
+ngx_post_event(wev);
 ngx_mutex_unlock(ngx_posted_events_mutex);
+} else {
+wev->ready = 1;
+if (!ngx_threaded && !ngx_accept_mutex_held) {
+wev->event_handler(wev);
+} else {
+ngx_post_event(wev);
+}
 }
 }
 }
 } else if (signo == SIGIO) {
 if (expire && delta) {
 ngx_event_expire_timers((ngx_msec_t) delta);
 }
-if (!ngx_threaded) {
+if (ngx_posted_events) {
-ngx_event_process_posted(cycle);
+if (ngx_threaded) {
+ngx_wakeup_worker_thread(cycle);
+} else {
+ngx_event_process_posted(cycle);
+}
 }
 if (signo == -1) {
 return NGX_AGAIN;
 } else {
 {
 int                name[2], rtsig_max, rtsig_nr, events, ready;
 size_t             len;
 ngx_int_t          tested, n, i;
 ngx_err_t          err;
+ngx_event_t       *rev, *wev;
 ngx_connection_t  *c;
 ngx_rtsig_conf_t  *rtscf;
 rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
 err = ngx_errno;
 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
 cycle->log, 0,
 "poll() failed while the overflow recover");
-if (err == NGX_EINTR) {
+if (err != NGX_EINTR) {
-continue;
+break;
 }
 }
-break;
 }
 if (ready <= 0) {
 continue;
 }
+if (n) {
+if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
+return NGX_ERROR;
+}
+}
 for (i = 0; i < n; i++) {
 c = &cycle->connections[overflow_list[i].fd];
+rev = c->read;
 if (overflow_list[i].revents & (POLLIN|POLLERR|POLLHUP|POLLNVAL)) {
 tested++;
-c->read->ready = 1;
+if (ngx_threaded) {
-if (!ngx_threaded) {
+rev->posted_ready = 1;
-c->read->event_handler(c->read);
+ngx_post_event(rev);
 } else {
-if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
+rev->ready = 1;
-return NGX_ERROR;
+rev->event_handler(rev);
-}
-ngx_post_event(c->read);
-c->read->returned_instance = c->read->instance;
-ngx_mutex_unlock(ngx_posted_events_mutex);
 }
 }
+wev = c->write;
 if (overflow_list[i].revents & (POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
 tested++;
-c->write->ready = 1;
+if (ngx_threaded) {
-if (!ngx_threaded) {
+wev->posted_ready = 1;
-c->write->event_handler(c->write);
+ngx_post_event(wev);
 } else {
-if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
+wev->ready = 1;
-return NGX_ERROR;
+wev->event_handler(wev);
-}
-ngx_post_event(c->write);
-c->write->returned_instance = c->write->instance;
-ngx_mutex_unlock(ngx_posted_events_mutex);
 }
 }
+}
+if (n) {
+ngx_mutex_unlock(ngx_posted_events_mutex);
 }
 if (tested >= rtscf->overflow_test) {
 /*
 tested = 0;
 }
 }
-if (!ngx_threaded) {
+if (ngx_posted_events) {
-ngx_event_process_posted(cycle);
+if (ngx_threaded) {
+ngx_wakeup_worker_thread(cycle);
+} else {
+ngx_event_process_posted(cycle);
+}
 }
 ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
 "rt signal queue overflow recovered");

Mercurial > hg > nginx

comparison src/event/modules/ngx_rtsig_module.c @ 381:02a511569afb