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

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

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

vendor/current/source3/lib/events.c

@@ -3 +3 @@
    Timed event library.
    Copyright (C) Andrew Tridgell 1992-1998
-   Copyright (C) Volker Lendecke 2005
+   Copyright (C) Volker Lendecke 2005-2007
 
    This program is free software; you can redistribute it and/or modify
@@ -43 +43 @@
         state = (struct tevent_poll_private *)ev->additional_data;
         if (state == NULL) {
-                state = TALLOC_ZERO_P(ev, struct tevent_poll_private);
+                state = talloc_zero(ev, struct tevent_poll_private);
                 ev->additional_data = (void *)state;
                 if (state == NULL) {
@@ -60 +60 @@
 
         for (fde = ev->fd_events; fde != NULL; fde = fde->next) {
-                if (fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) {
+                if (fde->flags & (TEVENT_FD_READ|TEVENT_FD_WRITE)) {
                         num_fds += 1;
                         if (fde->fd > max_fd) {
@@ -91 +91 @@
 
         if (talloc_array_length(state->pollfd_idx) < idx_len) {
-                state->pollfd_idx = TALLOC_REALLOC_ARRAY(
+                state->pollfd_idx = talloc_realloc(
                         state, state->pollfd_idx, int, idx_len);
                 if (state->pollfd_idx == NULL) {
@@ -102 +102 @@
         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 (talloc_array_length(fds) < num_pollfds + num_fds) {
+                fds = talloc_realloc(mem_ctx, fds, struct pollfd,
+                                           num_pollfds + num_fds);
                 if (fds == NULL) {
                         DEBUG(10, ("talloc_realloc failed\n"));
@@ -132 +127 @@
                 struct pollfd *pfd;
 
-                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) == 0) {
+                if ((fde->flags & (TEVENT_FD_READ|TEVENT_FD_WRITE)) == 0) {
                         continue;
                 }
@@ -152 +147 @@
                 pfd->fd = fde->fd;
 
-                if (fde->flags & EVENT_FD_READ) {
+                if (fde->flags & TEVENT_FD_READ) {
                         pfd->events |= (POLLIN|POLLHUP);
                 }
-                if (fde->flags & EVENT_FD_WRITE) {
+                if (fde->flags & TEVENT_FD_WRITE) {
                         pfd->events |= POLLOUT;
                 }
@@ -188 +183 @@
         int *pollfd_idx;
         struct tevent_fd *fde;
-        struct timeval now;
 
         if (ev->signal_events &&
@@ -200 +194 @@
         }
 
-        GetTimeOfDay(&now);
-
-        if ((ev->timer_events != NULL)
-            && (timeval_compare(&now, &ev->timer_events->next_event) >= 0)) {
-                /* this older events system did not auto-free timed
-                   events on running them, and had a race condition
-                   where the event could be called twice if the
-                   talloc_free of the te happened after the callback
-                   made a call which invoked the event loop. To avoid
-                   this while still allowing old code which frees the
-                   te, we need to create a temporary context which
-                   will be used to ensure the te is freed. We also
-                   remove the te from the timed event list before we
-                   call the handler, to ensure we can't loop */
-
-                struct tevent_timer *te = ev->timer_events;
-                TALLOC_CTX *tmp_ctx = talloc_new(ev);
-
-                DEBUG(10, ("Running timed event \"%s\" %p\n",
-                           ev->timer_events->handler_name, ev->timer_events));
-
-                DLIST_REMOVE(ev->timer_events, te);
-                talloc_steal(tmp_ctx, te);
-
-                te->handler(ev, te, now, te->private_data);
-
-                talloc_free(tmp_ctx);
-                return true;
-        }
-
         if (pollrtn <= 0) {
+                struct timeval tval;
+
+                tval = tevent_common_loop_timer_delay(ev);
+                if (tevent_timeval_is_zero(&tval)) {
+                        return true;
+                }
+
                 /*
                  * No fd ready
@@ -242 +213 @@
         for (fde = ev->fd_events; fde; fde = fde->next) {
                 struct pollfd *pfd;
-                uint16 flags = 0;
-
-                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) == 0) {
+                uint16_t flags = 0;
+
+                if ((fde->flags & (TEVENT_FD_READ|TEVENT_FD_WRITE)) == 0) {
                         continue;
                 }
@@ -264 +235 @@
 
                 if (pfd->revents & (POLLHUP|POLLERR)) {
-                        /* If we only wait for EVENT_FD_WRITE, we
+                        /* If we only wait for TEVENT_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);
+                        if (!(fde->flags & TEVENT_FD_READ)) {
+                                TEVENT_FD_NOT_WRITEABLE(fde);
                                 continue;
                         }
-                        flags |= EVENT_FD_READ;
+                        flags |= TEVENT_FD_READ;
                 }
 
                 if (pfd->revents & POLLIN) {
-                        flags |= EVENT_FD_READ;
+                        flags |= TEVENT_FD_READ;
                 }
                 if (pfd->revents & POLLOUT) {
-                        flags |= EVENT_FD_WRITE;
+                        flags |= TEVENT_FD_WRITE;
                 }
                 if (flags & fde->flags) {
-                        DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd);
+                        DLIST_DEMOTE(ev->fd_events, fde);
                         fde->handler(ev, fde, flags, fde->private_data);
                         return true;
@@ -320 +291 @@
         int num_pfds;
         int ret;
+        int poll_errno;
 
         timeout = INT_MAX;
@@ -339 +311 @@
         }
 
-        ret = sys_poll(state->pfds, num_pfds, timeout);
+        tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_WAIT);
+        ret = poll(state->pfds, num_pfds, timeout);
+        poll_errno = errno;
+        tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_WAIT);
+        errno = poll_errno;
+
         if (ret == -1 && errno != EINTR) {
                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
@@ -414 +391 @@
 }
 
-/*
-  this is used to catch debug messages from events
-*/
-static void s3_event_debug(void *context, enum tevent_debug_level level,
-                           const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
-
-static void s3_event_debug(void *context, enum tevent_debug_level level,
-                           const char *fmt, va_list ap)
-{
-        int samba_level = -1;
-        char *s = NULL;
-        switch (level) {
-        case TEVENT_DEBUG_FATAL:
-                samba_level = 0;
-                break;
-        case TEVENT_DEBUG_ERROR:
-                samba_level = 1;
-                break;
-        case TEVENT_DEBUG_WARNING:
-                samba_level = 2;
-                break;
-        case TEVENT_DEBUG_TRACE:
-                samba_level = 11;
-                break;
-
-        };
-        if (vasprintf(&s, fmt, ap) == -1) {
-                return;
-        }
-        DEBUG(samba_level, ("s3_event: %s", s));
-        free(s);
-}
-
 struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
 {
@@ -455 +399 @@
         ev = tevent_context_init_byname(mem_ctx, "s3");
         if (ev) {
-                tevent_set_debug(ev, s3_event_debug, NULL);
+                samba_tevent_set_debug(ev, "s3_tevent");
         }
 
@@ -461 +405 @@
 }
 
+struct idle_event {
+        struct tevent_timer *te;
+        struct timeval interval;
+        char *name;
+        bool (*handler)(const struct timeval *now, void *private_data);
+        void *private_data;
+};
+
+static void smbd_idle_event_handler(struct tevent_context *ctx,
+                                    struct tevent_timer *te,
+                                    struct timeval now,
+                                    void *private_data)
+{
+        struct idle_event *event =
+                talloc_get_type_abort(private_data, struct idle_event);
+
+        TALLOC_FREE(event->te);
+
+        DEBUG(10,("smbd_idle_event_handler: %s %p called\n",
+                  event->name, event->te));
+
+        if (!event->handler(&now, event->private_data)) {
+                DEBUG(10,("smbd_idle_event_handler: %s %p stopped\n",
+                          event->name, event->te));
+                /* Don't repeat, delete ourselves */
+                TALLOC_FREE(event);
+                return;
+        }
+
+        DEBUG(10,("smbd_idle_event_handler: %s %p rescheduled\n",
+                  event->name, event->te));
+
+        event->te = tevent_add_timer(ctx, event,
+                                     timeval_sum(&now, &event->interval),
+                                     smbd_idle_event_handler, event);
+
+        /* We can't do much but fail here. */
+        SMB_ASSERT(event->te != NULL);
+}
+
+struct idle_event *event_add_idle(struct tevent_context *event_ctx,
+                                  TALLOC_CTX *mem_ctx,
+                                  struct timeval interval,
+                                  const char *name,
+                                  bool (*handler)(const struct timeval *now,
+                                                  void *private_data),
+                                  void *private_data)
+{
+        struct idle_event *result;
+        struct timeval now = timeval_current();
+
+        result = talloc(mem_ctx, struct idle_event);
+        if (result == NULL) {
+                DEBUG(0, ("talloc failed\n"));
+                return NULL;
+        }
+
+        result->interval = interval;
+        result->handler = handler;
+        result->private_data = private_data;
+
+        if (!(result->name = talloc_asprintf(result, "idle_evt(%s)", name))) {
+                DEBUG(0, ("talloc failed\n"));
+                TALLOC_FREE(result);
+                return NULL;
+        }
+
+        result->te = tevent_add_timer(event_ctx, result,
+                                      timeval_sum(&now, &interval),
+                                      smbd_idle_event_handler, result);
+        if (result->te == NULL) {
+                DEBUG(0, ("event_add_timed failed\n"));
+                TALLOC_FREE(result);
+                return NULL;
+        }
+
+        DEBUG(10,("event_add_idle: %s %p\n", result->name, result->te));
+        return result;
+}
+