void

 evmap_io_active_(struct event_base *base, evutil_socket_t fd, short events)

 {

     struct event_io_map *io = &base->io;

     struct evmap_io *ctx;

     struct event *ev;

 #ifndef EVMAP_USE_HT

     if (fd <  || fd >= io->nentries)

         return;

 #endif

     GET_IO_SLOT(ctx, io, fd, evmap_io);

     if (NULL == ctx)

         return;

     LIST_FOREACH(ev, &ctx->events, ev_io_next) {

         if (ev->ev_events & events)

             event_active_nolock_(ev, ev->ev_events & events, );

     }

 }

 void

 event_active_nolock_(struct event *ev, int res, short ncalls)

 {

     struct event_base *base;

     event_debug(("event_active: %p (fd "EV_SOCK_FMT"), res %d, callback %p",

         ev, EV_SOCK_ARG(ev->ev_fd), (int)res, ev->ev_callback));

     base = ev->ev_base;

     EVENT_BASE_ASSERT_LOCKED(base);

     if (ev->ev_flags & EVLIST_FINALIZING) {

         /* XXXX debug */

         return;

     }

     switch ((ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {

     default:

     case EVLIST_ACTIVE|EVLIST_ACTIVE_LATER:

         EVUTIL_ASSERT();

         break;

     case EVLIST_ACTIVE:

         /* We get different kinds of events, add them together */

         ev->ev_res |= res;

         return;

     case EVLIST_ACTIVE_LATER:

         ev->ev_res |= res;

         break;

     case :

         ev->ev_res = res;

         break;

     }

     if (ev->ev_pri < base->event_running_priority)

         base->event_continue = ;

     if (ev->ev_events & EV_SIGNAL) {

 #ifndef EVENT__DISABLE_THREAD_SUPPORT

         if (base->current_event == event_to_event_callback(ev) &&

             !EVBASE_IN_THREAD(base)) {

             ++base->current_event_waiters;

             EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);

         }

 #endif

         ev->ev_ncalls = ncalls;

         ev->ev_pncalls = NULL;

     }

     event_callback_activate_nolock_(base, event_to_event_callback(ev));

 }

 int

 event_callback_activate_nolock_(struct event_base *base,

     struct event_callback *evcb)

 {

     int r = ;

     if (evcb->evcb_flags & EVLIST_FINALIZING)

         return ;

     switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) {

     default:

         EVUTIL_ASSERT();

     case EVLIST_ACTIVE_LATER:

         event_queue_remove_active_later(base, evcb);

         r = ;

         break;

     case EVLIST_ACTIVE:

         return ;

     case :

         break;

     }

     event_queue_insert_active(base, evcb);

     if (EVBASE_NEED_NOTIFY(base))

         evthread_notify_base(base);

     return r;

 }

 static void

 event_queue_insert_active(struct event_base *base, struct event_callback *evcb)

 {

     EVENT_BASE_ASSERT_LOCKED(base);

     if (evcb->evcb_flags & EVLIST_ACTIVE) {

         /* Double insertion is possible for active events */

         return;

     }

     INCR_EVENT_COUNT(base, evcb->evcb_flags);

     evcb->evcb_flags |= EVLIST_ACTIVE;

     base->event_count_active++;

     MAX_EVENT_COUNT(base->event_count_active_max, base->event_count_active);

     EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues);

     TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri],

         evcb, evcb_active_next);

 }