ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.479 by root, Sun Dec 20 01:31:17 2015 UTC vs.
Revision 1.518 by root, Fri Dec 27 16:12:37 2019 UTC

1	/*	1	/*
2	* libev event processing core, watcher management	2	* libev event processing core, watcher management
3	*	3	*
4	* Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de>	4	* Copyright (c) 2007-2019 Marc Alexander Lehmann <libev@schmorp.de>
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without modifica-	7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:	8	* tion, are permitted provided that the following conditions are met:
9	*	9	*
…		…
115	# else	115	# else
116	# undef EV_USE_EPOLL	116	# undef EV_USE_EPOLL
117	# define EV_USE_EPOLL 0	117	# define EV_USE_EPOLL 0
118	# endif	118	# endif
119		119
		120	# if HAVE_LINUX_AIO_ABI_H
		121	# ifndef EV_USE_LINUXAIO
		122	# define EV_USE_LINUXAIO 0 /* was: EV_FEATURE_BACKENDS, always off by default */
		123	# endif
		124	# else
		125	# undef EV_USE_LINUXAIO
		126	# define EV_USE_LINUXAIO 0
		127	# endif
		128
		129	# if HAVE_LINUX_FS_H && HAVE_SYS_TIMERFD_H && HAVE_KERNEL_RWF_T
		130	# ifndef EV_USE_IOURING
		131	# define EV_USE_IOURING EV_FEATURE_BACKENDS
		132	# endif
		133	# else
		134	# undef EV_USE_IOURING
		135	# define EV_USE_IOURING 0
		136	# endif
		137
120	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H	138	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
121	# ifndef EV_USE_KQUEUE	139	# ifndef EV_USE_KQUEUE
122	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS	140	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS
123	# endif	141	# endif
124	# else	142	# else
…		…
159	# endif	177	# endif
160	# else	178	# else
161	# undef EV_USE_EVENTFD	179	# undef EV_USE_EVENTFD
162	# define EV_USE_EVENTFD 0	180	# define EV_USE_EVENTFD 0
163	# endif	181	# endif
164		182
		183	# if HAVE_SYS_TIMERFD_H
		184	# ifndef EV_USE_TIMERFD
		185	# define EV_USE_TIMERFD EV_FEATURE_OS
		186	# endif
		187	# else
		188	# undef EV_USE_TIMERFD
		189	# define EV_USE_TIMERFD 0
165	#endif	190	# endif
		191
		192	#endif
		193
		194	/* OS X, in its infinite idiocy, actually HARDCODES
		195	* a limit of 1024 into their select. Where people have brains,
		196	* OS X engineers apparently have a vacuum. Or maybe they were
		197	* ordered to have a vacuum, or they do anything for money.
		198	* This might help. Or not.
		199	* Note that this must be defined early, as other include files
		200	* will rely on this define as well.
		201	*/
		202	#define _DARWIN_UNLIMITED_SELECT 1
166		203
167	#include <stdlib.h>	204	#include <stdlib.h>
168	#include <string.h>	205	#include <string.h>
169	#include <fcntl.h>	206	#include <fcntl.h>
170	#include <stddef.h>	207	#include <stddef.h>
…		…
208	# ifndef EV_SELECT_IS_WINSOCKET	245	# ifndef EV_SELECT_IS_WINSOCKET
209	# define EV_SELECT_IS_WINSOCKET 1	246	# define EV_SELECT_IS_WINSOCKET 1
210	# endif	247	# endif
211	# undef EV_AVOID_STDIO	248	# undef EV_AVOID_STDIO
212	#endif	249	#endif
213
214	/* OS X, in its infinite idiocy, actually HARDCODES
215	* a limit of 1024 into their select. Where people have brains,
216	* OS X engineers apparently have a vacuum. Or maybe they were
217	* ordered to have a vacuum, or they do anything for money.
218	* This might help. Or not.
219	*/
220	#define _DARWIN_UNLIMITED_SELECT 1
221		250
222	/* this block tries to deduce configuration from header-defined symbols and defaults */	251	/* this block tries to deduce configuration from header-defined symbols and defaults */
223		252
224	/* try to deduce the maximum number of signals on this platform */	253	/* try to deduce the maximum number of signals on this platform */
225	#if defined EV_NSIG	254	#if defined EV_NSIG
…		…
313		342
314	#ifndef EV_USE_PORT	343	#ifndef EV_USE_PORT
315	# define EV_USE_PORT 0	344	# define EV_USE_PORT 0
316	#endif	345	#endif
317		346
		347	#ifndef EV_USE_LINUXAIO
		348	# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */
		349	# define EV_USE_LINUXAIO 0 /* was: 1, always off by default */
		350	# else
		351	# define EV_USE_LINUXAIO 0
		352	# endif
		353	#endif
		354
		355	#ifndef EV_USE_IOURING
		356	# if __linux /* later checks might disable again */
		357	# define EV_USE_IOURING 1
		358	# else
		359	# define EV_USE_IOURING 0
		360	# endif
		361	#endif
		362
318	#ifndef EV_USE_INOTIFY	363	#ifndef EV_USE_INOTIFY
319	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))	364	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
320	# define EV_USE_INOTIFY EV_FEATURE_OS	365	# define EV_USE_INOTIFY EV_FEATURE_OS
321	# else	366	# else
322	# define EV_USE_INOTIFY 0	367	# define EV_USE_INOTIFY 0
…		…
345	# else	390	# else
346	# define EV_USE_SIGNALFD 0	391	# define EV_USE_SIGNALFD 0
347	# endif	392	# endif
348	#endif	393	#endif
349		394
		395	#ifndef EV_USE_TIMERFD
		396	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8))
		397	# define EV_USE_TIMERFD EV_FEATURE_OS
		398	# else
		399	# define EV_USE_TIMERFD 0
		400	# endif
		401	#endif
		402
350	#if 0 /* debugging */	403	#if 0 /* debugging */
351	# define EV_VERIFY 3	404	# define EV_VERIFY 3
352	# define EV_USE_4HEAP 1	405	# define EV_USE_4HEAP 1
353	# define EV_HEAP_CACHE_AT 1	406	# define EV_HEAP_CACHE_AT 1
354	#endif	407	#endif
…		…
363		416
364	#ifndef EV_HEAP_CACHE_AT	417	#ifndef EV_HEAP_CACHE_AT
365	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA	418	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
366	#endif	419	#endif
367		420
368	#ifdef ANDROID	421	#ifdef __ANDROID__
369	/* supposedly, android doesn't typedef fd_mask */	422	/* supposedly, android doesn't typedef fd_mask */
370	# undef EV_USE_SELECT	423	# undef EV_USE_SELECT
371	# define EV_USE_SELECT 0	424	# define EV_USE_SELECT 0
372	/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */	425	/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
373	# undef EV_USE_CLOCK_SYSCALL	426	# undef EV_USE_CLOCK_SYSCALL
…		…
387	# include <sys/syscall.h>	440	# include <sys/syscall.h>
388	# ifdef SYS_clock_gettime	441	# ifdef SYS_clock_gettime
389	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))	442	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
390	# undef EV_USE_MONOTONIC	443	# undef EV_USE_MONOTONIC
391	# define EV_USE_MONOTONIC 1	444	# define EV_USE_MONOTONIC 1
		445	# define EV_NEED_SYSCALL 1
392	# else	446	# else
393	# undef EV_USE_CLOCK_SYSCALL	447	# undef EV_USE_CLOCK_SYSCALL
394	# define EV_USE_CLOCK_SYSCALL 0	448	# define EV_USE_CLOCK_SYSCALL 0
395	# endif	449	# endif
396	#endif	450	#endif
…		…
410	#if !EV_STAT_ENABLE	464	#if !EV_STAT_ENABLE
411	# undef EV_USE_INOTIFY	465	# undef EV_USE_INOTIFY
412	# define EV_USE_INOTIFY 0	466	# define EV_USE_INOTIFY 0
413	#endif	467	#endif
414		468
		469	#if __linux && EV_USE_IOURING
		470	# include <linux/version.h>
		471	# if LINUX_VERSION_CODE < KERNEL_VERSION(4,14,0)
		472	# undef EV_USE_IOURING
		473	# define EV_USE_IOURING 0
		474	# endif
		475	#endif
		476
415	#if !EV_USE_NANOSLEEP	477	#if !EV_USE_NANOSLEEP
416	/* hp-ux has it in sys/time.h, which we unconditionally include above */	478	/* hp-ux has it in sys/time.h, which we unconditionally include above */
417	# if !defined _WIN32 && !defined __hpux	479	# if !defined _WIN32 && !defined __hpux
418	# include <sys/select.h>	480	# include <sys/select.h>
		481	# endif
		482	#endif
		483
		484	#if EV_USE_LINUXAIO
		485	# include <sys/syscall.h>
		486	# if SYS_io_getevents && EV_USE_EPOLL /* linuxaio backend requires epoll backend */
		487	# define EV_NEED_SYSCALL 1
		488	# else
		489	# undef EV_USE_LINUXAIO
		490	# define EV_USE_LINUXAIO 0
		491	# endif
		492	#endif
		493
		494	#if EV_USE_IOURING
		495	# include <sys/syscall.h>
		496	# if !SYS_io_uring_setup && __linux && !__alpha
		497	# define SYS_io_uring_setup 425
		498	# define SYS_io_uring_enter 426
		499	# define SYS_io_uring_wregister 427
		500	# endif
		501	# if SYS_io_uring_setup && EV_USE_EPOLL /* iouring backend requires epoll backend */
		502	# define EV_NEED_SYSCALL 1
		503	# else
		504	# undef EV_USE_IOURING
		505	# define EV_USE_IOURING 0
419	# endif	506	# endif
420	#endif	507	#endif
421		508
422	#if EV_USE_INOTIFY	509	#if EV_USE_INOTIFY
423	# include <sys/statfs.h>	510	# include <sys/statfs.h>
…		…
428	# define EV_USE_INOTIFY 0	515	# define EV_USE_INOTIFY 0
429	# endif	516	# endif
430	#endif	517	#endif
431		518
432	#if EV_USE_EVENTFD	519	#if EV_USE_EVENTFD
433	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */	520	/* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
434	# include <stdint.h>	521	# include <stdint.h>
435	# ifndef EFD_NONBLOCK	522	# ifndef EFD_NONBLOCK
436	# define EFD_NONBLOCK O_NONBLOCK	523	# define EFD_NONBLOCK O_NONBLOCK
437	# endif	524	# endif
438	# ifndef EFD_CLOEXEC	525	# ifndef EFD_CLOEXEC
…		…
444	# endif	531	# endif
445	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);	532	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
446	#endif	533	#endif
447		534
448	#if EV_USE_SIGNALFD	535	#if EV_USE_SIGNALFD
449	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */	536	/* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
450	# include <stdint.h>	537	# include <stdint.h>
451	# ifndef SFD_NONBLOCK	538	# ifndef SFD_NONBLOCK
452	# define SFD_NONBLOCK O_NONBLOCK	539	# define SFD_NONBLOCK O_NONBLOCK
453	# endif	540	# endif
454	# ifndef SFD_CLOEXEC	541	# ifndef SFD_CLOEXEC
…		…
456	# define SFD_CLOEXEC O_CLOEXEC	543	# define SFD_CLOEXEC O_CLOEXEC
457	# else	544	# else
458	# define SFD_CLOEXEC 02000000	545	# define SFD_CLOEXEC 02000000
459	# endif	546	# endif
460	# endif	547	# endif
461	EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);	548	EV_CPP (extern "C") int (signalfd) (int fd, const sigset_t *mask, int flags);
462		549
463	struct signalfd_siginfo	550	struct signalfd_siginfo
464	{	551	{
465	uint32_t ssi_signo;	552	uint32_t ssi_signo;
466	char pad[128 - sizeof (uint32_t)];	553	char pad[128 - sizeof (uint32_t)];
467	};	554	};
468	#endif	555	#endif
469		556
470	/**/	557	/* for timerfd, libev core requires TFD_TIMER_CANCEL_ON_SET &c */
		558	#if EV_USE_TIMERFD
		559	# include <sys/timerfd.h>
		560	/* timerfd is only used for periodics */
		561	# if !(defined (TFD_TIMER_CANCEL_ON_SET) && defined (TFD_CLOEXEC) && defined (TFD_NONBLOCK)) || !EV_PERIODIC_ENABLE
		562	# undef EV_USE_TIMERFD
		563	# define EV_USE_TIMERFD 0
		564	# endif
		565	#endif
		566
		567	/*****************************************************************************/
471		568
472	#if EV_VERIFY >= 3	569	#if EV_VERIFY >= 3
473	# define EV_FREQUENT_CHECK ev_verify (EV_A)	570	# define EV_FREQUENT_CHECK ev_verify (EV_A)
474	#else	571	#else
475	# define EV_FREQUENT_CHECK do { } while (0)	572	# define EV_FREQUENT_CHECK do { } while (0)
…		…
480	* This value is good at least till the year 4000.	577	* This value is good at least till the year 4000.
481	*/	578	*/
482	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */	579	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
483	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */	580	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
484		581
485	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	582	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
486	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	583	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
487		584
		585	/* find a portable timestamp that is "always" in the future but fits into time_t.
		586	* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
		587	* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
		588	#define EV_TSTAMP_HUGE \
		589	(sizeof (time_t) >= 8 ? 10000000000000. \
		590	: 0 < (time_t)4294967295 ? 4294967295. \
		591	: 2147483647.) \
		592
		593	#ifndef EV_TS_CONST
		594	# define EV_TS_CONST(nv) nv
		595	# define EV_TS_TO_MSEC(a) a * 1e3 + 0.9999
		596	# define EV_TS_FROM_USEC(us) us * 1e-6
488	#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)	597	# define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
489	#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)	598	# define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
		599	# define EV_TV_GET(tv) ((tv).tv_sec + (tv).tv_usec * 1e-6)
		600	# define EV_TS_GET(ts) ((ts).tv_sec + (ts).tv_nsec * 1e-9)
		601	#endif
490		602
491	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */	603	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
492	/* ECB.H BEGIN */	604	/* ECB.H BEGIN */
493	/*	605	/*
494	* libecb - http://software.schmorp.de/pkg/libecb	606	* libecb - http://software.schmorp.de/pkg/libecb
…		…
532		644
533	#ifndef ECB_H	645	#ifndef ECB_H
534	#define ECB_H	646	#define ECB_H
535		647
536	/* 16 bits major, 16 bits minor */	648	/* 16 bits major, 16 bits minor */
537	#define ECB_VERSION 0x00010005	649	#define ECB_VERSION 0x00010006
538		650
539	#ifdef _WIN32	651	#ifdef _WIN32
540	typedef signed char int8_t;	652	typedef signed char int8_t;
541	typedef unsigned char uint8_t;	653	typedef unsigned char uint8_t;
542	typedef signed short int16_t;	654	typedef signed short int16_t;
…		…
607	#define ECB_CLANG_EXTENSION(x) 0	719	#define ECB_CLANG_EXTENSION(x) 0
608	#endif	720	#endif
609		721
610	#define ECB_CPP (__cplusplus+0)	722	#define ECB_CPP (__cplusplus+0)
611	#define ECB_CPP11 (__cplusplus >= 201103L)	723	#define ECB_CPP11 (__cplusplus >= 201103L)
		724	#define ECB_CPP14 (__cplusplus >= 201402L)
		725	#define ECB_CPP17 (__cplusplus >= 201703L)
612		726
613	#if ECB_CPP	727	#if ECB_CPP
614	#define ECB_C 0	728	#define ECB_C 0
615	#define ECB_STDC_VERSION 0	729	#define ECB_STDC_VERSION 0
616	#else	730	#else
…		…
618	#define ECB_STDC_VERSION __STDC_VERSION__	732	#define ECB_STDC_VERSION __STDC_VERSION__
619	#endif	733	#endif
620		734
621	#define ECB_C99 (ECB_STDC_VERSION >= 199901L)	735	#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
622	#define ECB_C11 (ECB_STDC_VERSION >= 201112L)	736	#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
		737	#define ECB_C17 (ECB_STDC_VERSION >= 201710L)
