mirror/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2025-06-07 17:52:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

nginx-0.0.1-2002-12-24-20:30:59 import

Browse Source
This commit is contained in:
Igor Sysoev 2002-12-24 17:30:59 +00:00
parent 0d2bda5374
commit 3a17f24836
14 changed files with 461 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/nginx.c
View File

@ -56,7 +56,7 @@ int main(int argc, char *const *argv)
/* TODO: read config */
#if 1
#if 0
ngx_memzero(&conf, sizeof(ngx_conf_t));
ngx_test_null(conf.args,
ngx_create_array(ngx_pool, 10, sizeof(ngx_str_t)), 1);

24
src/core/ngx_alloc.c
View File

@ -12,11 +12,14 @@ void *ngx_alloc(size_t size, ngx_log_t *log)
void *p;
p = malloc(size);
if (p == NULL)
if (p == NULL) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
"malloc() %d bytes failed", size);
}
#if (NGX_DEBUG_ALLOC)
ngx_log_debug(log, "malloc: %08x:%d" _ p _ size);
#endif
return p;
}
@ -26,8 +29,9 @@ void *ngx_calloc(size_t size, ngx_log_t *log)
void *p;
p = ngx_alloc(size, log);
if (p)
if (p) {
ngx_memzero(p, size);
}
return p;
}
@ -53,17 +57,22 @@ void ngx_destroy_pool(ngx_pool_t *pool)
ngx_pool_large_t *l;
for (l = pool->large; l; l = l->next) {
#if (NGX_DEBUG_ALLOC)
ngx_log_debug(pool->log, "free: %08x" _ l->alloc);
#endif
free(l->alloc);
}
for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
#if (NGX_DEBUG_ALLOC)
ngx_log_debug(pool->log, "free: %08x" _ p);
#endif
free(p);
if (n == NULL)
if (n == NULL) {
break;
}
}
}
void *ngx_palloc(ngx_pool_t *pool, size_t size)
@ -83,9 +92,10 @@ void *ngx_palloc(ngx_pool_t *pool, size_t size)
return m;
}
if (n == NULL)
if (n == NULL) {
break;
}
}
/* alloc new pool block */
ngx_test_null(n, ngx_create_pool(p->end - (char *) p, p->log), NULL);
@ -107,10 +117,11 @@ void *ngx_palloc(ngx_pool_t *pool, size_t size)
break;
}
if (last->next == NULL)
if (last->next == NULL) {
break;
}
}
}
if (large == NULL) {
ngx_test_null(large, ngx_palloc(pool, sizeof(ngx_pool_large_t)),
@ -138,8 +149,9 @@ void *ngx_pcalloc(ngx_pool_t *pool, size_t size)
void *p;
p = ngx_palloc(pool, size);
if (p)
if (p) {
ngx_memzero(p, size);
}
return p;
}

6
src/core/ngx_config.h
View File

@ -99,6 +99,12 @@
*/
#endif
#if (HAVE_DEVPOLL)
#include <sys/devpoll.h> /* Solaris, HP/UX */
#endif
#define ngx_inline inline

4
src/core/ngx_config_file.h
View File

@ -53,6 +53,10 @@ typedef struct {
char *description;
} ngx_command_t;
int ngx_conf_read_token(ngx_conf_t *cf);
char *ngx_conf_set_size_slot(char *conf, int offset, char *value);
char *ngx_conf_set_time_slot(char *conf, int offset, char *value);

240
src/event/modules/ngx_devpoll_module.c
View File

@ -16,10 +16,17 @@
#endif
/* STUB */
#define DEVPOLL_NCHANGES 512
#define DEVPOLL_NEVENTS 512
/* should be per-thread */
static int dp;
static struct pollfd *change_list, *event_list;
static int nchanges, nevents;
static unsigned int nchanges;
static int nevents;
static ngx_event_t **change_index;
static ngx_event_t timer_queue;
/* */
@ -27,11 +34,12 @@ static ngx_event_t timer_queue;
int ngx_devpoll_init(int max_connections, ngx_log_t *log)
{
int size;
int change_size, event_size;
size = sizeof(struct pollfd) * 512;
nevents = DEVPOLL_NEVENTS;
nchanges = 0;
nevents = 512;
change_size = sizeof(struct pollfd) * DEVPOLL_NCHANGES;
event_size = sizeof(struct pollfd) * DEVPOLL_NEVENTS;
dp = open("/dev/poll", O_RDWR);
@ -40,9 +48,10 @@ int ngx_devpoll_init(int max_connections, ngx_log_t *log)
return NGX_ERROR;
}
ngx_test_null(change_list, ngx_alloc(size, log), NGX_ERROR);
ngx_test_null(event_list, ngx_alloc(size, log), NGX_ERROR);
ngx_test_null(event_index, ngx_alloc(sizeof(ngx_event_t *) * nevents, log),
ngx_test_null(change_list, ngx_alloc(change_size, log), NGX_ERROR);
ngx_test_null(event_list, ngx_alloc(event_size, log), NGX_ERROR);
ngx_test_null(change_index,
ngx_alloc(sizeof(ngx_event_t *) * DEVPOLL_NCHANGES, log),
NGX_ERROR);
timer_queue.timer_prev = &timer_queue;
@ -59,95 +68,89 @@ int ngx_devpoll_init(int max_connections, ngx_log_t *log)
}
/* NOT READY */
int ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags)
{
ngx_event_t *e;
ngx_connection_t *c;
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
#endif
c = (ngx_connection_t *) ev->data;
ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
if (event == NGX_READ_EVENT) {
e = c->write;
#if (NGX_READ_EVENT != POLLIN)
if (event == NGX_READ_EVENT) {
event = POLLOUT;
#if (NGX_WRITE_EVENT != POLLOUT)
} else {
event = POLLIN;
#endif
} else {
e = c->read;
#if (NGX_WRITE_EVENT != POLLOUT)
event = POLLOUT;
}
#endif
}
ngx_log_debug(ev->log, "poll fd:%d event:%d" _ c->fd _ event);
#if (NGX_DEBUG_EVENT)
c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "add event: %d:%d" _ c->fd _ event);
#endif
if (e == NULL || e->index == NGX_INVALID_INDEX) {
event_list[nevents].fd = c->fd;
event_list[nevents].events = event;
event_list[nevents].revents = 0;
ev->active = 1;
ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
event_index[nevents] = ev;
ev->index = nevents;
nevents++;
} else {
event_list[e->index].events |= event;
ev->index = e->index;
}
return ngx_devpoll_set_event(ev, event, EV_ADD | flags);
return ngx_devpoll_set_event(ev, event, 0);
}
/* NOT READY */
int ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags)
{
ngx_event_t *e;
if (nchanges > 0 && ev->index < nchanges
&& change_list[ev->index].udata == ev)
{
ngx_connection_t *cn = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "kqueue del event: %d: ft:%d" _
cn->fd _ event);
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(c->log, "del event: %d, %d" _ c->fd _ event);
#endif
if (ev->index < --nchanges) {
e = (ngx_event_t *) change_list[nchanges].udata;
change_list[ev->index] = change_list[nchanges];
e->index = ev->index;
if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) {
return NGX_ERROR;
}
ev->active = 0;
if (flags & NGX_CLOSE_EVENT) {
return NGX_OK;
}
if (flags & NGX_CLOSE_EVENT)
return NGX_OK;
if (event == NGX_READ_EVENT) {
e = c->write;
event = POLLOUT;
return ngx_devpoll_set_event(ev, POLLREMOVE);
} else {
e = c->read;
event = POLLIN;
}
if (e) {
return ngx_devpoll_set_event(e, event, 0);
}
return NGX_OK;
}
/* NOT READY */
int ngx_devpoll_set_event(ngx_event_t *ev, int event)
int ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags)
{
int n;
ngx_connection_t *c;
c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "devpoll fd:%d event:%d" _ c->fd _ event);
#if (NGX_DEBUG_EVENT)
ngx_log_debug(ev->log, "devpoll fd:%d event:%d flush:%d" _
c->fd _ event _ flags);
#endif
if (nchanges >= nevents) {
if (nchanges >= DEVPOLL_NCHANGES) {
ngx_log_error(NGX_LOG_WARN, ev->log, 0,
"/dev/pool change list is filled up");
n = nchanges * sizeof(struct pollfd);
if (write(dp, change_list, n) != n) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
"write(/dev/poll) failed");
return NGX_ERROR;
}
@ -155,47 +158,53 @@ int ngx_devpoll_set_event(ngx_event_t *ev, int event)
nchanges = 0;
}
event_list[nchanges].fd = c->fd;
event_list[nchanges].events = event;
event_list[nchanges].revents = 0;
change_list[nchanges].fd = c->fd;
change_list[nchanges].events = event;
change_list[nchanges].revents = 0;
event_index[nchanges] = ev;
change_index[nchanges] = ev;
ev->index = nchanges;
/*
if (flags == EV_ADD)
ev->index = nchanges;
*/
nchanges++;
if (flags & NGX_CLOSE_EVENT) {
n = nchanges * sizeof(struct pollfd);
if (write(dp, change_list, n) != n) {
ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
"write(/dev/poll) failed");
return NGX_ERROR;
}
nchanges = 0;
}
return NGX_OK;
}
int ngx_devpoll_process_events(ngx_log_t *log)
{
int events, i;
int events, n, i;
u_int timer, delta;
ngx_err_t err;
ngx_event_t *ev;
ngx_connection_t *c;
struct dvpoll dvpoll;
struct timeval tv;
if (timer_queue.timer_next != &timer_queue) {
timer = timer_queue.timer_next->timer_delta;
#if 1
gettimeofday(&tv, NULL);
delta = tv.tv_sec * 1000 + tv.tv_usec / 1000;
#else
delta = ngx_msec();
#endif
} else {
timer = INFTIM;
delta = 0;
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "devpoll timer: %d" _ timer);
#endif
n = nchanges * sizeof(struct pollfd);
if (write(dp, change_list, n) != n) {
@ -216,53 +225,41 @@ int ngx_devpoll_process_events(ngx_log_t *log)
nchanges = 0;
if (timer != INFTIM) {
#if 1
gettimeofday(&tv, NULL);
delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
#else
delta = ngx_msec() - delta;
#endif
} else {
ngx_assert((events != 0), return NGX_ERROR, log,
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"ioctl(DP_POLL) returns no events without timeout");
return NGX_ERROR;
}
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "devpoll timer: %d, delta: %d" _ timer _ delta);
if (timer != INFTIM) {
if (delta >= timer) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta)
break;
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR)
ev->close_handler(ev);
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
#endif
for (i = 0; i < events; i++) {
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "devpoll: %d: ev:%d rev:%d" _
event_list[i].fd _
event_list[i].events _ event_list[i].revents);
#endif
c = &ngx_connections[event_list[i].fd];
if (event_list[i].revents & POLLIN) {
if (!c->read->active) {
continue;
}
c->read->ready = 1;
if (c->read->oneshot) {
ngx_del_timer(c->read);
ngx_select_del_event(c->read, NGX_READ_EVENT, 0);
ngx_devpoll_del_event(c->read, NGX_READ_EVENT, 0);
}
if (c->read->event_handler(c->read) == NGX_ERROR) {
@ -271,11 +268,15 @@ int ngx_devpoll_process_events(ngx_log_t *log)
}
if (event_list[i].revents & POLLOUT) {
if (!c->write->active) {
continue;
}
c->write->ready = 1;
if (c->write->oneshot) {
ngx_del_timer(c->write);
ngx_select_del_event(c->write, NGX_WRITE_EVENT, 0);
ngx_devpoll_del_event(c->write, NGX_WRITE_EVENT, 0);
}
if (c->write->event_handler(c->write) == NGX_ERROR) {
@ -284,12 +285,40 @@ int ngx_devpoll_process_events(ngx_log_t *log)
}
if (event_list[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
ngx_log_error(NGX_LOG_ERR, log, ngx_errno,
err = 0;
if (event_list[i].revents & POLLNVAL) {
err = EBADF;
}
ngx_log_error(NGX_LOG_ERR, log, err,
"ioctl(DP_POLL) error on %d:%d",
event_list[i].fd, event_list[i].revents);
}
}
if (timer != INFTIM && timer_queue.timer_next != &timer_queue) {
if (delta >= timer_queue.timer_next->timer_delta) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta) {
break;
}
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
return NGX_OK;
}
@ -298,15 +327,22 @@ void ngx_devpoll_add_timer(ngx_event_t *ev, ngx_msec_t timer)
{
ngx_event_t *e;
ngx_log_debug(ev->log, "set timer: %d" _ timer);
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
#endif
ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
"timer already set");
if (ev->timer_next || ev->timer_prev) {
ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
return;
}
for (e = timer_queue.timer_next;
e != &timer_queue && timer > e->timer_delta;
e = e->timer_next)
{
timer -= e->timer_delta;
}
ev->timer_delta = timer;

11
src/event/modules/ngx_devpoll_module.h
View File

@ -13,9 +13,18 @@ void ngx_devpoll_add_timer(ngx_event_t *ev, ngx_msec_t timer);
int ngx_devpoll_process_events(ngx_log_t *log);
#if 0
/* DEBUG */
#define POLLREMOVE 0x0800
#define DP_POLL 1
#define DP_POLL 0xD001
struct dvpoll {
struct pollfd* dp_fds;
int dp_nfds;
int dp_timeout;
};
#endif
#endif /* _NGX_DEVPOLL_MODULE_H_INCLUDED_ */

115
src/event/modules/ngx_kqueue_module.c
View File

@ -16,10 +16,16 @@
#endif
/* STUB */
#define KQUEUE_NCHANGES 512
#define KQUEUE_NEVENTS 512
/* should be per-thread */
static int kq;
static struct kevent *change_list, *event_list;
static int nchanges, nevents;
static unsigned int nchanges;
static int nevents;
static ngx_event_t timer_queue;
/* */
@ -27,11 +33,12 @@ static ngx_event_t timer_queue;
int ngx_kqueue_init(int max_connections, ngx_log_t *log)
{
int size;
int change_size, event_size;
size = sizeof(struct kevent) * 512;
nevents = KQUEUE_NEVENTS;
nchanges = 0;
nevents = 512;
change_size = sizeof(struct kevent) * KQUEUE_NCHANGES;
event_size = sizeof(struct kevent) * KQUEUE_NEVENTS;
kq = kqueue();
@ -40,8 +47,8 @@ int ngx_kqueue_init(int max_connections, ngx_log_t *log)
return NGX_ERROR;
}
ngx_test_null(change_list, ngx_alloc(size, log), NGX_ERROR);
ngx_test_null(event_list, ngx_alloc(size, log), NGX_ERROR);
ngx_test_null(change_list, ngx_alloc(change_size, log), NGX_ERROR);
ngx_test_null(event_list, ngx_alloc(event_size, log), NGX_ERROR);
timer_queue.timer_prev = &timer_queue;
timer_queue.timer_next = &timer_queue;
@ -59,16 +66,17 @@ int ngx_kqueue_init(int max_connections, ngx_log_t *log)
int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
{
ev->active = 1;
ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
if (nchanges > 0
&& ev->index < nchanges
&& change_list[ev->index].udata == ev)
{
/* DEBUG */
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "kqueue add event: %d: ft:%d" _ c->fd _ event);
#endif
change_list[ev->index].filter = event;
change_list[ev->index].flags = flags;
@ -83,14 +91,16 @@ int ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags)
{
ngx_event_t *e;
ev->active = 0;
if (nchanges > 0
&& ev->index < nchanges
&& change_list[ev->index].udata == ev)
{
/* DEBUG */
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "kqueue del event: %d: ft:%d" _ c->fd _ event);
#endif
if (ev->index < --nchanges) {
e = (ngx_event_t *) change_list[nchanges].udata;
change_list[ev->index] = change_list[nchanges];
@ -100,8 +110,9 @@ int ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags)
return NGX_OK;
}
if (flags & NGX_CLOSE_EVENT)
if (flags & NGX_CLOSE_EVENT) {
return NGX_OK;
}
return ngx_kqueue_set_event(ev, event, EV_DELETE);
}
@ -114,10 +125,12 @@ int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
c = (ngx_connection_t *) ev->data;
#if (NGX_DEBUG_EVENT)
ngx_log_debug(ev->log, "kqueue set event: %d: ft:%d f:%08x" _
c->fd _ filter _ flags);
#endif
if (nchanges >= nevents) {
if (nchanges >= KQUEUE_NCHANGES) {
ngx_log_error(NGX_LOG_WARN, ev->log, 0,
"kqueue change list is filled up");
@ -128,6 +141,7 @@ int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent failed");
return NGX_ERROR;
}
nchanges = 0;
}
@ -168,7 +182,9 @@ int ngx_kqueue_process_events(ngx_log_t *log)
tp = NULL;
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "kevent timer: %d" _ timer);
#endif
events = kevent(kq, change_list, nchanges, event_list, nevents, tp);
@ -184,38 +200,25 @@ int ngx_kqueue_process_events(ngx_log_t *log)
delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
} else {
ngx_assert((events != 0), return NGX_ERROR, log,
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"kevent returns no events without timeout");
return NGX_ERROR;
}
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
if (timer) {
if (delta >= timer) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta)
break;
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR)
ev->close_handler(ev);
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
#endif
for (i = 0; i < events; i++) {
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "kevent: %d: ft:%d f:%08x ff:%08x d:%d ud:%08x" _
event_list[i].ident _ event_list[i].filter _
event_list[i].flags _ event_list[i].fflags _
event_list[i].data _ event_list[i].udata);
#endif
if (event_list[i].flags & EV_ERROR) {
ngx_log_error(NGX_LOG_ALERT, log, event_list[i].data,
@ -225,6 +228,10 @@ int ngx_kqueue_process_events(ngx_log_t *log)
ev = (ngx_event_t *) event_list[i].udata;
if (!ev->active) {
continue;
}
switch (event_list[i].filter) {
case EVFILT_READ:
@ -237,20 +244,45 @@ int ngx_kqueue_process_events(ngx_log_t *log)
ev->error = event_list[i].fflags;
}
if (ev->oneshot)
if (ev->oneshot) {
ngx_del_timer(ev);
}
if (ev->event_handler(ev) == NGX_ERROR)
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
break;
default:
ngx_assert(0, /* void */, log,
ngx_log_error(NGX_LOG_ALERT, log, 0,
"unknown kevent filter %d" _ event_list[i].filter);
}
}
if (timer && timer_queue.timer_next != &timer_queue) {
if (delta >= timer_queue.timer_next->timer_delta) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta) {
break;
}
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
return NGX_OK;
}
@ -259,17 +291,22 @@ void ngx_kqueue_add_timer(ngx_event_t *ev, ngx_msec_t timer)
{
ngx_event_t *e;
#if (NGX_DEBUG)
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
#endif
ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
"timer already set");
if (ev->timer_next || ev->timer_prev) {
ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
return;
}
for (e = timer_queue.timer_next;
e != &timer_queue && timer > e->timer_delta;
e = e->timer_next)
{
timer -= e->timer_delta;
}
ev->timer_delta = timer;

