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 "poll-loop.h"
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <poll.h>
  38 #include <string.h>
  39 #include "list.h"
  40
  41 #define THIS_MODULE VLM_poll_loop
  42 #include "vlog.h"
  43
  44 struct poll_waiter {
  45     struct list node;
  46     int fd;
  47     short int events;
  48     struct pollfd *pollfd;
  49
  50     short int *revents;
  51
  52     poll_fd_func *function;
  53     void *aux;
  54 };
  55
  56 static struct list waiters = LIST_INITIALIZER(&waiters);
  57 static size_t n_waiters;
  58 static int timeout = -1;
  59
  60 #ifndef NDEBUG
  61 static struct poll_waiter *running_cb;
  62 #endif
  63
  64 static struct poll_waiter *
  65 new_waiter(int fd, short int events)
  66 {
  67     struct poll_waiter *waiter = xcalloc(1, sizeof *waiter);
  68     assert(fd >= 0);
  69     waiter->fd = fd;
  70     waiter->events = events;
  71     list_push_back(&waiters, &waiter->node);
  72     n_waiters++;
  73     return waiter;
  74 }
  75
  76 struct poll_waiter *
  77 poll_fd_callback(int fd, short int events, poll_fd_func *function, void *aux)
  78 {
  79     struct poll_waiter *pw = new_waiter(fd, events);
  80     pw->function = function;
  81     pw->aux = aux;
  82     return pw;
  83 }
  84
  85 struct poll_waiter *
  86 poll_fd_wait(int fd, short int events, short int *revents)
  87 {
  88     struct poll_waiter *pw = new_waiter(fd, events);
  89     pw->revents = revents;
  90     if (revents) {
  91         *revents = 0;
  92     }
  93     return pw;
  94 }
  95
  96 void
  97 poll_cancel(struct poll_waiter *pw)
  98 {
  99     if (pw) {
 100         assert(pw != running_cb);
 101         list_remove(&pw->node);
 102         n_waiters--;
 103     }
 104 }
 105
 106 void
 107 poll_immediate_wake(void)
 108 {
 109     timeout = 0;
 110 }
 111
 112 void
 113 poll_timer_wait(int msec)
 114 {
 115     if (timeout < 0 || msec < timeout) {
 116         timeout = MAX(0, msec);
 117     }
 118 }
 119
 120 void
 121 poll_block(void)
 122 {
 123     static struct pollfd *pollfds;
 124     static size_t max_pollfds;
 125
 126     struct poll_waiter *pw;
 127     struct list *node;
 128     int n_pollfds;
 129     int retval;
 130
 131     assert(!running_cb);
 132     if (max_pollfds < n_waiters) {
 133         max_pollfds = n_waiters;
 134         pollfds = xrealloc(pollfds, max_pollfds * sizeof *pollfds);
 135     }
 136
 137     n_pollfds = 0;
 138     LIST_FOR_EACH (pw, struct poll_waiter, node, &waiters) {
 139         pw->pollfd = &pollfds[n_pollfds];
 140         pollfds[n_pollfds].fd = pw->fd;
 141         pollfds[n_pollfds].events = pw->events;
 142         pollfds[n_pollfds].revents = 0;
 143         n_pollfds++;
 144     }
 145
 146     do {
 147         retval = poll(pollfds, n_pollfds, timeout);
 148     } while (retval < 0 && errno == EINTR);
 149     if (retval < 0) {
 150         VLOG_ERR("poll: %s", strerror(errno));
 151     }
 152
 153     for (node = waiters.next; node != &waiters; ) {
 154         pw = CONTAINER_OF(node, struct poll_waiter, node);
 155         if (!pw->pollfd || !pw->pollfd->revents) {
 156             if (pw->function) {
 157                 node = node->next;
 158                 continue;
 159             }
 160         } else {
 161             if (pw->function) {
 162 #ifndef NDEBUG
 163                 running_cb = pw;
 164 #endif
 165                 pw->function(pw->fd, pw->pollfd->revents, pw->aux);
 166 #ifndef NDEBUG
 167                 running_cb = NULL;
 168 #endif
 169             } else if (pw->revents) {
 170                 *pw->revents = pw->pollfd->revents;
 171             }
 172         }
 173         node = list_remove(node);
 174         n_waiters--;
 175     }
 176
 177     timeout = -1;
 178 }