623		738
624	#if ECB_CPP	739	#if ECB_CPP
625	#define ECB_EXTERN_C extern "C"	740	#define ECB_EXTERN_C extern "C"
626	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {	741	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {
627	#define ECB_EXTERN_C_END }	742	#define ECB_EXTERN_C_END }
…		…
653	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */	768	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
654	#endif	769	#endif
655		770
656	#ifndef ECB_MEMORY_FENCE	771	#ifndef ECB_MEMORY_FENCE
657	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	772	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
		773	#define ECB_MEMORY_FENCE_RELAXED __asm__ __volatile__ ("" : : : "memory")
658	#if __i386 || __i386__	774	#if __i386 || __i386__
659	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")	775	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
660	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")	776	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
661	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")	777	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
662	#elif ECB_GCC_AMD64	778	#elif ECB_GCC_AMD64
663	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")	779	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
664	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")	780	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
665	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")	781	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
666	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__	782	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
667	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	783	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
668	#elif defined __ARM_ARCH_2__ \	784	#elif defined __ARM_ARCH_2__ \
669	|| defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \	785	|| defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
670	|| defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \	786	|| defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
…		…
712	#if ECB_GCC_VERSION(4,7)	828	#if ECB_GCC_VERSION(4,7)
713	/* see comment below (stdatomic.h) about the C11 memory model. */	829	/* see comment below (stdatomic.h) about the C11 memory model. */
714	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)	830	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
715	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)	831	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
716	#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)	832	#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
		833	#define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
717		834
718	#elif ECB_CLANG_EXTENSION(c_atomic)	835	#elif ECB_CLANG_EXTENSION(c_atomic)
719	/* see comment below (stdatomic.h) about the C11 memory model. */	836	/* see comment below (stdatomic.h) about the C11 memory model. */
720	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)	837	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
721	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)	838	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
722	#define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)	839	#define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
		840	#define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
723		841
724	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__	842	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
725	#define ECB_MEMORY_FENCE __sync_synchronize ()	843	#define ECB_MEMORY_FENCE __sync_synchronize ()
726	#elif _MSC_VER >= 1500 /* VC++ 2008 */	844	#elif _MSC_VER >= 1500 /* VC++ 2008 */
727	/* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */	845	/* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
…		…
737	#elif defined _WIN32	855	#elif defined _WIN32
738	#include <WinNT.h>	856	#include <WinNT.h>
739	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */	857	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
740	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	858	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
741	#include <mbarrier.h>	859	#include <mbarrier.h>
742	#define ECB_MEMORY_FENCE __machine_rw_barrier ()	860	#define ECB_MEMORY_FENCE __machine_rw_barrier ()
743	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()	861	#define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
744	#define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()	862	#define ECB_MEMORY_FENCE_RELEASE __machine_rel_barrier ()
		863	#define ECB_MEMORY_FENCE_RELAXED __compiler_barrier ()
745	#elif __xlC__	864	#elif __xlC__
746	#define ECB_MEMORY_FENCE __sync ()	865	#define ECB_MEMORY_FENCE __sync ()
747	#endif	866	#endif
748	#endif	867	#endif
749		868
750	#ifndef ECB_MEMORY_FENCE	869	#ifndef ECB_MEMORY_FENCE
751	#if ECB_C11 && !defined __STDC_NO_ATOMICS__	870	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
752	/* we assume that these memory fences work on all variables/all memory accesses, */	871	/* we assume that these memory fences work on all variables/all memory accesses, */
753	/* not just C11 atomics and atomic accesses */	872	/* not just C11 atomics and atomic accesses */
754	#include <stdatomic.h>	873	#include <stdatomic.h>
755	/* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
756	/* any fence other than seq_cst, which isn't very efficient for us. */
757	/* Why that is, we don't know - either the C11 memory model is quite useless */
758	/* for most usages, or gcc and clang have a bug */
759	/* I *currently* lean towards the latter, and inefficiently implement */
760	/* all three of ecb's fences as a seq_cst fence */
761	/* Update, gcc-4.8 generates mfence for all c++ fences, but nothing */
762	/* for all __atomic_thread_fence's except seq_cst */
763	#define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)	874	#define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
		875	#define ECB_MEMORY_FENCE_ACQUIRE atomic_thread_fence (memory_order_acquire)
		876	#define ECB_MEMORY_FENCE_RELEASE atomic_thread_fence (memory_order_release)
764	#endif	877	#endif
765	#endif	878	#endif
766		879
767	#ifndef ECB_MEMORY_FENCE	880	#ifndef ECB_MEMORY_FENCE
768	#if !ECB_AVOID_PTHREADS	881	#if !ECB_AVOID_PTHREADS
…		…
786	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	899	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
787	#endif	900	#endif
788		901
789	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE	902	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
790	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	903	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
		904	#endif
		905
		906	#if !defined ECB_MEMORY_FENCE_RELAXED && defined ECB_MEMORY_FENCE
		907	#define ECB_MEMORY_FENCE_RELAXED ECB_MEMORY_FENCE /* very heavy-handed */
791	#endif	908	#endif
792		909
793	/*****************************************************************************/	910	/*****************************************************************************/
794		911
795	#if ECB_CPP	912	#if ECB_CPP
…		…
1504	/* ECB.H END */	1621	/* ECB.H END */
1505		1622
1506	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1623	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1507	/* if your architecture doesn't need memory fences, e.g. because it is	1624	/* if your architecture doesn't need memory fences, e.g. because it is
1508	* single-cpu/core, or if you use libev in a project that doesn't use libev	1625	* single-cpu/core, or if you use libev in a project that doesn't use libev
1509	* from multiple threads, then you can define ECB_AVOID_PTHREADS when compiling	1626	* from multiple threads, then you can define ECB_NO_THREADS when compiling
1510	* libev, in which cases the memory fences become nops.	1627	* libev, in which cases the memory fences become nops.
1511	* alternatively, you can remove this #error and link against libpthread,	1628	* alternatively, you can remove this #error and link against libpthread,
1512	* which will then provide the memory fences.	1629	* which will then provide the memory fences.
1513	*/	1630	*/
1514	# error "memory fences not defined for your architecture, please report"	1631	# error "memory fences not defined for your architecture, please report"
…		…
1518	# define ECB_MEMORY_FENCE do { } while (0)	1635	# define ECB_MEMORY_FENCE do { } while (0)
1519	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	1636	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1520	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	1637	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1521	#endif	1638	#endif
1522		1639
1523	#define expect_false(cond) ecb_expect_false (cond)
1524	#define expect_true(cond) ecb_expect_true (cond)
1525	#define noinline ecb_noinline
1526
1527	#define inline_size ecb_inline	1640	#define inline_size ecb_inline
1528		1641
1529	#if EV_FEATURE_CODE	1642	#if EV_FEATURE_CODE
1530	# define inline_speed ecb_inline	1643	# define inline_speed ecb_inline
1531	#else	1644	#else
1532	# define inline_speed static noinline	1645	# define inline_speed ecb_noinline static
1533	#endif	1646	#endif
		1647
		1648	/*****************************************************************************/
		1649	/* raw syscall wrappers */
		1650
		1651	#if EV_NEED_SYSCALL
		1652
		1653	#include <sys/syscall.h>
		1654
		1655	/*
		1656	* define some syscall wrappers for common architectures
		1657	* this is mostly for nice looks during debugging, not performance.
		1658	* our syscalls return < 0, not == -1, on error. which is good
		1659	* enough for linux aio.
		1660	* TODO: arm is also common nowadays, maybe even mips and x86
		1661	* TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
		1662	*/
		1663	#if __GNUC__ && __linux && ECB_AMD64 && !defined __OPTIMIZE_SIZE__
		1664	/* the costly errno access probably kills this for size optimisation */
		1665
		1666	#define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5,arg6) \
		1667	({ \
		1668	long res; \
		1669	register unsigned long r6 __asm__ ("r9" ); \
		1670	register unsigned long r5 __asm__ ("r8" ); \
		1671	register unsigned long r4 __asm__ ("r10"); \
		1672	register unsigned long r3 __asm__ ("rdx"); \
		1673	register unsigned long r2 __asm__ ("rsi"); \
		1674	register unsigned long r1 __asm__ ("rdi"); \
		1675	if (narg >= 6) r6 = (unsigned long)(arg6); \
		1676	if (narg >= 5) r5 = (unsigned long)(arg5); \
		1677	if (narg >= 4) r4 = (unsigned long)(arg4); \
		1678	if (narg >= 3) r3 = (unsigned long)(arg3); \
		1679	if (narg >= 2) r2 = (unsigned long)(arg2); \
		1680	if (narg >= 1) r1 = (unsigned long)(arg1); \
		1681	__asm__ __volatile__ ( \
		1682	"syscall\n\t" \
		1683	: "=a" (res) \
		1684	: "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
		1685	: "cc", "r11", "cx", "memory"); \
		1686	errno = -res; \
		1687	res; \
		1688	})
		1689
		1690	#endif
		1691
		1692	#ifdef ev_syscall
		1693	#define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0, 0)
		1694	#define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0, 0)
		1695	#define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0, 0)
		1696	#define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0, 0)
		1697	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0, 0)
		1698	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5, 0)
		1699	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) ev_syscall (nr, 6, arg1, arg2, arg3, arg4, arg5,arg6)
		1700	#else
		1701	#define ev_syscall0(nr) syscall (nr)
		1702	#define ev_syscall1(nr,arg1) syscall (nr, arg1)
		1703	#define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
		1704	#define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
		1705	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
		1706	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
		1707	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) syscall (nr, arg1, arg2, arg3, arg4, arg5,arg6)
		1708	#endif
		1709
		1710	#endif
		1711
		1712	/*****************************************************************************/
1534		1713
1535	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1714	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1536		1715
1537	#if EV_MINPRI == EV_MAXPRI	1716	#if EV_MINPRI == EV_MAXPRI
1538	# define ABSPRI(w) (((W)w), 0)	1717	# define ABSPRI(w) (((W)w), 0)
1539	#else	1718	#else
1540	# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)	1719	# define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
1541	#endif	1720	#endif
1542		1721
1543	#define EMPTY /* required for microsofts broken pseudo-c compiler */	1722	#define EMPTY /* required for microsofts broken pseudo-c compiler */
1544	#define EMPTY2(a,b) /* used to suppress some warnings */
1545		1723
1546	typedef ev_watcher *W;	1724	typedef ev_watcher *W;
1547	typedef ev_watcher_list *WL;	1725	typedef ev_watcher_list *WL;
1548	typedef ev_watcher_time *WT;	1726	typedef ev_watcher_time *WT;
1549		1727
…		…
1574	# include "ev_win32.c"	1752	# include "ev_win32.c"
1575	#endif	1753	#endif
1576		1754
1577	/*****************************************************************************/	1755	/*****************************************************************************/
1578		1756
		1757	#if EV_USE_LINUXAIO
		1758	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
		1759	#endif
		1760
1579	/* define a suitable floor function (only used by periodics atm) */	1761	/* define a suitable floor function (only used by periodics atm) */
1580		1762
1581	#if EV_USE_FLOOR	1763	#if EV_USE_FLOOR
1582	# include <math.h>	1764	# include <math.h>
1583	# define ev_floor(v) floor (v)	1765	# define ev_floor(v) floor (v)
1584	#else	1766	#else
1585		1767
1586	#include <float.h>	1768	#include <float.h>
1587		1769
1588	/* a floor() replacement function, should be independent of ev_tstamp type */	1770	/* a floor() replacement function, should be independent of ev_tstamp type */
		1771	ecb_noinline
1589	static ev_tstamp noinline	1772	static ev_tstamp
1590	ev_floor (ev_tstamp v)	1773	ev_floor (ev_tstamp v)
1591	{	1774	{
1592	/* the choice of shift factor is not terribly important */	1775	/* the choice of shift factor is not terribly important */
1593	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1776	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1594	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1777	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1595	#else	1778	#else
1596	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1779	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1597	#endif	1780	#endif
1598		1781
		1782	/* special treatment for negative arguments */
		1783	if (ecb_expect_false (v < 0.))
		1784	{
		1785	ev_tstamp f = -ev_floor (-v);
		1786
		1787	return f - (f == v ? 0 : 1);
		1788	}
		1789
1599	/* argument too large for an unsigned long? */	1790	/* argument too large for an unsigned long? then reduce it */
1600	if (expect_false (v >= shift))	1791	if (ecb_expect_false (v >= shift))
1601	{	1792	{
1602	ev_tstamp f;	1793	ev_tstamp f;
1603		1794
1604	if (v == v - 1.)	1795	if (v == v - 1.)
1605	return v; /* very large number */	1796	return v; /* very large numbers are assumed to be integer */
1606		1797
1607	f = shift * ev_floor (v * (1. / shift));	1798	f = shift * ev_floor (v * (1. / shift));
1608	return f + ev_floor (v - f);	1799	return f + ev_floor (v - f);
1609	}	1800	}
1610		1801
1611	/* special treatment for negative args? */
1612	if (expect_false (v < 0.))
1613	{
1614	ev_tstamp f = -ev_floor (-v);
1615
1616	return f - (f == v ? 0 : 1);
1617	}
1618
1619	/* fits into an unsigned long */	1802	/* fits into an unsigned long */
1620	return (unsigned long)v;	1803	return (unsigned long)v;
1621	}	1804	}
1622		1805
1623	#endif	1806	#endif
…		…
1626		1809
1627	#ifdef __linux	1810	#ifdef __linux
1628	# include <sys/utsname.h>	1811	# include <sys/utsname.h>
1629	#endif	1812	#endif
1630		1813
1631	static unsigned int noinline ecb_cold	1814	ecb_noinline ecb_cold
		1815	static unsigned int
1632	ev_linux_version (void)	1816	ev_linux_version (void)
1633	{	1817	{
1634	#ifdef __linux	1818	#ifdef __linux
1635	unsigned int v = 0;	1819	unsigned int v = 0;
1636	struct utsname buf;	1820	struct utsname buf;
…		…
1665	}	1849	}
1666		1850
1667	/*****************************************************************************/	1851	/*****************************************************************************/
1668		1852
1669	#if EV_AVOID_STDIO	1853	#if EV_AVOID_STDIO
1670	static void noinline ecb_cold	1854	ecb_noinline ecb_cold
		1855	static void
1671	ev_printerr (const char *msg)	1856	ev_printerr (const char *msg)
1672	{	1857	{
1673	write (STDERR_FILENO, msg, strlen (msg));	1858	write (STDERR_FILENO, msg, strlen (msg));
1674	}	1859	}
1675	#endif	1860	#endif
1676		1861
1677	static void (*syserr_cb)(const char *msg) EV_THROW;	1862	static void (*syserr_cb)(const char *msg) EV_NOEXCEPT;
1678		1863
1679	void ecb_cold	1864	ecb_cold
		1865	void
1680	ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW	1866	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
1681	{	1867	{
1682	syserr_cb = cb;	1868	syserr_cb = cb;
1683	}	1869	}
1684		1870
1685	static void noinline ecb_cold	1871	ecb_noinline ecb_cold
		1872	static void