142
src/event/modules/ngx_poll_module.c
View File

@ -12,9 +12,10 @@
/* should be per-thread */
static struct pollfd *event_list;
static int nevents;
static unsigned int nevents;
static ngx_event_t **event_index;
static ngx_event_t **ready_index;
static ngx_event_t timer_queue;
/* */
@ -28,6 +29,10 @@ int ngx_poll_init(int max_connections, ngx_log_t *log)
ngx_alloc(sizeof(ngx_event_t *) * max_connections, log),
NGX_ERROR);
ngx_test_null(ready_index,
ngx_alloc(sizeof(ngx_event_t *) * 2 * max_connections, log),
NGX_ERROR);
nevents = 0;
timer_queue.timer_prev = &timer_queue;
@ -48,6 +53,7 @@ int ngx_poll_add_event(ngx_event_t *ev, int event, u_int flags)
c = (ngx_connection_t *) ev->data;
ev->active = 1;
ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
if (event == NGX_READ_EVENT) {
@ -63,7 +69,9 @@ int ngx_poll_add_event(ngx_event_t *ev, int event, u_int flags)
#endif
}
ngx_log_debug(ev->log, "poll fd:%d event:%d" _ c->fd _ event);
#if (NGX_DEBUG_EVENT)
ngx_log_debug(ev->log, "add event: %d:%d" _ c->fd _ event);
#endif
if (e == NULL || e->index == NGX_INVALID_INDEX) {
event_list[nevents].fd = c->fd;
@ -89,8 +97,9 @@ int ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
c = (ngx_connection_t *) ev->data;
if (ev->index == NGX_INVALID_INDEX)
if (ev->index == NGX_INVALID_INDEX) {
return NGX_OK;
}
if (event == NGX_READ_EVENT) {
e = c->write;
@ -105,7 +114,9 @@ int ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
#endif
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(c->log, "del event: %d, %d" _ c->fd _ event);
#endif
if (e == NULL || e->index == NGX_INVALID_INDEX) {
if (ev->index < --nevents) {
@ -118,6 +129,7 @@ int ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
event_list[e->index].events &= ~event;
}
ev->active = 0;
ev->index = NGX_INVALID_INDEX;
return NGX_OK;
@ -125,7 +137,7 @@ int ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
int ngx_poll_process_events(ngx_log_t *log)
{
int i, ready, found;
int i, ready, nready, found;
u_int timer, delta;
ngx_err_t err;
ngx_event_t *ev;
@ -140,15 +152,14 @@ int ngx_poll_process_events(ngx_log_t *log)
delta = 0;
}
#if 1
/* DEBUG */
#if (NGX_DEBUG_EVENT)
for (i = 0; i < nevents; i++) {
ngx_log_debug(log, "poll: %d, %d" _
event_list[i].fd _ event_list[i].events);
}
#endif
ngx_log_debug(log, "poll timer: %d" _ timer);
#endif
if ((ready = poll(event_list, nevents, timer)) == -1) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "poll() failed");
@ -161,70 +172,38 @@ int ngx_poll_process_events(ngx_log_t *log)
delta = ngx_msec() - delta;
} else {
ngx_assert((ready != 0), return NGX_ERROR, log,
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"poll() returns no events without timeout");
return NGX_ERROR;
}
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "poll timer: %d, delta: %d" _ timer _ delta);
#endif
if (timer != INFTIM) {
if (delta >= timer) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta) {
break;
}
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
nready = 0;
for (i = 0; i < nevents && ready; i++) {
c = &ngx_connections[event_list[i].fd];
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "poll: fd:%d, ev:%d, rev:%d" _
event_list[i].fd _
event_list[i].events _ event_list[i].revents);
#endif
found = 0;
if (event_list[i].revents & POLLIN) {
found = 1;
c->read->ready = 1;
if (c->read->oneshot) {
ngx_del_timer(c->read);
ngx_poll_del_event(c->read, NGX_READ_EVENT, 0);
}
if (c->read->event_handler(c->read) == NGX_ERROR) {
c->read->close_handler(c->read);
}
ready_index[nready++] = c->read;
}
if (event_list[i].revents & POLLOUT) {
found = 1;
c->write->ready = 1;
if (c->write->oneshot) {
ngx_del_timer(c->write);
ngx_poll_del_event(c->write, NGX_WRITE_EVENT, 0);
}
if (c->write->event_handler(c->write) == NGX_ERROR) {
c->write->close_handler(c->write);
}
ready_index[nready++] = c->write;
}
if (event_list[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
@ -245,7 +224,56 @@ int ngx_poll_process_events(ngx_log_t *log)
}
}
ngx_assert((ready == 0), /* void */ ; , log, "poll ready != nevents");
for (i = 0; i < nready; i++) {
ev = ready_index[i];
if (!ev->active) {
continue;
}
ev->ready = 1;
if (ev->oneshot) {
ngx_del_timer(ev);
if (ev->write) {
ngx_poll_del_event(ev, NGX_WRITE_EVENT, 0);
} else {
ngx_poll_del_event(ev, NGX_READ_EVENT, 0);
}
}
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
}
if (ready != 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0, "poll ready != events");
}
if (timer != INFTIM && timer_queue.timer_next != &timer_queue) {
if (delta >= timer_queue.timer_next->timer_delta) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta) {
break;
}
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
return NGX_OK;
}
@ -254,10 +282,22 @@ void ngx_poll_add_timer(ngx_event_t *ev, ngx_msec_t timer)
{
ngx_event_t *e;
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
#endif
if (ev->timer_next || ev->timer_prev) {
ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
return;
}
for (e = timer_queue.timer_next;
e != &timer_queue && timer > e->timer_delta;
e = e->timer_next)
{
timer -= e->timer_delta;
}
ev->timer_delta = timer;

100
src/event/modules/ngx_select_module.c
View File

@ -22,7 +22,7 @@ static int max_write;
static int max_fd;
#endif
static int nevents;
static unsigned int nevents;
static ngx_event_t **event_index;
static ngx_event_t **ready_index;
@ -79,7 +79,9 @@ int ngx_select_add_event(ngx_event_t *ev, int event, u_int flags)
c = (ngx_connection_t *) ev->data;
#if (NGX_DEBUG_EVENT)
ngx_log_debug(ev->log, "select fd:%d event:%d" _ c->fd _ event);
#endif
if (ev->index != NGX_INVALID_INDEX) {
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
@ -117,6 +119,7 @@ int ngx_select_add_event(ngx_event_t *ev, int event, u_int flags)
#endif
ev->active = 1;
ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
event_index[nevents] = ev;
@ -134,7 +137,9 @@ int ngx_select_del_event(ngx_event_t *ev, int event, u_int flags)
if (ev->index == NGX_INVALID_INDEX)
return NGX_OK;
#if (NGX_DEBUG_EVENT)
ngx_log_debug(c->log, "del event: %d, %d" _ c->fd _ event);
#endif
#if (WIN32)
if (event == NGX_READ_EVENT) {
@ -161,6 +166,7 @@ int ngx_select_del_event(ngx_event_t *ev, int event, u_int flags)
event_index[ev->index]->index = ev->index;
}
ev->active = 0;
ev->index = NGX_INVALID_INDEX;
return NGX_OK;
@ -199,20 +205,21 @@ int ngx_select_process_events(ngx_log_t *log)
max_fd = c->fd;
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "change max_fd: %d" _ max_fd);
#endif
}
#endif
#if 1
/* DEBUG */
#if (NGX_DEBUG_EVENT)
for (i = 0; i < nevents; i++) {
ev = event_index[i];
c = (ngx_connection_t *) ev->data;
ngx_log_debug(log, "select: %d:%d" _ c->fd _ ev->write);
}
#endif
ngx_log_debug(log, "select timer: %d" _ timer);
#endif
#if (WIN32)
if ((ready = select(0, &work_read_fd_set, &work_write_fd_set, NULL, tp))
@ -220,42 +227,30 @@ int ngx_select_process_events(ngx_log_t *log)
if ((ready = select(max_fd + 1, &work_read_fd_set, &work_write_fd_set,
NULL, tp))
#endif
== -1) {
== -1)
{
ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno, "select() failed");
return NGX_ERROR;
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "select ready %d" _ ready);
#endif
if (timer) {
delta = ngx_msec() - delta;
} else {
ngx_assert((ready != 0), return NGX_ERROR, log,
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"select() returns no events without timeout");
return NGX_ERROR;
}
}
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "select timer: %d, delta: %d" _ timer _ delta);
if (timer) {
if (delta >= timer) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta)
break;
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR)
ev->close_handler(ev);
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
#endif
nready = 0;
@ -266,14 +261,18 @@ int ngx_select_process_events(ngx_log_t *log)
if (ev->write) {
if (FD_ISSET(c->fd, &work_write_fd_set)) {
ngx_log_debug(log, "select write %d" _ c->fd);
found = 1;
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "select write %d" _ c->fd);
#endif
}
} else {
if (FD_ISSET(c->fd, &work_read_fd_set)) {
ngx_log_debug(log, "select read %d" _ c->fd);
found = 1;
#if (NGX_DEBUG_EVENT)
ngx_log_debug(log, "select read %d" _ c->fd);
#endif
}
}
@ -284,6 +283,11 @@ int ngx_select_process_events(ngx_log_t *log)
for (i = 0; i < nready; i++) {
ev = ready_index[i];
ready--;
if (!ev->active) {
continue;
}
ev->ready = 1;
@ -298,11 +302,34 @@ int ngx_select_process_events(ngx_log_t *log)
if (ev->event_handler(ev) == NGX_ERROR)
ev->close_handler(ev);
ready--;
}
ngx_assert((ready == 0), /* void */ ; , log, "select ready != events");
if (ready != 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0, "select ready != events");
}
if (timer && timer_queue.timer_next != &timer_queue) {
if (delta >= timer_queue.timer_next->timer_delta) {
for ( ;; ) {
ev = timer_queue.timer_next;
if (ev == &timer_queue || delta < ev->timer_delta) {
break;
}
delta -= ev->timer_delta;
ngx_del_timer(ev);
ev->timedout = 1;
if (ev->event_handler(ev) == NGX_ERROR) {
ev->close_handler(ev);
}
}
} else {
timer_queue.timer_next->timer_delta -= delta;
}
}
return NGX_OK;
}
@ -311,17 +338,22 @@ void ngx_select_add_timer(ngx_event_t *ev, ngx_msec_t timer)
{
ngx_event_t *e;
#if (NGX_DEBUG)
#if (NGX_DEBUG_EVENT)
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
#endif
ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
"timer already set");
if (ev->timer_next || ev->timer_prev) {
ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
return;
}
for (e = timer_queue.timer_next;
e != &timer_queue && timer > e->timer_delta;
e = e->timer_next)
{
timer -= e->timer_delta;
}
ev->timer_delta = timer;

