/src/libev/ev.c
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