1686	ev_syserr (const char *msg)	1873	ev_syserr (const char *msg)
1687	{	1874	{
1688	if (!msg)	1875	if (!msg)
1689	msg = "(libev) system error";	1876	msg = "(libev) system error";
1690		1877
…		…
1703	abort ();	1890	abort ();
1704	}	1891	}
1705	}	1892	}
1706		1893
1707	static void *	1894	static void *
1708	ev_realloc_emul (void *ptr, long size) EV_THROW	1895	ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
1709	{	1896	{
1710	/* some systems, notably openbsd and darwin, fail to properly	1897	/* some systems, notably openbsd and darwin, fail to properly
1711	* implement realloc (x, 0) (as required by both ansi c-89 and	1898	* implement realloc (x, 0) (as required by both ansi c-89 and
1712	* the single unix specification, so work around them here.	1899	* the single unix specification, so work around them here.
1713	* recently, also (at least) fedora and debian started breaking it,	1900	* recently, also (at least) fedora and debian started breaking it,
…		…
1719		1906
1720	free (ptr);	1907	free (ptr);
1721	return 0;	1908	return 0;
1722	}	1909	}
1723		1910
1724	static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;	1911	static void *(*alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul;
1725		1912
1726	void ecb_cold	1913	ecb_cold
		1914	void
1727	ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW	1915	ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT
1728	{	1916	{
1729	alloc = cb;	1917	alloc = cb;
1730	}	1918	}
1731		1919
1732	inline_speed void *	1920	inline_speed void *
…		…
1759	typedef struct	1947	typedef struct
1760	{	1948	{
1761	WL head;	1949	WL head;
1762	unsigned char events; /* the events watched for */	1950	unsigned char events; /* the events watched for */
1763	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */	1951	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
1764	unsigned char emask; /* the epoll backend stores the actual kernel mask in here */	1952	unsigned char emask; /* some backends store the actual kernel mask in here */
1765	unsigned char unused;	1953	unsigned char eflags; /* flags field for use by backends */
1766	#if EV_USE_EPOLL	1954	#if EV_USE_EPOLL
1767	unsigned int egen; /* generation counter to counter epoll bugs */	1955	unsigned int egen; /* generation counter to counter epoll bugs */
1768	#endif	1956	#endif
1769	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	1957	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1770	SOCKET handle;	1958	SOCKET handle;
…		…
1824	static struct ev_loop default_loop_struct;	2012	static struct ev_loop default_loop_struct;
1825	EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */	2013	EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
1826		2014
1827	#else	2015	#else
1828		2016
1829	EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */	2017	EV_API_DECL ev_tstamp ev_rt_now = EV_TS_CONST (0.); /* needs to be initialised to make it a definition despite extern */
1830	#define VAR(name,decl) static decl;	2018	#define VAR(name,decl) static decl;
1831	#include "ev_vars.h"	2019	#include "ev_vars.h"
1832	#undef VAR	2020	#undef VAR
1833		2021
1834	static int ev_default_loop_ptr;	2022	static int ev_default_loop_ptr;
1835		2023
1836	#endif	2024	#endif
1837		2025
1838	#if EV_FEATURE_API	2026	#if EV_FEATURE_API
1839	# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)	2027	# define EV_RELEASE_CB if (ecb_expect_false (release_cb)) release_cb (EV_A)
1840	# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)	2028	# define EV_ACQUIRE_CB if (ecb_expect_false (acquire_cb)) acquire_cb (EV_A)
1841	# define EV_INVOKE_PENDING invoke_cb (EV_A)	2029	# define EV_INVOKE_PENDING invoke_cb (EV_A)
1842	#else	2030	#else
1843	# define EV_RELEASE_CB (void)0	2031	# define EV_RELEASE_CB (void)0
1844	# define EV_ACQUIRE_CB (void)0	2032	# define EV_ACQUIRE_CB (void)0
1845	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)	2033	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
…		…
1849		2037
1850	/*****************************************************************************/	2038	/*****************************************************************************/
1851		2039
1852	#ifndef EV_HAVE_EV_TIME	2040	#ifndef EV_HAVE_EV_TIME
1853	ev_tstamp	2041	ev_tstamp
1854	ev_time (void) EV_THROW	2042	ev_time (void) EV_NOEXCEPT
1855	{	2043	{
1856	#if EV_USE_REALTIME	2044	#if EV_USE_REALTIME
1857	if (expect_true (have_realtime))	2045	if (ecb_expect_true (have_realtime))
1858	{	2046	{
1859	struct timespec ts;	2047	struct timespec ts;
1860	clock_gettime (CLOCK_REALTIME, &ts);	2048	clock_gettime (CLOCK_REALTIME, &ts);
1861	return ts.tv_sec + ts.tv_nsec * 1e-9;	2049	return EV_TS_GET (ts);
1862	}	2050	}
1863	#endif	2051	#endif
1864		2052
		2053	{
1865	struct timeval tv;	2054	struct timeval tv;
1866	gettimeofday (&tv, 0);	2055	gettimeofday (&tv, 0);
1867	return tv.tv_sec + tv.tv_usec * 1e-6;	2056	return EV_TV_GET (tv);
		2057	}
1868	}	2058	}
1869	#endif	2059	#endif
1870		2060
1871	inline_size ev_tstamp	2061	inline_size ev_tstamp
1872	get_clock (void)	2062	get_clock (void)
1873	{	2063	{
1874	#if EV_USE_MONOTONIC	2064	#if EV_USE_MONOTONIC
1875	if (expect_true (have_monotonic))	2065	if (ecb_expect_true (have_monotonic))
1876	{	2066	{
1877	struct timespec ts;	2067	struct timespec ts;
1878	clock_gettime (CLOCK_MONOTONIC, &ts);	2068	clock_gettime (CLOCK_MONOTONIC, &ts);
1879	return ts.tv_sec + ts.tv_nsec * 1e-9;	2069	return EV_TS_GET (ts);
1880	}	2070	}
1881	#endif	2071	#endif
1882		2072
1883	return ev_time ();	2073	return ev_time ();
1884	}	2074	}
1885		2075
1886	#if EV_MULTIPLICITY	2076	#if EV_MULTIPLICITY
1887	ev_tstamp	2077	ev_tstamp
1888	ev_now (EV_P) EV_THROW	2078	ev_now (EV_P) EV_NOEXCEPT
1889	{	2079	{
1890	return ev_rt_now;	2080	return ev_rt_now;
1891	}	2081	}
1892	#endif	2082	#endif
1893		2083
1894	void	2084	void
1895	ev_sleep (ev_tstamp delay) EV_THROW	2085	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1896	{	2086	{
1897	if (delay > 0.)	2087	if (delay > EV_TS_CONST (0.))
1898	{	2088	{
1899	#if EV_USE_NANOSLEEP	2089	#if EV_USE_NANOSLEEP
1900	struct timespec ts;	2090	struct timespec ts;
1901		2091
1902	EV_TS_SET (ts, delay);	2092	EV_TS_SET (ts, delay);
1903	nanosleep (&ts, 0);	2093	nanosleep (&ts, 0);
1904	#elif defined _WIN32	2094	#elif defined _WIN32
		2095	/* maybe this should round up, as ms is very low resolution */
		2096	/* compared to select (µs) or nanosleep (ns) */
1905	Sleep ((unsigned long)(delay * 1e3));	2097	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
1906	#else	2098	#else
1907	struct timeval tv;	2099	struct timeval tv;
1908		2100
1909	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */	2101	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
1910	/* something not guaranteed by newer posix versions, but guaranteed */	2102	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
1940	}	2132	}
1941		2133
1942	return ncur;	2134	return ncur;
1943	}	2135	}
1944		2136
1945	static void * noinline ecb_cold	2137	ecb_noinline ecb_cold
		2138	static void *
1946	array_realloc (int elem, void *base, int *cur, int cnt)	2139	array_realloc (int elem, void *base, int *cur, int cnt)
1947	{	2140	{
1948	*cur = array_nextsize (elem, *cur, cnt);	2141	*cur = array_nextsize (elem, *cur, cnt);
1949	return ev_realloc (base, elem * *cur);	2142	return ev_realloc (base, elem * *cur);
1950	}	2143	}
1951		2144
		2145	#define array_needsize_noinit(base,offset,count)
		2146
1952	#define array_init_zero(base,count) \	2147	#define array_needsize_zerofill(base,offset,count) \
1953	memset ((void *)(base), 0, sizeof (*(base)) * (count))	2148	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
1954		2149
1955	#define array_needsize(type,base,cur,cnt,init) \	2150	#define array_needsize(type,base,cur,cnt,init) \
1956	if (expect_false ((cnt) > (cur))) \	2151	if (ecb_expect_false ((cnt) > (cur))) \
1957	{ \	2152	{ \
1958	int ecb_unused ocur_ = (cur); \	2153	ecb_unused int ocur_ = (cur); \
1959	(base) = (type *)array_realloc \	2154	(base) = (type *)array_realloc \
1960	(sizeof (type), (base), &(cur), (cnt)); \	2155	(sizeof (type), (base), &(cur), (cnt)); \
1961	init ((base) + (ocur_), (cur) - ocur_); \	2156	init ((base), ocur_, ((cur) - ocur_)); \
1962	}	2157	}
1963		2158
1964	#if 0	2159	#if 0
1965	#define array_slim(type,stem) \	2160	#define array_slim(type,stem) \
1966	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \	2161	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
…		…
1975	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0	2170	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1976		2171
1977	/*****************************************************************************/	2172	/*****************************************************************************/
1978		2173
1979	/* dummy callback for pending events */	2174	/* dummy callback for pending events */
1980	static void noinline	2175	ecb_noinline
		2176	static void
1981	pendingcb (EV_P_ ev_prepare *w, int revents)	2177	pendingcb (EV_P_ ev_prepare *w, int revents)
1982	{	2178	{
1983	}	2179	}
1984		2180
1985	void noinline	2181	ecb_noinline
		2182	void
1986	ev_feed_event (EV_P_ void *w, int revents) EV_THROW	2183	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
1987	{	2184	{
1988	W w_ = (W)w;	2185	W w_ = (W)w;
1989	int pri = ABSPRI (w_);	2186	int pri = ABSPRI (w_);
1990		2187
1991	if (expect_false (w_->pending))	2188	if (ecb_expect_false (w_->pending))
1992	pendings [pri][w_->pending - 1].events |= revents;	2189	pendings [pri][w_->pending - 1].events |= revents;
1993	else	2190	else
1994	{	2191	{
1995	w_->pending = ++pendingcnt [pri];	2192	w_->pending = ++pendingcnt [pri];
1996	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);	2193	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);
1997	pendings [pri][w_->pending - 1].w = w_;	2194	pendings [pri][w_->pending - 1].w = w_;
1998	pendings [pri][w_->pending - 1].events = revents;	2195	pendings [pri][w_->pending - 1].events = revents;
1999	}	2196	}
2000		2197
2001	pendingpri = NUMPRI - 1;	2198	pendingpri = NUMPRI - 1;
2002	}	2199	}
2003		2200
2004	inline_speed void	2201	inline_speed void
2005	feed_reverse (EV_P_ W w)	2202	feed_reverse (EV_P_ W w)
2006	{	2203	{
2007	array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);	2204	array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, array_needsize_noinit);
2008	rfeeds [rfeedcnt++] = w;	2205	rfeeds [rfeedcnt++] = w;
2009	}	2206	}
2010		2207
2011	inline_size void	2208	inline_size void
2012	feed_reverse_done (EV_P_ int revents)	2209	feed_reverse_done (EV_P_ int revents)
…		…
2047	inline_speed void	2244	inline_speed void
2048	fd_event (EV_P_ int fd, int revents)	2245	fd_event (EV_P_ int fd, int revents)
2049	{	2246	{
2050	ANFD *anfd = anfds + fd;	2247	ANFD *anfd = anfds + fd;
2051		2248
2052	if (expect_true (!anfd->reify))	2249	if (ecb_expect_true (!anfd->reify))
2053	fd_event_nocheck (EV_A_ fd, revents);	2250	fd_event_nocheck (EV_A_ fd, revents);
2054	}	2251	}
2055		2252
2056	void	2253	void
2057	ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW	2254	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
2058	{	2255	{
2059	if (fd >= 0 && fd < anfdmax)	2256	if (fd >= 0 && fd < anfdmax)
2060	fd_event_nocheck (EV_A_ fd, revents);	2257	fd_event_nocheck (EV_A_ fd, revents);
2061	}	2258	}
2062		2259
…		…
2099	ev_io *w;	2296	ev_io *w;
2100		2297
2101	unsigned char o_events = anfd->events;	2298	unsigned char o_events = anfd->events;
2102	unsigned char o_reify = anfd->reify;	2299	unsigned char o_reify = anfd->reify;
2103		2300
2104	anfd->reify = 0;	2301	anfd->reify = 0;
2105		2302
2106	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2303	/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
2107	{	2304	{
2108	anfd->events = 0;	2305	anfd->events = 0;
2109		2306
2110	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)	2307	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
2111	anfd->events |= (unsigned char)w->events;	2308	anfd->events |= (unsigned char)w->events;
…		…
2120		2317
2121	fdchangecnt = 0;	2318	fdchangecnt = 0;
2122	}	2319	}
2123		2320
2124	/* something about the given fd changed */	2321	/* something about the given fd changed */
2125	inline_size void	2322	inline_size
		2323	void
2126	fd_change (EV_P_ int fd, int flags)	2324	fd_change (EV_P_ int fd, int flags)
2127	{	2325	{
2128	unsigned char reify = anfds [fd].reify;	2326	unsigned char reify = anfds [fd].reify;
2129	anfds [fd].reify |= flags;	2327	anfds [fd].reify |= flags;
2130		2328
2131	if (expect_true (!reify))	2329	if (ecb_expect_true (!reify))
2132	{	2330	{
2133	++fdchangecnt;	2331	++fdchangecnt;
2134	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);	2332	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
2135	fdchanges [fdchangecnt - 1] = fd;	2333	fdchanges [fdchangecnt - 1] = fd;
2136	}	2334	}
2137	}	2335	}
2138		2336
2139	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */	2337	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
2140	inline_speed void ecb_cold	2338	inline_speed ecb_cold void
2141	fd_kill (EV_P_ int fd)	2339	fd_kill (EV_P_ int fd)
2142	{	2340	{
2143	ev_io *w;	2341	ev_io *w;
2144		2342
2145	while ((w = (ev_io *)anfds [fd].head))	2343	while ((w = (ev_io *)anfds [fd].head))
…		…
2148	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);	2346	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
2149	}	2347	}
2150	}	2348	}
2151		2349
2152	/* check whether the given fd is actually valid, for error recovery */	2350	/* check whether the given fd is actually valid, for error recovery */
2153	inline_size int ecb_cold	2351	inline_size ecb_cold int
2154	fd_valid (int fd)	2352	fd_valid (int fd)
2155	{	2353	{
2156	#ifdef _WIN32	2354	#ifdef _WIN32
2157	return EV_FD_TO_WIN32_HANDLE (fd) != -1;	2355	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
2158	#else	2356	#else
2159	return fcntl (fd, F_GETFD) != -1;	2357	return fcntl (fd, F_GETFD) != -1;
2160	#endif	2358	#endif
2161	}	2359	}
2162		2360
2163	/* called on EBADF to verify fds */	2361	/* called on EBADF to verify fds */
2164	static void noinline ecb_cold	2362	ecb_noinline ecb_cold
		2363	static void
2165	fd_ebadf (EV_P)	2364	fd_ebadf (EV_P)
2166	{	2365	{
2167	int fd;	2366	int fd;
2168		2367
2169	for (fd = 0; fd < anfdmax; ++fd)	2368	for (fd = 0; fd < anfdmax; ++fd)
…		…
2171	if (!fd_valid (fd) && errno == EBADF)	2370	if (!fd_valid (fd) && errno == EBADF)
2172	fd_kill (EV_A_ fd);	2371	fd_kill (EV_A_ fd);
2173	}	2372	}
2174		2373
2175	/* called on ENOMEM in select/poll to kill some fds and retry */	2374	/* called on ENOMEM in select/poll to kill some fds and retry */
2176	static void noinline ecb_cold	2375	ecb_noinline ecb_cold
		2376	static void
2177	fd_enomem (EV_P)	2377	fd_enomem (EV_P)
2178	{	2378	{
2179	int fd;	2379	int fd;
2180		2380
2181	for (fd = anfdmax; fd--; )	2381	for (fd = anfdmax; fd--; )
…		…
2185	break;	2385	break;
2186	}	2386	}
2187	}	2387	}
2188		2388
2189	/* usually called after fork if backend needs to re-arm all fds from scratch */	2389	/* usually called after fork if backend needs to re-arm all fds from scratch */
2190	static void noinline	2390	ecb_noinline
		2391	static void
