ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.498 by root, Wed Jun 26 00:01:46 2019 UTC vs.
Revision 1.524 by root, Wed Jan 22 02:20:47 2020 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) */
		584	#define MAX_BLOCKTIME2 1500001.07 /* same, but when timerfd is used to detect jumps, also safe delay to not overflow */
514		585
		586	/* find a portable timestamp that is "always" in the future but fits into time_t.
		587	* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
		588	* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
		589	#define EV_TSTAMP_HUGE \
		590	(sizeof (time_t) >= 8 ? 10000000000000. \
		591	: 0 < (time_t)4294967295 ? 4294967295. \
		592	: 2147483647.) \
		593
		594	#ifndef EV_TS_CONST
		595	# define EV_TS_CONST(nv) nv
		596	# define EV_TS_TO_MSEC(a) a * 1e3 + 0.9999
		597	# 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)	598	# 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)	599	# define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
		600	# define EV_TV_GET(tv) ((tv).tv_sec + (tv).tv_usec * 1e-6)
		601	# define EV_TS_GET(ts) ((ts).tv_sec + (ts).tv_nsec * 1e-9)
		602	#endif
517		603
518	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */	604	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
519	/* ECB.H BEGIN */	605	/* ECB.H BEGIN */
520	/*	606	/*
521	* libecb - http://software.schmorp.de/pkg/libecb	607	* libecb - http://software.schmorp.de/pkg/libecb
…		…
559		645
560	#ifndef ECB_H	646	#ifndef ECB_H
561	#define ECB_H	647	#define ECB_H
562		648
563	/* 16 bits major, 16 bits minor */	649	/* 16 bits major, 16 bits minor */
564	#define ECB_VERSION 0x00010006	650	#define ECB_VERSION 0x00010008
		651
		652	#include <string.h> /* for memcpy */
565		653
566	#ifdef _WIN32	654	#ifdef _WIN32
567	typedef signed char int8_t;	655	typedef signed char int8_t;
568	typedef unsigned char uint8_t;	656	typedef unsigned char uint8_t;
		657	typedef signed char int_fast8_t;
		658	typedef unsigned char uint_fast8_t;
569	typedef signed short int16_t;	659	typedef signed short int16_t;
570	typedef unsigned short uint16_t;	660	typedef unsigned short uint16_t;
		661	typedef signed int int_fast16_t;
		662	typedef unsigned int uint_fast16_t;
571	typedef signed int int32_t;	663	typedef signed int int32_t;
572	typedef unsigned int uint32_t;	664	typedef unsigned int uint32_t;
		665	typedef signed int int_fast32_t;
		666	typedef unsigned int uint_fast32_t;
573	#if __GNUC__	667	#if __GNUC__
574	typedef signed long long int64_t;	668	typedef signed long long int64_t;
575	typedef unsigned long long uint64_t;	669	typedef unsigned long long uint64_t;
576	#else /* _MSC_VER || __BORLANDC__ */	670	#else /* _MSC_VER || __BORLANDC__ */
577	typedef signed __int64 int64_t;	671	typedef signed __int64 int64_t;
578	typedef unsigned __int64 uint64_t;	672	typedef unsigned __int64 uint64_t;
579	#endif	673	#endif
		674	typedef int64_t int_fast64_t;
		675	typedef uint64_t uint_fast64_t;
580	#ifdef _WIN64	676	#ifdef _WIN64
581	#define ECB_PTRSIZE 8	677	#define ECB_PTRSIZE 8
582	typedef uint64_t uintptr_t;	678	typedef uint64_t uintptr_t;
583	typedef int64_t intptr_t;	679	typedef int64_t intptr_t;
584	#else	680	#else
…		…
595	#endif	691	#endif
596	#endif	692	#endif
597		693
598	#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)	694	#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
599	#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)	695	#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
		696
		697	#ifndef ECB_OPTIMIZE_SIZE
		698	#if __OPTIMIZE_SIZE__
		699	#define ECB_OPTIMIZE_SIZE 1
		700	#else
		701	#define ECB_OPTIMIZE_SIZE 0
		702	#endif
		703	#endif
600		704
601	/* work around x32 idiocy by defining proper macros */	705	/* work around x32 idiocy by defining proper macros */
602	#if ECB_GCC_AMD64 || ECB_MSVC_AMD64	706	#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
603	#if _ILP32	707	#if _ILP32
604	#define ECB_AMD64_X32 1	708	#define ECB_AMD64_X32 1
…		…
1111	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }	1215	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
1112	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }	1216	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
1113	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }	1217	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
1114	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }	1218	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
1115		1219
		1220	#if ECB_CPP
		1221
		1222	inline uint8_t ecb_ctz (uint8_t v) { return ecb_ctz32 (v); }
		1223	inline uint16_t ecb_ctz (uint16_t v) { return ecb_ctz32 (v); }
		1224	inline uint32_t ecb_ctz (uint32_t v) { return ecb_ctz32 (v); }
		1225	inline uint64_t ecb_ctz (uint64_t v) { return ecb_ctz64 (v); }
		1226
		1227	inline bool ecb_is_pot (uint8_t v) { return ecb_is_pot32 (v); }
		1228	inline bool ecb_is_pot (uint16_t v) { return ecb_is_pot32 (v); }
		1229	inline bool ecb_is_pot (uint32_t v) { return ecb_is_pot32 (v); }
		1230	inline bool ecb_is_pot (uint64_t v) { return ecb_is_pot64 (v); }
		1231
		1232	inline int ecb_ld (uint8_t v) { return ecb_ld32 (v); }
		1233	inline int ecb_ld (uint16_t v) { return ecb_ld32 (v); }
		1234	inline int ecb_ld (uint32_t v) { return ecb_ld32 (v); }
		1235	inline int ecb_ld (uint64_t v) { return ecb_ld64 (v); }
		1236
		1237	inline int ecb_popcount (uint8_t v) { return ecb_popcount32 (v); }
		1238	inline int ecb_popcount (uint16_t v) { return ecb_popcount32 (v); }
		1239	inline int ecb_popcount (uint32_t v) { return ecb_popcount32 (v); }
		1240	inline int ecb_popcount (uint64_t v) { return ecb_popcount64 (v); }
		1241
		1242	inline uint8_t ecb_bitrev (uint8_t v) { return ecb_bitrev8 (v); }
		1243	inline uint16_t ecb_bitrev (uint16_t v) { return ecb_bitrev16 (v); }
		1244	inline uint32_t ecb_bitrev (uint32_t v) { return ecb_bitrev32 (v); }
		1245
		1246	inline uint8_t ecb_rotl (uint8_t v, unsigned int count) { return ecb_rotl8 (v, count); }
		1247	inline uint16_t ecb_rotl (uint16_t v, unsigned int count) { return ecb_rotl16 (v, count); }
		1248	inline uint32_t ecb_rotl (uint32_t v, unsigned int count) { return ecb_rotl32 (v, count); }
		1249	inline uint64_t ecb_rotl (uint64_t v, unsigned int count) { return ecb_rotl64 (v, count); }
		1250
		1251	inline uint8_t ecb_rotr (uint8_t v, unsigned int count) { return ecb_rotr8 (v, count); }
		1252	inline uint16_t ecb_rotr (uint16_t v, unsigned int count) { return ecb_rotr16 (v, count); }
		1253	inline uint32_t ecb_rotr (uint32_t v, unsigned int count) { return ecb_rotr32 (v, count); }
		1254	inline uint64_t ecb_rotr (uint64_t v, unsigned int count) { return ecb_rotr64 (v, count); }
		1255
		1256	#endif
		1257
1116	#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))	1258	#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
1117	#if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)	1259	#if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
1118	#define ecb_bswap16(x) __builtin_bswap16 (x)	1260	#define ecb_bswap16(x) __builtin_bswap16 (x)
1119	#else	1261	#else
1120	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)	1262	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
…		…
1191	ecb_inline ecb_const ecb_bool ecb_big_endian (void);	1333	ecb_inline ecb_const ecb_bool ecb_big_endian (void);
1192	ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }	1334	ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
1193	ecb_inline ecb_const ecb_bool ecb_little_endian (void);	1335	ecb_inline ecb_const ecb_bool ecb_little_endian (void);
1194	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }	1336	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
1195		1337
		1338	/*****************************************************************************/
		1339	/* unaligned load/store */
		1340
		1341	ecb_inline uint_fast16_t ecb_be_u16_to_host (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
		1342	ecb_inline uint_fast32_t ecb_be_u32_to_host (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
		1343	ecb_inline uint_fast64_t ecb_be_u64_to_host (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
		1344
		1345	ecb_inline uint_fast16_t ecb_le_u16_to_host (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
		1346	ecb_inline uint_fast32_t ecb_le_u32_to_host (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
		1347	ecb_inline uint_fast64_t ecb_le_u64_to_host (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
		1348
		1349	ecb_inline uint_fast16_t ecb_peek_u16_u (const void *ptr) { uint16_t v; memcpy (&v, ptr, sizeof (v)); return v; }
		1350	ecb_inline uint_fast32_t ecb_peek_u32_u (const void *ptr) { uint32_t v; memcpy (&v, ptr, sizeof (v)); return v; }
		1351	ecb_inline uint_fast64_t ecb_peek_u64_u (const void *ptr) { uint64_t v; memcpy (&v, ptr, sizeof (v)); return v; }
		1352
		1353	ecb_inline uint_fast16_t ecb_peek_be_u16_u (const void *ptr) { return ecb_be_u16_to_host (ecb_peek_u16_u (ptr)); }
		1354	ecb_inline uint_fast32_t ecb_peek_be_u32_u (const void *ptr) { return ecb_be_u32_to_host (ecb_peek_u32_u (ptr)); }
		1355	ecb_inline uint_fast64_t ecb_peek_be_u64_u (const void *ptr) { return ecb_be_u64_to_host (ecb_peek_u64_u (ptr)); }
		1356
		1357	ecb_inline uint_fast16_t ecb_peek_le_u16_u (const void *ptr) { return ecb_le_u16_to_host (ecb_peek_u16_u (ptr)); }
		1358	ecb_inline uint_fast32_t ecb_peek_le_u32_u (const void *ptr) { return ecb_le_u32_to_host (ecb_peek_u32_u (ptr)); }
		1359	ecb_inline uint_fast64_t ecb_peek_le_u64_u (const void *ptr) { return ecb_le_u64_to_host (ecb_peek_u64_u (ptr)); }
		1360
		1361	ecb_inline uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
		1362	ecb_inline uint_fast32_t ecb_host_to_be_u32 (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
		1363	ecb_inline uint_fast64_t ecb_host_to_be_u64 (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
		1364
		1365	ecb_inline uint_fast16_t ecb_host_to_le_u16 (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
		1366	ecb_inline uint_fast32_t ecb_host_to_le_u32 (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
		1367	ecb_inline uint_fast64_t ecb_host_to_le_u64 (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
		1368
		1369	ecb_inline void ecb_poke_u16_u (void *ptr, uint16_t v) { memcpy (ptr, &v, sizeof (v)); }
		1370	ecb_inline void ecb_poke_u32_u (void *ptr, uint32_t v) { memcpy (ptr, &v, sizeof (v)); }
		1371	ecb_inline void ecb_poke_u64_u (void *ptr, uint64_t v) { memcpy (ptr, &v, sizeof (v)); }
		1372
		1373	ecb_inline void ecb_poke_be_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_be_u16 (v)); }
		1374	ecb_inline void ecb_poke_be_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_be_u32 (v)); }
		1375	ecb_inline void ecb_poke_be_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_be_u64 (v)); }
		1376
		1377	ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); }
		1378	ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); }
		1379	ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); }
		1380
		1381	#if ECB_CPP
		1382
		1383	inline uint8_t ecb_bswap (uint8_t v) { return v; }
		1384	inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
		1385	inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
		1386	inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
		1387
		1388	template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
		1389	template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
		1390	template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; }
		1391	template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); }
		1392	template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); }
		1393	template<typename T> inline T ecb_peek_u (const void *ptr) { T v; memcpy (&v, ptr, sizeof (v)); return v; }
		1394	template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); }
		1395	template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); }
		1396
		1397	template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
		1398	template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
		1399	template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; }
		1400	template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
		1401	template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
		1402	template<typename T> inline void ecb_poke_u (void *ptr, T v) { memcpy (ptr, &v, sizeof (v)); }
		1403	template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); }
		1404	template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
		1405
		1406	#endif
		1407
		1408	/*****************************************************************************/
		1409
