source4/lib/events/events_standard.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    main select loop and event handling
   4    Copyright (C) Andrew Tridgell        2003-2005
   5    Copyright (C) Stefan Metzmacher      2005
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 /*
  23   This is SAMBA's default event loop code
  24
  25   - we try to use epoll if configure detected support for it
  26     otherwise we use select()
  27   - if epoll is broken on the system or the kernel doesn't support it
  28     at runtime we fallback to select()
  29 */
  30
  31 #include "includes.h"
  32 #include "system/filesys.h"
  33 #include "system/select.h" /* needed for WITH_EPOLL */
  34 #include "dlinklist.h"
  35 #include "lib/events/events.h"
  36 #include "lib/events/events_internal.h"
  37
  38 struct std_event_context {
  39         /* a pointer back to the generic event_context */
  40         struct event_context *ev;
  41
  42         /* list of filedescriptor events */
  43         struct fd_event *fd_events;
  44
  45         /* list of timed events */
  46         struct timed_event *timed_events;
  47
  48         /* the maximum file descriptor number in fd_events */
  49         int maxfd;
  50
  51         /* information for exiting from the event loop */
  52         int exit_code;
  53
  54         /* this is changed by the destructors for the fd event
  55            type. It is used to detect event destruction by event
  56            handlers, which means the code that is calling the event
  57            handler needs to assume that the linked list is no longer
  58            valid
  59         */
  60         uint32_t destruction_count;
  61
  62         /* when using epoll this is the handle from epoll_create */
  63         int epoll_fd;
  64 };
  65
  66 static void std_event_loop_timer(struct std_event_context *std_ev);
  67
  68 /* use epoll if it is available */
  69 #if WITH_EPOLL
  70 /*
  71   called when a epoll call fails, and we should fallback
  72   to using select
  73 */
  74 static void epoll_fallback_to_select(struct std_event_context *std_ev, const char *reason)
  75 {
  76         DEBUG(0,("%s (%s) - falling back to select()\n", reason, strerror(errno)));
  77         close(std_ev->epoll_fd);
  78         std_ev->epoll_fd = -1;
  79         talloc_set_destructor(std_ev, NULL);
  80 }
  81
  82 /*
  83   map from EVENT_FD_* to EPOLLIN/EPOLLOUT
  84 */
  85 static uint32_t epoll_map_flags(uint16_t flags)
  86 {
  87         uint32_t ret = 0;
  88         if (flags & EVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
  89         if (flags & EVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
  90         return ret;
  91 }
  92
  93 /*
  94  free the epoll fd
  95 */
  96 static int epoll_ctx_destructor(void *ptr)
  97 {
  98         struct std_event_context *std_ev = talloc_get_type(ptr,
  99                                                            struct std_event_context);
 100         close(std_ev->epoll_fd);
 101         std_ev->epoll_fd = -1;
 102         return 0;
 103 }
 104
 105 /*
 106  init the epoll fd
 107 */
 108 static void epoll_init_ctx(struct std_event_context *std_ev, BOOL try_epoll)
 109 {
 110         if (!try_epoll) return;
 111         std_ev->epoll_fd = epoll_create(64);
 112         talloc_set_destructor(std_ev, epoll_ctx_destructor);
 113 }
 114
 115 #define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT      (1<<0)
 116 #define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR   (1<<1)
 117 #define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR      (1<<2)
 118
 119 /*
 120  add the epoll event to the given fd_event
 121 */
 122 static void epoll_add_event(struct std_event_context *std_ev, struct fd_event *fde)
 123 {
 124         struct epoll_event event;
 125         if (std_ev->epoll_fd == -1) return;
 126
 127         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 128
 129         /* if we don't want events yet, don't add an epoll_event */
 130         if (fde->flags == 0) return;
 131
 132         ZERO_STRUCT(event);
 133         event.events = epoll_map_flags(fde->flags);
 134         event.data.ptr = fde;
 135         if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
 136                 epoll_fallback_to_select(std_ev, "EPOLL_CTL_ADD failed");
 137         }
 138         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
 139
 140         /* only if we want to read we want to tell the event handler about errors */
 141         if (fde->flags & EVENT_FD_READ) {
 142                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 143         }
 144 }
 145
 146 /*
 147  delete the epoll event for given fd_event
 148 */
 149 static void epoll_del_event(struct std_event_context *std_ev, struct fd_event *fde)
 150 {
 151         struct epoll_event event;
 152         if (std_ev->epoll_fd == -1) return;
 153
 154         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 155
 156         /* if there's no epoll_event, we don't need to delete it */
 157         if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) return;
 158
 159         ZERO_STRUCT(event);
 160         event.events = epoll_map_flags(fde->flags);
 161         event.data.ptr = fde;
 162         epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
 163         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
 164 }
 165
 166 /*
 167  change the epoll event to the given fd_event
 168 */
 169 static void epoll_mod_event(struct std_event_context *std_ev, struct fd_event *fde)
 170 {
 171         struct epoll_event event;
 172         if (std_ev->epoll_fd == -1) return;
 173
 174         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 175
 176         ZERO_STRUCT(event);
 177         event.events = epoll_map_flags(fde->flags);
 178         event.data.ptr = fde;
 179         if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
 180                 epoll_fallback_to_select(std_ev, "EPOLL_CTL_MOD failed");
 181         }
 182
 183         /* only if we want to read we want to tell the event handler about errors */
 184         if (fde->flags & EVENT_FD_READ) {
 185                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 186         }
 187 }
 188
 189 static void epoll_change_event(struct std_event_context *std_ev, struct fd_event *fde)
 190 {
 191         BOOL got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
 192         BOOL want_read = (fde->flags & EVENT_FD_READ);
 193         BOOL want_write= (fde->flags & EVENT_FD_WRITE);
 194
 195         if (std_ev->epoll_fd == -1) return;
 196
 197         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 198
 199         /* there's already an event */
 200         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
 201                 if (want_read || (want_write && !got_error)) {
 202                         epoll_mod_event(std_ev, fde);
 203                         return;
 204                 }
 205                 /*
 206                  * if we want to match the select behavior, we need to remove the epoll_event
 207                  * when the caller isn't interested in events.
 208                  *
 209                  * this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
 210                  */
 211                 epoll_del_event(std_ev, fde);
 212                 return;
 213         }
 214
 215         /* there's no epoll_event attached to the fde */
 216         if (want_read || (want_write && !got_error)) {
 217                 epoll_add_event(std_ev, fde);
 218                 return;
 219         }
 220 }
 221
 222 /*
 223   event loop handling using epoll
 224 */
 225 static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tvalp)
 226 {
 227         int ret, i;
 228 #define MAXEVENTS 8
 229         struct epoll_event events[MAXEVENTS];
 230         uint32_t destruction_count = std_ev->destruction_count;
 231         int timeout = -1;
 232
 233         if (std_ev->epoll_fd == -1) return -1;
 234
 235         if (tvalp) {
 236                 /* it's better to trigger timed events a bit later than to early */
 237                 timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
 238         }
 239
 240         ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
 241
 242         if (ret == -1 && errno != EINTR) {
 243                 epoll_fallback_to_select(std_ev, "epoll_wait() failed");
 244                 return -1;
 245         }
 246
 247         if (ret == 0 && tvalp) {
 248                 std_event_loop_timer(std_ev);
 249                 return 0;
 250         }
 251
 252         for (i=0;i<ret;i++) {
 253                 struct fd_event *fde = talloc_get_type(events[i].data.ptr,
 254                                                        struct fd_event);
 255                 uint16_t flags = 0;
 256
 257                 if (fde == NULL) {
 258                         epoll_fallback_to_select(std_ev, "epoll_wait() gave bad data");
 259                         return -1;
 260                 }
 261                 if (events[i].events & (EPOLLHUP|EPOLLERR)) {
 262                         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
 263                         /*
 264                          * if we only wait for EVENT_FD_WRITE, we should not tell the
 265                          * event handler about it, and remove the epoll_event,
 266                          * as we only report errors when waiting for read events,
 267                          * to match the select() behavior
 268                          */
 269                         if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
 270                                 epoll_del_event(std_ev, fde);
 271                                 continue;
 272                         }
 273                         flags |= EVENT_FD_READ;
 274                 }
 275                 if (events[i].events & EPOLLIN) flags |= EVENT_FD_READ;
 276                 if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
 277                 if (flags) {
 278                         fde->handler(std_ev->ev, fde, flags, fde->private_data);
 279                         if (destruction_count != std_ev->destruction_count) {
 280                                 break;
 281                         }
 282                 }
 283         }
 284
 285         return 0;
 286 }
 287 #else
 288 #define epoll_init_ctx(std_ev,try_epoll) if (try_epoll) {/* fix unused variable warning*/}
 289 #define epoll_add_event(std_ev,fde)
 290 #define epoll_del_event(std_ev,fde)
 291 #define epoll_change_event(std_ev,fde)
 292 #define epoll_event_loop(std_ev,tvalp) (-1)
 293 #endif
 294
 295 /*
 296   create a std_event_context structure.
 297 */
 298 static int std_event_context_init(struct event_context *ev, void *private_data)
 299 {
 300         struct std_event_context *std_ev;
 301         BOOL *_try_epoll = private_data;
 302         BOOL try_epoll = (_try_epoll == NULL ? True : *_try_epoll);
 303
 304         std_ev = talloc_zero(ev, struct std_event_context);
 305         if (!std_ev) return -1;
 306         std_ev->ev = ev;
 307         std_ev->epoll_fd = -1;
 308
 309         epoll_init_ctx(std_ev, try_epoll);
 310
 311         ev->additional_data = std_ev;
 312         return 0;
 313 }
 314
 315 /*
 316   recalculate the maxfd
 317 */
 318 static void calc_maxfd(struct std_event_context *std_ev)
 319 {
 320         struct fd_event *fde;
 321
 322         std_ev->maxfd = 0;
 323         for (fde = std_ev->fd_events; fde; fde = fde->next) {
 324                 if (fde->fd > std_ev->maxfd) {
 325                         std_ev->maxfd = fde->fd;
 326                 }
 327         }
 328 }
 329
 330
 331 /* to mark the ev->maxfd invalid
 332  * this means we need to recalculate it
 333  */
 334 #define EVENT_INVALID_MAXFD (-1)
 335
 336 /*
 337   destroy an fd_event
 338 */
 339 static int std_event_fd_destructor(void *ptr)
 340 {
 341         struct fd_event *fde = talloc_get_type(ptr, struct fd_event);
 342         struct event_context *ev = fde->event_ctx;
 343         struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
 344                                                            struct std_event_context);
 345
 346         if (std_ev->maxfd == fde->fd) {
 347                 std_ev->maxfd = EVENT_INVALID_MAXFD;
 348         }
 349
 350         DLIST_REMOVE(std_ev->fd_events, fde);
 351         std_ev->destruction_count++;
 352
 353         epoll_del_event(std_ev, fde);
 354
 355         return 0;
 356 }
 357
 358 /*
 359   add a fd based event
 360   return NULL on failure (memory allocation error)
 361 */
 362 static struct fd_event *std_event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
 363                                          int fd, uint16_t flags,
 364                                          event_fd_handler_t handler,
 365                                          void *private_data)
 366 {
 367         struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
 368                                                            struct std_event_context);
 369         struct fd_event *fde;
 370
 371         fde = talloc(mem_ctx?mem_ctx:ev, struct fd_event);
 372         if (!fde) return NULL;
 373
 374         fde->event_ctx          = ev;
 375         fde->fd                 = fd;
 376         fde->flags              = flags;
 377         fde->handler            = handler;
 378         fde->private_data       = private_data;
 379         fde->additional_flags   = 0;
 380         fde->additional_data    = NULL;
 381
 382         DLIST_ADD(std_ev->fd_events, fde);
 383         if (fde->fd > std_ev->maxfd) {
 384                 std_ev->maxfd = fde->fd;
 385         }
 386         talloc_set_destructor(fde, std_event_fd_destructor);
 387
 388         epoll_add_event(std_ev, fde);
 389
 390         return fde;
 391 }
 392
 393
 394 /*
 395   return the fd event flags
 396 */
 397 static uint16_t std_event_get_fd_flags(struct fd_event *fde)
 398 {
 399         return fde->flags;
 400 }
 401
 402 /*
 403   set the fd event flags
 404 */
 405 static void std_event_set_fd_flags(struct fd_event *fde, uint16_t flags)
 406 {
 407         struct event_context *ev;
 408         struct std_event_context *std_ev;
 409
 410         if (fde->flags == flags) return;
 411
 412         ev = fde->event_ctx;
 413         std_ev = talloc_get_type(ev->additional_data, struct std_event_context);
 414
 415         fde->flags = flags;
 416
 417         epoll_change_event(std_ev, fde);
 418 }
 419
 420 /*
 421   destroy a timed event
 422 */
 423 static int std_event_timed_destructor(void *ptr)
 424 {
 425         struct timed_event *te = talloc_get_type(ptr, struct timed_event);
 426         struct std_event_context *std_ev = talloc_get_type(te->event_ctx->additional_data,
 427                                                            struct std_event_context);
 428         DLIST_REMOVE(std_ev->timed_events, te);
 429         return 0;
 430 }
 431
 432 static int std_event_timed_deny_destructor(void *ptr)
 433 {
 434         return -1;
 435 }
 436
 437 /*
 438   add a timed event
 439   return NULL on failure (memory allocation error)
 440 */
 441 static struct timed_event *std_event_add_timed(struct event_context *ev, TALLOC_CTX *mem_ctx,
 442                                                struct timeval next_event,
 443                                                event_timed_handler_t handler,
 444                                                void *private_data)
 445 {
 446         struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
 447                                                            struct std_event_context);
 448         struct timed_event *te, *last_te, *cur_te;
 449
 450         te = talloc(mem_ctx?mem_ctx:ev, struct timed_event);
 451         if (te == NULL) return NULL;
 452
 453         te->event_ctx           = ev;
 454         te->next_event          = next_event;
 455         te->handler             = handler;
 456         te->private_data        = private_data;
 457         te->additional_data     = NULL;
 458
 459         /* keep the list ordered */
 460         last_te = NULL;
 461         for (cur_te = std_ev->timed_events; cur_te; cur_te = cur_te->next) {
 462                 /* if the new event comes before the current one break */
 463                 if (!timeval_is_zero(&cur_te->next_event) &&
 464                     timeval_compare(&te->next_event,
 465                                     &cur_te->next_event) < 0) {
 466                         break;
 467                 }
 468
 469                 last_te = cur_te;
 470         }
 471
 472         DLIST_ADD_AFTER(std_ev->timed_events, te, last_te);
 473
 474         talloc_set_destructor(te, std_event_timed_destructor);
 475
 476         return te;
 477 }
 478
 479 /*
 480   a timer has gone off - call it
 481 */
 482 static void std_event_loop_timer(struct std_event_context *std_ev)
 483 {
 484         struct timeval t = timeval_current();
 485         struct timed_event *te = std_ev->timed_events;
 486
 487         if (te == NULL) {
 488                 return;
 489         }
 490
 491         /* deny the handler to free the event */
 492         talloc_set_destructor(te, std_event_timed_deny_destructor);
 493
 494         /* We need to remove the timer from the list before calling the
 495          * handler because in a semi-async inner event loop called from the
 496          * handler we don't want to come across this event again -- vl */
 497         DLIST_REMOVE(std_ev->timed_events, te);
 498
 499         te->handler(std_ev->ev, te, t, te->private_data);
 500
 501         /* The destructor isn't necessary anymore, we've already removed the
 502          * event from the list. */
 503         talloc_set_destructor(te, NULL);
 504
 505         talloc_free(te);
 506 }
 507
 508 /*
 509   event loop handling using select()
 510 */
 511 static int std_event_loop_select(struct std_event_context *std_ev, struct timeval *tvalp)
 512 {
 513         fd_set r_fds, w_fds;
 514         struct fd_event *fde;
 515         int selrtn;
 516         uint32_t destruction_count = std_ev->destruction_count;
 517
 518         /* we maybe need to recalculate the maxfd */
 519         if (std_ev->maxfd == EVENT_INVALID_MAXFD) {
 520                 calc_maxfd(std_ev);
 521         }
 522
 523         FD_ZERO(&r_fds);
 524         FD_ZERO(&w_fds);
 525
 526         /* setup any fd events */
 527         for (fde = std_ev->fd_events; fde; fde = fde->next) {
 528                 if (fde->flags & EVENT_FD_READ) {
 529                         FD_SET(fde->fd, &r_fds);
 530                 }
 531                 if (fde->flags & EVENT_FD_WRITE) {
 532                         FD_SET(fde->fd, &w_fds);
 533                 }
 534         }
 535
 536         selrtn = select(std_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
 537
 538         if (selrtn == -1 && errno == EBADF) {
 539                 /* the socket is dead! this should never
 540                    happen as the socket should have first been
 541                    made readable and that should have removed
 542                    the event, so this must be a bug. This is a
 543                    fatal error. */
 544                 DEBUG(0,("ERROR: EBADF on std_event_loop_once\n"));
 545                 std_ev->exit_code = EBADF;
 546                 return -1;
 547         }
 548
 549         if (selrtn == 0 && tvalp) {
 550                 std_event_loop_timer(std_ev);
 551                 return 0;
 552         }
 553
 554         if (selrtn > 0) {
 555                 /* at least one file descriptor is ready - check
 556                    which ones and call the handler, being careful to allow
 557                    the handler to remove itself when called */
 558                 for (fde = std_ev->fd_events; fde; fde = fde->next) {
 559                         uint16_t flags = 0;
 560
 561                         if (FD_ISSET(fde->fd, &r_fds)) flags |= EVENT_FD_READ;
 562                         if (FD_ISSET(fde->fd, &w_fds)) flags |= EVENT_FD_WRITE;
 563                         if (flags) {
 564                                 fde->handler(std_ev->ev, fde, flags, fde->private_data);
 565                                 if (destruction_count != std_ev->destruction_count) {
 566                                         break;
 567                                 }
 568                         }
 569                 }
 570         }
 571
 572         return 0;
 573 }
 574
 575 /*
 576   do a single event loop using the events defined in ev
 577 */
 578 static int std_event_loop_once(struct event_context *ev)
 579 {
 580         struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
 581                                                            struct std_event_context);
 582         struct timeval tval;
 583
 584         /* work out the right timeout for all timed events */
 585         if (std_ev->timed_events) {
 586                 struct timeval t = timeval_current();
 587                 tval = timeval_until(&t, &std_ev->timed_events->next_event);
 588                 if (timeval_is_zero(&tval)) {
 589                         std_event_loop_timer(std_ev);
 590                         return 0;
 591                 }
 592         } else {
 593                 /* have a default tick time of 30 seconds. This guarantees
 594                    that code that uses its own timeout checking will be
 595                    able to proceeed eventually */
 596                 tval = timeval_set(30, 0);
 597         }
 598
 599         if (epoll_event_loop(std_ev, &tval) == 0) {
 600                 return 0;
 601         }
 602
 603         return std_event_loop_select(std_ev, &tval);
 604 }
 605
 606 /*
 607   return on failure or (with 0) if all fd events are removed
 608 */
 609 static int std_event_loop_wait(struct event_context *ev)
 610 {
 611         struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
 612                                                            struct std_event_context);
 613         std_ev->exit_code = 0;
 614
 615         while (std_ev->fd_events && std_ev->exit_code == 0) {
 616                 if (std_event_loop_once(ev) != 0) {
 617                         break;
 618                 }
 619         }
 620
 621         return std_ev->exit_code;
 622 }
 623
 624 static const struct event_ops std_event_ops = {
 625         .context_init   = std_event_context_init,
 626         .add_fd         = std_event_add_fd,
 627         .get_fd_flags   = std_event_get_fd_flags,
 628         .set_fd_flags   = std_event_set_fd_flags,
 629         .add_timed      = std_event_add_timed,
 630         .loop_once      = std_event_loop_once,
 631         .loop_wait      = std_event_loop_wait,
 632 };
 633
 634 const struct event_ops *event_standard_get_ops(void)
 635 {
 636         return &std_event_ops;
 637 }