ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.491 by root, Thu Jun 20 23:14:53 2019 UTC vs.
Revision 1.522 by root, Tue Dec 31 06:02:28 2019 UTC

…		…
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	120	# if HAVE_LINUX_AIO_ABI_H
121	# ifndef EV_USE_LINUXAIO	121	# ifndef EV_USE_LINUXAIO
122	# define EV_USE_LINUXAIO EV_FEATURE_BACKENDS	122	# define EV_USE_LINUXAIO 0 /* was: EV_FEATURE_BACKENDS, always off by default */
123	# endif	123	# endif
124	# else	124	# else
125	# undef EV_USE_LINUXAIO	125	# undef EV_USE_LINUXAIO
126	# define EV_USE_LINUXAIO 0	126	# define EV_USE_LINUXAIO 0
127	# endif	127	# endif
128		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
129	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H	138	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
130	# ifndef EV_USE_KQUEUE	139	# ifndef EV_USE_KQUEUE
131	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS	140	# define EV_USE_KQUEUE EV_FEATURE_BACKENDS
132	# endif	141	# endif
133	# else	142	# else
…		…
168	# endif	177	# endif
169	# else	178	# else
170	# undef EV_USE_EVENTFD	179	# undef EV_USE_EVENTFD
171	# define EV_USE_EVENTFD 0	180	# define EV_USE_EVENTFD 0
172	# endif	181	# endif
173		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
174	#endif	192	#endif
175		193
176	/* OS X, in its infinite idiocy, actually HARDCODES	194	/* OS X, in its infinite idiocy, actually HARDCODES
177	* a limit of 1024 into their select. Where people have brains,	195	* a limit of 1024 into their select. Where people have brains,
178	* OS X engineers apparently have a vacuum. Or maybe they were	196	* OS X engineers apparently have a vacuum. Or maybe they were
…		…
325	#ifndef EV_USE_PORT	343	#ifndef EV_USE_PORT
326	# define EV_USE_PORT 0	344	# define EV_USE_PORT 0
327	#endif	345	#endif
328		346
329	#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
330	# 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
331	#endif	361	#endif
332		362
333	#ifndef EV_USE_INOTIFY	363	#ifndef EV_USE_INOTIFY
334	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))	364	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
335	# define EV_USE_INOTIFY EV_FEATURE_OS	365	# define EV_USE_INOTIFY EV_FEATURE_OS
…		…
357	#ifndef EV_USE_SIGNALFD	387	#ifndef EV_USE_SIGNALFD
358	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))	388	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
359	# define EV_USE_SIGNALFD EV_FEATURE_OS	389	# define EV_USE_SIGNALFD EV_FEATURE_OS
360	# else	390	# else
361	# 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
362	# endif	400	# endif
363	#endif	401	#endif
364		402
365	#if 0 /* debugging */	403	#if 0 /* debugging */
366	# define EV_VERIFY 3	404	# define EV_VERIFY 3
…		…
392	/* aix's poll.h seems to cause lots of trouble */	430	/* aix's poll.h seems to cause lots of trouble */
393	#ifdef _AIX	431	#ifdef _AIX
394	/* AIX has a completely broken poll.h header */	432	/* AIX has a completely broken poll.h header */
395	# undef EV_USE_POLL	433	# undef EV_USE_POLL
396	# define EV_USE_POLL 0	434	# define EV_USE_POLL 0
397	#endif
398
399	#if EV_USE_LINUXAIO
400	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
401	#endif	435	#endif
402		436
403	/* 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, */
404	/* which makes programs even slower. might work on other unices, too. */	438	/* which makes programs even slower. might work on other unices, too. */
405	#if EV_USE_CLOCK_SYSCALL	439	#if EV_USE_CLOCK_SYSCALL
406	# include <sys/syscall.h>	440	# include <sys/syscall.h>
407	# ifdef SYS_clock_gettime	441	# ifdef SYS_clock_gettime
408	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))	442	# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
409	# undef EV_USE_MONOTONIC	443	# undef EV_USE_MONOTONIC
410	# define EV_USE_MONOTONIC 1	444	# define EV_USE_MONOTONIC 1
		445	# define EV_NEED_SYSCALL 1
411	# else	446	# else
412	# undef EV_USE_CLOCK_SYSCALL	447	# undef EV_USE_CLOCK_SYSCALL
413	# define EV_USE_CLOCK_SYSCALL 0	448	# define EV_USE_CLOCK_SYSCALL 0
414	# endif	449	# endif
415	#endif	450	#endif
…		…
427	#endif	462	#endif
428		463
429	#if !EV_STAT_ENABLE	464	#if !EV_STAT_ENABLE
430	# undef EV_USE_INOTIFY	465	# undef EV_USE_INOTIFY
431	# define EV_USE_INOTIFY 0	466	# define EV_USE_INOTIFY 0
		467	#endif
		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
432	#endif	475	#endif
433		476
434	#if !EV_USE_NANOSLEEP	477	#if !EV_USE_NANOSLEEP
435	/* 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 */
436	# if !defined _WIN32 && !defined __hpux	479	# if !defined _WIN32 && !defined __hpux
…		…
438	# endif	481	# endif
439	#endif	482	#endif
440		483
441	#if EV_USE_LINUXAIO	484	#if EV_USE_LINUXAIO
442	# include <sys/syscall.h>	485	# include <sys/syscall.h>
443	# if !SYS_io_getevents	486	# if SYS_io_getevents && EV_USE_EPOLL /* linuxaio backend requires epoll backend */
		487	# define EV_NEED_SYSCALL 1
		488	# else
444	# undef EV_USE_LINUXAIO	489	# undef EV_USE_LINUXAIO
445	# define EV_USE_LINUXAIO 0	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
446	# endif	506	# endif
447	#endif	507	#endif
448		508
449	#if EV_USE_INOTIFY	509	#if EV_USE_INOTIFY
450	# include <sys/statfs.h>	510	# include <sys/statfs.h>
…		…
455	# define EV_USE_INOTIFY 0	515	# define EV_USE_INOTIFY 0
456	# endif	516	# endif
457	#endif	517	#endif
458		518
459	#if EV_USE_EVENTFD	519	#if EV_USE_EVENTFD
460	/* 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 */
461	# include <stdint.h>	521	# include <stdint.h>
462	# ifndef EFD_NONBLOCK	522	# ifndef EFD_NONBLOCK
463	# define EFD_NONBLOCK O_NONBLOCK	523	# define EFD_NONBLOCK O_NONBLOCK
464	# endif	524	# endif
465	# ifndef EFD_CLOEXEC	525	# ifndef EFD_CLOEXEC
…		…
471	# endif	531	# endif
472	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);	532	EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
473	#endif	533	#endif
474		534
475	#if EV_USE_SIGNALFD	535	#if EV_USE_SIGNALFD
476	/* 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 */
477	# include <stdint.h>	537	# include <stdint.h>
478	# ifndef SFD_NONBLOCK	538	# ifndef SFD_NONBLOCK
479	# define SFD_NONBLOCK O_NONBLOCK	539	# define SFD_NONBLOCK O_NONBLOCK
480	# endif	540	# endif
481	# ifndef SFD_CLOEXEC	541	# ifndef SFD_CLOEXEC
…		…
483	# define SFD_CLOEXEC O_CLOEXEC	543	# define SFD_CLOEXEC O_CLOEXEC
484	# else	544	# else
485	# define SFD_CLOEXEC 02000000	545	# define SFD_CLOEXEC 02000000
486	# endif	546	# endif
487	# endif	547	# endif
488	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);
489		549
490	struct signalfd_siginfo	550	struct signalfd_siginfo
491	{	551	{
492	uint32_t ssi_signo;	552	uint32_t ssi_signo;
493	char pad[128 - sizeof (uint32_t)];	553	char pad[128 - sizeof (uint32_t)];
494	};	554	};
495	#endif	555	#endif
496		556
497	/**/	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	/*****************************************************************************/
498		568
499	#if EV_VERIFY >= 3	569	#if EV_VERIFY >= 3
500	# define EV_FREQUENT_CHECK ev_verify (EV_A)	570	# define EV_FREQUENT_CHECK ev_verify (EV_A)
501	#else	571	#else
502	# define EV_FREQUENT_CHECK do { } while (0)	572	# define EV_FREQUENT_CHECK do { } while (0)
…		…
507	* This value is good at least till the year 4000.	577	* This value is good at least till the year 4000.
508	*/	578	*/
509	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */	579	#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
510	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */	580	/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
511		581
512	#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) */
513	#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) */
514		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
515	#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)
516	#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
517		602
518	/* 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 */
519	/* ECB.H BEGIN */	604	/* ECB.H BEGIN */
520	/*	605	/*
521	* libecb - http://software.schmorp.de/pkg/libecb	606	* libecb - http://software.schmorp.de/pkg/libecb
…		…
559		644
560	#ifndef ECB_H	645	#ifndef ECB_H
561	#define ECB_H	646	#define ECB_H
562		647
563	/* 16 bits major, 16 bits minor */	648	/* 16 bits major, 16 bits minor */
564	#define ECB_VERSION 0x00010005	649	#define ECB_VERSION 0x00010006
565		650
566	#ifdef _WIN32	651	#ifdef _WIN32
567	typedef signed char int8_t;	652	typedef signed char int8_t;
568	typedef unsigned char uint8_t;	653	typedef unsigned char uint8_t;
569	typedef signed short int16_t;	654	typedef signed short int16_t;
…		…
683	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */	768	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
684	#endif	769	#endif
685		770
686	#ifndef ECB_MEMORY_FENCE	771	#ifndef ECB_MEMORY_FENCE
687	#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")
688	#if __i386 || __i386__	774	#if __i386 || __i386__
689	#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")
690	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")	776	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
691	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")	777	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
692	#elif ECB_GCC_AMD64	778	#elif ECB_GCC_AMD64
…		…
742	#if ECB_GCC_VERSION(4,7)	828	#if ECB_GCC_VERSION(4,7)
743	/* see comment below (stdatomic.h) about the C11 memory model. */	829	/* see comment below (stdatomic.h) about the C11 memory model. */
744	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)	830	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
745	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)	831	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
746	#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)
747		834
748	#elif ECB_CLANG_EXTENSION(c_atomic)	835	#elif ECB_CLANG_EXTENSION(c_atomic)
749	/* see comment below (stdatomic.h) about the C11 memory model. */	836	/* see comment below (stdatomic.h) about the C11 memory model. */
750	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)	837	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
751	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)	838	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
752	#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)
753		841
754	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__	842	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
755	#define ECB_MEMORY_FENCE __sync_synchronize ()	843	#define ECB_MEMORY_FENCE __sync_synchronize ()
756	#elif _MSC_VER >= 1500 /* VC++ 2008 */	844	#elif _MSC_VER >= 1500 /* VC++ 2008 */
757	/* 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... */
…		…
767	#elif defined _WIN32	855	#elif defined _WIN32
768	#include <WinNT.h>	856	#include <WinNT.h>
769	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */	857	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
770	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	858	#elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
771	#include <mbarrier.h>	859	#include <mbarrier.h>
772	#define ECB_MEMORY_FENCE __machine_rw_barrier ()	860	#define ECB_MEMORY_FENCE __machine_rw_barrier ()
773	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()	861	#define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
774	#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 ()
775	#elif __xlC__	864	#elif __xlC__
776	#define ECB_MEMORY_FENCE __sync ()	865	#define ECB_MEMORY_FENCE __sync ()
777	#endif	866	#endif
778	#endif	867	#endif
779		868
780	#ifndef ECB_MEMORY_FENCE	869	#ifndef ECB_MEMORY_FENCE
781	#if ECB_C11 && !defined __STDC_NO_ATOMICS__	870	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
782	/* 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, */
783	/* not just C11 atomics and atomic accesses */	872	/* not just C11 atomics and atomic accesses */
784	#include <stdatomic.h>	873	#include <stdatomic.h>
785	/* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
786	/* any fence other than seq_cst, which isn't very efficient for us. */
787	/* Why that is, we don't know - either the C11 memory model is quite useless */
788	/* for most usages, or gcc and clang have a bug */
789	/* I *currently* lean towards the latter, and inefficiently implement */
790	/* all three of ecb's fences as a seq_cst fence */
791	/* Update, gcc-4.8 generates mfence for all c++ fences, but nothing */
792	/* for all __atomic_thread_fence's except seq_cst */
793	#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)
794	#endif	877	#endif
795	#endif	878	#endif
796		879
797	#ifndef ECB_MEMORY_FENCE	880	#ifndef ECB_MEMORY_FENCE
798	#if !ECB_AVOID_PTHREADS	881	#if !ECB_AVOID_PTHREADS
…		…
816	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	899	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
817	#endif	900	#endif
818		901
819	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE	902	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
820	#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 */
821	#endif	908	#endif
822		909
823	/*****************************************************************************/	910	/*****************************************************************************/
824		911
825	#if ECB_CPP	912	#if ECB_CPP
…		…
1534	/* ECB.H END */	1621	/* ECB.H END */
1535		1622
1536	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1623	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1537	/* 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
1538	* 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
1539	* 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
1540	* libev, in which cases the memory fences become nops.	1627	* libev, in which cases the memory fences become nops.
1541	* alternatively, you can remove this #error and link against libpthread,	1628	* alternatively, you can remove this #error and link against libpthread,
1542	* which will then provide the memory fences.	1629	* which will then provide the memory fences.
1543	*/	1630	*/
1544	# error "memory fences not defined for your architecture, please report"	1631	# error "memory fences not defined for your architecture, please report"
…		…
1548	# define ECB_MEMORY_FENCE do { } while (0)	1635	# define ECB_MEMORY_FENCE do { } while (0)
1549	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	1636	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1550	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	1637	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1551	#endif	1638	#endif
1552		1639
1553	#define expect_false(cond) ecb_expect_false (cond)
1554	#define expect_true(cond) ecb_expect_true (cond)
1555	#define noinline ecb_noinline
1556
1557	#define inline_size ecb_inline	1640	#define inline_size ecb_inline
1558		1641
1559	#if EV_FEATURE_CODE	1642	#if EV_FEATURE_CODE
1560	# define inline_speed ecb_inline	1643	# define inline_speed ecb_inline
1561	#else	1644	#else
1562	# define inline_speed noinline static	1645	# define inline_speed ecb_noinline static
1563	#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	/*****************************************************************************/
1564		1713
1565	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1714	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1566		1715
1567	#if EV_MINPRI == EV_MAXPRI	1716	#if EV_MINPRI == EV_MAXPRI
1568	# define ABSPRI(w) (((W)w), 0)	1717	# define ABSPRI(w) (((W)w), 0)
…		…
1603	# include "ev_win32.c"	1752	# include "ev_win32.c"
1604	#endif	1753	#endif
1605		1754
1606	/*****************************************************************************/	1755	/*****************************************************************************/
1607		1756
		1757	#if EV_USE_LINUXAIO
		1758	# include <linux/aio_abi.h> /* probably only needed for aio_context_t */
		1759	#endif
		1760
