IntenseWebs/nginx
3
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2024-12-27 09:21:18 -06:00
Code Issues Packages Projects Releases Wiki Activity

nginx-0.0.2-2004-02-17-20:53:12 import

Browse Source
This commit is contained in:
Igor Sysoev 2004-02-17 17:53:12 +00:00
parent 7b6062a1b8
commit 9139cd2351
8 changed files with 352 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
auto/modules
View File

@ -1,4 +1,10 @@
if [ $EVENT_RTSIG = YES ]; then
have=HAVE_RTSIG . auto/have
EVENT_MODULES="$EVENT_MODULES $RTSIG_MODULE"
CORE_SRCS="$CORE_SRCS $RTSIG_SRCS"
fi
if [ $EVENT_SELECT = NO -a $EVENT_FOUND = NO ]; then
EVENT_SELECT=YES
fi
@ -20,21 +26,24 @@ fi
if [ $TEST_BUILD_DEVPOLL = YES ]; then
CFLAGS="$CFLAGS -D HAVE_DEVPOLL=1 -D TEST_BUILD_DEVPOLL=1"
have=HAVE_DEVPOLL . auto/have
have=TEST_BUILD_DEVPOLL . auto/have
EVENT_MODULES="$EVENT_MODULES $DEVPOLL_MODULE"
CORE_SRCS="$CORE_SRCS $DEVPOLL_SRCS"
fi
if [ $TEST_BUILD_EPOLL = YES ]; then
CFLAGS="$CFLAGS -D HAVE_EPOLL=1 -D TEST_BUILD_EPOLL=1"
have=HAVE_EPOLL . auto/have
have=TEST_BUILD_EPOLL . auto/have
EVENT_MODULES="$EVENT_MODULES $EPOLL_MODULE"
CORE_SRCS="$CORE_SRCS $EPOLL_SRCS"
fi
if [ $TEST_BUILD_SIGIO = YES ]; then
CFLAGS="$CFLAGS -D HAVE_SIGIO=1 -D TEST_BUILD_SIGIO=1"
EVENT_MODULES="$EVENT_MODULES $SIGIO_MODULE"
CORE_SRCS="$CORE_SRCS $SIGIO_SRCS"
if [ $TEST_BUILD_RTSIG = YES ]; then
have=HAVE_RTSIG . auto/have
have=TEST_BUILD_RTSIG . auto/have
EVENT_MODULES="$EVENT_MODULES $RTSIG_MODULE"
CORE_SRCS="$CORE_SRCS $RTSIG_SRCS"
fi

6
auto/options
View File

@ -6,10 +6,11 @@ OBJS=objs
TEST_BUILD_DEVPOLL=NO
TEST_BUILD_EPOLL=NO
TEST_BUILD_SIGIO=NO
TEST_BUILD_RTSIG=NO
EVENT_FOUND=NO
EVENT_RTSIG=NO
EVENT_SELECT=NO
EVENT_POLL=NO
EVENT_AIO=NO
@ -43,6 +44,7 @@ do
--builddir=*) OBJS="$value" ;;
--with-rtsig_module) EVENT_RTSIG=YES ;;
--with-select_module) EVENT_SELECT=YES ;;
--without-select_module) EVENT_SELECT=NONE ;;
--with-poll_module) EVENT_POLL=YES ;;
@ -63,7 +65,7 @@ do
--test-build-devpoll) TEST_BUILD_DEVPOLL=YES ;;
--test-build-epoll) TEST_BUILD_EPOLL=YES ;;
--test-build-sigio) TEST_BUILD_SIGIO=YES ;;
--test-build-rtsig) TEST_BUILD_RTSIG=YES ;;
*)
echo "$0: error: invalid option \"$option\""

3
auto/os/freebsd
View File

@ -4,6 +4,9 @@ CORE_DEPS="$UNIX_DEPS $FREEBSD_DEPS"
CORE_SRCS="$UNIX_SRCS $FREEBSD_SRCS"
# __FreeBSD_version is the best way to learn when
# some capability appeared or became safe to use
version=`grep "#define __FreeBSD_version" /usr/include/osreldate.h \
| sed -e 's/^.* \(.*\)$/\1/'`

4
auto/sources
View File

@ -76,8 +76,8 @@ DEVPOLL_SRCS=src/event/modules/ngx_devpoll_module.c
EPOLL_MODULE=ngx_epoll_module
EPOLL_SRCS=src/event/modules/ngx_epoll_module.c
SIGIO_MODULE=ngx_sigio_module
SIGIO_SRCS=src/event/modules/ngx_sigio_module.c
RTSIG_MODULE=ngx_rtsig_module
RTSIG_SRCS=src/event/modules/ngx_rtsig_module.c
IOCP_MODULE=ngx_iocp_module
IOCP_SRCS=src/event/modules/ngx_iocp_module.c

