1 /* 2 * Copyright (c) 2000-2004 Niels Provos <provos (at) citi.umich.edu> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 #ifdef HAVE_CONFIG_H 28 #include "config.h" 29 #endif 30 31 #ifdef WIN32 32 #define WIN32_LEAN_AND_MEAN 33 #include <windows.h> 34 #undef WIN32_LEAN_AND_MEAN 35 #endif 36 #include <sys/types.h> 37 #ifdef HAVE_SYS_TIME_H 38 #include <sys/time.h> 39 #else 40 #include <sys/_libevent_time.h> 41 #endif 42 #include <sys/queue.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #ifndef WIN32 46 #include <unistd.h> 47 #endif 48 #include <errno.h> 49 #include <signal.h> 50 #include <string.h> 51 #include <assert.h> 52 #include <time.h> 53 54 #include "event.h" 55 #include "event-internal.h" 56 #include "evutil.h" 57 #include "log.h" 58 59 #ifdef HAVE_EVENT_PORTS 60 extern const struct eventop evportops; 61 #endif 62 #ifdef HAVE_SELECT 63 extern const struct eventop selectops; 64 #endif 65 #ifdef HAVE_POLL 66 extern const struct eventop pollops; 67 #endif 68 #ifdef HAVE_EPOLL 69 extern const struct eventop epollops; 70 #endif 71 #ifdef HAVE_WORKING_KQUEUE 72 extern const struct eventop kqops; 73 #endif 74 #ifdef HAVE_DEVPOLL 75 extern const struct eventop devpollops; 76 #endif 77 #ifdef WIN32 78 extern const struct eventop win32ops; 79 #endif 80 81 /* In order of preference */ 82 static const struct eventop *eventops[] = { 83 #ifdef HAVE_EVENT_PORTS 84 &evportops, 85 #endif 86 #ifdef HAVE_WORKING_KQUEUE 87 &kqops, 88 #endif 89 #ifdef HAVE_EPOLL 90 &epollops, 91 #endif 92 #ifdef HAVE_DEVPOLL 93 &devpollops, 94 #endif 95 #ifdef HAVE_POLL 96 &pollops, 97 #endif 98 #ifdef HAVE_SELECT 99 &selectops, 100 #endif 101 #ifdef WIN32 102 &win32ops, 103 #endif 104 NULL 105 }; 106 107 /* Global state */ 108 struct event_base *current_base = NULL; 109 extern struct event_base *evsignal_base; 110 static int use_monotonic = 1; 111 112 /* Prototypes */ 113 static void event_queue_insert(struct event_base *, struct event *, int); 114 static void event_queue_remove(struct event_base *, struct event *, int); 115 static int event_haveevents(struct event_base *); 116 117 static void event_process_active(struct event_base *); 118 119 static int timeout_next(struct event_base *, struct timeval **); 120 static void timeout_process(struct event_base *); 121 static void timeout_correct(struct event_base *, struct timeval *); 122 123 static int 124 gettime(struct event_base *base, struct timeval *tp) 125 { 126 if (base->tv_cache.tv_sec) { 127 *tp = base->tv_cache; 128 return (0); 129 } 130 131 #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) 132 struct timespec ts; 133 134 if (use_monotonic && 135 clock_gettime(CLOCK_MONOTONIC, &ts) == 0) { 136 tp->tv_sec = ts.tv_sec; 137 tp->tv_usec = ts.tv_nsec / 1000; 138 return (0); 139 } 140 #endif 141 142 use_monotonic = 0; 143 144 return (evutil_gettimeofday(tp, NULL)); 145 } 146 147 struct event_base * 148 event_init(void) 149 { 150 struct event_base *base = event_base_new(); 151 152 if (base != NULL) 153 current_base = base; 154 155 return (base); 156 } 157 158 struct event_base * 159 event_base_new(void) 160 { 161 int i; 162 struct event_base *base; 163 164 if ((base = calloc(1, sizeof(struct event_base))) == NULL) 165 event_err(1, "%s: calloc", __func__); 166 167 gettime(base, &base->event_tv); 168 169 min_heap_ctor(&base->timeheap); 170 TAILQ_INIT(&base->eventqueue); 171 base->sig.ev_signal_pair[0] = -1; 172 base->sig.ev_signal_pair[1] = -1; 173 174 base->evbase = NULL; 175 for (i = 0; eventops[i] && !base->evbase; i++) { 176 base->evsel = eventops[i]; 177 178 base->evbase = base->evsel->init(base); 179 } 180 181 if (base->evbase == NULL) 182 event_errx(1, "%s: no event mechanism available", __func__); 183 184 if (evutil_getenv("EVENT_SHOW_METHOD")) 185 event_msgx("libevent using: %s\n", 186 base->evsel->name); 187 188 /* allocate a single active event queue */ 189 event_base_priority_init(base, 1); 190 191 return (base); 192 } 193 194 void 195 event_base_free(struct event_base *base) 196 { 197 int i, n_deleted=0; 198 struct event *ev; 199 200 if (base == NULL && current_base) 201 base = current_base; 202 if (base == current_base) 203 current_base = NULL; 204 205 /* XXX(niels) - check for internal events first */ 206 assert(base); 207 /* Delete all non-internal events. */ 208 for (ev = TAILQ_FIRST(&base->eventqueue); ev; ) { 209 struct event *next = TAILQ_NEXT(ev, ev_next); 210 if (!(ev->ev_flags & EVLIST_INTERNAL)) { 211 event_del(ev); 212 ++n_deleted; 213 } 214 ev = next; 215 } 216 while ((ev = min_heap_top(&base->timeheap)) != NULL) { 217 event_del(ev); 218 ++n_deleted; 219 } 220 221 for (i = 0; i < base->nactivequeues; ++i) { 222 for (ev = TAILQ_FIRST(base->activequeues[i]); ev; ) { 223 struct event *next = TAILQ_NEXT(ev, ev_active_next); 224 if (!(ev->ev_flags & EVLIST_INTERNAL)) { 225 event_del(ev); 226 ++n_deleted; 227 } 228 ev = next; 229 } 230 } 231 232 if (n_deleted) 233 event_debug(("%s: %d events were still set in base", 234 __func__, n_deleted)); 235 236 if (base->evsel->dealloc != NULL) 237 base->evsel->dealloc(base, base->evbase); 238 239 for (i = 0; i < base->nactivequeues; ++i) 240 assert(TAILQ_EMPTY(base->activequeues[i])); 241 242 assert(min_heap_empty(&base->timeheap)); 243 min_heap_dtor(&base->timeheap); 244 245 for (i = 0; i < base->nactivequeues; ++i) 246 free(base->activequeues[i]); 247 free(base->activequeues); 248 249 assert(TAILQ_EMPTY(&base->eventqueue)); 250 251 free(base); 252 } 253 254 /* reinitialized the event base after a fork */ 255 int 256 event_reinit(struct event_base *base) 257 { 258 const struct eventop *evsel = base->evsel; 259 void *evbase = base->evbase; 260 int res = 0; 261 struct event *ev; 262 263 /* check if this event mechanism requires reinit */ 264 if (!evsel->need_reinit) 265 return (0); 266 267 /* prevent internal delete */ 268 if (base->sig.ev_signal_added) { 269 /* we cannot call event_del here because the base has 270 * not been reinitialized yet. */ 271 event_queue_remove(base, &base->sig.ev_signal, 272 EVLIST_INSERTED); 273 if (base->sig.ev_signal.ev_flags & EVLIST_ACTIVE) 274 event_queue_remove(base, &base->sig.ev_signal, 275 EVLIST_ACTIVE); 276 base->sig.ev_signal_added = 0; 277 } 278 279 if (base->evsel->dealloc != NULL) 280 base->evsel->dealloc(base, base->evbase); 281 evbase = base->evbase = evsel->init(base); 282 if (base->evbase == NULL) 283 event_errx(1, "%s: could not reinitialize event mechanism", 284 __func__); 285 286 TAILQ_FOREACH(ev, &base->eventqueue, ev_next) { 287 if (evsel->add(evbase, ev) == -1) 288 res = -1; 289 } 290 291 return (res); 292 } 293 294 int 295 event_priority_init(int npriorities) 296 { 297 return event_base_priority_init(current_base, npriorities); 298 } 299 300 int 301 event_base_priority_init(struct event_base *base, int npriorities) 302 { 303 int i; 304 305 if (base->event_count_active) 306 return (-1); 307 308 if (base->nactivequeues && npriorities != base->nactivequeues) { 309 for (i = 0; i < base->nactivequeues; ++i) { 310 free(base->activequeues[i]); 311 } 312 free(base->activequeues); 313 } 314 315 /* Allocate our priority queues */ 316 base->nactivequeues = npriorities; 317 base->activequeues = (struct event_list **) 318 calloc(base->nactivequeues, sizeof(struct event_list *)); 319 if (base->activequeues == NULL) 320 event_err(1, "%s: calloc", __func__); 321 322 for (i = 0; i < base->nactivequeues; ++i) { 323 base->activequeues[i] = malloc(sizeof(struct event_list)); 324 if (base->activequeues[i] == NULL) 325 event_err(1, "%s: malloc", __func__); 326 TAILQ_INIT(base->activequeues[i]); 327 } 328 329 return (0); 330 } 331 332 int 333 event_haveevents(struct event_base *base) 334 { 335 return (base->event_count > 0); 336 } 337 338 /* 339 * Active events are stored in priority queues. Lower priorities are always 340 * process before higher priorities. Low priority events can starve high 341 * priority ones. 342 */ 343 344 static void 345 event_process_active(struct event_base *base) 346 { 347 struct event *ev; 348 struct event_list *activeq = NULL; 349 int i; 350 short ncalls; 351 352 for (i = 0; i < base->nactivequeues; ++i) { 353 if (TAILQ_FIRST(base->activequeues[i]) != NULL) { 354 activeq = base->activequeues[i]; 355 break; 356 } 357 } 358 359 assert(activeq != NULL); 360 361 for (ev = TAILQ_FIRST(activeq); ev; ev = TAILQ_FIRST(activeq)) { 362 if (ev->ev_events & EV_PERSIST) 363 event_queue_remove(base, ev, EVLIST_ACTIVE); 364 else 365 event_del(ev); 366 367 /* Allows deletes to work */ 368 ncalls = ev->ev_ncalls; 369 ev->ev_pncalls = &ncalls; 370 while (ncalls) { 371 ncalls--; 372 ev->ev_ncalls = ncalls; 373 (*ev->ev_callback)((int)ev->ev_fd, ev->ev_res, ev->ev_arg); 374 if (base->event_break) 375 return; 376 } 377 } 378 } 379 380 /* 381 * Wait continously for events. We exit only if no events are left. 382 */ 383 384 int 385 event_dispatch(void) 386 { 387 return (event_loop(0)); 388 } 389 390 int 391 event_base_dispatch(struct event_base *event_base) 392 { 393 return (event_base_loop(event_base, 0)); 394 } 395 396 const char * 397 event_base_get_method(struct event_base *base) 398 { 399 assert(base); 400 return (base->evsel->name); 401 } 402 403 static void 404 event_loopexit_cb(int fd, short what, void *arg) 405 { 406 struct event_base *base = arg; 407 base->event_gotterm = 1; 408 } 409 410 /* not thread safe */ 411 int 412 event_loopexit(const struct timeval *tv) 413 { 414 return (event_once(-1, EV_TIMEOUT, event_loopexit_cb, 415 current_base, tv)); 416 } 417 418 int 419 event_base_loopexit(struct event_base *event_base, const struct timeval *tv) 420 { 421 return (event_base_once(event_base, -1, EV_TIMEOUT, event_loopexit_cb, 422 event_base, tv)); 423 } 424 425 /* not thread safe */ 426 int 427 event_loopbreak(void) 428 { 429 return (event_base_loopbreak(current_base)); 430 } 431 432 int 433 event_base_loopbreak(struct event_base *event_base) 434 { 435 if (event_base == NULL) 436 return (-1); 437 438 event_base->event_break = 1; 439 return (0); 440 } 441 442 443 444 /* not thread safe */ 445 446 int 447 event_loop(int flags) 448 { 449 return event_base_loop(current_base, flags); 450 } 451 452 int 453 event_base_loop(struct event_base *base, int flags) 454 { 455 const struct eventop *evsel = base->evsel; 456 void *evbase = base->evbase; 457 struct timeval tv; 458 struct timeval *tv_p; 459 int res, done; 460 461 /* clear time cache */ 462 base->tv_cache.tv_sec = 0; 463 464 if (base->sig.ev_signal_added) 465 evsignal_base = base; 466 done = 0; 467 while (!done) { 468 /* Terminate the loop if we have been asked to */ 469 if (base->event_gotterm) { 470 base->event_gotterm = 0; 471 break; 472 } 473 474 if (base->event_break) { 475 base->event_break = 0; 476 break; 477 } 478 479 timeout_correct(base, &tv); 480 481 tv_p = &tv; 482 if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK)) { 483 timeout_next(base, &tv_p); 484 } else { 485 /* 486 * if we have active events, we just poll new events 487 * without waiting. 488 */ 489 evutil_timerclear(&tv); 490 } 491 492 /* If we have no events, we just exit */ 493 if (!event_haveevents(base)) { 494 event_debug(("%s: no events registered.", __func__)); 495 return (1); 496 } 497 498 /* update last old time */ 499 gettime(base, &base->event_tv); 500 501 /* clear time cache */ 502 base->tv_cache.tv_sec = 0; 503 504 res = evsel->dispatch(base, evbase, tv_p); 505 506 if (res == -1) 507 return (-1); 508 gettime(base, &base->tv_cache); 509 510 timeout_process(base); 511 512 if (base->event_count_active) { 513 event_process_active(base); 514 if (!base->event_count_active && (flags & EVLOOP_ONCE)) 515 done = 1; 516 } else if (flags & EVLOOP_NONBLOCK) 517 done = 1; 518 } 519 520 /* clear time cache */ 521 base->tv_cache.tv_sec = 0; 522 523 event_debug(("%s: asked to terminate loop.", __func__)); 524 return (0); 525 } 526 527 /* Sets up an event for processing once */ 528 529 struct event_once { 530 struct event ev; 531 532 void (*cb)(int, short, void *); 533 void *arg; 534 }; 535 536 /* One-time callback, it deletes itself */ 537 538 static void 539 event_once_cb(int fd, short events, void *arg) 540 { 541 struct event_once *eonce = arg; 542 543 (*eonce->cb)(fd, events, eonce->arg); 544 free(eonce); 545 } 546 547 /* not threadsafe, event scheduled once. */ 548 int 549 event_once(int fd, short events, 550 void (*callback)(int, short, void *), void *arg, const struct timeval *tv) 551 { 552 return event_base_once(current_base, fd, events, callback, arg, tv); 553 } 554 555 /* Schedules an event once */ 556 int 557 event_base_once(struct event_base *base, int fd, short events, 558 void (*callback)(int, short, void *), void *arg, const struct timeval *tv) 559 { 560 struct event_once *eonce; 561 struct timeval etv; 562 int res; 563 564 /* We cannot support signals that just fire once */ 565 if (events & EV_SIGNAL) 566 return (-1); 567 568 if ((eonce = calloc(1, sizeof(struct event_once))) == NULL) 569 return (-1); 570 571 eonce->cb = callback; 572 eonce->arg = arg; 573 574 if (events == EV_TIMEOUT) { 575 if (tv == NULL) { 576 evutil_timerclear(&etv); 577 tv = &etv; 578 } 579 580 evtimer_set(&eonce->ev, event_once_cb, eonce); 581 } else if (events & (EV_READ|EV_WRITE)) { 582 events &= EV_READ|EV_WRITE; 583 584 event_set(&eonce->ev, fd, events, event_once_cb, eonce); 585 } else { 586 /* Bad event combination */ 587 free(eonce); 588 return (-1); 589 } 590 591 res = event_base_set(base, &eonce->ev); 592 if (res == 0) 593 res = event_add(&eonce->ev, tv); 594 if (res != 0) { 595 free(eonce); 596 return (res); 597 } 598 599 return (0); 600 } 601 602 void 603 event_set(struct event *ev, int fd, short events, 604 void (*callback)(int, short, void *), void *arg) 605 { 606 /* Take the current base - caller needs to set the real base later */ 607 ev->ev_base = current_base; 608 609 ev->ev_callback = callback; 610 ev->ev_arg = arg; 611 ev->ev_fd = fd; 612 ev->ev_events = events; 613 ev->ev_res = 0; 614 ev->ev_flags = EVLIST_INIT; 615 ev->ev_ncalls = 0; 616 ev->ev_pncalls = NULL; 617 618 min_heap_elem_init(ev); 619 620 /* by default, we put new events into the middle priority */ 621 if(current_base) 622 ev->ev_pri = current_base->nactivequeues/2; 623 } 624 625 int 626 event_base_set(struct event_base *base, struct event *ev) 627 { 628 /* Only innocent events may be assigned to a different base */ 629 if (ev->ev_flags != EVLIST_INIT) 630 return (-1); 631 632 ev->ev_base = base; 633 ev->ev_pri = base->nactivequeues/2; 634 635 return (0); 636 } 637 638 /* 639 * Set's the priority of an event - if an event is already scheduled 640 * changing the priority is going to fail. 641 */ 642 643 int 644 event_priority_set(struct event *ev, int pri) 645 { 646 if (ev->ev_flags & EVLIST_ACTIVE) 647 return (-1); 648 if (pri < 0 || pri >= ev->ev_base->nactivequeues) 649 return (-1); 650 651 ev->ev_pri = pri; 652 653 return (0); 654 } 655 656 /* 657 * Checks if a specific event is pending or scheduled. 658 */ 659 660 int 661 event_pending(struct event *ev, short event, struct timeval *tv) 662 { 663 struct timeval now, res; 664 int flags = 0; 665 666 if (ev->ev_flags & EVLIST_INSERTED) 667 flags |= (ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)); 668 if (ev->ev_flags & EVLIST_ACTIVE) 669 flags |= ev->ev_res; 670 if (ev->ev_flags & EVLIST_TIMEOUT) 671 flags |= EV_TIMEOUT; 672 673 event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_SIGNAL); 674 675 /* See if there is a timeout that we should report */ 676 if (tv != NULL && (flags & event & EV_TIMEOUT)) { 677 gettime(ev->ev_base, &now); 678 evutil_timersub(&ev->ev_timeout, &now, &res); 679 /* correctly remap to real time */ 680 evutil_gettimeofday(&now, NULL); 681 evutil_timeradd(&now, &res, tv); 682 } 683 684 return (flags & event); 685 } 686 687 int 688 event_add(struct event *ev, const struct timeval *tv) 689 { 690 struct event_base *base = ev->ev_base; 691 const struct eventop *evsel = base->evsel; 692 void *evbase = base->evbase; 693 int res = 0; 694 695 event_debug(( 696 "event_add: event: %p, %s%s%scall %p", 697 ev, 698 ev->ev_events & EV_READ ? "EV_READ " : " ", 699 ev->ev_events & EV_WRITE ? "EV_WRITE " : " ", 700 tv ? "EV_TIMEOUT " : " ", 701 ev->ev_callback)); 702 703 assert(!(ev->ev_flags & ~EVLIST_ALL)); 704 705 /* 706 * prepare for timeout insertion further below, if we get a 707 * failure on any step, we should not change any state. 708 */ 709 if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) { 710 if (min_heap_reserve(&base->timeheap, 711 1 + min_heap_size(&base->timeheap)) == -1) 712 return (-1); /* ENOMEM == errno */ 713 } 714 715 if ((ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)) && 716 !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) { 717 res = evsel->add(evbase, ev); 718 if (res != -1) 719 event_queue_insert(base, ev, EVLIST_INSERTED); 720 } 721 722 /* 723 * we should change the timout state only if the previous event 724 * addition succeeded. 725 */ 726 if (res != -1 && tv != NULL) { 727 struct timeval now; 728 729 /* 730 * we already reserved memory above for the case where we 731 * are not replacing an exisiting timeout. 732 */ 733 if (ev->ev_flags & EVLIST_TIMEOUT) 734 event_queue_remove(base, ev, EVLIST_TIMEOUT); 735 736 /* Check if it is active due to a timeout. Rescheduling 737 * this timeout before the callback can be executed 738 * removes it from the active list. */ 739 if ((ev->ev_flags & EVLIST_ACTIVE) && 740 (ev->ev_res & EV_TIMEOUT)) { 741 /* See if we are just active executing this 742 * event in a loop 743 */ 744 if (ev->ev_ncalls && ev->ev_pncalls) { 745 /* Abort loop */ 746 *ev->ev_pncalls = 0; 747 } 748 749 event_queue_remove(base, ev, EVLIST_ACTIVE); 750 } 751 752 gettime(base, &now); 753 evutil_timeradd(&now, tv, &ev->ev_timeout); 754 755 event_debug(( 756 "event_add: timeout in %ld seconds, call %p", 757 tv->tv_sec, ev->ev_callback)); 758 759 event_queue_insert(base, ev, EVLIST_TIMEOUT); 760 } 761 762 return (res); 763 } 764 765 int 766 event_del(struct event *ev) 767 { 768 struct event_base *base; 769 770 event_debug(("event_del: %p, callback %p", 771 ev, ev->ev_callback)); 772 773 /* An event without a base has not been added */ 774 if (ev->ev_base == NULL) 775 return (-1); 776 777 base = ev->ev_base; 778 779 assert(!(ev->ev_flags & ~EVLIST_ALL)); 780 781 /* See if we are just active executing this event in a loop */ 782 if (ev->ev_ncalls && ev->ev_pncalls) { 783 /* Abort loop */ 784 *ev->ev_pncalls = 0; 785 } 786 787 if (ev->ev_flags & EVLIST_TIMEOUT) 788 event_queue_remove(base, ev, EVLIST_TIMEOUT); 789 790 if (ev->ev_flags & EVLIST_ACTIVE) 791 event_queue_remove(base, ev, EVLIST_ACTIVE); 792 793 if (ev->ev_flags & EVLIST_INSERTED) { 794 event_queue_remove(base, ev, EVLIST_INSERTED); 795 return (base->evsel->del(base->evbase, ev)); 796 } 797 798 return (0); 799 } 800 801 void 802 event_active(struct event *ev, int res, short ncalls) 803 { 804 /* We get different kinds of events, add them together */ 805 if (ev->ev_flags & EVLIST_ACTIVE) { 806 ev->ev_res |= res; 807 return; 808 } 809 810 ev->ev_res = res; 811 ev->ev_ncalls = ncalls; 812 ev->ev_pncalls = NULL; 813 event_queue_insert(ev->ev_base, ev, EVLIST_ACTIVE); 814 } 815 816 static int 817 timeout_next(struct event_base *base, struct timeval **tv_p) 818 { 819 struct timeval now; 820 struct event *ev; 821 struct timeval *tv = *tv_p; 822 823 if ((ev = min_heap_top(&base->timeheap)) == NULL) { 824 /* if no time-based events are active wait for I/O */ 825 *tv_p = NULL; 826 return (0); 827 } 828 829 if (gettime(base, &now) == -1) 830 return (-1); 831 832 if (evutil_timercmp(&ev->ev_timeout, &now, <=)) { 833 evutil_timerclear(tv); 834 return (0); 835 } 836 837 evutil_timersub(&ev->ev_timeout, &now, tv); 838 839 assert(tv->tv_sec >= 0); 840 assert(tv->tv_usec >= 0); 841 842 event_debug(("timeout_next: in %ld seconds", tv->tv_sec)); 843 return (0); 844 } 845 846 /* 847 * Determines if the time is running backwards by comparing the current 848 * time against the last time we checked. Not needed when using clock 849 * monotonic. 850 */ 851 852 static void 853 timeout_correct(struct event_base *base, struct timeval *tv) 854 { 855 struct event **pev; 856 unsigned int size; 857 struct timeval off; 858 859 if (use_monotonic) 860 return; 861 862 /* Check if time is running backwards */ 863 gettime(base, tv); 864 if (evutil_timercmp(tv, &base->event_tv, >=)) { 865 base->event_tv = *tv; 866 return; 867 } 868 869 event_debug(("%s: time is running backwards, corrected", 870 __func__)); 871 evutil_timersub(&base->event_tv, tv, &off); 872 873 /* 874 * We can modify the key element of the node without destroying 875 * the key, beause we apply it to all in the right order. 876 */ 877 pev = base->timeheap.p; 878 size = base->timeheap.n; 879 for (; size-- > 0; ++pev) { 880 struct timeval *ev_tv = &(**pev).ev_timeout; 881 evutil_timersub(ev_tv, &off, ev_tv); 882 } 883 /* Now remember what the new time turned out to be. */ 884 base->event_tv = *tv; 885 } 886 887 void 888 timeout_process(struct event_base *base) 889 { 890 struct timeval now; 891 struct event *ev; 892 893 if (min_heap_empty(&base->timeheap)) 894 return; 895 896 gettime(base, &now); 897 898 while ((ev = min_heap_top(&base->timeheap))) { 899 if (evutil_timercmp(&ev->ev_timeout, &now, >)) 900 break; 901 902 /* delete this event from the I/O queues */ 903 event_del(ev); 904 905 event_debug(("timeout_process: call %p", 906 ev->ev_callback)); 907 event_active(ev, EV_TIMEOUT, 1); 908 } 909 } 910 911 void 912 event_queue_remove(struct event_base *base, struct event *ev, int queue) 913 { 914 if (!(ev->ev_flags & queue)) 915 event_errx(1, "%s: %p(fd %d) not on queue %x", __func__, 916 ev, ev->ev_fd, queue); 917 918 if (~ev->ev_flags & EVLIST_INTERNAL) 919 base->event_count--; 920 921 ev->ev_flags &= ~queue; 922 switch (queue) { 923 case EVLIST_INSERTED: 924 TAILQ_REMOVE(&base->eventqueue, ev, ev_next); 925 break; 926 case EVLIST_ACTIVE: 927 base->event_count_active--; 928 TAILQ_REMOVE(base->activequeues[ev->ev_pri], 929 ev, ev_active_next); 930 break; 931 case EVLIST_TIMEOUT: 932 min_heap_erase(&base->timeheap, ev); 933 break; 934 default: 935 event_errx(1, "%s: unknown queue %x", __func__, queue); 936 } 937 } 938 939 void 940 event_queue_insert(struct event_base *base, struct event *ev, int queue) 941 { 942 if (ev->ev_flags & queue) { 943 /* Double insertion is possible for active events */ 944 if (queue & EVLIST_ACTIVE) 945 return; 946 947 event_errx(1, "%s: %p(fd %d) already on queue %x", __func__, 948 ev, ev->ev_fd, queue); 949 } 950 951 if (~ev->ev_flags & EVLIST_INTERNAL) 952 base->event_count++; 953 954 ev->ev_flags |= queue; 955 switch (queue) { 956 case EVLIST_INSERTED: 957 TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next); 958 break; 959 case EVLIST_ACTIVE: 960 base->event_count_active++; 961 TAILQ_INSERT_TAIL(base->activequeues[ev->ev_pri], 962 ev,ev_active_next); 963 break; 964 case EVLIST_TIMEOUT: { 965 min_heap_push(&base->timeheap, ev); 966 break; 967 } 968 default: 969 event_errx(1, "%s: unknown queue %x", __func__, queue); 970 } 971 } 972 973 /* Functions for debugging */ 974 975 const char * 976 event_get_version(void) 977 { 978 return (VERSION); 979 } 980 981 /* 982 * No thread-safe interface needed - the information should be the same 983 * for all threads. 984 */ 985 986 const char * 987 event_get_method(void) 988 { 989 return (current_base->evsel->name); 990 } 991