14
src/event/ngx_event.c
View File

@ -15,6 +15,9 @@
#if (HAVE_POLL)
#include <ngx_poll_module.h>
#endif
#if (HAVE_DEVPOLL)
#include <ngx_devpoll_module.h>
#endif
#if (HAVE_KQUEUE)
#include <ngx_kqueue_module.h>
#endif
@ -29,18 +32,20 @@ ngx_event_t *ngx_read_events, *ngx_write_events;
#if 0
ngx_event_type_e ngx_event_type = NGX_SELECT_EVENT;
#elif 1
#elif 0
ngx_event_type_e ngx_event_type = NGX_POLL_EVENT;
#else
ngx_event_type_e ngx_event_type = NGX_KQUEUE_EVENT;
#endif
#elif (HAVE_POLL)
#elif (HAVE_DEVPOLL)
#if 0
ngx_event_type_e ngx_event_type = NGX_SELECT_EVENT;
#else
#elif 0
ngx_event_type_e ngx_event_type = NGX_POLL_EVENT;
#else
ngx_event_type_e ngx_event_type = NGX_DEVPOLL_EVENT;
#endif
#else
@ -57,6 +62,9 @@ static int (*ngx_event_init[]) (int max_connections, ngx_log_t *log) = {
#if (HAVE_POLL)
ngx_poll_init,
#endif
#if (HAVE_DEVPOLL)
ngx_devpoll_init,
#endif
#if (HAVE_KQUEUE)
ngx_kqueue_init
#endif

11
src/event/ngx_event.h
View File

@ -51,6 +51,7 @@ struct ngx_event_s {
unsigned listening:1;
unsigned write:1;
unsigned active:1;
unsigned ready:1;
unsigned timedout:1;
unsigned blocked:1;
@ -74,6 +75,9 @@ typedef enum {
#if (HAVE_POLL)
NGX_POLL_EVENT,
#endif
#if (HAVE_DEVPOLL)
NGX_DEVPOLL_EVENT,
#endif
#if (HAVE_KQUEUE)
NGX_KQUEUE_EVENT,
#endif
@ -120,7 +124,7 @@ NGX_CLOSE_EVENT kqueue: kqueue deletes events for file that closed
#define NGX_CLEAR_EVENT EV_CLEAR
#endif
#elif (HAVE_POLL)
#elif (HAVE_POLL) || (HAVE_DEVPOLL)
#define NGX_READ_EVENT POLLIN
#define NGX_WRITE_EVENT POLLOUT
@ -159,9 +163,10 @@ NGX_CLOSE_EVENT kqueue: kqueue deletes events for file that closed
#endif
static void ngx_inline ngx_del_timer(ngx_event_t *ev)
ngx_inline static void ngx_del_timer(ngx_event_t *ev)
{
#if (NGX_DEBUG)
#if (NGX_DEBUG_EVENT)
/* STUB - we can not cast (ngx_connection_t *) here */
ngx_log_debug(ev->log, "del timer: %d" _ *(int *)(ev->data));
#endif

1
src/http/ngx_http.c
View File

@ -34,6 +34,7 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
ngx_http_server.doc_root = "/home/is/dox/";
ngx_http_server.doc_root = "/home/is/work/xml/site-1.0.0/html";
ngx_http_server.doc_root = "/spool/test/lperltk";
ngx_http_server.doc_root = "/home/is/dox/ora/lperltk";
#endif
ngx_http_server.doc_root_len = strlen(ngx_http_server.doc_root) + 1;

3
src/http/ngx_http_core.c
View File

@ -350,7 +350,10 @@ static void *ngx_http_core_create_loc_conf(ngx_pool_t *pool)
ngx_pcalloc(pool, sizeof(ngx_http_core_loc_conf_t)),
NULL);
conf->send_timeout = 10;
/*
conf->send_timeout = NGX_CONF_UNSET;
*/
return conf;
}

2
src/http/ngx_http_event.c
View File

@ -549,7 +549,7 @@ static int ngx_http_writer(ngx_event_t *ev)
if (!r->keepalive) {
if (r->lingering_close) {
ngx_http_set_lingering_close(r);
return ngx_http_set_lingering_close(r);
} else {
return ngx_http_close_request(r);