2 * Copyright (c) 2000-2004 Niels Provos <provos@citi.umich.edu>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
32 #define WIN32_LEAN_AND_MEAN
34 #undef WIN32_LEAN_AND_MEAN
37 #include <sys/types.h>
39 #ifdef HAVE_SYS_TIME_H
42 #include <sys/_time.h>
44 #include <sys/queue.h>
56 #include "event-internal.h"
59 #ifdef HAVE_EVENT_PORTS
60 extern const struct eventop evportops;
63 extern const struct eventop selectops;
66 extern const struct eventop pollops;
69 extern const struct eventop rtsigops;
72 extern const struct eventop epollops;
74 #ifdef HAVE_WORKING_KQUEUE
75 extern const struct eventop kqops;
78 extern const struct eventop devpollops;
81 extern const struct eventop win32ops;
84 /* In order of preference */
85 const struct eventop *eventops[] = {
86 #ifdef HAVE_EVENT_PORTS
89 #ifdef HAVE_WORKING_KQUEUE
114 struct event_list signalqueue;
116 struct event_base *current_base = NULL;
118 /* Handle signals - This is a deprecated interface */
119 int (*event_sigcb)(void); /* Signal callback when gotsig is set */
120 volatile sig_atomic_t event_gotsig; /* Set in signal handler */
123 static void event_queue_insert(struct event_base *, struct event *, int);
124 static void event_queue_remove(struct event_base *, struct event *, int);
125 static int event_haveevents(struct event_base *);
127 static void event_process_active(struct event_base *);
129 static int timeout_next(struct event_base *, struct timeval *);
130 static void timeout_process(struct event_base *);
131 static void timeout_correct(struct event_base *, struct timeval *);
134 compare(struct event *a, struct event *b)
136 if (timercmp(&a->ev_timeout, &b->ev_timeout, <))
138 else if (timercmp(&a->ev_timeout, &b->ev_timeout, >))
148 gettime(struct timeval *tp)
150 #ifdef HAVE_CLOCK_GETTIME
153 #ifdef HAVE_CLOCK_MONOTONIC
154 if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
156 if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
159 tp->tv_sec = ts.tv_sec;
160 tp->tv_usec = ts.tv_nsec / 1000;
162 gettimeofday(tp, NULL);
168 RB_PROTOTYPE(event_tree, event, ev_timeout_node, compare);
170 RB_GENERATE(event_tree, event, ev_timeout_node, compare);
178 if ((current_base = calloc(1, sizeof(struct event_base))) == NULL)
179 event_err(1, "%s: calloc");
183 gettime(¤t_base->event_tv);
185 RB_INIT(¤t_base->timetree);
186 TAILQ_INIT(¤t_base->eventqueue);
187 TAILQ_INIT(&signalqueue);
189 current_base->evbase = NULL;
190 for (i = 0; eventops[i] && !current_base->evbase; i++) {
191 current_base->evsel = eventops[i];
193 current_base->evbase = current_base->evsel->init();
196 if (current_base->evbase == NULL)
197 event_errx(1, "%s: no event mechanism available", __func__);
199 if (getenv("EVENT_SHOW_METHOD"))
200 event_msgx("libevent using: %s\n",
201 current_base->evsel->name);
203 /* allocate a single active event queue */
204 event_base_priority_init(current_base, 1);
206 return (current_base);
210 event_base_free(struct event_base *base)
214 if (base == NULL && current_base)
216 if (base == current_base)
220 assert(TAILQ_EMPTY(&base->eventqueue));
221 for (i=0; i < base->nactivequeues; ++i)
222 assert(TAILQ_EMPTY(base->activequeues[i]));
224 assert(RB_EMPTY(&base->timetree));
226 for (i = 0; i < base->nactivequeues; ++i)
227 free(base->activequeues[i]);
228 free(base->activequeues);
230 if (base->evsel->dealloc != NULL)
231 base->evsel->dealloc(base->evbase);
237 event_priority_init(int npriorities)
239 return event_base_priority_init(current_base, npriorities);
243 event_base_priority_init(struct event_base *base, int npriorities)
247 if (base->event_count_active)
250 if (base->nactivequeues && npriorities != base->nactivequeues) {
251 for (i = 0; i < base->nactivequeues; ++i) {
252 free(base->activequeues[i]);
254 free(base->activequeues);
257 /* Allocate our priority queues */
258 base->nactivequeues = npriorities;
259 base->activequeues = (struct event_list **)calloc(base->nactivequeues,
260 npriorities * sizeof(struct event_list *));
261 if (base->activequeues == NULL)
262 event_err(1, "%s: calloc", __func__);
264 for (i = 0; i < base->nactivequeues; ++i) {
265 base->activequeues[i] = malloc(sizeof(struct event_list));
266 if (base->activequeues[i] == NULL)
267 event_err(1, "%s: malloc", __func__);
268 TAILQ_INIT(base->activequeues[i]);
275 event_haveevents(struct event_base *base)
277 return (base->event_count > 0);
281 * Active events are stored in priority queues. Lower priorities are always
282 * process before higher priorities. Low priority events can starve high
287 event_process_active(struct event_base *base)
290 struct event_list *activeq = NULL;
294 if (!base->event_count_active)
297 for (i = 0; i < base->nactivequeues; ++i) {
298 if (TAILQ_FIRST(base->activequeues[i]) != NULL) {
299 activeq = base->activequeues[i];
304 assert(activeq != NULL);
306 for (ev = TAILQ_FIRST(activeq); ev; ev = TAILQ_FIRST(activeq)) {
307 event_queue_remove(base, ev, EVLIST_ACTIVE);
309 /* Allows deletes to work */
310 ncalls = ev->ev_ncalls;
311 ev->ev_pncalls = &ncalls;
314 ev->ev_ncalls = ncalls;
315 (*ev->ev_callback)((int)ev->ev_fd, ev->ev_res, ev->ev_arg);
323 * Wait continously for events. We exit only if no events are left.
329 return (event_loop(0));
333 event_base_dispatch(struct event_base *event_base)
335 return (event_base_loop(event_base, 0));
339 event_loopexit_cb(int fd, short what, void *arg)
341 struct event_base *base = arg;
342 base->event_gotterm = 1;
345 /* not thread safe */
348 event_loopexit(struct timeval *tv)
350 return (event_once(-1, EV_TIMEOUT, event_loopexit_cb,
355 event_base_loopexit(struct event_base *event_base, struct timeval *tv)
357 return (event_once(-1, EV_TIMEOUT, event_loopexit_cb,
361 /* not thread safe */
364 event_loop(int flags)
366 return event_base_loop(current_base, flags);
370 event_base_loop(struct event_base *base, int flags)
372 const struct eventop *evsel = base->evsel;
373 void *evbase = base->evbase;
379 /* Calculate the initial events that we are waiting for */
380 if (evsel->recalc(base, evbase, 0) == -1)
383 /* Terminate the loop if we have been asked to */
384 if (base->event_gotterm) {
385 base->event_gotterm = 0;
389 /* You cannot use this interface for multi-threaded apps */
390 while (event_gotsig) {
393 res = (*event_sigcb)();
401 /* Check if time is running backwards */
403 if (timercmp(&tv, &base->event_tv, <)) {
405 event_debug(("%s: time is running backwards, corrected",
407 timersub(&base->event_tv, &tv, &off);
408 timeout_correct(base, &off);
412 if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK))
413 timeout_next(base, &tv);
417 /* If we have no events, we just exit */
418 if (!event_haveevents(base)) {
419 event_debug(("%s: no events registered.", __func__));
423 res = evsel->dispatch(base, evbase, &tv);
428 timeout_process(base);
430 if (base->event_count_active) {
431 event_process_active(base);
432 if (!base->event_count_active && (flags & EVLOOP_ONCE))
434 } else if (flags & EVLOOP_NONBLOCK)
438 event_debug(("%s: asked to terminate loop.", __func__));
442 /* Sets up an event for processing once */
447 void (*cb)(int, short, void *);
451 /* One-time callback, it deletes itself */
454 event_once_cb(int fd, short events, void *arg)
456 struct event_once *eonce = arg;
458 (*eonce->cb)(fd, events, eonce->arg);
462 /* Schedules an event once */
465 event_once(int fd, short events,
466 void (*callback)(int, short, void *), void *arg, struct timeval *tv)
468 struct event_once *eonce;
472 /* We cannot support signals that just fire once */
473 if (events & EV_SIGNAL)
476 if ((eonce = calloc(1, sizeof(struct event_once))) == NULL)
479 eonce->cb = callback;
482 if (events == EV_TIMEOUT) {
488 evtimer_set(&eonce->ev, event_once_cb, eonce);
489 } else if (events & (EV_READ|EV_WRITE)) {
490 events &= EV_READ|EV_WRITE;
492 event_set(&eonce->ev, fd, events, event_once_cb, eonce);
494 /* Bad event combination */
499 res = event_add(&eonce->ev, tv);
509 event_set(struct event *ev, int fd, short events,
510 void (*callback)(int, short, void *), void *arg)
512 /* Take the current base - caller needs to set the real base later */
513 ev->ev_base = current_base;
515 ev->ev_callback = callback;
518 ev->ev_events = events;
519 ev->ev_flags = EVLIST_INIT;
521 ev->ev_pncalls = NULL;
523 /* by default, we put new events into the middle priority */
524 ev->ev_pri = current_base->nactivequeues/2;
528 event_base_set(struct event_base *base, struct event *ev)
530 /* Only innocent events may be assigned to a different base */
531 if (ev->ev_flags != EVLIST_INIT)
535 ev->ev_pri = base->nactivequeues/2;
541 * Set's the priority of an event - if an event is already scheduled
542 * changing the priority is going to fail.
546 event_priority_set(struct event *ev, int pri)
548 if (ev->ev_flags & EVLIST_ACTIVE)
550 if (pri < 0 || pri >= ev->ev_base->nactivequeues)
559 * Checks if a specific event is pending or scheduled.
563 event_pending(struct event *ev, short event, struct timeval *tv)
565 struct timeval now, res;
568 if (ev->ev_flags & EVLIST_INSERTED)
569 flags |= (ev->ev_events & (EV_READ|EV_WRITE));
570 if (ev->ev_flags & EVLIST_ACTIVE)
572 if (ev->ev_flags & EVLIST_TIMEOUT)
574 if (ev->ev_flags & EVLIST_SIGNAL)
577 event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_SIGNAL);
579 /* See if there is a timeout that we should report */
580 if (tv != NULL && (flags & event & EV_TIMEOUT)) {
582 timersub(&ev->ev_timeout, &now, &res);
583 /* correctly remap to real time */
584 gettimeofday(&now, NULL);
585 timeradd(&now, &res, tv);
588 return (flags & event);
592 event_add(struct event *ev, struct timeval *tv)
594 struct event_base *base = ev->ev_base;
595 const struct eventop *evsel = base->evsel;
596 void *evbase = base->evbase;
599 "event_add: event: %p, %s%s%scall %p",
601 ev->ev_events & EV_READ ? "EV_READ " : " ",
602 ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
603 tv ? "EV_TIMEOUT " : " ",
606 assert(!(ev->ev_flags & ~EVLIST_ALL));
611 if (ev->ev_flags & EVLIST_TIMEOUT)
612 event_queue_remove(base, ev, EVLIST_TIMEOUT);
614 /* Check if it is active due to a timeout. Rescheduling
615 * this timeout before the callback can be executed
616 * removes it from the active list. */
617 if ((ev->ev_flags & EVLIST_ACTIVE) &&
618 (ev->ev_res & EV_TIMEOUT)) {
619 /* See if we are just active executing this
622 if (ev->ev_ncalls && ev->ev_pncalls) {
627 event_queue_remove(base, ev, EVLIST_ACTIVE);
631 timeradd(&now, tv, &ev->ev_timeout);
634 "event_add: timeout in %d seconds, call %p",
635 tv->tv_sec, ev->ev_callback));
637 event_queue_insert(base, ev, EVLIST_TIMEOUT);
640 if ((ev->ev_events & (EV_READ|EV_WRITE)) &&
641 !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) {
642 event_queue_insert(base, ev, EVLIST_INSERTED);
644 return (evsel->add(evbase, ev));
645 } else if ((ev->ev_events & EV_SIGNAL) &&
646 !(ev->ev_flags & EVLIST_SIGNAL)) {
647 event_queue_insert(base, ev, EVLIST_SIGNAL);
649 return (evsel->add(evbase, ev));
656 event_del(struct event *ev)
658 struct event_base *base;
659 const struct eventop *evsel;
662 event_debug(("event_del: %p, callback %p",
663 ev, ev->ev_callback));
665 /* An event without a base has not been added */
666 if (ev->ev_base == NULL)
671 evbase = base->evbase;
673 assert(!(ev->ev_flags & ~EVLIST_ALL));
675 /* See if we are just active executing this event in a loop */
676 if (ev->ev_ncalls && ev->ev_pncalls) {
681 if (ev->ev_flags & EVLIST_TIMEOUT)
682 event_queue_remove(base, ev, EVLIST_TIMEOUT);
684 if (ev->ev_flags & EVLIST_ACTIVE)
685 event_queue_remove(base, ev, EVLIST_ACTIVE);
687 if (ev->ev_flags & EVLIST_INSERTED) {
688 event_queue_remove(base, ev, EVLIST_INSERTED);
689 return (evsel->del(evbase, ev));
690 } else if (ev->ev_flags & EVLIST_SIGNAL) {
691 event_queue_remove(base, ev, EVLIST_SIGNAL);
692 return (evsel->del(evbase, ev));
699 event_active(struct event *ev, int res, short ncalls)
701 /* We get different kinds of events, add them together */
702 if (ev->ev_flags & EVLIST_ACTIVE) {
708 ev->ev_ncalls = ncalls;
709 ev->ev_pncalls = NULL;
710 event_queue_insert(ev->ev_base, ev, EVLIST_ACTIVE);
714 timeout_next(struct event_base *base, struct timeval *tv)
716 struct timeval dflt = TIMEOUT_DEFAULT;
721 if ((ev = RB_MIN(event_tree, &base->timetree)) == NULL) {
726 if (gettime(&now) == -1)
729 if (timercmp(&ev->ev_timeout, &now, <=)) {
734 timersub(&ev->ev_timeout, &now, tv);
736 assert(tv->tv_sec >= 0);
737 assert(tv->tv_usec >= 0);
739 event_debug(("timeout_next: in %d seconds", tv->tv_sec));
744 timeout_correct(struct event_base *base, struct timeval *off)
749 * We can modify the key element of the node without destroying
750 * the key, beause we apply it to all in the right order.
752 RB_FOREACH(ev, event_tree, &base->timetree)
753 timersub(&ev->ev_timeout, off, &ev->ev_timeout);
757 timeout_process(struct event_base *base)
760 struct event *ev, *next;
764 for (ev = RB_MIN(event_tree, &base->timetree); ev; ev = next) {
765 if (timercmp(&ev->ev_timeout, &now, >))
767 next = RB_NEXT(event_tree, &base->timetree, ev);
769 event_queue_remove(base, ev, EVLIST_TIMEOUT);
771 /* delete this event from the I/O queues */
774 event_debug(("timeout_process: call %p",
776 event_active(ev, EV_TIMEOUT, 1);
781 event_queue_remove(struct event_base *base, struct event *ev, int queue)
785 if (!(ev->ev_flags & queue))
786 event_errx(1, "%s: %p(fd %d) not on queue %x", __func__,
787 ev, ev->ev_fd, queue);
789 if (ev->ev_flags & EVLIST_INTERNAL)
795 ev->ev_flags &= ~queue;
799 base->event_count_active--;
800 TAILQ_REMOVE(base->activequeues[ev->ev_pri],
804 TAILQ_REMOVE(&signalqueue, ev, ev_signal_next);
807 RB_REMOVE(event_tree, &base->timetree, ev);
809 case EVLIST_INSERTED:
810 TAILQ_REMOVE(&base->eventqueue, ev, ev_next);
813 event_errx(1, "%s: unknown queue %x", __func__, queue);
818 event_queue_insert(struct event_base *base, struct event *ev, int queue)
822 if (ev->ev_flags & queue) {
823 /* Double insertion is possible for active events */
824 if (queue & EVLIST_ACTIVE)
827 event_errx(1, "%s: %p(fd %d) already on queue %x", __func__,
828 ev, ev->ev_fd, queue);
831 if (ev->ev_flags & EVLIST_INTERNAL)
837 ev->ev_flags |= queue;
841 base->event_count_active++;
842 TAILQ_INSERT_TAIL(base->activequeues[ev->ev_pri],
846 TAILQ_INSERT_TAIL(&signalqueue, ev, ev_signal_next);
848 case EVLIST_TIMEOUT: {
849 struct event *tmp = RB_INSERT(event_tree, &base->timetree, ev);
853 case EVLIST_INSERTED:
854 TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);
857 event_errx(1, "%s: unknown queue %x", __func__, queue);
861 /* Functions for debugging */
864 event_get_version(void)
870 * No thread-safe interface needed - the information should be the same
875 event_get_method(void)
877 return (current_base->evsel->name);