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