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