libevent/event.c

   1 /*
   2  * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu>
   3  * Copyright (c) 2007-2010 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
  29 #ifdef WIN32
  30 #include <winsock2.h>
  31 #define WIN32_LEAN_AND_MEAN
  32 #include <windows.h>
  33 #undef WIN32_LEAN_AND_MEAN
  34 #endif
  35 #include <sys/types.h>
  36 #if !defined(WIN32) && defined(_EVENT_HAVE_SYS_TIME_H)
  37 #include <sys/time.h>
  38 #endif
  39 #include <sys/queue.h>
  40 #ifdef _EVENT_HAVE_SYS_SOCKET_H
  41 #include <sys/socket.h>
  42 #endif
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #ifdef _EVENT_HAVE_UNISTD_H
  46 #include <unistd.h>
  47 #endif
  48 #ifdef _EVENT_HAVE_SYS_EVENTFD_H
  49 #include <sys/eventfd.h>
  50 #endif
  51 #include <ctype.h>
  52 #include <errno.h>
  53 #include <signal.h>
  54 #include <string.h>
  55 #include <time.h>
  56
  57 #include "event2/event.h"
  58 #include "event2/event_struct.h"
  59 #include "event2/event_compat.h"
  60 #include "event-internal.h"
  61 #include "defer-internal.h"
  62 #include "evthread-internal.h"
  63 #include "event2/thread.h"
  64 #include "event2/util.h"
  65 #include "log-internal.h"
  66 #include "evmap-internal.h"
  67 #include "iocp-internal.h"
  68 #include "changelist-internal.h"
  69 #include "ht-internal.h"
  70 #include "util-internal.h"
  71
  72 #ifdef _EVENT_HAVE_EVENT_PORTS
  73 extern const struct eventop evportops;
  74 #endif
  75 #ifdef _EVENT_HAVE_SELECT
  76 extern const struct eventop selectops;
  77 #endif
  78 #ifdef _EVENT_HAVE_POLL
  79 extern const struct eventop pollops;
  80 #endif
  81 #ifdef _EVENT_HAVE_EPOLL
  82 extern const struct eventop epollops;
  83 #endif
  84 #ifdef _EVENT_HAVE_WORKING_KQUEUE
  85 extern const struct eventop kqops;
  86 #endif
  87 #ifdef _EVENT_HAVE_DEVPOLL
  88 extern const struct eventop devpollops;
  89 #endif
  90 #ifdef WIN32
  91 extern const struct eventop win32ops;
  92 #endif
  93
  94 /* Array of backends in order of preference. */
  95 static const struct eventop *eventops[] = {
  96 #ifdef _EVENT_HAVE_EVENT_PORTS
  97         &evportops,
  98 #endif
  99 #ifdef _EVENT_HAVE_WORKING_KQUEUE
 100         &kqops,
 101 #endif
 102 #ifdef _EVENT_HAVE_EPOLL
 103         &epollops,
 104 #endif
 105 #ifdef _EVENT_HAVE_DEVPOLL
 106         &devpollops,
 107 #endif
 108 #ifdef _EVENT_HAVE_POLL
 109         &pollops,
 110 #endif
 111 #ifdef _EVENT_HAVE_SELECT
 112         &selectops,
 113 #endif
 114 #ifdef WIN32
 115         &win32ops,
 116 #endif
 117         NULL
 118 };
 119
 120 /* Global state; deprecated */
 121 struct event_base *event_global_current_base_ = NULL;
 122 #define current_base event_global_current_base_
 123
 124 /* Global state */
 125
 126 static int use_monotonic;
 127
 128 /* Prototypes */
 129 static inline int event_add_internal(struct event *ev,
 130     const struct timeval *tv, int tv_is_absolute);
 131 static inline int event_del_internal(struct event *ev);
 132
 133 static void     event_queue_insert(struct event_base *, struct event *, int);
 134 static void     event_queue_remove(struct event_base *, struct event *, int);
 135 static int      event_haveevents(struct event_base *);
 136
 137 static int      event_process_active(struct event_base *);
 138
 139 static int      timeout_next(struct event_base *, struct timeval **);
 140 static void     timeout_process(struct event_base *);
 141 static void     timeout_correct(struct event_base *, struct timeval *);
 142
 143 static inline void      event_signal_closure(struct event_base *, struct event *ev);
 144 static inline void      event_persist_closure(struct event_base *, struct event *ev);
 145
 146 static int      evthread_notify_base(struct event_base *base);
 147
 148 #ifndef _EVENT_DISABLE_DEBUG_MODE
 149 /* These functions implement a hashtable of which 'struct event *' structures
 150  * have been setup or added.  We don't want to trust the content of the struct
 151  * event itself, since we're trying to work through cases where an event gets
 152  * clobbered or freed.  Instead, we keep a hashtable indexed by the pointer.
 153  */
 154
 155 struct event_debug_entry {
 156         HT_ENTRY(event_debug_entry) node;
 157         const struct event *ptr;
 158         unsigned added : 1;
 159 };
 160
 161 static inline unsigned
 162 hash_debug_entry(const struct event_debug_entry *e)
 163 {
 164         /* We need to do this silliness to convince compilers that we
 165          * honestly mean to cast e->ptr to an integer, and discard any
 166          * part of it that doesn't fit in an unsigned.
 167          */
 168         unsigned u = (unsigned) ((ev_uintptr_t) e->ptr);
 169         /* Our hashtable implementation is pretty sensitive to low bits,
 170          * and every struct event is over 64 bytes in size, so we can
 171          * just say >>6. */
 172         return (u >> 6);
 173 }
 174
 175 static inline int
 176 eq_debug_entry(const struct event_debug_entry *a,
 177     const struct event_debug_entry *b)
 178 {
 179         return a->ptr == b->ptr;
 180 }
 181
 182 int _event_debug_mode_on = 0;
 183 /* Set if it's too late to enable event_debug_mode. */
 184 static int event_debug_mode_too_late = 0;
 185 static void *_event_debug_map_lock = NULL;
 186 static HT_HEAD(event_debug_map, event_debug_entry) global_debug_map =
 187         HT_INITIALIZER();
 188
 189 HT_PROTOTYPE(event_debug_map, event_debug_entry, node, hash_debug_entry,
 190     eq_debug_entry)
 191 HT_GENERATE(event_debug_map, event_debug_entry, node, hash_debug_entry,
 192     eq_debug_entry, 0.5, mm_malloc, mm_realloc, mm_free)
 193
 194 /* Macro: record that ev is now setup (that is, ready for an add) */
 195 #define _event_debug_note_setup(ev) do {                                \
 196         if (_event_debug_mode_on) {                                     \
 197                 struct event_debug_entry *dent,find;                    \
 198                 find.ptr = (ev);                                        \
 199                 EVLOCK_LOCK(_event_debug_map_lock, 0);                  \
 200                 dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
 201                 if (dent) {                                             \
 202                         dent->added = 0;                                \
 203                 } else {                                                \
 204                         dent = mm_malloc(sizeof(*dent));                \
 205                         if (!dent)                                      \
 206                                 event_err(1,                            \
 207                                     "Out of memory in debugging code"); \
 208                         dent->ptr = (ev);                               \
 209                         dent->added = 0;                                \
 210                         HT_INSERT(event_debug_map, &global_debug_map, dent); \
 211                 }                                                       \
 212                 EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 213         }                                                               \
 214         event_debug_mode_too_late = 1;                                  \
 215         } while (0)
 216 /* Macro: record that ev is no longer setup */
 217 #define _event_debug_note_teardown(ev) do {                             \
 218         if (_event_debug_mode_on) {                                     \
 219                 struct event_debug_entry *dent,find;                    \
 220                 find.ptr = (ev);                                        \
 221                 EVLOCK_LOCK(_event_debug_map_lock, 0);                  \
 222                 dent = HT_REMOVE(event_debug_map, &global_debug_map, &find); \
 223                 if (dent)                                               \
 224                         mm_free(dent);                                  \
 225                 EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 226         }                                                               \
 227         event_debug_mode_too_late = 1;                                  \
 228         } while (0)
 229 /* Macro: record that ev is now added */
 230 #define _event_debug_note_add(ev)       do {                            \
 231         if (_event_debug_mode_on) {                                     \
 232                 struct event_debug_entry *dent,find;                    \
 233                 find.ptr = (ev);                                        \
 234                 EVLOCK_LOCK(_event_debug_map_lock, 0);                  \
 235                 dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
 236                 if (dent) {                                             \
 237                         dent->added = 1;                                \
 238                 } else {                                                \
 239                         event_errx(_EVENT_ERR_ABORT,                    \
 240                             "%s: noting an add on a non-setup event %p", \
 241                             __func__, (ev));                            \
 242                 }                                                       \
 243                 EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 244         }                                                               \
 245         event_debug_mode_too_late = 1;                                  \
 246         } while (0)
 247 /* Macro: record that ev is no longer added */
 248 #define _event_debug_note_del(ev) do {                                  \
 249         if (_event_debug_mode_on) {                                     \
 250                 struct event_debug_entry *dent,find;                    \
 251                 find.ptr = (ev);                                        \
 252                 EVLOCK_LOCK(_event_debug_map_lock, 0);                  \
 253                 dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
 254                 if (dent) {                                             \
 255                         dent->added = 0;                                \
 256                 } else {                                                \
 257                         event_errx(_EVENT_ERR_ABORT,                    \
 258                             "%s: noting a del on a non-setup event %p", \
 259                             __func__, (ev));                            \
 260                 }                                                       \
 261                 EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 262         }                                                               \
 263         event_debug_mode_too_late = 1;                                  \
 264         } while (0)
 265 /* Macro: assert that ev is setup (i.e., okay to add or inspect) */
 266 #define _event_debug_assert_is_setup(ev) do {                           \
 267         if (_event_debug_mode_on) {                                     \
 268                 struct event_debug_entry *dent,find;                    \
 269                 find.ptr = (ev);                                        \
 270                 EVLOCK_LOCK(_event_debug_map_lock, 0);                  \
 271                 dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
 272                 if (!dent) {                                            \
 273                         event_errx(_EVENT_ERR_ABORT,                    \
 274                             "%s called on a non-initialized event %p",  \
 275                             __func__, (ev));                            \
 276                 }                                                       \
 277                 EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 278         }                                                               \
 279         } while (0)
 280 /* Macro: assert that ev is not added (i.e., okay to tear down or set
 281  * up again) */
 282 #define _event_debug_assert_not_added(ev) do {                          \
 283         if (_event_debug_mode_on) {                                     \
 284                 struct event_debug_entry *dent,find;                    \
 285                 find.ptr = (ev);                                        \
 286                 EVLOCK_LOCK(_event_debug_map_lock, 0);                  \
 287                 dent = HT_FIND(event_debug_map, &global_debug_map, &find); \
 288                 if (dent && dent->added) {                              \
 289                         event_errx(_EVENT_ERR_ABORT,                    \
 290                             "%s called on an already added event %p",   \
 291                             __func__, (ev));                            \
 292                 }                                                       \
 293                 EVLOCK_UNLOCK(_event_debug_map_lock, 0);                \
 294         }                                                               \
 295         } while (0)
 296 #else
 297 #define _event_debug_note_setup(ev) \
 298         ((void)0)
 299 #define _event_debug_note_teardown(ev) \
 300         ((void)0)
 301 #define _event_debug_note_add(ev) \
 302         ((void)0)
 303 #define _event_debug_note_del(ev) \
 304         ((void)0)
 305 #define _event_debug_assert_is_setup(ev) \
 306         ((void)0)
 307 #define _event_debug_assert_not_added(ev) \
 308         ((void)0)
 309 #endif
 310
 311 #define EVENT_BASE_ASSERT_LOCKED(base)          \
 312         EVLOCK_ASSERT_LOCKED((base)->th_base_lock)
 313
 314 /* The first time this function is called, it sets use_monotonic to 1
 315  * if we have a clock function that supports monotonic time */
 316 static void
 317 detect_monotonic(void)
 318 {
 319 #if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
 320         struct timespec ts;
 321         static int use_monotonic_initialized = 0;
 322
 323         if (use_monotonic_initialized)
 324                 return;
 325
 326         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
 327                 use_monotonic = 1;
 328
 329         use_monotonic_initialized = 1;
 330 #endif
 331 }
 332
 333 /** Set 'tp' to the current time according to 'base'.  We must hold the lock
 334  * on 'base'.  If there is a cached time, return it.  Otherwise, use
 335  * clock_gettime or gettimeofday as appropriate to find out the right time.
 336  * Return 0 on success, -1 on failure.
 337  */
 338 static int
 339 gettime(struct event_base *base, struct timeval *tp)
 340 {
 341         EVENT_BASE_ASSERT_LOCKED(base);
 342
 343         if (base->tv_cache.tv_sec) {
 344                 *tp = base->tv_cache;
 345                 return (0);
 346         }
 347
 348 #if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
 349         if (use_monotonic) {
 350                 struct timespec ts;
 351
 352                 if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
 353                         return (-1);
 354
 355                 tp->tv_sec = ts.tv_sec;
 356                 tp->tv_usec = ts.tv_nsec / 1000;
 357                 return (0);
 358         }
 359 #endif
 360
 361         return (evutil_gettimeofday(tp, NULL));
 362 }
 363
 364 int
 365 event_base_gettimeofday_cached(struct event_base *base, struct timeval *tv)
 366 {
 367         int r;
 368         if (!base) {
 369                 base = current_base;
 370                 if (!current_base)
 371                         return evutil_gettimeofday(tv, NULL);
 372         }
 373
 374         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
 375         r = gettime(base, tv);
 376         EVBASE_RELEASE_LOCK(base, th_base_lock);
 377         return r;
 378 }
 379
 380 /** Make 'base' have no current cached time. */
 381 static inline void
 382 clear_time_cache(struct event_base *base)
 383 {
 384         base->tv_cache.tv_sec = 0;
 385 }
 386
 387 /** Replace the cached time in 'base' with the current time. */
 388 static inline void
 389 update_time_cache(struct event_base *base)
 390 {
 391         base->tv_cache.tv_sec = 0;
 392         if (!(base->flags & EVENT_BASE_FLAG_NO_CACHE_TIME))
 393             gettime(base, &base->tv_cache);
 394 }
 395
 396 struct event_base *
 397 event_init(void)
 398 {
 399         struct event_base *base = event_base_new_with_config(NULL);
 400
 401         if (base == NULL) {
 402                 event_errx(1, "%s: Unable to construct event_base", __func__);
 403                 return NULL;
 404         }
 405
 406         current_base = base;
 407
 408         return (base);
 409 }
 410
 411 struct event_base *
 412 event_base_new(void)
 413 {
 414         struct event_base *base = NULL;
 415         struct event_config *cfg = event_config_new();
 416         if (cfg) {
 417                 base = event_base_new_with_config(cfg);
 418                 event_config_free(cfg);
 419         }
 420         return base;
 421 }
 422
 423 /** Return true iff 'method' is the name of a method that 'cfg' tells us to
 424  * avoid. */
 425 static int
 426 event_config_is_avoided_method(const struct event_config *cfg,
 427     const char *method)
 428 {
 429         struct event_config_entry *entry;
 430
 431         TAILQ_FOREACH(entry, &cfg->entries, next) {
 432                 if (entry->avoid_method != NULL &&
 433                     strcmp(entry->avoid_method, method) == 0)
 434                         return (1);
 435         }
 436
 437         return (0);
 438 }
 439
 440 /** Return true iff 'method' is disabled according to the environment. */
 441 static int
 442 event_is_method_disabled(const char *name)
 443 {
 444         char environment[64];
 445         int i;
 446
 447         evutil_snprintf(environment, sizeof(environment), "EVENT_NO%s", name);
 448         for (i = 8; environment[i] != '\0'; ++i)
 449                 environment[i] = EVUTIL_TOUPPER(environment[i]);
 450         /* Note that evutil_getenv() ignores the environment entirely if
 451          * we're setuid */
 452         return (evutil_getenv(environment) != NULL);
 453 }
 454
 455 int
 456 event_base_get_features(const struct event_base *base)
 457 {
 458         return base->evsel->features;
 459 }
 460
 461 void
 462 event_deferred_cb_queue_init(struct deferred_cb_queue *cb)
 463 {
 464         memset(cb, 0, sizeof(struct deferred_cb_queue));
 465         TAILQ_INIT(&cb->deferred_cb_list);
 466 }
 467
 468 /** Helper for the deferred_cb queue: wake up the event base. */
 469 static void
 470 notify_base_cbq_callback(struct deferred_cb_queue *cb, void *baseptr)
 471 {
 472         struct event_base *base = baseptr;
 473         if (EVBASE_NEED_NOTIFY(base))
 474                 evthread_notify_base(base);
 475 }
 476
 477 struct deferred_cb_queue *
 478 event_base_get_deferred_cb_queue(struct event_base *base)
 479 {
 480         return base ? &base->defer_queue : NULL;
 481 }
 482
 483 void
 484 event_enable_debug_mode(void)
 485 {
 486 #ifndef _EVENT_DISABLE_DEBUG_MODE
 487         if (_event_debug_mode_on)
 488                 event_errx(1, "%s was called twice!", __func__);
 489         if (event_debug_mode_too_late)
 490                 event_errx(1, "%s must be called *before* creating any events "
 491                     "or event_bases",__func__);
 492
 493         _event_debug_mode_on = 1;
 494
 495         HT_INIT(event_debug_map, &global_debug_map);
 496
 497         EVTHREAD_ALLOC_LOCK(_event_debug_map_lock, 0);
 498 #endif
 499 }
 500
 501 #if 0
 502 void
 503 event_disable_debug_mode(void)
 504 {
 505         struct event_debug_entry **ent, *victim;
 506
 507         EVLOCK_LOCK(_event_debug_map_lock, 0);
 508         for (ent = HT_START(event_debug_map, &global_debug_map); ent; ) {
 509                 victim = *ent;
 510                 ent = HT_NEXT_RMV(event_debug_map,&global_debug_map, ent);
 511                 mm_free(victim);
 512         }
 513         HT_CLEAR(event_debug_map, &global_debug_map);
 514         EVLOCK_UNLOCK(_event_debug_map_lock , 0);
 515 }
 516 #endif
 517
 518 struct event_base *
 519 event_base_new_with_config(const struct event_config *cfg)
 520 {
 521         int i;
 522         struct event_base *base;
 523         int should_check_environment;
 524
 525 #ifndef _EVENT_DISABLE_DEBUG_MODE
 526         event_debug_mode_too_late = 1;
 527         if (_event_debug_mode_on && !_event_debug_map_lock) {
 528                 EVTHREAD_ALLOC_LOCK(_event_debug_map_lock, 0);
 529         }
 530 #endif
 531
 532         if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) {
 533                 event_warn("%s: calloc", __func__);
 534                 return NULL;
 535         }
 536         detect_monotonic();
 537         gettime(base, &base->event_tv);
 538
 539         min_heap_ctor(&base->timeheap);
 540         TAILQ_INIT(&base->eventqueue);
 541         base->sig.ev_signal_pair[0] = -1;
 542         base->sig.ev_signal_pair[1] = -1;
 543         base->th_notify_fd[0] = -1;
 544         base->th_notify_fd[1] = -1;
 545
 546         event_deferred_cb_queue_init(&base->defer_queue);
 547         base->defer_queue.notify_fn = notify_base_cbq_callback;
 548         base->defer_queue.notify_arg = base;
 549         if (cfg)
 550                 base->flags = cfg->flags;
 551
 552         evmap_io_initmap(&base->io);
 553         evmap_signal_initmap(&base->sigmap);
 554         event_changelist_init(&base->changelist);
 555
 556         base->evbase = NULL;
 557
 558         should_check_environment =
 559             !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV));
 560
 561         for (i = 0; eventops[i] && !base->evbase; i++) {
 562                 if (cfg != NULL) {
 563                         /* determine if this backend should be avoided */
 564                         if (event_config_is_avoided_method(cfg,
 565                                 eventops[i]->name))
 566                                 continue;
 567                         if ((eventops[i]->features & cfg->require_features)
 568                             != cfg->require_features)
 569                                 continue;
 570                 }
 571
 572                 /* also obey the environment variables */
 573                 if (should_check_environment &&
 574                     event_is_method_disabled(eventops[i]->name))
 575                         continue;
 576
 577                 base->evsel = eventops[i];
 578
 579                 base->evbase = base->evsel->init(base);
 580         }
 581
 582         if (base->evbase == NULL) {
 583                 event_warnx("%s: no event mechanism available",
 584                     __func__);
 585                 event_base_free(base);
 586                 return NULL;
 587         }
 588
 589         if (evutil_getenv("EVENT_SHOW_METHOD"))
 590                 event_msgx("libevent using: %s", base->evsel->name);
 591
 592         /* allocate a single active event queue */
 593         if (event_base_priority_init(base, 1) < 0) {
 594                 event_base_free(base);
 595                 return NULL;
 596         }
 597
 598         /* prepare for threading */
 599
 600 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
 601         if (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK)) {
 602                 int r;
 603                 EVTHREAD_ALLOC_LOCK(base->th_base_lock,
 604                     EVTHREAD_LOCKTYPE_RECURSIVE);
 605                 base->defer_queue.lock = base->th_base_lock;
 606                 EVTHREAD_ALLOC_COND(base->current_event_cond);
 607                 r = evthread_make_base_notifiable(base);
 608                 if (r<0) {
 609                         event_base_free(base);
 610                         return NULL;
 611                 }
 612         }
 613 #endif
 614
 615 #ifdef WIN32
 616         if (cfg && (cfg->flags & EVENT_BASE_FLAG_STARTUP_IOCP))
 617                 event_base_start_iocp(base, cfg->n_cpus_hint);
 618 #endif
 619
 620         return (base);
 621 }
 622
 623 int
 624 event_base_start_iocp(struct event_base *base, int n_cpus)
 625 {
 626 #ifdef WIN32
 627         if (base->iocp)
 628                 return 0;
 629         base->iocp = event_iocp_port_launch(n_cpus);
 630         if (!base->iocp) {
 631                 event_warnx("%s: Couldn't launch IOCP", __func__);
 632                 return -1;
 633         }
 634         return 0;
 635 #else
 636         return -1;
 637 #endif
 638 }
 639
 640 void
 641 event_base_stop_iocp(struct event_base *base)
 642 {
 643 #ifdef WIN32
 644         int rv;
 645
 646         if (!base->iocp)
 647                 return;
 648         rv = event_iocp_shutdown(base->iocp, -1);
 649         EVUTIL_ASSERT(rv >= 0);
 650         base->iocp = NULL;
 651 #endif
 652 }
 653
 654 void
 655 event_base_free(struct event_base *base)
 656 {
 657         int i, n_deleted=0;
 658         struct event *ev;
 659         /* XXXX grab the lock? If there is contention when one thread frees
 660          * the base, then the contending thread will be very sad soon. */
 661
 662         if (base == NULL && current_base)
 663                 base = current_base;
 664         if (base == current_base)
 665                 current_base = NULL;
 666
 667         /* XXX(niels) - check for internal events first */
 668         EVUTIL_ASSERT(base);
 669
 670 #ifdef WIN32
 671         event_base_stop_iocp(base);
 672 #endif
 673
 674         /* threading fds if we have them */
 675         if (base->th_notify_fd[0] != -1) {
 676                 event_del(&base->th_notify);
 677                 EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);
 678                 if (base->th_notify_fd[1] != -1)
 679                         EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);
 680                 base->th_notify_fd[0] = -1;
 681                 base->th_notify_fd[1] = -1;
 682                 event_debug_unassign(&base->th_notify);
 683         }
 684
 685         /* Delete all non-internal events. */
 686         for (ev = TAILQ_FIRST(&base->eventqueue); ev; ) {
 687                 struct event *next = TAILQ_NEXT(ev, ev_next);
 688                 if (!(ev->ev_flags & EVLIST_INTERNAL)) {
 689                         event_del(ev);
 690                         ++n_deleted;
 691                 }
 692                 ev = next;
 693         }
 694         while ((ev = min_heap_top(&base->timeheap)) != NULL) {
 695                 event_del(ev);
 696                 ++n_deleted;
 697         }
 698         for (i = 0; i < base->n_common_timeouts; ++i) {
 699                 struct common_timeout_list *ctl =
 700                     base->common_timeout_queues[i];
 701                 event_del(&ctl->timeout_event); /* Internal; doesn't count */
 702                 event_debug_unassign(&ctl->timeout_event);
 703                 for (ev = TAILQ_FIRST(&ctl->events); ev; ) {
 704                         struct event *next = TAILQ_NEXT(ev,
 705                             ev_timeout_pos.ev_next_with_common_timeout);
 706                         if (!(ev->ev_flags & EVLIST_INTERNAL)) {
 707                                 event_del(ev);
 708                                 ++n_deleted;
 709                         }
 710                         ev = next;
 711                 }
 712                 mm_free(ctl);
 713         }
 714         if (base->common_timeout_queues)
 715                 mm_free(base->common_timeout_queues);
 716
 717         for (i = 0; i < base->nactivequeues; ++i) {
 718                 for (ev = TAILQ_FIRST(&base->activequeues[i]); ev; ) {
 719                         struct event *next = TAILQ_NEXT(ev, ev_active_next);
 720                         if (!(ev->ev_flags & EVLIST_INTERNAL)) {
 721                                 event_del(ev);
 722                                 ++n_deleted;
 723                         }
 724                         ev = next;
 725                 }
 726         }
 727
 728         if (n_deleted)
 729                 event_debug(("%s: %d events were still set in base",
 730                         __func__, n_deleted));
 731
 732         if (base->evsel != NULL && base->evsel->dealloc != NULL)
 733                 base->evsel->dealloc(base);
 734
 735         for (i = 0; i < base->nactivequeues; ++i)
 736                 EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i]));
 737
 738         EVUTIL_ASSERT(min_heap_empty(&base->timeheap));
 739         min_heap_dtor(&base->timeheap);
 740
 741         mm_free(base->activequeues);
 742
 743         EVUTIL_ASSERT(TAILQ_EMPTY(&base->eventqueue));
 744
 745         evmap_io_clear(&base->io);
 746         evmap_signal_clear(&base->sigmap);
 747         event_changelist_freemem(&base->changelist);
 748
 749         EVTHREAD_FREE_LOCK(base->th_base_lock, EVTHREAD_LOCKTYPE_RECURSIVE);
 750         EVTHREAD_FREE_COND(base->current_event_cond);
 751
 752         mm_free(base);
 753 }
 754
 755 /* reinitialize the event base after a fork */
 756 int
 757 event_reinit(struct event_base *base)
 758 {
 759         const struct eventop *evsel;
 760         int res = 0;
 761         struct event *ev;
 762         int was_notifiable = 0;
 763
 764         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
 765
 766         evsel = base->evsel;
 767
 768 #if 0
 769         /* Right now, reinit always takes effect, since even if the
 770            backend doesn't require it, the signal socketpair code does.
 771
 772            XXX
 773          */
 774         /* check if this event mechanism requires reinit */
 775         if (!evsel->need_reinit)
 776                 goto done;
 777 #endif
 778
 779         /* prevent internal delete */
 780         if (base->sig.ev_signal_added) {
 781                 /* we cannot call event_del here because the base has
 782                  * not been reinitialized yet. */
 783                 event_queue_remove(base, &base->sig.ev_signal,
 784                     EVLIST_INSERTED);
 785                 if (base->sig.ev_signal.ev_flags & EVLIST_ACTIVE)
 786                         event_queue_remove(base, &base->sig.ev_signal,
 787                             EVLIST_ACTIVE);
 788                 base->sig.ev_signal_added = 0;
 789         }
 790         if (base->th_notify_fd[0] != -1) {
 791                 /* we cannot call event_del here because the base has
 792                  * not been reinitialized yet. */
 793                 was_notifiable = 1;
 794                 event_queue_remove(base, &base->th_notify,
 795                     EVLIST_INSERTED);
 796                 if (base->th_notify.ev_flags & EVLIST_ACTIVE)
 797                         event_queue_remove(base, &base->th_notify,
 798                             EVLIST_ACTIVE);
 799                 base->sig.ev_signal_added = 0;
 800                 EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);
 801                 if (base->th_notify_fd[1] != -1)
 802                         EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);
 803                 base->th_notify_fd[0] = -1;
 804                 base->th_notify_fd[1] = -1;
 805                 event_debug_unassign(&base->th_notify);
 806         }
 807
 808         if (base->evsel->dealloc != NULL)
 809                 base->evsel->dealloc(base);
 810         base->evbase = evsel->init(base);
 811         if (base->evbase == NULL) {
 812                 event_errx(1, "%s: could not reinitialize event mechanism",
 813                     __func__);
 814                 res = -1;
 815                 goto done;
 816         }
 817
 818         event_changelist_freemem(&base->changelist); /* XXX */
 819         evmap_io_clear(&base->io);
 820         evmap_signal_clear(&base->sigmap);
 821
 822         TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {
 823                 if (ev->ev_events & (EV_READ|EV_WRITE)) {
 824                         if (evmap_io_add(base, ev->ev_fd, ev) == -1)
 825                                 res = -1;
 826                 } else if (ev->ev_events & EV_SIGNAL) {
 827                         if (evmap_signal_add(base, (int)ev->ev_fd, ev) == -1)
 828                                 res = -1;
 829                 }
 830         }
 831
 832         if (was_notifiable && res == 0)
 833                 res = evthread_make_base_notifiable(base);
 834
 835 done:
 836         EVBASE_RELEASE_LOCK(base, th_base_lock);
 837         return (res);
 838 }
 839
 840 const char **
 841 event_get_supported_methods(void)
 842 {
 843         static const char **methods = NULL;
 844         const struct eventop **method;
 845         const char **tmp;
 846         int i = 0, k;
 847
 848         /* count all methods */
 849         for (method = &eventops[0]; *method != NULL; ++method) {
 850                 ++i;
 851         }
 852
 853         /* allocate one more than we need for the NULL pointer */
 854         tmp = mm_calloc((i + 1), sizeof(char *));
 855         if (tmp == NULL)
 856                 return (NULL);
 857
 858         /* populate the array with the supported methods */
 859         for (k = 0, i = 0; eventops[k] != NULL; ++k) {
 860                 tmp[i++] = eventops[k]->name;
 861         }
 862         tmp[i] = NULL;
 863
 864         if (methods != NULL)
 865                 mm_free((char**)methods);
 866
 867         methods = tmp;
 868
 869         return (methods);
 870 }
 871
 872 struct event_config *
 873 event_config_new(void)
 874 {
 875         struct event_config *cfg = mm_calloc(1, sizeof(*cfg));
 876
 877         if (cfg == NULL)
 878                 return (NULL);
 879
 880         TAILQ_INIT(&cfg->entries);
 881
 882         return (cfg);
 883 }
 884
 885 static void
 886 event_config_entry_free(struct event_config_entry *entry)
 887 {
 888         if (entry->avoid_method != NULL)
 889                 mm_free((char *)entry->avoid_method);
 890         mm_free(entry);
 891 }
 892
 893 void
 894 event_config_free(struct event_config *cfg)
 895 {
 896         struct event_config_entry *entry;
 897
 898         while ((entry = TAILQ_FIRST(&cfg->entries)) != NULL) {
 899                 TAILQ_REMOVE(&cfg->entries, entry, next);
 900                 event_config_entry_free(entry);
 901         }
 902         mm_free(cfg);
 903 }
 904
 905 int
 906 event_config_set_flag(struct event_config *cfg, int flag)
 907 {
 908         if (!cfg)
 909                 return -1;
 910         cfg->flags |= flag;
 911         return 0;
 912 }
 913
 914 int
 915 event_config_avoid_method(struct event_config *cfg, const char *method)
 916 {
 917         struct event_config_entry *entry = mm_malloc(sizeof(*entry));
 918         if (entry == NULL)
 919                 return (-1);
 920
 921         if ((entry->avoid_method = mm_strdup(method)) == NULL) {
 922                 mm_free(entry);
 923                 return (-1);
 924         }
 925
 926         TAILQ_INSERT_TAIL(&cfg->entries, entry, next);
 927
 928         return (0);
 929 }
 930
 931 int
 932 event_config_require_features(struct event_config *cfg,
 933     int features)
 934 {
 935         if (!cfg)
 936                 return (-1);
 937         cfg->require_features = features;
 938         return (0);
 939 }
 940
 941 int
 942 event_config_set_num_cpus_hint(struct event_config *cfg, int cpus)
 943 {
 944         if (!cfg)
 945                 return (-1);
 946         cfg->n_cpus_hint = cpus;
 947         return (0);
 948 }
 949
 950 int
 951 event_priority_init(int npriorities)
 952 {
 953         return event_base_priority_init(current_base, npriorities);
 954 }
 955
 956 int
 957 event_base_priority_init(struct event_base *base, int npriorities)
 958 {
 959         int i;
 960
 961         if (N_ACTIVE_CALLBACKS(base) || npriorities < 1
 962             || npriorities >= EVENT_MAX_PRIORITIES)
 963                 return (-1);
 964
 965         if (npriorities == base->nactivequeues)
 966                 return (0);
 967
 968         if (base->nactivequeues) {
 969                 mm_free(base->activequeues);
 970                 base->nactivequeues = 0;
 971         }
 972
 973         /* Allocate our priority queues */
 974         base->activequeues = (struct event_list *)
 975           mm_calloc(npriorities, sizeof(struct event_list));
 976         if (base->activequeues == NULL) {
 977                 event_warn("%s: calloc", __func__);
 978                 return (-1);
 979         }
 980         base->nactivequeues = npriorities;
 981
 982         for (i = 0; i < base->nactivequeues; ++i) {
 983                 TAILQ_INIT(&base->activequeues[i]);
 984         }
 985
 986         return (0);
 987 }
 988
 989 /* Returns true iff we're currently watching any events. */
 990 static int
 991 event_haveevents(struct event_base *base)
 992 {
 993         /* Caller must hold th_base_lock */
 994         return (base->virtual_event_count > 0 || base->event_count > 0);
 995 }
 996
 997 /* "closure" function called when processing active signal events */
 998 static inline void
 999 event_signal_closure(struct event_base *base, struct event *ev)
