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