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