ev.c

   1 /*
   2  * libev event processing core, watcher management
   3  *
   4  * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without modifica-
   8  * tion, are permitted provided that the following conditions are met:
   9  *
  10  *   1.  Redistributions of source code must retain the above copyright notice,
  11  *       this list of conditions and the following disclaimer.
  12  *
  13  *   2.  Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in the
  15  *       documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
  19  * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
  20  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
  21  * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
  25  * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  26  * OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * the GNU General Public License ("GPL") version 2 or any later version,
  30  * in which case the provisions of the GPL are applicable instead of
  31  * the above. If you wish to allow the use of your version of this file
  32  * only under the terms of the GPL and not to allow others to use your
  33  * version of this file under the BSD license, indicate your decision
  34  * by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL. If you do not delete the
  36  * provisions above, a recipient may use your version of this file under
  37  * either the BSD or the GPL.
  38  */
  39
  40 /* this big block deduces configuration from config.h */
  41 #ifndef EV_STANDALONE
  42 # ifdef EV_CONFIG_H
  43 #  include EV_CONFIG_H
  44 # else
  45 #  include "config.h"
  46 # endif
  47
  48 #if HAVE_FLOOR
  49 # ifndef EV_USE_FLOOR
  50 #  define EV_USE_FLOOR 1
  51 # endif
  52 #endif
  53
  54 # if HAVE_CLOCK_SYSCALL
  55 #  ifndef EV_USE_CLOCK_SYSCALL
  56 #   define EV_USE_CLOCK_SYSCALL 1
  57 #   ifndef EV_USE_REALTIME
  58 #    define EV_USE_REALTIME  0
  59 #   endif
  60 #   ifndef EV_USE_MONOTONIC
  61 #    define EV_USE_MONOTONIC 1
  62 #   endif
  63 #  endif
  64 # elif !defined EV_USE_CLOCK_SYSCALL
  65 #  define EV_USE_CLOCK_SYSCALL 0
  66 # endif
  67
  68 # if HAVE_CLOCK_GETTIME
  69 #  ifndef EV_USE_MONOTONIC
  70 #   define EV_USE_MONOTONIC 1
  71 #  endif
  72 #  ifndef EV_USE_REALTIME
  73 #   define EV_USE_REALTIME  0
  74 #  endif
  75 # else
  76 #  ifndef EV_USE_MONOTONIC
  77 #   define EV_USE_MONOTONIC 0
  78 #  endif
  79 #  ifndef EV_USE_REALTIME
  80 #   define EV_USE_REALTIME  0
  81 #  endif
  82 # endif
  83
  84 # if HAVE_NANOSLEEP
  85 #  ifndef EV_USE_NANOSLEEP
  86 #    define EV_USE_NANOSLEEP EV_FEATURE_OS
  87 #  endif
  88 # else
  89 #   undef EV_USE_NANOSLEEP
  90 #   define EV_USE_NANOSLEEP 0
  91 # endif
  92
  93 # if HAVE_SELECT && HAVE_SYS_SELECT_H
  94 #  ifndef EV_USE_SELECT
  95 #   define EV_USE_SELECT EV_FEATURE_BACKENDS
  96 #  endif
  97 # else
  98 #  undef EV_USE_SELECT
  99 #  define EV_USE_SELECT 0
 100 # endif
 101
 102 # if HAVE_POLL && HAVE_POLL_H
 103 #  ifndef EV_USE_POLL
 104 #   define EV_USE_POLL EV_FEATURE_BACKENDS
 105 #  endif
 106 # else
 107 #  undef EV_USE_POLL
 108 #  define EV_USE_POLL 0
 109 # endif
 110
 111 # if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
 112 #  ifndef EV_USE_EPOLL
 113 #   define EV_USE_EPOLL EV_FEATURE_BACKENDS
 114 #  endif
 115 # else
 116 #  undef EV_USE_EPOLL
 117 #  define EV_USE_EPOLL 0
 118 # endif
 119
 120 # if HAVE_KQUEUE && HAVE_SYS_EVENT_H
 121 #  ifndef EV_USE_KQUEUE
 122 #   define EV_USE_KQUEUE EV_FEATURE_BACKENDS
 123 #  endif
 124 # else
 125 #  undef EV_USE_KQUEUE
 126 #  define EV_USE_KQUEUE 0
 127 # endif
 128
 129 # if HAVE_PORT_H && HAVE_PORT_CREATE
 130 #  ifndef EV_USE_PORT
 131 #   define EV_USE_PORT EV_FEATURE_BACKENDS
 132 #  endif
 133 # else
 134 #  undef EV_USE_PORT
 135 #  define EV_USE_PORT 0
 136 # endif
 137
 138 # if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
 139 #  ifndef EV_USE_INOTIFY
 140 #   define EV_USE_INOTIFY EV_FEATURE_OS
 141 #  endif
 142 # else
 143 #  undef EV_USE_INOTIFY
 144 #  define EV_USE_INOTIFY 0
 145 # endif
 146
 147 # if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
 148 #  ifndef EV_USE_SIGNALFD
 149 #   define EV_USE_SIGNALFD EV_FEATURE_OS
 150 #  endif
 151 # else
 152 #  undef EV_USE_SIGNALFD
 153 #  define EV_USE_SIGNALFD 0
 154 # endif
 155
 156 # if HAVE_EVENTFD
 157 #  ifndef EV_USE_EVENTFD
 158 #   define EV_USE_EVENTFD EV_FEATURE_OS
 159 #  endif
 160 # else
 161 #  undef EV_USE_EVENTFD
 162 #  define EV_USE_EVENTFD 0
 163 # endif
 164
 165 #endif
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <fcntl.h>
 170 #include <stddef.h>
 171
 172 #include <stdio.h>
 173
 174 #include <assert.h>
 175 #include <errno.h>
 176 #include <sys/types.h>
 177 #include <time.h>
 178 #include <limits.h>
 179
 180 #include <signal.h>
 181
 182 #ifdef EV_H
 183 # include EV_H
 184 #else
 185 # include "ev.h"
 186 #endif
 187
 188 #if EV_NO_THREADS
 189 # undef EV_NO_SMP
 190 # define EV_NO_SMP 1
 191 # undef ECB_NO_THREADS
 192 # define ECB_NO_THREADS 1
 193 #endif
 194 #if EV_NO_SMP
 195 # undef EV_NO_SMP
 196 # define ECB_NO_SMP 1
 197 #endif
 198
 199 #ifndef _WIN32
 200 # include <sys/time.h>
 201 # include <sys/wait.h>
 202 # include <unistd.h>
 203 #else
 204 # include <io.h>
 205 # define WIN32_LEAN_AND_MEAN
 206 # include <winsock2.h>
 207 # include <windows.h>
 208 # ifndef EV_SELECT_IS_WINSOCKET
 209 #  define EV_SELECT_IS_WINSOCKET 1
 210 # endif
 211 # undef EV_AVOID_STDIO
 212 #endif
 213
 214 /* OS X, in its infinite idiocy, actually HARDCODES
 215  * a limit of 1024 into their select. Where people have brains,
 216  * OS X engineers apparently have a vacuum. Or maybe they were
 217  * ordered to have a vacuum, or they do anything for money.
 218  * This might help. Or not.
 219  */
 220 #define _DARWIN_UNLIMITED_SELECT 1
 221
 222 /* this block tries to deduce configuration from header-defined symbols and defaults */
 223
 224 /* try to deduce the maximum number of signals on this platform */
 225 #if defined EV_NSIG
 226 /* use what's provided */
 227 #elif defined NSIG
 228 # define EV_NSIG (NSIG)
 229 #elif defined _NSIG
 230 # define EV_NSIG (_NSIG)
 231 #elif defined SIGMAX
 232 # define EV_NSIG (SIGMAX+1)
 233 #elif defined SIG_MAX
 234 # define EV_NSIG (SIG_MAX+1)
 235 #elif defined _SIG_MAX
 236 # define EV_NSIG (_SIG_MAX+1)
 237 #elif defined MAXSIG
 238 # define EV_NSIG (MAXSIG+1)
 239 #elif defined MAX_SIG
 240 # define EV_NSIG (MAX_SIG+1)
 241 #elif defined SIGARRAYSIZE
 242 # define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
 243 #elif defined _sys_nsig
 244 # define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
 245 #else
 246 # error "unable to find value for NSIG, please report"
 247 /* to make it compile regardless, just remove the above line, */
 248 /* but consider reporting it, too! :) */
 249 # define EV_NSIG 65
 250 #endif
 251
 252 #ifndef EV_USE_FLOOR
 253 # define EV_USE_FLOOR 0
 254 #endif
 255
 256 #ifndef EV_USE_CLOCK_SYSCALL
 257 # if __linux && __GLIBC__ >= 2
 258 #  define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
 259 # else
 260 #  define EV_USE_CLOCK_SYSCALL 0
 261 # endif
 262 #endif
 263
 264 #ifndef EV_USE_MONOTONIC
 265 # if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
 266 #  define EV_USE_MONOTONIC EV_FEATURE_OS
 267 # else
 268 #  define EV_USE_MONOTONIC 0
 269 # endif
 270 #endif
 271
 272 #ifndef EV_USE_REALTIME
 273 # define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL
 274 #endif
 275
 276 #ifndef EV_USE_NANOSLEEP
 277 # if _POSIX_C_SOURCE >= 199309L
 278 #  define EV_USE_NANOSLEEP EV_FEATURE_OS
 279 # else
 280 #  define EV_USE_NANOSLEEP 0
 281 # endif
 282 #endif
 283
 284 #ifndef EV_USE_SELECT
 285 # define EV_USE_SELECT EV_FEATURE_BACKENDS
 286 #endif
 287
 288 #ifndef EV_USE_POLL
 289 # ifdef _WIN32
 290 #  define EV_USE_POLL 0
 291 # else
 292 #  define EV_USE_POLL EV_FEATURE_BACKENDS
 293 # endif
 294 #endif
 295
 296 #ifndef EV_USE_EPOLL
 297 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
 298 #  define EV_USE_EPOLL EV_FEATURE_BACKENDS
 299 # else
 300 #  define EV_USE_EPOLL 0
 301 # endif
 302 #endif
 303
 304 #ifndef EV_USE_KQUEUE
 305 # define EV_USE_KQUEUE 0
 306 #endif
 307
 308 #ifndef EV_USE_PORT
 309 # define EV_USE_PORT 0
 310 #endif
 311
 312 #ifndef EV_USE_INOTIFY
 313 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
 314 #  define EV_USE_INOTIFY EV_FEATURE_OS
 315 # else
 316 #  define EV_USE_INOTIFY 0
 317 # endif
 318 #endif
 319
 320 #ifndef EV_PID_HASHSIZE
 321 # define EV_PID_HASHSIZE EV_FEATURE_DATA ? 16 : 1
 322 #endif
 323
 324 #ifndef EV_INOTIFY_HASHSIZE
 325 # define EV_INOTIFY_HASHSIZE EV_FEATURE_DATA ? 16 : 1
 326 #endif
 327
 328 #ifndef EV_USE_EVENTFD
 329 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
 330 #  define EV_USE_EVENTFD EV_FEATURE_OS
 331 # else
 332 #  define EV_USE_EVENTFD 0
 333 # endif
 334 #endif
 335
 336 #ifndef EV_USE_SIGNALFD
 337 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
 338 #  define EV_USE_SIGNALFD EV_FEATURE_OS
 339 # else
 340 #  define EV_USE_SIGNALFD 0
 341 # endif
 342 #endif
 343
 344 #if 0 /* debugging */
 345 # define EV_VERIFY 3
 346 # define EV_USE_4HEAP 1
 347 # define EV_HEAP_CACHE_AT 1
 348 #endif
 349
 350 #ifndef EV_VERIFY
 351 # define EV_VERIFY (EV_FEATURE_API ? 1 : 0)
 352 #endif
 353
 354 #ifndef EV_USE_4HEAP
 355 # define EV_USE_4HEAP EV_FEATURE_DATA
 356 #endif
 357
 358 #ifndef EV_HEAP_CACHE_AT
 359 # define EV_HEAP_CACHE_AT EV_FEATURE_DATA
 360 #endif
 361
 362 /* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
 363 /* which makes programs even slower. might work on other unices, too. */
 364 #if EV_USE_CLOCK_SYSCALL
 365 # include <sys/syscall.h>
 366 # ifdef SYS_clock_gettime
 367 #  define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
 368 #  undef EV_USE_MONOTONIC
 369 #  define EV_USE_MONOTONIC 1
 370 # else
 371 #  undef EV_USE_CLOCK_SYSCALL
 372 #  define EV_USE_CLOCK_SYSCALL 0
 373 # endif
 374 #endif
 375
 376 /* this block fixes any misconfiguration where we know we run into trouble otherwise */
 377
 378 #ifdef _AIX
 379 /* AIX has a completely broken poll.h header */
 380 # undef EV_USE_POLL
 381 # define EV_USE_POLL 0
 382 #endif
 383
 384 #ifndef CLOCK_MONOTONIC
 385 # undef EV_USE_MONOTONIC
 386 # define EV_USE_MONOTONIC 0
 387 #endif
 388
 389 #ifndef CLOCK_REALTIME
 390 # undef EV_USE_REALTIME
 391 # define EV_USE_REALTIME 0
 392 #endif
 393
 394 #if !EV_STAT_ENABLE
 395 # undef EV_USE_INOTIFY
 396 # define EV_USE_INOTIFY 0
 397 #endif
 398
 399 #if !EV_USE_NANOSLEEP
 400 /* hp-ux has it in sys/time.h, which we unconditionally include above */
 401 # if !defined _WIN32 && !defined __hpux
 402 #  include <sys/select.h>
 403 # endif
 404 #endif
 405
 406 #if EV_USE_INOTIFY
 407 # include <sys/statfs.h>
 408 # include <sys/inotify.h>
 409 /* some very old inotify.h headers don't have IN_DONT_FOLLOW */
 410 # ifndef IN_DONT_FOLLOW
 411 #  undef EV_USE_INOTIFY
 412 #  define EV_USE_INOTIFY 0
 413 # endif
 414 #endif
 415
 416 #if EV_USE_EVENTFD
 417 /* our minimum requirement is glibc 2.7 which has the stub, but not the header */
 418 # include <stdint.h>
 419 # ifndef EFD_NONBLOCK
 420 #  define EFD_NONBLOCK O_NONBLOCK
 421 # endif
 422 # ifndef EFD_CLOEXEC
 423 #  ifdef O_CLOEXEC
 424 #   define EFD_CLOEXEC O_CLOEXEC
 425 #  else
 426 #   define EFD_CLOEXEC 02000000
 427 #  endif
 428 # endif
 429 EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
 430 #endif
 431
 432 #if EV_USE_SIGNALFD
 433 /* our minimum requirement is glibc 2.7 which has the stub, but not the header */
 434 # include <stdint.h>
 435 # ifndef SFD_NONBLOCK
 436 #  define SFD_NONBLOCK O_NONBLOCK
 437 # endif
 438 # ifndef SFD_CLOEXEC
 439 #  ifdef O_CLOEXEC
 440 #   define SFD_CLOEXEC O_CLOEXEC
 441 #  else
 442 #   define SFD_CLOEXEC 02000000
 443 #  endif
 444 # endif
 445 EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);
 446
 447 struct signalfd_siginfo
 448 {
 449   uint32_t ssi_signo;
 450   char pad[128 - sizeof (uint32_t)];
 451 };
 452 #endif
 453
 454 /**/
 455
 456 #if EV_VERIFY >= 3
 457 # define EV_FREQUENT_CHECK ev_verify (EV_A)
 458 #else
 459 # define EV_FREQUENT_CHECK do { } while (0)
 460 #endif
 461
 462 /*
 463  * This is used to work around floating point rounding problems.
 464  * This value is good at least till the year 4000.
 465  */
 466 #define MIN_INTERVAL  0.0001220703125 /* 1/2**13, good till 4000 */
 467 /*#define MIN_INTERVAL  0.00000095367431640625 /* 1/2**20, good till 2200 */
 468
 469 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 470 #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
 471
 472 #define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
 473 #define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
 474
 475 /* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
 476 /* ECB.H BEGIN */
 477 /*
 478  * libecb - http://software.schmorp.de/pkg/libecb
 479  *
 480  * Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>
 481  * Copyright (©) 2011 Emanuele Giaquinta
 482  * All rights reserved.
 483  *
 484  * Redistribution and use in source and binary forms, with or without modifica-
 485  * tion, are permitted provided that the following conditions are met:
 486  *
 487  *   1.  Redistributions of source code must retain the above copyright notice,
 488  *       this list of conditions and the following disclaimer.
 489  *
 490  *   2.  Redistributions in binary form must reproduce the above copyright
 491  *       notice, this list of conditions and the following disclaimer in the
 492  *       documentation and/or other materials provided with the distribution.
 493  *
 494  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 495  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
 496  * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
 497  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
 498  * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 499  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 500  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 501  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
 502  * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 503  * OF THE POSSIBILITY OF SUCH DAMAGE.
 504  */
 505
 506 #ifndef ECB_H
 507 #define ECB_H
 508
 509 /* 16 bits major, 16 bits minor */
 510 #define ECB_VERSION 0x00010002
 511
 512 #ifdef _WIN32
 513   typedef   signed char   int8_t;
 514   typedef unsigned char  uint8_t;
 515   typedef   signed short  int16_t;
 516   typedef unsigned short uint16_t;
 517   typedef   signed int    int32_t;
 518   typedef unsigned int   uint32_t;
 519   #if __GNUC__
 520     typedef   signed long long int64_t;
 521     typedef unsigned long long uint64_t;
 522   #else /* _MSC_VER || __BORLANDC__ */
 523     typedef   signed __int64   int64_t;
 524     typedef unsigned __int64   uint64_t;
 525   #endif
 526   #ifdef _WIN64
 527     #define ECB_PTRSIZE 8
 528     typedef uint64_t uintptr_t;
 529     typedef  int64_t  intptr_t;
 530   #else
 531     #define ECB_PTRSIZE 4
 532     typedef uint32_t uintptr_t;
 533     typedef  int32_t  intptr_t;
 534   #endif
 535 #else
 536   #include <inttypes.h>
 537   #if UINTMAX_MAX > 0xffffffffU
 538     #define ECB_PTRSIZE 8
 539   #else
 540     #define ECB_PTRSIZE 4
 541   #endif
 542 #endif
 543
 544 /* many compilers define _GNUC_ to some versions but then only implement
 545  * what their idiot authors think are the "more important" extensions,
 546  * causing enormous grief in return for some better fake benchmark numbers.
 547  * or so.
 548  * we try to detect these and simply assume they are not gcc - if they have
 549  * an issue with that they should have done it right in the first place.
 550  */
 551 #ifndef ECB_GCC_VERSION
 552   #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
 553     #define ECB_GCC_VERSION(major,minor) 0
 554   #else
 555     #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
 556   #endif
 557 #endif
 558
 559 #define ECB_C     (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */
 560 #define ECB_C99   (__STDC_VERSION__ >= 199901L)
 561 #define ECB_C11   (__STDC_VERSION__ >= 201112L)
 562 #define ECB_CPP   (__cplusplus+0)
 563 #define ECB_CPP11 (__cplusplus >= 201103L)
 564
 565 #if ECB_CPP
 566   #define ECB_EXTERN_C extern "C"
 567   #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
 568   #define ECB_EXTERN_C_END }
 569 #else
 570   #define ECB_EXTERN_C extern
 571   #define ECB_EXTERN_C_BEG
 572   #define ECB_EXTERN_C_END
 573 #endif
 574
 575 /*****************************************************************************/
 576
 577 /* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
 578 /* ECB_NO_SMP     - ecb might be used in multiple threads, but only on a single cpu */
 579
 580 #if ECB_NO_THREADS
 581   #define ECB_NO_SMP 1
 582 #endif
 583
 584 #if ECB_NO_SMP
 585   #define ECB_MEMORY_FENCE do { } while (0)
 586 #endif
 587
 588 #ifndef ECB_MEMORY_FENCE
 589   #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
 590     #if __i386 || __i386__
 591       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
 592       #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ (""                        : : : "memory")
 593       #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
 594     #elif __amd64 || __amd64__ || __x86_64 || __x86_64__
 595       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("mfence"   : : : "memory")
 596       #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ (""         : : : "memory")
 597       #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
 598     #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
 599       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("sync"     : : : "memory")
 600     #elif defined __ARM_ARCH_6__  || defined __ARM_ARCH_6J__  \
 601        || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
 602       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
 603     #elif defined __ARM_ARCH_7__  || defined __ARM_ARCH_7A__  \
 604        || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
 605       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("dmb"      : : : "memory")
 606     #elif __sparc || __sparc__
 607       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
 608       #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad"                            : : : "memory")
 609       #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore             | #StoreStore")
 610     #elif defined __s390__ || defined __s390x__
 611       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("bcr 15,0" : : : "memory")
 612     #elif defined __mips__
 613       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("sync"     : : : "memory")
 614     #elif defined __alpha__
 615       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("mb"       : : : "memory")
 616     #elif defined __hppa__
 617       #define ECB_MEMORY_FENCE         __asm__ __volatile__ (""         : : : "memory")
 618       #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
 619     #elif defined __ia64__
 620       #define ECB_MEMORY_FENCE         __asm__ __volatile__ ("mf"       : : : "memory")
 621     #endif
 622   #endif
 623 #endif
 624
 625 #ifndef ECB_MEMORY_FENCE
 626   #if ECB_GCC_VERSION(4,7)
 627     /* see comment below (stdatomic.h) about the C11 memory model. */
 628     #define ECB_MEMORY_FENCE         __atomic_thread_fence (__ATOMIC_SEQ_CST)
 629
 630   /* The __has_feature syntax from clang is so misdesigned that we cannot use it
 631    * without risking compile time errors with other compilers. We *could*
 632    * define our own ecb_clang_has_feature, but I just can't be bothered to work
 633    * around this shit time and again.
 634    * #elif defined __clang && __has_feature (cxx_atomic)
 635    *   // see comment below (stdatomic.h) about the C11 memory model.
 636    *   #define ECB_MEMORY_FENCE         __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
 637    */
 638
 639   #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
 640     #define ECB_MEMORY_FENCE         __sync_synchronize ()
 641   #elif _MSC_VER >= 1400 /* VC++ 2005 */
 642     #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
 643     #define ECB_MEMORY_FENCE         _ReadWriteBarrier ()
 644     #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
 645     #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
 646   #elif defined _WIN32
 647     #include <WinNT.h>
 648     #define ECB_MEMORY_FENCE         MemoryBarrier () /* actually just xchg on x86... scary */
 649   #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
 650     #include <mbarrier.h>
 651     #define ECB_MEMORY_FENCE         __machine_rw_barrier ()
 652     #define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier  ()
 653     #define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier  ()
 654   #elif __xlC__
 655     #define ECB_MEMORY_FENCE         __sync ()
 656   #endif
 657 #endif
 658
 659 #ifndef ECB_MEMORY_FENCE
 660   #if ECB_C11 && !defined __STDC_NO_ATOMICS__
 661     /* we assume that these memory fences work on all variables/all memory accesses, */
 662     /* not just C11 atomics and atomic accesses */
 663     #include <stdatomic.h>
 664     /* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
 665     /* any fence other than seq_cst, which isn't very efficient for us. */
 666     /* Why that is, we don't know - either the C11 memory model is quite useless */
 667     /* for most usages, or gcc and clang have a bug */
 668     /* I *currently* lean towards the latter, and inefficiently implement */
 669     /* all three of ecb's fences as a seq_cst fence */
 670     #define ECB_MEMORY_FENCE         atomic_thread_fence (memory_order_seq_cst)
 671   #endif
 672 #endif
 673
 674 #ifndef ECB_MEMORY_FENCE
 675   #if !ECB_AVOID_PTHREADS
 676     /*
 677      * if you get undefined symbol references to pthread_mutex_lock,
 678      * or failure to find pthread.h, then you should implement
 679      * the ECB_MEMORY_FENCE operations for your cpu/compiler
 680      * OR provide pthread.h and link against the posix thread library
 681      * of your system.
 682      */
 683     #include <pthread.h>
 684     #define ECB_NEEDS_PTHREADS 1
 685     #define ECB_MEMORY_FENCE_NEEDS_PTHREADS 1
 686
 687     static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
 688     #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
 689   #endif
 690 #endif
 691
 692 #if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
 693   #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
 694 #endif
 695
 696 #if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
 697   #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
 698 #endif
 699
 700 /*****************************************************************************/
 701
 702 #if __cplusplus
 703   #define ecb_inline static inline
 704 #elif ECB_GCC_VERSION(2,5)
 705   #define ecb_inline static __inline__
 706 #elif ECB_C99
 707   #define ecb_inline static inline
 708 #else
 709   #define ecb_inline static
 710 #endif
 711
 712 #if ECB_GCC_VERSION(3,3)
 713   #define ecb_restrict __restrict__
 714 #elif ECB_C99
 715   #define ecb_restrict restrict
 716 #else
 717   #define ecb_restrict
 718 #endif
 719
 720 typedef int ecb_bool;
 721
 722 #define ECB_CONCAT_(a, b) a ## b
 723 #define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
 724 #define ECB_STRINGIFY_(a) # a
 725 #define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
 726
 727 #define ecb_function_ ecb_inline
 728
 729 #if ECB_GCC_VERSION(3,1)
 730   #define ecb_attribute(attrlist)        __attribute__(attrlist)
 731   #define ecb_is_constant(expr)          __builtin_constant_p (expr)
 732   #define ecb_expect(expr,value)         __builtin_expect ((expr),(value))
 733   #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
 734 #else
 735   #define ecb_attribute(attrlist)
 736   #define ecb_is_constant(expr)          0
 737   #define ecb_expect(expr,value)         (expr)
 738   #define ecb_prefetch(addr,rw,locality)
 739 #endif
 740
 741 /* no emulation for ecb_decltype */
 742 #if ECB_GCC_VERSION(4,5)
 743   #define ecb_decltype(x) __decltype(x)
 744 #elif ECB_GCC_VERSION(3,0)
 745   #define ecb_decltype(x) __typeof(x)
 746 #endif
 747
 748 #define ecb_noinline   ecb_attribute ((__noinline__))
 749 #define ecb_unused     ecb_attribute ((__unused__))
 750 #define ecb_const      ecb_attribute ((__const__))
 751 #define ecb_pure       ecb_attribute ((__pure__))
 752
 753 #if ECB_C11
 754   #define ecb_noreturn   _Noreturn
 755 #else
 756   #define ecb_noreturn   ecb_attribute ((__noreturn__))
 757 #endif
 758
 759 #if ECB_GCC_VERSION(4,3)
 760   #define ecb_artificial ecb_attribute ((__artificial__))
 761   #define ecb_hot        ecb_attribute ((__hot__))
 762   #define ecb_cold       ecb_attribute ((__cold__))
 763 #else
 764   #define ecb_artificial
 765   #define ecb_hot
 766   #define ecb_cold
 767 #endif
 768
 769 /* put around conditional expressions if you are very sure that the  */
 770 /* expression is mostly true or mostly false. note that these return */
 771 /* booleans, not the expression.                                     */
 772 #define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
 773 #define ecb_expect_true(expr)  ecb_expect (!!(expr), 1)
 774 /* for compatibility to the rest of the world */
 775 #define ecb_likely(expr)   ecb_expect_true  (expr)
 776 #define ecb_unlikely(expr) ecb_expect_false (expr)
 777
 778 /* count trailing zero bits and count # of one bits */
 779 #if ECB_GCC_VERSION(3,4)
 780   /* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
 781   #define ecb_ld32(x)      (__builtin_clz      (x) ^ 31)
 782   #define ecb_ld64(x)      (__builtin_clzll    (x) ^ 63)
 783   #define ecb_ctz32(x)      __builtin_ctz      (x)
 784   #define ecb_ctz64(x)      __builtin_ctzll    (x)
 785   #define ecb_popcount32(x) __builtin_popcount (x)
 786   /* no popcountll */
 787 #else
 788   ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;
 789   ecb_function_ int
 790   ecb_ctz32 (uint32_t x)
 791   {
 792     int r = 0;
 793
 794     x &= ~x + 1; /* this isolates the lowest bit */
 795
 796 #if ECB_branchless_on_i386
 797     r += !!(x & 0xaaaaaaaa) << 0;
 798     r += !!(x & 0xcccccccc) << 1;
 799     r += !!(x & 0xf0f0f0f0) << 2;
 800     r += !!(x & 0xff00ff00) << 3;
 801     r += !!(x & 0xffff0000) << 4;
 802 #else
 803     if (x & 0xaaaaaaaa) r +=  1;
 804     if (x & 0xcccccccc) r +=  2;
 805     if (x & 0xf0f0f0f0) r +=  4;
 806     if (x & 0xff00ff00) r +=  8;
 807     if (x & 0xffff0000) r += 16;
 808 #endif
 809
 810     return r;
 811   }
 812
 813   ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;
 814   ecb_function_ int
 815   ecb_ctz64 (uint64_t x)
 816   {
 817     int shift = x & 0xffffffffU ? 0 : 32;
 818     return ecb_ctz32 (x >> shift) + shift;
 819   }
 820
 821   ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;
 822   ecb_function_ int
 823   ecb_popcount32 (uint32_t x)
 824   {
 825     x -=  (x >> 1) & 0x55555555;
 826     x  = ((x >> 2) & 0x33333333) + (x & 0x33333333);
 827     x  = ((x >> 4) + x) & 0x0f0f0f0f;
 828     x *= 0x01010101;
 829
 830     return x >> 24;
 831   }
 832
 833   ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;
 834   ecb_function_ int ecb_ld32 (uint32_t x)
 835   {
 836     int r = 0;
 837
 838     if (x >> 16) { x >>= 16; r += 16; }
 839     if (x >>  8) { x >>=  8; r +=  8; }
 840     if (x >>  4) { x >>=  4; r +=  4; }
 841     if (x >>  2) { x >>=  2; r +=  2; }
 842     if (x >>  1) {           r +=  1; }
 843
 844     return r;
 845   }
 846
 847   ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;
 848   ecb_function_ int ecb_ld64 (uint64_t x)
 849   {
 850     int r = 0;
 851
 852     if (x >> 32) { x >>= 32; r += 32; }
 853
 854     return r + ecb_ld32 (x);
 855   }
 856 #endif
 857
 858 ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) ecb_const;
 859 ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
 860 ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) ecb_const;
 861 ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
 862
 863 ecb_function_ uint8_t  ecb_bitrev8  (uint8_t  x) ecb_const;
 864 ecb_function_ uint8_t  ecb_bitrev8  (uint8_t  x)
 865 {
 866   return (  (x * 0x0802U & 0x22110U)
 867           | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
 868 }
 869
 870 ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;
 871 ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
 872 {
 873   x = ((x >>  1) &     0x5555) | ((x &     0x5555) <<  1);
 874   x = ((x >>  2) &     0x3333) | ((x &     0x3333) <<  2);
 875   x = ((x >>  4) &     0x0f0f) | ((x &     0x0f0f) <<  4);
 876   x = ( x >>  8              ) | ( x               <<  8);
 877
 878   return x;
 879 }
 880
 881 ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;
 882 ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
 883 {
 884   x = ((x >>  1) & 0x55555555) | ((x & 0x55555555) <<  1);
 885   x = ((x >>  2) & 0x33333333) | ((x & 0x33333333) <<  2);
 886   x = ((x >>  4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) <<  4);
 887   x = ((x >>  8) & 0x00ff00ff) | ((x & 0x00ff00ff) <<  8);
 888   x = ( x >> 16              ) | ( x               << 16);
 889
 890   return x;
 891 }
 892
 893 /* popcount64 is only available on 64 bit cpus as gcc builtin */
 894 /* so for this version we are lazy */
 895 ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
 896 ecb_function_ int
 897 ecb_popcount64 (uint64_t x)
 898 {
 899   return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
 900 }
 901
 902 ecb_inline uint8_t  ecb_rotl8  (uint8_t  x, unsigned int count) ecb_const;
 903 ecb_inline uint8_t  ecb_rotr8  (uint8_t  x, unsigned int count) ecb_const;
 904 ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;
 905 ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;
 906 ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;
 907 ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;
 908 ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;
 909 ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;
 910
 911 ecb_inline uint8_t  ecb_rotl8  (uint8_t  x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
 912 ecb_inline uint8_t  ecb_rotr8  (uint8_t  x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
 913 ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
 914 ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
 915 ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
 916 ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
 917 ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
 918 ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
 919
 920 #if ECB_GCC_VERSION(4,3)
 921   #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
 922   #define ecb_bswap32(x)  __builtin_bswap32 (x)
 923   #define ecb_bswap64(x)  __builtin_bswap64 (x)
 924 #else
 925   ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;
 926   ecb_function_ uint16_t
 927   ecb_bswap16 (uint16_t x)
 928   {
 929     return ecb_rotl16 (x, 8);
 930   }
 931
 932   ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;
 933   ecb_function_ uint32_t
 934   ecb_bswap32 (uint32_t x)
 935   {
 936     return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
 937   }
 938
 939   ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;
 940   ecb_function_ uint64_t
 941   ecb_bswap64 (uint64_t x)
 942   {
 943     return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
 944   }
 945 #endif
 946
 947 #if ECB_GCC_VERSION(4,5)
 948   #define ecb_unreachable() __builtin_unreachable ()
 949 #else
 950   /* this seems to work fine, but gcc always emits a warning for it :/ */
 951   ecb_inline void ecb_unreachable (void) ecb_noreturn;
 952   ecb_inline void ecb_unreachable (void) { }
 953 #endif
 954
 955 /* try to tell the compiler that some condition is definitely true */
 956 #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
 957
 958 ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
 959 ecb_inline unsigned char
 960 ecb_byteorder_helper (void)
 961 {
 962   /* the union code still generates code under pressure in gcc, */
 963   /* but less than using pointers, and always seems to */
 964   /* successfully return a constant. */
 965   /* the reason why we have this horrible preprocessor mess */
 966   /* is to avoid it in all cases, at least on common architectures */
 967   /* or when using a recent enough gcc version (>= 4.6) */
 968 #if __i386 || __i386__ || _M_X86 || __amd64 || __amd64__ || _M_X64
 969   return 0x44;
 970 #elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 971   return 0x44;
 972 #elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 973   return 0x11;
 974 #else
 975   union
 976   {
 977     uint32_t i;
 978     uint8_t c;
 979   } u = { 0x11223344 };
 980   return u.c;
 981 #endif
 982 }
 983
 984 ecb_inline ecb_bool ecb_big_endian    (void) ecb_const;
 985 ecb_inline ecb_bool ecb_big_endian    (void) { return ecb_byteorder_helper () == 0x11; }
 986 ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
 987 ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
 988
 989 #if ECB_GCC_VERSION(3,0) || ECB_C99
 990   #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
 991 #else
 992   #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
 993 #endif
 994
 995 #if __cplusplus
 996   template<typename T>
 997   static inline T ecb_div_rd (T val, T div)
 998   {
 999     return val < 0 ? - ((-val + div - 1) / div) : (val          ) / div;
1000   }
1001   template<typename T>
1002   static inline T ecb_div_ru (T val, T div)
1003   {
1004     return val < 0 ? - ((-val          ) / div) : (val + div - 1) / div;
1005   }
1006 #else
1007   #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val)            ) / (div))
1008   #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val)            ) / (div)) : ((val) + (div) - 1) / (div))
1009 #endif
1010
1011 #if ecb_cplusplus_does_not_suck
1012   /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
1013   template<typename T, int N>
1014   static inline int ecb_array_length (const T (&arr)[N])
1015   {
1016     return N;
1017   }
1018 #else
1019   #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1020 #endif
1021
1022 /*******************************************************************************/
1023 /* floating point stuff, can be disabled by defining ECB_NO_LIBM */
1024
1025 /* basically, everything uses "ieee pure-endian" floating point numbers */
1026 /* the only noteworthy exception is ancient armle, which uses order 43218765 */
1027 #if 0 \
1028     || __i386 || __i386__ \
1029     || __amd64 || __amd64__ || __x86_64 || __x86_64__ \
1030     || __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
1031     || defined __arm__ && defined __ARM_EABI__ \
1032     || defined __s390__ || defined __s390x__ \
1033     || defined __mips__ \
1034     || defined __alpha__ \
1035     || defined __hppa__ \
1036     || defined __ia64__ \
1037     || defined _M_IX86 || defined _M_AMD64 || defined _M_IA64
1038   #define ECB_STDFP 1
1039   #include <string.h> /* for memcpy */
1040 #else
1041   #define ECB_STDFP 0
1042   #include <math.h> /* for frexp*, ldexp* */
1043 #endif
1044
1045 #ifndef ECB_NO_LIBM
1046
1047   /* convert a float to ieee single/binary32 */
1048   ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
1049   ecb_function_ uint32_t
1050   ecb_float_to_binary32 (float x)
1051   {
1052     uint32_t r;
1053
1054     #if ECB_STDFP
1055       memcpy (&r, &x, 4);
1056     #else
1057       /* slow emulation, works for anything but -0 */
1058       uint32_t m;
1059       int e;
1060
1061       if (x == 0e0f                    ) return 0x00000000U;
1062       if (x > +3.40282346638528860e+38f) return 0x7f800000U;
1063       if (x < -3.40282346638528860e+38f) return 0xff800000U;
1064       if (x != x                       ) return 0x7fbfffffU;
1065
1066       m = frexpf (x, &e) * 0x1000000U;
1067
1068       r = m & 0x80000000U;
1069
1070       if (r)
1071         m = -m;
1072
1073       if (e <= -126)
1074         {
1075           m &= 0xffffffU;
1076           m >>= (-125 - e);
1077           e = -126;
1078         }
1079
1080       r |= (e + 126) << 23;
1081       r |= m & 0x7fffffU;
1082     #endif
1083
1084     return r;
1085   }
1086
1087   /* converts an ieee single/binary32 to a float */
1088   ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
1089   ecb_function_ float
1090   ecb_binary32_to_float (uint32_t x)
1091   {
1092     float r;
1093
1094     #if ECB_STDFP
1095       memcpy (&r, &x, 4);
1096     #else
1097       /* emulation, only works for normals and subnormals and +0 */
1098       int neg = x >> 31;
1099       int e = (x >> 23) & 0xffU;
1100
1101       x &= 0x7fffffU;
1102
1103       if (e)
1104         x |= 0x800000U;
1105       else
1106         e = 1;
1107
1108       /* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
1109       r = ldexpf (x * (0.5f / 0x800000U), e - 126);
1110
1111       r = neg ? -r : r;
1112     #endif
1113
1114     return r;
1115   }
1116
1117   /* convert a double to ieee double/binary64 */
1118   ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
1119   ecb_function_ uint64_t
1120   ecb_double_to_binary64 (double x)
1121   {
1122     uint64_t r;
1123
1124     #if ECB_STDFP
1125       memcpy (&r, &x, 8);
1126     #else
1127       /* slow emulation, works for anything but -0 */
1128       uint64_t m;
1129       int e;
1130
1131       if (x == 0e0                     ) return 0x0000000000000000U;
1132       if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
1133       if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
1134       if (x != x                       ) return 0X7ff7ffffffffffffU;
1135
1136       m = frexp (x, &e) * 0x20000000000000U;
1137
1138       r = m & 0x8000000000000000;;
1139
1140       if (r)
1141         m = -m;
1142
1143       if (e <= -1022)
1144         {
1145           m &= 0x1fffffffffffffU;
1146           m >>= (-1021 - e);
1147           e = -1022;
1148         }
1149
1150       r |= ((uint64_t)(e + 1022)) << 52;
1151       r |= m & 0xfffffffffffffU;
1152     #endif
1153
1154     return r;
1155   }
1156
1157   /* converts an ieee double/binary64 to a double */
1158   ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
1159   ecb_function_ double
1160   ecb_binary64_to_double (uint64_t x)
1161   {
1162     double r;
1163
1164     #if ECB_STDFP
1165       memcpy (&r, &x, 8);
1166     #else
1167       /* emulation, only works for normals and subnormals and +0 */
1168       int neg = x >> 63;
1169       int e = (x >> 52) & 0x7ffU;
1170
1171       x &= 0xfffffffffffffU;
1172
1173       if (e)
1174         x |= 0x10000000000000U;
1175       else
1176         e = 1;
1177
1178       /* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
1179       r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
1180
1181       r = neg ? -r : r;
1182     #endif
1183
1184     return r;
1185   }
1186
1187 #endif
1188
1189 #endif
1190
1191 /* ECB.H END */
1192
1193 #if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1194 /* if your architecture doesn't need memory fences, e.g. because it is
1195  * single-cpu/core, or if you use libev in a project that doesn't use libev
1196  * from multiple threads, then you can define ECB_AVOID_PTHREADS when compiling
1197  * libev, in which cases the memory fences become nops.
1198  * alternatively, you can remove this #error and link against libpthread,
1199  * which will then provide the memory fences.
1200  */
1201 # error "memory fences not defined for your architecture, please report"
1202 #endif
1203
1204 #ifndef ECB_MEMORY_FENCE
1205 # define ECB_MEMORY_FENCE do { } while (0)
1206 # define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1207 # define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1208 #endif
1209
1210 #define expect_false(cond) ecb_expect_false (cond)
1211 #define expect_true(cond)  ecb_expect_true  (cond)
1212 #define noinline           ecb_noinline
1213
1214 #define inline_size        ecb_inline
1215
1216 #if EV_FEATURE_CODE
1217 # define inline_speed      ecb_inline
1218 #else
1219 # define inline_speed      static noinline
1220 #endif
1221
1222 #define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1223
1224 #if EV_MINPRI == EV_MAXPRI
1225 # define ABSPRI(w) (((W)w), 0)
1226 #else
1227 # define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
1228 #endif
1229
1230 #define EMPTY       /* required for microsofts broken pseudo-c compiler */
1231 #define EMPTY2(a,b) /* used to suppress some warnings */
1232
1233 typedef ev_watcher *W;
1234 typedef ev_watcher_list *WL;
1235 typedef ev_watcher_time *WT;
1236
1237 #define ev_active(w) ((W)(w))->active
1238 #define ev_at(w) ((WT)(w))->at
1239
1240 #if EV_USE_REALTIME
1241 /* sig_atomic_t is used to avoid per-thread variables or locking but still */
1242 /* giving it a reasonably high chance of working on typical architectures */
1243 static EV_ATOMIC_T have_realtime; /* did clock_gettime (CLOCK_REALTIME) work? */
1244 #endif
1245
1246 #if EV_USE_MONOTONIC
1247 static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
1248 #endif
1249
1250 #ifndef EV_FD_TO_WIN32_HANDLE
1251 # define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
1252 #endif
1253 #ifndef EV_WIN32_HANDLE_TO_FD
1254 # define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
1255 #endif
1256 #ifndef EV_WIN32_CLOSE_FD
1257 # define EV_WIN32_CLOSE_FD(fd) close (fd)
1258 #endif
1259
1260 #ifdef _WIN32
1261 # include "ev_win32.c"
1262 #endif
1263
1264 /*****************************************************************************/
1265
1266 /* define a suitable floor function (only used by periodics atm) */
1267
1268 #if EV_USE_FLOOR
1269 # include <math.h>
1270 # define ev_floor(v) floor (v)
1271 #else
1272
1273 #include <float.h>
1274
1275 /* a floor() replacement function, should be independent of ev_tstamp type */
1276 static ev_tstamp noinline
1277 ev_floor (ev_tstamp v)
1278 {
1279   /* the choice of shift factor is not terribly important */
1280 #if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1281   const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1282 #else
1283   const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1284 #endif
1285
1286   /* argument too large for an unsigned long? */
1287   if (expect_false (v >= shift))
1288     {
1289       ev_tstamp f;
1290
1291       if (v == v - 1.)
1292         return v; /* very large number */
1293
1294       f = shift * ev_floor (v * (1. / shift));
1295       return f + ev_floor (v - f);
1296     }
1297
1298   /* special treatment for negative args? */
1299   if (expect_false (v < 0.))
1300     {
1301       ev_tstamp f = -ev_floor (-v);
1302
1303       return f - (f == v ? 0 : 1);
1304     }
1305
1306   /* fits into an unsigned long */
1307   return (unsigned long)v;
1308 }
1309
1310 #endif
1311
1312 /*****************************************************************************/
1313
1314 #ifdef __linux
1315 # include <sys/utsname.h>
1316 #endif
1317
1318 static unsigned int noinline ecb_cold
1319 ev_linux_version (void)
1320 {
1321 #ifdef __linux
1322   unsigned int v = 0;
1323   struct utsname buf;
1324   int i;
1325   char *p = buf.release;
1326
1327   if (uname (&buf))
1328     return 0;
1329
1330   for (i = 3+1; --i; )
1331     {
1332       unsigned int c = 0;
1333
1334       for (;;)
1335         {
1336           if (*p >= '0' && *p <= '9')
1337             c = c * 10 + *p++ - '0';
1338           else
1339             {
1340               p += *p == '.';
1341               break;
1342             }
1343         }
1344
1345       v = (v << 8) | c;
1346     }
1347
1348   return v;
1349 #else
1350   return 0;
1351 #endif
1352 }
1353
1354 /*****************************************************************************/
1355
1356 #if EV_AVOID_STDIO
1357 static void noinline ecb_cold
1358 ev_printerr (const char *msg)
1359 {
1360   write (STDERR_FILENO, msg, strlen (msg));
1361 }
1362 #endif
1363
1364 static void (*syserr_cb)(const char *msg) EV_THROW;
1365
1366 void ecb_cold
1367 ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW
1368 {
1369   syserr_cb = cb;
1370 }
1371
1372 static void noinline ecb_cold
1373 ev_syserr (const char *msg)
1374 {
1375   if (!msg)
1376     msg = "(libev) system error";
1377
1378   if (syserr_cb)
1379     syserr_cb (msg);
1380   else
1381     {
1382 #if EV_AVOID_STDIO
1383       ev_printerr (msg);
1384       ev_printerr (": ");
1385       ev_printerr (strerror (errno));
1386       ev_printerr ("\n");
1387 #else
1388       perror (msg);
1389 #endif
1390       abort ();
1391     }
1392 }
1393
1394 static void *
1395 ev_realloc_emul (void *ptr, long size) EV_THROW
1396 {
1397   /* some systems, notably openbsd and darwin, fail to properly
1398    * implement realloc (x, 0) (as required by both ansi c-89 and
1399    * the single unix specification, so work around them here.
1400    * recently, also (at least) fedora and debian started breaking it,
1401    * despite documenting it otherwise.
1402    */
1403
1404   if (size)
1405     return realloc (ptr, size);
1406
1407   free (ptr);
1408   return 0;
1409 }
1410
1411 static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1412
1413 void ecb_cold
1414 ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW
1415 {
1416   alloc = cb;
1417 }
1418
1419 inline_speed void *
1420 ev_realloc (void *ptr, long size)
1421 {
1422   ptr = alloc (ptr, size);
1423
1424   if (!ptr && size)
1425     {
1426 #if EV_AVOID_STDIO
1427       ev_printerr ("(libev) memory allocation failed, aborting.\n");
1428 #else
1429       fprintf (stderr, "(libev) cannot allocate %ld bytes, aborting.", size);
1430 #endif
1431       abort ();
1432     }
1433
1434   return ptr;
1435 }
1436
1437 #define ev_malloc(size) ev_realloc (0, (size))
1438 #define ev_free(ptr)    ev_realloc ((ptr), 0)
1439
1440 /*****************************************************************************/
1441
1442 /* set in reify when reification needed */
1443 #define EV_ANFD_REIFY 1
1444
1445 /* file descriptor info structure */
1446 typedef struct
1447 {
1448   WL head;
1449   unsigned char events; /* the events watched for */
1450   unsigned char reify;  /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
1451   unsigned char emask;  /* the epoll backend stores the actual kernel mask in here */
1452   unsigned char unused;
1453 #if EV_USE_EPOLL
1454   unsigned int egen;    /* generation counter to counter epoll bugs */
1455 #endif
1456 #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1457   SOCKET handle;
1458 #endif
1459 #if EV_USE_IOCP
1460   OVERLAPPED or, ow;
1461 #endif
1462 } ANFD;
1463
1464 /* stores the pending event set for a given watcher */
1465 typedef struct
1466 {
1467   W w;
1468   int events; /* the pending event set for the given watcher */
1469 } ANPENDING;
1470
1471 #if EV_USE_INOTIFY
1472 /* hash table entry per inotify-id */
1473 typedef struct
1474 {
1475   WL head;
1476 } ANFS;
1477 #endif
1478
1479 /* Heap Entry */
1480 #if EV_HEAP_CACHE_AT
1481   /* a heap element */
1482   typedef struct {
1483     ev_tstamp at;
1484     WT w;
1485   } ANHE;
1486
1487   #define ANHE_w(he)        (he).w     /* access watcher, read-write */
1488   #define ANHE_at(he)       (he).at    /* access cached at, read-only */
1489   #define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
1490 #else
1491   /* a heap element */
1492   typedef WT ANHE;
1493
1494   #define ANHE_w(he)        (he)
1495   #define ANHE_at(he)       (he)->at
1496   #define ANHE_at_cache(he)
1497 #endif
1498
1499 #if EV_MULTIPLICITY
1500
1501   struct ev_loop
1502   {
1503     ev_tstamp ev_rt_now;
1504     #define ev_rt_now ((loop)->ev_rt_now)
1505     #define VAR(name,decl) decl;
1506       #include "ev_vars.h"
1507     #undef VAR
1508   };
1509   #include "ev_wrap.h"
1510
1511   static struct ev_loop default_loop_struct;
1512   EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
1513
1514 #else
1515
1516   EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */
1517   #define VAR(name,decl) static decl;
1518     #include "ev_vars.h"
1519   #undef VAR
1520
1521   static int ev_default_loop_ptr;
1522
1523 #endif
1524
1525 #if EV_FEATURE_API
1526 # define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
1527 # define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
1528 # define EV_INVOKE_PENDING invoke_cb (EV_A)
1529 #else
1530 # define EV_RELEASE_CB (void)0
1531 # define EV_ACQUIRE_CB (void)0
1532 # define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
1533 #endif
1534
1535 #define EVBREAK_RECURSE 0x80
1536
1537 /*****************************************************************************/
1538
1539 #ifndef EV_HAVE_EV_TIME
1540 ev_tstamp
1541 ev_time (void) EV_THROW
1542 {
1543 #if EV_USE_REALTIME
1544   if (expect_true (have_realtime))
1545     {
1546       struct timespec ts;
1547       clock_gettime (CLOCK_REALTIME, &ts);
1548       return ts.tv_sec + ts.tv_nsec * 1e-9;
1549     }
1550 #endif
1551
1552   struct timeval tv;
1553   gettimeofday (&tv, 0);
1554   return tv.tv_sec + tv.tv_usec * 1e-6;
1555 }
1556 #endif
1557
1558 inline_size ev_tstamp
1559 get_clock (void)
1560 {
1561 #if EV_USE_MONOTONIC
1562   if (expect_true (have_monotonic))
1563     {
1564       struct timespec ts;
1565       clock_gettime (CLOCK_MONOTONIC, &ts);
1566       return ts.tv_sec + ts.tv_nsec * 1e-9;
1567     }
1568 #endif
1569
1570   return ev_time ();
1571 }
1572
1573 #if EV_MULTIPLICITY
1574 ev_tstamp
1575 ev_now (EV_P) EV_THROW
1576 {
1577   return ev_rt_now;
1578 }
1579 #endif
1580
1581 void
1582 ev_sleep (ev_tstamp delay) EV_THROW
1583 {
1584   if (delay > 0.)
1585     {
1586 #if EV_USE_NANOSLEEP
1587       struct timespec ts;
1588
1589       EV_TS_SET (ts, delay);
1590       nanosleep (&ts, 0);
1591 #elif defined _WIN32
1592       Sleep ((unsigned long)(delay * 1e3));
1593 #else
1594       struct timeval tv;
1595
1596       /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
1597       /* something not guaranteed by newer posix versions, but guaranteed */
1598       /* by older ones */
1599       EV_TV_SET (tv, delay);
1600       select (0, 0, 0, 0, &tv);
1601 #endif
1602     }
1603 }
1604
1605 /*****************************************************************************/
1606
1607 #define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
1608
1609 /* find a suitable new size for the given array, */
1610 /* hopefully by rounding to a nice-to-malloc size */
1611 inline_size int
1612 array_nextsize (int elem, int cur, int cnt)
1613 {
1614   int ncur = cur + 1;
1615
1616   do
1617     ncur <<= 1;
1618   while (cnt > ncur);
1619
1620   /* if size is large, round to MALLOC_ROUND - 4 * longs to accommodate malloc overhead */
1621   if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
1622     {
1623       ncur *= elem;
1624       ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
1625       ncur = ncur - sizeof (void *) * 4;
1626       ncur /= elem;
1627     }
1628
1629   return ncur;
1630 }
1631
1632 static void * noinline ecb_cold
1633 array_realloc (int elem, void *base, int *cur, int cnt)
1634 {
1635   *cur = array_nextsize (elem, *cur, cnt);
1636   return ev_realloc (base, elem * *cur);
1637 }
1638
1639 #define array_init_zero(base,count)     \
1640   memset ((void *)(base), 0, sizeof (*(base)) * (count))
1641
1642 #define array_needsize(type,base,cur,cnt,init)                  \
1643   if (expect_false ((cnt) > (cur)))                             \
1644     {                                                           \
1645       int ecb_unused ocur_ = (cur);                                     \
1646       (base) = (type *)array_realloc                            \
1647          (sizeof (type), (base), &(cur), (cnt));                \
1648       init ((base) + (ocur_), (cur) - ocur_);                   \
1649     }
1650
1651 #if 0
1652 #define array_slim(type,stem)                                   \
1653   if (stem ## max < array_roundsize (stem ## cnt >> 2))         \
1654     {                                                           \
1655       stem ## max = array_roundsize (stem ## cnt >> 1);         \
1656       base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
1657       fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
1658     }
1659 #endif
1660
1661 #define array_free(stem, idx) \
1662   ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1663
1664 /*****************************************************************************/
1665
1666 /* dummy callback for pending events */
1667 static void noinline
1668 pendingcb (EV_P_ ev_prepare *w, int revents)
1669 {
1670 }
1671
1672 void noinline
1673 ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1674 {
1675   W w_ = (W)w;
1676   int pri = ABSPRI (w_);
1677
1678   if (expect_false (w_->pending))
1679     pendings [pri][w_->pending - 1].events |= revents;
1680   else
1681     {
1682       w_->pending = ++pendingcnt [pri];
1683       array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
1684       pendings [pri][w_->pending - 1].w      = w_;
1685       pendings [pri][w_->pending - 1].events = revents;
1686     }
1687
1688   pendingpri = NUMPRI - 1;
1689 }
1690
1691 inline_speed void
1692 feed_reverse (EV_P_ W w)
1693 {
1694   array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);
1695   rfeeds [rfeedcnt++] = w;
1696 }
1697
1698 inline_size void
1699 feed_reverse_done (EV_P_ int revents)
1700 {
1701   do
1702     ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents);
1703   while (rfeedcnt);
1704 }
1705
1706 inline_speed void
1707 queue_events (EV_P_ W *events, int eventcnt, int type)
1708 {
1709   int i;
1710
1711   for (i = 0; i < eventcnt; ++i)
1712     ev_feed_event (EV_A_ events [i], type);
1713 }
1714
1715 /*****************************************************************************/
1716
1717 inline_speed void
1718 fd_event_nocheck (EV_P_ int fd, int revents)
1719 {
1720   ANFD *anfd = anfds + fd;
1721   ev_io *w;
1722
1723   for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
1724     {
1725       int ev = w->events & revents;
1726
1727       if (ev)
1728         ev_feed_event (EV_A_ (W)w, ev);
1729     }
1730 }
1731
1732 /* do not submit kernel events for fds that have reify set */
1733 /* because that means they changed while we were polling for new events */
1734 inline_speed void
1735 fd_event (EV_P_ int fd, int revents)
1736 {
1737   ANFD *anfd = anfds + fd;
1738
1739   if (expect_true (!anfd->reify))
1740     fd_event_nocheck (EV_A_ fd, revents);
1741 }
1742
1743 void
1744 ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
1745 {
1746   if (fd >= 0 && fd < anfdmax)
1747     fd_event_nocheck (EV_A_ fd, revents);
1748 }
1749
1750 /* make sure the external fd watch events are in-sync */
1751 /* with the kernel/libev internal state */
1752 inline_size void
1753 fd_reify (EV_P)
1754 {
1755   int i;
1756
1757 #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1758   for (i = 0; i < fdchangecnt; ++i)
1759     {
1760       int fd = fdchanges [i];
1761       ANFD *anfd = anfds + fd;
1762
1763       if (anfd->reify & EV__IOFDSET && anfd->head)
1764         {
1765           SOCKET handle = EV_FD_TO_WIN32_HANDLE (fd);
1766
1767           if (handle != anfd->handle)
1768             {
1769               unsigned long arg;
1770
1771               assert (("libev: only socket fds supported in this configuration", ioctlsocket (handle, FIONREAD, &arg) == 0));
1772
1773               /* handle changed, but fd didn't - we need to do it in two steps */
1774               backend_modify (EV_A_ fd, anfd->events, 0);
1775               anfd->events = 0;
1776               anfd->handle = handle;
1777             }
1778         }
1779     }
1780 #endif
1781
1782   for (i = 0; i < fdchangecnt; ++i)
1783     {
1784       int fd = fdchanges [i];
1785       ANFD *anfd = anfds + fd;
1786       ev_io *w;
1787
1788       unsigned char o_events = anfd->events;
1789       unsigned char o_reify  = anfd->reify;
1790
1791       anfd->reify  = 0;
1792
1793       /*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
1794         {
1795           anfd->events = 0;
1796
1797           for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
1798             anfd->events |= (unsigned char)w->events;
1799
1800           if (o_events != anfd->events)
1801             o_reify = EV__IOFDSET; /* actually |= */
1802         }
1803
1804       if (o_reify & EV__IOFDSET)
1805         backend_modify (EV_A_ fd, o_events, anfd->events);
1806     }
1807
1808   fdchangecnt = 0;
1809 }
1810
1811 /* something about the given fd changed */
1812 inline_size void
1813 fd_change (EV_P_ int fd, int flags)
1814 {
1815   unsigned char reify = anfds [fd].reify;
1816   anfds [fd].reify |= flags;
1817
1818   if (expect_true (!reify))
1819     {
1820       ++fdchangecnt;
1821       array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
1822       fdchanges [fdchangecnt - 1] = fd;
1823     }
1824 }
1825
1826 /* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
1827 inline_speed void ecb_cold
1828 fd_kill (EV_P_ int fd)
1829 {
1830   ev_io *w;
1831
1832   while ((w = (ev_io *)anfds [fd].head))
1833     {
1834       ev_io_stop (EV_A_ w);
1835       ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
1836     }
1837 }
1838
1839 /* check whether the given fd is actually valid, for error recovery */
1840 inline_size int ecb_cold
1841 fd_valid (int fd)
1842 {
1843 #ifdef _WIN32
1844   return EV_FD_TO_WIN32_HANDLE (fd) != -1;
1845 #else
1846   return fcntl (fd, F_GETFD) != -1;
1847 #endif
1848 }
1849
1850 /* called on EBADF to verify fds */
1851 static void noinline ecb_cold
1852 fd_ebadf (EV_P)
1853 {
1854   int fd;
1855
1856   for (fd = 0; fd < anfdmax; ++fd)
1857     if (anfds [fd].events)
1858       if (!fd_valid (fd) && errno == EBADF)
1859         fd_kill (EV_A_ fd);
1860 }
1861
1862 /* called on ENOMEM in select/poll to kill some fds and retry */
1863 static void noinline ecb_cold
1864 fd_enomem (EV_P)
1865 {
1866   int fd;
1867
1868   for (fd = anfdmax; fd--; )
1869     if (anfds [fd].events)
1870       {
1871         fd_kill (EV_A_ fd);
1872         break;
1873       }
1874 }
1875
1876 /* usually called after fork if backend needs to re-arm all fds from scratch */
1877 static void noinline
1878 fd_rearm_all (EV_P)
1879 {
1880   int fd;
1881
1882   for (fd = 0; fd < anfdmax; ++fd)
1883     if (anfds [fd].events)
1884       {
1885         anfds [fd].events = 0;
1886         anfds [fd].emask  = 0;
1887         fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
1888       }
1889 }
1890
1891 /* used to prepare libev internal fd's */
1892 /* this is not fork-safe */
1893 inline_speed void
1894 fd_intern (int fd)
1895 {
1896 #ifdef _WIN32
1897   unsigned long arg = 1;
1898   ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
1899 #else
1900   fcntl (fd, F_SETFD, FD_CLOEXEC);
1901   fcntl (fd, F_SETFL, O_NONBLOCK);
1902 #endif
1903 }
1904
1905 /*****************************************************************************/
1906
1907 /*
1908  * the heap functions want a real array index. array index 0 is guaranteed to not
1909  * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
1910  * the branching factor of the d-tree.
1911  */
1912
1913 /*
1914  * at the moment we allow libev the luxury of two heaps,
1915  * a small-code-size 2-heap one and a ~1.5kb larger 4-heap
1916  * which is more cache-efficient.
1917  * the difference is about 5% with 50000+ watchers.
1918  */
1919 #if EV_USE_4HEAP
1920
1921 #define DHEAP 4
1922 #define HEAP0 (DHEAP - 1) /* index of first element in heap */
1923 #define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
1924 #define UPHEAP_DONE(p,k) ((p) == (k))
1925
1926 /* away from the root */
1927 inline_speed void
1928 downheap (ANHE *heap, int N, int k)
1929 {
1930   ANHE he = heap [k];
1931   ANHE *E = heap + N + HEAP0;
1932
1933   for (;;)
1934     {
1935       ev_tstamp minat;
1936       ANHE *minpos;
1937       ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
1938
1939       /* find minimum child */
1940       if (expect_true (pos + DHEAP - 1 < E))
1941         {
1942           /* fast path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
1943           if (               ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1944           if (               ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1945           if (               ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1946         }
1947       else if (pos < E)
1948         {
1949           /* slow path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
1950           if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1951           if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1952           if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1953         }
1954       else
1955         break;
1956
1957       if (ANHE_at (he) <= minat)
1958         break;
1959
1960       heap [k] = *minpos;
1961       ev_active (ANHE_w (*minpos)) = k;
1962
1963       k = minpos - heap;
1964     }
1965
1966   heap [k] = he;
1967   ev_active (ANHE_w (he)) = k;
1968 }
1969
1970 #else /* 4HEAP */
1971
1972 #define HEAP0 1
1973 #define HPARENT(k) ((k) >> 1)
1974 #define UPHEAP_DONE(p,k) (!(p))
1975
1976 /* away from the root */
1977 inline_speed void
1978 downheap (ANHE *heap, int N, int k)
1979 {
1980   ANHE he = heap [k];
1981
1982   for (;;)
1983     {
1984       int c = k << 1;
1985
1986       if (c >= N + HEAP0)
1987         break;
1988
1989       c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
1990            ? 1 : 0;
1991
1992       if (ANHE_at (he) <= ANHE_at (heap [c]))
1993         break;
1994
1995       heap [k] = heap [c];
1996       ev_active (ANHE_w (heap [k])) = k;
1997
1998       k = c;
1999     }
2000
2001   heap [k] = he;
2002   ev_active (ANHE_w (he)) = k;
2003 }
2004 #endif
2005
2006 /* towards the root */
2007 inline_speed void
2008 upheap (ANHE *heap, int k)
2009 {
2010   ANHE he = heap [k];
2011
2012   for (;;)
2013     {
2014       int p = HPARENT (k);
2015
2016       if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
2017         break;
2018
2019       heap [k] = heap [p];
2020       ev_active (ANHE_w (heap [k])) = k;
2021       k = p;
2022     }
2023
2024   heap [k] = he;
2025   ev_active (ANHE_w (he)) = k;
2026 }
2027
2028 /* move an element suitably so it is in a correct place */
2029 inline_size void
2030 adjustheap (ANHE *heap, int N, int k)
2031 {
2032   if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)]))
2033     upheap (heap, k);
2034   else
2035     downheap (heap, N, k);
2036 }
2037
2038 /* rebuild the heap: this function is used only once and executed rarely */
2039 inline_size void
2040 reheap (ANHE *heap, int N)
2041 {
2042   int i;
2043
2044   /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
2045   /* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
2046   for (i = 0; i < N; ++i)
2047     upheap (heap, i + HEAP0);
2048 }
2049
2050 /*****************************************************************************/
2051
2052 /* associate signal watchers to a signal signal */
2053 typedef struct
2054 {
2055   EV_ATOMIC_T pending;
2056 #if EV_MULTIPLICITY
2057   EV_P;
2058 #endif
2059   WL head;
2060 } ANSIG;
2061
2062 static ANSIG signals [EV_NSIG - 1];
2063
2064 /*****************************************************************************/
2065
2066 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2067
2068 static void noinline ecb_cold
2069 evpipe_init (EV_P)
2070 {
2071   if (!ev_is_active (&pipe_w))
2072     {
2073       int fds [2];
2074
2075 # if EV_USE_EVENTFD
2076       fds [0] = -1;
2077       fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
2078       if (fds [1] < 0 && errno == EINVAL)
2079         fds [1] = eventfd (0, 0);
2080
2081       if (fds [1] < 0)
2082 # endif
2083         {
2084           while (pipe (fds))
2085             ev_syserr ("(libev) error creating signal/async pipe");
2086
2087           fd_intern (fds [0]);
2088         }
2089
2090       fd_intern (fds [1]);
2091
2092       evpipe [0] = fds [0];
2093
2094       if (evpipe [1] < 0)
2095         evpipe [1] = fds [1]; /* first call, set write fd */
2096       else
2097         {
2098           /* on subsequent calls, do not change evpipe [1] */
2099           /* so that evpipe_write can always rely on its value. */
2100           /* this branch does not do anything sensible on windows, */
2101           /* so must not be executed on windows */
2102
2103           dup2 (fds [1], evpipe [1]);
2104           close (fds [1]);
2105         }
2106
2107       ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
2108       ev_io_start (EV_A_ &pipe_w);
2109       ev_unref (EV_A); /* watcher should not keep loop alive */
2110     }
2111 }
2112
2113 inline_speed void
2114 evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2115 {
2116   ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
2117
2118   if (expect_true (*flag))
2119     return;
2120
2121   *flag = 1;
2122   ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
2123
2124   pipe_write_skipped = 1;
2125
2126   ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
2127
2128   if (pipe_write_wanted)
2129     {
2130       int old_errno;
2131
2132       pipe_write_skipped = 0;
2133       ECB_MEMORY_FENCE_RELEASE;
2134
2135       old_errno = errno; /* save errno because write will clobber it */
2136
2137 #if EV_USE_EVENTFD
2138       if (evpipe [0] < 0)
2139         {
2140           uint64_t counter = 1;
2141           write (evpipe [1], &counter, sizeof (uint64_t));
2142         }
2143       else
2144 #endif
2145         {
2146 #ifdef _WIN32
2147           WSABUF buf;
2148           DWORD sent;
2149           buf.buf = &buf;
2150           buf.len = 1;
2151           WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
2152 #else
2153           write (evpipe [1], &(evpipe [1]), 1);
2154 #endif
2155         }
2156
2157       errno = old_errno;
2158     }
2159 }
2160
2161 /* called whenever the libev signal pipe */
2162 /* got some events (signal, async) */
2163 static void
2164 pipecb (EV_P_ ev_io *iow, int revents)
2165 {
2166   int i;
2167
2168   if (revents & EV_READ)
2169     {
2170 #if EV_USE_EVENTFD
2171       if (evpipe [0] < 0)
2172         {
2173           uint64_t counter;
2174           read (evpipe [1], &counter, sizeof (uint64_t));
2175         }
2176       else
2177 #endif
2178         {
2179           char dummy[4];
2180 #ifdef _WIN32
2181           WSABUF buf;
2182           DWORD recvd;
2183           DWORD flags = 0;
2184           buf.buf = dummy;
2185           buf.len = sizeof (dummy);
2186           WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, &flags, 0, 0);
2187 #else
2188           read (evpipe [0], &dummy, sizeof (dummy));
2189 #endif
2190         }
2191     }
2192
2193   pipe_write_skipped = 0;
2194
2195   ECB_MEMORY_FENCE; /* push out skipped, acquire flags */
2196
2197 #if EV_SIGNAL_ENABLE
2198   if (sig_pending)
2199     {
2200       sig_pending = 0;
2201
2202       ECB_MEMORY_FENCE;
2203
2204       for (i = EV_NSIG - 1; i--; )
2205         if (expect_false (signals [i].pending))
2206           ev_feed_signal_event (EV_A_ i + 1);
2207     }
2208 #endif
2209
2210 #if EV_ASYNC_ENABLE
2211   if (async_pending)
2212     {
2213       async_pending = 0;
2214
2215       ECB_MEMORY_FENCE;
2216
2217       for (i = asynccnt; i--; )
2218         if (asyncs [i]->sent)
2219           {
2220             asyncs [i]->sent = 0;
2221             ECB_MEMORY_FENCE_RELEASE;
2222             ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
2223           }
2224     }
2225 #endif
2226 }
2227
2228 /*****************************************************************************/
2229
2230 void
2231 ev_feed_signal (int signum) EV_THROW
2232 {
2233 #if EV_MULTIPLICITY
2234   ECB_MEMORY_FENCE_ACQUIRE;
2235   EV_P = signals [signum - 1].loop;
2236
2237   if (!EV_A)
2238     return;
2239 #endif
2240
2241   signals [signum - 1].pending = 1;
2242   evpipe_write (EV_A_ &sig_pending);
2243 }
2244
2245 static void
2246 ev_sighandler (int signum)
2247 {
2248 #ifdef _WIN32
2249   signal (signum, ev_sighandler);
2250 #endif
2251
2252   ev_feed_signal (signum);
2253 }
2254
2255 void noinline
2256 ev_feed_signal_event (EV_P_ int signum) EV_THROW
2257 {
2258   WL w;
2259
2260   if (expect_false (signum <= 0 || signum >= EV_NSIG))
2261     return;
2262
2263   --signum;
2264
2265 #if EV_MULTIPLICITY
2266   /* it is permissible to try to feed a signal to the wrong loop */
2267   /* or, likely more useful, feeding a signal nobody is waiting for */
2268
2269   if (expect_false (signals [signum].loop != EV_A))
2270     return;
2271 #endif
2272
2273   signals [signum].pending = 0;
2274   ECB_MEMORY_FENCE_RELEASE;
2275
2276   for (w = signals [signum].head; w; w = w->next)
2277     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
2278 }
2279
2280 #if EV_USE_SIGNALFD
2281 static void
2282 sigfdcb (EV_P_ ev_io *iow, int revents)
2283 {
2284   struct signalfd_siginfo si[2], *sip; /* these structs are big */
2285
2286   for (;;)
2287     {
2288       ssize_t res = read (sigfd, si, sizeof (si));
2289
2290       /* not ISO-C, as res might be -1, but works with SuS */
2291       for (sip = si; (char *)sip < (char *)si + res; ++sip)
2292         ev_feed_signal_event (EV_A_ sip->ssi_signo);
2293
2294       if (res < (ssize_t)sizeof (si))
2295         break;
2296     }
2297 }
2298 #endif
2299
2300 #endif
2301
2302 /*****************************************************************************/
2303
2304 #if EV_CHILD_ENABLE
2305 static WL childs [EV_PID_HASHSIZE];
2306
2307 static ev_signal childev;
2308
2309 #ifndef WIFCONTINUED
2310 # define WIFCONTINUED(status) 0
2311 #endif
2312
2313 /* handle a single child status event */
2314 inline_speed void
2315 child_reap (EV_P_ int chain, int pid, int status)
2316 {
2317   ev_child *w;
2318   int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
2319
2320   for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
2321     {
2322       if ((w->pid == pid || !w->pid)
2323           && (!traced || (w->flags & 1)))
2324         {
2325           ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
2326           w->rpid    = pid;
2327           w->rstatus = status;
2328           ev_feed_event (EV_A_ (W)w, EV_CHILD);
2329         }
2330     }
2331 }
2332
2333 #ifndef WCONTINUED
2334 # define WCONTINUED 0
2335 #endif
2336
2337 /* called on sigchld etc., calls waitpid */
2338 static void
2339 childcb (EV_P_ ev_signal *sw, int revents)
2340 {
2341   int pid, status;
2342
2343   /* some systems define WCONTINUED but then fail to support it (linux 2.4) */
2344   if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
2345     if (!WCONTINUED
2346         || errno != EINVAL
2347         || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
2348       return;
2349
2350   /* make sure we are called again until all children have been reaped */
2351   /* we need to do it this way so that the callback gets called before we continue */
2352   ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
2353
2354   child_reap (EV_A_ pid, pid, status);
2355   if ((EV_PID_HASHSIZE) > 1)
2356     child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
2357 }
2358
2359 #endif
2360
2361 /*****************************************************************************/
2362
2363 #if EV_USE_IOCP
2364 # include "ev_iocp.c"
2365 #endif
2366 #if EV_USE_PORT
2367 # include "ev_port.c"
2368 #endif
2369 #if EV_USE_KQUEUE
2370 # include "ev_kqueue.c"
2371 #endif
2372 #if EV_USE_EPOLL
2373 # include "ev_epoll.c"
2374 #endif
2375 #if EV_USE_POLL
2376 # include "ev_poll.c"
2377 #endif
2378 #if EV_USE_SELECT
2379 # include "ev_select.c"
2380 #endif
2381
2382 int ecb_cold
2383 ev_version_major (void) EV_THROW
2384 {
2385   return EV_VERSION_MAJOR;
2386 }
2387
2388 int ecb_cold
2389 ev_version_minor (void) EV_THROW
2390 {
2391   return EV_VERSION_MINOR;
2392 }
2393
2394 /* return true if we are running with elevated privileges and should ignore env variables */
2395 int inline_size ecb_cold
2396 enable_secure (void)
2397 {
2398 #ifdef _WIN32
2399   return 0;
2400 #else
2401   return getuid () != geteuid ()
2402       || getgid () != getegid ();
2403 #endif
2404 }
2405
2406 unsigned int ecb_cold
2407 ev_supported_backends (void) EV_THROW
2408 {
2409   unsigned int flags = 0;
2410
2411   if (EV_USE_PORT  ) flags |= EVBACKEND_PORT;
2412   if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
2413   if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
2414   if (EV_USE_POLL  ) flags |= EVBACKEND_POLL;
2415   if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
2416
2417   return flags;
2418 }
2419
2420 unsigned int ecb_cold
2421 ev_recommended_backends (void) EV_THROW
2422 {
2423   unsigned int flags = ev_supported_backends ();
2424
2425 #ifndef __NetBSD__
2426   /* kqueue is borked on everything but netbsd apparently */
2427   /* it usually doesn't work correctly on anything but sockets and pipes */
2428   flags &= ~EVBACKEND_KQUEUE;
2429 #endif
2430 #ifdef __APPLE__
2431   /* only select works correctly on that "unix-certified" platform */
2432   flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */
2433   flags &= ~EVBACKEND_POLL;   /* poll is based on kqueue from 10.5 onwards */
2434 #endif
2435 #ifdef __FreeBSD__
2436   flags &= ~EVBACKEND_POLL;   /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
2437 #endif
2438
2439   return flags;
2440 }
2441
2442 unsigned int ecb_cold
2443 ev_embeddable_backends (void) EV_THROW
2444 {
2445   int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2446
2447   /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2448   if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2449     flags &= ~EVBACKEND_EPOLL;
2450
2451   return flags;
2452 }
2453
2454 unsigned int
2455 ev_backend (EV_P) EV_THROW
2456 {
2457   return backend;
2458 }
2459
2460 #if EV_FEATURE_API
2461 unsigned int
2462 ev_iteration (EV_P) EV_THROW
2463 {
2464   return loop_count;
2465 }
2466
2467 unsigned int
2468 ev_depth (EV_P) EV_THROW
2469 {
2470   return loop_depth;
2471 }
2472
2473 void
2474 ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2475 {
2476   io_blocktime = interval;
2477 }
2478
2479 void
2480 ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2481 {
2482   timeout_blocktime = interval;
2483 }
2484
2485 void
2486 ev_set_userdata (EV_P_ void *data) EV_THROW
2487 {
2488   userdata = data;
2489 }
2490
2491 void *
2492 ev_userdata (EV_P) EV_THROW
2493 {
2494   return userdata;
2495 }
2496
2497 void
2498 ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
2499 {
2500   invoke_cb = invoke_pending_cb;
2501 }
2502
2503 void
2504 ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW
2505 {
2506   release_cb = release;
2507   acquire_cb = acquire;
2508 }
2509 #endif
2510
2511 /* initialise a loop structure, must be zero-initialised */
2512 static void noinline ecb_cold
2513 loop_init (EV_P_ unsigned int flags) EV_THROW
2514 {
2515   if (!backend)
2516     {
2517       origflags = flags;
2518
2519 #if EV_USE_REALTIME
2520       if (!have_realtime)
2521         {
2522           struct timespec ts;
2523
2524           if (!clock_gettime (CLOCK_REALTIME, &ts))
2525             have_realtime = 1;
2526         }
2527 #endif
2528
2529 #if EV_USE_MONOTONIC
2530       if (!have_monotonic)
2531         {
2532           struct timespec ts;
2533
2534           if (!clock_gettime (CLOCK_MONOTONIC, &ts))
2535             have_monotonic = 1;
2536         }
2537 #endif
2538
2539       /* pid check not overridable via env */
2540 #ifndef _WIN32
2541       if (flags & EVFLAG_FORKCHECK)
2542         curpid = getpid ();
2543 #endif
2544
2545       if (!(flags & EVFLAG_NOENV)
2546           && !enable_secure ()
2547           && getenv ("LIBEV_FLAGS"))
2548         flags = atoi (getenv ("LIBEV_FLAGS"));
2549
2550       ev_rt_now          = ev_time ();
2551       mn_now             = get_clock ();
2552       now_floor          = mn_now;
2553       rtmn_diff          = ev_rt_now - mn_now;
2554 #if EV_FEATURE_API
2555       invoke_cb          = ev_invoke_pending;
2556 #endif
2557
2558       io_blocktime       = 0.;
2559       timeout_blocktime  = 0.;
2560       backend            = 0;
2561       backend_fd         = -1;
2562       sig_pending        = 0;
2563 #if EV_ASYNC_ENABLE
2564       async_pending      = 0;
2565 #endif
2566       pipe_write_skipped = 0;
2567       pipe_write_wanted  = 0;
2568       evpipe [0]         = -1;
2569       evpipe [1]         = -1;
2570 #if EV_USE_INOTIFY
2571       fs_fd              = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2572 #endif
2573 #if EV_USE_SIGNALFD
2574       sigfd              = flags & EVFLAG_SIGNALFD  ? -2 : -1;
2575 #endif
2576
2577       if (!(flags & EVBACKEND_MASK))
2578         flags |= ev_recommended_backends ();
2579
2580 #if EV_USE_IOCP
2581       if (!backend && (flags & EVBACKEND_IOCP  )) backend = iocp_init   (EV_A_ flags);
2582 #endif
2583 #if EV_USE_PORT
2584       if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
2585 #endif
2586 #if EV_USE_KQUEUE
2587       if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
2588 #endif
2589 #if EV_USE_EPOLL
2590       if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init  (EV_A_ flags);
2591 #endif
2592 #if EV_USE_POLL
2593       if (!backend && (flags & EVBACKEND_POLL  )) backend = poll_init   (EV_A_ flags);
2594 #endif
2595 #if EV_USE_SELECT
2596       if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
2597 #endif
2598
2599       ev_prepare_init (&pending_w, pendingcb);
2600
2601 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2602       ev_init (&pipe_w, pipecb);
2603       ev_set_priority (&pipe_w, EV_MAXPRI);
2604 #endif
2605     }
2606 }
2607
2608 /* free up a loop structure */
2609 void ecb_cold
2610 ev_loop_destroy (EV_P)
2611 {
2612   int i;
2613
2614 #if EV_MULTIPLICITY
2615   /* mimic free (0) */
2616   if (!EV_A)
2617     return;
2618 #endif
2619
2620 #if EV_CLEANUP_ENABLE
2621   /* queue cleanup watchers (and execute them) */
2622   if (expect_false (cleanupcnt))
2623     {
2624       queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
2625       EV_INVOKE_PENDING;
2626     }
2627 #endif
2628
2629 #if EV_CHILD_ENABLE
2630   if (ev_is_default_loop (EV_A) && ev_is_active (&childev))
2631     {
2632       ev_ref (EV_A); /* child watcher */
2633       ev_signal_stop (EV_A_ &childev);
2634     }
2635 #endif
2636
2637   if (ev_is_active (&pipe_w))
2638     {
2639       /*ev_ref (EV_A);*/
2640       /*ev_io_stop (EV_A_ &pipe_w);*/
2641
2642       if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
2643       if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
2644     }
2645
2646 #if EV_USE_SIGNALFD
2647   if (ev_is_active (&sigfd_w))
2648     close (sigfd);
2649 #endif
2650
2651 #if EV_USE_INOTIFY
2652   if (fs_fd >= 0)
2653     close (fs_fd);
2654 #endif
2655
2656   if (backend_fd >= 0)
2657     close (backend_fd);
2658
2659 #if EV_USE_IOCP
2660   if (backend == EVBACKEND_IOCP  ) iocp_destroy   (EV_A);
2661 #endif
2662 #if EV_USE_PORT
2663   if (backend == EVBACKEND_PORT  ) port_destroy   (EV_A);
2664 #endif
2665 #if EV_USE_KQUEUE
2666   if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
2667 #endif
2668 #if EV_USE_EPOLL
2669   if (backend == EVBACKEND_EPOLL ) epoll_destroy  (EV_A);
2670 #endif
2671 #if EV_USE_POLL
2672   if (backend == EVBACKEND_POLL  ) poll_destroy   (EV_A);
2673 #endif
2674 #if EV_USE_SELECT
2675   if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
2676 #endif
2677
2678   for (i = NUMPRI; i--; )
2679     {
2680       array_free (pending, [i]);
2681 #if EV_IDLE_ENABLE
2682       array_free (idle, [i]);
2683 #endif
2684     }
2685
2686   ev_free (anfds); anfds = 0; anfdmax = 0;
2687
2688   /* have to use the microsoft-never-gets-it-right macro */
2689   array_free (rfeed, EMPTY);
2690   array_free (fdchange, EMPTY);
2691   array_free (timer, EMPTY);
2692 #if EV_PERIODIC_ENABLE
2693   array_free (periodic, EMPTY);
2694 #endif
2695 #if EV_FORK_ENABLE
2696   array_free (fork, EMPTY);
2697 #endif
2698 #if EV_CLEANUP_ENABLE
2699   array_free (cleanup, EMPTY);
2700 #endif
2701   array_free (prepare, EMPTY);
2702   array_free (check, EMPTY);
2703 #if EV_ASYNC_ENABLE
2704   array_free (async, EMPTY);
2705 #endif
2706
2707   backend = 0;
2708
2709 #if EV_MULTIPLICITY
2710   if (ev_is_default_loop (EV_A))
2711 #endif
2712     ev_default_loop_ptr = 0;
2713 #if EV_MULTIPLICITY
2714   else
2715     ev_free (EV_A);
2716 #endif
2717 }
2718
2719 #if EV_USE_INOTIFY
2720 inline_size void infy_fork (EV_P);
2721 #endif
2722
2723 inline_size void
2724 loop_fork (EV_P)
2725 {
2726 #if EV_USE_PORT
2727   if (backend == EVBACKEND_PORT  ) port_fork   (EV_A);
2728 #endif
2729 #if EV_USE_KQUEUE
2730   if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
2731 #endif
2732 #if EV_USE_EPOLL
2733   if (backend == EVBACKEND_EPOLL ) epoll_fork  (EV_A);
2734 #endif
2735 #if EV_USE_INOTIFY
2736   infy_fork (EV_A);
2737 #endif
2738
2739 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2740   if (ev_is_active (&pipe_w))
2741     {
2742       /* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2743
2744       ev_ref (EV_A);
2745       ev_io_stop (EV_A_ &pipe_w);
2746
2747       if (evpipe [0] >= 0)
2748         EV_WIN32_CLOSE_FD (evpipe [0]);
2749
2750       evpipe_init (EV_A);
2751       /* iterate over everything, in case we missed something before */
2752       ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2753     }
2754 #endif
2755
2756   postfork = 0;
2757 }
2758
2759 #if EV_MULTIPLICITY
2760
2761 struct ev_loop * ecb_cold
2762 ev_loop_new (unsigned int flags) EV_THROW
2763 {
2764   EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2765
2766   memset (EV_A, 0, sizeof (struct ev_loop));
2767   loop_init (EV_A_ flags);
2768
2769   if (ev_backend (EV_A))
2770     return EV_A;
2771
2772   ev_free (EV_A);
2773   return 0;
2774 }
2775
2776 #endif /* multiplicity */
2777
2778 #if EV_VERIFY
2779 static void noinline ecb_cold
2780 verify_watcher (EV_P_ W w)
2781 {
2782   assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
2783
2784   if (w->pending)
2785     assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
2786 }
2787
2788 static void noinline ecb_cold
2789 verify_heap (EV_P_ ANHE *heap, int N)
2790 {
2791   int i;
2792
2793   for (i = HEAP0; i < N + HEAP0; ++i)
2794     {
2795       assert (("libev: active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i));
2796       assert (("libev: heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i])));
2797       assert (("libev: heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i]))));
2798
2799       verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
2800     }
2801 }
2802
2803 static void noinline ecb_cold
2804 array_verify (EV_P_ W *ws, int cnt)
2805 {
2806   while (cnt--)
2807     {
2808       assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
2809       verify_watcher (EV_A_ ws [cnt]);
2810     }
2811 }
2812 #endif
2813
2814 #if EV_FEATURE_API
2815 void ecb_cold
2816 ev_verify (EV_P) EV_THROW
2817 {
2818 #if EV_VERIFY
2819   int i;
2820   WL w, w2;
2821
2822   assert (activecnt >= -1);
2823
2824   assert (fdchangemax >= fdchangecnt);
2825   for (i = 0; i < fdchangecnt; ++i)
2826     assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0));
2827
2828   assert (anfdmax >= 0);
2829   for (i = 0; i < anfdmax; ++i)
2830     {
2831       int j = 0;
2832
2833       for (w = w2 = anfds [i].head; w; w = w->next)
2834         {
2835           verify_watcher (EV_A_ (W)w);
2836
2837           if (j++ & 1)
2838             {
2839               assert (("libev: io watcher list contains a loop", w != w2));
2840               w2 = w2->next;
2841             }
2842
2843           assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1));
2844           assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
2845         }
2846     }
2847
2848   assert (timermax >= timercnt);
2849   verify_heap (EV_A_ timers, timercnt);
2850
2851 #if EV_PERIODIC_ENABLE
2852   assert (periodicmax >= periodiccnt);
2853   verify_heap (EV_A_ periodics, periodiccnt);
2854 #endif
2855
2856   for (i = NUMPRI; i--; )
2857     {
2858       assert (pendingmax [i] >= pendingcnt [i]);
2859 #if EV_IDLE_ENABLE
2860       assert (idleall >= 0);
2861       assert (idlemax [i] >= idlecnt [i]);
2862       array_verify (EV_A_ (W *)idles [i], idlecnt [i]);
2863 #endif
2864     }
2865
2866 #if EV_FORK_ENABLE
2867   assert (forkmax >= forkcnt);
2868   array_verify (EV_A_ (W *)forks, forkcnt);
2869 #endif
2870
2871 #if EV_CLEANUP_ENABLE
2872   assert (cleanupmax >= cleanupcnt);
2873   array_verify (EV_A_ (W *)cleanups, cleanupcnt);
2874 #endif
2875
2876 #if EV_ASYNC_ENABLE
2877   assert (asyncmax >= asynccnt);
2878   array_verify (EV_A_ (W *)asyncs, asynccnt);
2879 #endif
2880
2881 #if EV_PREPARE_ENABLE
2882   assert (preparemax >= preparecnt);
2883   array_verify (EV_A_ (W *)prepares, preparecnt);
2884 #endif
2885
2886 #if EV_CHECK_ENABLE
2887   assert (checkmax >= checkcnt);
2888   array_verify (EV_A_ (W *)checks, checkcnt);
2889 #endif
2890
2891 # if 0
2892 #if EV_CHILD_ENABLE
2893   for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
2894   for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
2895 #endif
2896 # endif
2897 #endif
2898 }
2899 #endif
2900
2901 #if EV_MULTIPLICITY
2902 struct ev_loop * ecb_cold
2903 #else
2904 int
2905 #endif
2906 ev_default_loop (unsigned int flags) EV_THROW
2907 {
2908   if (!ev_default_loop_ptr)
2909     {
2910 #if EV_MULTIPLICITY
2911       EV_P = ev_default_loop_ptr = &default_loop_struct;
2912 #else
2913       ev_default_loop_ptr = 1;
2914 #endif
2915
2916       loop_init (EV_A_ flags);
2917
2918       if (ev_backend (EV_A))
2919         {
2920 #if EV_CHILD_ENABLE
2921           ev_signal_init (&childev, childcb, SIGCHLD);
2922           ev_set_priority (&childev, EV_MAXPRI);
2923           ev_signal_start (EV_A_ &childev);
2924           ev_unref (EV_A); /* child watcher should not keep loop alive */
2925 #endif
2926         }
2927       else
2928         ev_default_loop_ptr = 0;
2929     }
2930
2931   return ev_default_loop_ptr;
2932 }
2933
2934 void
2935 ev_loop_fork (EV_P) EV_THROW
2936 {
2937   postfork = 1;
2938 }
2939
2940 /*****************************************************************************/
2941
2942 void
2943 ev_invoke (EV_P_ void *w, int revents)
2944 {
2945   EV_CB_INVOKE ((W)w, revents);
2946 }
2947
2948 unsigned int
2949 ev_pending_count (EV_P) EV_THROW
2950 {
2951   int pri;
2952   unsigned int count = 0;
2953
2954   for (pri = NUMPRI; pri--; )
2955     count += pendingcnt [pri];
2956
2957   return count;
2958 }
2959
2960 void noinline
2961 ev_invoke_pending (EV_P)
2962 {
2963   pendingpri = NUMPRI;
2964
2965   while (pendingpri) /* pendingpri possibly gets modified in the inner loop */
2966     {
2967       --pendingpri;
2968
2969       while (pendingcnt [pendingpri])
2970         {
2971           ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2972
2973           p->w->pending = 0;
2974           EV_CB_INVOKE (p->w, p->events);
2975           EV_FREQUENT_CHECK;
2976         }
2977     }
2978 }
2979
2980 #if EV_IDLE_ENABLE
2981 /* make idle watchers pending. this handles the "call-idle */
2982 /* only when higher priorities are idle" logic */
2983 inline_size void
2984 idle_reify (EV_P)
2985 {
2986   if (expect_false (idleall))
2987     {
2988       int pri;
2989
2990       for (pri = NUMPRI; pri--; )
2991         {
2992           if (pendingcnt [pri])
2993             break;
2994
2995           if (idlecnt [pri])
2996             {
2997               queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
2998               break;
2999             }
3000         }
3001     }
3002 }
3003 #endif
3004
3005 /* make timers pending */
3006 inline_size void
3007 timers_reify (EV_P)
3008 {
3009   EV_FREQUENT_CHECK;
3010
3011   if (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
3012     {
3013       do
3014         {
3015           ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
3016
3017           /*assert (("libev: inactive timer on timer heap detected", ev_is_active (w)));*/
3018
3019           /* first reschedule or stop timer */
3020           if (w->repeat)
3021             {
3022               ev_at (w) += w->repeat;
3023               if (ev_at (w) < mn_now)
3024                 ev_at (w) = mn_now;
3025
3026               assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));
3027
3028               ANHE_at_cache (timers [HEAP0]);
3029               downheap (timers, timercnt, HEAP0);
3030             }
3031           else
3032             ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
3033
3034           EV_FREQUENT_CHECK;
3035           feed_reverse (EV_A_ (W)w);
3036         }
3037       while (timercnt && ANHE_at (timers [HEAP0]) < mn_now);
3038
3039       feed_reverse_done (EV_A_ EV_TIMER);
3040     }
3041 }
3042
3043 #if EV_PERIODIC_ENABLE
3044
3045 static void noinline
3046 periodic_recalc (EV_P_ ev_periodic *w)
3047 {
3048   ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3049   ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
3050
3051   /* the above almost always errs on the low side */
3052   while (at <= ev_rt_now)
3053     {
3054       ev_tstamp nat = at + w->interval;
3055
3056       /* when resolution fails us, we use ev_rt_now */
3057       if (expect_false (nat == at))
3058         {
3059           at = ev_rt_now;
3060           break;
3061         }
3062
3063       at = nat;
3064     }
3065
3066   ev_at (w) = at;
3067 }
3068
3069 /* make periodics pending */
3070 inline_size void
3071 periodics_reify (EV_P)
3072 {
3073   EV_FREQUENT_CHECK;
3074
3075   while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
3076     {
3077       do
3078         {
3079           ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
3080
3081           /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/
3082
3083           /* first reschedule or stop timer */
3084           if (w->reschedule_cb)
3085             {
3086               ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3087
3088               assert (("libev: ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
3089
3090               ANHE_at_cache (periodics [HEAP0]);
3091               downheap (periodics, periodiccnt, HEAP0);
3092             }
3093           else if (w->interval)
3094             {
3095               periodic_recalc (EV_A_ w);
3096               ANHE_at_cache (periodics [HEAP0]);
3097               downheap (periodics, periodiccnt, HEAP0);
3098             }
3099           else
3100             ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
3101
3102           EV_FREQUENT_CHECK;
3103           feed_reverse (EV_A_ (W)w);
3104         }
3105       while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now);
3106
3107       feed_reverse_done (EV_A_ EV_PERIODIC);
3108     }
3109 }
3110
3111 /* simply recalculate all periodics */
3112 /* TODO: maybe ensure that at least one event happens when jumping forward? */
3113 static void noinline ecb_cold
3114 periodics_reschedule (EV_P)
3115 {
3116   int i;
3117
3118   /* adjust periodics after time jump */
3119   for (i = HEAP0; i < periodiccnt + HEAP0; ++i)
3120     {
3121       ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
3122
3123       if (w->reschedule_cb)
3124         ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3125       else if (w->interval)
3126         periodic_recalc (EV_A_ w);
3127
3128       ANHE_at_cache (periodics [i]);
3129     }
3130
3131   reheap (periodics, periodiccnt);
3132 }
3133 #endif
3134
3135 /* adjust all timers by a given offset */
3136 static void noinline ecb_cold
3137 timers_reschedule (EV_P_ ev_tstamp adjust)
3138 {
3139   int i;
3140
3141   for (i = 0; i < timercnt; ++i)
3142     {
3143       ANHE *he = timers + i + HEAP0;
3144       ANHE_w (*he)->at += adjust;
3145       ANHE_at_cache (*he);
3146     }
3147 }
3148
3149 /* fetch new monotonic and realtime times from the kernel */
3150 /* also detect if there was a timejump, and act accordingly */
3151 inline_speed void
3152 time_update (EV_P_ ev_tstamp max_block)
3153 {
3154 #if EV_USE_MONOTONIC
3155   if (expect_true (have_monotonic))
3156     {
3157       int i;
3158       ev_tstamp odiff = rtmn_diff;
3159
3160       mn_now = get_clock ();
3161
3162       /* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3163       /* interpolate in the meantime */
3164       if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
3165         {
3166           ev_rt_now = rtmn_diff + mn_now;
3167           return;
3168         }
3169
3170       now_floor = mn_now;
3171       ev_rt_now = ev_time ();
3172
3173       /* loop a few times, before making important decisions.
3174        * on the choice of "4": one iteration isn't enough,
3175        * in case we get preempted during the calls to
3176        * ev_time and get_clock. a second call is almost guaranteed
3177        * to succeed in that case, though. and looping a few more times
3178        * doesn't hurt either as we only do this on time-jumps or
3179        * in the unlikely event of having been preempted here.
3180        */
3181       for (i = 4; --i; )
3182         {
3183           ev_tstamp diff;
3184           rtmn_diff = ev_rt_now - mn_now;
3185
3186           diff = odiff - rtmn_diff;
3187
3188           if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))
3189             return; /* all is well */
3190
3191           ev_rt_now = ev_time ();
3192           mn_now    = get_clock ();
3193           now_floor = mn_now;
3194         }
3195
3196       /* no timer adjustment, as the monotonic clock doesn't jump */
3197       /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
3198 # if EV_PERIODIC_ENABLE
3199       periodics_reschedule (EV_A);
3200 # endif
3201     }
3202   else
3203 #endif
3204     {
3205       ev_rt_now = ev_time ();
3206
3207       if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))
3208         {
3209           /* adjust timers. this is easy, as the offset is the same for all of them */
3210           timers_reschedule (EV_A_ ev_rt_now - mn_now);
3211 #if EV_PERIODIC_ENABLE
3212           periodics_reschedule (EV_A);
3213 #endif
3214         }
3215
3216       mn_now = ev_rt_now;
3217     }
3218 }
3219
3220 int
3221 ev_run (EV_P_ int flags)
3222 {
3223 #if EV_FEATURE_API
3224   ++loop_depth;
3225 #endif
3226
3227   assert (("libev: ev_loop recursion during release detected", loop_done != EVBREAK_RECURSE));
3228
3229   loop_done = EVBREAK_CANCEL;
3230
3231   EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */
3232
3233   do
3234     {
3235 #if EV_VERIFY >= 2
3236       ev_verify (EV_A);
3237 #endif
3238
3239 #ifndef _WIN32
3240       if (expect_false (curpid)) /* penalise the forking check even more */
3241         if (expect_false (getpid () != curpid))
3242           {
3243             curpid = getpid ();
3244             postfork = 1;
3245           }
3246 #endif
3247
3248 #if EV_FORK_ENABLE
3249       /* we might have forked, so queue fork handlers */
3250       if (expect_false (postfork))
3251         if (forkcnt)
3252           {
3253             queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3254             EV_INVOKE_PENDING;
3255           }
3256 #endif
3257
3258 #if EV_PREPARE_ENABLE
3259       /* queue prepare watchers (and execute them) */
3260       if (expect_false (preparecnt))
3261         {
3262           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3263           EV_INVOKE_PENDING;
3264         }
3265 #endif
3266
3267       if (expect_false (loop_done))
3268         break;
3269
3270       /* we might have forked, so reify kernel state if necessary */
3271       if (expect_false (postfork))
3272         loop_fork (EV_A);
3273
3274       /* update fd-related kernel structures */
3275       fd_reify (EV_A);
3276
3277       /* calculate blocking time */
3278       {
3279         ev_tstamp waittime  = 0.;
3280         ev_tstamp sleeptime = 0.;
3281
3282         /* remember old timestamp for io_blocktime calculation */
3283         ev_tstamp prev_mn_now = mn_now;
3284
3285         /* update time to cancel out callback processing overhead */
3286         time_update (EV_A_ 1e100);
3287
3288         /* from now on, we want a pipe-wake-up */
3289         pipe_write_wanted = 1;
3290
3291         ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3292
3293         if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3294           {
3295             waittime = MAX_BLOCKTIME;
3296
3297             if (timercnt)
3298               {
3299                 ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3300                 if (waittime > to) waittime = to;
3301               }
3302
3303 #if EV_PERIODIC_ENABLE
3304             if (periodiccnt)
3305               {
3306                 ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now;
3307                 if (waittime > to) waittime = to;
3308               }
3309 #endif
3310
3311             /* don't let timeouts decrease the waittime below timeout_blocktime */
3312             if (expect_false (waittime < timeout_blocktime))
3313               waittime = timeout_blocktime;
3314
3315             /* at this point, we NEED to wait, so we have to ensure */
3316             /* to pass a minimum nonzero value to the backend */
3317             if (expect_false (waittime < backend_mintime))
3318               waittime = backend_mintime;
3319
3320             /* extra check because io_blocktime is commonly 0 */
3321             if (expect_false (io_blocktime))
3322               {
3323                 sleeptime = io_blocktime - (mn_now - prev_mn_now);
3324
3325                 if (sleeptime > waittime - backend_mintime)
3326                   sleeptime = waittime - backend_mintime;
3327
3328                 if (expect_true (sleeptime > 0.))
3329                   {
3330                     ev_sleep (sleeptime);
3331                     waittime -= sleeptime;
3332                   }
3333               }
3334           }
3335
3336 #if EV_FEATURE_API
3337         ++loop_count;
3338 #endif
3339         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
3340         backend_poll (EV_A_ waittime);
3341         assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
3342
3343         pipe_write_wanted = 0; /* just an optimisation, no fence needed */
3344
3345         ECB_MEMORY_FENCE_ACQUIRE;
3346         if (pipe_write_skipped)
3347           {
3348             assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3349             ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3350           }
3351
3352
3353         /* update ev_rt_now, do magic */
3354         time_update (EV_A_ waittime + sleeptime);
3355       }
3356
3357       /* queue pending timers and reschedule them */
3358       timers_reify (EV_A); /* relative timers called last */
3359 #if EV_PERIODIC_ENABLE
3360       periodics_reify (EV_A); /* absolute timers called first */
3361 #endif
3362
3363 #if EV_IDLE_ENABLE
3364       /* queue idle watchers unless other events are pending */
3365       idle_reify (EV_A);
3366 #endif
3367
3368 #if EV_CHECK_ENABLE
3369       /* queue check watchers, to be executed first */
3370       if (expect_false (checkcnt))
3371         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3372 #endif
3373
3374       EV_INVOKE_PENDING;
3375     }
3376   while (expect_true (
3377     activecnt
3378     && !loop_done
3379     && !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3380   ));
3381
3382   if (loop_done == EVBREAK_ONE)
3383     loop_done = EVBREAK_CANCEL;
3384
3385 #if EV_FEATURE_API
3386   --loop_depth;
3387 #endif
3388
3389   return activecnt;
3390 }
3391
3392 void
3393 ev_break (EV_P_ int how) EV_THROW
3394 {
3395   loop_done = how;
3396 }
3397
3398 void
3399 ev_ref (EV_P) EV_THROW
3400 {
3401   ++activecnt;
3402 }
3403
3404 void
3405 ev_unref (EV_P) EV_THROW
3406 {
3407   --activecnt;
3408 }
3409
3410 void
3411 ev_now_update (EV_P) EV_THROW
3412 {
3413   time_update (EV_A_ 1e100);
3414 }
3415
3416 void
3417 ev_suspend (EV_P) EV_THROW
3418 {
3419   ev_now_update (EV_A);
3420 }
3421
3422 void
3423 ev_resume (EV_P) EV_THROW
3424 {
3425   ev_tstamp mn_prev = mn_now;
3426
3427   ev_now_update (EV_A);
3428   timers_reschedule (EV_A_ mn_now - mn_prev);
3429 #if EV_PERIODIC_ENABLE
3430   /* TODO: really do this? */
3431   periodics_reschedule (EV_A);
3432 #endif
3433 }
3434
3435 /*****************************************************************************/
3436 /* singly-linked list management, used when the expected list length is short */
3437
3438 inline_size void
3439 wlist_add (WL *head, WL elem)
3440 {
3441   elem->next = *head;
3442   *head = elem;
3443 }
3444
3445 inline_size void
3446 wlist_del (WL *head, WL elem)
3447 {
3448   while (*head)
3449     {
3450       if (expect_true (*head == elem))
3451         {
3452           *head = elem->next;
3453           break;
3454         }
3455
3456       head = &(*head)->next;
3457     }
3458 }
3459
3460 /* internal, faster, version of ev_clear_pending */
3461 inline_speed void
3462 clear_pending (EV_P_ W w)
3463 {
3464   if (w->pending)
3465     {
3466       pendings [ABSPRI (w)][w->pending - 1].w = (W)&pending_w;
3467       w->pending = 0;
3468     }
3469 }
3470
3471 int
3472 ev_clear_pending (EV_P_ void *w) EV_THROW
3473 {
3474   W w_ = (W)w;
3475   int pending = w_->pending;
3476
3477   if (expect_true (pending))
3478     {
3479       ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3480       p->w = (W)&pending_w;
3481       w_->pending = 0;
3482       return p->events;
3483     }
3484   else
3485     return 0;
3486 }
3487
3488 inline_size void
3489 pri_adjust (EV_P_ W w)
3490 {
3491   int pri = ev_priority (w);
3492   pri = pri < EV_MINPRI ? EV_MINPRI : pri;
3493   pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
3494   ev_set_priority (w, pri);
3495 }
3496
3497 inline_speed void
3498 ev_start (EV_P_ W w, int active)
3499 {
3500   pri_adjust (EV_A_ w);
3501   w->active = active;
3502   ev_ref (EV_A);
3503 }
3504
3505 inline_size void
3506 ev_stop (EV_P_ W w)
3507 {
3508   ev_unref (EV_A);
3509   w->active = 0;
3510 }
3511
3512 /*****************************************************************************/
3513
3514 void noinline
3515 ev_io_start (EV_P_ ev_io *w) EV_THROW
3516 {
3517   int fd = w->fd;
3518
3519   if (expect_false (ev_is_active (w)))
3520     return;
3521
3522   assert (("libev: ev_io_start called with negative fd", fd >= 0));
3523   assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3524
3525   EV_FREQUENT_CHECK;
3526
3527   ev_start (EV_A_ (W)w, 1);
3528   array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
3529   wlist_add (&anfds[fd].head, (WL)w);
3530
3531   /* common bug, apparently */
3532   assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3533
3534   fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
3535   w->events &= ~EV__IOFDSET;
3536
3537   EV_FREQUENT_CHECK;
3538 }
3539
3540 void noinline
3541 ev_io_stop (EV_P_ ev_io *w) EV_THROW
3542 {
3543   clear_pending (EV_A_ (W)w);
3544   if (expect_false (!ev_is_active (w)))
3545     return;
3546
3547   assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3548
3549   EV_FREQUENT_CHECK;
3550
3551   wlist_del (&anfds[w->fd].head, (WL)w);
3552   ev_stop (EV_A_ (W)w);
3553
3554   fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3555
3556   EV_FREQUENT_CHECK;
3557 }
3558
3559 void noinline
3560 ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3561 {
3562   if (expect_false (ev_is_active (w)))
3563     return;
3564
3565   ev_at (w) += mn_now;
3566
3567   assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
3568
3569   EV_FREQUENT_CHECK;
3570
3571   ++timercnt;
3572   ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
3573   array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);
3574   ANHE_w (timers [ev_active (w)]) = (WT)w;
3575   ANHE_at_cache (timers [ev_active (w)]);
3576   upheap (timers, ev_active (w));
3577
3578   EV_FREQUENT_CHECK;
3579
3580   /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3581 }
3582
3583 void noinline
3584 ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3585 {
3586   clear_pending (EV_A_ (W)w);
3587   if (expect_false (!ev_is_active (w)))
3588     return;
3589
3590   EV_FREQUENT_CHECK;
3591
3592   {
3593     int active = ev_active (w);
3594
3595     assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
3596
3597     --timercnt;
3598
3599     if (expect_true (active < timercnt + HEAP0))
3600       {
3601         timers [active] = timers [timercnt + HEAP0];
3602         adjustheap (timers, timercnt, active);
3603       }
3604   }
3605
3606   ev_at (w) -= mn_now;
3607
3608   ev_stop (EV_A_ (W)w);
3609
3610   EV_FREQUENT_CHECK;
3611 }
3612
3613 void noinline
3614 ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3615 {
3616   EV_FREQUENT_CHECK;
3617
3618   clear_pending (EV_A_ (W)w);
3619
3620   if (ev_is_active (w))
3621     {
3622       if (w->repeat)
3623         {
3624           ev_at (w) = mn_now + w->repeat;
3625           ANHE_at_cache (timers [ev_active (w)]);
3626           adjustheap (timers, timercnt, ev_active (w));
3627         }
3628       else
3629         ev_timer_stop (EV_A_ w);
3630     }
3631   else if (w->repeat)
3632     {
3633       ev_at (w) = w->repeat;
3634       ev_timer_start (EV_A_ w);
3635     }
3636
3637   EV_FREQUENT_CHECK;
3638 }
3639
3640 ev_tstamp
3641 ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
3642 {
3643   return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3644 }
3645
3646 #if EV_PERIODIC_ENABLE
3647 void noinline
3648 ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3649 {
3650   if (expect_false (ev_is_active (w)))
3651     return;
3652
3653   if (w->reschedule_cb)
3654     ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3655   else if (w->interval)
3656     {
3657       assert (("libev: ev_periodic_start called with negative interval value", w->interval >= 0.));
3658       periodic_recalc (EV_A_ w);
3659     }
3660   else
3661     ev_at (w) = w->offset;
3662
3663   EV_FREQUENT_CHECK;
3664
3665   ++periodiccnt;
3666   ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
3667   array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
3668   ANHE_w (periodics [ev_active (w)]) = (WT)w;
3669   ANHE_at_cache (periodics [ev_active (w)]);
3670   upheap (periodics, ev_active (w));
3671
3672   EV_FREQUENT_CHECK;
3673
3674   /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3675 }
3676
3677 void noinline
3678 ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3679 {
3680   clear_pending (EV_A_ (W)w);
3681   if (expect_false (!ev_is_active (w)))
3682     return;
3683
3684   EV_FREQUENT_CHECK;
3685
3686   {
3687     int active = ev_active (w);
3688
3689     assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
3690
3691     --periodiccnt;
3692
3693     if (expect_true (active < periodiccnt + HEAP0))
3694       {
3695         periodics [active] = periodics [periodiccnt + HEAP0];
3696         adjustheap (periodics, periodiccnt, active);
3697       }
3698   }
3699
3700   ev_stop (EV_A_ (W)w);
3701
3702   EV_FREQUENT_CHECK;
3703 }
3704
3705 void noinline
3706 ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3707 {
3708   /* TODO: use adjustheap and recalculation */
3709   ev_periodic_stop (EV_A_ w);
3710   ev_periodic_start (EV_A_ w);
3711 }
3712 #endif
3713
3714 #ifndef SA_RESTART
3715 # define SA_RESTART 0
3716 #endif
3717
3718 #if EV_SIGNAL_ENABLE
3719
3720 void noinline
3721 ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3722 {
3723   if (expect_false (ev_is_active (w)))
3724     return;
3725
3726   assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
3727
3728 #if EV_MULTIPLICITY
3729   assert (("libev: a signal must not be attached to two different loops",
3730            !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3731
3732   signals [w->signum - 1].loop = EV_A;
3733   ECB_MEMORY_FENCE_RELEASE;
3734 #endif
3735
3736   EV_FREQUENT_CHECK;
3737
3738 #if EV_USE_SIGNALFD
3739   if (sigfd == -2)
3740     {
3741       sigfd = signalfd (-1, &sigfd_set, SFD_NONBLOCK | SFD_CLOEXEC);
3742       if (sigfd < 0 && errno == EINVAL)
3743         sigfd = signalfd (-1, &sigfd_set, 0); /* retry without flags */
3744
3745       if (sigfd >= 0)
3746         {
3747           fd_intern (sigfd); /* doing it twice will not hurt */
3748
3749           sigemptyset (&sigfd_set);
3750
3751           ev_io_init (&sigfd_w, sigfdcb, sigfd, EV_READ);
3752           ev_set_priority (&sigfd_w, EV_MAXPRI);
3753           ev_io_start (EV_A_ &sigfd_w);
3754           ev_unref (EV_A); /* signalfd watcher should not keep loop alive */
3755         }
3756     }
3757
3758   if (sigfd >= 0)
3759     {
3760       /* TODO: check .head */
3761       sigaddset (&sigfd_set, w->signum);
3762       sigprocmask (SIG_BLOCK, &sigfd_set, 0);
3763
3764       signalfd (sigfd, &sigfd_set, 0);
3765     }
3766 #endif
3767
3768   ev_start (EV_A_ (W)w, 1);
3769   wlist_add (&signals [w->signum - 1].head, (WL)w);
3770
3771   if (!((WL)w)->next)
3772 # if EV_USE_SIGNALFD
3773     if (sigfd < 0) /*TODO*/
3774 # endif
3775       {
3776 # ifdef _WIN32
3777         evpipe_init (EV_A);
3778
3779         signal (w->signum, ev_sighandler);
3780 # else
3781         struct sigaction sa;
3782
3783         evpipe_init (EV_A);
3784
3785         sa.sa_handler = ev_sighandler;
3786         sigfillset (&sa.sa_mask);
3787         sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
3788         sigaction (w->signum, &sa, 0);
3789
3790         if (origflags & EVFLAG_NOSIGMASK)
3791           {
3792             sigemptyset (&sa.sa_mask);
3793             sigaddset (&sa.sa_mask, w->signum);
3794             sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
3795           }
3796 #endif
3797       }
3798
3799   EV_FREQUENT_CHECK;
3800 }
3801
3802 void noinline
3803 ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3804 {
3805   clear_pending (EV_A_ (W)w);
3806   if (expect_false (!ev_is_active (w)))
3807     return;
3808
3809   EV_FREQUENT_CHECK;
3810
3811   wlist_del (&signals [w->signum - 1].head, (WL)w);
3812   ev_stop (EV_A_ (W)w);
3813
3814   if (!signals [w->signum - 1].head)
3815     {
3816 #if EV_MULTIPLICITY
3817       signals [w->signum - 1].loop = 0; /* unattach from signal */
3818 #endif
3819 #if EV_USE_SIGNALFD
3820       if (sigfd >= 0)
3821         {
3822           sigset_t ss;
3823
3824           sigemptyset (&ss);
3825           sigaddset (&ss, w->signum);
3826           sigdelset (&sigfd_set, w->signum);
3827
3828           signalfd (sigfd, &sigfd_set, 0);
3829           sigprocmask (SIG_UNBLOCK, &ss, 0);
3830         }
3831       else
3832 #endif
3833         signal (w->signum, SIG_DFL);
3834     }
3835
3836   EV_FREQUENT_CHECK;
3837 }
3838
3839 #endif
3840
3841 #if EV_CHILD_ENABLE
3842
3843 void
3844 ev_child_start (EV_P_ ev_child *w) EV_THROW
3845 {
3846 #if EV_MULTIPLICITY
3847   assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3848 #endif
3849   if (expect_false (ev_is_active (w)))
3850     return;
3851
3852   EV_FREQUENT_CHECK;
3853
3854   ev_start (EV_A_ (W)w, 1);
3855   wlist_add (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
3856
3857   EV_FREQUENT_CHECK;
3858 }
3859
3860 void
3861 ev_child_stop (EV_P_ ev_child *w) EV_THROW
3862 {
3863   clear_pending (EV_A_ (W)w);
3864   if (expect_false (!ev_is_active (w)))
3865     return;
3866
3867   EV_FREQUENT_CHECK;
3868
3869   wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
3870   ev_stop (EV_A_ (W)w);
3871
3872   EV_FREQUENT_CHECK;
3873 }
3874
3875 #endif
3876
3877 #if EV_STAT_ENABLE
3878
3879 # ifdef _WIN32
3880 #  undef lstat
3881 #  define lstat(a,b) _stati64 (a,b)
3882 # endif
3883
3884 #define DEF_STAT_INTERVAL  5.0074891
3885 #define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
3886 #define MIN_STAT_INTERVAL  0.1074891
3887
3888 static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
3889
3890 #if EV_USE_INOTIFY
3891
3892 /* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
3893 # define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3894
3895 static void noinline
3896 infy_add (EV_P_ ev_stat *w)
3897 {
3898   w->wd = inotify_add_watch (fs_fd, w->path,
3899                              IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
3900                              | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
3901                              | IN_DONT_FOLLOW | IN_MASK_ADD);
3902
3903   if (w->wd >= 0)
3904     {
3905       struct statfs sfs;
3906
3907       /* now local changes will be tracked by inotify, but remote changes won't */
3908       /* unless the filesystem is known to be local, we therefore still poll */
3909       /* also do poll on <2.6.25, but with normal frequency */
3910
3911       if (!fs_2625)
3912         w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3913       else if (!statfs (w->path, &sfs)
3914                && (sfs.f_type == 0x1373 /* devfs */
3915                    || sfs.f_type == 0x4006 /* fat */
3916                    || sfs.f_type == 0x4d44 /* msdos */
3917                    || sfs.f_type == 0xEF53 /* ext2/3 */
3918                    || sfs.f_type == 0x72b6 /* jffs2 */
3919                    || sfs.f_type == 0x858458f6 /* ramfs */
3920                    || sfs.f_type == 0x5346544e /* ntfs */
3921                    || sfs.f_type == 0x3153464a /* jfs */
3922                    || sfs.f_type == 0x9123683e /* btrfs */
3923                    || sfs.f_type == 0x52654973 /* reiser3 */
3924                    || sfs.f_type == 0x01021994 /* tmpfs */
3925                    || sfs.f_type == 0x58465342 /* xfs */))
3926         w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3927       else
3928         w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3929     }
3930   else
3931     {
3932       /* can't use inotify, continue to stat */
3933       w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3934
3935       /* if path is not there, monitor some parent directory for speedup hints */
3936       /* note that exceeding the hardcoded path limit is not a correctness issue, */
3937       /* but an efficiency issue only */
3938       if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096)
3939         {
3940           char path [4096];
3941           strcpy (path, w->path);
3942
3943           do
3944             {
3945               int mask = IN_MASK_ADD | IN_DELETE_SELF | IN_MOVE_SELF
3946                        | (errno == EACCES ? IN_ATTRIB : IN_CREATE | IN_MOVED_TO);
3947
3948               char *pend = strrchr (path, '/');
3949
3950               if (!pend || pend == path)
3951                 break;
3952
3953               *pend = 0;
3954               w->wd = inotify_add_watch (fs_fd, path, mask);
3955             }
3956           while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
3957         }
3958     }
3959
3960   if (w->wd >= 0)
3961     wlist_add (&fs_hash [w->wd & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
3962
3963   /* now re-arm timer, if required */
3964   if (ev_is_active (&w->timer)) ev_ref (EV_A);
3965   ev_timer_again (EV_A_ &w->timer);
3966   if (ev_is_active (&w->timer)) ev_unref (EV_A);
3967 }
3968
3969 static void noinline
3970 infy_del (EV_P_ ev_stat *w)
3971 {
3972   int slot;
3973   int wd = w->wd;
3974
3975   if (wd < 0)
3976     return;
3977
3978   w->wd = -2;
3979   slot = wd & ((EV_INOTIFY_HASHSIZE) - 1);
3980   wlist_del (&fs_hash [slot].head, (WL)w);
3981
3982   /* remove this watcher, if others are watching it, they will rearm */
3983   inotify_rm_watch (fs_fd, wd);
3984 }
3985
3986 static void noinline
3987 infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
3988 {
3989   if (slot < 0)
3990     /* overflow, need to check for all hash slots */
3991     for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
3992       infy_wd (EV_A_ slot, wd, ev);
3993   else
3994     {
3995       WL w_;
3996
3997       for (w_ = fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head; w_; )
3998         {
3999           ev_stat *w = (ev_stat *)w_;
4000           w_ = w_->next; /* lets us remove this watcher and all before it */
4001
4002           if (w->wd == wd || wd == -1)
4003             {
4004               if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF))
4005                 {
4006                   wlist_del (&fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
4007                   w->wd = -1;
4008                   infy_add (EV_A_ w); /* re-add, no matter what */
4009                 }
4010
4011               stat_timer_cb (EV_A_ &w->timer, 0);
4012             }
4013         }
4014     }
4015 }
4016
4017 static void
4018 infy_cb (EV_P_ ev_io *w, int revents)
4019 {
4020   char buf [EV_INOTIFY_BUFSIZE];
4021   int ofs;
4022   int len = read (fs_fd, buf, sizeof (buf));
4023
4024   for (ofs = 0; ofs < len; )
4025     {
4026       struct inotify_event *ev = (struct inotify_event *)(buf + ofs);
4027       infy_wd (EV_A_ ev->wd, ev->wd, ev);
4028       ofs += sizeof (struct inotify_event) + ev->len;
4029     }
4030 }
4031
4032 inline_size void ecb_cold
4033 ev_check_2625 (EV_P)
4034 {
4035   /* kernels < 2.6.25 are borked
4036    * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
4037    */
4038   if (ev_linux_version () < 0x020619)
4039     return;
4040
4041   fs_2625 = 1;
4042 }
4043
4044 inline_size int
4045 infy_newfd (void)
4046 {
4047 #if defined IN_CLOEXEC && defined IN_NONBLOCK
4048   int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK);
4049   if (fd >= 0)
4050     return fd;
4051 #endif
4052   return inotify_init ();
4053 }
4054
4055 inline_size void
4056 infy_init (EV_P)
4057 {
4058   if (fs_fd != -2)
4059     return;
4060
4061   fs_fd = -1;
4062
4063   ev_check_2625 (EV_A);
4064
4065   fs_fd = infy_newfd ();
4066
4067   if (fs_fd >= 0)
4068     {
4069       fd_intern (fs_fd);
4070       ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
4071       ev_set_priority (&fs_w, EV_MAXPRI);
4072       ev_io_start (EV_A_ &fs_w);
4073       ev_unref (EV_A);
4074     }
4075 }
4076
4077 inline_size void
4078 infy_fork (EV_P)
4079 {
4080   int slot;
4081
4082   if (fs_fd < 0)
4083     return;
4084
4085   ev_ref (EV_A);
4086   ev_io_stop (EV_A_ &fs_w);
4087   close (fs_fd);
4088   fs_fd = infy_newfd ();
4089
4090   if (fs_fd >= 0)
4091     {
4092       fd_intern (fs_fd);
4093       ev_io_set (&fs_w, fs_fd, EV_READ);
4094       ev_io_start (EV_A_ &fs_w);
4095       ev_unref (EV_A);
4096     }
4097
4098   for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
4099     {
4100       WL w_ = fs_hash [slot].head;
4101       fs_hash [slot].head = 0;
4102
4103       while (w_)
4104         {
4105           ev_stat *w = (ev_stat *)w_;
4106           w_ = w_->next; /* lets us add this watcher */
4107
4108           w->wd = -1;
4109
4110           if (fs_fd >= 0)
4111             infy_add (EV_A_ w); /* re-add, no matter what */
4112           else
4113             {
4114               w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
4115               if (ev_is_active (&w->timer)) ev_ref (EV_A);
4116               ev_timer_again (EV_A_ &w->timer);
4117               if (ev_is_active (&w->timer)) ev_unref (EV_A);
4118             }
4119         }
4120     }
4121 }
4122
4123 #endif
4124
4125 #ifdef _WIN32
4126 # define EV_LSTAT(p,b) _stati64 (p, b)
4127 #else
4128 # define EV_LSTAT(p,b) lstat (p, b)
4129 #endif
4130
4131 void
4132 ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
4133 {
4134   if (lstat (w->path, &w->attr) < 0)
4135     w->attr.st_nlink = 0;
4136   else if (!w->attr.st_nlink)
4137     w->attr.st_nlink = 1;
4138 }
4139
4140 static void noinline
4141 stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4142 {
4143   ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4144
4145   ev_statdata prev = w->attr;
4146   ev_stat_stat (EV_A_ w);
4147
4148   /* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
4149   if (
4150     prev.st_dev      != w->attr.st_dev
4151     || prev.st_ino   != w->attr.st_ino
4152     || prev.st_mode  != w->attr.st_mode
4153     || prev.st_nlink != w->attr.st_nlink
4154     || prev.st_uid   != w->attr.st_uid
4155     || prev.st_gid   != w->attr.st_gid
4156     || prev.st_rdev  != w->attr.st_rdev
4157     || prev.st_size  != w->attr.st_size
4158     || prev.st_atime != w->attr.st_atime
4159     || prev.st_mtime != w->attr.st_mtime
4160     || prev.st_ctime != w->attr.st_ctime
4161   ) {
4162       /* we only update w->prev on actual differences */
4163       /* in case we test more often than invoke the callback, */
4164       /* to ensure that prev is always different to attr */
4165       w->prev = prev;
4166
4167       #if EV_USE_INOTIFY
4168         if (fs_fd >= 0)
4169           {
4170             infy_del (EV_A_ w);
4171             infy_add (EV_A_ w);
4172             ev_stat_stat (EV_A_ w); /* avoid race... */
4173           }
4174       #endif
4175
4176       ev_feed_event (EV_A_ w, EV_STAT);
4177     }
4178 }
4179
4180 void
4181 ev_stat_start (EV_P_ ev_stat *w) EV_THROW
4182 {
4183   if (expect_false (ev_is_active (w)))
4184     return;
4185
4186   ev_stat_stat (EV_A_ w);
4187
4188   if (w->interval < MIN_STAT_INTERVAL && w->interval)
4189     w->interval = MIN_STAT_INTERVAL;
4190
4191   ev_timer_init (&w->timer, stat_timer_cb, 0., w->interval ? w->interval : DEF_STAT_INTERVAL);
4192   ev_set_priority (&w->timer, ev_priority (w));
4193
4194 #if EV_USE_INOTIFY
4195   infy_init (EV_A);
4196
4197   if (fs_fd >= 0)
4198     infy_add (EV_A_ w);
4199   else
4200 #endif
4201     {
4202       ev_timer_again (EV_A_ &w->timer);
4203       ev_unref (EV_A);
4204     }
4205
4206   ev_start (EV_A_ (W)w, 1);
4207
4208   EV_FREQUENT_CHECK;
4209 }
4210
4211 void
4212 ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
4213 {
4214   clear_pending (EV_A_ (W)w);
4215   if (expect_false (!ev_is_active (w)))
4216     return;
4217
4218   EV_FREQUENT_CHECK;
4219
4220 #if EV_USE_INOTIFY
4221   infy_del (EV_A_ w);
4222 #endif
4223
4224   if (ev_is_active (&w->timer))
4225     {
4226       ev_ref (EV_A);
4227       ev_timer_stop (EV_A_ &w->timer);
4228     }
4229
4230   ev_stop (EV_A_ (W)w);
4231
4232   EV_FREQUENT_CHECK;
4233 }
4234 #endif
4235
4236 #if EV_IDLE_ENABLE
4237 void
4238 ev_idle_start (EV_P_ ev_idle *w) EV_THROW
4239 {
4240   if (expect_false (ev_is_active (w)))
4241     return;
4242
4243   pri_adjust (EV_A_ (W)w);
4244
4245   EV_FREQUENT_CHECK;
4246
4247   {
4248     int active = ++idlecnt [ABSPRI (w)];
4249
4250     ++idleall;
4251     ev_start (EV_A_ (W)w, active);
4252
4253     array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
4254     idles [ABSPRI (w)][active - 1] = w;
4255   }
4256
4257   EV_FREQUENT_CHECK;
4258 }
4259
4260 void
4261 ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
4262 {
4263   clear_pending (EV_A_ (W)w);
4264   if (expect_false (!ev_is_active (w)))
4265     return;
4266
4267   EV_FREQUENT_CHECK;
4268
4269   {
4270     int active = ev_active (w);
4271
4272     idles [ABSPRI (w)][active - 1] = idles [ABSPRI (w)][--idlecnt [ABSPRI (w)]];
4273     ev_active (idles [ABSPRI (w)][active - 1]) = active;
4274
4275     ev_stop (EV_A_ (W)w);
4276     --idleall;
4277   }
4278
4279   EV_FREQUENT_CHECK;
4280 }
4281 #endif
4282
4283 #if EV_PREPARE_ENABLE
4284 void
4285 ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
4286 {
4287   if (expect_false (ev_is_active (w)))
4288     return;
4289
4290   EV_FREQUENT_CHECK;
4291
4292   ev_start (EV_A_ (W)w, ++preparecnt);
4293   array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
4294   prepares [preparecnt - 1] = w;
4295
4296   EV_FREQUENT_CHECK;
4297 }
4298
4299 void
4300 ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
4301 {
4302   clear_pending (EV_A_ (W)w);
4303   if (expect_false (!ev_is_active (w)))
4304     return;
4305
4306   EV_FREQUENT_CHECK;
4307
4308   {
4309     int active = ev_active (w);
4310
4311     prepares [active - 1] = prepares [--preparecnt];
4312     ev_active (prepares [active - 1]) = active;
4313   }
4314
4315   ev_stop (EV_A_ (W)w);
4316
4317   EV_FREQUENT_CHECK;
4318 }
4319 #endif
4320
4321 #if EV_CHECK_ENABLE
4322 void
4323 ev_check_start (EV_P_ ev_check *w) EV_THROW
4324 {
4325   if (expect_false (ev_is_active (w)))
4326     return;
4327
4328   EV_FREQUENT_CHECK;
4329
4330   ev_start (EV_A_ (W)w, ++checkcnt);
4331   array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
4332   checks [checkcnt - 1] = w;
4333
4334   EV_FREQUENT_CHECK;
4335 }
4336
4337 void
4338 ev_check_stop (EV_P_ ev_check *w) EV_THROW
4339 {
4340   clear_pending (EV_A_ (W)w);
4341   if (expect_false (!ev_is_active (w)))
4342     return;
4343
4344   EV_FREQUENT_CHECK;
4345
4346   {
4347     int active = ev_active (w);
4348
4349     checks [active - 1] = checks [--checkcnt];
4350     ev_active (checks [active - 1]) = active;
4351   }
4352
4353   ev_stop (EV_A_ (W)w);
4354
4355   EV_FREQUENT_CHECK;
4356 }
4357 #endif
4358
4359 #if EV_EMBED_ENABLE
4360 void noinline
4361 ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
4362 {
4363   ev_run (w->other, EVRUN_NOWAIT);
4364 }
4365
4366 static void
4367 embed_io_cb (EV_P_ ev_io *io, int revents)
4368 {
4369   ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io));
4370
4371   if (ev_cb (w))
4372     ev_feed_event (EV_A_ (W)w, EV_EMBED);
4373   else
4374     ev_run (w->other, EVRUN_NOWAIT);
4375 }
4376
4377 static void
4378 embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)
4379 {
4380   ev_embed *w = (ev_embed *)(((char *)prepare) - offsetof (ev_embed, prepare));
4381
4382   {
4383     EV_P = w->other;
4384
4385     while (fdchangecnt)
4386       {
4387         fd_reify (EV_A);
4388         ev_run (EV_A_ EVRUN_NOWAIT);
4389       }
4390   }
4391 }
4392
4393 static void
4394 embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4395 {
4396   ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
4397
4398   ev_embed_stop (EV_A_ w);
4399
4400   {
4401     EV_P = w->other;
4402
4403     ev_loop_fork (EV_A);
4404     ev_run (EV_A_ EVRUN_NOWAIT);
4405   }
4406
4407   ev_embed_start (EV_A_ w);
4408 }
4409
4410 #if 0
4411 static void
4412 embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4413 {
4414   ev_idle_stop (EV_A_ idle);
4415 }
4416 #endif
4417
4418 void
4419 ev_embed_start (EV_P_ ev_embed *w) EV_THROW
4420 {
4421   if (expect_false (ev_is_active (w)))
4422     return;
4423
4424   {
4425     EV_P = w->other;
4426     assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
4427     ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);
4428   }
4429
4430   EV_FREQUENT_CHECK;
4431
4432   ev_set_priority (&w->io, ev_priority (w));
4433   ev_io_start (EV_A_ &w->io);
4434
4435   ev_prepare_init (&w->prepare, embed_prepare_cb);
4436   ev_set_priority (&w->prepare, EV_MINPRI);
4437   ev_prepare_start (EV_A_ &w->prepare);
4438
4439   ev_fork_init (&w->fork, embed_fork_cb);
4440   ev_fork_start (EV_A_ &w->fork);
4441
4442   /*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4443
4444   ev_start (EV_A_ (W)w, 1);
4445
4446   EV_FREQUENT_CHECK;
4447 }
4448
4449 void
4450 ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
4451 {
4452   clear_pending (EV_A_ (W)w);
4453   if (expect_false (!ev_is_active (w)))
4454     return;
4455
4456   EV_FREQUENT_CHECK;
4457
4458   ev_io_stop      (EV_A_ &w->io);
4459   ev_prepare_stop (EV_A_ &w->prepare);
4460   ev_fork_stop    (EV_A_ &w->fork);
4461
4462   ev_stop (EV_A_ (W)w);
4463
4464   EV_FREQUENT_CHECK;
4465 }
4466 #endif
4467
4468 #if EV_FORK_ENABLE
4469 void
4470 ev_fork_start (EV_P_ ev_fork *w) EV_THROW
4471 {
4472   if (expect_false (ev_is_active (w)))
4473     return;
4474
4475   EV_FREQUENT_CHECK;
4476
4477   ev_start (EV_A_ (W)w, ++forkcnt);
4478   array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
4479   forks [forkcnt - 1] = w;
4480
4481   EV_FREQUENT_CHECK;
4482 }
4483
4484 void
4485 ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
4486 {
4487   clear_pending (EV_A_ (W)w);
4488   if (expect_false (!ev_is_active (w)))
4489     return;
4490
4491   EV_FREQUENT_CHECK;
4492
4493   {
4494     int active = ev_active (w);
4495
4496     forks [active - 1] = forks [--forkcnt];
4497     ev_active (forks [active - 1]) = active;
4498   }
4499
4500   ev_stop (EV_A_ (W)w);
4501
4502   EV_FREQUENT_CHECK;
4503 }
4504 #endif
4505
4506 #if EV_CLEANUP_ENABLE
4507 void
4508 ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
4509 {
4510   if (expect_false (ev_is_active (w)))
4511     return;
4512
4513   EV_FREQUENT_CHECK;
4514
4515   ev_start (EV_A_ (W)w, ++cleanupcnt);
4516   array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2);
4517   cleanups [cleanupcnt - 1] = w;
4518
4519   /* cleanup watchers should never keep a refcount on the loop */
4520   ev_unref (EV_A);
4521   EV_FREQUENT_CHECK;
4522 }
4523
4524 void
4525 ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
4526 {
4527   clear_pending (EV_A_ (W)w);
4528   if (expect_false (!ev_is_active (w)))
4529     return;
4530
4531   EV_FREQUENT_CHECK;
4532   ev_ref (EV_A);
4533
4534   {
4535     int active = ev_active (w);
4536
4537     cleanups [active - 1] = cleanups [--cleanupcnt];
4538     ev_active (cleanups [active - 1]) = active;
4539   }
4540
4541   ev_stop (EV_A_ (W)w);
4542
4543   EV_FREQUENT_CHECK;
4544 }
4545 #endif
4546
4547 #if EV_ASYNC_ENABLE
4548 void
4549 ev_async_start (EV_P_ ev_async *w) EV_THROW
4550 {
4551   if (expect_false (ev_is_active (w)))
4552     return;
4553
4554   w->sent = 0;
4555
4556   evpipe_init (EV_A);
4557
4558   EV_FREQUENT_CHECK;
4559
4560   ev_start (EV_A_ (W)w, ++asynccnt);
4561   array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);
4562   asyncs [asynccnt - 1] = w;
4563
4564   EV_FREQUENT_CHECK;
4565 }
4566
4567 void
4568 ev_async_stop (EV_P_ ev_async *w) EV_THROW
4569 {
4570   clear_pending (EV_A_ (W)w);
4571   if (expect_false (!ev_is_active (w)))
4572     return;
4573
4574   EV_FREQUENT_CHECK;
4575
4576   {
4577     int active = ev_active (w);
4578
4579     asyncs [active - 1] = asyncs [--asynccnt];
4580     ev_active (asyncs [active - 1]) = active;
4581   }
4582
4583   ev_stop (EV_A_ (W)w);
4584
4585   EV_FREQUENT_CHECK;
4586 }
4587
4588 void
4589 ev_async_send (EV_P_ ev_async *w) EV_THROW
4590 {
4591   w->sent = 1;
4592   evpipe_write (EV_A_ &async_pending);
4593 }
4594 #endif
4595
4596 /*****************************************************************************/
4597
4598 struct ev_once
4599 {
4600   ev_io io;
4601   ev_timer to;
4602   void (*cb)(int revents, void *arg);
4603   void *arg;
4604 };
4605
4606 static void
4607 once_cb (EV_P_ struct ev_once *once, int revents)
4608 {
4609   void (*cb)(int revents, void *arg) = once->cb;
4610   void *arg = once->arg;
4611
4612   ev_io_stop    (EV_A_ &once->io);
4613   ev_timer_stop (EV_A_ &once->to);
4614   ev_free (once);
4615
4616   cb (revents, arg);
4617 }
4618
4619 static void
4620 once_cb_io (EV_P_ ev_io *w, int revents)
4621 {
4622   struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io));
4623
4624   once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->to));
4625 }
4626
4627 static void
4628 once_cb_to (EV_P_ ev_timer *w, int revents)
4629 {
4630   struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to));
4631
4632   once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4633 }
4634
4635 void
4636 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW
4637 {
4638   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
4639
4640   if (expect_false (!once))
4641     {
4642       cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMER, arg);
4643       return;
4644     }
4645
4646   once->cb  = cb;
4647   once->arg = arg;
4648
4649   ev_init (&once->io, once_cb_io);
4650   if (fd >= 0)
4651     {
4652       ev_io_set (&once->io, fd, events);
4653       ev_io_start (EV_A_ &once->io);
4654     }
4655
4656   ev_init (&once->to, once_cb_to);
4657   if (timeout >= 0.)
4658     {
4659       ev_timer_set (&once->to, timeout, 0.);
4660       ev_timer_start (EV_A_ &once->to);
4661     }
4662 }
4663
4664 /*****************************************************************************/
4665
4666 #if EV_WALK_ENABLE
4667 void ecb_cold
4668 ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
4669 {
4670   int i, j;
4671   ev_watcher_list *wl, *wn;
4672
4673   if (types & (EV_IO | EV_EMBED))
4674     for (i = 0; i < anfdmax; ++i)
4675       for (wl = anfds [i].head; wl; )
4676         {
4677           wn = wl->next;
4678
4679 #if EV_EMBED_ENABLE
4680           if (ev_cb ((ev_io *)wl) == embed_io_cb)
4681             {
4682               if (types & EV_EMBED)
4683                 cb (EV_A_ EV_EMBED, ((char *)wl) - offsetof (struct ev_embed, io));
4684             }
4685           else
4686 #endif
4687 #if EV_USE_INOTIFY
4688           if (ev_cb ((ev_io *)wl) == infy_cb)
4689             ;
4690           else
4691 #endif
4692           if ((ev_io *)wl != &pipe_w)
4693             if (types & EV_IO)
4694               cb (EV_A_ EV_IO, wl);
4695
4696           wl = wn;
4697         }
4698
4699   if (types & (EV_TIMER | EV_STAT))
4700     for (i = timercnt + HEAP0; i-- > HEAP0; )
4701 #if EV_STAT_ENABLE
4702       /*TODO: timer is not always active*/
4703       if (ev_cb ((ev_timer *)ANHE_w (timers [i])) == stat_timer_cb)
4704         {
4705           if (types & EV_STAT)
4706             cb (EV_A_ EV_STAT, ((char *)ANHE_w (timers [i])) - offsetof (struct ev_stat, timer));
4707         }
4708       else
4709 #endif
4710       if (types & EV_TIMER)
4711         cb (EV_A_ EV_TIMER, ANHE_w (timers [i]));
4712
4713 #if EV_PERIODIC_ENABLE
4714   if (types & EV_PERIODIC)
4715     for (i = periodiccnt + HEAP0; i-- > HEAP0; )
4716       cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
4717 #endif
4718
4719 #if EV_IDLE_ENABLE
4720   if (types & EV_IDLE)
4721     for (j = NUMPRI; j--; )
4722       for (i = idlecnt [j]; i--; )
4723         cb (EV_A_ EV_IDLE, idles [j][i]);
4724 #endif
4725
4726 #if EV_FORK_ENABLE
4727   if (types & EV_FORK)
4728     for (i = forkcnt; i--; )
4729       if (ev_cb (forks [i]) != embed_fork_cb)
4730         cb (EV_A_ EV_FORK, forks [i]);
4731 #endif
4732
4733 #if EV_ASYNC_ENABLE
4734   if (types & EV_ASYNC)
4735     for (i = asynccnt; i--; )
4736       cb (EV_A_ EV_ASYNC, asyncs [i]);
4737 #endif
4738
4739 #if EV_PREPARE_ENABLE
4740   if (types & EV_PREPARE)
4741     for (i = preparecnt; i--; )
4742 # if EV_EMBED_ENABLE
4743       if (ev_cb (prepares [i]) != embed_prepare_cb)
4744 # endif
4745         cb (EV_A_ EV_PREPARE, prepares [i]);
4746 #endif
4747
4748 #if EV_CHECK_ENABLE
4749   if (types & EV_CHECK)
4750     for (i = checkcnt; i--; )
4751       cb (EV_A_ EV_CHECK, checks [i]);
4752 #endif
4753
4754 #if EV_SIGNAL_ENABLE
4755   if (types & EV_SIGNAL)
4756     for (i = 0; i < EV_NSIG - 1; ++i)
4757       for (wl = signals [i].head; wl; )
4758         {
4759           wn = wl->next;
4760           cb (EV_A_ EV_SIGNAL, wl);
4761           wl = wn;
4762         }
4763 #endif
4764
4765 #if EV_CHILD_ENABLE
4766   if (types & EV_CHILD)
4767     for (i = (EV_PID_HASHSIZE); i--; )
4768       for (wl = childs [i]; wl; )
4769         {
4770           wn = wl->next;
4771           cb (EV_A_ EV_CHILD, wl);
4772           wl = wn;
4773         }
4774 #endif
4775 /* EV_STAT     0x00001000 /* stat data changed */
4776 /* EV_EMBED    0x00010000 /* embedded event loop needs sweep */
4777 }
4778 #endif
4779
4780 #if EV_MULTIPLICITY
4781   #include "ev_wrap.h"
4782 #endif
4783