ev.c

   1 /*
   2  * libev event processing core, watcher management
   3  *
   4  * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *
  14  *     * Redistributions in binary form must reproduce the above
  15  *       copyright notice, this list of conditions and the following
  16  *       disclaimer in the documentation and/or other materials provided
  17  *       with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 #ifndef EV_STANDALONE
  32 # include "config.h"
  33
  34 # if HAVE_CLOCK_GETTIME
  35 #  define EV_USE_MONOTONIC 1
  36 #  define EV_USE_REALTIME  1
  37 # endif
  38
  39 # if HAVE_SELECT && HAVE_SYS_SELECT_H
  40 #  define EV_USE_SELECT 1
  41 # endif
  42
  43 # if HAVE_POLL && HAVE_POLL_H
  44 #  define EV_USE_POLL 1
  45 # endif
  46
  47 # if HAVE_EPOLL && HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
  48 #  define EV_USE_EPOLL 1
  49 # endif
  50
  51 # if HAVE_KQUEUE && HAVE_WORKING_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
  52 #  define EV_USE_KQUEUE 1
  53 # endif
  54
  55 #endif
  56
  57 #include <math.h>
  58 #include <stdlib.h>
  59 #include <fcntl.h>
  60 #include <stddef.h>
  61
  62 #include <stdio.h>
  63
  64 #include <assert.h>
  65 #include <errno.h>
  66 #include <sys/types.h>
  67 #include <time.h>
  68
  69 #include <signal.h>
  70
  71 #ifndef WIN32
  72 # include <unistd.h>
  73 # include <sys/time.h>
  74 # include <sys/wait.h>
  75 #endif
  76 /**/
  77
  78 #ifndef EV_USE_MONOTONIC
  79 # define EV_USE_MONOTONIC 1
  80 #endif
  81
  82 #ifndef EV_USE_SELECT
  83 # define EV_USE_SELECT 1
  84 #endif
  85
  86 #ifndef EV_USE_POLL
  87 # define EV_USE_POLL 0 /* poll is usually slower than select, and not as well tested */
  88 #endif
  89
  90 #ifndef EV_USE_EPOLL
  91 # define EV_USE_EPOLL 0
  92 #endif
  93
  94 #ifndef EV_USE_KQUEUE
  95 # define EV_USE_KQUEUE 0
  96 #endif
  97
  98 #ifndef EV_USE_WIN32
  99 # ifdef WIN32
 100 #  define EV_USE_WIN32 0 /* it does not exist, use select */
 101 #  undef EV_USE_SELECT
 102 #  define EV_USE_SELECT 1
 103 # else
 104 #  define EV_USE_WIN32 0
 105 # endif
 106 #endif
 107
 108 #ifndef EV_USE_REALTIME
 109 # define EV_USE_REALTIME 1
 110 #endif
 111
 112 /**/
 113
 114 #ifndef CLOCK_MONOTONIC
 115 # undef EV_USE_MONOTONIC
 116 # define EV_USE_MONOTONIC 0
 117 #endif
 118
 119 #ifndef CLOCK_REALTIME
 120 # undef EV_USE_REALTIME
 121 # define EV_USE_REALTIME 0
 122 #endif
 123
 124 /**/
 125
 126 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 127 #define MAX_BLOCKTIME 59.731 /* never wait longer than this time (to detect time jumps) */
 128 #define PID_HASHSIZE  16 /* size of pid hash table, must be power of two */
 129 /*#define CLEANUP_INTERVAL 300. /* how often to try to free memory and re-check fds */
 130
 131 #include "ev.h"
 132
 133 #if __GNUC__ >= 3
 134 # define expect(expr,value)         __builtin_expect ((expr),(value))
 135 # define inline                     inline
 136 #else
 137 # define expect(expr,value)         (expr)
 138 # define inline                     static
 139 #endif
 140
 141 #define expect_false(expr) expect ((expr) != 0, 0)
 142 #define expect_true(expr)  expect ((expr) != 0, 1)
 143
 144 #define NUMPRI    (EV_MAXPRI - EV_MINPRI + 1)
 145 #define ABSPRI(w) ((w)->priority - EV_MINPRI)
 146
 147 typedef struct ev_watcher *W;
 148 typedef struct ev_watcher_list *WL;
 149 typedef struct ev_watcher_time *WT;
 150
 151 static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 152
 153 #include "ev_win32.c"
 154
 155 /*****************************************************************************/
 156
 157 static void (*syserr_cb)(const char *msg);
 158
 159 void ev_set_syserr_cb (void (*cb)(const char *msg))
 160 {
 161   syserr_cb = cb;
 162 }
 163
 164 static void
 165 syserr (const char *msg)
 166 {
 167   if (!msg)
 168     msg = "(libev) system error";
 169
 170   if (syserr_cb)
 171     syserr_cb (msg);
 172   else
 173     {
 174       perror (msg);
 175       abort ();
 176     }
 177 }
 178
 179 static void *(*alloc)(void *ptr, long size);
 180
 181 void ev_set_allocator (void *(*cb)(void *ptr, long size))
 182 {
 183   alloc = cb;
 184 }
 185
 186 static void *
 187 ev_realloc (void *ptr, long size)
 188 {
 189   ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
 190
 191   if (!ptr && size)
 192     {
 193       fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
 194       abort ();
 195     }
 196
 197   return ptr;
 198 }
 199
 200 #define ev_malloc(size) ev_realloc (0, (size))
 201 #define ev_free(ptr)    ev_realloc ((ptr), 0)
 202
 203 /*****************************************************************************/
 204
 205 typedef struct
 206 {
 207   WL head;
 208   unsigned char events;
 209   unsigned char reify;
 210 } ANFD;
 211
 212 typedef struct
 213 {
 214   W w;
 215   int events;
 216 } ANPENDING;
 217
 218 #if EV_MULTIPLICITY
 219
 220 struct ev_loop
 221 {
 222 # define VAR(name,decl) decl;
 223 # include "ev_vars.h"
 224 };
 225 # undef VAR
 226 # include "ev_wrap.h"
 227
 228 #else
 229
 230 # define VAR(name,decl) static decl;
 231 # include "ev_vars.h"
 232 # undef VAR
 233
 234 #endif
 235
 236 /*****************************************************************************/
 237
 238 inline ev_tstamp
 239 ev_time (void)
 240 {
 241 #if EV_USE_REALTIME
 242   struct timespec ts;
 243   clock_gettime (CLOCK_REALTIME, &ts);
 244   return ts.tv_sec + ts.tv_nsec * 1e-9;
 245 #else
 246   struct timeval tv;
 247   gettimeofday (&tv, 0);
 248   return tv.tv_sec + tv.tv_usec * 1e-6;
 249 #endif
 250 }
 251
 252 inline ev_tstamp
 253 get_clock (void)
 254 {
 255 #if EV_USE_MONOTONIC
 256   if (expect_true (have_monotonic))
 257     {
 258       struct timespec ts;
 259       clock_gettime (CLOCK_MONOTONIC, &ts);
 260       return ts.tv_sec + ts.tv_nsec * 1e-9;
 261     }
 262 #endif
 263
 264   return ev_time ();
 265 }
 266
 267 ev_tstamp
 268 ev_now (EV_P)
 269 {
 270   return rt_now;
 271 }
 272
 273 #define array_roundsize(type,n) ((n) | 4 & ~3)
 274
 275 #define array_needsize(type,base,cur,cnt,init)                  \
 276   if (expect_false ((cnt) > cur))                               \
 277     {                                                           \
 278       int newcnt = cur;                                         \
 279       do                                                        \
 280         {                                                       \
 281           newcnt = array_roundsize (type, newcnt << 1);         \
 282         }                                                       \
 283       while ((cnt) > newcnt);                                   \
 284                                                                 \
 285       base = (type *)ev_realloc (base, sizeof (type) * (newcnt));\
 286       init (base + cur, newcnt - cur);                          \
 287       cur = newcnt;                                             \
 288     }
 289
 290 #define array_slim(type,stem)                                   \
 291   if (stem ## max < array_roundsize (stem ## cnt >> 2))         \
 292     {                                                           \
 293       stem ## max = array_roundsize (stem ## cnt >> 1);         \
 294       base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
 295       fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
 296     }
 297
 298 /* microsoft's pseudo-c is quite far from C as the rest of the world and the standard knows it */
 299 /* bringing us everlasting joy in form of stupid extra macros that are not required in C */
 300 #define array_free_microshit(stem) \
 301   ev_free (stem ## s); stem ## cnt = stem ## max = 0;
 302
 303 #define array_free(stem, idx) \
 304   ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 305
 306 /*****************************************************************************/
 307
 308 static void
 309 anfds_init (ANFD *base, int count)
 310 {
 311   while (count--)
 312     {
 313       base->head   = 0;
 314       base->events = EV_NONE;
 315       base->reify  = 0;
 316
 317       ++base;
 318     }
 319 }
 320
 321 void
 322 ev_feed_event (EV_P_ void *w, int revents)
 323 {
 324   W w_ = (W)w;
 325
 326   if (w_->pending)
 327     {
 328       pendings [ABSPRI (w_)][w_->pending - 1].events |= revents;
 329       return;
 330     }
 331
 332   w_->pending = ++pendingcnt [ABSPRI (w_)];
 333   array_needsize (ANPENDING, pendings [ABSPRI (w_)], pendingmax [ABSPRI (w_)], pendingcnt [ABSPRI (w_)], (void));
 334   pendings [ABSPRI (w_)][w_->pending - 1].w      = w_;
 335   pendings [ABSPRI (w_)][w_->pending - 1].events = revents;
 336 }
 337
 338 static void
 339 queue_events (EV_P_ W *events, int eventcnt, int type)
 340 {
 341   int i;
 342
 343   for (i = 0; i < eventcnt; ++i)
 344     ev_feed_event (EV_A_ events [i], type);
 345 }
 346
 347 static void
 348 fd_event (EV_P_ int fd, int events)
 349 {
 350   ANFD *anfd = anfds + fd;
 351   struct ev_io *w;
 352
 353   for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 354     {
 355       int ev = w->events & events;
 356
 357       if (ev)
 358         ev_feed_event (EV_A_ (W)w, ev);
 359     }
 360 }
 361
 362 /*****************************************************************************/
 363
 364 static void
 365 fd_reify (EV_P)
 366 {
 367   int i;
 368
 369   for (i = 0; i < fdchangecnt; ++i)
 370     {
 371       int fd = fdchanges [i];
 372       ANFD *anfd = anfds + fd;
 373       struct ev_io *w;
 374
 375       int events = 0;
 376
 377       for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 378         events |= w->events;
 379
 380       anfd->reify = 0;
 381
 382       method_modify (EV_A_ fd, anfd->events, events);
 383       anfd->events = events;
 384     }
 385
 386   fdchangecnt = 0;
 387 }
 388
 389 static void
 390 fd_change (EV_P_ int fd)
 391 {
 392   if (anfds [fd].reify)
 393     return;
 394
 395   anfds [fd].reify = 1;
 396
 397   ++fdchangecnt;
 398   array_needsize (int, fdchanges, fdchangemax, fdchangecnt, (void));
 399   fdchanges [fdchangecnt - 1] = fd;
 400 }
 401
 402 static void
 403 fd_kill (EV_P_ int fd)
 404 {
 405   struct ev_io *w;
 406
 407   while ((w = (struct ev_io *)anfds [fd].head))
 408     {
 409       ev_io_stop (EV_A_ w);
 410       ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
 411     }
 412 }
 413
 414 static int
 415 fd_valid (int fd)
 416 {
 417 #ifdef WIN32
 418   return !!win32_get_osfhandle (fd);
 419 #else
 420   return fcntl (fd, F_GETFD) != -1;
 421 #endif
 422 }
 423
 424 /* called on EBADF to verify fds */
 425 static void
 426 fd_ebadf (EV_P)
 427 {
 428   int fd;
 429
 430   for (fd = 0; fd < anfdmax; ++fd)
 431     if (anfds [fd].events)
 432       if (!fd_valid (fd) == -1 && errno == EBADF)
 433         fd_kill (EV_A_ fd);
 434 }
 435
 436 /* called on ENOMEM in select/poll to kill some fds and retry */
 437 static void
 438 fd_enomem (EV_P)
 439 {
 440   int fd;
 441
 442   for (fd = anfdmax; fd--; )
 443     if (anfds [fd].events)
 444       {
 445         fd_kill (EV_A_ fd);
 446         return;
 447       }
 448 }
 449
 450 /* usually called after fork if method needs to re-arm all fds from scratch */
 451 static void
 452 fd_rearm_all (EV_P)
 453 {
 454   int fd;
 455
 456   /* this should be highly optimised to not do anything but set a flag */
 457   for (fd = 0; fd < anfdmax; ++fd)
 458     if (anfds [fd].events)
 459       {
 460         anfds [fd].events = 0;
 461         fd_change (EV_A_ fd);
 462       }
 463 }
 464
 465 /*****************************************************************************/
 466
 467 static void
 468 upheap (WT *heap, int k)
 469 {
 470   WT w = heap [k];
 471
 472   while (k && heap [k >> 1]->at > w->at)
 473     {
 474       heap [k] = heap [k >> 1];
 475       ((W)heap [k])->active = k + 1;
 476       k >>= 1;
 477     }
 478
 479   heap [k] = w;
 480   ((W)heap [k])->active = k + 1;
 481
 482 }
 483
 484 static void
 485 downheap (WT *heap, int N, int k)
 486 {
 487   WT w = heap [k];
 488
 489   while (k < (N >> 1))
 490     {
 491       int j = k << 1;
 492
 493       if (j + 1 < N && heap [j]->at > heap [j + 1]->at)
 494         ++j;
 495
 496       if (w->at <= heap [j]->at)
 497         break;
 498
 499       heap [k] = heap [j];
 500       ((W)heap [k])->active = k + 1;
 501       k = j;
 502     }
 503
 504   heap [k] = w;
 505   ((W)heap [k])->active = k + 1;
 506 }
 507
 508 /*****************************************************************************/
 509
 510 typedef struct
 511 {
 512   WL head;
 513   sig_atomic_t volatile gotsig;
 514 } ANSIG;
 515
 516 static ANSIG *signals;
 517 static int signalmax;
 518
 519 static int sigpipe [2];
 520 static sig_atomic_t volatile gotsig;
 521 static struct ev_io sigev;
 522
 523 static void
 524 signals_init (ANSIG *base, int count)
 525 {
 526   while (count--)
 527     {
 528       base->head   = 0;
 529       base->gotsig = 0;
 530
 531       ++base;
 532     }
 533 }
 534
 535 static void
 536 sighandler (int signum)
 537 {
 538 #if WIN32
 539   signal (signum, sighandler);
 540 #endif
 541
 542   signals [signum - 1].gotsig = 1;
 543
 544   if (!gotsig)
 545     {
 546       int old_errno = errno;
 547       gotsig = 1;
 548 #ifdef WIN32
 549       send (sigpipe [1], &signum, 1, MSG_DONTWAIT);
 550 #else
 551       write (sigpipe [1], &signum, 1);
 552 #endif
 553       errno = old_errno;
 554     }
 555 }
 556
 557 static void
 558 sigcb (EV_P_ struct ev_io *iow, int revents)
 559 {
 560   WL w;
 561   int signum;
 562
 563 #ifdef WIN32
 564   recv (sigpipe [0], &revents, 1, MSG_DONTWAIT);
 565 #else
 566   read (sigpipe [0], &revents, 1);
 567 #endif
 568   gotsig = 0;
 569
 570   for (signum = signalmax; signum--; )
 571     if (signals [signum].gotsig)
 572       {
 573         signals [signum].gotsig = 0;
 574
 575         for (w = signals [signum].head; w; w = w->next)
 576           ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 577       }
 578 }
 579
 580 static void
 581 siginit (EV_P)
 582 {
 583 #ifndef WIN32
 584   fcntl (sigpipe [0], F_SETFD, FD_CLOEXEC);
 585   fcntl (sigpipe [1], F_SETFD, FD_CLOEXEC);
 586
 587   /* rather than sort out wether we really need nb, set it */
 588   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
 589   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
 590 #endif
 591
 592   ev_io_set (&sigev, sigpipe [0], EV_READ);
 593   ev_io_start (EV_A_ &sigev);
 594   ev_unref (EV_A); /* child watcher should not keep loop alive */
 595 }
 596
 597 /*****************************************************************************/
 598
 599 static struct ev_child *childs [PID_HASHSIZE];
 600
 601 #ifndef WIN32
 602
 603 static struct ev_signal childev;
 604
 605 #ifndef WCONTINUED
 606 # define WCONTINUED 0
 607 #endif
 608
 609 static void
 610 child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
 611 {
 612   struct ev_child *w;
 613
 614   for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
 615     if (w->pid == pid || !w->pid)
 616       {
 617         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
 618         w->rpid         = pid;
 619         w->rstatus      = status;
 620         ev_feed_event (EV_A_ (W)w, EV_CHILD);
 621       }
 622 }
 623
 624 static void
 625 childcb (EV_P_ struct ev_signal *sw, int revents)
 626 {
 627   int pid, status;
 628
 629   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
 630     {
 631       /* make sure we are called again until all childs have been reaped */
 632       ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
 633
 634       child_reap (EV_A_ sw, pid, pid, status);
 635       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */
 636     }
 637 }
 638
 639 #endif
 640
 641 /*****************************************************************************/
 642
 643 #if EV_USE_KQUEUE
 644 # include "ev_kqueue.c"
 645 #endif
 646 #if EV_USE_EPOLL
 647 # include "ev_epoll.c"
 648 #endif
 649 #if EV_USE_POLL
 650 # include "ev_poll.c"
 651 #endif
 652 #if EV_USE_SELECT
 653 # include "ev_select.c"
 654 #endif
 655
 656 int
 657 ev_version_major (void)
 658 {
 659   return EV_VERSION_MAJOR;
 660 }
 661
 662 int
 663 ev_version_minor (void)
 664 {
 665   return EV_VERSION_MINOR;
 666 }
 667
 668 /* return true if we are running with elevated privileges and should ignore env variables */
 669 static int
 670 enable_secure (void)
 671 {
 672 #ifdef WIN32
 673   return 0;
 674 #else
 675   return getuid () != geteuid ()
 676       || getgid () != getegid ();
 677 #endif
 678 }
 679
 680 int
 681 ev_method (EV_P)
 682 {
 683   return method;
 684 }
 685
 686 static void
 687 loop_init (EV_P_ int methods)
 688 {
 689   if (!method)
 690     {
 691 #if EV_USE_MONOTONIC
 692       {
 693         struct timespec ts;
 694         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
 695           have_monotonic = 1;
 696       }
 697 #endif
 698
 699       rt_now    = ev_time ();
 700       mn_now    = get_clock ();
 701       now_floor = mn_now;
 702       rtmn_diff = rt_now - mn_now;
 703
 704       if (methods == EVMETHOD_AUTO)
 705         if (!enable_secure () && getenv ("LIBEV_METHODS"))
 706           methods = atoi (getenv ("LIBEV_METHODS"));
 707         else
 708           methods = EVMETHOD_ANY;
 709
 710       method = 0;
 711 #if EV_USE_WIN32
 712       if (!method && (methods & EVMETHOD_WIN32 )) method = win32_init  (EV_A_ methods);
 713 #endif
 714 #if EV_USE_KQUEUE
 715       if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
 716 #endif
 717 #if EV_USE_EPOLL
 718       if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init  (EV_A_ methods);
 719 #endif
 720 #if EV_USE_POLL
 721       if (!method && (methods & EVMETHOD_POLL  )) method = poll_init   (EV_A_ methods);
 722 #endif
 723 #if EV_USE_SELECT
 724       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 725 #endif
 726
 727       ev_watcher_init (&sigev, sigcb);
 728       ev_set_priority (&sigev, EV_MAXPRI);
 729     }
 730 }
 731
 732 void
 733 loop_destroy (EV_P)
 734 {
 735   int i;
 736
 737 #if EV_USE_WIN32
 738   if (method == EVMETHOD_WIN32 ) win32_destroy  (EV_A);
 739 #endif
 740 #if EV_USE_KQUEUE
 741   if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
 742 #endif
 743 #if EV_USE_EPOLL
 744   if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
 745 #endif
 746 #if EV_USE_POLL
 747   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 748 #endif
 749 #if EV_USE_SELECT
 750   if (method == EVMETHOD_SELECT) select_destroy (EV_A);
 751 #endif
 752
 753   for (i = NUMPRI; i--; )
 754     array_free (pending, [i]);
 755
 756   /* have to use the microsoft-never-gets-it-right macro */
 757   array_free_microshit (fdchange);
 758   array_free_microshit (timer);
 759   array_free_microshit (periodic);
 760   array_free_microshit (idle);
 761   array_free_microshit (prepare);
 762   array_free_microshit (check);
 763
 764   method = 0;
 765 }
 766
 767 static void
 768 loop_fork (EV_P)
 769 {
 770 #if EV_USE_EPOLL
 771   if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
 772 #endif
 773 #if EV_USE_KQUEUE
 774   if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
 775 #endif
 776
 777   if (ev_is_active (&sigev))
 778     {
 779       /* default loop */
 780
 781       ev_ref (EV_A);
 782       ev_io_stop (EV_A_ &sigev);
 783       close (sigpipe [0]);
 784       close (sigpipe [1]);
 785
 786       while (pipe (sigpipe))
 787         syserr ("(libev) error creating pipe");
 788
 789       siginit (EV_A);
 790     }
 791
 792   postfork = 0;
 793 }
 794
 795 #if EV_MULTIPLICITY
 796 struct ev_loop *
 797 ev_loop_new (int methods)
 798 {
 799   struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
 800
 801   memset (loop, 0, sizeof (struct ev_loop));
 802
 803   loop_init (EV_A_ methods);
 804
 805   if (ev_method (EV_A))
 806     return loop;
 807
 808   return 0;
 809 }
 810
 811 void
 812 ev_loop_destroy (EV_P)
 813 {
 814   loop_destroy (EV_A);
 815   ev_free (loop);
 816 }
 817
 818 void
 819 ev_loop_fork (EV_P)
 820 {
 821   postfork = 1;
 822 }
 823
 824 #endif
 825
 826 #if EV_MULTIPLICITY
 827 struct ev_loop default_loop_struct;
 828 static struct ev_loop *default_loop;
 829
 830 struct ev_loop *
 831 #else
 832 static int default_loop;
 833
 834 int
 835 #endif
 836 ev_default_loop (int methods)
 837 {
 838   if (sigpipe [0] == sigpipe [1])
 839     if (pipe (sigpipe))
 840       return 0;
 841
 842   if (!default_loop)
 843     {
 844 #if EV_MULTIPLICITY
 845       struct ev_loop *loop = default_loop = &default_loop_struct;
 846 #else
 847       default_loop = 1;
 848 #endif
 849
 850       loop_init (EV_A_ methods);
 851
 852       if (ev_method (EV_A))
 853         {
 854           siginit (EV_A);
 855
 856 #ifndef WIN32
 857           ev_signal_init (&childev, childcb, SIGCHLD);
 858           ev_set_priority (&childev, EV_MAXPRI);
 859           ev_signal_start (EV_A_ &childev);
 860           ev_unref (EV_A); /* child watcher should not keep loop alive */
 861 #endif
 862         }
 863       else
 864         default_loop = 0;
 865     }
 866
 867   return default_loop;
 868 }
 869
 870 void
 871 ev_default_destroy (void)
 872 {
 873 #if EV_MULTIPLICITY
 874   struct ev_loop *loop = default_loop;
 875 #endif
 876
 877 #ifndef WIN32
 878   ev_ref (EV_A); /* child watcher */
 879   ev_signal_stop (EV_A_ &childev);
 880 #endif
 881
 882   ev_ref (EV_A); /* signal watcher */
 883   ev_io_stop (EV_A_ &sigev);
 884
 885   close (sigpipe [0]); sigpipe [0] = 0;
 886   close (sigpipe [1]); sigpipe [1] = 0;
 887
 888   loop_destroy (EV_A);
 889 }
 890
 891 void
 892 ev_default_fork (void)
 893 {
 894 #if EV_MULTIPLICITY
 895   struct ev_loop *loop = default_loop;
 896 #endif
 897
 898   if (method)
 899     postfork = 1;
 900 }
 901
 902 /*****************************************************************************/
 903
 904 static int
 905 any_pending (EV_P)
 906 {
 907   int pri;
 908
 909   for (pri = NUMPRI; pri--; )
 910     if (pendingcnt [pri])
 911       return 1;
 912
 913   return 0;
 914 }
 915
 916 static void
 917 call_pending (EV_P)
 918 {
 919   int pri;
 920
 921   for (pri = NUMPRI; pri--; )
 922     while (pendingcnt [pri])
 923       {
 924         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
 925
 926         if (p->w)
 927           {
 928             p->w->pending = 0;
 929             p->w->cb (EV_A_ p->w, p->events);
 930           }
 931       }
 932 }
 933
 934 static void
 935 timers_reify (EV_P)
 936 {
 937   while (timercnt && ((WT)timers [0])->at <= mn_now)
 938     {
 939       struct ev_timer *w = timers [0];
 940
 941       assert (("inactive timer on timer heap detected", ev_is_active (w)));
 942
 943       /* first reschedule or stop timer */
 944       if (w->repeat)
 945         {
 946           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 947           ((WT)w)->at = mn_now + w->repeat;
 948           downheap ((WT *)timers, timercnt, 0);
 949         }
 950       else
 951         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 952
 953       ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
 954     }
 955 }
 956
 957 static void
 958 periodics_reify (EV_P)
 959 {
 960   while (periodiccnt && ((WT)periodics [0])->at <= rt_now)
 961     {
 962       struct ev_periodic *w = periodics [0];
 963
 964       assert (("inactive timer on periodic heap detected", ev_is_active (w)));
 965
 966       /* first reschedule or stop timer */
 967       if (w->reschedule_cb)
 968         {
 969           ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, rt_now + 0.0001);
 970
 971           assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > rt_now));
 972           downheap ((WT *)periodics, periodiccnt, 0);
 973         }
 974       else if (w->interval)
 975         {
 976           ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
 977           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
 978           downheap ((WT *)periodics, periodiccnt, 0);
 979         }
 980       else
 981         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 982
 983       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
 984     }
 985 }
 986
 987 static void
 988 periodics_reschedule (EV_P)
 989 {
 990   int i;
 991
 992   /* adjust periodics after time jump */
 993   for (i = 0; i < periodiccnt; ++i)
 994     {
 995       struct ev_periodic *w = periodics [i];
 996
 997       if (w->reschedule_cb)
 998         ((WT)w)->at = w->reschedule_cb (w, rt_now);
 999       else if (w->interval)
1000         ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1001     }
1002
1003   /* now rebuild the heap */
1004   for (i = periodiccnt >> 1; i--; )
1005     downheap ((WT *)periodics, periodiccnt, i);
1006 }
1007
1008 inline int
1009 time_update_monotonic (EV_P)
1010 {
1011   mn_now = get_clock ();
1012
1013   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
1014     {
1015       rt_now = rtmn_diff + mn_now;
1016       return 0;
1017     }
1018   else
1019     {
1020       now_floor = mn_now;
1021       rt_now = ev_time ();
1022       return 1;
1023     }
1024 }
1025
1026 static void
1027 time_update (EV_P)
1028 {
1029   int i;
1030
1031 #if EV_USE_MONOTONIC
1032   if (expect_true (have_monotonic))
1033     {
1034       if (time_update_monotonic (EV_A))
1035         {
1036           ev_tstamp odiff = rtmn_diff;
1037
1038           for (i = 4; --i; ) /* loop a few times, before making important decisions */
1039             {
1040               rtmn_diff = rt_now - mn_now;
1041
1042               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
1043                 return; /* all is well */
1044
1045               rt_now    = ev_time ();
1046               mn_now    = get_clock ();
1047               now_floor = mn_now;
1048             }
1049
1050           periodics_reschedule (EV_A);
1051           /* no timer adjustment, as the monotonic clock doesn't jump */
1052           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1053         }
1054     }
1055   else
1056 #endif
1057     {
1058       rt_now = ev_time ();
1059
1060       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
1061         {
1062           periodics_reschedule (EV_A);
1063
1064           /* adjust timers. this is easy, as the offset is the same for all */
1065           for (i = 0; i < timercnt; ++i)
1066             ((WT)timers [i])->at += rt_now - mn_now;
1067         }
1068
1069       mn_now = rt_now;
1070     }
1071 }
1072
1073 void
1074 ev_ref (EV_P)
1075 {
1076   ++activecnt;
1077 }
1078
1079 void
1080 ev_unref (EV_P)
1081 {
1082   --activecnt;
1083 }
1084
1085 static int loop_done;
1086
1087 void
1088 ev_loop (EV_P_ int flags)
1089 {
1090   double block;
1091   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
1092
1093   do
1094     {
1095       /* queue check watchers (and execute them) */
1096       if (expect_false (preparecnt))
1097         {
1098           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1099           call_pending (EV_A);
1100         }
1101
1102       /* we might have forked, so reify kernel state if necessary */
1103       if (expect_false (postfork))
1104         loop_fork (EV_A);
1105
1106       /* update fd-related kernel structures */
1107       fd_reify (EV_A);
1108
1109       /* calculate blocking time */
1110
1111       /* we only need this for !monotonic clock or timers, but as we basically
1112          always have timers, we just calculate it always */
1113 #if EV_USE_MONOTONIC
1114       if (expect_true (have_monotonic))
1115         time_update_monotonic (EV_A);
1116       else
1117 #endif
1118         {
1119           rt_now = ev_time ();
1120           mn_now = rt_now;
1121         }
1122
1123       if (flags & EVLOOP_NONBLOCK || idlecnt)
1124         block = 0.;
1125       else
1126         {
1127           block = MAX_BLOCKTIME;
1128
1129           if (timercnt)
1130             {
1131               ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
1132               if (block > to) block = to;
1133             }
1134
1135           if (periodiccnt)
1136             {
1137               ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge;
1138               if (block > to) block = to;
1139             }
1140
1141           if (block < 0.) block = 0.;
1142         }
1143
1144       method_poll (EV_A_ block);
1145
1146       /* update rt_now, do magic */
1147       time_update (EV_A);
1148
1149       /* queue pending timers and reschedule them */
1150       timers_reify (EV_A); /* relative timers called last */
1151       periodics_reify (EV_A); /* absolute timers called first */
1152
1153       /* queue idle watchers unless io or timers are pending */
1154       if (idlecnt && !any_pending (EV_A))
1155         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1156
1157       /* queue check watchers, to be executed first */
1158       if (checkcnt)
1159         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1160
1161       call_pending (EV_A);
1162     }
1163   while (activecnt && !loop_done);
1164
1165   if (loop_done != 2)
1166     loop_done = 0;
1167 }
1168
1169 void
1170 ev_unloop (EV_P_ int how)
1171 {
1172   loop_done = how;
1173 }
1174
1175 /*****************************************************************************/
1176
1177 inline void
1178 wlist_add (WL *head, WL elem)
1179 {
1180   elem->next = *head;
1181   *head = elem;
1182 }
1183
1184 inline void
1185 wlist_del (WL *head, WL elem)
1186 {
1187   while (*head)
1188     {
1189       if (*head == elem)
1190         {
1191           *head = elem->next;
1192           return;
1193         }
1194
1195       head = &(*head)->next;
1196     }
1197 }
1198
1199 inline void
1200 ev_clear_pending (EV_P_ W w)
1201 {
1202   if (w->pending)
1203     {
1204       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1205       w->pending = 0;
1206     }
1207 }
1208
1209 inline void
1210 ev_start (EV_P_ W w, int active)
1211 {
1212   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1213   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1214
1215   w->active = active;
1216   ev_ref (EV_A);
1217 }
1218
1219 inline void
1220 ev_stop (EV_P_ W w)
1221 {
1222   ev_unref (EV_A);
1223   w->active = 0;
1224 }
1225
1226 /*****************************************************************************/
1227
1228 void
1229 ev_io_start (EV_P_ struct ev_io *w)
1230 {
1231   int fd = w->fd;
1232
1233   if (ev_is_active (w))
1234     return;
1235
1236   assert (("ev_io_start called with negative fd", fd >= 0));
1237
1238   ev_start (EV_A_ (W)w, 1);
1239   array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
1240   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1241
1242   fd_change (EV_A_ fd);
1243 }
1244
1245 void
1246 ev_io_stop (EV_P_ struct ev_io *w)
1247 {
1248   ev_clear_pending (EV_A_ (W)w);
1249   if (!ev_is_active (w))
1250     return;
1251
1252   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1253   ev_stop (EV_A_ (W)w);
1254
1255   fd_change (EV_A_ w->fd);
1256 }
1257
1258 void
1259 ev_timer_start (EV_P_ struct ev_timer *w)
1260 {
1261   if (ev_is_active (w))
1262     return;
1263
1264   ((WT)w)->at += mn_now;
1265
1266   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1267
1268   ev_start (EV_A_ (W)w, ++timercnt);
1269   array_needsize (struct ev_timer *, timers, timermax, timercnt, (void));
1270   timers [timercnt - 1] = w;
1271   upheap ((WT *)timers, timercnt - 1);
1272
1273   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1274 }
1275
1276 void
1277 ev_timer_stop (EV_P_ struct ev_timer *w)
1278 {
1279   ev_clear_pending (EV_A_ (W)w);
1280   if (!ev_is_active (w))
1281     return;
1282
1283   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1284
1285   if (((W)w)->active < timercnt--)
1286     {
1287       timers [((W)w)->active - 1] = timers [timercnt];
1288       downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1289     }
1290
1291   ((WT)w)->at = w->repeat;
1292
1293   ev_stop (EV_A_ (W)w);
1294 }
1295
1296 void
1297 ev_timer_again (EV_P_ struct ev_timer *w)
1298 {
1299   if (ev_is_active (w))
1300     {
1301       if (w->repeat)
1302         {
1303           ((WT)w)->at = mn_now + w->repeat;
1304           downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1305         }
1306       else
1307         ev_timer_stop (EV_A_ w);
1308     }
1309   else if (w->repeat)
1310     ev_timer_start (EV_A_ w);
1311 }
1312
1313 void
1314 ev_periodic_start (EV_P_ struct ev_periodic *w)
1315 {
1316   if (ev_is_active (w))
1317     return;
1318
1319   if (w->reschedule_cb)
1320     ((WT)w)->at = w->reschedule_cb (w, rt_now);
1321   else if (w->interval)
1322     {
1323       assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1324       /* this formula differs from the one in periodic_reify because we do not always round up */
1325       ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1326     }
1327
1328   ev_start (EV_A_ (W)w, ++periodiccnt);
1329   array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, (void));
1330   periodics [periodiccnt - 1] = w;
1331   upheap ((WT *)periodics, periodiccnt - 1);
1332
1333   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1334 }
1335
1336 void
1337 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1338 {
1339   ev_clear_pending (EV_A_ (W)w);
1340   if (!ev_is_active (w))
1341     return;
1342
1343   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1344
1345   if (((W)w)->active < periodiccnt--)
1346     {
1347       periodics [((W)w)->active - 1] = periodics [periodiccnt];
1348       downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
1349     }
1350
1351   ev_stop (EV_A_ (W)w);
1352 }
1353
1354 void
1355 ev_periodic_again (EV_P_ struct ev_periodic *w)
1356 {
1357   ev_periodic_stop (EV_A_ w);
1358   ev_periodic_start (EV_A_ w);
1359 }
1360
1361 void
1362 ev_idle_start (EV_P_ struct ev_idle *w)
1363 {
1364   if (ev_is_active (w))
1365     return;
1366
1367   ev_start (EV_A_ (W)w, ++idlecnt);
1368   array_needsize (struct ev_idle *, idles, idlemax, idlecnt, (void));
1369   idles [idlecnt - 1] = w;
1370 }
1371
1372 void
1373 ev_idle_stop (EV_P_ struct ev_idle *w)
1374 {
1375   ev_clear_pending (EV_A_ (W)w);
1376   if (ev_is_active (w))
1377     return;
1378
1379   idles [((W)w)->active - 1] = idles [--idlecnt];
1380   ev_stop (EV_A_ (W)w);
1381 }
1382
1383 void
1384 ev_prepare_start (EV_P_ struct ev_prepare *w)
1385 {
1386   if (ev_is_active (w))
1387     return;
1388
1389   ev_start (EV_A_ (W)w, ++preparecnt);
1390   array_needsize (struct ev_prepare *, prepares, preparemax, preparecnt, (void));
1391   prepares [preparecnt - 1] = w;
1392 }
1393
1394 void
1395 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1396 {
1397   ev_clear_pending (EV_A_ (W)w);
1398   if (ev_is_active (w))
1399     return;
1400
1401   prepares [((W)w)->active - 1] = prepares [--preparecnt];
1402   ev_stop (EV_A_ (W)w);
1403 }
1404
1405 void
1406 ev_check_start (EV_P_ struct ev_check *w)
1407 {
1408   if (ev_is_active (w))
1409     return;
1410
1411   ev_start (EV_A_ (W)w, ++checkcnt);
1412   array_needsize (struct ev_check *, checks, checkmax, checkcnt, (void));
1413   checks [checkcnt - 1] = w;
1414 }
1415
1416 void
1417 ev_check_stop (EV_P_ struct ev_check *w)
1418 {
1419   ev_clear_pending (EV_A_ (W)w);
1420   if (ev_is_active (w))
1421     return;
1422
1423   checks [((W)w)->active - 1] = checks [--checkcnt];
1424   ev_stop (EV_A_ (W)w);
1425 }
1426
1427 #ifndef SA_RESTART
1428 # define SA_RESTART 0
1429 #endif
1430
1431 void
1432 ev_signal_start (EV_P_ struct ev_signal *w)
1433 {
1434 #if EV_MULTIPLICITY
1435   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1436 #endif
1437   if (ev_is_active (w))
1438     return;
1439
1440   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1441
1442   ev_start (EV_A_ (W)w, 1);
1443   array_needsize (ANSIG, signals, signalmax, w->signum, signals_init);
1444   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1445
1446   if (!((WL)w)->next)
1447     {
1448 #if WIN32
1449       signal (w->signum, sighandler);
1450 #else
1451       struct sigaction sa;
1452       sa.sa_handler = sighandler;
1453       sigfillset (&sa.sa_mask);
1454       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1455       sigaction (w->signum, &sa, 0);
1456 #endif
1457     }
1458 }
1459
1460 void
1461 ev_signal_stop (EV_P_ struct ev_signal *w)
1462 {
1463   ev_clear_pending (EV_A_ (W)w);
1464   if (!ev_is_active (w))
1465     return;
1466
1467   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1468   ev_stop (EV_A_ (W)w);
1469
1470   if (!signals [w->signum - 1].head)
1471     signal (w->signum, SIG_DFL);
1472 }
1473
1474 void
1475 ev_child_start (EV_P_ struct ev_child *w)
1476 {
1477 #if EV_MULTIPLICITY
1478   assert (("child watchers are only supported in the default loop", loop == default_loop));
1479 #endif
1480   if (ev_is_active (w))
1481     return;
1482
1483   ev_start (EV_A_ (W)w, 1);
1484   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1485 }
1486
1487 void
1488 ev_child_stop (EV_P_ struct ev_child *w)
1489 {
1490   ev_clear_pending (EV_A_ (W)w);
1491   if (ev_is_active (w))
1492     return;
1493
1494   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1495   ev_stop (EV_A_ (W)w);
1496 }
1497
1498 /*****************************************************************************/
1499
1500 struct ev_once
1501 {
1502   struct ev_io io;
1503   struct ev_timer to;
1504   void (*cb)(int revents, void *arg);
1505   void *arg;
1506 };
1507
1508 static void
1509 once_cb (EV_P_ struct ev_once *once, int revents)
1510 {
1511   void (*cb)(int revents, void *arg) = once->cb;
1512   void *arg = once->arg;
1513
1514   ev_io_stop (EV_A_ &once->io);
1515   ev_timer_stop (EV_A_ &once->to);
1516   ev_free (once);
1517
1518   cb (revents, arg);
1519 }
1520
1521 static void
1522 once_cb_io (EV_P_ struct ev_io *w, int revents)
1523 {
1524   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1525 }
1526
1527 static void
1528 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1529 {
1530   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1531 }
1532
1533 void
1534 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1535 {
1536   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
1537
1538   if (!once)
1539     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1540   else
1541     {
1542       once->cb  = cb;
1543       once->arg = arg;
1544
1545       ev_watcher_init (&once->io, once_cb_io);
1546       if (fd >= 0)
1547         {
1548           ev_io_set (&once->io, fd, events);
1549           ev_io_start (EV_A_ &once->io);
1550         }
1551
1552       ev_watcher_init (&once->to, once_cb_to);
1553       if (timeout >= 0.)
1554         {
1555           ev_timer_set (&once->to, timeout, 0.);
1556           ev_timer_start (EV_A_ &once->to);
1557         }
1558     }
1559 }
1560