1608	/* define a suitable floor function (only used by periodics atm) */	1761	/* define a suitable floor function (only used by periodics atm) */
1609		1762
1610	#if EV_USE_FLOOR	1763	#if EV_USE_FLOOR
1611	# include <math.h>	1764	# include <math.h>
1612	# define ev_floor(v) floor (v)	1765	# define ev_floor(v) floor (v)
1613	#else	1766	#else
1614		1767
1615	#include <float.h>	1768	#include <float.h>
1616		1769
1617	/* a floor() replacement function, should be independent of ev_tstamp type */	1770	/* a floor() replacement function, should be independent of ev_tstamp type */
1618	noinline	1771	ecb_noinline
1619	static ev_tstamp	1772	static ev_tstamp
1620	ev_floor (ev_tstamp v)	1773	ev_floor (ev_tstamp v)
1621	{	1774	{
1622	/* the choice of shift factor is not terribly important */	1775	/* the choice of shift factor is not terribly important */
1623	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1776	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1624	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1777	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1625	#else	1778	#else
1626	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1779	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1627	#endif	1780	#endif
1628		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
1629	/* argument too large for an unsigned long? */	1790	/* argument too large for an unsigned long? then reduce it */
1630	if (expect_false (v >= shift))	1791	if (ecb_expect_false (v >= shift))
1631	{	1792	{
1632	ev_tstamp f;	1793	ev_tstamp f;
1633		1794
1634	if (v == v - 1.)	1795	if (v == v - 1.)
1635	return v; /* very large number */	1796	return v; /* very large numbers are assumed to be integer */
1636		1797
1637	f = shift * ev_floor (v * (1. / shift));	1798	f = shift * ev_floor (v * (1. / shift));
1638	return f + ev_floor (v - f);	1799	return f + ev_floor (v - f);
1639	}	1800	}
1640		1801
1641	/* special treatment for negative args? */
1642	if (expect_false (v < 0.))
1643	{
1644	ev_tstamp f = -ev_floor (-v);
1645
1646	return f - (f == v ? 0 : 1);
1647	}
1648
1649	/* fits into an unsigned long */	1802	/* fits into an unsigned long */
1650	return (unsigned long)v;	1803	return (unsigned long)v;
1651	}	1804	}
1652		1805
1653	#endif	1806	#endif
…		…
1656		1809
1657	#ifdef __linux	1810	#ifdef __linux
1658	# include <sys/utsname.h>	1811	# include <sys/utsname.h>
1659	#endif	1812	#endif
1660		1813
1661	noinline ecb_cold	1814	ecb_noinline ecb_cold
1662	static unsigned int	1815	static unsigned int
1663	ev_linux_version (void)	1816	ev_linux_version (void)
1664	{	1817	{
1665	#ifdef __linux	1818	#ifdef __linux
1666	unsigned int v = 0;	1819	unsigned int v = 0;
…		…
1696	}	1849	}
1697		1850
1698	/*****************************************************************************/	1851	/*****************************************************************************/
1699		1852
1700	#if EV_AVOID_STDIO	1853	#if EV_AVOID_STDIO
1701	noinline ecb_cold	1854	ecb_noinline ecb_cold
1702	static void	1855	static void
1703	ev_printerr (const char *msg)	1856	ev_printerr (const char *msg)
1704	{	1857	{
1705	write (STDERR_FILENO, msg, strlen (msg));	1858	write (STDERR_FILENO, msg, strlen (msg));
1706	}	1859	}
…		…
1713	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
1714	{	1867	{
1715	syserr_cb = cb;	1868	syserr_cb = cb;
1716	}	1869	}
1717		1870
1718	noinline ecb_cold	1871	ecb_noinline ecb_cold
1719	static void	1872	static void
1720	ev_syserr (const char *msg)	1873	ev_syserr (const char *msg)
1721	{	1874	{
1722	if (!msg)	1875	if (!msg)
1723	msg = "(libev) system error";	1876	msg = "(libev) system error";
…		…
1795	{	1948	{
1796	WL head;	1949	WL head;
1797	unsigned char events; /* the events watched for */	1950	unsigned char events; /* the events watched for */
1798	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) */
1799	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 */
1800	unsigned char unused;	1953	unsigned char eflags; /* flags field for use by backends */
1801	#if EV_USE_EPOLL	1954	#if EV_USE_EPOLL
1802	unsigned int egen; /* generation counter to counter epoll bugs */	1955	unsigned int egen; /* generation counter to counter epoll bugs */
1803	#endif	1956	#endif
1804	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	1957	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1805	SOCKET handle;	1958	SOCKET handle;
…		…
1859	static struct ev_loop default_loop_struct;	2012	static struct ev_loop default_loop_struct;
1860	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 */
1861		2014
1862	#else	2015	#else
1863		2016
1864	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 */
1865	#define VAR(name,decl) static decl;	2018	#define VAR(name,decl) static decl;
1866	#include "ev_vars.h"	2019	#include "ev_vars.h"
1867	#undef VAR	2020	#undef VAR
1868		2021
1869	static int ev_default_loop_ptr;	2022	static int ev_default_loop_ptr;
1870		2023
1871	#endif	2024	#endif
1872		2025
1873	#if EV_FEATURE_API	2026	#if EV_FEATURE_API
1874	# 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)
1875	# 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)
1876	# define EV_INVOKE_PENDING invoke_cb (EV_A)	2029	# define EV_INVOKE_PENDING invoke_cb (EV_A)
1877	#else	2030	#else
1878	# define EV_RELEASE_CB (void)0	2031	# define EV_RELEASE_CB (void)0
1879	# define EV_ACQUIRE_CB (void)0	2032	# define EV_ACQUIRE_CB (void)0
1880	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)	2033	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
…		…
1887	#ifndef EV_HAVE_EV_TIME	2040	#ifndef EV_HAVE_EV_TIME
1888	ev_tstamp	2041	ev_tstamp
1889	ev_time (void) EV_NOEXCEPT	2042	ev_time (void) EV_NOEXCEPT
1890	{	2043	{
1891	#if EV_USE_REALTIME	2044	#if EV_USE_REALTIME
1892	if (expect_true (have_realtime))	2045	if (ecb_expect_true (have_realtime))
1893	{	2046	{
1894	struct timespec ts;	2047	struct timespec ts;
1895	clock_gettime (CLOCK_REALTIME, &ts);	2048	clock_gettime (CLOCK_REALTIME, &ts);
1896	return ts.tv_sec + ts.tv_nsec * 1e-9;	2049	return EV_TS_GET (ts);
1897	}	2050	}
1898	#endif	2051	#endif
1899		2052
		2053	{
1900	struct timeval tv;	2054	struct timeval tv;
1901	gettimeofday (&tv, 0);	2055	gettimeofday (&tv, 0);
1902	return tv.tv_sec + tv.tv_usec * 1e-6;	2056	return EV_TV_GET (tv);
		2057	}
1903	}	2058	}
1904	#endif	2059	#endif
1905		2060
1906	inline_size ev_tstamp	2061	inline_size ev_tstamp
1907	get_clock (void)	2062	get_clock (void)
1908	{	2063	{
1909	#if EV_USE_MONOTONIC	2064	#if EV_USE_MONOTONIC
1910	if (expect_true (have_monotonic))	2065	if (ecb_expect_true (have_monotonic))
1911	{	2066	{
1912	struct timespec ts;	2067	struct timespec ts;
1913	clock_gettime (CLOCK_MONOTONIC, &ts);	2068	clock_gettime (CLOCK_MONOTONIC, &ts);
1914	return ts.tv_sec + ts.tv_nsec * 1e-9;	2069	return EV_TS_GET (ts);
1915	}	2070	}
1916	#endif	2071	#endif
1917		2072
1918	return ev_time ();	2073	return ev_time ();
1919	}	2074	}
…		…
1927	#endif	2082	#endif
1928		2083
1929	void	2084	void
1930	ev_sleep (ev_tstamp delay) EV_NOEXCEPT	2085	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1931	{	2086	{
1932	if (delay > 0.)	2087	if (delay > EV_TS_CONST (0.))
1933	{	2088	{
1934	#if EV_USE_NANOSLEEP	2089	#if EV_USE_NANOSLEEP
1935	struct timespec ts;	2090	struct timespec ts;
1936		2091
1937	EV_TS_SET (ts, delay);	2092	EV_TS_SET (ts, delay);
1938	nanosleep (&ts, 0);	2093	nanosleep (&ts, 0);
1939	#elif defined _WIN32	2094	#elif defined _WIN32
1940	/* maybe this should round up, as ms is very low resolution */	2095	/* maybe this should round up, as ms is very low resolution */
1941	/* compared to select (µs) or nanosleep (ns) */	2096	/* compared to select (µs) or nanosleep (ns) */
1942	Sleep ((unsigned long)(delay * 1e3));	2097	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
1943	#else	2098	#else
1944	struct timeval tv;	2099	struct timeval tv;
1945		2100
1946	/* 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 */
1947	/* something not guaranteed by newer posix versions, but guaranteed */	2102	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
1977	}	2132	}
1978		2133
1979	return ncur;	2134	return ncur;
1980	}	2135	}
1981		2136
1982	noinline ecb_cold	2137	ecb_noinline ecb_cold
1983	static void *	2138	static void *
1984	array_realloc (int elem, void *base, int *cur, int cnt)	2139	array_realloc (int elem, void *base, int *cur, int cnt)
1985	{	2140	{
1986	*cur = array_nextsize (elem, *cur, cnt);	2141	*cur = array_nextsize (elem, *cur, cnt);
1987	return ev_realloc (base, elem * *cur);	2142	return ev_realloc (base, elem * *cur);
1988	}	2143	}
1989		2144
1990	#define array_needsize_noinit(base,count)	2145	#define array_needsize_noinit(base,offset,count)
1991		2146
1992	#define array_needsize_zerofill(base,count) \	2147	#define array_needsize_zerofill(base,offset,count) \
1993	memset ((void *)(base), 0, sizeof (*(base)) * (count))	2148	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
1994		2149
1995	#define array_needsize(type,base,cur,cnt,init) \	2150	#define array_needsize(type,base,cur,cnt,init) \
1996	if (expect_false ((cnt) > (cur))) \	2151	if (ecb_expect_false ((cnt) > (cur))) \
1997	{ \	2152	{ \
1998	ecb_unused int ocur_ = (cur); \	2153	ecb_unused int ocur_ = (cur); \
1999	(base) = (type *)array_realloc \	2154	(base) = (type *)array_realloc \
2000	(sizeof (type), (base), &(cur), (cnt)); \	2155	(sizeof (type), (base), &(cur), (cnt)); \
2001	init ((base) + (ocur_), (cur) - ocur_); \	2156	init ((base), ocur_, ((cur) - ocur_)); \
2002	}	2157	}
2003		2158
2004	#if 0	2159	#if 0
2005	#define array_slim(type,stem) \	2160	#define array_slim(type,stem) \
2006	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \	2161	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
…		…
2015	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
2016		2171
2017	/*****************************************************************************/	2172	/*****************************************************************************/
2018		2173
2019	/* dummy callback for pending events */	2174	/* dummy callback for pending events */
2020	noinline	2175	ecb_noinline
2021	static void	2176	static void
2022	pendingcb (EV_P_ ev_prepare *w, int revents)	2177	pendingcb (EV_P_ ev_prepare *w, int revents)
2023	{	2178	{
2024	}	2179	}
2025		2180
2026	noinline	2181	ecb_noinline
2027	void	2182	void
2028	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT	2183	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
2029	{	2184	{
2030	W w_ = (W)w;	2185	W w_ = (W)w;
2031	int pri = ABSPRI (w_);	2186	int pri = ABSPRI (w_);
2032		2187
2033	if (expect_false (w_->pending))	2188	if (ecb_expect_false (w_->pending))
2034	pendings [pri][w_->pending - 1].events |= revents;	2189	pendings [pri][w_->pending - 1].events |= revents;
2035	else	2190	else
2036	{	2191	{
2037	w_->pending = ++pendingcnt [pri];	2192	w_->pending = ++pendingcnt [pri];
2038	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);
…		…
2089	inline_speed void	2244	inline_speed void
2090	fd_event (EV_P_ int fd, int revents)	2245	fd_event (EV_P_ int fd, int revents)
2091	{	2246	{
2092	ANFD *anfd = anfds + fd;	2247	ANFD *anfd = anfds + fd;
2093		2248
2094	if (expect_true (!anfd->reify))	2249	if (ecb_expect_true (!anfd->reify))
2095	fd_event_nocheck (EV_A_ fd, revents);	2250	fd_event_nocheck (EV_A_ fd, revents);
2096	}	2251	}
2097		2252
2098	void	2253	void
2099	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
…		…
2107	inline_size void	2262	inline_size void
2108	fd_reify (EV_P)	2263	fd_reify (EV_P)
2109	{	2264	{
2110	int i;	2265	int i;
2111		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
2112	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	2279	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
2113	for (i = 0; i < fdchangecnt; ++i)	2280	for (i = 0; i < changecnt; ++i)
2114	{	2281	{
2115	int fd = fdchanges [i];	2282	int fd = fdchanges [i];
2116	ANFD *anfd = anfds + fd;	2283	ANFD *anfd = anfds + fd;
2117		2284
2118	if (anfd->reify & EV__IOFDSET && anfd->head)	2285	if (anfd->reify & EV__IOFDSET && anfd->head)
…		…
2132	}	2299	}
2133	}	2300	}
2134	}	2301	}
2135	#endif	2302	#endif
2136		2303
2137	for (i = 0; i < fdchangecnt; ++i)	2304	for (i = 0; i < changecnt; ++i)
2138	{	2305	{
2139	int fd = fdchanges [i];	2306	int fd = fdchanges [i];
2140	ANFD *anfd = anfds + fd;	2307	ANFD *anfd = anfds + fd;
2141	ev_io *w;	2308	ev_io *w;
2142		2309
2143	unsigned char o_events = anfd->events;	2310	unsigned char o_events = anfd->events;
2144	unsigned char o_reify = anfd->reify;	2311	unsigned char o_reify = anfd->reify;
2145		2312
2146	anfd->reify = 0;	2313	anfd->reify = 0;
2147		2314
2148	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2315	/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
2149	{	2316	{
2150	anfd->events = 0;	2317	anfd->events = 0;
2151		2318
2152	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)
2153	anfd->events |= (unsigned char)w->events;	2320	anfd->events |= (unsigned char)w->events;
…		…
2158		2325
2159	if (o_reify & EV__IOFDSET)	2326	if (o_reify & EV__IOFDSET)
2160	backend_modify (EV_A_ fd, o_events, anfd->events);	2327	backend_modify (EV_A_ fd, o_events, anfd->events);
2161	}	2328	}
2162		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
2163	fdchangecnt = 0;	2337	fdchangecnt -= changecnt;
2164	}	2338	}
2165		2339
2166	/* something about the given fd changed */	2340	/* something about the given fd changed */
2167	inline_size	2341	inline_size
2168	void	2342	void
2169	fd_change (EV_P_ int fd, int flags)	2343	fd_change (EV_P_ int fd, int flags)
2170	{	2344	{
2171	unsigned char reify = anfds [fd].reify;	2345	unsigned char reify = anfds [fd].reify;
2172	anfds [fd].reify |= flags;	2346	anfds [fd].reify |= flags;
2173		2347
2174	if (expect_true (!reify))	2348	if (ecb_expect_true (!reify))
2175	{	2349	{
2176	++fdchangecnt;	2350	++fdchangecnt;
2177	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);	2351	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
2178	fdchanges [fdchangecnt - 1] = fd;	2352	fdchanges [fdchangecnt - 1] = fd;
2179	}	2353	}
…		…
2202	return fcntl (fd, F_GETFD) != -1;	2376	return fcntl (fd, F_GETFD) != -1;
2203	#endif	2377	#endif
2204	}	2378	}
2205		2379
2206	/* called on EBADF to verify fds */	2380	/* called on EBADF to verify fds */
2207	noinline ecb_cold	2381	ecb_noinline ecb_cold
2208	static void	2382	static void
2209	fd_ebadf (EV_P)	2383	fd_ebadf (EV_P)
2210	{	2384	{
2211	int fd;	2385	int fd;
2212		2386
…		…
2215	if (!fd_valid (fd) && errno == EBADF)	2389	if (!fd_valid (fd) && errno == EBADF)
2216	fd_kill (EV_A_ fd);	2390	fd_kill (EV_A_ fd);
2217	}	2391	}
2218		2392
2219	/* 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 */
2220	noinline ecb_cold	2394	ecb_noinline ecb_cold
2221	static void	2395	static void
2222	fd_enomem (EV_P)	2396	fd_enomem (EV_P)
2223	{	2397	{
2224	int fd;	2398	int fd;
2225		2399
…		…
2230	break;	2404	break;
2231	}	2405	}
2232	}	2406	}
2233		2407
2234	/* 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 */
2235	noinline	2409	ecb_noinline
2236	static void	2410	static void
2237	fd_rearm_all (EV_P)	2411	fd_rearm_all (EV_P)
2238	{	2412	{
2239	int fd;	2413	int fd;
2240		2414
…		…
2294	ev_tstamp minat;	2468	ev_tstamp minat;
2295	ANHE *minpos;	2469	ANHE *minpos;
2296	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;	2470	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
2297		2471
2298	/* find minimum child */	2472	/* find minimum child */
2299	if (expect_true (pos + DHEAP - 1 < E))	2473	if (ecb_expect_true (pos + DHEAP - 1 < E))
2300	{	2474	{
2301	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2475	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2302	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));
2303	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));
2304	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));
2305	}	2479	}
2306	else if (pos < E)	2480	else if (pos < E)
2307	{	2481	{
2308	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2482	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2309	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));
2310	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));
2311	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));
2312	}	2486	}
2313	else	2487	else
2314	break;	2488	break;
2315		2489
2316	if (ANHE_at (he) <= minat)	2490	if (ANHE_at (he) <= minat)
…		…
2324		2498
2325	heap [k] = he;	2499	heap [k] = he;
2326	ev_active (ANHE_w (he)) = k;	2500	ev_active (ANHE_w (he)) = k;
2327	}	2501	}
2328		2502
2329	#else /* 4HEAP */	2503	#else /* not 4HEAP */
2330		2504
2331	#define HEAP0 1	2505	#define HEAP0 1
2332	#define HPARENT(k) ((k) >> 1)	2506	#define HPARENT(k) ((k) >> 1)
2333	#define UPHEAP_DONE(p,k) (!(p))	2507	#define UPHEAP_DONE(p,k) (!(p))
2334		2508
…		…
2406	upheap (heap, i + HEAP0);	2580	upheap (heap, i + HEAP0);
2407	}	2581	}
2408		2582
2409	/*****************************************************************************/	2583	/*****************************************************************************/
2410		2584
2411	/* associate signal watchers to a signal signal */	2585	/* associate signal watchers to a signal */
2412	typedef struct	2586	typedef struct
2413	{	2587	{
2414	EV_ATOMIC_T pending;	2588	EV_ATOMIC_T pending;
2415	#if EV_MULTIPLICITY	2589	#if EV_MULTIPLICITY
2416	EV_P;	2590	EV_P;
…		…
2422		2596
2423	/*****************************************************************************/	2597	/*****************************************************************************/
2424		2598
2425	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2599	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2426		2600
2427	noinline ecb_cold	2601	ecb_noinline ecb_cold
2428	static void	2602	static void
2429	evpipe_init (EV_P)	2603	evpipe_init (EV_P)
2430	{	2604	{
2431	if (!ev_is_active (&pipe_w))	2605	if (!ev_is_active (&pipe_w))
2432	{	2606	{
…		…
2473	inline_speed void	2647	inline_speed void
2474	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	2648	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2475	{	2649	{
2476	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 */
2477		2651
2478	if (expect_true (*flag))	2652	if (ecb_expect_true (*flag))
2479	return;	2653	return;
2480		2654
2481	*flag = 1;	2655	*flag = 1;
2482	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 */
2483		2657
…		…
2560	sig_pending = 0;	2734	sig_pending = 0;
2561		2735
2562	ECB_MEMORY_FENCE;	2736	ECB_MEMORY_FENCE;
2563		2737
2564	for (i = EV_NSIG - 1; i--; )	2738	for (i = EV_NSIG - 1; i--; )
2565	if (expect_false (signals [i].pending))	2739	if (ecb_expect_false (signals [i].pending))
2566	ev_feed_signal_event (EV_A_ i + 1);	2740	ev_feed_signal_event (EV_A_ i + 1);
2567	}	2741	}
2568	#endif	2742	#endif
2569		2743
2570	#if EV_ASYNC_ENABLE	2744	#if EV_ASYNC_ENABLE
…		…
2611	#endif	2785	#endif
2612		2786
2613	ev_feed_signal (signum);	2787	ev_feed_signal (signum);
2614	}	2788	}
2615		2789
2616	noinline	2790	ecb_noinline
2617	void	2791	void
2618	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT	2792	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2619	{	2793	{
2620	WL w;	2794	WL w;
2621		2795
2622	if (expect_false (signum <= 0 || signum >= EV_NSIG))	2796	if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
2623	return;	2797	return;
2624		2798
2625	--signum;	2799	--signum;
2626		2800
2627	#if EV_MULTIPLICITY	2801	#if EV_MULTIPLICITY
2628	/* 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 */
2629	/* or, likely more useful, feeding a signal nobody is waiting for */	2803	/* or, likely more useful, feeding a signal nobody is waiting for */
2630		2804
2631	if (expect_false (signals [signum].loop != EV_A))	2805	if (ecb_expect_false (signals [signum].loop != EV_A))
2632	return;	2806	return;
2633	#endif	2807	#endif
2634		2808
2635	signals [signum].pending = 0;	2809	signals [signum].pending = 0;
2636	ECB_MEMORY_FENCE_RELEASE;	2810	ECB_MEMORY_FENCE_RELEASE;
…		…
2720		2894
2721	#endif	2895	#endif
2722		2896
2723	/*****************************************************************************/	2897	/*****************************************************************************/
2724		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
2725	#if EV_USE_IOCP	2951	#if EV_USE_IOCP
2726	# include "ev_iocp.c"	2952	# include "ev_iocp.c"
2727	#endif	2953	#endif
2728	#if EV_USE_PORT	2954	#if EV_USE_PORT
2729	# include "ev_port.c"	2955	# include "ev_port.c"
2730	#endif	2956	#endif
2731	#if EV_USE_KQUEUE	2957	#if EV_USE_KQUEUE
2732	# include "ev_kqueue.c"	2958	# include "ev_kqueue.c"
2733	#endif	2959	#endif
		2960	#if EV_USE_EPOLL
		2961	# include "ev_epoll.c"
		2962	#endif
2734	#if EV_USE_LINUXAIO	2963	#if EV_USE_LINUXAIO
2735	# include "ev_linuxaio.c"	2964	# include "ev_linuxaio.c"
2736	#endif	2965	#endif
2737	#if EV_USE_EPOLL	2966	#if EV_USE_IOURING
2738	# include "ev_epoll.c"	2967	# include "ev_iouring.c"
2739	#endif	2968	#endif
2740	#if EV_USE_POLL	2969	#if EV_USE_POLL
2741	# include "ev_poll.c"	2970	# include "ev_poll.c"
2742	#endif	2971	#endif
2743	#if EV_USE_SELECT	2972	#if EV_USE_SELECT
…		…
2772	unsigned int	3001	unsigned int
2773	ev_supported_backends (void) EV_NOEXCEPT	3002	ev_supported_backends (void) EV_NOEXCEPT
2774	{	3003	{
2775	unsigned int flags = 0;	3004	unsigned int flags = 0;
2776		3005
2777	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	3006	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2778	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;	3007	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2779	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	3008	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
2780	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;	3009	if (EV_USE_LINUXAIO ) flags |= EVBACKEND_LINUXAIO;
2781	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	3010	if (EV_USE_IOURING && ev_linux_version () >= 0x050601) flags |= EVBACKEND_IOURING; /* 5.6.1+ */
2782	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;	3011	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2783		3012	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
		3013
2784	return flags;	3014	return flags;
2785	}	3015	}
2786		3016
2787	ecb_cold	3017	ecb_cold
2788	unsigned int	3018	unsigned int
…		…
2803	#ifdef __FreeBSD__	3033	#ifdef __FreeBSD__
2804	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) */
2805	#endif	3035	#endif
2806		3036
2807	/* TODO: linuxaio is very experimental */	3037	/* TODO: linuxaio is very experimental */
		3038	#if !EV_RECOMMEND_LINUXAIO
2808	flags &= ~EVBACKEND_LINUXAIO;	3039	flags &= ~EVBACKEND_LINUXAIO;
		3040	#endif
		3041	/* TODO: linuxaio is super experimental */
		3042	#if !EV_RECOMMEND_IOURING
		3043	flags &= ~EVBACKEND_IOURING;
		3044	#endif
2809		3045
2810	return flags;	3046	return flags;
2811	}	3047	}
2812		3048
2813	ecb_cold	3049	ecb_cold
2814	unsigned int	3050	unsigned int
2815	ev_embeddable_backends (void) EV_NOEXCEPT	3051	ev_embeddable_backends (void) EV_NOEXCEPT
2816	{	3052	{
2817	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	3053	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT | EVBACKEND_IOURING;
2818		3054
2819	/* 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 */
2820	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 */
2821	flags &= ~EVBACKEND_EPOLL;	3057	flags &= ~EVBACKEND_EPOLL;
2822		3058
		3059	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
		3060
2823	return flags;	3061	return flags;
2824	}	3062	}
2825		3063
2826	unsigned int	3064	unsigned int
2827	ev_backend (EV_P) EV_NOEXCEPT	3065	ev_backend (EV_P) EV_NOEXCEPT
…		…
2879	acquire_cb = acquire;	3117	acquire_cb = acquire;
2880	}	3118	}
2881	#endif	3119	#endif
2882		3120
2883	/* initialise a loop structure, must be zero-initialised */	3121	/* initialise a loop structure, must be zero-initialised */
2884	noinline ecb_cold	3122	ecb_noinline ecb_cold
2885	static void	3123	static void
2886	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT	3124	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2887	{	3125	{
2888	if (!backend)	3126	if (!backend)
2889	{	3127	{
…		…
2944	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3182	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2945	#endif	3183	#endif
2946	#if EV_USE_SIGNALFD	3184	#if EV_USE_SIGNALFD
2947	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3185	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
2948	#endif	3186	#endif
		3187	#if EV_USE_TIMERFD
		3188	timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
		3189	#endif
2949		3190
2950	if (!(flags & EVBACKEND_MASK))	3191	if (!(flags & EVBACKEND_MASK))
2951	flags |= ev_recommended_backends ();	3192	flags |= ev_recommended_backends ();
2952		3193
2953	#if EV_USE_IOCP	3194	#if EV_USE_IOCP
…		…
2956	#if EV_USE_PORT	3197	#if EV_USE_PORT
2957	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	3198	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2958	#endif	3199	#endif
2959	#if EV_USE_KQUEUE	3200	#if EV_USE_KQUEUE
2960	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);
2961	#endif	3205	#endif
2962	#if EV_USE_LINUXAIO	3206	#if EV_USE_LINUXAIO
2963	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);	3207	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2964	#endif	3208	#endif
2965	#if EV_USE_EPOLL	3209	#if EV_USE_EPOLL
…		…
2994	return;	3238	return;
2995	#endif	3239	#endif
2996		3240
2997	#if EV_CLEANUP_ENABLE	3241	#if EV_CLEANUP_ENABLE
2998	/* queue cleanup watchers (and execute them) */	3242	/* queue cleanup watchers (and execute them) */
2999	if (expect_false (cleanupcnt))	3243	if (ecb_expect_false (cleanupcnt))
3000	{	3244	{
3001	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);	3245	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
3002	EV_INVOKE_PENDING;	3246	EV_INVOKE_PENDING;
3003	}	3247	}
3004	#endif	3248	#endif
…		…
3023	#if EV_USE_SIGNALFD	3267	#if EV_USE_SIGNALFD
3024	if (ev_is_active (&sigfd_w))	3268	if (ev_is_active (&sigfd_w))
3025	close (sigfd);	3269	close (sigfd);
3026	#endif	3270	#endif
3027		3271
		3272	#if EV_USE_TIMERFD
		3273	if (ev_is_active (&timerfd_w))
		3274	close (timerfd);
		3275	#endif
		3276
3028	#if EV_USE_INOTIFY	3277	#if EV_USE_INOTIFY
3029	if (fs_fd >= 0)	3278	if (fs_fd >= 0)
3030	close (fs_fd);	3279	close (fs_fd);
3031	#endif	3280	#endif
3032		3281
…		…
3039	#if EV_USE_PORT	3288	#if EV_USE_PORT
3040	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3289	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
3041	#endif	3290	#endif
3042	#if EV_USE_KQUEUE	3291	#if EV_USE_KQUEUE
3043	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);
3044	#endif	3296	#endif
3045	#if EV_USE_LINUXAIO	3297	#if EV_USE_LINUXAIO
3046	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);	3298	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
3047	#endif	3299	#endif
3048	#if EV_USE_EPOLL	3300	#if EV_USE_EPOLL
…		…
3107	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3359	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
3108	#endif	3360	#endif
3109	#if EV_USE_KQUEUE	3361	#if EV_USE_KQUEUE
3110	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);	3362	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
3111	#endif	3363	#endif
		3364	#if EV_USE_IOURING
		3365	if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
		3366	#endif
