ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.490 by root, Thu Jun 20 22:44:59 2019 UTC vs.
Revision 1.522 by root, Tue Dec 31 06:02:28 2019 UTC

…		…
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
		190	# endif
		191
165	#endif	192	#endif
166		193
167	/* OS X, in its infinite idiocy, actually HARDCODES	194	/* OS X, in its infinite idiocy, actually HARDCODES
168	* a limit of 1024 into their select. Where people have brains,	195	* a limit of 1024 into their select. Where people have brains,
169	* OS X engineers apparently have a vacuum. Or maybe they were	196	* OS X engineers apparently have a vacuum. Or maybe they were
…		…
316	#ifndef EV_USE_PORT	343	#ifndef EV_USE_PORT
317	# define EV_USE_PORT 0	344	# define EV_USE_PORT 0
318	#endif	345	#endif
319		346
320	#ifndef EV_USE_LINUXAIO	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
321	# define EV_USE_LINUXAIO 0	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
322	#endif	361	#endif
323		362
324	#ifndef EV_USE_INOTIFY	363	#ifndef EV_USE_INOTIFY
325	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))	364	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
326	# define EV_USE_INOTIFY EV_FEATURE_OS	365	# define EV_USE_INOTIFY EV_FEATURE_OS
…		…
348	#ifndef EV_USE_SIGNALFD	387	#ifndef EV_USE_SIGNALFD
349	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))	388	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
350	# define EV_USE_SIGNALFD EV_FEATURE_OS	389	# define EV_USE_SIGNALFD EV_FEATURE_OS
351	# else	390	# else
352	# define EV_USE_SIGNALFD 0	391	# define EV_USE_SIGNALFD 0
		392	# endif
		393	#endif
		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
353	# endif	400	# endif
354	#endif	401	#endif
355		402
356	#if 0 /* debugging */	403	#if 0 /* debugging */
357	# define EV_VERIFY 3	404	# define EV_VERIFY 3
…		…
383	/* aix's poll.h seems to cause lots of trouble */	430	/* aix's poll.h seems to cause lots of trouble */
384	#ifdef _AIX	431	#ifdef _AIX
385	/* AIX has a completely broken poll.h header */	432	/* AIX has a completely broken poll.h header */
386	# undef EV_USE_POLL	433	# undef EV_USE_POLL
387	# define EV_USE_POLL 0	434	# define EV_USE_POLL 0
388	#endif
389
390	#if EV_USE_LINUXAIO
391	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
392	#endif	435	#endif
393		436
394	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */	437	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
395	/* which makes programs even slower. might work on other unices, too. */	438	/* which makes programs even slower. might work on other unices, too. */
396	#if EV_USE_CLOCK_SYSCALL	439	#if EV_USE_CLOCK_SYSCALL
397	# include <sys/syscall.h>	440	# include <sys/syscall.h>
398	# ifdef SYS_clock_gettime	441	# ifdef SYS_clock_gettime
399	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))	442	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
400	# undef EV_USE_MONOTONIC	443	# undef EV_USE_MONOTONIC
401	# define EV_USE_MONOTONIC 1	444	# define EV_USE_MONOTONIC 1
		445	# define EV_NEED_SYSCALL 1
402	# else	446	# else
403	# undef EV_USE_CLOCK_SYSCALL	447	# undef EV_USE_CLOCK_SYSCALL
404	# define EV_USE_CLOCK_SYSCALL 0	448	# define EV_USE_CLOCK_SYSCALL 0
405	# endif	449	# endif
406	#endif	450	#endif
…		…
420	#if !EV_STAT_ENABLE	464	#if !EV_STAT_ENABLE
421	# undef EV_USE_INOTIFY	465	# undef EV_USE_INOTIFY
422	# define EV_USE_INOTIFY 0	466	# define EV_USE_INOTIFY 0
423	#endif	467	#endif
424		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
425	#if !EV_USE_NANOSLEEP	477	#if !EV_USE_NANOSLEEP
426	/* 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 */
427	# if !defined _WIN32 && !defined __hpux	479	# if !defined _WIN32 && !defined __hpux
428	# 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
429	# endif	506	# endif
430	#endif	507	#endif
431		508
432	#if EV_USE_INOTIFY	509	#if EV_USE_INOTIFY
433	# include <sys/statfs.h>	510	# include <sys/statfs.h>
…		…
438	# define EV_USE_INOTIFY 0	515	# define EV_USE_INOTIFY 0
439	# endif	516	# endif
440	#endif	517	#endif
441		518
442	#if EV_USE_EVENTFD	519	#if EV_USE_EVENTFD
443	/* 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 */
444	# include <stdint.h>	521	# include <stdint.h>
445	# ifndef EFD_NONBLOCK	522	# ifndef EFD_NONBLOCK
446	# define EFD_NONBLOCK O_NONBLOCK	523	# define EFD_NONBLOCK O_NONBLOCK
447	# endif	524	# endif
448	# ifndef EFD_CLOEXEC	525	# ifndef EFD_CLOEXEC
…		…
454	# endif	531	# endif
455	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);	532	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
456	#endif	533	#endif
457		534
458	#if EV_USE_SIGNALFD	535	#if EV_USE_SIGNALFD
459	/* 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 */
460	# include <stdint.h>	537	# include <stdint.h>
461	# ifndef SFD_NONBLOCK	538	# ifndef SFD_NONBLOCK
462	# define SFD_NONBLOCK O_NONBLOCK	539	# define SFD_NONBLOCK O_NONBLOCK
463	# endif	540	# endif
464	# ifndef SFD_CLOEXEC	541	# ifndef SFD_CLOEXEC
…		…
466	# define SFD_CLOEXEC O_CLOEXEC	543	# define SFD_CLOEXEC O_CLOEXEC
467	# else	544	# else
468	# define SFD_CLOEXEC 02000000	545	# define SFD_CLOEXEC 02000000
469	# endif	546	# endif
470	# endif	547	# endif
471	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);
472		549
473	struct signalfd_siginfo	550	struct signalfd_siginfo
474	{	551	{
475	uint32_t ssi_signo;	552	uint32_t ssi_signo;
476	char pad[128 - sizeof (uint32_t)];	553	char pad[128 - sizeof (uint32_t)];
477	};	554	};
478	#endif	555	#endif
479		556
480	/**/	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	/*****************************************************************************/
481		568
482	#if EV_VERIFY >= 3	569	#if EV_VERIFY >= 3
483	# define EV_FREQUENT_CHECK ev_verify (EV_A)	570	# define EV_FREQUENT_CHECK ev_verify (EV_A)
484	#else	571	#else
485	# define EV_FREQUENT_CHECK do { } while (0)	572	# define EV_FREQUENT_CHECK do { } while (0)
…		…
490	* This value is good at least till the year 4000.	577	* This value is good at least till the year 4000.
491	*/	578	*/
492	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */	579	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
493	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */	580	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
494		581
495	#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) */
496	#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) */
497		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
498	#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)
499	#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
500		602
501	/* 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 */
502	/* ECB.H BEGIN */	604	/* ECB.H BEGIN */
503	/*	605	/*
504	* libecb - http://software.schmorp.de/pkg/libecb	606	* libecb - http://software.schmorp.de/pkg/libecb
…		…
542		644
543	#ifndef ECB_H	645	#ifndef ECB_H
544	#define ECB_H	646	#define ECB_H
545		647
546	/* 16 bits major, 16 bits minor */	648	/* 16 bits major, 16 bits minor */
547	#define ECB_VERSION 0x00010005	649	#define ECB_VERSION 0x00010006
548		650
549	#ifdef _WIN32	651	#ifdef _WIN32
550	typedef signed char int8_t;	652	typedef signed char int8_t;
551	typedef unsigned char uint8_t;	653	typedef unsigned char uint8_t;
552	typedef signed short int16_t;	654	typedef signed short int16_t;
…		…
666	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */	768	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
667	#endif	769	#endif
668		770
669	#ifndef ECB_MEMORY_FENCE	771	#ifndef ECB_MEMORY_FENCE
670	#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")
671	#if __i386 || __i386__	774	#if __i386 || __i386__
672	#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")
673	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")	776	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
674	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")	777	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
675	#elif ECB_GCC_AMD64	778	#elif ECB_GCC_AMD64
…		…
725	#if ECB_GCC_VERSION(4,7)	828	#if ECB_GCC_VERSION(4,7)
726	/* see comment below (stdatomic.h) about the C11 memory model. */	829	/* see comment below (stdatomic.h) about the C11 memory model. */
727	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)	830	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
728	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)	831	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
729	#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)
730		834
731	#elif ECB_CLANG_EXTENSION(c_atomic)	835	#elif ECB_CLANG_EXTENSION(c_atomic)
732	/* see comment below (stdatomic.h) about the C11 memory model. */	836	/* see comment below (stdatomic.h) about the C11 memory model. */
733	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)	837	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
734	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)	838	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
735	#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)
736		841
737	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__	842	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
738	#define ECB_MEMORY_FENCE __sync_synchronize ()	843	#define ECB_MEMORY_FENCE __sync_synchronize ()
739	#elif _MSC_VER >= 1500 /* VC++ 2008 */	844	#elif _MSC_VER >= 1500 /* VC++ 2008 */
740	/* 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... */
…		…
750	#elif defined _WIN32	855	#elif defined _WIN32
751	#include <WinNT.h>	856	#include <WinNT.h>
752	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */	857	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
753	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	858	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
754	#include <mbarrier.h>	859	#include <mbarrier.h>
755	#define ECB_MEMORY_FENCE __machine_rw_barrier ()	860	#define ECB_MEMORY_FENCE __machine_rw_barrier ()
756	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()	861	#define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
757	#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 ()
758	#elif __xlC__	864	#elif __xlC__
759	#define ECB_MEMORY_FENCE __sync ()	865	#define ECB_MEMORY_FENCE __sync ()
760	#endif	866	#endif
761	#endif	867	#endif
762		868
763	#ifndef ECB_MEMORY_FENCE	869	#ifndef ECB_MEMORY_FENCE
764	#if ECB_C11 && !defined __STDC_NO_ATOMICS__	870	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
765	/* 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, */
766	/* not just C11 atomics and atomic accesses */	872	/* not just C11 atomics and atomic accesses */
767	#include <stdatomic.h>	873	#include <stdatomic.h>
768	/* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
769	/* any fence other than seq_cst, which isn't very efficient for us. */
770	/* Why that is, we don't know - either the C11 memory model is quite useless */
771	/* for most usages, or gcc and clang have a bug */
772	/* I *currently* lean towards the latter, and inefficiently implement */
773	/* all three of ecb's fences as a seq_cst fence */
774	/* Update, gcc-4.8 generates mfence for all c++ fences, but nothing */
775	/* for all __atomic_thread_fence's except seq_cst */
776	#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)
777	#endif	877	#endif
778	#endif	878	#endif
779		879
780	#ifndef ECB_MEMORY_FENCE	880	#ifndef ECB_MEMORY_FENCE
781	#if !ECB_AVOID_PTHREADS	881	#if !ECB_AVOID_PTHREADS
…		…
799	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	899	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
800	#endif	900	#endif
801		901
802	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE	902	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
803	#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 */
804	#endif	908	#endif
805		909
806	/*****************************************************************************/	910	/*****************************************************************************/
807		911
808	#if ECB_CPP	912	#if ECB_CPP
…		…
1517	/* ECB.H END */	1621	/* ECB.H END */
1518		1622
1519	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1623	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1520	/* 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
1521	* 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
1522	* 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
1523	* libev, in which cases the memory fences become nops.	1627	* libev, in which cases the memory fences become nops.
1524	* alternatively, you can remove this #error and link against libpthread,	1628	* alternatively, you can remove this #error and link against libpthread,
1525	* which will then provide the memory fences.	1629	* which will then provide the memory fences.
1526	*/	1630	*/
1527	# error "memory fences not defined for your architecture, please report"	1631	# error "memory fences not defined for your architecture, please report"
…		…
1531	# define ECB_MEMORY_FENCE do { } while (0)	1635	# define ECB_MEMORY_FENCE do { } while (0)
1532	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	1636	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1533	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	1637	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1534	#endif	1638	#endif
1535		1639
1536	#define expect_false(cond) ecb_expect_false (cond)
1537	#define expect_true(cond) ecb_expect_true (cond)
1538	#define noinline ecb_noinline
1539
1540	#define inline_size ecb_inline	1640	#define inline_size ecb_inline
1541		1641
1542	#if EV_FEATURE_CODE	1642	#if EV_FEATURE_CODE
1543	# define inline_speed ecb_inline	1643	# define inline_speed ecb_inline
1544	#else	1644	#else
1545	# define inline_speed noinline static	1645	# define inline_speed ecb_noinline static
1546	#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 && !EV_FEATURE_CODE
		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	/*****************************************************************************/
