lib/poll-loop.c

   1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
   2  * Junior University
   3  *
   4  * We are making the OpenFlow specification and associated documentation
   5  * (Software) available for public use and benefit with the expectation
   6  * that others will use, modify and enhance the Software and contribute
   7  * those enhancements back to the community. However, since we would
   8  * like to make the Software available for broadest use, with as few
   9  * restrictions as possible permission is hereby granted, free of
  10  * charge, to any person obtaining a copy of this Software to deal in
  11  * the Software under the copyrights without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  *
  29  * The name and trademarks of copyright holder(s) may NOT be used in
  30  * advertising or publicity pertaining to the Software or any
  31  * derivatives without specific, written prior permission.
  32  */
  33
  34 #include <config.h>
  35 #include "poll-loop.h"
  36 #include <assert.h>
  37 #include <errno.h>
  38 #include <poll.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include "list.h"
  42 #include "timeval.h"
  43
  44 #define THIS_MODULE VLM_poll_loop
  45 #include "vlog.h"
  46
  47 /* An event that will wake the following call to poll_block(). */
  48 struct poll_waiter {
  49     /* Set when the waiter is created. */
  50     struct list node;           /* Element in global waiters list. */
  51     int fd;                     /* File descriptor. */
  52     short int events;           /* Events to wait for (POLLIN, POLLOUT). */
  53     poll_fd_func *function;     /* Callback function, if any, or null. */
  54     void *aux;                  /* Argument to callback function. */
  55
  56     /* Set only when poll_block() is called. */
  57     struct pollfd *pollfd;      /* Pointer to element of the pollfds array
  58                                    (null if added from a callback). */
  59 };
  60
  61 /* All active poll waiters. */
  62 static struct list waiters = LIST_INITIALIZER(&waiters);
  63
  64 /* Number of elements in the waiters list. */
  65 static size_t n_waiters;
  66
  67 /* Max time to wait in next call to poll_block(), in milliseconds, or -1 to
  68  * wait forever. */
  69 static int timeout = -1;
  70
  71 /* Callback currently running, to allow verifying that poll_cancel() is not
  72  * being called on a running callback. */
  73 #ifndef NDEBUG
  74 static struct poll_waiter *running_cb;
  75 #endif
  76
  77 static struct poll_waiter *new_waiter(int fd, short int events);
  78
  79 /* Registers 'fd' as waiting for the specified 'events' (which should be POLLIN
  80  * or POLLOUT or POLLIN | POLLOUT).  The following call to poll_block() will
  81  * wake up when 'fd' becomes ready for one or more of the requested events.
  82  *
  83  * The event registration is one-shot: only the following call to poll_block()
  84  * is affected.  The event will need to be re-registered after poll_block() is
  85  * called if it is to persist. */
  86 struct poll_waiter *
  87 poll_fd_wait(int fd, short int events)
  88 {
  89     return new_waiter(fd, events);
  90 }
  91
  92 /* Causes the following call to poll_block() to block for no more than 'msec'
  93  * milliseconds.  If 'msec' is nonpositive, the following call to poll_block()
  94  * will not block at all.
  95  *
  96  * The timer registration is one-shot: only the following call to poll_block()
  97  * is affected.  The timer will need to be re-registered after poll_block() is
  98  * called if it is to persist. */
  99 void
 100 poll_timer_wait(int msec)
 101 {
 102     if (timeout < 0 || msec < timeout) {
 103         timeout = MAX(0, msec);
 104     }
 105 }
 106
 107 /* Causes the following call to poll_block() to wake up immediately, without
 108  * blocking. */
 109 void
 110 poll_immediate_wake(void)
 111 {
 112     timeout = 0;
 113 }
 114
 115 /* Blocks until one or more of the events registered with poll_fd_wait()
 116  * occurs, or until the minimum duration registered with poll_timer_wait()
 117  * elapses, or not at all if poll_immediate_wake() has been called.
 118  *
 119  * Also executes any autonomous subroutines registered with poll_fd_callback(),
 120  * if their file descriptor have become ready. */
 121 void
 122 poll_block(void)
 123 {
 124     static struct pollfd *pollfds;
 125     static size_t max_pollfds;
 126
 127     struct poll_waiter *pw;
 128     struct list *node;
 129     int n_pollfds;
 130     int retval;
 131
 132     assert(!running_cb);
 133     if (max_pollfds < n_waiters) {
 134         max_pollfds = n_waiters;
 135         pollfds = xrealloc(pollfds, max_pollfds * sizeof *pollfds);
 136     }
 137
 138     n_pollfds = 0;
 139     LIST_FOR_EACH (pw, struct poll_waiter, node, &waiters) {
 140         pw->pollfd = &pollfds[n_pollfds];
 141         pollfds[n_pollfds].fd = pw->fd;
 142         pollfds[n_pollfds].events = pw->events;
 143         pollfds[n_pollfds].revents = 0;
 144         n_pollfds++;
 145     }
 146
 147     retval = time_poll(pollfds, n_pollfds, timeout);
 148     if (retval < 0) {
 149         VLOG_ERR("poll: %s", strerror(-retval));
 150     }
 151
 152     for (node = waiters.next; node != &waiters; ) {
 153         pw = CONTAINER_OF(node, struct poll_waiter, node);
 154         if (!pw->pollfd || !pw->pollfd->revents) {
 155             if (pw->function) {
 156                 node = node->next;
 157                 continue;
 158             }
 159         } else if (pw->function) {
 160 #ifndef NDEBUG
 161             running_cb = pw;
 162 #endif
 163             pw->function(pw->fd, pw->pollfd->revents, pw->aux);
 164 #ifndef NDEBUG
 165             running_cb = NULL;
 166 #endif
 167         }
 168         node = node->next;
 169         poll_cancel(pw);
 170     }
 171
 172     timeout = -1;
 173 }
 174
 175 /* Registers 'function' to be called with argument 'aux' by poll_block() when
 176  * 'fd' becomes ready for one of the events in 'events', which should be POLLIN
 177  * or POLLOUT or POLLIN | POLLOUT.
 178  *
 179  * The callback registration persists until the event actually occurs.  At that
 180  * point, it is automatically de-registered.  The callback function must
 181  * re-register the event by calling poll_fd_callback() again within the
 182  * callback, if it wants to be called back again later. */
 183 struct poll_waiter *
 184 poll_fd_callback(int fd, short int events, poll_fd_func *function, void *aux)
 185 {
 186     struct poll_waiter *pw = new_waiter(fd, events);
 187     pw->function = function;
 188     pw->aux = aux;
 189     return pw;
 190 }
 191
 192 /* Cancels the file descriptor event registered with poll_fd_wait() or
 193  * poll_fd_callback().  'pw' must be the struct poll_waiter returned by one of
 194  * those functions.
 195  *
 196  * An event registered with poll_fd_wait() may be canceled from its time of
 197  * registration until the next call to poll_block().  At that point, the event
 198  * is automatically canceled by the system and its poll_waiter is freed.
 199  *
 200  * An event registered with poll_fd_callback() may be canceled from its time of
 201  * registration until its callback is actually called.  At that point, the
 202  * event is automatically canceled by the system and its poll_waiter is
 203  * freed. */
 204 void
 205 poll_cancel(struct poll_waiter *pw)
 206 {
 207     if (pw) {
 208         assert(pw != running_cb);
 209         list_remove(&pw->node);
 210         free(pw);
 211         n_waiters--;
 212     }
 213 }
 214 \f
 215 /* Creates and returns a new poll_waiter for 'fd' and 'events'. */
 216 static struct poll_waiter *
 217 new_waiter(int fd, short int events)
 218 {
 219     struct poll_waiter *waiter = xcalloc(1, sizeof *waiter);
 220     assert(fd >= 0);
 221     waiter->fd = fd;
 222     waiter->events = events;
 223     list_push_back(&waiters, &waiter->node);
 224     n_waiters++;
 225     return waiter;
 226 }