2191	fd_rearm_all (EV_P)	2392	fd_rearm_all (EV_P)
2192	{	2393	{
2193	int fd;	2394	int fd;
2194		2395
2195	for (fd = 0; fd < anfdmax; ++fd)	2396	for (fd = 0; fd < anfdmax; ++fd)
…		…
2248	ev_tstamp minat;	2449	ev_tstamp minat;
2249	ANHE *minpos;	2450	ANHE *minpos;
2250	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;	2451	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
2251		2452
2252	/* find minimum child */	2453	/* find minimum child */
2253	if (expect_true (pos + DHEAP - 1 < E))	2454	if (ecb_expect_true (pos + DHEAP - 1 < E))
2254	{	2455	{
2255	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2456	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2256	if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2457	if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2257	if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2458	if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2258	if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2459	if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2259	}	2460	}
2260	else if (pos < E)	2461	else if (pos < E)
2261	{	2462	{
2262	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2463	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2263	if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2464	if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2264	if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2465	if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2265	if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2466	if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2266	}	2467	}
2267	else	2468	else
2268	break;	2469	break;
2269		2470
2270	if (ANHE_at (he) <= minat)	2471	if (ANHE_at (he) <= minat)
…		…
2278		2479
2279	heap [k] = he;	2480	heap [k] = he;
2280	ev_active (ANHE_w (he)) = k;	2481	ev_active (ANHE_w (he)) = k;
2281	}	2482	}
2282		2483
2283	#else /* 4HEAP */	2484	#else /* not 4HEAP */
2284		2485
2285	#define HEAP0 1	2486	#define HEAP0 1
2286	#define HPARENT(k) ((k) >> 1)	2487	#define HPARENT(k) ((k) >> 1)
2287	#define UPHEAP_DONE(p,k) (!(p))	2488	#define UPHEAP_DONE(p,k) (!(p))
2288		2489
…		…
2376		2577
2377	/*****************************************************************************/	2578	/*****************************************************************************/
2378		2579
2379	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2580	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2380		2581
2381	static void noinline ecb_cold	2582	ecb_noinline ecb_cold
		2583	static void
2382	evpipe_init (EV_P)	2584	evpipe_init (EV_P)
2383	{	2585	{
2384	if (!ev_is_active (&pipe_w))	2586	if (!ev_is_active (&pipe_w))
2385	{	2587	{
2386	int fds [2];	2588	int fds [2];
…		…
2426	inline_speed void	2628	inline_speed void
2427	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	2629	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2428	{	2630	{
2429	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */	2631	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
2430		2632
2431	if (expect_true (*flag))	2633	if (ecb_expect_true (*flag))
2432	return;	2634	return;
2433		2635
2434	*flag = 1;	2636	*flag = 1;
2435	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */	2637	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
2436		2638
…		…
2457	#endif	2659	#endif
2458	{	2660	{
2459	#ifdef _WIN32	2661	#ifdef _WIN32
2460	WSABUF buf;	2662	WSABUF buf;
2461	DWORD sent;	2663	DWORD sent;
2462	buf.buf = &buf;	2664	buf.buf = (char *)&buf;
2463	buf.len = 1;	2665	buf.len = 1;
2464	WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);	2666	WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
2465	#else	2667	#else
2466	write (evpipe [1], &(evpipe [1]), 1);	2668	write (evpipe [1], &(evpipe [1]), 1);
2467	#endif	2669	#endif
…		…
2513	sig_pending = 0;	2715	sig_pending = 0;
2514		2716
2515	ECB_MEMORY_FENCE;	2717	ECB_MEMORY_FENCE;
2516		2718
2517	for (i = EV_NSIG - 1; i--; )	2719	for (i = EV_NSIG - 1; i--; )
2518	if (expect_false (signals [i].pending))	2720	if (ecb_expect_false (signals [i].pending))
2519	ev_feed_signal_event (EV_A_ i + 1);	2721	ev_feed_signal_event (EV_A_ i + 1);
2520	}	2722	}
2521	#endif	2723	#endif
2522		2724
2523	#if EV_ASYNC_ENABLE	2725	#if EV_ASYNC_ENABLE
…		…
2539	}	2741	}
2540		2742
2541	/*****************************************************************************/	2743	/*****************************************************************************/
2542		2744
2543	void	2745	void
2544	ev_feed_signal (int signum) EV_THROW	2746	ev_feed_signal (int signum) EV_NOEXCEPT
2545	{	2747	{
2546	#if EV_MULTIPLICITY	2748	#if EV_MULTIPLICITY
2547	EV_P;	2749	EV_P;
2548	ECB_MEMORY_FENCE_ACQUIRE;	2750	ECB_MEMORY_FENCE_ACQUIRE;
2549	EV_A = signals [signum - 1].loop;	2751	EV_A = signals [signum - 1].loop;
…		…
2564	#endif	2766	#endif
2565		2767
2566	ev_feed_signal (signum);	2768	ev_feed_signal (signum);
2567	}	2769	}
2568		2770
2569	void noinline	2771	ecb_noinline
		2772	void
2570	ev_feed_signal_event (EV_P_ int signum) EV_THROW	2773	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2571	{	2774	{
2572	WL w;	2775	WL w;
2573		2776
2574	if (expect_false (signum <= 0 || signum >= EV_NSIG))	2777	if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
2575	return;	2778	return;
2576		2779
2577	--signum;	2780	--signum;
2578		2781
2579	#if EV_MULTIPLICITY	2782	#if EV_MULTIPLICITY
2580	/* it is permissible to try to feed a signal to the wrong loop */	2783	/* it is permissible to try to feed a signal to the wrong loop */
2581	/* or, likely more useful, feeding a signal nobody is waiting for */	2784	/* or, likely more useful, feeding a signal nobody is waiting for */
2582		2785
2583	if (expect_false (signals [signum].loop != EV_A))	2786	if (ecb_expect_false (signals [signum].loop != EV_A))
2584	return;	2787	return;
2585	#endif	2788	#endif
2586		2789
2587	signals [signum].pending = 0;	2790	signals [signum].pending = 0;
2588	ECB_MEMORY_FENCE_RELEASE;	2791	ECB_MEMORY_FENCE_RELEASE;
…		…
2672		2875
2673	#endif	2876	#endif
2674		2877
2675	/*****************************************************************************/	2878	/*****************************************************************************/
2676		2879
		2880	#if EV_USE_TIMERFD
		2881
		2882	static void periodics_reschedule (EV_P);
		2883
		2884	static void
		2885	timerfdcb (EV_P_ ev_io *iow, int revents)
		2886	{
		2887	struct itimerspec its = { 0 };
		2888
		2889	/* since we can't easily come zup with a (portable) maximum value of time_t,
		2890	* we wake up once per month, which hopefully is rare enough to not
		2891	* be a problem. */
		2892	its.it_value.tv_sec = ev_rt_now + 86400 * 30;
		2893	timerfd_settime (timerfd, TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &its, 0);
		2894
		2895	ev_rt_now = ev_time ();
		2896	/* periodics_reschedule only needs ev_rt_now */
		2897	/* but maybe in the future we want the full treatment. */
		2898	/*
		2899	now_floor = EV_TS_CONST (0.);
		2900	time_update (EV_A_ EV_TSTAMP_HUGE);
		2901	*/
		2902	periodics_reschedule (EV_A);
		2903	}
		2904
		2905	ecb_noinline ecb_cold
		2906	static void
		2907	evtimerfd_init (EV_P)
		2908	{
		2909	if (!ev_is_active (&timerfd_w))
		2910	{
		2911	timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
		2912
		2913	if (timerfd >= 0)
		2914	{
		2915	fd_intern (timerfd); /* just to be sure */
		2916
		2917	ev_io_init (&timerfd_w, timerfdcb, timerfd, EV_READ);
		2918	ev_set_priority (&timerfd_w, EV_MINPRI);
		2919	ev_io_start (EV_A_ &timerfd_w);
		2920	ev_unref (EV_A); /* watcher should not keep loop alive */
		2921
		2922	/* (re-) arm timer */
		2923	timerfdcb (EV_A_ 0, 0);
		2924	}
		2925	}
		2926	}
		2927
		2928	#endif
		2929
		2930	/*****************************************************************************/
		2931
2677	#if EV_USE_IOCP	2932	#if EV_USE_IOCP
2678	# include "ev_iocp.c"	2933	# include "ev_iocp.c"
2679	#endif	2934	#endif
2680	#if EV_USE_PORT	2935	#if EV_USE_PORT
2681	# include "ev_port.c"	2936	# include "ev_port.c"
…		…
2684	# include "ev_kqueue.c"	2939	# include "ev_kqueue.c"
2685	#endif	2940	#endif
2686	#if EV_USE_EPOLL	2941	#if EV_USE_EPOLL
2687	# include "ev_epoll.c"	2942	# include "ev_epoll.c"
2688	#endif	2943	#endif
		2944	#if EV_USE_LINUXAIO
		2945	# include "ev_linuxaio.c"
		2946	#endif
		2947	#if EV_USE_IOURING
		2948	# include "ev_iouring.c"
		2949	#endif
2689	#if EV_USE_POLL	2950	#if EV_USE_POLL
2690	# include "ev_poll.c"	2951	# include "ev_poll.c"
2691	#endif	2952	#endif
2692	#if EV_USE_SELECT	2953	#if EV_USE_SELECT
2693	# include "ev_select.c"	2954	# include "ev_select.c"
2694	#endif	2955	#endif
2695		2956
2696	int ecb_cold	2957	ecb_cold int
2697	ev_version_major (void) EV_THROW	2958	ev_version_major (void) EV_NOEXCEPT
2698	{	2959	{
2699	return EV_VERSION_MAJOR;	2960	return EV_VERSION_MAJOR;
2700	}	2961	}
2701		2962
2702	int ecb_cold	2963	ecb_cold int
2703	ev_version_minor (void) EV_THROW	2964	ev_version_minor (void) EV_NOEXCEPT
2704	{	2965	{
2705	return EV_VERSION_MINOR;	2966	return EV_VERSION_MINOR;
2706	}	2967	}
2707		2968
2708	/* return true if we are running with elevated privileges and should ignore env variables */	2969	/* return true if we are running with elevated privileges and should ignore env variables */
2709	int inline_size ecb_cold	2970	inline_size ecb_cold int
2710	enable_secure (void)	2971	enable_secure (void)
2711	{	2972	{
2712	#ifdef _WIN32	2973	#ifdef _WIN32
2713	return 0;	2974	return 0;
2714	#else	2975	#else
2715	return getuid () != geteuid ()	2976	return getuid () != geteuid ()
2716	|| getgid () != getegid ();	2977	|| getgid () != getegid ();
2717	#endif	2978	#endif
2718	}	2979	}
2719		2980
2720	unsigned int ecb_cold	2981	ecb_cold
		2982	unsigned int
2721	ev_supported_backends (void) EV_THROW	2983	ev_supported_backends (void) EV_NOEXCEPT
2722	{	2984	{
2723	unsigned int flags = 0;	2985	unsigned int flags = 0;
2724		2986
2725	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	2987	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2726	if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;	2988	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2727	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	2989	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
		2990	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;
		2991	if (EV_USE_IOURING ) flags |= EVBACKEND_IOURING;
2728	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	2992	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2729	if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;	2993	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
2730		2994
2731	return flags;	2995	return flags;
2732	}	2996	}
2733		2997
2734	unsigned int ecb_cold	2998	ecb_cold
		2999	unsigned int
2735	ev_recommended_backends (void) EV_THROW	3000	ev_recommended_backends (void) EV_NOEXCEPT
2736	{	3001	{
2737	unsigned int flags = ev_supported_backends ();	3002	unsigned int flags = ev_supported_backends ();
2738		3003
2739	#ifndef __NetBSD__	3004	#ifndef __NetBSD__
2740	/* kqueue is borked on everything but netbsd apparently */	3005	/* kqueue is borked on everything but netbsd apparently */
…		…
2748	#endif	3013	#endif
2749	#ifdef __FreeBSD__	3014	#ifdef __FreeBSD__
2750	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */	3015	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
2751	#endif	3016	#endif
2752		3017
		3018	/* TODO: linuxaio is very experimental */
		3019	#if !EV_RECOMMEND_LINUXAIO
		3020	flags &= ~EVBACKEND_LINUXAIO;
		3021	#endif
		3022	/* TODO: linuxaio is super experimental */
		3023	#if !EV_RECOMMEND_IOURING
		3024	flags &= ~EVBACKEND_IOURING;
		3025	#endif
		3026
2753	return flags;	3027	return flags;
2754	}	3028	}
2755		3029
2756	unsigned int ecb_cold	3030	ecb_cold
		3031	unsigned int
2757	ev_embeddable_backends (void) EV_THROW	3032	ev_embeddable_backends (void) EV_NOEXCEPT
2758	{	3033	{
2759	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	3034	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2760		3035
2761	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	3036	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2762	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	3037	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2763	flags &= ~EVBACKEND_EPOLL;	3038	flags &= ~EVBACKEND_EPOLL;
2764		3039
		3040	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
		3041
		3042	/* EVBACKEND_IOURING is practically embeddable, but the current implementation is not
		3043	* because our backend_fd is the epoll fd we need as fallback.
		3044	* if the kernel ever is fixed, this might change...
		3045	*/
		3046
2765	return flags;	3047	return flags;
2766	}	3048	}
2767		3049
2768	unsigned int	3050	unsigned int
2769	ev_backend (EV_P) EV_THROW	3051	ev_backend (EV_P) EV_NOEXCEPT
2770	{	3052	{
2771	return backend;	3053	return backend;
2772	}	3054	}
2773		3055
2774	#if EV_FEATURE_API	3056	#if EV_FEATURE_API
2775	unsigned int	3057	unsigned int
2776	ev_iteration (EV_P) EV_THROW	3058	ev_iteration (EV_P) EV_NOEXCEPT
2777	{	3059	{
2778	return loop_count;	3060	return loop_count;
2779	}	3061	}
2780		3062
2781	unsigned int	3063	unsigned int
2782	ev_depth (EV_P) EV_THROW	3064	ev_depth (EV_P) EV_NOEXCEPT
2783	{	3065	{
2784	return loop_depth;	3066	return loop_depth;
2785	}	3067	}
2786		3068
2787	void	3069	void
2788	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	3070	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2789	{	3071	{
2790	io_blocktime = interval;	3072	io_blocktime = interval;
2791	}	3073	}
2792		3074
2793	void	3075	void
2794	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	3076	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2795	{	3077	{
2796	timeout_blocktime = interval;	3078	timeout_blocktime = interval;
2797	}	3079	}
2798		3080
2799	void	3081	void
2800	ev_set_userdata (EV_P_ void *data) EV_THROW	3082	ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT
2801	{	3083	{
2802	userdata = data;	3084	userdata = data;
2803	}	3085	}
2804		3086
2805	void *	3087	void *
2806	ev_userdata (EV_P) EV_THROW	3088	ev_userdata (EV_P) EV_NOEXCEPT
2807	{	3089	{
2808	return userdata;	3090	return userdata;
2809	}	3091	}
2810		3092
2811	void	3093	void
2812	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW	3094	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT
2813	{	3095	{
2814	invoke_cb = invoke_pending_cb;	3096	invoke_cb = invoke_pending_cb;
2815	}	3097	}
2816		3098
2817	void	3099	void
2818	ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW	3100	ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT
2819	{	3101	{
2820	release_cb = release;	3102	release_cb = release;
2821	acquire_cb = acquire;	3103	acquire_cb = acquire;
2822	}	3104	}
2823	#endif	3105	#endif
2824		3106
2825	/* initialise a loop structure, must be zero-initialised */	3107	/* initialise a loop structure, must be zero-initialised */
2826	static void noinline ecb_cold	3108	ecb_noinline ecb_cold
		3109	static void
2827	loop_init (EV_P_ unsigned int flags) EV_THROW	3110	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2828	{	3111	{
2829	if (!backend)	3112	if (!backend)
2830	{	3113	{
2831	origflags = flags;	3114	origflags = flags;
2832		3115
…		…
2885	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3168	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2886	#endif	3169	#endif
2887	#if EV_USE_SIGNALFD	3170	#if EV_USE_SIGNALFD
2888	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3171	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
2889	#endif	3172	#endif
		3173	#if EV_USE_TIMERFD
		3174	timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
		3175	#endif
2890		3176
2891	if (!(flags & EVBACKEND_MASK))	3177	if (!(flags & EVBACKEND_MASK))
2892	flags |= ev_recommended_backends ();	3178	flags |= ev_recommended_backends ();
2893		3179
2894	#if EV_USE_IOCP	3180	#if EV_USE_IOCP
2895	if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);	3181	if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);
2896	#endif	3182	#endif
2897	#if EV_USE_PORT	3183	#if EV_USE_PORT
2898	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	3184	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2899	#endif	3185	#endif
2900	#if EV_USE_KQUEUE	3186	#if EV_USE_KQUEUE
2901	if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);	3187	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
		3188	#endif
		3189	#if EV_USE_IOURING
		3190	if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
		3191	#endif
		3192	#if EV_USE_LINUXAIO
		3193	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2902	#endif	3194	#endif
2903	#if EV_USE_EPOLL	3195	#if EV_USE_EPOLL
2904	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);	3196	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
2905	#endif	3197	#endif
2906	#if EV_USE_POLL	3198	#if EV_USE_POLL
2907	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);	3199	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
2908	#endif	3200	#endif
2909	#if EV_USE_SELECT	3201	#if EV_USE_SELECT
2910	if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);	3202	if (!backend && (flags & EVBACKEND_SELECT )) backend = select_init (EV_A_ flags);
2911	#endif	3203	#endif
2912		3204
2913	ev_prepare_init (&pending_w, pendingcb);	3205	ev_prepare_init (&pending_w, pendingcb);
2914		3206
2915	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3207	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
…		…
2918	#endif	3210	#endif
2919	}	3211	}
2920	}	3212	}
2921		3213
2922	/* free up a loop structure */	3214	/* free up a loop structure */
2923	void ecb_cold	3215	ecb_cold
		3216	void