1547		1713
1548	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1714	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1549		1715
1550	#if EV_MINPRI == EV_MAXPRI	1716	#if EV_MINPRI == EV_MAXPRI
1551	# define ABSPRI(w) (((W)w), 0)	1717	# define ABSPRI(w) (((W)w), 0)
…		…
1586	# include "ev_win32.c"	1752	# include "ev_win32.c"
1587	#endif	1753	#endif
1588		1754
1589	/*****************************************************************************/	1755	/*****************************************************************************/
1590		1756
		1757	#if EV_USE_LINUXAIO
		1758	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
		1759	#endif
		1760
1591	/* define a suitable floor function (only used by periodics atm) */	1761	/* define a suitable floor function (only used by periodics atm) */
1592		1762
1593	#if EV_USE_FLOOR	1763	#if EV_USE_FLOOR
1594	# include <math.h>	1764	# include <math.h>
1595	# define ev_floor(v) floor (v)	1765	# define ev_floor(v) floor (v)
1596	#else	1766	#else
1597		1767
1598	#include <float.h>	1768	#include <float.h>
1599		1769
1600	/* a floor() replacement function, should be independent of ev_tstamp type */	1770	/* a floor() replacement function, should be independent of ev_tstamp type */
1601	noinline	1771	ecb_noinline
1602	static ev_tstamp	1772	static ev_tstamp
1603	ev_floor (ev_tstamp v)	1773	ev_floor (ev_tstamp v)
1604	{	1774	{
1605	/* the choice of shift factor is not terribly important */	1775	/* the choice of shift factor is not terribly important */
1606	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1776	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1607	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1777	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1608	#else	1778	#else
1609	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1779	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1610	#endif	1780	#endif
1611		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
1612	/* argument too large for an unsigned long? */	1790	/* argument too large for an unsigned long? then reduce it */
1613	if (expect_false (v >= shift))	1791	if (ecb_expect_false (v >= shift))
1614	{	1792	{
1615	ev_tstamp f;	1793	ev_tstamp f;
1616		1794
1617	if (v == v - 1.)	1795	if (v == v - 1.)
1618	return v; /* very large number */	1796	return v; /* very large numbers are assumed to be integer */
1619		1797
1620	f = shift * ev_floor (v * (1. / shift));	1798	f = shift * ev_floor (v * (1. / shift));
1621	return f + ev_floor (v - f);	1799	return f + ev_floor (v - f);
1622	}	1800	}
1623		1801
1624	/* special treatment for negative args? */
1625	if (expect_false (v < 0.))
1626	{
1627	ev_tstamp f = -ev_floor (-v);
1628
1629	return f - (f == v ? 0 : 1);
1630	}
1631
1632	/* fits into an unsigned long */	1802	/* fits into an unsigned long */
1633	return (unsigned long)v;	1803	return (unsigned long)v;
1634	}	1804	}
1635		1805
1636	#endif	1806	#endif
…		…
1639		1809
1640	#ifdef __linux	1810	#ifdef __linux
1641	# include <sys/utsname.h>	1811	# include <sys/utsname.h>
1642	#endif	1812	#endif
1643		1813
1644	noinline ecb_cold	1814	ecb_noinline ecb_cold
1645	static unsigned int	1815	static unsigned int
1646	ev_linux_version (void)	1816	ev_linux_version (void)
1647	{	1817	{
1648	#ifdef __linux	1818	#ifdef __linux
1649	unsigned int v = 0;	1819	unsigned int v = 0;
…		…
1679	}	1849	}
1680		1850
1681	/*****************************************************************************/	1851	/*****************************************************************************/
1682		1852
1683	#if EV_AVOID_STDIO	1853	#if EV_AVOID_STDIO
1684	noinline ecb_cold	1854	ecb_noinline ecb_cold
1685	static void	1855	static void
1686	ev_printerr (const char *msg)	1856	ev_printerr (const char *msg)
1687	{	1857	{
1688	write (STDERR_FILENO, msg, strlen (msg));	1858	write (STDERR_FILENO, msg, strlen (msg));
1689	}	1859	}
…		…
1696	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT	1866	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
1697	{	1867	{
1698	syserr_cb = cb;	1868	syserr_cb = cb;
1699	}	1869	}
1700		1870
1701	noinline ecb_cold	1871	ecb_noinline ecb_cold
1702	static void	1872	static void
1703	ev_syserr (const char *msg)	1873	ev_syserr (const char *msg)
1704	{	1874	{
1705	if (!msg)	1875	if (!msg)
1706	msg = "(libev) system error";	1876	msg = "(libev) system error";
…		…
1778	{	1948	{
1779	WL head;	1949	WL head;
1780	unsigned char events; /* the events watched for */	1950	unsigned char events; /* the events watched for */
1781	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) */
1782	unsigned char emask; /* some backends store the actual kernel mask in here */	1952	unsigned char emask; /* some backends store the actual kernel mask in here */
1783	unsigned char unused;	1953	unsigned char eflags; /* flags field for use by backends */
1784	#if EV_USE_EPOLL	1954	#if EV_USE_EPOLL
1785	unsigned int egen; /* generation counter to counter epoll bugs */	1955	unsigned int egen; /* generation counter to counter epoll bugs */
1786	#endif	1956	#endif
1787	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	1957	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1788	SOCKET handle;	1958	SOCKET handle;
…		…
1842	static struct ev_loop default_loop_struct;	2012	static struct ev_loop default_loop_struct;
1843	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 */
1844		2014
1845	#else	2015	#else
1846		2016
1847	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 */
1848	#define VAR(name,decl) static decl;	2018	#define VAR(name,decl) static decl;
1849	#include "ev_vars.h"	2019	#include "ev_vars.h"
1850	#undef VAR	2020	#undef VAR
1851		2021
1852	static int ev_default_loop_ptr;	2022	static int ev_default_loop_ptr;
1853		2023
1854	#endif	2024	#endif
1855		2025
1856	#if EV_FEATURE_API	2026	#if EV_FEATURE_API
1857	# 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)
1858	# 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)
1859	# define EV_INVOKE_PENDING invoke_cb (EV_A)	2029	# define EV_INVOKE_PENDING invoke_cb (EV_A)
1860	#else	2030	#else
1861	# define EV_RELEASE_CB (void)0	2031	# define EV_RELEASE_CB (void)0
1862	# define EV_ACQUIRE_CB (void)0	2032	# define EV_ACQUIRE_CB (void)0
1863	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)	2033	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
…		…
1870	#ifndef EV_HAVE_EV_TIME	2040	#ifndef EV_HAVE_EV_TIME
1871	ev_tstamp	2041	ev_tstamp
1872	ev_time (void) EV_NOEXCEPT	2042	ev_time (void) EV_NOEXCEPT
1873	{	2043	{
1874	#if EV_USE_REALTIME	2044	#if EV_USE_REALTIME
1875	if (expect_true (have_realtime))	2045	if (ecb_expect_true (have_realtime))
1876	{	2046	{
1877	struct timespec ts;	2047	struct timespec ts;
1878	clock_gettime (CLOCK_REALTIME, &ts);	2048	clock_gettime (CLOCK_REALTIME, &ts);
1879	return ts.tv_sec + ts.tv_nsec * 1e-9;	2049	return EV_TS_GET (ts);
1880	}	2050	}
1881	#endif	2051	#endif
1882		2052
		2053	{
1883	struct timeval tv;	2054	struct timeval tv;
1884	gettimeofday (&tv, 0);	2055	gettimeofday (&tv, 0);
1885	return tv.tv_sec + tv.tv_usec * 1e-6;	2056	return EV_TV_GET (tv);
		2057	}
1886	}	2058	}
1887	#endif	2059	#endif
1888		2060
1889	inline_size ev_tstamp	2061	inline_size ev_tstamp
1890	get_clock (void)	2062	get_clock (void)
1891	{	2063	{
1892	#if EV_USE_MONOTONIC	2064	#if EV_USE_MONOTONIC
1893	if (expect_true (have_monotonic))	2065	if (ecb_expect_true (have_monotonic))
1894	{	2066	{
1895	struct timespec ts;	2067	struct timespec ts;
1896	clock_gettime (CLOCK_MONOTONIC, &ts);	2068	clock_gettime (CLOCK_MONOTONIC, &ts);
1897	return ts.tv_sec + ts.tv_nsec * 1e-9;	2069	return EV_TS_GET (ts);
1898	}	2070	}
1899	#endif	2071	#endif
1900		2072
1901	return ev_time ();	2073	return ev_time ();
1902	}	2074	}
…		…
1910	#endif	2082	#endif
1911		2083
1912	void	2084	void
1913	ev_sleep (ev_tstamp delay) EV_NOEXCEPT	2085	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1914	{	2086	{
1915	if (delay > 0.)	2087	if (delay > EV_TS_CONST (0.))
1916	{	2088	{
1917	#if EV_USE_NANOSLEEP	2089	#if EV_USE_NANOSLEEP
1918	struct timespec ts;	2090	struct timespec ts;
1919		2091
1920	EV_TS_SET (ts, delay);	2092	EV_TS_SET (ts, delay);
1921	nanosleep (&ts, 0);	2093	nanosleep (&ts, 0);
1922	#elif defined _WIN32	2094	#elif defined _WIN32
1923	/* maybe this should round up, as ms is very low resolution */	2095	/* maybe this should round up, as ms is very low resolution */
1924	/* compared to select (µs) or nanosleep (ns) */	2096	/* compared to select (µs) or nanosleep (ns) */
1925	Sleep ((unsigned long)(delay * 1e3));	2097	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
1926	#else	2098	#else
1927	struct timeval tv;	2099	struct timeval tv;
1928		2100
1929	/* 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 */
1930	/* something not guaranteed by newer posix versions, but guaranteed */	2102	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
1960	}	2132	}
1961		2133
1962	return ncur;	2134	return ncur;
1963	}	2135	}
1964		2136
1965	noinline ecb_cold	2137	ecb_noinline ecb_cold
1966	static void *	2138	static void *
1967	array_realloc (int elem, void *base, int *cur, int cnt)	2139	array_realloc (int elem, void *base, int *cur, int cnt)
1968	{	2140	{
1969	*cur = array_nextsize (elem, *cur, cnt);	2141	*cur = array_nextsize (elem, *cur, cnt);
1970	return ev_realloc (base, elem * *cur);	2142	return ev_realloc (base, elem * *cur);
1971	}	2143	}
1972		2144
1973	#define array_needsize_noinit(base,count)	2145	#define array_needsize_noinit(base,offset,count)
1974		2146
1975	#define array_needsize_zerofill(base,count) \	2147	#define array_needsize_zerofill(base,offset,count) \
1976	memset ((void *)(base), 0, sizeof (*(base)) * (count))	2148	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
1977		2149
1978	#define array_needsize(type,base,cur,cnt,init) \	2150	#define array_needsize(type,base,cur,cnt,init) \
1979	if (expect_false ((cnt) > (cur))) \	2151	if (ecb_expect_false ((cnt) > (cur))) \
1980	{ \	2152	{ \
1981	ecb_unused int ocur_ = (cur); \	2153	ecb_unused int ocur_ = (cur); \
1982	(base) = (type *)array_realloc \	2154	(base) = (type *)array_realloc \
1983	(sizeof (type), (base), &(cur), (cnt)); \	2155	(sizeof (type), (base), &(cur), (cnt)); \
1984	init ((base) + (ocur_), (cur) - ocur_); \	2156	init ((base), ocur_, ((cur) - ocur_)); \
1985	}	2157	}
1986		2158
1987	#if 0	2159	#if 0
1988	#define array_slim(type,stem) \	2160	#define array_slim(type,stem) \
1989	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \	2161	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
…		…
1998	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
1999		2171
2000	/*****************************************************************************/	2172	/*****************************************************************************/
2001		2173
2002	/* dummy callback for pending events */	2174	/* dummy callback for pending events */
2003	noinline	2175	ecb_noinline
2004	static void	2176	static void
2005	pendingcb (EV_P_ ev_prepare *w, int revents)	2177	pendingcb (EV_P_ ev_prepare *w, int revents)
2006	{	2178	{
2007	}	2179	}
2008		2180
2009	noinline	2181	ecb_noinline
2010	void	2182	void
2011	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT	2183	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
2012	{	2184	{
2013	W w_ = (W)w;	2185	W w_ = (W)w;
2014	int pri = ABSPRI (w_);	2186	int pri = ABSPRI (w_);
2015		2187
2016	if (expect_false (w_->pending))	2188	if (ecb_expect_false (w_->pending))
2017	pendings [pri][w_->pending - 1].events |= revents;	2189	pendings [pri][w_->pending - 1].events |= revents;
2018	else	2190	else
2019	{	2191	{
2020	w_->pending = ++pendingcnt [pri];	2192	w_->pending = ++pendingcnt [pri];
2021	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);	2193	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);
…		…
2072	inline_speed void	2244	inline_speed void
2073	fd_event (EV_P_ int fd, int revents)	2245	fd_event (EV_P_ int fd, int revents)
2074	{	2246	{
2075	ANFD *anfd = anfds + fd;	2247	ANFD *anfd = anfds + fd;
2076		2248
2077	if (expect_true (!anfd->reify))	2249	if (ecb_expect_true (!anfd->reify))
2078	fd_event_nocheck (EV_A_ fd, revents);	2250	fd_event_nocheck (EV_A_ fd, revents);
2079	}	2251	}
2080		2252
2081	void	2253	void
2082	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT	2254	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
…		…
2090	inline_size void	2262	inline_size void
2091	fd_reify (EV_P)	2263	fd_reify (EV_P)
2092	{	2264	{
2093	int i;	2265	int i;
2094		2266
		2267	/* most backends do not modify the fdchanges list in backend_modfiy.
		2268	* except io_uring, which has fixed-size buffers which might force us
		2269	* to handle events in backend_modify, causing fdchangesd to be amended,
		2270	* which could result in an endless loop.
		2271	* to avoid this, we do not dynamically handle fds that were added
		2272	* during fd_reify. that menas thast for those backends, fdchangecnt
		2273	* might be non-zero during poll, which must cause them to not block.
		2274	* to not put too much of a burden on other backends, this detail
		2275	* needs to be handled in the backend.
		2276	*/
		2277	int changecnt = fdchangecnt;
		2278
2095	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	2279	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
2096	for (i = 0; i < fdchangecnt; ++i)	2280	for (i = 0; i < changecnt; ++i)
2097	{	2281	{
2098	int fd = fdchanges [i];	2282	int fd = fdchanges [i];
2099	ANFD *anfd = anfds + fd;	2283	ANFD *anfd = anfds + fd;
2100		2284
2101	if (anfd->reify & EV__IOFDSET && anfd->head)	2285	if (anfd->reify & EV__IOFDSET && anfd->head)
…		…
2115	}	2299	}
2116	}	2300	}
2117	}	2301	}
2118	#endif	2302	#endif
2119		2303
2120	for (i = 0; i < fdchangecnt; ++i)	2304	for (i = 0; i < changecnt; ++i)
2121	{	2305	{
2122	int fd = fdchanges [i];	2306	int fd = fdchanges [i];
2123	ANFD *anfd = anfds + fd;	2307	ANFD *anfd = anfds + fd;
2124	ev_io *w;	2308	ev_io *w;
2125		2309
2126	unsigned char o_events = anfd->events;	2310	unsigned char o_events = anfd->events;
2127	unsigned char o_reify = anfd->reify;	2311	unsigned char o_reify = anfd->reify;
2128		2312
2129	anfd->reify = 0;	2313	anfd->reify = 0;
2130		2314
2131	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2315	/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
2132	{	2316	{
2133	anfd->events = 0;	2317	anfd->events = 0;
2134		2318
2135	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)	2319	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
2136	anfd->events |= (unsigned char)w->events;	2320	anfd->events |= (unsigned char)w->events;
…		…
2141		2325
2142	if (o_reify & EV__IOFDSET)	2326	if (o_reify & EV__IOFDSET)
2143	backend_modify (EV_A_ fd, o_events, anfd->events);	2327	backend_modify (EV_A_ fd, o_events, anfd->events);
2144	}	2328	}
2145		2329
		2330	/* normally, fdchangecnt hasn't changed. if it has, then new fds have been added.
		2331	* this is a rare case (see beginning comment in this function), so we copy them to the
		2332	* front and hope the backend handles this case.
		2333	*/
		2334	if (ecb_expect_false (fdchangecnt != changecnt))
		2335	memmove (fdchanges, fdchanges + changecnt, (fdchangecnt - changecnt) * sizeof (*fdchanges));
		2336
2146	fdchangecnt = 0;	2337	fdchangecnt -= changecnt;
2147	}	2338	}
2148		2339
2149	/* something about the given fd changed */	2340	/* something about the given fd changed */
2150	inline_size	2341	inline_size
2151	void	2342	void
2152	fd_change (EV_P_ int fd, int flags)	2343	fd_change (EV_P_ int fd, int flags)
2153	{	2344	{
2154	unsigned char reify = anfds [fd].reify;	2345	unsigned char reify = anfds [fd].reify;
2155	anfds [fd].reify |= flags;	2346	anfds [fd].reify |= flags;
2156		2347
2157	if (expect_true (!reify))	2348	if (ecb_expect_true (!reify))
2158	{	2349	{
2159	++fdchangecnt;	2350	++fdchangecnt;
2160	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);	2351	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
2161	fdchanges [fdchangecnt - 1] = fd;	2352	fdchanges [fdchangecnt - 1] = fd;
2162	}	2353	}
…		…
2185	return fcntl (fd, F_GETFD) != -1;	2376	return fcntl (fd, F_GETFD) != -1;
2186	#endif	2377	#endif
2187	}	2378	}
2188		2379
2189	/* called on EBADF to verify fds */	2380	/* called on EBADF to verify fds */
2190	noinline ecb_cold	2381	ecb_noinline ecb_cold
2191	static void	2382	static void
2192	fd_ebadf (EV_P)	2383	fd_ebadf (EV_P)
2193	{	2384	{
2194	int fd;	2385	int fd;
2195		2386
…		…
2198	if (!fd_valid (fd) && errno == EBADF)	2389	if (!fd_valid (fd) && errno == EBADF)
2199	fd_kill (EV_A_ fd);	2390	fd_kill (EV_A_ fd);
2200	}	2391	}
2201		2392
2202	/* called on ENOMEM in select/poll to kill some fds and retry */	2393	/* called on ENOMEM in select/poll to kill some fds and retry */
2203	noinline ecb_cold	2394	ecb_noinline ecb_cold
2204	static void	2395	static void
2205	fd_enomem (EV_P)	2396	fd_enomem (EV_P)
2206	{	2397	{
2207	int fd;	2398	int fd;
2208		2399
…		…
2213	break;	2404	break;
2214	}	2405	}
2215	}	2406	}
2216		2407
2217	/* usually called after fork if backend needs to re-arm all fds from scratch */	2408	/* usually called after fork if backend needs to re-arm all fds from scratch */
2218	noinline	2409	ecb_noinline
2219	static void	2410	static void
2220	fd_rearm_all (EV_P)	2411	fd_rearm_all (EV_P)
2221	{	2412	{
2222	int fd;	2413	int fd;
2223		2414
…		…
2277	ev_tstamp minat;	2468	ev_tstamp minat;
2278	ANHE *minpos;	2469	ANHE *minpos;
2279	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;	2470	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
2280		2471
2281	/* find minimum child */	2472	/* find minimum child */
2282	if (expect_true (pos + DHEAP - 1 < E))	2473	if (ecb_expect_true (pos + DHEAP - 1 < E))
2283	{	2474	{
2284	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2475	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2285	if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2476	if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2286	if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2477	if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2287	if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2478	if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2288	}	2479	}
2289	else if (pos < E)	2480	else if (pos < E)
2290	{	2481	{
2291	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2482	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2292	if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2483	if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2293	if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2484	if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2294	if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2485	if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2295	}	2486	}
2296	else	2487	else
2297	break;	2488	break;
2298		2489
2299	if (ANHE_at (he) <= minat)	2490	if (ANHE_at (he) <= minat)
…		…
2307		2498
2308	heap [k] = he;	2499	heap [k] = he;
2309	ev_active (ANHE_w (he)) = k;	2500	ev_active (ANHE_w (he)) = k;
2310	}	2501	}
2311		2502
2312	#else /* 4HEAP */	2503	#else /* not 4HEAP */
2313		2504
2314	#define HEAP0 1	2505	#define HEAP0 1
2315	#define HPARENT(k) ((k) >> 1)	2506	#define HPARENT(k) ((k) >> 1)
2316	#define UPHEAP_DONE(p,k) (!(p))	2507	#define UPHEAP_DONE(p,k) (!(p))
2317		2508
…		…
2389	upheap (heap, i + HEAP0);	2580	upheap (heap, i + HEAP0);
2390	}	2581	}
2391		2582
2392	/*****************************************************************************/	2583	/*****************************************************************************/
2393		2584
2394	/* associate signal watchers to a signal signal */	2585	/* associate signal watchers to a signal */
2395	typedef struct	2586	typedef struct
2396	{	2587	{
2397	EV_ATOMIC_T pending;	2588	EV_ATOMIC_T pending;
2398	#if EV_MULTIPLICITY	2589	#if EV_MULTIPLICITY
2399	EV_P;	2590	EV_P;
…		…
2405		2596
2406	/*****************************************************************************/	2597	/*****************************************************************************/
2407		2598
2408	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2599	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2409		2600
2410	noinline ecb_cold	2601	ecb_noinline ecb_cold
2411	static void	2602	static void
2412	evpipe_init (EV_P)	2603	evpipe_init (EV_P)
2413	{	2604	{
2414	if (!ev_is_active (&pipe_w))	2605	if (!ev_is_active (&pipe_w))
2415	{	2606	{
…		…
2456	inline_speed void	2647	inline_speed void
2457	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	2648	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2458	{	2649	{
2459	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */	2650	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
2460		2651
2461	if (expect_true (*flag))	2652	if (ecb_expect_true (*flag))
2462	return;	2653	return;
2463		2654
2464	*flag = 1;	2655	*flag = 1;
2465	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */	2656	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
2466		2657
…		…
2543	sig_pending = 0;	2734	sig_pending = 0;
2544		2735
2545	ECB_MEMORY_FENCE;	2736	ECB_MEMORY_FENCE;
2546		2737
2547	for (i = EV_NSIG - 1; i--; )	2738	for (i = EV_NSIG - 1; i--; )
2548	if (expect_false (signals [i].pending))	2739	if (ecb_expect_false (signals [i].pending))
2549	ev_feed_signal_event (EV_A_ i + 1);	2740	ev_feed_signal_event (EV_A_ i + 1);
2550	}	2741	}
2551	#endif	2742	#endif
2552		2743
2553	#if EV_ASYNC_ENABLE	2744	#if EV_ASYNC_ENABLE
…		…
2594	#endif	2785	#endif
2595		2786
2596	ev_feed_signal (signum);	2787	ev_feed_signal (signum);
2597	}	2788	}
2598		2789
2599	noinline	2790	ecb_noinline
2600	void	2791	void
2601	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT	2792	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2602	{	2793	{
2603	WL w;	2794	WL w;
2604		2795
2605	if (expect_false (signum <= 0 || signum >= EV_NSIG))	2796	if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
2606	return;	2797	return;
2607		2798
2608	--signum;	2799	--signum;
2609		2800
2610	#if EV_MULTIPLICITY	2801	#if EV_MULTIPLICITY
2611	/* it is permissible to try to feed a signal to the wrong loop */	2802	/* it is permissible to try to feed a signal to the wrong loop */
2612	/* or, likely more useful, feeding a signal nobody is waiting for */	2803	/* or, likely more useful, feeding a signal nobody is waiting for */
2613		2804
2614	if (expect_false (signals [signum].loop != EV_A))	2805	if (ecb_expect_false (signals [signum].loop != EV_A))
2615	return;	2806	return;
2616	#endif	2807	#endif
2617		2808
2618	signals [signum].pending = 0;	2809	signals [signum].pending = 0;
2619	ECB_MEMORY_FENCE_RELEASE;	2810	ECB_MEMORY_FENCE_RELEASE;
…		…
2703		2894
2704	#endif	2895	#endif
2705		2896
2706	/*****************************************************************************/	2897	/*****************************************************************************/
2707		2898
		2899	#if EV_USE_TIMERFD
		2900
		2901	static void periodics_reschedule (EV_P);
		2902
		2903	static void
		2904	timerfdcb (EV_P_ ev_io *iow, int revents)
		2905	{
		2906	struct itimerspec its = { 0 };
		2907
		2908	/* since we can't easily come zup with a (portable) maximum value of time_t,
		2909	* we wake up once per month, which hopefully is rare enough to not
		2910	* be a problem. */
		2911	its.it_value.tv_sec = ev_rt_now + 86400 * 30;
		2912	timerfd_settime (timerfd, TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &its, 0);
		2913
		2914	ev_rt_now = ev_time ();
		2915	/* periodics_reschedule only needs ev_rt_now */
		2916	/* but maybe in the future we want the full treatment. */
		2917	/*
		2918	now_floor = EV_TS_CONST (0.);
		2919	time_update (EV_A_ EV_TSTAMP_HUGE);
		2920	*/
		2921	periodics_reschedule (EV_A);
		2922	}
		2923
		2924	ecb_noinline ecb_cold
		2925	static void
		2926	evtimerfd_init (EV_P)
		2927	{
		2928	if (!ev_is_active (&timerfd_w))
		2929	{
		2930	timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
		2931
		2932	if (timerfd >= 0)
		2933	{
		2934	fd_intern (timerfd); /* just to be sure */
		2935
		2936	ev_io_init (&timerfd_w, timerfdcb, timerfd, EV_READ);
		2937	ev_set_priority (&timerfd_w, EV_MINPRI);
		2938	ev_io_start (EV_A_ &timerfd_w);
		2939	ev_unref (EV_A); /* watcher should not keep loop alive */
		2940
		2941	/* (re-) arm timer */
		2942	timerfdcb (EV_A_ 0, 0);
		2943	}
		2944	}
		2945	}
		2946
		2947	#endif
		2948
		2949	/*****************************************************************************/
		2950
2708	#if EV_USE_IOCP	2951	#if EV_USE_IOCP
2709	# include "ev_iocp.c"	2952	# include "ev_iocp.c"
2710	#endif	2953	#endif
2711	#if EV_USE_PORT	2954	#if EV_USE_PORT
2712	# include "ev_port.c"	2955	# include "ev_port.c"
2713	#endif	2956	#endif
2714	#if EV_USE_KQUEUE	2957	#if EV_USE_KQUEUE
2715	# include "ev_kqueue.c"	2958	# include "ev_kqueue.c"
2716	#endif	2959	#endif
		2960	#if EV_USE_EPOLL
		2961	# include "ev_epoll.c"
		2962	#endif
2717	#if EV_USE_LINUXAIO	2963	#if EV_USE_LINUXAIO
2718	# include "ev_linuxaio.c"	2964	# include "ev_linuxaio.c"
2719	#endif	2965	#endif
2720	#if EV_USE_EPOLL	2966	#if EV_USE_IOURING
2721	# include "ev_epoll.c"	2967	# include "ev_iouring.c"
2722	#endif	2968	#endif
2723	#if EV_USE_POLL	2969	#if EV_USE_POLL
2724	# include "ev_poll.c"	2970	# include "ev_poll.c"
2725	#endif	2971	#endif
2726	#if EV_USE_SELECT	2972	#if EV_USE_SELECT
…		…
2755	unsigned int	3001	unsigned int
2756	ev_supported_backends (void) EV_NOEXCEPT	3002	ev_supported_backends (void) EV_NOEXCEPT
2757	{	3003	{
2758	unsigned int flags = 0;	3004	unsigned int flags = 0;
2759		3005
2760	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	3006	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2761	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;	3007	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2762	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	3008	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
2763	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;	3009	if (EV_USE_LINUXAIO ) flags |= EVBACKEND_LINUXAIO;
2764	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	3010	if (EV_USE_IOURING && ev_linux_version () >= 0x050601) flags |= EVBACKEND_IOURING; /* 5.6.1+ */
2765	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;	3011	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2766		3012	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
		3013
2767	return flags;	3014	return flags;
2768	}	3015	}
2769		3016
2770	ecb_cold	3017	ecb_cold
2771	unsigned int	3018	unsigned int
…		…
2785	#endif	3032	#endif
2786	#ifdef __FreeBSD__	3033	#ifdef __FreeBSD__
2787	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */	3034	flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
2788	#endif	3035	#endif
2789		3036
		3037	/* TODO: linuxaio is very experimental */
		3038	#if !EV_RECOMMEND_LINUXAIO
		3039	flags &= ~EVBACKEND_LINUXAIO;
		3040	#endif
		3041	/* TODO: linuxaio is super experimental */
		3042	#if !EV_RECOMMEND_IOURING
		3043	flags &= ~EVBACKEND_IOURING;
		3044	#endif
		3045
2790	return flags;	3046	return flags;
2791	}	3047	}
2792		3048
2793	ecb_cold	3049	ecb_cold
2794	unsigned int	3050	unsigned int
2795	ev_embeddable_backends (void) EV_NOEXCEPT	3051	ev_embeddable_backends (void) EV_NOEXCEPT
2796	{	3052	{
2797	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	3053	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT | EVBACKEND_IOURING;
2798		3054
2799	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	3055	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2800	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	3056	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2801	flags &= ~EVBACKEND_EPOLL;	3057	flags &= ~EVBACKEND_EPOLL;
2802		3058
		3059	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
		3060
2803	return flags;	3061	return flags;
2804	}	3062	}
2805		3063
2806	unsigned int	3064	unsigned int
2807	ev_backend (EV_P) EV_NOEXCEPT	3065	ev_backend (EV_P) EV_NOEXCEPT
…		…
2859	acquire_cb = acquire;	3117	acquire_cb = acquire;
2860	}	3118	}
2861	#endif	3119	#endif
2862		3120
2863	/* initialise a loop structure, must be zero-initialised */	3121	/* initialise a loop structure, must be zero-initialised */
2864	noinline ecb_cold	3122	ecb_noinline ecb_cold
2865	static void	3123	static void
2866	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT	3124	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2867	{	3125	{
2868	if (!backend)	3126	if (!backend)
2869	{	3127	{
…		…
2924	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3182	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2925	#endif	3183	#endif
2926	#if EV_USE_SIGNALFD	3184	#if EV_USE_SIGNALFD
2927	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3185	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
2928	#endif	3186	#endif
		3187	#if EV_USE_TIMERFD
		3188	timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
		3189	#endif
2929		3190
2930	if (!(flags & EVBACKEND_MASK))	3191	if (!(flags & EVBACKEND_MASK))
2931	flags |= ev_recommended_backends ();	3192	flags |= ev_recommended_backends ();
2932		3193
2933	#if EV_USE_IOCP	3194	#if EV_USE_IOCP
…		…
2936	#if EV_USE_PORT	3197	#if EV_USE_PORT
2937	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	3198	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2938	#endif	3199	#endif
2939	#if EV_USE_KQUEUE	3200	#if EV_USE_KQUEUE
2940	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);	3201	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
		3202	#endif
		3203	#if EV_USE_IOURING
		3204	if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
2941	#endif	3205	#endif
2942	#if EV_USE_LINUXAIO	3206	#if EV_USE_LINUXAIO
2943	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);	3207	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2944	#endif	3208	#endif
2945	#if EV_USE_EPOLL	3209	#if EV_USE_EPOLL
…		…
2974	return;	3238	return;
2975	#endif	3239	#endif
2976		3240
2977	#if EV_CLEANUP_ENABLE	3241	#if EV_CLEANUP_ENABLE
2978	/* queue cleanup watchers (and execute them) */	3242	/* queue cleanup watchers (and execute them) */
2979	if (expect_false (cleanupcnt))	3243	if (ecb_expect_false (cleanupcnt))
2980	{	3244	{
2981	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);	3245	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
2982	EV_INVOKE_PENDING;	3246	EV_INVOKE_PENDING;
2983	}	3247	}
2984	#endif	3248	#endif
…		…
3003	#if EV_USE_SIGNALFD	3267	#if EV_USE_SIGNALFD
3004	if (ev_is_active (&sigfd_w))	3268	if (ev_is_active (&sigfd_w))
3005	close (sigfd);	3269	close (sigfd);
3006	#endif	3270	#endif
3007		3271
		3272	#if EV_USE_TIMERFD
		3273	if (ev_is_active (&timerfd_w))
		3274	close (timerfd);
		3275	#endif
		3276
3008	#if EV_USE_INOTIFY	3277	#if EV_USE_INOTIFY
3009	if (fs_fd >= 0)	3278	if (fs_fd >= 0)
3010	close (fs_fd);	3279	close (fs_fd);
3011	#endif	3280	#endif
3012		3281
…		…
3019	#if EV_USE_PORT	3288	#if EV_USE_PORT
3020	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3289	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
3021	#endif	3290	#endif
3022	#if EV_USE_KQUEUE	3291	#if EV_USE_KQUEUE
3023	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);	3292	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
		3293	#endif
		3294	#if EV_USE_IOURING
		3295	if (backend == EVBACKEND_IOURING ) iouring_destroy (EV_A);
3024	#endif	3296	#endif
3025	#if EV_USE_LINUXAIO	3297	#if EV_USE_LINUXAIO
3026	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);	3298	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
3027	#endif	3299	#endif
3028	#if EV_USE_EPOLL	3300	#if EV_USE_EPOLL
…		…
3087	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3359	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
3088	#endif	3360	#endif
3089	#if EV_USE_KQUEUE	3361	#if EV_USE_KQUEUE
3090	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);	3362	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
3091	#endif	3363	#endif
		3364	#if EV_USE_IOURING
		3365	if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
		3366	#endif
