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