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