ev.c

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