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       /* first reschedule or stop timer */
 800       if (w->repeat)
 801         {
 802           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 803           w->at = mn_now + w->repeat;
 804           downheap ((WT *)timers, timercnt, 0);
 805         }
 806       else
 807         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 808
 809       event (EV_A_ (W)w, EV_TIMEOUT);
 810     }
 811 }
 812
 813 static void
 814 periodics_reify (EV_P)
 815 {
 816   while (periodiccnt && periodics [0]->at <= rt_now)
 817     {
 818       struct ev_periodic *w = periodics [0];
 819
 820       /* first reschedule or stop timer */
 821       if (w->interval)
 822         {
 823           w->at += floor ((rt_now - w->at) / w->interval + 1.) * w->interval;
 824           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", w->at > rt_now));
 825           downheap ((WT *)periodics, periodiccnt, 0);
 826         }
 827       else
 828         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 829
 830       event (EV_A_ (W)w, EV_PERIODIC);
 831     }
 832 }
 833
 834 static void
 835 periodics_reschedule (EV_P)
 836 {
 837   int i;
 838
 839   /* adjust periodics after time jump */
 840   for (i = 0; i < periodiccnt; ++i)
 841     {
 842       struct ev_periodic *w = periodics [i];
 843
 844       if (w->interval)
 845         {
 846           ev_tstamp diff = ceil ((rt_now - w->at) / w->interval) * w->interval;
 847
 848           if (fabs (diff) >= 1e-4)
 849             {
 850               ev_periodic_stop (EV_A_ w);
 851               ev_periodic_start (EV_A_ w);
 852
 853               i = 0; /* restart loop, inefficient, but time jumps should be rare */
 854             }
 855         }
 856     }
 857 }
 858
 859 inline int
 860 time_update_monotonic (EV_P)
 861 {
 862   mn_now = get_clock ();
 863
 864   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
 865     {
 866       rt_now = rtmn_diff + mn_now;
 867       return 0;
 868     }
 869   else
 870     {
 871       now_floor = mn_now;
 872       rt_now = ev_time ();
 873       return 1;
 874     }
 875 }
 876
 877 static void
 878 time_update (EV_P)
 879 {
 880   int i;
 881
 882 #if EV_USE_MONOTONIC
 883   if (expect_true (have_monotonic))
 884     {
 885       if (time_update_monotonic (EV_A))
 886         {
 887           ev_tstamp odiff = rtmn_diff;
 888
 889           for (i = 4; --i; ) /* loop a few times, before making important decisions */
 890             {
 891               rtmn_diff = rt_now - mn_now;
 892
 893               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
 894                 return; /* all is well */
 895
 896               rt_now    = ev_time ();
 897               mn_now    = get_clock ();
 898               now_floor = mn_now;
 899             }
 900
 901           periodics_reschedule (EV_A);
 902           /* no timer adjustment, as the monotonic clock doesn't jump */
 903           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
 904         }
 905     }
 906   else
 907 #endif
 908     {
 909       rt_now = ev_time ();
 910
 911       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
 912         {
 913           periodics_reschedule (EV_A);
 914
 915           /* adjust timers. this is easy, as the offset is the same for all */
 916           for (i = 0; i < timercnt; ++i)
 917             timers [i]->at += rt_now - mn_now;
 918         }
 919
 920       mn_now = rt_now;
 921     }
 922 }
 923
 924 void
 925 ev_ref (EV_P)
 926 {
 927   ++activecnt;
 928 }
 929
 930 void
 931 ev_unref (EV_P)
 932 {
 933   --activecnt;
 934 }
 935
 936 static int loop_done;
 937
 938 void
 939 ev_loop (EV_P_ int flags)
 940 {
 941   double block;
 942   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
 943
 944   do
 945     {
 946       /* queue check watchers (and execute them) */
 947       if (expect_false (preparecnt))
 948         {
 949           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
 950           call_pending (EV_A);
 951         }
 952
 953       /* update fd-related kernel structures */
 954       fd_reify (EV_A);
 955
 956       /* calculate blocking time */
 957
 958       /* we only need this for !monotonic clockor timers, but as we basically
 959          always have timers, we just calculate it always */
 960 #if EV_USE_MONOTONIC
 961       if (expect_true (have_monotonic))
 962         time_update_monotonic (EV_A);
 963       else
 964 #endif
 965         {
 966           rt_now = ev_time ();
 967           mn_now = rt_now;
 968         }
 969
 970       if (flags & EVLOOP_NONBLOCK || idlecnt)
 971         block = 0.;
 972       else
 973         {
 974           block = MAX_BLOCKTIME;
 975
 976           if (timercnt)
 977             {
 978               ev_tstamp to = timers [0]->at - mn_now + method_fudge;
 979               if (block > to) block = to;
 980             }
 981
 982           if (periodiccnt)
 983             {
 984               ev_tstamp to = periodics [0]->at - rt_now + method_fudge;
 985               if (block > to) block = to;
 986             }
 987
 988           if (block < 0.) block = 0.;
 989         }
 990
 991       method_poll (EV_A_ block);
 992
 993       /* update rt_now, do magic */
 994       time_update (EV_A);
 995
 996       /* queue pending timers and reschedule them */
 997       timers_reify (EV_A); /* relative timers called last */
 998       periodics_reify (EV_A); /* absolute timers called first */
 999
1000       /* queue idle watchers unless io or timers are pending */
1001       if (!pendingcnt)
1002         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1003
1004       /* queue check watchers, to be executed first */
1005       if (checkcnt)
1006         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1007
1008       call_pending (EV_A);
1009     }
1010   while (activecnt && !loop_done);
1011
1012   if (loop_done != 2)
1013     loop_done = 0;
1014 }
1015
1016 void
1017 ev_unloop (EV_P_ int how)
1018 {
1019   loop_done = how;
1020 }
1021
1022 /*****************************************************************************/
1023
1024 inline void
1025 wlist_add (WL *head, WL elem)
1026 {
1027   elem->next = *head;
1028   *head = elem;
1029 }
1030
1031 inline void
1032 wlist_del (WL *head, WL elem)
1033 {
1034   while (*head)
1035     {
1036       if (*head == elem)
1037         {
1038           *head = elem->next;
1039           return;
1040         }
1041
1042       head = &(*head)->next;
1043     }
1044 }
1045
1046 inline void
1047 ev_clear_pending (EV_P_ W w)
1048 {
1049   if (w->pending)
1050     {
1051       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1052       w->pending = 0;
1053     }
1054 }
1055
1056 inline void
1057 ev_start (EV_P_ W w, int active)
1058 {
1059   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1060   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1061
1062   w->active = active;
1063   ev_ref (EV_A);
1064 }
1065
1066 inline void
1067 ev_stop (EV_P_ W w)
1068 {
1069   ev_unref (EV_A);
1070   w->active = 0;
1071 }
1072
1073 /*****************************************************************************/
1074
1075 void
1076 ev_io_start (EV_P_ struct ev_io *w)
1077 {
1078   int fd = w->fd;
1079
1080   if (ev_is_active (w))
1081     return;
1082
1083   assert (("ev_io_start called with negative fd", fd >= 0));
1084
1085   ev_start (EV_A_ (W)w, 1);
1086   array_needsize (anfds, anfdmax, fd + 1, anfds_init);
1087   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1088
1089   fd_change (EV_A_ fd);
1090 }
1091
1092 void
1093 ev_io_stop (EV_P_ struct ev_io *w)
1094 {
1095   ev_clear_pending (EV_A_ (W)w);
1096   if (!ev_is_active (w))
1097     return;
1098
1099   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1100   ev_stop (EV_A_ (W)w);
1101
1102   fd_change (EV_A_ w->fd);
1103 }
1104
1105 void
1106 ev_timer_start (EV_P_ struct ev_timer *w)
1107 {
1108   if (ev_is_active (w))
1109     return;
1110
1111   w->at += mn_now;
1112
1113   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1114
1115   ev_start (EV_A_ (W)w, ++timercnt);
1116   array_needsize (timers, timermax, timercnt, );
1117   timers [timercnt - 1] = w;
1118   upheap ((WT *)timers, timercnt - 1);
1119 }
1120
1121 void
1122 ev_timer_stop (EV_P_ struct ev_timer *w)
1123 {
1124   ev_clear_pending (EV_A_ (W)w);
1125   if (!ev_is_active (w))
1126     return;
1127
1128   if (w->active < timercnt--)
1129     {
1130       timers [w->active - 1] = timers [timercnt];
1131       downheap ((WT *)timers, timercnt, w->active - 1);
1132     }
1133
1134   w->at = w->repeat;
1135
1136   ev_stop (EV_A_ (W)w);
1137 }
1138
1139 void
1140 ev_timer_again (EV_P_ struct ev_timer *w)
1141 {
1142   if (ev_is_active (w))
1143     {
1144       if (w->repeat)
1145         {
1146           w->at = mn_now + w->repeat;
1147           downheap ((WT *)timers, timercnt, w->active - 1);
1148         }
1149       else
1150         ev_timer_stop (EV_A_ w);
1151     }
1152   else if (w->repeat)
1153     ev_timer_start (EV_A_ w);
1154 }
1155
1156 void
1157 ev_periodic_start (EV_P_ struct ev_periodic *w)
1158 {
1159   if (ev_is_active (w))
1160     return;
1161
1162   assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1163
1164   /* this formula differs from the one in periodic_reify because we do not always round up */
1165   if (w->interval)
1166     w->at += ceil ((rt_now - w->at) / w->interval) * w->interval;
1167
1168   ev_start (EV_A_ (W)w, ++periodiccnt);
1169   array_needsize (periodics, periodicmax, periodiccnt, );
1170   periodics [periodiccnt - 1] = w;
1171   upheap ((WT *)periodics, periodiccnt - 1);
1172 }
1173
1174 void
1175 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1176 {
1177   ev_clear_pending (EV_A_ (W)w);
1178   if (!ev_is_active (w))
1179     return;
1180
1181   if (w->active < periodiccnt--)
1182     {
1183       periodics [w->active - 1] = periodics [periodiccnt];
1184       downheap ((WT *)periodics, periodiccnt, w->active - 1);
1185     }
1186
1187   ev_stop (EV_A_ (W)w);
1188 }
1189
1190 void
1191 ev_idle_start (EV_P_ struct ev_idle *w)
1192 {
1193   if (ev_is_active (w))
1194     return;
1195
1196   ev_start (EV_A_ (W)w, ++idlecnt);
1197   array_needsize (idles, idlemax, idlecnt, );
1198   idles [idlecnt - 1] = w;
1199 }
1200
1201 void
1202 ev_idle_stop (EV_P_ struct ev_idle *w)
1203 {
1204   ev_clear_pending (EV_A_ (W)w);
1205   if (ev_is_active (w))
1206     return;
1207
1208   idles [w->active - 1] = idles [--idlecnt];
1209   ev_stop (EV_A_ (W)w);
1210 }
1211
1212 void
1213 ev_prepare_start (EV_P_ struct ev_prepare *w)
1214 {
1215   if (ev_is_active (w))
1216     return;
1217
1218   ev_start (EV_A_ (W)w, ++preparecnt);
1219   array_needsize (prepares, preparemax, preparecnt, );
1220   prepares [preparecnt - 1] = w;
1221 }
1222
1223 void
1224 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1225 {
1226   ev_clear_pending (EV_A_ (W)w);
1227   if (ev_is_active (w))
1228     return;
1229
1230   prepares [w->active - 1] = prepares [--preparecnt];
1231   ev_stop (EV_A_ (W)w);
1232 }
1233
1234 void
1235 ev_check_start (EV_P_ struct ev_check *w)
1236 {
1237   if (ev_is_active (w))
1238     return;
1239
1240   ev_start (EV_A_ (W)w, ++checkcnt);
1241   array_needsize (checks, checkmax, checkcnt, );
1242   checks [checkcnt - 1] = w;
1243 }
1244
1245 void
1246 ev_check_stop (EV_P_ struct ev_check *w)
1247 {
1248   ev_clear_pending (EV_A_ (W)w);
1249   if (ev_is_active (w))
1250     return;
1251
1252   checks [w->active - 1] = checks [--checkcnt];
1253   ev_stop (EV_A_ (W)w);
1254 }
1255
1256 #ifndef SA_RESTART
1257 # define SA_RESTART 0
1258 #endif
1259
1260 void
1261 ev_signal_start (EV_P_ struct ev_signal *w)
1262 {
1263 #if EV_MULTIPLICITY
1264   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1265 #endif
1266   if (ev_is_active (w))
1267     return;
1268
1269   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1270
1271   ev_start (EV_A_ (W)w, 1);
1272   array_needsize (signals, signalmax, w->signum, signals_init);
1273   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1274
1275   if (!w->next)
1276     {
1277       struct sigaction sa;
1278       sa.sa_handler = sighandler;
1279       sigfillset (&sa.sa_mask);
1280       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1281       sigaction (w->signum, &sa, 0);
1282     }
1283 }
1284
1285 void
1286 ev_signal_stop (EV_P_ struct ev_signal *w)
1287 {
1288   ev_clear_pending (EV_A_ (W)w);
1289   if (!ev_is_active (w))
1290     return;
1291
1292   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1293   ev_stop (EV_A_ (W)w);
1294
1295   if (!signals [w->signum - 1].head)
1296     signal (w->signum, SIG_DFL);
1297 }
1298
1299 void
1300 ev_child_start (EV_P_ struct ev_child *w)
1301 {
1302 #if EV_MULTIPLICITY
1303   assert (("child watchers are only supported in the default loop", loop == default_loop));
1304 #endif
1305   if (ev_is_active (w))
1306     return;
1307
1308   ev_start (EV_A_ (W)w, 1);
1309   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1310 }
1311
1312 void
1313 ev_child_stop (EV_P_ struct ev_child *w)
1314 {
1315   ev_clear_pending (EV_A_ (W)w);
1316   if (ev_is_active (w))
1317     return;
1318
1319   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1320   ev_stop (EV_A_ (W)w);
1321 }
1322
1323 /*****************************************************************************/
1324
1325 struct ev_once
1326 {
1327   struct ev_io io;
1328   struct ev_timer to;
1329   void (*cb)(int revents, void *arg);
1330   void *arg;
1331 };
1332
1333 static void
1334 once_cb (EV_P_ struct ev_once *once, int revents)
1335 {
1336   void (*cb)(int revents, void *arg) = once->cb;
1337   void *arg = once->arg;
1338
1339   ev_io_stop (EV_A_ &once->io);
1340   ev_timer_stop (EV_A_ &once->to);
1341   free (once);
1342
1343   cb (revents, arg);
1344 }
1345
1346 static void
1347 once_cb_io (EV_P_ struct ev_io *w, int revents)
1348 {
1349   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1350 }
1351
1352 static void
1353 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1354 {
1355   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1356 }
1357
1358 void
1359 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1360 {
1361   struct ev_once *once = malloc (sizeof (struct ev_once));
1362
1363   if (!once)
1364     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1365   else
1366     {
1367       once->cb  = cb;
1368       once->arg = arg;
1369
1370       ev_watcher_init (&once->io, once_cb_io);
1371       if (fd >= 0)
1372         {
1373           ev_io_set (&once->io, fd, events);
1374           ev_io_start (EV_A_ &once->io);
1375         }
1376
1377       ev_watcher_init (&once->to, once_cb_to);
1378       if (timeout >= 0.)
1379         {
1380           ev_timer_set (&once->to, timeout, 0.);
1381           ev_timer_start (EV_A_ &once->to);
1382         }
1383     }
1384 }
1385