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