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
  32 #ifdef __cplusplus
  33 extern "C" {
  34 #endif
  35
  36 #ifndef EV_STANDALONE
  37 # ifdef EV_CONFIG_H
  38 #  include EV_CONFIG_H
  39 # else
  40 #  include "config.h"
  41 # endif
  42
  43 # if HAVE_CLOCK_GETTIME
  44 #  ifndef EV_USE_MONOTONIC
  45 #   define EV_USE_MONOTONIC 1
  46 #  endif
  47 #  ifndef EV_USE_REALTIME
  48 #   define EV_USE_REALTIME  1
  49 #  endif
  50 # else
  51 #  ifndef EV_USE_MONOTONIC
  52 #   define EV_USE_MONOTONIC 0
  53 #  endif
  54 #  ifndef EV_USE_REALTIME
  55 #   define EV_USE_REALTIME  0
  56 #  endif
  57 # endif
  58
  59 # ifndef EV_USE_SELECT
  60 #  if HAVE_SELECT && HAVE_SYS_SELECT_H
  61 #   define EV_USE_SELECT 1
  62 #  else
  63 #   define EV_USE_SELECT 0
  64 #  endif
  65 # endif
  66
  67 # ifndef EV_USE_POLL
  68 #  if HAVE_POLL && HAVE_POLL_H
  69 #   define EV_USE_POLL 1
  70 #  else
  71 #   define EV_USE_POLL 0
  72 #  endif
  73 # endif
  74
  75 # ifndef EV_USE_EPOLL
  76 #  if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
  77 #   define EV_USE_EPOLL 1
  78 #  else
  79 #   define EV_USE_EPOLL 0
  80 #  endif
  81 # endif
  82
  83 # ifndef EV_USE_KQUEUE
  84 #  if HAVE_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
  85 #   define EV_USE_KQUEUE 1
  86 #  else
  87 #   define EV_USE_KQUEUE 0
  88 #  endif
  89 # endif
  90
  91 # ifndef EV_USE_PORT
  92 #  if HAVE_PORT_H && HAVE_PORT_CREATE
  93 #   define EV_USE_PORT 1
  94 #  else
  95 #   define EV_USE_PORT 0
  96 #  endif
  97 # endif
  98
  99 #endif
 100
 101 #include <math.h>
 102 #include <stdlib.h>
 103 #include <fcntl.h>
 104 #include <stddef.h>
 105
 106 #include <stdio.h>
 107
 108 #include <assert.h>
 109 #include <errno.h>
 110 #include <sys/types.h>
 111 #include <time.h>
 112
 113 #include <signal.h>
 114
 115 #ifndef _WIN32
 116 # include <sys/time.h>
 117 # include <sys/wait.h>
 118 # include <unistd.h>
 119 #else
 120 # define WIN32_LEAN_AND_MEAN
 121 # include <windows.h>
 122 # ifndef EV_SELECT_IS_WINSOCKET
 123 #  define EV_SELECT_IS_WINSOCKET 1
 124 # endif
 125 #endif
 126
 127 /**/
 128
 129 #ifndef EV_USE_MONOTONIC
 130 # define EV_USE_MONOTONIC 0
 131 #endif
 132
 133 #ifndef EV_USE_REALTIME
 134 # define EV_USE_REALTIME 0
 135 #endif
 136
 137 #ifndef EV_USE_SELECT
 138 # define EV_USE_SELECT 1
 139 #endif
 140
 141 #ifndef EV_USE_POLL
 142 # ifdef _WIN32
 143 #  define EV_USE_POLL 0
 144 # else
 145 #  define EV_USE_POLL 1
 146 # endif
 147 #endif
 148
 149 #ifndef EV_USE_EPOLL
 150 # define EV_USE_EPOLL 0
 151 #endif
 152
 153 #ifndef EV_USE_KQUEUE
 154 # define EV_USE_KQUEUE 0
 155 #endif
 156
 157 #ifndef EV_USE_PORT
 158 # define EV_USE_PORT 0
 159 #endif
 160
 161 #ifndef EV_PID_HASHSIZE
 162 # if EV_MINIMAL
 163 #  define EV_PID_HASHSIZE 1
 164 # else
 165 #  define EV_PID_HASHSIZE 16
 166 # endif
 167 #endif
 168
 169 /**/
 170
 171 #ifndef CLOCK_MONOTONIC
 172 # undef EV_USE_MONOTONIC
 173 # define EV_USE_MONOTONIC 0
 174 #endif
 175
 176 #ifndef CLOCK_REALTIME
 177 # undef EV_USE_REALTIME
 178 # define EV_USE_REALTIME 0
 179 #endif
 180
 181 #if EV_SELECT_IS_WINSOCKET
 182 # include <winsock.h>
 183 #endif
 184
 185 /**/
 186
 187 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 188 #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
 189 /*#define CLEANUP_INTERVAL (MAX_BLOCKTIME * 5.) /* how often to try to free memory and re-check fds */
 190
 191 #ifdef EV_H
 192 # include EV_H
 193 #else
 194 # include "ev.h"
 195 #endif
 196
 197 #if __GNUC__ >= 3
 198 # define expect(expr,value)         __builtin_expect ((expr),(value))
 199 # define inline_size                static inline /* inline for codesize */
 200 # if EV_MINIMAL
 201 #  define noinline                  __attribute__ ((noinline))
 202 #  define inline_speed              static noinline
 203 # else
 204 #  define noinline
 205 #  define inline_speed              static inline
 206 # endif
 207 #else
 208 # define expect(expr,value)         (expr)
 209 # define inline_speed               static
 210 # define inline_size                static
 211 # define noinline
 212 #endif
 213
 214 #define expect_false(expr) expect ((expr) != 0, 0)
 215 #define expect_true(expr)  expect ((expr) != 0, 1)
 216
 217 #define NUMPRI    (EV_MAXPRI - EV_MINPRI + 1)
 218 #define ABSPRI(w) ((w)->priority - EV_MINPRI)
 219
 220 #define EMPTY0      /* required for microsofts broken pseudo-c compiler */
 221 #define EMPTY2(a,b) /* used to suppress some warnings */
 222
 223 typedef ev_watcher *W;
 224 typedef ev_watcher_list *WL;
 225 typedef ev_watcher_time *WT;
 226
 227 static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 228
 229 #ifdef _WIN32
 230 # include "ev_win32.c"
 231 #endif
 232
 233 /*****************************************************************************/
 234
 235 static void (*syserr_cb)(const char *msg);
 236
 237 void
 238 ev_set_syserr_cb (void (*cb)(const char *msg))
 239 {
 240   syserr_cb = cb;
 241 }
 242
 243 static void noinline
 244 syserr (const char *msg)
 245 {
 246   if (!msg)
 247     msg = "(libev) system error";
 248
 249   if (syserr_cb)
 250     syserr_cb (msg);
 251   else
 252     {
 253       perror (msg);
 254       abort ();
 255     }
 256 }
 257
 258 static void *(*alloc)(void *ptr, size_t size) = realloc;
 259
 260 void
 261 ev_set_allocator (void *(*cb)(void *ptr, size_t size))
 262 {
 263   alloc = cb;
 264 }
 265
 266 inline_speed void *
 267 ev_realloc (void *ptr, size_t size)
 268 {
 269   ptr = alloc (ptr, size);
 270
 271   if (!ptr && size)
 272     {
 273       fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", (long)size);
 274       abort ();
 275     }
 276
 277   return ptr;
 278 }
 279
 280 #define ev_malloc(size) ev_realloc (0, (size))
 281 #define ev_free(ptr)    ev_realloc ((ptr), 0)
 282
 283 /*****************************************************************************/
 284
 285 typedef struct
 286 {
 287   WL head;
 288   unsigned char events;
 289   unsigned char reify;
 290 #if EV_SELECT_IS_WINSOCKET
 291   SOCKET handle;
 292 #endif
 293 } ANFD;
 294
 295 typedef struct
 296 {
 297   W w;
 298   int events;
 299 } ANPENDING;
 300
 301 #if EV_MULTIPLICITY
 302
 303   struct ev_loop
 304   {
 305     ev_tstamp ev_rt_now;
 306     #define ev_rt_now ((loop)->ev_rt_now)
 307     #define VAR(name,decl) decl;
 308       #include "ev_vars.h"
 309     #undef VAR
 310   };
 311   #include "ev_wrap.h"
 312
 313   static struct ev_loop default_loop_struct;
 314   struct ev_loop *ev_default_loop_ptr;
 315
 316 #else
 317
 318   ev_tstamp ev_rt_now;
 319   #define VAR(name,decl) static decl;
 320     #include "ev_vars.h"
 321   #undef VAR
 322
 323   static int ev_default_loop_ptr;
 324
 325 #endif
 326
 327 /*****************************************************************************/
 328
 329 ev_tstamp
 330 ev_time (void)
 331 {
 332 #if EV_USE_REALTIME
 333   struct timespec ts;
 334   clock_gettime (CLOCK_REALTIME, &ts);
 335   return ts.tv_sec + ts.tv_nsec * 1e-9;
 336 #else
 337   struct timeval tv;
 338   gettimeofday (&tv, 0);
 339   return tv.tv_sec + tv.tv_usec * 1e-6;
 340 #endif
 341 }
 342
 343 ev_tstamp inline_size
 344 get_clock (void)
 345 {
 346 #if EV_USE_MONOTONIC
 347   if (expect_true (have_monotonic))
 348     {
 349       struct timespec ts;
 350       clock_gettime (CLOCK_MONOTONIC, &ts);
 351       return ts.tv_sec + ts.tv_nsec * 1e-9;
 352     }
 353 #endif
 354
 355   return ev_time ();
 356 }
 357
 358 #if EV_MULTIPLICITY
 359 ev_tstamp
 360 ev_now (EV_P)
 361 {
 362   return ev_rt_now;
 363 }
 364 #endif
 365
 366 #define array_roundsize(type,n) (((n) | 4) & ~3)
 367
 368 #define array_needsize(type,base,cur,cnt,init)                  \
 369   if (expect_false ((cnt) > cur))                               \
 370     {                                                           \
 371       int newcnt = cur;                                         \
 372       do                                                        \
 373         {                                                       \
 374           newcnt = array_roundsize (type, newcnt << 1);         \
 375         }                                                       \
 376       while ((cnt) > newcnt);                                   \
 377                                                                 \
 378       base = (type *)ev_realloc (base, sizeof (type) * (newcnt));\
 379       init (base + cur, newcnt - cur);                          \
 380       cur = newcnt;                                             \
 381     }
 382
 383 #define array_slim(type,stem)                                   \
 384   if (stem ## max < array_roundsize (stem ## cnt >> 2))         \
 385     {                                                           \
 386       stem ## max = array_roundsize (stem ## cnt >> 1);         \
 387       base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
 388       fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
 389     }
 390
 391 #define array_free(stem, idx) \
 392   ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 393
 394 /*****************************************************************************/
 395
 396 void noinline
 397 ev_feed_event (EV_P_ void *w, int revents)
 398 {
 399   W w_ = (W)w;
 400
 401   if (expect_false (w_->pending))
 402     {
 403       pendings [ABSPRI (w_)][w_->pending - 1].events |= revents;
 404       return;
 405     }
 406
 407   w_->pending = ++pendingcnt [ABSPRI (w_)];
 408   array_needsize (ANPENDING, pendings [ABSPRI (w_)], pendingmax [ABSPRI (w_)], pendingcnt [ABSPRI (w_)], EMPTY2);
 409   pendings [ABSPRI (w_)][w_->pending - 1].w      = w_;
 410   pendings [ABSPRI (w_)][w_->pending - 1].events = revents;
 411 }
 412
 413 void inline_size
 414 queue_events (EV_P_ W *events, int eventcnt, int type)
 415 {
 416   int i;
 417
 418   for (i = 0; i < eventcnt; ++i)
 419     ev_feed_event (EV_A_ events [i], type);
 420 }
 421
 422 /*****************************************************************************/
 423
 424 void inline_size
 425 anfds_init (ANFD *base, int count)
 426 {
 427   while (count--)
 428     {
 429       base->head   = 0;
 430       base->events = EV_NONE;
 431       base->reify  = 0;
 432
 433       ++base;
 434     }
 435 }
 436
 437 void inline_speed
 438 fd_event (EV_P_ int fd, int revents)
 439 {
 440   ANFD *anfd = anfds + fd;
 441   ev_io *w;
 442
 443   for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
 444     {
 445       int ev = w->events & revents;
 446
 447       if (ev)
 448         ev_feed_event (EV_A_ (W)w, ev);
 449     }
 450 }
 451
 452 void
 453 ev_feed_fd_event (EV_P_ int fd, int revents)
 454 {
 455   fd_event (EV_A_ fd, revents);
 456 }
 457
 458 void inline_size
 459 fd_reify (EV_P)
 460 {
 461   int i;
 462
 463   for (i = 0; i < fdchangecnt; ++i)
 464     {
 465       int fd = fdchanges [i];
 466       ANFD *anfd = anfds + fd;
 467       ev_io *w;
 468
 469       int events = 0;
 470
 471       for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
 472         events |= w->events;
 473
 474 #if EV_SELECT_IS_WINSOCKET
 475       if (events)
 476         {
 477           unsigned long argp;
 478           anfd->handle = _get_osfhandle (fd);
 479           assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &argp) == 0));
 480         }
 481 #endif
 482
 483       anfd->reify = 0;
 484
 485       backend_modify (EV_A_ fd, anfd->events, events);
 486       anfd->events = events;
 487     }
 488
 489   fdchangecnt = 0;
 490 }
 491
 492 void inline_size
 493 fd_change (EV_P_ int fd)
 494 {
 495   if (expect_false (anfds [fd].reify))
 496     return;
 497
 498   anfds [fd].reify = 1;
 499
 500   ++fdchangecnt;
 501   array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
 502   fdchanges [fdchangecnt - 1] = fd;
 503 }
 504
 505 void inline_speed
 506 fd_kill (EV_P_ int fd)
 507 {
 508   ev_io *w;
 509
 510   while ((w = (ev_io *)anfds [fd].head))
 511     {
 512       ev_io_stop (EV_A_ w);
 513       ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
 514     }
 515 }
 516
 517 int inline_size
 518 fd_valid (int fd)
 519 {
 520 #ifdef _WIN32
 521   return _get_osfhandle (fd) != -1;
 522 #else
 523   return fcntl (fd, F_GETFD) != -1;
 524 #endif
 525 }
 526
 527 /* called on EBADF to verify fds */
 528 static void noinline
 529 fd_ebadf (EV_P)
 530 {
 531   int fd;
 532
 533   for (fd = 0; fd < anfdmax; ++fd)
 534     if (anfds [fd].events)
 535       if (!fd_valid (fd) == -1 && errno == EBADF)
 536         fd_kill (EV_A_ fd);
 537 }
 538
 539 /* called on ENOMEM in select/poll to kill some fds and retry */
 540 static void noinline
 541 fd_enomem (EV_P)
 542 {
 543   int fd;
 544
 545   for (fd = anfdmax; fd--; )
 546     if (anfds [fd].events)
 547       {
 548         fd_kill (EV_A_ fd);
 549         return;
 550       }
 551 }
 552
 553 /* usually called after fork if backend needs to re-arm all fds from scratch */
 554 static void noinline
 555 fd_rearm_all (EV_P)
 556 {
 557   int fd;
 558
 559   /* this should be highly optimised to not do anything but set a flag */
 560   for (fd = 0; fd < anfdmax; ++fd)
 561     if (anfds [fd].events)
 562       {
 563         anfds [fd].events = 0;
 564         fd_change (EV_A_ fd);
 565       }
 566 }
 567
 568 /*****************************************************************************/
 569
 570 void inline_speed
 571 upheap (WT *heap, int k)
 572 {
 573   WT w = heap [k];
 574
 575   while (k && heap [k >> 1]->at > w->at)
 576     {
 577       heap [k] = heap [k >> 1];
 578       ((W)heap [k])->active = k + 1;
 579       k >>= 1;
 580     }
 581
 582   heap [k] = w;
 583   ((W)heap [k])->active = k + 1;
 584
 585 }
 586
 587 void inline_speed
 588 downheap (WT *heap, int N, int k)
 589 {
 590   WT w = heap [k];
 591
 592   while (k < (N >> 1))
 593     {
 594       int j = k << 1;
 595
 596       if (j + 1 < N && heap [j]->at > heap [j + 1]->at)
 597         ++j;
 598
 599       if (w->at <= heap [j]->at)
 600         break;
 601
 602       heap [k] = heap [j];
 603       ((W)heap [k])->active = k + 1;
 604       k = j;
 605     }
 606
 607   heap [k] = w;
 608   ((W)heap [k])->active = k + 1;
 609 }
 610
 611 void inline_size
 612 adjustheap (WT *heap, int N, int k)
 613 {
 614   upheap (heap, k);
 615   downheap (heap, N, k);
 616 }
 617
 618 /*****************************************************************************/
 619
 620 typedef struct
 621 {
 622   WL head;
 623   sig_atomic_t volatile gotsig;
 624 } ANSIG;
 625
 626 static ANSIG *signals;
 627 static int signalmax;
 628
 629 static int sigpipe [2];
 630 static sig_atomic_t volatile gotsig;
 631 static ev_io sigev;
 632
 633 void inline_size
 634 signals_init (ANSIG *base, int count)
 635 {
 636   while (count--)
 637     {
 638       base->head   = 0;
 639       base->gotsig = 0;
 640
 641       ++base;
 642     }
 643 }
 644
 645 static void
 646 sighandler (int signum)
 647 {
 648 #if _WIN32
 649   signal (signum, sighandler);
 650 #endif
 651
 652   signals [signum - 1].gotsig = 1;
 653
 654   if (!gotsig)
 655     {
 656       int old_errno = errno;
 657       gotsig = 1;
 658       write (sigpipe [1], &signum, 1);
 659       errno = old_errno;
 660     }
 661 }
 662
 663 void noinline
 664 ev_feed_signal_event (EV_P_ int signum)
 665 {
 666   WL w;
 667
 668 #if EV_MULTIPLICITY
 669   assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
 670 #endif
 671
 672   --signum;
 673
 674   if (signum < 0 || signum >= signalmax)
 675     return;
 676
 677   signals [signum].gotsig = 0;
 678
 679   for (w = signals [signum].head; w; w = w->next)
 680     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 681 }
 682
 683 static void
 684 sigcb (EV_P_ ev_io *iow, int revents)
 685 {
 686   int signum;
 687
 688   read (sigpipe [0], &revents, 1);
 689   gotsig = 0;
 690
 691   for (signum = signalmax; signum--; )
 692     if (signals [signum].gotsig)
 693       ev_feed_signal_event (EV_A_ signum + 1);
 694 }
 695
 696 void inline_size
 697 fd_intern (int fd)
 698 {
 699 #ifdef _WIN32
 700   int arg = 1;
 701   ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
 702 #else
 703   fcntl (fd, F_SETFD, FD_CLOEXEC);
 704   fcntl (fd, F_SETFL, O_NONBLOCK);
 705 #endif
 706 }
 707
 708 static void noinline
 709 siginit (EV_P)
 710 {
 711   fd_intern (sigpipe [0]);
 712   fd_intern (sigpipe [1]);
 713
 714   ev_io_set (&sigev, sigpipe [0], EV_READ);
 715   ev_io_start (EV_A_ &sigev);
 716   ev_unref (EV_A); /* child watcher should not keep loop alive */
 717 }
 718
 719 /*****************************************************************************/
 720
 721 static ev_child *childs [EV_PID_HASHSIZE];
 722
 723 #ifndef _WIN32
 724
 725 static ev_signal childev;
 726
 727 void inline_speed
 728 child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status)
 729 {
 730   ev_child *w;
 731
 732   for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
 733     if (w->pid == pid || !w->pid)
 734       {
 735         ev_priority (w) = ev_priority (sw); /* need to do it *now* */
 736         w->rpid         = pid;
 737         w->rstatus      = status;
 738         ev_feed_event (EV_A_ (W)w, EV_CHILD);
 739       }
 740 }
 741
 742 #ifndef WCONTINUED
 743 # define WCONTINUED 0
 744 #endif
 745
 746 static void
 747 childcb (EV_P_ ev_signal *sw, int revents)
 748 {
 749   int pid, status;
 750
 751   /* some systems define WCONTINUED but then fail to support it (linux 2.4) */
 752   if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
 753     if (!WCONTINUED
 754         || errno != EINVAL
 755         || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
 756       return;
 757
 758   /* make sure we are called again until all childs have been reaped */
 759   /* we need to do it this way so that the callback gets called before we continue */
 760   ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
 761
 762   child_reap (EV_A_ sw, pid, pid, status);
 763   if (EV_PID_HASHSIZE > 1)
 764     child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
 765 }
 766
 767 #endif
 768
 769 /*****************************************************************************/
 770
 771 #if EV_USE_PORT
 772 # include "ev_port.c"
 773 #endif
 774 #if EV_USE_KQUEUE
 775 # include "ev_kqueue.c"
 776 #endif
 777 #if EV_USE_EPOLL
 778 # include "ev_epoll.c"
 779 #endif
 780 #if EV_USE_POLL
 781 # include "ev_poll.c"
 782 #endif
 783 #if EV_USE_SELECT
 784 # include "ev_select.c"
 785 #endif
 786
 787 int
 788 ev_version_major (void)
 789 {
 790   return EV_VERSION_MAJOR;
 791 }
 792
 793 int
 794 ev_version_minor (void)
 795 {
 796   return EV_VERSION_MINOR;
 797 }
 798
 799 /* return true if we are running with elevated privileges and should ignore env variables */
 800 int inline_size
 801 enable_secure (void)
 802 {
 803 #ifdef _WIN32
 804   return 0;
 805 #else
 806   return getuid () != geteuid ()
 807       || getgid () != getegid ();
 808 #endif
 809 }
 810
 811 unsigned int
 812 ev_supported_backends (void)
 813 {
 814   unsigned int flags = 0;
 815
 816   if (EV_USE_PORT  ) flags |= EVBACKEND_PORT;
 817   if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
 818   if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
 819   if (EV_USE_POLL  ) flags |= EVBACKEND_POLL;
 820   if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
 821
 822   return flags;
 823 }
 824
 825 unsigned int
 826 ev_recommended_backends (void)
 827 {
 828   unsigned int flags = ev_supported_backends ();
 829
 830 #ifndef __NetBSD__
 831   /* kqueue is borked on everything but netbsd apparently */
 832   /* it usually doesn't work correctly on anything but sockets and pipes */
 833   flags &= ~EVBACKEND_KQUEUE;
 834 #endif
 835 #ifdef __APPLE__
 836   // flags &= ~EVBACKEND_KQUEUE; for documentation
 837   flags &= ~EVBACKEND_POLL;
 838 #endif
 839
 840   return flags;
 841 }
 842
 843 unsigned int
 844 ev_embeddable_backends (void)
 845 {
 846   return EVBACKEND_EPOLL
 847        | EVBACKEND_KQUEUE
 848        | EVBACKEND_PORT;
 849 }
 850
 851 unsigned int
 852 ev_backend (EV_P)
 853 {
 854   return backend;
 855 }
 856
 857 static void noinline
 858 loop_init (EV_P_ unsigned int flags)
 859 {
 860   if (!backend)
 861     {
 862 #if EV_USE_MONOTONIC
 863       {
 864         struct timespec ts;
 865         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
 866           have_monotonic = 1;
 867       }
 868 #endif
 869
 870       ev_rt_now = ev_time ();
 871       mn_now    = get_clock ();
 872       now_floor = mn_now;
 873       rtmn_diff = ev_rt_now - mn_now;
 874
 875       if (!(flags & EVFLAG_NOENV)
 876           && !enable_secure ()
 877           && getenv ("LIBEV_FLAGS"))
 878         flags = atoi (getenv ("LIBEV_FLAGS"));
 879
 880       if (!(flags & 0x0000ffffUL))
 881         flags |= ev_recommended_backends ();
 882
 883       backend = 0;
 884 #if EV_USE_PORT
 885       if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
 886 #endif
 887 #if EV_USE_KQUEUE
 888       if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
 889 #endif
 890 #if EV_USE_EPOLL
 891       if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init  (EV_A_ flags);
 892 #endif
 893 #if EV_USE_POLL
 894       if (!backend && (flags & EVBACKEND_POLL  )) backend = poll_init   (EV_A_ flags);
 895 #endif
 896 #if EV_USE_SELECT
 897       if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
 898 #endif
 899
 900       ev_init (&sigev, sigcb);
 901       ev_set_priority (&sigev, EV_MAXPRI);
 902     }
 903 }
 904
 905 static void noinline
 906 loop_destroy (EV_P)
 907 {
 908   int i;
 909
 910 #if EV_USE_PORT
 911   if (backend == EVBACKEND_PORT  ) port_destroy   (EV_A);
 912 #endif
 913 #if EV_USE_KQUEUE
 914   if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
 915 #endif
 916 #if EV_USE_EPOLL
 917   if (backend == EVBACKEND_EPOLL ) epoll_destroy  (EV_A);
 918 #endif
 919 #if EV_USE_POLL
 920   if (backend == EVBACKEND_POLL  ) poll_destroy   (EV_A);
 921 #endif
 922 #if EV_USE_SELECT
 923   if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
 924 #endif
 925
 926   for (i = NUMPRI; i--; )
 927     array_free (pending, [i]);
 928
 929   /* have to use the microsoft-never-gets-it-right macro */
 930   array_free (fdchange, EMPTY0);
 931   array_free (timer, EMPTY0);
 932 #if EV_PERIODIC_ENABLE
 933   array_free (periodic, EMPTY0);
 934 #endif
 935   array_free (idle, EMPTY0);
 936   array_free (prepare, EMPTY0);
 937   array_free (check, EMPTY0);
 938
 939   backend = 0;
 940 }
 941
 942 void inline_size
 943 loop_fork (EV_P)
 944 {
 945 #if EV_USE_PORT
 946   if (backend == EVBACKEND_PORT  ) port_fork   (EV_A);
 947 #endif
 948 #if EV_USE_KQUEUE
 949   if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
 950 #endif
 951 #if EV_USE_EPOLL
 952   if (backend == EVBACKEND_EPOLL ) epoll_fork  (EV_A);
 953 #endif
 954
 955   if (ev_is_active (&sigev))
 956     {
 957       /* default loop */
 958
 959       ev_ref (EV_A);
 960       ev_io_stop (EV_A_ &sigev);
 961       close (sigpipe [0]);
 962       close (sigpipe [1]);
 963
 964       while (pipe (sigpipe))
 965         syserr ("(libev) error creating pipe");
 966
 967       siginit (EV_A);
 968     }
 969
 970   postfork = 0;
 971 }
 972
 973 #if EV_MULTIPLICITY
 974 struct ev_loop *
 975 ev_loop_new (unsigned int flags)
 976 {
 977   struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
 978
 979   memset (loop, 0, sizeof (struct ev_loop));
 980
 981   loop_init (EV_A_ flags);
 982
 983   if (ev_backend (EV_A))
 984     return loop;
 985
 986   return 0;
 987 }
 988
 989 void
 990 ev_loop_destroy (EV_P)
 991 {
 992   loop_destroy (EV_A);
 993   ev_free (loop);
 994 }
 995
 996 void
 997 ev_loop_fork (EV_P)
 998 {
 999   postfork = 1;
1000 }
1001
1002 #endif
1003
1004 #if EV_MULTIPLICITY
1005 struct ev_loop *
1006 ev_default_loop_init (unsigned int flags)
1007 #else
1008 int
1009 ev_default_loop (unsigned int flags)
1010 #endif
1011 {
1012   if (sigpipe [0] == sigpipe [1])
1013     if (pipe (sigpipe))
1014       return 0;
1015
1016   if (!ev_default_loop_ptr)
1017     {
1018 #if EV_MULTIPLICITY
1019       struct ev_loop *loop = ev_default_loop_ptr = &default_loop_struct;
1020 #else
1021       ev_default_loop_ptr = 1;
1022 #endif
1023
1024       loop_init (EV_A_ flags);
1025
1026       if (ev_backend (EV_A))
1027         {
1028           siginit (EV_A);
1029
1030 #ifndef _WIN32
1031           ev_signal_init (&childev, childcb, SIGCHLD);
1032           ev_set_priority (&childev, EV_MAXPRI);
1033           ev_signal_start (EV_A_ &childev);
1034           ev_unref (EV_A); /* child watcher should not keep loop alive */
1035 #endif
1036         }
1037       else
1038         ev_default_loop_ptr = 0;
1039     }
1040
1041   return ev_default_loop_ptr;
1042 }
1043
1044 void
1045 ev_default_destroy (void)
1046 {
1047 #if EV_MULTIPLICITY
1048   struct ev_loop *loop = ev_default_loop_ptr;
1049 #endif
1050
1051 #ifndef _WIN32
1052   ev_ref (EV_A); /* child watcher */
1053   ev_signal_stop (EV_A_ &childev);
1054 #endif
1055
1056   ev_ref (EV_A); /* signal watcher */
1057   ev_io_stop (EV_A_ &sigev);
1058
1059   close (sigpipe [0]); sigpipe [0] = 0;
1060   close (sigpipe [1]); sigpipe [1] = 0;
1061
1062   loop_destroy (EV_A);
1063 }
1064
1065 void
1066 ev_default_fork (void)
1067 {
1068 #if EV_MULTIPLICITY
1069   struct ev_loop *loop = ev_default_loop_ptr;
1070 #endif
1071
1072   if (backend)
1073     postfork = 1;
1074 }
1075
1076 /*****************************************************************************/
1077
1078 int inline_size
1079 any_pending (EV_P)
1080 {
1081   int pri;
1082
1083   for (pri = NUMPRI; pri--; )
1084     if (pendingcnt [pri])
1085       return 1;
1086
1087   return 0;
1088 }
1089
1090 void inline_speed
1091 call_pending (EV_P)
1092 {
1093   int pri;
1094
1095   for (pri = NUMPRI; pri--; )
1096     while (pendingcnt [pri])
1097       {
1098         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
1099
1100         if (expect_true (p->w))
1101           {
1102             /*assert (("non-pending watcher on pending list", p->w->pending));*/
1103
1104             p->w->pending = 0;
1105             EV_CB_INVOKE (p->w, p->events);
1106           }
1107       }
1108 }
1109
1110 void inline_size
1111 timers_reify (EV_P)
1112 {
1113   while (timercnt && ((WT)timers [0])->at <= mn_now)
1114     {
1115       ev_timer *w = timers [0];
1116
1117       /*assert (("inactive timer on timer heap detected", ev_is_active (w)));*/
1118
1119       /* first reschedule or stop timer */
1120       if (w->repeat)
1121         {
1122           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
1123
1124           ((WT)w)->at += w->repeat;
1125           if (((WT)w)->at < mn_now)
1126             ((WT)w)->at = mn_now;
1127
1128           downheap ((WT *)timers, timercnt, 0);
1129         }
1130       else
1131         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
1132
1133       ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
1134     }
1135 }
1136
1137 #if EV_PERIODIC_ENABLE
1138 void inline_size
1139 periodics_reify (EV_P)
1140 {
1141   while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now)
1142     {
1143       ev_periodic *w = periodics [0];
1144
1145       /*assert (("inactive timer on periodic heap detected", ev_is_active (w)));*/
1146
1147       /* first reschedule or stop timer */
1148       if (w->reschedule_cb)
1149         {
1150           ((WT)w)->at = w->reschedule_cb (w, ev_rt_now + 0.0001);
1151           assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now));
1152           downheap ((WT *)periodics, periodiccnt, 0);
1153         }
1154       else if (w->interval)
1155         {
1156           ((WT)w)->at += floor ((ev_rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
1157           assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));
1158           downheap ((WT *)periodics, periodiccnt, 0);
1159         }
1160       else
1161         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1162
1163       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
1164     }
1165 }
1166
1167 static void noinline
1168 periodics_reschedule (EV_P)
1169 {
1170   int i;
1171
1172   /* adjust periodics after time jump */
1173   for (i = 0; i < periodiccnt; ++i)
1174     {
1175       ev_periodic *w = periodics [i];
1176
1177       if (w->reschedule_cb)
1178         ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1179       else if (w->interval)
1180         ((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval;
1181     }
1182
1183   /* now rebuild the heap */
1184   for (i = periodiccnt >> 1; i--; )
1185     downheap ((WT *)periodics, periodiccnt, i);
1186 }
1187 #endif
1188
1189 int inline_size
1190 time_update_monotonic (EV_P)
1191 {
1192   mn_now = get_clock ();
1193
1194   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
1195     {
1196       ev_rt_now = rtmn_diff + mn_now;
1197       return 0;
1198     }
1199   else
1200     {
1201       now_floor = mn_now;
1202       ev_rt_now = ev_time ();
1203       return 1;
1204     }
1205 }
1206
1207 void inline_size
1208 time_update (EV_P)
1209 {
1210   int i;
1211
1212 #if EV_USE_MONOTONIC
1213   if (expect_true (have_monotonic))
1214     {
1215       if (time_update_monotonic (EV_A))
1216         {
1217           ev_tstamp odiff = rtmn_diff;
1218
1219           /* loop a few times, before making important decisions.
1220            * on the choice of "4": one iteration isn't enough,
1221            * in case we get preempted during the calls to
1222            * ev_time and get_clock. a second call is almost guarenteed
1223            * to succeed in that case, though. and looping a few more times
1224            * doesn't hurt either as we only do this on time-jumps or
1225            * in the unlikely event of getting preempted here.
1226            */
1227           for (i = 4; --i; )
1228             {
1229               rtmn_diff = ev_rt_now - mn_now;
1230
1231               if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
1232                 return; /* all is well */
1233
1234               ev_rt_now = ev_time ();
1235               mn_now    = get_clock ();
1236               now_floor = mn_now;
1237             }
1238
1239 # if EV_PERIODIC_ENABLE
1240           periodics_reschedule (EV_A);
1241 # endif
1242           /* no timer adjustment, as the monotonic clock doesn't jump */
1243           /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1244         }
1245     }
1246   else
1247 #endif
1248     {
1249       ev_rt_now = ev_time ();
1250
1251       if (expect_false (mn_now > ev_rt_now || mn_now < ev_rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
1252         {
1253 #if EV_PERIODIC_ENABLE
1254           periodics_reschedule (EV_A);
1255 #endif
1256
1257           /* adjust timers. this is easy, as the offset is the same for all */
1258           for (i = 0; i < timercnt; ++i)
1259             ((WT)timers [i])->at += ev_rt_now - mn_now;
1260         }
1261
1262       mn_now = ev_rt_now;
1263     }
1264 }
1265
1266 void
1267 ev_ref (EV_P)
1268 {
1269   ++activecnt;
1270 }
1271
1272 void
1273 ev_unref (EV_P)
1274 {
1275   --activecnt;
1276 }
1277
1278 static int loop_done;
1279
1280 void
1281 ev_loop (EV_P_ int flags)
1282 {
1283   loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)
1284             ? EVUNLOOP_ONE
1285             : EVUNLOOP_CANCEL;
1286
1287   while (activecnt)
1288     {
1289       /* we might have forked, so reify kernel state if necessary */
1290       #if EV_FORK_ENABLE
1291         if (expect_false (postfork))
1292           if (forkcnt)
1293             {
1294               queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
1295               call_pending (EV_A);
1296             }
1297       #endif
1298
1299       /* queue check watchers (and execute them) */
1300       if (expect_false (preparecnt))
1301         {
1302           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1303           call_pending (EV_A);
1304         }
1305
1306       /* we might have forked, so reify kernel state if necessary */
1307       if (expect_false (postfork))
1308         loop_fork (EV_A);
1309
1310       /* update fd-related kernel structures */
1311       fd_reify (EV_A);
1312
1313       /* calculate blocking time */
1314       {
1315         double block;
1316
1317         if (flags & EVLOOP_NONBLOCK || idlecnt)
1318           block = 0.; /* do not block at all */
1319         else
1320           {
1321             /* update time to cancel out callback processing overhead */
1322 #if EV_USE_MONOTONIC
1323             if (expect_true (have_monotonic))
1324               time_update_monotonic (EV_A);
1325             else
1326 #endif
1327               {
1328                 ev_rt_now = ev_time ();
1329                 mn_now    = ev_rt_now;
1330               }
1331
1332             block = MAX_BLOCKTIME;
1333
1334             if (timercnt)
1335               {
1336                 ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge;
1337                 if (block > to) block = to;
1338               }
1339
1340 #if EV_PERIODIC_ENABLE
1341             if (periodiccnt)
1342               {
1343                 ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge;
1344                 if (block > to) block = to;
1345               }
1346 #endif
1347
1348             if (expect_false (block < 0.)) block = 0.;
1349           }
1350
1351         backend_poll (EV_A_ block);
1352       }
1353
1354       /* update ev_rt_now, do magic */
1355       time_update (EV_A);
1356
1357       /* queue pending timers and reschedule them */
1358       timers_reify (EV_A); /* relative timers called last */
1359 #if EV_PERIODIC_ENABLE
1360       periodics_reify (EV_A); /* absolute timers called first */
1361 #endif
1362
1363       /* queue idle watchers unless other events are pending */
1364       if (idlecnt && !any_pending (EV_A))
1365         queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1366
1367       /* queue check watchers, to be executed first */
1368       if (expect_false (checkcnt))
1369         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1370
1371       call_pending (EV_A);
1372
1373       if (expect_false (loop_done))
1374         break;
1375     }
1376
1377   if (loop_done == EVUNLOOP_ONE)
1378     loop_done = EVUNLOOP_CANCEL;
1379 }
1380
1381 void
1382 ev_unloop (EV_P_ int how)
1383 {
1384   loop_done = how;
1385 }
1386
1387 /*****************************************************************************/
1388
1389 void inline_size
1390 wlist_add (WL *head, WL elem)
1391 {
1392   elem->next = *head;
1393   *head = elem;
1394 }
1395
1396 void inline_size
1397 wlist_del (WL *head, WL elem)
1398 {
1399   while (*head)
1400     {
1401       if (*head == elem)
1402         {
1403           *head = elem->next;
1404           return;
1405         }
1406
1407       head = &(*head)->next;
1408     }
1409 }
1410
1411 void inline_speed
1412 ev_clear_pending (EV_P_ W w)
1413 {
1414   if (w->pending)
1415     {
1416       pendings [ABSPRI (w)][w->pending - 1].w = 0;
1417       w->pending = 0;
1418     }
1419 }
1420
1421 void inline_speed
1422 ev_start (EV_P_ W w, int active)
1423 {
1424   if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1425   if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1426
1427   w->active = active;
1428   ev_ref (EV_A);
1429 }
1430
1431 void inline_size
1432 ev_stop (EV_P_ W w)
1433 {
1434   ev_unref (EV_A);
1435   w->active = 0;
1436 }
1437
1438 /*****************************************************************************/
1439
1440 void
1441 ev_io_start (EV_P_ ev_io *w)
1442 {
1443   int fd = w->fd;
1444
1445   if (expect_false (ev_is_active (w)))
1446     return;
1447
1448   assert (("ev_io_start called with negative fd", fd >= 0));
1449
1450   ev_start (EV_A_ (W)w, 1);
1451   array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
1452   wlist_add ((WL *)&anfds[fd].head, (WL)w);
1453
1454   fd_change (EV_A_ fd);
1455 }
1456
1457 void
1458 ev_io_stop (EV_P_ ev_io *w)
1459 {
1460   ev_clear_pending (EV_A_ (W)w);
1461   if (expect_false (!ev_is_active (w)))
1462     return;
1463
1464   assert (("ev_io_start called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
1465
1466   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
1467   ev_stop (EV_A_ (W)w);
1468
1469   fd_change (EV_A_ w->fd);
1470 }
1471
1472 void
1473 ev_timer_start (EV_P_ ev_timer *w)
1474 {
1475   if (expect_false (ev_is_active (w)))
1476     return;
1477
1478   ((WT)w)->at += mn_now;
1479
1480   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1481
1482   ev_start (EV_A_ (W)w, ++timercnt);
1483   array_needsize (ev_timer *, timers, timermax, timercnt, EMPTY2);
1484   timers [timercnt - 1] = w;
1485   upheap ((WT *)timers, timercnt - 1);
1486
1487   /*assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));*/
1488 }
1489
1490 void
1491 ev_timer_stop (EV_P_ ev_timer *w)
1492 {
1493   ev_clear_pending (EV_A_ (W)w);
1494   if (expect_false (!ev_is_active (w)))
1495     return;
1496
1497   assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1498
1499   {
1500     int active = ((W)w)->active;
1501
1502     if (expect_true (--active < --timercnt))
1503       {
1504         timers [active] = timers [timercnt];
1505         adjustheap ((WT *)timers, timercnt, active);
1506       }
1507   }
1508
1509   ((WT)w)->at -= mn_now;
1510
1511   ev_stop (EV_A_ (W)w);
1512 }
1513
1514 void
1515 ev_timer_again (EV_P_ ev_timer *w)
1516 {
1517   if (ev_is_active (w))
1518     {
1519       if (w->repeat)
1520         {
1521           ((WT)w)->at = mn_now + w->repeat;
1522           adjustheap ((WT *)timers, timercnt, ((W)w)->active - 1);
1523         }
1524       else
1525         ev_timer_stop (EV_A_ w);
1526     }
1527   else if (w->repeat)
1528     {
1529       w->at = w->repeat;
1530       ev_timer_start (EV_A_ w);
1531     }
1532 }
1533
1534 #if EV_PERIODIC_ENABLE
1535 void
1536 ev_periodic_start (EV_P_ ev_periodic *w)
1537 {
1538   if (expect_false (ev_is_active (w)))
1539     return;
1540
1541   if (w->reschedule_cb)
1542     ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1543   else if (w->interval)
1544     {
1545       assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1546       /* this formula differs from the one in periodic_reify because we do not always round up */
1547       ((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval;
1548     }
1549
1550   ev_start (EV_A_ (W)w, ++periodiccnt);
1551   array_needsize (ev_periodic *, periodics, periodicmax, periodiccnt, EMPTY2);
1552   periodics [periodiccnt - 1] = w;
1553   upheap ((WT *)periodics, periodiccnt - 1);
1554
1555   /*assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));*/
1556 }
1557
1558 void
1559 ev_periodic_stop (EV_P_ ev_periodic *w)
1560 {
1561   ev_clear_pending (EV_A_ (W)w);
1562   if (expect_false (!ev_is_active (w)))
1563     return;
1564
1565   assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1566
1567   {
1568     int active = ((W)w)->active;
1569
1570     if (expect_true (--active < --periodiccnt))
1571       {
1572         periodics [active] = periodics [periodiccnt];
1573         adjustheap ((WT *)periodics, periodiccnt, active);
1574       }
1575   }
1576
1577   ev_stop (EV_A_ (W)w);
1578 }
1579
1580 void
1581 ev_periodic_again (EV_P_ ev_periodic *w)
1582 {
1583   /* TODO: use adjustheap and recalculation */
1584   ev_periodic_stop (EV_A_ w);
1585   ev_periodic_start (EV_A_ w);
1586 }
1587 #endif
1588
1589 #ifndef SA_RESTART
1590 # define SA_RESTART 0
1591 #endif
1592
1593 void
1594 ev_signal_start (EV_P_ ev_signal *w)
1595 {
1596 #if EV_MULTIPLICITY
1597   assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr));
1598 #endif
1599   if (expect_false (ev_is_active (w)))
1600     return;
1601
1602   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1603
1604   ev_start (EV_A_ (W)w, 1);
1605   array_needsize (ANSIG, signals, signalmax, w->signum, signals_init);
1606   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
1607
1608   if (!((WL)w)->next)
1609     {
1610 #if _WIN32
1611       signal (w->signum, sighandler);
1612 #else
1613       struct sigaction sa;
1614       sa.sa_handler = sighandler;
1615       sigfillset (&sa.sa_mask);
1616       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1617       sigaction (w->signum, &sa, 0);
1618 #endif
1619     }
1620 }
1621
1622 void
1623 ev_signal_stop (EV_P_ ev_signal *w)
1624 {
1625   ev_clear_pending (EV_A_ (W)w);
1626   if (expect_false (!ev_is_active (w)))
1627     return;
1628
1629   wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
1630   ev_stop (EV_A_ (W)w);
1631
1632   if (!signals [w->signum - 1].head)
1633     signal (w->signum, SIG_DFL);
1634 }
1635
1636 void
1637 ev_child_start (EV_P_ ev_child *w)
1638 {
1639 #if EV_MULTIPLICITY
1640   assert (("child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
1641 #endif
1642   if (expect_false (ev_is_active (w)))
1643     return;
1644
1645   ev_start (EV_A_ (W)w, 1);
1646   wlist_add ((WL *)&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
1647 }
1648
1649 void
1650 ev_child_stop (EV_P_ ev_child *w)
1651 {
1652   ev_clear_pending (EV_A_ (W)w);
1653   if (expect_false (!ev_is_active (w)))
1654     return;
1655
1656   wlist_del ((WL *)&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
1657   ev_stop (EV_A_ (W)w);
1658 }
1659
1660 #if EV_STAT_ENABLE
1661
1662 # ifdef _WIN32
1663 #  undef lstat
1664 #  define lstat(a,b) _stati64 (a,b)
1665 # endif
1666
1667 #define DEF_STAT_INTERVAL 5.0074891
1668 #define MIN_STAT_INTERVAL 0.1074891
1669
1670 void
1671 ev_stat_stat (EV_P_ ev_stat *w)
1672 {
1673   if (lstat (w->path, &w->attr) < 0)
1674     w->attr.st_nlink = 0;
1675   else if (!w->attr.st_nlink)
1676     w->attr.st_nlink = 1;
1677 }
1678
1679 static void
1680 stat_timer_cb (EV_P_ ev_timer *w_, int revents)
1681 {
1682   ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
1683
1684   /* we copy this here each the time so that */
1685   /* prev has the old value when the callback gets invoked */
1686   w->prev = w->attr;
1687   ev_stat_stat (EV_A_ w);
1688
1689   if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata)))
1690     ev_feed_event (EV_A_ w, EV_STAT);
1691 }
1692
1693 void
1694 ev_stat_start (EV_P_ ev_stat *w)
1695 {
1696   if (expect_false (ev_is_active (w)))
1697     return;
1698
1699   /* since we use memcmp, we need to clear any padding data etc. */
1700   memset (&w->prev, 0, sizeof (ev_statdata));
1701   memset (&w->attr, 0, sizeof (ev_statdata));
1702
1703   ev_stat_stat (EV_A_ w);
1704
1705   if (w->interval < MIN_STAT_INTERVAL)
1706     w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;
1707
1708   ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
1709   ev_set_priority (&w->timer, ev_priority (w));
1710   ev_timer_start (EV_A_ &w->timer);
1711
1712   ev_start (EV_A_ (W)w, 1);
1713 }
1714
1715 void
1716 ev_stat_stop (EV_P_ ev_stat *w)
1717 {
1718   ev_clear_pending (EV_A_ (W)w);
1719   if (expect_false (!ev_is_active (w)))
1720     return;
1721
1722   ev_timer_stop (EV_A_ &w->timer);
1723
1724   ev_stop (EV_A_ (W)w);
1725 }
1726 #endif
1727
1728 void
1729 ev_idle_start (EV_P_ ev_idle *w)
1730 {
1731   if (expect_false (ev_is_active (w)))
1732     return;
1733
1734   ev_start (EV_A_ (W)w, ++idlecnt);
1735   array_needsize (ev_idle *, idles, idlemax, idlecnt, EMPTY2);
1736   idles [idlecnt - 1] = w;
1737 }
1738
1739 void
1740 ev_idle_stop (EV_P_ ev_idle *w)
1741 {
1742   ev_clear_pending (EV_A_ (W)w);
1743   if (expect_false (!ev_is_active (w)))
1744     return;
1745
1746   {
1747     int active = ((W)w)->active;
1748     idles [active - 1] = idles [--idlecnt];
1749     ((W)idles [active - 1])->active = active;
1750   }
1751
1752   ev_stop (EV_A_ (W)w);
1753 }
1754
1755 void
1756 ev_prepare_start (EV_P_ ev_prepare *w)
1757 {
1758   if (expect_false (ev_is_active (w)))
1759     return;
1760
1761   ev_start (EV_A_ (W)w, ++preparecnt);
1762   array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
1763   prepares [preparecnt - 1] = w;
1764 }
1765
1766 void
1767 ev_prepare_stop (EV_P_ ev_prepare *w)
1768 {
1769   ev_clear_pending (EV_A_ (W)w);
1770   if (expect_false (!ev_is_active (w)))
1771     return;
1772
1773   {
1774     int active = ((W)w)->active;
1775     prepares [active - 1] = prepares [--preparecnt];
1776     ((W)prepares [active - 1])->active = active;
1777   }
1778
1779   ev_stop (EV_A_ (W)w);
1780 }
1781
1782 void
1783 ev_check_start (EV_P_ ev_check *w)
1784 {
1785   if (expect_false (ev_is_active (w)))
1786     return;
1787
1788   ev_start (EV_A_ (W)w, ++checkcnt);
1789   array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
1790   checks [checkcnt - 1] = w;
1791 }
1792
1793 void
1794 ev_check_stop (EV_P_ ev_check *w)
1795 {
1796   ev_clear_pending (EV_A_ (W)w);
1797   if (expect_false (!ev_is_active (w)))
1798     return;
1799
1800   {
1801     int active = ((W)w)->active;
1802     checks [active - 1] = checks [--checkcnt];
1803     ((W)checks [active - 1])->active = active;
1804   }
1805
1806   ev_stop (EV_A_ (W)w);
1807 }
1808
1809 #if EV_EMBED_ENABLE
1810 void noinline
1811 ev_embed_sweep (EV_P_ ev_embed *w)
1812 {
1813   ev_loop (w->loop, EVLOOP_NONBLOCK);
1814 }
1815
1816 static void
1817 embed_cb (EV_P_ ev_io *io, int revents)
1818 {
1819   ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io));
1820
1821   if (ev_cb (w))
1822     ev_feed_event (EV_A_ (W)w, EV_EMBED);
1823   else
1824     ev_embed_sweep (loop, w);
1825 }
1826
1827 void
1828 ev_embed_start (EV_P_ ev_embed *w)
1829 {
1830   if (expect_false (ev_is_active (w)))
1831     return;
1832
1833   {
1834     struct ev_loop *loop = w->loop;
1835     assert (("loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
1836     ev_io_init (&w->io, embed_cb, backend_fd, EV_READ);
1837   }
1838
1839   ev_set_priority (&w->io, ev_priority (w));
1840   ev_io_start (EV_A_ &w->io);
1841
1842   ev_start (EV_A_ (W)w, 1);
1843 }
1844
1845 void
1846 ev_embed_stop (EV_P_ ev_embed *w)
1847 {
1848   ev_clear_pending (EV_A_ (W)w);
1849   if (expect_false (!ev_is_active (w)))
1850     return;
1851
1852   ev_io_stop (EV_A_ &w->io);
1853
1854   ev_stop (EV_A_ (W)w);
1855 }
1856 #endif
1857
1858 #if EV_FORK_ENABLE
1859 void
1860 ev_fork_start (EV_P_ ev_fork *w)
1861 {
1862   if (expect_false (ev_is_active (w)))
1863     return;
1864
1865   ev_start (EV_A_ (W)w, ++forkcnt);
1866   array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
1867   forks [forkcnt - 1] = w;
1868 }
1869
1870 void
1871 ev_fork_stop (EV_P_ ev_fork *w)
1872 {
1873   ev_clear_pending (EV_A_ (W)w);
1874   if (expect_false (!ev_is_active (w)))
1875     return;
1876
1877   {
1878     int active = ((W)w)->active;
1879     forks [active - 1] = forks [--forkcnt];
1880     ((W)forks [active - 1])->active = active;
1881   }
1882
1883   ev_stop (EV_A_ (W)w);
1884 }
1885 #endif
1886
1887 /*****************************************************************************/
1888
1889 struct ev_once
1890 {
1891   ev_io io;
1892   ev_timer to;
1893   void (*cb)(int revents, void *arg);
1894   void *arg;
1895 };
1896
1897 static void
1898 once_cb (EV_P_ struct ev_once *once, int revents)
1899 {
1900   void (*cb)(int revents, void *arg) = once->cb;
1901   void *arg = once->arg;
1902
1903   ev_io_stop (EV_A_ &once->io);
1904   ev_timer_stop (EV_A_ &once->to);
1905   ev_free (once);
1906
1907   cb (revents, arg);
1908 }
1909
1910 static void
1911 once_cb_io (EV_P_ ev_io *w, int revents)
1912 {
1913   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1914 }
1915
1916 static void
1917 once_cb_to (EV_P_ ev_timer *w, int revents)
1918 {
1919   once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1920 }
1921
1922 void
1923 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1924 {
1925   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
1926
1927   if (expect_false (!once))
1928     {
1929       cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1930       return;
1931     }
1932
1933   once->cb  = cb;
1934   once->arg = arg;
1935
1936   ev_init (&once->io, once_cb_io);
1937   if (fd >= 0)
1938     {
1939       ev_io_set (&once->io, fd, events);
1940       ev_io_start (EV_A_ &once->io);
1941     }
1942
1943   ev_init (&once->to, once_cb_to);
1944   if (timeout >= 0.)
1945     {
1946       ev_timer_set (&once->to, timeout, 0.);
1947       ev_timer_start (EV_A_ &once->to);
1948     }
1949 }
1950
1951 #ifdef __cplusplus
1952 }
1953 #endif
1954