Changeset 740 for vendor/current/source3/lib/events.c

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

File:

• vendor/current/source3/lib/events.c (modified) (5 diffs)

vendor/current/source3/lib/events.c

@@ -20 +20 @@
 
 #include "includes.h"
-#include <tevent_internal.h>
-
-void event_fd_set_writeable(struct tevent_fd *fde)
-{
-        TEVENT_FD_WRITEABLE(fde);
-}
-
-void event_fd_set_not_writeable(struct tevent_fd *fde)
-{
-        TEVENT_FD_NOT_WRITEABLE(fde);
-}
-
-void event_fd_set_readable(struct tevent_fd *fde)
-{
-        TEVENT_FD_READABLE(fde);
-}
-
-void event_fd_set_not_readable(struct tevent_fd *fde)
-{
-        TEVENT_FD_NOT_READABLE(fde);
-}
-
-/*
- * Return if there's something in the queue
- */
-
-bool event_add_to_select_args(struct tevent_context *ev,
-                              const struct timeval *now,
-                              fd_set *read_fds, fd_set *write_fds,
-                              struct timeval *timeout, int *maxfd)
+#include "lib/tevent/tevent_internal.h"
+#include "../lib/util/select.h"
+#include "system/select.h"
+
+struct tevent_poll_private {
+        /*
+         * Index from file descriptor into the pollfd array
+         */
+        int *pollfd_idx;
+
+        /*
+         * Cache for s3_event_loop_once to avoid reallocs
+         */
+        struct pollfd *pfds;
+};
+
+static struct tevent_poll_private *tevent_get_poll_private(
+        struct tevent_context *ev)
+{
+        struct tevent_poll_private *state;
+
+        state = (struct tevent_poll_private *)ev->additional_data;
+        if (state == NULL) {
+                state = TALLOC_ZERO_P(ev, struct tevent_poll_private);
+                ev->additional_data = (void *)state;
+                if (state == NULL) {
+                        DEBUG(10, ("talloc failed\n"));
+                }
+        }
+        return state;
+}
+
+static void count_fds(struct tevent_context *ev,
+                      int *pnum_fds, int *pmax_fd)
 {
         struct tevent_fd *fde;
-        struct timeval diff;
-        bool ret = false;
+        int num_fds = 0;
+        int max_fd = 0;
+
+        for (fde = ev->fd_events; fde != NULL; fde = fde->next) {
+                if (fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) {
+                        num_fds += 1;
+                        if (fde->fd > max_fd) {
+                                max_fd = fde->fd;
+                        }
+                }
+        }
+        *pnum_fds = num_fds;
+        *pmax_fd = max_fd;
+}
+
+bool event_add_to_poll_args(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
+                            struct pollfd **pfds, int *pnum_pfds,
+                            int *ptimeout)
+{
+        struct tevent_poll_private *state;
+        struct tevent_fd *fde;
+        int i, num_fds, max_fd, num_pollfds, idx_len;
+        struct pollfd *fds;
+        struct timeval now, diff;
+        int timeout;
+
+        state = tevent_get_poll_private(ev);
+        if (state == NULL) {
+                return false;
+        }
+        count_fds(ev, &num_fds, &max_fd);
+
+        idx_len = max_fd+1;
+
+        if (talloc_array_length(state->pollfd_idx) < idx_len) {
+                state->pollfd_idx = TALLOC_REALLOC_ARRAY(
+                        state, state->pollfd_idx, int, idx_len);
+                if (state->pollfd_idx == NULL) {
+                        DEBUG(10, ("talloc_realloc failed\n"));
+                        return false;
+                }
+        }
+
+        fds = *pfds;
+        num_pollfds = *pnum_pfds;
+
+        /*
+         * The +1 is for the sys_poll calling convention. It expects
+         * an array 1 longer for the signal pipe
+         */
+
+        if (talloc_array_length(fds) < num_pollfds + num_fds + 1) {
+                fds = TALLOC_REALLOC_ARRAY(mem_ctx, fds, struct pollfd,
+                                           num_pollfds + num_fds + 1);
+                if (fds == NULL) {
+                        DEBUG(10, ("talloc_realloc failed\n"));
+                        return false;
+                }
+        }
+
+        memset(&fds[num_pollfds], 0, sizeof(struct pollfd) * num_fds);
+
+        /*
+         * This needs tuning. We need to cope with multiple fde's for a file
+         * descriptor. The problem is that we need to re-use pollfd_idx across
+         * calls for efficiency. One way would be a direct bitmask that might
+         * be initialized quicker, but our bitmap_init implementation is
+         * pretty heavy-weight as well.
+         */
+        for (i=0; i<idx_len; i++) {
+                state->pollfd_idx[i] = -1;
+        }
 
         for (fde = ev->fd_events; fde; fde = fde->next) {
-                if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
-                        /* We ignore here, as it shouldn't be
-                           possible to add an invalid fde->fd
-                           but we don't want FD_SET to see an
-                           invalid fd. */
+                struct pollfd *pfd;
+
+                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) == 0) {
                         continue;
                 }
 
