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