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