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