third_party/libevent/select.c

   1 /*      $OpenBSD: select.c,v 1.2 2002/06/25 15:50:15 mickey Exp $       */
   2
   3 /*
   4  * Copyright 2000-2002 Niels Provos <provos@citi.umich.edu>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <sys/types.h>
  34 #ifdef HAVE_SYS_TIME_H
  35 #include <sys/time.h>
  36 #else
  37 #include <sys/_libevent_time.h>
  38 #endif
  39 #ifdef HAVE_SYS_SELECT_H
  40 #include <sys/select.h>
  41 #endif
  42 #include <sys/queue.h>
  43 #include <signal.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <errno.h>
  49 #ifdef CHECK_INVARIANTS
  50 #include <assert.h>
  51 #endif
  52
  53 #include "event.h"
  54 #include "evutil.h"
  55 #include "event-internal.h"
  56 #include "evsignal.h"
  57 #include "log.h"
  58
  59 #ifndef howmany
  60 #define        howmany(x, y)   (((x)+((y)-1))/(y))
  61 #endif
  62
  63 #ifndef _EVENT_HAVE_FD_MASK
  64 /* This type is mandatory, but Android doesn't define it. */
  65 #undef NFDBITS
  66 #define NFDBITS (sizeof(long)*8)
  67 typedef unsigned long fd_mask;
  68 #endif
  69
  70 struct selectop {
  71         int event_fds;          /* Highest fd in fd set */
  72         int event_fdsz;
  73         fd_set *event_readset_in;
  74         fd_set *event_writeset_in;
  75         fd_set *event_readset_out;
  76         fd_set *event_writeset_out;
  77         struct event **event_r_by_fd;
  78         struct event **event_w_by_fd;
  79 };
  80
  81 static void *select_init        (struct event_base *);
  82 static int select_add           (void *, struct event *);
  83 static int select_del           (void *, struct event *);
  84 static int select_dispatch      (struct event_base *, void *, struct timeval *);
  85 static void select_dealloc     (struct event_base *, void *);
  86
  87 const struct eventop selectops = {
  88         "select",
  89         select_init,
  90         select_add,
  91         select_del,
  92         select_dispatch,
  93         select_dealloc,
  94         0
  95 };
  96
  97 static int select_resize(struct selectop *sop, int fdsz);
  98
  99 static void *
 100 select_init(struct event_base *base)
 101 {
 102         struct selectop *sop;
 103
 104         /* Disable select when this environment variable is set */
 105         if (evutil_getenv("EVENT_NOSELECT"))
 106                 return (NULL);
 107
 108         if (!(sop = calloc(1, sizeof(struct selectop))))
 109                 return (NULL);
 110
 111         select_resize(sop, howmany(32 + 1, NFDBITS)*sizeof(fd_mask));
 112
 113         evsignal_init(base);
 114
 115         return (sop);
 116 }
 117
 118 #ifdef CHECK_INVARIANTS
 119 static void
 120 check_selectop(struct selectop *sop)
 121 {
 122         int i;
 123         for (i = 0; i <= sop->event_fds; ++i) {
 124                 if (FD_ISSET(i, sop->event_readset_in)) {
 125                         assert(sop->event_r_by_fd[i]);
 126                         assert(sop->event_r_by_fd[i]->ev_events & EV_READ);
 127                         assert(sop->event_r_by_fd[i]->ev_fd == i);
 128                 } else {
 129                         assert(! sop->event_r_by_fd[i]);
 130                 }
 131                 if (FD_ISSET(i, sop->event_writeset_in)) {
 132                         assert(sop->event_w_by_fd[i]);
 133                         assert(sop->event_w_by_fd[i]->ev_events & EV_WRITE);
 134                         assert(sop->event_w_by_fd[i]->ev_fd == i);
 135                 } else {
 136                         assert(! sop->event_w_by_fd[i]);
 137                 }
 138         }
 139
 140 }
 141 #else
 142 #define check_selectop(sop) do { (void) sop; } while (0)
 143 #endif
 144
 145 static int
 146 select_dispatch(struct event_base *base, void *arg, struct timeval *tv)
 147 {
 148         int res, i, j;
 149         struct selectop *sop = arg;
 150
 151         check_selectop(sop);
 152
 153         memcpy(sop->event_readset_out, sop->event_readset_in,
 154                sop->event_fdsz);
 155         memcpy(sop->event_writeset_out, sop->event_writeset_in,
 156                sop->event_fdsz);
 157
 158         res = select(sop->event_fds + 1, sop->event_readset_out,
 159             sop->event_writeset_out, NULL, tv);
 160
 161         check_selectop(sop);
 162
 163         if (res == -1) {
 164                 if (errno != EINTR) {
 165                         event_warn("select");
 166                         return (-1);
 167                 }
 168
 169                 evsignal_process(base);
 170                 return (0);
 171         } else if (base->sig.evsignal_caught) {
 172                 evsignal_process(base);
 173         }
 174
 175         event_debug(("%s: select reports %d", __func__, res));
 176
 177         check_selectop(sop);
 178         i = random() % (sop->event_fds+1);
 179         for (j = 0; j <= sop->event_fds; ++j) {
 180                 struct event *r_ev = NULL, *w_ev = NULL;
 181                 if (++i >= sop->event_fds+1)
 182                         i = 0;
 183
 184                 res = 0;
 185                 if (FD_ISSET(i, sop->event_readset_out)) {
 186                         r_ev = sop->event_r_by_fd[i];
 187                         res |= EV_READ;
 188                 }
 189                 if (FD_ISSET(i, sop->event_writeset_out)) {
 190                         w_ev = sop->event_w_by_fd[i];
 191                         res |= EV_WRITE;
 192                 }
 193                 if (r_ev && (res & r_ev->ev_events)) {
 194                         event_active(r_ev, res & r_ev->ev_events, 1);
 195                 }
 196                 if (w_ev && w_ev != r_ev && (res & w_ev->ev_events)) {
 197                         event_active(w_ev, res & w_ev->ev_events, 1);
 198                 }
 199         }
 200         check_selectop(sop);
 201
 202         return (0);
 203 }
 204
 205
 206 static int
 207 select_resize(struct selectop *sop, int fdsz)
 208 {
 209         int n_events, n_events_old;
 210
 211         fd_set *readset_in = NULL;
 212         fd_set *writeset_in = NULL;
 213         fd_set *readset_out = NULL;
 214         fd_set *writeset_out = NULL;
 215         struct event **r_by_fd = NULL;
 216         struct event **w_by_fd = NULL;
 217
 218         n_events = (fdsz/sizeof(fd_mask)) * NFDBITS;
 219         n_events_old = (sop->event_fdsz/sizeof(fd_mask)) * NFDBITS;
 220
 221         if (sop->event_readset_in)
 222                 check_selectop(sop);
 223
 224         if ((readset_in = realloc(sop->event_readset_in, fdsz)) == NULL)
 225                 goto error;
 226         sop->event_readset_in = readset_in;
 227         if ((readset_out = realloc(sop->event_readset_out, fdsz)) == NULL)
 228                 goto error;
 229         sop->event_readset_out = readset_out;
 230         if ((writeset_in = realloc(sop->event_writeset_in, fdsz)) == NULL)
 231                 goto error;
 232         sop->event_writeset_in = writeset_in;
 233         if ((writeset_out = realloc(sop->event_writeset_out, fdsz)) == NULL)
 234                 goto error;
 235         sop->event_writeset_out = writeset_out;
 236         if ((r_by_fd = realloc(sop->event_r_by_fd,
 237                  n_events*sizeof(struct event*))) == NULL)
 238                 goto error;
 239         sop->event_r_by_fd = r_by_fd;
 240         if ((w_by_fd = realloc(sop->event_w_by_fd,
 241                  n_events * sizeof(struct event*))) == NULL)
 242                 goto error;
 243         sop->event_w_by_fd = w_by_fd;
 244
 245         memset((char *)sop->event_readset_in + sop->event_fdsz, 0,
 246             fdsz - sop->event_fdsz);
 247         memset((char *)sop->event_writeset_in + sop->event_fdsz, 0,
 248             fdsz - sop->event_fdsz);
 249         memset(sop->event_r_by_fd + n_events_old, 0,
 250             (n_events-n_events_old) * sizeof(struct event*));
 251         memset(sop->event_w_by_fd + n_events_old, 0,
 252             (n_events-n_events_old) * sizeof(struct event*));
 253
 254         sop->event_fdsz = fdsz;
 255         check_selectop(sop);
 256
 257         return (0);
 258
 259  error:
 260         event_warn("malloc");
 261         return (-1);
 262 }
 263
 264
 265 static int
 266 select_add(void *arg, struct event *ev)
 267 {
 268         struct selectop *sop = arg;
 269
 270         if (ev->ev_events & EV_SIGNAL)
 271                 return (evsignal_add(ev));
 272
 273         check_selectop(sop);
 274         /*
 275          * Keep track of the highest fd, so that we can calculate the size
 276          * of the fd_sets for select(2)
 277          */
 278         if (sop->event_fds < ev->ev_fd) {
 279                 int fdsz = sop->event_fdsz;
 280
 281                 if (fdsz < sizeof(fd_mask))
 282                         fdsz = sizeof(fd_mask);
 283
 284                 while (fdsz <
 285                     (howmany(ev->ev_fd + 1, NFDBITS) * sizeof(fd_mask)))
 286                         fdsz *= 2;
 287
 288                 if (fdsz != sop->event_fdsz) {
 289                         if (select_resize(sop, fdsz)) {
 290                                 check_selectop(sop);
 291                                 return (-1);
 292                         }
 293                 }
 294
 295                 sop->event_fds = ev->ev_fd;
 296         }
 297
 298         if (ev->ev_events & EV_READ) {
 299                 FD_SET(ev->ev_fd, sop->event_readset_in);
 300                 sop->event_r_by_fd[ev->ev_fd] = ev;
 301         }
 302         if (ev->ev_events & EV_WRITE) {
 303                 FD_SET(ev->ev_fd, sop->event_writeset_in);
 304                 sop->event_w_by_fd[ev->ev_fd] = ev;
 305         }
 306         check_selectop(sop);
 307
 308         return (0);
 309 }
 310
 311 /*
 312  * Nothing to be done here.
 313  */
 314
 315 static int
 316 select_del(void *arg, struct event *ev)
 317 {
 318         struct selectop *sop = arg;
 319
 320         check_selectop(sop);
 321         if (ev->ev_events & EV_SIGNAL)
 322                 return (evsignal_del(ev));
 323
 324         if (sop->event_fds < ev->ev_fd) {
 325                 check_selectop(sop);
 326                 return (0);
 327         }
 328
 329         if (ev->ev_events & EV_READ) {
 330                 FD_CLR(ev->ev_fd, sop->event_readset_in);
 331                 sop->event_r_by_fd[ev->ev_fd] = NULL;
 332         }
 333
 334         if (ev->ev_events & EV_WRITE) {
 335                 FD_CLR(ev->ev_fd, sop->event_writeset_in);
 336                 sop->event_w_by_fd[ev->ev_fd] = NULL;
 337         }
 338
 339         check_selectop(sop);
 340         return (0);
 341 }
 342
 343 static void
 344 select_dealloc(struct event_base *base, void *arg)
 345 {
 346         struct selectop *sop = arg;
 347
 348         evsignal_dealloc(base);
 349         if (sop->event_readset_in)
 350                 free(sop->event_readset_in);
 351         if (sop->event_writeset_in)
 352                 free(sop->event_writeset_in);
 353         if (sop->event_readset_out)
 354                 free(sop->event_readset_out);
 355         if (sop->event_writeset_out)
 356                 free(sop->event_writeset_out);
 357         if (sop->event_r_by_fd)
 358                 free(sop->event_r_by_fd);
 359         if (sop->event_w_by_fd)
 360                 free(sop->event_w_by_fd);
 361
 362         memset(sop, 0, sizeof(struct selectop));
 363         free(sop);
 364 }