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 #ifndef EV_STANDALONE
  32 # include "config.h"
  33
  34 # if HAVE_CLOCK_GETTIME
  35 #  define EV_USE_MONOTONIC 1
  36 #  define EV_USE_REALTIME  1
  37 # endif
  38
  39 # if HAVE_SELECT && HAVE_SYS_SELECT_H
  40 #  define EV_USE_SELECT 1
  41 # endif
  42
  43 # if HAVE_POLL && HAVE_POLL_H
  44 #  define EV_USE_POLL 1
  45 # endif
  46
  47 # if HAVE_EPOLL && HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
  48 #  define EV_USE_EPOLL 1
  49 # endif
  50
  51 # if HAVE_KQUEUE && HAVE_WORKING_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
  52 #  define EV_USE_KQUEUE 1
  53 # endif
  54
  55 #endif
  56
  57 #include <math.h>
  58 #include <stdlib.h>
  59 #include <fcntl.h>
  60 #include <stddef.h>
  61
  62 #include <stdio.h>
  63
  64 #include <assert.h>
  65 #include <errno.h>
  66 #include <sys/types.h>
  67 #include <time.h>
  68
  69 #include <signal.h>
  70
  71 #ifndef WIN32
  72 # include <unistd.h>
  73 # include <sys/time.h>
  74 # include <sys/wait.h>
  75 #endif
  76 /**/
  77
  78 #ifndef EV_USE_MONOTONIC
  79 # define EV_USE_MONOTONIC 1
  80 #endif
  81
  82 #ifndef EV_USE_SELECT
  83 # define EV_USE_SELECT 1
  84 #endif
  85
  86 #ifndef EV_USE_POLL
  87 # define EV_USE_POLL 0 /* poll is usually slower than select, and not as well tested */
  88 #endif
  89
  90 #ifndef EV_USE_EPOLL
  91 # define EV_USE_EPOLL 0
  92 #endif
  93
  94 #ifndef EV_USE_KQUEUE
  95 # define EV_USE_KQUEUE 0
  96 #endif
  97
  98 #ifndef EV_USE_WIN32
  99 # ifdef WIN32
 100 #  define EV_USE_WIN32 0 /* it does not exist, use select */
 101 #  undef EV_USE_SELECT
 102 #  define EV_USE_SELECT 1
 103 # else
 104 #  define EV_USE_WIN32 0
 105 # endif
 106 #endif
 107
 108 #ifndef EV_USE_REALTIME
 109 # define EV_USE_REALTIME 1
 110 #endif
 111
 112 /**/
 113
 114 #ifndef CLOCK_MONOTONIC
 115 # undef EV_USE_MONOTONIC
 116 # define EV_USE_MONOTONIC 0
 117 #endif
 118
 119 #ifndef CLOCK_REALTIME
 120 # undef EV_USE_REALTIME
 121 # define EV_USE_REALTIME 0
 122 #endif
 123
 124 /**/
 125
 126 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 127 #define MAX_BLOCKTIME 59.731 /* never wait longer than this time (to detect time jumps) */
 128 #define PID_HASHSIZE  16 /* size of pid hash table, must be power of two */
 129 /*#define CLEANUP_INTERVAL 300. /* how often to try to free memory and re-check fds */
 130
 131 #ifdef EV_H
 132 # include EV_H
 133 #else
 134 # include "ev.h"
 135 #endif
 136
 137 #if __GNUC__ >= 3
 138 # define expect(expr,value)         __builtin_expect ((expr),(value))
 139 # define inline                     inline
 140 #else
 141 # define expect(expr,value)         (expr)
 142 # define inline                     static
 143 #endif
 144
 145 #define expect_false(expr) expect ((expr) != 0, 0)
 146 #define expect_true(expr)  expect ((expr) != 0, 1)
 147
 148 #define NUMPRI    (EV_MAXPRI - EV_MINPRI + 1)
 149 #define ABSPRI(w) ((w)->priority - EV_MINPRI)
 150
 151 typedef struct ev_watcher *W;
 152 typedef struct ev_watcher_list *WL;
 153 typedef struct ev_watcher_time *WT;
 154
 155 static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 156
 157 #include "ev_win32.c"
 158
 159 /*****************************************************************************/
 160
 161 static void (*syserr_cb)(const char *msg);
 162
 163 void ev_set_syserr_cb (void (*cb)(const char *msg))
 164 {
 165   syserr_cb = cb;
 166 }
 167
 168 static void
 169 syserr (const char *msg)
 170 {
 171   if (!msg)
 172     msg = "(libev) system error";
 173
 174   if (syserr_cb)
 175     syserr_cb (msg);
 176   else
 177     {
 178       perror (msg);
 179       abort ();
 180     }
 181 }
 182
 183 static void *(*alloc)(void *ptr, long size);
 184
 185 void ev_set_allocator (void *(*cb)(void *ptr, long size))
 186 {
 187   alloc = cb;
 188 }
 189
 190 static void *
 191 ev_realloc (void *ptr, long size)
 192 {
 193   ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
 194
 195   if (!ptr && size)
 196     {
 197       fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
 198       abort ();
 199     }
 200
 201   return ptr;
 202 }
 203
 204 #define ev_malloc(size) ev_realloc (0, (size))
 205 #define ev_free(ptr)    ev_realloc ((ptr), 0)
 206
 207 /*****************************************************************************/
 208
 209 typedef struct
 210 {
 211   WL head;
 212   unsigned char events;
 213   unsigned char reify;
 214 } ANFD;
 215
 216 typedef struct
 217 {
 218   W w;
 219   int events;
 220 } ANPENDING;
 221
 222 #if EV_MULTIPLICITY
 223
 224   struct ev_loop
 225   {
 226     #define VAR(name,decl) decl;
 227       #include "ev_vars.h"
 228     #undef VAR
 229   };
 230   #include "ev_wrap.h"
 231
 232   struct ev_loop default_loop_struct;
 233   static struct ev_loop *default_loop;
 234
 235 #else
 236
 237   #define VAR(name,decl) static decl;
 238     #include "ev_vars.h"
 239   #undef VAR
 240
 241   static int default_loop;
 242
 243 #endif
 244
 245 /*****************************************************************************/
 246
 247 inline ev_tstamp
 248 ev_time (void)
 249 {
 250 #if EV_USE_REALTIME
 251   struct timespec ts;
 252   clock_gettime (CLOCK_REALTIME, &ts);
 253   return ts.tv_sec + ts.tv_nsec * 1e-9;
 254 #else
 255   struct timeval tv;
 256   gettimeofday (&tv, 0);
 257   return tv.tv_sec + tv.tv_usec * 1e-6;
 258 #endif
 259 }
 260
 261 inline ev_tstamp
 262 get_clock (void)
 263 {
 264 #if EV_USE_MONOTONIC
 265   if (expect_true (have_monotonic))
 266     {
 267       struct timespec ts;
 268       clock_gettime (CLOCK_MONOTONIC, &ts);
 269       return ts.tv_sec + ts.tv_nsec * 1e-9;
 270     }
 271 #endif
 272
 273   return ev_time ();
 274 }
 275
 276 ev_tstamp
 277 ev_now (EV_P)
 278 {
 279   return rt_now;
 280 }
 281
 282 #define array_roundsize(type,n) ((n) | 4 & ~3)
 283
 284 #define array_needsize(type,base,cur,cnt,init)                  \
 285   if (expect_false ((cnt) > cur))                               \
 286     {                                                           \
 287       int newcnt = cur;                                         \
 288       do                                                        \
 289         {                                                       \
 290           newcnt = array_roundsize (type, newcnt << 1);         \
 291         }                                                       \
 292       while ((cnt) > newcnt);                                   \
 293                                                                 \
 294       base = (type *)ev_realloc (base, sizeof (type) * (newcnt));\
 295       init (base + cur, newcnt - cur);                          \
 296       cur = newcnt;                                             \
 297     }
 298
 299 #define array_slim(type,stem)                                   \
 300   if (stem ## max < array_roundsize (stem ## cnt >> 2))         \
 301     {                                                           \
 302       stem ## max = array_roundsize (stem ## cnt >> 1);         \
 303       base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
 304       fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
 305     }
 306
 307 /* microsoft's pseudo-c is quite far from C as the rest of the world and the standard knows it */
 308 /* bringing us everlasting joy in form of stupid extra macros that are not required in C */
 309 #define array_free_microshit(stem) \
 310   ev_free (stem ## s); stem ## cnt = stem ## max = 0;
 311
 312 #define array_free(stem, idx) \
 313   ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 314
 315 /*****************************************************************************/
 316
 317 static void
 318 anfds_init (ANFD *base, int count)
 319 {
 320   while (count--)
 321     {
 322       base->head   = 0;
 323       base->events = EV_NONE;
 324       base->reify  = 0;
 325
 326       ++base;
 327     }
 328 }
 329
 330 void
 331 ev_feed_event (EV_P_ void *w, int revents)
 332 {
 333   W w_ = (W)w;
 334
 335   if (w_->pending)
 336     {
 337       pendings [ABSPRI (w_)][w_->pending - 1].events |= revents;
 338       return;
 339     }
 340
 341   w_->pending = ++pendingcnt [ABSPRI (w_)];
 342   array_needsize (ANPENDING, pendings [ABSPRI (w_)], pendingmax [ABSPRI (w_)], pendingcnt [ABSPRI (w_)], (void));
 343   pendings [ABSPRI (w_)][w_->pending - 1].w      = w_;
 344   pendings [ABSPRI (w_)][w_->pending - 1].events = revents;
 345 }
 346
 347 static void
 348 queue_events (EV_P_ W *events, int eventcnt, int type)
 349 {
 350   int i;
 351
 352   for (i = 0; i < eventcnt; ++i)
 353     ev_feed_event (EV_A_ events [i], type);
 354 }
 355
 356 inline void
 357 fd_event (EV_P_ int fd, int revents)
 358 {
 359   ANFD *anfd = anfds + fd;
 360   struct ev_io *w;
 361
 362   for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 363     {
 364       int ev = w->events & revents;
 365
 366       if (ev)
 367         ev_feed_event (EV_A_ (W)w, ev);
 368     }
 369 }
 370
 371 void
 372 ev_feed_fd_event (EV_P_ int fd, int revents)
 373 {
 374   fd_event (EV_A_ fd, revents);
 375 }
 376
 377 /*****************************************************************************/
 378
 379 static void
 380 fd_reify (EV_P)
 381 {
 382   int i;
 383
 384   for (i = 0; i < fdchangecnt; ++i)
 385     {
 386       int fd = fdchanges [i];
 387       ANFD *anfd = anfds + fd;
 388       struct ev_io *w;
 389
 390       int events = 0;
 391
 392       for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
 393         events |= w->events;
 394
 395       anfd->reify = 0;
 396
 397       method_modify (EV_A_ fd, anfd->events, events);
 398       anfd->events = events;
 399     }
 400
 401   fdchangecnt = 0;
 402 }
 403
 404 static void
 405 fd_change (EV_P_ int fd)
 406 {
 407   if (anfds [fd].reify)
 408     return;
 409
 410   anfds [fd].reify = 1;
 411
 412   ++fdchangecnt;
 413   array_needsize (int, fdchanges, fdchangemax, fdchangecnt, (void));
 414   fdchanges [fdchangecnt - 1] = fd;
 415 }
 416
 417 static void
 418 fd_kill (EV_P_ int fd)
 419 {
 420   struct ev_io *w;
 421
 422   while ((w = (struct ev_io *)anfds [fd].head))
 423     {
 424       ev_io_stop (EV_A_ w);
 425       ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
 426     }
 427 }
 428
 429 static int
 430 fd_valid (int fd)
 431 {
 432 #ifdef WIN32
 433   return !!win32_get_osfhandle (fd);
 434 #else
 435   return fcntl (fd, F_GETFD) != -1;
 436 #endif
 437 }
 438
 439 /* called on EBADF to verify fds */
 440 static void
 441 fd_ebadf (EV_P)
 442 {
 443   int fd;
 444
 445   for (fd = 0; fd < anfdmax; ++fd)
 446     if (anfds [fd].events)
 447       if (!fd_valid (fd) == -1 && errno == EBADF)
 448         fd_kill (EV_A_ fd);
 449 }
 450
 451 /* called on ENOMEM in select/poll to kill some fds and retry */
 452 static void
 453 fd_enomem (EV_P)
 454 {
 455   int fd;
 456
 457   for (fd = anfdmax; fd--; )
 458     if (anfds [fd].events)
 459       {
 460         fd_kill (EV_A_ fd);
 461         return;
 462       }
 463 }
 464
 465 /* usually called after fork if method needs to re-arm all fds from scratch */
 466 static void
 467 fd_rearm_all (EV_P)
 468 {
 469   int fd;
 470
 471   /* this should be highly optimised to not do anything but set a flag */
 472   for (fd = 0; fd < anfdmax; ++fd)
 473     if (anfds [fd].events)
 474       {
 475         anfds [fd].events = 0;
 476         fd_change (EV_A_ fd);
 477       }
 478 }
 479
 480 /*****************************************************************************/
 481
 482 static void
 483 upheap (WT *heap, int k)
 484 {
 485   WT w = heap [k];
 486
 487   while (k && heap [k >> 1]->at > w->at)
 488     {
 489       heap [k] = heap [k >> 1];
 490       ((W)heap [k])->active = k + 1;
 491       k >>= 1;
 492     }
 493
 494   heap [k] = w;
 495   ((W)heap [k])->active = k + 1;
 496
 497 }
 498
 499 static void
 500 downheap (WT *heap, int N, int k)
 501 {
 502   WT w = heap [k];
 503
 504   while (k < (N >> 1))
 505     {
 506       int j = k << 1;
 507
 508       if (j + 1 < N && heap [j]->at > heap [j + 1]->at)
 509         ++j;
 510
 511       if (w->at <= heap [j]->at)
 512         break;
 513
 514       heap [k] = heap [j];
 515       ((W)heap [k])->active = k + 1;
 516       k = j;
 517     }
 518
 519   heap [k] = w;
 520   ((W)heap [k])->active = k + 1;
 521 }
 522
 523 /*****************************************************************************/
 524
 525 typedef struct
 526 {
 527   WL head;
 528   sig_atomic_t volatile gotsig;
 529 } ANSIG;
 530
 531 static ANSIG *signals;
 532 static int signalmax;
 533
 534 static int sigpipe [2];
 535 static sig_atomic_t volatile gotsig;
 536 static struct ev_io sigev;
 537
 538 static void
 539 signals_init (ANSIG *base, int count)
 540 {
 541   while (count--)
 542     {
 543       base->head   = 0;
 544       base->gotsig = 0;
 545
 546       ++base;
 547     }
 548 }
 549
 550 static void
 551 sighandler (int signum)
 552 {
 553 #if WIN32
 554   signal (signum, sighandler);
 555 #endif
 556
 557   signals [signum - 1].gotsig = 1;
 558
 559   if (!gotsig)
 560     {
 561       int old_errno = errno;
 562       gotsig = 1;
 563 #ifdef WIN32
 564       send (sigpipe [1], &signum, 1, MSG_DONTWAIT);
 565 #else
 566       write (sigpipe [1], &signum, 1);
 567 #endif
 568       errno = old_errno;
 569     }
 570 }
 571
 572 void
 573 ev_feed_signal_event (EV_P_ int signum)
 574 {
 575   WL w;
 576
 577 #if EV_MULTIPLICITY
 578   assert (("feeding signal events is only supported in the default loop", loop == default_loop));
 579 #endif
 580
 581   --signum;
 582
 583   if (signum < 0 || signum >= signalmax)
 584     return;
 585
 586   signals [signum].gotsig = 0;
 587
 588   for (w = signals [signum].head; w; w = w->next)
 589     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 590 }
 591
 592 static void
 593 sigcb (EV_P_ struct ev_io *iow, int revents)
 594 {
 595   int signum;
 596
 597 #ifdef WIN32
 598   recv (sigpipe [0], &revents, 1, MSG_DONTWAIT);
 599 #else
 600   read (sigpipe [0], &revents, 1);
 601 #endif
 602   gotsig = 0;
 603
 604   for (signum = signalmax; signum--; )
 605     if (signals [signum].gotsig)
 606       ev_feed_signal_event (EV_A_ signum + 1);
 607 }
 608
 609 static void
 610 siginit (EV_P)
 611 {
 612 #ifndef WIN32
 613   fcntl (sigpipe [0], F_SETFD, FD_CLOEXEC);
 614   fcntl (sigpipe [1], F_SETFD, FD_CLOEXEC);
 615
 616   /* rather than sort out wether we really need nb, set it */
 617   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
 618   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
 619 #endif
 620
 621   ev_io_set (&sigev, sigpipe [0], EV_READ);
 622   ev_io_start (EV_A_ &sigev);
 623   ev_unref (EV_A); /* child watcher should not keep loop alive */
 624 }
 625
 626 /*****************************************************************************/
 627
 628 static struct ev_child *childs [PID_HASHSIZE];
 629
 630 #ifndef WIN32
 631
 632 static struct ev_signal childev;
 633
 634 #ifndef WCONTINUED
 635 # define WCONTINUED 0
 636 #endif
 637
 638 static void
 639 child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
 640 {
 641   struct ev_child *w;
 642
 643   for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
 644     if (w->pid == pid || !w->pid)
 645       {
 646         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
 647         w->rpid         = pid;
 648         w->rstatus      = status;
 649         ev_feed_event (EV_A_ (W)w, EV_CHILD);
 650       }
 651 }
 652
 653 static void
 654 childcb (EV_P_ struct ev_signal *sw, int revents)
 655 {
 656   int pid, status;
 657
 658   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
 659     {
 660       /* make sure we are called again until all childs have been reaped */
 661       ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
 662
 663       child_reap (EV_A_ sw, pid, pid, status);
 664       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */
 665     }
 666 }
 667
 668 #endif
 669
 670 /*****************************************************************************/
 671
 672 #if EV_USE_KQUEUE
 673 # include "ev_kqueue.c"
 674 #endif
 675 #if EV_USE_EPOLL
 676 # include "ev_epoll.c"
 677 #endif
 678 #if EV_USE_POLL
 679 # include "ev_poll.c"
 680 #endif
 681 #if EV_USE_SELECT
 682 # include "ev_select.c"
 683 #endif
 684
 685 int
 686 ev_version_major (void)
 687 {
 688   return EV_VERSION_MAJOR;
 689 }
 690
 691 int
 692 ev_version_minor (void)
 693 {
 694   return EV_VERSION_MINOR;
 695 }
 696
 697 /* return true if we are running with elevated privileges and should ignore env variables */
 698 static int
 699 enable_secure (void)
 700 {
 701 #ifdef WIN32
 702   return 0;
 703 #else
 704   return getuid () != geteuid ()
 705       || getgid () != getegid ();
 706 #endif
 707 }
 708
 709 int
 710 ev_method (EV_P)
 711 {
 712   return method;
 713 }
 714
 715 static void
 716 loop_init (EV_P_ int methods)
 717 {
 718   if (!method)
 719     {
 720 #if EV_USE_MONOTONIC
 721       {
 722         struct timespec ts;
 723         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
 724           have_monotonic = 1;
 725       }
 726 #endif
 727
 728       rt_now    = ev_time ();
 729       mn_now    = get_clock ();
 730       now_floor = mn_now;
 731       rtmn_diff = rt_now - mn_now;
 732
 733       if (methods == EVMETHOD_AUTO)
 734         if (!enable_secure () && getenv ("LIBEV_METHODS"))
 735           methods = atoi (getenv ("LIBEV_METHODS"));
 736         else
 737           methods = EVMETHOD_ANY;
 738
 739       method = 0;
 740 #if EV_USE_WIN32
 741       if (!method && (methods & EVMETHOD_WIN32 )) method = win32_init  (EV_A_ methods);
 742 #endif
 743 #if EV_USE_KQUEUE
 744       if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
 745 #endif
 746 #if EV_USE_EPOLL
 747       if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init  (EV_A_ methods);
 748 #endif
 749 #if EV_USE_POLL
 750       if (!method && (methods & EVMETHOD_POLL  )) method = poll_init   (EV_A_ methods);
 751 #endif
 752 #if EV_USE_SELECT
 753       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 754 #endif
 755
 756       ev_init (&sigev, sigcb);
 757       ev_set_priority (&sigev, EV_MAXPRI);
 758     }
 759 }
 760
 761 void
 762 loop_destroy (EV_P)
 763 {
 764   int i;
 765
 766 #if EV_USE_WIN32
 767   if (method == EVMETHOD_WIN32 ) win32_destroy  (EV_A);
 768 #endif
 769 #if EV_USE_KQUEUE
 770   if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
 771 #endif
 772 #if EV_USE_EPOLL
 773   if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
 774 #endif
 775 #if EV_USE_POLL
 776   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 777 #endif
 778 #if EV_USE_SELECT
 779   if (method == EVMETHOD_SELECT) select_destroy (EV_A);
 780 #endif
 781
 782   for (i = NUMPRI; i--; )
 783     array_free (pending, [i]);
 784
 785   /* have to use the microsoft-never-gets-it-right macro */
 786   array_free_microshit (fdchange);
 787   array_free_microshit (timer);
 788   array_free_microshit (periodic);
 789   array_free_microshit (idle);
 790   array_free_microshit (prepare);
 791   array_free_microshit (check);
 792
 793   method = 0;
 794 }
 795
 796 static void
 797 loop_fork (EV_P)
 798 {
 799 #if EV_USE_EPOLL
 800   if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
 801 #endif
 802 #if EV_USE_KQUEUE
 803   if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
 804 #endif
 805
 806   if (ev_is_active (&sigev))
 807     {
 808       /* default loop */
 809
 810       ev_ref (EV_A);
 811       ev_io_stop (EV_A_ &sigev);
 812       close (sigpipe [0]);
 813       close (sigpipe [1]);
 814
 815       while (pipe (sigpipe))
 816         syserr ("(libev) error creating pipe");
 817
 818       siginit (EV_A);
 819     }
 820
 821   postfork = 0;
 822 }
 823
 824 #if EV_MULTIPLICITY
 825 struct ev_loop *
 826 ev_loop_new (int methods)
 827 {
 828   struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
 829
 830   memset (loop, 0, sizeof (struct ev_loop));
 831
 832   loop_init (EV_A_ methods);
 833
 834   if (ev_method (EV_A))
 835     return loop;
 836
 837   return 0;
 838 }
 839
 840 void
 841 ev_loop_destroy (EV_P)
 842 {
 843   loop_destroy (EV_A);
 844   ev_free (loop);
 845 }
 846
 847 void
 848 ev_loop_fork (EV_P)
 849 {
 850   postfork = 1;
 851 }
 852
 853 #endif
 854
 855 #if EV_MULTIPLICITY
 856 struct ev_loop *
 857 #else
 858 int
 859 #endif
 860 ev_default_loop (int methods)
 861 {
 862   if (sigpipe [0] == sigpipe [1])
 863     if (pipe (sigpipe))
 864       return 0;
 865
 866   if (!default_loop)
 867     {
 868 #if EV_MULTIPLICITY
 869       struct ev_loop *loop = default_loop = &default_loop_struct;
 870 #else
 871       default_loop = 1;
 872 #endif
 873
 874       loop_init (EV_A_ methods);
 875
 876       if (ev_method (EV_A))
 877         {
 878           siginit (EV_A);
 879
 880 #ifndef WIN32
 881           ev_signal_init (&childev, childcb, SIGCHLD);
 882           ev_set_priority (&childev, EV_MAXPRI);
 883           ev_signal_start (EV_A_ &childev);
 884           ev_unref (EV_A); /* child watcher should not keep loop alive */
 885 #endif
 886         }
 887       else
 888         default_loop = 0;
 889     }
 890
 891   return default_loop;
 892 }
 893
 894 void
 895 ev_default_destroy (void)
 896 {
 897 #if EV_MULTIPLICITY
 898   struct ev_loop *loop = default_loop;
 899 #endif
 900
 901 #ifndef WIN32
 902   ev_ref (EV_A); /* child watcher */
 903   ev_signal_stop (EV_A_ &childev);
 904 #endif
 905
 906   ev_ref (EV_A); /* signal watcher */
 907   ev_io_stop (EV_A_ &sigev);
 908
 909   close (sigpipe [0]); sigpipe [0] = 0;
 910   close (sigpipe [1]); sigpipe [1] = 0;
 911
 912   loop_destroy (EV_A);
 913 }
 914
 915 void
 916 ev_default_fork (void)
 917 {
 918 #if EV_MULTIPLICITY
 919   struct ev_loop *loop = default_loop;
 920 #endif
 921
 922   if (method)
 923     postfork = 1;
 924 }
 925
 926 /*****************************************************************************/
 927
 928 static int
 929 any_pending (EV_P)
 930 {
 931   int pri;
 932
 933   for (pri = NUMPRI; pri--; )
 934     if (pendingcnt [pri])
 935       return 1;
 936
 937   return 0;
 938 }
 939
 940 static void
 941 call_pending (EV_P)
 942 {
 943   int pri;
 944
 945   for (pri = NUMPRI; pri--; )
 946     while (pendingcnt [pri])
 947       {
 948         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
 949
 950         if (p->w)
 951           {
 952             p->w->pending = 0;
 953             EV_CB_INVOKE (p->w, p->events);
 954           }
 955       }
 956 }
 957
 958 static void
 959 timers_reify (EV_P)
 960 {
 961   while (timercnt && ((WT)timers [0])->at <= mn_now)
 962     {
 963       struct ev_timer *w = timers [0];
 964
 965       assert (("inactive timer on timer heap detected", ev_is_active (w)));
 966
 967       /* first reschedule or stop timer */
 968       if (w->repeat)
 969         {
 970           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 971           ((WT)w)->at = mn_now + w->repeat;
 972           downheap ((WT *)timers, timercnt, 0);
 973         }
 974       else
 975         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 976
 977       ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
 978     }
 979 }
 980
 981 static void
 982 periodics_reify (EV_P)
 983 {
 984   while (periodiccnt && ((WT)periodics [0])->at <= rt_now)
 985     {
 986       struct ev_periodic *w = periodics [0];
 987
 988       assert (("inactive timer on periodic heap detected", ev_is_active (w)));
 989
 990       /* first reschedule or stop timer */
 991       if (w->reschedule_cb)
 992         {
 993           ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, rt_now + 0.0001);
 994
 995           assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > rt_now));
 996           downheap ((WT *)periodics, periodiccnt, 0);
 997         }
 998       else if (w->interval)
 999         {
1000           ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
1001           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
1002           downheap ((WT *)periodics, periodiccnt, 0);
1003         }
1004       else
1005         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1006
1007       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
1008     }
1009 }
1010
1011 static void
1012 periodics_reschedule (EV_P)
1013 {
1014   int i;
1015
1016   /* adjust periodics after time jump */
1017   for (i = 0; i < periodiccnt; ++i)
1018     {
1019       struct ev_periodic *w = periodics [i];
1020
1021       if (w->reschedule_cb)
1022         ((WT)w)->at = w->reschedule_cb (w, rt_now);
1023       else if (w->interval)
1024         ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1025     }
1026
1027   /* now rebuild the heap */
1028   for (i = periodiccnt >> 1; i--; )
1029     downheap ((WT *)periodics, periodiccnt, i);
1030 }
1031
1032 inline int
1033 time_update_monotonic (EV_P)
1034 {
1035   mn_now = get_clock ();
1036
1037   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
1038     {
1039       rt_now = rtmn_diff + mn_now;
1040       return 0;
1041     }
1042   else
1043     {
1044       now_floor = mn_now;
1045       rt_now = ev_time ();
1046       return 1;
1047     }
1048 }
1049
1050 static void
1051 time_update (EV_P)
1052 {
1053   int i;
1054
1055 #if EV_USE_MONOTONIC
1056   if (expect_true (have_monotonic))
1057     {
1058       if (time_update_monotonic (EV_A))
1059         {
1060           ev_tstamp odiff = rtmn_diff;
1061
1062           for (i = 4; --i; ) /* loop a few times, before making important decisions */
1063             {
1064               rtmn_diff = rt_now - mn_now;
1065
1066               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
1067                 return; /* all is well */
1068
1069               rt_now    = ev_time ();
1070               mn_now    = get_clock ();
1071               now_floor = mn_now;
1072             }
1073
1074           periodics_reschedule (EV_A);
1075           /* no timer adjustment, as the monotonic clock doesn't jump */
1076           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1077         }
1078     }
1079   else
1080 #endif
1081     {
1082       rt_now = ev_time ();
1083
1084       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
1085         {
1086           periodics_reschedule (EV_A);
1087
1088           /* adjust timers. this is easy, as the offset is the same for all */
1089           for (i = 0; i < timercnt; ++i)
1090             ((WT)timers [i])->at += rt_now - mn_now;
1091         }
1092
1093       mn_now = rt_now;
1094     }
1095 }
1096
1097 void
1098 ev_ref (EV_P)
1099 {
1100   ++activecnt;
1101 }
1102
1103 void
1104 ev_unref (EV_P)
1105 {
1106   --activecnt;
1107 }
1108
1109 static int loop_done;
1110
1111 void
1112 ev_loop (EV_P_ int flags)
1113 {
1114   double block;
1115   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
1116
1117   do
1118     {
1119       /* queue check watchers (and execute them) */
1120       if (expect_false (preparecnt))
1121         {
1122           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1123           call_pending (EV_A);
1124         }
1125
1126       /* we might have forked, so reify kernel state if necessary */
1127       if (expect_false (postfork))
1128         loop_fork (EV_A);
1129
1130       /* update fd-related kernel structures */
1131       fd_reify (EV_A);
1132
1133       /* calculate blocking time */
1134
1135       /* we only need this for !monotonic clock or timers, but as we basically
1136          always have timers, we just calculate it always */
1137 #if EV_USE_MONOTONIC
1138       if (expect_true (have_monotonic))
1139         time_update_monotonic (EV_A);
1140       else
1141 #endif
1142         {
1143           rt_now = ev_time ();
1144           mn_now = rt_now;
1145         }
1146
1147       if (flags & EVLOOP_NONBLOCK || idlecnt)
1148         block = 0.;
1149       else
1150         {
1151           block = MAX_BLOCKTIME;
1152
1153           if (timercnt)
1154             {
1155               ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
1156               if (block > to) block = to;
1157             }
1158
1159           if (periodiccnt)
1160             {
1161               ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge;
1162               if (block > to) block = to;
1163             }
1164
1165           if (block < 0.) block = 0.;
1166         }
1167
1168       method_poll (EV_A_ block);
1169
1170       /* update rt_now, do magic */
1171       time_update (EV_A);
1172
1173       /* queue pending timers and reschedule them */
1174       timers_reify (EV_A); /* relative timers called last */
1175       periodics_reify (EV_A); /* absolute timers called first */
1176
1177       /* queue idle watchers unless io or timers are pending */
1178       if (idlecnt && !any_pending (EV_A))
1179         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1180
1181       /* queue check watchers, to be executed first */
1182       if (checkcnt)
1183         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1184
1185       call_pending (EV_A);
1186     }
1187   while (activecnt && !loop_done);
1188
1189   if (loop_done != 2)
1190     loop_done = 0;
1191 }
1192
1193 void
1194 ev_unloop (EV_P_ int how)
1195 {
1196   loop_done = how;
1197 }
1198
1199 /*****************************************************************************/
1200
1201 inline void
1202 wlist_add (WL *head, WL elem)
1203 {
1204   elem->next = *head;
1205   *head = elem;
1206 }
1207
1208 inline void
1209 wlist_del (WL *head, WL elem)
1210 {
1211   while (*head)
1212     {
1213       if (*head == elem)
1214         {
1215           *head = elem->next;
1216           return;
1217         }
1218
1219       head = &(*head)->next;
1220     }
1221 }
1222
1223 inline void
1224 ev_clear_pending (EV_P_ W w)
1225 {
1226   if (w->pending)
1227     {
1228       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1229       w->pending = 0;
1230     }
1231 }
1232
1233 inline void
1234 ev_start (EV_P_ W w, int active)
1235 {
1236   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1237   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1238
1239   w->active = active;
1240   ev_ref (EV_A);
1241 }
1242
1243 inline void
1244 ev_stop (EV_P_ W w)
1245 {
1246   ev_unref (EV_A);
1247   w->active = 0;
1248 }
1249
1250 /*****************************************************************************/
1251
1252 void
1253 ev_io_start (EV_P_ struct ev_io *w)
1254 {
1255   int fd = w->fd;
1256
1257   if (ev_is_active (w))
1258     return;
1259
1260   assert (("ev_io_start called with negative fd", fd >= 0));
1261
1262   ev_start (EV_A_ (W)w, 1);
1263   array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
1264   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1265
1266   fd_change (EV_A_ fd);
1267 }
1268
1269 void
1270 ev_io_stop (EV_P_ struct ev_io *w)
1271 {
1272   ev_clear_pending (EV_A_ (W)w);
1273   if (!ev_is_active (w))
1274     return;
1275
1276   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1277   ev_stop (EV_A_ (W)w);
1278
1279   fd_change (EV_A_ w->fd);
1280 }
1281
1282 void
1283 ev_timer_start (EV_P_ struct ev_timer *w)
1284 {
1285   if (ev_is_active (w))
1286     return;
1287
1288   ((WT)w)->at += mn_now;
1289
1290   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1291
1292   ev_start (EV_A_ (W)w, ++timercnt);
1293   array_needsize (struct ev_timer *, timers, timermax, timercnt, (void));
1294   timers [timercnt - 1] = w;
1295   upheap ((WT *)timers, timercnt - 1);
1296
1297   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1298 }
1299
1300 void
1301 ev_timer_stop (EV_P_ struct ev_timer *w)
1302 {
1303   ev_clear_pending (EV_A_ (W)w);
1304   if (!ev_is_active (w))
1305     return;
1306
1307   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1308
1309   if (((W)w)->active < timercnt--)
1310     {
1311       timers [((W)w)->active - 1] = timers [timercnt];
1312       downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1313     }
1314
1315   ((WT)w)->at = w->repeat;
1316
1317   ev_stop (EV_A_ (W)w);
1318 }
1319
1320 void
1321 ev_timer_again (EV_P_ struct ev_timer *w)
1322 {
1323   if (ev_is_active (w))
1324     {
1325       if (w->repeat)
1326         {
1327           ((WT)w)->at = mn_now + w->repeat;
1328           downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1329         }
1330       else
1331         ev_timer_stop (EV_A_ w);
1332     }
1333   else if (w->repeat)
1334     ev_timer_start (EV_A_ w);
1335 }
1336
1337 void
1338 ev_periodic_start (EV_P_ struct ev_periodic *w)
1339 {
1340   if (ev_is_active (w))
1341     return;
1342
1343   if (w->reschedule_cb)
1344     ((WT)w)->at = w->reschedule_cb (w, rt_now);
1345   else if (w->interval)
1346     {
1347       assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1348       /* this formula differs from the one in periodic_reify because we do not always round up */
1349       ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1350     }
1351
1352   ev_start (EV_A_ (W)w, ++periodiccnt);
1353   array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, (void));
1354   periodics [periodiccnt - 1] = w;
1355   upheap ((WT *)periodics, periodiccnt - 1);
1356
1357   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1358 }
1359
1360 void
1361 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1362 {
1363   ev_clear_pending (EV_A_ (W)w);
1364   if (!ev_is_active (w))
1365     return;
1366
1367   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1368
1369   if (((W)w)->active < periodiccnt--)
1370     {
1371       periodics [((W)w)->active - 1] = periodics [periodiccnt];
1372       downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
1373     }
1374
1375   ev_stop (EV_A_ (W)w);
1376 }
1377
1378 void
1379 ev_periodic_again (EV_P_ struct ev_periodic *w)
1380 {
1381   ev_periodic_stop (EV_A_ w);
1382   ev_periodic_start (EV_A_ w);
1383 }
1384
1385 void
1386 ev_idle_start (EV_P_ struct ev_idle *w)
1387 {
1388   if (ev_is_active (w))
1389     return;
1390
1391   ev_start (EV_A_ (W)w, ++idlecnt);
1392   array_needsize (struct ev_idle *, idles, idlemax, idlecnt, (void));
1393   idles [idlecnt - 1] = w;
1394 }
1395
1396 void
1397 ev_idle_stop (EV_P_ struct ev_idle *w)
1398 {
1399   ev_clear_pending (EV_A_ (W)w);
1400   if (ev_is_active (w))
1401     return;
1402
1403   idles [((W)w)->active - 1] = idles [--idlecnt];
1404   ev_stop (EV_A_ (W)w);
1405 }
1406
1407 void
1408 ev_prepare_start (EV_P_ struct ev_prepare *w)
1409 {
1410   if (ev_is_active (w))
1411     return;
1412
1413   ev_start (EV_A_ (W)w, ++preparecnt);
1414   array_needsize (struct ev_prepare *, prepares, preparemax, preparecnt, (void));
1415   prepares [preparecnt - 1] = w;
1416 }
1417
1418 void
1419 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1420 {
1421   ev_clear_pending (EV_A_ (W)w);
1422   if (ev_is_active (w))
1423     return;
1424
1425   prepares [((W)w)->active - 1] = prepares [--preparecnt];
1426   ev_stop (EV_A_ (W)w);
1427 }
1428
1429 void
1430 ev_check_start (EV_P_ struct ev_check *w)
1431 {
1432   if (ev_is_active (w))
1433     return;
1434
1435   ev_start (EV_A_ (W)w, ++checkcnt);
1436   array_needsize (struct ev_check *, checks, checkmax, checkcnt, (void));
1437   checks [checkcnt - 1] = w;
1438 }
1439
1440 void
1441 ev_check_stop (EV_P_ struct ev_check *w)
1442 {
1443   ev_clear_pending (EV_A_ (W)w);
1444   if (ev_is_active (w))
1445     return;
1446
1447   checks [((W)w)->active - 1] = checks [--checkcnt];
1448   ev_stop (EV_A_ (W)w);
1449 }
1450
1451 #ifndef SA_RESTART
1452 # define SA_RESTART 0
1453 #endif
1454
1455 void
1456 ev_signal_start (EV_P_ struct ev_signal *w)
1457 {
1458 #if EV_MULTIPLICITY
1459   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1460 #endif
1461   if (ev_is_active (w))
1462     return;
1463
1464   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1465
1466   ev_start (EV_A_ (W)w, 1);
1467   array_needsize (ANSIG, signals, signalmax, w->signum, signals_init);
1468   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1469
1470   if (!((WL)w)->next)
1471     {
1472 #if WIN32
1473       signal (w->signum, sighandler);
1474 #else
1475       struct sigaction sa;
1476       sa.sa_handler = sighandler;
1477       sigfillset (&sa.sa_mask);
1478       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1479       sigaction (w->signum, &sa, 0);
1480 #endif
1481     }
1482 }
1483
1484 void
1485 ev_signal_stop (EV_P_ struct ev_signal *w)
1486 {
1487   ev_clear_pending (EV_A_ (W)w);
1488   if (!ev_is_active (w))
1489     return;
1490
1491   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1492   ev_stop (EV_A_ (W)w);
1493
1494   if (!signals [w->signum - 1].head)
1495     signal (w->signum, SIG_DFL);
1496 }
1497
1498 void
1499 ev_child_start (EV_P_ struct ev_child *w)
1500 {
1501 #if EV_MULTIPLICITY
1502   assert (("child watchers are only supported in the default loop", loop == default_loop));
1503 #endif
1504   if (ev_is_active (w))
1505     return;
1506
1507   ev_start (EV_A_ (W)w, 1);
1508   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1509 }
1510
1511 void
1512 ev_child_stop (EV_P_ struct ev_child *w)
1513 {
1514   ev_clear_pending (EV_A_ (W)w);
1515   if (ev_is_active (w))
1516     return;
1517
1518   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1519   ev_stop (EV_A_ (W)w);
1520 }
1521
1522 /*****************************************************************************/
1523
1524 struct ev_once
1525 {
1526   struct ev_io io;
1527   struct ev_timer to;
1528   void (*cb)(int revents, void *arg);
1529   void *arg;
1530 };
1531
1532 static void
1533 once_cb (EV_P_ struct ev_once *once, int revents)
1534 {
1535   void (*cb)(int revents, void *arg) = once->cb;
1536   void *arg = once->arg;
1537
1538   ev_io_stop (EV_A_ &once->io);
1539   ev_timer_stop (EV_A_ &once->to);
1540   ev_free (once);
1541
1542   cb (revents, arg);
1543 }
1544
1545 static void
1546 once_cb_io (EV_P_ struct ev_io *w, int revents)
1547 {
1548   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1549 }
1550
1551 static void
1552 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1553 {
1554   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1555 }
1556
1557 void
1558 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1559 {
1560   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
1561
1562   if (!once)
1563     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1564   else
1565     {
1566       once->cb  = cb;
1567       once->arg = arg;
1568
1569       ev_init (&once->io, once_cb_io);
1570       if (fd >= 0)
1571         {
1572           ev_io_set (&once->io, fd, events);
1573           ev_io_start (EV_A_ &once->io);
1574         }
1575
1576       ev_init (&once->to, once_cb_to);
1577       if (timeout >= 0.)
1578         {
1579           ev_timer_set (&once->to, timeout, 0.);
1580           ev_timer_start (EV_A_ &once->to);
1581         }
1582     }
1583 }
1584