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 inline void
 524 adjustheap (WT *heap, int N, int k, ev_tstamp at)
 525 {
 526   ev_tstamp old_at = heap [k]->at;
 527   heap [k]->at = at;
 528
 529   if (old_at < at)
 530     downheap (heap, N, k);
 531   else
 532     upheap (heap, k);
 533 }
 534
 535 /*****************************************************************************/
 536
 537 typedef struct
 538 {
 539   WL head;
 540   sig_atomic_t volatile gotsig;
 541 } ANSIG;
 542
 543 static ANSIG *signals;
 544 static int signalmax;
 545
 546 static int sigpipe [2];
 547 static sig_atomic_t volatile gotsig;
 548 static struct ev_io sigev;
 549
 550 static void
 551 signals_init (ANSIG *base, int count)
 552 {
 553   while (count--)
 554     {
 555       base->head   = 0;
 556       base->gotsig = 0;
 557
 558       ++base;
 559     }
 560 }
 561
 562 static void
 563 sighandler (int signum)
 564 {
 565 #if WIN32
 566   signal (signum, sighandler);
 567 #endif
 568
 569   signals [signum - 1].gotsig = 1;
 570
 571   if (!gotsig)
 572     {
 573       int old_errno = errno;
 574       gotsig = 1;
 575 #ifdef WIN32
 576       send (sigpipe [1], &signum, 1, MSG_DONTWAIT);
 577 #else
 578       write (sigpipe [1], &signum, 1);
 579 #endif
 580       errno = old_errno;
 581     }
 582 }
 583
 584 void
 585 ev_feed_signal_event (EV_P_ int signum)
 586 {
 587   WL w;
 588
 589 #if EV_MULTIPLICITY
 590   assert (("feeding signal events is only supported in the default loop", loop == default_loop));
 591 #endif
 592
 593   --signum;
 594
 595   if (signum < 0 || signum >= signalmax)
 596     return;
 597
 598   signals [signum].gotsig = 0;
 599
 600   for (w = signals [signum].head; w; w = w->next)
 601     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 602 }
 603
 604 static void
 605 sigcb (EV_P_ struct ev_io *iow, int revents)
 606 {
 607   int signum;
 608
 609 #ifdef WIN32
 610   recv (sigpipe [0], &revents, 1, MSG_DONTWAIT);
 611 #else
 612   read (sigpipe [0], &revents, 1);
 613 #endif
 614   gotsig = 0;
 615
 616   for (signum = signalmax; signum--; )
 617     if (signals [signum].gotsig)
 618       ev_feed_signal_event (EV_A_ signum + 1);
 619 }
 620
 621 static void
 622 siginit (EV_P)
 623 {
 624 #ifndef WIN32
 625   fcntl (sigpipe [0], F_SETFD, FD_CLOEXEC);
 626   fcntl (sigpipe [1], F_SETFD, FD_CLOEXEC);
 627
 628   /* rather than sort out wether we really need nb, set it */
 629   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
 630   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
 631 #endif
 632
 633   ev_io_set (&sigev, sigpipe [0], EV_READ);
 634   ev_io_start (EV_A_ &sigev);
 635   ev_unref (EV_A); /* child watcher should not keep loop alive */
 636 }
 637
 638 /*****************************************************************************/
 639
 640 static struct ev_child *childs [PID_HASHSIZE];
 641
 642 #ifndef WIN32
 643
 644 static struct ev_signal childev;
 645
 646 #ifndef WCONTINUED
 647 # define WCONTINUED 0
 648 #endif
 649
 650 static void
 651 child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
 652 {
 653   struct ev_child *w;
 654
 655   for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
 656     if (w->pid == pid || !w->pid)
 657       {
 658         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
 659         w->rpid         = pid;
 660         w->rstatus      = status;
 661         ev_feed_event (EV_A_ (W)w, EV_CHILD);
 662       }
 663 }
 664
 665 static void
 666 childcb (EV_P_ struct ev_signal *sw, int revents)
 667 {
 668   int pid, status;
 669
 670   if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
 671     {
 672       /* make sure we are called again until all childs have been reaped */
 673       ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
 674
 675       child_reap (EV_A_ sw, pid, pid, status);
 676       child_reap (EV_A_ sw,   0, pid, status); /* this might trigger a watcher twice, but event catches that */
 677     }
 678 }
 679
 680 #endif
 681
 682 /*****************************************************************************/
 683
 684 #if EV_USE_KQUEUE
 685 # include "ev_kqueue.c"
 686 #endif
 687 #if EV_USE_EPOLL
 688 # include "ev_epoll.c"
 689 #endif
 690 #if EV_USE_POLL
 691 # include "ev_poll.c"
 692 #endif
 693 #if EV_USE_SELECT
 694 # include "ev_select.c"
 695 #endif
 696
 697 int
 698 ev_version_major (void)
 699 {
 700   return EV_VERSION_MAJOR;
 701 }
 702
 703 int
 704 ev_version_minor (void)
 705 {
 706   return EV_VERSION_MINOR;
 707 }
 708
 709 /* return true if we are running with elevated privileges and should ignore env variables */
 710 static int
 711 enable_secure (void)
 712 {
 713 #ifdef WIN32
 714   return 0;
 715 #else
 716   return getuid () != geteuid ()
 717       || getgid () != getegid ();
 718 #endif
 719 }
 720
 721 int
 722 ev_method (EV_P)
 723 {
 724   return method;
 725 }
 726
 727 static void
 728 loop_init (EV_P_ int methods)
 729 {
 730   if (!method)
 731     {
 732 #if EV_USE_MONOTONIC
 733       {
 734         struct timespec ts;
 735         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
 736           have_monotonic = 1;
 737       }
 738 #endif
 739
 740       rt_now    = ev_time ();
 741       mn_now    = get_clock ();
 742       now_floor = mn_now;
 743       rtmn_diff = rt_now - mn_now;
 744
 745       if (methods == EVMETHOD_AUTO)
 746         if (!enable_secure () && getenv ("LIBEV_METHODS"))
 747           methods = atoi (getenv ("LIBEV_METHODS"));
 748         else
 749           methods = EVMETHOD_ANY;
 750
 751       method = 0;
 752 #if EV_USE_WIN32
 753       if (!method && (methods & EVMETHOD_WIN32 )) method = win32_init  (EV_A_ methods);
 754 #endif
 755 #if EV_USE_KQUEUE
 756       if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
 757 #endif
 758 #if EV_USE_EPOLL
 759       if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init  (EV_A_ methods);
 760 #endif
 761 #if EV_USE_POLL
 762       if (!method && (methods & EVMETHOD_POLL  )) method = poll_init   (EV_A_ methods);
 763 #endif
 764 #if EV_USE_SELECT
 765       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 766 #endif
 767
 768       ev_init (&sigev, sigcb);
 769       ev_set_priority (&sigev, EV_MAXPRI);
 770     }
 771 }
 772
 773 void
 774 loop_destroy (EV_P)
 775 {
 776   int i;
 777
 778 #if EV_USE_WIN32
 779   if (method == EVMETHOD_WIN32 ) win32_destroy  (EV_A);
 780 #endif
 781 #if EV_USE_KQUEUE
 782   if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
 783 #endif
 784 #if EV_USE_EPOLL
 785   if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
 786 #endif
 787 #if EV_USE_POLL
 788   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 789 #endif
 790 #if EV_USE_SELECT
 791   if (method == EVMETHOD_SELECT) select_destroy (EV_A);
 792 #endif
 793
 794   for (i = NUMPRI; i--; )
 795     array_free (pending, [i]);
 796
 797   /* have to use the microsoft-never-gets-it-right macro */
 798   array_free_microshit (fdchange);
 799   array_free_microshit (timer);
 800   array_free_microshit (periodic);
 801   array_free_microshit (idle);
 802   array_free_microshit (prepare);
 803   array_free_microshit (check);
 804
 805   method = 0;
 806 }
 807
 808 static void
 809 loop_fork (EV_P)
 810 {
 811 #if EV_USE_EPOLL
 812   if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
 813 #endif
 814 #if EV_USE_KQUEUE
 815   if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
 816 #endif
 817
 818   if (ev_is_active (&sigev))
 819     {
 820       /* default loop */
 821
 822       ev_ref (EV_A);
 823       ev_io_stop (EV_A_ &sigev);
 824       close (sigpipe [0]);
 825       close (sigpipe [1]);
 826
 827       while (pipe (sigpipe))
 828         syserr ("(libev) error creating pipe");
 829
 830       siginit (EV_A);
 831     }
 832
 833   postfork = 0;
 834 }
 835
 836 #if EV_MULTIPLICITY
 837 struct ev_loop *
 838 ev_loop_new (int methods)
 839 {
 840   struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
 841
 842   memset (loop, 0, sizeof (struct ev_loop));
 843
 844   loop_init (EV_A_ methods);
 845
 846   if (ev_method (EV_A))
 847     return loop;
 848
 849   return 0;
 850 }
 851
 852 void
 853 ev_loop_destroy (EV_P)
 854 {
 855   loop_destroy (EV_A);
 856   ev_free (loop);
 857 }
 858
 859 void
 860 ev_loop_fork (EV_P)
 861 {
 862   postfork = 1;
 863 }
 864
 865 #endif
 866
 867 #if EV_MULTIPLICITY
 868 struct ev_loop *
 869 #else
 870 int
 871 #endif
 872 ev_default_loop (int methods)
 873 {
 874   if (sigpipe [0] == sigpipe [1])
 875     if (pipe (sigpipe))
 876       return 0;
 877
 878   if (!default_loop)
 879     {
 880 #if EV_MULTIPLICITY
 881       struct ev_loop *loop = default_loop = &default_loop_struct;
 882 #else
 883       default_loop = 1;
 884 #endif
 885
 886       loop_init (EV_A_ methods);
 887
 888       if (ev_method (EV_A))
 889         {
 890           siginit (EV_A);
 891
 892 #ifndef WIN32
 893           ev_signal_init (&childev, childcb, SIGCHLD);
 894           ev_set_priority (&childev, EV_MAXPRI);
 895           ev_signal_start (EV_A_ &childev);
 896           ev_unref (EV_A); /* child watcher should not keep loop alive */
 897 #endif
 898         }
 899       else
 900         default_loop = 0;
 901     }
 902
 903   return default_loop;
 904 }
 905
 906 void
 907 ev_default_destroy (void)
 908 {
 909 #if EV_MULTIPLICITY
 910   struct ev_loop *loop = default_loop;
 911 #endif
 912
 913 #ifndef WIN32
 914   ev_ref (EV_A); /* child watcher */
 915   ev_signal_stop (EV_A_ &childev);
 916 #endif
 917
 918   ev_ref (EV_A); /* signal watcher */
 919   ev_io_stop (EV_A_ &sigev);
 920
 921   close (sigpipe [0]); sigpipe [0] = 0;
 922   close (sigpipe [1]); sigpipe [1] = 0;
 923
 924   loop_destroy (EV_A);
 925 }
 926
 927 void
 928 ev_default_fork (void)
 929 {
 930 #if EV_MULTIPLICITY
 931   struct ev_loop *loop = default_loop;
 932 #endif
 933
 934   if (method)
 935     postfork = 1;
 936 }
 937
 938 /*****************************************************************************/
 939
 940 static int
 941 any_pending (EV_P)
 942 {
 943   int pri;
 944
 945   for (pri = NUMPRI; pri--; )
 946     if (pendingcnt [pri])
 947       return 1;
 948
 949   return 0;
 950 }
 951
 952 static void
 953 call_pending (EV_P)
 954 {
 955   int pri;
 956
 957   for (pri = NUMPRI; pri--; )
 958     while (pendingcnt [pri])
 959       {
 960         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
 961
 962         if (p->w)
 963           {
 964             p->w->pending = 0;
 965             EV_CB_INVOKE (p->w, p->events);
 966           }
 967       }
 968 }
 969
 970 static void
 971 timers_reify (EV_P)
 972 {
 973   while (timercnt && ((WT)timers [0])->at <= mn_now)
 974     {
 975       struct ev_timer *w = timers [0];
 976
 977       assert (("inactive timer on timer heap detected", ev_is_active (w)));
 978
 979       /* first reschedule or stop timer */
 980       if (w->repeat)
 981         {
 982           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 983           ((WT)w)->at = mn_now + w->repeat;
 984           downheap ((WT *)timers, timercnt, 0);
 985         }
 986       else
 987         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 988
 989       ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
 990     }
 991 }
 992
 993 static void
 994 periodics_reify (EV_P)
 995 {
 996   while (periodiccnt && ((WT)periodics [0])->at <= rt_now)
 997     {
 998       struct ev_periodic *w = periodics [0];
 999
1000       assert (("inactive timer on periodic heap detected", ev_is_active (w)));
1001
1002       /* first reschedule or stop timer */
1003       if (w->reschedule_cb)
1004         {
1005           ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, rt_now + 0.0001);
1006
1007           assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > rt_now));
1008           downheap ((WT *)periodics, periodiccnt, 0);
1009         }
1010       else if (w->interval)
1011         {
1012           ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
1013           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
1014           downheap ((WT *)periodics, periodiccnt, 0);
1015         }
1016       else
1017         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1018
1019       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
1020     }
1021 }
1022
1023 static void
1024 periodics_reschedule (EV_P)
1025 {
1026   int i;
1027
1028   /* adjust periodics after time jump */
1029   for (i = 0; i < periodiccnt; ++i)
1030     {
1031       struct ev_periodic *w = periodics [i];
1032
1033       if (w->reschedule_cb)
1034         ((WT)w)->at = w->reschedule_cb (w, rt_now);
1035       else if (w->interval)
1036         ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1037     }
1038
1039   /* now rebuild the heap */
1040   for (i = periodiccnt >> 1; i--; )
1041     downheap ((WT *)periodics, periodiccnt, i);
1042 }
1043
1044 inline int
1045 time_update_monotonic (EV_P)
1046 {
1047   mn_now = get_clock ();
1048
1049   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
1050     {
1051       rt_now = rtmn_diff + mn_now;
1052       return 0;
1053     }
1054   else
1055     {
1056       now_floor = mn_now;
1057       rt_now = ev_time ();
1058       return 1;
1059     }
1060 }
1061
1062 static void
1063 time_update (EV_P)
1064 {
1065   int i;
1066
1067 #if EV_USE_MONOTONIC
1068   if (expect_true (have_monotonic))
1069     {
1070       if (time_update_monotonic (EV_A))
1071         {
1072           ev_tstamp odiff = rtmn_diff;
1073
1074           for (i = 4; --i; ) /* loop a few times, before making important decisions */
1075             {
1076               rtmn_diff = rt_now - mn_now;
1077
1078               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
1079                 return; /* all is well */
1080
1081               rt_now    = ev_time ();
1082               mn_now    = get_clock ();
1083               now_floor = mn_now;
1084             }
1085
1086           periodics_reschedule (EV_A);
1087           /* no timer adjustment, as the monotonic clock doesn't jump */
1088           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1089         }
1090     }
1091   else
1092 #endif
1093     {
1094       rt_now = ev_time ();
1095
1096       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
1097         {
1098           periodics_reschedule (EV_A);
1099
1100           /* adjust timers. this is easy, as the offset is the same for all */
1101           for (i = 0; i < timercnt; ++i)
1102             ((WT)timers [i])->at += rt_now - mn_now;
1103         }
1104
1105       mn_now = rt_now;
1106     }
1107 }
1108
1109 void
1110 ev_ref (EV_P)
1111 {
1112   ++activecnt;
1113 }
1114
1115 void
1116 ev_unref (EV_P)
1117 {
1118   --activecnt;
1119 }
1120
1121 static int loop_done;
1122
1123 void
1124 ev_loop (EV_P_ int flags)
1125 {
1126   double block;
1127   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
1128
1129   do
1130     {
1131       /* queue check watchers (and execute them) */
1132       if (expect_false (preparecnt))
1133         {
1134           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1135           call_pending (EV_A);
1136         }
1137
1138       /* we might have forked, so reify kernel state if necessary */
1139       if (expect_false (postfork))
1140         loop_fork (EV_A);
1141
1142       /* update fd-related kernel structures */
1143       fd_reify (EV_A);
1144
1145       /* calculate blocking time */
1146
1147       /* we only need this for !monotonic clock or timers, but as we basically
1148          always have timers, we just calculate it always */
1149 #if EV_USE_MONOTONIC
1150       if (expect_true (have_monotonic))
1151         time_update_monotonic (EV_A);
1152       else
1153 #endif
1154         {
1155           rt_now = ev_time ();
1156           mn_now = rt_now;
1157         }
1158
1159       if (flags & EVLOOP_NONBLOCK || idlecnt)
1160         block = 0.;
1161       else
1162         {
1163           block = MAX_BLOCKTIME;
1164
1165           if (timercnt)
1166             {
1167               ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
1168               if (block > to) block = to;
1169             }
1170
1171           if (periodiccnt)
1172             {
1173               ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge;
1174               if (block > to) block = to;
1175             }
1176
1177           if (block < 0.) block = 0.;
1178         }
1179
1180       method_poll (EV_A_ block);
1181
1182       /* update rt_now, do magic */
1183       time_update (EV_A);
1184
1185       /* queue pending timers and reschedule them */
1186       timers_reify (EV_A); /* relative timers called last */
1187       periodics_reify (EV_A); /* absolute timers called first */
1188
1189       /* queue idle watchers unless io or timers are pending */
1190       if (idlecnt && !any_pending (EV_A))
1191         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1192
1193       /* queue check watchers, to be executed first */
1194       if (checkcnt)
1195         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1196
1197       call_pending (EV_A);
1198     }
1199   while (activecnt && !loop_done);
1200
1201   if (loop_done != 2)
1202     loop_done = 0;
1203 }
1204
1205 void
1206 ev_unloop (EV_P_ int how)
1207 {
1208   loop_done = how;
1209 }
1210
1211 /*****************************************************************************/
1212
1213 inline void
1214 wlist_add (WL *head, WL elem)
1215 {
1216   elem->next = *head;
1217   *head = elem;
1218 }
1219
1220 inline void
1221 wlist_del (WL *head, WL elem)
1222 {
1223   while (*head)
1224     {
1225       if (*head == elem)
1226         {
1227           *head = elem->next;
1228           return;
1229         }
1230
1231       head = &(*head)->next;
1232     }
1233 }
1234
1235 inline void
1236 ev_clear_pending (EV_P_ W w)
1237 {
1238   if (w->pending)
1239     {
1240       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1241       w->pending = 0;
1242     }
1243 }
1244
1245 inline void
1246 ev_start (EV_P_ W w, int active)
1247 {
1248   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1249   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1250
1251   w->active = active;
1252   ev_ref (EV_A);
1253 }
1254
1255 inline void
1256 ev_stop (EV_P_ W w)
1257 {
1258   ev_unref (EV_A);
1259   w->active = 0;
1260 }
1261
1262 /*****************************************************************************/
1263
1264 void
1265 ev_io_start (EV_P_ struct ev_io *w)
1266 {
1267   int fd = w->fd;
1268
1269   if (ev_is_active (w))
1270     return;
1271
1272   assert (("ev_io_start called with negative fd", fd >= 0));
1273
1274   ev_start (EV_A_ (W)w, 1);
1275   array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
1276   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1277
1278   fd_change (EV_A_ fd);
1279 }
1280
1281 void
1282 ev_io_stop (EV_P_ struct ev_io *w)
1283 {
1284   ev_clear_pending (EV_A_ (W)w);
1285   if (!ev_is_active (w))
1286     return;
1287
1288   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1289   ev_stop (EV_A_ (W)w);
1290
1291   fd_change (EV_A_ w->fd);
1292 }
1293
1294 void
1295 ev_timer_start (EV_P_ struct ev_timer *w)
1296 {
1297   if (ev_is_active (w))
1298     return;
1299
1300   ((WT)w)->at += mn_now;
1301
1302   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1303
1304   ev_start (EV_A_ (W)w, ++timercnt);
1305   array_needsize (struct ev_timer *, timers, timermax, timercnt, (void));
1306   timers [timercnt - 1] = w;
1307   upheap ((WT *)timers, timercnt - 1);
1308
1309   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1310 }
1311
1312 void
1313 ev_timer_stop (EV_P_ struct ev_timer *w)
1314 {
1315   ev_clear_pending (EV_A_ (W)w);
1316   if (!ev_is_active (w))
1317     return;
1318
1319   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1320
1321   if (((W)w)->active < timercnt--)
1322     {
1323       timers [((W)w)->active - 1] = timers [timercnt];
1324       downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1325     }
1326
1327   ((WT)w)->at = w->repeat;
1328
1329   ev_stop (EV_A_ (W)w);
1330 }
1331
1332 void
1333 ev_timer_again (EV_P_ struct ev_timer *w)
1334 {
1335   if (ev_is_active (w))
1336     {
1337       if (w->repeat)
1338         adjustheap ((WT *)timers, timercnt, ((W)w)->active - 1, mn_now + w->repeat);
1339       else
1340         ev_timer_stop (EV_A_ w);
1341     }
1342   else if (w->repeat)
1343     ev_timer_start (EV_A_ w);
1344 }
1345
1346 void
1347 ev_periodic_start (EV_P_ struct ev_periodic *w)
1348 {
1349   if (ev_is_active (w))
1350     return;
1351
1352   if (w->reschedule_cb)
1353     ((WT)w)->at = w->reschedule_cb (w, rt_now);
1354   else if (w->interval)
1355     {
1356       assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1357       /* this formula differs from the one in periodic_reify because we do not always round up */
1358       ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1359     }
1360
1361   ev_start (EV_A_ (W)w, ++periodiccnt);
1362   array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, (void));
1363   periodics [periodiccnt - 1] = w;
1364   upheap ((WT *)periodics, periodiccnt - 1);
1365
1366   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1367 }
1368
1369 void
1370 ev_periodic_stop (EV_P_ struct ev_periodic *w)
1371 {
1372   ev_clear_pending (EV_A_ (W)w);
1373   if (!ev_is_active (w))
1374     return;
1375
1376   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1377
1378   if (((W)w)->active < periodiccnt--)
1379     {
1380       periodics [((W)w)->active - 1] = periodics [periodiccnt];
1381       downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
1382     }
1383
1384   ev_stop (EV_A_ (W)w);
1385 }
1386
1387 void
1388 ev_periodic_again (EV_P_ struct ev_periodic *w)
1389 {
1390   /* TODO: use adjustheap and recalculation */
1391   ev_periodic_stop (EV_A_ w);
1392   ev_periodic_start (EV_A_ w);
1393 }
1394
1395 void
1396 ev_idle_start (EV_P_ struct ev_idle *w)
1397 {
1398   if (ev_is_active (w))
1399     return;
1400
1401   ev_start (EV_A_ (W)w, ++idlecnt);
1402   array_needsize (struct ev_idle *, idles, idlemax, idlecnt, (void));
1403   idles [idlecnt - 1] = w;
1404 }
1405
1406 void
1407 ev_idle_stop (EV_P_ struct ev_idle *w)
1408 {
1409   ev_clear_pending (EV_A_ (W)w);
1410   if (ev_is_active (w))
1411     return;
1412
1413   idles [((W)w)->active - 1] = idles [--idlecnt];
1414   ev_stop (EV_A_ (W)w);
1415 }
1416
1417 void
1418 ev_prepare_start (EV_P_ struct ev_prepare *w)
1419 {
1420   if (ev_is_active (w))
1421     return;
1422
1423   ev_start (EV_A_ (W)w, ++preparecnt);
1424   array_needsize (struct ev_prepare *, prepares, preparemax, preparecnt, (void));
1425   prepares [preparecnt - 1] = w;
1426 }
1427
1428 void
1429 ev_prepare_stop (EV_P_ struct ev_prepare *w)
1430 {
1431   ev_clear_pending (EV_A_ (W)w);
1432   if (ev_is_active (w))
1433     return;
1434
1435   prepares [((W)w)->active - 1] = prepares [--preparecnt];
1436   ev_stop (EV_A_ (W)w);
1437 }
1438
1439 void
1440 ev_check_start (EV_P_ struct ev_check *w)
1441 {
1442   if (ev_is_active (w))
1443     return;
1444
1445   ev_start (EV_A_ (W)w, ++checkcnt);
1446   array_needsize (struct ev_check *, checks, checkmax, checkcnt, (void));
1447   checks [checkcnt - 1] = w;
1448 }
1449
1450 void
1451 ev_check_stop (EV_P_ struct ev_check *w)
1452 {
1453   ev_clear_pending (EV_A_ (W)w);
1454   if (ev_is_active (w))
1455     return;
1456
1457   checks [((W)w)->active - 1] = checks [--checkcnt];
1458   ev_stop (EV_A_ (W)w);
1459 }
1460
1461 #ifndef SA_RESTART
1462 # define SA_RESTART 0
1463 #endif
1464
1465 void
1466 ev_signal_start (EV_P_ struct ev_signal *w)
1467 {
1468 #if EV_MULTIPLICITY
1469   assert (("signal watchers are only supported in the default loop", loop == default_loop));
1470 #endif
1471   if (ev_is_active (w))
1472     return;
1473
1474   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1475
1476   ev_start (EV_A_ (W)w, 1);
1477   array_needsize (ANSIG, signals, signalmax, w->signum, signals_init);
1478   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1479
1480   if (!((WL)w)->next)
1481     {
1482 #if WIN32
1483       signal (w->signum, sighandler);
1484 #else
1485       struct sigaction sa;
1486       sa.sa_handler = sighandler;
1487       sigfillset (&sa.sa_mask);
1488       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1489       sigaction (w->signum, &sa, 0);
1490 #endif
1491     }
1492 }
1493
1494 void
1495 ev_signal_stop (EV_P_ struct ev_signal *w)
1496 {
1497   ev_clear_pending (EV_A_ (W)w);
1498   if (!ev_is_active (w))
1499     return;
1500
1501   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1502   ev_stop (EV_A_ (W)w);
1503
1504   if (!signals [w->signum - 1].head)
1505     signal (w->signum, SIG_DFL);
1506 }
1507
1508 void
1509 ev_child_start (EV_P_ struct ev_child *w)
1510 {
1511 #if EV_MULTIPLICITY
1512   assert (("child watchers are only supported in the default loop", loop == default_loop));
1513 #endif
1514   if (ev_is_active (w))
1515     return;
1516
1517   ev_start (EV_A_ (W)w, 1);
1518   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1519 }
1520
1521 void
1522 ev_child_stop (EV_P_ struct ev_child *w)
1523 {
1524   ev_clear_pending (EV_A_ (W)w);
1525   if (ev_is_active (w))
1526     return;
1527
1528   wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
1529   ev_stop (EV_A_ (W)w);
1530 }
1531
1532 /*****************************************************************************/
1533
1534 struct ev_once
1535 {
1536   struct ev_io io;
1537   struct ev_timer to;
1538   void (*cb)(int revents, void *arg);
1539   void *arg;
1540 };
1541
1542 static void
1543 once_cb (EV_P_ struct ev_once *once, int revents)
1544 {
1545   void (*cb)(int revents, void *arg) = once->cb;
1546   void *arg = once->arg;
1547
1548   ev_io_stop (EV_A_ &once->io);
1549   ev_timer_stop (EV_A_ &once->to);
1550   ev_free (once);
1551
1552   cb (revents, arg);
1553 }
1554
1555 static void
1556 once_cb_io (EV_P_ struct ev_io *w, int revents)
1557 {
1558   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1559 }
1560
1561 static void
1562 once_cb_to (EV_P_ struct ev_timer *w, int revents)
1563 {
1564   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1565 }
1566
1567 void
1568 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1569 {
1570   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
1571
1572   if (!once)
1573     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1574   else
1575     {
1576       once->cb  = cb;
1577       once->arg = arg;
1578
1579       ev_init (&once->io, once_cb_io);
1580       if (fd >= 0)
1581         {
1582           ev_io_set (&once->io, fd, events);
1583           ev_io_start (EV_A_ &once->io);
1584         }
1585
1586       ev_init (&once->to, once_cb_to);
1587       if (timeout >= 0.)
1588         {
1589           ev_timer_set (&once->to, timeout, 0.);
1590           ev_timer_start (EV_A_ &once->to);
1591         }
1592     }
1593 }
1594