2924	ev_loop_destroy (EV_P)	3217	ev_loop_destroy (EV_P)
2925	{	3218	{
2926	int i;	3219	int i;
2927		3220
2928	#if EV_MULTIPLICITY	3221	#if EV_MULTIPLICITY
…		…
2931	return;	3224	return;
2932	#endif	3225	#endif
2933		3226
2934	#if EV_CLEANUP_ENABLE	3227	#if EV_CLEANUP_ENABLE
2935	/* queue cleanup watchers (and execute them) */	3228	/* queue cleanup watchers (and execute them) */
2936	if (expect_false (cleanupcnt))	3229	if (ecb_expect_false (cleanupcnt))
2937	{	3230	{
2938	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);	3231	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
2939	EV_INVOKE_PENDING;	3232	EV_INVOKE_PENDING;
2940	}	3233	}
2941	#endif	3234	#endif
…		…
2960	#if EV_USE_SIGNALFD	3253	#if EV_USE_SIGNALFD
2961	if (ev_is_active (&sigfd_w))	3254	if (ev_is_active (&sigfd_w))
2962	close (sigfd);	3255	close (sigfd);
2963	#endif	3256	#endif
2964		3257
		3258	#if EV_USE_TIMERFD
		3259	if (ev_is_active (&timerfd_w))
		3260	close (timerfd);
		3261	#endif
		3262
2965	#if EV_USE_INOTIFY	3263	#if EV_USE_INOTIFY
2966	if (fs_fd >= 0)	3264	if (fs_fd >= 0)
2967	close (fs_fd);	3265	close (fs_fd);
2968	#endif	3266	#endif
2969		3267
2970	if (backend_fd >= 0)	3268	if (backend_fd >= 0)
2971	close (backend_fd);	3269	close (backend_fd);
2972		3270
2973	#if EV_USE_IOCP	3271	#if EV_USE_IOCP
2974	if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);	3272	if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);
2975	#endif	3273	#endif
2976	#if EV_USE_PORT	3274	#if EV_USE_PORT
2977	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3275	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
2978	#endif	3276	#endif
2979	#if EV_USE_KQUEUE	3277	#if EV_USE_KQUEUE
2980	if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);	3278	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
		3279	#endif
		3280	#if EV_USE_IOURING
		3281	if (backend == EVBACKEND_IOURING ) iouring_destroy (EV_A);
		3282	#endif
		3283	#if EV_USE_LINUXAIO
		3284	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
2981	#endif	3285	#endif
2982	#if EV_USE_EPOLL	3286	#if EV_USE_EPOLL
2983	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);	3287	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
2984	#endif	3288	#endif
2985	#if EV_USE_POLL	3289	#if EV_USE_POLL
2986	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);	3290	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
2987	#endif	3291	#endif
2988	#if EV_USE_SELECT	3292	#if EV_USE_SELECT
2989	if (backend == EVBACKEND_SELECT) select_destroy (EV_A);	3293	if (backend == EVBACKEND_SELECT ) select_destroy (EV_A);
2990	#endif	3294	#endif
2991		3295
2992	for (i = NUMPRI; i--; )	3296	for (i = NUMPRI; i--; )
2993	{	3297	{
2994	array_free (pending, [i]);	3298	array_free (pending, [i]);
…		…
3036		3340
3037	inline_size void	3341	inline_size void
3038	loop_fork (EV_P)	3342	loop_fork (EV_P)
3039	{	3343	{
3040	#if EV_USE_PORT	3344	#if EV_USE_PORT
3041	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3345	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
3042	#endif	3346	#endif
3043	#if EV_USE_KQUEUE	3347	#if EV_USE_KQUEUE
3044	if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);	3348	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
		3349	#endif
		3350	#if EV_USE_IOURING
		3351	if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
		3352	#endif
		3353	#if EV_USE_LINUXAIO
		3354	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
3045	#endif	3355	#endif
3046	#if EV_USE_EPOLL	3356	#if EV_USE_EPOLL
3047	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3357	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
3048	#endif	3358	#endif
3049	#if EV_USE_INOTIFY	3359	#if EV_USE_INOTIFY
3050	infy_fork (EV_A);	3360	infy_fork (EV_A);
3051	#endif	3361	#endif
3052		3362
		3363	if (postfork != 2)
		3364	{
		3365	#if EV_USE_SIGNALFD
		3366	/* surprisingly, nothing needs to be done for signalfd, accoridng to docs, it does the right thing on fork */
		3367	#endif
		3368
		3369	#if EV_USE_TIMERFD
		3370	if (ev_is_active (&timerfd_w))
		3371	{
		3372	ev_ref (EV_A);
		3373	ev_io_stop (EV_A_ &timerfd_w);
		3374
		3375	close (timerfd);
		3376	timerfd = -2;
		3377
		3378	evtimerfd_init (EV_A);
		3379	/* reschedule periodics, in case we missed something */
		3380	ev_feed_event (EV_A_ &timerfd_w, EV_CUSTOM);
		3381	}
		3382	#endif
		3383
3053	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3384	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
3054	if (ev_is_active (&pipe_w) && postfork != 2)	3385	if (ev_is_active (&pipe_w))
3055	{	3386	{
3056	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3387	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
3057		3388
3058	ev_ref (EV_A);	3389	ev_ref (EV_A);
3059	ev_io_stop (EV_A_ &pipe_w);	3390	ev_io_stop (EV_A_ &pipe_w);
3060		3391
3061	if (evpipe [0] >= 0)	3392	if (evpipe [0] >= 0)
3062	EV_WIN32_CLOSE_FD (evpipe [0]);	3393	EV_WIN32_CLOSE_FD (evpipe [0]);
3063		3394
3064	evpipe_init (EV_A);	3395	evpipe_init (EV_A);
3065	/* iterate over everything, in case we missed something before */	3396	/* iterate over everything, in case we missed something before */
3066	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3397	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
		3398	}
		3399	#endif
3067	}	3400	}
3068	#endif
3069		3401
3070	postfork = 0;	3402	postfork = 0;
3071	}	3403	}
3072		3404
3073	#if EV_MULTIPLICITY	3405	#if EV_MULTIPLICITY
3074		3406
		3407	ecb_cold
3075	struct ev_loop * ecb_cold	3408	struct ev_loop *
3076	ev_loop_new (unsigned int flags) EV_THROW	3409	ev_loop_new (unsigned int flags) EV_NOEXCEPT
3077	{	3410	{
3078	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));	3411	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
3079		3412
3080	memset (EV_A, 0, sizeof (struct ev_loop));	3413	memset (EV_A, 0, sizeof (struct ev_loop));
3081	loop_init (EV_A_ flags);	3414	loop_init (EV_A_ flags);
…		…
3088	}	3421	}
3089		3422
3090	#endif /* multiplicity */	3423	#endif /* multiplicity */
3091		3424
3092	#if EV_VERIFY	3425	#if EV_VERIFY
3093	static void noinline ecb_cold	3426	ecb_noinline ecb_cold
		3427	static void
3094	verify_watcher (EV_P_ W w)	3428	verify_watcher (EV_P_ W w)
3095	{	3429	{
3096	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3430	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
3097		3431
3098	if (w->pending)	3432	if (w->pending)
3099	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3433	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
3100	}	3434	}
3101		3435
3102	static void noinline ecb_cold	3436	ecb_noinline ecb_cold
		3437	static void
3103	verify_heap (EV_P_ ANHE *heap, int N)	3438	verify_heap (EV_P_ ANHE *heap, int N)
3104	{	3439	{
3105	int i;	3440	int i;
3106		3441
3107	for (i = HEAP0; i < N + HEAP0; ++i)	3442	for (i = HEAP0; i < N + HEAP0; ++i)
…		…
3112		3447
3113	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3448	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
3114	}	3449	}
3115	}	3450	}
3116		3451
3117	static void noinline ecb_cold	3452	ecb_noinline ecb_cold
		3453	static void
3118	array_verify (EV_P_ W *ws, int cnt)	3454	array_verify (EV_P_ W *ws, int cnt)
3119	{	3455	{
3120	while (cnt--)	3456	while (cnt--)
3121	{	3457	{
3122	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));	3458	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
…		…
3125	}	3461	}
3126	#endif	3462	#endif
3127		3463
3128	#if EV_FEATURE_API	3464	#if EV_FEATURE_API
3129	void ecb_cold	3465	void ecb_cold
3130	ev_verify (EV_P) EV_THROW	3466	ev_verify (EV_P) EV_NOEXCEPT
3131	{	3467	{
3132	#if EV_VERIFY	3468	#if EV_VERIFY
3133	int i;	3469	int i;
3134	WL w, w2;	3470	WL w, w2;
3135		3471
…		…
3211	#endif	3547	#endif
3212	}	3548	}
3213	#endif	3549	#endif
3214		3550
3215	#if EV_MULTIPLICITY	3551	#if EV_MULTIPLICITY
		3552	ecb_cold
3216	struct ev_loop * ecb_cold	3553	struct ev_loop *
3217	#else	3554	#else
3218	int	3555	int
3219	#endif	3556	#endif
3220	ev_default_loop (unsigned int flags) EV_THROW	3557	ev_default_loop (unsigned int flags) EV_NOEXCEPT
3221	{	3558	{
3222	if (!ev_default_loop_ptr)	3559	if (!ev_default_loop_ptr)
3223	{	3560	{
3224	#if EV_MULTIPLICITY	3561	#if EV_MULTIPLICITY
3225	EV_P = ev_default_loop_ptr = &default_loop_struct;	3562	EV_P = ev_default_loop_ptr = &default_loop_struct;
…		…
3244		3581
3245	return ev_default_loop_ptr;	3582	return ev_default_loop_ptr;
3246	}	3583	}
3247		3584
3248	void	3585	void
3249	ev_loop_fork (EV_P) EV_THROW	3586	ev_loop_fork (EV_P) EV_NOEXCEPT
3250	{	3587	{
3251	postfork = 1;	3588	postfork = 1;
3252	}	3589	}
3253		3590
3254	/*****************************************************************************/	3591	/*****************************************************************************/
…		…
3258	{	3595	{
3259	EV_CB_INVOKE ((W)w, revents);	3596	EV_CB_INVOKE ((W)w, revents);
3260	}	3597	}
3261		3598
3262	unsigned int	3599	unsigned int
3263	ev_pending_count (EV_P) EV_THROW	3600	ev_pending_count (EV_P) EV_NOEXCEPT
3264	{	3601	{
3265	int pri;	3602	int pri;
3266	unsigned int count = 0;	3603	unsigned int count = 0;
3267		3604
3268	for (pri = NUMPRI; pri--; )	3605	for (pri = NUMPRI; pri--; )
3269	count += pendingcnt [pri];	3606	count += pendingcnt [pri];
3270		3607
3271	return count;	3608	return count;
3272	}	3609	}
3273		3610
3274	void noinline	3611	ecb_noinline
		3612	void
3275	ev_invoke_pending (EV_P)	3613	ev_invoke_pending (EV_P)
3276	{	3614	{
3277	pendingpri = NUMPRI;	3615	pendingpri = NUMPRI;
3278		3616
3279	while (pendingpri) /* pendingpri possibly gets modified in the inner loop */	3617	do
3280	{	3618	{
3281	--pendingpri;	3619	--pendingpri;
3282		3620
		3621	/* pendingpri possibly gets modified in the inner loop */
3283	while (pendingcnt [pendingpri])	3622	while (pendingcnt [pendingpri])
3284	{	3623	{
3285	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];	3624	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
3286		3625
3287	p->w->pending = 0;	3626	p->w->pending = 0;
3288	EV_CB_INVOKE (p->w, p->events);	3627	EV_CB_INVOKE (p->w, p->events);
3289	EV_FREQUENT_CHECK;	3628	EV_FREQUENT_CHECK;
3290	}	3629	}
3291	}	3630	}
		3631	while (pendingpri);
3292	}	3632	}
3293		3633
3294	#if EV_IDLE_ENABLE	3634	#if EV_IDLE_ENABLE
3295	/* make idle watchers pending. this handles the "call-idle */	3635	/* make idle watchers pending. this handles the "call-idle */
3296	/* only when higher priorities are idle" logic */	3636	/* only when higher priorities are idle" logic */
3297	inline_size void	3637	inline_size void
3298	idle_reify (EV_P)	3638	idle_reify (EV_P)
3299	{	3639	{
3300	if (expect_false (idleall))	3640	if (ecb_expect_false (idleall))
3301	{	3641	{
3302	int pri;	3642	int pri;
3303		3643
3304	for (pri = NUMPRI; pri--; )	3644	for (pri = NUMPRI; pri--; )
3305	{	3645	{
…		…
3335	{	3675	{
3336	ev_at (w) += w->repeat;	3676	ev_at (w) += w->repeat;
3337	if (ev_at (w) < mn_now)	3677	if (ev_at (w) < mn_now)
3338	ev_at (w) = mn_now;	3678	ev_at (w) = mn_now;
3339		3679
3340	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));	3680	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > EV_TS_CONST (0.)));
3341		3681
3342	ANHE_at_cache (timers [HEAP0]);	3682	ANHE_at_cache (timers [HEAP0]);
3343	downheap (timers, timercnt, HEAP0);	3683	downheap (timers, timercnt, HEAP0);
3344	}	3684	}
3345	else	3685	else
…		…
3354	}	3694	}
3355	}	3695	}
3356		3696
3357	#if EV_PERIODIC_ENABLE	3697	#if EV_PERIODIC_ENABLE
3358		3698
3359	static void noinline	3699	ecb_noinline
		3700	static void
3360	periodic_recalc (EV_P_ ev_periodic *w)	3701	periodic_recalc (EV_P_ ev_periodic *w)
3361	{	3702	{
3362	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3703	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3363	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);	3704	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
3364		3705
…		…
3366	while (at <= ev_rt_now)	3707	while (at <= ev_rt_now)
3367	{	3708	{
3368	ev_tstamp nat = at + w->interval;	3709	ev_tstamp nat = at + w->interval;
3369		3710
3370	/* when resolution fails us, we use ev_rt_now */	3711	/* when resolution fails us, we use ev_rt_now */
3371	if (expect_false (nat == at))	3712	if (ecb_expect_false (nat == at))
3372	{	3713	{
3373	at = ev_rt_now;	3714	at = ev_rt_now;
3374	break;	3715	break;
3375	}	3716	}
3376		3717
…		…
3422	}	3763	}
3423	}	3764	}
3424		3765
3425	/* simply recalculate all periodics */	3766	/* simply recalculate all periodics */
3426	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3767	/* TODO: maybe ensure that at least one event happens when jumping forward? */
3427	static void noinline ecb_cold	3768	ecb_noinline ecb_cold
		3769	static void
