nginx-0.0.1-2002-12-23-09:29:22 import

1 files changed, 318 insertions, 0 deletions

diff --git a/src/event/modules/ngx_devpoll_module.c b/src/event/modules/ngx_devpoll_module.c
new file mode 100644
index 000000000..0bc9ef71a
--- /dev/null
+++ b/src/event/modules/ngx_devpoll_module.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2002 Igor Sysoev, http://sysoev.ru
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_types.h>
+#include <ngx_log.h>
+#include <ngx_connection.h>
+#include <ngx_event.h>
+#include <ngx_devpoll_module.h>
+
+#if (USE_DEVPOLL) && !(HAVE_DEVPOLL)
+#error "/dev/poll is not supported on this platform"
+#endif
+
+
+/* should be per-thread */
+static int              dp;
+static struct pollfd   *change_list, *event_list;
+static int              nchanges, nevents;
+
+static ngx_event_t      timer_queue;
+/* */
+
+
+int ngx_devpoll_init(int max_connections, ngx_log_t *log)
+{
+    int size;
+
+    size = sizeof(struct pollfd) * 512;
+    nchanges = 0;
+    nevents = 512;
+
+    dp = open("/dev/poll", O_RDWR);
+
+    if (dp == -1) {
+        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "open(/dev/poll) failed");
+        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_ERROR);
+
+    timer_queue.timer_prev = &timer_queue;
+    timer_queue.timer_next = &timer_queue;
+
+#if !(USE_DEVPOLL)
+    ngx_event_actions.add = ngx_devpoll_add_event;
+    ngx_event_actions.del = ngx_devpoll_del_event;
+    ngx_event_actions.timer = ngx_devpoll_add_timer;
+    ngx_event_actions.process = ngx_devpoll_process_events;
+#endif
+
+    return NGX_OK;
+}
+
+
+/* NOT READY */
+
+int ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags)
+{
+    ngx_event_t      *e;
+    ngx_connection_t *c;
+
+    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)
+        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 (e == NULL || e->index == NGX_INVALID_INDEX) {
+        event_list[nevents].fd = c->fd;
+        event_list[nevents].events = event;
+        event_list[nevents].revents = 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);
+}
+
+/* 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 (ev->index < --nchanges) {
+            e = (ngx_event_t *) change_list[nchanges].udata;
+            change_list[ev->index] = change_list[nchanges];
+            e->index = ev->index;
+        }
+
+        return NGX_OK;
+    }
+
+    if (flags & NGX_CLOSE_EVENT)
+        return NGX_OK;
+
+    return ngx_devpoll_set_event(ev, POLLREMOVE);
+}
+
+/* NOT READY */
+
+int ngx_devpoll_set_event(ngx_event_t *ev, int event)
+{
+    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 (nchanges >= nevents) {
+        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,
+                          "write(/dev/poll) failed");
+            return NGX_ERROR;
+        }
+
+        nchanges = 0;
+    }
+
+    event_list[nchanges].fd = c->fd;
+    event_list[nchanges].events = event;
+    event_list[nchanges].revents = 0;
+
+    event_index[nchanges] = ev;
+    ev->index = nchanges;
+
+/*
+    if (flags == EV_ADD)
+        ev->index = nchanges;
+*/
+
+    nchanges++;
+
+    return NGX_OK;
+}
+
+
+int ngx_devpoll_process_events(ngx_log_t *log)
+{
+    int              events, i;
+    u_int            timer, delta;
+    ngx_event_t      *ev;
+    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;
+    }
+
+    ngx_log_debug(log, "devpoll timer: %d" _ timer);
+
+    n = nchanges * sizeof(struct pollfd);
+    if (write(dp, change_list, n) != n) {
+        ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "write(/dev/poll) failed");
+        return NGX_ERROR;
+    }
+
+    dvpoll.dp_fds = event_list;
+    dvpoll.dp_nfds = nevents;
+    dvpoll.dp_timeout = timer;
+    events = ioctl(dp, DP_POLL, &dvpoll);
+
+    if (events == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "ioctl(DP_POLL) failed");
+        return NGX_ERROR;
+    }
+
+    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,
+                   "ioctl(DP_POLL) returns no events without timeout");
+    }
+
+    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;
+        }
+    }
+
+    for (i = 0; i < events; i++) {
+
+        ngx_log_debug(log, "devpoll: %d: ev:%d rev:%d" _
+                      event_list[i].fd _
+                      event_list[i].events _ event_list[i].revents);
+
+
+        if (event_list[i].revents & POLLIN) {
+            c->read->ready = 1;
+            
+            if (c->read->oneshot) {
+                ngx_del_timer(c->read);
+                ngx_select_del_event(c->read, NGX_READ_EVENT, 0);
+            }
+
+            if (c->read->event_handler(c->read) == NGX_ERROR) {
+                c->read->close_handler(c->read);
+            }   
+        }
+
+        if (event_list[i].revents & POLLOUT) {
+            c->write->ready = 1;
+
+            if (c->write->oneshot) {
+                ngx_del_timer(c->write);
+                ngx_select_del_event(c->write, NGX_WRITE_EVENT, 0);
+            }
+
+            if (c->write->event_handler(c->write) == NGX_ERROR) {
+                c->write->close_handler(c->write);
+            }   
+        }
+
+        if (event_list[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
+            ngx_log_error(NGX_LOG_ERR, log, ngx_errno,
+                          "ioctl(DP_POLL) error on %d:%d",
+                          event_list[i].fd, event_list[i].revents);
+        }
+    }
+
+    return NGX_OK;
+}
+
+
+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);
+
+    ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
+               "timer already set");
+
+    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;
+
+    ev->timer_next = e;
+    ev->timer_prev = e->timer_prev;
+
+    e->timer_prev->timer_next = ev;
+    e->timer_prev = ev;
+}