ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.495 by root, Mon Jun 24 21:27:57 2019 UTC vs.
Revision 1.520 by root, Sat Dec 28 07:44:15 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
…		…
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
330	# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */	348	# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */
331	# define EV_USE_LINUXAIO 1	349	# define EV_USE_LINUXAIO 0 /* was: 1, always off by default */
332	# else	350	# else
333	# 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
334	# endif	360	# endif
335	#endif	361	#endif
336		362
337	#ifndef EV_USE_INOTIFY	363	#ifndef EV_USE_INOTIFY
338	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))	364	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
…		…
361	#ifndef EV_USE_SIGNALFD	387	#ifndef EV_USE_SIGNALFD
362	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))	388	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
363	# define EV_USE_SIGNALFD EV_FEATURE_OS	389	# define EV_USE_SIGNALFD EV_FEATURE_OS
364	# else	390	# else
365	# 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
366	# endif	400	# endif
367	#endif	401	#endif
368		402
369	#if 0 /* debugging */	403	#if 0 /* debugging */
370	# define EV_VERIFY 3	404	# define EV_VERIFY 3
…		…
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 || !EV_USE_EPOLL /* ev_linxaio uses ev_poll.c:ev_epoll_create */	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)
…		…
1617	#else	1766	#else
1618		1767
1619	#include <float.h>	1768	#include <float.h>
1620		1769
1621	/* a floor() replacement function, should be independent of ev_tstamp type */	1770	/* a floor() replacement function, should be independent of ev_tstamp type */
1622	noinline	1771	ecb_noinline
1623	static ev_tstamp	1772	static ev_tstamp
1624	ev_floor (ev_tstamp v)	1773	ev_floor (ev_tstamp v)
1625	{	1774	{
1626	/* the choice of shift factor is not terribly important */	1775	/* the choice of shift factor is not terribly important */
1627	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1776	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1628	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1777	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1629	#else	1778	#else
1630	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1779	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1631	#endif	1780	#endif
1632		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
1633	/* argument too large for an unsigned long? */	1790	/* argument too large for an unsigned long? then reduce it */
1634	if (expect_false (v >= shift))	1791	if (ecb_expect_false (v >= shift))
1635	{	1792	{
1636	ev_tstamp f;	1793	ev_tstamp f;
1637		1794
1638	if (v == v - 1.)	1795	if (v == v - 1.)
1639	return v; /* very large number */	1796	return v; /* very large numbers are assumed to be integer */
1640		1797
1641	f = shift * ev_floor (v * (1. / shift));	1798	f = shift * ev_floor (v * (1. / shift));
1642	return f + ev_floor (v - f);	1799	return f + ev_floor (v - f);
1643	}	1800	}
1644		1801
1645	/* special treatment for negative args? */
1646	if (expect_false (v < 0.))
1647	{
1648	ev_tstamp f = -ev_floor (-v);
1649
1650	return f - (f == v ? 0 : 1);
1651	}
1652
1653	/* fits into an unsigned long */	1802	/* fits into an unsigned long */
1654	return (unsigned long)v;	1803	return (unsigned long)v;
1655	}	1804	}
1656		1805
1657	#endif	1806	#endif
…		…
1660		1809
1661	#ifdef __linux	1810	#ifdef __linux
1662	# include <sys/utsname.h>	1811	# include <sys/utsname.h>
1663	#endif	1812	#endif
1664		1813
1665	noinline ecb_cold	1814	ecb_noinline ecb_cold
1666	static unsigned int	1815	static unsigned int
1667	ev_linux_version (void)	1816	ev_linux_version (void)
1668	{	1817	{
1669	#ifdef __linux	1818	#ifdef __linux
1670	unsigned int v = 0;	1819	unsigned int v = 0;
…		…
1700	}	1849	}
1701		1850
1702	/*****************************************************************************/	1851	/*****************************************************************************/
1703		1852
1704	#if EV_AVOID_STDIO	1853	#if EV_AVOID_STDIO
1705	noinline ecb_cold	1854	ecb_noinline ecb_cold
1706	static void	1855	static void
1707	ev_printerr (const char *msg)	1856	ev_printerr (const char *msg)
1708	{	1857	{
1709	write (STDERR_FILENO, msg, strlen (msg));	1858	write (STDERR_FILENO, msg, strlen (msg));
1710	}	1859	}
…		…
1717	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
1718	{	1867	{
1719	syserr_cb = cb;	1868	syserr_cb = cb;
1720	}	1869	}
1721		1870
1722	noinline ecb_cold	1871	ecb_noinline ecb_cold
1723	static void	1872	static void
1724	ev_syserr (const char *msg)	1873	ev_syserr (const char *msg)
1725	{	1874	{
1726	if (!msg)	1875	if (!msg)
1727	msg = "(libev) system error";	1876	msg = "(libev) system error";
…		…
1799	{	1948	{
1800	WL head;	1949	WL head;
1801	unsigned char events; /* the events watched for */	1950	unsigned char events; /* the events watched for */
1802	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) */
1803	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 */
1804	unsigned char unused;	1953	unsigned char eflags; /* flags field for use by backends */
1805	#if EV_USE_EPOLL	1954	#if EV_USE_EPOLL
1806	unsigned int egen; /* generation counter to counter epoll bugs */	1955	unsigned int egen; /* generation counter to counter epoll bugs */
1807	#endif	1956	#endif
1808	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	1957	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1809	SOCKET handle;	1958	SOCKET handle;
…		…
1863	static struct ev_loop default_loop_struct;	2012	static struct ev_loop default_loop_struct;
1864	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 */
1865		2014
1866	#else	2015	#else
1867		2016
1868	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 */
1869	#define VAR(name,decl) static decl;	2018	#define VAR(name,decl) static decl;
1870	#include "ev_vars.h"	2019	#include "ev_vars.h"
1871	#undef VAR	2020	#undef VAR
1872		2021
1873	static int ev_default_loop_ptr;	2022	static int ev_default_loop_ptr;
1874		2023
1875	#endif	2024	#endif
1876		2025
1877	#if EV_FEATURE_API	2026	#if EV_FEATURE_API
1878	# 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)
1879	# 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)
1880	# define EV_INVOKE_PENDING invoke_cb (EV_A)	2029	# define EV_INVOKE_PENDING invoke_cb (EV_A)
1881	#else	2030	#else
1882	# define EV_RELEASE_CB (void)0	2031	# define EV_RELEASE_CB (void)0
1883	# define EV_ACQUIRE_CB (void)0	2032	# define EV_ACQUIRE_CB (void)0
1884	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)	2033	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
…		…
1891	#ifndef EV_HAVE_EV_TIME	2040	#ifndef EV_HAVE_EV_TIME
1892	ev_tstamp	2041	ev_tstamp
1893	ev_time (void) EV_NOEXCEPT	2042	ev_time (void) EV_NOEXCEPT
1894	{	2043	{
1895	#if EV_USE_REALTIME	2044	#if EV_USE_REALTIME
1896	if (expect_true (have_realtime))	2045	if (ecb_expect_true (have_realtime))
1897	{	2046	{
1898	struct timespec ts;	2047	struct timespec ts;
1899	clock_gettime (CLOCK_REALTIME, &ts);	2048	clock_gettime (CLOCK_REALTIME, &ts);
1900	return ts.tv_sec + ts.tv_nsec * 1e-9;	2049	return EV_TS_GET (ts);
1901	}	2050	}
1902	#endif	2051	#endif
1903		2052
		2053	{
1904	struct timeval tv;	2054	struct timeval tv;
1905	gettimeofday (&tv, 0);	2055	gettimeofday (&tv, 0);
1906	return tv.tv_sec + tv.tv_usec * 1e-6;	2056	return EV_TV_GET (tv);
		2057	}
1907	}	2058	}
1908	#endif	2059	#endif
1909		2060
1910	inline_size ev_tstamp	2061	inline_size ev_tstamp
1911	get_clock (void)	2062	get_clock (void)
1912	{	2063	{
1913	#if EV_USE_MONOTONIC	2064	#if EV_USE_MONOTONIC
1914	if (expect_true (have_monotonic))	2065	if (ecb_expect_true (have_monotonic))
1915	{	2066	{
1916	struct timespec ts;	2067	struct timespec ts;
1917	clock_gettime (CLOCK_MONOTONIC, &ts);	2068	clock_gettime (CLOCK_MONOTONIC, &ts);
1918	return ts.tv_sec + ts.tv_nsec * 1e-9;	2069	return EV_TS_GET (ts);
1919	}	2070	}
1920	#endif	2071	#endif
1921		2072
1922	return ev_time ();	2073	return ev_time ();
1923	}	2074	}
…		…
1931	#endif	2082	#endif
1932		2083
1933	void	2084	void
1934	ev_sleep (ev_tstamp delay) EV_NOEXCEPT	2085	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1935	{	2086	{
1936	if (delay > 0.)	2087	if (delay > EV_TS_CONST (0.))
1937	{	2088	{
1938	#if EV_USE_NANOSLEEP	2089	#if EV_USE_NANOSLEEP
1939	struct timespec ts;	2090	struct timespec ts;
1940		2091
1941	EV_TS_SET (ts, delay);	2092	EV_TS_SET (ts, delay);
1942	nanosleep (&ts, 0);	2093	nanosleep (&ts, 0);
1943	#elif defined _WIN32	2094	#elif defined _WIN32
1944	/* maybe this should round up, as ms is very low resolution */	2095	/* maybe this should round up, as ms is very low resolution */
1945	/* compared to select (µs) or nanosleep (ns) */	2096	/* compared to select (µs) or nanosleep (ns) */
1946	Sleep ((unsigned long)(delay * 1e3));	2097	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
1947	#else	2098	#else
1948	struct timeval tv;	2099	struct timeval tv;
1949		2100
1950	/* 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 */
1951	/* something not guaranteed by newer posix versions, but guaranteed */	2102	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
1981	}	2132	}
1982		2133
1983	return ncur;	2134	return ncur;
1984	}	2135	}
1985		2136
1986	noinline ecb_cold	2137	ecb_noinline ecb_cold
1987	static void *	2138	static void *
1988	array_realloc (int elem, void *base, int *cur, int cnt)	2139	array_realloc (int elem, void *base, int *cur, int cnt)
1989	{	2140	{
1990	*cur = array_nextsize (elem, *cur, cnt);	2141	*cur = array_nextsize (elem, *cur, cnt);
1991	return ev_realloc (base, elem * *cur);	2142	return ev_realloc (base, elem * *cur);
…		…
1995		2146
1996	#define array_needsize_zerofill(base,offset,count) \	2147	#define array_needsize_zerofill(base,offset,count) \
1997	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))	2148	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
1998		2149
1999	#define array_needsize(type,base,cur,cnt,init) \	2150	#define array_needsize(type,base,cur,cnt,init) \
2000	if (expect_false ((cnt) > (cur))) \	2151	if (ecb_expect_false ((cnt) > (cur))) \
2001	{ \	2152	{ \
2002	ecb_unused int ocur_ = (cur); \	2153	ecb_unused int ocur_ = (cur); \
2003	(base) = (type *)array_realloc \	2154	(base) = (type *)array_realloc \
2004	(sizeof (type), (base), &(cur), (cnt)); \	2155	(sizeof (type), (base), &(cur), (cnt)); \
2005	init ((base), ocur_, ((cur) - ocur_)); \	2156	init ((base), ocur_, ((cur) - ocur_)); \
…		…
2019	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
2020		2171
2021	/*****************************************************************************/	2172	/*****************************************************************************/
2022		2173
2023	/* dummy callback for pending events */	2174	/* dummy callback for pending events */
2024	noinline	2175	ecb_noinline
2025	static void	2176	static void
2026	pendingcb (EV_P_ ev_prepare *w, int revents)	2177	pendingcb (EV_P_ ev_prepare *w, int revents)
2027	{	2178	{
2028	}	2179	}
2029		2180
2030	noinline	2181	ecb_noinline
2031	void	2182	void
2032	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT	2183	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
2033	{	2184	{
2034	W w_ = (W)w;	2185	W w_ = (W)w;
2035	int pri = ABSPRI (w_);	2186	int pri = ABSPRI (w_);
2036		2187
2037	if (expect_false (w_->pending))	2188	if (ecb_expect_false (w_->pending))
2038	pendings [pri][w_->pending - 1].events |= revents;	2189	pendings [pri][w_->pending - 1].events |= revents;
2039	else	2190	else
2040	{	2191	{
2041	w_->pending = ++pendingcnt [pri];	2192	w_->pending = ++pendingcnt [pri];
2042	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);
…		…
2093	inline_speed void	2244	inline_speed void
2094	fd_event (EV_P_ int fd, int revents)	2245	fd_event (EV_P_ int fd, int revents)
2095	{	2246	{
2096	ANFD *anfd = anfds + fd;	2247	ANFD *anfd = anfds + fd;
2097		2248
2098	if (expect_true (!anfd->reify))	2249	if (ecb_expect_true (!anfd->reify))
2099	fd_event_nocheck (EV_A_ fd, revents);	2250	fd_event_nocheck (EV_A_ fd, revents);
2100	}	2251	}
2101		2252
2102	void	2253	void
2103	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
…		…
2111	inline_size void	2262	inline_size void
2112	fd_reify (EV_P)	2263	fd_reify (EV_P)
2113	{	2264	{
2114	int i;	2265	int i;
2115		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
2116	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	2279	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
2117	for (i = 0; i < fdchangecnt; ++i)	2280	for (i = 0; i < changecnt; ++i)
2118	{	2281	{
2119	int fd = fdchanges [i];	2282	int fd = fdchanges [i];
2120	ANFD *anfd = anfds + fd;	2283	ANFD *anfd = anfds + fd;
2121		2284
2122	if (anfd->reify & EV__IOFDSET && anfd->head)	2285	if (anfd->reify & EV__IOFDSET && anfd->head)
…		…
2136	}	2299	}
2137	}	2300	}
2138	}	2301	}
2139	#endif	2302	#endif
2140		2303
2141	for (i = 0; i < fdchangecnt; ++i)	2304	for (i = 0; i < changecnt; ++i)
2142	{	2305	{
2143	int fd = fdchanges [i];	2306	int fd = fdchanges [i];
2144	ANFD *anfd = anfds + fd;	2307	ANFD *anfd = anfds + fd;
2145	ev_io *w;	2308	ev_io *w;
2146		2309
2147	unsigned char o_events = anfd->events;	2310	unsigned char o_events = anfd->events;
2148	unsigned char o_reify = anfd->reify;	2311	unsigned char o_reify = anfd->reify;
2149		2312
2150	anfd->reify = 0;	2313	anfd->reify = 0;
2151		2314
2152	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2315	/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
2153	{	2316	{
2154	anfd->events = 0;	2317	anfd->events = 0;
2155		2318
2156	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)
2157	anfd->events |= (unsigned char)w->events;	2320	anfd->events |= (unsigned char)w->events;
…		…
2162		2325
2163	if (o_reify & EV__IOFDSET)	2326	if (o_reify & EV__IOFDSET)
2164	backend_modify (EV_A_ fd, o_events, anfd->events);	2327	backend_modify (EV_A_ fd, o_events, anfd->events);
2165	}	2328	}
2166		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
2167	fdchangecnt = 0;	2337	fdchangecnt -= changecnt;
2168	}	2338	}
2169		2339
2170	/* something about the given fd changed */	2340	/* something about the given fd changed */
2171	inline_size	2341	inline_size
2172	void	2342	void
2173	fd_change (EV_P_ int fd, int flags)	2343	fd_change (EV_P_ int fd, int flags)
2174	{	2344	{
2175	unsigned char reify = anfds [fd].reify;	2345	unsigned char reify = anfds [fd].reify;
2176	anfds [fd].reify |= flags;	2346	anfds [fd].reify |= flags;
2177		2347
2178	if (expect_true (!reify))	2348	if (ecb_expect_true (!reify))
2179	{	2349	{
2180	++fdchangecnt;	2350	++fdchangecnt;
2181	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);	2351	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
2182	fdchanges [fdchangecnt - 1] = fd;	2352	fdchanges [fdchangecnt - 1] = fd;
2183	}	2353	}
…		…
2206	return fcntl (fd, F_GETFD) != -1;	2376	return fcntl (fd, F_GETFD) != -1;
2207	#endif	2377	#endif
2208	}	2378	}
2209		2379
2210	/* called on EBADF to verify fds */	2380	/* called on EBADF to verify fds */
2211	noinline ecb_cold	2381	ecb_noinline ecb_cold
2212	static void	2382	static void
2213	fd_ebadf (EV_P)	2383	fd_ebadf (EV_P)
2214	{	2384	{
2215	int fd;	2385	int fd;
2216		2386
…		…
2219	if (!fd_valid (fd) && errno == EBADF)	2389	if (!fd_valid (fd) && errno == EBADF)
2220	fd_kill (EV_A_ fd);	2390	fd_kill (EV_A_ fd);
2221	}	2391	}
2222		2392
2223	/* 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 */
2224	noinline ecb_cold	2394	ecb_noinline ecb_cold
2225	static void	2395	static void
2226	fd_enomem (EV_P)	2396	fd_enomem (EV_P)
2227	{	2397	{
2228	int fd;	2398	int fd;
2229		2399
…		…
2234	break;	2404	break;
2235	}	2405	}
2236	}	2406	}
2237		2407
2238	/* 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 */
2239	noinline	2409	ecb_noinline
2240	static void	2410	static void
2241	fd_rearm_all (EV_P)	2411	fd_rearm_all (EV_P)
2242	{	2412	{
2243	int fd;	2413	int fd;
2244		2414
…		…
2298	ev_tstamp minat;	2468	ev_tstamp minat;
2299	ANHE *minpos;	2469	ANHE *minpos;
2300	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;	2470	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
2301		2471
2302	/* find minimum child */	2472	/* find minimum child */
2303	if (expect_true (pos + DHEAP - 1 < E))	2473	if (ecb_expect_true (pos + DHEAP - 1 < E))
2304	{	2474	{
2305	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2475	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2306	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));
2307	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));
2308	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));
2309	}	2479	}
2310	else if (pos < E)	2480	else if (pos < E)
2311	{	2481	{
2312	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2482	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2313	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));
2314	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));
2315	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));
2316	}	2486	}
2317	else	2487	else
2318	break;	2488	break;
2319		2489
2320	if (ANHE_at (he) <= minat)	2490	if (ANHE_at (he) <= minat)
…		…
2328		2498
2329	heap [k] = he;	2499	heap [k] = he;
2330	ev_active (ANHE_w (he)) = k;	2500	ev_active (ANHE_w (he)) = k;
2331	}	2501	}
2332		2502
2333	#else /* 4HEAP */	2503	#else /* not 4HEAP */
2334		2504
2335	#define HEAP0 1	2505	#define HEAP0 1
2336	#define HPARENT(k) ((k) >> 1)	2506	#define HPARENT(k) ((k) >> 1)
2337	#define UPHEAP_DONE(p,k) (!(p))	2507	#define UPHEAP_DONE(p,k) (!(p))
2338		2508
…		…
2426		2596
2427	/*****************************************************************************/	2597	/*****************************************************************************/
2428		2598
2429	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2599	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2430		2600
2431	noinline ecb_cold	2601	ecb_noinline ecb_cold
2432	static void	2602	static void
2433	evpipe_init (EV_P)	2603	evpipe_init (EV_P)
2434	{	2604	{
2435	if (!ev_is_active (&pipe_w))	2605	if (!ev_is_active (&pipe_w))
2436	{	2606	{
…		…
2477	inline_speed void	2647	inline_speed void
2478	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	2648	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2479	{	2649	{
2480	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 */
2481		2651
2482	if (expect_true (*flag))	2652	if (ecb_expect_true (*flag))
2483	return;	2653	return;
2484		2654
2485	*flag = 1;	2655	*flag = 1;
2486	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 */
2487		2657
…		…
2564	sig_pending = 0;	2734	sig_pending = 0;
2565		2735
2566	ECB_MEMORY_FENCE;	2736	ECB_MEMORY_FENCE;
2567		2737
2568	for (i = EV_NSIG - 1; i--; )	2738	for (i = EV_NSIG - 1; i--; )
2569	if (expect_false (signals [i].pending))	2739	if (ecb_expect_false (signals [i].pending))
2570	ev_feed_signal_event (EV_A_ i + 1);	2740	ev_feed_signal_event (EV_A_ i + 1);
2571	}	2741	}
2572	#endif	2742	#endif
2573		2743
2574	#if EV_ASYNC_ENABLE	2744	#if EV_ASYNC_ENABLE
…		…
2615	#endif	2785	#endif
2616		2786
2617	ev_feed_signal (signum);	2787	ev_feed_signal (signum);
2618	}	2788	}
2619		2789
2620	noinline	2790	ecb_noinline
2621	void	2791	void
2622	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT	2792	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2623	{	2793	{
2624	WL w;	2794	WL w;
2625		2795
2626	if (expect_false (signum <= 0 || signum >= EV_NSIG))	2796	if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
2627	return;	2797	return;
2628		2798
2629	--signum;	2799	--signum;
2630		2800
2631	#if EV_MULTIPLICITY	2801	#if EV_MULTIPLICITY
2632	/* 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 */
2633	/* or, likely more useful, feeding a signal nobody is waiting for */	2803	/* or, likely more useful, feeding a signal nobody is waiting for */
2634		2804
2635	if (expect_false (signals [signum].loop != EV_A))	2805	if (ecb_expect_false (signals [signum].loop != EV_A))
2636	return;	2806	return;
2637	#endif	2807	#endif
2638		2808
2639	signals [signum].pending = 0;	2809	signals [signum].pending = 0;
2640	ECB_MEMORY_FENCE_RELEASE;	2810	ECB_MEMORY_FENCE_RELEASE;
…		…
2724		2894
2725	#endif	2895	#endif
2726		2896
2727	/*****************************************************************************/	2897	/*****************************************************************************/
2728		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
2729	#if EV_USE_IOCP	2951	#if EV_USE_IOCP
2730	# include "ev_iocp.c"	2952	# include "ev_iocp.c"
2731	#endif	2953	#endif
2732	#if EV_USE_PORT	2954	#if EV_USE_PORT
2733	# include "ev_port.c"	2955	# include "ev_port.c"
…		…
2738	#if EV_USE_EPOLL	2960	#if EV_USE_EPOLL
2739	# include "ev_epoll.c"	2961	# include "ev_epoll.c"
2740	#endif	2962	#endif
2741	#if EV_USE_LINUXAIO	2963	#if EV_USE_LINUXAIO
2742	# include "ev_linuxaio.c"	2964	# include "ev_linuxaio.c"
		2965	#endif
		2966	#if EV_USE_IOURING
		2967	# include "ev_iouring.c"
2743	#endif	2968	#endif
2744	#if EV_USE_POLL	2969	#if EV_USE_POLL
2745	# include "ev_poll.c"	2970	# include "ev_poll.c"
2746	#endif	2971	#endif
2747	#if EV_USE_SELECT	2972	#if EV_USE_SELECT
…		…
2776	unsigned int	3001	unsigned int
2777	ev_supported_backends (void) EV_NOEXCEPT	3002	ev_supported_backends (void) EV_NOEXCEPT
2778	{	3003	{
2779	unsigned int flags = 0;	3004	unsigned int flags = 0;
2780		3005
2781	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	3006	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2782	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;	3007	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2783	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	3008	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
2784	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;	3009	if (EV_USE_LINUXAIO ) flags |= EVBACKEND_LINUXAIO;
2785	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	3010	if (EV_USE_IOURING && ev_linux_version () >= 0x050601) flags |= EVBACKEND_IOURING; /* 5.6.1+ */
2786	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;	3011	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2787		3012	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
		3013
2788	return flags;	3014	return flags;
2789	}	3015	}
2790		3016
2791	ecb_cold	3017	ecb_cold
2792	unsigned int	3018	unsigned int
…		…
2810		3036
2811	/* TODO: linuxaio is very experimental */	3037	/* TODO: linuxaio is very experimental */
2812	#if !EV_RECOMMEND_LINUXAIO	3038	#if !EV_RECOMMEND_LINUXAIO
2813	flags &= ~EVBACKEND_LINUXAIO;	3039	flags &= ~EVBACKEND_LINUXAIO;
2814	#endif	3040	#endif
		3041	/* TODO: linuxaio is super experimental */
		3042	#if !EV_RECOMMEND_IOURING
		3043	flags &= ~EVBACKEND_IOURING;
		3044	#endif
2815		3045
2816	return flags;	3046	return flags;
2817	}	3047	}
2818		3048
2819	ecb_cold	3049	ecb_cold
…		…
2824		3054
2825	/* 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 */
2826	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 */
2827	flags &= ~EVBACKEND_EPOLL;	3057	flags &= ~EVBACKEND_EPOLL;
2828		3058
		3059	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
		3060
		3061	/* EVBACKEND_IOURING is practically embeddable, but the current implementation is not
		3062	* because our backend_fd is the epoll fd we need as fallback.
		3063	* if the kernel ever is fixed, this might change...
		3064	*/
		3065
2829	return flags;	3066	return flags;
2830	}	3067	}
2831		3068
2832	unsigned int	3069	unsigned int
2833	ev_backend (EV_P) EV_NOEXCEPT	3070	ev_backend (EV_P) EV_NOEXCEPT
…		…
2885	acquire_cb = acquire;	3122	acquire_cb = acquire;
2886	}	3123	}
2887	#endif	3124	#endif
2888		3125
2889	/* initialise a loop structure, must be zero-initialised */	3126	/* initialise a loop structure, must be zero-initialised */
2890	noinline ecb_cold	3127	ecb_noinline ecb_cold
2891	static void	3128	static void
2892	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT	3129	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2893	{	3130	{
2894	if (!backend)	3131	if (!backend)
2895	{	3132	{
…		…
2950	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3187	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2951	#endif	3188	#endif
2952	#if EV_USE_SIGNALFD	3189	#if EV_USE_SIGNALFD
2953	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3190	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
2954	#endif	3191	#endif
		3192	#if EV_USE_TIMERFD
		3193	timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
		3194	#endif
2955		3195
2956	if (!(flags & EVBACKEND_MASK))	3196	if (!(flags & EVBACKEND_MASK))
2957	flags |= ev_recommended_backends ();	3197	flags |= ev_recommended_backends ();
2958		3198
2959	#if EV_USE_IOCP	3199	#if EV_USE_IOCP
…		…
2962	#if EV_USE_PORT	3202	#if EV_USE_PORT
2963	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	3203	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2964	#endif	3204	#endif
2965	#if EV_USE_KQUEUE	3205	#if EV_USE_KQUEUE
2966	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);	3206	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
		3207	#endif
		3208	#if EV_USE_IOURING
		3209	if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
2967	#endif	3210	#endif
2968	#if EV_USE_LINUXAIO	3211	#if EV_USE_LINUXAIO
2969	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);	3212	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2970	#endif	3213	#endif
2971	#if EV_USE_EPOLL	3214	#if EV_USE_EPOLL
…		…
3000	return;	3243	return;
3001	#endif	3244	#endif
3002		3245
3003	#if EV_CLEANUP_ENABLE	3246	#if EV_CLEANUP_ENABLE
3004	/* queue cleanup watchers (and execute them) */	3247	/* queue cleanup watchers (and execute them) */
3005	if (expect_false (cleanupcnt))	3248	if (ecb_expect_false (cleanupcnt))
3006	{	3249	{
3007	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);	3250	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
3008	EV_INVOKE_PENDING;	3251	EV_INVOKE_PENDING;
3009	}	3252	}
3010	#endif	3253	#endif
…		…
3029	#if EV_USE_SIGNALFD	3272	#if EV_USE_SIGNALFD
3030	if (ev_is_active (&sigfd_w))	3273	if (ev_is_active (&sigfd_w))
3031	close (sigfd);	3274	close (sigfd);
3032	#endif	3275	#endif
3033		3276
		3277	#if EV_USE_TIMERFD
		3278	if (ev_is_active (&timerfd_w))
		3279	close (timerfd);
		3280	#endif
		3281
3034	#if EV_USE_INOTIFY	3282	#if EV_USE_INOTIFY
3035	if (fs_fd >= 0)	3283	if (fs_fd >= 0)
3036	close (fs_fd);	3284	close (fs_fd);
3037	#endif	3285	#endif
3038		3286
…		…
3045	#if EV_USE_PORT	3293	#if EV_USE_PORT
3046	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3294	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
3047	#endif	3295	#endif
3048	#if EV_USE_KQUEUE	3296	#if EV_USE_KQUEUE
3049	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);	3297	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
		3298	#endif
		3299	#if EV_USE_IOURING
		3300	if (backend == EVBACKEND_IOURING ) iouring_destroy (EV_A);
