contrib/libevent/event.c

   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
 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
 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
 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
 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
 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
 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
 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 *
 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 *
 459 event_to_event_callback(struct event *ev)
 460 {
 461         return &ev->ev_evcallback;
 462 }
 463
 464 struct event_base *
 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 *
 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
 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
 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
 524 event_base_get_features(const struct event_base *base)
 525 {
 526         return base->evsel->features;
 527 }
 528
 529 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
 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 *
 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
 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
 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
 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
 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
 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
 906 event_base_free_nofinalize(struct event_base *base)
 907 {
 908         event_base_free_(base, 0);
 909 }
 910
 911 void
 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
 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
 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
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 **
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 *
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
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
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
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
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
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
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
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
1191 event_priority_init(int npriorities)
1192 {
1193         return event_base_priority_init(current_base, npriorities);
1194 }
1195
1196 int
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
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
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
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
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
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
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
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 *
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
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
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 *
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
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
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
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
1764 event_dispatch(void)
1765 {
1766         return (event_loop(0));
1767 }
1768
1769 int
1770 event_base_dispatch(struct event_base *event_base)
1771 {
1772         return (event_base_loop(event_base, 0));
1773 }
1774
1775 const char *
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
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
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
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
1806 event_loopbreak(void)
1807 {
1808         return (event_base_loopbreak(current_base));
1809 }
1810
1811 int
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
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
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
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
1872 event_loop(int flags)
1873 {
1874         return event_base_loop(current_base, flags);
1875 }
1876
1877 int
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
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
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
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
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
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
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 *
2138 event_self_cbarg(void)
2139 {
2140         return &event_self_cbarg_ptr_;
2141 }
2142
2143 struct event *
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
2386 event_get_struct_event_size(void)
2387 {
2388         return sizeof(struct event);
2389 }
2390
2391 evutil_socket_t
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 *
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
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
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 *
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
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
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
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
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
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
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
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
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
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
2738 event_del(struct event *ev)
2739 {
2740         return event_del_(ev, EVENT_DEL_AUTOBLOCK);
2741 }
2742
2743 int
2744 event_del_block(struct event *ev)
2745 {
2746         return event_del_(ev, EVENT_DEL_BLOCK);
2747 }
2748
2749 int
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
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
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
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
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
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
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
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
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
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
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
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
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
3054 event_deferred_cb_set_priority_(struct event_callback *cb, ev_uint8_t priority)
3055 {
3056         cb->evcb_pri = priority;
3057 }
3058
3059 void
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
3405 event_get_version(void)
3406 {
3407         return (EVENT__VERSION);
3408 }
3409
3410 ev_uint32_t
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 *
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 *
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 *
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 *
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
3826 event_free_debug_globals(void)
3827 {
3828         event_free_debug_globals_locks();
3829 }
3830
3831 static void
3832 event_free_evsig_globals(void)
3833 {
3834         evsig_free_globals_();
3835 }
3836
3837 static void
3838 event_free_evutil_globals(void)
3839 {
3840         evutil_free_globals_();
3841 }
3842
3843 static 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
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
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
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
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 }