3428	periodics_reschedule (EV_P)	3770	periodics_reschedule (EV_P)
3429	{	3771	{
3430	int i;	3772	int i;
3431		3773
3432	/* adjust periodics after time jump */	3774	/* adjust periodics after time jump */
…		…
3445	reheap (periodics, periodiccnt);	3787	reheap (periodics, periodiccnt);
3446	}	3788	}
3447	#endif	3789	#endif
3448		3790
3449	/* adjust all timers by a given offset */	3791	/* adjust all timers by a given offset */
3450	static void noinline ecb_cold	3792	ecb_noinline ecb_cold
		3793	static void
3451	timers_reschedule (EV_P_ ev_tstamp adjust)	3794	timers_reschedule (EV_P_ ev_tstamp adjust)
3452	{	3795	{
3453	int i;	3796	int i;
3454		3797
3455	for (i = 0; i < timercnt; ++i)	3798	for (i = 0; i < timercnt; ++i)
…		…
3464	/* also detect if there was a timejump, and act accordingly */	3807	/* also detect if there was a timejump, and act accordingly */
3465	inline_speed void	3808	inline_speed void
3466	time_update (EV_P_ ev_tstamp max_block)	3809	time_update (EV_P_ ev_tstamp max_block)
3467	{	3810	{
3468	#if EV_USE_MONOTONIC	3811	#if EV_USE_MONOTONIC
3469	if (expect_true (have_monotonic))	3812	if (ecb_expect_true (have_monotonic))
3470	{	3813	{
3471	int i;	3814	int i;
3472	ev_tstamp odiff = rtmn_diff;	3815	ev_tstamp odiff = rtmn_diff;
3473		3816
3474	mn_now = get_clock ();	3817	mn_now = get_clock ();
3475		3818
3476	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */	3819	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3477	/* interpolate in the meantime */	3820	/* interpolate in the meantime */
3478	if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))	3821	if (ecb_expect_true (mn_now - now_floor < EV_TS_CONST (MIN_TIMEJUMP * .5)))
3479	{	3822	{
3480	ev_rt_now = rtmn_diff + mn_now;	3823	ev_rt_now = rtmn_diff + mn_now;
3481	return;	3824	return;
3482	}	3825	}
3483		3826
…		…
3497	ev_tstamp diff;	3840	ev_tstamp diff;
3498	rtmn_diff = ev_rt_now - mn_now;	3841	rtmn_diff = ev_rt_now - mn_now;
3499		3842
3500	diff = odiff - rtmn_diff;	3843	diff = odiff - rtmn_diff;
3501		3844
3502	if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))	3845	if (ecb_expect_true ((diff < EV_TS_CONST (0.) ? -diff : diff) < EV_TS_CONST (MIN_TIMEJUMP)))
3503	return; /* all is well */	3846	return; /* all is well */
3504		3847
3505	ev_rt_now = ev_time ();	3848	ev_rt_now = ev_time ();
3506	mn_now = get_clock ();	3849	mn_now = get_clock ();
3507	now_floor = mn_now;	3850	now_floor = mn_now;
…		…
3516	else	3859	else
3517	#endif	3860	#endif
3518	{	3861	{
3519	ev_rt_now = ev_time ();	3862	ev_rt_now = ev_time ();
3520		3863
3521	if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))	3864	if (ecb_expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + EV_TS_CONST (MIN_TIMEJUMP)))
3522	{	3865	{
3523	/* adjust timers. this is easy, as the offset is the same for all of them */	3866	/* adjust timers. this is easy, as the offset is the same for all of them */
3524	timers_reschedule (EV_A_ ev_rt_now - mn_now);	3867	timers_reschedule (EV_A_ ev_rt_now - mn_now);
3525	#if EV_PERIODIC_ENABLE	3868	#if EV_PERIODIC_ENABLE
3526	periodics_reschedule (EV_A);	3869	periodics_reschedule (EV_A);
…		…
3549	#if EV_VERIFY >= 2	3892	#if EV_VERIFY >= 2
3550	ev_verify (EV_A);	3893	ev_verify (EV_A);
3551	#endif	3894	#endif
3552		3895
3553	#ifndef _WIN32	3896	#ifndef _WIN32
3554	if (expect_false (curpid)) /* penalise the forking check even more */	3897	if (ecb_expect_false (curpid)) /* penalise the forking check even more */
3555	if (expect_false (getpid () != curpid))	3898	if (ecb_expect_false (getpid () != curpid))
3556	{	3899	{
3557	curpid = getpid ();	3900	curpid = getpid ();
3558	postfork = 1;	3901	postfork = 1;
3559	}	3902	}
3560	#endif	3903	#endif
3561		3904
3562	#if EV_FORK_ENABLE	3905	#if EV_FORK_ENABLE
3563	/* we might have forked, so queue fork handlers */	3906	/* we might have forked, so queue fork handlers */
3564	if (expect_false (postfork))	3907	if (ecb_expect_false (postfork))
3565	if (forkcnt)	3908	if (forkcnt)
3566	{	3909	{
3567	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	3910	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3568	EV_INVOKE_PENDING;	3911	EV_INVOKE_PENDING;
3569	}	3912	}
3570	#endif	3913	#endif
3571		3914
3572	#if EV_PREPARE_ENABLE	3915	#if EV_PREPARE_ENABLE
3573	/* queue prepare watchers (and execute them) */	3916	/* queue prepare watchers (and execute them) */
3574	if (expect_false (preparecnt))	3917	if (ecb_expect_false (preparecnt))
3575	{	3918	{
3576	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	3919	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3577	EV_INVOKE_PENDING;	3920	EV_INVOKE_PENDING;
3578	}	3921	}
3579	#endif	3922	#endif
3580		3923
3581	if (expect_false (loop_done))	3924	if (ecb_expect_false (loop_done))
3582	break;	3925	break;
3583		3926
3584	/* we might have forked, so reify kernel state if necessary */	3927	/* we might have forked, so reify kernel state if necessary */
3585	if (expect_false (postfork))	3928	if (ecb_expect_false (postfork))
3586	loop_fork (EV_A);	3929	loop_fork (EV_A);
3587		3930
3588	/* update fd-related kernel structures */	3931	/* update fd-related kernel structures */
3589	fd_reify (EV_A);	3932	fd_reify (EV_A);
3590		3933
…		…
3595		3938
3596	/* remember old timestamp for io_blocktime calculation */	3939	/* remember old timestamp for io_blocktime calculation */
3597	ev_tstamp prev_mn_now = mn_now;	3940	ev_tstamp prev_mn_now = mn_now;
3598		3941
3599	/* update time to cancel out callback processing overhead */	3942	/* update time to cancel out callback processing overhead */
3600	time_update (EV_A_ 1e100);	3943	time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
3601		3944
3602	/* from now on, we want a pipe-wake-up */	3945	/* from now on, we want a pipe-wake-up */
3603	pipe_write_wanted = 1;	3946	pipe_write_wanted = 1;
3604		3947
3605	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */	3948	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3606		3949
3607	if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))	3950	if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3608	{	3951	{
3609	waittime = MAX_BLOCKTIME;	3952	waittime = EV_TS_CONST (MAX_BLOCKTIME);
3610		3953
3611	if (timercnt)	3954	if (timercnt)
3612	{	3955	{
3613	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	3956	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3614	if (waittime > to) waittime = to;	3957	if (waittime > to) waittime = to;
…		…
3621	if (waittime > to) waittime = to;	3964	if (waittime > to) waittime = to;
3622	}	3965	}
3623	#endif	3966	#endif
3624		3967
3625	/* don't let timeouts decrease the waittime below timeout_blocktime */	3968	/* don't let timeouts decrease the waittime below timeout_blocktime */
3626	if (expect_false (waittime < timeout_blocktime))	3969	if (ecb_expect_false (waittime < timeout_blocktime))
3627	waittime = timeout_blocktime;	3970	waittime = timeout_blocktime;
3628		3971
3629	/* at this point, we NEED to wait, so we have to ensure */	3972	/* now there are two more special cases left, either we have
3630	/* to pass a minimum nonzero value to the backend */	3973	* already-expired timers, so we should not sleep, or we have timers
		3974	* that expire very soon, in which case we need to wait for a minimum
		3975	* amount of time for some event loop backends.
		3976	*/
3631	if (expect_false (waittime < backend_mintime))	3977	if (ecb_expect_false (waittime < backend_mintime))
		3978	waittime = waittime <= EV_TS_CONST (0.)
		3979	? EV_TS_CONST (0.)
3632	waittime = backend_mintime;	3980	: backend_mintime;
3633		3981
3634	/* extra check because io_blocktime is commonly 0 */	3982	/* extra check because io_blocktime is commonly 0 */
3635	if (expect_false (io_blocktime))	3983	if (ecb_expect_false (io_blocktime))
3636	{	3984	{
3637	sleeptime = io_blocktime - (mn_now - prev_mn_now);	3985	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3638		3986
3639	if (sleeptime > waittime - backend_mintime)	3987	if (sleeptime > waittime - backend_mintime)
3640	sleeptime = waittime - backend_mintime;	3988	sleeptime = waittime - backend_mintime;
3641		3989
3642	if (expect_true (sleeptime > 0.))	3990	if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
3643	{	3991	{
3644	ev_sleep (sleeptime);	3992	ev_sleep (sleeptime);
3645	waittime -= sleeptime;	3993	waittime -= sleeptime;
3646	}	3994	}
3647	}	3995	}
…		…
3661	{	4009	{
3662	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	4010	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3663	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	4011	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3664	}	4012	}
3665		4013
3666
3667	/* update ev_rt_now, do magic */	4014	/* update ev_rt_now, do magic */
3668	time_update (EV_A_ waittime + sleeptime);	4015	time_update (EV_A_ waittime + sleeptime);
3669	}	4016	}
3670		4017
3671	/* queue pending timers and reschedule them */	4018	/* queue pending timers and reschedule them */
…		…
3679	idle_reify (EV_A);	4026	idle_reify (EV_A);
3680	#endif	4027	#endif
3681		4028
3682	#if EV_CHECK_ENABLE	4029	#if EV_CHECK_ENABLE
3683	/* queue check watchers, to be executed first */	4030	/* queue check watchers, to be executed first */
3684	if (expect_false (checkcnt))	4031	if (ecb_expect_false (checkcnt))
3685	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	4032	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3686	#endif	4033	#endif
3687		4034
3688	EV_INVOKE_PENDING;	4035	EV_INVOKE_PENDING;
3689	}	4036	}
3690	while (expect_true (	4037	while (ecb_expect_true (
3691	activecnt	4038	activecnt
3692	&& !loop_done	4039	&& !loop_done
3693	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))	4040	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3694	));	4041	));
3695		4042
…		…
3702		4049
3703	return activecnt;	4050	return activecnt;
3704	}	4051	}
3705		4052
3706	void	4053	void
3707	ev_break (EV_P_ int how) EV_THROW	4054	ev_break (EV_P_ int how) EV_NOEXCEPT
3708	{	4055	{
3709	loop_done = how;	4056	loop_done = how;
3710	}	4057	}
3711		4058
3712	void	4059	void
3713	ev_ref (EV_P) EV_THROW	4060	ev_ref (EV_P) EV_NOEXCEPT
3714	{	4061	{
3715	++activecnt;	4062	++activecnt;
3716	}	4063	}
3717		4064
3718	void	4065	void
3719	ev_unref (EV_P) EV_THROW	4066	ev_unref (EV_P) EV_NOEXCEPT
3720	{	4067	{
3721	--activecnt;	4068	--activecnt;
3722	}	4069	}
3723		4070
3724	void	4071	void
3725	ev_now_update (EV_P) EV_THROW	4072	ev_now_update (EV_P) EV_NOEXCEPT
3726	{	4073	{
3727	time_update (EV_A_ 1e100);	4074	time_update (EV_A_ EV_TSTAMP_HUGE);
3728	}	4075	}
3729		4076
3730	void	4077	void
3731	ev_suspend (EV_P) EV_THROW	4078	ev_suspend (EV_P) EV_NOEXCEPT
3732	{	4079	{
3733	ev_now_update (EV_A);	4080	ev_now_update (EV_A);
3734	}	4081	}
3735		4082
3736	void	4083	void
3737	ev_resume (EV_P) EV_THROW	4084	ev_resume (EV_P) EV_NOEXCEPT
3738	{	4085	{
3739	ev_tstamp mn_prev = mn_now;	4086	ev_tstamp mn_prev = mn_now;
3740		4087
3741	ev_now_update (EV_A);	4088	ev_now_update (EV_A);
3742	timers_reschedule (EV_A_ mn_now - mn_prev);	4089	timers_reschedule (EV_A_ mn_now - mn_prev);
…		…
3759	inline_size void	4106	inline_size void
3760	wlist_del (WL *head, WL elem)	4107	wlist_del (WL *head, WL elem)
3761	{	4108	{
3762	while (*head)	4109	while (*head)
3763	{	4110	{
3764	if (expect_true (*head == elem))	4111	if (ecb_expect_true (*head == elem))
3765	{	4112	{
3766	*head = elem->next;	4113	*head = elem->next;
3767	break;	4114	break;
3768	}	4115	}
3769		4116
…		…
3781	w->pending = 0;	4128	w->pending = 0;
3782	}	4129	}
3783	}	4130	}
3784		4131
3785	int	4132	int
3786	ev_clear_pending (EV_P_ void *w) EV_THROW	4133	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3787	{	4134	{
3788	W w_ = (W)w;	4135	W w_ = (W)w;
3789	int pending = w_->pending;	4136	int pending = w_->pending;
3790		4137
3791	if (expect_true (pending))	4138	if (ecb_expect_true (pending))
3792	{	4139	{
3793	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	4140	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3794	p->w = (W)&pending_w;	4141	p->w = (W)&pending_w;
3795	w_->pending = 0;	4142	w_->pending = 0;
3796	return p->events;	4143	return p->events;
…		…
3823	w->active = 0;	4170	w->active = 0;
3824	}	4171	}
3825		4172
3826	/*****************************************************************************/	4173	/*****************************************************************************/
3827		4174
3828	void noinline	4175	ecb_noinline
		4176	void
3829	ev_io_start (EV_P_ ev_io *w) EV_THROW	4177	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3830	{	4178	{
3831	int fd = w->fd;	4179	int fd = w->fd;
3832		4180
3833	if (expect_false (ev_is_active (w)))	4181	if (ecb_expect_false (ev_is_active (w)))
3834	return;	4182	return;
3835		4183
3836	assert (("libev: ev_io_start called with negative fd", fd >= 0));	4184	assert (("libev: ev_io_start called with negative fd", fd >= 0));
3837	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));	4185	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3838		4186
		4187	#if EV_VERIFY >= 2
		4188	assert (("libev: ev_io_start called on watcher with invalid fd", fd_valid (fd)));
		4189	#endif
3839	EV_FREQUENT_CHECK;	4190	EV_FREQUENT_CHECK;
3840		4191
3841	ev_start (EV_A_ (W)w, 1);	4192	ev_start (EV_A_ (W)w, 1);
3842	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	4193	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);
3843	wlist_add (&anfds[fd].head, (WL)w);	4194	wlist_add (&anfds[fd].head, (WL)w);
3844		4195
3845	/* common bug, apparently */	4196	/* common bug, apparently */
3846	assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));	4197	assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3847		4198
…		…
3849	w->events &= ~EV__IOFDSET;	4200	w->events &= ~EV__IOFDSET;
3850		4201
3851	EV_FREQUENT_CHECK;	4202	EV_FREQUENT_CHECK;
3852	}	4203	}
3853		4204
3854	void noinline	4205	ecb_noinline
		4206	void
