libevent源码分析：event_add、event_del

event_add、event_del两个函数分别是使event生效和失效的，下面就来看一下两个函数的实现。

event_add

 int
 event_add(struct event *ev, const struct timeval *tv)
 {
     int res;
 
     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
         event_warnx("%s: event has no event_base set.", __func__);
         return -;
     }
 
     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
 
     res = event_add_nolock_(ev, tv, );
 
     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
 
     return (res);
 }
 
 /* Implementation function to add an event.  Works just like event_add,
  * except: 1) it requires that we have the lock.  2) if tv_is_absolute is set,
  * we treat tv as an absolute time, not as an interval to add to the current
  * time */
 int
 event_add_nolock_(struct event *ev, const struct timeval *tv,
     int tv_is_absolute)
 {
     struct event_base *base = ev->ev_base;
     int res = ;
     int notify = ;
 
     EVENT_BASE_ASSERT_LOCKED(base);
     event_debug_assert_is_setup_(ev);
 
     event_debug((
          "event_add: event: %p (fd "EV_SOCK_FMT"), %s%s%s%scall %p",
          ev,
          EV_SOCK_ARG(ev->ev_fd),
          ev->ev_events & EV_READ ? "EV_READ " : " ",
          ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
          ev->ev_events & EV_CLOSED ? "EV_CLOSED " : " ",
          tv ? "EV_TIMEOUT " : " ",
          ev->ev_callback));
 
     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
 
     if (ev->ev_flags & EVLIST_FINALIZING) {
         /* XXXX debug */
         return (-);
     }
 
     /*
      * prepare for timeout insertion further below, if we get a
      * failure on any step, we should not change any state.
      */
     if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
         if (min_heap_reserve_(&base->timeheap,
              + min_heap_size_(&base->timeheap)) == -)
             return (-);  /* ENOMEM == errno */
     }
 
     /* If the main thread is currently executing a signal event's
      * callback, and we are not the main thread, then we want to wait
      * until the callback is done before we mess with the event, or else
      * we can race on ev_ncalls and ev_pncalls below. */
 #ifndef EVENT__DISABLE_THREAD_SUPPORT
     if (base->current_event == event_to_event_callback(ev) &&
         (ev->ev_events & EV_SIGNAL)
         && !EVBASE_IN_THREAD(base)) {
         ++base->current_event_waiters;
         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
     }
 #endif
 
     if ((ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED|EV_SIGNAL)) &&
         !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {
         if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))
             res = evmap_io_add_(base, ev->ev_fd, ev);
         else if (ev->ev_events & EV_SIGNAL)
             res = evmap_signal_add_(base, (int)ev->ev_fd, ev);
         if (res != -)
             event_queue_insert_inserted(base, ev);
         if (res == ) {
             /* evmap says we need to notify the main thread. */
             notify = ;
             res = ;
         }
     }
 
     /*
      * we should change the timeout state only if the previous event
      * addition succeeded.
      */
     if (res != - && tv != NULL) {
         struct timeval now;
         int common_timeout;
 #ifdef USE_REINSERT_TIMEOUT
         int was_common;
         int old_timeout_idx;
 #endif
 
         /*
          * for persistent timeout events, we remember the
          * timeout value and re-add the event.
          *
          * If tv_is_absolute, this was already set.
          */
         if (ev->ev_closure == EV_CLOSURE_EVENT_PERSIST && !tv_is_absolute)
             ev->ev_io_timeout = *tv;
 
 #ifndef USE_REINSERT_TIMEOUT
         if (ev->ev_flags & EVLIST_TIMEOUT) {
             event_queue_remove_timeout(base, ev);
         }
 #endif
 
         /* Check if it is active due to a timeout.  Rescheduling
          * this timeout before the callback can be executed
          * removes it from the active list. */
         if ((ev->ev_flags & EVLIST_ACTIVE) &&
             (ev->ev_res & EV_TIMEOUT)) {
             if (ev->ev_events & EV_SIGNAL) {
                 /* See if we are just active executing
                  * this event in a loop
                  */
                 if (ev->ev_ncalls && ev->ev_pncalls) {
                     /* Abort loop */
                     *ev->ev_pncalls = ;
                 }
             }
 
             event_queue_remove_active(base, event_to_event_callback(ev));
         }
 
         gettime(base, &now);
 
         common_timeout = is_common_timeout(tv, base);
 #ifdef USE_REINSERT_TIMEOUT
         was_common = is_common_timeout(&ev->ev_timeout, base);
         old_timeout_idx = COMMON_TIMEOUT_IDX(&ev->ev_timeout);
 #endif
 
         if (tv_is_absolute) {
             ev->ev_timeout = *tv;
         } else if (common_timeout) {
             struct timeval tmp = *tv;
             tmp.tv_usec &= MICROSECONDS_MASK;
             evutil_timeradd(&now, &tmp, &ev->ev_timeout);
             ev->ev_timeout.tv_usec |=
                 (tv->tv_usec & ~MICROSECONDS_MASK);
         } else {
             evutil_timeradd(&now, tv, &ev->ev_timeout);
         }
 
         event_debug((
              "event_add: event %p, timeout in %d seconds %d useconds, call %p",
              ev, (int)tv->tv_sec, (int)tv->tv_usec, ev->ev_callback));
 
 #ifdef USE_REINSERT_TIMEOUT
         event_queue_reinsert_timeout(base, ev, was_common, common_timeout, old_timeout_idx);
 #else
         event_queue_insert_timeout(base, ev);
 #endif
 
         if (common_timeout) {
             struct common_timeout_list *ctl =
                 get_common_timeout_list(base, &ev->ev_timeout);
             if (ev == TAILQ_FIRST(&ctl->events)) {
                 common_timeout_schedule(ctl, &now, ev);
             }
         } else {
             struct event* top = NULL;
             /* See if the earliest timeout is now earlier than it
              * was before: if so, we will need to tell the main
              * thread to wake up earlier than it would otherwise.
              * We double check the timeout of the top element to
              * handle time distortions due to system suspension.
              */
             if (min_heap_elt_is_top_(ev))
                 notify = ;
             else if ((top = min_heap_top_(&base->timeheap)) != NULL &&
                      evutil_timercmp(&top->ev_timeout, &now, <))
                 notify = ;
         }
     }
 
     /* if we are not in the right thread, we need to wake up the loop */
     if (res != - && notify && EVBASE_NEED_NOTIFY(base))
         evthread_notify_base(base);
 
     event_debug_note_add_(ev);
 
     return (res);
 }

