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