ev.c

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