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_USEV_POLL
  64 # define EV_USEV_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
 415 static void
 416 signals_init (ANSIG *base, int count)
 417 {
 418   while (count--)
 419     {
 420       base->head   = 0;
 421       base->gotsig = 0;
 422
 423       ++base;
 424     }
 425 }
 426
 427 static void
 428 sighandler (int signum)
 429 {
 430   signals [signum - 1].gotsig = 1;
 431
 432   if (!gotsig)
 433     {
 434       int old_errno = errno;
 435       gotsig = 1;
 436       write (sigpipe [1], &signum, 1);
 437       errno = old_errno;
 438     }
 439 }
 440
 441 static void
 442 sigcb (EV_P_ struct ev_io *iow, int revents)
 443 {
 444   struct ev_watcher_list *w;
 445   int signum;
 446
 447   read (sigpipe [0], &revents, 1);
 448   gotsig = 0;
 449
 450   for (signum = signalmax; signum--; )
 451     if (signals [signum].gotsig)
 452       {
 453         signals [signum].gotsig = 0;
 454
 455         for (w = signals [signum].head; w; w = w->next)
 456           event (EV_A_ (W)w, EV_SIGNAL);
 457       }
 458 }
 459
 460 static void
 461 siginit (EV_P)
 462 {
 463 #ifndef WIN32
 464   fcntl (sigpipe [0], F_SETFD, FD_CLOEXEC);
 465   fcntl (sigpipe [1], F_SETFD, FD_CLOEXEC);
 466
 467   /* rather than sort out wether we really need nb, set it */
 468   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
 469   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
 470 #endif
 471
 472   ev_io_set (&sigev, sigpipe [0], EV_READ);
 473   ev_io_start (EV_A_ &sigev);
 474   ev_unref (EV_A); /* child watcher should not keep loop alive */
 475 }
 476
 477 /*****************************************************************************/
 478
 479 #ifndef WIN32
 480
 481 #ifndef WCONTINUED
 482 # define WCONTINUED 0
 483 #endif
 484
 485 static void
 486 child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
 487 {
 488   struct ev_child *w;
 489
 490   for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
 491     if (w->pid == pid || !w->pid)
 492       {
 493         w->priority = sw->priority; /* need to do it *now* */
 494         w->rpid     = pid;
 495         w->rstatus  = status;
 496         event (EV_A_ (W)w, EV_CHILD);
 497       }
 498 }
 499
 500 static void
 501 childcb (EV_P_ struct ev_signal *sw, int revents)
 502 {
 503   int pid, status;
 504
 505   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
 506     {
 507       /* make sure we are called again until all childs have been reaped */
 508       event (EV_A_ (W)sw, EV_SIGNAL);
 509
 510       child_reap (EV_A_ sw, pid, pid, status);
 511       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */
 512     }
 513 }
 514
 515 #endif
 516
 517 /*****************************************************************************/
 518
 519 #if EV_USE_KQUEUE
 520 # include "ev_kqueue.c"
 521 #endif
 522 #if EV_USE_EPOLL
 523 # include "ev_epoll.c"
 524 #endif
 525 #if EV_USEV_POLL
 526 # include "ev_poll.c"
 527 #endif
 528 #if EV_USE_SELECT
 529 # include "ev_select.c"
 530 #endif
 531
 532 int
 533 ev_version_major (void)
 534 {
 535   return EV_VERSION_MAJOR;
 536 }
 537
 538 int
 539 ev_version_minor (void)
 540 {
 541   return EV_VERSION_MINOR;
 542 }
 543
 544 /* return true if we are running with elevated privileges and should ignore env variables */
 545 static int
 546 enable_secure (void)
 547 {
 548 #ifdef WIN32
 549   return 0;
 550 #else
 551   return getuid () != geteuid ()
 552       || getgid () != getegid ();
 553 #endif
 554 }
 555
 556 int
 557 ev_method (EV_P)
 558 {
 559   return method;
 560 }
 561
 562 static void
 563 loop_init (EV_P_ int methods)
 564 {
 565   if (!method)
 566     {
 567 #if EV_USE_MONOTONIC
 568       {
 569         struct timespec ts;
 570         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
 571           have_monotonic = 1;
 572       }
 573 #endif
 574
 575       rt_now    = ev_time ();
 576       mn_now    = get_clock ();
 577       now_floor = mn_now;
 578       rtmn_diff = rt_now - mn_now;
 579
 580       if (methods == EVMETHOD_AUTO)
 581         if (!enable_secure () && getenv ("LIBEV_METHODS"))
 582           methods = atoi (getenv ("LIBEV_METHODS"));
 583         else
 584           methods = EVMETHOD_ANY;
 585
 586       method = 0;
 587 #if EV_USE_KQUEUE
 588       if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
 589 #endif
 590 #if EV_USE_EPOLL
 591       if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init  (EV_A_ methods);
 592 #endif
 593 #if EV_USEV_POLL
 594       if (!method && (methods & EVMETHOD_POLL  )) method = poll_init   (EV_A_ methods);
 595 #endif
 596 #if EV_USE_SELECT
 597       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 598 #endif
 599     }
 600 }
 601
 602 void
 603 loop_destroy (EV_P)
 604 {
 605 #if EV_USE_KQUEUE
 606   if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
 607 #endif
 608 #if EV_USE_EPOLL
 609   if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
 610 #endif
 611 #if EV_USEV_POLL
 612   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 613 #endif
 614 #if EV_USE_SELECT
 615   if (method == EVMETHOD_SELECT) select_destroy (EV_A);
 616 #endif
 617
 618   method = 0;
 619   /*TODO*/
 620 }
 621
 622 void
 623 loop_fork (EV_P)
 624 {
 625   /*TODO*/
 626 #if EV_USE_EPOLL
 627   if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
 628 #endif
 629 #if EV_USE_KQUEUE
 630   if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
 631 #endif
 632 }
 633
 634 #if EV_MULTIPLICITY
 635 struct ev_loop *
 636 ev_loop_new (int methods)
 637 {
 638   struct ev_loop *loop = (struct ev_loop *)calloc (1, sizeof (struct ev_loop));
 639
 640   loop_init (EV_A_ methods);
 641
 642   if (ev_methods (EV_A))
 643     return loop;
 644
 645   return 0;
 646 }
 647
 648 void
 649 ev_loop_destroy (EV_P)
 650 {
 651   loop_destroy (EV_A);
 652   free (loop);
 653 }
 654
 655 void
 656 ev_loop_fork (EV_P)
 657 {
 658   loop_fork (EV_A);
 659 }
 660
 661 #endif
 662
 663 #if EV_MULTIPLICITY
 664 struct ev_loop default_loop_struct;
 665 static struct ev_loop *default_loop;
 666
 667 struct ev_loop *
 668 #else
 669 static int default_loop;
 670
 671 int
 672 #endif
 673 ev_default_loop (int methods)
 674 {
 675   if (sigpipe [0] == sigpipe [1])
 676     if (pipe (sigpipe))
 677       return 0;
 678
 679   if (!default_loop)
 680     {
 681 #if EV_MULTIPLICITY
 682       struct ev_loop *loop = default_loop = &default_loop_struct;
 683 #else
 684       default_loop = 1;
 685 #endif
 686
 687       loop_init (EV_A_ methods);
 688
 689       if (ev_method (EV_A))
 690         {
 691           ev_watcher_init (&sigev, sigcb);
 692           ev_set_priority (&sigev, EV_MAXPRI);
 693           siginit (EV_A);
 694
 695 #ifndef WIN32
 696           ev_signal_init (&childev, childcb, SIGCHLD);
 697           ev_set_priority (&childev, EV_MAXPRI);
 698           ev_signal_start (EV_A_ &childev);
 699           ev_unref (EV_A); /* child watcher should not keep loop alive */
 700 #endif
 701         }
 702       else
 703         default_loop = 0;
 704     }
 705
 706   return default_loop;
 707 }
 708
 709 void
 710 ev_default_destroy (void)
 711 {
 712 #if EV_MULTIPLICITY
 713   struct ev_loop *loop = default_loop;
 714 #endif
 715
 716   ev_ref (EV_A); /* child watcher */
 717   ev_signal_stop (EV_A_ &childev);
 718
 719   ev_ref (EV_A); /* signal watcher */
 720   ev_io_stop (EV_A_ &sigev);
 721
 722   close (sigpipe [0]); sigpipe [0] = 0;
 723   close (sigpipe [1]); sigpipe [1] = 0;
 724
 725   loop_destroy (EV_A);
 726 }
 727
 728 void
 729 ev_default_fork (EV_P)
 730 {
 731   loop_fork (EV_A);
 732
 733   ev_io_stop (EV_A_ &sigev);
 734   close (sigpipe [0]);
 735   close (sigpipe [1]);
 736   pipe (sigpipe);
 737
 738   ev_ref (EV_A); /* signal watcher */
 739   siginit (EV_A);
 740 }
 741
 742 /*****************************************************************************/
 743
 744 static void
 745 call_pending (EV_P)
 746 {
 747   int pri;
 748
 749   for (pri = NUMPRI; pri--; )
 750     while (pendingcnt [pri])
 751       {
 752         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
 753
 754         if (p->w)
 755           {
 756             p->w->pending = 0;
 757             p->w->cb (EV_A_ p->w, p->events);
 758           }
 759       }
 760 }
 761
 762 static void
 763 timers_reify (EV_P)
 764 {
 765   while (timercnt && timers [0]->at <= mn_now)
 766     {
 767       struct ev_timer *w = timers [0];
 768
 769       /* first reschedule or stop timer */
 770       if (w->repeat)
 771         {
 772           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 773           w->at = mn_now + w->repeat;
 774           downheap ((WT *)timers, timercnt, 0);
 775         }
 776       else
 777         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 778
 779       event (EV_A_ (W)w, EV_TIMEOUT);
 780     }
 781 }
 782
 783 static void
 784 periodics_reify (EV_P)
 785 {
 786   while (periodiccnt && periodics [0]->at <= rt_now)
 787     {
 788       struct ev_periodic *w = periodics [0];
 789
 790       /* first reschedule or stop timer */
 791       if (w->interval)
 792         {
 793           w->at += floor ((rt_now - w->at) / w->interval + 1.) * w->interval;
 794           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", w->at > rt_now));
 795           downheap ((WT *)periodics, periodiccnt, 0);
 796         }
 797       else
 798         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 799
 800       event (EV_A_ (W)w, EV_PERIODIC);
 801     }
 802 }
 803
 804 static void
 805 periodics_reschedule (EV_P)
 806 {
 807   int i;
 808
 809   /* adjust periodics after time jump */
 810   for (i = 0; i < periodiccnt; ++i)
 811     {
 812       struct ev_periodic *w = periodics [i];
 813
 814       if (w->interval)
 815         {
 816           ev_tstamp diff = ceil ((rt_now - w->at) / w->interval) * w->interval;
 817
 818           if (fabs (diff) >= 1e-4)
 819             {
 820               ev_periodic_stop (EV_A_ w);
 821               ev_periodic_start (EV_A_ w);
 822
 823               i = 0; /* restart loop, inefficient, but time jumps should be rare */
 824             }
 825         }
 826     }
 827 }
 828
 829 inline int
 830 time_update_monotonic (EV_P)
 831 {
 832   mn_now = get_clock ();
 833
 834   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
 835     {
 836       rt_now = rtmn_diff + mn_now;
 837       return 0;
 838     }
 839   else
 840     {
 841       now_floor = mn_now;
 842       rt_now = ev_time ();
 843       return 1;
 844     }
 845 }
 846
 847 static void
 848 time_update (EV_P)
 849 {
 850   int i;
 851
 852 #if EV_USE_MONOTONIC
 853   if (expect_true (have_monotonic))
 854     {
 855       if (time_update_monotonic (EV_A))
 856         {
 857           ev_tstamp odiff = rtmn_diff;
 858
 859           for (i = 4; --i; ) /* loop a few times, before making important decisions */
 860             {
 861               rtmn_diff = rt_now - mn_now;
 862
 863               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
 864                 return; /* all is well */
 865
 866               rt_now    = ev_time ();
 867               mn_now    = get_clock ();
 868               now_floor = mn_now;
 869             }
 870
 871           periodics_reschedule (EV_A);
 872           /* no timer adjustment, as the monotonic clock doesn't jump */
 873           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
 874         }
 875     }
 876   else
 877 #endif
 878     {
 879       rt_now = ev_time ();
 880
 881       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
 882         {
 883           periodics_reschedule (EV_A);
 884
 885           /* adjust timers. this is easy, as the offset is the same for all */
 886           for (i = 0; i < timercnt; ++i)
 887             timers [i]->at += rt_now - mn_now;
 888         }
 889
 890       mn_now = rt_now;
 891     }
 892 }
 893
 894 void
 895 ev_ref (EV_P)
 896 {
 897   ++activecnt;
 898 }
 899
 900 void
 901 ev_unref (EV_P)
 902 {
 903   --activecnt;
 904 }
 905
 906 static int loop_done;
 907
 908 void
 909 ev_loop (EV_P_ int flags)
 910 {
 911   double block;
 912   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
 913
 914   do
 915     {
 916       /* queue check watchers (and execute them) */
 917       if (expect_false (preparecnt))
 918         {
 919           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
 920           call_pending (EV_A);
 921         }
 922
 923       /* update fd-related kernel structures */
 924       fd_reify (EV_A);
 925
 926       /* calculate blocking time */
 927
 928       /* we only need this for !monotonic clockor timers, but as we basically
 929          always have timers, we just calculate it always */
 930 #if EV_USE_MONOTONIC
 931       if (expect_true (have_monotonic))
 932         time_update_monotonic (EV_A);
 933       else
 934 #endif
 935         {
 936           rt_now = ev_time ();
 937           mn_now = rt_now;
 938         }
 939
 940       if (flags & EVLOOP_NONBLOCK || idlecnt)
 941         block = 0.;
 942       else
 943         {
 944           block = MAX_BLOCKTIME;
 945
 946           if (timercnt)
 947             {
 948               ev_tstamp to = timers [0]->at - mn_now + method_fudge;
 949               if (block > to) block = to;
 950             }
 951
 952           if (periodiccnt)
 953             {
 954               ev_tstamp to = periodics [0]->at - rt_now + method_fudge;
 955               if (block > to) block = to;
 956             }
 957
 958           if (block < 0.) block = 0.;
 959         }
 960
 961       method_poll (EV_A_ block);
 962
 963       /* update rt_now, do magic */
 964       time_update (EV_A);
 965
 966       /* queue pending timers and reschedule them */
 967       timers_reify (EV_A); /* relative timers called last */
 968       periodics_reify (EV_A); /* absolute timers called first */
 969
 970       /* queue idle watchers unless io or timers are pending */
 971       if (!pendingcnt)
 972         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
 973
 974       /* queue check watchers, to be executed first */
 975       if (checkcnt)
 976         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
 977
 978       call_pending (EV_A);
 979     }
 980   while (activecnt && !loop_done);
 981
 982   if (loop_done != 2)
 983     loop_done = 0;
 984 }
 985
 986 void
 987 ev_unloop (EV_P_ int how)
 988 {
 989   loop_done = how;
 990 }
 991
 992 /*****************************************************************************/
 993
 994 inline void
 995 wlist_add (WL *head, WL elem)
 996 {
 997   elem->next = *head;
 998   *head = elem;
 999 }