1196	#if ECB_GCC_VERSION(3,0) || ECB_C99	1410	#if ECB_GCC_VERSION(3,0) || ECB_C99
1197	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))	1411	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
1198	#else	1412	#else
1199	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))	1413	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
1200	#endif	1414	#endif
…		…
1223	return N;	1437	return N;
1224	}	1438	}
1225	#else	1439	#else
1226	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	1440	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1227	#endif	1441	#endif
		1442
		1443	/*****************************************************************************/
1228		1444
1229	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);	1445	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
1230	ecb_function_ ecb_const uint32_t	1446	ecb_function_ ecb_const uint32_t
1231	ecb_binary16_to_binary32 (uint32_t x)	1447	ecb_binary16_to_binary32 (uint32_t x)
1232	{	1448	{
…		…
1341	|| defined __sh__ \	1557	|| defined __sh__ \
1342	|| defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \	1558	|| defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
1343	|| (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \	1559	|| (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
1344	|| defined __aarch64__	1560	|| defined __aarch64__
1345	#define ECB_STDFP 1	1561	#define ECB_STDFP 1
1346	#include <string.h> /* for memcpy */
1347	#else	1562	#else
1348	#define ECB_STDFP 0	1563	#define ECB_STDFP 0
1349	#endif	1564	#endif
1350		1565
1351	#ifndef ECB_NO_LIBM	1566	#ifndef ECB_NO_LIBM
…		…
1536	/* ECB.H END */	1751	/* ECB.H END */
1537		1752
1538	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1753	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1539	/* if your architecture doesn't need memory fences, e.g. because it is	1754	/* if your architecture doesn't need memory fences, e.g. because it is
1540	* single-cpu/core, or if you use libev in a project that doesn't use libev	1755	* single-cpu/core, or if you use libev in a project that doesn't use libev
1541	* from multiple threads, then you can define ECB_AVOID_PTHREADS when compiling	1756	* from multiple threads, then you can define ECB_NO_THREADS when compiling
1542	* libev, in which cases the memory fences become nops.	1757	* libev, in which cases the memory fences become nops.
1543	* alternatively, you can remove this #error and link against libpthread,	1758	* alternatively, you can remove this #error and link against libpthread,
1544	* which will then provide the memory fences.	1759	* which will then provide the memory fences.
1545	*/	1760	*/
1546	# error "memory fences not defined for your architecture, please report"	1761	# error "memory fences not defined for your architecture, please report"
…		…
1550	# define ECB_MEMORY_FENCE do { } while (0)	1765	# define ECB_MEMORY_FENCE do { } while (0)
1551	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	1766	# define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1552	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	1767	# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1553	#endif	1768	#endif
1554		1769
1555	#define expect_false(cond) ecb_expect_false (cond)
1556	#define expect_true(cond) ecb_expect_true (cond)
1557	#define noinline ecb_noinline
1558
1559	#define inline_size ecb_inline	1770	#define inline_size ecb_inline
1560		1771
1561	#if EV_FEATURE_CODE	1772	#if EV_FEATURE_CODE
1562	# define inline_speed ecb_inline	1773	# define inline_speed ecb_inline
1563	#else	1774	#else
1564	# define inline_speed noinline static	1775	# define inline_speed ecb_noinline static
1565	#endif	1776	#endif
		1777
		1778	/*****************************************************************************/
		1779	/* raw syscall wrappers */
		1780
		1781	#if EV_NEED_SYSCALL
		1782
		1783	#include <sys/syscall.h>
		1784
		1785	/*
		1786	* define some syscall wrappers for common architectures
		1787	* this is mostly for nice looks during debugging, not performance.
		1788	* our syscalls return < 0, not == -1, on error. which is good
		1789	* enough for linux aio.
		1790	* TODO: arm is also common nowadays, maybe even mips and x86
		1791	* TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
		1792	*/
		1793	#if __GNUC__ && __linux && ECB_AMD64 && !EV_FEATURE_CODE
		1794	/* the costly errno access probably kills this for size optimisation */
		1795
		1796	#define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5,arg6) \
		1797	({ \
		1798	long res; \
		1799	register unsigned long r6 __asm__ ("r9" ); \
		1800	register unsigned long r5 __asm__ ("r8" ); \
		1801	register unsigned long r4 __asm__ ("r10"); \
		1802	register unsigned long r3 __asm__ ("rdx"); \
		1803	register unsigned long r2 __asm__ ("rsi"); \
		1804	register unsigned long r1 __asm__ ("rdi"); \
		1805	if (narg >= 6) r6 = (unsigned long)(arg6); \
		1806	if (narg >= 5) r5 = (unsigned long)(arg5); \
		1807	if (narg >= 4) r4 = (unsigned long)(arg4); \
		1808	if (narg >= 3) r3 = (unsigned long)(arg3); \
		1809	if (narg >= 2) r2 = (unsigned long)(arg2); \
		1810	if (narg >= 1) r1 = (unsigned long)(arg1); \
		1811	__asm__ __volatile__ ( \
		1812	"syscall\n\t" \
		1813	: "=a" (res) \
		1814	: "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
		1815	: "cc", "r11", "cx", "memory"); \
		1816	errno = -res; \
		1817	res; \
		1818	})
		1819
		1820	#endif
		1821
		1822	#ifdef ev_syscall
		1823	#define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0, 0)
		1824	#define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0, 0)
		1825	#define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0, 0)
		1826	#define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0, 0)
		1827	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0, 0)
		1828	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5, 0)
		1829	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) ev_syscall (nr, 6, arg1, arg2, arg3, arg4, arg5,arg6)
		1830	#else
		1831	#define ev_syscall0(nr) syscall (nr)
		1832	#define ev_syscall1(nr,arg1) syscall (nr, arg1)
		1833	#define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
		1834	#define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
		1835	#define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
		1836	#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
		1837	#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) syscall (nr, arg1, arg2, arg3, arg4, arg5,arg6)
		1838	#endif
		1839
		1840	#endif
		1841
		1842	/*****************************************************************************/
1566		1843
1567	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1844	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1568		1845
1569	#if EV_MINPRI == EV_MAXPRI	1846	#if EV_MINPRI == EV_MAXPRI
1570	# define ABSPRI(w) (((W)w), 0)	1847	# define ABSPRI(w) (((W)w), 0)
…		…
1619	#else	1896	#else
1620		1897
1621	#include <float.h>	1898	#include <float.h>
1622		1899
1623	/* a floor() replacement function, should be independent of ev_tstamp type */	1900	/* a floor() replacement function, should be independent of ev_tstamp type */
1624	noinline	1901	ecb_noinline
1625	static ev_tstamp	1902	static ev_tstamp
1626	ev_floor (ev_tstamp v)	1903	ev_floor (ev_tstamp v)
1627	{	1904	{
1628	/* the choice of shift factor is not terribly important */	1905	/* the choice of shift factor is not terribly important */
1629	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1906	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1630	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1907	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1631	#else	1908	#else
1632	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;	1909	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1633	#endif	1910	#endif
1634		1911
		1912	/* special treatment for negative arguments */
		1913	if (ecb_expect_false (v < 0.))
		1914	{
		1915	ev_tstamp f = -ev_floor (-v);
		1916
		1917	return f - (f == v ? 0 : 1);
		1918	}
		1919
1635	/* argument too large for an unsigned long? */	1920	/* argument too large for an unsigned long? then reduce it */
1636	if (expect_false (v >= shift))	1921	if (ecb_expect_false (v >= shift))
1637	{	1922	{
1638	ev_tstamp f;	1923	ev_tstamp f;
1639		1924
1640	if (v == v - 1.)	1925	if (v == v - 1.)
1641	return v; /* very large number */	1926	return v; /* very large numbers are assumed to be integer */
1642		1927
1643	f = shift * ev_floor (v * (1. / shift));	1928	f = shift * ev_floor (v * (1. / shift));
1644	return f + ev_floor (v - f);	1929	return f + ev_floor (v - f);
1645	}	1930	}
1646		1931
1647	/* special treatment for negative args? */
1648	if (expect_false (v < 0.))
1649	{
1650	ev_tstamp f = -ev_floor (-v);
1651
1652	return f - (f == v ? 0 : 1);
1653	}
1654
1655	/* fits into an unsigned long */	1932	/* fits into an unsigned long */
1656	return (unsigned long)v;	1933	return (unsigned long)v;
1657	}	1934	}
1658		1935
1659	#endif	1936	#endif
…		…
1662		1939
1663	#ifdef __linux	1940	#ifdef __linux
1664	# include <sys/utsname.h>	1941	# include <sys/utsname.h>
1665	#endif	1942	#endif
1666		1943
1667	noinline ecb_cold	1944	ecb_noinline ecb_cold
1668	static unsigned int	1945	static unsigned int
1669	ev_linux_version (void)	1946	ev_linux_version (void)
1670	{	1947	{
1671	#ifdef __linux	1948	#ifdef __linux
1672	unsigned int v = 0;	1949	unsigned int v = 0;
…		…
1702	}	1979	}
1703		1980
1704	/*****************************************************************************/	1981	/*****************************************************************************/
1705		1982
1706	#if EV_AVOID_STDIO	1983	#if EV_AVOID_STDIO
1707	noinline ecb_cold	1984	ecb_noinline ecb_cold
1708	static void	1985	static void
1709	ev_printerr (const char *msg)	1986	ev_printerr (const char *msg)
1710	{	1987	{
1711	write (STDERR_FILENO, msg, strlen (msg));	1988	write (STDERR_FILENO, msg, strlen (msg));
1712	}	1989	}
…		…
1719	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT	1996	ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
1720	{	1997	{
1721	syserr_cb = cb;	1998	syserr_cb = cb;
1722	}	1999	}
1723		2000
1724	noinline ecb_cold	2001	ecb_noinline ecb_cold
1725	static void	2002	static void
1726	ev_syserr (const char *msg)	2003	ev_syserr (const char *msg)
1727	{	2004	{
1728	if (!msg)	2005	if (!msg)
1729	msg = "(libev) system error";	2006	msg = "(libev) system error";
…		…
1801	{	2078	{
1802	WL head;	2079	WL head;
1803	unsigned char events; /* the events watched for */	2080	unsigned char events; /* the events watched for */
1804	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */	2081	unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
1805	unsigned char emask; /* some backends store the actual kernel mask in here */	2082	unsigned char emask; /* some backends store the actual kernel mask in here */
1806	unsigned char unused;	2083	unsigned char eflags; /* flags field for use by backends */
1807	#if EV_USE_EPOLL	2084	#if EV_USE_EPOLL
1808	unsigned int egen; /* generation counter to counter epoll bugs */	2085	unsigned int egen; /* generation counter to counter epoll bugs */
1809	#endif	2086	#endif
1810	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	2087	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1811	SOCKET handle;	2088	SOCKET handle;
…		…
1865	static struct ev_loop default_loop_struct;	2142	static struct ev_loop default_loop_struct;
1866	EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */	2143	EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
1867		2144
1868	#else	2145	#else
1869		2146
1870	EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */	2147	EV_API_DECL ev_tstamp ev_rt_now = EV_TS_CONST (0.); /* needs to be initialised to make it a definition despite extern */
1871	#define VAR(name,decl) static decl;	2148	#define VAR(name,decl) static decl;
1872	#include "ev_vars.h"	2149	#include "ev_vars.h"
1873	#undef VAR	2150	#undef VAR
1874		2151
1875	static int ev_default_loop_ptr;	2152	static int ev_default_loop_ptr;
1876		2153
1877	#endif	2154	#endif
1878		2155
1879	#if EV_FEATURE_API	2156	#if EV_FEATURE_API
1880	# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)	2157	# define EV_RELEASE_CB if (ecb_expect_false (release_cb)) release_cb (EV_A)
1881	# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)	2158	# define EV_ACQUIRE_CB if (ecb_expect_false (acquire_cb)) acquire_cb (EV_A)
1882	# define EV_INVOKE_PENDING invoke_cb (EV_A)	2159	# define EV_INVOKE_PENDING invoke_cb (EV_A)
1883	#else	2160	#else
1884	# define EV_RELEASE_CB (void)0	2161	# define EV_RELEASE_CB (void)0
1885	# define EV_ACQUIRE_CB (void)0	2162	# define EV_ACQUIRE_CB (void)0
1886	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)	2163	# define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
…		…
1893	#ifndef EV_HAVE_EV_TIME	2170	#ifndef EV_HAVE_EV_TIME
1894	ev_tstamp	2171	ev_tstamp
1895	ev_time (void) EV_NOEXCEPT	2172	ev_time (void) EV_NOEXCEPT
1896	{	2173	{
1897	#if EV_USE_REALTIME	2174	#if EV_USE_REALTIME
1898	if (expect_true (have_realtime))	2175	if (ecb_expect_true (have_realtime))
1899	{	2176	{
1900	struct timespec ts;	2177	struct timespec ts;
1901	clock_gettime (CLOCK_REALTIME, &ts);	2178	clock_gettime (CLOCK_REALTIME, &ts);
1902	return ts.tv_sec + ts.tv_nsec * 1e-9;	2179	return EV_TS_GET (ts);
1903	}	2180	}
1904	#endif	2181	#endif
1905		2182
		2183	{
1906	struct timeval tv;	2184	struct timeval tv;
1907	gettimeofday (&tv, 0);	2185	gettimeofday (&tv, 0);
1908	return tv.tv_sec + tv.tv_usec * 1e-6;	2186	return EV_TV_GET (tv);
		2187	}
1909	}	2188	}
1910	#endif	2189	#endif
1911		2190
1912	inline_size ev_tstamp	2191	inline_size ev_tstamp
1913	get_clock (void)	2192	get_clock (void)
1914	{	2193	{
1915	#if EV_USE_MONOTONIC	2194	#if EV_USE_MONOTONIC
1916	if (expect_true (have_monotonic))	2195	if (ecb_expect_true (have_monotonic))
1917	{	2196	{
1918	struct timespec ts;	2197	struct timespec ts;
1919	clock_gettime (CLOCK_MONOTONIC, &ts);	2198	clock_gettime (CLOCK_MONOTONIC, &ts);
1920	return ts.tv_sec + ts.tv_nsec * 1e-9;	2199	return EV_TS_GET (ts);
1921	}	2200	}
1922	#endif	2201	#endif
1923		2202
1924	return ev_time ();	2203	return ev_time ();
1925	}	2204	}
…		…
1933	#endif	2212	#endif
1934		2213
1935	void	2214	void
1936	ev_sleep (ev_tstamp delay) EV_NOEXCEPT	2215	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1937	{	2216	{
1938	if (delay > 0.)	2217	if (delay > EV_TS_CONST (0.))
1939	{	2218	{
1940	#if EV_USE_NANOSLEEP	2219	#if EV_USE_NANOSLEEP
1941	struct timespec ts;	2220	struct timespec ts;
1942		2221
1943	EV_TS_SET (ts, delay);	2222	EV_TS_SET (ts, delay);
1944	nanosleep (&ts, 0);	2223	nanosleep (&ts, 0);
1945	#elif defined _WIN32	2224	#elif defined _WIN32
1946	/* maybe this should round up, as ms is very low resolution */	2225	/* maybe this should round up, as ms is very low resolution */
1947	/* compared to select (µs) or nanosleep (ns) */	2226	/* compared to select (µs) or nanosleep (ns) */
1948	Sleep ((unsigned long)(delay * 1e3));	2227	Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
1949	#else	2228	#else
1950	struct timeval tv;	2229	struct timeval tv;
1951		2230
1952	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */	2231	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
1953	/* something not guaranteed by newer posix versions, but guaranteed */	2232	/* something not guaranteed by newer posix versions, but guaranteed */
…		…
1983	}	2262	}
1984		2263
1985	return ncur;	2264	return ncur;
1986	}	2265	}
1987		2266
1988	noinline ecb_cold	2267	ecb_noinline ecb_cold
1989	static void *	2268	static void *
1990	array_realloc (int elem, void *base, int *cur, int cnt)	2269	array_realloc (int elem, void *base, int *cur, int cnt)
1991	{	2270	{
1992	*cur = array_nextsize (elem, *cur, cnt);	2271	*cur = array_nextsize (elem, *cur, cnt);
1993	return ev_realloc (base, elem * *cur);	2272	return ev_realloc (base, elem * *cur);
…		…
1997		2276
1998	#define array_needsize_zerofill(base,offset,count) \	2277	#define array_needsize_zerofill(base,offset,count) \
1999	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))	2278	memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
2000		2279
2001	#define array_needsize(type,base,cur,cnt,init) \	2280	#define array_needsize(type,base,cur,cnt,init) \
2002	if (expect_false ((cnt) > (cur))) \	2281	if (ecb_expect_false ((cnt) > (cur))) \
2003	{ \	2282	{ \
2004	ecb_unused int ocur_ = (cur); \	2283	ecb_unused int ocur_ = (cur); \
2005	(base) = (type *)array_realloc \	2284	(base) = (type *)array_realloc \
2006	(sizeof (type), (base), &(cur), (cnt)); \	2285	(sizeof (type), (base), &(cur), (cnt)); \
2007	init ((base), ocur_, ((cur) - ocur_)); \	2286	init ((base), ocur_, ((cur) - ocur_)); \
…		…
2021	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0	2300	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
2022		2301
2023	/*****************************************************************************/	2302	/*****************************************************************************/
2024		2303
2025	/* dummy callback for pending events */	2304	/* dummy callback for pending events */
2026	noinline	2305	ecb_noinline
2027	static void	2306	static void
2028	pendingcb (EV_P_ ev_prepare *w, int revents)	2307	pendingcb (EV_P_ ev_prepare *w, int revents)
2029	{	2308	{
2030	}	2309	}
2031		2310
2032	noinline	2311	ecb_noinline
2033	void	2312	void
2034	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT	2313	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
2035	{	2314	{
2036	W w_ = (W)w;	2315	W w_ = (W)w;
2037	int pri = ABSPRI (w_);	2316	int pri = ABSPRI (w_);
2038		2317
2039	if (expect_false (w_->pending))	2318	if (ecb_expect_false (w_->pending))
2040	pendings [pri][w_->pending - 1].events |= revents;	2319	pendings [pri][w_->pending - 1].events |= revents;
2041	else	2320	else
2042	{	2321	{
2043	w_->pending = ++pendingcnt [pri];	2322	w_->pending = ++pendingcnt [pri];
2044	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);	2323	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);
…		…
2095	inline_speed void	2374	inline_speed void
2096	fd_event (EV_P_ int fd, int revents)	2375	fd_event (EV_P_ int fd, int revents)
2097	{	2376	{
2098	ANFD *anfd = anfds + fd;	2377	ANFD *anfd = anfds + fd;
2099		2378
2100	if (expect_true (!anfd->reify))	2379	if (ecb_expect_true (!anfd->reify))
2101	fd_event_nocheck (EV_A_ fd, revents);	2380	fd_event_nocheck (EV_A_ fd, revents);
2102	}	2381	}
2103		2382
2104	void	2383	void
2105	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT	2384	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
…		…
2113	inline_size void	2392	inline_size void
2114	fd_reify (EV_P)	2393	fd_reify (EV_P)
2115	{	2394	{
2116	int i;	2395	int i;
2117		2396
		2397	/* most backends do not modify the fdchanges list in backend_modfiy.
		2398	* except io_uring, which has fixed-size buffers which might force us
		2399	* to handle events in backend_modify, causing fdchanges to be amended,
		2400	* which could result in an endless loop.
		2401	* to avoid this, we do not dynamically handle fds that were added
		2402	* during fd_reify. that means that for those backends, fdchangecnt
		2403	* might be non-zero during poll, which must cause them to not block.
		2404	* to not put too much of a burden on other backends, this detail
		2405	* needs to be handled in the backend.
		2406	*/
		2407	int changecnt = fdchangecnt;
		2408
2118	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP	2409	#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
2119	for (i = 0; i < fdchangecnt; ++i)	2410	for (i = 0; i < changecnt; ++i)
2120	{	2411	{
2121	int fd = fdchanges [i];	2412	int fd = fdchanges [i];
2122	ANFD *anfd = anfds + fd;	2413	ANFD *anfd = anfds + fd;
2123		2414
2124	if (anfd->reify & EV__IOFDSET && anfd->head)	2415	if (anfd->reify & EV__IOFDSET && anfd->head)
…		…
2138	}	2429	}
2139	}	2430	}
2140	}	2431	}
2141	#endif	2432	#endif
2142		2433
2143	for (i = 0; i < fdchangecnt; ++i)	2434	for (i = 0; i < changecnt; ++i)
2144	{	2435	{
2145	int fd = fdchanges [i];	2436	int fd = fdchanges [i];
2146	ANFD *anfd = anfds + fd;	2437	ANFD *anfd = anfds + fd;
2147	ev_io *w;	2438	ev_io *w;
2148		2439
2149	unsigned char o_events = anfd->events;	2440	unsigned char o_events = anfd->events;
2150	unsigned char o_reify = anfd->reify;	2441	unsigned char o_reify = anfd->reify;
2151		2442
2152	anfd->reify = 0;	2443	anfd->reify = 0;
2153		2444
2154	/*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */	2445	/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
2155	{	2446	{
2156	anfd->events = 0;	2447	anfd->events = 0;
2157		2448
2158	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)	2449	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
2159	anfd->events |= (unsigned char)w->events;	2450	anfd->events |= (unsigned char)w->events;
…		…
2164		2455
2165	if (o_reify & EV__IOFDSET)	2456	if (o_reify & EV__IOFDSET)
2166	backend_modify (EV_A_ fd, o_events, anfd->events);	2457	backend_modify (EV_A_ fd, o_events, anfd->events);
2167	}	2458	}
2168		2459
		2460	/* normally, fdchangecnt hasn't changed. if it has, then new fds have been added.
		2461	* this is a rare case (see beginning comment in this function), so we copy them to the
		2462	* front and hope the backend handles this case.
		2463	*/
		2464	if (ecb_expect_false (fdchangecnt != changecnt))
		2465	memmove (fdchanges, fdchanges + changecnt, (fdchangecnt - changecnt) * sizeof (*fdchanges));
		2466
2169	fdchangecnt = 0;	2467	fdchangecnt -= changecnt;
2170	}	2468	}
2171		2469
2172	/* something about the given fd changed */	2470	/* something about the given fd changed */
2173	inline_size	2471	inline_size
2174	void	2472	void
2175	fd_change (EV_P_ int fd, int flags)	2473	fd_change (EV_P_ int fd, int flags)
2176	{	2474	{
2177	unsigned char reify = anfds [fd].reify;	2475	unsigned char reify = anfds [fd].reify;
2178	anfds [fd].reify |= flags;	2476	anfds [fd].reify |= flags;
2179		2477
2180	if (expect_true (!reify))	2478	if (ecb_expect_true (!reify))
2181	{	2479	{
2182	++fdchangecnt;	2480	++fdchangecnt;
2183	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);	2481	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
2184	fdchanges [fdchangecnt - 1] = fd;	2482	fdchanges [fdchangecnt - 1] = fd;
2185	}	2483	}
…		…
2208	return fcntl (fd, F_GETFD) != -1;	2506	return fcntl (fd, F_GETFD) != -1;
2209	#endif	2507	#endif
2210	}	2508	}
2211		2509
2212	/* called on EBADF to verify fds */	2510	/* called on EBADF to verify fds */
2213	noinline ecb_cold	2511	ecb_noinline ecb_cold
2214	static void	2512	static void
2215	fd_ebadf (EV_P)	2513	fd_ebadf (EV_P)
2216	{	2514	{
2217	int fd;	2515	int fd;
2218		2516
…		…
2221	if (!fd_valid (fd) && errno == EBADF)	2519	if (!fd_valid (fd) && errno == EBADF)
2222	fd_kill (EV_A_ fd);	2520	fd_kill (EV_A_ fd);
2223	}	2521	}
2224		2522
2225	/* called on ENOMEM in select/poll to kill some fds and retry */	2523	/* called on ENOMEM in select/poll to kill some fds and retry */
2226	noinline ecb_cold	2524	ecb_noinline ecb_cold
2227	static void	2525	static void
2228	fd_enomem (EV_P)	2526	fd_enomem (EV_P)
2229	{	2527	{
2230	int fd;	2528	int fd;
2231		2529
…		…
2236	break;	2534	break;
2237	}	2535	}
2238	}	2536	}
2239		2537
2240	/* usually called after fork if backend needs to re-arm all fds from scratch */	2538	/* usually called after fork if backend needs to re-arm all fds from scratch */
2241	noinline	2539	ecb_noinline
2242	static void	2540	static void
2243	fd_rearm_all (EV_P)	2541	fd_rearm_all (EV_P)
2244	{	2542	{
2245	int fd;	2543	int fd;
2246		2544
…		…
2300	ev_tstamp minat;	2598	ev_tstamp minat;
2301	ANHE *minpos;	2599	ANHE *minpos;
2302	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;	2600	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
2303		2601
2304	/* find minimum child */	2602	/* find minimum child */
2305	if (expect_true (pos + DHEAP - 1 < E))	2603	if (ecb_expect_true (pos + DHEAP - 1 < E))
2306	{	2604	{
2307	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2605	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2308	if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2606	if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2309	if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2607	if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2310	if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2608	if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2311	}	2609	}
2312	else if (pos < E)	2610	else if (pos < E)
2313	{	2611	{
2314	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));	2612	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2315	if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));	2613	if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2316	if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));	2614	if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2317	if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));	2615	if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2318	}	2616	}
2319	else	2617	else
2320	break;	2618	break;
2321		2619
2322	if (ANHE_at (he) <= minat)	2620	if (ANHE_at (he) <= minat)
…		…
2330		2628
2331	heap [k] = he;	2629	heap [k] = he;
2332	ev_active (ANHE_w (he)) = k;	2630	ev_active (ANHE_w (he)) = k;
2333	}	2631	}
2334		2632
2335	#else /* 4HEAP */	2633	#else /* not 4HEAP */
2336		2634
2337	#define HEAP0 1	2635	#define HEAP0 1
2338	#define HPARENT(k) ((k) >> 1)	2636	#define HPARENT(k) ((k) >> 1)
2339	#define UPHEAP_DONE(p,k) (!(p))	2637	#define UPHEAP_DONE(p,k) (!(p))
2340		2638
…		…
2412	upheap (heap, i + HEAP0);	2710	upheap (heap, i + HEAP0);
2413	}	2711	}
2414		2712
2415	/*****************************************************************************/	2713	/*****************************************************************************/
2416		2714
2417	/* associate signal watchers to a signal signal */	2715	/* associate signal watchers to a signal */
2418	typedef struct	2716	typedef struct
2419	{	2717	{
2420	EV_ATOMIC_T pending;	2718	EV_ATOMIC_T pending;
2421	#if EV_MULTIPLICITY	2719	#if EV_MULTIPLICITY
2422	EV_P;	2720	EV_P;
…		…
2428		2726
2429	/*****************************************************************************/	2727	/*****************************************************************************/
2430		2728
2431	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2729	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2432		2730
2433	noinline ecb_cold	2731	ecb_noinline ecb_cold
2434	static void	2732	static void
2435	evpipe_init (EV_P)	2733	evpipe_init (EV_P)
2436	{	2734	{
2437	if (!ev_is_active (&pipe_w))	2735	if (!ev_is_active (&pipe_w))
2438	{	2736	{
…		…
2479	inline_speed void	2777	inline_speed void
2480	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	2778	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2481	{	2779	{
2482	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */	2780	ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
2483		2781
2484	if (expect_true (*flag))	2782	if (ecb_expect_true (*flag))
2485	return;	2783	return;
2486		2784
2487	*flag = 1;	2785	*flag = 1;
2488	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */	2786	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
2489		2787
…		…
2566	sig_pending = 0;	2864	sig_pending = 0;
2567		2865
2568	ECB_MEMORY_FENCE;	2866	ECB_MEMORY_FENCE;
2569		2867
2570	for (i = EV_NSIG - 1; i--; )	2868	for (i = EV_NSIG - 1; i--; )
2571	if (expect_false (signals [i].pending))	2869	if (ecb_expect_false (signals [i].pending))
2572	ev_feed_signal_event (EV_A_ i + 1);	2870	ev_feed_signal_event (EV_A_ i + 1);
2573	}	2871	}
2574	#endif	2872	#endif
2575		2873
2576	#if EV_ASYNC_ENABLE	2874	#if EV_ASYNC_ENABLE
…		…
2617	#endif	2915	#endif
2618		2916
2619	ev_feed_signal (signum);	2917	ev_feed_signal (signum);
2620	}	2918	}
2621		2919
2622	noinline	2920	ecb_noinline
2623	void	2921	void
2624	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT	2922	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2625	{	2923	{
2626	WL w;	2924	WL w;
2627		2925
2628	if (expect_false (signum <= 0 || signum >= EV_NSIG))	2926	if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
2629	return;	2927	return;
2630		2928
2631	--signum;	2929	--signum;
2632		2930
2633	#if EV_MULTIPLICITY	2931	#if EV_MULTIPLICITY
2634	/* it is permissible to try to feed a signal to the wrong loop */	2932	/* it is permissible to try to feed a signal to the wrong loop */
2635	/* or, likely more useful, feeding a signal nobody is waiting for */	2933	/* or, likely more useful, feeding a signal nobody is waiting for */
2636		2934
2637	if (expect_false (signals [signum].loop != EV_A))	2935	if (ecb_expect_false (signals [signum].loop != EV_A))
2638	return;	2936	return;
2639	#endif	2937	#endif
2640		2938
2641	signals [signum].pending = 0;	2939	signals [signum].pending = 0;
2642	ECB_MEMORY_FENCE_RELEASE;	2940	ECB_MEMORY_FENCE_RELEASE;
…		…
2726		3024
2727	#endif	3025	#endif
2728		3026
2729	/*****************************************************************************/	3027	/*****************************************************************************/
2730		3028
		3029	#if EV_USE_TIMERFD
		3030
		3031	static void periodics_reschedule (EV_P);
		3032
		3033	static void
		3034	timerfdcb (EV_P_ ev_io *iow, int revents)
		3035	{
		3036	struct itimerspec its = { 0 };
		3037
		3038	its.it_value.tv_sec = ev_rt_now + (int)MAX_BLOCKTIME2;
		3039	timerfd_settime (timerfd, TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &its, 0);
		3040
		3041	ev_rt_now = ev_time ();
		3042	/* periodics_reschedule only needs ev_rt_now */
		3043	/* but maybe in the future we want the full treatment. */
		3044	/*
		3045	now_floor = EV_TS_CONST (0.);
		3046	time_update (EV_A_ EV_TSTAMP_HUGE);
		3047	*/
		3048	periodics_reschedule (EV_A);
		3049	}
		3050
		3051	ecb_noinline ecb_cold
		3052	static void
		3053	evtimerfd_init (EV_P)
		3054	{
		3055	if (!ev_is_active (&timerfd_w))
		3056	{
		3057	timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
		3058
		3059	if (timerfd >= 0)
		3060	{
		3061	fd_intern (timerfd); /* just to be sure */
		3062
		3063	ev_io_init (&timerfd_w, timerfdcb, timerfd, EV_READ);
		3064	ev_set_priority (&timerfd_w, EV_MINPRI);
		3065	ev_io_start (EV_A_ &timerfd_w);
		3066	ev_unref (EV_A); /* watcher should not keep loop alive */
		3067
		3068	/* (re-) arm timer */
		3069	timerfdcb (EV_A_ 0, 0);
		3070	}
		3071	}
		3072	}
		3073
		3074	#endif
		3075
		3076	/*****************************************************************************/
		3077
2731	#if EV_USE_IOCP	3078	#if EV_USE_IOCP
2732	# include "ev_iocp.c"	3079	# include "ev_iocp.c"
2733	#endif	3080	#endif
2734	#if EV_USE_PORT	3081	#if EV_USE_PORT
2735	# include "ev_port.c"	3082	# include "ev_port.c"
…		…
2740	#if EV_USE_EPOLL	3087	#if EV_USE_EPOLL
2741	# include "ev_epoll.c"	3088	# include "ev_epoll.c"
2742	#endif	3089	#endif
2743	#if EV_USE_LINUXAIO	3090	#if EV_USE_LINUXAIO
2744	# include "ev_linuxaio.c"	3091	# include "ev_linuxaio.c"
		3092	#endif
		3093	#if EV_USE_IOURING
		3094	# include "ev_iouring.c"
2745	#endif	3095	#endif
2746	#if EV_USE_POLL	3096	#if EV_USE_POLL
2747	# include "ev_poll.c"	3097	# include "ev_poll.c"
2748	#endif	3098	#endif
2749	#if EV_USE_SELECT	3099	#if EV_USE_SELECT
…		…
2778	unsigned int	3128	unsigned int
2779	ev_supported_backends (void) EV_NOEXCEPT	3129	ev_supported_backends (void) EV_NOEXCEPT
2780	{	3130	{
2781	unsigned int flags = 0;	3131	unsigned int flags = 0;
2782		3132
2783	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	3133	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2784	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;	3134	if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
2785	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;	3135	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
2786	if (EV_USE_LINUXAIO) flags |= EVBACKEND_LINUXAIO;	3136	if (EV_USE_LINUXAIO ) flags |= EVBACKEND_LINUXAIO;
2787	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;	3137	if (EV_USE_IOURING && ev_linux_version () >= 0x050601) flags |= EVBACKEND_IOURING; /* 5.6.1+ */
2788	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;	3138	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2789		3139	if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
		3140
2790	return flags;	3141	return flags;
2791	}	3142	}
2792		3143
2793	ecb_cold	3144	ecb_cold
2794	unsigned int	3145	unsigned int
…		…
2812		3163
2813	/* TODO: linuxaio is very experimental */	3164	/* TODO: linuxaio is very experimental */
2814	#if !EV_RECOMMEND_LINUXAIO	3165	#if !EV_RECOMMEND_LINUXAIO
2815	flags &= ~EVBACKEND_LINUXAIO;	3166	flags &= ~EVBACKEND_LINUXAIO;
2816	#endif	3167	#endif
		3168	/* TODO: linuxaio is super experimental */
		3169	#if !EV_RECOMMEND_IOURING
		3170	flags &= ~EVBACKEND_IOURING;
		3171	#endif
2817		3172
2818	return flags;	3173	return flags;
2819	}	3174	}
2820		3175
2821	ecb_cold	3176	ecb_cold
2822	unsigned int	3177	unsigned int
2823	ev_embeddable_backends (void) EV_NOEXCEPT	3178	ev_embeddable_backends (void) EV_NOEXCEPT
2824	{	3179	{
2825	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	3180	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT | EVBACKEND_IOURING;
2826		3181
2827	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	3182	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2828	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	3183	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2829	flags &= ~EVBACKEND_EPOLL;	3184	flags &= ~EVBACKEND_EPOLL;
2830		3185
		3186	/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
		3187
2831	return flags;	3188	return flags;
2832	}	3189	}
2833		3190
2834	unsigned int	3191	unsigned int
2835	ev_backend (EV_P) EV_NOEXCEPT	3192	ev_backend (EV_P) EV_NOEXCEPT
…		…
2887	acquire_cb = acquire;	3244	acquire_cb = acquire;
2888	}	3245	}
2889	#endif	3246	#endif
2890		3247
2891	/* initialise a loop structure, must be zero-initialised */	3248	/* initialise a loop structure, must be zero-initialised */
2892	noinline ecb_cold	3249	ecb_noinline ecb_cold
2893	static void	3250	static void
2894	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT	3251	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2895	{	3252	{
2896	if (!backend)	3253	if (!backend)
2897	{	3254	{
…		…
2952	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	3309	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2953	#endif	3310	#endif
2954	#if EV_USE_SIGNALFD	3311	#if EV_USE_SIGNALFD
2955	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	3312	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
2956	#endif	3313	#endif
		3314	#if EV_USE_TIMERFD
		3315	timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
		3316	#endif
2957		3317
2958	if (!(flags & EVBACKEND_MASK))	3318	if (!(flags & EVBACKEND_MASK))
2959	flags |= ev_recommended_backends ();	3319	flags |= ev_recommended_backends ();
2960		3320
2961	#if EV_USE_IOCP	3321	#if EV_USE_IOCP
…		…
2964	#if EV_USE_PORT	3324	#if EV_USE_PORT
2965	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	3325	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2966	#endif	3326	#endif
2967	#if EV_USE_KQUEUE	3327	#if EV_USE_KQUEUE
2968	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);	3328	if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
		3329	#endif
		3330	#if EV_USE_IOURING
		3331	if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
2969	#endif	3332	#endif
2970	#if EV_USE_LINUXAIO	3333	#if EV_USE_LINUXAIO
2971	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);	3334	if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
2972	#endif	3335	#endif
2973	#if EV_USE_EPOLL	3336	#if EV_USE_EPOLL
…		…
3002	return;	3365	return;
3003	#endif	3366	#endif
3004		3367
3005	#if EV_CLEANUP_ENABLE	3368	#if EV_CLEANUP_ENABLE
3006	/* queue cleanup watchers (and execute them) */	3369	/* queue cleanup watchers (and execute them) */
3007	if (expect_false (cleanupcnt))	3370	if (ecb_expect_false (cleanupcnt))
3008	{	3371	{
3009	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);	3372	queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
3010	EV_INVOKE_PENDING;	3373	EV_INVOKE_PENDING;
3011	}	3374	}
3012	#endif	3375	#endif
…		…
3031	#if EV_USE_SIGNALFD	3394	#if EV_USE_SIGNALFD
3032	if (ev_is_active (&sigfd_w))	3395	if (ev_is_active (&sigfd_w))
3033	close (sigfd);	3396	close (sigfd);
3034	#endif	3397	#endif
3035		3398
		3399	#if EV_USE_TIMERFD
		3400	if (ev_is_active (&timerfd_w))
		3401	close (timerfd);
		3402	#endif
		3403
3036	#if EV_USE_INOTIFY	3404	#if EV_USE_INOTIFY
3037	if (fs_fd >= 0)	3405	if (fs_fd >= 0)
3038	close (fs_fd);	3406	close (fs_fd);
3039	#endif	3407	#endif
3040		3408
…		…
3047	#if EV_USE_PORT	3415	#if EV_USE_PORT
3048	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	3416	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
3049	#endif	3417	#endif
3050	#if EV_USE_KQUEUE	3418	#if EV_USE_KQUEUE
3051	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);	3419	if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
		3420	#endif
		3421	#if EV_USE_IOURING
		3422	if (backend == EVBACKEND_IOURING ) iouring_destroy (EV_A);
3052	#endif	3423	#endif
3053	#if EV_USE_LINUXAIO	3424	#if EV_USE_LINUXAIO
3054	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);	3425	if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
3055	#endif	3426	#endif
3056	#if EV_USE_EPOLL	3427	#if EV_USE_EPOLL
…		…
3115	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	3486	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
3116	#endif	3487	#endif
3117	#if EV_USE_KQUEUE	3488	#if EV_USE_KQUEUE
3118	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);	3489	if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
3119	#endif	3490	#endif
		3491	#if EV_USE_IOURING
		3492	if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
		3493	#endif