3050	#endif	3301	#endif
3051	#if EV_USE_LINUXAIO	3302	#if EV_USE_LINUXAIO
3052	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);	3303	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
3053	#endif	3304	#endif
3054	#if EV_USE_EPOLL	3305	#if EV_USE_EPOLL
…		…
3113	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3364	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
3114	#endif	3365	#endif
3115	#if EV_USE_KQUEUE	3366	#if EV_USE_KQUEUE
3116	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);	3367	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
3117	#endif	3368	#endif
		3369	#if EV_USE_IOURING
		3370	if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
		3371	#endif
3118	#if EV_USE_LINUXAIO	3372	#if EV_USE_LINUXAIO
3119	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);	3373	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
3120	#endif	3374	#endif
3121	#if EV_USE_EPOLL	3375	#if EV_USE_EPOLL
3122	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3376	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
3123	#endif	3377	#endif
3124	#if EV_USE_INOTIFY	3378	#if EV_USE_INOTIFY
3125	infy_fork (EV_A);	3379	infy_fork (EV_A);
3126	#endif	3380	#endif
3127		3381
		3382	if (postfork != 2)
		3383	{
		3384	#if EV_USE_SIGNALFD
		3385	/* surprisingly, nothing needs to be done for signalfd, accoridng to docs, it does the right thing on fork */
		3386	#endif
		3387
		3388	#if EV_USE_TIMERFD
		3389	if (ev_is_active (&timerfd_w))
		3390	{
		3391	ev_ref (EV_A);
		3392	ev_io_stop (EV_A_ &timerfd_w);
		3393
		3394	close (timerfd);
		3395	timerfd = -2;
		3396
		3397	evtimerfd_init (EV_A);
		3398	/* reschedule periodics, in case we missed something */
		3399	ev_feed_event (EV_A_ &timerfd_w, EV_CUSTOM);
		3400	}
		3401	#endif
		3402
3128	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3403	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
3129	if (ev_is_active (&pipe_w) && postfork != 2)	3404	if (ev_is_active (&pipe_w))
3130	{	3405	{
3131	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3406	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
3132		3407
3133	ev_ref (EV_A);	3408	ev_ref (EV_A);
3134	ev_io_stop (EV_A_ &pipe_w);	3409	ev_io_stop (EV_A_ &pipe_w);
3135		3410
3136	if (evpipe [0] >= 0)	3411	if (evpipe [0] >= 0)
3137	EV_WIN32_CLOSE_FD (evpipe [0]);	3412	EV_WIN32_CLOSE_FD (evpipe [0]);
3138		3413
3139	evpipe_init (EV_A);	3414	evpipe_init (EV_A);
3140	/* iterate over everything, in case we missed something before */	3415	/* iterate over everything, in case we missed something before */
3141	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3416	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
		3417	}
		3418	#endif
3142	}	3419	}
3143	#endif
3144		3420
3145	postfork = 0;	3421	postfork = 0;
3146	}	3422	}
3147		3423
3148	#if EV_MULTIPLICITY	3424	#if EV_MULTIPLICITY
…		…
3164	}	3440	}
3165		3441
3166	#endif /* multiplicity */	3442	#endif /* multiplicity */
3167		3443
3168	#if EV_VERIFY	3444	#if EV_VERIFY
3169	noinline ecb_cold	3445	ecb_noinline ecb_cold
3170	static void	3446	static void
3171	verify_watcher (EV_P_ W w)	3447	verify_watcher (EV_P_ W w)
3172	{	3448	{
3173	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3449	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
3174		3450
3175	if (w->pending)	3451	if (w->pending)
3176	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3452	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
3177	}	3453	}
3178		3454
3179	noinline ecb_cold	3455	ecb_noinline ecb_cold
3180	static void	3456	static void
3181	verify_heap (EV_P_ ANHE *heap, int N)	3457	verify_heap (EV_P_ ANHE *heap, int N)
3182	{	3458	{
3183	int i;	3459	int i;
3184		3460
…		…
3190		3466
3191	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3467	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
3192	}	3468	}
3193	}	3469	}
3194		3470
3195	noinline ecb_cold	3471	ecb_noinline ecb_cold
3196	static void	3472	static void
3197	array_verify (EV_P_ W *ws, int cnt)	3473	array_verify (EV_P_ W *ws, int cnt)
3198	{	3474	{
3199	while (cnt--)	3475	while (cnt--)
3200	{	3476	{
…		…
3349	count += pendingcnt [pri];	3625	count += pendingcnt [pri];
3350		3626
3351	return count;	3627	return count;
3352	}	3628	}
3353		3629
3354	noinline	3630	ecb_noinline
3355	void	3631	void
3356	ev_invoke_pending (EV_P)	3632	ev_invoke_pending (EV_P)
3357	{	3633	{
3358	pendingpri = NUMPRI;	3634	pendingpri = NUMPRI;
3359		3635
…		…
3378	/* make idle watchers pending. this handles the "call-idle */	3654	/* make idle watchers pending. this handles the "call-idle */
3379	/* only when higher priorities are idle" logic */	3655	/* only when higher priorities are idle" logic */
3380	inline_size void	3656	inline_size void
3381	idle_reify (EV_P)	3657	idle_reify (EV_P)
3382	{	3658	{
3383	if (expect_false (idleall))	3659	if (ecb_expect_false (idleall))
3384	{	3660	{
3385	int pri;	3661	int pri;
3386		3662
3387	for (pri = NUMPRI; pri--; )	3663	for (pri = NUMPRI; pri--; )
3388	{	3664	{
…		…
3418	{	3694	{
3419	ev_at (w) += w->repeat;	3695	ev_at (w) += w->repeat;
3420	if (ev_at (w) < mn_now)	3696	if (ev_at (w) < mn_now)
3421	ev_at (w) = mn_now;	3697	ev_at (w) = mn_now;
3422		3698
3423	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));	3699	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > EV_TS_CONST (0.)));
3424		3700
3425	ANHE_at_cache (timers [HEAP0]);	3701	ANHE_at_cache (timers [HEAP0]);
3426	downheap (timers, timercnt, HEAP0);	3702	downheap (timers, timercnt, HEAP0);
3427	}	3703	}
3428	else	3704	else
…		…
3437	}	3713	}
3438	}	3714	}
3439		3715
3440	#if EV_PERIODIC_ENABLE	3716	#if EV_PERIODIC_ENABLE
3441		3717
3442	noinline	3718	ecb_noinline
3443	static void	3719	static void
3444	periodic_recalc (EV_P_ ev_periodic *w)	3720	periodic_recalc (EV_P_ ev_periodic *w)
3445	{	3721	{
3446	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3722	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3447	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);	3723	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
…		…
3450	while (at <= ev_rt_now)	3726	while (at <= ev_rt_now)
3451	{	3727	{
3452	ev_tstamp nat = at + w->interval;	3728	ev_tstamp nat = at + w->interval;
3453		3729
3454	/* when resolution fails us, we use ev_rt_now */	3730	/* when resolution fails us, we use ev_rt_now */
3455	if (expect_false (nat == at))	3731	if (ecb_expect_false (nat == at))
3456	{	3732	{
3457	at = ev_rt_now;	3733	at = ev_rt_now;
3458	break;	3734	break;
3459	}	3735	}
3460		3736
…		…
3506	}	3782	}
3507	}	3783	}
3508		3784
3509	/* simply recalculate all periodics */	3785	/* simply recalculate all periodics */
3510	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3786	/* TODO: maybe ensure that at least one event happens when jumping forward? */
3511	noinline ecb_cold	3787	ecb_noinline ecb_cold
3512	static void	3788	static void
3513	periodics_reschedule (EV_P)	3789	periodics_reschedule (EV_P)
3514	{	3790	{
3515	int i;	3791	int i;
3516		3792
…		…
3530	reheap (periodics, periodiccnt);	3806	reheap (periodics, periodiccnt);
3531	}	3807	}
3532	#endif	3808	#endif
3533		3809
3534	/* adjust all timers by a given offset */	3810	/* adjust all timers by a given offset */
3535	noinline ecb_cold	3811	ecb_noinline ecb_cold
3536	static void	3812	static void
3537	timers_reschedule (EV_P_ ev_tstamp adjust)	3813	timers_reschedule (EV_P_ ev_tstamp adjust)
3538	{	3814	{
3539	int i;	3815	int i;
3540		3816
…		…
3550	/* also detect if there was a timejump, and act accordingly */	3826	/* also detect if there was a timejump, and act accordingly */
3551	inline_speed void	3827	inline_speed void
3552	time_update (EV_P_ ev_tstamp max_block)	3828	time_update (EV_P_ ev_tstamp max_block)
3553	{	3829	{
3554	#if EV_USE_MONOTONIC	3830	#if EV_USE_MONOTONIC
3555	if (expect_true (have_monotonic))	3831	if (ecb_expect_true (have_monotonic))
3556	{	3832	{
3557	int i;	3833	int i;
3558	ev_tstamp odiff = rtmn_diff;	3834	ev_tstamp odiff = rtmn_diff;
3559		3835
3560	mn_now = get_clock ();	3836	mn_now = get_clock ();
3561		3837
3562	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */	3838	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3563	/* interpolate in the meantime */	3839	/* interpolate in the meantime */
3564	if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))	3840	if (ecb_expect_true (mn_now - now_floor < EV_TS_CONST (MIN_TIMEJUMP * .5)))
3565	{	3841	{
3566	ev_rt_now = rtmn_diff + mn_now;	3842	ev_rt_now = rtmn_diff + mn_now;
3567	return;	3843	return;
3568	}	3844	}
3569		3845
…		…
3583	ev_tstamp diff;	3859	ev_tstamp diff;
3584	rtmn_diff = ev_rt_now - mn_now;	3860	rtmn_diff = ev_rt_now - mn_now;
3585		3861
3586	diff = odiff - rtmn_diff;	3862	diff = odiff - rtmn_diff;
3587		3863
3588	if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))	3864	if (ecb_expect_true ((diff < EV_TS_CONST (0.) ? -diff : diff) < EV_TS_CONST (MIN_TIMEJUMP)))
3589	return; /* all is well */	3865	return; /* all is well */
3590		3866
3591	ev_rt_now = ev_time ();	3867	ev_rt_now = ev_time ();
3592	mn_now = get_clock ();	3868	mn_now = get_clock ();
3593	now_floor = mn_now;	3869	now_floor = mn_now;
…		…
3602	else	3878	else
3603	#endif	3879	#endif
3604	{	3880	{
3605	ev_rt_now = ev_time ();	3881	ev_rt_now = ev_time ();
3606		3882
3607	if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))	3883	if (ecb_expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + EV_TS_CONST (MIN_TIMEJUMP)))
3608	{	3884	{
3609	/* adjust timers. this is easy, as the offset is the same for all of them */	3885	/* adjust timers. this is easy, as the offset is the same for all of them */
3610	timers_reschedule (EV_A_ ev_rt_now - mn_now);	3886	timers_reschedule (EV_A_ ev_rt_now - mn_now);
3611	#if EV_PERIODIC_ENABLE	3887	#if EV_PERIODIC_ENABLE
3612	periodics_reschedule (EV_A);	3888	periodics_reschedule (EV_A);
…		…
3635	#if EV_VERIFY >= 2	3911	#if EV_VERIFY >= 2
3636	ev_verify (EV_A);	3912	ev_verify (EV_A);
3637	#endif	3913	#endif
3638		3914
3639	#ifndef _WIN32	3915	#ifndef _WIN32
3640	if (expect_false (curpid)) /* penalise the forking check even more */	3916	if (ecb_expect_false (curpid)) /* penalise the forking check even more */
3641	if (expect_false (getpid () != curpid))	3917	if (ecb_expect_false (getpid () != curpid))
3642	{	3918	{
3643	curpid = getpid ();	3919	curpid = getpid ();
3644	postfork = 1;	3920	postfork = 1;
3645	}	3921	}
3646	#endif	3922	#endif
3647		3923
3648	#if EV_FORK_ENABLE	3924	#if EV_FORK_ENABLE
3649	/* we might have forked, so queue fork handlers */	3925	/* we might have forked, so queue fork handlers */
3650	if (expect_false (postfork))	3926	if (ecb_expect_false (postfork))
3651	if (forkcnt)	3927	if (forkcnt)
3652	{	3928	{
3653	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	3929	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3654	EV_INVOKE_PENDING;	3930	EV_INVOKE_PENDING;
3655	}	3931	}
3656	#endif	3932	#endif
3657		3933
3658	#if EV_PREPARE_ENABLE	3934	#if EV_PREPARE_ENABLE
3659	/* queue prepare watchers (and execute them) */	3935	/* queue prepare watchers (and execute them) */
3660	if (expect_false (preparecnt))	3936	if (ecb_expect_false (preparecnt))
3661	{	3937	{
3662	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	3938	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3663	EV_INVOKE_PENDING;	3939	EV_INVOKE_PENDING;
3664	}	3940	}
3665	#endif	3941	#endif
3666		3942
3667	if (expect_false (loop_done))	3943	if (ecb_expect_false (loop_done))
3668	break;	3944	break;
3669		3945
3670	/* we might have forked, so reify kernel state if necessary */	3946	/* we might have forked, so reify kernel state if necessary */
3671	if (expect_false (postfork))	3947	if (ecb_expect_false (postfork))
3672	loop_fork (EV_A);	3948	loop_fork (EV_A);
3673		3949
3674	/* update fd-related kernel structures */	3950	/* update fd-related kernel structures */
3675	fd_reify (EV_A);	3951	fd_reify (EV_A);
3676		3952
…		…
3681		3957
3682	/* remember old timestamp for io_blocktime calculation */	3958	/* remember old timestamp for io_blocktime calculation */
3683	ev_tstamp prev_mn_now = mn_now;	3959	ev_tstamp prev_mn_now = mn_now;
3684		3960
3685	/* update time to cancel out callback processing overhead */	3961	/* update time to cancel out callback processing overhead */
3686	time_update (EV_A_ 1e100);	3962	time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
3687		3963
3688	/* from now on, we want a pipe-wake-up */	3964	/* from now on, we want a pipe-wake-up */
3689	pipe_write_wanted = 1;	3965	pipe_write_wanted = 1;
3690		3966
3691	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */	3967	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3692		3968
3693	if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))	3969	if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3694	{	3970	{
3695	waittime = MAX_BLOCKTIME;	3971	waittime = EV_TS_CONST (MAX_BLOCKTIME);
3696		3972
3697	if (timercnt)	3973	if (timercnt)
3698	{	3974	{
3699	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	3975	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3700	if (waittime > to) waittime = to;	3976	if (waittime > to) waittime = to;
…		…
3707	if (waittime > to) waittime = to;	3983	if (waittime > to) waittime = to;
3708	}	3984	}
3709	#endif	3985	#endif
3710		3986
3711	/* don't let timeouts decrease the waittime below timeout_blocktime */	3987	/* don't let timeouts decrease the waittime below timeout_blocktime */
3712	if (expect_false (waittime < timeout_blocktime))	3988	if (ecb_expect_false (waittime < timeout_blocktime))
3713	waittime = timeout_blocktime;	3989	waittime = timeout_blocktime;
3714		3990
3715	/* at this point, we NEED to wait, so we have to ensure */	3991	/* now there are two more special cases left, either we have
3716	/* to pass a minimum nonzero value to the backend */	3992	* already-expired timers, so we should not sleep, or we have timers
		3993	* that expire very soon, in which case we need to wait for a minimum
		3994	* amount of time for some event loop backends.
		3995	*/
3717	if (expect_false (waittime < backend_mintime))	3996	if (ecb_expect_false (waittime < backend_mintime))
		3997	waittime = waittime <= EV_TS_CONST (0.)
		3998	? EV_TS_CONST (0.)
3718	waittime = backend_mintime;	3999	: backend_mintime;
3719		4000
3720	/* extra check because io_blocktime is commonly 0 */	4001	/* extra check because io_blocktime is commonly 0 */
3721	if (expect_false (io_blocktime))	4002	if (ecb_expect_false (io_blocktime))
3722	{	4003	{
3723	sleeptime = io_blocktime - (mn_now - prev_mn_now);	4004	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3724		4005
3725	if (sleeptime > waittime - backend_mintime)	4006	if (sleeptime > waittime - backend_mintime)
3726	sleeptime = waittime - backend_mintime;	4007	sleeptime = waittime - backend_mintime;
3727		4008
3728	if (expect_true (sleeptime > 0.))	4009	if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
3729	{	4010	{
3730	ev_sleep (sleeptime);	4011	ev_sleep (sleeptime);
3731	waittime -= sleeptime;	4012	waittime -= sleeptime;
3732	}	4013	}
3733	}	4014	}
…		…
3747	{	4028	{
3748	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	4029	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3749	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	4030	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3750	}	4031	}
3751		4032
3752
3753	/* update ev_rt_now, do magic */	4033	/* update ev_rt_now, do magic */
3754	time_update (EV_A_ waittime + sleeptime);	4034	time_update (EV_A_ waittime + sleeptime);
3755	}	4035	}
3756		4036
3757	/* queue pending timers and reschedule them */	4037	/* queue pending timers and reschedule them */
…		…
3765	idle_reify (EV_A);	4045	idle_reify (EV_A);
3766	#endif	4046	#endif
3767		4047
3768	#if EV_CHECK_ENABLE	4048	#if EV_CHECK_ENABLE
3769	/* queue check watchers, to be executed first */	4049	/* queue check watchers, to be executed first */
3770	if (expect_false (checkcnt))	4050	if (ecb_expect_false (checkcnt))
3771	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	4051	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3772	#endif	4052	#endif
3773		4053
3774	EV_INVOKE_PENDING;	4054	EV_INVOKE_PENDING;
3775	}	4055	}
3776	while (expect_true (	4056	while (ecb_expect_true (
3777	activecnt	4057	activecnt
3778	&& !loop_done	4058	&& !loop_done
3779	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))	4059	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3780	));	4060	));
3781		4061
…		…
3808	}	4088	}
3809		4089
3810	void	4090	void
3811	ev_now_update (EV_P) EV_NOEXCEPT	4091	ev_now_update (EV_P) EV_NOEXCEPT
3812	{	4092	{
3813	time_update (EV_A_ 1e100);	4093	time_update (EV_A_ EV_TSTAMP_HUGE);
3814	}	4094	}
3815		4095
3816	void	4096	void
3817	ev_suspend (EV_P) EV_NOEXCEPT	4097	ev_suspend (EV_P) EV_NOEXCEPT
3818	{	4098	{
…		…
3845	inline_size void	4125	inline_size void
3846	wlist_del (WL *head, WL elem)	4126	wlist_del (WL *head, WL elem)
3847	{	4127	{
3848	while (*head)	4128	while (*head)
3849	{	4129	{
3850	if (expect_true (*head == elem))	4130	if (ecb_expect_true (*head == elem))
3851	{	4131	{
3852	*head = elem->next;	4132	*head = elem->next;
3853	break;	4133	break;
3854	}	4134	}
3855		4135
…		…
3872	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT	4152	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3873	{	4153	{
3874	W w_ = (W)w;	4154	W w_ = (W)w;
3875	int pending = w_->pending;	4155	int pending = w_->pending;
3876		4156
3877	if (expect_true (pending))	4157	if (ecb_expect_true (pending))
3878	{	4158	{
3879	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	4159	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3880	p->w = (W)&pending_w;	4160	p->w = (W)&pending_w;
3881	w_->pending = 0;	4161	w_->pending = 0;
3882	return p->events;	4162	return p->events;
…		…
3909	w->active = 0;	4189	w->active = 0;
3910	}	4190	}
3911		4191
3912	/*****************************************************************************/	4192	/*****************************************************************************/
3913		4193
3914	noinline	4194	ecb_noinline
3915	void	4195	void
3916	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT	4196	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3917	{	4197	{
3918	int fd = w->fd;	4198	int fd = w->fd;
3919		4199
3920	if (expect_false (ev_is_active (w)))	4200	if (ecb_expect_false (ev_is_active (w)))
3921	return;	4201	return;
3922		4202
3923	assert (("libev: ev_io_start called with negative fd", fd >= 0));	4203	assert (("libev: ev_io_start called with negative fd", fd >= 0));
3924	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));	4204	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3925		4205
		4206	#if EV_VERIFY >= 2
		4207	assert (("libev: ev_io_start called on watcher with invalid fd", fd_valid (fd)));
		4208	#endif
3926	EV_FREQUENT_CHECK;	4209	EV_FREQUENT_CHECK;
3927		4210
3928	ev_start (EV_A_ (W)w, 1);	4211	ev_start (EV_A_ (W)w, 1);
3929	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);	4212	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_needsize_zerofill);
3930	wlist_add (&anfds[fd].head, (WL)w);	4213	wlist_add (&anfds[fd].head, (WL)w);
…		…
3936	w->events &= ~EV__IOFDSET;	4219	w->events &= ~EV__IOFDSET;
3937		4220
3938	EV_FREQUENT_CHECK;	4221	EV_FREQUENT_CHECK;
3939	}	4222	}
3940		4223
3941	noinline	4224	ecb_noinline
3942	void	4225	void
3943	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT	4226	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3944	{	4227	{
3945	clear_pending (EV_A_ (W)w);	4228	clear_pending (EV_A_ (W)w);
3946	if (expect_false (!ev_is_active (w)))	4229	if (ecb_expect_false (!ev_is_active (w)))
3947	return;	4230	return;
3948		4231
3949	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));	4232	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3950		4233
		4234	#if EV_VERIFY >= 2
		4235	assert (("libev: ev_io_stop called on watcher with invalid fd", fd_valid (w->fd)));
		4236	#endif
3951	EV_FREQUENT_CHECK;	4237	EV_FREQUENT_CHECK;
3952		4238
3953	wlist_del (&anfds[w->fd].head, (WL)w);	4239	wlist_del (&anfds[w->fd].head, (WL)w);
3954	ev_stop (EV_A_ (W)w);	4240	ev_stop (EV_A_ (W)w);
3955		4241
3956	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	4242	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3957		4243
3958	EV_FREQUENT_CHECK;	4244	EV_FREQUENT_CHECK;
3959	}	4245	}
3960		4246
3961	noinline	4247	ecb_noinline
3962	void	4248	void
3963	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT	4249	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3964	{	4250	{
3965	if (expect_false (ev_is_active (w)))	4251	if (ecb_expect_false (ev_is_active (w)))
3966	return;	4252	return;
3967		4253
3968	ev_at (w) += mn_now;	4254	ev_at (w) += mn_now;
3969		4255
3970	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));	4256	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
…		…
3981	EV_FREQUENT_CHECK;	4267	EV_FREQUENT_CHECK;
3982		4268
3983	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	4269	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3984	}	4270	}
3985		4271
3986	noinline	4272	ecb_noinline
3987	void	4273	void
3988	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT	4274	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3989	{	4275	{
3990	clear_pending (EV_A_ (W)w);	4276	clear_pending (EV_A_ (W)w);
3991	if (expect_false (!ev_is_active (w)))	4277	if (ecb_expect_false (!ev_is_active (w)))
3992	return;	4278	return;
3993		4279
3994	EV_FREQUENT_CHECK;	4280	EV_FREQUENT_CHECK;
3995		4281
3996	{	4282	{
…		…
3998		4284
3999	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));	4285	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
4000		4286
4001	--timercnt;	4287	--timercnt;
4002		4288
4003	if (expect_true (active < timercnt + HEAP0))	4289	if (ecb_expect_true (active < timercnt + HEAP0))
4004	{	4290	{
4005	timers [active] = timers [timercnt + HEAP0];	4291	timers [active] = timers [timercnt + HEAP0];
4006	adjustheap (timers, timercnt, active);	4292	adjustheap (timers, timercnt, active);
4007	}	4293	}
4008	}	4294	}
…		…
4012	ev_stop (EV_A_ (W)w);	4298	ev_stop (EV_A_ (W)w);
4013		4299
4014	EV_FREQUENT_CHECK;	4300	EV_FREQUENT_CHECK;
4015	}	4301	}
4016		4302
4017	noinline	4303	ecb_noinline
4018	void	4304	void
4019	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT	4305	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
4020	{	4306	{
4021	EV_FREQUENT_CHECK;	4307	EV_FREQUENT_CHECK;
4022		4308
…		…
4043	}	4329	}
4044		4330
4045	ev_tstamp	4331	ev_tstamp
4046	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT	4332	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
4047	{	4333	{
4048	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4334	return ev_at (w) - (ev_is_active (w) ? mn_now : EV_TS_CONST (0.));
4049	}	4335	}
4050		4336
4051	#if EV_PERIODIC_ENABLE	4337	#if EV_PERIODIC_ENABLE
4052	noinline	4338	ecb_noinline
4053	void	4339	void
4054	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT	4340	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4055	{	4341	{
4056	if (expect_false (ev_is_active (w)))	4342	if (ecb_expect_false (ev_is_active (w)))
4057	return;	4343	return;
		4344
		4345	#if EV_USE_TIMERFD
		4346	if (timerfd == -2)
		4347	evtimerfd_init (EV_A);
		4348	#endif
4058		4349
4059	if (w->reschedule_cb)	4350	if (w->reschedule_cb)
4060	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4351	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
4061	else if (w->interval)	4352	else if (w->interval)
4062	{	4353	{
…		…
4078	EV_FREQUENT_CHECK;	4369	EV_FREQUENT_CHECK;
4079		4370
4080	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4371	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
4081	}	4372	}
4082		4373
4083	noinline	4374	ecb_noinline
4084	void	4375	void
4085	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT	4376	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
4086	{	4377	{
4087	clear_pending (EV_A_ (W)w);	4378	clear_pending (EV_A_ (W)w);
4088	if (expect_false (!ev_is_active (w)))	4379	if (ecb_expect_false (!ev_is_active (w)))
4089	return;	4380	return;
4090		4381
4091	EV_FREQUENT_CHECK;	4382	EV_FREQUENT_CHECK;
4092		4383
4093	{	4384	{
…		…
4095		4386
4096	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));	4387	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
4097		4388
4098	--periodiccnt;	4389	--periodiccnt;
4099		4390
4100	if (expect_true (active < periodiccnt + HEAP0))	4391	if (ecb_expect_true (active < periodiccnt + HEAP0))
4101	{	4392	{
4102	periodics [active] = periodics [periodiccnt + HEAP0];	4393	periodics [active] = periodics [periodiccnt + HEAP0];
4103	adjustheap (periodics, periodiccnt, active);	4394	adjustheap (periodics, periodiccnt, active);
4104	}	4395	}
4105	}	4396	}
…		…
4107	ev_stop (EV_A_ (W)w);	4398	ev_stop (EV_A_ (W)w);
4108		4399
4109	EV_FREQUENT_CHECK;	4400	EV_FREQUENT_CHECK;
4110	}	4401	}
4111		4402
4112	noinline	4403	ecb_noinline
4113	void	4404	void
4114	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT	4405	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4115	{	4406	{
4116	/* TODO: use adjustheap and recalculation */	4407	/* TODO: use adjustheap and recalculation */
4117	ev_periodic_stop (EV_A_ w);	4408	ev_periodic_stop (EV_A_ w);
…		…
4123	# define SA_RESTART 0	4414	# define SA_RESTART 0
4124	#endif	4415	#endif
4125		4416
4126	#if EV_SIGNAL_ENABLE	4417	#if EV_SIGNAL_ENABLE
4127		4418
4128	noinline	4419	ecb_noinline
4129	void	4420	void
4130	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT	4421	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4131	{	4422	{
4132	if (expect_false (ev_is_active (w)))	4423	if (ecb_expect_false (ev_is_active (w)))
4133	return;	4424	return;
4134		4425
4135	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4426	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
4136		4427
4137	#if EV_MULTIPLICITY	4428	#if EV_MULTIPLICITY
…		…
4206	}	4497	}
4207		4498
4208	EV_FREQUENT_CHECK;	4499	EV_FREQUENT_CHECK;
4209	}	4500	}
4210		4501
4211	noinline	4502	ecb_noinline
4212	void	4503	void
4213	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT	4504	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4214	{	4505	{
4215	clear_pending (EV_A_ (W)w);	4506	clear_pending (EV_A_ (W)w);
4216	if (expect_false (!ev_is_active (w)))	4507	if (ecb_expect_false (!ev_is_active (w)))
4217	return;	4508	return;
4218		4509
4219	EV_FREQUENT_CHECK;	4510	EV_FREQUENT_CHECK;
4220		4511
4221	wlist_del (&signals [w->signum - 1].head, (WL)w);	4512	wlist_del (&signals [w->signum - 1].head, (WL)w);
…		…
4254	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT	4545	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4255	{	4546	{
4256	#if EV_MULTIPLICITY	4547	#if EV_MULTIPLICITY
4257	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4548	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
4258	#endif	4549	#endif
4259	if (expect_false (ev_is_active (w)))	4550	if (ecb_expect_false (ev_is_active (w)))
4260	return;	4551	return;
4261		4552
4262	EV_FREQUENT_CHECK;	4553	EV_FREQUENT_CHECK;
4263		4554
4264	ev_start (EV_A_ (W)w, 1);	4555	ev_start (EV_A_ (W)w, 1);
…		…
4269		4560
4270	void	4561	void
4271	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT	4562	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4272	{	4563	{
4273	clear_pending (EV_A_ (W)w);	4564	clear_pending (EV_A_ (W)w);
4274	if (expect_false (!ev_is_active (w)))	4565	if (ecb_expect_false (!ev_is_active (w)))
4275	return;	4566	return;
4276		4567
4277	EV_FREQUENT_CHECK;	4568	EV_FREQUENT_CHECK;
4278		4569
4279	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);	4570	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
…		…
4293		4584
4294	#define DEF_STAT_INTERVAL 5.0074891	4585	#define DEF_STAT_INTERVAL 5.0074891
4295	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4586	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
4296	#define MIN_STAT_INTERVAL 0.1074891	4587	#define MIN_STAT_INTERVAL 0.1074891
4297		4588
4298	noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4589	ecb_noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
4299		4590
4300	#if EV_USE_INOTIFY	4591	#if EV_USE_INOTIFY
4301		4592
4302	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4593	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
4303	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4594	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
4304		4595
4305	noinline	4596	ecb_noinline
4306	static void	4597	static void
4307	infy_add (EV_P_ ev_stat *w)	4598	infy_add (EV_P_ ev_stat *w)
4308	{	4599	{
4309	w->wd = inotify_add_watch (fs_fd, w->path,	4600	w->wd = inotify_add_watch (fs_fd, w->path,
4310	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY	4601	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
…		…
4375	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4666	if (ev_is_active (&w->timer)) ev_ref (EV_A);
4376	ev_timer_again (EV_A_ &w->timer);	4667	ev_timer_again (EV_A_ &w->timer);
4377	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4668	if (ev_is_active (&w->timer)) ev_unref (EV_A);
4378	}	4669	}
4379		4670
4380	noinline	4671	ecb_noinline
4381	static void	4672	static void
4382	infy_del (EV_P_ ev_stat *w)	4673	infy_del (EV_P_ ev_stat *w)
4383	{	4674	{
4384	int slot;	4675	int slot;
4385	int wd = w->wd;	4676	int wd = w->wd;
…		…
4393		4684
4394	/* remove this watcher, if others are watching it, they will rearm */	4685	/* remove this watcher, if others are watching it, they will rearm */
4395	inotify_rm_watch (fs_fd, wd);	4686	inotify_rm_watch (fs_fd, wd);
4396	}	4687	}
4397		4688
4398	noinline	4689	ecb_noinline
4399	static void	4690	static void
4400	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4691	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
4401	{	4692	{
4402	if (slot < 0)	4693	if (slot < 0)
4403	/* overflow, need to check for all hash slots */	4694	/* overflow, need to check for all hash slots */
…		…
4549	w->attr.st_nlink = 0;	4840	w->attr.st_nlink = 0;
4550	else if (!w->attr.st_nlink)	4841	else if (!w->attr.st_nlink)
4551	w->attr.st_nlink = 1;	4842	w->attr.st_nlink = 1;
4552	}	4843	}
4553		4844
4554	noinline	4845	ecb_noinline
4555	static void	4846	static void
4556	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4847	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4557	{	4848	{
4558	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4849	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4559		4850
…		…
4593	}	4884	}
4594		4885
4595	void	4886	void
4596	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT	4887	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4597	{	4888	{
4598	if (expect_false (ev_is_active (w)))	4889	if (ecb_expect_false (ev_is_active (w)))
4599	return;	4890	return;
4600		4891
4601	ev_stat_stat (EV_A_ w);	4892	ev_stat_stat (EV_A_ w);
4602		4893
4603	if (w->interval < MIN_STAT_INTERVAL && w->interval)	4894	if (w->interval < MIN_STAT_INTERVAL && w->interval)
…		…
4625		4916
4626	void	4917	void
4627	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT	4918	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4628	{	4919	{
4629	clear_pending (EV_A_ (W)w);	4920	clear_pending (EV_A_ (W)w);
4630	if (expect_false (!ev_is_active (w)))	4921	if (ecb_expect_false (!ev_is_active (w)))
4631	return;	4922	return;
4632		4923
4633	EV_FREQUENT_CHECK;	4924	EV_FREQUENT_CHECK;
4634		4925
4635	#if EV_USE_INOTIFY	4926	#if EV_USE_INOTIFY
…		…
4650		4941
4651	#if EV_IDLE_ENABLE	4942	#if EV_IDLE_ENABLE
4652	void	4943	void
4653	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT	4944	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4654	{	4945	{
4655	if (expect_false (ev_is_active (w)))	4946	if (ecb_expect_false (ev_is_active (w)))
4656	return;	4947	return;
4657		4948
4658	pri_adjust (EV_A_ (W)w);	4949	pri_adjust (EV_A_ (W)w);
4659		4950
4660	EV_FREQUENT_CHECK;	4951	EV_FREQUENT_CHECK;
…		…
4674		4965
4675	void	4966	void
4676	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT	4967	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4677	{	4968	{
4678	clear_pending (EV_A_ (W)w);	4969	clear_pending (EV_A_ (W)w);
4679	if (expect_false (!ev_is_active (w)))	4970	if (ecb_expect_false (!ev_is_active (w)))
4680	return;	4971	return;
4681		4972
4682	EV_FREQUENT_CHECK;	4973	EV_FREQUENT_CHECK;
4683		4974
4684	{	4975	{
…		…
4697		4988
4698	#if EV_PREPARE_ENABLE	4989	#if EV_PREPARE_ENABLE
4699	void	4990	void
4700	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT	4991	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4701	{	4992	{
4702	if (expect_false (ev_is_active (w)))	4993	if (ecb_expect_false (ev_is_active (w)))
4703	return;	4994	return;
4704		4995
4705	EV_FREQUENT_CHECK;	4996	EV_FREQUENT_CHECK;
4706		4997
4707	ev_start (EV_A_ (W)w, ++preparecnt);	4998	ev_start (EV_A_ (W)w, ++preparecnt);
…		…
4713		5004
4714	void	5005	void
4715	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT	5006	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4716	{	5007	{
4717	clear_pending (EV_A_ (W)w);	5008	clear_pending (EV_A_ (W)w);
4718	if (expect_false (!ev_is_active (w)))	5009	if (ecb_expect_false (!ev_is_active (w)))
4719	return;	5010	return;
4720		5011
4721	EV_FREQUENT_CHECK;	5012	EV_FREQUENT_CHECK;
4722		5013
4723	{	5014	{
…		…
4735		5026
4736	#if EV_CHECK_ENABLE	5027	#if EV_CHECK_ENABLE
4737	void	5028	void
4738	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT	5029	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4739	{	5030	{
4740	if (expect_false (ev_is_active (w)))	5031	if (ecb_expect_false (ev_is_active (w)))
4741	return;	5032	return;
4742		5033
4743	EV_FREQUENT_CHECK;	5034	EV_FREQUENT_CHECK;
4744		5035
4745	ev_start (EV_A_ (W)w, ++checkcnt);	5036	ev_start (EV_A_ (W)w, ++checkcnt);
…		…
4751		5042
4752	void	5043	void
4753	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT	5044	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4754	{	5045	{
4755	clear_pending (EV_A_ (W)w);	5046	clear_pending (EV_A_ (W)w);
4756	if (expect_false (!ev_is_active (w)))	5047	if (ecb_expect_false (!ev_is_active (w)))
4757	return;	5048	return;
4758		5049
4759	EV_FREQUENT_CHECK;	5050	EV_FREQUENT_CHECK;
4760		5051
4761	{	5052	{
…		…
4770	EV_FREQUENT_CHECK;	5061	EV_FREQUENT_CHECK;
4771	}	5062	}
4772	#endif	5063	#endif
4773		5064
4774	#if EV_EMBED_ENABLE	5065	#if EV_EMBED_ENABLE
4775	noinline	5066	ecb_noinline
4776	void	5067	void
4777	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT	5068	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4778	{	5069	{
4779	ev_run (w->other, EVRUN_NOWAIT);	5070	ev_run (w->other, EVRUN_NOWAIT);
4780	}	5071	}
…		…
4804	ev_run (EV_A_ EVRUN_NOWAIT);	5095	ev_run (EV_A_ EVRUN_NOWAIT);
4805	}	5096	}
4806	}	5097	}
4807	}	5098	}
4808		5099
		5100	#if EV_FORK_ENABLE
4809	static void	5101	static void
4810	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)	5102	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4811	{	5103	{
4812	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));	5104	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
4813		5105
…		…
4820	ev_run (EV_A_ EVRUN_NOWAIT);	5112	ev_run (EV_A_ EVRUN_NOWAIT);
4821	}	5113	}
4822		5114
4823	ev_embed_start (EV_A_ w);	5115	ev_embed_start (EV_A_ w);
4824	}	5116	}
		5117	#endif
4825		5118
4826	#if 0	5119	#if 0
4827	static void	5120	static void
4828	embed_idle_cb (EV_P_ ev_idle *idle, int revents)	5121	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4829	{	5122	{
…		…
4832	#endif	5125	#endif
4833		5126
4834	void	5127	void
4835	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT	5128	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4836	{	5129	{
4837	if (expect_false (ev_is_active (w)))	5130	if (ecb_expect_false (ev_is_active (w)))
4838	return;	5131	return;
4839		5132
4840	{	5133	{
4841	EV_P = w->other;	5134	EV_P = w->other;
4842	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));	5135	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
…		…
4850		5143
4851	ev_prepare_init (&w->prepare, embed_prepare_cb);	5144	ev_prepare_init (&w->prepare, embed_prepare_cb);
4852	ev_set_priority (&w->prepare, EV_MINPRI);	5145	ev_set_priority (&w->prepare, EV_MINPRI);
4853	ev_prepare_start (EV_A_ &w->prepare);	5146	ev_prepare_start (EV_A_ &w->prepare);
4854		5147
		5148	#if EV_FORK_ENABLE
4855	ev_fork_init (&w->fork, embed_fork_cb);	5149	ev_fork_init (&w->fork, embed_fork_cb);
4856	ev_fork_start (EV_A_ &w->fork);	5150	ev_fork_start (EV_A_ &w->fork);
		5151	#endif
4857		5152
4858	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/	5153	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4859		5154
4860	ev_start (EV_A_ (W)w, 1);	5155	ev_start (EV_A_ (W)w, 1);
4861		5156
…		…
4864		5159
4865	void	5160	void
4866	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT	5161	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4867	{	5162	{
4868	clear_pending (EV_A_ (W)w);	5163	clear_pending (EV_A_ (W)w);
4869	if (expect_false (!ev_is_active (w)))	5164	if (ecb_expect_false (!ev_is_active (w)))
4870	return;	5165	return;
4871		5166
4872	EV_FREQUENT_CHECK;	5167	EV_FREQUENT_CHECK;
4873		5168
4874	ev_io_stop (EV_A_ &w->io);	5169	ev_io_stop (EV_A_ &w->io);
4875	ev_prepare_stop (EV_A_ &w->prepare);	5170	ev_prepare_stop (EV_A_ &w->prepare);
		5171	#if EV_FORK_ENABLE
4876	ev_fork_stop (EV_A_ &w->fork);	5172	ev_fork_stop (EV_A_ &w->fork);
		5173	#endif
4877		5174
4878	ev_stop (EV_A_ (W)w);	5175	ev_stop (EV_A_ (W)w);
4879		5176
4880	EV_FREQUENT_CHECK;	5177	EV_FREQUENT_CHECK;
4881	}	5178	}
…		…
4883		5180
4884	#if EV_FORK_ENABLE	5181	#if EV_FORK_ENABLE
4885	void	5182	void
4886	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT	5183	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4887	{	5184	{
4888	if (expect_false (ev_is_active (w)))	5185	if (ecb_expect_false (ev_is_active (w)))
4889	return;	5186	return;
4890		5187
4891	EV_FREQUENT_CHECK;	5188	EV_FREQUENT_CHECK;
4892		5189
4893	ev_start (EV_A_ (W)w, ++forkcnt);	5190	ev_start (EV_A_ (W)w, ++forkcnt);
…		…
4899		5196
4900	void	5197	void
4901	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT	5198	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4902	{	5199	{
4903	clear_pending (EV_A_ (W)w);	5200	clear_pending (EV_A_ (W)w);
4904	if (expect_false (!ev_is_active (w)))	5201	if (ecb_expect_false (!ev_is_active (w)))
4905	return;	5202	return;
4906		5203
4907	EV_FREQUENT_CHECK;	5204	EV_FREQUENT_CHECK;
4908		5205
4909	{	5206	{
…		…
4921		5218
4922	#if EV_CLEANUP_ENABLE	5219	#if EV_CLEANUP_ENABLE
4923	void	5220	void
4924	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5221	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4925	{	5222	{
4926	if (expect_false (ev_is_active (w)))	5223	if (ecb_expect_false (ev_is_active (w)))
4927	return;	5224	return;
4928		5225
4929	EV_FREQUENT_CHECK;	5226	EV_FREQUENT_CHECK;
4930		5227
4931	ev_start (EV_A_ (W)w, ++cleanupcnt);	5228	ev_start (EV_A_ (W)w, ++cleanupcnt);
…		…
4939		5236
4940	void	5237	void
4941	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5238	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4942	{	5239	{
4943	clear_pending (EV_A_ (W)w);	5240	clear_pending (EV_A_ (W)w);
4944	if (expect_false (!ev_is_active (w)))	5241	if (ecb_expect_false (!ev_is_active (w)))
4945	return;	5242	return;
4946		5243
4947	EV_FREQUENT_CHECK;	5244	EV_FREQUENT_CHECK;
4948	ev_ref (EV_A);	5245	ev_ref (EV_A);
4949		5246
…		…
4962		5259
4963	#if EV_ASYNC_ENABLE	5260	#if EV_ASYNC_ENABLE
4964	void	5261	void
4965	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT	5262	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4966	{	5263	{
4967	if (expect_false (ev_is_active (w)))	5264	if (ecb_expect_false (ev_is_active (w)))
4968	return;	5265	return;
4969		5266
4970	w->sent = 0;	5267	w->sent = 0;
4971		5268
4972	evpipe_init (EV_A);	5269	evpipe_init (EV_A);
…		…
4982		5279
4983	void	5280	void
4984	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT	5281	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4985	{	5282	{
4986	clear_pending (EV_A_ (W)w);	5283	clear_pending (EV_A_ (W)w);
4987	if (expect_false (!ev_is_active (w)))	5284	if (ecb_expect_false (!ev_is_active (w)))
4988	return;	5285	return;
4989		5286
4990	EV_FREQUENT_CHECK;	5287	EV_FREQUENT_CHECK;
4991		5288
4992	{	5289	{

Diff Legend

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