3112	#if EV_USE_LINUXAIO	3367	#if EV_USE_LINUXAIO
3113	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);	3368	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
3114	#endif	3369	#endif
3115	#if EV_USE_EPOLL	3370	#if EV_USE_EPOLL
3116	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3371	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
3117	#endif	3372	#endif
3118	#if EV_USE_INOTIFY	3373	#if EV_USE_INOTIFY
3119	infy_fork (EV_A);	3374	infy_fork (EV_A);
3120	#endif	3375	#endif
3121		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
3122	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3398	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
3123	if (ev_is_active (&pipe_w) && postfork != 2)	3399	if (ev_is_active (&pipe_w))
3124	{	3400	{
3125	/* 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 */
3126		3402
3127	ev_ref (EV_A);	3403	ev_ref (EV_A);
3128	ev_io_stop (EV_A_ &pipe_w);	3404	ev_io_stop (EV_A_ &pipe_w);
3129		3405
3130	if (evpipe [0] >= 0)	3406	if (evpipe [0] >= 0)
3131	EV_WIN32_CLOSE_FD (evpipe [0]);	3407	EV_WIN32_CLOSE_FD (evpipe [0]);
3132		3408
3133	evpipe_init (EV_A);	3409	evpipe_init (EV_A);
3134	/* iterate over everything, in case we missed something before */	3410	/* iterate over everything, in case we missed something before */
3135	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3411	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
		3412	}
		3413	#endif
3136	}	3414	}
3137	#endif
3138		3415
3139	postfork = 0;	3416	postfork = 0;
3140	}	3417	}
3141		3418
3142	#if EV_MULTIPLICITY	3419	#if EV_MULTIPLICITY
…		…
3158	}	3435	}
3159		3436
3160	#endif /* multiplicity */	3437	#endif /* multiplicity */
3161		3438
3162	#if EV_VERIFY	3439	#if EV_VERIFY
3163	noinline ecb_cold	3440	ecb_noinline ecb_cold
3164	static void	3441	static void
3165	verify_watcher (EV_P_ W w)	3442	verify_watcher (EV_P_ W w)
3166	{	3443	{
3167	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));
3168		3445
3169	if (w->pending)	3446	if (w->pending)
3170	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));
3171	}	3448	}
3172		3449
3173	noinline ecb_cold	3450	ecb_noinline ecb_cold
3174	static void	3451	static void
3175	verify_heap (EV_P_ ANHE *heap, int N)	3452	verify_heap (EV_P_ ANHE *heap, int N)
3176	{	3453	{
3177	int i;	3454	int i;
3178		3455
…		…
3184		3461
3185	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3462	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
3186	}	3463	}
3187	}	3464	}
3188		3465
3189	noinline ecb_cold	3466	ecb_noinline ecb_cold
3190	static void	3467	static void
3191	array_verify (EV_P_ W *ws, int cnt)	3468	array_verify (EV_P_ W *ws, int cnt)
3192	{	3469	{
3193	while (cnt--)	3470	while (cnt--)
3194	{	3471	{
…		…
3343	count += pendingcnt [pri];	3620	count += pendingcnt [pri];
3344		3621
3345	return count;	3622	return count;
3346	}	3623	}
3347		3624
3348	noinline	3625	ecb_noinline
3349	void	3626	void
3350	ev_invoke_pending (EV_P)	3627	ev_invoke_pending (EV_P)
3351	{	3628	{
3352	pendingpri = NUMPRI;	3629	pendingpri = NUMPRI;
3353		3630
…		…
3372	/* make idle watchers pending. this handles the "call-idle */	3649	/* make idle watchers pending. this handles the "call-idle */
3373	/* only when higher priorities are idle" logic */	3650	/* only when higher priorities are idle" logic */
3374	inline_size void	3651	inline_size void
3375	idle_reify (EV_P)	3652	idle_reify (EV_P)
3376	{	3653	{
3377	if (expect_false (idleall))	3654	if (ecb_expect_false (idleall))
3378	{	3655	{
3379	int pri;	3656	int pri;
3380		3657
3381	for (pri = NUMPRI; pri--; )	3658	for (pri = NUMPRI; pri--; )
3382	{	3659	{
…		…
3412	{	3689	{
3413	ev_at (w) += w->repeat;	3690	ev_at (w) += w->repeat;
3414	if (ev_at (w) < mn_now)	3691	if (ev_at (w) < mn_now)
3415	ev_at (w) = mn_now;	3692	ev_at (w) = mn_now;
3416		3693
3417	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.)));
3418		3695
3419	ANHE_at_cache (timers [HEAP0]);	3696	ANHE_at_cache (timers [HEAP0]);
3420	downheap (timers, timercnt, HEAP0);	3697	downheap (timers, timercnt, HEAP0);
3421	}	3698	}
3422	else	3699	else
…		…
3431	}	3708	}
3432	}	3709	}
3433		3710
3434	#if EV_PERIODIC_ENABLE	3711	#if EV_PERIODIC_ENABLE
3435		3712
3436	noinline	3713	ecb_noinline
3437	static void	3714	static void
3438	periodic_recalc (EV_P_ ev_periodic *w)	3715	periodic_recalc (EV_P_ ev_periodic *w)
3439	{	3716	{
3440	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3717	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3441	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);
…		…
3444	while (at <= ev_rt_now)	3721	while (at <= ev_rt_now)
3445	{	3722	{
3446	ev_tstamp nat = at + w->interval;	3723	ev_tstamp nat = at + w->interval;
3447		3724
3448	/* when resolution fails us, we use ev_rt_now */	3725	/* when resolution fails us, we use ev_rt_now */
3449	if (expect_false (nat == at))	3726	if (ecb_expect_false (nat == at))
3450	{	3727	{
3451	at = ev_rt_now;	3728	at = ev_rt_now;
3452	break;	3729	break;
3453	}	3730	}
3454		3731
…		…
3500	}	3777	}
3501	}	3778	}
3502		3779
3503	/* simply recalculate all periodics */	3780	/* simply recalculate all periodics */
3504	/* 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? */
3505	noinline ecb_cold	3782	ecb_noinline ecb_cold
3506	static void	3783	static void
3507	periodics_reschedule (EV_P)	3784	periodics_reschedule (EV_P)
3508	{	3785	{
3509	int i;	3786	int i;
3510		3787
…		…
3524	reheap (periodics, periodiccnt);	3801	reheap (periodics, periodiccnt);
3525	}	3802	}
3526	#endif	3803	#endif
3527		3804
3528	/* adjust all timers by a given offset */	3805	/* adjust all timers by a given offset */
3529	noinline ecb_cold	3806	ecb_noinline ecb_cold
3530	static void	3807	static void
3531	timers_reschedule (EV_P_ ev_tstamp adjust)	3808	timers_reschedule (EV_P_ ev_tstamp adjust)
3532	{	3809	{
3533	int i;	3810	int i;
3534		3811
…		…
3544	/* also detect if there was a timejump, and act accordingly */	3821	/* also detect if there was a timejump, and act accordingly */
3545	inline_speed void	3822	inline_speed void
3546	time_update (EV_P_ ev_tstamp max_block)	3823	time_update (EV_P_ ev_tstamp max_block)
3547	{	3824	{
3548	#if EV_USE_MONOTONIC	3825	#if EV_USE_MONOTONIC
3549	if (expect_true (have_monotonic))	3826	if (ecb_expect_true (have_monotonic))
3550	{	3827	{
3551	int i;	3828	int i;
3552	ev_tstamp odiff = rtmn_diff;	3829	ev_tstamp odiff = rtmn_diff;
3553		3830
3554	mn_now = get_clock ();	3831	mn_now = get_clock ();
3555		3832
3556	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */	3833	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3557	/* interpolate in the meantime */	3834	/* interpolate in the meantime */
3558	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)))
3559	{	3836	{
3560	ev_rt_now = rtmn_diff + mn_now;	3837	ev_rt_now = rtmn_diff + mn_now;
3561	return;	3838	return;
3562	}	3839	}
3563		3840
…		…
3577	ev_tstamp diff;	3854	ev_tstamp diff;
3578	rtmn_diff = ev_rt_now - mn_now;	3855	rtmn_diff = ev_rt_now - mn_now;
3579		3856
3580	diff = odiff - rtmn_diff;	3857	diff = odiff - rtmn_diff;
3581		3858
3582	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)))
3583	return; /* all is well */	3860	return; /* all is well */
3584		3861
3585	ev_rt_now = ev_time ();	3862	ev_rt_now = ev_time ();
3586	mn_now = get_clock ();	3863	mn_now = get_clock ();
3587	now_floor = mn_now;	3864	now_floor = mn_now;
…		…
3596	else	3873	else
3597	#endif	3874	#endif
3598	{	3875	{
3599	ev_rt_now = ev_time ();	3876	ev_rt_now = ev_time ();
3600		3877
3601	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)))
3602	{	3879	{
3603	/* 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 */
3604	timers_reschedule (EV_A_ ev_rt_now - mn_now);	3881	timers_reschedule (EV_A_ ev_rt_now - mn_now);
3605	#if EV_PERIODIC_ENABLE	3882	#if EV_PERIODIC_ENABLE
3606	periodics_reschedule (EV_A);	3883	periodics_reschedule (EV_A);
…		…
3629	#if EV_VERIFY >= 2	3906	#if EV_VERIFY >= 2
3630	ev_verify (EV_A);	3907	ev_verify (EV_A);
3631	#endif	3908	#endif
3632		3909
3633	#ifndef _WIN32	3910	#ifndef _WIN32
3634	if (expect_false (curpid)) /* penalise the forking check even more */	3911	if (ecb_expect_false (curpid)) /* penalise the forking check even more */
3635	if (expect_false (getpid () != curpid))	3912	if (ecb_expect_false (getpid () != curpid))
3636	{	3913	{
3637	curpid = getpid ();	3914	curpid = getpid ();
3638	postfork = 1;	3915	postfork = 1;
3639	}	3916	}
3640	#endif	3917	#endif
3641		3918
3642	#if EV_FORK_ENABLE	3919	#if EV_FORK_ENABLE
3643	/* we might have forked, so queue fork handlers */	3920	/* we might have forked, so queue fork handlers */
3644	if (expect_false (postfork))	3921	if (ecb_expect_false (postfork))
3645	if (forkcnt)	3922	if (forkcnt)
3646	{	3923	{
3647	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	3924	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3648	EV_INVOKE_PENDING;	3925	EV_INVOKE_PENDING;
3649	}	3926	}
3650	#endif	3927	#endif
3651		3928
3652	#if EV_PREPARE_ENABLE	3929	#if EV_PREPARE_ENABLE
3653	/* queue prepare watchers (and execute them) */	3930	/* queue prepare watchers (and execute them) */
3654	if (expect_false (preparecnt))	3931	if (ecb_expect_false (preparecnt))
3655	{	3932	{
3656	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	3933	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3657	EV_INVOKE_PENDING;	3934	EV_INVOKE_PENDING;
3658	}	3935	}
3659	#endif	3936	#endif
3660		3937
3661	if (expect_false (loop_done))	3938	if (ecb_expect_false (loop_done))
3662	break;	3939	break;
3663		3940
3664	/* we might have forked, so reify kernel state if necessary */	3941	/* we might have forked, so reify kernel state if necessary */
3665	if (expect_false (postfork))	3942	if (ecb_expect_false (postfork))
3666	loop_fork (EV_A);	3943	loop_fork (EV_A);
3667		3944
3668	/* update fd-related kernel structures */	3945	/* update fd-related kernel structures */
3669	fd_reify (EV_A);	3946	fd_reify (EV_A);
3670		3947
…		…
3675		3952
3676	/* remember old timestamp for io_blocktime calculation */	3953	/* remember old timestamp for io_blocktime calculation */
3677	ev_tstamp prev_mn_now = mn_now;	3954	ev_tstamp prev_mn_now = mn_now;
3678		3955
3679	/* update time to cancel out callback processing overhead */	3956	/* update time to cancel out callback processing overhead */
3680	time_update (EV_A_ 1e100);	3957	time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
3681		3958
3682	/* from now on, we want a pipe-wake-up */	3959	/* from now on, we want a pipe-wake-up */
3683	pipe_write_wanted = 1;	3960	pipe_write_wanted = 1;
3684		3961
3685	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 */
3686		3963
3687	if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))	3964	if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3688	{	3965	{
3689	waittime = MAX_BLOCKTIME;	3966	waittime = EV_TS_CONST (MAX_BLOCKTIME);
3690		3967
3691	if (timercnt)	3968	if (timercnt)
3692	{	3969	{
3693	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	3970	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3694	if (waittime > to) waittime = to;	3971	if (waittime > to) waittime = to;
…		…
3701	if (waittime > to) waittime = to;	3978	if (waittime > to) waittime = to;
3702	}	3979	}
3703	#endif	3980	#endif
3704		3981
3705	/* don't let timeouts decrease the waittime below timeout_blocktime */	3982	/* don't let timeouts decrease the waittime below timeout_blocktime */
3706	if (expect_false (waittime < timeout_blocktime))	3983	if (ecb_expect_false (waittime < timeout_blocktime))
3707	waittime = timeout_blocktime;	3984	waittime = timeout_blocktime;
3708		3985
3709	/* at this point, we NEED to wait, so we have to ensure */	3986	/* now there are two more special cases left, either we have
3710	/* 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	*/
3711	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.)
3712	waittime = backend_mintime;	3994	: backend_mintime;
3713		3995
3714	/* extra check because io_blocktime is commonly 0 */	3996	/* extra check because io_blocktime is commonly 0 */
3715	if (expect_false (io_blocktime))	3997	if (ecb_expect_false (io_blocktime))
3716	{	3998	{
3717	sleeptime = io_blocktime - (mn_now - prev_mn_now);	3999	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3718		4000
3719	if (sleeptime > waittime - backend_mintime)	4001	if (sleeptime > waittime - backend_mintime)
3720	sleeptime = waittime - backend_mintime;	4002	sleeptime = waittime - backend_mintime;
3721		4003
3722	if (expect_true (sleeptime > 0.))	4004	if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
3723	{	4005	{
3724	ev_sleep (sleeptime);	4006	ev_sleep (sleeptime);
3725	waittime -= sleeptime;	4007	waittime -= sleeptime;
3726	}	4008	}
3727	}	4009	}
…		…
3741	{	4023	{
3742	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)));
3743	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	4025	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3744	}	4026	}
3745		4027
3746
3747	/* update ev_rt_now, do magic */	4028	/* update ev_rt_now, do magic */
3748	time_update (EV_A_ waittime + sleeptime);	4029	time_update (EV_A_ waittime + sleeptime);
3749	}	4030	}
3750		4031
3751	/* queue pending timers and reschedule them */	4032	/* queue pending timers and reschedule them */
…		…
3759	idle_reify (EV_A);	4040	idle_reify (EV_A);
3760	#endif	4041	#endif
3761		4042
3762	#if EV_CHECK_ENABLE	4043	#if EV_CHECK_ENABLE
3763	/* queue check watchers, to be executed first */	4044	/* queue check watchers, to be executed first */
3764	if (expect_false (checkcnt))	4045	if (ecb_expect_false (checkcnt))
3765	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	4046	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3766	#endif	4047	#endif
3767		4048
3768	EV_INVOKE_PENDING;	4049	EV_INVOKE_PENDING;
3769	}	4050	}
3770	while (expect_true (	4051	while (ecb_expect_true (
3771	activecnt	4052	activecnt
3772	&& !loop_done	4053	&& !loop_done
3773	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))	4054	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3774	));	4055	));
3775		4056
…		…
3802	}	4083	}
3803		4084
3804	void	4085	void
3805	ev_now_update (EV_P) EV_NOEXCEPT	4086	ev_now_update (EV_P) EV_NOEXCEPT
3806	{	4087	{
3807	time_update (EV_A_ 1e100);	4088	time_update (EV_A_ EV_TSTAMP_HUGE);
3808	}	4089	}
3809		4090
3810	void	4091	void
3811	ev_suspend (EV_P) EV_NOEXCEPT	4092	ev_suspend (EV_P) EV_NOEXCEPT
3812	{	4093	{
…		…
3839	inline_size void	4120	inline_size void
3840	wlist_del (WL *head, WL elem)	4121	wlist_del (WL *head, WL elem)
3841	{	4122	{
3842	while (*head)	4123	while (*head)
3843	{	4124	{
3844	if (expect_true (*head == elem))	4125	if (ecb_expect_true (*head == elem))
3845	{	4126	{
3846	*head = elem->next;	4127	*head = elem->next;
3847	break;	4128	break;
3848	}	4129	}
3849		4130
…		…
3866	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT	4147	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3867	{	4148	{
3868	W w_ = (W)w;	4149	W w_ = (W)w;
3869	int pending = w_->pending;	4150	int pending = w_->pending;
3870		4151
3871	if (expect_true (pending))	4152	if (ecb_expect_true (pending))
3872	{	4153	{
3873	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	4154	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3874	p->w = (W)&pending_w;	4155	p->w = (W)&pending_w;
3875	w_->pending = 0;	4156	w_->pending = 0;
3876	return p->events;	4157	return p->events;
…		…
3903	w->active = 0;	4184	w->active = 0;
3904	}	4185	}
3905		4186
3906	/*****************************************************************************/	4187	/*****************************************************************************/
3907		4188
3908	noinline	4189	ecb_noinline
3909	void	4190	void
3910	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT	4191	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3911	{	4192	{
3912	int fd = w->fd;	4193	int fd = w->fd;
3913		4194
3914	if (expect_false (ev_is_active (w)))	4195	if (ecb_expect_false (ev_is_active (w)))
3915	return;	4196	return;
3916		4197
3917	assert (("libev: ev_io_start called with negative fd", fd >= 0));	4198	assert (("libev: ev_io_start called with negative fd", fd >= 0));
3918	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))));
3919		4200
		4201	#if EV_VERIFY >= 2
		4202	assert (("libev: ev_io_start called on watcher with invalid fd", fd_valid (fd)));
		4203	#endif
3920	EV_FREQUENT_CHECK;	4204	EV_FREQUENT_CHECK;
3921		4205
3922	ev_start (EV_A_ (W)w, 1);	4206	ev_start (EV_A_ (W)w, 1);
3923	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);	4207	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);
3924	wlist_add (&anfds[fd].head, (WL)w);	4208	wlist_add (&anfds[fd].head, (WL)w);
…		…
3930	w->events &= ~EV__IOFDSET;	4214	w->events &= ~EV__IOFDSET;
3931		4215
3932	EV_FREQUENT_CHECK;	4216	EV_FREQUENT_CHECK;
3933	}	4217	}
3934		4218
3935	noinline	4219	ecb_noinline
3936	void	4220	void
3937	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT	4221	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3938	{	4222	{
3939	clear_pending (EV_A_ (W)w);	4223	clear_pending (EV_A_ (W)w);
3940	if (expect_false (!ev_is_active (w)))	4224	if (ecb_expect_false (!ev_is_active (w)))
3941	return;	4225	return;
3942		4226
3943	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));
3944		4228
		4229	#if EV_VERIFY >= 2
		4230	assert (("libev: ev_io_stop called on watcher with invalid fd", fd_valid (w->fd)));
		4231	#endif
3945	EV_FREQUENT_CHECK;	4232	EV_FREQUENT_CHECK;
3946		4233
3947	wlist_del (&anfds[w->fd].head, (WL)w);	4234	wlist_del (&anfds[w->fd].head, (WL)w);
3948	ev_stop (EV_A_ (W)w);	4235	ev_stop (EV_A_ (W)w);
3949		4236
3950	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	4237	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3951		4238
3952	EV_FREQUENT_CHECK;	4239	EV_FREQUENT_CHECK;
3953	}	4240	}
3954		4241
3955	noinline	4242	ecb_noinline
3956	void	4243	void
3957	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT	4244	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3958	{	4245	{
3959	if (expect_false (ev_is_active (w)))	4246	if (ecb_expect_false (ev_is_active (w)))
3960	return;	4247	return;
3961		4248
3962	ev_at (w) += mn_now;	4249	ev_at (w) += mn_now;
3963		4250
3964	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.));
…		…
3975	EV_FREQUENT_CHECK;	4262	EV_FREQUENT_CHECK;
3976		4263
3977	/*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));*/
3978	}	4265	}
3979		4266
3980	noinline	4267	ecb_noinline
3981	void	4268	void
3982	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT	4269	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3983	{	4270	{
3984	clear_pending (EV_A_ (W)w);	4271	clear_pending (EV_A_ (W)w);
3985	if (expect_false (!ev_is_active (w)))	4272	if (ecb_expect_false (!ev_is_active (w)))
3986	return;	4273	return;
3987		4274
3988	EV_FREQUENT_CHECK;	4275	EV_FREQUENT_CHECK;
3989		4276
3990	{	4277	{
…		…
3992		4279
3993	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));
3994		4281
3995	--timercnt;	4282	--timercnt;
3996		4283
3997	if (expect_true (active < timercnt + HEAP0))	4284	if (ecb_expect_true (active < timercnt + HEAP0))
3998	{	4285	{
3999	timers [active] = timers [timercnt + HEAP0];	4286	timers [active] = timers [timercnt + HEAP0];
4000	adjustheap (timers, timercnt, active);	4287	adjustheap (timers, timercnt, active);
4001	}	4288	}
4002	}	4289	}
…		…
4006	ev_stop (EV_A_ (W)w);	4293	ev_stop (EV_A_ (W)w);
4007		4294
4008	EV_FREQUENT_CHECK;	4295	EV_FREQUENT_CHECK;
4009	}	4296	}
4010		4297
4011	noinline	4298	ecb_noinline
4012	void	4299	void
4013	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT	4300	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
4014	{	4301	{
4015	EV_FREQUENT_CHECK;	4302	EV_FREQUENT_CHECK;
4016		4303
…		…
4037	}	4324	}
4038		4325
4039	ev_tstamp	4326	ev_tstamp
4040	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT	4327	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
4041	{	4328	{
4042	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.));
4043	}	4330	}
4044		4331
4045	#if EV_PERIODIC_ENABLE	4332	#if EV_PERIODIC_ENABLE
4046	noinline	4333	ecb_noinline
4047	void	4334	void
4048	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT	4335	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4049	{	4336	{
4050	if (expect_false (ev_is_active (w)))	4337	if (ecb_expect_false (ev_is_active (w)))
4051	return;	4338	return;
		4339
		4340	#if EV_USE_TIMERFD
		4341	if (timerfd == -2)
		4342	evtimerfd_init (EV_A);
		4343	#endif
4052		4344
4053	if (w->reschedule_cb)	4345	if (w->reschedule_cb)
4054	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4346	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
4055	else if (w->interval)	4347	else if (w->interval)
4056	{	4348	{
…		…
4072	EV_FREQUENT_CHECK;	4364	EV_FREQUENT_CHECK;
4073		4365
4074	/*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));*/
4075	}	4367	}
4076		4368
4077	noinline	4369	ecb_noinline
4078	void	4370	void
4079	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT	4371	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
4080	{	4372	{
4081	clear_pending (EV_A_ (W)w);	4373	clear_pending (EV_A_ (W)w);
4082	if (expect_false (!ev_is_active (w)))	4374	if (ecb_expect_false (!ev_is_active (w)))
4083	return;	4375	return;
4084		4376
4085	EV_FREQUENT_CHECK;	4377	EV_FREQUENT_CHECK;
4086		4378
4087	{	4379	{
…		…
4089		4381
4090	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));
4091		4383
4092	--periodiccnt;	4384	--periodiccnt;
4093		4385
4094	if (expect_true (active < periodiccnt + HEAP0))	4386	if (ecb_expect_true (active < periodiccnt + HEAP0))
4095	{	4387	{
4096	periodics [active] = periodics [periodiccnt + HEAP0];	4388	periodics [active] = periodics [periodiccnt + HEAP0];
4097	adjustheap (periodics, periodiccnt, active);	4389	adjustheap (periodics, periodiccnt, active);
4098	}	4390	}
4099	}	4391	}
…		…
4101	ev_stop (EV_A_ (W)w);	4393	ev_stop (EV_A_ (W)w);
4102		4394
4103	EV_FREQUENT_CHECK;	4395	EV_FREQUENT_CHECK;
4104	}	4396	}
4105		4397
4106	noinline	4398	ecb_noinline
4107	void	4399	void
4108	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT	4400	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4109	{	4401	{
4110	/* TODO: use adjustheap and recalculation */	4402	/* TODO: use adjustheap and recalculation */
4111	ev_periodic_stop (EV_A_ w);	4403	ev_periodic_stop (EV_A_ w);
…		…
4117	# define SA_RESTART 0	4409	# define SA_RESTART 0
4118	#endif	4410	#endif
4119		4411
4120	#if EV_SIGNAL_ENABLE	4412	#if EV_SIGNAL_ENABLE
4121		4413
4122	noinline	4414	ecb_noinline
4123	void	4415	void
4124	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT	4416	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4125	{	4417	{
4126	if (expect_false (ev_is_active (w)))	4418	if (ecb_expect_false (ev_is_active (w)))
4127	return;	4419	return;
4128		4420
4129	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));
4130		4422
4131	#if EV_MULTIPLICITY	4423	#if EV_MULTIPLICITY
…		…
4200	}	4492	}
4201		4493
4202	EV_FREQUENT_CHECK;	4494	EV_FREQUENT_CHECK;
4203	}	4495	}
4204		4496
4205	noinline	4497	ecb_noinline
4206	void	4498	void
4207	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT	4499	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4208	{	4500	{
4209	clear_pending (EV_A_ (W)w);	4501	clear_pending (EV_A_ (W)w);
4210	if (expect_false (!ev_is_active (w)))	4502	if (ecb_expect_false (!ev_is_active (w)))
4211	return;	4503	return;
4212		4504
4213	EV_FREQUENT_CHECK;	4505	EV_FREQUENT_CHECK;
4214		4506
4215	wlist_del (&signals [w->signum - 1].head, (WL)w);	4507	wlist_del (&signals [w->signum - 1].head, (WL)w);
…		…
4248	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT	4540	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4249	{	4541	{
4250	#if EV_MULTIPLICITY	4542	#if EV_MULTIPLICITY
4251	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));
4252	#endif	4544	#endif
4253	if (expect_false (ev_is_active (w)))	4545	if (ecb_expect_false (ev_is_active (w)))
4254	return;	4546	return;
4255		4547
4256	EV_FREQUENT_CHECK;	4548	EV_FREQUENT_CHECK;
4257		4549
4258	ev_start (EV_A_ (W)w, 1);	4550	ev_start (EV_A_ (W)w, 1);
…		…
4263		4555
4264	void	4556	void
4265	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT	4557	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4266	{	4558	{
4267	clear_pending (EV_A_ (W)w);	4559	clear_pending (EV_A_ (W)w);
4268	if (expect_false (!ev_is_active (w)))	4560	if (ecb_expect_false (!ev_is_active (w)))
4269	return;	4561	return;
4270		4562
4271	EV_FREQUENT_CHECK;	4563	EV_FREQUENT_CHECK;
4272		4564
4273	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);	4565	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
…		…
4287		4579
4288	#define DEF_STAT_INTERVAL 5.0074891	4580	#define DEF_STAT_INTERVAL 5.0074891
4289	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4581	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
4290	#define MIN_STAT_INTERVAL 0.1074891	4582	#define MIN_STAT_INTERVAL 0.1074891
4291		4583
4292	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);
4293		4585
4294	#if EV_USE_INOTIFY	4586	#if EV_USE_INOTIFY
4295		4587
4296	/* 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 */
4297	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4589	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
4298		4590
4299	noinline	4591	ecb_noinline
4300	static void	4592	static void
4301	infy_add (EV_P_ ev_stat *w)	4593	infy_add (EV_P_ ev_stat *w)
4302	{	4594	{
4303	w->wd = inotify_add_watch (fs_fd, w->path,	4595	w->wd = inotify_add_watch (fs_fd, w->path,
4304	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY	4596	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
…		…
4369	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4661	if (ev_is_active (&w->timer)) ev_ref (EV_A);
4370	ev_timer_again (EV_A_ &w->timer);	4662	ev_timer_again (EV_A_ &w->timer);
4371	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4663	if (ev_is_active (&w->timer)) ev_unref (EV_A);
4372	}	4664	}
4373		4665
4374	noinline	4666	ecb_noinline
4375	static void	4667	static void
4376	infy_del (EV_P_ ev_stat *w)	4668	infy_del (EV_P_ ev_stat *w)
4377	{	4669	{
4378	int slot;	4670	int slot;
4379	int wd = w->wd;	4671	int wd = w->wd;
…		…
4387		4679
4388	/* remove this watcher, if others are watching it, they will rearm */	4680	/* remove this watcher, if others are watching it, they will rearm */
4389	inotify_rm_watch (fs_fd, wd);	4681	inotify_rm_watch (fs_fd, wd);
4390	}	4682	}
4391		4683
4392	noinline	4684	ecb_noinline
4393	static void	4685	static void
4394	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)
4395	{	4687	{
4396	if (slot < 0)	4688	if (slot < 0)
4397	/* overflow, need to check for all hash slots */	4689	/* overflow, need to check for all hash slots */
…		…
4543	w->attr.st_nlink = 0;	4835	w->attr.st_nlink = 0;
4544	else if (!w->attr.st_nlink)	4836	else if (!w->attr.st_nlink)
4545	w->attr.st_nlink = 1;	4837	w->attr.st_nlink = 1;
4546	}	4838	}
4547		4839
4548	noinline	4840	ecb_noinline
4549	static void	4841	static void
4550	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4842	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4551	{	4843	{
4552	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4844	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4553		4845
…		…
4587	}	4879	}
4588		4880
4589	void	4881	void
4590	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT	4882	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4591	{	4883	{
4592	if (expect_false (ev_is_active (w)))	4884	if (ecb_expect_false (ev_is_active (w)))
4593	return;	4885	return;
4594		4886
4595	ev_stat_stat (EV_A_ w);	4887	ev_stat_stat (EV_A_ w);
4596		4888
4597	if (w->interval < MIN_STAT_INTERVAL && w->interval)	4889	if (w->interval < MIN_STAT_INTERVAL && w->interval)
…		…
4619		4911
4620	void	4912	void
4621	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT	4913	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4622	{	4914	{
4623	clear_pending (EV_A_ (W)w);	4915	clear_pending (EV_A_ (W)w);
4624	if (expect_false (!ev_is_active (w)))	4916	if (ecb_expect_false (!ev_is_active (w)))
4625	return;	4917	return;
4626		4918
4627	EV_FREQUENT_CHECK;	4919	EV_FREQUENT_CHECK;
4628		4920
4629	#if EV_USE_INOTIFY	4921	#if EV_USE_INOTIFY
…		…
4644		4936
4645	#if EV_IDLE_ENABLE	4937	#if EV_IDLE_ENABLE
4646	void	4938	void
4647	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT	4939	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4648	{	4940	{
4649	if (expect_false (ev_is_active (w)))	4941	if (ecb_expect_false (ev_is_active (w)))
4650	return;	4942	return;
4651		4943
4652	pri_adjust (EV_A_ (W)w);	4944	pri_adjust (EV_A_ (W)w);
4653		4945
4654	EV_FREQUENT_CHECK;	4946	EV_FREQUENT_CHECK;
…		…
4668		4960
4669	void	4961	void
4670	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT	4962	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4671	{	4963	{
4672	clear_pending (EV_A_ (W)w);	4964	clear_pending (EV_A_ (W)w);
4673	if (expect_false (!ev_is_active (w)))	4965	if (ecb_expect_false (!ev_is_active (w)))
4674	return;	4966	return;
4675		4967
4676	EV_FREQUENT_CHECK;	4968	EV_FREQUENT_CHECK;
4677		4969
4678	{	4970	{
…		…
4691		4983
4692	#if EV_PREPARE_ENABLE	4984	#if EV_PREPARE_ENABLE
4693	void	4985	void
4694	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT	4986	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4695	{	4987	{
4696	if (expect_false (ev_is_active (w)))	4988	if (ecb_expect_false (ev_is_active (w)))
4697	return;	4989	return;
4698		4990
4699	EV_FREQUENT_CHECK;	4991	EV_FREQUENT_CHECK;
4700		4992
4701	ev_start (EV_A_ (W)w, ++preparecnt);	4993	ev_start (EV_A_ (W)w, ++preparecnt);
…		…
4707		4999
4708	void	5000	void
4709	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT	5001	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4710	{	5002	{
4711	clear_pending (EV_A_ (W)w);	5003	clear_pending (EV_A_ (W)w);
4712	if (expect_false (!ev_is_active (w)))	5004	if (ecb_expect_false (!ev_is_active (w)))
4713	return;	5005	return;
4714		5006
4715	EV_FREQUENT_CHECK;	5007	EV_FREQUENT_CHECK;
4716		5008
4717	{	5009	{
…		…
4729		5021
4730	#if EV_CHECK_ENABLE	5022	#if EV_CHECK_ENABLE
4731	void	5023	void
4732	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT	5024	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4733	{	5025	{
4734	if (expect_false (ev_is_active (w)))	5026	if (ecb_expect_false (ev_is_active (w)))
4735	return;	5027	return;
4736		5028
4737	EV_FREQUENT_CHECK;	5029	EV_FREQUENT_CHECK;
4738		5030
4739	ev_start (EV_A_ (W)w, ++checkcnt);	5031	ev_start (EV_A_ (W)w, ++checkcnt);
…		…
4745		5037
4746	void	5038	void
4747	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT	5039	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4748	{	5040	{
4749	clear_pending (EV_A_ (W)w);	5041	clear_pending (EV_A_ (W)w);
4750	if (expect_false (!ev_is_active (w)))	5042	if (ecb_expect_false (!ev_is_active (w)))
4751	return;	5043	return;
4752		5044
4753	EV_FREQUENT_CHECK;	5045	EV_FREQUENT_CHECK;
4754		5046
4755	{	5047	{
…		…
4764	EV_FREQUENT_CHECK;	5056	EV_FREQUENT_CHECK;
4765	}	5057	}
4766	#endif	5058	#endif
4767		5059
4768	#if EV_EMBED_ENABLE	5060	#if EV_EMBED_ENABLE
4769	noinline	5061	ecb_noinline
4770	void	5062	void
4771	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT	5063	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4772	{	5064	{
4773	ev_run (w->other, EVRUN_NOWAIT);	5065	ev_run (w->other, EVRUN_NOWAIT);
4774	}	5066	}
…		…
4798	ev_run (EV_A_ EVRUN_NOWAIT);	5090	ev_run (EV_A_ EVRUN_NOWAIT);
4799	}	5091	}
4800	}	5092	}
4801	}	5093	}
4802		5094
		5095	#if EV_FORK_ENABLE
4803	static void	5096	static void
4804	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)	5097	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4805	{	5098	{
4806	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));
4807		5100
…		…
4814	ev_run (EV_A_ EVRUN_NOWAIT);	5107	ev_run (EV_A_ EVRUN_NOWAIT);
4815	}	5108	}
4816		5109
4817	ev_embed_start (EV_A_ w);	5110	ev_embed_start (EV_A_ w);
4818	}	5111	}
		5112	#endif
4819		5113
4820	#if 0	5114	#if 0
4821	static void	5115	static void
4822	embed_idle_cb (EV_P_ ev_idle *idle, int revents)	5116	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4823	{	5117	{
…		…
4826	#endif	5120	#endif
4827		5121
4828	void	5122	void
4829	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT	5123	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4830	{	5124	{
4831	if (expect_false (ev_is_active (w)))	5125	if (ecb_expect_false (ev_is_active (w)))
4832	return;	5126	return;
4833		5127
4834	{	5128	{
4835	EV_P = w->other;	5129	EV_P = w->other;
4836	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 ()));
…		…
4844		5138
4845	ev_prepare_init (&w->prepare, embed_prepare_cb);	5139	ev_prepare_init (&w->prepare, embed_prepare_cb);
4846	ev_set_priority (&w->prepare, EV_MINPRI);	5140	ev_set_priority (&w->prepare, EV_MINPRI);
4847	ev_prepare_start (EV_A_ &w->prepare);	5141	ev_prepare_start (EV_A_ &w->prepare);
4848		5142
		5143	#if EV_FORK_ENABLE
4849	ev_fork_init (&w->fork, embed_fork_cb);	5144	ev_fork_init (&w->fork, embed_fork_cb);
4850	ev_fork_start (EV_A_ &w->fork);	5145	ev_fork_start (EV_A_ &w->fork);
		5146	#endif
4851		5147
4852	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/	5148	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4853		5149
4854	ev_start (EV_A_ (W)w, 1);	5150	ev_start (EV_A_ (W)w, 1);
4855		5151
…		…
4858		5154
4859	void	5155	void
4860	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT	5156	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4861	{	5157	{
4862	clear_pending (EV_A_ (W)w);	5158	clear_pending (EV_A_ (W)w);
4863	if (expect_false (!ev_is_active (w)))	5159	if (ecb_expect_false (!ev_is_active (w)))
4864	return;	5160	return;
4865		5161
4866	EV_FREQUENT_CHECK;	5162	EV_FREQUENT_CHECK;
4867		5163
4868	ev_io_stop (EV_A_ &w->io);	5164	ev_io_stop (EV_A_ &w->io);
4869	ev_prepare_stop (EV_A_ &w->prepare);	5165	ev_prepare_stop (EV_A_ &w->prepare);
		5166	#if EV_FORK_ENABLE
4870	ev_fork_stop (EV_A_ &w->fork);	5167	ev_fork_stop (EV_A_ &w->fork);
		5168	#endif
4871		5169
4872	ev_stop (EV_A_ (W)w);	5170	ev_stop (EV_A_ (W)w);
4873		5171
4874	EV_FREQUENT_CHECK;	5172	EV_FREQUENT_CHECK;
4875	}	5173	}
…		…
4877		5175
4878	#if EV_FORK_ENABLE	5176	#if EV_FORK_ENABLE
4879	void	5177	void
4880	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT	5178	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4881	{	5179	{
4882	if (expect_false (ev_is_active (w)))	5180	if (ecb_expect_false (ev_is_active (w)))
4883	return;	5181	return;
4884		5182
4885	EV_FREQUENT_CHECK;	5183	EV_FREQUENT_CHECK;
4886		5184
4887	ev_start (EV_A_ (W)w, ++forkcnt);	5185	ev_start (EV_A_ (W)w, ++forkcnt);
…		…
4893		5191
4894	void	5192	void
4895	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT	5193	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4896	{	5194	{
4897	clear_pending (EV_A_ (W)w);	5195	clear_pending (EV_A_ (W)w);
4898	if (expect_false (!ev_is_active (w)))	5196	if (ecb_expect_false (!ev_is_active (w)))
4899	return;	5197	return;
4900		5198
4901	EV_FREQUENT_CHECK;	5199	EV_FREQUENT_CHECK;
4902		5200
4903	{	5201	{
…		…
4915		5213
4916	#if EV_CLEANUP_ENABLE	5214	#if EV_CLEANUP_ENABLE
4917	void	5215	void
4918	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5216	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4919	{	5217	{
4920	if (expect_false (ev_is_active (w)))	5218	if (ecb_expect_false (ev_is_active (w)))
4921	return;	5219	return;
4922		5220
4923	EV_FREQUENT_CHECK;	5221	EV_FREQUENT_CHECK;
4924		5222
4925	ev_start (EV_A_ (W)w, ++cleanupcnt);	5223	ev_start (EV_A_ (W)w, ++cleanupcnt);
…		…
4933		5231
4934	void	5232	void
4935	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5233	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4936	{	5234	{
4937	clear_pending (EV_A_ (W)w);	5235	clear_pending (EV_A_ (W)w);
4938	if (expect_false (!ev_is_active (w)))	5236	if (ecb_expect_false (!ev_is_active (w)))
4939	return;	5237	return;
4940		5238
4941	EV_FREQUENT_CHECK;	5239	EV_FREQUENT_CHECK;
4942	ev_ref (EV_A);	5240	ev_ref (EV_A);
4943		5241
…		…
4956		5254
4957	#if EV_ASYNC_ENABLE	5255	#if EV_ASYNC_ENABLE
4958	void	5256	void
4959	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT	5257	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4960	{	5258	{
4961	if (expect_false (ev_is_active (w)))	5259	if (ecb_expect_false (ev_is_active (w)))
4962	return;	5260	return;
4963		5261
4964	w->sent = 0;	5262	w->sent = 0;
4965		5263
4966	evpipe_init (EV_A);	5264	evpipe_init (EV_A);
…		…
4976		5274
4977	void	5275	void
4978	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT	5276	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4979	{	5277	{
4980	clear_pending (EV_A_ (W)w);	5278	clear_pending (EV_A_ (W)w);
4981	if (expect_false (!ev_is_active (w)))	5279	if (ecb_expect_false (!ev_is_active (w)))
4982	return;	5280	return;
4983		5281
4984	EV_FREQUENT_CHECK;	5282	EV_FREQUENT_CHECK;
4985		5283
4986	{	5284	{

Diff Legend

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