3120	#if EV_USE_LINUXAIO	3494	#if EV_USE_LINUXAIO
3121	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);	3495	if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
3122	#endif	3496	#endif
3123	#if EV_USE_EPOLL	3497	#if EV_USE_EPOLL
3124	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	3498	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
3125	#endif	3499	#endif
3126	#if EV_USE_INOTIFY	3500	#if EV_USE_INOTIFY
3127	infy_fork (EV_A);	3501	infy_fork (EV_A);
3128	#endif	3502	#endif
3129		3503
		3504	if (postfork != 2)
		3505	{
		3506	#if EV_USE_SIGNALFD
		3507	/* surprisingly, nothing needs to be done for signalfd, accoridng to docs, it does the right thing on fork */
		3508	#endif
		3509
		3510	#if EV_USE_TIMERFD
		3511	if (ev_is_active (&timerfd_w))
		3512	{
		3513	ev_ref (EV_A);
		3514	ev_io_stop (EV_A_ &timerfd_w);
		3515
		3516	close (timerfd);
		3517	timerfd = -2;
		3518
		3519	evtimerfd_init (EV_A);
		3520	/* reschedule periodics, in case we missed something */
		3521	ev_feed_event (EV_A_ &timerfd_w, EV_CUSTOM);
		3522	}
		3523	#endif
		3524
3130	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	3525	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
3131	if (ev_is_active (&pipe_w) && postfork != 2)	3526	if (ev_is_active (&pipe_w))
3132	{	3527	{
3133	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3528	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
3134		3529
3135	ev_ref (EV_A);	3530	ev_ref (EV_A);
3136	ev_io_stop (EV_A_ &pipe_w);	3531	ev_io_stop (EV_A_ &pipe_w);
3137		3532
3138	if (evpipe [0] >= 0)	3533	if (evpipe [0] >= 0)
3139	EV_WIN32_CLOSE_FD (evpipe [0]);	3534	EV_WIN32_CLOSE_FD (evpipe [0]);
3140		3535
3141	evpipe_init (EV_A);	3536	evpipe_init (EV_A);
3142	/* iterate over everything, in case we missed something before */	3537	/* iterate over everything, in case we missed something before */
3143	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3538	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
		3539	}
		3540	#endif
3144	}	3541	}
3145	#endif
3146		3542
3147	postfork = 0;	3543	postfork = 0;
3148	}	3544	}
3149		3545
3150	#if EV_MULTIPLICITY	3546	#if EV_MULTIPLICITY
…		…
3166	}	3562	}
3167		3563
3168	#endif /* multiplicity */	3564	#endif /* multiplicity */
3169		3565
3170	#if EV_VERIFY	3566	#if EV_VERIFY
3171	noinline ecb_cold	3567	ecb_noinline ecb_cold
3172	static void	3568	static void
3173	verify_watcher (EV_P_ W w)	3569	verify_watcher (EV_P_ W w)
3174	{	3570	{
3175	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3571	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
3176		3572
3177	if (w->pending)	3573	if (w->pending)
3178	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3574	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
3179	}	3575	}
3180		3576
3181	noinline ecb_cold	3577	ecb_noinline ecb_cold
3182	static void	3578	static void
3183	verify_heap (EV_P_ ANHE *heap, int N)	3579	verify_heap (EV_P_ ANHE *heap, int N)
3184	{	3580	{
3185	int i;	3581	int i;
3186		3582
…		…
3192		3588
3193	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3589	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
3194	}	3590	}
3195	}	3591	}
3196		3592
3197	noinline ecb_cold	3593	ecb_noinline ecb_cold
3198	static void	3594	static void
3199	array_verify (EV_P_ W *ws, int cnt)	3595	array_verify (EV_P_ W *ws, int cnt)
3200	{	3596	{
3201	while (cnt--)	3597	while (cnt--)
3202	{	3598	{
…		…
3351	count += pendingcnt [pri];	3747	count += pendingcnt [pri];
3352		3748
3353	return count;	3749	return count;
3354	}	3750	}
3355		3751
3356	noinline	3752	ecb_noinline
3357	void	3753	void
3358	ev_invoke_pending (EV_P)	3754	ev_invoke_pending (EV_P)
3359	{	3755	{
3360	pendingpri = NUMPRI;	3756	pendingpri = NUMPRI;
3361		3757
…		…
3380	/* make idle watchers pending. this handles the "call-idle */	3776	/* make idle watchers pending. this handles the "call-idle */
3381	/* only when higher priorities are idle" logic */	3777	/* only when higher priorities are idle" logic */
3382	inline_size void	3778	inline_size void
3383	idle_reify (EV_P)	3779	idle_reify (EV_P)
3384	{	3780	{
3385	if (expect_false (idleall))	3781	if (ecb_expect_false (idleall))
3386	{	3782	{
3387	int pri;	3783	int pri;
3388		3784
3389	for (pri = NUMPRI; pri--; )	3785	for (pri = NUMPRI; pri--; )
3390	{	3786	{
…		…
3420	{	3816	{
3421	ev_at (w) += w->repeat;	3817	ev_at (w) += w->repeat;
3422	if (ev_at (w) < mn_now)	3818	if (ev_at (w) < mn_now)
3423	ev_at (w) = mn_now;	3819	ev_at (w) = mn_now;
3424		3820
3425	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));	3821	assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > EV_TS_CONST (0.)));
3426		3822
3427	ANHE_at_cache (timers [HEAP0]);	3823	ANHE_at_cache (timers [HEAP0]);
3428	downheap (timers, timercnt, HEAP0);	3824	downheap (timers, timercnt, HEAP0);
3429	}	3825	}
3430	else	3826	else
…		…
3439	}	3835	}
3440	}	3836	}
3441		3837
3442	#if EV_PERIODIC_ENABLE	3838	#if EV_PERIODIC_ENABLE
3443		3839
3444	noinline	3840	ecb_noinline
3445	static void	3841	static void
3446	periodic_recalc (EV_P_ ev_periodic *w)	3842	periodic_recalc (EV_P_ ev_periodic *w)
3447	{	3843	{
3448	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3844	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3449	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);	3845	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
…		…
3452	while (at <= ev_rt_now)	3848	while (at <= ev_rt_now)
3453	{	3849	{
3454	ev_tstamp nat = at + w->interval;	3850	ev_tstamp nat = at + w->interval;
3455		3851
3456	/* when resolution fails us, we use ev_rt_now */	3852	/* when resolution fails us, we use ev_rt_now */
3457	if (expect_false (nat == at))	3853	if (ecb_expect_false (nat == at))
3458	{	3854	{
3459	at = ev_rt_now;	3855	at = ev_rt_now;
3460	break;	3856	break;
3461	}	3857	}
3462		3858
…		…
3508	}	3904	}
3509	}	3905	}
3510		3906
3511	/* simply recalculate all periodics */	3907	/* simply recalculate all periodics */
3512	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3908	/* TODO: maybe ensure that at least one event happens when jumping forward? */
3513	noinline ecb_cold	3909	ecb_noinline ecb_cold
3514	static void	3910	static void
3515	periodics_reschedule (EV_P)	3911	periodics_reschedule (EV_P)
3516	{	3912	{
3517	int i;	3913	int i;
3518		3914
…		…
3532	reheap (periodics, periodiccnt);	3928	reheap (periodics, periodiccnt);
3533	}	3929	}
3534	#endif	3930	#endif
3535		3931
3536	/* adjust all timers by a given offset */	3932	/* adjust all timers by a given offset */
3537	noinline ecb_cold	3933	ecb_noinline ecb_cold
3538	static void	3934	static void
3539	timers_reschedule (EV_P_ ev_tstamp adjust)	3935	timers_reschedule (EV_P_ ev_tstamp adjust)
3540	{	3936	{
3541	int i;	3937	int i;
3542		3938
…		…
3552	/* also detect if there was a timejump, and act accordingly */	3948	/* also detect if there was a timejump, and act accordingly */
3553	inline_speed void	3949	inline_speed void
3554	time_update (EV_P_ ev_tstamp max_block)	3950	time_update (EV_P_ ev_tstamp max_block)
3555	{	3951	{
3556	#if EV_USE_MONOTONIC	3952	#if EV_USE_MONOTONIC
3557	if (expect_true (have_monotonic))	3953	if (ecb_expect_true (have_monotonic))
3558	{	3954	{
3559	int i;	3955	int i;
3560	ev_tstamp odiff = rtmn_diff;	3956	ev_tstamp odiff = rtmn_diff;
3561		3957
3562	mn_now = get_clock ();	3958	mn_now = get_clock ();
3563		3959
3564	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */	3960	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3565	/* interpolate in the meantime */	3961	/* interpolate in the meantime */
3566	if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))	3962	if (ecb_expect_true (mn_now - now_floor < EV_TS_CONST (MIN_TIMEJUMP * .5)))
3567	{	3963	{
3568	ev_rt_now = rtmn_diff + mn_now;	3964	ev_rt_now = rtmn_diff + mn_now;
3569	return;	3965	return;
3570	}	3966	}
3571		3967
…		…
3585	ev_tstamp diff;	3981	ev_tstamp diff;
3586	rtmn_diff = ev_rt_now - mn_now;	3982	rtmn_diff = ev_rt_now - mn_now;
3587		3983
3588	diff = odiff - rtmn_diff;	3984	diff = odiff - rtmn_diff;
3589		3985
3590	if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))	3986	if (ecb_expect_true ((diff < EV_TS_CONST (0.) ? -diff : diff) < EV_TS_CONST (MIN_TIMEJUMP)))
3591	return; /* all is well */	3987	return; /* all is well */
3592		3988
3593	ev_rt_now = ev_time ();	3989	ev_rt_now = ev_time ();
3594	mn_now = get_clock ();	3990	mn_now = get_clock ();
3595	now_floor = mn_now;	3991	now_floor = mn_now;
…		…
3604	else	4000	else
3605	#endif	4001	#endif
3606	{	4002	{
3607	ev_rt_now = ev_time ();	4003	ev_rt_now = ev_time ();
3608		4004
3609	if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))	4005	if (ecb_expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + EV_TS_CONST (MIN_TIMEJUMP)))
3610	{	4006	{
3611	/* adjust timers. this is easy, as the offset is the same for all of them */	4007	/* adjust timers. this is easy, as the offset is the same for all of them */
3612	timers_reschedule (EV_A_ ev_rt_now - mn_now);	4008	timers_reschedule (EV_A_ ev_rt_now - mn_now);
3613	#if EV_PERIODIC_ENABLE	4009	#if EV_PERIODIC_ENABLE
3614	periodics_reschedule (EV_A);	4010	periodics_reschedule (EV_A);
…		…
3637	#if EV_VERIFY >= 2	4033	#if EV_VERIFY >= 2
3638	ev_verify (EV_A);	4034	ev_verify (EV_A);
3639	#endif	4035	#endif
3640		4036
3641	#ifndef _WIN32	4037	#ifndef _WIN32
3642	if (expect_false (curpid)) /* penalise the forking check even more */	4038	if (ecb_expect_false (curpid)) /* penalise the forking check even more */
3643	if (expect_false (getpid () != curpid))	4039	if (ecb_expect_false (getpid () != curpid))
3644	{	4040	{
3645	curpid = getpid ();	4041	curpid = getpid ();
3646	postfork = 1;	4042	postfork = 1;
3647	}	4043	}
3648	#endif	4044	#endif
3649		4045
3650	#if EV_FORK_ENABLE	4046	#if EV_FORK_ENABLE
3651	/* we might have forked, so queue fork handlers */	4047	/* we might have forked, so queue fork handlers */
3652	if (expect_false (postfork))	4048	if (ecb_expect_false (postfork))
3653	if (forkcnt)	4049	if (forkcnt)
3654	{	4050	{
3655	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	4051	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3656	EV_INVOKE_PENDING;	4052	EV_INVOKE_PENDING;
3657	}	4053	}
3658	#endif	4054	#endif
3659		4055
3660	#if EV_PREPARE_ENABLE	4056	#if EV_PREPARE_ENABLE
3661	/* queue prepare watchers (and execute them) */	4057	/* queue prepare watchers (and execute them) */
3662	if (expect_false (preparecnt))	4058	if (ecb_expect_false (preparecnt))
3663	{	4059	{
3664	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	4060	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3665	EV_INVOKE_PENDING;	4061	EV_INVOKE_PENDING;
3666	}	4062	}
3667	#endif	4063	#endif
3668		4064
3669	if (expect_false (loop_done))	4065	if (ecb_expect_false (loop_done))
3670	break;	4066	break;
3671		4067
3672	/* we might have forked, so reify kernel state if necessary */	4068	/* we might have forked, so reify kernel state if necessary */
3673	if (expect_false (postfork))	4069	if (ecb_expect_false (postfork))
3674	loop_fork (EV_A);	4070	loop_fork (EV_A);
3675		4071
3676	/* update fd-related kernel structures */	4072	/* update fd-related kernel structures */
3677	fd_reify (EV_A);	4073	fd_reify (EV_A);
3678		4074
…		…
3683		4079
3684	/* remember old timestamp for io_blocktime calculation */	4080	/* remember old timestamp for io_blocktime calculation */
3685	ev_tstamp prev_mn_now = mn_now;	4081	ev_tstamp prev_mn_now = mn_now;
3686		4082
3687	/* update time to cancel out callback processing overhead */	4083	/* update time to cancel out callback processing overhead */
3688	time_update (EV_A_ 1e100);	4084	time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
3689		4085
3690	/* from now on, we want a pipe-wake-up */	4086	/* from now on, we want a pipe-wake-up */
3691	pipe_write_wanted = 1;	4087	pipe_write_wanted = 1;
3692		4088
3693	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */	4089	ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3694		4090
3695	if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))	4091	if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3696	{	4092	{
3697	waittime = MAX_BLOCKTIME;	4093	waittime = EV_TS_CONST (MAX_BLOCKTIME);
		4094
		4095	#if EV_USE_TIMERFD
		4096	/* sleep a lot longer when we can reliably detect timejumps */
		4097	if (ecb_expect_true (timerfd >= 0))
		4098	waittime = EV_TS_CONST (MAX_BLOCKTIME2);
		4099	#endif
3698		4100
3699	if (timercnt)	4101	if (timercnt)
3700	{	4102	{
3701	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;	4103	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3702	if (waittime > to) waittime = to;	4104	if (waittime > to) waittime = to;
…		…
3709	if (waittime > to) waittime = to;	4111	if (waittime > to) waittime = to;
3710	}	4112	}
3711	#endif	4113	#endif
3712		4114
3713	/* don't let timeouts decrease the waittime below timeout_blocktime */	4115	/* don't let timeouts decrease the waittime below timeout_blocktime */
3714	if (expect_false (waittime < timeout_blocktime))	4116	if (ecb_expect_false (waittime < timeout_blocktime))
3715	waittime = timeout_blocktime;	4117	waittime = timeout_blocktime;
3716		4118
3717	/* at this point, we NEED to wait, so we have to ensure */	4119	/* now there are two more special cases left, either we have
3718	/* to pass a minimum nonzero value to the backend */	4120	* already-expired timers, so we should not sleep, or we have timers
		4121	* that expire very soon, in which case we need to wait for a minimum
		4122	* amount of time for some event loop backends.
		4123	*/
3719	if (expect_false (waittime < backend_mintime))	4124	if (ecb_expect_false (waittime < backend_mintime))
		4125	waittime = waittime <= EV_TS_CONST (0.)
		4126	? EV_TS_CONST (0.)
3720	waittime = backend_mintime;	4127	: backend_mintime;
3721		4128
3722	/* extra check because io_blocktime is commonly 0 */	4129	/* extra check because io_blocktime is commonly 0 */
3723	if (expect_false (io_blocktime))	4130	if (ecb_expect_false (io_blocktime))
3724	{	4131	{
3725	sleeptime = io_blocktime - (mn_now - prev_mn_now);	4132	sleeptime = io_blocktime - (mn_now - prev_mn_now);
3726		4133
3727	if (sleeptime > waittime - backend_mintime)	4134	if (sleeptime > waittime - backend_mintime)
3728	sleeptime = waittime - backend_mintime;	4135	sleeptime = waittime - backend_mintime;
3729		4136
3730	if (expect_true (sleeptime > 0.))	4137	if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
3731	{	4138	{
3732	ev_sleep (sleeptime);	4139	ev_sleep (sleeptime);
3733	waittime -= sleeptime;	4140	waittime -= sleeptime;
3734	}	4141	}
3735	}	4142	}
…		…
3749	{	4156	{
3750	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	4157	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3751	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	4158	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3752	}	4159	}
3753		4160
3754
3755	/* update ev_rt_now, do magic */	4161	/* update ev_rt_now, do magic */
3756	time_update (EV_A_ waittime + sleeptime);	4162	time_update (EV_A_ waittime + sleeptime);
3757	}	4163	}
3758		4164
3759	/* queue pending timers and reschedule them */	4165	/* queue pending timers and reschedule them */
…		…
3767	idle_reify (EV_A);	4173	idle_reify (EV_A);
3768	#endif	4174	#endif
3769		4175
3770	#if EV_CHECK_ENABLE	4176	#if EV_CHECK_ENABLE
3771	/* queue check watchers, to be executed first */	4177	/* queue check watchers, to be executed first */
3772	if (expect_false (checkcnt))	4178	if (ecb_expect_false (checkcnt))
3773	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	4179	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3774	#endif	4180	#endif
3775		4181
3776	EV_INVOKE_PENDING;	4182	EV_INVOKE_PENDING;
3777	}	4183	}
3778	while (expect_true (	4184	while (ecb_expect_true (
3779	activecnt	4185	activecnt
3780	&& !loop_done	4186	&& !loop_done
3781	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))	4187	&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3782	));	4188	));
3783		4189
…		…
3810	}	4216	}
3811		4217
3812	void	4218	void
3813	ev_now_update (EV_P) EV_NOEXCEPT	4219	ev_now_update (EV_P) EV_NOEXCEPT
3814	{	4220	{
3815	time_update (EV_A_ 1e100);	4221	time_update (EV_A_ EV_TSTAMP_HUGE);
3816	}	4222	}
3817		4223
3818	void	4224	void
3819	ev_suspend (EV_P) EV_NOEXCEPT	4225	ev_suspend (EV_P) EV_NOEXCEPT
3820	{	4226	{
…		…
3847	inline_size void	4253	inline_size void
3848	wlist_del (WL *head, WL elem)	4254	wlist_del (WL *head, WL elem)
3849	{	4255	{
3850	while (*head)	4256	while (*head)
3851	{	4257	{
3852	if (expect_true (*head == elem))	4258	if (ecb_expect_true (*head == elem))
3853	{	4259	{
3854	*head = elem->next;	4260	*head = elem->next;
3855	break;	4261	break;
3856	}	4262	}
3857		4263
…		…
3874	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT	4280	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3875	{	4281	{
3876	W w_ = (W)w;	4282	W w_ = (W)w;
3877	int pending = w_->pending;	4283	int pending = w_->pending;
3878		4284
3879	if (expect_true (pending))	4285	if (ecb_expect_true (pending))
3880	{	4286	{
3881	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;	4287	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3882	p->w = (W)&pending_w;	4288	p->w = (W)&pending_w;
3883	w_->pending = 0;	4289	w_->pending = 0;
3884	return p->events;	4290	return p->events;
…		…
3911	w->active = 0;	4317	w->active = 0;
3912	}	4318	}
3913		4319
3914	/*****************************************************************************/	4320	/*****************************************************************************/
3915		4321
3916	noinline	4322	ecb_noinline
3917	void	4323	void
3918	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT	4324	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3919	{	4325	{
3920	int fd = w->fd;	4326	int fd = w->fd;
3921		4327
3922	if (expect_false (ev_is_active (w)))	4328	if (ecb_expect_false (ev_is_active (w)))
3923	return;	4329	return;
3924		4330
3925	assert (("libev: ev_io_start called with negative fd", fd >= 0));	4331	assert (("libev: ev_io_start called with negative fd", fd >= 0));
3926	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));	4332	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3927		4333
…		…
3941	w->events &= ~EV__IOFDSET;	4347	w->events &= ~EV__IOFDSET;
3942		4348
3943	EV_FREQUENT_CHECK;	4349	EV_FREQUENT_CHECK;
3944	}	4350	}
3945		4351
3946	noinline	4352	ecb_noinline
3947	void	4353	void
3948	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT	4354	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3949	{	4355	{
3950	clear_pending (EV_A_ (W)w);	4356	clear_pending (EV_A_ (W)w);
3951	if (expect_false (!ev_is_active (w)))	4357	if (ecb_expect_false (!ev_is_active (w)))
3952	return;	4358	return;
3953		4359
3954	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));	4360	assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3955		4361
3956	#if EV_VERIFY >= 2	4362	#if EV_VERIFY >= 2
…		…
3964	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	4370	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3965		4371
3966	EV_FREQUENT_CHECK;	4372	EV_FREQUENT_CHECK;
3967	}	4373	}
3968		4374
3969	noinline	4375	ecb_noinline
3970	void	4376	void
3971	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT	4377	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3972	{	4378	{
3973	if (expect_false (ev_is_active (w)))	4379	if (ecb_expect_false (ev_is_active (w)))
3974	return;	4380	return;
3975		4381
3976	ev_at (w) += mn_now;	4382	ev_at (w) += mn_now;
3977		4383
3978	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));	4384	assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
…		…
3989	EV_FREQUENT_CHECK;	4395	EV_FREQUENT_CHECK;
3990		4396
3991	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	4397	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3992	}	4398	}
3993		4399
3994	noinline	4400	ecb_noinline
3995	void	4401	void
3996	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT	4402	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3997	{	4403	{
3998	clear_pending (EV_A_ (W)w);	4404	clear_pending (EV_A_ (W)w);
3999	if (expect_false (!ev_is_active (w)))	4405	if (ecb_expect_false (!ev_is_active (w)))
4000	return;	4406	return;
4001		4407
4002	EV_FREQUENT_CHECK;	4408	EV_FREQUENT_CHECK;
4003		4409
4004	{	4410	{
…		…
4006		4412
4007	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));	4413	assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
4008		4414
4009	--timercnt;	4415	--timercnt;
4010		4416
4011	if (expect_true (active < timercnt + HEAP0))	4417	if (ecb_expect_true (active < timercnt + HEAP0))
4012	{	4418	{
4013	timers [active] = timers [timercnt + HEAP0];	4419	timers [active] = timers [timercnt + HEAP0];
4014	adjustheap (timers, timercnt, active);	4420	adjustheap (timers, timercnt, active);
4015	}	4421	}
4016	}	4422	}
…		…
4020	ev_stop (EV_A_ (W)w);	4426	ev_stop (EV_A_ (W)w);
4021		4427
4022	EV_FREQUENT_CHECK;	4428	EV_FREQUENT_CHECK;
4023	}	4429	}
4024		4430
4025	noinline	4431	ecb_noinline
4026	void	4432	void
4027	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT	4433	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
4028	{	4434	{
4029	EV_FREQUENT_CHECK;	4435	EV_FREQUENT_CHECK;
4030		4436
…		…
4051	}	4457	}
4052		4458
4053	ev_tstamp	4459	ev_tstamp
4054	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT	4460	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
4055	{	4461	{
4056	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	4462	return ev_at (w) - (ev_is_active (w) ? mn_now : EV_TS_CONST (0.));
4057	}	4463	}
4058		4464
4059	#if EV_PERIODIC_ENABLE	4465	#if EV_PERIODIC_ENABLE
4060	noinline	4466	ecb_noinline
4061	void	4467	void
4062	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT	4468	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4063	{	4469	{
4064	if (expect_false (ev_is_active (w)))	4470	if (ecb_expect_false (ev_is_active (w)))
4065	return;	4471	return;
		4472
		4473	#if EV_USE_TIMERFD
		4474	if (timerfd == -2)
		4475	evtimerfd_init (EV_A);
		4476	#endif
4066		4477
4067	if (w->reschedule_cb)	4478	if (w->reschedule_cb)
4068	ev_at (w) = w->reschedule_cb (w, ev_rt_now);	4479	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
4069	else if (w->interval)	4480	else if (w->interval)
4070	{	4481	{
…		…
4086	EV_FREQUENT_CHECK;	4497	EV_FREQUENT_CHECK;
4087		4498
4088	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4499	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
4089	}	4500	}
4090		4501
4091	noinline	4502	ecb_noinline
4092	void	4503	void
4093	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT	4504	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
4094	{	4505	{
4095	clear_pending (EV_A_ (W)w);	4506	clear_pending (EV_A_ (W)w);
4096	if (expect_false (!ev_is_active (w)))	4507	if (ecb_expect_false (!ev_is_active (w)))
4097	return;	4508	return;
4098		4509
4099	EV_FREQUENT_CHECK;	4510	EV_FREQUENT_CHECK;
4100		4511
4101	{	4512	{
…		…
4103		4514
4104	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));	4515	assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
4105		4516
4106	--periodiccnt;	4517	--periodiccnt;
4107		4518
4108	if (expect_true (active < periodiccnt + HEAP0))	4519	if (ecb_expect_true (active < periodiccnt + HEAP0))
4109	{	4520	{
4110	periodics [active] = periodics [periodiccnt + HEAP0];	4521	periodics [active] = periodics [periodiccnt + HEAP0];
4111	adjustheap (periodics, periodiccnt, active);	4522	adjustheap (periodics, periodiccnt, active);
4112	}	4523	}
4113	}	4524	}
…		…
4115	ev_stop (EV_A_ (W)w);	4526	ev_stop (EV_A_ (W)w);
4116		4527
4117	EV_FREQUENT_CHECK;	4528	EV_FREQUENT_CHECK;
4118	}	4529	}
4119		4530
4120	noinline	4531	ecb_noinline
4121	void	4532	void
4122	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT	4533	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4123	{	4534	{
4124	/* TODO: use adjustheap and recalculation */	4535	/* TODO: use adjustheap and recalculation */
4125	ev_periodic_stop (EV_A_ w);	4536	ev_periodic_stop (EV_A_ w);
…		…
4131	# define SA_RESTART 0	4542	# define SA_RESTART 0
4132	#endif	4543	#endif
4133		4544
4134	#if EV_SIGNAL_ENABLE	4545	#if EV_SIGNAL_ENABLE
4135		4546
4136	noinline	4547	ecb_noinline
4137	void	4548	void
4138	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT	4549	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4139	{	4550	{
4140	if (expect_false (ev_is_active (w)))	4551	if (ecb_expect_false (ev_is_active (w)))
4141	return;	4552	return;
4142		4553
4143	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4554	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
4144		4555
4145	#if EV_MULTIPLICITY	4556	#if EV_MULTIPLICITY
…		…
4214	}	4625	}
4215		4626
4216	EV_FREQUENT_CHECK;	4627	EV_FREQUENT_CHECK;
4217	}	4628	}
4218		4629
4219	noinline	4630	ecb_noinline
4220	void	4631	void
4221	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT	4632	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4222	{	4633	{
4223	clear_pending (EV_A_ (W)w);	4634	clear_pending (EV_A_ (W)w);
4224	if (expect_false (!ev_is_active (w)))	4635	if (ecb_expect_false (!ev_is_active (w)))
4225	return;	4636	return;
4226		4637
4227	EV_FREQUENT_CHECK;	4638	EV_FREQUENT_CHECK;
4228		4639
4229	wlist_del (&signals [w->signum - 1].head, (WL)w);	4640	wlist_del (&signals [w->signum - 1].head, (WL)w);
…		…
4262	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT	4673	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4263	{	4674	{
4264	#if EV_MULTIPLICITY	4675	#if EV_MULTIPLICITY
4265	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4676	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
4266	#endif	4677	#endif
4267	if (expect_false (ev_is_active (w)))	4678	if (ecb_expect_false (ev_is_active (w)))
4268	return;	4679	return;
4269		4680
4270	EV_FREQUENT_CHECK;	4681	EV_FREQUENT_CHECK;
4271		4682
4272	ev_start (EV_A_ (W)w, 1);	4683	ev_start (EV_A_ (W)w, 1);
…		…
4277		4688
4278	void	4689	void
4279	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT	4690	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4280	{	4691	{
4281	clear_pending (EV_A_ (W)w);	4692	clear_pending (EV_A_ (W)w);
4282	if (expect_false (!ev_is_active (w)))	4693	if (ecb_expect_false (!ev_is_active (w)))
4283	return;	4694	return;
4284		4695
4285	EV_FREQUENT_CHECK;	4696	EV_FREQUENT_CHECK;
4286		4697
4287	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);	4698	wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
…		…
4301		4712
4302	#define DEF_STAT_INTERVAL 5.0074891	4713	#define DEF_STAT_INTERVAL 5.0074891
4303	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4714	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
4304	#define MIN_STAT_INTERVAL 0.1074891	4715	#define MIN_STAT_INTERVAL 0.1074891
4305		4716
4306	noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4717	ecb_noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
4307		4718
4308	#if EV_USE_INOTIFY	4719	#if EV_USE_INOTIFY
4309		4720
4310	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4721	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
4311	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4722	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
4312		4723
4313	noinline	4724	ecb_noinline
4314	static void	4725	static void
4315	infy_add (EV_P_ ev_stat *w)	4726	infy_add (EV_P_ ev_stat *w)
4316	{	4727	{
4317	w->wd = inotify_add_watch (fs_fd, w->path,	4728	w->wd = inotify_add_watch (fs_fd, w->path,
4318	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY	4729	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
…		…
4383	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4794	if (ev_is_active (&w->timer)) ev_ref (EV_A);
4384	ev_timer_again (EV_A_ &w->timer);	4795	ev_timer_again (EV_A_ &w->timer);
4385	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4796	if (ev_is_active (&w->timer)) ev_unref (EV_A);
4386	}	4797	}
4387		4798
4388	noinline	4799	ecb_noinline
4389	static void	4800	static void
4390	infy_del (EV_P_ ev_stat *w)	4801	infy_del (EV_P_ ev_stat *w)
4391	{	4802	{
4392	int slot;	4803	int slot;
4393	int wd = w->wd;	4804	int wd = w->wd;
…		…
4401		4812
4402	/* remove this watcher, if others are watching it, they will rearm */	4813	/* remove this watcher, if others are watching it, they will rearm */
4403	inotify_rm_watch (fs_fd, wd);	4814	inotify_rm_watch (fs_fd, wd);
4404	}	4815	}
4405		4816
4406	noinline	4817	ecb_noinline
4407	static void	4818	static void
4408	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4819	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
4409	{	4820	{
4410	if (slot < 0)	4821	if (slot < 0)
4411	/* overflow, need to check for all hash slots */	4822	/* overflow, need to check for all hash slots */
…		…
4557	w->attr.st_nlink = 0;	4968	w->attr.st_nlink = 0;
4558	else if (!w->attr.st_nlink)	4969	else if (!w->attr.st_nlink)
4559	w->attr.st_nlink = 1;	4970	w->attr.st_nlink = 1;
4560	}	4971	}
4561		4972
4562	noinline	4973	ecb_noinline
4563	static void	4974	static void
4564	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4975	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4565	{	4976	{
4566	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4977	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4567		4978
…		…
4601	}	5012	}
4602		5013
4603	void	5014	void
4604	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT	5015	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4605	{	5016	{
4606	if (expect_false (ev_is_active (w)))	5017	if (ecb_expect_false (ev_is_active (w)))
4607	return;	5018	return;
4608		5019
4609	ev_stat_stat (EV_A_ w);	5020	ev_stat_stat (EV_A_ w);
4610		5021
4611	if (w->interval < MIN_STAT_INTERVAL && w->interval)	5022	if (w->interval < MIN_STAT_INTERVAL && w->interval)
…		…
4633		5044
4634	void	5045	void
4635	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT	5046	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4636	{	5047	{
4637	clear_pending (EV_A_ (W)w);	5048	clear_pending (EV_A_ (W)w);
4638	if (expect_false (!ev_is_active (w)))	5049	if (ecb_expect_false (!ev_is_active (w)))
4639	return;	5050	return;
4640		5051
4641	EV_FREQUENT_CHECK;	5052	EV_FREQUENT_CHECK;
4642		5053
4643	#if EV_USE_INOTIFY	5054	#if EV_USE_INOTIFY
…		…
4658		5069
4659	#if EV_IDLE_ENABLE	5070	#if EV_IDLE_ENABLE
4660	void	5071	void
4661	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT	5072	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4662	{	5073	{
4663	if (expect_false (ev_is_active (w)))	5074	if (ecb_expect_false (ev_is_active (w)))
4664	return;	5075	return;
4665		5076
4666	pri_adjust (EV_A_ (W)w);	5077	pri_adjust (EV_A_ (W)w);
4667		5078
4668	EV_FREQUENT_CHECK;	5079	EV_FREQUENT_CHECK;
…		…
4682		5093
4683	void	5094	void
4684	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT	5095	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4685	{	5096	{
4686	clear_pending (EV_A_ (W)w);	5097	clear_pending (EV_A_ (W)w);
4687	if (expect_false (!ev_is_active (w)))	5098	if (ecb_expect_false (!ev_is_active (w)))
4688	return;	5099	return;
4689		5100
4690	EV_FREQUENT_CHECK;	5101	EV_FREQUENT_CHECK;
4691		5102
4692	{	5103	{
…		…
4705		5116
4706	#if EV_PREPARE_ENABLE	5117	#if EV_PREPARE_ENABLE
4707	void	5118	void
4708	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT	5119	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4709	{	5120	{
4710	if (expect_false (ev_is_active (w)))	5121	if (ecb_expect_false (ev_is_active (w)))
4711	return;	5122	return;
4712		5123
4713	EV_FREQUENT_CHECK;	5124	EV_FREQUENT_CHECK;
4714		5125
4715	ev_start (EV_A_ (W)w, ++preparecnt);	5126	ev_start (EV_A_ (W)w, ++preparecnt);
…		…
4721		5132
4722	void	5133	void
4723	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT	5134	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4724	{	5135	{
4725	clear_pending (EV_A_ (W)w);	5136	clear_pending (EV_A_ (W)w);
4726	if (expect_false (!ev_is_active (w)))	5137	if (ecb_expect_false (!ev_is_active (w)))
4727	return;	5138	return;
4728		5139
4729	EV_FREQUENT_CHECK;	5140	EV_FREQUENT_CHECK;
4730		5141
4731	{	5142	{
…		…
4743		5154
4744	#if EV_CHECK_ENABLE	5155	#if EV_CHECK_ENABLE
4745	void	5156	void
4746	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT	5157	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4747	{	5158	{
4748	if (expect_false (ev_is_active (w)))	5159	if (ecb_expect_false (ev_is_active (w)))
4749	return;	5160	return;
4750		5161
4751	EV_FREQUENT_CHECK;	5162	EV_FREQUENT_CHECK;
4752		5163
4753	ev_start (EV_A_ (W)w, ++checkcnt);	5164	ev_start (EV_A_ (W)w, ++checkcnt);
…		…
4759		5170
4760	void	5171	void
4761	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT	5172	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4762	{	5173	{
4763	clear_pending (EV_A_ (W)w);	5174	clear_pending (EV_A_ (W)w);
4764	if (expect_false (!ev_is_active (w)))	5175	if (ecb_expect_false (!ev_is_active (w)))
4765	return;	5176	return;
4766		5177
4767	EV_FREQUENT_CHECK;	5178	EV_FREQUENT_CHECK;
4768		5179
4769	{	5180	{
…		…
4778	EV_FREQUENT_CHECK;	5189	EV_FREQUENT_CHECK;
4779	}	5190	}
4780	#endif	5191	#endif
4781		5192
4782	#if EV_EMBED_ENABLE	5193	#if EV_EMBED_ENABLE
4783	noinline	5194	ecb_noinline
4784	void	5195	void
4785	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT	5196	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4786	{	5197	{
4787	ev_run (w->other, EVRUN_NOWAIT);	5198	ev_run (w->other, EVRUN_NOWAIT);
4788	}	5199	}
…		…
4812	ev_run (EV_A_ EVRUN_NOWAIT);	5223	ev_run (EV_A_ EVRUN_NOWAIT);
4813	}	5224	}
4814	}	5225	}
4815	}	5226	}
4816		5227
		5228	#if EV_FORK_ENABLE
4817	static void	5229	static void
4818	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)	5230	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4819	{	5231	{
4820	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));	5232	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
4821		5233
…		…
4828	ev_run (EV_A_ EVRUN_NOWAIT);	5240	ev_run (EV_A_ EVRUN_NOWAIT);
4829	}	5241	}
4830		5242
4831	ev_embed_start (EV_A_ w);	5243	ev_embed_start (EV_A_ w);
4832	}	5244	}
		5245	#endif
4833		5246
4834	#if 0	5247	#if 0
4835	static void	5248	static void
4836	embed_idle_cb (EV_P_ ev_idle *idle, int revents)	5249	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4837	{	5250	{
…		…
4840	#endif	5253	#endif
4841		5254
4842	void	5255	void
4843	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT	5256	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4844	{	5257	{
4845	if (expect_false (ev_is_active (w)))	5258	if (ecb_expect_false (ev_is_active (w)))
4846	return;	5259	return;
4847		5260
4848	{	5261	{
4849	EV_P = w->other;	5262	EV_P = w->other;
4850	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));	5263	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
…		…
4858		5271
4859	ev_prepare_init (&w->prepare, embed_prepare_cb);	5272	ev_prepare_init (&w->prepare, embed_prepare_cb);
4860	ev_set_priority (&w->prepare, EV_MINPRI);	5273	ev_set_priority (&w->prepare, EV_MINPRI);
4861	ev_prepare_start (EV_A_ &w->prepare);	5274	ev_prepare_start (EV_A_ &w->prepare);
4862		5275
		5276	#if EV_FORK_ENABLE
4863	ev_fork_init (&w->fork, embed_fork_cb);	5277	ev_fork_init (&w->fork, embed_fork_cb);
4864	ev_fork_start (EV_A_ &w->fork);	5278	ev_fork_start (EV_A_ &w->fork);
		5279	#endif
4865		5280
4866	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/	5281	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4867		5282
4868	ev_start (EV_A_ (W)w, 1);	5283	ev_start (EV_A_ (W)w, 1);
4869		5284
…		…
4872		5287
4873	void	5288	void
4874	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT	5289	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4875	{	5290	{
4876	clear_pending (EV_A_ (W)w);	5291	clear_pending (EV_A_ (W)w);
4877	if (expect_false (!ev_is_active (w)))	5292	if (ecb_expect_false (!ev_is_active (w)))
4878	return;	5293	return;
4879		5294
4880	EV_FREQUENT_CHECK;	5295	EV_FREQUENT_CHECK;
4881		5296
4882	ev_io_stop (EV_A_ &w->io);	5297	ev_io_stop (EV_A_ &w->io);
4883	ev_prepare_stop (EV_A_ &w->prepare);	5298	ev_prepare_stop (EV_A_ &w->prepare);
		5299	#if EV_FORK_ENABLE
4884	ev_fork_stop (EV_A_ &w->fork);	5300	ev_fork_stop (EV_A_ &w->fork);
		5301	#endif
4885		5302
4886	ev_stop (EV_A_ (W)w);	5303	ev_stop (EV_A_ (W)w);
4887		5304
4888	EV_FREQUENT_CHECK;	5305	EV_FREQUENT_CHECK;
4889	}	5306	}
…		…
4891		5308
4892	#if EV_FORK_ENABLE	5309	#if EV_FORK_ENABLE
4893	void	5310	void
4894	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT	5311	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4895	{	5312	{
4896	if (expect_false (ev_is_active (w)))	5313	if (ecb_expect_false (ev_is_active (w)))
4897	return;	5314	return;
4898		5315
4899	EV_FREQUENT_CHECK;	5316	EV_FREQUENT_CHECK;
4900		5317
4901	ev_start (EV_A_ (W)w, ++forkcnt);	5318	ev_start (EV_A_ (W)w, ++forkcnt);
…		…
4907		5324
4908	void	5325	void
4909	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT	5326	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4910	{	5327	{
4911	clear_pending (EV_A_ (W)w);	5328	clear_pending (EV_A_ (W)w);
4912	if (expect_false (!ev_is_active (w)))	5329	if (ecb_expect_false (!ev_is_active (w)))
4913	return;	5330	return;
4914		5331
4915	EV_FREQUENT_CHECK;	5332	EV_FREQUENT_CHECK;
4916		5333
4917	{	5334	{
…		…
4929		5346
4930	#if EV_CLEANUP_ENABLE	5347	#if EV_CLEANUP_ENABLE
4931	void	5348	void
4932	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5349	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4933	{	5350	{
4934	if (expect_false (ev_is_active (w)))	5351	if (ecb_expect_false (ev_is_active (w)))
4935	return;	5352	return;
4936		5353
4937	EV_FREQUENT_CHECK;	5354	EV_FREQUENT_CHECK;
4938		5355
4939	ev_start (EV_A_ (W)w, ++cleanupcnt);	5356	ev_start (EV_A_ (W)w, ++cleanupcnt);
…		…
4947		5364
4948	void	5365	void
4949	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT	5366	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4950	{	5367	{
4951	clear_pending (EV_A_ (W)w);	5368	clear_pending (EV_A_ (W)w);
4952	if (expect_false (!ev_is_active (w)))	5369	if (ecb_expect_false (!ev_is_active (w)))
4953	return;	5370	return;
4954		5371
4955	EV_FREQUENT_CHECK;	5372	EV_FREQUENT_CHECK;
4956	ev_ref (EV_A);	5373	ev_ref (EV_A);
4957		5374
…		…
4970		5387
4971	#if EV_ASYNC_ENABLE	5388	#if EV_ASYNC_ENABLE
4972	void	5389	void
4973	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT	5390	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4974	{	5391	{
4975	if (expect_false (ev_is_active (w)))	5392	if (ecb_expect_false (ev_is_active (w)))
4976	return;	5393	return;
4977		5394
4978	w->sent = 0;	5395	w->sent = 0;
4979		5396
4980	evpipe_init (EV_A);	5397	evpipe_init (EV_A);
…		…
4990		5407
4991	void	5408	void
4992	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT	5409	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4993	{	5410	{
4994	clear_pending (EV_A_ (W)w);	5411	clear_pending (EV_A_ (W)w);
4995	if (expect_false (!ev_is_active (w)))	5412	if (ecb_expect_false (!ev_is_active (w)))
4996	return;	5413	return;
4997		5414
4998	EV_FREQUENT_CHECK;	5415	EV_FREQUENT_CHECK;
4999		5416
5000	{	5417	{

Diff Legend

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