1 /* 2 * libev event processing core, watcher management 3 * 4 * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <[email protected]> 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 183 EV_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 /* hp-ux has it in sys/time.h, which we unconditionally include above */ 382 # if !defined(_WIN32) && !defined(__hpux) 383 # include <sys/select.h> 384 # endif 385 #endif 386 387 #if EV_USE_INOTIFY 388 # include <sys/statfs.h> 389 # include <sys/inotify.h> 390 /* some very old inotify.h headers don't have IN_DONT_FOLLOW */ 391 # ifndef IN_DONT_FOLLOW 392 # undef EV_USE_INOTIFY 393 # define EV_USE_INOTIFY 0 394 # endif 395 #endif 396 397 #if EV_SELECT_IS_WINSOCKET 398 # include <winsock.h> 399 #endif 400 401 #if EV_USE_EVENTFD 402 /* our minimum requirement is glibc 2.7 which has the stub, but not the header */ 403 # include <stdint.h> 404 # ifndef EFD_NONBLOCK 405 # define EFD_NONBLOCK O_NONBLOCK 406 # endif 407 # ifndef EFD_CLOEXEC 408 # ifdef O_CLOEXEC 409 # define EFD_CLOEXEC O_CLOEXEC 410 # else 411 # define EFD_CLOEXEC 02000000 412 # endif 413 # endif 414 EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags); 415 #endif 416 417 #if EV_USE_SIGNALFD 418 /* our minimum requirement is glibc 2.7 which has the stub, but not the header */ 419 # include <stdint.h> 420 # ifndef SFD_NONBLOCK 421 # define SFD_NONBLOCK O_NONBLOCK 422 # endif 423 # ifndef SFD_CLOEXEC 424 # ifdef O_CLOEXEC 425 # define SFD_CLOEXEC O_CLOEXEC 426 # else 427 # define SFD_CLOEXEC 02000000 428 # endif 429 # endif 430 EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags); 431 432 struct signalfd_siginfo 433 { 434 uint32_t ssi_signo; 435 char pad[128 - sizeof (uint32_t)]; 436 }; 437 #endif 438 439 /**/ 440 441 #if EV_VERIFY >= 3 442 # define EV_FREQUENT_CHECK ev_verify (EV_A) 443 #else 444 # define EV_FREQUENT_CHECK do { } while (0) 445 #endif 446 447 /* 448 * This is used to avoid floating point rounding problems. 449 * It is added to ev_rt_now when scheduling periodics 450 * to ensure progress, time-wise, even when rounding 451 * errors are against us. 452 * This value is good at least till the year 4000. 453 * Better solutions welcome. 454 */ 455 #define TIME_EPSILON 0.0001220703125 /* 1/8192 */ 456 457 #define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */ 458 #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */ 459 460 #define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0) 461 #define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0) 462 463 #if __GNUC__ >= 4 464 # define expect(expr,value) __builtin_expect ((expr),(value)) 465 # define noinline __attribute__ ((noinline)) 466 #else 467 # define expect(expr,value) (expr) 468 # define noinline 469 # if __STDC_VERSION__ < 199901L && __GNUC__ < 2 470 # define inline 471 # endif 472 #endif 473 474 #define expect_false(expr) expect ((expr) != 0, 0) 475 #define expect_true(expr) expect ((expr) != 0, 1) 476 #define inline_size static inline 477 478 #if EV_FEATURE_CODE 479 # define inline_speed static inline 480 #else 481 # define inline_speed static noinline 482 #endif 483 484 #define NUMPRI (EV_MAXPRI - EV_MINPRI + 1) 485 486 #if EV_MINPRI == EV_MAXPRI 487 # define ABSPRI(w) (((W)w), 0) 488 #else 489 # define ABSPRI(w) (((W)w)->priority - EV_MINPRI) 490 #endif 491 492 #define EMPTY /* required for microsofts broken pseudo-c compiler */ 493 #define EMPTY2(a,b) /* used to suppress some warnings */ 494 495 typedef ev_watcher *W; 496 typedef ev_watcher_list *WL; 497 typedef ev_watcher_time *WT; 498 499 #define ev_active(w) ((W)(w))->active 500 #define ev_at(w) ((WT)(w))->at 501 502 #if EV_USE_REALTIME 503 /* sig_atomic_t is used to avoid per-thread variables or locking but still */ 504 /* giving it a reasonably high chance of working on typical architectures */ 505 static EV_ATOMIC_T have_realtime; /* did clock_gettime (CLOCK_REALTIME) work? */ 506 #endif 507 508 #if EV_USE_MONOTONIC 509 static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */ 510 #endif 511 512 #ifndef EV_FD_TO_WIN32_HANDLE 513 # define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd) 514 #endif 515 #ifndef EV_WIN32_HANDLE_TO_FD 516 # define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0) 517 #endif 518 #ifndef EV_WIN32_CLOSE_FD 519 # define EV_WIN32_CLOSE_FD(fd) close (fd) 520 #endif 521 522 #ifdef _WIN32 523 # include "ev_win32.c" 524 #endif 525 526 /*****************************************************************************/ 527 528 #ifdef __linux 529 # include <sys/utsname.h> 530 #endif 531 532 static unsigned int noinline 533 ev_linux_version (void) 534 { 535 #ifdef __linux 536 unsigned int v = 0; 537 struct utsname buf; 538 int i; 539 char *p = buf.release; 540 541 if (uname (&buf)) 542 return 0; 543 544 for (i = 3+1; --i; ) 545 { 546 unsigned int c = 0; 547 548 for (;;) 549 { 550 if (*p >= '0' && *p <= '9') 551 c = c * 10 + *p++ - '0'; 552 else 553 { 554 p += *p == '.'; 555 break; 556 } 557 } 558 559 v = (v << 8) | c; 560 } 561 562 return v; 563 #else 564 return 0; 565 #endif 566 } 567 568 /*****************************************************************************/ 569 570 #if EV_AVOID_STDIO 571 static void noinline 572 ev_printerr (const char *msg) 573 { 574 write (STDERR_FILENO, msg, strlen (msg)); 575 } 576 #endif 577 578 static void (*syserr_cb)(const char *msg); 579 580 void 581 ev_set_syserr_cb (void (*cb)(const char *msg)) 582 { 583 syserr_cb = cb; 584 } 585 586 static void noinline 587 ev_syserr (const char *msg) 588 { 589 if (!msg) 590 msg = "(libev) system error"; 591 592 if (syserr_cb) 593 syserr_cb (msg); 594 else 595 { 596 #if EV_AVOID_STDIO 597 ev_printerr (msg); 598 ev_printerr (": "); 599 ev_printerr (strerror (errno)); 600 ev_printerr ("\n"); 601 #else 602 perror (msg); 603 #endif 604 abort (); 605 } 606 } 607 608 static void * 609 ev_realloc_emul (void *ptr, long size) 610 { 611 #if __GLIBC__ 612 return realloc (ptr, size); 613 #else 614 /* some systems, notably openbsd and darwin, fail to properly 615 * implement realloc (x, 0) (as required by both ansi c-89 and 616 * the single unix specification, so work around them here. 617 */ 618 619 if (size) 620 return realloc (ptr, size); 621 622 free (ptr); 623 return 0; 624 #endif 625 } 626 627 static void *(*alloc)(void *ptr, long size) = ev_realloc_emul; 628 629 void 630 ev_set_allocator (void *(*cb)(void *ptr, long size)) 631 { 632 alloc = cb; 633 } 634 635 inline_speed void * 636 ev_realloc (void *ptr, long size) 637 { 638 ptr = alloc (ptr, size); 639 640 if (!ptr && size) 641 { 642 #if EV_AVOID_STDIO 643 ev_printerr ("(libev) memory allocation failed, aborting.\n"); 644 #else 645 fprintf (stderr, "(libev) cannot allocate %ld bytes, aborting.", size); 646 #endif 647 abort (); 648 } 649 650 return ptr; 651 } 652 653 #define ev_malloc(size) ev_realloc (0, (size)) 654 #define ev_free(ptr) ev_realloc ((ptr), 0) 655 656 /*****************************************************************************/ 657 658 /* set in reify when reification needed */ 659 #define EV_ANFD_REIFY 1 660 661 /* file descriptor info structure */ 662 typedef struct 663 { 664 WL head; 665 unsigned char events; /* the events watched for */ 666 unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */ 667 unsigned char emask; /* the epoll backend stores the actual kernel mask in here */ 668 unsigned char unused; 669 #if EV_USE_EPOLL 670 unsigned int egen; /* generation counter to counter epoll bugs */ 671 #endif 672 #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP 673 SOCKET handle; 674 #endif 675 #if EV_USE_IOCP 676 OVERLAPPED or, ow; 677 #endif 678 } ANFD; 679 680 /* stores the pending event set for a given watcher */ 681 typedef struct 682 { 683 W w; 684 int events; /* the pending event set for the given watcher */ 685 } ANPENDING; 686 687 #if EV_USE_INOTIFY 688 /* hash table entry per inotify-id */ 689 typedef struct 690 { 691 WL head; 692 } ANFS; 693 #endif 694 695 /* Heap Entry */ 696 #if EV_HEAP_CACHE_AT 697 /* a heap element */ 698 typedef struct { 699 ev_tstamp at; 700 WT w; 701 } ANHE; 702 703 #define ANHE_w(he) (he).w /* access watcher, read-write */ 704 #define ANHE_at(he) (he).at /* access cached at, read-only */ 705 #define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */ 706 #else 707 /* a heap element */ 708 typedef WT ANHE; 709 710 #define ANHE_w(he) (he) 711 #define ANHE_at(he) (he)->at 712 #define ANHE_at_cache(he) 713 #endif 714 715 #if EV_MULTIPLICITY 716 717 struct ev_loop 718 { 719 ev_tstamp ev_rt_now; 720 #define ev_rt_now ((loop)->ev_rt_now) 721 #define VAR(name,decl) decl; 722 #include "ev_vars.h" 723 #undef VAR 724 }; 725 #include "ev_wrap.h" 726 727 static struct ev_loop default_loop_struct; 728 struct ev_loop *ev_default_loop_ptr; 729 730 #else 731 732 ev_tstamp ev_rt_now; 733 #define VAR(name,decl) static decl; 734 #include "ev_vars.h" 735 #undef VAR 736 737 static int ev_default_loop_ptr; 738 739 #endif 740 741 #if EV_FEATURE_API 742 # define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A) 743 # define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A) 744 # define EV_INVOKE_PENDING invoke_cb (EV_A) 745 #else 746 # define EV_RELEASE_CB (void)0 747 # define EV_ACQUIRE_CB (void)0 748 # define EV_INVOKE_PENDING ev_invoke_pending (EV_A) 749 #endif 750 751 #define EVBREAK_RECURSE 0x80 752 753 /*****************************************************************************/ 754 755 #ifndef EV_HAVE_EV_TIME 756 ev_tstamp 757 ev_time (void) 758 { 759 #if EV_USE_REALTIME 760 if (expect_true (have_realtime)) 761 { 762 struct timespec ts; 763 clock_gettime (CLOCK_REALTIME, &ts); 764 return ts.tv_sec + ts.tv_nsec * 1e-9; 765 } 766 #endif 767 768 struct timeval tv; 769 gettimeofday (&tv, 0); 770 return tv.tv_sec + tv.tv_usec * 1e-6; 771 } 772 #endif 773 774 inline_size ev_tstamp 775 get_clock (void) 776 { 777 #if EV_USE_MONOTONIC 778 if (expect_true (have_monotonic)) 779 { 780 struct timespec ts; 781 clock_gettime (CLOCK_MONOTONIC, &ts); 782 return ts.tv_sec + ts.tv_nsec * 1e-9; 783 } 784 #endif 785 786 return ev_time (); 787 } 788 789 #if EV_MULTIPLICITY 790 ev_tstamp 791 ev_now (EV_P) 792 { 793 return ev_rt_now; 794 } 795 #endif 796 797 void 798 ev_sleep (ev_tstamp delay) 799 { 800 if (delay > 0.) 801 { 802 #if EV_USE_NANOSLEEP 803 struct timespec ts; 804 805 EV_TS_SET (ts, delay); 806 nanosleep (&ts, 0); 807 #elif defined(_WIN32) 808 Sleep ((unsigned long)(delay * 1e3)); 809 #else 810 struct timeval tv; 811 812 /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */ 813 /* something not guaranteed by newer posix versions, but guaranteed */ 814 /* by older ones */ 815 EV_TV_SET (tv, delay); 816 select (0, 0, 0, 0, &tv); 817 #endif 818 } 819 } 820 821 inline_speed int 822 ev_timeout_to_ms (ev_tstamp timeout) 823 { 824 int ms = timeout * 1000. + .999999; 825 826 return expect_true (ms) ? ms : timeout < 1e-6 ? 0 : 1; 827 } 828 829 /*****************************************************************************/ 830 831 #define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */ 832 833 /* find a suitable new size for the given array, */ 834 /* hopefully by rounding to a nice-to-malloc size */ 835 inline_size int 836 array_nextsize (int elem, int cur, int cnt) 837 { 838 int ncur = cur + 1; 839 840 do 841 ncur <<= 1; 842 while (cnt > ncur); 843 844 /* if size is large, round to MALLOC_ROUND - 4 * longs to accomodate malloc overhead */ 845 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4) 846 { 847 ncur *= elem; 848 ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1); 849 ncur = ncur - sizeof (void *) * 4; 850 ncur /= elem; 851 } 852 853 return ncur; 854 } 855 856 static noinline void * 857 array_realloc (int elem, void *base, int *cur, int cnt) 858 { 859 *cur = array_nextsize (elem, *cur, cnt); 860 return ev_realloc (base, elem * *cur); 861 } 862 863 #define array_init_zero(base,count) \ 864 memset ((void *)(base), 0, sizeof (*(base)) * (count)) 865 866 #define array_needsize(type,base,cur,cnt,init) \ 867 if (expect_false ((cnt) > (cur))) \ 868 { \ 869 int ocur_ = (cur); \ 870 (base) = (type *)array_realloc \ 871 (sizeof (type), (base), &(cur), (cnt)); \ 872 init ((base) + (ocur_), (cur) - ocur_); \ 873 } 874 875 #if 0 876 #define array_slim(type,stem) \ 877 if (stem ## max < array_roundsize (stem ## cnt >> 2)) \ 878 { \ 879 stem ## max = array_roundsize (stem ## cnt >> 1); \ 880 base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\ 881 fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\ 882 } 883 #endif 884 885 #define array_free(stem, idx) \ 886 ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0 887 888 /*****************************************************************************/ 889 890 /* dummy callback for pending events */ 891 static void noinline 892 pendingcb (EV_P_ ev_prepare *w, int revents) 893 { 894 } 895 896 void noinline 897 ev_feed_event (EV_P_ void *w, int revents) 898 { 899 W w_ = (W)w; 900 int pri = ABSPRI (w_); 901 902 if (expect_false (w_->pending)) 903 pendings [pri][w_->pending - 1].events |= revents; 904 else 905 { 906 w_->pending = ++pendingcnt [pri]; 907 array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2); 908 pendings [pri][w_->pending - 1].w = w_; 909 pendings [pri][w_->pending - 1].events = revents; 910 } 911 } 912 913 inline_speed void 914 feed_reverse (EV_P_ W w) 915 { 916 array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2); 917 rfeeds [rfeedcnt++] = w; 918 } 919 920 inline_size void 921 feed_reverse_done (EV_P_ int revents) 922 { 923 do 924 ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents); 925 while (rfeedcnt); 926 } 927 928 inline_speed void 929 queue_events (EV_P_ W *events, int eventcnt, int type) 930 { 931 int i; 932 933 for (i = 0; i < eventcnt; ++i) 934 ev_feed_event (EV_A_ events [i], type); 935 } 936 937 /*****************************************************************************/ 938 939 inline_speed void 940 fd_event_nocheck (EV_P_ int fd, int revents) 941 { 942 ANFD *anfd = anfds + fd; 943 ev_io *w; 944 945 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next) 946 { 947 int ev = w->events & revents; 948 949 if (ev) 950 ev_feed_event (EV_A_ (W)w, ev); 951 } 952 } 953 954 /* do not submit kernel events for fds that have reify set */ 955 /* because that means they changed while we were polling for new events */ 956 inline_speed void 957 fd_event (EV_P_ int fd, int revents) 958 { 959 ANFD *anfd = anfds + fd; 960 961 if (expect_true (!anfd->reify)) 962 fd_event_nocheck (EV_A_ fd, revents); 963 } 964 965 void 966 ev_feed_fd_event (EV_P_ int fd, int revents) 967 { 968 if (fd >= 0 && fd < anfdmax) 969 fd_event_nocheck (EV_A_ fd, revents); 970 } 971 972 /* make sure the external fd watch events are in-sync */ 973 /* with the kernel/libev internal state */ 974 inline_size void 975 fd_reify (EV_P) 976 { 977 int i; 978 979 #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP 980 for (i = 0; i < fdchangecnt; ++i) 981 { 982 int fd = fdchanges [i]; 983 ANFD *anfd = anfds + fd; 984 985 if (anfd->reify & EV__IOFDSET) 986 { 987 SOCKET handle = EV_FD_TO_WIN32_HANDLE (fd); 988 989 if (handle != anfd->handle) 990 { 991 unsigned long arg; 992 993 assert (("libev: only socket fds supported in this configuration", ioctlsocket (handle, FIONREAD, &arg) == 0)); 994 995 /* handle changed, but fd didn't - we need to do it in two steps */ 996 backend_modify (EV_A_ fd, anfd->events, 0); 997 anfd->events = 0; 998 anfd->handle = handle; 999 } 1000 } 1001 } 1002 #endif 1003 1004 for (i = 0; i < fdchangecnt; ++i) 1005 { 1006 int fd = fdchanges [i]; 1007 ANFD *anfd = anfds + fd; 1008 ev_io *w; 1009 1010 unsigned char o_events = anfd->events; 1011 unsigned char o_reify = anfd->reify; 1012 1013 anfd->reify = 0; 1014 1015 /*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */ 1016 { 1017 anfd->events = 0; 1018 1019 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next) 1020 anfd->events |= (unsigned char)w->events; 1021 1022 if (o_events != anfd->events) 1023 o_reify = EV__IOFDSET; /* actually |= */ 1024 } 1025 1026 if (o_reify & EV__IOFDSET) 1027 backend_modify (EV_A_ fd, o_events, anfd->events); 1028 } 1029 1030 fdchangecnt = 0; 1031 } 1032 1033 /* something about the given fd changed */ 1034 inline_size void 1035 fd_change (EV_P_ int fd, int flags) 1036 { 1037 unsigned char reify = anfds [fd].reify; 1038 anfds [fd].reify |= flags; 1039 1040 if (expect_true (!reify)) 1041 { 1042 ++fdchangecnt; 1043 array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2); 1044 fdchanges [fdchangecnt - 1] = fd; 1045 } 1046 } 1047 1048 /* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */ 1049 inline_speed void 1050 fd_kill (EV_P_ int fd) 1051 { 1052 ev_io *w; 1053 1054 while ((w = (ev_io *)anfds [fd].head)) 1055 { 1056 ev_io_stop (EV_A_ w); 1057 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE); 1058 } 1059 } 1060 1061 /* check whether the given fd is actually valid, for error recovery */ 1062 inline_size int 1063 fd_valid (int fd) 1064 { 1065 #ifdef _WIN32 1066 return EV_FD_TO_WIN32_HANDLE (fd) != -1; 1067 #else 1068 return fcntl (fd, F_GETFD) != -1; 1069 #endif 1070 } 1071 1072 /* called on EBADF to verify fds */ 1073 static void noinline 1074 fd_ebadf (EV_P) 1075 { 1076 int fd; 1077 1078 for (fd = 0; fd < anfdmax; ++fd) 1079 if (anfds [fd].events) 1080 if (!fd_valid (fd) && errno == EBADF) 1081 fd_kill (EV_A_ fd); 1082 } 1083 1084 /* called on ENOMEM in select/poll to kill some fds and retry */ 1085 static void noinline 1086 fd_enomem (EV_P) 1087 { 1088 int fd; 1089 1090 for (fd = anfdmax; fd--; ) 1091 if (anfds [fd].events) 1092 { 1093 fd_kill (EV_A_ fd); 1094 break; 1095 } 1096 } 1097 1098 /* usually called after fork if backend needs to re-arm all fds from scratch */ 1099 static void noinline 1100 fd_rearm_all (EV_P) 1101 { 1102 int fd; 1103 1104 for (fd = 0; fd < anfdmax; ++fd) 1105 if (anfds [fd].events) 1106 { 1107 anfds [fd].events = 0; 1108 anfds [fd].emask = 0; 1109 fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY); 1110 } 1111 } 1112 1113 /* used to prepare libev internal fd's */ 1114 /* this is not fork-safe */ 1115 inline_speed void 1116 fd_intern (int fd) 1117 { 1118 #ifdef _WIN32 1119 unsigned long arg = 1; 1120 ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg); 1121 #else 1122 fcntl (fd, F_SETFD, FD_CLOEXEC); 1123 fcntl (fd, F_SETFL, O_NONBLOCK); 1124 #endif 1125 } 1126 1127 /*****************************************************************************/ 1128 1129 /* 1130 * the heap functions want a real array index. array index 0 is guaranteed to not 1131 * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives 1132 * the branching factor of the d-tree. 1133 */ 1134 1135 /* 1136 * at the moment we allow libev the luxury of two heaps, 1137 * a small-code-size 2-heap one and a ~1.5kb larger 4-heap 1138 * which is more cache-efficient. 1139 * the difference is about 5% with 50000+ watchers. 1140 */ 1141 #if EV_USE_4HEAP 1142 1143 #define DHEAP 4 1144 #define HEAP0 (DHEAP - 1) /* index of first element in heap */ 1145 #define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0) 1146 #define UPHEAP_DONE(p,k) ((p) == (k)) 1147 1148 /* away from the root */ 1149 inline_speed void 1150 downheap (ANHE *heap, int N, int k) 1151 { 1152 ANHE he = heap [k]; 1153 ANHE *E = heap + N + HEAP0; 1154 1155 for (;;) 1156 { 1157 ev_tstamp minat; 1158 ANHE *minpos; 1159 ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1; 1160 1161 /* find minimum child */ 1162 if (expect_true (pos + DHEAP - 1 < E)) 1163 { 1164 /* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos)); 1165 if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos)); 1166 if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos)); 1167 if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos)); 1168 } 1169 else if (pos < E) 1170 { 1171 /* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos)); 1172 if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos)); 1173 if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos)); 1174 if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos)); 1175 } 1176 else 1177 break; 1178 1179 if (ANHE_at (he) <= minat) 1180 break; 1181 1182 heap [k] = *minpos; 1183 ev_active (ANHE_w (*minpos)) = k; 1184 1185 k = minpos - heap; 1186 } 1187 1188 heap [k] = he; 1189 ev_active (ANHE_w (he)) = k; 1190 } 1191 1192 #else /* 4HEAP */ 1193 1194 #define HEAP0 1 1195 #define HPARENT(k) ((k) >> 1) 1196 #define UPHEAP_DONE(p,k) (!(p)) 1197 1198 /* away from the root */ 1199 inline_speed void 1200 downheap (ANHE *heap, int N, int k) 1201 { 1202 ANHE he = heap [k]; 1203 1204 for (;;) 1205 { 1206 int c = k << 1; 1207 1208 if (c >= N + HEAP0) 1209 break; 1210 1211 c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1]) 1212 ? 1 : 0; 1213 1214 if (ANHE_at (he) <= ANHE_at (heap [c])) 1215 break; 1216 1217 heap [k] = heap [c]; 1218 ev_active (ANHE_w (heap [k])) = k; 1219 1220 k = c; 1221 } 1222 1223 heap [k] = he; 1224 ev_active (ANHE_w (he)) = k; 1225 } 1226 #endif 1227 1228 /* towards the root */ 1229 inline_speed void 1230 upheap (ANHE *heap, int k) 1231 { 1232 ANHE he = heap [k]; 1233 1234 for (;;) 1235 { 1236 int p = HPARENT (k); 1237 1238 if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he)) 1239 break; 1240 1241 heap [k] = heap [p]; 1242 ev_active (ANHE_w (heap [k])) = k; 1243 k = p; 1244 } 1245 1246 heap [k] = he; 1247 ev_active (ANHE_w (he)) = k; 1248 } 1249 1250 /* move an element suitably so it is in a correct place */ 1251 inline_size void 1252 adjustheap (ANHE *heap, int N, int k) 1253 { 1254 if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)])) 1255 upheap (heap, k); 1256 else 1257 downheap (heap, N, k); 1258 } 1259 1260 /* rebuild the heap: this function is used only once and executed rarely */ 1261 inline_size void 1262 reheap (ANHE *heap, int N) 1263 { 1264 int i; 1265 1266 /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */ 1267 /* also, this is easy to implement and correct for both 2-heaps and 4-heaps */ 1268 for (i = 0; i < N; ++i) 1269 upheap (heap, i + HEAP0); 1270 } 1271 1272 /*****************************************************************************/ 1273 1274 /* associate signal watchers to a signal signal */ 1275 typedef struct 1276 { 1277 EV_ATOMIC_T pending; 1278 #if EV_MULTIPLICITY 1279 EV_P; 1280 #endif 1281 WL head; 1282 } ANSIG; 1283 1284 static ANSIG signals [EV_NSIG - 1]; 1285 1286 /*****************************************************************************/ 1287 1288 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE 1289 1290 static void noinline 1291 evpipe_init (EV_P) 1292 { 1293 if (!ev_is_active (&pipe_w)) 1294 { 1295 # if EV_USE_EVENTFD 1296 evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC); 1297 if (evfd < 0 && errno == EINVAL) 1298 evfd = eventfd (0, 0); 1299 1300 if (evfd >= 0) 1301 { 1302 evpipe [0] = -1; 1303 fd_intern (evfd); /* doing it twice doesn't hurt */ 1304 ev_io_set (&pipe_w, evfd, EV_READ); 1305 } 1306 else 1307 # endif 1308 { 1309 while (pipe (evpipe)) 1310 ev_syserr ("(libev) error creating signal/async pipe"); 1311 1312 fd_intern (evpipe [0]); 1313 fd_intern (evpipe [1]); 1314 ev_io_set (&pipe_w, evpipe [0], EV_READ); 1315 } 1316 1317 ev_io_start (EV_A_ &pipe_w); 1318 ev_unref (EV_A); /* watcher should not keep loop alive */ 1319 } 1320 } 1321 1322 inline_size void 1323 evpipe_write (EV_P_ EV_ATOMIC_T *flag) 1324 { 1325 if (!*flag) 1326 { 1327 int old_errno = errno; /* save errno because write might clobber it */ 1328 char dummy; 1329 1330 *flag = 1; 1331 1332 #if EV_USE_EVENTFD 1333 if (evfd >= 0) 1334 { 1335 uint64_t counter = 1; 1336 write (evfd, &counter, sizeof (uint64_t)); 1337 } 1338 else 1339 #endif 1340 /* win32 people keep sending patches that change this write() to send() */ 1341 /* and then run away. but send() is wrong, it wants a socket handle on win32 */ 1342 /* so when you think this write should be a send instead, please find out */ 1343 /* where your send() is from - it's definitely not the microsoft send, and */ 1344 /* tell me. thank you. */ 1345 write (evpipe [1], &dummy, 1); 1346 1347 errno = old_errno; 1348 } 1349 } 1350 1351 /* called whenever the libev signal pipe */ 1352 /* got some events (signal, async) */ 1353 static void 1354 pipecb (EV_P_ ev_io *iow, int revents) 1355 { 1356 int i; 1357 1358 #if EV_USE_EVENTFD 1359 if (evfd >= 0) 1360 { 1361 uint64_t counter; 1362 read (evfd, &counter, sizeof (uint64_t)); 1363 } 1364 else 1365 #endif 1366 { 1367 char dummy; 1368 /* see discussion in evpipe_write when you think this read should be recv in win32 */ 1369 read (evpipe [0], &dummy, 1); 1370 } 1371 1372 #if EV_SIGNAL_ENABLE 1373 if (sig_pending) 1374 { 1375 sig_pending = 0; 1376 1377 for (i = EV_NSIG - 1; i--; ) 1378 if (expect_false (signals [i].pending)) 1379 ev_feed_signal_event (EV_A_ i + 1); 1380 } 1381 #endif 1382 1383 #if EV_ASYNC_ENABLE 1384 if (async_pending) 1385 { 1386 async_pending = 0; 1387 1388 for (i = asynccnt; i--; ) 1389 if (asyncs [i]->sent) 1390 { 1391 asyncs [i]->sent = 0; 1392 ev_feed_event (EV_A_ asyncs [i], EV_ASYNC); 1393 } 1394 } 1395 #endif 1396 } 1397 1398 /*****************************************************************************/ 1399 1400 void 1401 ev_feed_signal (int signum) 1402 { 1403 #if EV_MULTIPLICITY 1404 EV_P = signals [signum - 1].loop; 1405 1406 if (!EV_A) 1407 return; 1408 #endif 1409 1410 signals [signum - 1].pending = 1; 1411 evpipe_write (EV_A_ &sig_pending); 1412 } 1413 1414 static void 1415 ev_sighandler (int signum) 1416 { 1417 #ifdef _WIN32 1418 signal (signum, ev_sighandler); 1419 #endif 1420 1421 ev_feed_signal (signum); 1422 } 1423 1424 void noinline 1425 ev_feed_signal_event (EV_P_ int signum) 1426 { 1427 WL w; 1428 1429 if (expect_false (signum <= 0 || signum > EV_NSIG)) 1430 return; 1431 1432 --signum; 1433 1434 #if EV_MULTIPLICITY 1435 /* it is permissible to try to feed a signal to the wrong loop */ 1436 /* or, likely more useful, feeding a signal nobody is waiting for */ 1437 1438 if (expect_false (signals [signum].loop != EV_A)) 1439 return; 1440 #endif 1441 1442 signals [signum].pending = 0; 1443 1444 for (w = signals [signum].head; w; w = w->next) 1445 ev_feed_event (EV_A_ (W)w, EV_SIGNAL); 1446 } 1447 1448 #if EV_USE_SIGNALFD 1449 static void 1450 sigfdcb (EV_P_ ev_io *iow, int revents) 1451 { 1452 struct signalfd_siginfo si[2], *sip; /* these structs are big */ 1453 1454 for (;;) 1455 { 1456 ssize_t res = read (sigfd, si, sizeof (si)); 1457 1458 /* not ISO-C, as res might be -1, but works with SuS */ 1459 for (sip = si; (char *)sip < (char *)si + res; ++sip) 1460 ev_feed_signal_event (EV_A_ sip->ssi_signo); 1461 1462 if (res < (ssize_t)sizeof (si)) 1463 break; 1464 } 1465 } 1466 #endif 1467 1468 #endif 1469 1470 /*****************************************************************************/ 1471 1472 #if EV_CHILD_ENABLE 1473 static WL childs [EV_PID_HASHSIZE]; 1474 1475 static ev_signal childev; 1476 1477 #ifndef WIFCONTINUED 1478 # define WIFCONTINUED(status) 0 1479 #endif 1480 1481 /* handle a single child status event */ 1482 inline_speed void 1483 child_reap (EV_P_ int chain, int pid, int status) 1484 { 1485 ev_child *w; 1486 int traced = WIFSTOPPED (status) || WIFCONTINUED (status); 1487 1488 for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next) 1489 { 1490 if ((w->pid == pid || !w->pid) 1491 && (!traced || (w->flags & 1))) 1492 { 1493 ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */ 1494 w->rpid = pid; 1495 w->rstatus = status; 1496 ev_feed_event (EV_A_ (W)w, EV_CHILD); 1497 } 1498 } 1499 } 1500 1501 #ifndef WCONTINUED 1502 # define WCONTINUED 0 1503 #endif 1504 1505 /* called on sigchld etc., calls waitpid */ 1506 static void 1507 childcb (EV_P_ ev_signal *sw, int revents) 1508 { 1509 int pid, status; 1510 1511 /* some systems define WCONTINUED but then fail to support it (linux 2.4) */ 1512 if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED))) 1513 if (!WCONTINUED 1514 || errno != EINVAL 1515 || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED))) 1516 return; 1517 1518 /* make sure we are called again until all children have been reaped */ 1519 /* we need to do it this way so that the callback gets called before we continue */ 1520 ev_feed_event (EV_A_ (W)sw, EV_SIGNAL); 1521 1522 child_reap (EV_A_ pid, pid, status); 1523 if ((EV_PID_HASHSIZE) > 1) 1524 child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */ 1525 } 1526 1527 #endif 1528 1529 /*****************************************************************************/ 1530 1531 #if EV_USE_IOCP 1532 # include "ev_iocp.c" 1533 #endif 1534 #if EV_USE_PORT 1535 # include "ev_port.c" 1536 #endif 1537 #if EV_USE_KQUEUE 1538 # include "ev_kqueue.c" 1539 #endif 1540 #if EV_USE_EPOLL 1541 # include "ev_epoll.c" 1542 #endif 1543 #if EV_USE_POLL 1544 # include "ev_poll.c" 1545 #endif 1546 #if EV_USE_SELECT 1547 # include "ev_select.c" 1548 #endif 1549 1550 int 1551 ev_version_major (void) 1552 { 1553 return EV_VERSION_MAJOR; 1554 } 1555 1556 int 1557 ev_version_minor (void) 1558 { 1559 return EV_VERSION_MINOR; 1560 } 1561 1562 /* return true if we are running with elevated privileges and should ignore env variables */ 1563 int inline_size 1564 enable_secure (void) 1565 { 1566 #ifdef _WIN32 1567 return 0; 1568 #else 1569 return getuid () != geteuid () 1570 || getgid () != getegid (); 1571 #endif 1572 } 1573 1574 unsigned int 1575 ev_supported_backends (void) 1576 { 1577 unsigned int flags = 0; 1578 1579 if (EV_USE_PORT ) flags |= EVBACKEND_PORT; 1580 if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE; 1581 if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL; 1582 if (EV_USE_POLL ) flags |= EVBACKEND_POLL; 1583 if (EV_USE_SELECT) flags |= EVBACKEND_SELECT; 1584 1585 return flags; 1586 } 1587 1588 unsigned int 1589 ev_recommended_backends (void) 1590 { 1591 unsigned int flags = ev_supported_backends (); 1592 1593 #ifndef __NetBSD__ 1594 /* kqueue is borked on everything but netbsd apparently */ 1595 /* it usually doesn't work correctly on anything but sockets and pipes */ 1596 flags &= ~EVBACKEND_KQUEUE; 1597 #endif 1598 #ifdef __APPLE__ 1599 /* only select works correctly on that "unix-certified" platform */ 1600 flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */ 1601 flags &= ~EVBACKEND_POLL; /* poll is based on kqueue from 10.5 onwards */ 1602 #endif 1603 #ifdef __FreeBSD__ 1604 flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */ 1605 #endif 1606 1607 return flags; 1608 } 1609 1610 unsigned int 1611 ev_embeddable_backends (void) 1612 { 1613 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT; 1614 1615 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */ 1616 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */ 1617 flags &= ~EVBACKEND_EPOLL; 1618 1619 return flags; 1620 } 1621 1622 unsigned int 1623 ev_backend (EV_P) 1624 { 1625 return backend; 1626 } 1627 1628 #if EV_FEATURE_API 1629 unsigned int 1630 ev_iteration (EV_P) 1631 { 1632 return loop_count; 1633 } 1634 1635 unsigned int 1636 ev_depth (EV_P) 1637 { 1638 return loop_depth; 1639 } 1640 1641 void 1642 ev_set_io_collect_interval (EV_P_ ev_tstamp interval) 1643 { 1644 io_blocktime = interval; 1645 } 1646 1647 void 1648 ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) 1649 { 1650 timeout_blocktime = interval; 1651 } 1652 1653 void 1654 ev_set_userdata (EV_P_ void *data) 1655 { 1656 userdata = data; 1657 } 1658 1659 void * 1660 ev_userdata (EV_P) 1661 { 1662 return userdata; 1663 } 1664 1665 void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) 1666 { 1667 invoke_cb = invoke_pending_cb; 1668 } 1669 1670 void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) 1671 { 1672 release_cb = release; 1673 acquire_cb = acquire; 1674 } 1675 #endif 1676 1677 /* initialise a loop structure, must be zero-initialised */ 1678 static void noinline 1679 loop_init (EV_P_ unsigned int flags) 1680 { 1681 if (!backend) 1682 { 1683 origflags = flags; 1684 1685 #if EV_USE_REALTIME 1686 if (!have_realtime) 1687 { 1688 struct timespec ts; 1689 1690 if (!clock_gettime (CLOCK_REALTIME, &ts)) 1691 have_realtime = 1; 1692 } 1693 #endif 1694 1695 #if EV_USE_MONOTONIC 1696 if (!have_monotonic) 1697 { 1698 struct timespec ts; 1699 1700 if (!clock_gettime (CLOCK_MONOTONIC, &ts)) 1701 have_monotonic = 1; 1702 } 1703 #endif 1704 1705 /* pid check not overridable via env */ 1706 #ifndef _WIN32 1707 if (flags & EVFLAG_FORKCHECK) 1708 curpid = getpid (); 1709 #endif 1710 1711 if (!(flags & EVFLAG_NOENV) 1712 && !enable_secure () 1713 && getenv ("LIBEV_FLAGS")) 1714 flags = atoi (getenv ("LIBEV_FLAGS")); 1715 1716 ev_rt_now = ev_time (); 1717 mn_now = get_clock (); 1718 now_floor = mn_now; 1719 rtmn_diff = ev_rt_now - mn_now; 1720 #if EV_FEATURE_API 1721 invoke_cb = ev_invoke_pending; 1722 #endif 1723 1724 io_blocktime = 0.; 1725 timeout_blocktime = 0.; 1726 backend = 0; 1727 backend_fd = -1; 1728 sig_pending = 0; 1729 #if EV_ASYNC_ENABLE 1730 async_pending = 0; 1731 #endif 1732 #if EV_USE_INOTIFY 1733 fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2; 1734 #endif 1735 #if EV_USE_SIGNALFD 1736 sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1; 1737 #endif 1738 1739 if (!(flags & EVBACKEND_MASK)) 1740 flags |= ev_recommended_backends (); 1741 1742 #if EV_USE_IOCP 1743 if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags); 1744 #endif 1745 #if EV_USE_PORT 1746 if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags); 1747 #endif 1748 #if EV_USE_KQUEUE 1749 if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags); 1750 #endif 1751 #if EV_USE_EPOLL 1752 if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags); 1753 #endif 1754 #if EV_USE_POLL 1755 if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags); 1756 #endif 1757 #if EV_USE_SELECT 1758 if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags); 1759 #endif 1760 1761 ev_prepare_init (&pending_w, pendingcb); 1762 1763 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE 1764 ev_init (&pipe_w, pipecb); 1765 ev_set_priority (&pipe_w, EV_MAXPRI); 1766 #endif 1767 } 1768 } 1769 1770 /* free up a loop structure */ 1771 void 1772 ev_loop_destroy (EV_P) 1773 { 1774 int i; 1775 1776 #if EV_MULTIPLICITY 1777 /* mimic free (0) */ 1778 if (!EV_A) 1779 return; 1780 #endif 1781 1782 #if EV_CLEANUP_ENABLE 1783 /* queue cleanup watchers (and execute them) */ 1784 if (expect_false (cleanupcnt)) 1785 { 1786 queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP); 1787 EV_INVOKE_PENDING; 1788 } 1789 #endif 1790 1791 #if EV_CHILD_ENABLE 1792 if (ev_is_active (&childev)) 1793 { 1794 ev_ref (EV_A); /* child watcher */ 1795 ev_signal_stop (EV_A_ &childev); 1796 } 1797 #endif 1798 1799 if (ev_is_active (&pipe_w)) 1800 { 1801 /*ev_ref (EV_A);*/ 1802 /*ev_io_stop (EV_A_ &pipe_w);*/ 1803 1804 #if EV_USE_EVENTFD 1805 if (evfd >= 0) 1806 close (evfd); 1807 #endif 1808 1809 if (evpipe [0] >= 0) 1810 { 1811 EV_WIN32_CLOSE_FD (evpipe [0]); 1812 EV_WIN32_CLOSE_FD (evpipe [1]); 1813 } 1814 } 1815 1816 #if EV_USE_SIGNALFD 1817 if (ev_is_active (&sigfd_w)) 1818 close (sigfd); 1819 #endif 1820 1821 #if EV_USE_INOTIFY 1822 if (fs_fd >= 0) 1823 close (fs_fd); 1824 #endif 1825 1826 if (backend_fd >= 0) 1827 close (backend_fd); 1828 1829 #if EV_USE_IOCP 1830 if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A); 1831 #endif 1832 #if EV_USE_PORT 1833 if (backend == EVBACKEND_PORT ) port_destroy (EV_A); 1834 #endif 1835 #if EV_USE_KQUEUE 1836 if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A); 1837 #endif 1838 #if EV_USE_EPOLL 1839 if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A); 1840 #endif 1841 #if EV_USE_POLL 1842 if (backend == EVBACKEND_POLL ) poll_destroy (EV_A); 1843 #endif 1844 #if EV_USE_SELECT 1845 if (backend == EVBACKEND_SELECT) select_destroy (EV_A); 1846 #endif 1847 1848 for (i = NUMPRI; i--; ) 1849 { 1850 array_free (pending, [i]); 1851 #if EV_IDLE_ENABLE 1852 array_free (idle, [i]); 1853 #endif 1854 } 1855 1856 ev_free (anfds); anfds = 0; anfdmax = 0; 1857 1858 /* have to use the microsoft-never-gets-it-right macro */ 1859 array_free (rfeed, EMPTY); 1860 array_free (fdchange, EMPTY); 1861 array_free (timer, EMPTY); 1862 #if EV_PERIODIC_ENABLE 1863 array_free (periodic, EMPTY); 1864 #endif 1865 #if EV_FORK_ENABLE 1866 array_free (fork, EMPTY); 1867 #endif 1868 #if EV_CLEANUP_ENABLE 1869 array_free (cleanup, EMPTY); 1870 #endif 1871 array_free (prepare, EMPTY); 1872 array_free (check, EMPTY); 1873 #if EV_ASYNC_ENABLE 1874 array_free (async, EMPTY); 1875 #endif 1876 1877 backend = 0; 1878 1879 #if EV_MULTIPLICITY 1880 if (ev_is_default_loop (EV_A)) 1881 #endif 1882 ev_default_loop_ptr = 0; 1883 #if EV_MULTIPLICITY 1884 else 1885 ev_free (EV_A); 1886 #endif 1887 } 1888 1889 #if EV_USE_INOTIFY 1890 inline_size void infy_fork (EV_P); 1891 #endif 1892 1893 inline_size void 1894 loop_fork (EV_P) 1895 { 1896 #if EV_USE_PORT 1897 if (backend == EVBACKEND_PORT ) port_fork (EV_A); 1898 #endif 1899 #if EV_USE_KQUEUE 1900 if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A); 1901 #endif 1902 #if EV_USE_EPOLL 1903 if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A); 1904 #endif 1905 #if EV_USE_INOTIFY 1906 infy_fork (EV_A); 1907 #endif 1908 1909 if (ev_is_active (&pipe_w)) 1910 { 1911 /* this "locks" the handlers against writing to the pipe */ 1912 /* while we modify the fd vars */ 1913 sig_pending = 1; 1914 #if EV_ASYNC_ENABLE 1915 async_pending = 1; 1916 #endif 1917 1918 ev_ref (EV_A); 1919 ev_io_stop (EV_A_ &pipe_w); 1920 1921 #if EV_USE_EVENTFD 1922 if (evfd >= 0) 1923 close (evfd); 1924 #endif 1925 1926 if (evpipe [0] >= 0) 1927 { 1928 EV_WIN32_CLOSE_FD (evpipe [0]); 1929 EV_WIN32_CLOSE_FD (evpipe [1]); 1930 } 1931 1932 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE 1933 evpipe_init (EV_A); 1934 /* now iterate over everything, in case we missed something */ 1935 pipecb (EV_A_ &pipe_w, EV_READ); 1936 #endif 1937 } 1938 1939 postfork = 0; 1940 } 1941 1942 #if EV_MULTIPLICITY 1943 1944 struct ev_loop * 1945 ev_loop_new (unsigned int flags) 1946 { 1947 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop)); 1948 1949 memset (EV_A, 0, sizeof (struct ev_loop)); 1950 loop_init (EV_A_ flags); 1951 1952 if (ev_backend (EV_A)) 1953 return EV_A; 1954 1955 ev_free (EV_A); 1956 return 0; 1957 } 1958 1959 #endif /* multiplicity */ 1960 1961 #if EV_VERIFY 1962 static void noinline 1963 verify_watcher (EV_P_ W w) 1964 { 1965 assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI)); 1966 1967 if (w->pending) 1968 assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w)); 1969 } 1970 1971 static void noinline 1972 verify_heap (EV_P_ ANHE *heap, int N) 1973 { 1974 int i; 1975 1976 for (i = HEAP0; i < N + HEAP0; ++i) 1977 { 1978 assert (("libev: active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i)); 1979 assert (("libev: heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i]))); 1980 assert (("libev: heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i])))); 1981 1982 verify_watcher (EV_A_ (W)ANHE_w (heap [i])); 1983 } 1984 } 1985 1986 static void noinline 1987 array_verify (EV_P_ W *ws, int cnt) 1988 { 1989 while (cnt--) 1990 { 1991 assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1)); 1992 verify_watcher (EV_A_ ws [cnt]); 1993 } 1994 } 1995 #endif 1996 1997 #if EV_FEATURE_API 1998 void 1999 ev_verify (EV_P) 2000 { 2001 #if EV_VERIFY 2002 int i; 2003 WL w; 2004 2005 assert (activecnt >= -1); 2006 2007 assert (fdchangemax >= fdchangecnt); 2008 for (i = 0; i < fdchangecnt; ++i) 2009 assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0)); 2010 2011 assert (anfdmax >= 0); 2012 for (i = 0; i < anfdmax; ++i) 2013 for (w = anfds [i].head; w; w = w->next) 2014 { 2015 verify_watcher (EV_A_ (W)w); 2016 assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1)); 2017 assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i)); 2018 } 2019 2020 assert (timermax >= timercnt); 2021 verify_heap (EV_A_ timers, timercnt); 2022 2023 #if EV_PERIODIC_ENABLE 2024 assert (periodicmax >= periodiccnt); 2025 verify_heap (EV_A_ periodics, periodiccnt); 2026 #endif 2027 2028 for (i = NUMPRI; i--; ) 2029 { 2030 assert (pendingmax [i] >= pendingcnt [i]); 2031 #if EV_IDLE_ENABLE 2032 assert (idleall >= 0); 2033 assert (idlemax [i] >= idlecnt [i]); 2034 array_verify (EV_A_ (W *)idles [i], idlecnt [i]); 2035 #endif 2036 } 2037 2038 #if EV_FORK_ENABLE 2039 assert (forkmax >= forkcnt); 2040 array_verify (EV_A_ (W *)forks, forkcnt); 2041 #endif 2042 2043 #if EV_CLEANUP_ENABLE 2044 assert (cleanupmax >= cleanupcnt); 2045 array_verify (EV_A_ (W *)cleanups, cleanupcnt); 2046 #endif 2047 2048 #if EV_ASYNC_ENABLE 2049 assert (asyncmax >= asynccnt); 2050 array_verify (EV_A_ (W *)asyncs, asynccnt); 2051 #endif 2052 2053 #if EV_PREPARE_ENABLE 2054 assert (preparemax >= preparecnt); 2055 array_verify (EV_A_ (W *)prepares, preparecnt); 2056 #endif 2057 2058 #if EV_CHECK_ENABLE 2059 assert (checkmax >= checkcnt); 2060 array_verify (EV_A_ (W *)checks, checkcnt); 2061 #endif 2062 2063 # if 0 2064 #if EV_CHILD_ENABLE 2065 for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next) 2066 for (signum = EV_NSIG; signum--; ) if (signals [signum].pending) 2067 #endif 2068 # endif 2069 #endif 2070 } 2071 #endif 2072 2073 #if EV_MULTIPLICITY 2074 struct ev_loop * 2075 #else 2076 int 2077 #endif 2078 ev_default_loop (unsigned int flags) 2079 { 2080 if (!ev_default_loop_ptr) 2081 { 2082 #if EV_MULTIPLICITY 2083 EV_P = ev_default_loop_ptr = &default_loop_struct; 2084 #else 2085 ev_default_loop_ptr = 1; 2086 #endif 2087 2088 loop_init (EV_A_ flags); 2089 2090 if (ev_backend (EV_A)) 2091 { 2092 #if EV_CHILD_ENABLE 2093 ev_signal_init (&childev, childcb, SIGCHLD); 2094 ev_set_priority (&childev, EV_MAXPRI); 2095 ev_signal_start (EV_A_ &childev); 2096 ev_unref (EV_A); /* child watcher should not keep loop alive */ 2097 #endif 2098 } 2099 else 2100 ev_default_loop_ptr = 0; 2101 } 2102 2103 return ev_default_loop_ptr; 2104 } 2105 2106 void 2107 ev_loop_fork (EV_P) 2108 { 2109 postfork = 1; /* must be in line with ev_default_fork */ 2110 } 2111 2112 /*****************************************************************************/ 2113 2114 void 2115 ev_invoke (EV_P_ void *w, int revents) 2116 { 2117 EV_CB_INVOKE ((W)w, revents); 2118 } 2119 2120 unsigned int 2121 ev_pending_count (EV_P) 2122 { 2123 int pri; 2124 unsigned int count = 0; 2125 2126 for (pri = NUMPRI; pri--; ) 2127 count += pendingcnt [pri]; 2128 2129 return count; 2130 } 2131 2132 void noinline 2133 ev_invoke_pending (EV_P) 2134 { 2135 int pri; 2136 2137 for (pri = NUMPRI; pri--; ) 2138 while (pendingcnt [pri]) 2139 { 2140 ANPENDING *p = pendings [pri] + --pendingcnt [pri]; 2141 2142 p->w->pending = 0; 2143 EV_CB_INVOKE (p->w, p->events); 2144 EV_FREQUENT_CHECK; 2145 } 2146 } 2147 2148 #if EV_IDLE_ENABLE 2149 /* make idle watchers pending. this handles the "call-idle */ 2150 /* only when higher priorities are idle" logic */ 2151 inline_size void 2152 idle_reify (EV_P) 2153 { 2154 if (expect_false (idleall)) 2155 { 2156 int pri; 2157 2158 for (pri = NUMPRI; pri--; ) 2159 { 2160 if (pendingcnt [pri]) 2161 break; 2162 2163 if (idlecnt [pri]) 2164 { 2165 queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE); 2166 break; 2167 } 2168 } 2169 } 2170 } 2171 #endif 2172 2173 /* make timers pending */ 2174 inline_size void 2175 timers_reify (EV_P) 2176 { 2177 EV_FREQUENT_CHECK; 2178 2179 if (timercnt && ANHE_at (timers [HEAP0]) < mn_now) 2180 { 2181 do 2182 { 2183 ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]); 2184 2185 /*assert (("libev: inactive timer on timer heap detected", ev_is_active (w)));*/ 2186 2187 /* first reschedule or stop timer */ 2188 if (w->repeat) 2189 { 2190 ev_at (w) += w->repeat; 2191 if (ev_at (w) < mn_now) 2192 ev_at (w) = mn_now; 2193 2194 assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.)); 2195 2196 ANHE_at_cache (timers [HEAP0]); 2197 downheap (timers, timercnt, HEAP0); 2198 } 2199 else 2200 ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */ 2201 2202 EV_FREQUENT_CHECK; 2203 feed_reverse (EV_A_ (W)w); 2204 } 2205 while (timercnt && ANHE_at (timers [HEAP0]) < mn_now); 2206 2207 feed_reverse_done (EV_A_ EV_TIMER); 2208 } 2209 } 2210 2211 #if EV_PERIODIC_ENABLE 2212 2213 inline_speed void 2214 periodic_recalc (EV_P_ ev_periodic *w) 2215 { 2216 /* TODO: use slow but potentially more correct incremental algo, */ 2217 /* also do not rely on ceil */ 2218 ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval; 2219 } 2220 2221 /* make periodics pending */ 2222 inline_size void 2223 periodics_reify (EV_P) 2224 { 2225 EV_FREQUENT_CHECK; 2226 2227 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now) 2228 { 2229 int feed_count = 0; 2230 2231 do 2232 { 2233 ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]); 2234 2235 /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/ 2236 2237 /* first reschedule or stop timer */ 2238 if (w->reschedule_cb) 2239 { 2240 ev_at (w) = w->reschedule_cb (w, ev_rt_now); 2241 2242 assert (("libev: ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now)); 2243 2244 ANHE_at_cache (periodics [HEAP0]); 2245 downheap (periodics, periodiccnt, HEAP0); 2246 } 2247 else if (w->interval) 2248 { 2249 periodic_recalc (EV_A_ w); 2250 2251 /* if next trigger time is not sufficiently in the future, put it there */ 2252 /* this might happen because of floating point inexactness */ 2253 if (ev_at (w) - ev_rt_now < TIME_EPSILON) 2254 { 2255 ev_at (w) += w->interval; 2256 2257 /* if interval is unreasonably low we might still have a time in the past */ 2258 /* so correct this. this will make the periodic very inexact, but the user */ 2259 /* has effectively asked to get triggered more often than possible */ 2260 if (ev_at (w) < ev_rt_now) 2261 ev_at (w) = ev_rt_now; 2262 } 2263 2264 ANHE_at_cache (periodics [HEAP0]); 2265 downheap (periodics, periodiccnt, HEAP0); 2266 } 2267 else 2268 ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */ 2269 2270 EV_FREQUENT_CHECK; 2271 feed_reverse (EV_A_ (W)w); 2272 } 2273 while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now); 2274 2275 feed_reverse_done (EV_A_ EV_PERIODIC); 2276 } 2277 } 2278 2279 /* simply recalculate all periodics */ 2280 /* TODO: maybe ensure that at least one event happens when jumping forward? */ 2281 static void noinline 2282 periodics_reschedule (EV_P) 2283 { 2284 int i; 2285 2286 /* adjust periodics after time jump */ 2287 for (i = HEAP0; i < periodiccnt + HEAP0; ++i) 2288 { 2289 ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]); 2290 2291 if (w->reschedule_cb) 2292 ev_at (w) = w->reschedule_cb (w, ev_rt_now); 2293 else if (w->interval) 2294 periodic_recalc (EV_A_ w); 2295 2296 ANHE_at_cache (periodics [i]); 2297 } 2298 2299 reheap (periodics, periodiccnt); 2300 } 2301 #endif 2302 2303 /* adjust all timers by a given offset */ 2304 static void noinline 2305 timers_reschedule (EV_P_ ev_tstamp adjust) 2306 { 2307 int i; 2308 2309 for (i = 0; i < timercnt; ++i) 2310 { 2311 ANHE *he = timers + i + HEAP0; 2312 ANHE_w (*he)->at += adjust; 2313 ANHE_at_cache (*he); 2314 } 2315 } 2316 2317 /* fetch new monotonic and realtime times from the kernel */ 2318 /* also detect if there was a timejump, and act accordingly */ 2319 inline_speed void 2320 time_update (EV_P_ ev_tstamp max_block) 2321 { 2322 #if EV_USE_MONOTONIC 2323 if (expect_true (have_monotonic)) 2324 { 2325 int i; 2326 ev_tstamp odiff = rtmn_diff; 2327 2328 mn_now = get_clock (); 2329 2330 /* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */ 2331 /* interpolate in the meantime */ 2332 if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5)) 2333 { 2334 ev_rt_now = rtmn_diff + mn_now; 2335 return; 2336 } 2337 2338 now_floor = mn_now; 2339 ev_rt_now = ev_time (); 2340 2341 /* loop a few times, before making important decisions. 2342 * on the choice of "4": one iteration isn't enough, 2343 * in case we get preempted during the calls to 2344 * ev_time and get_clock. a second call is almost guaranteed 2345 * to succeed in that case, though. and looping a few more times 2346 * doesn't hurt either as we only do this on time-jumps or 2347 * in the unlikely event of having been preempted here. 2348 */ 2349 for (i = 4; --i; ) 2350 { 2351 rtmn_diff = ev_rt_now - mn_now; 2352 2353 if (expect_true (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)) 2354 return; /* all is well */ 2355 2356 ev_rt_now = ev_time (); 2357 mn_now = get_clock (); 2358 now_floor = mn_now; 2359 } 2360 2361 /* no timer adjustment, as the monotonic clock doesn't jump */ 2362 /* timers_reschedule (EV_A_ rtmn_diff - odiff) */ 2363 # if EV_PERIODIC_ENABLE 2364 periodics_reschedule (EV_A); 2365 # endif 2366 } 2367 else 2368 #endif 2369 { 2370 ev_rt_now = ev_time (); 2371 2372 if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP)) 2373 { 2374 /* adjust timers. this is easy, as the offset is the same for all of them */ 2375 timers_reschedule (EV_A_ ev_rt_now - mn_now); 2376 #if EV_PERIODIC_ENABLE 2377 periodics_reschedule (EV_A); 2378 #endif 2379 } 2380 2381 mn_now = ev_rt_now; 2382 } 2383 } 2384 2385 void 2386 ev_run (EV_P_ int flags) 2387 { 2388 #if EV_FEATURE_API 2389 ++loop_depth; 2390 #endif 2391 2392 assert (("libev: ev_loop recursion during release detected", loop_done != EVBREAK_RECURSE)); 2393 2394 loop_done = EVBREAK_CANCEL; 2395 2396 EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */ 2397 2398 do 2399 { 2400 #if EV_VERIFY >= 2 2401 ev_verify (EV_A); 2402 #endif 2403 2404 #ifndef _WIN32 2405 if (expect_false (curpid)) /* penalise the forking check even more */ 2406 if (expect_false (getpid () != curpid)) 2407 { 2408 curpid = getpid (); 2409 postfork = 1; 2410 } 2411 #endif 2412 2413 #if EV_FORK_ENABLE 2414 /* we might have forked, so queue fork handlers */ 2415 if (expect_false (postfork)) 2416 if (forkcnt) 2417 { 2418 queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK); 2419 EV_INVOKE_PENDING; 2420 } 2421 #endif 2422 2423 #if EV_PREPARE_ENABLE 2424 /* queue prepare watchers (and execute them) */ 2425 if (expect_false (preparecnt)) 2426 { 2427 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); 2428 EV_INVOKE_PENDING; 2429 } 2430 #endif 2431 2432 if (expect_false (loop_done)) 2433 break; 2434 2435 /* we might have forked, so reify kernel state if necessary */ 2436 if (expect_false (postfork)) 2437 loop_fork (EV_A); 2438 2439 /* update fd-related kernel structures */ 2440 fd_reify (EV_A); 2441 2442 /* calculate blocking time */ 2443 { 2444 ev_tstamp waittime = 0.; 2445 ev_tstamp sleeptime = 0.; 2446 2447 /* remember old timestamp for io_blocktime calculation */ 2448 ev_tstamp prev_mn_now = mn_now; 2449 2450 /* update time to cancel out callback processing overhead */ 2451 time_update (EV_A_ 1e100); 2452 2453 if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt))) 2454 { 2455 waittime = MAX_BLOCKTIME; 2456 2457 if (timercnt) 2458 { 2459 ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge; 2460 if (waittime > to) waittime = to; 2461 } 2462 2463 #if EV_PERIODIC_ENABLE 2464 if (periodiccnt) 2465 { 2466 ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now + backend_fudge; 2467 if (waittime > to) waittime = to; 2468 } 2469 #endif 2470 2471 /* don't let timeouts decrease the waittime below timeout_blocktime */ 2472 if (expect_false (waittime < timeout_blocktime)) 2473 waittime = timeout_blocktime; 2474 2475 /* extra check because io_blocktime is commonly 0 */ 2476 if (expect_false (io_blocktime)) 2477 { 2478 sleeptime = io_blocktime - (mn_now - prev_mn_now); 2479 2480 if (sleeptime > waittime - backend_fudge) 2481 sleeptime = waittime - backend_fudge; 2482 2483 if (expect_true (sleeptime > 0.)) 2484 { 2485 ev_sleep (sleeptime); 2486 waittime -= sleeptime; 2487 } 2488 } 2489 } 2490 2491 #if EV_FEATURE_API 2492 ++loop_count; 2493 #endif 2494 assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */ 2495 backend_poll (EV_A_ waittime); 2496 assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */ 2497 2498 /* update ev_rt_now, do magic */ 2499 time_update (EV_A_ waittime + sleeptime); 2500 } 2501 2502 /* queue pending timers and reschedule them */ 2503 timers_reify (EV_A); /* relative timers called last */ 2504 #if EV_PERIODIC_ENABLE 2505 periodics_reify (EV_A); /* absolute timers called first */ 2506 #endif 2507 2508 #if EV_IDLE_ENABLE 2509 /* queue idle watchers unless other events are pending */ 2510 idle_reify (EV_A); 2511 #endif 2512 2513 #if EV_CHECK_ENABLE 2514 /* queue check watchers, to be executed first */ 2515 if (expect_false (checkcnt)) 2516 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK); 2517 #endif 2518 2519 EV_INVOKE_PENDING; 2520 } 2521 while (expect_true ( 2522 activecnt 2523 && !loop_done 2524 && !(flags & (EVRUN_ONCE | EVRUN_NOWAIT)) 2525 )); 2526 2527 if (loop_done == EVBREAK_ONE) 2528 loop_done = EVBREAK_CANCEL; 2529 2530 #if EV_FEATURE_API 2531 --loop_depth; 2532 #endif 2533 } 2534 2535 void 2536 ev_break (EV_P_ int how) 2537 { 2538 loop_done = how; 2539 } 2540 2541 void 2542 ev_ref (EV_P) 2543 { 2544 ++activecnt; 2545 } 2546 2547 void 2548 ev_unref (EV_P) 2549 { 2550 --activecnt; 2551 } 2552 2553 void 2554 ev_now_update (EV_P) 2555 { 2556 time_update (EV_A_ 1e100); 2557 } 2558 2559 void 2560 ev_suspend (EV_P) 2561 { 2562 ev_now_update (EV_A); 2563 } 2564 2565 void 2566 ev_resume (EV_P) 2567 { 2568 ev_tstamp mn_prev = mn_now; 2569 2570 ev_now_update (EV_A); 2571 timers_reschedule (EV_A_ mn_now - mn_prev); 2572 #if EV_PERIODIC_ENABLE 2573 /* TODO: really do this? */ 2574 periodics_reschedule (EV_A); 2575 #endif 2576 } 2577 2578 /*****************************************************************************/ 2579 /* singly-linked list management, used when the expected list length is short */ 2580 2581 inline_size void 2582 wlist_add (WL *head, WL elem) 2583 { 2584 elem->next = *head; 2585 *head = elem; 2586 } 2587 2588 inline_size void 2589 wlist_del (WL *head, WL elem) 2590 { 2591 while (*head) 2592 { 2593 if (expect_true (*head == elem)) 2594 { 2595 *head = elem->next; 2596 break; 2597 } 2598 2599 head = &(*head)->next; 2600 } 2601 } 2602 2603 /* internal, faster, version of ev_clear_pending */ 2604 inline_speed void 2605 clear_pending (EV_P_ W w) 2606 { 2607 if (w->pending) 2608 { 2609 pendings [ABSPRI (w)][w->pending - 1].w = (W)&pending_w; 2610 w->pending = 0; 2611 } 2612 } 2613 2614 int 2615 ev_clear_pending (EV_P_ void *w) 2616 { 2617 W w_ = (W)w; 2618 int pending = w_->pending; 2619 2620 if (expect_true (pending)) 2621 { 2622 ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1; 2623 p->w = (W)&pending_w; 2624 w_->pending = 0; 2625 return p->events; 2626 } 2627 else 2628 return 0; 2629 } 2630 2631 inline_size void 2632 pri_adjust (EV_P_ W w) 2633 { 2634 int pri = ev_priority (w); 2635 pri = pri < EV_MINPRI ? EV_MINPRI : pri; 2636 pri = pri > EV_MAXPRI ? EV_MAXPRI : pri; 2637 ev_set_priority (w, pri); 2638 } 2639 2640 inline_speed void 2641 ev_start (EV_P_ W w, int active) 2642 { 2643 pri_adjust (EV_A_ w); 2644 w->active = active; 2645 ev_ref (EV_A); 2646 } 2647 2648 inline_size void 2649 ev_stop (EV_P_ W w) 2650 { 2651 ev_unref (EV_A); 2652 w->active = 0; 2653 } 2654 2655 /*****************************************************************************/ 2656 2657 void noinline 2658 ev_io_start (EV_P_ ev_io *w) 2659 { 2660 int fd = w->fd; 2661 2662 if (expect_false (ev_is_active (w))) 2663 return; 2664 2665 assert (("libev: ev_io_start called with negative fd", fd >= 0)); 2666 assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE)))); 2667 2668 EV_FREQUENT_CHECK; 2669 2670 ev_start (EV_A_ (W)w, 1); 2671 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); 2672 wlist_add (&anfds[fd].head, (WL)w); 2673 2674 fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY); 2675 w->events &= ~EV__IOFDSET; 2676 2677 EV_FREQUENT_CHECK; 2678 } 2679 2680 void noinline 2681 ev_io_stop (EV_P_ ev_io *w) 2682 { 2683 clear_pending (EV_A_ (W)w); 2684 if (expect_false (!ev_is_active (w))) 2685 return; 2686 2687 assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax)); 2688 2689 EV_FREQUENT_CHECK; 2690 2691 wlist_del (&anfds[w->fd].head, (WL)w); 2692 ev_stop (EV_A_ (W)w); 2693 2694 fd_change (EV_A_ w->fd, EV_ANFD_REIFY); 2695 2696 EV_FREQUENT_CHECK; 2697 } 2698 2699 void noinline 2700 ev_timer_start (EV_P_ ev_timer *w) 2701 { 2702 if (expect_false (ev_is_active (w))) 2703 return; 2704 2705 ev_at (w) += mn_now; 2706 2707 assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.)); 2708 2709 EV_FREQUENT_CHECK; 2710 2711 ++timercnt; 2712 ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1); 2713 array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2); 2714 ANHE_w (timers [ev_active (w)]) = (WT)w; 2715 ANHE_at_cache (timers [ev_active (w)]); 2716 upheap (timers, ev_active (w)); 2717 2718 EV_FREQUENT_CHECK; 2719 2720 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/ 2721 } 2722 2723 void noinline 2724 ev_timer_stop (EV_P_ ev_timer *w) 2725 { 2726 clear_pending (EV_A_ (W)w); 2727 if (expect_false (!ev_is_active (w))) 2728 return; 2729 2730 EV_FREQUENT_CHECK; 2731 2732 { 2733 int active = ev_active (w); 2734 2735 assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w)); 2736 2737 --timercnt; 2738 2739 if (expect_true (active < timercnt + HEAP0)) 2740 { 2741 timers [active] = timers [timercnt + HEAP0]; 2742 adjustheap (timers, timercnt, active); 2743 } 2744 } 2745 2746 ev_at (w) -= mn_now; 2747 2748 ev_stop (EV_A_ (W)w); 2749 2750 EV_FREQUENT_CHECK; 2751 } 2752 2753 void noinline 2754 ev_timer_again (EV_P_ ev_timer *w) 2755 { 2756 EV_FREQUENT_CHECK; 2757 2758 if (ev_is_active (w)) 2759 { 2760 if (w->repeat) 2761 { 2762 ev_at (w) = mn_now + w->repeat; 2763 ANHE_at_cache (timers [ev_active (w)]); 2764 adjustheap (timers, timercnt, ev_active (w)); 2765 } 2766 else 2767 ev_timer_stop (EV_A_ w); 2768 } 2769 else if (w->repeat) 2770 { 2771 ev_at (w) = w->repeat; 2772 ev_timer_start (EV_A_ w); 2773 } 2774 2775 EV_FREQUENT_CHECK; 2776 } 2777 2778 ev_tstamp 2779 ev_timer_remaining (EV_P_ ev_timer *w) 2780 { 2781 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); 2782 } 2783 2784 #if EV_PERIODIC_ENABLE 2785 void noinline 2786 ev_periodic_start (EV_P_ ev_periodic *w) 2787 { 2788 if (expect_false (ev_is_active (w))) 2789 return; 2790 2791 if (w->reschedule_cb) 2792 ev_at (w) = w->reschedule_cb (w, ev_rt_now); 2793 else if (w->interval) 2794 { 2795 assert (("libev: ev_periodic_start called with negative interval value", w->interval >= 0.)); 2796 periodic_recalc (EV_A_ w); 2797 } 2798 else 2799 ev_at (w) = w->offset; 2800 2801 EV_FREQUENT_CHECK; 2802 2803 ++periodiccnt; 2804 ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1); 2805 array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2); 2806 ANHE_w (periodics [ev_active (w)]) = (WT)w; 2807 ANHE_at_cache (periodics [ev_active (w)]); 2808 upheap (periodics, ev_active (w)); 2809 2810 EV_FREQUENT_CHECK; 2811 2812 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/ 2813 } 2814 2815 void noinline 2816 ev_periodic_stop (EV_P_ ev_periodic *w) 2817 { 2818 clear_pending (EV_A_ (W)w); 2819 if (expect_false (!ev_is_active (w))) 2820 return; 2821 2822 EV_FREQUENT_CHECK; 2823 2824 { 2825 int active = ev_active (w); 2826 2827 assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w)); 2828 2829 --periodiccnt; 2830 2831 if (expect_true (active < periodiccnt + HEAP0)) 2832 { 2833 periodics [active] = periodics [periodiccnt + HEAP0]; 2834 adjustheap (periodics, periodiccnt, active); 2835 } 2836 } 2837 2838 ev_stop (EV_A_ (W)w); 2839 2840 EV_FREQUENT_CHECK; 2841 } 2842 2843 void noinline 2844 ev_periodic_again (EV_P_ ev_periodic *w) 2845 { 2846 /* TODO: use adjustheap and recalculation */ 2847 ev_periodic_stop (EV_A_ w); 2848 ev_periodic_start (EV_A_ w); 2849 } 2850 #endif 2851 2852 #ifndef SA_RESTART 2853 # define SA_RESTART 0 2854 #endif 2855 2856 #if EV_SIGNAL_ENABLE 2857 2858 void noinline 2859 ev_signal_start (EV_P_ ev_signal *w) 2860 { 2861 if (expect_false (ev_is_active (w))) 2862 return; 2863 2864 assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG)); 2865 2866 #if EV_MULTIPLICITY 2867 assert (("libev: a signal must not be attached to two different loops", 2868 !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop)); 2869 2870 signals [w->signum - 1].loop = EV_A; 2871 #endif 2872 2873 EV_FREQUENT_CHECK; 2874 2875 #if EV_USE_SIGNALFD 2876 if (sigfd == -2) 2877 { 2878 sigfd = signalfd (-1, &sigfd_set, SFD_NONBLOCK | SFD_CLOEXEC); 2879 if (sigfd < 0 && errno == EINVAL) 2880 sigfd = signalfd (-1, &sigfd_set, 0); /* retry without flags */ 2881 2882 if (sigfd >= 0) 2883 { 2884 fd_intern (sigfd); /* doing it twice will not hurt */ 2885 2886 sigemptyset (&sigfd_set); 2887 2888 ev_io_init (&sigfd_w, sigfdcb, sigfd, EV_READ); 2889 ev_set_priority (&sigfd_w, EV_MAXPRI); 2890 ev_io_start (EV_A_ &sigfd_w); 2891 ev_unref (EV_A); /* signalfd watcher should not keep loop alive */ 2892 } 2893 } 2894 2895 if (sigfd >= 0) 2896 { 2897 /* TODO: check .head */ 2898 sigaddset (&sigfd_set, w->signum); 2899 sigprocmask (SIG_BLOCK, &sigfd_set, 0); 2900 2901 signalfd (sigfd, &sigfd_set, 0); 2902 } 2903 #endif 2904 2905 ev_start (EV_A_ (W)w, 1); 2906 wlist_add (&signals [w->signum - 1].head, (WL)w); 2907 2908 if (!((WL)w)->next) 2909 # if EV_USE_SIGNALFD 2910 if (sigfd < 0) /*TODO*/ 2911 # endif 2912 { 2913 # ifdef _WIN32 2914 evpipe_init (EV_A); 2915 2916 signal (w->signum, ev_sighandler); 2917 # else 2918 struct sigaction sa; 2919 2920 evpipe_init (EV_A); 2921 2922 sa.sa_handler = ev_sighandler; 2923 sigfillset (&sa.sa_mask); 2924 sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */ 2925 sigaction (w->signum, &sa, 0); 2926 2927 if (origflags & EVFLAG_NOSIGMASK) 2928 { 2929 sigemptyset (&sa.sa_mask); 2930 sigaddset (&sa.sa_mask, w->signum); 2931 sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0); 2932 } 2933 #endif 2934 } 2935 2936 EV_FREQUENT_CHECK; 2937 } 2938 2939 void noinline 2940 ev_signal_stop (EV_P_ ev_signal *w) 2941 { 2942 clear_pending (EV_A_ (W)w); 2943 if (expect_false (!ev_is_active (w))) 2944 return; 2945 2946 EV_FREQUENT_CHECK; 2947 2948 wlist_del (&signals [w->signum - 1].head, (WL)w); 2949 ev_stop (EV_A_ (W)w); 2950 2951 if (!signals [w->signum - 1].head) 2952 { 2953 #if EV_MULTIPLICITY 2954 signals [w->signum - 1].loop = 0; /* unattach from signal */ 2955 #endif 2956 #if EV_USE_SIGNALFD 2957 if (sigfd >= 0) 2958 { 2959 sigset_t ss; 2960 2961 sigemptyset (&ss); 2962 sigaddset (&ss, w->signum); 2963 sigdelset (&sigfd_set, w->signum); 2964 2965 signalfd (sigfd, &sigfd_set, 0); 2966 sigprocmask (SIG_UNBLOCK, &ss, 0); 2967 } 2968 else 2969 #endif 2970 signal (w->signum, SIG_DFL); 2971 } 2972 2973 EV_FREQUENT_CHECK; 2974 } 2975 2976 #endif 2977 2978 #if EV_CHILD_ENABLE 2979 2980 void 2981 ev_child_start (EV_P_ ev_child *w) 2982 { 2983 #if EV_MULTIPLICITY 2984 assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); 2985 #endif 2986 if (expect_false (ev_is_active (w))) 2987 return; 2988 2989 EV_FREQUENT_CHECK; 2990 2991 ev_start (EV_A_ (W)w, 1); 2992 wlist_add (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w); 2993 2994 EV_FREQUENT_CHECK; 2995 } 2996 2997 void 2998 ev_child_stop (EV_P_ ev_child *w) 2999 { 3000 clear_pending (EV_A_ (W)w); 3001 if (expect_false (!ev_is_active (w))) 3002 return; 3003 3004 EV_FREQUENT_CHECK; 3005 3006 wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w); 3007 ev_stop (EV_A_ (W)w); 3008 3009 EV_FREQUENT_CHECK; 3010 } 3011 3012 #endif 3013 3014 #if EV_STAT_ENABLE 3015 3016 # ifdef _WIN32 3017 # undef lstat 3018 # define lstat(a,b) _stati64 (a,b) 3019 # endif 3020 3021 #define DEF_STAT_INTERVAL 5.0074891 3022 #define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */ 3023 #define MIN_STAT_INTERVAL 0.1074891 3024 3025 static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents); 3026 3027 #if EV_USE_INOTIFY 3028 3029 /* the * 2 is to allow for alignment padding, which for some reason is >> 8 */ 3030 # define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX) 3031 3032 static void noinline 3033 infy_add (EV_P_ ev_stat *w) 3034 { 3035 w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD); 3036 3037 if (w->wd >= 0) 3038 { 3039 struct statfs sfs; 3040 3041 /* now local changes will be tracked by inotify, but remote changes won't */ 3042 /* unless the filesystem is known to be local, we therefore still poll */ 3043 /* also do poll on <2.6.25, but with normal frequency */ 3044 3045 if (!fs_2625) 3046 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL; 3047 else if (!statfs (w->path, &sfs) 3048 && (sfs.f_type == 0x1373 /* devfs */ 3049 || sfs.f_type == 0xEF53 /* ext2/3 */ 3050 || sfs.f_type == 0x3153464a /* jfs */ 3051 || sfs.f_type == 0x52654973 /* reiser3 */ 3052 || sfs.f_type == 0x01021994 /* tempfs */ 3053 || sfs.f_type == 0x58465342 /* xfs */)) 3054 w->timer.repeat = 0.; /* filesystem is local, kernel new enough */ 3055 else 3056 w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */ 3057 } 3058 else 3059 { 3060 /* can't use inotify, continue to stat */ 3061 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL; 3062 3063 /* if path is not there, monitor some parent directory for speedup hints */ 3064 /* note that exceeding the hardcoded path limit is not a correctness issue, */ 3065 /* but an efficiency issue only */ 3066 if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096) 3067 { 3068 char path [4096]; 3069 strcpy (path, w->path); 3070 3071 do 3072 { 3073 int mask = IN_MASK_ADD | IN_DELETE_SELF | IN_MOVE_SELF 3074 | (errno == EACCES ? IN_ATTRIB : IN_CREATE | IN_MOVED_TO); 3075 3076 char *pend = strrchr (path, '/'); 3077 3078 if (!pend || pend == path) 3079 break; 3080 3081 *pend = 0; 3082 w->wd = inotify_add_watch (fs_fd, path, mask); 3083 } 3084 while (w->wd < 0 && (errno == ENOENT || errno == EACCES)); 3085 } 3086 } 3087 3088 if (w->wd >= 0) 3089 wlist_add (&fs_hash [w->wd & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w); 3090 3091 /* now re-arm timer, if required */ 3092 if (ev_is_active (&w->timer)) ev_ref (EV_A); 3093 ev_timer_again (EV_A_ &w->timer); 3094 if (ev_is_active (&w->timer)) ev_unref (EV_A); 3095 } 3096 3097 static void noinline 3098 infy_del (EV_P_ ev_stat *w) 3099 { 3100 int slot; 3101 int wd = w->wd; 3102 3103 if (wd < 0) 3104 return; 3105 3106 w->wd = -2; 3107 slot = wd & ((EV_INOTIFY_HASHSIZE) - 1); 3108 wlist_del (&fs_hash [slot].head, (WL)w); 3109 3110 /* remove this watcher, if others are watching it, they will rearm */ 3111 inotify_rm_watch (fs_fd, wd); 3112 } 3113 3114 static void noinline 3115 infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev) 3116 { 3117 if (slot < 0) 3118 /* overflow, need to check for all hash slots */ 3119 for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot) 3120 infy_wd (EV_A_ slot, wd, ev); 3121 else 3122 { 3123 WL w_; 3124 3125 for (w_ = fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head; w_; ) 3126 { 3127 ev_stat *w = (ev_stat *)w_; 3128 w_ = w_->next; /* lets us remove this watcher and all before it */ 3129 3130 if (w->wd == wd || wd == -1) 3131 { 3132 if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF)) 3133 { 3134 wlist_del (&fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w); 3135 w->wd = -1; 3136 infy_add (EV_A_ w); /* re-add, no matter what */ 3137 } 3138 3139 stat_timer_cb (EV_A_ &w->timer, 0); 3140 } 3141 } 3142 } 3143 } 3144 3145 static void 3146 infy_cb (EV_P_ ev_io *w, int revents) 3147 { 3148 char buf [EV_INOTIFY_BUFSIZE]; 3149 int ofs; 3150 int len = read (fs_fd, buf, sizeof (buf)); 3151 3152 for (ofs = 0; ofs < len; ) 3153 { 3154 struct inotify_event *ev = (struct inotify_event *)(buf + ofs); 3155 infy_wd (EV_A_ ev->wd, ev->wd, ev); 3156 ofs += sizeof (struct inotify_event) + ev->len; 3157 } 3158 } 3159 3160 inline_size void 3161 ev_check_2625 (EV_P) 3162 { 3163 /* kernels < 2.6.25 are borked 3164 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html 3165 */ 3166 if (ev_linux_version () < 0x020619) 3167 return; 3168 3169 fs_2625 = 1; 3170 } 3171 3172 inline_size int 3173 infy_newfd (void) 3174 { 3175 #if defined (IN_CLOEXEC) && defined (IN_NONBLOCK) 3176 int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK); 3177 if (fd >= 0) 3178 return fd; 3179 #endif 3180 return inotify_init (); 3181 } 3182 3183 inline_size void 3184 infy_init (EV_P) 3185 { 3186 if (fs_fd != -2) 3187 return; 3188 3189 fs_fd = -1; 3190 3191 ev_check_2625 (EV_A); 3192 3193 fs_fd = infy_newfd (); 3194 3195 if (fs_fd >= 0) 3196 { 3197 fd_intern (fs_fd); 3198 ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ); 3199 ev_set_priority (&fs_w, EV_MAXPRI); 3200 ev_io_start (EV_A_ &fs_w); 3201 ev_unref (EV_A); 3202 } 3203 } 3204 3205 inline_size void 3206 infy_fork (EV_P) 3207 { 3208 int slot; 3209 3210 if (fs_fd < 0) 3211 return; 3212 3213 ev_ref (EV_A); 3214 ev_io_stop (EV_A_ &fs_w); 3215 close (fs_fd); 3216 fs_fd = infy_newfd (); 3217 3218 if (fs_fd >= 0) 3219 { 3220 fd_intern (fs_fd); 3221 ev_io_set (&fs_w, fs_fd, EV_READ); 3222 ev_io_start (EV_A_ &fs_w); 3223 ev_unref (EV_A); 3224 } 3225 3226 for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot) 3227 { 3228 WL w_ = fs_hash [slot].head; 3229 fs_hash [slot].head = 0; 3230 3231 while (w_) 3232 { 3233 ev_stat *w = (ev_stat *)w_; 3234 w_ = w_->next; /* lets us add this watcher */ 3235 3236 w->wd = -1; 3237 3238 if (fs_fd >= 0) 3239 infy_add (EV_A_ w); /* re-add, no matter what */ 3240 else 3241 { 3242 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL; 3243 if (ev_is_active (&w->timer)) ev_ref (EV_A); 3244 ev_timer_again (EV_A_ &w->timer); 3245 if (ev_is_active (&w->timer)) ev_unref (EV_A); 3246 } 3247 } 3248 } 3249 } 3250 3251 #endif 3252 3253 #ifdef _WIN32 3254 # define EV_LSTAT(p,b) _stati64 (p, b) 3255 #else 3256 # define EV_LSTAT(p,b) lstat (p, b) 3257 #endif 3258 3259 void 3260 ev_stat_stat (EV_P_ ev_stat *w) 3261 { 3262 if (lstat (w->path, &w->attr) < 0) 3263 w->attr.st_nlink = 0; 3264 else if (!w->attr.st_nlink) 3265 w->attr.st_nlink = 1; 3266 } 3267 3268 static void noinline 3269 stat_timer_cb (EV_P_ ev_timer *w_, int revents) 3270 { 3271 ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer)); 3272 3273 ev_statdata prev = w->attr; 3274 ev_stat_stat (EV_A_ w); 3275 3276 /* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */ 3277 if ( 3278 prev.st_dev != w->attr.st_dev 3279 || prev.st_ino != w->attr.st_ino 3280 || prev.st_mode != w->attr.st_mode 3281 || prev.st_nlink != w->attr.st_nlink 3282 || prev.st_uid != w->attr.st_uid 3283 || prev.st_gid != w->attr.st_gid 3284 || prev.st_rdev != w->attr.st_rdev 3285 || prev.st_size != w->attr.st_size 3286 || prev.st_atime != w->attr.st_atime 3287 || prev.st_mtime != w->attr.st_mtime 3288 || prev.st_ctime != w->attr.st_ctime 3289 ) { 3290 /* we only update w->prev on actual differences */ 3291 /* in case we test more often than invoke the callback, */ 3292 /* to ensure that prev is always different to attr */ 3293 w->prev = prev; 3294 3295 #if EV_USE_INOTIFY 3296 if (fs_fd >= 0) 3297 { 3298 infy_del (EV_A_ w); 3299 infy_add (EV_A_ w); 3300 ev_stat_stat (EV_A_ w); /* avoid race... */ 3301 } 3302 #endif 3303 3304 ev_feed_event (EV_A_ w, EV_STAT); 3305 } 3306 } 3307 3308 void 3309 ev_stat_start (EV_P_ ev_stat *w) 3310 { 3311 if (expect_false (ev_is_active (w))) 3312 return; 3313 3314 ev_stat_stat (EV_A_ w); 3315 3316 if (w->interval < MIN_STAT_INTERVAL && w->interval) 3317 w->interval = MIN_STAT_INTERVAL; 3318 3319 ev_timer_init (&w->timer, stat_timer_cb, 0., w->interval ? w->interval : DEF_STAT_INTERVAL); 3320 ev_set_priority (&w->timer, ev_priority (w)); 3321 3322 #if EV_USE_INOTIFY 3323 infy_init (EV_A); 3324 3325 if (fs_fd >= 0) 3326 infy_add (EV_A_ w); 3327 else 3328 #endif 3329 { 3330 ev_timer_again (EV_A_ &w->timer); 3331 ev_unref (EV_A); 3332 } 3333 3334 ev_start (EV_A_ (W)w, 1); 3335 3336 EV_FREQUENT_CHECK; 3337 } 3338 3339 void 3340 ev_stat_stop (EV_P_ ev_stat *w) 3341 { 3342 clear_pending (EV_A_ (W)w); 3343 if (expect_false (!ev_is_active (w))) 3344 return; 3345 3346 EV_FREQUENT_CHECK; 3347 3348 #if EV_USE_INOTIFY 3349 infy_del (EV_A_ w); 3350 #endif 3351 3352 if (ev_is_active (&w->timer)) 3353 { 3354 ev_ref (EV_A); 3355 ev_timer_stop (EV_A_ &w->timer); 3356 } 3357 3358 ev_stop (EV_A_ (W)w); 3359 3360 EV_FREQUENT_CHECK; 3361 } 3362 #endif 3363 3364 #if EV_IDLE_ENABLE 3365 void 3366 ev_idle_start (EV_P_ ev_idle *w) 3367 { 3368 if (expect_false (ev_is_active (w))) 3369 return; 3370 3371 pri_adjust (EV_A_ (W)w); 3372 3373 EV_FREQUENT_CHECK; 3374 3375 { 3376 int active = ++idlecnt [ABSPRI (w)]; 3377 3378 ++idleall; 3379 ev_start (EV_A_ (W)w, active); 3380 3381 array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2); 3382 idles [ABSPRI (w)][active - 1] = w; 3383 } 3384 3385 EV_FREQUENT_CHECK; 3386 } 3387 3388 void 3389 ev_idle_stop (EV_P_ ev_idle *w) 3390 { 3391 clear_pending (EV_A_ (W)w); 3392 if (expect_false (!ev_is_active (w))) 3393 return; 3394 3395 EV_FREQUENT_CHECK; 3396 3397 { 3398 int active = ev_active (w); 3399 3400 idles [ABSPRI (w)][active - 1] = idles [ABSPRI (w)][--idlecnt [ABSPRI (w)]]; 3401 ev_active (idles [ABSPRI (w)][active - 1]) = active; 3402 3403 ev_stop (EV_A_ (W)w); 3404 --idleall; 3405 } 3406 3407 EV_FREQUENT_CHECK; 3408 } 3409 #endif 3410 3411 #if EV_PREPARE_ENABLE 3412 void 3413 ev_prepare_start (EV_P_ ev_prepare *w) 3414 { 3415 if (expect_false (ev_is_active (w))) 3416 return; 3417 3418 EV_FREQUENT_CHECK; 3419 3420 ev_start (EV_A_ (W)w, ++preparecnt); 3421 array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2); 3422 prepares [preparecnt - 1] = w; 3423 3424 EV_FREQUENT_CHECK; 3425 } 3426 3427 void 3428 ev_prepare_stop (EV_P_ ev_prepare *w) 3429 { 3430 clear_pending (EV_A_ (W)w); 3431 if (expect_false (!ev_is_active (w))) 3432 return; 3433 3434 EV_FREQUENT_CHECK; 3435 3436 { 3437 int active = ev_active (w); 3438 3439 prepares [active - 1] = prepares [--preparecnt]; 3440 ev_active (prepares [active - 1]) = active; 3441 } 3442 3443 ev_stop (EV_A_ (W)w); 3444 3445 EV_FREQUENT_CHECK; 3446 } 3447 #endif 3448 3449 #if EV_CHECK_ENABLE 3450 void 3451 ev_check_start (EV_P_ ev_check *w) 3452 { 3453 if (expect_false (ev_is_active (w))) 3454 return; 3455 3456 EV_FREQUENT_CHECK; 3457 3458 ev_start (EV_A_ (W)w, ++checkcnt); 3459 array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2); 3460 checks [checkcnt - 1] = w; 3461 3462 EV_FREQUENT_CHECK; 3463 } 3464 3465 void 3466 ev_check_stop (EV_P_ ev_check *w) 3467 { 3468 clear_pending (EV_A_ (W)w); 3469 if (expect_false (!ev_is_active (w))) 3470 return; 3471 3472 EV_FREQUENT_CHECK; 3473 3474 { 3475 int active = ev_active (w); 3476 3477 checks [active - 1] = checks [--checkcnt]; 3478 ev_active (checks [active - 1]) = active; 3479 } 3480 3481 ev_stop (EV_A_ (W)w); 3482 3483 EV_FREQUENT_CHECK; 3484 } 3485 #endif 3486 3487 #if EV_EMBED_ENABLE 3488 void noinline 3489 ev_embed_sweep (EV_P_ ev_embed *w) 3490 { 3491 ev_run (w->other, EVRUN_NOWAIT); 3492 } 3493 3494 static void 3495 embed_io_cb (EV_P_ ev_io *io, int revents) 3496 { 3497 ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io)); 3498 3499 if (ev_cb (w)) 3500 ev_feed_event (EV_A_ (W)w, EV_EMBED); 3501 else 3502 ev_run (w->other, EVRUN_NOWAIT); 3503 } 3504 3505 static void 3506 embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents) 3507 { 3508 ev_embed *w = (ev_embed *)(((char *)prepare) - offsetof (ev_embed, prepare)); 3509 3510 { 3511 EV_P = w->other; 3512 3513 while (fdchangecnt) 3514 { 3515 fd_reify (EV_A); 3516 ev_run (EV_A_ EVRUN_NOWAIT); 3517 } 3518 } 3519 } 3520 3521 static void 3522 embed_fork_cb (EV_P_ ev_fork *fork_w, int revents) 3523 { 3524 ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork)); 3525 3526 ev_embed_stop (EV_A_ w); 3527 3528 { 3529 EV_P = w->other; 3530 3531 ev_loop_fork (EV_A); 3532 ev_run (EV_A_ EVRUN_NOWAIT); 3533 } 3534 3535 ev_embed_start (EV_A_ w); 3536 } 3537 3538 #if 0 3539 static void 3540 embed_idle_cb (EV_P_ ev_idle *idle, int revents) 3541 { 3542 ev_idle_stop (EV_A_ idle); 3543 } 3544 #endif 3545 3546 void 3547 ev_embed_start (EV_P_ ev_embed *w) 3548 { 3549 if (expect_false (ev_is_active (w))) 3550 return; 3551 3552 { 3553 EV_P = w->other; 3554 assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ())); 3555 ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ); 3556 } 3557 3558 EV_FREQUENT_CHECK; 3559 3560 ev_set_priority (&w->io, ev_priority (w)); 3561 ev_io_start (EV_A_ &w->io); 3562 3563 ev_prepare_init (&w->prepare, embed_prepare_cb); 3564 ev_set_priority (&w->prepare, EV_MINPRI); 3565 ev_prepare_start (EV_A_ &w->prepare); 3566 3567 ev_fork_init (&w->fork, embed_fork_cb); 3568 ev_fork_start (EV_A_ &w->fork); 3569 3570 /*ev_idle_init (&w->idle, e,bed_idle_cb);*/ 3571 3572 ev_start (EV_A_ (W)w, 1); 3573 3574 EV_FREQUENT_CHECK; 3575 } 3576 3577 void 3578 ev_embed_stop (EV_P_ ev_embed *w) 3579 { 3580 clear_pending (EV_A_ (W)w); 3581 if (expect_false (!ev_is_active (w))) 3582 return; 3583 3584 EV_FREQUENT_CHECK; 3585 3586 ev_io_stop (EV_A_ &w->io); 3587 ev_prepare_stop (EV_A_ &w->prepare); 3588 ev_fork_stop (EV_A_ &w->fork); 3589 3590 ev_stop (EV_A_ (W)w); 3591 3592 EV_FREQUENT_CHECK; 3593 } 3594 #endif 3595 3596 #if EV_FORK_ENABLE 3597 void 3598 ev_fork_start (EV_P_ ev_fork *w) 3599 { 3600 if (expect_false (ev_is_active (w))) 3601 return; 3602 3603 EV_FREQUENT_CHECK; 3604 3605 ev_start (EV_A_ (W)w, ++forkcnt); 3606 array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2); 3607 forks [forkcnt - 1] = w; 3608 3609 EV_FREQUENT_CHECK; 3610 } 3611 3612 void 3613 ev_fork_stop (EV_P_ ev_fork *w) 3614 { 3615 clear_pending (EV_A_ (W)w); 3616 if (expect_false (!ev_is_active (w))) 3617 return; 3618 3619 EV_FREQUENT_CHECK; 3620 3621 { 3622 int active = ev_active (w); 3623 3624 forks [active - 1] = forks [--forkcnt]; 3625 ev_active (forks [active - 1]) = active; 3626 } 3627 3628 ev_stop (EV_A_ (W)w); 3629 3630 EV_FREQUENT_CHECK; 3631 } 3632 #endif 3633 3634 #if EV_CLEANUP_ENABLE 3635 void 3636 ev_cleanup_start (EV_P_ ev_cleanup *w) 3637 { 3638 if (expect_false (ev_is_active (w))) 3639 return; 3640 3641 EV_FREQUENT_CHECK; 3642 3643 ev_start (EV_A_ (W)w, ++cleanupcnt); 3644 array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2); 3645 cleanups [cleanupcnt - 1] = w; 3646 3647 /* cleanup watchers should never keep a refcount on the loop */ 3648 ev_unref (EV_A); 3649 EV_FREQUENT_CHECK; 3650 } 3651 3652 void 3653 ev_cleanup_stop (EV_P_ ev_cleanup *w) 3654 { 3655 clear_pending (EV_A_ (W)w); 3656 if (expect_false (!ev_is_active (w))) 3657 return; 3658 3659 EV_FREQUENT_CHECK; 3660 ev_ref (EV_A); 3661 3662 { 3663 int active = ev_active (w); 3664 3665 cleanups [active - 1] = cleanups [--cleanupcnt]; 3666 ev_active (cleanups [active - 1]) = active; 3667 } 3668 3669 ev_stop (EV_A_ (W)w); 3670 3671 EV_FREQUENT_CHECK; 3672 } 3673 #endif 3674 3675 #if EV_ASYNC_ENABLE 3676 void 3677 ev_async_start (EV_P_ ev_async *w) 3678 { 3679 if (expect_false (ev_is_active (w))) 3680 return; 3681 3682 w->sent = 0; 3683 3684 evpipe_init (EV_A); 3685 3686 EV_FREQUENT_CHECK; 3687 3688 ev_start (EV_A_ (W)w, ++asynccnt); 3689 array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2); 3690 asyncs [asynccnt - 1] = w; 3691 3692 EV_FREQUENT_CHECK; 3693 } 3694 3695 void 3696 ev_async_stop (EV_P_ ev_async *w) 3697 { 3698 clear_pending (EV_A_ (W)w); 3699 if (expect_false (!ev_is_active (w))) 3700 return; 3701 3702 EV_FREQUENT_CHECK; 3703 3704 { 3705 int active = ev_active (w); 3706 3707 asyncs [active - 1] = asyncs [--asynccnt]; 3708 ev_active (asyncs [active - 1]) = active; 3709 } 3710 3711 ev_stop (EV_A_ (W)w); 3712 3713 EV_FREQUENT_CHECK; 3714 } 3715 3716 void 3717 ev_async_send (EV_P_ ev_async *w) 3718 { 3719 w->sent = 1; 3720 evpipe_write (EV_A_ &async_pending); 3721 } 3722 #endif 3723 3724 /*****************************************************************************/ 3725 3726 struct ev_once 3727 { 3728 ev_io io; 3729 ev_timer to; 3730 void (*cb)(int revents, void *arg); 3731 void *arg; 3732 }; 3733 3734 static void 3735 once_cb (EV_P_ struct ev_once *once, int revents) 3736 { 3737 void (*cb)(int revents, void *arg) = once->cb; 3738 void *arg = once->arg; 3739 3740 ev_io_stop (EV_A_ &once->io); 3741 ev_timer_stop (EV_A_ &once->to); 3742 ev_free (once); 3743 3744 cb (revents, arg); 3745 } 3746 3747 static void 3748 once_cb_io (EV_P_ ev_io *w, int revents) 3749 { 3750 struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)); 3751 3752 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->to)); 3753 } 3754 3755 static void 3756 once_cb_to (EV_P_ ev_timer *w, int revents) 3757 { 3758 struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)); 3759 3760 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io)); 3761 } 3762 3763 void 3764 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) 3765 { 3766 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once)); 3767 3768 if (expect_false (!once)) 3769 { 3770 cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMER, arg); 3771 return; 3772 } 3773 3774 once->cb = cb; 3775 once->arg = arg; 3776 3777 ev_init (&once->io, once_cb_io); 3778 if (fd >= 0) 3779 { 3780 ev_io_set (&once->io, fd, events); 3781 ev_io_start (EV_A_ &once->io); 3782 } 3783 3784 ev_init (&once->to, once_cb_to); 3785 if (timeout >= 0.) 3786 { 3787 ev_timer_set (&once->to, timeout, 0.); 3788 ev_timer_start (EV_A_ &once->to); 3789 } 3790 } 3791 3792 /*****************************************************************************/ 3793 3794 #if EV_WALK_ENABLE 3795 void 3796 ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) 3797 { 3798 int i, j; 3799 ev_watcher_list *wl, *wn; 3800 3801 if (types & (EV_IO | EV_EMBED)) 3802 for (i = 0; i < anfdmax; ++i) 3803 for (wl = anfds [i].head; wl; ) 3804 { 3805 wn = wl->next; 3806 3807 #if EV_EMBED_ENABLE 3808 if (ev_cb ((ev_io *)wl) == embed_io_cb) 3809 { 3810 if (types & EV_EMBED) 3811 cb (EV_A_ EV_EMBED, ((char *)wl) - offsetof (struct ev_embed, io)); 3812 } 3813 else 3814 #endif 3815 #if EV_USE_INOTIFY 3816 if (ev_cb ((ev_io *)wl) == infy_cb) 3817 ; 3818 else 3819 #endif 3820 if ((ev_io *)wl != &pipe_w) 3821 if (types & EV_IO) 3822 cb (EV_A_ EV_IO, wl); 3823 3824 wl = wn; 3825 } 3826 3827 if (types & (EV_TIMER | EV_STAT)) 3828 for (i = timercnt + HEAP0; i-- > HEAP0; ) 3829 #if EV_STAT_ENABLE 3830 /*TODO: timer is not always active*/ 3831 if (ev_cb ((ev_timer *)ANHE_w (timers [i])) == stat_timer_cb) 3832 { 3833 if (types & EV_STAT) 3834 cb (EV_A_ EV_STAT, ((char *)ANHE_w (timers [i])) - offsetof (struct ev_stat, timer)); 3835 } 3836 else 3837 #endif 3838 if (types & EV_TIMER) 3839 cb (EV_A_ EV_TIMER, ANHE_w (timers [i])); 3840 3841 #if EV_PERIODIC_ENABLE 3842 if (types & EV_PERIODIC) 3843 for (i = periodiccnt + HEAP0; i-- > HEAP0; ) 3844 cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i])); 3845 #endif 3846 3847 #if EV_IDLE_ENABLE 3848 if (types & EV_IDLE) 3849 for (j = NUMPRI; i--; ) 3850 for (i = idlecnt [j]; i--; ) 3851 cb (EV_A_ EV_IDLE, idles [j][i]); 3852 #endif 3853 3854 #if EV_FORK_ENABLE 3855 if (types & EV_FORK) 3856 for (i = forkcnt; i--; ) 3857 if (ev_cb (forks [i]) != embed_fork_cb) 3858 cb (EV_A_ EV_FORK, forks [i]); 3859 #endif 3860 3861 #if EV_ASYNC_ENABLE 3862 if (types & EV_ASYNC) 3863 for (i = asynccnt; i--; ) 3864 cb (EV_A_ EV_ASYNC, asyncs [i]); 3865 #endif 3866 3867 #if EV_PREPARE_ENABLE 3868 if (types & EV_PREPARE) 3869 for (i = preparecnt; i--; ) 3870 # if EV_EMBED_ENABLE 3871 if (ev_cb (prepares [i]) != embed_prepare_cb) 3872 # endif 3873 cb (EV_A_ EV_PREPARE, prepares [i]); 3874 #endif 3875 3876 #if EV_CHECK_ENABLE 3877 if (types & EV_CHECK) 3878 for (i = checkcnt; i--; ) 3879 cb (EV_A_ EV_CHECK, checks [i]); 3880 #endif 3881 3882 #if EV_SIGNAL_ENABLE 3883 if (types & EV_SIGNAL) 3884 for (i = 0; i < EV_NSIG - 1; ++i) 3885 for (wl = signals [i].head; wl; ) 3886 { 3887 wn = wl->next; 3888 cb (EV_A_ EV_SIGNAL, wl); 3889 wl = wn; 3890 } 3891 #endif 3892 3893 #if EV_CHILD_ENABLE 3894 if (types & EV_CHILD) 3895 for (i = (EV_PID_HASHSIZE); i--; ) 3896 for (wl = childs [i]; wl; ) 3897 { 3898 wn = wl->next; 3899 cb (EV_A_ EV_CHILD, wl); 3900 wl = wn; 3901 } 3902 #endif 3903 /* EV_STAT 0x00001000 /* stat data changed */ 3904 /* EV_EMBED 0x00010000 /* embedded event loop needs sweep */ 3905 } 3906 #endif 3907 3908 #if EV_MULTIPLICITY 3909 #include "ev_wrap.h" 3910 #endif 3911 3912 EV_CPP(}) 3913 3914