1000
1001 inline void
1002 wlist_del (WL *head, WL elem)
1003 {
1004   while (*head)
1005     {
1006       if (*head == elem)
1007         {
1008           *head = elem->next;
1009           return;
1010         }
1011
1012       head = &(*head)->next;
1013     }
1014 }
1015
1016 inline void
1017 ev_clear_pending (EV_P_ W w)
1018 {
1019   if (w->pending)
1020     {
1021       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1022       w->pending = 0;
1023     }
1024 }
1025
1026 inline void
1027 ev_start (EV_P_ W w, int active)
1028 {
1029   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1030   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1031
1032   w->active = active;
1033   ev_ref (EV_A);
1034 }
1035
1036 inline void
1037 ev_stop (EV_P_ W w)
1038 {
1039   ev_unref (EV_A);
1040   w->active = 0;
1041 }
1042
1043 /*****************************************************************************/
1044
1045 void
1046 ev_io_start (EV_P_ struct ev_io *w)
1047 {
1048   int fd = w->fd;
1049
1050   if (ev_is_active (w))
1051     return;
1052
1053   assert (("ev_io_start called with negative fd", fd >= 0));
1054
1055   ev_start (EV_A_ (W)w, 1);
1056   array_needsize (anfds, anfdmax, fd + 1, anfds_init);
1057   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1058
1059   fd_change (EV_A_ fd);
1060 }
1061
1062 void
1063 ev_io_stop (EV_P_ struct ev_io *w)
1064 {
1065   ev_clear_pending (EV_A_ (W)w);
1066   if (!ev_is_active (w))
1067     return;
1068
1069   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1070   ev_stop (EV_A_ (W)w);
1071
1072   fd_change (EV_A_ w->fd);
1073 }
1074
1075 void
1076 ev_timer_start (EV_P_ struct ev_timer *w)
1077 {
1078   if (ev_is_active (w))
1079     return;
1080
1081   w->at += mn_now;
1082
1083   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1084
1085   ev_start (EV_A_ (W)w, ++timercnt);
1086   array_needsize (timers, timermax, timercnt, );
1087   timers [timercnt - 1] = w;
1088   upheap ((WT *)timers, timercnt - 1);
1089 }
1090
1091 void
1092 ev_timer_stop (EV_P_ struct ev_timer *w)
1093 {
1094   ev_clear_pending (EV_A_ (W)w);
1095   if (!ev_is_active (w))
1096     return;
1097
1098   if (w->active < timercnt--)
1099     {
1100       timers [w->active - 1] = timers [timercnt];
1101       downheap ((WT *)timers, timercnt, w->active - 1);
1102     }
1103
1104   w->at = w->repeat;
1105
1106   ev_stop (EV_A_ (W)w);
1107 }
1108
1109 void
1110 ev_timer_again (EV_P_ struct ev_timer *w)
1111 {
1112   if (ev_is_active (w))
1113     {
1114       if (w->repeat)
1115         {
1116           w->at = mn_now + w->repeat;
1117           downheap ((WT *)timers, timercnt, w->active - 1);
1118         }
1119       else
1120         ev_timer_stop (EV_A_ w);
1121     }
1122   else if (w->repeat)
1123     ev_timer_start (EV_A_ w);
1124 }
1125
1126 void
1127 ev_periodic_start (EV_P_ struct ev_periodic *w)
1128 {
1129   if (ev_is_active (w))
1130     return;
1131
1132   assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1133
1134   /* this formula differs from the one in periodic_reify because we do not always round up */
1135   if (w->interval)
1136     w->at += ceil ((rt_now - w->at) / w->interval) * w->interval;
1137
1138   ev_start (EV_A_ (W)w, ++periodiccnt);
1139   array_needsize (periodics, periodicmax, periodiccnt, );
1140   periodics [periodiccnt - 1] = w;
1141   upheap ((WT *)periodics, periodiccnt - 1);
1142 }
1143
1144 void
1145 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1146 {
1147   ev_clear_pending (EV_A_ (W)w);
1148   if (!ev_is_active (w))
1149     return;
1150
1151   if (w->active < periodiccnt--)
1152     {
1153       periodics [w->active - 1] = periodics [periodiccnt];
1154       downheap ((WT *)periodics, periodiccnt, w->active - 1);
1155     }
1156
1157   ev_stop (EV_A_ (W)w);
1158 }
1159
1160 void
1161 ev_idle_start (EV_P_ struct ev_idle *w)
1162 {
1163   if (ev_is_active (w))
1164     return;
1165
1166   ev_start (EV_A_ (W)w, ++idlecnt);
1167   array_needsize (idles, idlemax, idlecnt, );
1168   idles [idlecnt - 1] = w;
1169 }
1170
1171 void
1172 ev_idle_stop (EV_P_ struct ev_idle *w)
1173 {
1174   ev_clear_pending (EV_A_ (W)w);
1175   if (ev_is_active (w))
1176     return;
1177
1178   idles [w->active - 1] = idles [--idlecnt];
1179   ev_stop (EV_A_ (W)w);
1180 }
1181
1182 void
1183 ev_prepare_start (EV_P_ struct ev_prepare *w)
1184 {
1185   if (ev_is_active (w))
1186     return;
1187
1188   ev_start (EV_A_ (W)w, ++preparecnt);
1189   array_needsize (prepares, preparemax, preparecnt, );
1190   prepares [preparecnt - 1] = w;
1191 }
1192
1193 void
1194 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1195 {
1196   ev_clear_pending (EV_A_ (W)w);
1197   if (ev_is_active (w))
1198     return;
1199
1200   prepares [w->active - 1] = prepares [--preparecnt];
1201   ev_stop (EV_A_ (W)w);
1202 }
1203
1204 void
1205 ev_check_start (EV_P_ struct ev_check *w)
1206 {
1207   if (ev_is_active (w))
1208     return;
1209
1210   ev_start (EV_A_ (W)w, ++checkcnt);
1211   array_needsize (checks, checkmax, checkcnt, );
1212   checks [checkcnt - 1] = w;
1213 }
1214
1215 void
1216 ev_check_stop (EV_P_ struct ev_check *w)
1217 {
1218   ev_clear_pending (EV_A_ (W)w);
1219   if (ev_is_active (w))
1220     return;
1221
1222   checks [w->active - 1] = checks [--checkcnt];
1223   ev_stop (EV_A_ (W)w);
1224 }
1225
1226 #ifndef SA_RESTART
1227 # define SA_RESTART 0
1228 #endif
1229
1230 void
1231 ev_signal_start (EV_P_ struct ev_signal *w)
1232 {
1233 #if EV_MULTIPLICITY
1234   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1235 #endif
1236   if (ev_is_active (w))
1237     return;
1238
1239   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1240
1241   ev_start (EV_A_ (W)w, 1);
1242   array_needsize (signals, signalmax, w->signum, signals_init);
1243   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1244
1245   if (!w->next)
1246     {
1247       struct sigaction sa;
1248       sa.sa_handler = sighandler;
1249       sigfillset (&sa.sa_mask);
1250       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1251       sigaction (w->signum, &sa, 0);
1252     }
1253 }
1254
1255 void
1256 ev_signal_stop (EV_P_ struct ev_signal *w)
1257 {
1258   ev_clear_pending (EV_A_ (W)w);
1259   if (!ev_is_active (w))
1260     return;
1261
1262   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1263   ev_stop (EV_A_ (W)w);
1264
1265   if (!signals [w->signum - 1].head)
1266     signal (w->signum, SIG_DFL);
1267 }
1268
1269 void
1270 ev_child_start (EV_P_ struct ev_child *w)
1271 {
1272 #if EV_MULTIPLICITY
1273   assert (("child watchers are only supported in the default loop", loop == default_loop));
1274 #endif
1275   if (ev_is_active (w))
1276     return;
1277
1278   ev_start (EV_A_ (W)w, 1);
1279   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1280 }
1281
1282 void
1283 ev_child_stop (EV_P_ struct ev_child *w)
1284 {
1285   ev_clear_pending (EV_A_ (W)w);
1286   if (ev_is_active (w))
1287     return;
1288
1289   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1290   ev_stop (EV_A_ (W)w);
1291 }
1292
1293 /*****************************************************************************/
1294
1295 struct ev_once
1296 {
1297   struct ev_io io;
1298   struct ev_timer to;
1299   void (*cb)(int revents, void *arg);
1300   void *arg;
1301 };
1302
1303 static void
1304 once_cb (EV_P_ struct ev_once *once, int revents)
1305 {
1306   void (*cb)(int revents, void *arg) = once->cb;
1307   void *arg = once->arg;
1308
1309   ev_io_stop (EV_A_ &once->io);
1310   ev_timer_stop (EV_A_ &once->to);
1311   free (once);
1312
1313   cb (revents, arg);
1314 }
1315
1316 static void
1317 once_cb_io (EV_P_ struct ev_io *w, int revents)
1318 {
1319   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1320 }
1321
1322 static void
1323 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1324 {
1325   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1326 }
1327
1328 void
1329 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1330 {
1331   struct ev_once *once = malloc (sizeof (struct ev_once));
1332
1333   if (!once)
1334     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1335   else
1336     {
1337       once->cb  = cb;
1338       once->arg = arg;
1339
1340       ev_watcher_init (&once->io, once_cb_io);
1341       if (fd >= 0)
1342         {
1343           ev_io_set (&once->io, fd, events);
1344           ev_io_start (EV_A_ &once->io);
1345         }
1346
1347       ev_watcher_init (&once->to, once_cb_to);
1348       if (timeout >= 0.)
1349         {
1350           ev_timer_set (&once->to, timeout, 0.);
1351           ev_timer_start (EV_A_ &once->to);
1352         }
1353     }
1354 }
1355