315
src/event/modules/ngx_rtsig_module.c Normal file
View File

@ -0,0 +1,315 @@
/*
* Copyright (C) 2002-2004 Igor Sysoev, http://sysoev.ru/en/
*/
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_event.h>
#if (TEST_BUILD_RTSIG)
#define F_SETSIG 10
#define SIGRTMIN 33
#define si_fd __spare__[0]
int sigwaitinfo(const sigset_t *set, siginfo_t *info);
int sigtimedwait(const sigset_t *set, siginfo_t *info,
const struct timespec *timeout);
int sigwaitinfo(const sigset_t *set, siginfo_t *info)
{
return -1;
}
int sigtimedwait(const sigset_t *set, siginfo_t *info,
const struct timespec *timeout)
{
return -1;
}
#endif
typedef struct {
int signo;
} ngx_rtsig_conf_t;
static int ngx_rtsig_init(ngx_cycle_t *cycle);
static void ngx_rtsig_done(ngx_cycle_t *cycle);
static int ngx_rtsig_add_connection(ngx_connection_t *c);
static int ngx_rtsig_del_connection(ngx_connection_t *c);
static int ngx_rtsig_process_events(ngx_log_t *log);
static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle);
static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf);
static sigset_t set;
static ngx_str_t rtsig_name = ngx_string("rtsig");
static ngx_command_t ngx_rtsig_commands[] = {
{ngx_string("rtsig_signo"),
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_conf_set_num_slot,
0,
offsetof(ngx_rtsig_conf_t, signo),
NULL},
ngx_null_command
};
ngx_event_module_t ngx_rtsig_module_ctx = {
&rtsig_name,
ngx_rtsig_create_conf, /* create configuration */
ngx_rtsig_init_conf, /* init configuration */
{
NULL, /* add an event */
NULL, /* delete an event */
NULL, /* enable an event */
NULL, /* disable an event */
ngx_rtsig_add_connection, /* add an connection */
ngx_rtsig_del_connection, /* delete an connection */
ngx_rtsig_process_events, /* process the events */
ngx_rtsig_init, /* init the events */
ngx_rtsig_done, /* done the events */
}
};
ngx_module_t ngx_rtsig_module = {
NGX_MODULE,
&ngx_rtsig_module_ctx, /* module context */
ngx_rtsig_commands, /* module directives */
NGX_EVENT_MODULE, /* module type */
NULL, /* init module */
NULL /* init child */
};
static int ngx_rtsig_init(ngx_cycle_t *cycle)
{
ngx_rtsig_conf_t *rtscf;
rtscf = ngx_event_get_conf(cycle->conf_ctx, ngx_rtsig_module);
sigemptyset(&set);
sigaddset(&set, rtscf->signo);
sigaddset(&set, SIGIO);
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
"sigprocmask() failed");
return NGX_ERROR;
}
ngx_io = ngx_os_io;
ngx_event_actions = ngx_rtsig_module_ctx.actions;
ngx_event_flags = NGX_USE_SIGIO_EVENT;
return NGX_OK;
}
static void ngx_rtsig_done(ngx_cycle_t *cycle)
{
}
static int ngx_rtsig_add_connection(ngx_connection_t *c)
{
ngx_rtsig_conf_t *rtscf;
rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"rtsig add connection: fd:%d signo:%d", c->fd, rtscf->signo);
if (fcntl(c->fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(O_RDWR|O_NONBLOCK|O_ASYNC) failed");
return NGX_ERROR;
}
if (fcntl(c->fd, F_SETSIG, rtscf->signo) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(F_SETSIG) failed");
return NGX_ERROR;
}
if (fcntl(c->fd, F_SETOWN, ngx_getpid()) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(F_SETOWN) failed");
return NGX_ERROR;
}
#if (HAVE_ONESIGFD)
if (fcntl(c->fd, F_SETAUXFL, O_ONESIGFD) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(F_SETAUXFL) failed");
return NGX_ERROR;
}
#endif
c->read->active = 1;
c->write->active = 1;
return NGX_OK;
}
static int ngx_rtsig_del_connection(ngx_connection_t *c)
{
c->read->active = 0;
c->write->active = 0;
return NGX_OK;
}
int ngx_rtsig_process_events(ngx_log_t *log)
{
int signo;
ngx_int_t instance, i;
size_t n;
ngx_msec_t timer;
ngx_err_t err;
ngx_cycle_t **cycle;
siginfo_t si;
struct timeval tv;
struct timespec ts;
struct sigaction sa;
ngx_connection_t *c;
ngx_epoch_msec_t delta;
ngx_rtsig_conf_t *rtscf;
timer = ngx_event_find_timer();
ngx_old_elapsed_msec = ngx_elapsed_msec;
if (timer) {
ts.tv_sec = timer / 1000;
ts.tv_nsec = (timer % 1000) * 1000000;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "rtsig timer: %d", timer);
if (timer) {
signo = sigtimedwait(&set, &si, &ts);
} else {
signo = sigwaitinfo(&set, &si);
}
if (signo == -1) {
err = ngx_errno;
} else {
err = 0;
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_elapsed_msec;
ngx_elapsed_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000 - ngx_start_msec;
if (signo == -1) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
log, err,
timer ? "sigtimedwait() failed" : "sigwaitinfo() failed");
return NGX_ERROR;
}
if (timer) {
delta = ngx_elapsed_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
"rtsig timer: %d, delta: %d", timer, (int) delta);
}
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, log, 0,
"signo:%d fd:%d band:%X", signo, si.si_fd, si.si_band);
rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
if (signo == rtscf->signo) {
/* TODO: old_cycles */
c = &ngx_cycle->connections[si.si_fd];
/* TODO: stale signals */
if (si.si_band & (POLLIN|POLLHUP|POLLERR)) {
if (c->read->active) {
c->read->ready = 1;
c->read->event_handler(c->read);
}
}
if (si.si_band & (POLLOUT|POLLHUP|POLLERR)) {
if (c->write->active) {
c->write->ready = 1;
c->write->event_handler(c->write);
}
}
} else if (signo == SIGIO) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"signal queue overflowed: "
"SIGIO, fd:%d, band:%X", si.si_fd, si.si_band);
ngx_memzero(&sa, sizeof(struct sigaction));
sa.sa_handler = SIG_DFL;
sigemptyset(&sa.sa_mask);
if (sigaction(rtscf->signo, &sa, NULL) == -1) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"sigaction(%d, SIG_DFL) failed", rtscf->signo);
}
} else {
ngx_log_error(NGX_LOG_ALERT, log, 0,
timer ? "sigtimedwait() returned unexpected signal: %d":
"sigwaitinfo() returned unexpected signal: %d",
signo);
return NGX_ERROR;
}
if (timer != (ngx_msec_t) -1 && delta) {
ngx_event_expire_timers((ngx_msec_t) delta);
}
return NGX_OK;
}
static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle)
{
ngx_rtsig_conf_t *rtscf;
ngx_test_null(rtscf, ngx_palloc(cycle->pool, sizeof(ngx_rtsig_conf_t)),
NGX_CONF_ERROR);
rtscf->signo = NGX_CONF_UNSET;
return rtscf;
}
static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf)
{
ngx_rtsig_conf_t *rtscf = conf;
/* LinuxThreads use the first 3 RT signals */
ngx_conf_init_value(rtscf->signo, SIGRTMIN + 10);
return NGX_CONF_OK;
}