+                if (state->pollfd_idx[fde->fd] == -1) {
+                        /*
+                         * We haven't seen this fd yet. Allocate a new pollfd.
+                         */
+                        state->pollfd_idx[fde->fd] = num_pollfds;
+                        pfd = &fds[num_pollfds];
+                        num_pollfds += 1;
+                } else {
+                        /*
+                         * We have already seen this fd. OR in the flags.
+                         */
+                        pfd = &fds[state->pollfd_idx[fde->fd]];
+                }
+
+                pfd->fd = fde->fd;
+
                 if (fde->flags & EVENT_FD_READ) {
-                        FD_SET(fde->fd, read_fds);
-                        ret = true;
+                        pfd->events |= (POLLIN|POLLHUP);
                 }
                 if (fde->flags & EVENT_FD_WRITE) {
-                        FD_SET(fde->fd, write_fds);
-                        ret = true;
-                }
-
-                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
-                    && (fde->fd > *maxfd)) {
-                        *maxfd = fde->fd;
-                }
-        }
+                        pfd->events |= POLLOUT;
+                }
+        }
+        *pfds = fds;
+        *pnum_pfds = num_pollfds;
 
         if (ev->immediate_events != NULL) {
-                *timeout = timeval_zero();
-                return true;
-        }
-
+                *ptimeout = 0;
+                return true;
+        }
         if (ev->timer_events == NULL) {
-                return ret;
-        }
-
-        diff = timeval_until(now, &ev->timer_events->next_event);
-        *timeout = timeval_min(timeout, &diff);
+                *ptimeout = MIN(*ptimeout, INT_MAX);
+                return true;
+        }
+
+        now = timeval_current();
+        diff = timeval_until(&now, &ev->timer_events->next_event);
+        timeout = timeval_to_msec(diff);
+
+        if (timeout < *ptimeout) {
+                *ptimeout = timeout;
+        }
 
         return true;
 }
 
-bool run_events(struct tevent_context *ev,
-                int selrtn, fd_set *read_fds, fd_set *write_fds)
-{
+bool run_events_poll(struct tevent_context *ev, int pollrtn,
+                     struct pollfd *pfds, int num_pfds)
+{
+        struct tevent_poll_private *state;
+        int *pollfd_idx;
         struct tevent_fd *fde;
         struct timeval now;
@@ -140 +230 @@
         }
 
-        if (selrtn <= 0) {
+        if (pollrtn <= 0) {
                 /*
                  * No fd ready
@@ -147 +237 @@
         }
 
+        state = (struct tevent_poll_private *)ev->additional_data;
+        pollfd_idx = state->pollfd_idx;
+
         for (fde = ev->fd_events; fde; fde = fde->next) {
+                struct pollfd *pfd;
                 uint16 flags = 0;
 
-                if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
-                if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
-
+                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) == 0) {
+                        continue;
+                }
+
+                if (pollfd_idx[fde->fd] >= num_pfds) {
+                        DEBUG(1, ("internal error: pollfd_idx[fde->fd] (%d) "
+                                  ">= num_pfds (%d)\n", pollfd_idx[fde->fd],
+                                  num_pfds));
+                        return false;
+                }
+                pfd = &pfds[pollfd_idx[fde->fd]];
+
+                if (pfd->fd != fde->fd) {
+                        DEBUG(1, ("internal error: pfd->fd (%d) "
+                                  "!= fde->fd (%d)\n", pollfd_idx[fde->fd],
+                                  num_pfds));
+                        return false;
+                }
+
+                if (pfd->revents & (POLLHUP|POLLERR)) {
+                        /* If we only wait for EVENT_FD_WRITE, we
+                           should not tell the event handler about it,
+                           and remove the writable flag, as we only
+                           report errors when waiting for read events
+                           to match the select behavior. */
+                        if (!(fde->flags & EVENT_FD_READ)) {
+                                EVENT_FD_NOT_WRITEABLE(fde);
+                                continue;
+                        }
+                        flags |= EVENT_FD_READ;
+                }
+
+                if (pfd->revents & POLLIN) {
+                        flags |= EVENT_FD_READ;
+                }
+                if (pfd->revents & POLLOUT) {
+                        flags |= EVENT_FD_WRITE;
+                }
                 if (flags & fde->flags) {
-                        DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd *);
+                        DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd);
                         fde->handler(ev, fde, flags, fde->private_data);
                         return true;
@@ -162 +291 @@
         return false;
 }
-
 
 struct timeval *get_timed_events_timeout(struct tevent_context *ev,
@@ -188 +316 @@
 static int s3_event_loop_once(struct tevent_context *ev, const char *location)
 {
-        struct timeval now, to;
-        fd_set r_fds, w_fds;
-        int maxfd = 0;
+        struct tevent_poll_private *state;
+        int timeout;
+        int num_pfds;
         int ret;
 
-        FD_ZERO(&r_fds);
-        FD_ZERO(&w_fds);
-
-        to.tv_sec = 9999;       /* Max timeout */
-        to.tv_usec = 0;
-
-        if (run_events(ev, 0, NULL, NULL)) {
+        timeout = INT_MAX;
+
+        state = tevent_get_poll_private(ev);
+        if (state == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+
+        if (run_events_poll(ev, 0, NULL, 0)) {
                 return 0;
         }
 
-        GetTimeOfDay(&now);
-
-        if (!event_add_to_select_args(ev, &now, &r_fds, &w_fds, &to, &maxfd)) {
+        num_pfds = 0;
+        if (!event_add_to_poll_args(ev, state,
+                                    &state->pfds, &num_pfds, &timeout)) {
                 return -1;
         }
 
-        ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
-
+        ret = sys_poll(state->pfds, num_pfds, timeout);
         if (ret == -1 && errno != EINTR) {
                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
-                             "sys_select() failed: %d:%s\n",
+                             "poll() failed: %d:%s\n",
                              errno, strerror(errno));
                 return -1;
         }
 
-        run_events(ev, ret, &r_fds, &w_fds);
+        run_events_poll(ev, ret, state->pfds, num_pfds);
         return 0;
-}
-
-void event_context_reinit(struct tevent_context *ev)
-{
-        tevent_common_context_destructor(ev);
-        return;
 }