3855	ev_io_stop (EV_P_ ev_io *w) EV_THROW	4207	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3856	{	4208	{
3857	clear_pending (EV_A_ (W)w);	4209	clear_pending (EV_A_ (W)w);
3858	if (expect_false (!ev_is_active (w)))	4210	if (ecb_expect_false (!ev_is_active (w)))
3859	return;	4211	return;
3860		4212
3861	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));	4213	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3862		4214
		4215	#if EV_VERIFY >= 2
		4216	assert (("libev: ev_io_stop called on watcher with invalid fd", fd_valid (w->fd)));
		4217	#endif
3863	EV_FREQUENT_CHECK;	4218	EV_FREQUENT_CHECK;
3864		4219
3865	wlist_del (&anfds[w->fd].head, (WL)w);	4220	wlist_del (&anfds[w->fd].head, (WL)w);
3866	ev_stop (EV_A_ (W)w);	4221	ev_stop (EV_A_ (W)w);
3867		4222
3868	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	4223	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3869		4224
3870	EV_FREQUENT_CHECK;	4225	EV_FREQUENT_CHECK;
3871	}	4226	}
3872		4227
3873	void noinline	4228	ecb_noinline
		4229	void
3874	ev_timer_start (EV_P_ ev_timer *w) EV_THROW	4230	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3875	{	4231	{
3876	if (expect_false (ev_is_active (w)))	4232	if (ecb_expect_false (ev_is_active (w)))
3877	return;	4233	return;
3878		4234
3879	ev_at (w) += mn_now;	4235	ev_at (w) += mn_now;
3880		4236
3881	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));	4237	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
3882		4238
3883	EV_FREQUENT_CHECK;	4239	EV_FREQUENT_CHECK;
3884		4240
3885	++timercnt;	4241	++timercnt;
3886	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);	4242	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
3887	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);	4243	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, array_needsize_noinit);
3888	ANHE_w (timers [ev_active (w)]) = (WT)w;	4244	ANHE_w (timers [ev_active (w)]) = (WT)w;
3889	ANHE_at_cache (timers [ev_active (w)]);	4245	ANHE_at_cache (timers [ev_active (w)]);
3890	upheap (timers, ev_active (w));	4246	upheap (timers, ev_active (w));
3891		4247
3892	EV_FREQUENT_CHECK;	4248	EV_FREQUENT_CHECK;
3893		4249
3894	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	4250	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3895	}	4251	}
3896		4252
3897	void noinline	4253	ecb_noinline
		4254	void
3898	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW	4255	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3899	{	4256	{
3900	clear_pending (EV_A_ (W)w);	4257	clear_pending (EV_A_ (W)w);
3901	if (expect_false (!ev_is_active (w)))	4258	if (ecb_expect_false (!ev_is_active (w)))
3902	return;	4259	return;
3903		4260
3904	EV_FREQUENT_CHECK;	4261	EV_FREQUENT_CHECK;
3905		4262
3906	{	4263	{
…		…
3908		4265
3909	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));	4266	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
3910		4267
3911	--timercnt;	4268	--timercnt;
3912		4269
3913	if (expect_true (active < timercnt + HEAP0))	4270	if (ecb_expect_true (active < timercnt + HEAP0))
3914	{	4271	{
3915	timers [active] = timers [timercnt + HEAP0];	4272	timers [active] = timers [timercnt + HEAP0];
3916	adjustheap (timers, timercnt, active);	4273	adjustheap (timers, timercnt, active);
3917	}	4274	}
3918	}	4275	}
…		…
3922	ev_stop (EV_A_ (W)w);	4279	ev_stop (EV_A_ (W)w);
3923		4280
3924	EV_FREQUENT_CHECK;	4281	EV_FREQUENT_CHECK;
3925	}	4282	}
3926		4283
3927	void noinline	4284	ecb_noinline
		4285	void
3928	ev_timer_again (EV_P_ ev_timer *w) EV_THROW	4286	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
3929	{	4287	{
3930	EV_FREQUENT_CHECK;	4288	EV_FREQUENT_CHECK;
3931		4289
3932	clear_pending (EV_A_ (W)w);	4290	clear_pending (EV_A_ (W)w);
3933		4291
…		…
3950		4308
3951	EV_FREQUENT_CHECK;	4309	EV_FREQUENT_CHECK;
3952	}	4310	}
3953		4311
3954	ev_tstamp	4312	ev_tstamp
3955	ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW	4313	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
3956	{	4314	{
3957	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4315	return ev_at (w) - (ev_is_active (w) ? mn_now : EV_TS_CONST (0.));
3958	}	4316	}
3959		4317
3960	#if EV_PERIODIC_ENABLE	4318	#if EV_PERIODIC_ENABLE
3961	void noinline	4319	ecb_noinline
		4320	void
3962	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW	4321	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
3963	{	4322	{
3964	if (expect_false (ev_is_active (w)))	4323	if (ecb_expect_false (ev_is_active (w)))
3965	return;	4324	return;
		4325
		4326	#if EV_USE_TIMERFD
		4327	if (timerfd == -2)
		4328	evtimerfd_init (EV_A);
		4329	#endif
3966		4330
3967	if (w->reschedule_cb)	4331	if (w->reschedule_cb)
3968	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4332	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3969	else if (w->interval)	4333	else if (w->interval)
3970	{	4334	{
…		…
3976		4340
3977	EV_FREQUENT_CHECK;	4341	EV_FREQUENT_CHECK;
3978		4342
3979	++periodiccnt;	4343	++periodiccnt;
3980	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);	4344	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
3981	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);	4345	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, array_needsize_noinit);
3982	ANHE_w (periodics [ev_active (w)]) = (WT)w;	4346	ANHE_w (periodics [ev_active (w)]) = (WT)w;
3983	ANHE_at_cache (periodics [ev_active (w)]);	4347	ANHE_at_cache (periodics [ev_active (w)]);
3984	upheap (periodics, ev_active (w));	4348	upheap (periodics, ev_active (w));
3985		4349
3986	EV_FREQUENT_CHECK;	4350	EV_FREQUENT_CHECK;
3987		4351
3988	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4352	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3989	}	4353	}
3990		4354
3991	void noinline	4355	ecb_noinline
		4356	void
3992	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW	4357	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
3993	{	4358	{
3994	clear_pending (EV_A_ (W)w);	4359	clear_pending (EV_A_ (W)w);
3995	if (expect_false (!ev_is_active (w)))	4360	if (ecb_expect_false (!ev_is_active (w)))
3996	return;	4361	return;
3997		4362
3998	EV_FREQUENT_CHECK;	4363	EV_FREQUENT_CHECK;
3999		4364
4000	{	4365	{
…		…
4002		4367
4003	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));	4368	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
4004		4369
4005	--periodiccnt;	4370	--periodiccnt;
4006		4371
4007	if (expect_true (active < periodiccnt + HEAP0))	4372	if (ecb_expect_true (active < periodiccnt + HEAP0))
4008	{	4373	{
4009	periodics [active] = periodics [periodiccnt + HEAP0];	4374	periodics [active] = periodics [periodiccnt + HEAP0];
4010	adjustheap (periodics, periodiccnt, active);	4375	adjustheap (periodics, periodiccnt, active);
4011	}	4376	}
4012	}	4377	}
…		…
4014	ev_stop (EV_A_ (W)w);	4379	ev_stop (EV_A_ (W)w);
4015		4380
4016	EV_FREQUENT_CHECK;	4381	EV_FREQUENT_CHECK;
4017	}	4382	}
4018		4383
4019	void noinline	4384	ecb_noinline
		4385	void
4020	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW	4386	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4021	{	4387	{
4022	/* TODO: use adjustheap and recalculation */	4388	/* TODO: use adjustheap and recalculation */
4023	ev_periodic_stop (EV_A_ w);	4389	ev_periodic_stop (EV_A_ w);
4024	ev_periodic_start (EV_A_ w);	4390	ev_periodic_start (EV_A_ w);
4025	}	4391	}
…		…
4029	# define SA_RESTART 0	4395	# define SA_RESTART 0
4030	#endif	4396	#endif
4031		4397
4032	#if EV_SIGNAL_ENABLE	4398	#if EV_SIGNAL_ENABLE
4033		4399
4034	void noinline	4400	ecb_noinline
		4401	void
4035	ev_signal_start (EV_P_ ev_signal *w) EV_THROW	4402	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4036	{	4403	{
4037	if (expect_false (ev_is_active (w)))	4404	if (ecb_expect_false (ev_is_active (w)))
4038	return;	4405	return;
4039		4406
4040	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4407	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
4041		4408
4042	#if EV_MULTIPLICITY	4409	#if EV_MULTIPLICITY
…		…
4111	}	4478	}
4112		4479
4113	EV_FREQUENT_CHECK;	4480	EV_FREQUENT_CHECK;
4114	}	4481	}
4115		4482
4116	void noinline	4483	ecb_noinline
		4484	void
4117	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW	4485	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4118	{	4486	{
4119	clear_pending (EV_A_ (W)w);	4487	clear_pending (EV_A_ (W)w);
4120	if (expect_false (!ev_is_active (w)))	4488	if (ecb_expect_false (!ev_is_active (w)))
4121	return;	4489	return;
4122		4490
4123	EV_FREQUENT_CHECK;	4491	EV_FREQUENT_CHECK;
4124		4492
4125	wlist_del (&signals [w->signum - 1].head, (WL)w);	4493	wlist_del (&signals [w->signum - 1].head, (WL)w);
…		…
4153	#endif	4521	#endif
4154		4522
4155	#if EV_CHILD_ENABLE	4523	#if EV_CHILD_ENABLE
4156		4524
4157	void	4525	void
4158	ev_child_start (EV_P_ ev_child *w) EV_THROW	4526	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4159	{	4527	{
4160	#if EV_MULTIPLICITY	4528	#if EV_MULTIPLICITY
4161	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4529	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
4162	#endif	4530	#endif
4163	if (expect_false (ev_is_active (w)))	4531	if (ecb_expect_false (ev_is_active (w)))
4164	return;	4532	return;
4165		4533
4166	EV_FREQUENT_CHECK;	4534	EV_FREQUENT_CHECK;
4167		4535
4168	ev_start (EV_A_ (W)w, 1);	4536	ev_start (EV_A_ (W)w, 1);
…		…
4170		4538
4171	EV_FREQUENT_CHECK;	4539	EV_FREQUENT_CHECK;
4172	}	4540	}
4173		4541
4174	void	4542	void
4175	ev_child_stop (EV_P_ ev_child *w) EV_THROW	4543	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4176	{	4544	{
4177	clear_pending (EV_A_ (W)w);	4545	clear_pending (EV_A_ (W)w);
4178	if (expect_false (!ev_is_active (w)))	4546	if (ecb_expect_false (!ev_is_active (w)))
4179	return;	4547	return;
4180		4548
4181	EV_FREQUENT_CHECK;	4549	EV_FREQUENT_CHECK;
4182		4550
4183	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);	4551	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
…		…
4197		4565
4198	#define DEF_STAT_INTERVAL 5.0074891	4566	#define DEF_STAT_INTERVAL 5.0074891
4199	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4567	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
4200	#define MIN_STAT_INTERVAL 0.1074891	4568	#define MIN_STAT_INTERVAL 0.1074891
4201		4569
4202	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4570	ecb_noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
4203		4571
4204	#if EV_USE_INOTIFY	4572	#if EV_USE_INOTIFY
4205		4573
4206	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4574	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
4207	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4575	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
4208		4576
4209	static void noinline	4577	ecb_noinline
		4578	static void
4210	infy_add (EV_P_ ev_stat *w)	4579	infy_add (EV_P_ ev_stat *w)
4211	{	4580	{
4212	w->wd = inotify_add_watch (fs_fd, w->path,	4581	w->wd = inotify_add_watch (fs_fd, w->path,
4213	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY	4582	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
4214	| IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO	4583	| IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
…		…
4278	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4647	if (ev_is_active (&w->timer)) ev_ref (EV_A);
4279	ev_timer_again (EV_A_ &w->timer);	4648	ev_timer_again (EV_A_ &w->timer);
4280	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4649	if (ev_is_active (&w->timer)) ev_unref (EV_A);
4281	}	4650	}
4282		4651
4283	static void noinline	4652	ecb_noinline
		4653	static void
4284	infy_del (EV_P_ ev_stat *w)	4654	infy_del (EV_P_ ev_stat *w)
4285	{	4655	{
4286	int slot;	4656	int slot;
4287	int wd = w->wd;	4657	int wd = w->wd;
4288		4658
…		…
4295		4665
4296	/* remove this watcher, if others are watching it, they will rearm */	4666	/* remove this watcher, if others are watching it, they will rearm */
4297	inotify_rm_watch (fs_fd, wd);	4667	inotify_rm_watch (fs_fd, wd);
4298	}	4668	}
4299		4669
4300	static void noinline	4670	ecb_noinline
		4671	static void
4301	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4672	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
4302	{	4673	{
4303	if (slot < 0)	4674	if (slot < 0)
4304	/* overflow, need to check for all hash slots */	4675	/* overflow, need to check for all hash slots */
4305	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)	4676	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
…		…
4341	infy_wd (EV_A_ ev->wd, ev->wd, ev);	4712	infy_wd (EV_A_ ev->wd, ev->wd, ev);
4342	ofs += sizeof (struct inotify_event) + ev->len;	4713	ofs += sizeof (struct inotify_event) + ev->len;
4343	}	4714	}
4344	}	4715	}
4345		4716
4346	inline_size void ecb_cold	4717	inline_size ecb_cold
		4718	void
4347	ev_check_2625 (EV_P)	4719	ev_check_2625 (EV_P)
4348	{	4720	{
4349	/* kernels < 2.6.25 are borked	4721	/* kernels < 2.6.25 are borked
4350	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	4722	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
4351	*/	4723	*/
…		…
4441	#else	4813	#else
4442	# define EV_LSTAT(p,b) lstat (p, b)	4814	# define EV_LSTAT(p,b) lstat (p, b)
4443	#endif	4815	#endif
4444		4816
4445	void	4817	void
4446	ev_stat_stat (EV_P_ ev_stat *w) EV_THROW	4818	ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT
4447	{	4819	{
4448	if (lstat (w->path, &w->attr) < 0)	4820	if (lstat (w->path, &w->attr) < 0)
4449	w->attr.st_nlink = 0;	4821	w->attr.st_nlink = 0;
4450	else if (!w->attr.st_nlink)	4822	else if (!w->attr.st_nlink)
4451	w->attr.st_nlink = 1;	4823	w->attr.st_nlink = 1;
4452	}	4824	}
4453		4825
4454	static void noinline	4826	ecb_noinline
		4827	static void
4455	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4828	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4456	{	4829	{
4457	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4830	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4458		4831
4459	ev_statdata prev = w->attr;	4832	ev_statdata prev = w->attr;
…		…
4490	ev_feed_event (EV_A_ w, EV_STAT);	4863	ev_feed_event (EV_A_ w, EV_STAT);
4491	}	4864	}
4492	}	4865	}
4493		4866
4494	void	4867	void
4495	ev_stat_start (EV_P_ ev_stat *w) EV_THROW	4868	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4496	{	4869	{
4497	if (expect_false (ev_is_active (w)))	4870	if (ecb_expect_false (ev_is_active (w)))
4498	return;	4871	return;
4499		4872
4500	ev_stat_stat (EV_A_ w);	4873	ev_stat_stat (EV_A_ w);
4501		4874
4502	if (w->interval < MIN_STAT_INTERVAL && w->interval)	4875	if (w->interval < MIN_STAT_INTERVAL && w->interval)
…		…
4521		4894
4522	EV_FREQUENT_CHECK;	4895	EV_FREQUENT_CHECK;
4523	}	4896	}
4524		4897
4525	void	4898	void
4526	ev_stat_stop (EV_P_ ev_stat *w) EV_THROW	4899	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4527	{	4900	{
4528	clear_pending (EV_A_ (W)w);	4901	clear_pending (EV_A_ (W)w);
4529	if (expect_false (!ev_is_active (w)))	4902	if (ecb_expect_false (!ev_is_active (w)))
4530	return;	4903	return;
4531		4904
4532	EV_FREQUENT_CHECK;	4905	EV_FREQUENT_CHECK;
4533		4906
4534	#if EV_USE_INOTIFY	4907	#if EV_USE_INOTIFY
…		…
4547	}	4920	}
4548	#endif	4921	#endif
4549		4922
4550	#if EV_IDLE_ENABLE	4923	#if EV_IDLE_ENABLE
4551	void	4924	void
4552	ev_idle_start (EV_P_ ev_idle *w) EV_THROW	4925	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4553	{	4926	{
4554	if (expect_false (ev_is_active (w)))	4927	if (ecb_expect_false (ev_is_active (w)))
4555	return;	4928	return;
4556		4929
4557	pri_adjust (EV_A_ (W)w);	4930	pri_adjust (EV_A_ (W)w);
4558		4931
4559	EV_FREQUENT_CHECK;	4932	EV_FREQUENT_CHECK;
…		…
4562	int active = ++idlecnt [ABSPRI (w)];	4935	int active = ++idlecnt [ABSPRI (w)];
4563		4936
4564	++idleall;	4937	++idleall;
4565	ev_start (EV_A_ (W)w, active);	4938	ev_start (EV_A_ (W)w, active);
4566		4939
4567	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);	4940	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, array_needsize_noinit);
4568	idles [ABSPRI (w)][active - 1] = w;	4941	idles [ABSPRI (w)][active - 1] = w;
4569	}	4942	}
4570		4943
4571	EV_FREQUENT_CHECK;	4944	EV_FREQUENT_CHECK;
4572	}	4945	}
4573		4946
4574	void	4947	void
4575	ev_idle_stop (EV_P_ ev_idle *w) EV_THROW	4948	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4576	{	4949	{
4577	clear_pending (EV_A_ (W)w);	4950	clear_pending (EV_A_ (W)w);
4578	if (expect_false (!ev_is_active (w)))	4951	if (ecb_expect_false (!ev_is_active (w)))
4579	return;	4952	return;
4580		4953
4581	EV_FREQUENT_CHECK;	4954	EV_FREQUENT_CHECK;
4582		4955
4583	{	4956	{
…		…
4594	}	4967	}
4595	#endif	4968	#endif
4596		4969
4597	#if EV_PREPARE_ENABLE	4970	#if EV_PREPARE_ENABLE
4598	void	4971	void
4599	ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW	4972	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4600	{	4973	{
4601	if (expect_false (ev_is_active (w)))	4974	if (ecb_expect_false (ev_is_active (w)))
4602	return;	4975	return;
4603		4976
4604	EV_FREQUENT_CHECK;	4977	EV_FREQUENT_CHECK;
4605		4978
4606	ev_start (EV_A_ (W)w, ++preparecnt);	4979	ev_start (EV_A_ (W)w, ++preparecnt);
4607	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);	4980	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, array_needsize_noinit);
4608	prepares [preparecnt - 1] = w;	4981	prepares [preparecnt - 1] = w;
4609		4982
4610	EV_FREQUENT_CHECK;	4983	EV_FREQUENT_CHECK;
4611	}	4984	}
4612		4985
4613	void	4986	void
4614	ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW	4987	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4615	{	4988	{
4616	clear_pending (EV_A_ (W)w);	4989	clear_pending (EV_A_ (W)w);
4617	if (expect_false (!ev_is_active (w)))	4990	if (ecb_expect_false (!ev_is_active (w)))
4618	return;	4991	return;
4619		4992
4620	EV_FREQUENT_CHECK;	4993	EV_FREQUENT_CHECK;
4621		4994
4622	{	4995	{
…		…
4632	}	5005	}
4633	#endif	5006	#endif
4634		5007
4635	#if EV_CHECK_ENABLE	5008	#if EV_CHECK_ENABLE
4636	void	5009	void
4637	ev_check_start (EV_P_ ev_check *w) EV_THROW	5010	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4638	{	5011	{
4639	if (expect_false (ev_is_active (w)))	5012	if (ecb_expect_false (ev_is_active (w)))
4640	return;	5013	return;
4641		5014
4642	EV_FREQUENT_CHECK;	5015	EV_FREQUENT_CHECK;
4643		5016
4644	ev_start (EV_A_ (W)w, ++checkcnt);	5017	ev_start (EV_A_ (W)w, ++checkcnt);
4645	array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);	5018	array_needsize (ev_check *, checks, checkmax, checkcnt, array_needsize_noinit);
4646	checks [checkcnt - 1] = w;	5019	checks [checkcnt - 1] = w;
4647		5020
4648	EV_FREQUENT_CHECK;	5021	EV_FREQUENT_CHECK;
4649	}	5022	}
4650		5023
4651	void	5024	void
4652	ev_check_stop (EV_P_ ev_check *w) EV_THROW	5025	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4653	{	5026	{
4654	clear_pending (EV_A_ (W)w);	5027	clear_pending (EV_A_ (W)w);
4655	if (expect_false (!ev_is_active (w)))	5028	if (ecb_expect_false (!ev_is_active (w)))
4656	return;	5029	return;
4657		5030
4658	EV_FREQUENT_CHECK;	5031	EV_FREQUENT_CHECK;
4659		5032
4660	{	5033	{
…		…
4669	EV_FREQUENT_CHECK;	5042	EV_FREQUENT_CHECK;
4670	}	5043	}
4671	#endif	5044	#endif
4672		5045
4673	#if EV_EMBED_ENABLE	5046	#if EV_EMBED_ENABLE
4674	void noinline	5047	ecb_noinline
		5048	void
4675	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW	5049	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4676	{	5050	{
4677	ev_run (w->other, EVRUN_NOWAIT);	5051	ev_run (w->other, EVRUN_NOWAIT);
4678	}	5052	}
4679		5053
4680	static void	5054	static void
…		…
4702	ev_run (EV_A_ EVRUN_NOWAIT);	5076	ev_run (EV_A_ EVRUN_NOWAIT);
4703	}	5077	}
4704	}	5078	}
4705	}	5079	}
4706		5080
		5081	#if EV_FORK_ENABLE
