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