379
src/event/modules/ngx_sigio_module.c
View File

@ -1,379 +0,0 @@
/*
* Copyright (C) 2002-2004 Igor Sysoev, http://sysoev.ru/en/
*/
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_event.h>
#if (TEST_BUILD_SIGIO)
#define F_SETSIG 10
#define POLL_IN POLLIN
#define POLL_OUT POLLOUT
#endif
typedef struct {
int signo;
} ngx_sigio_conf_t;
static int ngx_sigio_init(ngx_cycle_t *cycle);
static void ngx_sigio_done(ngx_cycle_t *cycle);
static int ngx_sigio_add_event(ngx_event_t *ev, int event, u_int flags);
static int ngx_sigio_del_event(ngx_event_t *ev, int event, u_int flags);
static int ngx_sigio_add_connection(ngx_connection_t *c);
static int ngx_sigio_del_connection(ngx_connection_t *c);
static int ngx_sigio_process_events(ngx_log_t *log);
static void *ngx_sigio_create_conf(ngx_cycle_t *cycle);
static char *ngx_sigio_init_conf(ngx_cycle_t *cycle, void *conf);
static sigset_t set;
static ngx_str_t sigio_name = ngx_string("sigio");
static ngx_command_t ngx_sigio_commands[] = {
{ngx_string("sigio_signal"),
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_conf_set_num_slot,
0,
offsetof(ngx_sigio_conf_t, signo),
NULL},
ngx_null_command
};
ngx_event_module_t ngx_sigio_module_ctx = {
&sigio_name,
ngx_sigio_create_conf, /* create configuration */
ngx_sigio_init_conf, /* init configuration */
{
ngx_sigio_add_event, /* add an event */
ngx_sigio_del_event, /* delete an event */
ngx_sigio_add_event, /* enable an event */
ngx_sigio_del_event, /* disable an event */
ngx_sigio_add_connection, /* add an connection */
ngx_sigio_del_connection, /* delete an connection */
ngx_sigio_process_events, /* process the events */
ngx_sigio_init, /* init the events */
ngx_sigio_done, /* done the events */
}
};
ngx_module_t ngx_sigio_module = {
NGX_MODULE,
&ngx_sigio_module_ctx, /* module context */
ngx_sigio_commands, /* module directives */
NGX_EVENT_MODULE, /* module type */
NULL, /* init module */
NULL /* init child */
};
static int ngx_sigio_init(ngx_cycle_t *cycle)
{
ngx_sigio_conf_t *sgcf;
sgcf = ngx_event_get_conf(cycle->conf_ctx, ngx_sigio_module);
sigemptyset(&set);
sigaddset(&set, sgcf->signo);
sigaddset(&set, SIGIO);
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
"sigprocmask() failed");
return NGX_ERROR;
}
ngx_io = ngx_os_io;
ngx_event_actions = ngx_sigio_module_ctx.actions;
ngx_event_flags = NGX_USE_SIGIO_EVENT;
return NGX_OK;
}
static void ngx_sigio_done(ngx_cycle_t *cycle)
{
}
static int ngx_sigio_add_event(ngx_event_t *ev, int event, u_int flags)
{
ngx_connection_t *c;
c = ev->data;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sigio add event: fd:%d ev:%04X", c->fd, event);
return NGX_OK;
}
static int ngx_sigio_del_event(ngx_event_t *ev, int event, u_int flags)
{
ngx_connection_t *c;
c = ev->data;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sigio del event: fd:%d ev:%04X", c->fd, event);
return NGX_OK;
}
static int ngx_sigio_add_connection(ngx_connection_t *c)
{
ngx_sigio_conf_t *sgcf;
sgcf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_sigio_module);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sigio add connection: fd:%d signo:%d", c->fd, sgcf->signo);
if (fcntl(c->fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(O_RDWR|O_NONBLOCK|O_ASYNC) failed");
return NGX_ERROR;
}
if (fcntl(c->fd, F_SETSIG, sgcf->signo) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(F_SETSIG) failed");
return NGX_ERROR;
}
if (fcntl(c->fd, F_SETOWN, ngx_getpid()) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(F_SETOWN) failed");
return NGX_ERROR;
}
#if (HAVE_ONESIGFD)
if (fcntl(c->fd, F_SETAUXFL, O_ONESIGFD) == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
"fcntl(F_SETAUXFL) failed");
return NGX_ERROR;
}
#endif
c->read->active = 1;
c->write->active = 1;
return NGX_OK;
}
static int ngx_sigio_del_connection(ngx_connection_t *c)
{
c->read->active = 0;
c->write->active = 0;
return NGX_OK;
}
int ngx_sigio_process_events(ngx_log_t *log)
{
int signo;
ngx_int_t instance, i;
size_t n;
ngx_msec_t timer;
ngx_err_t err;
ngx_cycle_t **cycle;
siginfo_t si;
struct timeval tv;
struct timespec ts;
struct sigaction sa;
ngx_connection_t *c;
ngx_epoch_msec_t delta;
ngx_sigio_conf_t *sgcf;
timer = ngx_event_find_timer();
ngx_old_elapsed_msec = ngx_elapsed_msec;
if (timer) {
ts.tv_sec = timer / 1000;
ts.tv_nsec = (timer % 1000) * 1000000;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "sigio timer: %d", timer);
if (timer) {
signo = sigtimedwait(&set, &si, &ts);
} else {
signo = sigwaitinfo(&set, &si);
}
if (signo == -1) {
err = ngx_errno;
} else {
err = 0;
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_elapsed_msec;
ngx_elapsed_msec = tv.tv_sec * 1000 + tv.tv_usec / 1000 - ngx_start_msec;
if (err == -1) {
ngx_log_error(NGX_LOG_ALERT, c->log, err,
timer ? "sigtimedwait() failed" : "sigwaitinfo() failed");
return NGX_ERROR;
}
if (timer) {
delta = ngx_elapsed_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0,
"sigio timer: %d, delta: %d", timer, (int) delta);
}
sgcf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_sigio_module);
if (signo == sgcf->signo) {
/* STUB: old_cycles */
c = &ngx_cycle->connections[si.si_fd];
if (si.si_band & POLL_IN) {
if (!c->read->active) {
continue;
}
c->read->ready = 1;
c->read->event_handler(c->read);
}
if (si.si_band & POLL_OUT) {
if (!c->read->active) {
continue;
}
c->read->ready = 1;
c->read->event_handler(c->read);
}
} else if (signo == SIGIO) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"signal queue overflowed: "
"SIGIO, fd:%d, band:%d", si.si_fd, si.si_band);
ngx_memzero(&sa, sizeof(struct sigaction));
sa.sa_sigaction = SIG_DFL;
sigemptyset(&sa.sa_mask);
if (sigaction(sgcf->signo, &sa, NULL) == -1) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"sigaction queue overflowed: "
"SIGIO, fd:%d, band:%d", si.si_fd, si.si_band);
}
} else {
ngx_log_error(NGX_LOG_ALERT, log, 0,
timer ? "sigtimedwait() returned unexpected signal: %d":
"sigwaitinfo() returned unexpected signal: %d",
signo);
return NGX_ERROR;
}
}
for (i = 0; i < events; i++) {
c = event_list[i].data.ptr;
instance = (uintptr_t) c & 1;
c = (ngx_connection_t *) ((uintptr_t) c & (uintptr_t) ~1);
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, log, 0,
"sigio: fd:%d ev:%04X d:" PTR_FMT,
c->fd, event_list[i].events, event_list[i].data);
if (c->read->instance != instance) {
/*
* it's a stale event from a file descriptor
* that was just closed in this iteration
*/
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
"sigio: stale event " PTR_FMT, c);
continue;
}
if (event_list[i].events & EPOLLOUT) {
if (!c->write->active) {
continue;
}
c->write->ready = 1;
c->write->event_handler(c->write);
}
if (event_list[i].events & (EPOLLERR|EPOLLHUP)) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"sigio_wait() error on fd:%d ev:%d",
c->fd, event_list[i].events);
continue;
}
if (event_list[i].events & ~(EPOLLIN|EPOLLOUT)) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"sigio_wait() returned strange events on fd:%d ev:%d",
c->fd, event_list[i].events);
}
}
if (timer != (ngx_msec_t) -1 && delta) {
ngx_event_expire_timers((ngx_msec_t) delta);
}
return NGX_OK;
}
static void *ngx_sigio_create_conf(ngx_cycle_t *cycle)
{
ngx_sigio_conf_t *sgcf;
ngx_test_null(sgcf, ngx_palloc(cycle->pool, sizeof(ngx_sigio_conf_t)),
NGX_CONF_ERROR);
sgcf->events = NGX_CONF_UNSET;
return epcf;
}
static char *ngx_sigio_init_conf(ngx_cycle_t *cycle, void *conf)
{
ngx_sigio_conf_t *sgcf = conf;
/* LinuxThreads uses the first 3 RT signals */
ngx_conf_init_unsigned_value(sgcf->signo, SIGRTMIN + 10);
return NGX_CONF_OK;
}

7
src/event/ngx_event.c
View File

@ -264,7 +264,12 @@ static int ngx_event_init(ngx_cycle_t *cycle)
#else
rev->event_handler = &ngx_event_accept;
ngx_add_event(rev, NGX_READ_EVENT, 0);
if (ngx_event_flags & NGX_USE_SIGIO_EVENT) {
ngx_add_conn(c);
} else {
ngx_add_event(rev, NGX_READ_EVENT, 0);
}
#endif
}

10
src/event/ngx_event_accept.c
View File

@ -94,9 +94,13 @@ void ngx_event_accept(ngx_event_t *ev)
err = ngx_socket_errno;
if (err == NGX_EAGAIN) {
ngx_log_error(NGX_LOG_NOTICE, log, err,
"EAGAIN after %d accepted connection(s)",
accepted);
if (!(ngx_event_flags
& (NGX_USE_EDGE_EVENT|NGX_USE_SIGIO_EVENT)))
{
ngx_log_error(NGX_LOG_NOTICE, log, err,
"EAGAIN after %d accepted connection(s)",
accepted);
}
ngx_destroy_pool(pool);
return;