source4/lib/events/events.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    main select loop and event handling
   4    Copyright (C) Andrew Tridgell 2003
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 /*
  22   PLEASE READ THIS BEFORE MODIFYING!
  23
  24   This module is a general abstraction for the main select loop and
  25   event handling. Do not ever put any localised hacks in here, instead
  26   register one of the possible event types and implement that event
  27   somewhere else.
  28
  29   There are 2 types of event handling that are handled in this module:
  30
  31   1) a file descriptor becoming readable or writeable. This is mostly
  32      used for network sockets, but can be used for any type of file
  33      descriptor. You may only register one handler for each file
  34      descriptor/io combination or you will get unpredictable results
  35      (this means that you can have a handler for read events, and a
  36      separate handler for write events, but not two handlers that are
  37      both handling read events)
  38
  39   2) a timed event. You can register an event that happens at a
  40      specific time.  You can register as many of these as you
  41      like. They are single shot - add a new timed event in the event
  42      handler to get another event.
  43
  44   To setup a set of events you first need to create a event_context
  45   structure using the function event_context_init(); This returns a
  46   'struct event_context' that you use in all subsequent calls.
  47
  48   After that you can add/remove events that you are interested in
  49   using event_add_*() and talloc_free()
  50
  51   Finally, you call event_loop_wait() to block waiting for one of the
  52   events to occor. In normal operation event_loop_wait() will loop
  53   forever.
  54
  55 */
  56
  57 #include "includes.h"
  58 #include "system/time.h"
  59 #include "system/select.h"
  60 #include "dlinklist.h"
  61 #include "lib/events/events.h"
  62
  63 /* use epoll if it is available */
  64 #if defined(HAVE_EPOLL_CREATE) && defined(HAVE_SYS_EPOLL_H)
  65 #define WITH_EPOLL 1
  66 #endif
  67
  68 #if WITH_EPOLL
  69 #include <sys/epoll.h>
  70 #endif
  71
  72 struct event_context {
  73         /* list of filedescriptor events */
  74         struct fd_event {
  75                 struct event_context *event_ctx;
  76                 struct fd_event *next, *prev;
  77                 int fd;
  78                 uint16_t flags; /* see EVENT_FD_* flags */
  79                 event_fd_handler_t handler;
  80                 void *private;
  81         } *fd_events;
  82
  83         /* list of timed events */
  84         struct timed_event {
  85                 struct event_context *event_ctx;
  86                 struct timed_event *next, *prev;
  87                 struct timeval next_event;
  88                 event_timed_handler_t handler;
  89                 void *private;
  90         } *timed_events;
  91
  92         /* the maximum file descriptor number in fd_events */
  93         int maxfd;
  94
  95         /* information for exiting from the event loop */
  96         int exit_code;
  97
  98         /* this is changed by the destructors for the fd event
  99            type. It is used to detect event destruction by event
 100            handlers, which means the code that is calling the event
 101            handler needs to assume that the linked list is no longer
 102            valid
 103         */
 104         uint32_t destruction_count;
 105
 106 #if WITH_EPOLL
 107         /* when using epoll this is the handle from epoll_create */
 108         int epoll_fd;
 109 #endif
 110 };
 111
 112
 113 /*
 114   create a event_context structure. This must be the first events
 115   call, and all subsequent calls pass this event_context as the first
 116   element. Event handlers also receive this as their first argument.
 117 */
 118 struct event_context *event_context_init(TALLOC_CTX *mem_ctx)
 119 {
 120         struct event_context *ev;
 121
 122         ev = talloc_zero(mem_ctx, struct event_context);
 123         if (!ev) return NULL;
 124
 125 #if WITH_EPOLL
 126         ev->epoll_fd = epoll_create(64);
 127 #endif
 128
 129         return ev;
 130 }
 131
 132
 133 /*
 134   recalculate the maxfd
 135 */
 136 static void calc_maxfd(struct event_context *ev)
 137 {
 138         struct fd_event *e;
 139         ev->maxfd = 0;
 140         for (e=ev->fd_events; e; e=e->next) {
 141                 if (e->fd > ev->maxfd) {
 142                         ev->maxfd = e->fd;
 143                 }
 144         }
 145 }
 146
 147
 148 /* to mark the ev->maxfd invalid
 149  * this means we need to recalculate it
 150  */
 151 #define EVENT_INVALID_MAXFD (-1)
 152
 153
 154 #if WITH_EPOLL
 155 /*
 156   called when a epoll call fails, and we should fallback
 157   to using select
 158 */
 159 static void epoll_fallback_to_select(struct event_context *ev, const char *reason)
 160 {
 161         DEBUG(0,("%s (%s) - falling back to select()\n", reason, strerror(errno)));
 162         close(ev->epoll_fd);
 163         ev->epoll_fd = -1;
 164 }
 165 #endif
 166
 167
 168 #if WITH_EPOLL
 169 /*
 170   map from EVENT_FD_* to EPOLLIN/EPOLLOUT
 171 */
 172 static uint32_t epoll_map_flags(uint16_t flags)
 173 {
 174         uint32_t ret = 0;
 175         if (flags & EVENT_FD_READ) ret |= EPOLLIN;
 176         if (flags & EVENT_FD_WRITE) ret |= EPOLLOUT;
 177         return ret;
 178 }
 179 #endif
 180
 181 /*
 182   destroy an fd_event
 183 */
 184 static int event_fd_destructor(void *ptr)
 185 {
 186         struct fd_event *fde = talloc_get_type(ptr, struct fd_event);
 187         struct event_context *ev = fde->event_ctx;
 188
 189         if (ev->maxfd == fde->fd) {
 190                 ev->maxfd = EVENT_INVALID_MAXFD;
 191         }
 192         DLIST_REMOVE(ev->fd_events, fde);
 193         ev->destruction_count++;
 194 #if WITH_EPOLL
 195         if (ev->epoll_fd != -1) {
 196                 struct epoll_event event;
 197                 ZERO_STRUCT(event);
 198                 event.events = epoll_map_flags(fde->flags);
 199                 event.data.ptr = fde;
 200                 epoll_ctl(ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
 201         }
 202 #endif
 203         return 0;
 204 }
 205
 206 /*
 207   add a fd based event
 208   return NULL on failure (memory allocation error)
 209 */
 210 struct fd_event *event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
 211                               int fd, uint16_t flags, event_fd_handler_t handler,
 212                               void *private)
 213 {
 214         struct fd_event *e = talloc(ev, struct fd_event);
 215         if (!e) return NULL;
 216
 217         e->event_ctx = ev;
 218         e->fd        = fd;
 219         e->flags     = flags;
 220         e->handler   = handler;
 221         e->private   = private;
 222
 223         DLIST_ADD(ev->fd_events, e);
 224
 225         if (e->fd > ev->maxfd) {
 226                 ev->maxfd = e->fd;
 227         }
 228
 229         talloc_set_destructor(e, event_fd_destructor);
 230         if (mem_ctx) {
 231                 talloc_steal(mem_ctx, e);
 232         }
 233
 234 #if WITH_EPOLL
 235         if (ev->epoll_fd != -1) {
 236                 struct epoll_event event;
 237                 ZERO_STRUCT(event);
 238                 event.events = epoll_map_flags(flags);
 239                 event.data.ptr = e;
 240                 if (epoll_ctl(ev->epoll_fd, EPOLL_CTL_ADD, e->fd, &event) != 0) {
 241                         epoll_fallback_to_select(ev, "EPOLL_CTL_ADD failed");
 242                 }
 243         }
 244 #endif
 245
 246         return e;
 247 }
 248
 249
 250 /*
 251   return the fd event flags
 252 */
 253 uint16_t event_fd_flags(struct fd_event *fde)
 254 {
 255         return fde?fde->flags:0;
 256 }
 257
 258 /*
 259   set the fd event flags
 260 */
 261 void event_fd_setflags(struct fd_event *fde, uint16_t flags)
 262 {
 263 #if WITH_EPOLL
 264         struct event_context *ev;
 265         if (fde == NULL ||
 266             fde->flags == flags) {
 267                 return;
 268         }
 269         ev = fde->event_ctx;
 270         if (ev->epoll_fd != -1) {
 271                 struct epoll_event event;
 272                 ZERO_STRUCT(event);
 273                 event.events = epoll_map_flags(flags);
 274                 event.data.ptr = fde;
 275                 if (epoll_ctl(ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
 276                         epoll_fallback_to_select(ev, "EPOLL_CTL_MOD failed");
 277                 }
 278         }
 279 #endif
 280         if (fde) {
 281                 fde->flags = flags;
 282         }
 283 }
 284
 285 /*
 286   destroy a timed event
 287 */
 288 static int event_timed_destructor(void *ptr)
 289 {
 290         struct timed_event *te = talloc_get_type(ptr, struct timed_event);
 291         DLIST_REMOVE(te->event_ctx->timed_events, te);
 292         return 0;
 293 }
 294
 295 /*
 296   add a timed event
 297   return NULL on failure (memory allocation error)
 298 */
 299 struct timed_event *event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ctx,
 300                                     struct timeval next_event,
 301                                     event_timed_handler_t handler,
 302                                     void *private)
 303 {
 304         struct timed_event *te, *e;
 305
 306         e = talloc(mem_ctx?mem_ctx:ev, struct timed_event);
 307         if (e == NULL) return NULL;
 308
 309         e->event_ctx  = ev;
 310         e->next_event = next_event;
 311         e->handler    = handler;
 312         e->private    = private;
 313
 314         /* keep the list ordered */
 315         if (ev->timed_events == NULL ||
 316             timeval_compare(&e->next_event, &ev->timed_events->next_event) > 0) {
 317                 DLIST_ADD(ev->timed_events, e);
 318         } else {
 319                 for (te=ev->timed_events;te && te->next;te=te->next) {
 320                         if (!timeval_is_zero(&te->next_event) &&
 321                             timeval_compare(&te->next_event, &e->next_event) < 0) {
 322                                 break;
 323                         }
 324                 }
 325                 DLIST_ADD_AFTER(ev->timed_events, e, te);
 326         }
 327
 328         talloc_set_destructor(e, event_timed_destructor);
 329
 330         return e;
 331 }
 332
 333 /*
 334   a timer has gone off - call it
 335 */
 336 static void event_loop_timer(struct event_context *ev)
 337 {
 338         struct timeval t = timeval_current();
 339         struct timed_event *te = ev->timed_events;
 340
 341         te->next_event = timeval_zero();
 342
 343         te->handler(ev, te, t, te->private);
 344
 345         /* note the care taken to prevent referencing a event
 346            that could have been freed by the handler */
 347         if (ev->timed_events && timeval_is_zero(&ev->timed_events->next_event)) {
 348                 talloc_free(ev->timed_events);
 349         }
 350 }
 351
 352 #if WITH_EPOLL
 353 /*
 354   event loop handling using epoll
 355 */
 356 static int event_loop_epoll(struct event_context *ev, struct timeval *tvalp)
 357 {
 358         int ret, i;
 359         const int maxevents = 8;
 360         struct epoll_event events[maxevents];
 361         uint32_t destruction_count = ev->destruction_count;
 362         int timeout = -1;
 363
 364         if (tvalp) {
 365                 timeout = (tvalp->tv_usec / 1000) + (tvalp->tv_sec*1000);
 366         }
 367
 368         ret = epoll_wait(ev->epoll_fd, events, maxevents, timeout);
 369
 370         if (ret == -1 && errno != EINTR) {
 371                 epoll_fallback_to_select(ev, "epoll_wait() failed");
 372                 return -1;
 373         }
 374
 375         if (ret == 0 && tvalp) {
 376                 event_loop_timer(ev);
 377                 return 0;
 378         }
 379
 380         for (i=0;i<ret;i++) {
 381                 struct fd_event *fde = talloc_get_type(events[i].data.ptr,
 382                                                        struct fd_event);
 383                 uint16_t flags = 0;
 384
 385                 if (fde == NULL) {
 386                         epoll_fallback_to_select(ev, "epoll_wait() gave bad data");
 387                         return -1;
 388                 }
 389                 if (events[i].events & EPOLLIN) flags |= EVENT_FD_READ;
 390                 if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
 391                 if (flags) {
 392                         fde->handler(ev, fde, flags, fde->private);
 393                         if (destruction_count != ev->destruction_count) {
 394                                 break;
 395                         }
 396                 }
 397         }
 398
 399         return 0;
 400 }
 401 #endif
 402
 403 /*
 404   event loop handling using select()
 405 */
 406 static int event_loop_select(struct event_context *ev, struct timeval *tvalp)
 407 {
 408         fd_set r_fds, w_fds;
 409         int selrtn;
 410         uint32_t destruction_count = ev->destruction_count;
 411         struct fd_event *fe;
 412
 413         /* we maybe need to recalculate the maxfd */
 414         if (ev->maxfd == EVENT_INVALID_MAXFD) {
 415                 calc_maxfd(ev);
 416         }
 417
 418         FD_ZERO(&r_fds);
 419         FD_ZERO(&w_fds);
 420
 421         /* setup any fd events */
 422         for (fe=ev->fd_events; fe; ) {
 423                 struct fd_event *next = fe->next;
 424                 if (fe->flags & EVENT_FD_READ) {
 425                         FD_SET(fe->fd, &r_fds);
 426                 }
 427                 if (fe->flags & EVENT_FD_WRITE) {
 428                         FD_SET(fe->fd, &w_fds);
 429                 }
 430                 fe = next;
 431         }
 432
 433         selrtn = select(ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
 434
 435         if (selrtn == -1 && errno == EBADF) {
 436                 /* the socket is dead! this should never
 437                    happen as the socket should have first been
 438                    made readable and that should have removed
 439                    the event, so this must be a bug. This is a
 440                    fatal error. */
 441                 DEBUG(0,("ERROR: EBADF on event_loop_once\n"));
 442                 ev->exit_code = EBADF;
 443                 return -1;
 444         }
 445
 446         if (selrtn == 0 && tvalp) {
 447                 event_loop_timer(ev);
 448                 return 0;
 449         }
 450
 451         if (selrtn > 0) {
 452                 /* at least one file descriptor is ready - check
 453                    which ones and call the handler, being careful to allow
 454                    the handler to remove itself when called */
 455                 for (fe=ev->fd_events; fe; fe=fe->next) {
 456                         uint16_t flags = 0;
 457                         if (FD_ISSET(fe->fd, &r_fds)) flags |= EVENT_FD_READ;
 458                         if (FD_ISSET(fe->fd, &w_fds)) flags |= EVENT_FD_WRITE;
 459                         if (flags) {
 460                                 fe->handler(ev, fe, flags, fe->private);
 461                                 if (destruction_count != ev->destruction_count) {
 462                                         break;
 463                                 }
 464                         }
 465                 }
 466         }
 467
 468         return 0;
 469 }
 470
 471 /*
 472   do a single event loop using the events defined in ev
 473 */
 474 int event_loop_once(struct event_context *ev)
 475 {
 476         struct timeval tval, *tvalp;
 477
 478         tvalp = NULL;
 479
 480         /* work out the right timeout for all timed events */
 481         if (ev->timed_events) {
 482                 struct timeval t = timeval_current();
 483                 tval = timeval_diff(&ev->timed_events->next_event, &t);
 484                 tvalp = &tval;
 485                 if (timeval_is_zero(tvalp)) {
 486                         event_loop_timer(ev);
 487                         return 0;
 488                 }
 489         }
 490
 491 #if WITH_EPOLL
 492         if (ev->epoll_fd != -1) {
 493                 if (event_loop_epoll(ev, tvalp) == 0) {
 494                         return 0;
 495                 }
 496         }
 497 #endif
 498
 499         return event_loop_select(ev, tvalp);
 500 }
 501
 502 /*
 503   go into an event loop using the events defined in ev this function
 504   will return with the specified code if one of the handlers calls
 505   event_loop_exit()
 506
 507   also return (with code 0) if all fd events are removed
 508 */
 509 int event_loop_wait(struct event_context *ev)
 510 {
 511         ev->exit_code = 0;
 512         ev->maxfd = EVENT_INVALID_MAXFD;
 513
 514         while (ev->fd_events && ev->exit_code == 0) {
 515                 if (event_loop_once(ev) != 0) {
 516                         break;
 517                 }
 518         }
 519
 520         return ev->exit_code;
 521 }