LCOV - code coverage report
Current view: directory - ipc/chromium/src/third_party/libevent - event.c (source / functions) Found Hit Coverage
Test: app.info Lines: 391 195 49.9 %
Date: 2012-06-02 Functions: 37 19 51.4 %

       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                 : }

Generated by: LCOV version 1.7