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