ev.c

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