Annotation of embedaddon/libevent/event.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 2000-2004 Niels Provos <provos@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;
! 111:
! 112: /* Handle signals - This is a deprecated interface */
! 113: int (*event_sigcb)(void); /* Signal callback when gotsig is set */
! 114: volatile sig_atomic_t event_gotsig; /* Set in signal handler */
! 115:
! 116: /* Prototypes */
! 117: static void event_queue_insert(struct event_base *, struct event *, int);
! 118: static void event_queue_remove(struct event_base *, struct event *, int);
! 119: static int event_haveevents(struct event_base *);
! 120:
! 121: static void event_process_active(struct event_base *);
! 122:
! 123: static int timeout_next(struct event_base *, struct timeval **);
! 124: static void timeout_process(struct event_base *);
! 125: static void timeout_correct(struct event_base *, struct timeval *);
! 126:
! 127: static void
! 128: detect_monotonic(void)
! 129: {
! 130: #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
! 131: struct timespec ts;
! 132:
! 133: if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
! 134: use_monotonic = 1;
! 135: #endif
! 136: }
! 137:
! 138: static int
! 139: gettime(struct event_base *base, struct timeval *tp)
! 140: {
! 141: if (base->tv_cache.tv_sec) {
! 142: *tp = base->tv_cache;
! 143: return (0);
! 144: }
! 145:
! 146: #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
! 147: if (use_monotonic) {
! 148: struct timespec ts;
! 149:
! 150: if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
! 151: return (-1);
! 152:
! 153: tp->tv_sec = ts.tv_sec;
! 154: tp->tv_usec = ts.tv_nsec / 1000;
! 155: return (0);
! 156: }
! 157: #endif
! 158:
! 159: return (evutil_gettimeofday(tp, NULL));
! 160: }
! 161:
! 162: struct event_base *
! 163: event_init(void)
! 164: {
! 165: struct event_base *base = event_base_new();
! 166:
! 167: if (base != NULL)
! 168: current_base = base;
! 169:
! 170: return (base);
! 171: }
! 172:
! 173: struct event_base *
! 174: event_base_new(void)
! 175: {
! 176: int i;
! 177: struct event_base *base;
! 178:
! 179: if ((base = calloc(1, sizeof(struct event_base))) == NULL)
! 180: event_err(1, "%s: calloc", __func__);
! 181:
! 182: event_sigcb = NULL;
! 183: event_gotsig = 0;
! 184:
! 185: detect_monotonic();
! 186: gettime(base, &base->event_tv);
! 187:
! 188: min_heap_ctor(&base->timeheap);
! 189: TAILQ_INIT(&base->eventqueue);
! 190: base->sig.ev_signal_pair[0] = -1;
! 191: base->sig.ev_signal_pair[1] = -1;
! 192:
! 193: base->evbase = NULL;
! 194: for (i = 0; eventops[i] && !base->evbase; i++) {
! 195: base->evsel = eventops[i];
! 196:
! 197: base->evbase = base->evsel->init(base);
! 198: }
! 199:
! 200: if (base->evbase == NULL)
! 201: event_errx(1, "%s: no event mechanism available", __func__);
! 202:
! 203: if (evutil_getenv("EVENT_SHOW_METHOD"))
! 204: event_msgx("libevent using: %s\n",
! 205: base->evsel->name);
! 206:
! 207: /* allocate a single active event queue */
! 208: event_base_priority_init(base, 1);
! 209:
! 210: return (base);
! 211: }
! 212:
! 213: void
! 214: event_base_free(struct event_base *base)
! 215: {
! 216: int i, n_deleted=0;
! 217: struct event *ev;
! 218:
! 219: if (base == NULL && current_base)
! 220: base = current_base;
! 221: if (base == current_base)
! 222: current_base = NULL;
! 223:
! 224: /* XXX(niels) - check for internal events first */
! 225: assert(base);
! 226: /* Delete all non-internal events. */
! 227: for (ev = TAILQ_FIRST(&base->eventqueue); ev; ) {
! 228: struct event *next = TAILQ_NEXT(ev, ev_next);
! 229: if (!(ev->ev_flags & EVLIST_INTERNAL)) {
! 230: event_del(ev);
! 231: ++n_deleted;
! 232: }
! 233: ev = next;
! 234: }
! 235: while ((ev = min_heap_top(&base->timeheap)) != NULL) {
! 236: event_del(ev);
! 237: ++n_deleted;
! 238: }
! 239:
! 240: for (i = 0; i < base->nactivequeues; ++i) {
! 241: for (ev = TAILQ_FIRST(base->activequeues[i]); ev; ) {
! 242: struct event *next = TAILQ_NEXT(ev, ev_active_next);
! 243: if (!(ev->ev_flags & EVLIST_INTERNAL)) {
! 244: event_del(ev);
! 245: ++n_deleted;
! 246: }
! 247: ev = next;
! 248: }
! 249: }
! 250:
! 251: if (n_deleted)
! 252: event_debug(("%s: %d events were still set in base",
! 253: __func__, n_deleted));
! 254:
! 255: if (base->evsel->dealloc != NULL)
! 256: base->evsel->dealloc(base, base->evbase);
! 257:
! 258: for (i = 0; i < base->nactivequeues; ++i)
! 259: assert(TAILQ_EMPTY(base->activequeues[i]));
! 260:
! 261: assert(min_heap_empty(&base->timeheap));
! 262: min_heap_dtor(&base->timeheap);
! 263:
! 264: for (i = 0; i < base->nactivequeues; ++i)
! 265: free(base->activequeues[i]);
! 266: free(base->activequeues);
! 267:
! 268: assert(TAILQ_EMPTY(&base->eventqueue));
! 269:
! 270: free(base);
! 271: }
! 272:
! 273: /* reinitialized the event base after a fork */
! 274: int
! 275: event_reinit(struct event_base *base)
! 276: {
! 277: const struct eventop *evsel = base->evsel;
! 278: void *evbase = base->evbase;
! 279: int res = 0;
! 280: struct event *ev;
! 281:
! 282: /* check if this event mechanism requires reinit */
! 283: if (!evsel->need_reinit)
! 284: return (0);
! 285:
! 286: /* prevent internal delete */
! 287: if (base->sig.ev_signal_added) {
! 288: /* we cannot call event_del here because the base has
! 289: * not been reinitialized yet. */
! 290: event_queue_remove(base, &base->sig.ev_signal,
! 291: EVLIST_INSERTED);
! 292: if (base->sig.ev_signal.ev_flags & EVLIST_ACTIVE)
! 293: event_queue_remove(base, &base->sig.ev_signal,
! 294: EVLIST_ACTIVE);
! 295: base->sig.ev_signal_added = 0;
! 296: }
! 297:
! 298: if (base->evsel->dealloc != NULL)
! 299: base->evsel->dealloc(base, base->evbase);
! 300: evbase = base->evbase = evsel->init(base);
! 301: if (base->evbase == NULL)
! 302: event_errx(1, "%s: could not reinitialize event mechanism",
! 303: __func__);
! 304:
! 305: TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {
! 306: if (evsel->add(evbase, ev) == -1)
! 307: res = -1;
! 308: }
! 309:
! 310: return (res);
! 311: }
! 312:
! 313: int
! 314: event_priority_init(int npriorities)
! 315: {
! 316: return event_base_priority_init(current_base, npriorities);
! 317: }
! 318:
! 319: int
! 320: event_base_priority_init(struct event_base *base, int npriorities)
! 321: {
! 322: int i;
! 323:
! 324: if (base->event_count_active)
! 325: return (-1);
! 326:
! 327: if (npriorities == base->nactivequeues)
! 328: return (0);
! 329:
! 330: if (base->nactivequeues) {
! 331: for (i = 0; i < base->nactivequeues; ++i) {
! 332: free(base->activequeues[i]);
! 333: }
! 334: free(base->activequeues);
! 335: }
! 336:
! 337: /* Allocate our priority queues */
! 338: base->nactivequeues = npriorities;
! 339: base->activequeues = (struct event_list **)
! 340: calloc(base->nactivequeues, sizeof(struct event_list *));
! 341: if (base->activequeues == NULL)
! 342: event_err(1, "%s: calloc", __func__);
! 343:
! 344: for (i = 0; i < base->nactivequeues; ++i) {
! 345: base->activequeues[i] = malloc(sizeof(struct event_list));
! 346: if (base->activequeues[i] == NULL)
! 347: event_err(1, "%s: malloc", __func__);
! 348: TAILQ_INIT(base->activequeues[i]);
! 349: }
! 350:
! 351: return (0);
! 352: }
! 353:
! 354: int
! 355: event_haveevents(struct event_base *base)
! 356: {
! 357: return (base->event_count > 0);
! 358: }
! 359:
! 360: /*
! 361: * Active events are stored in priority queues. Lower priorities are always
! 362: * process before higher priorities. Low priority events can starve high
! 363: * priority ones.
! 364: */
! 365:
! 366: static void
! 367: event_process_active(struct event_base *base)
! 368: {
! 369: struct event *ev;
! 370: struct event_list *activeq = NULL;
! 371: int i;
! 372: short ncalls;
! 373:
! 374: for (i = 0; i < base->nactivequeues; ++i) {
! 375: if (TAILQ_FIRST(base->activequeues[i]) != NULL) {
! 376: activeq = base->activequeues[i];
! 377: break;
! 378: }
! 379: }
! 380:
! 381: assert(activeq != NULL);
! 382:
! 383: for (ev = TAILQ_FIRST(activeq); ev; ev = TAILQ_FIRST(activeq)) {
! 384: if (ev->ev_events & EV_PERSIST)
! 385: event_queue_remove(base, ev, EVLIST_ACTIVE);
! 386: else
! 387: event_del(ev);
! 388:
! 389: /* Allows deletes to work */
! 390: ncalls = ev->ev_ncalls;
! 391: ev->ev_pncalls = &ncalls;
! 392: while (ncalls) {
! 393: ncalls--;
! 394: ev->ev_ncalls = ncalls;
! 395: (*ev->ev_callback)((int)ev->ev_fd, ev->ev_res, ev->ev_arg);
! 396: if (event_gotsig || base->event_break)
! 397: return;
! 398: }
! 399: }
! 400: }
! 401:
! 402: /*
! 403: * Wait continously for events. We exit only if no events are left.
! 404: */
! 405:
! 406: int
! 407: event_dispatch(void)
! 408: {
! 409: return (event_loop(0));
! 410: }
! 411:
! 412: int
! 413: event_base_dispatch(struct event_base *event_base)
! 414: {
! 415: return (event_base_loop(event_base, 0));
! 416: }
! 417:
! 418: const char *
! 419: event_base_get_method(struct event_base *base)
! 420: {
! 421: assert(base);
! 422: return (base->evsel->name);
! 423: }
! 424:
! 425: static void
! 426: event_loopexit_cb(int fd, short what, void *arg)
! 427: {
! 428: struct event_base *base = arg;
! 429: base->event_gotterm = 1;
! 430: }
! 431:
! 432: /* not thread safe */
! 433: int
! 434: event_loopexit(const struct timeval *tv)
! 435: {
! 436: return (event_once(-1, EV_TIMEOUT, event_loopexit_cb,
! 437: current_base, tv));
! 438: }
! 439:
! 440: int
! 441: event_base_loopexit(struct event_base *event_base, const struct timeval *tv)
! 442: {
! 443: return (event_base_once(event_base, -1, EV_TIMEOUT, event_loopexit_cb,
! 444: event_base, tv));
! 445: }
! 446:
! 447: /* not thread safe */
! 448: int
! 449: event_loopbreak(void)
! 450: {
! 451: return (event_base_loopbreak(current_base));
! 452: }
! 453:
! 454: int
! 455: event_base_loopbreak(struct event_base *event_base)
! 456: {
! 457: if (event_base == NULL)
! 458: return (-1);
! 459:
! 460: event_base->event_break = 1;
! 461: return (0);
! 462: }
! 463:
! 464:
! 465:
! 466: /* not thread safe */
! 467:
! 468: int
! 469: event_loop(int flags)
! 470: {
! 471: return event_base_loop(current_base, flags);
! 472: }
! 473:
! 474: int
! 475: event_base_loop(struct event_base *base, int flags)
! 476: {
! 477: const struct eventop *evsel = base->evsel;
! 478: void *evbase = base->evbase;
! 479: struct timeval tv;
! 480: struct timeval *tv_p;
! 481: int res, done;
! 482:
! 483: /* clear time cache */
! 484: base->tv_cache.tv_sec = 0;
! 485:
! 486: if (base->sig.ev_signal_added)
! 487: evsignal_base = base;
! 488: done = 0;
! 489: while (!done) {
! 490: /* Terminate the loop if we have been asked to */
! 491: if (base->event_gotterm) {
! 492: base->event_gotterm = 0;
! 493: break;
! 494: }
! 495:
! 496: if (base->event_break) {
! 497: base->event_break = 0;
! 498: break;
! 499: }
! 500:
! 501: /* You cannot use this interface for multi-threaded apps */
! 502: while (event_gotsig) {
! 503: event_gotsig = 0;
! 504: if (event_sigcb) {
! 505: res = (*event_sigcb)();
! 506: if (res == -1) {
! 507: errno = EINTR;
! 508: return (-1);
! 509: }
! 510: }
! 511: }
! 512:
! 513: timeout_correct(base, &tv);
! 514:
! 515: tv_p = &tv;
! 516: if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK)) {
! 517: timeout_next(base, &tv_p);
! 518: } else {
! 519: /*
! 520: * if we have active events, we just poll new events
! 521: * without waiting.
! 522: */
! 523: evutil_timerclear(&tv);
! 524: }
! 525:
! 526: /* If we have no events, we just exit */
! 527: if (!event_haveevents(base)) {
! 528: event_debug(("%s: no events registered.", __func__));
! 529: return (1);
! 530: }
! 531:
! 532: /* update last old time */
! 533: gettime(base, &base->event_tv);
! 534:
! 535: /* clear time cache */
! 536: base->tv_cache.tv_sec = 0;
! 537:
! 538: res = evsel->dispatch(base, evbase, tv_p);
! 539:
! 540: if (res == -1)
! 541: return (-1);
! 542: gettime(base, &base->tv_cache);
! 543:
! 544: timeout_process(base);
! 545:
! 546: if (base->event_count_active) {
! 547: event_process_active(base);
! 548: if (!base->event_count_active && (flags & EVLOOP_ONCE))
! 549: done = 1;
! 550: } else if (flags & EVLOOP_NONBLOCK)
! 551: done = 1;
! 552: }
! 553:
! 554: /* clear time cache */
! 555: base->tv_cache.tv_sec = 0;
! 556:
! 557: event_debug(("%s: asked to terminate loop.", __func__));
! 558: return (0);
! 559: }
! 560:
! 561: /* Sets up an event for processing once */
! 562:
! 563: struct event_once {
! 564: struct event ev;
! 565:
! 566: void (*cb)(int, short, void *);
! 567: void *arg;
! 568: };
! 569:
! 570: /* One-time callback, it deletes itself */
! 571:
! 572: static void
! 573: event_once_cb(int fd, short events, void *arg)
! 574: {
! 575: struct event_once *eonce = arg;
! 576:
! 577: (*eonce->cb)(fd, events, eonce->arg);
! 578: free(eonce);
! 579: }
! 580:
! 581: /* not threadsafe, event scheduled once. */
! 582: int
! 583: event_once(int fd, short events,
! 584: void (*callback)(int, short, void *), void *arg, const struct timeval *tv)
! 585: {
! 586: return event_base_once(current_base, fd, events, callback, arg, tv);
! 587: }
! 588:
! 589: /* Schedules an event once */
! 590: int
! 591: event_base_once(struct event_base *base, int fd, short events,
! 592: void (*callback)(int, short, void *), void *arg, const struct timeval *tv)
! 593: {
! 594: struct event_once *eonce;
! 595: struct timeval etv;
! 596: int res;
! 597:
! 598: /* We cannot support signals that just fire once */
! 599: if (events & EV_SIGNAL)
! 600: return (-1);
! 601:
! 602: if ((eonce = calloc(1, sizeof(struct event_once))) == NULL)
! 603: return (-1);
! 604:
! 605: eonce->cb = callback;
! 606: eonce->arg = arg;
! 607:
! 608: if (events == EV_TIMEOUT) {
! 609: if (tv == NULL) {
! 610: evutil_timerclear(&etv);
! 611: tv = &etv;
! 612: }
! 613:
! 614: evtimer_set(&eonce->ev, event_once_cb, eonce);
! 615: } else if (events & (EV_READ|EV_WRITE)) {
! 616: events &= EV_READ|EV_WRITE;
! 617:
! 618: event_set(&eonce->ev, fd, events, event_once_cb, eonce);
! 619: } else {
! 620: /* Bad event combination */
! 621: free(eonce);
! 622: return (-1);
! 623: }
! 624:
! 625: res = event_base_set(base, &eonce->ev);
! 626: if (res == 0)
! 627: res = event_add(&eonce->ev, tv);
! 628: if (res != 0) {
! 629: free(eonce);
! 630: return (res);
! 631: }
! 632:
! 633: return (0);
! 634: }
! 635:
! 636: void
! 637: event_set(struct event *ev, int fd, short events,
! 638: void (*callback)(int, short, void *), void *arg)
! 639: {
! 640: /* Take the current base - caller needs to set the real base later */
! 641: ev->ev_base = current_base;
! 642:
! 643: ev->ev_callback = callback;
! 644: ev->ev_arg = arg;
! 645: ev->ev_fd = fd;
! 646: ev->ev_events = events;
! 647: ev->ev_res = 0;
! 648: ev->ev_flags = EVLIST_INIT;
! 649: ev->ev_ncalls = 0;
! 650: ev->ev_pncalls = NULL;
! 651:
! 652: min_heap_elem_init(ev);
! 653:
! 654: /* by default, we put new events into the middle priority */
! 655: if(current_base)
! 656: ev->ev_pri = current_base->nactivequeues/2;
! 657: }
! 658:
! 659: int
! 660: event_base_set(struct event_base *base, struct event *ev)
! 661: {
! 662: /* Only innocent events may be assigned to a different base */
! 663: if (ev->ev_flags != EVLIST_INIT)
! 664: return (-1);
! 665:
! 666: ev->ev_base = base;
! 667: ev->ev_pri = base->nactivequeues/2;
! 668:
! 669: return (0);
! 670: }
! 671:
! 672: /*
! 673: * Set's the priority of an event - if an event is already scheduled
! 674: * changing the priority is going to fail.
! 675: */
! 676:
! 677: int
! 678: event_priority_set(struct event *ev, int pri)
! 679: {
! 680: if (ev->ev_flags & EVLIST_ACTIVE)
! 681: return (-1);
! 682: if (pri < 0 || pri >= ev->ev_base->nactivequeues)
! 683: return (-1);
! 684:
! 685: ev->ev_pri = pri;
! 686:
! 687: return (0);
! 688: }
! 689:
! 690: /*
! 691: * Checks if a specific event is pending or scheduled.
! 692: */
! 693:
! 694: int
! 695: event_pending(struct event *ev, short event, struct timeval *tv)
! 696: {
! 697: struct timeval now, res;
! 698: int flags = 0;
! 699:
! 700: if (ev->ev_flags & EVLIST_INSERTED)
! 701: flags |= (ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL));
! 702: if (ev->ev_flags & EVLIST_ACTIVE)
! 703: flags |= ev->ev_res;
! 704: if (ev->ev_flags & EVLIST_TIMEOUT)
! 705: flags |= EV_TIMEOUT;
! 706:
! 707: event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_SIGNAL);
! 708:
! 709: /* See if there is a timeout that we should report */
! 710: if (tv != NULL && (flags & event & EV_TIMEOUT)) {
! 711: gettime(ev->ev_base, &now);
! 712: evutil_timersub(&ev->ev_timeout, &now, &res);
! 713: /* correctly remap to real time */
! 714: evutil_gettimeofday(&now, NULL);
! 715: evutil_timeradd(&now, &res, tv);
! 716: }
! 717:
! 718: return (flags & event);
! 719: }
! 720:
! 721: int
! 722: event_add(struct event *ev, const struct timeval *tv)
! 723: {
! 724: struct event_base *base = ev->ev_base;
! 725: const struct eventop *evsel = base->evsel;
! 726: void *evbase = base->evbase;
! 727: int res = 0;
! 728:
! 729: event_debug((
! 730: "event_add: event: %p, %s%s%scall %p",
! 731: ev,
! 732: ev->ev_events & EV_READ ? "EV_READ " : " ",
! 733: ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
! 734: tv ? "EV_TIMEOUT " : " ",
! 735: ev->ev_callback));
! 736:
! 737: assert(!(ev->ev_flags & ~EVLIST_ALL));
! 738:
! 739: /*
! 740: * prepare for timeout insertion further below, if we get a
! 741: * failure on any step, we should not change any state.
! 742: */
! 743: if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
! 744: if (min_heap_reserve(&base->timeheap,
! 745: 1 + min_heap_size(&base->timeheap)) == -1)
! 746: return (-1); /* ENOMEM == errno */
! 747: }
! 748:
! 749: if ((ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)) &&
! 750: !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) {
! 751: res = evsel->add(evbase, ev);
! 752: if (res != -1)
! 753: event_queue_insert(base, ev, EVLIST_INSERTED);
! 754: }
! 755:
! 756: /*
! 757: * we should change the timout state only if the previous event
! 758: * addition succeeded.
! 759: */
! 760: if (res != -1 && tv != NULL) {
! 761: struct timeval now;
! 762:
! 763: /*
! 764: * we already reserved memory above for the case where we
! 765: * are not replacing an exisiting timeout.
! 766: */
! 767: if (ev->ev_flags & EVLIST_TIMEOUT)
! 768: event_queue_remove(base, ev, EVLIST_TIMEOUT);
! 769:
! 770: /* Check if it is active due to a timeout. Rescheduling
! 771: * this timeout before the callback can be executed
! 772: * removes it from the active list. */
! 773: if ((ev->ev_flags & EVLIST_ACTIVE) &&
! 774: (ev->ev_res & EV_TIMEOUT)) {
! 775: /* See if we are just active executing this
! 776: * event in a loop
! 777: */
! 778: if (ev->ev_ncalls && ev->ev_pncalls) {
! 779: /* Abort loop */
! 780: *ev->ev_pncalls = 0;
! 781: }
! 782:
! 783: event_queue_remove(base, ev, EVLIST_ACTIVE);
! 784: }
! 785:
! 786: gettime(base, &now);
! 787: evutil_timeradd(&now, tv, &ev->ev_timeout);
! 788:
! 789: event_debug((
! 790: "event_add: timeout in %ld seconds, call %p",
! 791: tv->tv_sec, ev->ev_callback));
! 792:
! 793: event_queue_insert(base, ev, EVLIST_TIMEOUT);
! 794: }
! 795:
! 796: return (res);
! 797: }
! 798:
! 799: int
! 800: event_del(struct event *ev)
! 801: {
! 802: struct event_base *base;
! 803: const struct eventop *evsel;
! 804: void *evbase;
! 805:
! 806: event_debug(("event_del: %p, callback %p",
! 807: ev, ev->ev_callback));
! 808:
! 809: /* An event without a base has not been added */
! 810: if (ev->ev_base == NULL)
! 811: return (-1);
! 812:
! 813: base = ev->ev_base;
! 814: evsel = base->evsel;
! 815: evbase = base->evbase;
! 816:
! 817: assert(!(ev->ev_flags & ~EVLIST_ALL));
! 818:
! 819: /* See if we are just active executing this event in a loop */
! 820: if (ev->ev_ncalls && ev->ev_pncalls) {
! 821: /* Abort loop */
! 822: *ev->ev_pncalls = 0;
! 823: }
! 824:
! 825: if (ev->ev_flags & EVLIST_TIMEOUT)
! 826: event_queue_remove(base, ev, EVLIST_TIMEOUT);
! 827:
! 828: if (ev->ev_flags & EVLIST_ACTIVE)
! 829: event_queue_remove(base, ev, EVLIST_ACTIVE);
! 830:
! 831: if (ev->ev_flags & EVLIST_INSERTED) {
! 832: event_queue_remove(base, ev, EVLIST_INSERTED);
! 833: return (evsel->del(evbase, ev));
! 834: }
! 835:
! 836: return (0);
! 837: }
! 838:
! 839: void
! 840: event_active(struct event *ev, int res, short ncalls)
! 841: {
! 842: /* We get different kinds of events, add them together */
! 843: if (ev->ev_flags & EVLIST_ACTIVE) {
! 844: ev->ev_res |= res;
! 845: return;
! 846: }
! 847:
! 848: ev->ev_res = res;
! 849: ev->ev_ncalls = ncalls;
! 850: ev->ev_pncalls = NULL;
! 851: event_queue_insert(ev->ev_base, ev, EVLIST_ACTIVE);
! 852: }
! 853:
! 854: static int
! 855: timeout_next(struct event_base *base, struct timeval **tv_p)
! 856: {
! 857: struct timeval now;
! 858: struct event *ev;
! 859: struct timeval *tv = *tv_p;
! 860:
! 861: if ((ev = min_heap_top(&base->timeheap)) == NULL) {
! 862: /* if no time-based events are active wait for I/O */
! 863: *tv_p = NULL;
! 864: return (0);
! 865: }
! 866:
! 867: if (gettime(base, &now) == -1)
! 868: return (-1);
! 869:
! 870: if (evutil_timercmp(&ev->ev_timeout, &now, <=)) {
! 871: evutil_timerclear(tv);
! 872: return (0);
! 873: }
! 874:
! 875: evutil_timersub(&ev->ev_timeout, &now, tv);
! 876:
! 877: assert(tv->tv_sec >= 0);
! 878: assert(tv->tv_usec >= 0);
! 879:
! 880: event_debug(("timeout_next: in %ld seconds", tv->tv_sec));
! 881: return (0);
! 882: }
! 883:
! 884: /*
! 885: * Determines if the time is running backwards by comparing the current
! 886: * time against the last time we checked. Not needed when using clock
! 887: * monotonic.
! 888: */
! 889:
! 890: static void
! 891: timeout_correct(struct event_base *base, struct timeval *tv)
! 892: {
! 893: struct event **pev;
! 894: unsigned int size;
! 895: struct timeval off;
! 896:
! 897: if (use_monotonic)
! 898: return;
! 899:
! 900: /* Check if time is running backwards */
! 901: gettime(base, tv);
! 902: if (evutil_timercmp(tv, &base->event_tv, >=)) {
! 903: base->event_tv = *tv;
! 904: return;
! 905: }
! 906:
! 907: event_debug(("%s: time is running backwards, corrected",
! 908: __func__));
! 909: evutil_timersub(&base->event_tv, tv, &off);
! 910:
! 911: /*
! 912: * We can modify the key element of the node without destroying
! 913: * the key, beause we apply it to all in the right order.
! 914: */
! 915: pev = base->timeheap.p;
! 916: size = base->timeheap.n;
! 917: for (; size-- > 0; ++pev) {
! 918: struct timeval *ev_tv = &(**pev).ev_timeout;
! 919: evutil_timersub(ev_tv, &off, ev_tv);
! 920: }
! 921: /* Now remember what the new time turned out to be. */
! 922: base->event_tv = *tv;
! 923: }
! 924:
! 925: void
! 926: timeout_process(struct event_base *base)
! 927: {
! 928: struct timeval now;
! 929: struct event *ev;
! 930:
! 931: if (min_heap_empty(&base->timeheap))
! 932: return;
! 933:
! 934: gettime(base, &now);
! 935:
! 936: while ((ev = min_heap_top(&base->timeheap))) {
! 937: if (evutil_timercmp(&ev->ev_timeout, &now, >))
! 938: break;
! 939:
! 940: /* delete this event from the I/O queues */
! 941: event_del(ev);
! 942:
! 943: event_debug(("timeout_process: call %p",
! 944: ev->ev_callback));
! 945: event_active(ev, EV_TIMEOUT, 1);
! 946: }
! 947: }
! 948:
! 949: void
! 950: event_queue_remove(struct event_base *base, struct event *ev, int queue)
! 951: {
! 952: if (!(ev->ev_flags & queue))
! 953: event_errx(1, "%s: %p(fd %d) not on queue %x", __func__,
! 954: ev, ev->ev_fd, queue);
! 955:
! 956: if (~ev->ev_flags & EVLIST_INTERNAL)
! 957: base->event_count--;
! 958:
! 959: ev->ev_flags &= ~queue;
! 960: switch (queue) {
! 961: case EVLIST_INSERTED:
! 962: TAILQ_REMOVE(&base->eventqueue, ev, ev_next);
! 963: break;
! 964: case EVLIST_ACTIVE:
! 965: base->event_count_active--;
! 966: TAILQ_REMOVE(base->activequeues[ev->ev_pri],
! 967: ev, ev_active_next);
! 968: break;
! 969: case EVLIST_TIMEOUT:
! 970: min_heap_erase(&base->timeheap, ev);
! 971: break;
! 972: default:
! 973: event_errx(1, "%s: unknown queue %x", __func__, queue);
! 974: }
! 975: }
! 976:
! 977: void
! 978: event_queue_insert(struct event_base *base, struct event *ev, int queue)
! 979: {
! 980: if (ev->ev_flags & queue) {
! 981: /* Double insertion is possible for active events */
! 982: if (queue & EVLIST_ACTIVE)
! 983: return;
! 984:
! 985: event_errx(1, "%s: %p(fd %d) already on queue %x", __func__,
! 986: ev, ev->ev_fd, queue);
! 987: }
! 988:
! 989: if (~ev->ev_flags & EVLIST_INTERNAL)
! 990: base->event_count++;
! 991:
! 992: ev->ev_flags |= queue;
! 993: switch (queue) {
! 994: case EVLIST_INSERTED:
! 995: TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);
! 996: break;
! 997: case EVLIST_ACTIVE:
! 998: base->event_count_active++;
! 999: TAILQ_INSERT_TAIL(base->activequeues[ev->ev_pri],
! 1000: ev,ev_active_next);
! 1001: break;
! 1002: case EVLIST_TIMEOUT: {
! 1003: min_heap_push(&base->timeheap, ev);
! 1004: break;
! 1005: }
! 1006: default:
! 1007: event_errx(1, "%s: unknown queue %x", __func__, queue);
! 1008: }
! 1009: }
! 1010:
! 1011: /* Functions for debugging */
! 1012:
! 1013: const char *
! 1014: event_get_version(void)
! 1015: {
! 1016: return (VERSION);
! 1017: }
! 1018:
! 1019: /*
! 1020: * No thread-safe interface needed - the information should be the same
! 1021: * for all threads.
! 1022: */
! 1023:
! 1024: const char *
! 1025: event_get_method(void)
! 1026: {
! 1027: return (current_base->evsel->name);
! 1028: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to event.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent