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 #define array_free(stem, idx) \
 238   free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 239
 240 /*****************************************************************************/
 241
 242 static void
 243 anfds_init (ANFD *base, int count)
 244 {
 245   while (count--)
 246     {
 247       base->head   = 0;
 248       base->events = EV_NONE;
 249       base->reify  = 0;
 250
 251       ++base;
 252     }
 253 }
 254
 255 static void
 256 event (EV_P_ W w, int events)
 257 {
 258   if (w->pending)
 259     {
 260       pendings [ABSPRI (w)][w->pending - 1].events |= events;
 261       return;
 262     }
 263
 264   w->pending = ++pendingcnt [ABSPRI (w)];
 265   array_needsize (pendings [ABSPRI (w)], pendingmax [ABSPRI (w)], pendingcnt [ABSPRI (w)], );
 266   pendings [ABSPRI (w)][w->pending - 1].w      = w;
 267   pendings [ABSPRI (w)][w->pending - 1].events = events;
 268 }
 269
 270 static void
 271 queue_events (EV_P_ W *events, int eventcnt, int type)
 272 {
 273   int i;
 274
 275   for (i = 0; i < eventcnt; ++i)
 276     event (EV_A_ events [i], type);
 277 }
 278
 279 static void
 280 fd_event (EV_P_ int fd, int events)
 281 {
 282   ANFD *anfd = anfds + fd;
 283   struct ev_io *w;
 284
 285   for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 286     {
 287       int ev = w->events & events;
 288
 289       if (ev)
 290         event (EV_A_ (W)w, ev);
 291     }
 292 }
 293
 294 /*****************************************************************************/
 295
 296 static void
 297 fd_reify (EV_P)
 298 {
 299   int i;
 300
 301   for (i = 0; i < fdchangecnt; ++i)
 302     {
 303       int fd = fdchanges [i];
 304       ANFD *anfd = anfds + fd;
 305       struct ev_io *w;
 306
 307       int events = 0;
 308
 309       for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 310         events |= w->events;
 311
 312       anfd->reify = 0;
 313
 314       method_modify (EV_A_ fd, anfd->events, events);
 315       anfd->events = events;
 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   int i;
 643
 644 #if EV_USE_WIN32
 645   if (method == EVMETHOD_WIN32 ) win32_destroy  (EV_A);
 646 #endif
 647 #if EV_USE_KQUEUE
 648   if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
 649 #endif
 650 #if EV_USE_EPOLL
 651   if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
 652 #endif
 653 #if EV_USE_POLL
 654   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 655 #endif
 656 #if EV_USE_SELECT
 657   if (method == EVMETHOD_SELECT) select_destroy (EV_A);
 658 #endif
 659
 660   for (i = NUMPRI; i--; )
 661     array_free (pending, [i]);
 662
 663   array_free (fdchange, );
 664   array_free (timer, );
 665   array_free (periodic, );
 666   array_free (idle, );
 667   array_free (prepare, );
 668   array_free (check, );
 669
 670   method = 0;
 671   /*TODO*/
 672 }
 673
 674 void
 675 loop_fork (EV_P)
 676 {
 677   /*TODO*/
 678 #if EV_USE_EPOLL
 679   if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
 680 #endif
 681 #if EV_USE_KQUEUE
 682   if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
 683 #endif
 684 }
 685
 686 #if EV_MULTIPLICITY
 687 struct ev_loop *
 688 ev_loop_new (int methods)
 689 {
 690   struct ev_loop *loop = (struct ev_loop *)calloc (1, sizeof (struct ev_loop));
 691
 692   loop_init (EV_A_ methods);
 693
 694   if (ev_method (EV_A))
 695     return loop;
 696
 697   return 0;
 698 }
 699
 700 void
 701 ev_loop_destroy (EV_P)
 702 {
 703   loop_destroy (EV_A);
 704   free (loop);
 705 }
 706
 707 void
 708 ev_loop_fork (EV_P)
 709 {
 710   loop_fork (EV_A);
 711 }
 712
 713 #endif
 714
 715 #if EV_MULTIPLICITY
 716 struct ev_loop default_loop_struct;
 717 static struct ev_loop *default_loop;
 718
 719 struct ev_loop *
 720 #else
 721 static int default_loop;
 722
 723 int
 724 #endif
 725 ev_default_loop (int methods)
 726 {
 727   if (sigpipe [0] == sigpipe [1])
 728     if (pipe (sigpipe))
 729       return 0;
 730
 731   if (!default_loop)
 732     {
 733 #if EV_MULTIPLICITY
 734       struct ev_loop *loop = default_loop = &default_loop_struct;
 735 #else
 736       default_loop = 1;
 737 #endif
 738
 739       loop_init (EV_A_ methods);
 740
 741       if (ev_method (EV_A))
 742         {
 743           ev_watcher_init (&sigev, sigcb);
 744           ev_set_priority (&sigev, EV_MAXPRI);
 745           siginit (EV_A);
 746
 747 #ifndef WIN32
 748           ev_signal_init (&childev, childcb, SIGCHLD);
 749           ev_set_priority (&childev, EV_MAXPRI);
 750           ev_signal_start (EV_A_ &childev);
 751           ev_unref (EV_A); /* child watcher should not keep loop alive */
 752 #endif
 753         }
 754       else
 755         default_loop = 0;
 756     }
 757
 758   return default_loop;
 759 }
 760
 761 void
 762 ev_default_destroy (void)
 763 {
 764 #if EV_MULTIPLICITY
 765   struct ev_loop *loop = default_loop;
 766 #endif
 767
 768   ev_ref (EV_A); /* child watcher */
 769   ev_signal_stop (EV_A_ &childev);
 770
 771   ev_ref (EV_A); /* signal watcher */
 772   ev_io_stop (EV_A_ &sigev);
 773
 774   close (sigpipe [0]); sigpipe [0] = 0;
 775   close (sigpipe [1]); sigpipe [1] = 0;
 776
 777   loop_destroy (EV_A);
 778 }
 779
 780 void
 781 ev_default_fork (void)
 782 {
 783 #if EV_MULTIPLICITY
 784   struct ev_loop *loop = default_loop;
 785 #endif
 786
 787   loop_fork (EV_A);
 788
 789   ev_io_stop (EV_A_ &sigev);
 790   close (sigpipe [0]);
 791   close (sigpipe [1]);
 792   pipe (sigpipe);
 793
 794   ev_ref (EV_A); /* signal watcher */
 795   siginit (EV_A);
 796 }
 797
 798 /*****************************************************************************/
 799
 800 static void
 801 call_pending (EV_P)
 802 {
 803   int pri;
 804
 805   for (pri = NUMPRI; pri--; )
 806     while (pendingcnt [pri])
 807       {
 808         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
 809
 810         if (p->w)
 811           {
 812             p->w->pending = 0;
 813             p->w->cb (EV_A_ p->w, p->events);
 814           }
 815       }
 816 }
 817
 818 static void
 819 timers_reify (EV_P)
 820 {
 821   while (timercnt && ((WT)timers [0])->at <= mn_now)
 822     {
 823       struct ev_timer *w = timers [0];
 824
 825       assert (("inactive timer on timer heap detected", ev_is_active (w)));
 826
 827       /* first reschedule or stop timer */
 828       if (w->repeat)
 829         {
 830           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 831           ((WT)w)->at = mn_now + w->repeat;
 832           downheap ((WT *)timers, timercnt, 0);
 833         }
 834       else
 835         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 836
 837       event (EV_A_ (W)w, EV_TIMEOUT);
 838     }
 839 }
 840
 841 static void
 842 periodics_reify (EV_P)
 843 {
 844   while (periodiccnt && ((WT)periodics [0])->at <= rt_now)
 845     {
 846       struct ev_periodic *w = periodics [0];
 847
 848       assert (("inactive timer on periodic heap detected", ev_is_active (w)));
 849
 850       /* first reschedule or stop timer */
 851       if (w->interval)
 852         {
 853           ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
 854           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
 855           downheap ((WT *)periodics, periodiccnt, 0);
 856         }
 857       else
 858         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 859
 860       event (EV_A_ (W)w, EV_PERIODIC);
 861     }
 862 }
 863
 864 static void
 865 periodics_reschedule (EV_P)
 866 {
 867   int i;
 868
 869   /* adjust periodics after time jump */
 870   for (i = 0; i < periodiccnt; ++i)
 871     {
 872       struct ev_periodic *w = periodics [i];
 873
 874       if (w->interval)
 875         {
 876           ev_tstamp diff = ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
 877
 878           if (fabs (diff) >= 1e-4)
 879             {
 880               ev_periodic_stop (EV_A_ w);
 881               ev_periodic_start (EV_A_ w);
 882
 883               i = 0; /* restart loop, inefficient, but time jumps should be rare */
 884             }
 885         }
 886     }
 887 }
 888
 889 inline int
 890 time_update_monotonic (EV_P)
 891 {
 892   mn_now = get_clock ();
 893
 894   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
 895     {
 896       rt_now = rtmn_diff + mn_now;
 897       return 0;
 898     }
 899   else
 900     {
 901       now_floor = mn_now;
 902       rt_now = ev_time ();
 903       return 1;
 904     }
 905 }
 906
 907 static void
 908 time_update (EV_P)
 909 {
 910   int i;
 911
 912 #if EV_USE_MONOTONIC
 913   if (expect_true (have_monotonic))
 914     {
 915       if (time_update_monotonic (EV_A))
 916         {
 917           ev_tstamp odiff = rtmn_diff;
 918
 919           for (i = 4; --i; ) /* loop a few times, before making important decisions */
 920             {
 921               rtmn_diff = rt_now - mn_now;
 922
 923               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
 924                 return; /* all is well */
 925
 926               rt_now    = ev_time ();
 927               mn_now    = get_clock ();
 928               now_floor = mn_now;
 929             }
 930
 931           periodics_reschedule (EV_A);
 932           /* no timer adjustment, as the monotonic clock doesn't jump */
 933           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
 934         }
 935     }
 936   else
 937 #endif
 938     {
 939       rt_now = ev_time ();
 940
 941       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
 942         {
 943           periodics_reschedule (EV_A);
 944
 945           /* adjust timers. this is easy, as the offset is the same for all */
 946           for (i = 0; i < timercnt; ++i)
 947             ((WT)timers [i])->at += rt_now - mn_now;
 948         }
 949
 950       mn_now = rt_now;
 951     }
 952 }
 953
 954 void
 955 ev_ref (EV_P)
 956 {
 957   ++activecnt;
 958 }
 959
 960 void
 961 ev_unref (EV_P)
 962 {
 963   --activecnt;
 964 }
 965
 966 static int loop_done;
 967
 968 void
 969 ev_loop (EV_P_ int flags)
 970 {
 971   double block;
 972   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
 973
 974   do
 975     {
 976       /* queue check watchers (and execute them) */
 977       if (expect_false (preparecnt))
 978         {
 979           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
 980           call_pending (EV_A);
 981         }
 982
 983       /* update fd-related kernel structures */
 984       fd_reify (EV_A);
 985
 986       /* calculate blocking time */
 987
 988       /* we only need this for !monotonic clockor timers, but as we basically
 989          always have timers, we just calculate it always */
 990 #if EV_USE_MONOTONIC
 991       if (expect_true (have_monotonic))
 992         time_update_monotonic (EV_A);
 993       else
 994 #endif
 995         {
 996           rt_now = ev_time ();
 997           mn_now = rt_now;
 998         }
 999
1000       if (flags & EVLOOP_NONBLOCK || idlecnt)
1001         block = 0.;
1002       else
1003         {
1004           block = MAX_BLOCKTIME;
1005
1006           if (timercnt)
1007             {
1008               ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
1009               if (block > to) block = to;
1010             }
1011
1012           if (periodiccnt)
1013             {
1014               ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge;
1015               if (block > to) block = to;
1016             }
1017
1018           if (block < 0.) block = 0.;
1019         }
1020
1021       method_poll (EV_A_ block);
1022
1023       /* update rt_now, do magic */
1024       time_update (EV_A);
1025
1026       /* queue pending timers and reschedule them */
1027       timers_reify (EV_A); /* relative timers called last */
1028       periodics_reify (EV_A); /* absolute timers called first */
1029
1030       /* queue idle watchers unless io or timers are pending */
1031       if (!pendingcnt)
1032         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1033
1034       /* queue check watchers, to be executed first */
1035       if (checkcnt)
1036         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1037
1038       call_pending (EV_A);
1039     }
1040   while (activecnt && !loop_done);
1041
1042   if (loop_done != 2)
1043     loop_done = 0;
1044 }
1045
1046 void
1047 ev_unloop (EV_P_ int how)
1048 {
1049   loop_done = how;
1050 }
1051
1052 /*****************************************************************************/
1053
1054 inline void
1055 wlist_add (WL *head, WL elem)
1056 {
1057   elem->next = *head;
1058   *head = elem;
1059 }
1060
1061 inline void
1062 wlist_del (WL *head, WL elem)
1063 {
1064   while (*head)
1065     {
1066       if (*head == elem)
1067         {
1068           *head = elem->next;
1069           return;
1070         }
1071
1072       head = &(*head)->next;
1073     }
1074 }
1075
1076 inline void
1077 ev_clear_pending (EV_P_ W w)
1078 {
1079   if (w->pending)
1080     {
1081       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1082       w->pending = 0;
1083     }
1084 }
1085
1086 inline void
1087 ev_start (EV_P_ W w, int active)
1088 {
1089   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1090   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1091
1092   w->active = active;
1093   ev_ref (EV_A);
1094 }
1095
1096 inline void
1097 ev_stop (EV_P_ W w)
1098 {
1099   ev_unref (EV_A);
1100   w->active = 0;
1101 }
1102
1103 /*****************************************************************************/
1104
1105 void
1106 ev_io_start (EV_P_ struct ev_io *w)
1107 {
1108   int fd = w->fd;
1109
1110   if (ev_is_active (w))
1111     return;
1112
1113   assert (("ev_io_start called with negative fd", fd >= 0));
1114
1115   ev_start (EV_A_ (W)w, 1);
1116   array_needsize (anfds, anfdmax, fd + 1, anfds_init);
1117   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1118
1119   fd_change (EV_A_ fd);
1120 }
1121
1122 void
1123 ev_io_stop (EV_P_ struct ev_io *w)
1124 {
1125   ev_clear_pending (EV_A_ (W)w);
1126   if (!ev_is_active (w))
1127     return;
1128
1129   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1130   ev_stop (EV_A_ (W)w);
1131
1132   fd_change (EV_A_ w->fd);
1133 }
1134
1135 void
1136 ev_timer_start (EV_P_ struct ev_timer *w)
1137 {
1138   if (ev_is_active (w))
1139     return;
1140
1141   ((WT)w)->at += mn_now;
1142
1143   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1144
1145   ev_start (EV_A_ (W)w, ++timercnt);
1146   array_needsize (timers, timermax, timercnt, );
1147   timers [timercnt - 1] = w;
1148   upheap ((WT *)timers, timercnt - 1);
1149
1150   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1151 }
1152
1153 void
1154 ev_timer_stop (EV_P_ struct ev_timer *w)
1155 {
1156   ev_clear_pending (EV_A_ (W)w);
1157   if (!ev_is_active (w))
1158     return;
1159
1160   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1161
1162   if (((W)w)->active < timercnt--)
1163     {
1164       timers [((W)w)->active - 1] = timers [timercnt];
1165       downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1166     }
1167
1168   ((WT)w)->at = w->repeat;
1169
1170   ev_stop (EV_A_ (W)w);
1171 }
1172
1173 void
1174 ev_timer_again (EV_P_ struct ev_timer *w)
1175 {
1176   if (ev_is_active (w))
1177     {
1178       if (w->repeat)
1179         {
1180           ((WT)w)->at = mn_now + w->repeat;
1181           downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1182         }
1183       else
1184         ev_timer_stop (EV_A_ w);
1185     }
1186   else if (w->repeat)
1187     ev_timer_start (EV_A_ w);
1188 }
1189
1190 void
1191 ev_periodic_start (EV_P_ struct ev_periodic *w)
1192 {
1193   if (ev_is_active (w))
1194     return;
1195
1196   assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1197
1198   /* this formula differs from the one in periodic_reify because we do not always round up */
1199   if (w->interval)
1200     ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1201
1202   ev_start (EV_A_ (W)w, ++periodiccnt);
1203   array_needsize (periodics, periodicmax, periodiccnt, );
1204   periodics [periodiccnt - 1] = w;
1205   upheap ((WT *)periodics, periodiccnt - 1);
1206
1207   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1208 }
1209
1210 void
1211 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1212 {
1213   ev_clear_pending (EV_A_ (W)w);
1214   if (!ev_is_active (w))
1215     return;
1216
1217   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1218
1219   if (((W)w)->active < periodiccnt--)
1220     {
1221       periodics [((W)w)->active - 1] = periodics [periodiccnt];
1222       downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
1223     }
1224
1225   ev_stop (EV_A_ (W)w);
1226 }
1227
1228 void
1229 ev_idle_start (EV_P_ struct ev_idle *w)
1230 {
1231   if (ev_is_active (w))
1232     return;
1233
1234   ev_start (EV_A_ (W)w, ++idlecnt);
1235   array_needsize (idles, idlemax, idlecnt, );
1236   idles [idlecnt - 1] = w;
1237 }
1238
1239 void
1240 ev_idle_stop (EV_P_ struct ev_idle *w)
1241 {
1242   ev_clear_pending (EV_A_ (W)w);
1243   if (ev_is_active (w))
1244     return;
1245
1246   idles [((W)w)->active - 1] = idles [--idlecnt];
1247   ev_stop (EV_A_ (W)w);
1248 }
1249
1250 void
1251 ev_prepare_start (EV_P_ struct ev_prepare *w)
1252 {
1253   if (ev_is_active (w))
1254     return;
1255
1256   ev_start (EV_A_ (W)w, ++preparecnt);
1257   array_needsize (prepares, preparemax, preparecnt, );
1258   prepares [preparecnt - 1] = w;
1259 }
1260
1261 void
1262 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1263 {
1264   ev_clear_pending (EV_A_ (W)w);
1265   if (ev_is_active (w))
1266     return;
1267
1268   prepares [((W)w)->active - 1] = prepares [--preparecnt];
1269   ev_stop (EV_A_ (W)w);
1270 }
1271
1272 void
1273 ev_check_start (EV_P_ struct ev_check *w)
1274 {
1275   if (ev_is_active (w))
1276     return;
1277
1278   ev_start (EV_A_ (W)w, ++checkcnt);
1279   array_needsize (checks, checkmax, checkcnt, );
1280   checks [checkcnt - 1] = w;
1281 }
1282
1283 void
1284 ev_check_stop (EV_P_ struct ev_check *w)
1285 {
1286   ev_clear_pending (EV_A_ (W)w);
1287   if (ev_is_active (w))
1288     return;
1289
1290   checks [((W)w)->active - 1] = checks [--checkcnt];
1291   ev_stop (EV_A_ (W)w);
1292 }
1293
1294 #ifndef SA_RESTART
1295 # define SA_RESTART 0
1296 #endif
1297
1298 void
1299 ev_signal_start (EV_P_ struct ev_signal *w)
1300 {
1301 #if EV_MULTIPLICITY
1302   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1303 #endif
1304   if (ev_is_active (w))
1305     return;
1306
1307   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1308
1309   ev_start (EV_A_ (W)w, 1);
1310   array_needsize (signals, signalmax, w->signum, signals_init);
1311   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1312
1313   if (!((WL)w)->next)
1314     {
1315       struct sigaction sa;
1316       sa.sa_handler = sighandler;
1317       sigfillset (&sa.sa_mask);
1318       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1319       sigaction (w->signum, &sa, 0);
1320     }
1321 }
1322
1323 void
1324 ev_signal_stop (EV_P_ struct ev_signal *w)
1325 {
1326   ev_clear_pending (EV_A_ (W)w);
1327   if (!ev_is_active (w))
1328     return;
1329
1330   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1331   ev_stop (EV_A_ (W)w);
1332
1333   if (!signals [w->signum - 1].head)
1334     signal (w->signum, SIG_DFL);
1335 }
1336
1337 void
1338 ev_child_start (EV_P_ struct ev_child *w)
1339 {
1340 #if EV_MULTIPLICITY
1341   assert (("child watchers are only supported in the default loop", loop == default_loop));
1342 #endif
1343   if (ev_is_active (w))
1344     return;
1345
1346   ev_start (EV_A_ (W)w, 1);
1347   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1348 }
1349
1350 void
1351 ev_child_stop (EV_P_ struct ev_child *w)
1352 {
1353   ev_clear_pending (EV_A_ (W)w);
1354   if (ev_is_active (w))
1355     return;
1356
1357   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1358   ev_stop (EV_A_ (W)w);
1359 }
1360
1361 /*****************************************************************************/
1362
1363 struct ev_once
1364 {
1365   struct ev_io io;
1366   struct ev_timer to;
1367   void (*cb)(int revents, void *arg);
1368   void *arg;
1369 };
1370
1371 static void
1372 once_cb (EV_P_ struct ev_once *once, int revents)
1373 {
1374   void (*cb)(int revents, void *arg) = once->cb;
1375   void *arg = once->arg;
1376
1377   ev_io_stop (EV_A_ &once->io);
1378   ev_timer_stop (EV_A_ &once->to);
1379   free (once);
1380
1381   cb (revents, arg);
1382 }
1383
1384 static void
1385 once_cb_io (EV_P_ struct ev_io *w, int revents)
1386 {
1387   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1388 }
1389
1390 static void
1391 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1392 {
1393   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1394 }
1395
1396 void
1397 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1398 {
1399   struct ev_once *once = malloc (sizeof (struct ev_once));
1400
1401   if (!once)
1402     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1403   else
1404     {
1405       once->cb  = cb;
1406       once->arg = arg;
1407
1408       ev_watcher_init (&once->io, once_cb_io);
1409       if (fd >= 0)
1410         {
1411           ev_io_set (&once->io, fd, events);
1412           ev_io_start (EV_A_ &once->io);
1413         }
1414
1415       ev_watcher_init (&once->to, once_cb_to);
1416       if (timeout >= 0.)
1417         {
1418           ev_timer_set (&once->to, timeout, 0.);
1419           ev_timer_start (EV_A_ &once->to);
1420         }
1421     }
1422 }
1423