PageRenderTime 416ms CodeModel.GetById 160ms app.highlight 68ms RepoModel.GetById 175ms app.codeStats 1ms

/src/libev/ev.c

http://github.com/jacksonh/manos
C | 3878 lines | 2930 code | 703 blank | 245 comment | 505 complexity | 8beea16dda02c1d1b8b9d1c7d1de7e57 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * libev event processing core, watcher management
   3 *
   4 * Copyright (c) 2007,2008,2009,2010,2011 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_CLOCK_SYSCALL
  49#  ifndef EV_USE_CLOCK_SYSCALL
  50#   define EV_USE_CLOCK_SYSCALL 1
  51#   ifndef EV_USE_REALTIME
  52#    define EV_USE_REALTIME  0
  53#   endif
  54#   ifndef EV_USE_MONOTONIC
  55#    define EV_USE_MONOTONIC 1
  56#   endif
  57#  endif
  58# elif !defined(EV_USE_CLOCK_SYSCALL)
  59#  define EV_USE_CLOCK_SYSCALL 0
  60# endif
  61
  62# if HAVE_CLOCK_GETTIME
  63#  ifndef EV_USE_MONOTONIC
  64#   define EV_USE_MONOTONIC 1
  65#  endif
  66#  ifndef EV_USE_REALTIME
  67#   define EV_USE_REALTIME  0
  68#  endif
  69# else
  70#  ifndef EV_USE_MONOTONIC
  71#   define EV_USE_MONOTONIC 0
  72#  endif
  73#  ifndef EV_USE_REALTIME
  74#   define EV_USE_REALTIME  0
  75#  endif
  76# endif
  77
  78# if HAVE_NANOSLEEP
  79#  ifndef EV_USE_NANOSLEEP
  80#    define EV_USE_NANOSLEEP EV_FEATURE_OS
  81#  endif
  82# else
  83#   undef EV_USE_NANOSLEEP
  84#   define EV_USE_NANOSLEEP 0
  85# endif
  86
  87# if HAVE_SELECT && HAVE_SYS_SELECT_H
  88#  ifndef EV_USE_SELECT
  89#   define EV_USE_SELECT EV_FEATURE_BACKENDS
  90#  endif
  91# else
  92#  undef EV_USE_SELECT
  93#  define EV_USE_SELECT 0
  94# endif
  95
  96# if HAVE_POLL && HAVE_POLL_H
  97#  ifndef EV_USE_POLL
  98#   define EV_USE_POLL EV_FEATURE_BACKENDS
  99#  endif
 100# else
 101#  undef EV_USE_POLL
 102#  define EV_USE_POLL 0
 103# endif
 104   
 105# if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
 106#  ifndef EV_USE_EPOLL
 107#   define EV_USE_EPOLL EV_FEATURE_BACKENDS
 108#  endif
 109# else
 110#  undef EV_USE_EPOLL
 111#  define EV_USE_EPOLL 0
 112# endif
 113   
 114# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
 115#  ifndef EV_USE_KQUEUE
 116#   define EV_USE_KQUEUE EV_FEATURE_BACKENDS
 117#  endif
 118# else
 119#  undef EV_USE_KQUEUE
 120#  define EV_USE_KQUEUE 0
 121# endif
 122   
 123# if HAVE_PORT_H && HAVE_PORT_CREATE
 124#  ifndef EV_USE_PORT
 125#   define EV_USE_PORT EV_FEATURE_BACKENDS
 126#  endif
 127# else
 128#  undef EV_USE_PORT
 129#  define EV_USE_PORT 0
 130# endif
 131
 132# if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
 133#  ifndef EV_USE_INOTIFY
 134#   define EV_USE_INOTIFY EV_FEATURE_OS
 135#  endif
 136# else
 137#  undef EV_USE_INOTIFY
 138#  define EV_USE_INOTIFY 0
 139# endif
 140
 141# if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
 142#  ifndef EV_USE_SIGNALFD
 143#   define EV_USE_SIGNALFD EV_FEATURE_OS
 144#  endif
 145# else
 146#  undef EV_USE_SIGNALFD
 147#  define EV_USE_SIGNALFD 0
 148# endif
 149
 150# if HAVE_EVENTFD
 151#  ifndef EV_USE_EVENTFD
 152#   define EV_USE_EVENTFD EV_FEATURE_OS
 153#  endif
 154# else
 155#  undef EV_USE_EVENTFD
 156#  define EV_USE_EVENTFD 0
 157# endif
 158 
 159#endif
 160
 161#include <math.h>
 162#include <stdlib.h>
 163#include <string.h>
 164#include <fcntl.h>
 165#include <stddef.h>
 166
 167#include <stdio.h>
 168
 169#include <assert.h>
 170#include <errno.h>
 171#include <sys/types.h>
 172#include <time.h>
 173#include <limits.h>
 174
 175#include <signal.h>
 176
 177#ifdef EV_H
 178# include EV_H
 179#else
 180# include "ev.h"
 181#endif
 182
 183EV_CPP(extern "C" {)
 184
 185#ifndef _WIN32
 186# include <sys/time.h>
 187# include <sys/wait.h>
 188# include <unistd.h>
 189#else
 190# include <io.h>
 191# define WIN32_LEAN_AND_MEAN
 192# include <windows.h>
 193# ifndef EV_SELECT_IS_WINSOCKET
 194#  define EV_SELECT_IS_WINSOCKET 1
 195# endif
 196# undef EV_AVOID_STDIO
 197#endif
 198
 199/* OS X, in its infinite idiocy, actually HARDCODES
 200 * a limit of 1024 into their select. Where people have brains,
 201 * OS X engineers apparently have a vacuum. Or maybe they were
 202 * ordered to have a vacuum, or they do anything for money.
 203 * This might help. Or not.
 204 */
 205#define _DARWIN_UNLIMITED_SELECT 1
 206
 207/* this block tries to deduce configuration from header-defined symbols and defaults */
 208
 209/* try to deduce the maximum number of signals on this platform */
 210#if defined (EV_NSIG)
 211/* use what's provided */
 212#elif defined (NSIG)
 213# define EV_NSIG (NSIG)
 214#elif defined(_NSIG)
 215# define EV_NSIG (_NSIG)
 216#elif defined (SIGMAX)
 217# define EV_NSIG (SIGMAX+1)
 218#elif defined (SIG_MAX)
 219# define EV_NSIG (SIG_MAX+1)
 220#elif defined (_SIG_MAX)
 221# define EV_NSIG (_SIG_MAX+1)
 222#elif defined (MAXSIG)
 223# define EV_NSIG (MAXSIG+1)
 224#elif defined (MAX_SIG)
 225# define EV_NSIG (MAX_SIG+1)
 226#elif defined (SIGARRAYSIZE)
 227# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
 228#elif defined (_sys_nsig)
 229# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
 230#else
 231# error "unable to find value for NSIG, please report"
 232/* to make it compile regardless, just remove the above line, */
 233/* but consider reporting it, too! :) */
 234# define EV_NSIG 65
 235#endif
 236
 237#ifndef EV_USE_CLOCK_SYSCALL
 238# if __linux && __GLIBC__ >= 2
 239#  define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
 240# else
 241#  define EV_USE_CLOCK_SYSCALL 0
 242# endif
 243#endif
 244
 245#ifndef EV_USE_MONOTONIC
 246# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
 247#  define EV_USE_MONOTONIC EV_FEATURE_OS
 248# else
 249#  define EV_USE_MONOTONIC 0
 250# endif
 251#endif
 252
 253#ifndef EV_USE_REALTIME
 254# define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL
 255#endif
 256
 257#ifndef EV_USE_NANOSLEEP
 258# if _POSIX_C_SOURCE >= 199309L
 259#  define EV_USE_NANOSLEEP EV_FEATURE_OS
 260# else
 261#  define EV_USE_NANOSLEEP 0
 262# endif
 263#endif
 264
 265#ifndef EV_USE_SELECT
 266# define EV_USE_SELECT EV_FEATURE_BACKENDS
 267#endif
 268
 269#ifndef EV_USE_POLL
 270# ifdef _WIN32
 271#  define EV_USE_POLL 0
 272# else
 273#  define EV_USE_POLL EV_FEATURE_BACKENDS
 274# endif
 275#endif
 276
 277#ifndef EV_USE_EPOLL
 278# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
 279#  define EV_USE_EPOLL EV_FEATURE_BACKENDS
 280# else
 281#  define EV_USE_EPOLL 0
 282# endif
 283#endif
 284
 285#ifndef EV_USE_KQUEUE
 286# define EV_USE_KQUEUE 0
 287#endif
 288
 289#ifndef EV_USE_PORT
 290# define EV_USE_PORT 0
 291#endif
 292
 293#ifndef EV_USE_INOTIFY
 294# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
 295#  define EV_USE_INOTIFY EV_FEATURE_OS
 296# else
 297#  define EV_USE_INOTIFY 0
 298# endif
 299#endif
 300
 301#ifndef EV_PID_HASHSIZE
 302# define EV_PID_HASHSIZE EV_FEATURE_DATA ? 16 : 1
 303#endif
 304
 305#ifndef EV_INOTIFY_HASHSIZE
 306# define EV_INOTIFY_HASHSIZE EV_FEATURE_DATA ? 16 : 1
 307#endif
 308
 309#ifndef EV_USE_EVENTFD
 310# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
 311#  define EV_USE_EVENTFD EV_FEATURE_OS
 312# else
 313#  define EV_USE_EVENTFD 0
 314# endif
 315#endif
 316
 317#ifndef EV_USE_SIGNALFD
 318# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
 319#  define EV_USE_SIGNALFD EV_FEATURE_OS
 320# else
 321#  define EV_USE_SIGNALFD 0
 322# endif
 323#endif
 324
 325#if 0 /* debugging */
 326# define EV_VERIFY 3
 327# define EV_USE_4HEAP 1
 328# define EV_HEAP_CACHE_AT 1
 329#endif
 330
 331#ifndef EV_VERIFY
 332# define EV_VERIFY (EV_FEATURE_API ? 1 : 0)
 333#endif
 334
 335#ifndef EV_USE_4HEAP
 336# define EV_USE_4HEAP EV_FEATURE_DATA
 337#endif
 338
 339#ifndef EV_HEAP_CACHE_AT
 340# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
 341#endif
 342
 343/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
 344/* which makes programs even slower. might work on other unices, too. */
 345#if EV_USE_CLOCK_SYSCALL
 346# include <syscall.h>
 347# ifdef SYS_clock_gettime
 348#  define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
 349#  undef EV_USE_MONOTONIC
 350#  define EV_USE_MONOTONIC 1
 351# else
 352#  undef EV_USE_CLOCK_SYSCALL
 353#  define EV_USE_CLOCK_SYSCALL 0
 354# endif
 355#endif
 356
 357/* this block fixes any misconfiguration where we know we run into trouble otherwise */
 358
 359#ifdef _AIX
 360/* AIX has a completely broken poll.h header */
 361# undef EV_USE_POLL
 362# define EV_USE_POLL 0
 363#endif
 364
 365#ifndef CLOCK_MONOTONIC
 366# undef EV_USE_MONOTONIC
 367# define EV_USE_MONOTONIC 0
 368#endif
 369
 370#ifndef CLOCK_REALTIME
 371# undef EV_USE_REALTIME
 372# define EV_USE_REALTIME 0
 373#endif
 374
 375#if !EV_STAT_ENABLE
 376# undef EV_USE_INOTIFY
 377# define EV_USE_INOTIFY 0
 378#endif
 379
 380#if !EV_USE_NANOSLEEP
 381# ifndef _WIN32
 382#  include <sys/select.h>
 383# endif
 384#endif
 385
 386#if EV_USE_INOTIFY
 387# include <sys/statfs.h>
 388# include <sys/inotify.h>
 389/* some very old inotify.h headers don't have IN_DONT_FOLLOW */
 390# ifndef IN_DONT_FOLLOW
 391#  undef EV_USE_INOTIFY
 392#  define EV_USE_INOTIFY 0
 393# endif
 394#endif
 395
 396#if EV_SELECT_IS_WINSOCKET
 397# include <winsock.h>
 398#endif
 399
 400#if EV_USE_EVENTFD
 401/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
 402# include <stdint.h>
 403# ifndef EFD_NONBLOCK
 404#  define EFD_NONBLOCK O_NONBLOCK
 405# endif
 406# ifndef EFD_CLOEXEC
 407#  ifdef O_CLOEXEC
 408#   define EFD_CLOEXEC O_CLOEXEC
 409#  else
 410#   define EFD_CLOEXEC 02000000
 411#  endif
 412# endif
 413EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
 414#endif
 415
 416#if EV_USE_SIGNALFD
 417/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
 418# include <stdint.h>
 419# ifndef SFD_NONBLOCK
 420#  define SFD_NONBLOCK O_NONBLOCK
 421# endif
 422# ifndef SFD_CLOEXEC
 423#  ifdef O_CLOEXEC
 424#   define SFD_CLOEXEC O_CLOEXEC
 425#  else
 426#   define SFD_CLOEXEC 02000000
 427#  endif
 428# endif
 429EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);
 430
 431struct signalfd_siginfo
 432{
 433  uint32_t ssi_signo;
 434  char pad[128 - sizeof (uint32_t)];
 435};
 436#endif
 437
 438/**/
 439
 440#if EV_VERIFY >= 3
 441# define EV_FREQUENT_CHECK ev_verify (EV_A)
 442#else
 443# define EV_FREQUENT_CHECK do { } while (0)
 444#endif
 445
 446/*
 447 * This is used to avoid floating point rounding problems.
 448 * It is added to ev_rt_now when scheduling periodics
 449 * to ensure progress, time-wise, even when rounding
 450 * errors are against us.
 451 * This value is good at least till the year 4000.
 452 * Better solutions welcome.
 453 */
 454#define TIME_EPSILON  0.0001220703125 /* 1/8192 */
 455
 456#define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 457#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
 458
 459#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
 460#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
 461
 462#if __GNUC__ >= 4
 463# define expect(expr,value)         __builtin_expect ((expr),(value))
 464# define noinline                   __attribute__ ((noinline))
 465#else
 466# define expect(expr,value)         (expr)
 467# define noinline
 468# if __STDC_VERSION__ < 199901L && __GNUC__ < 2
 469#  define inline
 470# endif
 471#endif
 472
 473#define expect_false(expr) expect ((expr) != 0, 0)
 474#define expect_true(expr)  expect ((expr) != 0, 1)
 475#define inline_size        static inline
 476
 477#if EV_FEATURE_CODE
 478# define inline_speed      static inline
 479#else
 480# define inline_speed      static noinline
 481#endif
 482
 483#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
 484
 485#if EV_MINPRI == EV_MAXPRI
 486# define ABSPRI(w) (((W)w), 0)
 487#else
 488# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
 489#endif
 490
 491#define EMPTY       /* required for microsofts broken pseudo-c compiler */
 492#define EMPTY2(a,b) /* used to suppress some warnings */
 493
 494typedef ev_watcher *W;
 495typedef ev_watcher_list *WL;
 496typedef ev_watcher_time *WT;
 497
 498#define ev_active(w) ((W)(w))->active
 499#define ev_at(w) ((WT)(w))->at
 500
 501#if EV_USE_REALTIME
 502/* sig_atomic_t is used to avoid per-thread variables or locking but still */
 503/* giving it a reasonably high chance of working on typical architectures */
 504static EV_ATOMIC_T have_realtime; /* did clock_gettime (CLOCK_REALTIME) work? */
 505#endif
 506
 507#if EV_USE_MONOTONIC
 508static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 509#endif
 510
 511#ifndef EV_FD_TO_WIN32_HANDLE
 512# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
 513#endif
 514#ifndef EV_WIN32_HANDLE_TO_FD
 515# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
 516#endif
 517#ifndef EV_WIN32_CLOSE_FD
 518# define EV_WIN32_CLOSE_FD(fd) close (fd)
 519#endif
 520
 521#ifdef _WIN32
 522# include "ev_win32.c"
 523#endif
 524
 525/*****************************************************************************/
 526
 527#ifdef __linux
 528# include <sys/utsname.h>
 529#endif
 530
 531static unsigned int noinline
 532ev_linux_version (void)
 533{
 534#ifdef __linux
 535  unsigned int v = 0;
 536  struct utsname buf;
 537  int i;
 538  char *p = buf.release;
 539
 540  if (uname (&buf))
 541    return 0;
 542
 543  for (i = 3+1; --i; )
 544    {
 545      unsigned int c = 0;
 546
 547      for (;;)
 548        {
 549          if (*p >= '0' && *p <= '9')
 550            c = c * 10 + *p++ - '0';
 551          else
 552            {
 553              p += *p == '.';
 554              break;
 555            }
 556        }
 557
 558      v = (v << 8) | c;
 559    }
 560
 561  return v;
 562#else
 563  return 0;
 564#endif
 565}
 566
 567/*****************************************************************************/
 568
 569#if EV_AVOID_STDIO
 570static void noinline
 571ev_printerr (const char *msg)
 572{
 573  write (STDERR_FILENO, msg, strlen (msg));
 574}
 575#endif
 576
 577static void (*syserr_cb)(const char *msg);
 578
 579void
 580ev_set_syserr_cb (void (*cb)(const char *msg))
 581{
 582  syserr_cb = cb;
 583}
 584
 585static void noinline
 586ev_syserr (const char *msg)
 587{
 588  if (!msg)
 589    msg = "(libev) system error";
 590
 591  if (syserr_cb)
 592    syserr_cb (msg);
 593  else
 594    {
 595#if EV_AVOID_STDIO
 596      ev_printerr (msg);
 597      ev_printerr (": ");
 598      ev_printerr (strerror (errno));
 599      ev_printerr ("\n");
 600#else
 601      perror (msg);
 602#endif
 603      abort ();
 604    }
 605}
 606
 607static void *
 608ev_realloc_emul (void *ptr, long size)
 609{
 610#if __GLIBC__
 611  return realloc (ptr, size);
 612#else
 613  /* some systems, notably openbsd and darwin, fail to properly
 614   * implement realloc (x, 0) (as required by both ansi c-89 and
 615   * the single unix specification, so work around them here.
 616   */
 617
 618  if (size)
 619    return realloc (ptr, size);
 620
 621  free (ptr);
 622  return 0;
 623#endif
 624}
 625
 626static void *(*alloc)(void *ptr, long size) = ev_realloc_emul;
 627
 628void
 629ev_set_allocator (void *(*cb)(void *ptr, long size))
 630{
 631  alloc = cb;
 632}
 633
 634inline_speed void *
 635ev_realloc (void *ptr, long size)
 636{
 637  ptr = alloc (ptr, size);
 638
 639  if (!ptr && size)
 640    {
 641#if EV_AVOID_STDIO
 642      ev_printerr ("(libev) memory allocation failed, aborting.\n");
 643#else
 644      fprintf (stderr, "(libev) cannot allocate %ld bytes, aborting.", size);
 645#endif
 646      abort ();
 647    }
 648
 649  return ptr;
 650}
 651
 652#define ev_malloc(size) ev_realloc (0, (size))
 653#define ev_free(ptr)    ev_realloc ((ptr), 0)
 654
 655/*****************************************************************************/
 656
 657/* set in reify when reification needed */
 658#define EV_ANFD_REIFY 1
 659
 660/* file descriptor info structure */
 661typedef struct
 662{
 663  WL head;
 664  unsigned char events; /* the events watched for */
 665  unsigned char reify;  /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
 666  unsigned char emask;  /* the epoll backend stores the actual kernel mask in here */
 667  unsigned char unused;
 668#if EV_USE_EPOLL
 669  unsigned int egen;    /* generation counter to counter epoll bugs */
 670#endif
 671#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
 672  SOCKET handle;
 673#endif
 674#if EV_USE_IOCP
 675  OVERLAPPED or, ow;
 676#endif
 677} ANFD;
 678
 679/* stores the pending event set for a given watcher */
 680typedef struct
 681{
 682  W w;
 683  int events; /* the pending event set for the given watcher */
 684} ANPENDING;
 685
 686#if EV_USE_INOTIFY
 687/* hash table entry per inotify-id */
 688typedef struct
 689{
 690  WL head;
 691} ANFS;
 692#endif
 693
 694/* Heap Entry */
 695#if EV_HEAP_CACHE_AT
 696  /* a heap element */
 697  typedef struct {
 698    ev_tstamp at;
 699    WT w;
 700  } ANHE;
 701
 702  #define ANHE_w(he)        (he).w     /* access watcher, read-write */
 703  #define ANHE_at(he)       (he).at    /* access cached at, read-only */
 704  #define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
 705#else
 706  /* a heap element */
 707  typedef WT ANHE;
 708
 709  #define ANHE_w(he)        (he)
 710  #define ANHE_at(he)       (he)->at
 711  #define ANHE_at_cache(he)
 712#endif
 713
 714#if EV_MULTIPLICITY
 715
 716  struct ev_loop
 717  {
 718    ev_tstamp ev_rt_now;
 719    #define ev_rt_now ((loop)->ev_rt_now)
 720    #define VAR(name,decl) decl;
 721      #include "ev_vars.h"
 722    #undef VAR
 723  };
 724  #include "ev_wrap.h"
 725
 726  static struct ev_loop default_loop_struct;
 727  struct ev_loop *ev_default_loop_ptr;
 728
 729#else
 730
 731  ev_tstamp ev_rt_now;
 732  #define VAR(name,decl) static decl;
 733    #include "ev_vars.h"
 734  #undef VAR
 735
 736  static int ev_default_loop_ptr;
 737
 738#endif
 739
 740#if EV_FEATURE_API
 741# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
 742# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
 743# define EV_INVOKE_PENDING invoke_cb (EV_A)
 744#else
 745# define EV_RELEASE_CB (void)0
 746# define EV_ACQUIRE_CB (void)0
 747# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
 748#endif
 749
 750#define EVBREAK_RECURSE 0x80
 751
 752/*****************************************************************************/
 753
 754#ifndef EV_HAVE_EV_TIME
 755ev_tstamp
 756ev_time (void)
 757{
 758#if EV_USE_REALTIME
 759  if (expect_true (have_realtime))
 760    {
 761      struct timespec ts;
 762      clock_gettime (CLOCK_REALTIME, &ts);
 763      return ts.tv_sec + ts.tv_nsec * 1e-9;
 764    }
 765#endif
 766
 767  struct timeval tv;
 768  gettimeofday (&tv, 0);
 769  return tv.tv_sec + tv.tv_usec * 1e-6;
 770}
 771#endif
 772
 773inline_size ev_tstamp
 774get_clock (void)
 775{
 776#if EV_USE_MONOTONIC
 777  if (expect_true (have_monotonic))
 778    {
 779      struct timespec ts;
 780      clock_gettime (CLOCK_MONOTONIC, &ts);
 781      return ts.tv_sec + ts.tv_nsec * 1e-9;
 782    }
 783#endif
 784
 785  return ev_time ();
 786}
 787
 788#if EV_MULTIPLICITY
 789ev_tstamp
 790ev_now (EV_P)
 791{
 792  return ev_rt_now;
 793}
 794#endif
 795
 796void
 797ev_sleep (ev_tstamp delay)
 798{
 799  if (delay > 0.)
 800    {
 801#if EV_USE_NANOSLEEP
 802      struct timespec ts;
 803
 804      EV_TS_SET (ts, delay);
 805      nanosleep (&ts, 0);
 806#elif defined(_WIN32)
 807      Sleep ((unsigned long)(delay * 1e3));
 808#else
 809      struct timeval tv;
 810
 811      /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
 812      /* something not guaranteed by newer posix versions, but guaranteed */
 813      /* by older ones */
 814      EV_TV_SET (tv, delay);
 815      select (0, 0, 0, 0, &tv);
 816#endif
 817    }
 818}
 819
 820/*****************************************************************************/
 821
 822#define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
 823
 824/* find a suitable new size for the given array, */
 825/* hopefully by rounding to a nice-to-malloc size */
 826inline_size int
 827array_nextsize (int elem, int cur, int cnt)
 828{
 829  int ncur = cur + 1;
 830
 831  do
 832    ncur <<= 1;
 833  while (cnt > ncur);
 834
 835  /* if size is large, round to MALLOC_ROUND - 4 * longs to accomodate malloc overhead */
 836  if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
 837    {
 838      ncur *= elem;
 839      ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
 840      ncur = ncur - sizeof (void *) * 4;
 841      ncur /= elem;
 842    }
 843
 844  return ncur;
 845}
 846
 847static noinline void *
 848array_realloc (int elem, void *base, int *cur, int cnt)
 849{
 850  *cur = array_nextsize (elem, *cur, cnt);
 851  return ev_realloc (base, elem * *cur);
 852}
 853
 854#define array_init_zero(base,count)	\
 855  memset ((void *)(base), 0, sizeof (*(base)) * (count))
 856
 857#define array_needsize(type,base,cur,cnt,init)			\
 858  if (expect_false ((cnt) > (cur)))				\
 859    {								\
 860      int ocur_ = (cur);					\
 861      (base) = (type *)array_realloc				\
 862         (sizeof (type), (base), &(cur), (cnt));		\
 863      init ((base) + (ocur_), (cur) - ocur_);			\
 864    }
 865
 866#if 0
 867#define array_slim(type,stem)					\
 868  if (stem ## max < array_roundsize (stem ## cnt >> 2))		\
 869    {								\
 870      stem ## max = array_roundsize (stem ## cnt >> 1);		\
 871      base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
 872      fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
 873    }
 874#endif
 875
 876#define array_free(stem, idx) \
 877  ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
 878
 879/*****************************************************************************/
 880
 881/* dummy callback for pending events */
 882static void noinline
 883pendingcb (EV_P_ ev_prepare *w, int revents)
 884{
 885}
 886
 887void noinline
 888ev_feed_event (EV_P_ void *w, int revents)
 889{
 890  W w_ = (W)w;
 891  int pri = ABSPRI (w_);
 892
 893  if (expect_false (w_->pending))
 894    pendings [pri][w_->pending - 1].events |= revents;
 895  else
 896    {
 897      w_->pending = ++pendingcnt [pri];
 898      array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
 899      pendings [pri][w_->pending - 1].w      = w_;
 900      pendings [pri][w_->pending - 1].events = revents;
 901    }
 902}
 903
 904inline_speed void
 905feed_reverse (EV_P_ W w)
 906{
 907  array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);
 908  rfeeds [rfeedcnt++] = w;
 909}
 910
 911inline_size void
 912feed_reverse_done (EV_P_ int revents)
 913{
 914  do
 915    ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents);
 916  while (rfeedcnt);
 917}
 918
 919inline_speed void
 920queue_events (EV_P_ W *events, int eventcnt, int type)
 921{
 922  int i;
 923
 924  for (i = 0; i < eventcnt; ++i)
 925    ev_feed_event (EV_A_ events [i], type);
 926}
 927
 928/*****************************************************************************/
 929
 930inline_speed void
 931fd_event_nocheck (EV_P_ int fd, int revents)
 932{
 933  ANFD *anfd = anfds + fd;
 934  ev_io *w;
 935
 936  for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
 937    {
 938      int ev = w->events & revents;
 939
 940      if (ev)
 941        ev_feed_event (EV_A_ (W)w, ev);
 942    }
 943}
 944
 945/* do not submit kernel events for fds that have reify set */
 946/* because that means they changed while we were polling for new events */
 947inline_speed void
 948fd_event (EV_P_ int fd, int revents)
 949{
 950  ANFD *anfd = anfds + fd;
 951
 952  if (expect_true (!anfd->reify))
 953    fd_event_nocheck (EV_A_ fd, revents);
 954}
 955
 956void
 957ev_feed_fd_event (EV_P_ int fd, int revents)
 958{
 959  if (fd >= 0 && fd < anfdmax)
 960    fd_event_nocheck (EV_A_ fd, revents);
 961}
 962
 963/* make sure the external fd watch events are in-sync */
 964/* with the kernel/libev internal state */
 965inline_size void
 966fd_reify (EV_P)
 967{
 968  int i;
 969
 970  for (i = 0; i < fdchangecnt; ++i)
 971    {
 972      int fd = fdchanges [i];
 973      ANFD *anfd = anfds + fd;
 974      ev_io *w;
 975
 976      unsigned char o_events = anfd->events;
 977      unsigned char o_reify  = anfd->reify;
 978
 979      anfd->reify  = 0;
 980
 981#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
 982      if (o_reify & EV__IOFDSET)
 983        {
 984          unsigned long arg;
 985          anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
 986          assert (("libev: only socket fds supported in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
 987          printf ("oi %d %x\n", fd, anfd->handle);//D
 988        }
 989#endif
 990
 991      /*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
 992        {
 993          anfd->events = 0;
 994
 995          for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
 996            anfd->events |= (unsigned char)w->events;
 997
 998          if (o_events != anfd->events)
 999            o_reify = EV__IOFDSET; /* actually |= */
1000        }
1001
1002      if (o_reify & EV__IOFDSET)
1003        backend_modify (EV_A_ fd, o_events, anfd->events);
1004    }
1005
1006  fdchangecnt = 0;
1007}
1008
1009/* something about the given fd changed */
1010inline_size void
1011fd_change (EV_P_ int fd, int flags)
1012{
1013  unsigned char reify = anfds [fd].reify;
1014  anfds [fd].reify |= flags;
1015
1016  if (expect_true (!reify))
1017    {
1018      ++fdchangecnt;
1019      array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
1020      fdchanges [fdchangecnt - 1] = fd;
1021    }
1022}
1023
1024/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
1025inline_speed void
1026fd_kill (EV_P_ int fd)
1027{
1028  ev_io *w;
1029
1030  while ((w = (ev_io *)anfds [fd].head))
1031    {
1032      ev_io_stop (EV_A_ w);
1033      ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
1034    }
1035}
1036
1037/* check whether the given fd is actually valid, for error recovery */
1038inline_size int
1039fd_valid (int fd)
1040{
1041#ifdef _WIN32
1042  return EV_FD_TO_WIN32_HANDLE (fd) != -1;
1043#else
1044  return fcntl (fd, F_GETFD) != -1;
1045#endif
1046}
1047
1048/* called on EBADF to verify fds */
1049static void noinline
1050fd_ebadf (EV_P)
1051{
1052  int fd;
1053
1054  for (fd = 0; fd < anfdmax; ++fd)
1055    if (anfds [fd].events)
1056      if (!fd_valid (fd) && errno == EBADF)
1057        fd_kill (EV_A_ fd);
1058}
1059
1060/* called on ENOMEM in select/poll to kill some fds and retry */
1061static void noinline
1062fd_enomem (EV_P)
1063{
1064  int fd;
1065
1066  for (fd = anfdmax; fd--; )
1067    if (anfds [fd].events)
1068      {
1069        fd_kill (EV_A_ fd);
1070        break;
1071      }
1072}
1073
1074/* usually called after fork if backend needs to re-arm all fds from scratch */
1075static void noinline
1076fd_rearm_all (EV_P)
1077{
1078  int fd;
1079
1080  for (fd = 0; fd < anfdmax; ++fd)
1081    if (anfds [fd].events)
1082      {
1083        anfds [fd].events = 0;
1084        anfds [fd].emask  = 0;
1085        fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
1086      }
1087}
1088
1089/* used to prepare libev internal fd's */
1090/* this is not fork-safe */
1091inline_speed void
1092fd_intern (int fd)
1093{
1094#ifdef _WIN32
1095  unsigned long arg = 1;
1096  ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
1097#else
1098  fcntl (fd, F_SETFD, FD_CLOEXEC);
1099  fcntl (fd, F_SETFL, O_NONBLOCK);
1100#endif
1101}
1102
1103/*****************************************************************************/
1104
1105/*
1106 * the heap functions want a real array index. array index 0 is guaranteed to not
1107 * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
1108 * the branching factor of the d-tree.
1109 */
1110
1111/*
1112 * at the moment we allow libev the luxury of two heaps,
1113 * a small-code-size 2-heap one and a ~1.5kb larger 4-heap
1114 * which is more cache-efficient.
1115 * the difference is about 5% with 50000+ watchers.
1116 */
1117#if EV_USE_4HEAP
1118
1119#define DHEAP 4
1120#define HEAP0 (DHEAP - 1) /* index of first element in heap */
1121#define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
1122#define UPHEAP_DONE(p,k) ((p) == (k))
1123
1124/* away from the root */
1125inline_speed void
1126downheap (ANHE *heap, int N, int k)
1127{
1128  ANHE he = heap [k];
1129  ANHE *E = heap + N + HEAP0;
1130
1131  for (;;)
1132    {
1133      ev_tstamp minat;
1134      ANHE *minpos;
1135      ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
1136
1137      /* find minimum child */
1138      if (expect_true (pos + DHEAP - 1 < E))
1139        {
1140          /* fast path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
1141          if (               ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1142          if (               ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1143          if (               ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1144        }
1145      else if (pos < E)
1146        {
1147          /* slow path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
1148          if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1149          if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1150          if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1151        }
1152      else
1153        break;
1154
1155      if (ANHE_at (he) <= minat)
1156        break;
1157
1158      heap [k] = *minpos;
1159      ev_active (ANHE_w (*minpos)) = k;
1160
1161      k = minpos - heap;
1162    }
1163
1164  heap [k] = he;
1165  ev_active (ANHE_w (he)) = k;
1166}
1167
1168#else /* 4HEAP */
1169
1170#define HEAP0 1
1171#define HPARENT(k) ((k) >> 1)
1172#define UPHEAP_DONE(p,k) (!(p))
1173
1174/* away from the root */
1175inline_speed void
1176downheap (ANHE *heap, int N, int k)
1177{
1178  ANHE he = heap [k];
1179
1180  for (;;)
1181    {
1182      int c = k << 1;
1183
1184      if (c >= N + HEAP0)
1185        break;
1186
1187      c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
1188           ? 1 : 0;
1189
1190      if (ANHE_at (he) <= ANHE_at (heap [c]))
1191        break;
1192
1193      heap [k] = heap [c];
1194      ev_active (ANHE_w (heap [k])) = k;
1195      
1196      k = c;
1197    }
1198
1199  heap [k] = he;
1200  ev_active (ANHE_w (he)) = k;
1201}
1202#endif
1203
1204/* towards the root */
1205inline_speed void
1206upheap (ANHE *heap, int k)
1207{
1208  ANHE he = heap [k];
1209
1210  for (;;)
1211    {
1212      int p = HPARENT (k);
1213
1214      if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
1215        break;
1216
1217      heap [k] = heap [p];
1218      ev_active (ANHE_w (heap [k])) = k;
1219      k = p;
1220    }
1221
1222  heap [k] = he;
1223  ev_active (ANHE_w (he)) = k;
1224}
1225
1226/* move an element suitably so it is in a correct place */
1227inline_size void
1228adjustheap (ANHE *heap, int N, int k)
1229{
1230  if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)]))
1231    upheap (heap, k);
1232  else
1233    downheap (heap, N, k);
1234}
1235
1236/* rebuild the heap: this function is used only once and executed rarely */
1237inline_size void
1238reheap (ANHE *heap, int N)
1239{
1240  int i;
1241
1242  /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
1243  /* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
1244  for (i = 0; i < N; ++i)
1245    upheap (heap, i + HEAP0);
1246}
1247
1248/*****************************************************************************/
1249
1250/* associate signal watchers to a signal signal */
1251typedef struct
1252{
1253  EV_ATOMIC_T pending;
1254#if EV_MULTIPLICITY
1255  EV_P;
1256#endif
1257  WL head;
1258} ANSIG;
1259
1260static ANSIG signals [EV_NSIG - 1];
1261
1262/*****************************************************************************/
1263
1264#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
1265
1266static void noinline
1267evpipe_init (EV_P)
1268{
1269  if (!ev_is_active (&pipe_w))
1270    {
1271# if EV_USE_EVENTFD
1272      evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
1273      if (evfd < 0 && errno == EINVAL)
1274        evfd = eventfd (0, 0);
1275
1276      if (evfd >= 0)
1277        {
1278          evpipe [0] = -1;
1279          fd_intern (evfd); /* doing it twice doesn't hurt */
1280          ev_io_set (&pipe_w, evfd, EV_READ);
1281        }
1282      else
1283# endif
1284        {
1285          while (pipe (evpipe))
1286            ev_syserr ("(libev) error creating signal/async pipe");
1287
1288          fd_intern (evpipe [0]);
1289          fd_intern (evpipe [1]);
1290          ev_io_set (&pipe_w, evpipe [0], EV_READ);
1291        }
1292
1293      ev_io_start (EV_A_ &pipe_w);
1294      ev_unref (EV_A); /* watcher should not keep loop alive */
1295    }
1296}
1297
1298inline_size void
1299evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1300{
1301  if (!*flag)
1302    {
1303      int old_errno = errno; /* save errno because write might clobber it */
1304      char dummy;
1305
1306      *flag = 1;
1307
1308#if EV_USE_EVENTFD
1309      if (evfd >= 0)
1310        {
1311          uint64_t counter = 1;
1312          write (evfd, &counter, sizeof (uint64_t));
1313        }
1314      else
1315#endif
1316        /* win32 people keep sending patches that change this write() to send() */
1317        /* and then run away. but send() is wrong, it wants a socket handle on win32 */
1318        /* so when you think this write should be a send instead, please find out */
1319        /* where your send() is from - it's definitely not the microsoft send, and */
1320        /* tell me. thank you. */
1321        write (evpipe [1], &dummy, 1);
1322
1323      errno = old_errno;
1324    }
1325}
1326
1327/* called whenever the libev signal pipe */
1328/* got some events (signal, async) */
1329static void
1330pipecb (EV_P_ ev_io *iow, int revents)
1331{
1332  int i;
1333
1334#if EV_USE_EVENTFD
1335  if (evfd >= 0)
1336    {
1337      uint64_t counter;
1338      read (evfd, &counter, sizeof (uint64_t));
1339    }
1340  else
1341#endif
1342    {
1343      char dummy;
1344      /* see discussion in evpipe_write when you think this read should be recv in win32 */
1345      read (evpipe [0], &dummy, 1);
1346    }
1347
1348  if (sig_pending)
1349    {    
1350      sig_pending = 0;
1351
1352      for (i = EV_NSIG - 1; i--; )
1353        if (expect_false (signals [i].pending))
1354          ev_feed_signal_event (EV_A_ i + 1);
1355    }
1356
1357#if EV_ASYNC_ENABLE
1358  if (async_pending)
1359    {
1360      async_pending = 0;
1361
1362      for (i = asynccnt; i--; )
1363        if (asyncs [i]->sent)
1364          {
1365            asyncs [i]->sent = 0;
1366            ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
1367          }
1368    }
1369#endif
1370}
1371
1372/*****************************************************************************/
1373
1374void
1375ev_feed_signal (int signum)
1376{
1377#if EV_MULTIPLICITY
1378  EV_P = signals [signum - 1].loop;
1379
1380  if (!EV_A)
1381    return;
1382#endif
1383
1384  signals [signum - 1].pending = 1;
1385  evpipe_write (EV_A_ &sig_pending);
1386}
1387
1388static void
1389ev_sighandler (int signum)
1390{
1391#ifdef _WIN32
1392  signal (signum, ev_sighandler);
1393#endif
1394
1395  ev_feed_signal (signum);
1396}
1397
1398void noinline
1399ev_feed_signal_event (EV_P_ int signum)
1400{
1401  WL w;
1402
1403  if (expect_false (signum <= 0 || signum > EV_NSIG))
1404    return;
1405
1406  --signum;
1407
1408#if EV_MULTIPLICITY
1409  /* it is permissible to try to feed a signal to the wrong loop */
1410  /* or, likely more useful, feeding a signal nobody is waiting for */
1411
1412  if (expect_false (signals [signum].loop != EV_A))
1413    return;
1414#endif
1415
1416  signals [signum].pending = 0;
1417
1418  for (w = signals [signum].head; w; w = w->next)
1419    ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
1420}
1421
1422#if EV_USE_SIGNALFD
1423static void
1424sigfdcb (EV_P_ ev_io *iow, int revents)
1425{
1426  struct signalfd_siginfo si[2], *sip; /* these structs are big */
1427
1428  for (;;)
1429    {
1430      ssize_t res = read (sigfd, si, sizeof (si));
1431
1432      /* not ISO-C, as res might be -1, but works with SuS */
1433      for (sip = si; (char *)sip < (char *)si + res; ++sip)
1434        ev_feed_signal_event (EV_A_ sip->ssi_signo);
1435
1436      if (res < (ssize_t)sizeof (si))
1437        break;
1438    }
1439}
1440#endif
1441
1442#endif
1443
1444/*****************************************************************************/
1445
1446#if EV_CHILD_ENABLE
1447static WL childs [EV_PID_HASHSIZE];
1448
1449static ev_signal childev;
1450
1451#ifndef WIFCONTINUED
1452# define WIFCONTINUED(status) 0
1453#endif
1454
1455/* handle a single child status event */
1456inline_speed void
1457child_reap (EV_P_ int chain, int pid, int status)
1458{
1459  ev_child *w;
1460  int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
1461
1462  for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
1463    {
1464      if ((w->pid == pid || !w->pid)
1465          && (!traced || (w->flags & 1)))
1466        {
1467          ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
1468          w->rpid    = pid;
1469          w->rstatus = status;
1470          ev_feed_event (EV_A_ (W)w, EV_CHILD);
1471        }
1472    }
1473}
1474
1475#ifndef WCONTINUED
1476# define WCONTINUED 0
1477#endif
1478
1479/* called on sigchld etc., calls waitpid */
1480static void
1481childcb (EV_P_ ev_signal *sw, int revents)
1482{
1483  int pid, status;
1484
1485  /* some systems define WCONTINUED but then fail to support it (linux 2.4) */
1486  if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
1487    if (!WCONTINUED
1488        || errno != EINVAL
1489        || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
1490      return;
1491
1492  /* make sure we are called again until all children have been reaped */
1493  /* we need to do it this way so that the callback gets called before we continue */
1494  ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
1495
1496  child_reap (EV_A_ pid, pid, status);
1497  if ((EV_PID_HASHSIZE) > 1)
1498    child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
1499}
1500
1501#endif
1502
1503/*****************************************************************************/
1504
1505#if EV_USE_IOCP
1506# include "ev_iocp.c"
1507#endif
1508#if EV_USE_PORT
1509# include "ev_port.c"
1510#endif
1511#if EV_USE_KQUEUE
1512# include "ev_kqueue.c"
1513#endif
1514#if EV_USE_EPOLL
1515# include "ev_epoll.c"
1516#endif
1517#if EV_USE_POLL
1518# include "ev_poll.c"
1519#endif
1520#if EV_USE_SELECT
1521# include "ev_select.c"
1522#endif
1523
1524int
1525ev_version_major (void)
1526{
1527  return EV_VERSION_MAJOR;
1528}
1529
1530int
1531ev_version_minor (void)
1532{
1533  return EV_VERSION_MINOR;
1534}
1535
1536/* return true if we are running with elevated privileges and should ignore env variables */
1537int inline_size
1538enable_secure (void)
1539{
1540#ifdef _WIN32
1541  return 0;
1542#else
1543  return getuid () != geteuid ()
1544      || getgid () != getegid ();
1545#endif
1546}
1547
1548unsigned int
1549ev_supported_backends (void)
1550{
1551  unsigned int flags = 0;
1552
1553  if (EV_USE_PORT  ) flags |= EVBACKEND_PORT;
1554  if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
1555  if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
1556  if (EV_USE_POLL  ) flags |= EVBACKEND_POLL;
1557  if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
1558  
1559  return flags;
1560}
1561
1562unsigned int
1563ev_recommended_backends (void)
1564{
1565  unsigned int flags = ev_supported_backends ();
1566
1567#ifndef __NetBSD__
1568  /* kqueue is borked on everything but netbsd apparently */
1569  /* it usually doesn't work correctly on anything but sockets and pipes */
1570  flags &= ~EVBACKEND_KQUEUE;
1571#endif
1572#ifdef __APPLE__
1573  /* only select works correctly on that "unix-certified" platform */
1574  flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */
1575  flags &= ~EVBACKEND_POLL;   /* poll is based on kqueue from 10.5 onwards */
1576#endif
1577#ifdef __FreeBSD__
1578  flags &= ~EVBACKEND_POLL;   /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
1579#endif
1580
1581  return flags;
1582}
1583
1584unsigned int
1585ev_embeddable_backends (void)
1586{
1587  int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
1588
1589  /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
1590  if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
1591    flags &= ~EVBACKEND_EPOLL;
1592
1593  return flags;
1594}
1595
1596unsigned int
1597ev_backend (EV_P)
1598{
1599  return backend;
1600}
1601
1602#if EV_FEATURE_API
1603unsigned int
1604ev_iteration (EV_P)
1605{
1606  return loop_count;
1607}
1608
1609unsigned int
1610ev_depth (EV_P)
1611{
1612  return loop_depth;
1613}
1614
1615void
1616ev_set_io_collect_interval (EV_P_ ev_tstamp interval)
1617{
1618  io_blocktime = interval;
1619}
1620
1621void
1622ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval)
1623{
1624  timeout_blocktime = interval;
1625}
1626
1627void
1628ev_set_userdata (EV_P_ void *data)
1629{
1630  userdata = data;
1631}
1632
1633void *
1634ev_userdata (EV_P)
1635{
1636  return userdata;
1637}
1638
1639void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P))
1640{
1641  invoke_cb = invoke_pending_cb;
1642}
1643
1644void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P))
1645{
1646  release_cb = release;
1647  acquire_cb = acquire;
1648}
1649#endif
1650
1651/* initialise a loop structure, must be zero-initialised */
1652static void noinline
1653loop_init (EV_P_ unsigned int flags)
1654{
1655  if (!backend)
1656    {
1657      origflags = flags;
1658
1659#if EV_USE_REALTIME
1660      if (!have_realtime)
1661        {
1662          struct timespec ts;
1663
1664          if (!clock_gettime (CLOCK_REALTIME, &ts))
1665            have_realtime = 1;
1666        }
1667#endif
1668
1669#if EV_USE_MONOTONIC
1670      if (!have_monotonic)
1671        {
1672          struct timespec ts;
1673
1674          if (!clock_gettime (CLOCK_MONOTONIC, &ts))
1675            have_monotonic = 1;
1676        }
1677#endif
1678
1679      /* pid check not overridable via env */
1680#ifndef _WIN32
1681      if (flags & EVFLAG_FORKCHECK)
1682        curpid = getpid ();
1683#endif
1684
1685      if (!(flags & EVFLAG_NOENV)
1686          && !enable_secure ()
1687          && getenv ("LIBEV_FLAGS"))
1688        flags = atoi (getenv ("LIBEV_FLAGS"));
1689
1690      ev_rt_now         = ev_time ();
1691      mn_now            = get_clock ();
1692      now_floor         = mn_now;
1693      rtmn_diff         = ev_rt_now - mn_now;
1694#if EV_FEATURE_API
1695      invoke_cb         = ev_invoke_pending;
1696#endif
1697
1698      io_blocktime      = 0.;
1699      timeout_blocktime = 0.;
1700      backend           = 0;
1701      backend_fd        = -1;
1702      sig_pending       = 0;
1703#if EV_ASYNC_ENABLE
1704      async_pending     = 0;
1705#endif
1706#if EV_USE_INOTIFY
1707      fs_fd             = flags & EVFLAG_NOINOTIFY ? -1 : -2;
1708#endif
1709#if EV_USE_SIGNALFD
1710      sigfd             = flags & EVFLAG_SIGNALFD  ? -2 : -1;
1711#endif
1712
1713      if (!(flags & EVBACKEND_MASK))
1714        flags |= ev_recommended_backends ();
1715
1716#if EV_USE_IOCP
1717      if (!backend && (flags & EVBACKEND_IOCP  )) backend = iocp_init   (EV_A_ flags);
1718#endif
1719#if EV_USE_PORT
1720      if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
1721#endif
1722#if EV_USE_KQUEUE
1723      if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
1724#endif
1725#if EV_USE_EPOLL
1726      if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init  (EV_A_ flags);
1727#endif
1728#if EV_USE_POLL
1729      if (!backend && (flags & EVBACKEND_POLL  )) backend = poll_init   (EV_A_ flags);
1730#endif
1731#if EV_USE_SELECT
1732      if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
1733#endif
1734
1735      ev_prepare_init (&pending_w, pendingcb);
1736
1737#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
1738      ev_init (&pipe_w, pipecb);
1739      ev_set_priority (&pipe_w, EV_MAXPRI);
1740#endif
1741    }
1742}
1743
1744/* free up a loop structure */
1745void
1746ev_loop_destroy (EV_P)
1747{
1748  int i;
1749
1750#if EV_MULTIPLICITY
1751  /* mimic free (0) */
1752  if (!EV_A)
1753    return;
1754#endif
1755
1756#if EV_CLEANUP_ENABLE
1757  /* queue cleanup watchers (and execute them) */
1758  if (expect_false (cleanupcnt))
1759    {
1760      queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
1761      EV_INVOKE_PENDING;
1762    }
1763#endif
1764
1765#if EV_CHILD_ENABLE
1766  if (ev_is_active (&childev))
1767    {
1768      ev_ref (EV_A); /* child watcher */
1769      ev_signal_stop (EV_A_ &childev);
1770    }
1771#endif
1772
1773  if (ev_is_active (&pipe_w))
1774    {
1775      /*ev_ref (EV_A);*/
1776      /*ev_io_stop (EV_A_ &pipe_w);*/
1777
1778#if EV_USE_EVENTFD
1779      if (evfd >= 0)
1780        close (evfd);
1781#endif
1782
1783      if (evpipe [0] >= 0)
1784        {
1785          EV_WIN32_CLOSE_FD (evpipe [0]);
1786          EV_WIN32_CLOSE_FD (evpipe [1]);
1787        }
1788    }
1789
1790#if EV_USE_SIGNALFD
1791  if (ev_is_active (&sigfd_w))
1792    close (sigfd);
1793#endif
1794
1795#if EV_USE_INOTIFY
1796  if (fs_fd >= 0)
1797    close (fs_fd);
1798#endif
1799
1800  if (backend_fd >= 0)
1801    close (backend_fd);
1802
1803#if EV_USE_IOCP
1804  if (backend == EVBACKEND_IOCP  ) iocp_destroy   (EV_A);
1805#endif
1806#if EV_USE_PORT
1807  if (backend == EVBACKEND_PORT  ) port_destroy   (EV_A);
1808#endif
1809#if EV_USE_KQUEUE
1810  if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
1811#endif
1812#if EV_USE_EPOLL
1813  if (backend == EVBACKEND_EPOLL ) epoll_destroy  (EV_A);
1814#endif
1815#if EV_USE_POLL
1816  if (backend == EVBACKEND_POLL  ) poll_destroy   (EV_A);
1817#endif
1818#if EV_USE_SELECT
1819  if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
1820#endif
1821
1822  for (i = NUMPRI; i--; )
1823    {
1824      array_free (pending, [i]);
1825#if EV_IDLE_ENABLE
1826      array_free (idle, [i]);
1827#endif
1828    }
1829
1830  ev_free (anfds); anfds = 0; anfdmax = 0;
1831
1832  /* have to use the microsoft-never-gets-it-right macro */
1833  array_free (rfeed, EMPTY);
1834  array_free (fdchange, EMPTY);
1835  array_free (timer, EMPTY);
1836#if EV_PERIODIC_ENABLE
1837  array_free (periodic, EMPTY);
1838#endif
1839#if EV_FORK_ENABLE
1840  array_free (fork, EMPTY);
1841#endif
1842#if EV_CLEANUP_ENABLE
1843  array_free (cleanup, EMPTY);
1844#endif
1845  array_free (prepare, EMPTY);
1846  array_free (check, EMPTY);
1847#if EV_ASYNC_ENABLE
1848  array_free (async, EMPTY);
1849#endif
1850
1851  backend = 0;
1852
1853#if EV_MULTIPLICITY
1854  if (ev_is_default_loop (EV_A))
1855#endif
1856    ev_default_loop_ptr = 0;
1857#if EV_MULTIPLICITY
1858  else
1859    ev_free (EV_A);
1860#endif
1861}
1862
1863#if EV_USE_INOTIFY
1864inline_size void infy_fork (EV_P);
1865#endif
1866
1867inline_size void
1868loop_fork (EV_P)
1869{
1870#if EV_USE_PORT
1871  if (backend == EVBACKEND_PORT  ) port_fork   (EV_A);
1872#endif
1873#if EV_USE_KQUEUE
1874  if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
1875#endif
1876#if EV_USE_EPOLL
1877  if (backend == EVBACKEND_EPOLL ) epoll_fork  (EV_A);
1878#endif
1879#if EV_USE_INOTIFY
1880  infy_fork (EV_A);
1881#endif
1882
1883  if (ev_is_active (&pipe_w))
1884    {
1885      /* this "locks" the handlers against writing to the pipe */
1886      /* while we modify the fd vars */
1887      sig_pending   = 1;
1888#if EV_ASYNC_ENABLE
1889      async_pending = 1;
1890#endif
1891
1892      ev_ref (EV_A);
1893      ev_io_stop (EV_A_ &pipe_w);
1894
1895#if EV_USE_EVENTFD
1896      if (evfd >= 0)
1897        close (evfd);
1898#endif
1899
1900      if (evpipe [0] >= 0)
1901        {
1902          EV_WIN32_CLOSE_FD (evpipe [0]);
1903          EV_WIN32_CLOSE_FD (evpipe [1]);
1904        }
1905
1906#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
1907      evpipe_init (EV_A);
1908      /* now iterate over everything, in case we missed something */
1909      pipecb (EV_A_ &pipe_w, EV_READ);
1910#endif
1911    }
1912
1913  postfork = 0;
1914}
1915
1916#if EV_MULTIPLICITY
1917
1918struct ev_loop *
1919ev_loop_new (unsigned int flags)
1920{
1921  EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
1922
1923  memset (EV_A, 0, sizeof (struct ev_loop));
1924  loop_init (EV_A_ flags);
1925
1926  if (ev_backend (EV_A))
1927    return EV_A;
1928
1929  ev_free (EV_A);
1930  return 0;
1931}
1932
1933#endif /* multiplicity */
1934
1935#if EV_VERIFY
1936static void noinline
1937verify_watcher (EV_P_ W w)
1938{
1939  assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
1940
1941  if (w->pending)
1942    assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
1943}
1944
1945static void noinline
1946verify_heap (EV_P_ ANHE *heap, int N)
1947{
1948  int i;
1949
1950  for (i = HEAP0; i < N + HEAP0; ++i)
1951    {
1952      assert (("libev: active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i));
1953      assert (("libev: heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i])));
1954      assert (("libev: heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i]))));
1955
1956      verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
1957    }
1958}
1959
1960static void noinline
1961array_verify (EV_P_ W *ws, int cnt)
1962{
1963  while (cnt--)
1964    {
1965      assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
1966      verify_watcher (EV_A_ ws [cnt]);
1967    }
1968}
1969#endif
1970
1971#if EV_FEATURE_API
1972void
1973ev_verify (EV_P)
1974{
1975#if EV_VERIFY
1976  int i;
1977  WL w;
1978
1979  assert (activecnt >= -1);
1980
1981  assert (fdchangemax >= fdchangecnt);
1982  for (i = 0; i < fdchangecnt; ++i)
1983    assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0));
1984
1985  assert (anfdmax >= 0);
1986  for (i = 0; i < anfdmax; ++i)
1987    for (w = anfds [i].head; w; w = w->next)
1988      {
1989        verify_watcher (EV_A_ (W)w);
1990        assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1));
1991        assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
1992      }
1993
1994  assert (timermax >= timercnt);
1995  verify_heap (EV_A_ timers, timercnt);
1996
1997#if EV_PERIODIC_ENABLE
1998  assert (periodicmax >= periodiccnt);
1999  verify_heap (EV_A_ periodics, periodiccnt);
2000#endif
2001
2002  for (i = NUMPRI; i--; )
2003    {
2004      assert (pendingmax [i] >= pendingcnt [i]);
2005#if EV_IDLE_ENABLE
2006      assert (idleall >= 0);
2007      assert (idlemax [i] >= idlecnt [i]);
2008      array_verify (EV_A_ (W *)idles [i], idlecnt [i]);
2009#endif
2010    }
2011
2012#if EV_FORK_ENABLE
2013  assert (forkmax >= forkcnt);
2014  array_verify (EV_A_ (W *)forks, forkcnt);
2015#endif
2016
2017#if EV_CLEANUP_ENABLE
2018  assert (cleanupmax >= cleanupcnt);
2019  array_verify (EV_A_ (W *)cleanups, cleanupcnt);
2020#endif
2021
2022#if EV_ASYNC_ENABLE
2023  assert (asyncmax >= asynccnt);
2024  array_verify (EV_A_ (W *)asyncs, asynccnt);
2025#endif
2026
2027#if EV_PREPARE_ENABLE
2028  assert (preparemax >= preparecnt);
2029  array_verify (EV_A_ (W *)prepares, preparecnt);
2030#endif
2031
2032#if EV_CHECK_ENABLE
2033  assert (checkmax >= checkcnt);
2034  array_verify (EV_A_ (W *)checks, checkcnt);
2035#endif
2036
2037# if 0
2038#if EV_CHILD_ENABLE
2039  for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
2040  for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
2041#endif
2042# endif
2043#endif
2044}
2045#endif
2046
2047#if EV_MULTIPLICITY
2048struct ev_loop *
2049#else
2050int
2051#endif
2052ev_default_loop (unsigned int flags)
2053{
2054  if (!ev_default_loop_ptr)
2055    {
2056#if EV_MULTIPLICITY
2057      EV_P = ev_default_loop_ptr = &default_loop_struct;
2058#else
2059      ev_default_loop_ptr = 1;
2060#endif
2061
2062      loop_init (EV_A_ flags);
2063
2064      if (ev_backend (EV_A))
2065        {
2066#if EV_CHILD_ENABLE
2067          ev_signal_init (&childev, childcb, SIGCHLD);
2068          ev_set_priority (&childev, EV_MAXPRI);
2069          ev_signal_start (EV_A_ &childev);
2070          ev_unref (EV_A); /* child watcher should not keep loop alive */
2071#endif
2072        }
2073      else
2074        ev_default_loop_ptr = 0;
2075    }
2076
2077  return ev_default_loop_ptr;
2078}
2079
2080void
2081ev_loop_fork (EV_P)
2082{
2083  postfork = 1; /* must be in line with ev_default_fork */
2084}
2085
2086/*****************************************************************************/
2087
2088void
2089ev_invoke (EV_P_ void *w, int revents)
2090{
2091  EV_CB_INVOKE ((W)w, revents);
2092}
2093
2094unsigned int
2095ev_pending_count (EV_P)
2096{
2097  int pri;
2098  unsigned int count = 0;
2099
2100  for (pri = NUMPRI; pri--; )
2101    count += pendingcnt [pri];
2102
2103  return count;
2104}
2105
2106void noinline
2107ev_invoke_pending (EV_P)
2108{
2109  int pri;
2110
2111  for (pri = NUMPRI; pri--; )
2112    while (pendingcnt [pri])
2113      {
2114        ANPENDING *p = pendings [pri] + --pendingcnt [pri];
2115
2116        p->w->pending = 0;
2117        EV_CB_INVOKE (p->w, p->events);
2118        EV_FREQUENT_CHECK;
2119      }
2120}
2121
2122#if EV_IDLE_ENABLE
2123/* make idle watchers pending. this handles the "call-idle */
2124/* only when higher priorities are idle" logic */
2125inline_size void
2126idle_reify (EV_P)
2127{
2128  if (expect_false (idleall))
2129    {
2130      int pri;
2131
2132      for (pri = NUMPRI; pri--; )
2133        {
2134          if (pendingcnt [pri])
2135            break;
2136
2137          if (idlecnt [pri])
2138            {
2139              queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
2140              break;
2141            }
2142        }
2143    }
2144}
2145#endif
2146
2147/* make timers pending */
2148inline_size void
2149timers_reify (EV_P)
2150{
2151  EV_FREQUENT_CHECK;
2152
2153  if (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
2154    {
2155      do
2156        {
2157          ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
2158
2159          /*assert (("libev: inactive timer on timer heap detected", ev_is_active (w)));*/
2160
2161          /* first reschedule or stop timer */
2162          if (w->repeat)
2163            {
2164              ev_at (w) += w->repeat;
2165              if (ev_at (w) < mn_now)
2166                ev_at (w) = mn_now;
2167
2168              assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));
2169
2170              ANHE_at_cache (timers [HEAP0]);
2171              downheap (timers, timercnt, HEAP0);
2172            }
2173          else
2174            ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
2175
2176          EV_FREQUENT_CHECK;
2177          feed_reverse (EV_A_ (W)w);
2178        }
2179      while (timercnt && ANHE_at (timers [HEAP0]) < mn_now);
2180
2181      feed_reverse_done (EV_A_ EV_TIMER);
2182    }
2183}
2184
2185#if EV_PERIODIC_ENABLE
2186/* make periodics pending */
2187inline_size void
2188periodics_reify (EV_P)
2189{
2190  EV_FREQUENT_CHECK;
2191
2192  while (periodiccnt && ANHE_at (period

Large files files are truncated, but you can click here to view the full file