1000 {
1001         short ncalls;
1002
1003         /* Allows deletes to work */
1004         ncalls = ev->ev_ncalls;
1005         ev->ev_pncalls = &ncalls;
1006         EVBASE_RELEASE_LOCK(base, th_base_lock);
1007         while (ncalls) {
1008                 ncalls--;
1009                 ev->ev_ncalls = ncalls;
1010                 if (ncalls == 0)
1011                         ev->ev_pncalls = NULL;
1012                 (*ev->ev_callback)((int)ev->ev_fd, ev->ev_res, ev->ev_arg);
1013 #if 0
1014                 /* XXXX we can't do this without a lock on the base. */
1015                 if (base->event_break)
1016                         return;
1017 #endif
1018         }
1019 }
1020
1021 /* Common timeouts are special timeouts that are handled as queues rather than
1022  * in the minheap.  This is more efficient than the minheap if we happen to
1023  * know that we're going to get several thousands of timeout events all with
1024  * the same timeout value.
1025  *
1026  * Since all our timeout handling code assumes timevals can be copied,
1027  * assigned, etc, we can't use "magic pointer" to encode these common
1028  * timeouts.  Searching through a list to see if every timeout is common could
1029  * also get inefficient.  Instead, we take advantage of the fact that tv_usec
1030  * is 32 bits long, but only uses 20 of those bits (since it can never be over
1031  * 999999.)  We use the top bits to encode 4 bites of magic number, and 8 bits
1032  * of index into the event_base's aray of common timeouts.
1033  */
1034
1035 #define MICROSECONDS_MASK       0x000fffff
1036 #define COMMON_TIMEOUT_IDX_MASK 0x0ff00000
1037 #define COMMON_TIMEOUT_IDX_SHIFT 20
1038 #define COMMON_TIMEOUT_MASK     0xf0000000
1039 #define COMMON_TIMEOUT_MAGIC    0x50000000
1040
1041 #define COMMON_TIMEOUT_IDX(tv) \
1042         (((tv)->tv_usec & COMMON_TIMEOUT_IDX_MASK)>>COMMON_TIMEOUT_IDX_SHIFT)
1043
1044 /** Return true iff if 'tv' is a common timeout in 'base' */
1045 static inline int
1046 is_common_timeout(const struct timeval *tv,
1047     const struct event_base *base)
1048 {
1049         int idx;
1050         if ((tv->tv_usec & COMMON_TIMEOUT_MASK) != COMMON_TIMEOUT_MAGIC)
1051                 return 0;
1052         idx = COMMON_TIMEOUT_IDX(tv);
1053         return idx < base->n_common_timeouts;
1054 }
1055
1056 /* True iff tv1 and tv2 have the same common-timeout index, or if neither
1057  * one is a common timeout. */
1058 static inline int
1059 is_same_common_timeout(const struct timeval *tv1, const struct timeval *tv2)
1060 {
1061         return (tv1->tv_usec & ~MICROSECONDS_MASK) ==
1062             (tv2->tv_usec & ~MICROSECONDS_MASK);
1063 }
1064
1065 /** Requires that 'tv' is a common timeout.  Return the corresponding
1066  * common_timeout_list. */
1067 static inline struct common_timeout_list *
1068 get_common_timeout_list(struct event_base *base, const struct timeval *tv)
1069 {
1070         return base->common_timeout_queues[COMMON_TIMEOUT_IDX(tv)];
1071 }
1072
1073 #if 0
1074 static inline int
1075 common_timeout_ok(const struct timeval *tv,
1076     struct event_base *base)
1077 {
1078         const struct timeval *expect =
1079             &get_common_timeout_list(base, tv)->duration;
1080         return tv->tv_sec == expect->tv_sec &&
1081             tv->tv_usec == expect->tv_usec;
1082 }
1083 #endif
1084
1085 /* Add the timeout for the first event in given common timeout list to the
1086  * event_base's minheap. */
1087 static void
1088 common_timeout_schedule(struct common_timeout_list *ctl,
1089     const struct timeval *now, struct event *head)
1090 {
1091         struct timeval timeout = head->ev_timeout;
1092         timeout.tv_usec &= MICROSECONDS_MASK;
1093         event_add_internal(&ctl->timeout_event, &timeout, 1);
1094 }
1095
1096 /* Callback: invoked when the timeout for a common timeout queue triggers.
1097  * This means that (at least) the first event in that queue should be run,
1098  * and the timeout should be rescheduled if there are more events. */
1099 static void
1100 common_timeout_callback(evutil_socket_t fd, short what, void *arg)
1101 {
1102         struct timeval now;
1103         struct common_timeout_list *ctl = arg;
1104         struct event_base *base = ctl->base;
1105         struct event *ev = NULL;
1106         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1107         gettime(base, &now);
1108         while (1) {
1109                 ev = TAILQ_FIRST(&ctl->events);
1110                 if (!ev || ev->ev_timeout.tv_sec > now.tv_sec ||
1111                     (ev->ev_timeout.tv_sec == now.tv_sec &&
1112                         (ev->ev_timeout.tv_usec&MICROSECONDS_MASK) > now.tv_usec))
1113                         break;
1114                 event_del_internal(ev);
1115                 event_active_nolock(ev, EV_TIMEOUT, 1);
1116         }
1117         if (ev)
1118                 common_timeout_schedule(ctl, &now, ev);
1119         EVBASE_RELEASE_LOCK(base, th_base_lock);
1120 }
1121
1122 #define MAX_COMMON_TIMEOUTS 256
1123
1124 const struct timeval *
1125 event_base_init_common_timeout(struct event_base *base,
1126     const struct timeval *duration)
1127 {
1128         int i;
1129         struct timeval tv;
1130         const struct timeval *result=NULL;
1131         struct common_timeout_list *new_ctl;
1132
1133         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1134         if (duration->tv_usec > 1000000) {
1135                 memcpy(&tv, duration, sizeof(struct timeval));
1136                 if (is_common_timeout(duration, base))
1137                         tv.tv_usec &= MICROSECONDS_MASK;
1138                 tv.tv_sec += tv.tv_usec / 1000000;
1139                 tv.tv_usec %= 1000000;
1140                 duration = &tv;
1141         }
1142         for (i = 0; i < base->n_common_timeouts; ++i) {
1143                 const struct common_timeout_list *ctl =
1144                     base->common_timeout_queues[i];
1145                 if (duration->tv_sec == ctl->duration.tv_sec &&
1146                     duration->tv_usec ==
1147                     (ctl->duration.tv_usec & MICROSECONDS_MASK)) {
1148                         EVUTIL_ASSERT(is_common_timeout(&ctl->duration, base));
1149                         result = &ctl->duration;
1150                         goto done;
1151                 }
1152         }
1153         if (base->n_common_timeouts == MAX_COMMON_TIMEOUTS) {
1154                 event_warnx("%s: Too many common timeouts already in use; "
1155                     "we only support %d per event_base", __func__,
1156                     MAX_COMMON_TIMEOUTS);
1157                 goto done;
1158         }
1159         if (base->n_common_timeouts_allocated == base->n_common_timeouts) {
1160                 int n = base->n_common_timeouts < 16 ? 16 :
1161                     base->n_common_timeouts*2;
1162                 struct common_timeout_list **newqueues =
1163                     mm_realloc(base->common_timeout_queues,
1164                         n*sizeof(struct common_timeout_queue *));
1165                 if (!newqueues) {
1166                         event_warn("%s: realloc",__func__);
1167                         goto done;
1168                 }
1169                 base->n_common_timeouts_allocated = n;
1170                 base->common_timeout_queues = newqueues;
1171         }
1172         new_ctl = mm_calloc(1, sizeof(struct common_timeout_list));
1173         if (!new_ctl) {
1174                 event_warn("%s: calloc",__func__);
1175                 goto done;
1176         }
1177         TAILQ_INIT(&new_ctl->events);
1178         new_ctl->duration.tv_sec = duration->tv_sec;
1179         new_ctl->duration.tv_usec =
1180             duration->tv_usec | COMMON_TIMEOUT_MAGIC |
1181             (base->n_common_timeouts << COMMON_TIMEOUT_IDX_SHIFT);
1182         evtimer_assign(&new_ctl->timeout_event, base,
1183             common_timeout_callback, new_ctl);
1184         new_ctl->timeout_event.ev_flags |= EVLIST_INTERNAL;
1185         event_priority_set(&new_ctl->timeout_event, 0);
1186         new_ctl->base = base;
1187         base->common_timeout_queues[base->n_common_timeouts++] = new_ctl;
1188         result = &new_ctl->duration;
1189
1190 done:
1191         if (result)
1192                 EVUTIL_ASSERT(is_common_timeout(result, base));
1193
1194         EVBASE_RELEASE_LOCK(base, th_base_lock);
1195         return result;
1196 }
1197
1198 /* Closure function invoked when we're activating a persistent event. */
1199 static inline void
1200 event_persist_closure(struct event_base *base, struct event *ev)
1201 {
1202         /* reschedule the persistent event if we have a timeout. */
1203         if (ev->ev_io_timeout.tv_sec || ev->ev_io_timeout.tv_usec) {
1204                 /* If there was a timeout, we want it to run at an interval of
1205                  * ev_io_timeout after the last time it was _scheduled_ for,
1206                  * not ev_io_timeout after _now_.  If it fired for another
1207                  * reason, though, the timeout ought to start ticking _now_. */
1208                 struct timeval run_at;
1209                 EVUTIL_ASSERT(is_same_common_timeout(&ev->ev_timeout,
1210                         &ev->ev_io_timeout));
1211                 if (is_common_timeout(&ev->ev_timeout, base)) {
1212                         ev_uint32_t usec_mask;
1213                         struct timeval delay, relative_to;
1214                         delay = ev->ev_io_timeout;
1215                         usec_mask = delay.tv_usec & ~MICROSECONDS_MASK;
1216                         delay.tv_usec &= MICROSECONDS_MASK;
1217                         if (ev->ev_res & EV_TIMEOUT) {
1218                                 relative_to = ev->ev_timeout;
1219                                 relative_to.tv_usec &= MICROSECONDS_MASK;
1220                         } else {
1221                                 gettime(base, &relative_to);
1222                         }
1223                         evutil_timeradd(&relative_to, &delay, &run_at);
1224                         run_at.tv_usec |= usec_mask;
1225                 } else {
1226                         struct timeval relative_to;
1227                         if (ev->ev_res & EV_TIMEOUT) {
1228                                 relative_to = ev->ev_timeout;
1229                         } else {
1230                                 gettime(base, &relative_to);
1231                         }
1232                         evutil_timeradd(&ev->ev_io_timeout, &relative_to,
1233                             &run_at);
1234                 }
1235                 event_add_internal(ev, &run_at, 1);
1236         }
1237         EVBASE_RELEASE_LOCK(base, th_base_lock);
1238         (*ev->ev_callback)((int)ev->ev_fd, ev->ev_res, ev->ev_arg);
1239 }
1240
1241 /*
1242   Helper for event_process_active to process all the events in a single queue,
1243   releasing the lock as we go.  This function requires that the lock be held
1244   when it's invoked.  Returns -1 if we get a signal or an event_break that
1245   means we should stop processing any active events now.  Otherwise returns
1246   the number of non-internal events that we processed.
1247 */
1248 static int
1249 event_process_active_single_queue(struct event_base *base,
1250     struct event_list *activeq)
1251 {
1252         struct event *ev;
1253         int count = 0;
1254
1255         EVUTIL_ASSERT(activeq != NULL);
1256
1257         for (ev = TAILQ_FIRST(activeq); ev; ev = TAILQ_FIRST(activeq)) {
1258                 if (ev->ev_events & EV_PERSIST)
1259                         event_queue_remove(base, ev, EVLIST_ACTIVE);
1260                 else
1261                         event_del_internal(ev);
1262                 if (!(ev->ev_flags & EVLIST_INTERNAL))
1263                         ++count;
1264
1265                 event_debug((
1266                          "event_process_active: event: %p, %s%scall %p",
1267                         ev,
1268                         ev->ev_res & EV_READ ? "EV_READ " : " ",
1269                         ev->ev_res & EV_WRITE ? "EV_WRITE " : " ",
1270                         ev->ev_callback));
1271
1272 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
1273                 base->current_event = ev;
1274                 base->current_event_waiters = 0;
1275 #endif
1276
1277                 switch (ev->ev_closure) {
1278                 case EV_CLOSURE_SIGNAL:
1279                         event_signal_closure(base, ev);
1280                         break;
1281                 case EV_CLOSURE_PERSIST:
1282                         event_persist_closure(base, ev);
1283                         break;
1284                 default:
1285                 case EV_CLOSURE_NONE:
1286                         EVBASE_RELEASE_LOCK(base, th_base_lock);
1287                         (*ev->ev_callback)(
1288                                 (int)ev->ev_fd, ev->ev_res, ev->ev_arg);
1289                         break;
1290                 }
1291
1292                 EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1293 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
1294                 base->current_event = NULL;
1295                 if (base->current_event_waiters) {
1296                         base->current_event_waiters = 0;
1297                         EVTHREAD_COND_BROADCAST(base->current_event_cond);
1298                 }
1299 #endif
1300
1301                 if (base->event_break)
1302                         return -1;
1303         }
1304         return count;
1305 }
1306
1307 /*
1308    Process up to MAX_DEFERRED of the defered_cb entries in 'queue'.  If
1309    *breakptr becomes set to 1, stop.  Requires that we start out holding
1310    the lock on 'queue'; releases the lock around 'queue' for each deferred_cb
1311    we process.
1312  */
1313 static int
1314 event_process_deferred_callbacks(struct deferred_cb_queue *queue, int *breakptr)
1315 {
1316         int count = 0;
1317         struct deferred_cb *cb;
1318
1319 #define MAX_DEFERRED 16
1320         while ((cb = TAILQ_FIRST(&queue->deferred_cb_list))) {
1321                 cb->queued = 0;
1322                 TAILQ_REMOVE(&queue->deferred_cb_list, cb, cb_next);
1323                 --queue->active_count;
1324                 UNLOCK_DEFERRED_QUEUE(queue);
1325
1326                 cb->cb(cb, cb->arg);
1327
1328                 LOCK_DEFERRED_QUEUE(queue);
1329                 if (*breakptr)
1330                         return -1;
1331                 if (++count == MAX_DEFERRED)
1332                         break;
1333         }
1334 #undef MAX_DEFERRED
1335         return count;
1336 }
1337
1338 /*
1339  * Active events are stored in priority queues.  Lower priorities are always
1340  * process before higher priorities.  Low priority events can starve high
1341  * priority ones.
1342  */
1343
1344 static int
1345 event_process_active(struct event_base *base)
1346 {
1347         /* Caller must hold th_base_lock */
1348         struct event_list *activeq = NULL;
1349         int i, c = 0;
1350
1351         for (i = 0; i < base->nactivequeues; ++i) {
1352                 if (TAILQ_FIRST(&base->activequeues[i]) != NULL) {
1353                         activeq = &base->activequeues[i];
1354                         c = event_process_active_single_queue(base, activeq);
1355                         if (c < 0)
1356                                 return -1;
1357                         else if (c > 0)
1358                                 break; /* Processed a real event; do not
1359                                         * consider lower-priority events */
1360                         /* If we get here, all of the events we processed
1361                          * were internal.  Continue. */
1362                 }
1363         }
1364
1365         event_process_deferred_callbacks(&base->defer_queue,&base->event_break);
1366         return c;
1367 }
1368
1369 /*
1370  * Wait continuously for events.  We exit only if no events are left.
1371  */
1372
1373 int
1374 event_dispatch(void)
1375 {
1376         return (event_loop(0));
1377 }
1378
1379 int
1380 event_base_dispatch(struct event_base *event_base)
1381 {
1382         return (event_base_loop(event_base, 0));
1383 }
1384
1385 const char *
1386 event_base_get_method(const struct event_base *base)
1387 {
1388         EVUTIL_ASSERT(base);
1389         return (base->evsel->name);
1390 }
1391
1392 /** Callback: used to implement event_base_loopexit by telling the event_base
1393  * that it's time to exit its loop. */
1394 static void
1395 event_loopexit_cb(evutil_socket_t fd, short what, void *arg)
1396 {
1397         struct event_base *base = arg;
1398         base->event_gotterm = 1;
1399 }
1400
1401 int
1402 event_loopexit(const struct timeval *tv)
1403 {
1404         return (event_once(-1, EV_TIMEOUT, event_loopexit_cb,
1405                     current_base, tv));
1406 }
1407
1408 int
1409 event_base_loopexit(struct event_base *event_base, const struct timeval *tv)
1410 {
1411         return (event_base_once(event_base, -1, EV_TIMEOUT, event_loopexit_cb,
1412                     event_base, tv));
1413 }
1414
1415 int
1416 event_loopbreak(void)
1417 {
1418         return (event_base_loopbreak(current_base));
1419 }
1420
1421 int
1422 event_base_loopbreak(struct event_base *event_base)
1423 {
1424         int r = 0;
1425         if (event_base == NULL)
1426                 return (-1);
1427
1428         EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1429         event_base->event_break = 1;
1430
1431         if (EVBASE_NEED_NOTIFY(event_base)) {
1432                 r = evthread_notify_base(event_base);
1433         } else {
1434                 r = (0);
1435         }
1436         EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1437         return r;
1438 }
1439
1440 int
1441 event_base_got_break(struct event_base *event_base)
1442 {
1443         int res;
1444         EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1445         res = event_base->event_break;
1446         EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1447         return res;
1448 }
1449
1450 int
1451 event_base_got_exit(struct event_base *event_base)
1452 {
1453         int res;
1454         EVBASE_ACQUIRE_LOCK(event_base, th_base_lock);
1455         res = event_base->event_gotterm;
1456         EVBASE_RELEASE_LOCK(event_base, th_base_lock);
1457         return res;
1458 }
1459
1460 /* not thread safe */
1461
1462 int
1463 event_loop(int flags)
1464 {
1465         return event_base_loop(current_base, flags);
1466 }
1467
1468 int
1469 event_base_loop(struct event_base *base, int flags)
1470 {
1471         const struct eventop *evsel = base->evsel;
1472         struct timeval tv;
1473         struct timeval *tv_p;
1474         int res, done, retval = 0;
1475
1476         /* Grab the lock.  We will release it inside evsel.dispatch, and again
1477          * as we invoke user callbacks. */
1478         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
1479
1480         if (base->running_loop) {
1481                 event_warnx("%s: reentrant invocation.  Only one event_base_loop"
1482                     " can run on each event_base at once.", __func__);
1483                 EVBASE_RELEASE_LOCK(base, th_base_lock);
1484                 return -1;
1485         }
1486
1487         base->running_loop = 1;
1488
1489         clear_time_cache(base);
1490
1491         if (base->sig.ev_signal_added && base->sig.ev_n_signals_added)
1492                 evsig_set_base(base);
1493
1494         done = 0;
1495
1496 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
1497         base->th_owner_id = EVTHREAD_GET_ID();
1498 #endif
1499
1500         base->event_gotterm = base->event_break = 0;
1501
1502         while (!done) {
1503                 /* Terminate the loop if we have been asked to */
1504                 if (base->event_gotterm) {
1505                         break;
1506                 }
1507
1508                 if (base->event_break) {
1509                         break;
1510                 }
1511
1512                 timeout_correct(base, &tv);
1513
1514                 tv_p = &tv;
1515                 if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) {
1516                         timeout_next(base, &tv_p);
1517                 } else {
1518                         /*
1519                          * if we have active events, we just poll new events
1520                          * without waiting.
1521                          */
1522                         evutil_timerclear(&tv);
1523                 }
1524
1525                 /* If we have no events, we just exit */
1526                 if (!event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) {
1527                         event_debug(("%s: no events registered.", __func__));
1528                         retval = 1;
1529                         goto done;
1530                 }
1531
1532                 /* update last old time */
1533                 gettime(base, &base->event_tv);
1534
1535                 clear_time_cache(base);
1536
1537                 res = evsel->dispatch(base, tv_p);
1538
1539                 if (res == -1) {
1540                         event_debug(("%s: dispatch returned unsuccessfully.",
1541                                 __func__));
1542                         retval = -1;
1543                         goto done;
1544                 }
1545
1546                 update_time_cache(base);
1547
1548                 timeout_process(base);
1549
1550                 if (N_ACTIVE_CALLBACKS(base)) {
1551                         int n = event_process_active(base);
1552                         if ((flags & EVLOOP_ONCE)
1553                             && N_ACTIVE_CALLBACKS(base) == 0
1554                             && n != 0)
1555                                 done = 1;
1556                 } else if (flags & EVLOOP_NONBLOCK)
1557                         done = 1;
1558         }
1559         event_debug(("%s: asked to terminate loop.", __func__));
1560
1561 done:
1562         clear_time_cache(base);
1563         base->running_loop = 0;
1564
1565         EVBASE_RELEASE_LOCK(base, th_base_lock);
1566
1567         return (retval);
1568 }
1569
1570 /* Sets up an event for processing once */
1571 struct event_once {
1572         struct event ev;
1573
1574         void (*cb)(evutil_socket_t, short, void *);
1575         void *arg;
1576 };
1577
1578 /* One-time callback to implement event_base_once: invokes the user callback,
1579  * then deletes the allocated storage */
1580 static void
1581 event_once_cb(evutil_socket_t fd, short events, void *arg)
1582 {
1583         struct event_once *eonce = arg;
1584
1585         (*eonce->cb)(fd, events, eonce->arg);
1586         event_debug_unassign(&eonce->ev);
1587         mm_free(eonce);
1588 }
1589
1590 /* not threadsafe, event scheduled once. */
1591 int
1592 event_once(evutil_socket_t fd, short events,
1593     void (*callback)(evutil_socket_t, short, void *),
1594     void *arg, const struct timeval *tv)
1595 {
1596         return event_base_once(current_base, fd, events, callback, arg, tv);
1597 }
1598
1599 /* Schedules an event once */
1600 int
1601 event_base_once(struct event_base *base, evutil_socket_t fd, short events,
1602     void (*callback)(evutil_socket_t, short, void *),
1603     void *arg, const struct timeval *tv)
1604 {
1605         struct event_once *eonce;
1606         struct timeval etv;
1607         int res = 0;
1608
1609         /* We cannot support signals that just fire once, or persistent
1610          * events. */
1611         if (events & (EV_SIGNAL|EV_PERSIST))
1612                 return (-1);
1613
1614         if ((eonce = mm_calloc(1, sizeof(struct event_once))) == NULL)
1615                 return (-1);
1616
1617         eonce->cb = callback;
1618         eonce->arg = arg;
1619
1620         if (events == EV_TIMEOUT) {
1621                 if (tv == NULL) {
1622                         evutil_timerclear(&etv);
1623                         tv = &etv;
1624                 }
1625
1626                 evtimer_assign(&eonce->ev, base, event_once_cb, eonce);
1627         } else if (events & (EV_READ|EV_WRITE)) {
1628                 events &= EV_READ|EV_WRITE;
1629
1630                 event_assign(&eonce->ev, base, fd, events, event_once_cb, eonce);
1631         } else {
1632                 /* Bad event combination */
1633                 mm_free(eonce);
1634                 return (-1);
1635         }
1636
1637         if (res == 0)
1638                 res = event_add(&eonce->ev, tv);
1639         if (res != 0) {
1640                 mm_free(eonce);
1641                 return (res);
1642         }
1643
1644         return (0);
1645 }
1646
1647 int
1648 event_assign(struct event *ev, struct event_base *base, evutil_socket_t fd, short events, void (*callback)(evutil_socket_t, short, void *), void *arg)
1649 {
1650         if (!base)
1651                 base = current_base;
1652
1653         _event_debug_assert_not_added(ev);
1654
1655         ev->ev_base = base;
1656
1657         ev->ev_callback = callback;
1658         ev->ev_arg = arg;
1659         ev->ev_fd = fd;
1660         ev->ev_events = events;
1661         ev->ev_res = 0;
1662         ev->ev_flags = EVLIST_INIT;
1663         ev->ev_ncalls = 0;
1664         ev->ev_pncalls = NULL;
1665
1666         if (events & EV_SIGNAL) {
1667                 if ((events & (EV_READ|EV_WRITE)) != 0) {
1668                         event_warnx("%s: EV_SIGNAL is not compatible with "
1669                             "EV_READ or EV_WRITE", __func__);
1670                         return -1;
1671                 }
1672                 ev->ev_closure = EV_CLOSURE_SIGNAL;
1673         } else {
1674                 if (events & EV_PERSIST) {
1675                         evutil_timerclear(&ev->ev_io_timeout);
1676                         ev->ev_closure = EV_CLOSURE_PERSIST;
1677                 } else {
1678                         ev->ev_closure = EV_CLOSURE_NONE;
1679                 }
1680         }
1681
1682         min_heap_elem_init(ev);
1683
1684         if (base != NULL) {
1685                 /* by default, we put new events into the middle priority */
1686                 ev->ev_pri = base->nactivequeues / 2;
1687         }
1688
1689         _event_debug_note_setup(ev);
1690
1691         return 0;
1692 }
1693
1694 int
1695 event_base_set(struct event_base *base, struct event *ev)
1696 {
1697         /* Only innocent events may be assigned to a different base */
1698         if (ev->ev_flags != EVLIST_INIT)
1699                 return (-1);
1700
1701         _event_debug_assert_is_setup(ev);
1702
1703         ev->ev_base = base;
1704         ev->ev_pri = base->nactivequeues/2;
1705
1706         return (0);
1707 }
1708
1709 void
1710 event_set(struct event *ev, evutil_socket_t fd, short events,
1711           void (*callback)(evutil_socket_t, short, void *), void *arg)
1712 {
1713         int r;
1714         r = event_assign(ev, current_base, fd, events, callback, arg);
1715         EVUTIL_ASSERT(r == 0);
1716 }
1717
1718 struct event *
1719 event_new(struct event_base *base, evutil_socket_t fd, short events, void (*cb)(evutil_socket_t, short, void *), void *arg)
1720 {
1721         struct event *ev;
1722         ev = mm_malloc(sizeof(struct event));
1723         if (ev == NULL)
1724                 return (NULL);
1725         if (event_assign(ev, base, fd, events, cb, arg) < 0) {
1726                 mm_free(ev);
1727                 return (NULL);
1728         }
1729
1730         return (ev);
1731 }
1732
1733 void
1734 event_free(struct event *ev)
1735 {
1736         _event_debug_assert_is_setup(ev);
1737
1738         /* make sure that this event won't be coming back to haunt us. */
1739         event_del(ev);
1740         _event_debug_note_teardown(ev);
1741         mm_free(ev);
1742
1743 }
1744
1745 void
1746 event_debug_unassign(struct event *ev)
1747 {
1748         _event_debug_assert_not_added(ev);
1749         _event_debug_note_teardown(ev);
1750
1751         ev->ev_flags &= ~EVLIST_INIT;
1752 }
1753
1754 /*
1755  * Set's the priority of an event - if an event is already scheduled
1756  * changing the priority is going to fail.
1757  */
1758
1759 int
1760 event_priority_set(struct event *ev, int pri)
1761 {
1762         _event_debug_assert_is_setup(ev);
1763
1764         if (ev->ev_flags & EVLIST_ACTIVE)
1765                 return (-1);
1766         if (pri < 0 || pri >= ev->ev_base->nactivequeues)
1767                 return (-1);
1768
1769         ev->ev_pri = pri;
1770
1771         return (0);
1772 }
1773
1774 /*
1775  * Checks if a specific event is pending or scheduled.
1776  */
1777
1778 int
1779 event_pending(const struct event *ev, short event, struct timeval *tv)
1780 {
1781         struct timeval  now, res;
1782         int flags = 0;
1783
1784         _event_debug_assert_is_setup(ev);
1785
1786         if (ev->ev_flags & EVLIST_INSERTED)
1787                 flags |= (ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL));
1788         if (ev->ev_flags & EVLIST_ACTIVE)
1789                 flags |= ev->ev_res;
1790         if (ev->ev_flags & EVLIST_TIMEOUT)
1791                 flags |= EV_TIMEOUT;
1792
1793         event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_SIGNAL);
1794
1795         /* See if there is a timeout that we should report */
1796         if (tv != NULL && (flags & event & EV_TIMEOUT)) {
1797                 struct timeval tmp = ev->ev_timeout;
1798                 event_base_gettimeofday_cached(ev->ev_base, &now);
1799                 tmp.tv_usec &= MICROSECONDS_MASK;
1800                 evutil_timersub(&tmp, &now, &res);
1801                 /* correctly remap to real time */
1802                 evutil_gettimeofday(&now, NULL);
1803                 evutil_timeradd(&now, &res, tv);
1804         }
1805
1806         return (flags & event);
1807 }
1808
1809 int
1810 event_initialized(const struct event *ev)
1811 {
1812         if (!(ev->ev_flags & EVLIST_INIT))
1813                 return 0;
1814
1815         return 1;
1816 }
1817
1818 void
1819 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)
1820 {
1821         _event_debug_assert_is_setup(event);
1822
1823         if (base_out)
1824                 *base_out = event->ev_base;
1825         if (fd_out)
1826                 *fd_out = event->ev_fd;
1827         if (events_out)
1828                 *events_out = event->ev_events;
1829         if (callback_out)
1830                 *callback_out = event->ev_callback;
1831         if (arg_out)
1832                 *arg_out = event->ev_arg;
1833 }
1834
1835 size_t
1836 event_get_struct_event_size(void)
1837 {
1838         return sizeof(struct event);
1839 }
1840
1841 evutil_socket_t
1842 event_get_fd(const struct event *ev)
1843 {
1844         _event_debug_assert_is_setup(ev);
1845         return ev->ev_fd;
1846 }
1847
1848 struct event_base *
1849 event_get_base(const struct event *ev)
1850 {
1851         _event_debug_assert_is_setup(ev);
1852         return ev->ev_base;
1853 }
1854
1855 short
1856 event_get_events(const struct event *ev)
1857 {
1858         _event_debug_assert_is_setup(ev);
1859         return ev->ev_events;
1860 }
1861
1862 event_callback_fn
1863 event_get_callback(const struct event *ev)
1864 {
1865         _event_debug_assert_is_setup(ev);
1866         return ev->ev_callback;
1867 }
1868
1869 void *
1870 event_get_callback_arg(const struct event *ev)
1871 {
1872         _event_debug_assert_is_setup(ev);
1873         return ev->ev_arg;
1874 }
1875
1876 int
1877 event_add(struct event *ev, const struct timeval *tv)
1878 {
1879         int res;
1880
1881         if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
1882                 event_warnx("%s: event has no event_base set.", __func__);
1883                 return -1;
1884         }
1885
1886         EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
1887
1888         res = event_add_internal(ev, tv, 0);
1889
1890         EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
1891
1892         return (res);
1893 }
1894
1895 /* Helper callback: wake an event_base from another thread.  This version
1896  * works by writing a byte to one end of a socketpair, so that the event_base
1897  * listening on the other end will wake up as the corresponding event
1898  * triggers */
1899 static int
1900 evthread_notify_base_default(struct event_base *base)
1901 {
1902         char buf[1];
1903         int r;
1904         buf[0] = (char) 0;
1905 #ifdef WIN32
1906         r = send(base->th_notify_fd[1], buf, 1, 0);
1907 #else
1908         r = write(base->th_notify_fd[1], buf, 1);
1909 #endif
1910         return (r < 0 && errno != EAGAIN) ? -1 : 0;
1911 }
1912
1913 #if defined(_EVENT_HAVE_EVENTFD) && defined(_EVENT_HAVE_SYS_EVENTFD_H)
1914 /* Helper callback: wake an event_base from another thread.  This version
1915  * assumes that you have a working eventfd() implementation. */
1916 static int
1917 evthread_notify_base_eventfd(struct event_base *base)
1918 {
1919         ev_uint64_t msg = 1;
1920         int r;
1921         do {
1922                 r = write(base->th_notify_fd[0], (void*) &msg, sizeof(msg));
1923         } while (r < 0 && errno == EAGAIN);
1924
1925         return (r < 0) ? -1 : 0;
1926 }
1927 #endif
1928
1929 /** Tell the thread currently running the event_loop for base (if any) that it
1930  * needs to stop waiting in its dispatch function (if it is) and process all
1931  * active events and deferred callbacks (if there are any).  */
1932 static int
1933 evthread_notify_base(struct event_base *base)
1934 {
1935         EVENT_BASE_ASSERT_LOCKED(base);
1936         if (!base->th_notify_fn)
1937                 return -1;
1938         if (base->is_notify_pending)
1939                 return 0;
1940         base->is_notify_pending = 1;
1941         return base->th_notify_fn(base);
1942 }
1943
1944 /* Implementation function to add an event.  Works just like event_add,
1945  * except: 1) it requires that we have the lock.  2) if tv_is_absolute is set,
1946  * we treat tv as an absolute time, not as an interval to add to the current
1947  * time */
1948 static inline int
1949 event_add_internal(struct event *ev, const struct timeval *tv,
1950     int tv_is_absolute)
1951 {
1952         struct event_base *base = ev->ev_base;
1953         int res = 0;
1954         int notify = 0;
1955
1956         EVENT_BASE_ASSERT_LOCKED(base);
1957         _event_debug_assert_is_setup(ev);
1958
1959         event_debug((
1960                  "event_add: event: %p (fd %d), %s%s%scall %p",
1961                  ev,
1962                  (int)ev->ev_fd,
1963                  ev->ev_events & EV_READ ? "EV_READ " : " ",
1964                  ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
1965                  tv ? "EV_TIMEOUT " : " ",
1966                  ev->ev_callback));
1967
1968         EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
1969
1970         /*
1971          * prepare for timeout insertion further below, if we get a
1972          * failure on any step, we should not change any state.
1973          */
1974         if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
1975                 if (min_heap_reserve(&base->timeheap,
1976                         1 + min_heap_size(&base->timeheap)) == -1)
1977                         return (-1);  /* ENOMEM == errno */
1978         }
1979
1980         /* If the main thread is currently executing a signal event's
1981          * callback, and we are not the main thread, then we want to wait
1982          * until the callback is done before we mess with the event, or else
1983          * we can race on ev_ncalls and ev_pncalls below. */
1984 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
1985         if (base->current_event == ev && (ev->ev_events & EV_SIGNAL)
1986             && !EVBASE_IN_THREAD(base)) {
1987                 ++base->current_event_waiters;
1988                 EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
1989         }
1990 #endif
1991
1992         if ((ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)) &&
1993             !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) {
1994                 if (ev->ev_events & (EV_READ|EV_WRITE))
1995                         res = evmap_io_add(base, ev->ev_fd, ev);
1996                 else if (ev->ev_events & EV_SIGNAL)
1997                         res = evmap_signal_add(base, (int)ev->ev_fd, ev);
1998                 if (res != -1)
1999                         event_queue_insert(base, ev, EVLIST_INSERTED);
2000                 if (res == 1) {
2001                         /* evmap says we need to notify the main thread. */
2002                         notify = 1;
2003                         res = 0;
2004                 }
2005         }
2006
2007         /*
2008          * we should change the timeout state only if the previous event
2009          * addition succeeded.
2010          */
2011         if (res != -1 && tv != NULL) {
2012                 struct timeval now;
2013                 int common_timeout;
2014
2015                 /*
2016                  * for persistent timeout events, we remember the
2017                  * timeout value and re-add the event.
2018                  *
2019                  * If tv_is_absolute, this was already set.
2020                  */
2021                 if (ev->ev_closure == EV_CLOSURE_PERSIST && !tv_is_absolute)
2022                         ev->ev_io_timeout = *tv;
2023
2024                 /*
2025                  * we already reserved memory above for the case where we
2026                  * are not replacing an existing timeout.
2027                  */
2028                 if (ev->ev_flags & EVLIST_TIMEOUT) {
2029                         /* XXX I believe this is needless. */
2030                         if (min_heap_elt_is_top(ev))
2031                                 notify = 1;
2032                         event_queue_remove(base, ev, EVLIST_TIMEOUT);
2033                 }
2034
2035                 /* Check if it is active due to a timeout.  Rescheduling
2036                  * this timeout before the callback can be executed
2037                  * removes it from the active list. */
2038                 if ((ev->ev_flags & EVLIST_ACTIVE) &&
2039                     (ev->ev_res & EV_TIMEOUT)) {
2040                         if (ev->ev_events & EV_SIGNAL) {
2041                                 /* See if we are just active executing
2042                                  * this event in a loop
2043                                  */
2044                                 if (ev->ev_ncalls && ev->ev_pncalls) {
2045                                         /* Abort loop */
2046                                         *ev->ev_pncalls = 0;
2047                                 }
2048                         }
2049
2050                         event_queue_remove(base, ev, EVLIST_ACTIVE);
2051                 }
2052
2053                 gettime(base, &now);
2054
2055                 common_timeout = is_common_timeout(tv, base);
2056                 if (tv_is_absolute) {
2057                         ev->ev_timeout = *tv;
2058                 } else if (common_timeout) {
2059                         struct timeval tmp = *tv;
2060                         tmp.tv_usec &= MICROSECONDS_MASK;
2061                         evutil_timeradd(&now, &tmp, &ev->ev_timeout);
2062                         ev->ev_timeout.tv_usec |=
2063                             (tv->tv_usec & ~MICROSECONDS_MASK);
2064                 } else {
2065                         evutil_timeradd(&now, tv, &ev->ev_timeout);
2066                 }
2067
2068                 event_debug((
2069                          "event_add: timeout in %d seconds, call %p",
2070                          (int)tv->tv_sec, ev->ev_callback));
2071
2072                 event_queue_insert(base, ev, EVLIST_TIMEOUT);
2073                 if (common_timeout) {
2074                         struct common_timeout_list *ctl =
2075                             get_common_timeout_list(base, &ev->ev_timeout);
2076                         if (ev == TAILQ_FIRST(&ctl->events)) {
2077                                 common_timeout_schedule(ctl, &now, ev);
2078                         }
2079                 } else {
2080                         /* See if the earliest timeout is now earlier than it
2081                          * was before: if so, we will need to tell the main
2082                          * thread to wake up earlier than it would
2083                          * otherwise. */
2084                         if (min_heap_elt_is_top(ev))
2085                                 notify = 1;
2086                 }
2087         }
2088
2089         /* if we are not in the right thread, we need to wake up the loop */
2090         if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
2091                 evthread_notify_base(base);
2092
2093         _event_debug_note_add(ev);
2094
2095         return (res);
2096 }
2097
2098 int
2099 event_del(struct event *ev)
2100 {
2101         int res;
2102
2103         if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
2104                 event_warnx("%s: event has no event_base set.", __func__);
2105                 return -1;
2106         }
2107
2108         EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2109
2110         res = event_del_internal(ev);
2111
2112         EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2113
2114         return (res);
2115 }
2116
2117 /* Helper for event_del: always called with th_base_lock held. */
2118 static inline int
2119 event_del_internal(struct event *ev)
2120 {
2121         struct event_base *base;
2122         int res = 0, notify = 0;
2123
2124         event_debug(("event_del: %p (fd %d), callback %p",
2125                 ev, (int)ev->ev_fd, ev->ev_callback));
2126
2127         /* An event without a base has not been added */
2128         if (ev->ev_base == NULL)
2129                 return (-1);
2130
2131         EVENT_BASE_ASSERT_LOCKED(ev->ev_base);
2132
2133         /* If the main thread is currently executing this event's callback,
2134          * and we are not the main thread, then we want to wait until the
2135          * callback is done before we start removing the event.  That way,
2136          * when this function returns, it will be safe to free the
2137          * user-supplied argument. */
2138         base = ev->ev_base;
2139 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
2140         if (base->current_event == ev && !EVBASE_IN_THREAD(base)) {
2141                 ++base->current_event_waiters;
2142                 EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
2143         }
2144 #endif
2145
2146         EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
2147
2148         /* See if we are just active executing this event in a loop */
2149         if (ev->ev_events & EV_SIGNAL) {
2150                 if (ev->ev_ncalls && ev->ev_pncalls) {
2151                         /* Abort loop */
2152                         *ev->ev_pncalls = 0;
2153                 }
2154         }
2155
2156         if (ev->ev_flags & EVLIST_TIMEOUT) {
2157                 /* NOTE: We never need to notify the main thread because of a
2158                  * deleted timeout event: all that could happen if we don't is
2159                  * that the dispatch loop might wake up too early.  But the
2160                  * point of notifying the main thread _is_ to wake up the
2161                  * dispatch loop early anyway, so we wouldn't gain anything by
2162                  * doing it.
2163                  */
2164                 event_queue_remove(base, ev, EVLIST_TIMEOUT);
2165         }
2166
2167         if (ev->ev_flags & EVLIST_ACTIVE)
2168                 event_queue_remove(base, ev, EVLIST_ACTIVE);
2169
2170         if (ev->ev_flags & EVLIST_INSERTED) {
2171                 event_queue_remove(base, ev, EVLIST_INSERTED);
2172                 if (ev->ev_events & (EV_READ|EV_WRITE))
2173                         res = evmap_io_del(base, ev->ev_fd, ev);
2174                 else
2175                         res = evmap_signal_del(base, (int)ev->ev_fd, ev);
2176                 if (res == 1) {
2177                         /* evmap says we need to notify the main thread. */
2178                         notify = 1;
2179                         res = 0;
2180                 }
2181         }
2182
2183         /* if we are not in the right thread, we need to wake up the loop */
2184         if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
2185                 evthread_notify_base(base);
2186
2187         _event_debug_note_del(ev);
2188
2189         return (res);
2190 }
2191
2192 void
2193 event_active(struct event *ev, int res, short ncalls)
2194 {
2195         if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
2196                 event_warnx("%s: event has no event_base set.", __func__);
2197                 return;
2198         }
2199
2200         EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
2201
2202         _event_debug_assert_is_setup(ev);
2203
2204         event_active_nolock(ev, res, ncalls);
2205
2206         EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
2207 }
2208
2209
2210 void
2211 event_active_nolock(struct event *ev, int res, short ncalls)
2212 {
2213         struct event_base *base;
2214
2215         event_debug(("event_active: %p (fd %d), res %d, callback %p",
2216                 ev, (int)ev->ev_fd, (int)res, ev->ev_callback));
2217
2218
2219         /* We get different kinds of events, add them together */
2220         if (ev->ev_flags & EVLIST_ACTIVE) {
2221                 ev->ev_res |= res;
2222                 return;
2223         }
2224
2225         base = ev->ev_base;
2226
2227         EVENT_BASE_ASSERT_LOCKED(base);
2228
2229         ev->ev_res = res;
2230
2231         if (ev->ev_events & EV_SIGNAL) {
2232 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
2233                 if (base->current_event == ev && !EVBASE_IN_THREAD(base)) {
2234                         ++base->current_event_waiters;
2235                         EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
2236                 }
2237 #endif
2238                 ev->ev_ncalls = ncalls;
2239                 ev->ev_pncalls = NULL;
2240         }
2241
2242         event_queue_insert(base, ev, EVLIST_ACTIVE);
2243
2244         if (EVBASE_NEED_NOTIFY(base))
2245                 evthread_notify_base(base);
2246 }
2247
2248 void
2249 event_deferred_cb_init(struct deferred_cb *cb, deferred_cb_fn fn, void *arg)
2250 {
2251         memset(cb, 0, sizeof(struct deferred_cb));
2252         cb->cb = fn;
2253         cb->arg = arg;
2254 }
2255
2256 void
2257 event_deferred_cb_cancel(struct deferred_cb_queue *queue,
2258     struct deferred_cb *cb)
2259 {
2260         if (!queue) {
2261                 if (current_base)
2262                         queue = &current_base->defer_queue;
2263                 else
2264                         return;
2265         }
2266
2267         LOCK_DEFERRED_QUEUE(queue);
2268         if (cb->queued) {
2269                 TAILQ_REMOVE(&queue->deferred_cb_list, cb, cb_next);
2270                 --queue->active_count;
2271                 cb->queued = 0;
2272         }
2273         UNLOCK_DEFERRED_QUEUE(queue);
2274 }
2275
2276 void
2277 event_deferred_cb_schedule(struct deferred_cb_queue *queue,
2278     struct deferred_cb *cb)
2279 {
2280         if (!queue) {
2281                 if (current_base)
2282                         queue = &current_base->defer_queue;
2283                 else
2284                         return;
2285         }
2286
2287         LOCK_DEFERRED_QUEUE(queue);
2288         if (!cb->queued) {
2289                 cb->queued = 1;
2290                 TAILQ_INSERT_TAIL(&queue->deferred_cb_list, cb, cb_next);
2291                 ++queue->active_count;
2292                 if (queue->notify_fn)
2293                         queue->notify_fn(queue, queue->notify_arg);
2294         }
2295         UNLOCK_DEFERRED_QUEUE(queue);
2296 }
2297
2298 static int
2299 timeout_next(struct event_base *base, struct timeval **tv_p)
2300 {
2301         /* Caller must hold th_base_lock */
2302         struct timeval now;
2303         struct event *ev;
2304         struct timeval *tv = *tv_p;
2305         int res = 0;
2306
2307         ev = min_heap_top(&base->timeheap);
2308
2309         if (ev == NULL) {
2310                 /* if no time-based events are active wait for I/O */
2311                 *tv_p = NULL;
2312                 goto out;
2313         }
2314
2315         if (gettime(base, &now) == -1) {
2316                 res = -1;
2317                 goto out;
2318         }
2319
2320         if (evutil_timercmp(&ev->ev_timeout, &now, <=)) {
2321                 evutil_timerclear(tv);
2322                 goto out;
2323         }
2324
2325         evutil_timersub(&ev->ev_timeout, &now, tv);
2326
2327         EVUTIL_ASSERT(tv->tv_sec >= 0);
2328         EVUTIL_ASSERT(tv->tv_usec >= 0);
2329         event_debug(("timeout_next: in %d seconds", (int)tv->tv_sec));
2330
2331 out:
2332         return (res);
2333 }
2334
2335 /*
2336  * Determines if the time is running backwards by comparing the current time
2337  * against the last time we checked.  Not needed when using clock monotonic.
2338  * If time is running backwards, we adjust the firing time of every event by
2339  * the amount that time seems to have jumped.
2340  */
2341 static void
2342 timeout_correct(struct event_base *base, struct timeval *tv)
2343 {
2344         /* Caller must hold th_base_lock. */
2345         struct event **pev;
2346         unsigned int size;
2347         struct timeval off;
2348         int i;
2349
2350         if (use_monotonic)
2351                 return;
2352
2353         /* Check if time is running backwards */
2354         gettime(base, tv);
2355
2356         if (evutil_timercmp(tv, &base->event_tv, >=)) {
2357                 base->event_tv = *tv;
2358                 return;
2359         }
2360
2361         event_debug(("%s: time is running backwards, corrected",
2362                     __func__));
2363         evutil_timersub(&base->event_tv, tv, &off);
2364
2365         /*
2366          * We can modify the key element of the node without destroying
2367          * the minheap property, because we change every element.
2368          */
2369         pev = base->timeheap.p;
2370         size = base->timeheap.n;
2371         for (; size-- > 0; ++pev) {
2372                 struct timeval *ev_tv = &(**pev).ev_timeout;
2373                 evutil_timersub(ev_tv, &off, ev_tv);
2374         }
2375         for (i=0; i<base->n_common_timeouts; ++i) {
2376                 struct event *ev;
2377                 struct common_timeout_list *ctl =
2378                     base->common_timeout_queues[i];
2379                 TAILQ_FOREACH(ev, &ctl->events,
2380                     ev_timeout_pos.ev_next_with_common_timeout) {
2381                         struct timeval *ev_tv = &ev->ev_timeout;
2382                         ev_tv->tv_usec &= MICROSECONDS_MASK;
2383                         evutil_timersub(ev_tv, &off, ev_tv);
2384                         ev_tv->tv_usec |= COMMON_TIMEOUT_MAGIC |
2385                             (i<<COMMON_TIMEOUT_IDX_SHIFT);
2386                 }
2387         }
2388
2389         /* Now remember what the new time turned out to be. */
2390         base->event_tv = *tv;
2391 }
2392
2393 /* Activate every event whose timeout has elapsed. */
2394 static void
2395 timeout_process(struct event_base *base)
2396 {
2397         /* Caller must hold lock. */
2398         struct timeval now;
2399         struct event *ev;
2400
2401         if (min_heap_empty(&base->timeheap)) {
2402                 return;
2403         }
2404
2405         gettime(base, &now);
2406
2407         while ((ev = min_heap_top(&base->timeheap))) {
2408                 if (evutil_timercmp(&ev->ev_timeout, &now, >))
2409                         break;
2410
2411                 /* delete this event from the I/O queues */
2412                 event_del_internal(ev);
2413
2414                 event_debug(("timeout_process: call %p",
2415                          ev->ev_callback));
2416                 event_active_nolock(ev, EV_TIMEOUT, 1);
2417         }
2418 }
2419
2420 /* Remove 'ev' from 'queue' (EVLIST_...) in base. */
2421 static void
2422 event_queue_remove(struct event_base *base, struct event *ev, int queue)
2423 {
2424         EVENT_BASE_ASSERT_LOCKED(base);
2425
2426         if (!(ev->ev_flags & queue)) {
2427                 event_errx(1, "%s: %p(fd %d) not on queue %x", __func__,
2428                            ev, ev->ev_fd, queue);
2429                 return;
2430         }
2431
2432         if (~ev->ev_flags & EVLIST_INTERNAL)
2433                 base->event_count--;
2434
2435         ev->ev_flags &= ~queue;
2436         switch (queue) {
2437         case EVLIST_INSERTED:
2438                 TAILQ_REMOVE(&base->eventqueue, ev, ev_next);
2439                 break;
2440         case EVLIST_ACTIVE:
2441                 base->event_count_active--;
2442                 TAILQ_REMOVE(&base->activequeues[ev->ev_pri],
2443                     ev, ev_active_next);
2444                 break;
2445         case EVLIST_TIMEOUT:
2446                 if (is_common_timeout(&ev->ev_timeout, base)) {
2447                         struct common_timeout_list *ctl =
2448                             get_common_timeout_list(base, &ev->ev_timeout);
2449                         TAILQ_REMOVE(&ctl->events, ev,
2450                             ev_timeout_pos.ev_next_with_common_timeout);
2451                 } else {
2452                         min_heap_erase(&base->timeheap, ev);
2453                 }
2454                 break;
2455         default:
2456                 event_errx(1, "%s: unknown queue %x", __func__, queue);
2457         }
2458 }
2459
2460 /* Add 'ev' to the common timeout list in 'ev'. */
2461 static void
2462 insert_common_timeout_inorder(struct common_timeout_list *ctl,
2463     struct event *ev)
2464 {
2465         struct event *e;
2466         /* By all logic, we should just be able to append 'ev' to the end of
2467          * ctl->events, since the timeout on each 'ev' is set to {the common
2468          * timeout} + {the time when we add the event}, and so the events
2469          * should arrive in order of their timeeouts.  But just in case
2470          * there's some wacky threading issue going on, we do a search from
2471          * the end of 'ev' to find the right insertion point.
2472          */
2473         TAILQ_FOREACH_REVERSE(e, &ctl->events,
2474             event_list, ev_timeout_pos.ev_next_with_common_timeout) {
2475                 /* This timercmp is a little sneaky, since both ev and e have
2476                  * magic values in tv_usec.  Fortunately, they ought to have
2477                  * the _same_ magic values in tv_usec.  Let's assert for that.
2478                  */
2479                 EVUTIL_ASSERT(
2480                         is_same_common_timeout(&e->ev_timeout, &ev->ev_timeout));
2481                 if (evutil_timercmp(&ev->ev_timeout, &e->ev_timeout, >=)) {
2482                         TAILQ_INSERT_AFTER(&ctl->events, e, ev,
2483                             ev_timeout_pos.ev_next_with_common_timeout);
2484                         return;
2485                 }
2486         }
2487         TAILQ_INSERT_HEAD(&ctl->events, ev,
2488             ev_timeout_pos.ev_next_with_common_timeout);
2489 }
2490
2491 static void
2492 event_queue_insert(struct event_base *base, struct event *ev, int queue)
2493 {
2494         EVENT_BASE_ASSERT_LOCKED(base);
2495
2496         if (ev->ev_flags & queue) {
2497                 /* Double insertion is possible for active events */
2498                 if (queue & EVLIST_ACTIVE)
2499                         return;
2500
2501                 event_errx(1, "%s: %p(fd %d) already on queue %x", __func__,
2502                            ev, ev->ev_fd, queue);
2503                 return;
2504         }
2505
2506         if (~ev->ev_flags & EVLIST_INTERNAL)
2507                 base->event_count++;
2508
2509         ev->ev_flags |= queue;
2510         switch (queue) {
2511         case EVLIST_INSERTED:
2512                 TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);
2513                 break;
2514         case EVLIST_ACTIVE:
2515                 base->event_count_active++;
2516                 TAILQ_INSERT_TAIL(&base->activequeues[ev->ev_pri],
2517                     ev,ev_active_next);
2518                 break;
2519         case EVLIST_TIMEOUT: {
2520                 if (is_common_timeout(&ev->ev_timeout, base)) {
2521                         struct common_timeout_list *ctl =
2522                             get_common_timeout_list(base, &ev->ev_timeout);
2523                         insert_common_timeout_inorder(ctl, ev);
2524                 } else
2525                         min_heap_push(&base->timeheap, ev);
2526                 break;
2527         }
2528         default:
2529                 event_errx(1, "%s: unknown queue %x", __func__, queue);
2530         }
2531 }
2532
2533 /* Functions for debugging */
2534
2535 const char *
2536 event_get_version(void)
2537 {
2538         return (_EVENT_VERSION);
2539 }
2540
2541 ev_uint32_t
2542 event_get_version_number(void)
2543 {
2544         return (_EVENT_NUMERIC_VERSION);
2545 }
2546
2547 /*
2548  * No thread-safe interface needed - the information should be the same
2549  * for all threads.
2550  */
2551
2552 const char *
2553 event_get_method(void)
2554 {
2555         return (current_base->evsel->name);
2556 }
2557
2558 #ifndef _EVENT_DISABLE_MM_REPLACEMENT
2559 static void *(*_mm_malloc_fn)(size_t sz) = NULL;
2560 static void *(*_mm_realloc_fn)(void *p, size_t sz) = NULL;
2561 static void (*_mm_free_fn)(void *p) = NULL;
2562
2563 void *
2564 event_mm_malloc_(size_t sz)
2565 {
2566         if (_mm_malloc_fn)
2567                 return _mm_malloc_fn(sz);
2568         else
2569                 return malloc(sz);
2570 }
2571
2572 void *
2573 event_mm_calloc_(size_t count, size_t size)
2574 {
2575         if (_mm_malloc_fn) {
2576                 size_t sz = count * size;
2577                 void *p = _mm_malloc_fn(sz);
2578                 if (p)
2579                         memset(p, 0, sz);
2580                 return p;
2581         } else
2582                 return calloc(count, size);
2583 }
2584
2585 char *
2586 event_mm_strdup_(const char *str)
2587 {
2588         if (_mm_malloc_fn) {
2589                 size_t ln = strlen(str);
2590                 void *p = _mm_malloc_fn(ln+1);
2591                 if (p)
2592                         memcpy(p, str, ln+1);
2593                 return p;
2594         } else
2595 #ifdef WIN32
2596                 return _strdup(str);
2597 #else
2598                 return strdup(str);
2599 #endif
2600 }
2601
2602 void *
2603 event_mm_realloc_(void *ptr, size_t sz)
2604 {
2605         if (_mm_realloc_fn)
2606                 return _mm_realloc_fn(ptr, sz);
2607         else
2608                 return realloc(ptr, sz);
2609 }
2610
2611 void
2612 event_mm_free_(void *ptr)
2613 {
2614         if (_mm_free_fn)
2615                 _mm_free_fn(ptr);
2616         else
2617                 free(ptr);
2618 }
2619
2620 void
2621 event_set_mem_functions(void *(*malloc_fn)(size_t sz),
2622                         void *(*realloc_fn)(void *ptr, size_t sz),
2623                         void (*free_fn)(void *ptr))
2624 {
2625         _mm_malloc_fn = malloc_fn;
2626         _mm_realloc_fn = realloc_fn;
2627         _mm_free_fn = free_fn;
2628 }
2629 #endif
2630
2631 #if defined(_EVENT_HAVE_EVENTFD) && defined(_EVENT_HAVE_SYS_EVENTFD_H)
2632 static void
2633 evthread_notify_drain_eventfd(evutil_socket_t fd, short what, void *arg)
2634 {
2635         ev_uint64_t msg;
2636         ev_ssize_t r;
2637         struct event_base *base = arg;
2638
2639         r = read(fd, (void*) &msg, sizeof(msg));
2640         if (r<0 && errno != EAGAIN) {
2641                 event_sock_warn(fd, "Error reading from eventfd");
2642         }
2643         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2644         base->is_notify_pending = 0;
2645         EVBASE_RELEASE_LOCK(base, th_base_lock);
2646 }
2647 #endif
2648
2649 static void
2650 evthread_notify_drain_default(evutil_socket_t fd, short what, void *arg)
2651 {
2652         unsigned char buf[1024];
2653         struct event_base *base = arg;
2654 #ifdef WIN32
2655         while (recv(fd, (char*)buf, sizeof(buf), 0) > 0)
2656                 ;
2657 #else
2658         while (read(fd, (char*)buf, sizeof(buf)) > 0)
2659                 ;
2660 #endif
2661
2662         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2663         base->is_notify_pending = 0;
2664         EVBASE_RELEASE_LOCK(base, th_base_lock);
2665 }
2666
2667 int
2668 evthread_make_base_notifiable(struct event_base *base)
2669 {
2670         void (*cb)(evutil_socket_t, short, void *) = evthread_notify_drain_default;
2671         int (*notify)(struct event_base *) = evthread_notify_base_default;
2672
2673         /* XXXX grab the lock here? */
2674         if (!base)
2675                 return -1;
2676
2677         if (base->th_notify_fd[0] >= 0)
2678                 return 0;
2679
2680 #if defined(_EVENT_HAVE_EVENTFD) && defined(_EVENT_HAVE_SYS_EVENTFD_H)
2681 #ifndef EFD_CLOEXEC
2682 #define EFD_CLOEXEC 0
2683 #endif
2684         base->th_notify_fd[0] = eventfd(0, EFD_CLOEXEC);
2685         if (base->th_notify_fd[0] >= 0) {
2686                 evutil_make_socket_closeonexec(base->th_notify_fd[0]);
2687                 notify = evthread_notify_base_eventfd;
2688                 cb = evthread_notify_drain_eventfd;
2689         }
2690 #endif
2691 #if defined(_EVENT_HAVE_PIPE)
2692         if (base->th_notify_fd[0] < 0) {
2693                 if ((base->evsel->features & EV_FEATURE_FDS)) {
2694                         if (pipe(base->th_notify_fd) < 0) {
2695                                 event_warn("%s: pipe", __func__);
2696                         } else {
2697                                 evutil_make_socket_closeonexec(base->th_notify_fd[0]);
2698                                 evutil_make_socket_closeonexec(base->th_notify_fd[1]);
2699                         }
2700                 }
2701         }
2702 #endif
2703
2704 #ifdef WIN32
2705 #define LOCAL_SOCKETPAIR_AF AF_INET
2706 #else
2707 #define LOCAL_SOCKETPAIR_AF AF_UNIX
2708 #endif
2709         if (base->th_notify_fd[0] < 0) {
2710                 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0,
2711                         base->th_notify_fd) == -1) {
2712                         event_sock_warn(-1, "%s: socketpair", __func__);
2713                         return (-1);
2714                 } else {
2715                         evutil_make_socket_closeonexec(base->th_notify_fd[0]);
2716                         evutil_make_socket_closeonexec(base->th_notify_fd[1]);
2717                 }
2718         }
2719
2720         evutil_make_socket_nonblocking(base->th_notify_fd[0]);
2721
2722         base->th_notify_fn = notify;
2723
2724         /*
2725           Making the second socket nonblocking is a bit subtle, given that we
2726           ignore any EAGAIN returns when writing to it, and you don't usally
2727           do that for a nonblocking socket. But if the kernel gives us EAGAIN,
2728           then there's no need to add any more data to the buffer, since
2729           the main thread is already either about to wake up and drain it,
2730           or woken up and in the process of draining it.
2731         */
2732         if (base->th_notify_fd[1] > 0)
2733                 evutil_make_socket_nonblocking(base->th_notify_fd[1]);
2734
2735         /* prepare an event that we can use for wakeup */
2736         event_assign(&base->th_notify, base, base->th_notify_fd[0],
2737                                  EV_READ|EV_PERSIST, cb, base);
2738
2739         /* we need to mark this as internal event */
2740         base->th_notify.ev_flags |= EVLIST_INTERNAL;
2741         event_priority_set(&base->th_notify, 0);
2742
2743         return event_add(&base->th_notify, NULL);
2744 }
2745
2746 void
2747 event_base_dump_events(struct event_base *base, FILE *output)
2748 {
2749         struct event *e;
2750         int i;
2751         fprintf(output, "Inserted events:\n");
2752         TAILQ_FOREACH(e, &base->eventqueue, ev_next) {
2753                 fprintf(output, "  %p [fd %ld]%s%s%s%s%s\n",
2754                                 (void*)e, (long)e->ev_fd,
2755                                 (e->ev_events&EV_READ)?" Read":"",
2756                                 (e->ev_events&EV_WRITE)?" Write":"",
2757                                 (e->ev_events&EV_SIGNAL)?" Signal":"",
2758                                 (e->ev_events&EV_TIMEOUT)?" Timeout":"",
2759                                 (e->ev_events&EV_PERSIST)?" Persist":"");
2760
2761         }
2762         for (i = 0; i < base->nactivequeues; ++i) {
2763                 if (TAILQ_EMPTY(&base->activequeues[i]))
2764                         continue;
2765                 fprintf(output, "Active events [priority %d]:\n", i);
2766                 TAILQ_FOREACH(e, &base->eventqueue, ev_next) {
2767                         fprintf(output, "  %p [fd %ld]%s%s%s%s\n",
2768                                         (void*)e, (long)e->ev_fd,
2769                                         (e->ev_res&EV_READ)?" Read active":"",
2770                                         (e->ev_res&EV_WRITE)?" Write active":"",
2771                                         (e->ev_res&EV_SIGNAL)?" Signal active":"",
2772                                         (e->ev_res&EV_TIMEOUT)?" Timeout active":"");
2773                 }
2774         }
2775 }
2776
2777 void
2778 event_base_add_virtual(struct event_base *base)
2779 {
2780         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2781         base->virtual_event_count++;
2782         EVBASE_RELEASE_LOCK(base, th_base_lock);
2783 }
2784
2785 void
2786 event_base_del_virtual(struct event_base *base)
2787 {
2788         EVBASE_ACQUIRE_LOCK(base, th_base_lock);
2789         EVUTIL_ASSERT(base->virtual_event_count > 0);
2790         base->virtual_event_count--;
2791         if (base->virtual_event_count == 0 && EVBASE_NEED_NOTIFY(base))
2792                 evthread_notify_base(base);
2793         EVBASE_RELEASE_LOCK(base, th_base_lock);
2794 }