1 /*
2  * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
3  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
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 #include "event2/event-config.h"
28 #include "evconfig-private.h"
29 
30 #ifdef _WIN32
31 #include <winsock2.h>
32 #define WIN32_LEAN_AND_MEAN
33 #include <windows.h>
34 #undef WIN32_LEAN_AND_MEAN
35 #endif
36 #include <sys/types.h>
37 #if !defined(_WIN32) && defined(EVENT__HAVE_SYS_TIME_H)
38 #include <sys/time.h>
39 #endif
40 #include <sys/queue.h>
41 #ifdef EVENT__HAVE_SYS_SOCKET_H
42 #include <sys/socket.h>
43 #endif
44 #include <stdio.h>
45 #include <stdlib.h>
46 #ifdef EVENT__HAVE_UNISTD_H
47 #include <unistd.h>
48 #endif
49 #include <ctype.h>
50 #include <errno.h>
51 #include <signal.h>
52 #include <string.h>
53 #include <time.h>
54 #include <limits.h>
55 
56 #include "event2/event.h"
57 #include "event2/event_struct.h"
58 #include "event2/event_compat.h"
59 #include "event-internal.h"
60 #include "defer-internal.h"
61 #include "evthread-internal.h"
62 #include "event2/thread.h"
63 #include "event2/util.h"
64 #include "log-internal.h"
65 #include "evmap-internal.h"
66 #include "iocp-internal.h"
67 #include "changelist-internal.h"
68 #define HT_NO_CACHE_HASH_VALUES
69 #include "ht-internal.h"
70 #include "util-internal.h"
71 
72 
73 #ifdef EVENT__HAVE_WORKING_KQUEUE
74 #include "kqueue-internal.h"
75 #endif
76 
77 #ifdef EVENT__HAVE_EVENT_PORTS
78 extern const struct eventop evportops;
79 #endif
80 #ifdef EVENT__HAVE_SELECT
81 extern const struct eventop selectops;
82 #endif
83 #ifdef EVENT__HAVE_POLL
84 extern const struct eventop pollops;
85 #endif
86 #ifdef EVENT__HAVE_EPOLL
87 extern const struct eventop epollops;
88 #endif
89 #ifdef EVENT__HAVE_WORKING_KQUEUE
90 extern const struct eventop kqops;
91 #endif
92 #ifdef EVENT__HAVE_DEVPOLL
93 extern const struct eventop devpollops;
94 #endif
95 #ifdef _WIN32
96 extern const struct eventop win32ops;
97 #endif
98 
99 /* Array of backends in order of preference. */
100 static const struct eventop *eventops[] = {
101 #ifdef EVENT__HAVE_EVENT_PORTS
102 	&evportops,
103 #endif
104 #ifdef EVENT__HAVE_WORKING_KQUEUE
105 	&kqops,
106 #endif
107 #ifdef EVENT__HAVE_EPOLL
108 	&epollops,
109 #endif
110 #ifdef EVENT__HAVE_DEVPOLL
111 	&devpollops,
112 #endif
113 #ifdef EVENT__HAVE_POLL
114 	&pollops,
115 #endif
116 #ifdef EVENT__HAVE_SELECT
117 	&selectops,
118 #endif
119 #ifdef _WIN32
120 	&win32ops,
121 #endif
122 	NULL
123 };
124 
125 /* Global state; deprecated */
126 struct event_base *event_global_current_base_ = NULL;
127 #define current_base event_global_current_base_
128 
129 /* Global state */
130 
131 static void *event_self_cbarg_ptr_ = NULL;
132 
133 /* Prototypes */
134 static void	event_queue_insert_active(struct event_base *, struct event_callback *);
135 static void	event_queue_insert_active_later(struct event_base *, struct event_callback *);
136 static void	event_queue_insert_timeout(struct event_base *, struct event *);
137 static void	event_queue_insert_inserted(struct event_base *, struct event *);
138 static void	event_queue_remove_active(struct event_base *, struct event_callback *);
139 static void	event_queue_remove_active_later(struct event_base *, struct event_callback *);
140 static void	event_queue_remove_timeout(struct event_base *, struct event *);
141 static void	event_queue_remove_inserted(struct event_base *, struct event *);
142 static void event_queue_make_later_events_active(struct event_base *base);
143 
144 static int evthread_make_base_notifiable_nolock_(struct event_base *base);
145 static int event_del_(struct event *ev, int blocking);
146 
147 #ifdef USE_REINSERT_TIMEOUT
148 /* This code seems buggy; only turn it on if we find out what the trouble is. */
149 static void	event_queue_reinsert_timeout(struct event_base *,struct event *, int was_common, int is_common, int old_timeout_idx);
150 #endif
151 
152 static int	event_haveevents(struct event_base *);
153 
154 static int	event_process_active(struct event_base *);
155 
156 static int	timeout_next(struct event_base *, struct timeval **);
157 static void	timeout_process(struct event_base *);
158 
159 static inline void	event_signal_closure(struct event_base *, struct event *ev);
160 static inline void	event_persist_closure(struct event_base *, struct event *ev);
161 
162 static int	evthread_notify_base(struct event_base *base);
163 
164 static void insert_common_timeout_inorder(struct common_timeout_list *ctl,
165     struct event *ev);
166 
167 #ifndef EVENT__DISABLE_DEBUG_MODE
168 /* These functions implement a hashtable of which 'struct event *' structures
169  * have been setup or added.  We don't want to trust the content of the struct
170  * event itself, since we're trying to work through cases where an event gets
171  * clobbered or freed.  Instead, we keep a hashtable indexed by the pointer.
172  */
173 
174 struct event_debug_entry {
175 	HT_ENTRY(event_debug_entry) node;
176 	const struct event *ptr;
177 	unsigned added : 1;
178 };
179 
180 static inline unsigned
hash_debug_entry(const struct event_debug_entry * e)181 hash_debug_entry(const struct event_debug_entry *e)
182 {
183 	/* We need to do this silliness to convince compilers that we
184 	 * honestly mean to cast e->ptr to an integer, and discard any
185 	 * part of it that doesn't fit in an unsigned.
186 	 */
187 	unsigned u = (unsigned) ((ev_uintptr_t) e->ptr);
188 	/* Our hashtable implementation is pretty sensitive to low bits,
189 	 * and every struct event is over 64 bytes in size, so we can
190 	 * just say >>6. */
191 	return (u >> 6);
192 }
193 
194 static inline int
eq_debug_entry(const struct event_debug_entry * a,const struct event_debug_entry * b)195 eq_debug_entry(const struct event_debug_entry *a,
196     const struct event_debug_entry *b)
197 {
198 	return a->ptr == b->ptr;
199 }
200 
201 int event_debug_mode_on_ = 0;
202 
203 
204 #if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE)
205 /**
206  * @brief debug mode variable which is set for any function/structure that needs
207  *        to be shared across threads (if thread support is enabled).
208  *
209  *        When and if evthreads are initialized, this variable will be evaluated,
210  *        and if set to something other than zero, this means the evthread setup
211  *        functions were called out of order.
212  *
213  *        See: "Locks and threading" in the documentation.
214  */
215 int event_debug_created_threadable_ctx_ = 0;
216 #endif
217 
218 /* Set if it's too late to enable event_debug_mode. */
219 static int event_debug_mode_too_late = 0;
220 #ifndef EVENT__DISABLE_THREAD_SUPPORT
221 static void *event_debug_map_lock_ = NULL;
222 #endif
223 static HT_HEAD(event_debug_map, event_debug_entry) global_debug_map =
224 	HT_INITIALIZER();
225 
HT_PROTOTYPE(event_debug_map,event_debug_entry,node,hash_debug_entry,eq_debug_entry)226 HT_PROTOTYPE(event_debug_map, event_debug_entry, node, hash_debug_entry,
227     eq_debug_entry)
228 HT_GENERATE(event_debug_map, event_debug_entry, node, hash_debug_entry,
229     eq_debug_entry, 0.5, mm_malloc, mm_realloc, mm_free)
230 
231 /* Macro: record that ev is now setup (that is, ready for an add) */
232 #define event_debug_note_setup_(ev) do {				\
233 	if (event_debug_mode_on_) {					\
234 		struct event_debug_entry *dent,find;			\
235 		find.ptr = (ev);					\
236 		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
237 		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
238 		if (dent) {						\
239 			dent->added = 0;				\
240 		} else {						\
241 			dent = mm_malloc(sizeof(*dent));		\
242 			if (!dent)					\
243 				event_err(1,				\
244 				    "Out of memory in debugging code");	\
245 			dent->ptr = (ev);				\
246 			dent->added = 0;				\
247 			HT_INSERT(event_debug_map, &global_debug_map, dent); \
248 		}							\
249 		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
250 	}								\
251 	event_debug_mode_too_late = 1;					\
252 	} while (0)
253 /* Macro: record that ev is no longer setup */
254 #define event_debug_note_teardown_(ev) do {				\
255 	if (event_debug_mode_on_) {					\
256 		struct event_debug_entry *dent,find;			\
257 		find.ptr = (ev);					\
258 		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
259 		dent = HT_REMOVE(event_debug_map, &global_debug_map, &find); \
260 		if (dent)						\
261 			mm_free(dent);					\
262 		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
263 	}								\
264 	event_debug_mode_too_late = 1;					\
265 	} while (0)
266 /* Macro: record that ev is now added */
267 #define event_debug_note_add_(ev)	do {				\
268 	if (event_debug_mode_on_) {					\
269 		struct event_debug_entry *dent,find;			\
270 		find.ptr = (ev);					\
271 		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
272 		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
273 		if (dent) {						\
274 			dent->added = 1;				\
275 		} else {						\
276 			event_errx(EVENT_ERR_ABORT_,			\
277 			    "%s: noting an add on a non-setup event %p" \
278 			    " (events: 0x%x, fd: "EV_SOCK_FMT		\
279 			    ", flags: 0x%x)",				\
280 			    __func__, (ev), (ev)->ev_events,		\
281 			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
282 		}							\
283 		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
284 	}								\
285 	event_debug_mode_too_late = 1;					\
286 	} while (0)
287 /* Macro: record that ev is no longer added */
288 #define event_debug_note_del_(ev) do {					\
289 	if (event_debug_mode_on_) {					\
290 		struct event_debug_entry *dent,find;			\
291 		find.ptr = (ev);					\
292 		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
293 		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
294 		if (dent) {						\
295 			dent->added = 0;				\
296 		} else {						\
297 			event_errx(EVENT_ERR_ABORT_,			\
298 			    "%s: noting a del on a non-setup event %p"	\
299 			    " (events: 0x%x, fd: "EV_SOCK_FMT		\
300 			    ", flags: 0x%x)",				\
301 			    __func__, (ev), (ev)->ev_events,		\
302 			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
303 		}							\
304 		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
305 	}								\
306 	event_debug_mode_too_late = 1;					\
307 	} while (0)
308 /* Macro: assert that ev is setup (i.e., okay to add or inspect) */
309 #define event_debug_assert_is_setup_(ev) do {				\
310 	if (event_debug_mode_on_) {					\
311 		struct event_debug_entry *dent,find;			\
312 		find.ptr = (ev);					\
313 		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
314 		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
315 		if (!dent) {						\
316 			event_errx(EVENT_ERR_ABORT_,			\
317 			    "%s called on a non-initialized event %p"	\
318 			    " (events: 0x%x, fd: "EV_SOCK_FMT\
319 			    ", flags: 0x%x)",				\
320 			    __func__, (ev), (ev)->ev_events,		\
321 			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
322 		}							\
323 		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
324 	}								\
325 	} while (0)
326 /* Macro: assert that ev is not added (i.e., okay to tear down or set
327  * up again) */
328 #define event_debug_assert_not_added_(ev) do {				\
329 	if (event_debug_mode_on_) {					\
330 		struct event_debug_entry *dent,find;			\
331 		find.ptr = (ev);					\
332 		EVLOCK_LOCK(event_debug_map_lock_, 0);			\
333 		dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
334 		if (dent && dent->added) {				\
335 			event_errx(EVENT_ERR_ABORT_,			\
336 			    "%s called on an already added event %p"	\
337 			    " (events: 0x%x, fd: "EV_SOCK_FMT", "	\
338 			    "flags: 0x%x)",				\
339 			    __func__, (ev), (ev)->ev_events,		\
340 			    EV_SOCK_ARG((ev)->ev_fd), (ev)->ev_flags);	\
341 		}							\
342 		EVLOCK_UNLOCK(event_debug_map_lock_, 0);		\
343 	}								\
344 	} while (0)
345 #else
346 #define event_debug_note_setup_(ev) \
347 	((void)0)
348 #define event_debug_note_teardown_(ev) \
349 	((void)0)
350 #define event_debug_note_add_(ev) \
351 	((void)0)
352 #define event_debug_note_del_(ev) \
353 	((void)0)
354 #define event_debug_assert_is_setup_(ev) \
355 	((void)0)
356 #define event_debug_assert_not_added_(ev) \
357 	((void)0)
358 #endif
359 
360 #define EVENT_BASE_ASSERT_LOCKED(base)		\
361 	EVLOCK_ASSERT_LOCKED((base)->th_base_lock)
362 
363 /* How often (in seconds) do we check for changes in wall clock time relative
364  * to monotonic time?  Set this to -1 for 'never.' */
365 #define CLOCK_SYNC_INTERVAL 5
366 
367 /** Set 'tp' to the current time according to 'base'.  We must hold the lock
368  * on 'base'.  If there is a cached time, return it.  Otherwise, use
369  * clock_gettime or gettimeofday as appropriate to find out the right time.
370  * Return 0 on success, -1 on failure.
371  */
372 static int
373 gettime(struct event_base *base, struct timeval *tp)
374 {
375 	EVENT_BASE_ASSERT_LOCKED(base);
376 
377 	if (base->tv_cache.tv_sec) {
378 		*tp = base->tv_cache;
379 		return (0);
380 	}
381 
382 	if (evutil_gettime_monotonic_(&base->monotonic_timer, tp) == -1) {
383 		return -1;
384 	}
385 
386 	if (base->last_updated_clock_diff + CLOCK_SYNC_INTERVAL
387 	    < tp->tv_sec) {
388 		struct timeval tv;
389 		evutil_gettimeofday(&tv,NULL);
390 		evutil_timersub(&tv, tp, &base->tv_clock_diff);
391 		base->last_updated_clock_diff = tp->tv_sec;
392 	}
393 
394 	return 0;
395 }
396 
397 int
event_base_gettimeofday_cached(struct event_base * base,struct timeval * tv)398 event_base_gettimeofday_cached(struct event_base *base, struct timeval *tv)
399 {
400 	int r;
401 	if (!base) {
402 		base = current_base;
403 		if (!current_base)
404 			return evutil_gettimeofday(tv, NULL);
405 	}
406 
407 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
408 	if (base->tv_cache.tv_sec == 0) {
409 		r = evutil_gettimeofday(tv, NULL);
410 	} else {
411 		evutil_timeradd(&base->tv_cache, &base->tv_clock_diff, tv);
412 		r = 0;
413 	}
414 	EVBASE_RELEASE_LOCK(base, th_base_lock);
415 	return r;
416 }
417 
418 /** Make 'base' have no current cached time. */
419 static inline void
clear_time_cache(struct event_base * base)420 clear_time_cache(struct event_base *base)
421 {
422 	base->tv_cache.tv_sec = 0;
423 }
424 
425 /** Replace the cached time in 'base' with the current time. */
426 static inline void
update_time_cache(struct event_base * base)427 update_time_cache(struct event_base *base)
428 {
429 	base->tv_cache.tv_sec = 0;
430 	if (!(base->flags & EVENT_BASE_FLAG_NO_CACHE_TIME))
431 	    gettime(base, &base->tv_cache);
432 }
433 
434 int
event_base_update_cache_time(struct event_base * base)435 event_base_update_cache_time(struct event_base *base)
436 {
437 
438 	if (!base) {
439 		base = current_base;
440 		if (!current_base)
441 			return -1;
442 	}
443 
444 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
445 	if (base->running_loop)
446 		update_time_cache(base);
447 	EVBASE_RELEASE_LOCK(base, th_base_lock);
448 	return 0;
449 }
450 
451 static inline struct event *
event_callback_to_event(struct event_callback * evcb)452 event_callback_to_event(struct event_callback *evcb)
453 {
454 	EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_INIT));
455 	return EVUTIL_UPCAST(evcb, struct event, ev_evcallback);
456 }
457 
458 static inline struct event_callback *
event_to_event_callback(struct event * ev)459 event_to_event_callback(struct event *ev)
460 {
461 	return &ev->ev_evcallback;
462 }
463 
464 struct event_base *
event_init(void)465 event_init(void)
466 {
467 	struct event_base *base = event_base_new_with_config(NULL);
468 
469 	if (base == NULL) {
470 		event_errx(1, "%s: Unable to construct event_base", __func__);
471 		return NULL;
472 	}
473 
474 	current_base = base;
475 
476 	return (base);
477 }
478 
479 struct event_base *
event_base_new(void)480 event_base_new(void)
481 {
482 	struct event_base *base = NULL;
483 	struct event_config *cfg = event_config_new();
484 	if (cfg) {
485 		base = event_base_new_with_config(cfg);
486 		event_config_free(cfg);
487 	}
488 	return base;
489 }
490 
491 /** Return true iff 'method' is the name of a method that 'cfg' tells us to
492  * avoid. */
493 static int
event_config_is_avoided_method(const struct event_config * cfg,const char * method)494 event_config_is_avoided_method(const struct event_config *cfg,
495     const char *method)
496 {
497 	struct event_config_entry *entry;
498 
499 	TAILQ_FOREACH(entry, &cfg->entries, next) {
500 		if (entry->avoid_method != NULL &&
501 		    strcmp(entry->avoid_method, method) == 0)
502 			return (1);
503 	}
504 
505 	return (0);
506 }
507 
508 /** Return true iff 'method' is disabled according to the environment. */
509 static int
event_is_method_disabled(const char * name)510 event_is_method_disabled(const char *name)
511 {
512 	char environment[64];
513 	int i;
514 
515 	evutil_snprintf(environment, sizeof(environment), "EVENT_NO%s", name);
516 	for (i = 8; environment[i] != '\0'; ++i)
517 		environment[i] = EVUTIL_TOUPPER_(environment[i]);
518 	/* Note that evutil_getenv_() ignores the environment entirely if
519 	 * we're setuid */
520 	return (evutil_getenv_(environment) != NULL);
521 }
522 
523 int
event_base_get_features(const struct event_base * base)524 event_base_get_features(const struct event_base *base)
525 {
526 	return base->evsel->features;
527 }
528 
529 void
event_enable_debug_mode(void)530 event_enable_debug_mode(void)
531 {
532 #ifndef EVENT__DISABLE_DEBUG_MODE
533 	if (event_debug_mode_on_)
534 		event_errx(1, "%s was called twice!", __func__);
535 	if (event_debug_mode_too_late)
536 		event_errx(1, "%s must be called *before* creating any events "
537 		    "or event_bases",__func__);
538 
539 	event_debug_mode_on_ = 1;
540 
541 	HT_INIT(event_debug_map, &global_debug_map);
542 #endif
543 }
544 
545 void
event_disable_debug_mode(void)546 event_disable_debug_mode(void)
547 {
548 #ifndef EVENT__DISABLE_DEBUG_MODE
549 	struct event_debug_entry **ent, *victim;
550 
551 	EVLOCK_LOCK(event_debug_map_lock_, 0);
552 	for (ent = HT_START(event_debug_map, &global_debug_map); ent; ) {
553 		victim = *ent;
554 		ent = HT_NEXT_RMV(event_debug_map, &global_debug_map, ent);
555 		mm_free(victim);
556 	}
557 	HT_CLEAR(event_debug_map, &global_debug_map);
558 	EVLOCK_UNLOCK(event_debug_map_lock_ , 0);
559 
560 	event_debug_mode_on_  = 0;
561 #endif
562 }
563 
564 struct event_base *
event_base_new_with_config(const struct event_config * cfg)565 event_base_new_with_config(const struct event_config *cfg)
566 {
567 	int i;
568 	struct event_base *base;
569 	int should_check_environment;
570 
571 #ifndef EVENT__DISABLE_DEBUG_MODE
572 	event_debug_mode_too_late = 1;
573 #endif
574 
575 	if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) {
576 		event_warn("%s: calloc", __func__);
577 		return NULL;
578 	}
579 
580 	if (cfg)
581 		base->flags = cfg->flags;
582 
583 	should_check_environment =
584 	    !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV));
585 
586 	{
587 		struct timeval tmp;
588 		int precise_time =
589 		    cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER);
590 		int flags;
591 		if (should_check_environment && !precise_time) {
592 			precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL;
593 			base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;
594 		}
595 		flags = precise_time ? EV_MONOT_PRECISE : 0;
596 		evutil_configure_monotonic_time_(&base->monotonic_timer, flags);
597 
598 		gettime(base, &tmp);
599 	}
600 
601 	min_heap_ctor_(&base->timeheap);
602 
603 	base->sig.ev_signal_pair[0] = -1;
604 	base->sig.ev_signal_pair[1] = -1;
605 	base->th_notify_fd[0] = -1;
606 	base->th_notify_fd[1] = -1;
607 
608 	TAILQ_INIT(&base->active_later_queue);
609 
610 	evmap_io_initmap_(&base->io);
611 	evmap_signal_initmap_(&base->sigmap);
612 	event_changelist_init_(&base->changelist);
613 
614 	base->evbase = NULL;
615 
616 	if (cfg) {
617 		memcpy(&base->max_dispatch_time,
618 		    &cfg->max_dispatch_interval, sizeof(struct timeval));
619 		base->limit_callbacks_after_prio =
620 		    cfg->limit_callbacks_after_prio;
621 	} else {
622 		base->max_dispatch_time.tv_sec = -1;
623 		base->limit_callbacks_after_prio = 1;
624 	}
625 	if (cfg && cfg->max_dispatch_callbacks >= 0) {
626 		base->max_dispatch_callbacks = cfg->max_dispatch_callbacks;
627 	} else {
628 		base->max_dispatch_callbacks = INT_MAX;
629 	}
630 	if (base->max_dispatch_callbacks == INT_MAX &&
631 	    base->max_dispatch_time.tv_sec == -1)
632 		base->limit_callbacks_after_prio = INT_MAX;
633 
634 	for (i = 0; eventops[i] && !base->evbase; i++) {
635 		if (cfg != NULL) {
636 			/* determine if this backend should be avoided */
637 			if (event_config_is_avoided_method(cfg,
638 				eventops[i]->name))
639 				continue;
640 			if ((eventops[i]->features & cfg->require_features)
641 			    != cfg->require_features)
642 				continue;
643 		}
644 
645 		/* also obey the environment variables */
646 		if (should_check_environment &&
647 		    event_is_method_disabled(eventops[i]->name))
648 			continue;
649 
650 		base->evsel = eventops[i];
651 
652 		base->evbase = base->evsel->init(base);
653 	}
654 
655 	if (base->evbase == NULL) {
656 		event_warnx("%s: no event mechanism available",
657 		    __func__);
658 		base->evsel = NULL;
659 		event_base_free(base);
660 		return NULL;
661 	}
662 
663 	if (evutil_getenv_("EVENT_SHOW_METHOD"))
664 		event_msgx("libevent using: %s", base->evsel->name);
665 
666 	/* allocate a single active event queue */
667 	if (event_base_priority_init(base, 1) < 0) {
668 		event_base_free(base);
669 		return NULL;
670 	}
671 
672 	/* prepare for threading */
673 
674 #if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE)
675 	event_debug_created_threadable_ctx_ = 1;
676 #endif
677 
678 #ifndef EVENT__DISABLE_THREAD_SUPPORT
679 	if (EVTHREAD_LOCKING_ENABLED() &&
680 	    (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) {
681 		int r;
682 		EVTHREAD_ALLOC_LOCK(base->th_base_lock, 0);
683 		EVTHREAD_ALLOC_COND(base->current_event_cond);
684 		r = evthread_make_base_notifiable(base);
685 		if (r<0) {
686 			event_warnx("%s: Unable to make base notifiable.", __func__);
687 			event_base_free(base);
688 			return NULL;
689 		}
690 	}
691 #endif
692 
693 #ifdef _WIN32
694 	if (cfg && (cfg->flags & EVENT_BASE_FLAG_STARTUP_IOCP))
695 		event_base_start_iocp_(base, cfg->n_cpus_hint);
696 #endif
697 
698 	return (base);
699 }
700 
701 int
event_base_start_iocp_(struct event_base * base,int n_cpus)702 event_base_start_iocp_(struct event_base *base, int n_cpus)
703 {
704 #ifdef _WIN32
705 	if (base->iocp)
706 		return 0;
707 	base->iocp = event_iocp_port_launch_(n_cpus);
708 	if (!base->iocp) {
709 		event_warnx("%s: Couldn't launch IOCP", __func__);
710 		return -1;
711 	}
712 	return 0;
713 #else
714 	return -1;
715 #endif
716 }
717 
718 void
event_base_stop_iocp_(struct event_base * base)719 event_base_stop_iocp_(struct event_base *base)
720 {
721 #ifdef _WIN32
722 	int rv;
723 
724 	if (!base->iocp)
725 		return;
726 	rv = event_iocp_shutdown_(base->iocp, -1);
727 	EVUTIL_ASSERT(rv >= 0);
728 	base->iocp = NULL;
729 #endif
730 }
731 
732 static int
event_base_cancel_single_callback_(struct event_base * base,struct event_callback * evcb,int run_finalizers)733 event_base_cancel_single_callback_(struct event_base *base,
734     struct event_callback *evcb,
735     int run_finalizers)
736 {
737 	int result = 0;
738 
739 	if (evcb->evcb_flags & EVLIST_INIT) {
740 		struct event *ev = event_callback_to_event(evcb);
741 		if (!(ev->ev_flags & EVLIST_INTERNAL)) {
742 			event_del_(ev, EVENT_DEL_EVEN_IF_FINALIZING);
743 			result = 1;
744 		}
745 	} else {
746 		EVBASE_ACQUIRE_LOCK(base, th_base_lock);
747 		event_callback_cancel_nolock_(base, evcb, 1);
748 		EVBASE_RELEASE_LOCK(base, th_base_lock);
749 		result = 1;
750 	}
751 
752 	if (run_finalizers && (evcb->evcb_flags & EVLIST_FINALIZING)) {
753 		switch (evcb->evcb_closure) {
754 		case EV_CLOSURE_EVENT_FINALIZE:
755 		case EV_CLOSURE_EVENT_FINALIZE_FREE: {
756 			struct event *ev = event_callback_to_event(evcb);
757 			ev->ev_evcallback.evcb_cb_union.evcb_evfinalize(ev, ev->ev_arg);
758 			if (evcb->evcb_closure == EV_CLOSURE_EVENT_FINALIZE_FREE)
759 				mm_free(ev);
760 			break;
761 		}
762 		case EV_CLOSURE_CB_FINALIZE:
763 			evcb->evcb_cb_union.evcb_cbfinalize(evcb, evcb->evcb_arg);
764 			break;
765 		default:
766 			break;
767 		}
768 	}
769 	return result;
770 }
771 
event_base_free_queues_(struct event_base * base,int run_finalizers)772 static int event_base_free_queues_(struct event_base *base, int run_finalizers)
773 {
774 	int deleted = 0, i;
775 
776 	for (i = 0; i < base->nactivequeues; ++i) {
777 		struct event_callback *evcb, *next;
778 		for (evcb = TAILQ_FIRST(&base->activequeues[i]); evcb; ) {
779 			next = TAILQ_NEXT(evcb, evcb_active_next);
780 			deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers);
781 			evcb = next;
782 		}
783 	}
784 
785 	{
786 		struct event_callback *evcb;
787 		while ((evcb = TAILQ_FIRST(&base->active_later_queue))) {
788 			deleted += event_base_cancel_single_callback_(base, evcb, run_finalizers);
789 		}
790 	}
791 
792 	return deleted;
793 }
794 
795 static void
event_base_free_(struct event_base * base,int run_finalizers)796 event_base_free_(struct event_base *base, int run_finalizers)
797 {
798 	int i, n_deleted=0;
799 	struct event *ev;
800 	/* XXXX grab the lock? If there is contention when one thread frees
801 	 * the base, then the contending thread will be very sad soon. */
802 
803 	/* event_base_free(NULL) is how to free the current_base if we
804 	 * made it with event_init and forgot to hold a reference to it. */
805 	if (base == NULL && current_base)
806 		base = current_base;
807 	/* Don't actually free NULL. */
808 	if (base == NULL) {
809 		event_warnx("%s: no base to free", __func__);
810 		return;
811 	}
812 	/* XXX(niels) - check for internal events first */
813 
814 #ifdef _WIN32
815 	event_base_stop_iocp_(base);
816 #endif
817 
818 	/* threading fds if we have them */
819 	if (base->th_notify_fd[0] != -1) {
820 		event_del(&base->th_notify);
821 		EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);
822 		if (base->th_notify_fd[1] != -1)
823 			EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);
824 		base->th_notify_fd[0] = -1;
825 		base->th_notify_fd[1] = -1;
826 		event_debug_unassign(&base->th_notify);
827 	}
828 
829 	/* Delete all non-internal events. */
830 	evmap_delete_all_(base);
831 
832 	while ((ev = min_heap_top_(&base->timeheap)) != NULL) {
833 		event_del(ev);
834 		++n_deleted;
835 	}
836 	for (i = 0; i < base->n_common_timeouts; ++i) {
837 		struct common_timeout_list *ctl =
838 		    base->common_timeout_queues[i];
839 		event_del(&ctl->timeout_event); /* Internal; doesn't count */
840 		event_debug_unassign(&ctl->timeout_event);
841 		for (ev = TAILQ_FIRST(&ctl->events); ev; ) {
842 			struct event *next = TAILQ_NEXT(ev,
843 			    ev_timeout_pos.ev_next_with_common_timeout);
844 			if (!(ev->ev_flags & EVLIST_INTERNAL)) {
845 				event_del(ev);
846 				++n_deleted;
847 			}
848 			ev = next;
849 		}
850 		mm_free(ctl);
851 	}
852 	if (base->common_timeout_queues)
853 		mm_free(base->common_timeout_queues);
854 
855 	for (;;) {
856 		/* For finalizers we can register yet another finalizer out from
857 		 * finalizer, and iff finalizer will be in active_later_queue we can
858 		 * add finalizer to activequeues, and we will have events in
859 		 * activequeues after this function returns, which is not what we want
860 		 * (we even have an assertion for this).
861 		 *
862 		 * A simple case is bufferevent with underlying (i.e. filters).
863 		 */
864 		int i = event_base_free_queues_(base, run_finalizers);
865 		if (!i) {
866 			break;
867 		}
868 		n_deleted += i;
869 	}
870 
871 	if (n_deleted)
872 		event_debug(("%s: %d events were still set in base",
873 			__func__, n_deleted));
874 
875 	while (LIST_FIRST(&base->once_events)) {
876 		struct event_once *eonce = LIST_FIRST(&base->once_events);
877 		LIST_REMOVE(eonce, next_once);
878 		mm_free(eonce);
879 	}
880 
881 	if (base->evsel != NULL && base->evsel->dealloc != NULL)
882 		base->evsel->dealloc(base);
883 
884 	for (i = 0; i < base->nactivequeues; ++i)
885 		EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i]));
886 
887 	EVUTIL_ASSERT(min_heap_empty_(&base->timeheap));
888 	min_heap_dtor_(&base->timeheap);
889 
890 	mm_free(base->activequeues);
891 
892 	evmap_io_clear_(&base->io);
893 	evmap_signal_clear_(&base->sigmap);
894 	event_changelist_freemem_(&base->changelist);
895 
896 	EVTHREAD_FREE_LOCK(base->th_base_lock, 0);
897 	EVTHREAD_FREE_COND(base->current_event_cond);
898 
899 	/* If we're freeing current_base, there won't be a current_base. */
900 	if (base == current_base)
901 		current_base = NULL;
902 	mm_free(base);
903 }
904 
905 void
event_base_free_nofinalize(struct event_base * base)906 event_base_free_nofinalize(struct event_base *base)
907 {
908 	event_base_free_(base, 0);
909 }
910 
911 void
event_base_free(struct event_base * base)912 event_base_free(struct event_base *base)
913 {
914 	event_base_free_(base, 1);
915 }
916 
917 /* Fake eventop; used to disable the backend temporarily inside event_reinit
918  * so that we can call event_del() on an event without telling the backend.
919  */
920 static int
nil_backend_del(struct event_base * b,evutil_socket_t fd,short old,short events,void * fdinfo)921 nil_backend_del(struct event_base *b, evutil_socket_t fd, short old,
922     short events, void *fdinfo)
923 {
924 	return 0;
925 }
926 const struct eventop nil_eventop = {
927 	"nil",
928 	NULL, /* init: unused. */
929 	NULL, /* add: unused. */
930 	nil_backend_del, /* del: used, so needs to be killed. */
931 	NULL, /* dispatch: unused. */
932 	NULL, /* dealloc: unused. */
933 	0, 0, 0
934 };
935 
936 /* reinitialize the event base after a fork */
937 int
event_reinit(struct event_base * base)938 event_reinit(struct event_base *base)
939 {
940 	const struct eventop *evsel;
941 	int res = 0;
942 	int was_notifiable = 0;
943 	int had_signal_added = 0;
944 
945 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
946 
947 	evsel = base->evsel;
948 
949 	/* check if this event mechanism requires reinit on the backend */
950 	if (evsel->need_reinit) {
951 		/* We're going to call event_del() on our notify events (the
952 		 * ones that tell about signals and wakeup events).  But we
953 		 * don't actually want to tell the backend to change its
954 		 * state, since it might still share some resource (a kqueue,
955 		 * an epoll fd) with the parent process, and we don't want to
956 		 * delete the fds from _that_ backend, we temporarily stub out
957 		 * the evsel with a replacement.
958 		 */
959 		base->evsel = &nil_eventop;
960 	}
961 
962 	/* We need to re-create a new signal-notification fd and a new
963 	 * thread-notification fd.  Otherwise, we'll still share those with
964 	 * the parent process, which would make any notification sent to them
965 	 * get received by one or both of the event loops, more or less at
966 	 * random.
967 	 */
968 	if (base->sig.ev_signal_added) {
969 		event_del_nolock_(&base->sig.ev_signal, EVENT_DEL_AUTOBLOCK);
970 		event_debug_unassign(&base->sig.ev_signal);
971 		memset(&base->sig.ev_signal, 0, sizeof(base->sig.ev_signal));
972 		had_signal_added = 1;
973 		base->sig.ev_signal_added = 0;
974 	}
975 	if (base->sig.ev_signal_pair[0] != -1)
976 		EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[0]);
977 	if (base->sig.ev_signal_pair[1] != -1)
978 		EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[1]);
979 	if (base->th_notify_fn != NULL) {
980 		was_notifiable = 1;
981 		base->th_notify_fn = NULL;
982 	}
983 	if (base->th_notify_fd[0] != -1) {
984 		event_del_nolock_(&base->th_notify, EVENT_DEL_AUTOBLOCK);
985 		EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);
986 		if (base->th_notify_fd[1] != -1)
987 			EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);
988 		base->th_notify_fd[0] = -1;
989 		base->th_notify_fd[1] = -1;
990 		event_debug_unassign(&base->th_notify);
991 	}
992 
993 	/* Replace the original evsel. */
994         base->evsel = evsel;
995 
996 	if (evsel->need_reinit) {
997 		/* Reconstruct the backend through brute-force, so that we do
998 		 * not share any structures with the parent process. For some
999 		 * backends, this is necessary: epoll and kqueue, for
1000 		 * instance, have events associated with a kernel
1001 		 * structure. If didn't reinitialize, we'd share that
1002 		 * structure with the parent process, and any changes made by
1003 		 * the parent would affect our backend's behavior (and vice
1004 		 * versa).
1005 		 */
1006 		if (base->evsel->dealloc != NULL)
1007 			base->evsel->dealloc(base);
1008 		base->evbase = evsel->init(base);
1009 		if (base->evbase == NULL) {
1010 			event_errx(1,
1011 			   "%s: could not reinitialize event mechanism",
1012 			   __func__);
1013 			res = -1;
1014 			goto done;
1015 		}
1016 
1017 		/* Empty out the changelist (if any): we are starting from a
1018 		 * blank slate. */
1019 		event_changelist_freemem_(&base->changelist);
1020 
1021 		/* Tell the event maps to re-inform the backend about all
1022 		 * pending events. This will make the signal notification
1023 		 * event get re-created if necessary. */
1024 		if (evmap_reinit_(base) < 0)
1025 			res = -1;
1026 	} else {
1027 		res = evsig_init_(base);
1028 		if (res == 0 && had_signal_added) {
1029 			res = event_add_nolock_(&base->sig.ev_signal, NULL, 0);
1030 			if (res == 0)
1031 				base->sig.ev_signal_added = 1;
1032 		}
1033 	}
1034 
1035 	/* If we were notifiable before, and nothing just exploded, become
1036 	 * notifiable again. */
1037 	if (was_notifiable && res == 0)
1038 		res = evthread_make_base_notifiable_nolock_(base);
1039 
1040 done:
1041 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1042 	return (res);
1043 }
1044 
1045 /* Get the monotonic time for this event_base' timer */
1046 int
event_gettime_monotonic(struct event_base * base,struct timeval * tv)1047 event_gettime_monotonic(struct event_base *base, struct timeval *tv)
1048 {
1049   int rv = -1;
1050 
1051   if (base && tv) {
1052     EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1053     rv = evutil_gettime_monotonic_(&(base->monotonic_timer), tv);
1054     EVBASE_RELEASE_LOCK(base, th_base_lock);
1055   }
1056 
1057   return rv;
1058 }
1059 
1060 const char **
event_get_supported_methods(void)1061 event_get_supported_methods(void)
1062 {
1063 	static const char **methods = NULL;
1064 	const struct eventop **method;
1065 	const char **tmp;
1066 	int i = 0, k;
1067 
1068 	/* count all methods */
1069 	for (method = &eventops[0]; *method != NULL; ++method) {
1070 		++i;
1071 	}
1072 
1073 	/* allocate one more than we need for the NULL pointer */
1074 	tmp = mm_calloc((i + 1), sizeof(char *));
1075 	if (tmp == NULL)
1076 		return (NULL);
1077 
1078 	/* populate the array with the supported methods */
1079 	for (k = 0, i = 0; eventops[k] != NULL; ++k) {
1080 		tmp[i++] = eventops[k]->name;
1081 	}
1082 	tmp[i] = NULL;
1083 
1084 	if (methods != NULL)
1085 		mm_free((char**)methods);
1086 
1087 	methods = tmp;
1088 
1089 	return (methods);
1090 }
1091 
1092 struct event_config *
event_config_new(void)1093 event_config_new(void)
1094 {
1095 	struct event_config *cfg = mm_calloc(1, sizeof(*cfg));
1096 
1097 	if (cfg == NULL)
1098 		return (NULL);
1099 
1100 	TAILQ_INIT(&cfg->entries);
1101 	cfg->max_dispatch_interval.tv_sec = -1;
1102 	cfg->max_dispatch_callbacks = INT_MAX;
1103 	cfg->limit_callbacks_after_prio = 1;
1104 
1105 	return (cfg);
1106 }
1107 
1108 static void
event_config_entry_free(struct event_config_entry * entry)1109 event_config_entry_free(struct event_config_entry *entry)
1110 {
1111 	if (entry->avoid_method != NULL)
1112 		mm_free((char *)entry->avoid_method);
1113 	mm_free(entry);
1114 }
1115 
1116 void
event_config_free(struct event_config * cfg)1117 event_config_free(struct event_config *cfg)
1118 {
1119 	struct event_config_entry *entry;
1120 
1121 	while ((entry = TAILQ_FIRST(&cfg->entries)) != NULL) {
1122 		TAILQ_REMOVE(&cfg->entries, entry, next);
1123 		event_config_entry_free(entry);
1124 	}
1125 	mm_free(cfg);
1126 }
1127 
1128 int
event_config_set_flag(struct event_config * cfg,int flag)1129 event_config_set_flag(struct event_config *cfg, int flag)
1130 {
1131 	if (!cfg)
1132 		return -1;
1133 	cfg->flags |= flag;
1134 	return 0;
1135 }
1136 
1137 int
event_config_avoid_method(struct event_config * cfg,const char * method)1138 event_config_avoid_method(struct event_config *cfg, const char *method)
1139 {
1140 	struct event_config_entry *entry = mm_malloc(sizeof(*entry));
1141 	if (entry == NULL)
1142 		return (-1);
1143 
1144 	if ((entry->avoid_method = mm_strdup(method)) == NULL) {
1145 		mm_free(entry);
1146 		return (-1);
1147 	}
1148 
1149 	TAILQ_INSERT_TAIL(&cfg->entries, entry, next);
1150 
1151 	return (0);
1152 }
1153 
1154 int
event_config_require_features(struct event_config * cfg,int features)1155 event_config_require_features(struct event_config *cfg,
1156     int features)
1157 {
1158 	if (!cfg)
1159 		return (-1);
1160 	cfg->require_features = features;
1161 	return (0);
1162 }
1163 
1164 int
event_config_set_num_cpus_hint(struct event_config * cfg,int cpus)1165 event_config_set_num_cpus_hint(struct event_config *cfg, int cpus)
1166 {
1167 	if (!cfg)
1168 		return (-1);
1169 	cfg->n_cpus_hint = cpus;
1170 	return (0);
1171 }
1172 
1173 int
event_config_set_max_dispatch_interval(struct event_config * cfg,const struct timeval * max_interval,int max_callbacks,int min_priority)1174 event_config_set_max_dispatch_interval(struct event_config *cfg,
1175     const struct timeval *max_interval, int max_callbacks, int min_priority)
1176 {
1177 	if (max_interval)
1178 		memcpy(&cfg->max_dispatch_interval, max_interval,
1179 		    sizeof(struct timeval));
1180 	else
1181 		cfg->max_dispatch_interval.tv_sec = -1;
1182 	cfg->max_dispatch_callbacks =
1183 	    max_callbacks >= 0 ? max_callbacks : INT_MAX;
1184 	if (min_priority < 0)
1185 		min_priority = 0;
1186 	cfg->limit_callbacks_after_prio = min_priority;
1187 	return (0);
1188 }
1189 
1190 int
event_priority_init(int npriorities)1191 event_priority_init(int npriorities)
1192 {
1193 	return event_base_priority_init(current_base, npriorities);
1194 }
1195 
1196 int
event_base_priority_init(struct event_base * base,int npriorities)1197 event_base_priority_init(struct event_base *base, int npriorities)
1198 {
1199 	int i, r;
1200 	r = -1;
1201 
1202 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1203 
1204 	if (N_ACTIVE_CALLBACKS(base) || npriorities < 1
1205 	    || npriorities >= EVENT_MAX_PRIORITIES)
1206 		goto err;
1207 
1208 	if (npriorities == base->nactivequeues)
1209 		goto ok;
1210 
1211 	if (base->nactivequeues) {
1212 		mm_free(base->activequeues);
1213 		base->nactivequeues = 0;
1214 	}
1215 
1216 	/* Allocate our priority queues */
1217 	base->activequeues = (struct evcallback_list *)
1218 	  mm_calloc(npriorities, sizeof(struct evcallback_list));
1219 	if (base->activequeues == NULL) {
1220 		event_warn("%s: calloc", __func__);
1221 		goto err;
1222 	}
1223 	base->nactivequeues = npriorities;
1224 
1225 	for (i = 0; i < base->nactivequeues; ++i) {
1226 		TAILQ_INIT(&base->activequeues[i]);
1227 	}
1228 
1229 ok:
1230 	r = 0;
1231 err:
1232 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1233 	return (r);
1234 }
1235 
1236 int
event_base_get_npriorities(struct event_base * base)1237 event_base_get_npriorities(struct event_base *base)
1238 {
1239 
1240 	int n;
1241 	if (base == NULL)
1242 		base = current_base;
1243 
1244 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1245 	n = base->nactivequeues;
1246 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1247 	return (n);
1248 }
1249 
1250 int
event_base_get_num_events(struct event_base * base,unsigned int type)1251 event_base_get_num_events(struct event_base *base, unsigned int type)
1252 {
1253 	int r = 0;
1254 
1255 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1256 
1257 	if (type & EVENT_BASE_COUNT_ACTIVE)
1258 		r += base->event_count_active;
1259 
1260 	if (type & EVENT_BASE_COUNT_VIRTUAL)
1261 		r += base->virtual_event_count;
1262 
1263 	if (type & EVENT_BASE_COUNT_ADDED)
1264 		r += base->event_count;
1265 
1266 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1267 
1268 	return r;
1269 }
1270 
1271 int
event_base_get_max_events(struct event_base * base,unsigned int type,int clear)1272 event_base_get_max_events(struct event_base *base, unsigned int type, int clear)
1273 {
1274 	int r = 0;
1275 
1276 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1277 
1278 	if (type & EVENT_BASE_COUNT_ACTIVE) {
1279 		r += base->event_count_active_max;
1280 		if (clear)
1281 			base->event_count_active_max = 0;
1282 	}
1283 
1284 	if (type & EVENT_BASE_COUNT_VIRTUAL) {
1285 		r += base->virtual_event_count_max;
1286 		if (clear)
1287 			base->virtual_event_count_max = 0;
1288 	}
1289 
1290 	if (type & EVENT_BASE_COUNT_ADDED) {
1291 		r += base->event_count_max;
1292 		if (clear)
1293 			base->event_count_max = 0;
1294 	}
1295 
1296 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1297 
1298 	return r;
1299 }
1300 
1301 /* Returns true iff we're currently watching any events. */
1302 static int
event_haveevents(struct event_base * base)1303 event_haveevents(struct event_base *base)
1304 {
1305 	/* Caller must hold th_base_lock */
1306 	return (base->virtual_event_count > 0 || base->event_count > 0);
1307 }
1308 
1309 /* "closure" function called when processing active signal events */
1310 static inline void
event_signal_closure(struct event_base * base,struct event * ev)1311 event_signal_closure(struct event_base *base, struct event *ev)
1312 {
1313 	short ncalls;
1314 	int should_break;
1315 
1316 	/* Allows deletes to work */
1317 	ncalls = ev->ev_ncalls;
1318 	if (ncalls != 0)
1319 		ev->ev_pncalls = &ncalls;
1320 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1321 	while (ncalls) {
1322 		ncalls--;
1323 		ev->ev_ncalls = ncalls;
1324 		if (ncalls == 0)
1325 			ev->ev_pncalls = NULL;
1326 		(*ev->ev_callback)(ev->ev_fd, ev->ev_res, ev->ev_arg);
1327 
1328 		EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1329 		should_break = base->event_break;
1330 		EVBASE_RELEASE_LOCK(base, th_base_lock);
1331 
1332 		if (should_break) {
1333 			if (ncalls != 0)
1334 				ev->ev_pncalls = NULL;
1335 			return;
1336 		}
1337 	}
1338 }
1339 
1340 /* Common timeouts are special timeouts that are handled as queues rather than
1341  * in the minheap.  This is more efficient than the minheap if we happen to
1342  * know that we're going to get several thousands of timeout events all with
1343  * the same timeout value.
1344  *
1345  * Since all our timeout handling code assumes timevals can be copied,
1346  * assigned, etc, we can't use "magic pointer" to encode these common
1347  * timeouts.  Searching through a list to see if every timeout is common could
1348  * also get inefficient.  Instead, we take advantage of the fact that tv_usec
1349  * is 32 bits long, but only uses 20 of those bits (since it can never be over
1350  * 999999.)  We use the top bits to encode 4 bites of magic number, and 8 bits
1351  * of index into the event_base's aray of common timeouts.
1352  */
1353 
1354 #define MICROSECONDS_MASK       COMMON_TIMEOUT_MICROSECONDS_MASK
1355 #define COMMON_TIMEOUT_IDX_MASK 0x0ff00000
1356 #define COMMON_TIMEOUT_IDX_SHIFT 20
1357 #define COMMON_TIMEOUT_MASK     0xf0000000
1358 #define COMMON_TIMEOUT_MAGIC    0x50000000
1359 
1360 #define COMMON_TIMEOUT_IDX(tv) \
1361 	(((tv)->tv_usec & COMMON_TIMEOUT_IDX_MASK)>>COMMON_TIMEOUT_IDX_SHIFT)
1362 
1363 /** Return true iff if 'tv' is a common timeout in 'base' */
1364 static inline int
is_common_timeout(const struct timeval * tv,const struct event_base * base)1365 is_common_timeout(const struct timeval *tv,
1366     const struct event_base *base)
1367 {
1368 	int idx;
1369 	if ((tv->tv_usec & COMMON_TIMEOUT_MASK) != COMMON_TIMEOUT_MAGIC)
1370 		return 0;
1371 	idx = COMMON_TIMEOUT_IDX(tv);
1372 	return idx < base->n_common_timeouts;
1373 }
1374 
1375 /* True iff tv1 and tv2 have the same common-timeout index, or if neither
1376  * one is a common timeout. */
1377 static inline int
is_same_common_timeout(const struct timeval * tv1,const struct timeval * tv2)1378 is_same_common_timeout(const struct timeval *tv1, const struct timeval *tv2)
1379 {
1380 	return (tv1->tv_usec & ~MICROSECONDS_MASK) ==
1381 	    (tv2->tv_usec & ~MICROSECONDS_MASK);
1382 }
1383 
1384 /** Requires that 'tv' is a common timeout.  Return the corresponding
1385  * common_timeout_list. */
1386 static inline struct common_timeout_list *
get_common_timeout_list(struct event_base * base,const struct timeval * tv)1387 get_common_timeout_list(struct event_base *base, const struct timeval *tv)
1388 {
1389 	return base->common_timeout_queues[COMMON_TIMEOUT_IDX(tv)];
1390 }
1391 
1392 #if 0
1393 static inline int
1394 common_timeout_ok(const struct timeval *tv,
1395     struct event_base *base)
1396 {
1397 	const struct timeval *expect =
1398 	    &get_common_timeout_list(base, tv)->duration;
1399 	return tv->tv_sec == expect->tv_sec &&
1400 	    tv->tv_usec == expect->tv_usec;
1401 }
1402 #endif
1403 
1404 /* Add the timeout for the first event in given common timeout list to the
1405  * event_base's minheap. */
1406 static void
common_timeout_schedule(struct common_timeout_list * ctl,const struct timeval * now,struct event * head)1407 common_timeout_schedule(struct common_timeout_list *ctl,
1408     const struct timeval *now, struct event *head)
1409 {
1410 	struct timeval timeout = head->ev_timeout;
1411 	timeout.tv_usec &= MICROSECONDS_MASK;
1412 	event_add_nolock_(&ctl->timeout_event, &timeout, 1);
1413 }
1414 
1415 /* Callback: invoked when the timeout for a common timeout queue triggers.
1416  * This means that (at least) the first event in that queue should be run,
1417  * and the timeout should be rescheduled if there are more events. */
1418 static void
common_timeout_callback(evutil_socket_t fd,short what,void * arg)1419 common_timeout_callback(evutil_socket_t fd, short what, void *arg)
1420 {
1421 	struct timeval now;
1422 	struct common_timeout_list *ctl = arg;
1423 	struct event_base *base = ctl->base;
1424 	struct event *ev = NULL;
1425 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1426 	gettime(base, &now);
1427 	while (1) {
1428 		ev = TAILQ_FIRST(&ctl->events);
1429 		if (!ev || ev->ev_timeout.tv_sec > now.tv_sec ||
1430 		    (ev->ev_timeout.tv_sec == now.tv_sec &&
1431 			(ev->ev_timeout.tv_usec&MICROSECONDS_MASK) > now.tv_usec))
1432 			break;
1433 		event_del_nolock_(ev, EVENT_DEL_NOBLOCK);
1434 		event_active_nolock_(ev, EV_TIMEOUT, 1);
1435 	}
1436 	if (ev)
1437 		common_timeout_schedule(ctl, &now, ev);
1438 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1439 }
1440 
1441 #define MAX_COMMON_TIMEOUTS 256
1442 
1443 const struct timeval *
event_base_init_common_timeout(struct event_base * base,const struct timeval * duration)1444 event_base_init_common_timeout(struct event_base *base,
1445     const struct timeval *duration)
1446 {
1447 	int i;
1448 	struct timeval tv;
1449 	const struct timeval *result=NULL;
1450 	struct common_timeout_list *new_ctl;
1451 
1452 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1453 	if (duration->tv_usec > 1000000) {
1454 		memcpy(&tv, duration, sizeof(struct timeval));
1455 		if (is_common_timeout(duration, base))
1456 			tv.tv_usec &= MICROSECONDS_MASK;
1457 		tv.tv_sec += tv.tv_usec / 1000000;
1458 		tv.tv_usec %= 1000000;
1459 		duration = &tv;
1460 	}
1461 	for (i = 0; i < base->n_common_timeouts; ++i) {
1462 		const struct common_timeout_list *ctl =
1463 		    base->common_timeout_queues[i];
1464 		if (duration->tv_sec == ctl->duration.tv_sec &&
1465 		    duration->tv_usec ==
1466 		    (ctl->duration.tv_usec & MICROSECONDS_MASK)) {
1467 			EVUTIL_ASSERT(is_common_timeout(&ctl->duration, base));
1468 			result = &ctl->duration;
1469 			goto done;
1470 		}
1471 	}
1472 	if (base->n_common_timeouts == MAX_COMMON_TIMEOUTS) {
1473 		event_warnx("%s: Too many common timeouts already in use; "
1474 		    "we only support %d per event_base", __func__,
1475 		    MAX_COMMON_TIMEOUTS);
1476 		goto done;
1477 	}
1478 	if (base->n_common_timeouts_allocated == base->n_common_timeouts) {
1479 		int n = base->n_common_timeouts < 16 ? 16 :
1480 		    base->n_common_timeouts*2;
1481 		struct common_timeout_list **newqueues =
1482 		    mm_realloc(base->common_timeout_queues,
1483 			n*sizeof(struct common_timeout_queue *));
1484 		if (!newqueues) {
1485 			event_warn("%s: realloc",__func__);
1486 			goto done;
1487 		}
1488 		base->n_common_timeouts_allocated = n;
1489 		base->common_timeout_queues = newqueues;
1490 	}
1491 	new_ctl = mm_calloc(1, sizeof(struct common_timeout_list));
1492 	if (!new_ctl) {
1493 		event_warn("%s: calloc",__func__);
1494 		goto done;
1495 	}
1496 	TAILQ_INIT(&new_ctl->events);
1497 	new_ctl->duration.tv_sec = duration->tv_sec;
1498 	new_ctl->duration.tv_usec =
1499 	    duration->tv_usec | COMMON_TIMEOUT_MAGIC |
1500 	    (base->n_common_timeouts << COMMON_TIMEOUT_IDX_SHIFT);
1501 	evtimer_assign(&new_ctl->timeout_event, base,
1502 	    common_timeout_callback, new_ctl);
1503 	new_ctl->timeout_event.ev_flags |= EVLIST_INTERNAL;
1504 	event_priority_set(&new_ctl->timeout_event, 0);
1505 	new_ctl->base = base;
1506 	base->common_timeout_queues[base->n_common_timeouts++] = new_ctl;
1507 	result = &new_ctl->duration;
1508 
1509 done:
1510 	if (result)
1511 		EVUTIL_ASSERT(is_common_timeout(result, base));
1512 
1513 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1514 	return result;
1515 }
1516 
1517 /* Closure function invoked when we're activating a persistent event. */
1518 static inline void
event_persist_closure(struct event_base * base,struct event * ev)1519 event_persist_closure(struct event_base *base, struct event *ev)
1520 {
1521 	void (*evcb_callback)(evutil_socket_t, short, void *);
1522 
1523         // Other fields of *ev that must be stored before executing
1524         evutil_socket_t evcb_fd;
1525         short evcb_res;
1526         void *evcb_arg;
1527 
1528 	/* reschedule the persistent event if we have a timeout. */
1529 	if (ev->ev_io_timeout.tv_sec || ev->ev_io_timeout.tv_usec) {
1530 		/* If there was a timeout, we want it to run at an interval of
1531 		 * ev_io_timeout after the last time it was _scheduled_ for,
1532 		 * not ev_io_timeout after _now_.  If it fired for another
1533 		 * reason, though, the timeout ought to start ticking _now_. */
1534 		struct timeval run_at, relative_to, delay, now;
1535 		ev_uint32_t usec_mask = 0;
1536 		EVUTIL_ASSERT(is_same_common_timeout(&ev->ev_timeout,
1537 			&ev->ev_io_timeout));
1538 		gettime(base, &now);
1539 		if (is_common_timeout(&ev->ev_timeout, base)) {
1540 			delay = ev->ev_io_timeout;
1541 			usec_mask = delay.tv_usec & ~MICROSECONDS_MASK;
1542 			delay.tv_usec &= MICROSECONDS_MASK;
1543 			if (ev->ev_res & EV_TIMEOUT) {
1544 				relative_to = ev->ev_timeout;
1545 				relative_to.tv_usec &= MICROSECONDS_MASK;
1546 			} else {
1547 				relative_to = now;
1548 			}
1549 		} else {
1550 			delay = ev->ev_io_timeout;
1551 			if (ev->ev_res & EV_TIMEOUT) {
1552 				relative_to = ev->ev_timeout;
1553 			} else {
1554 				relative_to = now;
1555 			}
1556 		}
1557 		evutil_timeradd(&relative_to, &delay, &run_at);
1558 		if (evutil_timercmp(&run_at, &now, <)) {
1559 			/* Looks like we missed at least one invocation due to
1560 			 * a clock jump, not running the event loop for a
1561 			 * while, really slow callbacks, or
1562 			 * something. Reschedule relative to now.
1563 			 */
1564 			evutil_timeradd(&now, &delay, &run_at);
1565 		}
1566 		run_at.tv_usec |= usec_mask;
1567 		event_add_nolock_(ev, &run_at, 1);
1568 	}
1569 
1570 	// Save our callback before we release the lock
1571 	evcb_callback = ev->ev_callback;
1572         evcb_fd = ev->ev_fd;
1573         evcb_res = ev->ev_res;
1574         evcb_arg = ev->ev_arg;
1575 
1576 	// Release the lock
1577  	EVBASE_RELEASE_LOCK(base, th_base_lock);
1578 
1579 	// Execute the callback
1580         (evcb_callback)(evcb_fd, evcb_res, evcb_arg);
1581 }
1582 
1583 /*
1584   Helper for event_process_active to process all the events in a single queue,
1585   releasing the lock as we go.  This function requires that the lock be held
1586   when it's invoked.  Returns -1 if we get a signal or an event_break that
1587   means we should stop processing any active events now.  Otherwise returns
1588   the number of non-internal event_callbacks that we processed.
1589 */
1590 static int
event_process_active_single_queue(struct event_base * base,struct evcallback_list * activeq,int max_to_process,const struct timeval * endtime)1591 event_process_active_single_queue(struct event_base *base,
1592     struct evcallback_list *activeq,
1593     int max_to_process, const struct timeval *endtime)
1594 {
1595 	struct event_callback *evcb;
1596 	int count = 0;
1597 
1598 	EVUTIL_ASSERT(activeq != NULL);
1599 
1600 	for (evcb = TAILQ_FIRST(activeq); evcb; evcb = TAILQ_FIRST(activeq)) {
1601 		struct event *ev=NULL;
1602 		if (evcb->evcb_flags & EVLIST_INIT) {
1603 			ev = event_callback_to_event(evcb);
1604 
1605 			if (ev->ev_events & EV_PERSIST || ev->ev_flags & EVLIST_FINALIZING)
1606 				event_queue_remove_active(base, evcb);
1607 			else
1608 				event_del_nolock_(ev, EVENT_DEL_NOBLOCK);
1609 			event_debug((
1610 			    "event_process_active: event: %p, %s%s%scall %p",
1611 			    ev,
1612 			    ev->ev_res & EV_READ ? "EV_READ " : " ",
1613 			    ev->ev_res & EV_WRITE ? "EV_WRITE " : " ",
1614 			    ev->ev_res & EV_CLOSED ? "EV_CLOSED " : " ",
1615 			    ev->ev_callback));
1616 		} else {
1617 			event_queue_remove_active(base, evcb);
1618 			event_debug(("event_process_active: event_callback %p, "
1619 				"closure %d, call %p",
1620 				evcb, evcb->evcb_closure, evcb->evcb_cb_union.evcb_callback));
1621 		}
1622 
1623 		if (!(evcb->evcb_flags & EVLIST_INTERNAL))
1624 			++count;
1625 
1626 
1627 		base->current_event = evcb;
1628 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1629 		base->current_event_waiters = 0;
1630 #endif
1631 
1632 		switch (evcb->evcb_closure) {
1633 		case EV_CLOSURE_EVENT_SIGNAL:
1634 			EVUTIL_ASSERT(ev != NULL);
1635 			event_signal_closure(base, ev);
1636 			break;
1637 		case EV_CLOSURE_EVENT_PERSIST:
1638 			EVUTIL_ASSERT(ev != NULL);
1639 			event_persist_closure(base, ev);
1640 			break;
1641 		case EV_CLOSURE_EVENT: {
1642 			void (*evcb_callback)(evutil_socket_t, short, void *);
1643 			EVUTIL_ASSERT(ev != NULL);
1644 			evcb_callback = *ev->ev_callback;
1645 			EVBASE_RELEASE_LOCK(base, th_base_lock);
1646 			evcb_callback(ev->ev_fd, ev->ev_res, ev->ev_arg);
1647 		}
1648 		break;
1649 		case EV_CLOSURE_CB_SELF: {
1650 			void (*evcb_selfcb)(struct event_callback *, void *) = evcb->evcb_cb_union.evcb_selfcb;
1651 			EVBASE_RELEASE_LOCK(base, th_base_lock);
1652 			evcb_selfcb(evcb, evcb->evcb_arg);
1653 		}
1654 		break;
1655 		case EV_CLOSURE_EVENT_FINALIZE:
1656 		case EV_CLOSURE_EVENT_FINALIZE_FREE: {
1657 			void (*evcb_evfinalize)(struct event *, void *);
1658 			int evcb_closure = evcb->evcb_closure;
1659 			EVUTIL_ASSERT(ev != NULL);
1660 			base->current_event = NULL;
1661 			evcb_evfinalize = ev->ev_evcallback.evcb_cb_union.evcb_evfinalize;
1662 			EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_FINALIZING));
1663 			EVBASE_RELEASE_LOCK(base, th_base_lock);
1664 			evcb_evfinalize(ev, ev->ev_arg);
1665 			event_debug_note_teardown_(ev);
1666 			if (evcb_closure == EV_CLOSURE_EVENT_FINALIZE_FREE)
1667 				mm_free(ev);
1668 		}
1669 		break;
1670 		case EV_CLOSURE_CB_FINALIZE: {
1671 			void (*evcb_cbfinalize)(struct event_callback *, void *) = evcb->evcb_cb_union.evcb_cbfinalize;
1672 			base->current_event = NULL;
1673 			EVUTIL_ASSERT((evcb->evcb_flags & EVLIST_FINALIZING));
1674 			EVBASE_RELEASE_LOCK(base, th_base_lock);
1675 			evcb_cbfinalize(evcb, evcb->evcb_arg);
1676 		}
1677 		break;
1678 		default:
1679 			EVUTIL_ASSERT(0);
1680 		}
1681 
1682 		EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1683 		base->current_event = NULL;
1684 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1685 		if (base->current_event_waiters) {
1686 			base->current_event_waiters = 0;
1687 			EVTHREAD_COND_BROADCAST(base->current_event_cond);
1688 		}
1689 #endif
1690 
1691 		if (base->event_break)
1692 			return -1;
1693 		if (count >= max_to_process)
1694 			return count;
1695 		if (count && endtime) {
1696 			struct timeval now;
1697 			update_time_cache(base);
1698 			gettime(base, &now);
1699 			if (evutil_timercmp(&now, endtime, >=))
1700 				return count;
1701 		}
1702 		if (base->event_continue)
1703 			break;
1704 	}
1705 	return count;
1706 }
1707 
1708 /*
1709  * Active events are stored in priority queues.  Lower priorities are always
1710  * process before higher priorities.  Low priority events can starve high
1711  * priority ones.
1712  */
1713 
1714 static int
event_process_active(struct event_base * base)1715 event_process_active(struct event_base *base)
1716 {
1717 	/* Caller must hold th_base_lock */
1718 	struct evcallback_list *activeq = NULL;
1719 	int i, c = 0;
1720 	const struct timeval *endtime;
1721 	struct timeval tv;
1722 	const int maxcb = base->max_dispatch_callbacks;
1723 	const int limit_after_prio = base->limit_callbacks_after_prio;
1724 	if (base->max_dispatch_time.tv_sec >= 0) {
1725 		update_time_cache(base);
1726 		gettime(base, &tv);
1727 		evutil_timeradd(&base->max_dispatch_time, &tv, &tv);
1728 		endtime = &tv;
1729 	} else {
1730 		endtime = NULL;
1731 	}
1732 
1733 	for (i = 0; i < base->nactivequeues; ++i) {
1734 		if (TAILQ_FIRST(&base->activequeues[i]) != NULL) {
1735 			base->event_running_priority = i;
1736 			activeq = &base->activequeues[i];
1737 			if (i < limit_after_prio)
1738 				c = event_process_active_single_queue(base, activeq,
1739 				    INT_MAX, NULL);
1740 			else
1741 				c = event_process_active_single_queue(base, activeq,
1742 				    maxcb, endtime);
1743 			if (c < 0) {
1744 				goto done;
1745 			} else if (c > 0)
1746 				break; /* Processed a real event; do not
1747 					* consider lower-priority events */
1748 			/* If we get here, all of the events we processed
1749 			 * were internal.  Continue. */
1750 		}
1751 	}
1752 
1753 done:
1754 	base->event_running_priority = -1;
1755 
1756 	return c;
1757 }
1758 
1759 /*
1760  * Wait continuously for events.  We exit only if no events are left.
1761  */
1762 
1763 int
event_dispatch(void)1764 event_dispatch(void)
1765 {
1766 	return (event_loop(0));
1767 }
1768 
1769 int
event_base_dispatch(struct event_base * event_base)1770 event_base_dispatch(struct event_base *event_base)
1771 {
1772 	return (event_base_loop(event_base, 0));
1773 }
1774 
1775 const char *
event_base_get_method(const struct event_base * base)1776 event_base_get_method(const struct event_base *base)
1777 {
1778 	EVUTIL_ASSERT(base);
1779 	return (base->evsel->name);
1780 }
1781 
1782 /** Callback: used to implement event_base_loopexit by telling the event_base
1783  * that it's time to exit its loop. */
1784 static void
event_loopexit_cb(evutil_socket_t fd,short what,void * arg)1785 event_loopexit_cb(evutil_socket_t fd, short what, void *arg)
1786 {
1787 	struct event_base *base = arg;
1788 	base->event_gotterm = 1;
1789 }
1790 
1791 int
event_loopexit(const struct timeval * tv)1792 event_loopexit(const struct timeval *tv)
1793 {
1794 	return (event_once(-1, EV_TIMEOUT, event_loopexit_cb,
1795 		    current_base, tv));
1796 }
1797 
1798 int
event_base_loopexit(struct event_base * event_base,const struct timeval * tv)1799 event_base_loopexit(struct event_base *event_base, const struct timeval *tv)
1800 {
1801 	return (event_base_once(event_base, -1, EV_TIMEOUT, event_loopexit_cb,
1802 		    event_base, tv));
1803 }
1804 
1805 int
event_loopbreak(void)1806 event_loopbreak(void)
1807 {
1808 	return (event_base_loopbreak(current_base));
1809 }
1810 
1811 int
event_base_loopbreak(struct event_base * event_base)1812 event_base_loopbreak(struct event_base *event_base)
1813 {
1814 	int r = 0;
1815 	if (event_base == NULL)
1816 		return (-1);
1817 
1818 	EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1819 	event_base->event_break = 1;
1820 
1821 	if (EVBASE_NEED_NOTIFY(event_base)) {
1822 		r = evthread_notify_base(event_base);
1823 	} else {
1824 		r = (0);
1825 	}
1826 	EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1827 	return r;
1828 }
1829 
1830 int
event_base_loopcontinue(struct event_base * event_base)1831 event_base_loopcontinue(struct event_base *event_base)
1832 {
1833 	int r = 0;
1834 	if (event_base == NULL)
1835 		return (-1);
1836 
1837 	EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1838 	event_base->event_continue = 1;
1839 
1840 	if (EVBASE_NEED_NOTIFY(event_base)) {
1841 		r = evthread_notify_base(event_base);
1842 	} else {
1843 		r = (0);
1844 	}
1845 	EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1846 	return r;
1847 }
1848 
1849 int
event_base_got_break(struct event_base * event_base)1850 event_base_got_break(struct event_base *event_base)
1851 {
1852 	int res;
1853 	EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1854 	res = event_base->event_break;
1855 	EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1856 	return res;
1857 }
1858 
1859 int
event_base_got_exit(struct event_base * event_base)1860 event_base_got_exit(struct event_base *event_base)
1861 {
1862 	int res;
1863 	EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1864 	res = event_base->event_gotterm;
1865 	EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1866 	return res;
1867 }
1868 
1869 /* not thread safe */
1870 
1871 int
event_loop(int flags)1872 event_loop(int flags)
1873 {
1874 	return event_base_loop(current_base, flags);
1875 }
1876 
1877 int
event_base_loop(struct event_base * base,int flags)1878 event_base_loop(struct event_base *base, int flags)
1879 {
1880 	const struct eventop *evsel = base->evsel;
1881 	struct timeval tv;
1882 	struct timeval *tv_p;
1883 	int res, done, retval = 0;
1884 
1885 	/* Grab the lock.  We will release it inside evsel.dispatch, and again
1886 	 * as we invoke user callbacks. */
1887 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1888 
1889 	if (base->running_loop) {
1890 		event_warnx("%s: reentrant invocation.  Only one event_base_loop"
1891 		    " can run on each event_base at once.", __func__);
1892 		EVBASE_RELEASE_LOCK(base, th_base_lock);
1893 		return -1;
1894 	}
1895 
1896 	base->running_loop = 1;
1897 
1898 	clear_time_cache(base);
1899 
1900 	if (base->sig.ev_signal_added && base->sig.ev_n_signals_added)
1901 		evsig_set_base_(base);
1902 
1903 	done = 0;
1904 
1905 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1906 	base->th_owner_id = EVTHREAD_GET_ID();
1907 #endif
1908 
1909 	base->event_gotterm = base->event_break = 0;
1910 
1911 	while (!done) {
1912 		base->event_continue = 0;
1913 		base->n_deferreds_queued = 0;
1914 
1915 		/* Terminate the loop if we have been asked to */
1916 		if (base->event_gotterm) {
1917 			break;
1918 		}
1919 
1920 		if (base->event_break) {
1921 			break;
1922 		}
1923 
1924 		tv_p = &tv;
1925 		if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) {
1926 			timeout_next(base, &tv_p);
1927 		} else {
1928 			/*
1929 			 * if we have active events, we just poll new events
1930 			 * without waiting.
1931 			 */
1932 			evutil_timerclear(&tv);
1933 		}
1934 
1935 		/* If we have no events, we just exit */
1936 		if (0==(flags&EVLOOP_NO_EXIT_ON_EMPTY) &&
1937 		    !event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) {
1938 			event_debug(("%s: no events registered.", __func__));
1939 			retval = 1;
1940 			goto done;
1941 		}
1942 
1943 		event_queue_make_later_events_active(base);
1944 
1945 		clear_time_cache(base);
1946 
1947 		res = evsel->dispatch(base, tv_p);
1948 
1949 		if (res == -1) {
1950 			event_debug(("%s: dispatch returned unsuccessfully.",
1951 				__func__));
1952 			retval = -1;
1953 			goto done;
1954 		}
1955 
1956 		update_time_cache(base);
1957 
1958 		timeout_process(base);
1959 
1960 		if (N_ACTIVE_CALLBACKS(base)) {
1961 			int n = event_process_active(base);
1962 			if ((flags & EVLOOP_ONCE)
1963 			    && N_ACTIVE_CALLBACKS(base) == 0
1964 			    && n != 0)
1965 				done = 1;
1966 		} else if (flags & EVLOOP_NONBLOCK)
1967 			done = 1;
1968 	}
1969 	event_debug(("%s: asked to terminate loop.", __func__));
1970 
1971 done:
1972 	clear_time_cache(base);
1973 	base->running_loop = 0;
1974 
1975 	EVBASE_RELEASE_LOCK(base, th_base_lock);
1976 
1977 	return (retval);
1978 }
1979 
1980 /* One-time callback to implement event_base_once: invokes the user callback,
1981  * then deletes the allocated storage */
1982 static void
event_once_cb(evutil_socket_t fd,short events,void * arg)1983 event_once_cb(evutil_socket_t fd, short events, void *arg)
1984 {
1985 	struct event_once *eonce = arg;
1986 
1987 	(*eonce->cb)(fd, events, eonce->arg);
1988 	EVBASE_ACQUIRE_LOCK(eonce->ev.ev_base, th_base_lock);
1989 	LIST_REMOVE(eonce, next_once);
1990 	EVBASE_RELEASE_LOCK(eonce->ev.ev_base, th_base_lock);
1991 	event_debug_unassign(&eonce->ev);
1992 	mm_free(eonce);
1993 }
1994 
1995 /* not threadsafe, event scheduled once. */
1996 int
event_once(evutil_socket_t fd,short events,void (* callback)(evutil_socket_t,short,void *),void * arg,const struct timeval * tv)1997 event_once(evutil_socket_t fd, short events,
1998     void (*callback)(evutil_socket_t, short, void *),
1999     void *arg, const struct timeval *tv)
2000 {
2001 	return event_base_once(current_base, fd, events, callback, arg, tv);
2002 }
2003 
2004 /* Schedules an event once */
2005 int
event_base_once(struct event_base * base,evutil_socket_t fd,short events,void (* callback)(evutil_socket_t,short,void *),void * arg,const struct timeval * tv)2006 event_base_once(struct event_base *base, evutil_socket_t fd, short events,
2007     void (*callback)(evutil_socket_t, short, void *),
2008     void *arg, const struct timeval *tv)
2009 {
2010 	struct event_once *eonce;
2011 	int res = 0;
2012 	int activate = 0;
2013 
2014 	/* We cannot support signals that just fire once, or persistent
2015 	 * events. */
2016 	if (events & (EV_SIGNAL|EV_PERSIST))
2017 		return (-1);
2018 
2019 	if ((eonce = mm_calloc(1, sizeof(struct event_once))) == NULL)
2020 		return (-1);
2021 
2022 	eonce->cb = callback;
2023 	eonce->arg = arg;
2024 
2025 	if ((events & (EV_TIMEOUT|EV_SIGNAL|EV_READ|EV_WRITE|EV_CLOSED)) == EV_TIMEOUT) {
2026 		evtimer_assign(&eonce->ev, base, event_once_cb, eonce);
2027 
2028 		if (tv == NULL || ! evutil_timerisset(tv)) {
2029 			/* If the event is going to become active immediately,
2030 			 * don't put it on the timeout queue.  This is one
2031 			 * idiom for scheduling a callback, so let's make
2032 			 * it fast (and order-preserving). */
2033 			activate = 1;
2034 		}
2035 	} else if (events & (EV_READ|EV_WRITE|EV_CLOSED)) {
2036 		events &= EV_READ|EV_WRITE|EV_CLOSED;
2037 
2038 		event_assign(&eonce->ev, base, fd, events, event_once_cb, eonce);
2039 	} else {
2040 		/* Bad event combination */
2041 		mm_free(eonce);
2042 		return (-1);
2043 	}
2044 
2045 	if (res == 0) {
2046 		EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2047 		if (activate)
2048 			event_active_nolock_(&eonce->ev, EV_TIMEOUT, 1);
2049 		else
2050 			res = event_add_nolock_(&eonce->ev, tv, 0);
2051 
2052 		if (res != 0) {
2053 			mm_free(eonce);
2054 			return (res);
2055 		} else {
2056 			LIST_INSERT_HEAD(&base->once_events, eonce, next_once);
2057 		}
2058 		EVBASE_RELEASE_LOCK(base, th_base_lock);
2059 	}
2060 
2061 	return (0);
2062 }
2063 
2064 int
event_assign(struct event * ev,struct event_base * base,evutil_socket_t fd,short events,void (* callback)(evutil_socket_t,short,void *),void * arg)2065 event_assign(struct event *ev, struct event_base *base, evutil_socket_t fd, short events, void (*callback)(evutil_socket_t, short, void *), void *arg)
2066 {
2067 	if (!base)
2068 		base = current_base;
2069 	if (arg == &event_self_cbarg_ptr_)
2070 		arg = ev;
2071 
2072 	event_debug_assert_not_added_(ev);
2073 
2074 	ev->ev_base = base;
2075 
2076 	ev->ev_callback = callback;
2077 	ev->ev_arg = arg;
2078 	ev->ev_fd = fd;
2079 	ev->ev_events = events;
2080 	ev->ev_res = 0;
2081 	ev->ev_flags = EVLIST_INIT;
2082 	ev->ev_ncalls = 0;
2083 	ev->ev_pncalls = NULL;
2084 
2085 	if (events & EV_SIGNAL) {
2086 		if ((events & (EV_READ|EV_WRITE|EV_CLOSED)) != 0) {
2087 			event_warnx("%s: EV_SIGNAL is not compatible with "
2088 			    "EV_READ, EV_WRITE or EV_CLOSED", __func__);
2089 			return -1;
2090 		}
2091 		ev->ev_closure = EV_CLOSURE_EVENT_SIGNAL;
2092 	} else {
2093 		if (events & EV_PERSIST) {
2094 			evutil_timerclear(&ev->ev_io_timeout);
2095 			ev->ev_closure = EV_CLOSURE_EVENT_PERSIST;
2096 		} else {
2097 			ev->ev_closure = EV_CLOSURE_EVENT;
2098 		}
2099 	}
2100 
2101 	min_heap_elem_init_(ev);
2102 
2103 	if (base != NULL) {
2104 		/* by default, we put new events into the middle priority */
2105 		ev->ev_pri = base->nactivequeues / 2;
2106 	}
2107 
2108 	event_debug_note_setup_(ev);
2109 
2110 	return 0;
2111 }
2112 
2113 int
event_base_set(struct event_base * base,struct event * ev)2114 event_base_set(struct event_base *base, struct event *ev)
2115 {
2116 	/* Only innocent events may be assigned to a different base */
2117 	if (ev->ev_flags != EVLIST_INIT)
2118 		return (-1);
2119 
2120 	event_debug_assert_is_setup_(ev);
2121 
2122 	ev->ev_base = base;
2123 	ev->ev_pri = base->nactivequeues/2;
2124 
2125 	return (0);
2126 }
2127 
2128 void
event_set(struct event * ev,evutil_socket_t fd,short events,void (* callback)(evutil_socket_t,short,void *),void * arg)2129 event_set(struct event *ev, evutil_socket_t fd, short events,
2130 	  void (*callback)(evutil_socket_t, short, void *), void *arg)
2131 {
2132 	int r;
2133 	r = event_assign(ev, current_base, fd, events, callback, arg);
2134 	EVUTIL_ASSERT(r == 0);
2135 }
2136 
2137 void *
event_self_cbarg(void)2138 event_self_cbarg(void)
2139 {
2140 	return &event_self_cbarg_ptr_;
2141 }
2142 
2143 struct event *
event_base_get_running_event(struct event_base * base)2144 event_base_get_running_event(struct event_base *base)
2145 {
2146 	struct event *ev = NULL;
2147 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2148 	if (EVBASE_IN_THREAD(base)) {
2149 		struct event_callback *evcb = base->current_event;
2150 		if (evcb->evcb_flags & EVLIST_INIT)
2151 			ev = event_callback_to_event(evcb);
2152 	}
2153 	EVBASE_RELEASE_LOCK(base, th_base_lock);
2154 	return ev;
2155 }
2156 
2157 struct event *
event_new(struct event_base * base,evutil_socket_t fd,short events,void (* cb)(evutil_socket_t,short,void *),void * arg)2158 event_new(struct event_base *base, evutil_socket_t fd, short events, void (*cb)(evutil_socket_t, short, void *), void *arg)
2159 {
2160 	struct event *ev;
2161 	ev = mm_malloc(sizeof(struct event));
2162 	if (ev == NULL)
2163 		return (NULL);
2164 	if (event_assign(ev, base, fd, events, cb, arg) < 0) {
2165 		mm_free(ev);
2166 		return (NULL);
2167 	}
2168 
2169 	return (ev);
2170 }
2171 
2172 void
event_free(struct event * ev)2173 event_free(struct event *ev)
2174 {
2175 	/* This is disabled, so that events which have been finalized be a
2176 	 * valid target for event_free(). That's */
2177 	// event_debug_assert_is_setup_(ev);
2178 
2179 	/* make sure that this event won't be coming back to haunt us. */
2180 	event_del(ev);
2181 	event_debug_note_teardown_(ev);
2182 	mm_free(ev);
2183 
2184 }
2185 
2186 void
event_debug_unassign(struct event * ev)2187 event_debug_unassign(struct event *ev)
2188 {
2189 	event_debug_assert_not_added_(ev);
2190 	event_debug_note_teardown_(ev);
2191 
2192 	ev->ev_flags &= ~EVLIST_INIT;
2193 }
2194 
2195 #define EVENT_FINALIZE_FREE_ 0x10000
2196 static int
event_finalize_nolock_(struct event_base * base,unsigned flags,struct event * ev,event_finalize_callback_fn cb)2197 event_finalize_nolock_(struct event_base *base, unsigned flags, struct event *ev, event_finalize_callback_fn cb)
2198 {
2199 	ev_uint8_t closure = (flags & EVENT_FINALIZE_FREE_) ?
2200 	    EV_CLOSURE_EVENT_FINALIZE_FREE : EV_CLOSURE_EVENT_FINALIZE;
2201 
2202 	event_del_nolock_(ev, EVENT_DEL_NOBLOCK);
2203 	ev->ev_closure = closure;
2204 	ev->ev_evcallback.evcb_cb_union.evcb_evfinalize = cb;
2205 	event_active_nolock_(ev, EV_FINALIZE, 1);
2206 	ev->ev_flags |= EVLIST_FINALIZING;
2207 	return 0;
2208 }
2209 
2210 static int
event_finalize_impl_(unsigned flags,struct event * ev,event_finalize_callback_fn cb)2211 event_finalize_impl_(unsigned flags, struct event *ev, event_finalize_callback_fn cb)
2212 {
2213 	int r;
2214 	struct event_base *base = ev->ev_base;
2215 	if (EVUTIL_FAILURE_CHECK(!base)) {
2216 		event_warnx("%s: event has no event_base set.", __func__);
2217 		return -1;
2218 	}
2219 
2220 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2221 	r = event_finalize_nolock_(base, flags, ev, cb);
2222 	EVBASE_RELEASE_LOCK(base, th_base_lock);
2223 	return r;
2224 }
2225 
2226 int
event_finalize(unsigned flags,struct event * ev,event_finalize_callback_fn cb)2227 event_finalize(unsigned flags, struct event *ev, event_finalize_callback_fn cb)
2228 {
2229 	return event_finalize_impl_(flags, ev, cb);
2230 }
2231 
2232 int
event_free_finalize(unsigned flags,struct event * ev,event_finalize_callback_fn cb)2233 event_free_finalize(unsigned flags, struct event *ev, event_finalize_callback_fn cb)
2234 {
2235 	return event_finalize_impl_(flags|EVENT_FINALIZE_FREE_, ev, cb);
2236 }
2237 
2238 void
event_callback_finalize_nolock_(struct event_base * base,unsigned flags,struct event_callback * evcb,void (* cb)(struct event_callback *,void *))2239 event_callback_finalize_nolock_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *))
2240 {
2241 	struct event *ev = NULL;
2242 	if (evcb->evcb_flags & EVLIST_INIT) {
2243 		ev = event_callback_to_event(evcb);
2244 		event_del_nolock_(ev, EVENT_DEL_NOBLOCK);
2245 	} else {
2246 		event_callback_cancel_nolock_(base, evcb, 0); /*XXX can this fail?*/
2247 	}
2248 
2249 	evcb->evcb_closure = EV_CLOSURE_CB_FINALIZE;
2250 	evcb->evcb_cb_union.evcb_cbfinalize = cb;
2251 	event_callback_activate_nolock_(base, evcb); /* XXX can this really fail?*/
2252 	evcb->evcb_flags |= EVLIST_FINALIZING;
2253 }
2254 
2255 void
event_callback_finalize_(struct event_base * base,unsigned flags,struct event_callback * evcb,void (* cb)(struct event_callback *,void *))2256 event_callback_finalize_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *))
2257 {
2258 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2259 	event_callback_finalize_nolock_(base, flags, evcb, cb);
2260 	EVBASE_RELEASE_LOCK(base, th_base_lock);
2261 }
2262 
2263 /** Internal: Finalize all of the n_cbs callbacks in evcbs.  The provided
2264  * callback will be invoked on *one of them*, after they have *all* been
2265  * finalized. */
2266 int
event_callback_finalize_many_(struct event_base * base,int n_cbs,struct event_callback ** evcbs,void (* cb)(struct event_callback *,void *))2267 event_callback_finalize_many_(struct event_base *base, int n_cbs, struct event_callback **evcbs, void (*cb)(struct event_callback *, void *))
2268 {
2269 	int n_pending = 0, i;
2270 
2271 	if (base == NULL)
2272 		base = current_base;
2273 
2274 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2275 
2276 	event_debug(("%s: %d events finalizing", __func__, n_cbs));
2277 
2278 	/* At most one can be currently executing; the rest we just
2279 	 * cancel... But we always make sure that the finalize callback
2280 	 * runs. */
2281 	for (i = 0; i < n_cbs; ++i) {
2282 		struct event_callback *evcb = evcbs[i];
2283 		if (evcb == base->current_event) {
2284 			event_callback_finalize_nolock_(base, 0, evcb, cb);
2285 			++n_pending;
2286 		} else {
2287 			event_callback_cancel_nolock_(base, evcb, 0);
2288 		}
2289 	}
2290 
2291 	if (n_pending == 0) {
2292 		/* Just do the first one. */
2293 		event_callback_finalize_nolock_(base, 0, evcbs[0], cb);
2294 	}
2295 
2296 	EVBASE_RELEASE_LOCK(base, th_base_lock);
2297 	return 0;
2298 }
2299 
2300 /*
2301  * Set's the priority of an event - if an event is already scheduled
2302  * changing the priority is going to fail.
2303  */
2304 
2305 int
event_priority_set(struct event * ev,int pri)2306 event_priority_set(struct event *ev, int pri)
2307 {
2308 	event_debug_assert_is_setup_(ev);
2309 
2310 	if (ev->ev_flags & EVLIST_ACTIVE)
2311 		return (-1);
2312 	if (pri < 0 || pri >= ev->ev_base->nactivequeues)
2313 		return (-1);
2314 
2315 	ev->ev_pri = pri;
2316 
2317 	return (0);
2318 }
2319 
2320 /*
2321  * Checks if a specific event is pending or scheduled.
2322  */
2323 
2324 int
event_pending(const struct event * ev,short event,struct timeval * tv)2325 event_pending(const struct event *ev, short event, struct timeval *tv)
2326 {
2327 	int flags = 0;
2328 
2329 	if (EVUTIL_FAILURE_CHECK(ev->ev_base == NULL)) {
2330 		event_warnx("%s: event has no event_base set.", __func__);
2331 		return 0;
2332 	}
2333 
2334 	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2335 	event_debug_assert_is_setup_(ev);
2336 
2337 	if (ev->ev_flags & EVLIST_INSERTED)
2338 		flags |= (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED|EV_SIGNAL));
2339 	if (ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))
2340 		flags |= ev->ev_res;
2341 	if (ev->ev_flags & EVLIST_TIMEOUT)
2342 		flags |= EV_TIMEOUT;
2343 
2344 	event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_CLOSED|EV_SIGNAL);
2345 
2346 	/* See if there is a timeout that we should report */
2347 	if (tv != NULL && (flags & event & EV_TIMEOUT)) {
2348 		struct timeval tmp = ev->ev_timeout;
2349 		tmp.tv_usec &= MICROSECONDS_MASK;
2350 		/* correctly remamp to real time */
2351 		evutil_timeradd(&ev->ev_base->tv_clock_diff, &tmp, tv);
2352 	}
2353 
2354 	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2355 
2356 	return (flags & event);
2357 }
2358 
2359 int
event_initialized(const struct event * ev)2360 event_initialized(const struct event *ev)
2361 {
2362 	if (!(ev->ev_flags & EVLIST_INIT))
2363 		return 0;
2364 
2365 	return 1;
2366 }
2367 
2368 void
event_get_assignment(const struct event * event,struct event_base ** base_out,evutil_socket_t * fd_out,short * events_out,event_callback_fn * callback_out,void ** arg_out)2369 event_get_assignment(const struct event *event, struct event_base **base_out, evutil_socket_t *fd_out, short *events_out, event_callback_fn *callback_out, void **arg_out)
2370 {
2371 	event_debug_assert_is_setup_(event);
2372 
2373 	if (base_out)
2374 		*base_out = event->ev_base;
2375 	if (fd_out)
2376 		*fd_out = event->ev_fd;
2377 	if (events_out)
2378 		*events_out = event->ev_events;
2379 	if (callback_out)
2380 		*callback_out = event->ev_callback;
2381 	if (arg_out)
2382 		*arg_out = event->ev_arg;
2383 }
2384 
2385 size_t
event_get_struct_event_size(void)2386 event_get_struct_event_size(void)
2387 {
2388 	return sizeof(struct event);
2389 }
2390 
2391 evutil_socket_t
event_get_fd(const struct event * ev)2392 event_get_fd(const struct event *ev)
2393 {
2394 	event_debug_assert_is_setup_(ev);
2395 	return ev->ev_fd;
2396 }
2397 
2398 struct event_base *
event_get_base(const struct event * ev)2399 event_get_base(const struct event *ev)
2400 {
2401 	event_debug_assert_is_setup_(ev);
2402 	return ev->ev_base;
2403 }
2404 
2405 short
event_get_events(const struct event * ev)2406 event_get_events(const struct event *ev)
2407 {
2408 	event_debug_assert_is_setup_(ev);
2409 	return ev->ev_events;
2410 }
2411 
2412 event_callback_fn
event_get_callback(const struct event * ev)2413 event_get_callback(const struct event *ev)
2414 {
2415 	event_debug_assert_is_setup_(ev);
2416 	return ev->ev_callback;
2417 }
2418 
2419 void *
event_get_callback_arg(const struct event * ev)2420 event_get_callback_arg(const struct event *ev)
2421 {
2422 	event_debug_assert_is_setup_(ev);
2423 	return ev->ev_arg;
2424 }
2425 
2426 int
event_get_priority(const struct event * ev)2427 event_get_priority(const struct event *ev)
2428 {
2429 	event_debug_assert_is_setup_(ev);
2430 	return ev->ev_pri;
2431 }
2432 
2433 int
event_add(struct event * ev,const struct timeval * tv)2434 event_add(struct event *ev, const struct timeval *tv)
2435 {
2436 	int res;
2437 
2438 	if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
2439 		event_warnx("%s: event has no event_base set.", __func__);
2440 		return -1;
2441 	}
2442 
2443 	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2444 
2445 	res = event_add_nolock_(ev, tv, 0);
2446 
2447 	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2448 
2449 	return (res);
2450 }
2451 
2452 /* Helper callback: wake an event_base from another thread.  This version
2453  * works by writing a byte to one end of a socketpair, so that the event_base
2454  * listening on the other end will wake up as the corresponding event
2455  * triggers */
2456 static int
evthread_notify_base_default(struct event_base * base)2457 evthread_notify_base_default(struct event_base *base)
2458 {
2459 	char buf[1];
2460 	int r;
2461 	buf[0] = (char) 0;
2462 #ifdef _WIN32
2463 	r = send(base->th_notify_fd[1], buf, 1, 0);
2464 #else
2465 	r = write(base->th_notify_fd[1], buf, 1);
2466 #endif
2467 	return (r < 0 && ! EVUTIL_ERR_IS_EAGAIN(errno)) ? -1 : 0;
2468 }
2469 
2470 #ifdef EVENT__HAVE_EVENTFD
2471 /* Helper callback: wake an event_base from another thread.  This version
2472  * assumes that you have a working eventfd() implementation. */
2473 static int
evthread_notify_base_eventfd(struct event_base * base)2474 evthread_notify_base_eventfd(struct event_base *base)
2475 {
2476 	ev_uint64_t msg = 1;
2477 	int r;
2478 	do {
2479 		r = write(base->th_notify_fd[0], (void*) &msg, sizeof(msg));
2480 	} while (r < 0 && errno == EAGAIN);
2481 
2482 	return (r < 0) ? -1 : 0;
2483 }
2484 #endif
2485 
2486 
2487 /** Tell the thread currently running the event_loop for base (if any) that it
2488  * needs to stop waiting in its dispatch function (if it is) and process all
2489  * active callbacks. */
2490 static int
evthread_notify_base(struct event_base * base)2491 evthread_notify_base(struct event_base *base)
2492 {
2493 	EVENT_BASE_ASSERT_LOCKED(base);
2494 	if (!base->th_notify_fn)
2495 		return -1;
2496 	if (base->is_notify_pending)
2497 		return 0;
2498 	base->is_notify_pending = 1;
2499 	return base->th_notify_fn(base);
2500 }
2501 
2502 /* Implementation function to remove a timeout on a currently pending event.
2503  */
2504 int
event_remove_timer_nolock_(struct event * ev)2505 event_remove_timer_nolock_(struct event *ev)
2506 {
2507 	struct event_base *base = ev->ev_base;
2508 
2509 	EVENT_BASE_ASSERT_LOCKED(base);
2510 	event_debug_assert_is_setup_(ev);
2511 
2512 	event_debug(("event_remove_timer_nolock: event: %p", ev));
2513 
2514 	/* If it's not pending on a timeout, we don't need to do anything. */
2515 	if (ev->ev_flags & EVLIST_TIMEOUT) {
2516 		event_queue_remove_timeout(base, ev);
2517 		evutil_timerclear(&ev->ev_.ev_io.ev_timeout);
2518 	}
2519 
2520 	return (0);
2521 }
2522 
2523 int
event_remove_timer(struct event * ev)2524 event_remove_timer(struct event *ev)
2525 {
2526 	int res;
2527 
2528 	if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
2529 		event_warnx("%s: event has no event_base set.", __func__);
2530 		return -1;
2531 	}
2532 
2533 	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2534 
2535 	res = event_remove_timer_nolock_(ev);
2536 
2537 	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2538 
2539 	return (res);
2540 }
2541 
2542 /* Implementation function to add an event.  Works just like event_add,
2543  * except: 1) it requires that we have the lock.  2) if tv_is_absolute is set,
2544  * we treat tv as an absolute time, not as an interval to add to the current
2545  * time */
2546 int
event_add_nolock_(struct event * ev,const struct timeval * tv,int tv_is_absolute)2547 event_add_nolock_(struct event *ev, const struct timeval *tv,
2548     int tv_is_absolute)
2549 {
2550 	struct event_base *base = ev->ev_base;
2551 	int res = 0;
2552 	int notify = 0;
2553 
2554 	EVENT_BASE_ASSERT_LOCKED(base);
2555 	event_debug_assert_is_setup_(ev);
2556 
2557 	event_debug((
2558 		 "event_add: event: %p (fd "EV_SOCK_FMT"), %s%s%s%scall %p",
2559 		 ev,
2560 		 EV_SOCK_ARG(ev->ev_fd),
2561 		 ev->ev_events & EV_READ ? "EV_READ " : " ",
2562 		 ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
2563 		 ev->ev_events & EV_CLOSED ? "EV_CLOSED " : " ",
2564 		 tv ? "EV_TIMEOUT " : " ",
2565 		 ev->ev_callback));
2566 
2567 	EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
2568 
2569 	if (ev->ev_flags & EVLIST_FINALIZING) {
2570 		/* XXXX debug */
2571 		return (-1);
2572 	}
2573 
2574 	/*
2575 	 * prepare for timeout insertion further below, if we get a
2576 	 * failure on any step, we should not change any state.
2577 	 */
2578 	if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
2579 		if (min_heap_reserve_(&base->timeheap,
2580 			1 + min_heap_size_(&base->timeheap)) == -1)
2581 			return (-1);  /* ENOMEM == errno */
2582 	}
2583 
2584 	/* If the main thread is currently executing a signal event's
2585 	 * callback, and we are not the main thread, then we want to wait
2586 	 * until the callback is done before we mess with the event, or else
2587 	 * we can race on ev_ncalls and ev_pncalls below. */
2588 #ifndef EVENT__DISABLE_THREAD_SUPPORT
2589 	if (base->current_event == event_to_event_callback(ev) &&
2590 	    (ev->ev_events & EV_SIGNAL)
2591 	    && !EVBASE_IN_THREAD(base)) {
2592 		++base->current_event_waiters;
2593 		EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
2594 	}
2595 #endif
2596 
2597 	if ((ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED|EV_SIGNAL)) &&
2598 	    !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {
2599 		if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))
2600 			res = evmap_io_add_(base, ev->ev_fd, ev);
2601 		else if (ev->ev_events & EV_SIGNAL)
2602 			res = evmap_signal_add_(base, (int)ev->ev_fd, ev);
2603 		if (res != -1)
2604 			event_queue_insert_inserted(base, ev);
2605 		if (res == 1) {
2606 			/* evmap says we need to notify the main thread. */
2607 			notify = 1;
2608 			res = 0;
2609 		}
2610 	}
2611 
2612 	/*
2613 	 * we should change the timeout state only if the previous event
2614 	 * addition succeeded.
2615 	 */
2616 	if (res != -1 && tv != NULL) {
2617 		struct timeval now;
2618 		int common_timeout;
2619 #ifdef USE_REINSERT_TIMEOUT
2620 		int was_common;
2621 		int old_timeout_idx;
2622 #endif
2623 
2624 		/*
2625 		 * for persistent timeout events, we remember the
2626 		 * timeout value and re-add the event.
2627 		 *
2628 		 * If tv_is_absolute, this was already set.
2629 		 */
2630 		if (ev->ev_closure == EV_CLOSURE_EVENT_PERSIST && !tv_is_absolute)
2631 			ev->ev_io_timeout = *tv;
2632 
2633 #ifndef USE_REINSERT_TIMEOUT
2634 		if (ev->ev_flags & EVLIST_TIMEOUT) {
2635 			event_queue_remove_timeout(base, ev);
2636 		}
2637 #endif
2638 
2639 		/* Check if it is active due to a timeout.  Rescheduling
2640 		 * this timeout before the callback can be executed
2641 		 * removes it from the active list. */
2642 		if ((ev->ev_flags & EVLIST_ACTIVE) &&
2643 		    (ev->ev_res & EV_TIMEOUT)) {
2644 			if (ev->ev_events & EV_SIGNAL) {
2645 				/* See if we are just active executing
2646 				 * this event in a loop
2647 				 */
2648 				if (ev->ev_ncalls && ev->ev_pncalls) {
2649 					/* Abort loop */
2650 					*ev->ev_pncalls = 0;
2651 				}
2652 			}
2653 
2654 			event_queue_remove_active(base, event_to_event_callback(ev));
2655 		}
2656 
2657 		gettime(base, &now);
2658 
2659 		common_timeout = is_common_timeout(tv, base);
2660 #ifdef USE_REINSERT_TIMEOUT
2661 		was_common = is_common_timeout(&ev->ev_timeout, base);
2662 		old_timeout_idx = COMMON_TIMEOUT_IDX(&ev->ev_timeout);
2663 #endif
2664 
2665 		if (tv_is_absolute) {
2666 			ev->ev_timeout = *tv;
2667 		} else if (common_timeout) {
2668 			struct timeval tmp = *tv;
2669 			tmp.tv_usec &= MICROSECONDS_MASK;
2670 			evutil_timeradd(&now, &tmp, &ev->ev_timeout);
2671 			ev->ev_timeout.tv_usec |=
2672 			    (tv->tv_usec & ~MICROSECONDS_MASK);
2673 		} else {
2674 			evutil_timeradd(&now, tv, &ev->ev_timeout);
2675 		}
2676 
2677 		event_debug((
2678 			 "event_add: event %p, timeout in %d seconds %d useconds, call %p",
2679 			 ev, (int)tv->tv_sec, (int)tv->tv_usec, ev->ev_callback));
2680 
2681 #ifdef USE_REINSERT_TIMEOUT
2682 		event_queue_reinsert_timeout(base, ev, was_common, common_timeout, old_timeout_idx);
2683 #else
2684 		event_queue_insert_timeout(base, ev);
2685 #endif
2686 
2687 		if (common_timeout) {
2688 			struct common_timeout_list *ctl =
2689 			    get_common_timeout_list(base, &ev->ev_timeout);
2690 			if (ev == TAILQ_FIRST(&ctl->events)) {
2691 				common_timeout_schedule(ctl, &now, ev);
2692 			}
2693 		} else {
2694 			struct event* top = NULL;
2695 			/* See if the earliest timeout is now earlier than it
2696 			 * was before: if so, we will need to tell the main
2697 			 * thread to wake up earlier than it would otherwise.
2698 			 * We double check the timeout of the top element to
2699 			 * handle time distortions due to system suspension.
2700 			 */
2701 			if (min_heap_elt_is_top_(ev))
2702 				notify = 1;
2703 			else if ((top = min_heap_top_(&base->timeheap)) != NULL &&
2704 					 evutil_timercmp(&top->ev_timeout, &now, <))
2705 				notify = 1;
2706 		}
2707 	}
2708 
2709 	/* if we are not in the right thread, we need to wake up the loop */
2710 	if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
2711 		evthread_notify_base(base);
2712 
2713 	event_debug_note_add_(ev);
2714 
2715 	return (res);
2716 }
2717 
2718 static int
event_del_(struct event * ev,int blocking)2719 event_del_(struct event *ev, int blocking)
2720 {
2721 	int res;
2722 
2723 	if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
2724 		event_warnx("%s: event has no event_base set.", __func__);
2725 		return -1;
2726 	}
2727 
2728 	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2729 
2730 	res = event_del_nolock_(ev, blocking);
2731 
2732 	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2733 
2734 	return (res);
2735 }
2736 
2737 int
event_del(struct event * ev)2738 event_del(struct event *ev)
2739 {
2740 	return event_del_(ev, EVENT_DEL_AUTOBLOCK);
2741 }
2742 
2743 int
event_del_block(struct event * ev)2744 event_del_block(struct event *ev)
2745 {
2746 	return event_del_(ev, EVENT_DEL_BLOCK);
2747 }
2748 
2749 int
event_del_noblock(struct event * ev)2750 event_del_noblock(struct event *ev)
2751 {
2752 	return event_del_(ev, EVENT_DEL_NOBLOCK);
2753 }
2754 
2755 /** Helper for event_del: always called with th_base_lock held.
2756  *
2757  * "blocking" must be one of the EVENT_DEL_{BLOCK, NOBLOCK, AUTOBLOCK,
2758  * EVEN_IF_FINALIZING} values. See those for more information.
2759  */
2760 int
event_del_nolock_(struct event * ev,int blocking)2761 event_del_nolock_(struct event *ev, int blocking)
2762 {
2763 	struct event_base *base;
2764 	int res = 0, notify = 0;
2765 
2766 	event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p",
2767 		ev, EV_SOCK_ARG(ev->ev_fd), ev->ev_callback));
2768 
2769 	/* An event without a base has not been added */
2770 	if (ev->ev_base == NULL)
2771 		return (-1);
2772 
2773 	EVENT_BASE_ASSERT_LOCKED(ev->ev_base);
2774 
2775 	if (blocking != EVENT_DEL_EVEN_IF_FINALIZING) {
2776 		if (ev->ev_flags & EVLIST_FINALIZING) {
2777 			/* XXXX Debug */
2778 			return 0;
2779 		}
2780 	}
2781 
2782 	/* If the main thread is currently executing this event's callback,
2783 	 * and we are not the main thread, then we want to wait until the
2784 	 * callback is done before we start removing the event.  That way,
2785 	 * when this function returns, it will be safe to free the
2786 	 * user-supplied argument. */
2787 	base = ev->ev_base;
2788 #ifndef EVENT__DISABLE_THREAD_SUPPORT
2789 	if (blocking != EVENT_DEL_NOBLOCK &&
2790 	    base->current_event == event_to_event_callback(ev) &&
2791 	    !EVBASE_IN_THREAD(base) &&
2792 	    (blocking == EVENT_DEL_BLOCK || !(ev->ev_events & EV_FINALIZE))) {
2793 		++base->current_event_waiters;
2794 		EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
2795 	}
2796 #endif
2797 
2798 	EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
2799 
2800 	/* See if we are just active executing this event in a loop */
2801 	if (ev->ev_events & EV_SIGNAL) {
2802 		if (ev->ev_ncalls && ev->ev_pncalls) {
2803 			/* Abort loop */
2804 			*ev->ev_pncalls = 0;
2805 		}
2806 	}
2807 
2808 	if (ev->ev_flags & EVLIST_TIMEOUT) {
2809 		/* NOTE: We never need to notify the main thread because of a
2810 		 * deleted timeout event: all that could happen if we don't is
2811 		 * that the dispatch loop might wake up too early.  But the
2812 		 * point of notifying the main thread _is_ to wake up the
2813 		 * dispatch loop early anyway, so we wouldn't gain anything by
2814 		 * doing it.
2815 		 */
2816 		event_queue_remove_timeout(base, ev);
2817 	}
2818 
2819 	if (ev->ev_flags & EVLIST_ACTIVE)
2820 		event_queue_remove_active(base, event_to_event_callback(ev));
2821 	else if (ev->ev_flags & EVLIST_ACTIVE_LATER)
2822 		event_queue_remove_active_later(base, event_to_event_callback(ev));
2823 
2824 	if (ev->ev_flags & EVLIST_INSERTED) {
2825 		event_queue_remove_inserted(base, ev);
2826 		if (ev->ev_events & (EV_READ|EV_WRITE|EV_CLOSED))
2827 			res = evmap_io_del_(base, ev->ev_fd, ev);
2828 		else
2829 			res = evmap_signal_del_(base, (int)ev->ev_fd, ev);
2830 		if (res == 1) {
2831 			/* evmap says we need to notify the main thread. */
2832 			notify = 1;
2833 			res = 0;
2834 		}
2835 	}
2836 
2837 	/* if we are not in the right thread, we need to wake up the loop */
2838 	if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
2839 		evthread_notify_base(base);
2840 
2841 	event_debug_note_del_(ev);
2842 
2843 	return (res);
2844 }
2845 
2846 void
event_active(struct event * ev,int res,short ncalls)2847 event_active(struct event *ev, int res, short ncalls)
2848 {
2849 	if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
2850 		event_warnx("%s: event has no event_base set.", __func__);
2851 		return;
2852 	}
2853 
2854 	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2855 
2856 	event_debug_assert_is_setup_(ev);
2857 
2858 	event_active_nolock_(ev, res, ncalls);
2859 
2860 	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2861 }
2862 
2863 
2864 void
event_active_nolock_(struct event * ev,int res,short ncalls)2865 event_active_nolock_(struct event *ev, int res, short ncalls)
2866 {
2867 	struct event_base *base;
2868 
2869 	event_debug(("event_active: %p (fd "EV_SOCK_FMT"), res %d, callback %p",
2870 		ev, EV_SOCK_ARG(ev->ev_fd), (int)res, ev->ev_callback));
2871 
2872 	base = ev->ev_base;
2873 	EVENT_BASE_ASSERT_LOCKED(base);
2874 
2875 	if (ev->ev_flags & EVLIST_FINALIZING) {
2876 		/* XXXX debug */
2877 		return;
2878 	}
2879 
2880 	switch ((ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {
2881 	default:
2882 	case EVLIST_ACTIVE|EVLIST_ACTIVE_LATER:
2883 		EVUTIL_ASSERT(0);
2884 		break;
2885 	case EVLIST_ACTIVE:
2886 		/* We get different kinds of events, add them together */
2887 		ev->ev_res |= res;
2888 		return;
2889 	case EVLIST_ACTIVE_LATER:
2890 		ev->ev_res |= res;
2891 		break;
2892 	case 0:
2893 		ev->ev_res = res;
2894 		break;
2895 	}
2896 
2897 	if (ev->ev_pri < base->event_running_priority)
2898 		base->event_continue = 1;
2899 
2900 	if (ev->ev_events & EV_SIGNAL) {
2901 #ifndef EVENT__DISABLE_THREAD_SUPPORT
2902 		if (base->current_event == event_to_event_callback(ev) &&
2903 		    !EVBASE_IN_THREAD(base)) {
2904 			++base->current_event_waiters;
2905 			EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
2906 		}
2907 #endif
2908 		ev->ev_ncalls = ncalls;
2909 		ev->ev_pncalls = NULL;
2910 	}
2911 
2912 	event_callback_activate_nolock_(base, event_to_event_callback(ev));
2913 }
2914 
2915 void
event_active_later_(struct event * ev,int res)2916 event_active_later_(struct event *ev, int res)
2917 {
2918 	EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2919 	event_active_later_nolock_(ev, res);
2920 	EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2921 }
2922 
2923 void
event_active_later_nolock_(struct event * ev,int res)2924 event_active_later_nolock_(struct event *ev, int res)
2925 {
2926 	struct event_base *base = ev->ev_base;
2927 	EVENT_BASE_ASSERT_LOCKED(base);
2928 
2929 	if (ev->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) {
2930 		/* We get different kinds of events, add them together */
2931 		ev->ev_res |= res;
2932 		return;
2933 	}
2934 
2935 	ev->ev_res = res;
2936 
2937 	event_callback_activate_later_nolock_(base, event_to_event_callback(ev));
2938 }
2939 
2940 int
event_callback_activate_(struct event_base * base,struct event_callback * evcb)2941 event_callback_activate_(struct event_base *base,
2942     struct event_callback *evcb)
2943 {
2944 	int r;
2945 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2946 	r = event_callback_activate_nolock_(base, evcb);
2947 	EVBASE_RELEASE_LOCK(base, th_base_lock);
2948 	return r;
2949 }
2950 
2951 int
event_callback_activate_nolock_(struct event_base * base,struct event_callback * evcb)2952 event_callback_activate_nolock_(struct event_base *base,
2953     struct event_callback *evcb)
2954 {
2955 	int r = 1;
2956 
2957 	if (evcb->evcb_flags & EVLIST_FINALIZING)
2958 		return 0;
2959 
2960 	switch (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) {
2961 	default:
2962 		EVUTIL_ASSERT(0);
2963 	case EVLIST_ACTIVE_LATER:
2964 		event_queue_remove_active_later(base, evcb);
2965 		r = 0;
2966 		break;
2967 	case EVLIST_ACTIVE:
2968 		return 0;
2969 	case 0:
2970 		break;
2971 	}
2972 
2973 	event_queue_insert_active(base, evcb);
2974 
2975 	if (EVBASE_NEED_NOTIFY(base))
2976 		evthread_notify_base(base);
2977 
2978 	return r;
2979 }
2980 
2981 int
event_callback_activate_later_nolock_(struct event_base * base,struct event_callback * evcb)2982 event_callback_activate_later_nolock_(struct event_base *base,
2983     struct event_callback *evcb)
2984 {
2985 	if (evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))
2986 		return 0;
2987 
2988 	event_queue_insert_active_later(base, evcb);
2989 	if (EVBASE_NEED_NOTIFY(base))
2990 		evthread_notify_base(base);
2991 	return 1;
2992 }
2993 
2994 void
event_callback_init_(struct event_base * base,struct event_callback * cb)2995 event_callback_init_(struct event_base *base,
2996     struct event_callback *cb)
2997 {
2998 	memset(cb, 0, sizeof(*cb));
2999 	cb->evcb_pri = base->nactivequeues - 1;
3000 }
3001 
3002 int
event_callback_cancel_(struct event_base * base,struct event_callback * evcb)3003 event_callback_cancel_(struct event_base *base,
3004     struct event_callback *evcb)
3005 {
3006 	int r;
3007 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3008 	r = event_callback_cancel_nolock_(base, evcb, 0);
3009 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3010 	return r;
3011 }
3012 
3013 int
event_callback_cancel_nolock_(struct event_base * base,struct event_callback * evcb,int even_if_finalizing)3014 event_callback_cancel_nolock_(struct event_base *base,
3015     struct event_callback *evcb, int even_if_finalizing)
3016 {
3017 	if ((evcb->evcb_flags & EVLIST_FINALIZING) && !even_if_finalizing)
3018 		return 0;
3019 
3020 	if (evcb->evcb_flags & EVLIST_INIT)
3021 		return event_del_nolock_(event_callback_to_event(evcb),
3022 		    even_if_finalizing ? EVENT_DEL_EVEN_IF_FINALIZING : EVENT_DEL_AUTOBLOCK);
3023 
3024 	switch ((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER))) {
3025 	default:
3026 	case EVLIST_ACTIVE|EVLIST_ACTIVE_LATER:
3027 		EVUTIL_ASSERT(0);
3028 		break;
3029 	case EVLIST_ACTIVE:
3030 		/* We get different kinds of events, add them together */
3031 		event_queue_remove_active(base, evcb);
3032 		return 0;
3033 	case EVLIST_ACTIVE_LATER:
3034 		event_queue_remove_active_later(base, evcb);
3035 		break;
3036 	case 0:
3037 		break;
3038 	}
3039 
3040 	return 0;
3041 }
3042 
3043 void
event_deferred_cb_init_(struct event_callback * cb,ev_uint8_t priority,deferred_cb_fn fn,void * arg)3044 event_deferred_cb_init_(struct event_callback *cb, ev_uint8_t priority, deferred_cb_fn fn, void *arg)
3045 {
3046 	memset(cb, 0, sizeof(*cb));
3047 	cb->evcb_cb_union.evcb_selfcb = fn;
3048 	cb->evcb_arg = arg;
3049 	cb->evcb_pri = priority;
3050 	cb->evcb_closure = EV_CLOSURE_CB_SELF;
3051 }
3052 
3053 void
event_deferred_cb_set_priority_(struct event_callback * cb,ev_uint8_t priority)3054 event_deferred_cb_set_priority_(struct event_callback *cb, ev_uint8_t priority)
3055 {
3056 	cb->evcb_pri = priority;
3057 }
3058 
3059 void
event_deferred_cb_cancel_(struct event_base * base,struct event_callback * cb)3060 event_deferred_cb_cancel_(struct event_base *base, struct event_callback *cb)
3061 {
3062 	if (!base)
3063 		base = current_base;
3064 	event_callback_cancel_(base, cb);
3065 }
3066 
3067 #define MAX_DEFERREDS_QUEUED 32
3068 int
event_deferred_cb_schedule_(struct event_base * base,struct event_callback * cb)3069 event_deferred_cb_schedule_(struct event_base *base, struct event_callback *cb)
3070 {
3071 	int r = 1;
3072 	if (!base)
3073 		base = current_base;
3074 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3075 	if (base->n_deferreds_queued > MAX_DEFERREDS_QUEUED) {
3076 		r = event_callback_activate_later_nolock_(base, cb);
3077 	} else {
3078 		r = event_callback_activate_nolock_(base, cb);
3079 		if (r) {
3080 			++base->n_deferreds_queued;
3081 		}
3082 	}
3083 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3084 	return r;
3085 }
3086 
3087 static int
timeout_next(struct event_base * base,struct timeval ** tv_p)3088 timeout_next(struct event_base *base, struct timeval **tv_p)
3089 {
3090 	/* Caller must hold th_base_lock */
3091 	struct timeval now;
3092 	struct event *ev;
3093 	struct timeval *tv = *tv_p;
3094 	int res = 0;
3095 
3096 	ev = min_heap_top_(&base->timeheap);
3097 
3098 	if (ev == NULL) {
3099 		/* if no time-based events are active wait for I/O */
3100 		*tv_p = NULL;
3101 		goto out;
3102 	}
3103 
3104 	if (gettime(base, &now) == -1) {
3105 		res = -1;
3106 		goto out;
3107 	}
3108 
3109 	if (evutil_timercmp(&ev->ev_timeout, &now, <=)) {
3110 		evutil_timerclear(tv);
3111 		goto out;
3112 	}
3113 
3114 	evutil_timersub(&ev->ev_timeout, &now, tv);
3115 
3116 	EVUTIL_ASSERT(tv->tv_sec >= 0);
3117 	EVUTIL_ASSERT(tv->tv_usec >= 0);
3118 	event_debug(("timeout_next: event: %p, in %d seconds, %d useconds", ev, (int)tv->tv_sec, (int)tv->tv_usec));
3119 
3120 out:
3121 	return (res);
3122 }
3123 
3124 /* Activate every event whose timeout has elapsed. */
3125 static void
timeout_process(struct event_base * base)3126 timeout_process(struct event_base *base)
3127 {
3128 	/* Caller must hold lock. */
3129 	struct timeval now;
3130 	struct event *ev;
3131 
3132 	if (min_heap_empty_(&base->timeheap)) {
3133 		return;
3134 	}
3135 
3136 	gettime(base, &now);
3137 
3138 	while ((ev = min_heap_top_(&base->timeheap))) {
3139 		if (evutil_timercmp(&ev->ev_timeout, &now, >))
3140 			break;
3141 
3142 		/* delete this event from the I/O queues */
3143 		event_del_nolock_(ev, EVENT_DEL_NOBLOCK);
3144 
3145 		event_debug(("timeout_process: event: %p, call %p",
3146 			 ev, ev->ev_callback));
3147 		event_active_nolock_(ev, EV_TIMEOUT, 1);
3148 	}
3149 }
3150 
3151 #if (EVLIST_INTERNAL >> 4) != 1
3152 #error "Mismatch for value of EVLIST_INTERNAL"
3153 #endif
3154 
3155 #ifndef MAX
3156 #define MAX(a,b) (((a)>(b))?(a):(b))
3157 #endif
3158 
3159 #define MAX_EVENT_COUNT(var, v) var = MAX(var, v)
3160 
3161 /* These are a fancy way to spell
3162      if (flags & EVLIST_INTERNAL)
3163          base->event_count--/++;
3164 */
3165 #define DECR_EVENT_COUNT(base,flags) \
3166 	((base)->event_count -= (~((flags) >> 4) & 1))
3167 #define INCR_EVENT_COUNT(base,flags) do {					\
3168 	((base)->event_count += (~((flags) >> 4) & 1));				\
3169 	MAX_EVENT_COUNT((base)->event_count_max, (base)->event_count);		\
3170 } while (0)
3171 
3172 static void
event_queue_remove_inserted(struct event_base * base,struct event * ev)3173 event_queue_remove_inserted(struct event_base *base, struct event *ev)
3174 {
3175 	EVENT_BASE_ASSERT_LOCKED(base);
3176 	if (EVUTIL_FAILURE_CHECK(!(ev->ev_flags & EVLIST_INSERTED))) {
3177 		event_errx(1, "%s: %p(fd "EV_SOCK_FMT") not on queue %x", __func__,
3178 		    ev, EV_SOCK_ARG(ev->ev_fd), EVLIST_INSERTED);
3179 		return;
3180 	}
3181 	DECR_EVENT_COUNT(base, ev->ev_flags);
3182 	ev->ev_flags &= ~EVLIST_INSERTED;
3183 }
3184 static void
event_queue_remove_active(struct event_base * base,struct event_callback * evcb)3185 event_queue_remove_active(struct event_base *base, struct event_callback *evcb)
3186 {
3187 	EVENT_BASE_ASSERT_LOCKED(base);
3188 	if (EVUTIL_FAILURE_CHECK(!(evcb->evcb_flags & EVLIST_ACTIVE))) {
3189 		event_errx(1, "%s: %p not on queue %x", __func__,
3190 			   evcb, EVLIST_ACTIVE);
3191 		return;
3192 	}
3193 	DECR_EVENT_COUNT(base, evcb->evcb_flags);
3194 	evcb->evcb_flags &= ~EVLIST_ACTIVE;
3195 	base->event_count_active--;
3196 
3197 	TAILQ_REMOVE(&base->activequeues[evcb->evcb_pri],
3198 	    evcb, evcb_active_next);
3199 }
3200 static void
event_queue_remove_active_later(struct event_base * base,struct event_callback * evcb)3201 event_queue_remove_active_later(struct event_base *base, struct event_callback *evcb)
3202 {
3203 	EVENT_BASE_ASSERT_LOCKED(base);
3204 	if (EVUTIL_FAILURE_CHECK(!(evcb->evcb_flags & EVLIST_ACTIVE_LATER))) {
3205 		event_errx(1, "%s: %p not on queue %x", __func__,
3206 			   evcb, EVLIST_ACTIVE_LATER);
3207 		return;
3208 	}
3209 	DECR_EVENT_COUNT(base, evcb->evcb_flags);
3210 	evcb->evcb_flags &= ~EVLIST_ACTIVE_LATER;
3211 	base->event_count_active--;
3212 
3213 	TAILQ_REMOVE(&base->active_later_queue, evcb, evcb_active_next);
3214 }
3215 static void
event_queue_remove_timeout(struct event_base * base,struct event * ev)3216 event_queue_remove_timeout(struct event_base *base, struct event *ev)
3217 {
3218 	EVENT_BASE_ASSERT_LOCKED(base);
3219 	if (EVUTIL_FAILURE_CHECK(!(ev->ev_flags & EVLIST_TIMEOUT))) {
3220 		event_errx(1, "%s: %p(fd "EV_SOCK_FMT") not on queue %x", __func__,
3221 		    ev, EV_SOCK_ARG(ev->ev_fd), EVLIST_TIMEOUT);
3222 		return;
3223 	}
3224 	DECR_EVENT_COUNT(base, ev->ev_flags);
3225 	ev->ev_flags &= ~EVLIST_TIMEOUT;
3226 
3227 	if (is_common_timeout(&ev->ev_timeout, base)) {
3228 		struct common_timeout_list *ctl =
3229 		    get_common_timeout_list(base, &ev->ev_timeout);
3230 		TAILQ_REMOVE(&ctl->events, ev,
3231 		    ev_timeout_pos.ev_next_with_common_timeout);
3232 	} else {
3233 		min_heap_erase_(&base->timeheap, ev);
3234 	}
3235 }
3236 
3237 #ifdef USE_REINSERT_TIMEOUT
3238 /* Remove and reinsert 'ev' into the timeout queue. */
3239 static void
event_queue_reinsert_timeout(struct event_base * base,struct event * ev,int was_common,int is_common,int old_timeout_idx)3240 event_queue_reinsert_timeout(struct event_base *base, struct event *ev,
3241     int was_common, int is_common, int old_timeout_idx)
3242 {
3243 	struct common_timeout_list *ctl;
3244 	if (!(ev->ev_flags & EVLIST_TIMEOUT)) {
3245 		event_queue_insert_timeout(base, ev);
3246 		return;
3247 	}
3248 
3249 	switch ((was_common<<1) | is_common) {
3250 	case 3: /* Changing from one common timeout to another */
3251 		ctl = base->common_timeout_queues[old_timeout_idx];
3252 		TAILQ_REMOVE(&ctl->events, ev,
3253 		    ev_timeout_pos.ev_next_with_common_timeout);
3254 		ctl = get_common_timeout_list(base, &ev->ev_timeout);
3255 		insert_common_timeout_inorder(ctl, ev);
3256 		break;
3257 	case 2: /* Was common; is no longer common */
3258 		ctl = base->common_timeout_queues[old_timeout_idx];
3259 		TAILQ_REMOVE(&ctl->events, ev,
3260 		    ev_timeout_pos.ev_next_with_common_timeout);
3261 		min_heap_push_(&base->timeheap, ev);
3262 		break;
3263 	case 1: /* Wasn't common; has become common. */
3264 		min_heap_erase_(&base->timeheap, ev);
3265 		ctl = get_common_timeout_list(base, &ev->ev_timeout);
3266 		insert_common_timeout_inorder(ctl, ev);
3267 		break;
3268 	case 0: /* was in heap; is still on heap. */
3269 		min_heap_adjust_(&base->timeheap, ev);
3270 		break;
3271 	default:
3272 		EVUTIL_ASSERT(0); /* unreachable */
3273 		break;
3274 	}
3275 }
3276 #endif
3277 
3278 /* Add 'ev' to the common timeout list in 'ev'. */
3279 static void
insert_common_timeout_inorder(struct common_timeout_list * ctl,struct event * ev)3280 insert_common_timeout_inorder(struct common_timeout_list *ctl,
3281     struct event *ev)
3282 {
3283 	struct event *e;
3284 	/* By all logic, we should just be able to append 'ev' to the end of
3285 	 * ctl->events, since the timeout on each 'ev' is set to {the common
3286 	 * timeout} + {the time when we add the event}, and so the events
3287 	 * should arrive in order of their timeeouts.  But just in case
3288 	 * there's some wacky threading issue going on, we do a search from
3289 	 * the end of 'ev' to find the right insertion point.
3290 	 */
3291 	TAILQ_FOREACH_REVERSE(e, &ctl->events,
3292 	    event_list, ev_timeout_pos.ev_next_with_common_timeout) {
3293 		/* This timercmp is a little sneaky, since both ev and e have
3294 		 * magic values in tv_usec.  Fortunately, they ought to have
3295 		 * the _same_ magic values in tv_usec.  Let's assert for that.
3296 		 */
3297 		EVUTIL_ASSERT(
3298 			is_same_common_timeout(&e->ev_timeout, &ev->ev_timeout));
3299 		if (evutil_timercmp(&ev->ev_timeout, &e->ev_timeout, >=)) {
3300 			TAILQ_INSERT_AFTER(&ctl->events, e, ev,
3301 			    ev_timeout_pos.ev_next_with_common_timeout);
3302 			return;
3303 		}
3304 	}
3305 	TAILQ_INSERT_HEAD(&ctl->events, ev,
3306 	    ev_timeout_pos.ev_next_with_common_timeout);
3307 }
3308 
3309 static void
event_queue_insert_inserted(struct event_base * base,struct event * ev)3310 event_queue_insert_inserted(struct event_base *base, struct event *ev)
3311 {
3312 	EVENT_BASE_ASSERT_LOCKED(base);
3313 
3314 	if (EVUTIL_FAILURE_CHECK(ev->ev_flags & EVLIST_INSERTED)) {
3315 		event_errx(1, "%s: %p(fd "EV_SOCK_FMT") already inserted", __func__,
3316 		    ev, EV_SOCK_ARG(ev->ev_fd));
3317 		return;
3318 	}
3319 
3320 	INCR_EVENT_COUNT(base, ev->ev_flags);
3321 
3322 	ev->ev_flags |= EVLIST_INSERTED;
3323 }
3324 
3325 static void
event_queue_insert_active(struct event_base * base,struct event_callback * evcb)3326 event_queue_insert_active(struct event_base *base, struct event_callback *evcb)
3327 {
3328 	EVENT_BASE_ASSERT_LOCKED(base);
3329 
3330 	if (evcb->evcb_flags & EVLIST_ACTIVE) {
3331 		/* Double insertion is possible for active events */
3332 		return;
3333 	}
3334 
3335 	INCR_EVENT_COUNT(base, evcb->evcb_flags);
3336 
3337 	evcb->evcb_flags |= EVLIST_ACTIVE;
3338 
3339 	base->event_count_active++;
3340 	MAX_EVENT_COUNT(base->event_count_active_max, base->event_count_active);
3341 	EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues);
3342 	TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri],
3343 	    evcb, evcb_active_next);
3344 }
3345 
3346 static void
event_queue_insert_active_later(struct event_base * base,struct event_callback * evcb)3347 event_queue_insert_active_later(struct event_base *base, struct event_callback *evcb)
3348 {
3349 	EVENT_BASE_ASSERT_LOCKED(base);
3350 	if (evcb->evcb_flags & (EVLIST_ACTIVE_LATER|EVLIST_ACTIVE)) {
3351 		/* Double insertion is possible */
3352 		return;
3353 	}
3354 
3355 	INCR_EVENT_COUNT(base, evcb->evcb_flags);
3356 	evcb->evcb_flags |= EVLIST_ACTIVE_LATER;
3357 	base->event_count_active++;
3358 	MAX_EVENT_COUNT(base->event_count_active_max, base->event_count_active);
3359 	EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues);
3360 	TAILQ_INSERT_TAIL(&base->active_later_queue, evcb, evcb_active_next);
3361 }
3362 
3363 static void
event_queue_insert_timeout(struct event_base * base,struct event * ev)3364 event_queue_insert_timeout(struct event_base *base, struct event *ev)
3365 {
3366 	EVENT_BASE_ASSERT_LOCKED(base);
3367 
3368 	if (EVUTIL_FAILURE_CHECK(ev->ev_flags & EVLIST_TIMEOUT)) {
3369 		event_errx(1, "%s: %p(fd "EV_SOCK_FMT") already on timeout", __func__,
3370 		    ev, EV_SOCK_ARG(ev->ev_fd));
3371 		return;
3372 	}
3373 
3374 	INCR_EVENT_COUNT(base, ev->ev_flags);
3375 
3376 	ev->ev_flags |= EVLIST_TIMEOUT;
3377 
3378 	if (is_common_timeout(&ev->ev_timeout, base)) {
3379 		struct common_timeout_list *ctl =
3380 		    get_common_timeout_list(base, &ev->ev_timeout);
3381 		insert_common_timeout_inorder(ctl, ev);
3382 	} else {
3383 		min_heap_push_(&base->timeheap, ev);
3384 	}
3385 }
3386 
3387 static void
event_queue_make_later_events_active(struct event_base * base)3388 event_queue_make_later_events_active(struct event_base *base)
3389 {
3390 	struct event_callback *evcb;
3391 	EVENT_BASE_ASSERT_LOCKED(base);
3392 
3393 	while ((evcb = TAILQ_FIRST(&base->active_later_queue))) {
3394 		TAILQ_REMOVE(&base->active_later_queue, evcb, evcb_active_next);
3395 		evcb->evcb_flags = (evcb->evcb_flags & ~EVLIST_ACTIVE_LATER) | EVLIST_ACTIVE;
3396 		EVUTIL_ASSERT(evcb->evcb_pri < base->nactivequeues);
3397 		TAILQ_INSERT_TAIL(&base->activequeues[evcb->evcb_pri], evcb, evcb_active_next);
3398 		base->n_deferreds_queued += (evcb->evcb_closure == EV_CLOSURE_CB_SELF);
3399 	}
3400 }
3401 
3402 /* Functions for debugging */
3403 
3404 const char *
event_get_version(void)3405 event_get_version(void)
3406 {
3407 	return (EVENT__VERSION);
3408 }
3409 
3410 ev_uint32_t
event_get_version_number(void)3411 event_get_version_number(void)
3412 {
3413 	return (EVENT__NUMERIC_VERSION);
3414 }
3415 
3416 /*
3417  * No thread-safe interface needed - the information should be the same
3418  * for all threads.
3419  */
3420 
3421 const char *
event_get_method(void)3422 event_get_method(void)
3423 {
3424 	return (current_base->evsel->name);
3425 }
3426 
3427 #ifndef EVENT__DISABLE_MM_REPLACEMENT
3428 static void *(*mm_malloc_fn_)(size_t sz) = NULL;
3429 static void *(*mm_realloc_fn_)(void *p, size_t sz) = NULL;
3430 static void (*mm_free_fn_)(void *p) = NULL;
3431 
3432 void *
event_mm_malloc_(size_t sz)3433 event_mm_malloc_(size_t sz)
3434 {
3435 	if (sz == 0)
3436 		return NULL;
3437 
3438 	if (mm_malloc_fn_)
3439 		return mm_malloc_fn_(sz);
3440 	else
3441 		return malloc(sz);
3442 }
3443 
3444 void *
event_mm_calloc_(size_t count,size_t size)3445 event_mm_calloc_(size_t count, size_t size)
3446 {
3447 	if (count == 0 || size == 0)
3448 		return NULL;
3449 
3450 	if (mm_malloc_fn_) {
3451 		size_t sz = count * size;
3452 		void *p = NULL;
3453 		if (count > EV_SIZE_MAX / size)
3454 			goto error;
3455 		p = mm_malloc_fn_(sz);
3456 		if (p)
3457 			return memset(p, 0, sz);
3458 	} else {
3459 		void *p = calloc(count, size);
3460 #ifdef _WIN32
3461 		/* Windows calloc doesn't reliably set ENOMEM */
3462 		if (p == NULL)
3463 			goto error;
3464 #endif
3465 		return p;
3466 	}
3467 
3468 error:
3469 	errno = ENOMEM;
3470 	return NULL;
3471 }
3472 
3473 char *
event_mm_strdup_(const char * str)3474 event_mm_strdup_(const char *str)
3475 {
3476 	if (!str) {
3477 		errno = EINVAL;
3478 		return NULL;
3479 	}
3480 
3481 	if (mm_malloc_fn_) {
3482 		size_t ln = strlen(str);
3483 		void *p = NULL;
3484 		if (ln == EV_SIZE_MAX)
3485 			goto error;
3486 		p = mm_malloc_fn_(ln+1);
3487 		if (p)
3488 			return memcpy(p, str, ln+1);
3489 	} else
3490 #ifdef _WIN32
3491 		return _strdup(str);
3492 #else
3493 		return strdup(str);
3494 #endif
3495 
3496 error:
3497 	errno = ENOMEM;
3498 	return NULL;
3499 }
3500 
3501 void *
event_mm_realloc_(void * ptr,size_t sz)3502 event_mm_realloc_(void *ptr, size_t sz)
3503 {
3504 	if (mm_realloc_fn_)
3505 		return mm_realloc_fn_(ptr, sz);
3506 	else
3507 		return realloc(ptr, sz);
3508 }
3509 
3510 void
event_mm_free_(void * ptr)3511 event_mm_free_(void *ptr)
3512 {
3513 	if (mm_free_fn_)
3514 		mm_free_fn_(ptr);
3515 	else
3516 		free(ptr);
3517 }
3518 
3519 void
event_set_mem_functions(void * (* malloc_fn)(size_t sz),void * (* realloc_fn)(void * ptr,size_t sz),void (* free_fn)(void * ptr))3520 event_set_mem_functions(void *(*malloc_fn)(size_t sz),
3521 			void *(*realloc_fn)(void *ptr, size_t sz),
3522 			void (*free_fn)(void *ptr))
3523 {
3524 	mm_malloc_fn_ = malloc_fn;
3525 	mm_realloc_fn_ = realloc_fn;
3526 	mm_free_fn_ = free_fn;
3527 }
3528 #endif
3529 
3530 #ifdef EVENT__HAVE_EVENTFD
3531 static void
evthread_notify_drain_eventfd(evutil_socket_t fd,short what,void * arg)3532 evthread_notify_drain_eventfd(evutil_socket_t fd, short what, void *arg)
3533 {
3534 	ev_uint64_t msg;
3535 	ev_ssize_t r;
3536 	struct event_base *base = arg;
3537 
3538 	r = read(fd, (void*) &msg, sizeof(msg));
3539 	if (r<0 && errno != EAGAIN) {
3540 		event_sock_warn(fd, "Error reading from eventfd");
3541 	}
3542 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3543 	base->is_notify_pending = 0;
3544 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3545 }
3546 #endif
3547 
3548 static void
evthread_notify_drain_default(evutil_socket_t fd,short what,void * arg)3549 evthread_notify_drain_default(evutil_socket_t fd, short what, void *arg)
3550 {
3551 	unsigned char buf[1024];
3552 	struct event_base *base = arg;
3553 #ifdef _WIN32
3554 	while (recv(fd, (char*)buf, sizeof(buf), 0) > 0)
3555 		;
3556 #else
3557 	while (read(fd, (char*)buf, sizeof(buf)) > 0)
3558 		;
3559 #endif
3560 
3561 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3562 	base->is_notify_pending = 0;
3563 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3564 }
3565 
3566 int
evthread_make_base_notifiable(struct event_base * base)3567 evthread_make_base_notifiable(struct event_base *base)
3568 {
3569 	int r;
3570 	if (!base)
3571 		return -1;
3572 
3573 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3574 	r = evthread_make_base_notifiable_nolock_(base);
3575 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3576 	return r;
3577 }
3578 
3579 static int
evthread_make_base_notifiable_nolock_(struct event_base * base)3580 evthread_make_base_notifiable_nolock_(struct event_base *base)
3581 {
3582 	void (*cb)(evutil_socket_t, short, void *);
3583 	int (*notify)(struct event_base *);
3584 
3585 	if (base->th_notify_fn != NULL) {
3586 		/* The base is already notifiable: we're doing fine. */
3587 		return 0;
3588 	}
3589 
3590 #if defined(EVENT__HAVE_WORKING_KQUEUE)
3591 	if (base->evsel == &kqops && event_kq_add_notify_event_(base) == 0) {
3592 		base->th_notify_fn = event_kq_notify_base_;
3593 		/* No need to add an event here; the backend can wake
3594 		 * itself up just fine. */
3595 		return 0;
3596 	}
3597 #endif
3598 
3599 #ifdef EVENT__HAVE_EVENTFD
3600 	base->th_notify_fd[0] = evutil_eventfd_(0,
3601 	    EVUTIL_EFD_CLOEXEC|EVUTIL_EFD_NONBLOCK);
3602 	if (base->th_notify_fd[0] >= 0) {
3603 		base->th_notify_fd[1] = -1;
3604 		notify = evthread_notify_base_eventfd;
3605 		cb = evthread_notify_drain_eventfd;
3606 	} else
3607 #endif
3608 	if (evutil_make_internal_pipe_(base->th_notify_fd) == 0) {
3609 		notify = evthread_notify_base_default;
3610 		cb = evthread_notify_drain_default;
3611 	} else {
3612 		return -1;
3613 	}
3614 
3615 	base->th_notify_fn = notify;
3616 
3617 	/* prepare an event that we can use for wakeup */
3618 	event_assign(&base->th_notify, base, base->th_notify_fd[0],
3619 				 EV_READ|EV_PERSIST, cb, base);
3620 
3621 	/* we need to mark this as internal event */
3622 	base->th_notify.ev_flags |= EVLIST_INTERNAL;
3623 	event_priority_set(&base->th_notify, 0);
3624 
3625 	return event_add_nolock_(&base->th_notify, NULL, 0);
3626 }
3627 
3628 int
event_base_foreach_event_nolock_(struct event_base * base,event_base_foreach_event_cb fn,void * arg)3629 event_base_foreach_event_nolock_(struct event_base *base,
3630     event_base_foreach_event_cb fn, void *arg)
3631 {
3632 	int r, i;
3633 	unsigned u;
3634 	struct event *ev;
3635 
3636 	/* Start out with all the EVLIST_INSERTED events. */
3637 	if ((r = evmap_foreach_event_(base, fn, arg)))
3638 		return r;
3639 
3640 	/* Okay, now we deal with those events that have timeouts and are in
3641 	 * the min-heap. */
3642 	for (u = 0; u < base->timeheap.n; ++u) {
3643 		ev = base->timeheap.p[u];
3644 		if (ev->ev_flags & EVLIST_INSERTED) {
3645 			/* we already processed this one */
3646 			continue;
3647 		}
3648 		if ((r = fn(base, ev, arg)))
3649 			return r;
3650 	}
3651 
3652 	/* Now for the events in one of the timeout queues.
3653 	 * the min-heap. */
3654 	for (i = 0; i < base->n_common_timeouts; ++i) {
3655 		struct common_timeout_list *ctl =
3656 		    base->common_timeout_queues[i];
3657 		TAILQ_FOREACH(ev, &ctl->events,
3658 		    ev_timeout_pos.ev_next_with_common_timeout) {
3659 			if (ev->ev_flags & EVLIST_INSERTED) {
3660 				/* we already processed this one */
3661 				continue;
3662 			}
3663 			if ((r = fn(base, ev, arg)))
3664 				return r;
3665 		}
3666 	}
3667 
3668 	/* Finally, we deal wit all the active events that we haven't touched
3669 	 * yet. */
3670 	for (i = 0; i < base->nactivequeues; ++i) {
3671 		struct event_callback *evcb;
3672 		TAILQ_FOREACH(evcb, &base->activequeues[i], evcb_active_next) {
3673 			if ((evcb->evcb_flags & (EVLIST_INIT|EVLIST_INSERTED|EVLIST_TIMEOUT)) != EVLIST_INIT) {
3674 				/* This isn't an event (evlist_init clear), or
3675 				 * we already processed it. (inserted or
3676 				 * timeout set */
3677 				continue;
3678 			}
3679 			ev = event_callback_to_event(evcb);
3680 			if ((r = fn(base, ev, arg)))
3681 				return r;
3682 		}
3683 	}
3684 
3685 	return 0;
3686 }
3687 
3688 /* Helper for event_base_dump_events: called on each event in the event base;
3689  * dumps only the inserted events. */
3690 static int
dump_inserted_event_fn(const struct event_base * base,const struct event * e,void * arg)3691 dump_inserted_event_fn(const struct event_base *base, const struct event *e, void *arg)
3692 {
3693 	FILE *output = arg;
3694 	const char *gloss = (e->ev_events & EV_SIGNAL) ?
3695 	    "sig" : "fd ";
3696 
3697 	if (! (e->ev_flags & (EVLIST_INSERTED|EVLIST_TIMEOUT)))
3698 		return 0;
3699 
3700 	fprintf(output, "  %p [%s "EV_SOCK_FMT"]%s%s%s%s%s%s",
3701 	    (void*)e, gloss, EV_SOCK_ARG(e->ev_fd),
3702 	    (e->ev_events&EV_READ)?" Read":"",
3703 	    (e->ev_events&EV_WRITE)?" Write":"",
3704 	    (e->ev_events&EV_CLOSED)?" EOF":"",
3705 	    (e->ev_events&EV_SIGNAL)?" Signal":"",
3706 	    (e->ev_events&EV_PERSIST)?" Persist":"",
3707 	    (e->ev_flags&EVLIST_INTERNAL)?" Internal":"");
3708 	if (e->ev_flags & EVLIST_TIMEOUT) {
3709 		struct timeval tv;
3710 		tv.tv_sec = e->ev_timeout.tv_sec;
3711 		tv.tv_usec = e->ev_timeout.tv_usec & MICROSECONDS_MASK;
3712 		evutil_timeradd(&tv, &base->tv_clock_diff, &tv);
3713 		fprintf(output, " Timeout=%ld.%06d",
3714 		    (long)tv.tv_sec, (int)(tv.tv_usec & MICROSECONDS_MASK));
3715 	}
3716 	fputc('\n', output);
3717 
3718 	return 0;
3719 }
3720 
3721 /* Helper for event_base_dump_events: called on each event in the event base;
3722  * dumps only the active events. */
3723 static int
dump_active_event_fn(const struct event_base * base,const struct event * e,void * arg)3724 dump_active_event_fn(const struct event_base *base, const struct event *e, void *arg)
3725 {
3726 	FILE *output = arg;
3727 	const char *gloss = (e->ev_events & EV_SIGNAL) ?
3728 	    "sig" : "fd ";
3729 
3730 	if (! (e->ev_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)))
3731 		return 0;
3732 
3733 	fprintf(output, "  %p [%s "EV_SOCK_FMT", priority=%d]%s%s%s%s%s active%s%s\n",
3734 	    (void*)e, gloss, EV_SOCK_ARG(e->ev_fd), e->ev_pri,
3735 	    (e->ev_res&EV_READ)?" Read":"",
3736 	    (e->ev_res&EV_WRITE)?" Write":"",
3737 	    (e->ev_res&EV_CLOSED)?" EOF":"",
3738 	    (e->ev_res&EV_SIGNAL)?" Signal":"",
3739 	    (e->ev_res&EV_TIMEOUT)?" Timeout":"",
3740 	    (e->ev_flags&EVLIST_INTERNAL)?" [Internal]":"",
3741 	    (e->ev_flags&EVLIST_ACTIVE_LATER)?" [NextTime]":"");
3742 
3743 	return 0;
3744 }
3745 
3746 int
event_base_foreach_event(struct event_base * base,event_base_foreach_event_cb fn,void * arg)3747 event_base_foreach_event(struct event_base *base,
3748     event_base_foreach_event_cb fn, void *arg)
3749 {
3750 	int r;
3751 	if ((!fn) || (!base)) {
3752 		return -1;
3753 	}
3754 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3755 	r = event_base_foreach_event_nolock_(base, fn, arg);
3756 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3757 	return r;
3758 }
3759 
3760 
3761 void
event_base_dump_events(struct event_base * base,FILE * output)3762 event_base_dump_events(struct event_base *base, FILE *output)
3763 {
3764 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3765 	fprintf(output, "Inserted events:\n");
3766 	event_base_foreach_event_nolock_(base, dump_inserted_event_fn, output);
3767 
3768 	fprintf(output, "Active events:\n");
3769 	event_base_foreach_event_nolock_(base, dump_active_event_fn, output);
3770 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3771 }
3772 
3773 void
event_base_active_by_fd(struct event_base * base,evutil_socket_t fd,short events)3774 event_base_active_by_fd(struct event_base *base, evutil_socket_t fd, short events)
3775 {
3776 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3777 	evmap_io_active_(base, fd, events & (EV_READ|EV_WRITE|EV_CLOSED));
3778 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3779 }
3780 
3781 void
event_base_active_by_signal(struct event_base * base,int sig)3782 event_base_active_by_signal(struct event_base *base, int sig)
3783 {
3784 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3785 	evmap_signal_active_(base, sig, 1);
3786 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3787 }
3788 
3789 
3790 void
event_base_add_virtual_(struct event_base * base)3791 event_base_add_virtual_(struct event_base *base)
3792 {
3793 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3794 	base->virtual_event_count++;
3795 	MAX_EVENT_COUNT(base->virtual_event_count_max, base->virtual_event_count);
3796 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3797 }
3798 
3799 void
event_base_del_virtual_(struct event_base * base)3800 event_base_del_virtual_(struct event_base *base)
3801 {
3802 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3803 	EVUTIL_ASSERT(base->virtual_event_count > 0);
3804 	base->virtual_event_count--;
3805 	if (base->virtual_event_count == 0 && EVBASE_NEED_NOTIFY(base))
3806 		evthread_notify_base(base);
3807 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3808 }
3809 
3810 static void
event_free_debug_globals_locks(void)3811 event_free_debug_globals_locks(void)
3812 {
3813 #ifndef EVENT__DISABLE_THREAD_SUPPORT
3814 #ifndef EVENT__DISABLE_DEBUG_MODE
3815 	if (event_debug_map_lock_ != NULL) {
3816 		EVTHREAD_FREE_LOCK(event_debug_map_lock_, 0);
3817 		event_debug_map_lock_ = NULL;
3818 		evthreadimpl_disable_lock_debugging_();
3819 	}
3820 #endif /* EVENT__DISABLE_DEBUG_MODE */
3821 #endif /* EVENT__DISABLE_THREAD_SUPPORT */
3822 	return;
3823 }
3824 
3825 static void
event_free_debug_globals(void)3826 event_free_debug_globals(void)
3827 {
3828 	event_free_debug_globals_locks();
3829 }
3830 
3831 static void
event_free_evsig_globals(void)3832 event_free_evsig_globals(void)
3833 {
3834 	evsig_free_globals_();
3835 }
3836 
3837 static void
event_free_evutil_globals(void)3838 event_free_evutil_globals(void)
3839 {
3840 	evutil_free_globals_();
3841 }
3842 
3843 static void
event_free_globals(void)3844 event_free_globals(void)
3845 {
3846 	event_free_debug_globals();
3847 	event_free_evsig_globals();
3848 	event_free_evutil_globals();
3849 }
3850 
3851 void
libevent_global_shutdown(void)3852 libevent_global_shutdown(void)
3853 {
3854 	event_disable_debug_mode();
3855 	event_free_globals();
3856 }
3857 
3858 #ifndef EVENT__DISABLE_THREAD_SUPPORT
3859 int
event_global_setup_locks_(const int enable_locks)3860 event_global_setup_locks_(const int enable_locks)
3861 {
3862 #ifndef EVENT__DISABLE_DEBUG_MODE
3863 	EVTHREAD_SETUP_GLOBAL_LOCK(event_debug_map_lock_, 0);
3864 #endif
3865 	if (evsig_global_setup_locks_(enable_locks) < 0)
3866 		return -1;
3867 	if (evutil_global_setup_locks_(enable_locks) < 0)
3868 		return -1;
3869 	if (evutil_secure_rng_global_setup_locks_(enable_locks) < 0)
3870 		return -1;
3871 	return 0;
3872 }
3873 #endif
3874 
3875 void
event_base_assert_ok_(struct event_base * base)3876 event_base_assert_ok_(struct event_base *base)
3877 {
3878 	EVBASE_ACQUIRE_LOCK(base, th_base_lock);
3879 	event_base_assert_ok_nolock_(base);
3880 	EVBASE_RELEASE_LOCK(base, th_base_lock);
3881 }
3882 
3883 void
event_base_assert_ok_nolock_(struct event_base * base)3884 event_base_assert_ok_nolock_(struct event_base *base)
3885 {
3886 	int i;
3887 	int count;
3888 
3889 	/* First do checks on the per-fd and per-signal lists */
3890 	evmap_check_integrity_(base);
3891 
3892 	/* Check the heap property */
3893 	for (i = 1; i < (int)base->timeheap.n; ++i) {
3894 		int parent = (i - 1) / 2;
3895 		struct event *ev, *p_ev;
3896 		ev = base->timeheap.p[i];
3897 		p_ev = base->timeheap.p[parent];
3898 		EVUTIL_ASSERT(ev->ev_flags & EVLIST_TIMEOUT);
3899 		EVUTIL_ASSERT(evutil_timercmp(&p_ev->ev_timeout, &ev->ev_timeout, <=));
3900 		EVUTIL_ASSERT(ev->ev_timeout_pos.min_heap_idx == i);
3901 	}
3902 
3903 	/* Check that the common timeouts are fine */
3904 	for (i = 0; i < base->n_common_timeouts; ++i) {
3905 		struct common_timeout_list *ctl = base->common_timeout_queues[i];
3906 		struct event *last=NULL, *ev;
3907 
3908 		EVUTIL_ASSERT_TAILQ_OK(&ctl->events, event, ev_timeout_pos.ev_next_with_common_timeout);
3909 
3910 		TAILQ_FOREACH(ev, &ctl->events, ev_timeout_pos.ev_next_with_common_timeout) {
3911 			if (last)
3912 				EVUTIL_ASSERT(evutil_timercmp(&last->ev_timeout, &ev->ev_timeout, <=));
3913 			EVUTIL_ASSERT(ev->ev_flags & EVLIST_TIMEOUT);
3914 			EVUTIL_ASSERT(is_common_timeout(&ev->ev_timeout,base));
3915 			EVUTIL_ASSERT(COMMON_TIMEOUT_IDX(&ev->ev_timeout) == i);
3916 			last = ev;
3917 		}
3918 	}
3919 
3920 	/* Check the active queues. */
3921 	count = 0;
3922 	for (i = 0; i < base->nactivequeues; ++i) {
3923 		struct event_callback *evcb;
3924 		EVUTIL_ASSERT_TAILQ_OK(&base->activequeues[i], event_callback, evcb_active_next);
3925 		TAILQ_FOREACH(evcb, &base->activequeues[i], evcb_active_next) {
3926 			EVUTIL_ASSERT((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) == EVLIST_ACTIVE);
3927 			EVUTIL_ASSERT(evcb->evcb_pri == i);
3928 			++count;
3929 		}
3930 	}
3931 
3932 	{
3933 		struct event_callback *evcb;
3934 		TAILQ_FOREACH(evcb, &base->active_later_queue, evcb_active_next) {
3935 			EVUTIL_ASSERT((evcb->evcb_flags & (EVLIST_ACTIVE|EVLIST_ACTIVE_LATER)) == EVLIST_ACTIVE_LATER);
3936 			++count;
3937 		}
3938 	}
3939 	EVUTIL_ASSERT(count == base->event_count_active);
3940 }
3941