这里以epoll作为后端来举例分析event_add函数的调用流程：

event_del

 int
 event_del(struct event *ev)
 {
     return event_del_(ev, EVENT_DEL_AUTOBLOCK);
 }
 
 static int
 event_del_(struct event *ev, int blocking)
 {
     int res;
 
     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
         event_warnx("%s: event has no event_base set.", __func__);
         return -;
     }
 
     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
 
     res = event_del_nolock_(ev, blocking);
 
     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
 
     return (res);
 }
 
 /** Helper for event_del: always called with th_base_lock held.
  *
  * "blocking" must be one of the EVENT_DEL_{BLOCK, NOBLOCK, AUTOBLOCK,
  * EVEN_IF_FINALIZING} values. See those for more information.
  */
 int
 event_del_nolock_(struct event *ev, int blocking)
 {
     struct event_base *base;
     int res = , notify = ;
 
     event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p",
         ev, EV_SOCK_ARG(ev->ev_fd), ev->ev_callback));
 
     /* An event without a base has not been added */
     if (ev->ev_base == NULL)
         return (-);
 
     EVENT_BASE_ASSERT_LOCKED(ev->ev_base);
 
     if (blocking != EVENT_DEL_EVEN_IF_FINALIZING) {
         if (ev->ev_flags & EVLIST_FINALIZING) {
             /* XXXX Debug */
             return ;
         }
     }
 
     /* If the main thread is currently executing this event's callback,
      * and we are not the main thread, then we want to wait until the
      * callback is done before we start removing the event.  That way,
      * when this function returns, it will be safe to free the
      * user-supplied argument. */
     base = ev->ev_base;
 #ifndef EVENT__DISABLE_THREAD_SUPPORT
     if (blocking != EVENT_DEL_NOBLOCK &&
         base->current_event == event_to_event_callback(ev) &&
         !EVBASE_IN_THREAD(base) &&
         (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) {
         ++base->current_event_waiters;
         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
     }
 #endif
 
     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
 
     /* See if we are just active executing this event in a loop */
     if (ev->ev_events & EV_SIGNAL) {
         if (ev->ev_ncalls && ev->ev_pncalls) {
             /* Abort loop */
             *ev->ev_pncalls = ;
         }
     }
 
     if (ev->ev_flags & EVLIST_TIMEOUT) {
         /* NOTE: We never need to notify the main thread because of a
          * deleted timeout event: all that could happen if we don't is
          * that the dispatch loop might wake up too early.  But the
          * point of notifying the main thread _is_ to wake up the
          * dispatch loop early anyway, so we wouldn't gain anything by
          * doing it.
          */
         event_queue_remove_timeout(base, ev);
     }
 
     if (ev->ev_flags & EVLIST_ACTIVE)
         event_queue_remove_active(base, event_to_event_callback(ev));
     else if (ev->ev_flags & EVLIST_ACTIVE_LATER)
         event_queue_remove_active_later(base, event_to_event_callback(ev));
 
     if (ev->ev_flags & EVLIST_INSERTED) {
         event_queue_remove_inserted(base, ev);
         if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))
             res = evmap_io_del_(base, ev->ev_fd, ev);
         else
             res = evmap_signal_del_(base, (int)ev->ev_fd, ev);
         if (res == ) {
             /* evmap says we need to notify the main thread. */
             notify = ;
             res = ;
         }
     }
 
     /* if we are not in the right thread, we need to wake up the loop */
     if (res != - && notify && EVBASE_NEED_NOTIFY(base))
         evthread_notify_base(base);
 
     event_debug_note_del_(ev);
 
     return (res);
 }

这里以epoll作为后端来分析event_del的调用流程：

结论：

到这里event_add、event_del函数就分析完了，这两个函数的功能就是使事件生效和失效，以epoll作为后端举例，最后都会调用epoll_ctl来修改事件，libevent实现的很复杂，是因为它考虑到效率的问题，关于libevent如何保证了libevent的高效，这个待之后彻底理解了libevent的设计之后再来分析。