3092	#if EV_USE_LINUXAIO	3367	#if EV_USE_LINUXAIO
3093	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);	3368	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
3094	#endif	3369	#endif
3095	#if EV_USE_EPOLL	3370	#if EV_USE_EPOLL
3096	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3371	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
3097	#endif	3372	#endif
3098	#if EV_USE_INOTIFY	3373	#if EV_USE_INOTIFY
3099	infy_fork (EV_A);	3374	infy_fork (EV_A);
3100	#endif	3375	#endif
3101		3376
		3377	if (postfork != 2)
		3378	{
		3379	#if EV_USE_SIGNALFD
		3380	/* surprisingly, nothing needs to be done for signalfd, accoridng to docs, it does the right thing on fork */
		3381	#endif
		3382
		3383	#if EV_USE_TIMERFD
		3384	if (ev_is_active (&timerfd_w))
		3385	{
		3386	ev_ref (EV_A);
		3387	ev_io_stop (EV_A_ &timerfd_w);
		3388
		3389	close (timerfd);
		3390	timerfd = -2;
		3391
		3392	evtimerfd_init (EV_A);
		3393	/* reschedule periodics, in case we missed something */
		3394	ev_feed_event (EV_A_ &timerfd_w, EV_CUSTOM);
		3395	}
		3396	#endif
		3397
3102	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3398	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
3103	if (ev_is_active (&pipe_w) && postfork != 2)	3399	if (ev_is_active (&pipe_w))
3104	{	3400	{
3105	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3401	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
3106		3402
3107	ev_ref (EV_A);	3403	ev_ref (EV_A);
3108	ev_io_stop (EV_A_ &pipe_w);	3404	ev_io_stop (EV_A_ &pipe_w);
3109		3405
3110	if (evpipe [0] >= 0)	3406	if (evpipe [0] >= 0)
3111	EV_WIN32_CLOSE_FD (evpipe [0]);	3407	EV_WIN32_CLOSE_FD (evpipe [0]);
3112		3408
3113	evpipe_init (EV_A);	3409	evpipe_init (EV_A);
3114	/* iterate over everything, in case we missed something before */	3410	/* iterate over everything, in case we missed something before */
3115	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3411	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
		3412	}
		3413	#endif
3116	}	3414	}
3117	#endif
3118		3415
3119	postfork = 0;	3416	postfork = 0;
3120	}	3417	}
3121		3418
3122	#if EV_MULTIPLICITY	3419	#if EV_MULTIPLICITY
…		…
3138	}	3435	}
3139		3436
3140	#endif /* multiplicity */	3437	#endif /* multiplicity */
3141		3438
3142	#if EV_VERIFY	3439	#if EV_VERIFY
3143	noinline ecb_cold	3440	ecb_noinline ecb_cold
3144	static void	3441	static void
3145	verify_watcher (EV_P_ W w)	3442	verify_watcher (EV_P_ W w)
3146	{	3443	{
3147	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3444	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
3148		3445
3149	if (w->pending)	3446	if (w->pending)
3150	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3447	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
3151	}	3448	}
3152		3449
3153	noinline ecb_cold	3450	ecb_noinline ecb_cold
3154	static void	3451	static void
3155	verify_heap (EV_P_ ANHE *heap, int N)	3452	verify_heap (EV_P_ ANHE *heap, int N)
3156	{	3453	{
3157	int i;	3454	int i;
3158		3455
…		…
3164		3461
3165	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3462	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
3166	}	3463	}
3167	}	3464	}
3168		3465
3169	noinline ecb_cold	3466	ecb_noinline ecb_cold
3170	static void	3467	static void
3171	array_verify (EV_P_ W *ws, int cnt)	3468	array_verify (EV_P_ W *ws, int cnt)
3172	{	3469	{
3173	while (cnt--)	3470	while (cnt--)
3174	{	3471	{
…		…
3323	count += pendingcnt [pri];	3620	count += pendingcnt [pri];
3324		3621
3325	return count;	3622	return count;
3326	}	3623	}
3327		3624
3328	noinline	3625	ecb_noinline
3329	void	3626	void
3330	ev_invoke_pending (EV_P)	3627	ev_invoke_pending (EV_P)
3331	{	3628	{
3332	pendingpri = NUMPRI;	3629	pendingpri = NUMPRI;
3333		3630
…		…
3352	/* make idle watchers pending. this handles the "call-idle */	3649	/* make idle watchers pending. this handles the "call-idle */
3353	/* only when higher priorities are idle" logic */	3650	/* only when higher priorities are idle" logic */
3354	inline_size void	3651	inline_size void
3355	idle_reify (EV_P)	3652	idle_reify (EV_P)
3356	{	3653	{
3357	if (expect_false (idleall))	3654	if (ecb_expect_false (idleall))
3358	{	3655	{
3359	int pri;	3656	int pri;
3360		3657
3361	for (pri = NUMPRI; pri--; )	3658	for (pri = NUMPRI; pri--; )
3362	{	3659	{
…		…
3392	{	3689	{
3393	ev_at (w) += w->repeat;	3690	ev_at (w) += w->repeat;
3394	if (ev_at (w) < mn_now)	3691	if (ev_at (w) < mn_now)
3395	ev_at (w) = mn_now;	3692	ev_at (w) = mn_now;
3396		3693
3397	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));	3694	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > EV_TS_CONST (0.)));
3398		3695
3399	ANHE_at_cache (timers [HEAP0]);	3696	ANHE_at_cache (timers [HEAP0]);
3400	downheap (timers, timercnt, HEAP0);	3697	downheap (timers, timercnt, HEAP0);
3401	}	3698	}
3402	else	3699	else
…		…
3411	}	3708	}
3412	}	3709	}
3413		3710
3414	#if EV_PERIODIC_ENABLE	3711	#if EV_PERIODIC_ENABLE
3415		3712
3416	noinline	3713	ecb_noinline
3417	static void	3714	static void
3418	periodic_recalc (EV_P_ ev_periodic *w)	3715	periodic_recalc (EV_P_ ev_periodic *w)
3419	{	3716	{
3420	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3717	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3421	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);	3718	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
…		…
3424	while (at <= ev_rt_now)	3721	while (at <= ev_rt_now)
3425	{	3722	{
3426	ev_tstamp nat = at + w->interval;	3723	ev_tstamp nat = at + w->interval;
3427		3724
3428	/* when resolution fails us, we use ev_rt_now */	3725	/* when resolution fails us, we use ev_rt_now */
3429	if (expect_false (nat == at))	3726	if (ecb_expect_false (nat == at))
3430	{	3727	{
3431	at = ev_rt_now;	3728	at = ev_rt_now;
3432	break;	3729	break;
3433	}	3730	}
3434		3731
…		…
3480	}	3777	}
3481	}	3778	}
3482		3779
3483	/* simply recalculate all periodics */	3780	/* simply recalculate all periodics */
3484	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3781	/* TODO: maybe ensure that at least one event happens when jumping forward? */
3485	noinline ecb_cold	3782	ecb_noinline ecb_cold
3486	static void	3783	static void
3487	periodics_reschedule (EV_P)	3784	periodics_reschedule (EV_P)
3488	{	3785	{
3489	int i;	3786	int i;
3490		3787
…		…
3504	reheap (periodics, periodiccnt);	3801	reheap (periodics, periodiccnt);
3505	}	3802	}
3506	#endif	3803	#endif
3507		3804
3508	/* adjust all timers by a given offset */	3805	/* adjust all timers by a given offset */
3509	noinline ecb_cold	3806	ecb_noinline ecb_cold
3510	static void	3807	static void
3511	timers_reschedule (EV_P_ ev_tstamp adjust)	3808	timers_reschedule (EV_P_ ev_tstamp adjust)
3512	{	3809	{
3513	int i;	3810	int i;
3514		3811
…		…
3524	/* also detect if there was a timejump, and act accordingly */	3821	/* also detect if there was a timejump, and act accordingly */
3525	inline_speed void	3822	inline_speed void
3526	time_update (EV_P_ ev_tstamp max_block)	3823	time_update (EV_P_ ev_tstamp max_block)
3527	{	3824	{
3528	#if EV_USE_MONOTONIC	3825	#if EV_USE_MONOTONIC
3529	if (expect_true (have_monotonic))	3826	if (ecb_expect_true (have_monotonic))
3530	{	3827	{
3531	int i;	3828	int i;
3532	ev_tstamp odiff = rtmn_diff;	3829	ev_tstamp odiff = rtmn_diff;
3533		3830
3534	mn_now = get_clock ();	3831	mn_now = get_clock ();
3535		3832
3536	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */	3833	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3537	/* interpolate in the meantime */	3834	/* interpolate in the meantime */
3538	if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))	3835	if (ecb_expect_true (mn_now - now_floor < EV_TS_CONST (MIN_TIMEJUMP * .5)))
3539	{	3836	{
3540	ev_rt_now = rtmn_diff + mn_now;	3837	ev_rt_now = rtmn_diff + mn_now;
3541	return;	3838	return;
3542	}	3839	}
3543		3840
…		…
3557	ev_tstamp diff;	3854	ev_tstamp diff;
3558	rtmn_diff = ev_rt_now - mn_now;	3855	rtmn_diff = ev_rt_now - mn_now;
3559		3856
3560	diff = odiff - rtmn_diff;	3857	diff = odiff - rtmn_diff;
3561		3858
3562	if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))	3859	if (ecb_expect_true ((diff < EV_TS_CONST (0.) ? -diff : diff) < EV_TS_CONST (MIN_TIMEJUMP)))
3563	return; /* all is well */	3860	return; /* all is well */
3564		3861
3565	ev_rt_now = ev_time ();	3862	ev_rt_now = ev_time ();
3566	mn_now = get_clock ();	3863	mn_now = get_clock ();
3567	now_floor = mn_now;	3864	now_floor = mn_now;
…		…
3576	else	3873	else
3577	#endif	3874	#endif
3578	{	3875	{
3579	ev_rt_now = ev_time ();	3876	ev_rt_now = ev_time ();
3580		3877
3581	if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))	3878	if (ecb_expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + EV_TS_CONST (MIN_TIMEJUMP)))
3582	{	3879	{
3583	/* adjust timers. this is easy, as the offset is the same for all of them */	3880	/* adjust timers. this is easy, as the offset is the same for all of them */
3584	timers_reschedule (EV_A_ ev_rt_now - mn_now);	3881	timers_reschedule (EV_A_ ev_rt_now - mn_now);
3585	#if EV_PERIODIC_ENABLE	3882	#if EV_PERIODIC_ENABLE
3586	periodics_reschedule (EV_A);	3883	periodics_reschedule (EV_A);
…		…
3609	#if EV_VERIFY >= 2	3906	#if EV_VERIFY >= 2
3610	ev_verify (EV_A);	3907	ev_verify (EV_A);
3611	#endif	3908	#endif
3612		3909
3613	#ifndef _WIN32	3910	#ifndef _WIN32
3614	if (expect_false (curpid)) /* penalise the forking check even more */	3911	if (ecb_expect_false (curpid)) /* penalise the forking check even more */
3615	if (expect_false (getpid () != curpid))	3912	if (ecb_expect_false (getpid () != curpid))
3616	{	3913	{
3617	curpid = getpid ();	3914	curpid = getpid ();
3618	postfork = 1;	3915	postfork = 1;
3619	}	3916	}
3620	#endif	3917	#endif
3621		3918
3622	#if EV_FORK_ENABLE	3919	#if EV_FORK_ENABLE
3623	/* we might have forked, so queue fork handlers */	3920	/* we might have forked, so queue fork handlers */
3624	if (expect_false (postfork))	3921	if (ecb_expect_false (postfork))
3625	if (forkcnt)	3922	if (forkcnt)
3626	{	3923	{
3627	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	3924	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3628	EV_INVOKE_PENDING;	3925	EV_INVOKE_PENDING;
3629	}	3926	}
3630	#endif	3927	#endif
3631		3928
3632	#if EV_PREPARE_ENABLE	3929	#if EV_PREPARE_ENABLE
3633	/* queue prepare watchers (and execute them) */	3930	/* queue prepare watchers (and execute them) */
3634	if (expect_false (preparecnt))	3931	if (ecb_expect_false (preparecnt))
3635	{	3932	{
3636	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	3933	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3637	EV_INVOKE_PENDING;	3934	EV_INVOKE_PENDING;
3638	}	3935	}
3639	#endif	3936	#endif
3640		3937
3641	if (expect_false (loop_done))	3938	if (ecb_expect_false (loop_done))
3642	break;	3939	break;
3643		3940
3644	/* we might have forked, so reify kernel state if necessary */	3941	/* we might have forked, so reify kernel state if necessary */
3645	if (expect_false (postfork))	3942	if (ecb_expect_false (postfork))
3646	loop_fork (EV_A);	3943	loop_fork (EV_A);
3647		3944
3648	/* update fd-related kernel structures */	3945	/* update fd-related kernel structures */
3649	fd_reify (EV_A);	3946	fd_reify (EV_A);
3650		3947
…		…
3655		3952
3656	/* remember old timestamp for io_blocktime calculation */	3953	/* remember old timestamp for io_blocktime calculation */
3657	ev_tstamp prev_mn_now = mn_now;	3954	ev_tstamp prev_mn_now = mn_now;
3658		3955
3659	/* update time to cancel out callback processing overhead */	3956	/* update time to cancel out callback processing overhead */
3660	time_update (EV_A_ 1e100);	3957	time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
3661		3958
3662	/* from now on, we want a pipe-wake-up */	3959	/* from now on, we want a pipe-wake-up */
3663	pipe_write_wanted = 1;	3960	pipe_write_wanted = 1;
3664		3961
3665	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */	3962	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3666		3963
3667	if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))	3964	if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3668	{	3965	{
3669	waittime = MAX_BLOCKTIME;	3966	waittime = EV_TS_CONST (MAX_BLOCKTIME);
3670		3967
3671	if (timercnt)	3968	if (timercnt)
3672	{	3969	{
3673	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	3970	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3674	if (waittime > to) waittime = to;	3971	if (waittime > to) waittime = to;
…		…
3681	if (waittime > to) waittime = to;	3978	if (waittime > to) waittime = to;
3682	}	3979	}
3683	#endif	3980	#endif
3684		3981
3685	/* don't let timeouts decrease the waittime below timeout_blocktime */	3982	/* don't let timeouts decrease the waittime below timeout_blocktime */
3686	if (expect_false (waittime < timeout_blocktime))	3983	if (ecb_expect_false (waittime < timeout_blocktime))
3687	waittime = timeout_blocktime;	3984	waittime = timeout_blocktime;
3688		3985
3689	/* at this point, we NEED to wait, so we have to ensure */	3986	/* now there are two more special cases left, either we have
3690	/* to pass a minimum nonzero value to the backend */	3987	* already-expired timers, so we should not sleep, or we have timers
		3988	* that expire very soon, in which case we need to wait for a minimum
		3989	* amount of time for some event loop backends.
		3990	*/
3691	if (expect_false (waittime < backend_mintime))	3991	if (ecb_expect_false (waittime < backend_mintime))
		3992	waittime = waittime <= EV_TS_CONST (0.)
		3993	? EV_TS_CONST (0.)
3692	waittime = backend_mintime;	3994	: backend_mintime;
3693		3995
3694	/* extra check because io_blocktime is commonly 0 */	3996	/* extra check because io_blocktime is commonly 0 */
3695	if (expect_false (io_blocktime))	3997	if (ecb_expect_false (io_blocktime))
3696	{	3998	{
3697	sleeptime = io_blocktime - (mn_now - prev_mn_now);	3999	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3698		4000
3699	if (sleeptime > waittime - backend_mintime)	4001	if (sleeptime > waittime - backend_mintime)
3700	sleeptime = waittime - backend_mintime;	4002	sleeptime = waittime - backend_mintime;
3701		4003
3702	if (expect_true (sleeptime > 0.))	4004	if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
3703	{	4005	{
3704	ev_sleep (sleeptime);	4006	ev_sleep (sleeptime);
3705	waittime -= sleeptime;	4007	waittime -= sleeptime;
3706	}	4008	}
3707	}	4009	}
…		…
3721	{	4023	{
3722	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	4024	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3723	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	4025	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3724	}	4026	}
3725		4027
3726
3727	/* update ev_rt_now, do magic */	4028	/* update ev_rt_now, do magic */
3728	time_update (EV_A_ waittime + sleeptime);	4029	time_update (EV_A_ waittime + sleeptime);
3729	}	4030	}
3730		4031
3731	/* queue pending timers and reschedule them */	4032	/* queue pending timers and reschedule them */
…		…
3739	idle_reify (EV_A);	4040	idle_reify (EV_A);
3740	#endif	4041	#endif
3741		4042
3742	#if EV_CHECK_ENABLE	4043	#if EV_CHECK_ENABLE
3743	/* queue check watchers, to be executed first */	4044	/* queue check watchers, to be executed first */
3744	if (expect_false (checkcnt))	4045	if (ecb_expect_false (checkcnt))
3745	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	4046	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3746	#endif	4047	#endif
3747		4048
3748	EV_INVOKE_PENDING;	4049	EV_INVOKE_PENDING;
3749	}	4050	}
3750	while (expect_true (	4051	while (ecb_expect_true (
3751	activecnt	4052	activecnt
3752	&& !loop_done	4053	&& !loop_done
3753	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))	4054	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3754	));	4055	));
3755		4056
…		…
3782	}	4083	}
3783		4084
3784	void	4085	void
3785	ev_now_update (EV_P) EV_NOEXCEPT	4086	ev_now_update (EV_P) EV_NOEXCEPT
3786	{	4087	{
3787	time_update (EV_A_ 1e100);	4088	time_update (EV_A_ EV_TSTAMP_HUGE);
3788	}	4089	}
3789		4090
3790	void	4091	void
3791	ev_suspend (EV_P) EV_NOEXCEPT	4092	ev_suspend (EV_P) EV_NOEXCEPT
3792	{	4093	{
…		…
3819	inline_size void	4120	inline_size void
3820	wlist_del (WL *head, WL elem)	4121	wlist_del (WL *head, WL elem)
3821	{	4122	{
3822	while (*head)	4123	while (*head)
3823	{	4124	{
3824	if (expect_true (*head == elem))	4125	if (ecb_expect_true (*head == elem))
3825	{	4126	{
3826	*head = elem->next;	4127	*head = elem->next;
3827	break;	4128	break;
3828	}	4129	}
3829		4130
…		…
3846	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT	4147	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3847	{	4148	{
3848	W w_ = (W)w;	4149	W w_ = (W)w;
3849	int pending = w_->pending;	4150	int pending = w_->pending;
3850		4151
3851	if (expect_true (pending))	4152	if (ecb_expect_true (pending))
3852	{	4153	{
3853	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	4154	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3854	p->w = (W)&pending_w;	4155	p->w = (W)&pending_w;
3855	w_->pending = 0;	4156	w_->pending = 0;
3856	return p->events;	4157	return p->events;
…		…
3883	w->active = 0;	4184	w->active = 0;
3884	}	4185	}
3885		4186
3886	/*****************************************************************************/	4187	/*****************************************************************************/
3887		4188
3888	noinline	4189	ecb_noinline
3889	void	4190	void
3890	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT	4191	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3891	{	4192	{
3892	int fd = w->fd;	4193	int fd = w->fd;
3893		4194
3894	if (expect_false (ev_is_active (w)))	4195	if (ecb_expect_false (ev_is_active (w)))
3895	return;	4196	return;
3896		4197
3897	assert (("libev: ev_io_start called with negative fd", fd >= 0));	4198	assert (("libev: ev_io_start called with negative fd", fd >= 0));
3898	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));	4199	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3899		4200
		4201	#if EV_VERIFY >= 2
		4202	assert (("libev: ev_io_start called on watcher with invalid fd", fd_valid (fd)));
		4203	#endif
3900	EV_FREQUENT_CHECK;	4204	EV_FREQUENT_CHECK;
3901		4205
3902	ev_start (EV_A_ (W)w, 1);	4206	ev_start (EV_A_ (W)w, 1);
3903	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);	4207	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);
3904	wlist_add (&anfds[fd].head, (WL)w);	4208	wlist_add (&anfds[fd].head, (WL)w);
…		…
3910	w->events &= ~EV__IOFDSET;	4214	w->events &= ~EV__IOFDSET;
3911		4215
3912	EV_FREQUENT_CHECK;	4216	EV_FREQUENT_CHECK;
3913	}	4217	}
3914		4218
3915	noinline	4219	ecb_noinline
3916	void	4220	void
3917	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT	4221	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3918	{	4222	{
3919	clear_pending (EV_A_ (W)w);	4223	clear_pending (EV_A_ (W)w);
3920	if (expect_false (!ev_is_active (w)))	4224	if (ecb_expect_false (!ev_is_active (w)))
3921	return;	4225	return;
3922		4226
3923	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));	4227	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3924		4228
		4229	#if EV_VERIFY >= 2
		4230	assert (("libev: ev_io_stop called on watcher with invalid fd", fd_valid (w->fd)));
		4231	#endif
3925	EV_FREQUENT_CHECK;	4232	EV_FREQUENT_CHECK;
3926		4233
3927	wlist_del (&anfds[w->fd].head, (WL)w);	4234	wlist_del (&anfds[w->fd].head, (WL)w);
3928	ev_stop (EV_A_ (W)w);	4235	ev_stop (EV_A_ (W)w);
3929		4236
3930	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	4237	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3931		4238
3932	EV_FREQUENT_CHECK;	4239	EV_FREQUENT_CHECK;
3933	}	4240	}
3934		4241
3935	noinline	4242	ecb_noinline
3936	void	4243	void
3937	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT	4244	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3938	{	4245	{
3939	if (expect_false (ev_is_active (w)))	4246	if (ecb_expect_false (ev_is_active (w)))
3940	return;	4247	return;
3941		4248
3942	ev_at (w) += mn_now;	4249	ev_at (w) += mn_now;
3943		4250
3944	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));	4251	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
…		…
3955	EV_FREQUENT_CHECK;	4262	EV_FREQUENT_CHECK;
3956		4263
3957	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	4264	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3958	}	4265	}
3959		4266
3960	noinline	4267	ecb_noinline
3961	void	4268	void
3962	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT	4269	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3963	{	4270	{
3964	clear_pending (EV_A_ (W)w);	4271	clear_pending (EV_A_ (W)w);
3965	if (expect_false (!ev_is_active (w)))	4272	if (ecb_expect_false (!ev_is_active (w)))
3966	return;	4273	return;
3967		4274
3968	EV_FREQUENT_CHECK;	4275	EV_FREQUENT_CHECK;
3969		4276
3970	{	4277	{
…		…
3972		4279
3973	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));	4280	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
3974		4281
3975	--timercnt;	4282	--timercnt;
3976		4283
3977	if (expect_true (active < timercnt + HEAP0))	4284	if (ecb_expect_true (active < timercnt + HEAP0))
3978	{	4285	{
3979	timers [active] = timers [timercnt + HEAP0];	4286	timers [active] = timers [timercnt + HEAP0];
3980	adjustheap (timers, timercnt, active);	4287	adjustheap (timers, timercnt, active);
3981	}	4288	}
3982	}	4289	}
…		…
3986	ev_stop (EV_A_ (W)w);	4293	ev_stop (EV_A_ (W)w);
3987		4294
3988	EV_FREQUENT_CHECK;	4295	EV_FREQUENT_CHECK;
3989	}	4296	}
3990		4297
3991	noinline	4298	ecb_noinline
3992	void	4299	void
3993	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT	4300	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
3994	{	4301	{
3995	EV_FREQUENT_CHECK;	4302	EV_FREQUENT_CHECK;
3996		4303
…		…
4017	}	4324	}
4018		4325
4019	ev_tstamp	4326	ev_tstamp
4020	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT	4327	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
4021	{	4328	{
4022	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4329	return ev_at (w) - (ev_is_active (w) ? mn_now : EV_TS_CONST (0.));
4023	}	4330	}
4024		4331
4025	#if EV_PERIODIC_ENABLE	4332	#if EV_PERIODIC_ENABLE
4026	noinline	4333	ecb_noinline
4027	void	4334	void
4028	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT	4335	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4029	{	4336	{
4030	if (expect_false (ev_is_active (w)))	4337	if (ecb_expect_false (ev_is_active (w)))
4031	return;	4338	return;
		4339
		4340	#if EV_USE_TIMERFD
		4341	if (timerfd == -2)
		4342	evtimerfd_init (EV_A);
		4343	#endif
4032		4344
4033	if (w->reschedule_cb)	4345	if (w->reschedule_cb)
4034	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4346	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
4035	else if (w->interval)	4347	else if (w->interval)
4036	{	4348	{
…		…
4052	EV_FREQUENT_CHECK;	4364	EV_FREQUENT_CHECK;
4053		4365
4054	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4366	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
4055	}	4367	}
4056		4368
4057	noinline	4369	ecb_noinline
4058	void	4370	void
4059	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT	4371	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
4060	{	4372	{
4061	clear_pending (EV_A_ (W)w);	4373	clear_pending (EV_A_ (W)w);
4062	if (expect_false (!ev_is_active (w)))	4374	if (ecb_expect_false (!ev_is_active (w)))
4063	return;	4375	return;
4064		4376
4065	EV_FREQUENT_CHECK;	4377	EV_FREQUENT_CHECK;
4066		4378
4067	{	4379	{
…		…
4069		4381
4070	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));	4382	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
4071		4383
4072	--periodiccnt;	4384	--periodiccnt;
4073		4385
4074	if (expect_true (active < periodiccnt + HEAP0))	4386	if (ecb_expect_true (active < periodiccnt + HEAP0))
4075	{	4387	{
4076	periodics [active] = periodics [periodiccnt + HEAP0];	4388	periodics [active] = periodics [periodiccnt + HEAP0];
4077	adjustheap (periodics, periodiccnt, active);	4389	adjustheap (periodics, periodiccnt, active);
4078	}	4390	}
4079	}	4391	}
…		…
4081	ev_stop (EV_A_ (W)w);	4393	ev_stop (EV_A_ (W)w);
4082		4394
4083	EV_FREQUENT_CHECK;	4395	EV_FREQUENT_CHECK;
4084	}	4396	}
4085		4397
4086	noinline	4398	ecb_noinline
4087	void	4399	void
4088	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT	4400	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4089	{	4401	{
4090	/* TODO: use adjustheap and recalculation */	4402	/* TODO: use adjustheap and recalculation */
4091	ev_periodic_stop (EV_A_ w);	4403	ev_periodic_stop (EV_A_ w);
…		…
4097	# define SA_RESTART 0	4409	# define SA_RESTART 0
4098	#endif	4410	#endif
4099		4411
4100	#if EV_SIGNAL_ENABLE	4412	#if EV_SIGNAL_ENABLE
4101		4413
4102	noinline	4414	ecb_noinline
4103	void	4415	void
4104	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT	4416	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4105	{	4417	{
4106	if (expect_false (ev_is_active (w)))	4418	if (ecb_expect_false (ev_is_active (w)))
4107	return;	4419	return;
4108		4420
4109	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4421	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
4110		4422
4111	#if EV_MULTIPLICITY	4423	#if EV_MULTIPLICITY
…		…
4180	}	4492	}
4181		4493
4182	EV_FREQUENT_CHECK;	4494	EV_FREQUENT_CHECK;
4183	}	4495	}
4184		4496
4185	noinline	4497	ecb_noinline
4186	void	4498	void
4187	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT	4499	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4188	{	4500	{
4189	clear_pending (EV_A_ (W)w);	4501	clear_pending (EV_A_ (W)w);
4190	if (expect_false (!ev_is_active (w)))	4502	if (ecb_expect_false (!ev_is_active (w)))
4191	return;	4503	return;
4192		4504
4193	EV_FREQUENT_CHECK;	4505	EV_FREQUENT_CHECK;
4194		4506
4195	wlist_del (&signals [w->signum - 1].head, (WL)w);	4507	wlist_del (&signals [w->signum - 1].head, (WL)w);
…		…
4228	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT	4540	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4229	{	4541	{
4230	#if EV_MULTIPLICITY	4542	#if EV_MULTIPLICITY
4231	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4543	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
4232	#endif	4544	#endif
4233	if (expect_false (ev_is_active (w)))	4545	if (ecb_expect_false (ev_is_active (w)))
4234	return;	4546	return;
4235		4547
4236	EV_FREQUENT_CHECK;	4548	EV_FREQUENT_CHECK;
4237		4549
4238	ev_start (EV_A_ (W)w, 1);	4550	ev_start (EV_A_ (W)w, 1);
…		…
4243		4555
4244	void	4556	void
4245	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT	4557	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4246	{	4558	{
4247	clear_pending (EV_A_ (W)w);	4559	clear_pending (EV_A_ (W)w);
4248	if (expect_false (!ev_is_active (w)))	4560	if (ecb_expect_false (!ev_is_active (w)))
4249	return;	4561	return;
4250		4562
4251	EV_FREQUENT_CHECK;	4563	EV_FREQUENT_CHECK;
4252		4564
4253	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);	4565	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
…		…
4267		4579
4268	#define DEF_STAT_INTERVAL 5.0074891	4580	#define DEF_STAT_INTERVAL 5.0074891
4269	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4581	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
4270	#define MIN_STAT_INTERVAL 0.1074891	4582	#define MIN_STAT_INTERVAL 0.1074891
4271		4583
4272	noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4584	ecb_noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
4273		4585
4274	#if EV_USE_INOTIFY	4586	#if EV_USE_INOTIFY
4275		4587
4276	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4588	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
4277	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4589	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
4278		4590
4279	noinline	4591	ecb_noinline
4280	static void	4592	static void
4281	infy_add (EV_P_ ev_stat *w)	4593	infy_add (EV_P_ ev_stat *w)
4282	{	4594	{
4283	w->wd = inotify_add_watch (fs_fd, w->path,	4595	w->wd = inotify_add_watch (fs_fd, w->path,
4284	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY	4596	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
…		…
4349	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4661	if (ev_is_active (&w->timer)) ev_ref (EV_A);
4350	ev_timer_again (EV_A_ &w->timer);	4662	ev_timer_again (EV_A_ &w->timer);
4351	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4663	if (ev_is_active (&w->timer)) ev_unref (EV_A);
4352	}	4664	}
4353		4665
4354	noinline	4666	ecb_noinline
4355	static void	4667	static void
4356	infy_del (EV_P_ ev_stat *w)	4668	infy_del (EV_P_ ev_stat *w)
4357	{	4669	{
4358	int slot;	4670	int slot;
4359	int wd = w->wd;	4671	int wd = w->wd;
…		…
4367		4679
4368	/* remove this watcher, if others are watching it, they will rearm */	4680	/* remove this watcher, if others are watching it, they will rearm */
4369	inotify_rm_watch (fs_fd, wd);	4681	inotify_rm_watch (fs_fd, wd);
4370	}	4682	}
4371		4683
4372	noinline	4684	ecb_noinline
4373	static void	4685	static void
4374	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4686	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
4375	{	4687	{
4376	if (slot < 0)	4688	if (slot < 0)
4377	/* overflow, need to check for all hash slots */	4689	/* overflow, need to check for all hash slots */
…		…
4523	w->attr.st_nlink = 0;	4835	w->attr.st_nlink = 0;
4524	else if (!w->attr.st_nlink)	4836	else if (!w->attr.st_nlink)
4525	w->attr.st_nlink = 1;	4837	w->attr.st_nlink = 1;
4526	}	4838	}
4527		4839
4528	noinline	4840	ecb_noinline
4529	static void	4841	static void
4530	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4842	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4531	{	4843	{
4532	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4844	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4533		4845
…		…
4567	}	4879	}
4568		4880
4569	void	4881	void
4570	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT	4882	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4571	{	4883	{
4572	if (expect_false (ev_is_active (w)))	4884	if (ecb_expect_false (ev_is_active (w)))
4573	return;	4885	return;
4574		4886
4575	ev_stat_stat (EV_A_ w);	4887	ev_stat_stat (EV_A_ w);
4576		4888
4577	if (w->interval < MIN_STAT_INTERVAL && w->interval)	4889	if (w->interval < MIN_STAT_INTERVAL && w->interval)
…		…
4599		4911
4600	void	4912	void
4601	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT	4913	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4602	{	4914	{
4603	clear_pending (EV_A_ (W)w);	4915	clear_pending (EV_A_ (W)w);
4604	if (expect_false (!ev_is_active (w)))	4916	if (ecb_expect_false (!ev_is_active (w)))
4605	return;	4917	return;
4606		4918
4607	EV_FREQUENT_CHECK;	4919	EV_FREQUENT_CHECK;
4608		4920
4609	#if EV_USE_INOTIFY	4921	#if EV_USE_INOTIFY
…		…
4624		4936
4625	#if EV_IDLE_ENABLE	4937	#if EV_IDLE_ENABLE
4626	void	4938	void
4627	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT	4939	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4628	{	4940	{
4629	if (expect_false (ev_is_active (w)))	4941	if (ecb_expect_false (ev_is_active (w)))
4630	return;	4942	return;
4631		4943
4632	pri_adjust (EV_A_ (W)w);	4944	pri_adjust (EV_A_ (W)w);
4633		4945
4634	EV_FREQUENT_CHECK;	4946	EV_FREQUENT_CHECK;
…		…
4648		4960
4649	void	4961	void
4650	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT	4962	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4651	{	4963	{
4652	clear_pending (EV_A_ (W)w);	4964	clear_pending (EV_A_ (W)w);
4653	if (expect_false (!ev_is_active (w)))	4965	if (ecb_expect_false (!ev_is_active (w)))
4654	return;	4966	return;
4655		4967
4656	EV_FREQUENT_CHECK;	4968	EV_FREQUENT_CHECK;
4657		4969
4658	{	4970	{
…		…
4671		4983
4672	#if EV_PREPARE_ENABLE	4984	#if EV_PREPARE_ENABLE
4673	void	4985	void
4674	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT	4986	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4675	{	4987	{
4676	if (expect_false (ev_is_active (w)))	4988	if (ecb_expect_false (ev_is_active (w)))
4677	return;	4989	return;
4678		4990
4679	EV_FREQUENT_CHECK;	4991	EV_FREQUENT_CHECK;
4680		4992
4681	ev_start (EV_A_ (W)w, ++preparecnt);	4993	ev_start (EV_A_ (W)w, ++preparecnt);
…		…
4687		4999
4688	void	5000	void
4689	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT	5001	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4690	{	5002	{
4691	clear_pending (EV_A_ (W)w);	5003	clear_pending (EV_A_ (W)w);
4692	if (expect_false (!ev_is_active (w)))	5004	if (ecb_expect_false (!ev_is_active (w)))
4693	return;	5005	return;
4694		5006
4695	EV_FREQUENT_CHECK;	5007	EV_FREQUENT_CHECK;
4696		5008
4697	{	5009	{
…		…
4709		5021
4710	#if EV_CHECK_ENABLE	5022	#if EV_CHECK_ENABLE
4711	void	5023	void
4712	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT	5024	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4713	{	5025	{
4714	if (expect_false (ev_is_active (w)))	5026	if (ecb_expect_false (ev_is_active (w)))
4715	return;	5027	return;
4716		5028
4717	EV_FREQUENT_CHECK;	5029	EV_FREQUENT_CHECK;
4718		5030
4719	ev_start (EV_A_ (W)w, ++checkcnt);	5031	ev_start (EV_A_ (W)w, ++checkcnt);
…		…
4725		5037
4726	void	5038	void
4727	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT	5039	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4728	{	5040	{
4729	clear_pending (EV_A_ (W)w);	5041	clear_pending (EV_A_ (W)w);
4730	if (expect_false (!ev_is_active (w)))	5042	if (ecb_expect_false (!ev_is_active (w)))
4731	return;	5043	return;
4732		5044
4733	EV_FREQUENT_CHECK;	5045	EV_FREQUENT_CHECK;
4734		5046
4735	{	5047	{
…		…
4744	EV_FREQUENT_CHECK;	5056	EV_FREQUENT_CHECK;
4745	}	5057	}
4746	#endif	5058	#endif
4747		5059
4748	#if EV_EMBED_ENABLE	5060	#if EV_EMBED_ENABLE
4749	noinline	5061	ecb_noinline
4750	void	5062	void
4751	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT	5063	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4752	{	5064	{
4753	ev_run (w->other, EVRUN_NOWAIT);	5065	ev_run (w->other, EVRUN_NOWAIT);
4754	}	5066	}
…		…
4778	ev_run (EV_A_ EVRUN_NOWAIT);	5090	ev_run (EV_A_ EVRUN_NOWAIT);
4779	}	5091	}
4780	}	5092	}
4781	}	5093	}
4782		5094
		5095	#if EV_FORK_ENABLE
4783	static void	5096	static void
4784	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)	5097	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4785	{	5098	{
4786	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));	5099	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
4787		5100
…		…
4794	ev_run (EV_A_ EVRUN_NOWAIT);	5107	ev_run (EV_A_ EVRUN_NOWAIT);
4795	}	5108	}
4796		5109
4797	ev_embed_start (EV_A_ w);	5110	ev_embed_start (EV_A_ w);
4798	}	5111	}
		5112	#endif
4799		5113
4800	#if 0	5114	#if 0
4801	static void	5115	static void
4802	embed_idle_cb (EV_P_ ev_idle *idle, int revents)	5116	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4803	{	5117	{
…		…
4806	#endif	5120	#endif
4807		5121
4808	void	5122	void
4809	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT	5123	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4810	{	5124	{
4811	if (expect_false (ev_is_active (w)))	5125	if (ecb_expect_false (ev_is_active (w)))
4812	return;	5126	return;
4813		5127
4814	{	5128	{
4815	EV_P = w->other;	5129	EV_P = w->other;
4816	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));	5130	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
…		…
4824		5138
4825	ev_prepare_init (&w->prepare, embed_prepare_cb);	5139	ev_prepare_init (&w->prepare, embed_prepare_cb);
4826	ev_set_priority (&w->prepare, EV_MINPRI);	5140	ev_set_priority (&w->prepare, EV_MINPRI);
4827	ev_prepare_start (EV_A_ &w->prepare);	5141	ev_prepare_start (EV_A_ &w->prepare);
4828		5142
		5143	#if EV_FORK_ENABLE
4829	ev_fork_init (&w->fork, embed_fork_cb);	5144	ev_fork_init (&w->fork, embed_fork_cb);
4830	ev_fork_start (EV_A_ &w->fork);	5145	ev_fork_start (EV_A_ &w->fork);
		5146	#endif
4831		5147
4832	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/	5148	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4833		5149
4834	ev_start (EV_A_ (W)w, 1);	5150	ev_start (EV_A_ (W)w, 1);
4835		5151
…		…
4838		5154
4839	void	5155	void
4840	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT	5156	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4841	{	5157	{
4842	clear_pending (EV_A_ (W)w);	5158	clear_pending (EV_A_ (W)w);
4843	if (expect_false (!ev_is_active (w)))	5159	if (ecb_expect_false (!ev_is_active (w)))
4844	return;	5160	return;
4845		5161
4846	EV_FREQUENT_CHECK;	5162	EV_FREQUENT_CHECK;
4847		5163
4848	ev_io_stop (EV_A_ &w->io);	5164	ev_io_stop (EV_A_ &w->io);
4849	ev_prepare_stop (EV_A_ &w->prepare);	5165	ev_prepare_stop (EV_A_ &w->prepare);
		5166	#if EV_FORK_ENABLE
4850	ev_fork_stop (EV_A_ &w->fork);	5167	ev_fork_stop (EV_A_ &w->fork);
		5168	#endif
4851		5169
4852	ev_stop (EV_A_ (W)w);	5170	ev_stop (EV_A_ (W)w);
4853		5171
4854	EV_FREQUENT_CHECK;	5172	EV_FREQUENT_CHECK;
4855	}	5173	}
…		…
4857		5175
4858	#if EV_FORK_ENABLE	5176	#if EV_FORK_ENABLE
4859	void	5177	void
4860	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT	5178	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4861	{	5179	{
4862	if (expect_false (ev_is_active (w)))	5180	if (ecb_expect_false (ev_is_active (w)))
4863	return;	5181	return;
4864		5182
4865	EV_FREQUENT_CHECK;	5183	EV_FREQUENT_CHECK;
4866		5184
4867	ev_start (EV_A_ (W)w, ++forkcnt);	5185	ev_start (EV_A_ (W)w, ++forkcnt);
…		…
4873		5191
4874	void	5192	void
4875	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT	5193	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4876	{	5194	{
4877	clear_pending (EV_A_ (W)w);	5195	clear_pending (EV_A_ (W)w);
4878	if (expect_false (!ev_is_active (w)))	5196	if (ecb_expect_false (!ev_is_active (w)))
4879	return;	5197	return;
4880		5198
4881	EV_FREQUENT_CHECK;	5199	EV_FREQUENT_CHECK;
4882		5200
4883	{	5201	{
…		…
4895		5213
4896	#if EV_CLEANUP_ENABLE	5214	#if EV_CLEANUP_ENABLE
4897	void	5215	void
4898	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5216	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4899	{	5217	{
4900	if (expect_false (ev_is_active (w)))	5218	if (ecb_expect_false (ev_is_active (w)))
4901	return;	5219	return;
4902		5220
4903	EV_FREQUENT_CHECK;	5221	EV_FREQUENT_CHECK;
4904		5222
4905	ev_start (EV_A_ (W)w, ++cleanupcnt);	5223	ev_start (EV_A_ (W)w, ++cleanupcnt);
…		…
4913		5231
4914	void	5232	void
4915	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5233	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4916	{	5234	{
4917	clear_pending (EV_A_ (W)w);	5235	clear_pending (EV_A_ (W)w);
4918	if (expect_false (!ev_is_active (w)))	5236	if (ecb_expect_false (!ev_is_active (w)))
4919	return;	5237	return;
4920		5238
4921	EV_FREQUENT_CHECK;	5239	EV_FREQUENT_CHECK;
4922	ev_ref (EV_A);	5240	ev_ref (EV_A);
4923		5241
…		…
4936		5254
4937	#if EV_ASYNC_ENABLE	5255	#if EV_ASYNC_ENABLE
4938	void	5256	void
4939	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT	5257	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4940	{	5258	{
4941	if (expect_false (ev_is_active (w)))	5259	if (ecb_expect_false (ev_is_active (w)))
4942	return;	5260	return;
4943		5261
4944	w->sent = 0;	5262	w->sent = 0;
4945		5263
4946	evpipe_init (EV_A);	5264	evpipe_init (EV_A);
…		…
4956		5274
4957	void	5275	void
4958	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT	5276	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4959	{	5277	{
4960	clear_pending (EV_A_ (W)w);	5278	clear_pending (EV_A_ (W)w);
4961	if (expect_false (!ev_is_active (w)))	5279	if (ecb_expect_false (!ev_is_active (w)))
4962	return;	5280	return;
4963		5281
4964	EV_FREQUENT_CHECK;	5282	EV_FREQUENT_CHECK;
4965		5283
4966	{	5284	{

Diff Legend

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