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