4707	static void	5082	static void
4708	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)	5083	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4709	{	5084	{
4710	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));	5085	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
4711		5086
…		…
4718	ev_run (EV_A_ EVRUN_NOWAIT);	5093	ev_run (EV_A_ EVRUN_NOWAIT);
4719	}	5094	}
4720		5095
4721	ev_embed_start (EV_A_ w);	5096	ev_embed_start (EV_A_ w);
4722	}	5097	}
		5098	#endif
4723		5099
4724	#if 0	5100	#if 0
4725	static void	5101	static void
4726	embed_idle_cb (EV_P_ ev_idle *idle, int revents)	5102	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4727	{	5103	{
4728	ev_idle_stop (EV_A_ idle);	5104	ev_idle_stop (EV_A_ idle);
4729	}	5105	}
4730	#endif	5106	#endif
4731		5107
4732	void	5108	void
4733	ev_embed_start (EV_P_ ev_embed *w) EV_THROW	5109	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4734	{	5110	{
4735	if (expect_false (ev_is_active (w)))	5111	if (ecb_expect_false (ev_is_active (w)))
4736	return;	5112	return;
4737		5113
4738	{	5114	{
4739	EV_P = w->other;	5115	EV_P = w->other;
4740	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));	5116	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
…		…
4748		5124
4749	ev_prepare_init (&w->prepare, embed_prepare_cb);	5125	ev_prepare_init (&w->prepare, embed_prepare_cb);
4750	ev_set_priority (&w->prepare, EV_MINPRI);	5126	ev_set_priority (&w->prepare, EV_MINPRI);
4751	ev_prepare_start (EV_A_ &w->prepare);	5127	ev_prepare_start (EV_A_ &w->prepare);
4752		5128
		5129	#if EV_FORK_ENABLE
4753	ev_fork_init (&w->fork, embed_fork_cb);	5130	ev_fork_init (&w->fork, embed_fork_cb);
4754	ev_fork_start (EV_A_ &w->fork);	5131	ev_fork_start (EV_A_ &w->fork);
		5132	#endif
4755		5133
4756	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/	5134	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4757		5135
4758	ev_start (EV_A_ (W)w, 1);	5136	ev_start (EV_A_ (W)w, 1);
4759		5137
4760	EV_FREQUENT_CHECK;	5138	EV_FREQUENT_CHECK;
4761	}	5139	}
4762		5140
4763	void	5141	void
4764	ev_embed_stop (EV_P_ ev_embed *w) EV_THROW	5142	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4765	{	5143	{
4766	clear_pending (EV_A_ (W)w);	5144	clear_pending (EV_A_ (W)w);
4767	if (expect_false (!ev_is_active (w)))	5145	if (ecb_expect_false (!ev_is_active (w)))
4768	return;	5146	return;
4769		5147
4770	EV_FREQUENT_CHECK;	5148	EV_FREQUENT_CHECK;
4771		5149
4772	ev_io_stop (EV_A_ &w->io);	5150	ev_io_stop (EV_A_ &w->io);
4773	ev_prepare_stop (EV_A_ &w->prepare);	5151	ev_prepare_stop (EV_A_ &w->prepare);
		5152	#if EV_FORK_ENABLE
4774	ev_fork_stop (EV_A_ &w->fork);	5153	ev_fork_stop (EV_A_ &w->fork);
		5154	#endif
4775		5155
4776	ev_stop (EV_A_ (W)w);	5156	ev_stop (EV_A_ (W)w);
4777		5157
4778	EV_FREQUENT_CHECK;	5158	EV_FREQUENT_CHECK;
4779	}	5159	}
4780	#endif	5160	#endif
4781		5161
4782	#if EV_FORK_ENABLE	5162	#if EV_FORK_ENABLE
4783	void	5163	void
4784	ev_fork_start (EV_P_ ev_fork *w) EV_THROW	5164	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4785	{	5165	{
4786	if (expect_false (ev_is_active (w)))	5166	if (ecb_expect_false (ev_is_active (w)))
4787	return;	5167	return;
4788		5168
4789	EV_FREQUENT_CHECK;	5169	EV_FREQUENT_CHECK;
4790		5170
4791	ev_start (EV_A_ (W)w, ++forkcnt);	5171	ev_start (EV_A_ (W)w, ++forkcnt);
4792	array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);	5172	array_needsize (ev_fork *, forks, forkmax, forkcnt, array_needsize_noinit);
4793	forks [forkcnt - 1] = w;	5173	forks [forkcnt - 1] = w;
4794		5174
4795	EV_FREQUENT_CHECK;	5175	EV_FREQUENT_CHECK;
4796	}	5176	}
4797		5177
4798	void	5178	void
4799	ev_fork_stop (EV_P_ ev_fork *w) EV_THROW	5179	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4800	{	5180	{
4801	clear_pending (EV_A_ (W)w);	5181	clear_pending (EV_A_ (W)w);
4802	if (expect_false (!ev_is_active (w)))	5182	if (ecb_expect_false (!ev_is_active (w)))
4803	return;	5183	return;
4804		5184
4805	EV_FREQUENT_CHECK;	5185	EV_FREQUENT_CHECK;
4806		5186
4807	{	5187	{
…		…
4817	}	5197	}
4818	#endif	5198	#endif
4819		5199
4820	#if EV_CLEANUP_ENABLE	5200	#if EV_CLEANUP_ENABLE
4821	void	5201	void
4822	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW	5202	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4823	{	5203	{
4824	if (expect_false (ev_is_active (w)))	5204	if (ecb_expect_false (ev_is_active (w)))
4825	return;	5205	return;
4826		5206
4827	EV_FREQUENT_CHECK;	5207	EV_FREQUENT_CHECK;
4828		5208
4829	ev_start (EV_A_ (W)w, ++cleanupcnt);	5209	ev_start (EV_A_ (W)w, ++cleanupcnt);
4830	array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2);	5210	array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, array_needsize_noinit);
4831	cleanups [cleanupcnt - 1] = w;	5211	cleanups [cleanupcnt - 1] = w;
4832		5212
4833	/* cleanup watchers should never keep a refcount on the loop */	5213	/* cleanup watchers should never keep a refcount on the loop */
4834	ev_unref (EV_A);	5214	ev_unref (EV_A);
4835	EV_FREQUENT_CHECK;	5215	EV_FREQUENT_CHECK;
4836	}	5216	}
4837		5217
4838	void	5218	void
4839	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW	5219	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4840	{	5220	{
4841	clear_pending (EV_A_ (W)w);	5221	clear_pending (EV_A_ (W)w);
4842	if (expect_false (!ev_is_active (w)))	5222	if (ecb_expect_false (!ev_is_active (w)))
4843	return;	5223	return;
4844		5224
4845	EV_FREQUENT_CHECK;	5225	EV_FREQUENT_CHECK;
4846	ev_ref (EV_A);	5226	ev_ref (EV_A);
4847		5227
…		…
4858	}	5238	}
4859	#endif	5239	#endif
4860		5240
4861	#if EV_ASYNC_ENABLE	5241	#if EV_ASYNC_ENABLE
4862	void	5242	void
4863	ev_async_start (EV_P_ ev_async *w) EV_THROW	5243	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4864	{	5244	{
4865	if (expect_false (ev_is_active (w)))	5245	if (ecb_expect_false (ev_is_active (w)))
4866	return;	5246	return;
4867		5247
4868	w->sent = 0;	5248	w->sent = 0;
4869		5249
4870	evpipe_init (EV_A);	5250	evpipe_init (EV_A);
4871		5251
4872	EV_FREQUENT_CHECK;	5252	EV_FREQUENT_CHECK;
4873		5253
4874	ev_start (EV_A_ (W)w, ++asynccnt);	5254	ev_start (EV_A_ (W)w, ++asynccnt);
4875	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);	5255	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, array_needsize_noinit);
4876	asyncs [asynccnt - 1] = w;	5256	asyncs [asynccnt - 1] = w;
4877		5257
4878	EV_FREQUENT_CHECK;	5258	EV_FREQUENT_CHECK;
4879	}	5259	}
4880		5260
4881	void	5261	void
4882	ev_async_stop (EV_P_ ev_async *w) EV_THROW	5262	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4883	{	5263	{
4884	clear_pending (EV_A_ (W)w);	5264	clear_pending (EV_A_ (W)w);
4885	if (expect_false (!ev_is_active (w)))	5265	if (ecb_expect_false (!ev_is_active (w)))
4886	return;	5266	return;
4887		5267
4888	EV_FREQUENT_CHECK;	5268	EV_FREQUENT_CHECK;
4889		5269
4890	{	5270	{
…		…
4898		5278
4899	EV_FREQUENT_CHECK;	5279	EV_FREQUENT_CHECK;
4900	}	5280	}
4901		5281
4902	void	5282	void
4903	ev_async_send (EV_P_ ev_async *w) EV_THROW	5283	ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT
4904	{	5284	{
4905	w->sent = 1;	5285	w->sent = 1;
4906	evpipe_write (EV_A_ &async_pending);	5286	evpipe_write (EV_A_ &async_pending);
4907	}	5287	}
4908	#endif	5288	#endif
…		…
4945		5325
4946	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));	5326	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4947	}	5327	}
4948		5328
4949	void	5329	void
4950	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW	5330	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT
4951	{	5331	{
4952	struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));	5332	struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
4953
4954	if (expect_false (!once))
4955	{
4956	cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMER, arg);
4957	return;
4958	}
4959		5333
4960	once->cb = cb;	5334	once->cb = cb;
4961	once->arg = arg;	5335	once->arg = arg;
4962		5336
4963	ev_init (&once->io, once_cb_io);	5337	ev_init (&once->io, once_cb_io);
…		…
4976	}	5350	}
4977		5351
4978	/*****************************************************************************/	5352	/*****************************************************************************/
4979		5353
4980	#if EV_WALK_ENABLE	5354	#if EV_WALK_ENABLE
4981	void ecb_cold	5355	ecb_cold
		5356	void
4982	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW	5357	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT
4983	{	5358	{
4984	int i, j;	5359	int i, j;
4985	ev_watcher_list *wl, *wn;	5360	ev_watcher_list *wl, *wn;
4986		5361
4987	if (types & (EV_IO | EV_EMBED))	5362	if (types & (EV_IO | EV_EMBED))

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines