libevent源码分析：evmap_io_active_函数

evmap_io_active_函数用于将激活指定文件描述符上的事件

 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, );
     }
 }

遍历evmap_io的成员events，在每一次遍历中实际调用ev_active_nolock_

 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));
 }

该函数在最后又调用函数event_callback_activate_nolock

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

该函数最后又调用event_queue_insert_active

 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);
 }

1、L18将该事件插入到event_base.activequeues队列中。

函数调用关系图：

待续。。。