libevent源码分析：event_add、event_del

  1 int
  2 event_add(struct event *ev, const struct timeval *tv)
  3 {
  4     int res;
  5 
  6     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
  7         event_warnx("%s: event has no event_base set.", __func__);
  8         return -1;
  9     }
 10 
 11     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
 12 
 13     res = event_add_nolock_(ev, tv, 0);
 14 
 15     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
 16 
 17     return (res);
 18 }
 19 
 20 /* Implementation function to add an event.  Works just like event_add,
 21  * except: 1) it requires that we have the lock.  2) if tv_is_absolute is set,
 22  * we treat tv as an absolute time, not as an interval to add to the current
 23  * time */
 24 int
 25 event_add_nolock_(struct event *ev, const struct timeval *tv,
 26     int tv_is_absolute)
 27 {
 28     struct event_base *base = ev->ev_base;
 29     int res = 0;
 30     int notify = 0;
 31 
 32     EVENT_BASE_ASSERT_LOCKED(base);
 33     event_debug_assert_is_setup_(ev);
 34 
 35     event_debug((
 36          "event_add: event: %p (fd "EV_SOCK_FMT"), %s%s%s%scall %p",
 37          ev,
 38          EV_SOCK_ARG(ev->ev_fd),
 39          ev->ev_events & EV_READ ? "EV_READ " : " ",
 40          ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
 41          ev->ev_events & EV_CLOSED ? "EV_CLOSED " : " ",
 42          tv ? "EV_TIMEOUT " : " ",
 43          ev->ev_callback));
 44 
 45     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
 46 
 47     if (ev->ev_flags & EVLIST_FINALIZING) {
 48         /* XXXX debug */
 49         return (-1);
 50     }
 51 
 52     /*
 53      * prepare for timeout insertion further below, if we get a
 54      * failure on any step, we should not change any state.
 55      */
 56     if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
 57         if (min_heap_reserve_(&base->timeheap,
 58             1 + min_heap_size_(&base->timeheap)) == -1)
 59             return (-1);  /* ENOMEM == errno */
 60     }
 61 
 62     /* If the main thread is currently executing a signal event‘s
 63      * callback, and we are not the main thread, then we want to wait
 64      * until the callback is done before we mess with the event, or else
 65      * we can race on ev_ncalls and ev_pncalls below. */
 66 #ifndef EVENT__DISABLE_THREAD_SUPPORT
 67     if (base->current_event == event_to_event_callback(ev) &&
 68         (ev->ev_events & EV_SIGNAL)
 69         && !EVBASE_IN_THREAD(base)) {
 70         ++base->current_event_waiters;
 71         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
 72     }
 73 #endif
 74 
 75     if ((ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED|EV_SIGNAL)) &&
 76         !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {
 77         if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))
 78             res = evmap_io_add_(base, ev->ev_fd, ev);
 79         else if (ev->ev_events & EV_SIGNAL)
 80             res = evmap_signal_add_(base, (int)ev->ev_fd, ev);
 81         if (res != -1)
 82             event_queue_insert_inserted(base, ev);
 83         if (res == 1) {
 84             /* evmap says we need to notify the main thread. */
 85             notify = 1;
 86             res = 0;
 87         }
 88     }
 89 
 90     /*
 91      * we should change the timeout state only if the previous event
 92      * addition succeeded.
 93      */
 94     if (res != -1 && tv != NULL) {
 95         struct timeval now;
 96         int common_timeout;
 97 #ifdef USE_REINSERT_TIMEOUT
 98         int was_common;
 99         int old_timeout_idx;
100 #endif
101 
102         /*
103          * for persistent timeout events, we remember the
104          * timeout value and re-add the event.
105          *
106          * If tv_is_absolute, this was already set.
107          */
108         if (ev->ev_closure == EV_CLOSURE_EVENT_PERSIST && !tv_is_absolute)
109             ev->ev_io_timeout = *tv;
110 
111 #ifndef USE_REINSERT_TIMEOUT
112         if (ev->ev_flags & EVLIST_TIMEOUT) {
113             event_queue_remove_timeout(base, ev);
114         }
115 #endif
116 
117         /* Check if it is active due to a timeout.  Rescheduling
118          * this timeout before the callback can be executed
119          * removes it from the active list. */
120         if ((ev->ev_flags & EVLIST_ACTIVE) &&
121             (ev->ev_res & EV_TIMEOUT)) {
122             if (ev->ev_events & EV_SIGNAL) {
123                 /* See if we are just active executing
124                  * this event in a loop
125                  */
126                 if (ev->ev_ncalls && ev->ev_pncalls) {
127                     /* Abort loop */
128                     *ev->ev_pncalls = 0;
129                 }
130             }
131 
132             event_queue_remove_active(base, event_to_event_callback(ev));
133         }
134 
135         gettime(base, &now);
136 
137         common_timeout = is_common_timeout(tv, base);
138 #ifdef USE_REINSERT_TIMEOUT
139         was_common = is_common_timeout(&ev->ev_timeout, base);
140         old_timeout_idx = COMMON_TIMEOUT_IDX(&ev->ev_timeout);
141 #endif
142 
143         if (tv_is_absolute) {
144             ev->ev_timeout = *tv;
145         } else if (common_timeout) {
146             struct timeval tmp = *tv;
147             tmp.tv_usec &= MICROSECONDS_MASK;
148             evutil_timeradd(&now, &tmp, &ev->ev_timeout);
149             ev->ev_timeout.tv_usec |=
150                 (tv->tv_usec & ~MICROSECONDS_MASK);
151         } else {
152             evutil_timeradd(&now, tv, &ev->ev_timeout);
153         }
154 
155         event_debug((
156              "event_add: event %p, timeout in %d seconds %d useconds, call %p",
157              ev, (int)tv->tv_sec, (int)tv->tv_usec, ev->ev_callback));
158 
159 #ifdef USE_REINSERT_TIMEOUT
160         event_queue_reinsert_timeout(base, ev, was_common, common_timeout, old_timeout_idx);
161 #else
162         event_queue_insert_timeout(base, ev);
163 #endif
164 
165         if (common_timeout) {
166             struct common_timeout_list *ctl =
167                 get_common_timeout_list(base, &ev->ev_timeout);
168             if (ev == TAILQ_FIRST(&ctl->events)) {
169                 common_timeout_schedule(ctl, &now, ev);
170             }
171         } else {
172             struct event* top = NULL;
173             /* See if the earliest timeout is now earlier than it
174              * was before: if so, we will need to tell the main
175              * thread to wake up earlier than it would otherwise.
176              * We double check the timeout of the top element to
177              * handle time distortions due to system suspension.
178              */
179             if (min_heap_elt_is_top_(ev))
180                 notify = 1;
181             else if ((top = min_heap_top_(&base->timeheap)) != NULL &&
182                      evutil_timercmp(&top->ev_timeout, &now, <))
183                 notify = 1;
184         }
185     }
186 
187     /* if we are not in the right thread, we need to wake up the loop */
188     if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
189         evthread_notify_base(base);
190 
191     event_debug_note_add_(ev);
192 
193     return (res);
194 }

  1 int
  2 event_del(struct event *ev)
  3 {
  4     return event_del_(ev, EVENT_DEL_AUTOBLOCK);
  5 }
  6 
  7 static int
  8 event_del_(struct event *ev, int blocking)
  9 {
 10     int res;
 11 
 12     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
 13         event_warnx("%s: event has no event_base set.", __func__);
 14         return -1;
 15     }
 16 
 17     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
 18 
 19     res = event_del_nolock_(ev, blocking);
 20 
 21     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
 22 
 23     return (res);
 24 }
 25 
 26 /** Helper for event_del: always called with th_base_lock held.
 27  *
 28  * "blocking" must be one of the EVENT_DEL_{BLOCK, NOBLOCK, AUTOBLOCK,
 29  * EVEN_IF_FINALIZING} values. See those for more information.
 30  */
 31 int
 32 event_del_nolock_(struct event *ev, int blocking)
 33 {
 34     struct event_base *base;
 35     int res = 0, notify = 0;
 36 
 37     event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p",
 38         ev, EV_SOCK_ARG(ev->ev_fd), ev->ev_callback));
 39 
 40     /* An event without a base has not been added */
 41     if (ev->ev_base == NULL)
 42         return (-1);
 43 
 44     EVENT_BASE_ASSERT_LOCKED(ev->ev_base);
 45 
 46     if (blocking != EVENT_DEL_EVEN_IF_FINALIZING) {
 47         if (ev->ev_flags & EVLIST_FINALIZING) {
 48             /* XXXX Debug */
 49             return 0;
 50         }
 51     }
 52 
 53     /* If the main thread is currently executing this event‘s callback,
 54      * and we are not the main thread, then we want to wait until the
 55      * callback is done before we start removing the event.  That way,
 56      * when this function returns, it will be safe to free the
 57      * user-supplied argument. */
 58     base = ev->ev_base;
 59 #ifndef EVENT__DISABLE_THREAD_SUPPORT
 60     if (blocking != EVENT_DEL_NOBLOCK &&
 61         base->current_event == event_to_event_callback(ev) &&
 62         !EVBASE_IN_THREAD(base) &&
 63         (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) {
 64         ++base->current_event_waiters;
 65         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
 66     }
 67 #endif
 68 
 69     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
 70 
 71     /* See if we are just active executing this event in a loop */
 72     if (ev->ev_events & EV_SIGNAL) {
 73         if (ev->ev_ncalls && ev->ev_pncalls) {
 74             /* Abort loop */
 75             *ev->ev_pncalls = 0;
 76         }
 77     }
 78 
 79     if (ev->ev_flags & EVLIST_TIMEOUT) {
 80         /* NOTE: We never need to notify the main thread because of a
 81          * deleted timeout event: all that could happen if we don‘t is
 82          * that the dispatch loop might wake up too early.  But the
 83          * point of notifying the main thread _is_ to wake up the
 84          * dispatch loop early anyway, so we wouldn‘t gain anything by
 85          * doing it.
 86          */
 87         event_queue_remove_timeout(base, ev);
 88     }
 89 
 90     if (ev->ev_flags & EVLIST_ACTIVE)
 91         event_queue_remove_active(base, event_to_event_callback(ev));
 92     else if (ev->ev_flags & EVLIST_ACTIVE_LATER)
 93         event_queue_remove_active_later(base, event_to_event_callback(ev));
 94 
 95     if (ev->ev_flags & EVLIST_INSERTED) {
 96         event_queue_remove_inserted(base, ev);
 97         if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))
 98             res = evmap_io_del_(base, ev->ev_fd, ev);
 99         else
100             res = evmap_signal_del_(base, (int)ev->ev_fd, ev);
101         if (res == 1) {
102             /* evmap says we need to notify the main thread. */
103             notify = 1;
104             res = 0;
105         }
106     }
107 
108     /* if we are not in the right thread, we need to wake up the loop */
109     if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
110         evthread_notify_base(base);
111 
112     event_debug_note_del_(ev);
113 
114     return (res);
115 }