ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.4 by root, Tue Oct 30 23:10:33 2007 UTC vs.
Revision 1.268 by root, Mon Oct 27 13:39:18 2008 UTC

		1	/*
		2	* libev event processing core, watcher management
		3	*
		4	* Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
		5	* All rights reserved.
		6	*
		7	* Redistribution and use in source and binary forms, with or without modifica-
		8	* tion, are permitted provided that the following conditions are met:
		9	*
		10	* 1. Redistributions of source code must retain the above copyright notice,
		11	* this list of conditions and the following disclaimer.
		12	*
		13	* 2. Redistributions in binary form must reproduce the above copyright
		14	* notice, this list of conditions and the following disclaimer in the
		15	* documentation and/or other materials provided with the distribution.
		16	*
		17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
		18	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
		19	* CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
		20	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
		21	* CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		22	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
		23	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
		24	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
		25	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
		26	* OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*
		28	* Alternatively, the contents of this file may be used under the terms of
		29	* the GNU General Public License ("GPL") version 2 or any later version,
		30	* in which case the provisions of the GPL are applicable instead of
		31	* the above. If you wish to allow the use of your version of this file
		32	* only under the terms of the GPL and not to allow others to use your
		33	* version of this file under the BSD license, indicate your decision
		34	* by deleting the provisions above and replace them with the notice
		35	* and other provisions required by the GPL. If you do not delete the
		36	* provisions above, a recipient may use your version of this file under
		37	* either the BSD or the GPL.
		38	*/
		39
		40	#ifdef __cplusplus
		41	extern "C" {
		42	#endif
		43
		44	/* this big block deduces configuration from config.h */
		45	#ifndef EV_STANDALONE
		46	# ifdef EV_CONFIG_H
		47	# include EV_CONFIG_H
		48	# else
		49	# include "config.h"
		50	# endif
		51
		52	# if HAVE_CLOCK_GETTIME
		53	# ifndef EV_USE_MONOTONIC
		54	# define EV_USE_MONOTONIC 1
		55	# endif
		56	# ifndef EV_USE_REALTIME
		57	# define EV_USE_REALTIME 1
		58	# endif
		59	# else
		60	# ifndef EV_USE_MONOTONIC
		61	# define EV_USE_MONOTONIC 0
		62	# endif
		63	# ifndef EV_USE_REALTIME
		64	# define EV_USE_REALTIME 0
		65	# endif
		66	# endif
		67
		68	# ifndef EV_USE_NANOSLEEP
		69	# if HAVE_NANOSLEEP
		70	# define EV_USE_NANOSLEEP 1
		71	# else
		72	# define EV_USE_NANOSLEEP 0
		73	# endif
		74	# endif
		75
		76	# ifndef EV_USE_SELECT
		77	# if HAVE_SELECT && HAVE_SYS_SELECT_H
		78	# define EV_USE_SELECT 1
		79	# else
		80	# define EV_USE_SELECT 0
		81	# endif
		82	# endif
		83
		84	# ifndef EV_USE_POLL
		85	# if HAVE_POLL && HAVE_POLL_H
		86	# define EV_USE_POLL 1
		87	# else
		88	# define EV_USE_POLL 0
		89	# endif
		90	# endif
		91
		92	# ifndef EV_USE_EPOLL
		93	# if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
		94	# define EV_USE_EPOLL 1
		95	# else
		96	# define EV_USE_EPOLL 0
		97	# endif
		98	# endif
		99
		100	# ifndef EV_USE_KQUEUE
		101	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
		102	# define EV_USE_KQUEUE 1
		103	# else
		104	# define EV_USE_KQUEUE 0
		105	# endif
		106	# endif
		107
		108	# ifndef EV_USE_PORT
		109	# if HAVE_PORT_H && HAVE_PORT_CREATE
		110	# define EV_USE_PORT 1
		111	# else
		112	# define EV_USE_PORT 0
		113	# endif
		114	# endif
		115
		116	# ifndef EV_USE_INOTIFY
		117	# if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
		118	# define EV_USE_INOTIFY 1
		119	# else
		120	# define EV_USE_INOTIFY 0
		121	# endif
		122	# endif
		123
		124	# ifndef EV_USE_EVENTFD
		125	# if HAVE_EVENTFD
		126	# define EV_USE_EVENTFD 1
		127	# else
		128	# define EV_USE_EVENTFD 0
		129	# endif
		130	# endif
		131
		132	#endif
		133
1	#include <math.h>	134	#include <math.h>
2	#include <stdlib.h>	135	#include <stdlib.h>
		136	#include <fcntl.h>
		137	#include <stddef.h>
3		138
4	#include <stdio.h>	139	#include <stdio.h>
5		140
6	#include <assert.h>	141	#include <assert.h>
7	#include <errno.h>	142	#include <errno.h>
8	#include <sys/time.h>	143	#include <sys/types.h>
9	#include <time.h>	144	#include <time.h>
10		145
		146	#include <signal.h>
		147
		148	#ifdef EV_H
		149	# include EV_H
		150	#else
		151	# include "ev.h"
		152	#endif
		153
		154	#ifndef _WIN32
		155	# include <sys/time.h>
		156	# include <sys/wait.h>
		157	# include <unistd.h>
		158	#else
		159	# include <io.h>
		160	# define WIN32_LEAN_AND_MEAN
		161	# include <windows.h>
		162	# ifndef EV_SELECT_IS_WINSOCKET
		163	# define EV_SELECT_IS_WINSOCKET 1
		164	# endif
		165	#endif
		166
		167	/* this block tries to deduce configuration from header-defined symbols and defaults */
		168
		169	#ifndef EV_USE_MONOTONIC
		170	# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
		171	# define EV_USE_MONOTONIC 1
		172	# else
		173	# define EV_USE_MONOTONIC 0
		174	# endif
		175	#endif
		176
		177	#ifndef EV_USE_REALTIME
		178	# define EV_USE_REALTIME 0
		179	#endif
		180
		181	#ifndef EV_USE_NANOSLEEP
		182	# if _POSIX_C_SOURCE >= 199309L
		183	# define EV_USE_NANOSLEEP 1
		184	# else
		185	# define EV_USE_NANOSLEEP 0
		186	# endif
		187	#endif
		188
		189	#ifndef EV_USE_SELECT
		190	# define EV_USE_SELECT 1
		191	#endif
		192
		193	#ifndef EV_USE_POLL
		194	# ifdef _WIN32
		195	# define EV_USE_POLL 0
		196	# else
		197	# define EV_USE_POLL 1
		198	# endif
		199	#endif
		200
		201	#ifndef EV_USE_EPOLL
		202	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
		203	# define EV_USE_EPOLL 1
		204	# else
		205	# define EV_USE_EPOLL 0
		206	# endif
		207	#endif
		208
		209	#ifndef EV_USE_KQUEUE
		210	# define EV_USE_KQUEUE 0
		211	#endif
		212
		213	#ifndef EV_USE_PORT
		214	# define EV_USE_PORT 0
		215	#endif
		216
		217	#ifndef EV_USE_INOTIFY
		218	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
		219	# define EV_USE_INOTIFY 1
		220	# else
		221	# define EV_USE_INOTIFY 0
		222	# endif
		223	#endif
		224
		225	#ifndef EV_PID_HASHSIZE
		226	# if EV_MINIMAL
		227	# define EV_PID_HASHSIZE 1
		228	# else
		229	# define EV_PID_HASHSIZE 16
		230	# endif
		231	#endif
		232
		233	#ifndef EV_INOTIFY_HASHSIZE
		234	# if EV_MINIMAL
		235	# define EV_INOTIFY_HASHSIZE 1
		236	# else
		237	# define EV_INOTIFY_HASHSIZE 16
		238	# endif
		239	#endif
		240
		241	#ifndef EV_USE_EVENTFD
		242	# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
		243	# define EV_USE_EVENTFD 1
		244	# else
		245	# define EV_USE_EVENTFD 0
		246	# endif
		247	#endif
		248
		249	#if 0 /* debugging */
		250	# define EV_VERIFY 3
		251	# define EV_USE_4HEAP 1
		252	# define EV_HEAP_CACHE_AT 1
		253	#endif
		254
		255	#ifndef EV_VERIFY
		256	# define EV_VERIFY !EV_MINIMAL
		257	#endif
		258
		259	#ifndef EV_USE_4HEAP
		260	# define EV_USE_4HEAP !EV_MINIMAL
		261	#endif
		262
		263	#ifndef EV_HEAP_CACHE_AT
		264	# define EV_HEAP_CACHE_AT !EV_MINIMAL
		265	#endif
		266
		267	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
		268
11	#ifdef CLOCK_MONOTONIC	269	#ifndef CLOCK_MONOTONIC
		270	# undef EV_USE_MONOTONIC
12	# define HAVE_MONOTONIC 1	271	# define EV_USE_MONOTONIC 0
		272	#endif
		273
		274	#ifndef CLOCK_REALTIME
		275	# undef EV_USE_REALTIME
		276	# define EV_USE_REALTIME 0
		277	#endif
		278
		279	#if !EV_STAT_ENABLE
		280	# undef EV_USE_INOTIFY
		281	# define EV_USE_INOTIFY 0
		282	#endif
		283
		284	#if !EV_USE_NANOSLEEP
		285	# ifndef _WIN32
		286	# include <sys/select.h>
13	#endif	287	# endif
		288	#endif
14		289
15	#define HAVE_EPOLL 1	290	#if EV_USE_INOTIFY
16	#define HAVE_REALTIME 1	291	# include <sys/utsname.h>
17	#define HAVE_SELECT 0	292	# include <sys/inotify.h>
		293	/* some very old inotify.h headers don't have IN_DONT_FOLLOW */
		294	# ifndef IN_DONT_FOLLOW
		295	# undef EV_USE_INOTIFY
		296	# define EV_USE_INOTIFY 0
		297	# endif
		298	#endif
		299
		300	#if EV_SELECT_IS_WINSOCKET
		301	# include <winsock.h>
		302	#endif
		303
		304	#if EV_USE_EVENTFD
		305	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
		306	# include <stdint.h>
		307	# ifdef __cplusplus
		308	extern "C" {
		309	# endif
		310	int eventfd (unsigned int initval, int flags);
		311	# ifdef __cplusplus
		312	}
		313	# endif
		314	#endif
		315
		316	/**/
		317
		318	#if EV_VERIFY >= 3
		319	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
		320	#else
		321	# define EV_FREQUENT_CHECK do { } while (0)
		322	#endif
		323
		324	/*
		325	* This is used to avoid floating point rounding problems.
		326	* It is added to ev_rt_now when scheduling periodics
		327	* to ensure progress, time-wise, even when rounding
		328	* errors are against us.
		329	* This value is good at least till the year 4000.
		330	* Better solutions welcome.
		331	*/
		332	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */
18		333
19	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	334	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
20	#define MAX_BLOCKTIME 60.	335	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
		336	/*#define CLEANUP_INTERVAL (MAX_BLOCKTIME * 5.) /* how often to try to free memory and re-check fds, TODO */
21		337
		338	#if __GNUC__ >= 4
		339	# define expect(expr,value) __builtin_expect ((expr),(value))
		340	# define noinline __attribute__ ((noinline))
		341	#else
		342	# define expect(expr,value) (expr)
		343	# define noinline
		344	# if __STDC_VERSION__ < 199901L && __GNUC__ < 2
		345	# define inline
		346	# endif
		347	#endif
		348
		349	#define expect_false(expr) expect ((expr) != 0, 0)
		350	#define expect_true(expr) expect ((expr) != 0, 1)
		351	#define inline_size static inline
		352
		353	#if EV_MINIMAL
		354	# define inline_speed static noinline
		355	#else
		356	# define inline_speed static inline
		357	#endif
		358
		359	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
		360	#define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
		361
		362	#define EMPTY /* required for microsofts broken pseudo-c compiler */
		363	#define EMPTY2(a,b) /* used to suppress some warnings */
		364
		365	typedef ev_watcher *W;
		366	typedef ev_watcher_list *WL;
		367	typedef ev_watcher_time *WT;
		368
		369	#define ev_active(w) ((W)(w))->active
		370	#define ev_at(w) ((WT)(w))->at
		371
		372	#if EV_USE_MONOTONIC
		373	/* sig_atomic_t is used to avoid per-thread variables or locking but still */
		374	/* giving it a reasonably high chance of working on typical architetcures */
		375	static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
		376	#endif
		377
		378	#ifdef _WIN32
		379	# include "ev_win32.c"
		380	#endif
		381
		382	/*****************************************************************************/
		383
		384	static void (*syserr_cb)(const char *msg);
		385
		386	void
		387	ev_set_syserr_cb (void (*cb)(const char *msg))
		388	{
		389	syserr_cb = cb;
		390	}
		391
		392	static void noinline
		393	syserr (const char *msg)
		394	{
		395	if (!msg)
		396	msg = "(libev) system error";
		397
		398	if (syserr_cb)
		399	syserr_cb (msg);
		400	else
		401	{
		402	perror (msg);
		403	abort ();
		404	}
		405	}
		406
		407	static void *
		408	ev_realloc_emul (void *ptr, long size)
		409	{
		410	/* some systems, notably openbsd and darwin, fail to properly
		411	* implement realloc (x, 0) (as required by both ansi c-98 and
		412	* the single unix specification, so work around them here.
		413	*/
		414
		415	if (size)
		416	return realloc (ptr, size);
		417
		418	free (ptr);
		419	return 0;
		420	}
		421
		422	static void *(*alloc)(void *ptr, long size) = ev_realloc_emul;
		423
		424	void
		425	ev_set_allocator (void *(*cb)(void *ptr, long size))
		426	{
		427	alloc = cb;
		428	}
		429
		430	inline_speed void *
		431	ev_realloc (void *ptr, long size)
		432	{
		433	ptr = alloc (ptr, size);
		434
		435	if (!ptr && size)
		436	{
		437	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
		438	abort ();
		439	}
		440
		441	return ptr;
		442	}
		443
		444	#define ev_malloc(size) ev_realloc (0, (size))
		445	#define ev_free(ptr) ev_realloc ((ptr), 0)
		446
		447	/*****************************************************************************/
		448
		449	typedef struct
		450	{
		451	WL head;
		452	unsigned char events;
		453	unsigned char reify;
		454	unsigned char emask; /* the epoll backend stores the actual kernel mask in here */
		455	unsigned char egen; /* generation counter to counter epoll bugs */
		456	#if EV_SELECT_IS_WINSOCKET
		457	SOCKET handle;
		458	#endif
		459	} ANFD;
		460
		461	typedef struct
		462	{
		463	W w;
		464	int events;
		465	} ANPENDING;
		466
		467	#if EV_USE_INOTIFY
		468	/* hash table entry per inotify-id */
		469	typedef struct
		470	{
		471	WL head;
		472	} ANFS;
		473	#endif
		474
		475	/* Heap Entry */
		476	#if EV_HEAP_CACHE_AT
		477	typedef struct {
		478	ev_tstamp at;
		479	WT w;
		480	} ANHE;
		481
		482	#define ANHE_w(he) (he).w /* access watcher, read-write */
		483	#define ANHE_at(he) (he).at /* access cached at, read-only */
		484	#define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
		485	#else
		486	typedef WT ANHE;
		487
		488	#define ANHE_w(he) (he)
		489	#define ANHE_at(he) (he)->at
		490	#define ANHE_at_cache(he)
		491	#endif
		492
		493	#if EV_MULTIPLICITY
		494
		495	struct ev_loop
		496	{
		497	ev_tstamp ev_rt_now;
		498	#define ev_rt_now ((loop)->ev_rt_now)
		499	#define VAR(name,decl) decl;
		500	#include "ev_vars.h"
		501	#undef VAR
		502	};
22	#include "ev.h"	503	#include "ev_wrap.h"
23		504
24	struct ev_watcher {	505	static struct ev_loop default_loop_struct;
25	EV_WATCHER (ev_watcher);	506	struct ev_loop *ev_default_loop_ptr;
26	};
27		507
28	struct ev_watcher_list {	508	#else
29	EV_WATCHER_LIST (ev_watcher_list);
30	};
31		509
32	static ev_tstamp now, diff; /* monotonic clock */
33	ev_tstamp ev_now;	510	ev_tstamp ev_rt_now;
34	int ev_method;	511	#define VAR(name,decl) static decl;
		512	#include "ev_vars.h"
		513	#undef VAR
35		514
36	static int have_monotonic; /* runtime */	515	static int ev_default_loop_ptr;
37		516
38	static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */	517	#endif
39	static void (*method_reify)(void);	518
40	static void (*method_poll)(ev_tstamp timeout);	519	/*****************************************************************************/
41		520
42	ev_tstamp	521	ev_tstamp
43	ev_time (void)	522	ev_time (void)
44	{	523	{
45	#if HAVE_REALTIME	524	#if EV_USE_REALTIME
46	struct timespec ts;	525	struct timespec ts;
47	clock_gettime (CLOCK_REALTIME, &ts);	526	clock_gettime (CLOCK_REALTIME, &ts);
48	return ts.tv_sec + ts.tv_nsec * 1e-9;	527	return ts.tv_sec + ts.tv_nsec * 1e-9;
49	#else	528	#else
50	struct timeval tv;	529	struct timeval tv;
51	gettimeofday (&tv, 0);	530	gettimeofday (&tv, 0);
52	return tv.tv_sec + tv.tv_usec * 1e-6;	531	return tv.tv_sec + tv.tv_usec * 1e-6;
53	#endif	532	#endif
54	}	533	}
55		534
56	static ev_tstamp	535	ev_tstamp inline_size
57	get_clock (void)	536	get_clock (void)
58	{	537	{
59	#if HAVE_MONOTONIC	538	#if EV_USE_MONOTONIC
60	if (have_monotonic)	539	if (expect_true (have_monotonic))
61	{	540	{
62	struct timespec ts;	541	struct timespec ts;
63	clock_gettime (CLOCK_MONOTONIC, &ts);	542	clock_gettime (CLOCK_MONOTONIC, &ts);
64	return ts.tv_sec + ts.tv_nsec * 1e-9;	543	return ts.tv_sec + ts.tv_nsec * 1e-9;
65	}	544	}
66	#endif	545	#endif
67		546
68	return ev_time ();	547	return ev_time ();
69	}	548	}
70		549
		550	#if EV_MULTIPLICITY
		551	ev_tstamp
		552	ev_now (EV_P)
		553	{
		554	return ev_rt_now;
		555	}
		556	#endif
		557
		558	void
		559	ev_sleep (ev_tstamp delay)
		560	{
		561	if (delay > 0.)
		562	{
		563	#if EV_USE_NANOSLEEP
		564	struct timespec ts;
		565
		566	ts.tv_sec = (time_t)delay;
		567	ts.tv_nsec = (long)((delay - (ev_tstamp)(ts.tv_sec)) * 1e9);
		568
		569	nanosleep (&ts, 0);
		570	#elif defined(_WIN32)
		571	Sleep ((unsigned long)(delay * 1e3));
		572	#else
		573	struct timeval tv;
		574
		575	tv.tv_sec = (time_t)delay;
		576	tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);
		577
		578	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
		579	/* somehting nto guaranteed by newer posix versions, but guaranteed */
		580	/* by older ones */
		581	select (0, 0, 0, 0, &tv);
		582	#endif
		583	}
		584	}
		585
		586	/*****************************************************************************/
		587
		588	#define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
		589
		590	int inline_size
		591	array_nextsize (int elem, int cur, int cnt)
		592	{
		593	int ncur = cur + 1;
		594
		595	do
		596	ncur <<= 1;
		597	while (cnt > ncur);
		598
		599	/* if size is large, round to MALLOC_ROUND - 4 * longs to accomodate malloc overhead */
		600	if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
		601	{
		602	ncur *= elem;
		603	ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
		604	ncur = ncur - sizeof (void *) * 4;
		605	ncur /= elem;
		606	}
		607
		608	return ncur;
		609	}
		610
		611	static noinline void *
		612	array_realloc (int elem, void *base, int *cur, int cnt)
		613	{
		614	*cur = array_nextsize (elem, *cur, cnt);
		615	return ev_realloc (base, elem * *cur);
		616	}
		617
		618	#define array_init_zero(base,count) \
		619	memset ((void *)(base), 0, sizeof (*(base)) * (count))
		620
71	#define array_needsize(base,cur,cnt,init) \	621	#define array_needsize(type,base,cur,cnt,init) \
72	if ((cnt) > cur) \	622	if (expect_false ((cnt) > (cur))) \
73	{ \	623	{ \
74	int newcnt = cur ? cur << 1 : 16; \	624	int ocur_ = (cur); \
75	fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\	625	(base) = (type *)array_realloc \
76	base = realloc (base, sizeof (*base) * (newcnt)); \	626	(sizeof (type), (base), &(cur), (cnt)); \
77	init (base + cur, newcnt - cur); \	627	init ((base) + (ocur_), (cur) - ocur_); \
78	cur = newcnt; \	628	}
		629
		630	#if 0
		631	#define array_slim(type,stem) \
		632	if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
		633	{ \
		634	stem ## max = array_roundsize (stem ## cnt >> 1); \
		635	base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
		636	fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
		637	}
		638	#endif
		639
		640	#define array_free(stem, idx) \
		641	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
		642
		643	/*****************************************************************************/
		644
		645	void noinline
		646	ev_feed_event (EV_P_ void *w, int revents)
		647	{
		648	W w_ = (W)w;
		649	int pri = ABSPRI (w_);
		650
		651	if (expect_false (w_->pending))
		652	pendings [pri][w_->pending - 1].events |= revents;
		653	else
		654	{
		655	w_->pending = ++pendingcnt [pri];
		656	array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
		657	pendings [pri][w_->pending - 1].w = w_;
		658	pendings [pri][w_->pending - 1].events = revents;
		659	}
		660	}
		661
		662	void inline_speed
		663	queue_events (EV_P_ W *events, int eventcnt, int type)
		664	{
		665	int i;
		666
		667	for (i = 0; i < eventcnt; ++i)
		668	ev_feed_event (EV_A_ events [i], type);
		669	}
		670
		671	/*****************************************************************************/
		672
		673	void inline_speed
		674	fd_event (EV_P_ int fd, int revents)
		675	{
		676	ANFD *anfd = anfds + fd;
		677	ev_io *w;
		678
		679	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
		680	{
		681	int ev = w->events & revents;
		682
		683	if (ev)
		684	ev_feed_event (EV_A_ (W)w, ev);
		685	}
		686	}
		687
		688	void
		689	ev_feed_fd_event (EV_P_ int fd, int revents)
		690	{
		691	if (fd >= 0 && fd < anfdmax)
		692	fd_event (EV_A_ fd, revents);
		693	}
		694
		695	void inline_size
		696	fd_reify (EV_P)
		697	{
		698	int i;
		699
		700	for (i = 0; i < fdchangecnt; ++i)
		701	{
		702	int fd = fdchanges [i];
		703	ANFD *anfd = anfds + fd;
		704	ev_io *w;
		705
		706	unsigned char events = 0;
		707
		708	for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
		709	events |= (unsigned char)w->events;
		710
		711	#if EV_SELECT_IS_WINSOCKET
		712	if (events)
		713	{
		714	unsigned long arg;
		715	#ifdef EV_FD_TO_WIN32_HANDLE
		716	anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
		717	#else
		718	anfd->handle = _get_osfhandle (fd);
		719	#endif
		720	assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
		721	}
		722	#endif
		723
		724	{
		725	unsigned char o_events = anfd->events;
		726	unsigned char o_reify = anfd->reify;
		727
		728	anfd->reify = 0;
		729	anfd->events = events;
		730
		731	if (o_events != events || o_reify & EV_IOFDSET)
		732	backend_modify (EV_A_ fd, o_events, events);
79	}	733	}
		734	}
		735
		736	fdchangecnt = 0;
		737	}
		738
		739	void inline_size
		740	fd_change (EV_P_ int fd, int flags)
		741	{
		742	unsigned char reify = anfds [fd].reify;
		743	anfds [fd].reify |= flags;
		744
		745	if (expect_true (!reify))
		746	{
		747	++fdchangecnt;
		748	array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
		749	fdchanges [fdchangecnt - 1] = fd;
		750	}
		751	}
		752
		753	void inline_speed
		754	fd_kill (EV_P_ int fd)
		755	{
		756	ev_io *w;
		757
		758	while ((w = (ev_io *)anfds [fd].head))
		759	{
		760	ev_io_stop (EV_A_ w);
		761	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
		762	}
		763	}
		764
		765	int inline_size
		766	fd_valid (int fd)
		767	{
		768	#ifdef _WIN32
		769	return _get_osfhandle (fd) != -1;
		770	#else
		771	return fcntl (fd, F_GETFD) != -1;
		772	#endif
		773	}
		774
		775	/* called on EBADF to verify fds */
		776	static void noinline
		777	fd_ebadf (EV_P)
		778	{
		779	int fd;
		780
		781	for (fd = 0; fd < anfdmax; ++fd)
		782	if (anfds [fd].events)
		783	if (!fd_valid (fd) && errno == EBADF)
		784	fd_kill (EV_A_ fd);
		785	}
		786
		787	/* called on ENOMEM in select/poll to kill some fds and retry */
		788	static void noinline
		789	fd_enomem (EV_P)
		790	{
		791	int fd;
		792
		793	for (fd = anfdmax; fd--; )
		794	if (anfds [fd].events)
		795	{
		796	fd_kill (EV_A_ fd);
		797	return;
		798	}
		799	}
		800
		801	/* usually called after fork if backend needs to re-arm all fds from scratch */
		802	static void noinline
		803	fd_rearm_all (EV_P)
		804	{
		805	int fd;
		806
		807	for (fd = 0; fd < anfdmax; ++fd)
		808	if (anfds [fd].events)
		809	{
		810	anfds [fd].events = 0;
		811	anfds [fd].emask = 0;
		812	fd_change (EV_A_ fd, EV_IOFDSET | 1);
		813	}
		814	}
		815
		816	/*****************************************************************************/
		817
		818	/*
		819	* the heap functions want a real array index. array index 0 uis guaranteed to not
		820	* be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
		821	* the branching factor of the d-tree.
		822	*/
		823
		824	/*
		825	* at the moment we allow libev the luxury of two heaps,
		826	* a small-code-size 2-heap one and a ~1.5kb larger 4-heap
		827	* which is more cache-efficient.
		828	* the difference is about 5% with 50000+ watchers.
		829	*/
		830	#if EV_USE_4HEAP
		831
		832	#define DHEAP 4
		833	#define HEAP0 (DHEAP - 1) /* index of first element in heap */
		834	#define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
		835	#define UPHEAP_DONE(p,k) ((p) == (k))
		836
		837	/* away from the root */
		838	void inline_speed
		839	downheap (ANHE *heap, int N, int k)
		840	{
		841	ANHE he = heap [k];
		842	ANHE *E = heap + N + HEAP0;
		843
		844	for (;;)
		845	{
		846	ev_tstamp minat;
		847	ANHE *minpos;
		848	ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
		849
		850	/* find minimum child */
		851	if (expect_true (pos + DHEAP - 1 < E))
		852	{
		853	/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
		854	if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
		855	if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
		856	if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
		857	}
		858	else if (pos < E)
		859	{
		860	/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
		861	if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
		862	if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
		863	if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
		864	}
		865	else
		866	break;
		867
		868	if (ANHE_at (he) <= minat)
		869	break;
		870
		871	heap [k] = *minpos;
		872	ev_active (ANHE_w (*minpos)) = k;
		873
		874	k = minpos - heap;
		875	}
		876
		877	heap [k] = he;
		878	ev_active (ANHE_w (he)) = k;
		879	}
		880
		881	#else /* 4HEAP */
		882
		883	#define HEAP0 1
		884	#define HPARENT(k) ((k) >> 1)
		885	#define UPHEAP_DONE(p,k) (!(p))
		886
		887	/* away from the root */
		888	void inline_speed
		889	downheap (ANHE *heap, int N, int k)
		890	{
		891	ANHE he = heap [k];
		892
		893	for (;;)
		894	{
		895	int c = k << 1;
		896
		897	if (c > N + HEAP0 - 1)
		898	break;
		899
		900	c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
		901	? 1 : 0;
		902
		903	if (ANHE_at (he) <= ANHE_at (heap [c]))
		904	break;
		905
		906	heap [k] = heap [c];
		907	ev_active (ANHE_w (heap [k])) = k;
		908
		909	k = c;
		910	}
		911
		912	heap [k] = he;
		913	ev_active (ANHE_w (he)) = k;
		914	}
		915	#endif
		916
		917	/* towards the root */
		918	void inline_speed
		919	upheap (ANHE *heap, int k)
		920	{
		921	ANHE he = heap [k];
		922
		923	for (;;)
		924	{
		925	int p = HPARENT (k);
		926
		927	if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
		928	break;
		929
		930	heap [k] = heap [p];
		931	ev_active (ANHE_w (heap [k])) = k;
		932	k = p;
		933	}
		934
		935	heap [k] = he;
		936	ev_active (ANHE_w (he)) = k;
		937	}
		938
		939	void inline_size
		940	adjustheap (ANHE *heap, int N, int k)
		941	{
		942	if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k]))
		943	upheap (heap, k);
		944	else
		945	downheap (heap, N, k);
		946	}
		947
		948	/* rebuild the heap: this function is used only once and executed rarely */
		949	void inline_size
		950	reheap (ANHE *heap, int N)
		951	{
		952	int i;
		953
		954	/* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
		955	/* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
		956	for (i = 0; i < N; ++i)
		957	upheap (heap, i + HEAP0);
		958	}
		959
		960	/*****************************************************************************/
80		961
81	typedef struct	962	typedef struct
82	{	963	{
83	struct ev_io *head;	964	WL head;
84	unsigned char wev, rev; /* want, received event set */	965	EV_ATOMIC_T gotsig;
85	} ANFD;	966	} ANSIG;
86		967
87	static ANFD *anfds;	968	static ANSIG *signals;
88	static int anfdmax;	969	static int signalmax;
89		970
90	static int *fdchanges;	971	static EV_ATOMIC_T gotsig;
91	static int fdchangemax, fdchangecnt;	972
		973	/*****************************************************************************/
		974
		975	void inline_speed
		976	fd_intern (int fd)
		977	{
		978	#ifdef _WIN32
		979	unsigned long arg = 1;
		980	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
		981	#else
		982	fcntl (fd, F_SETFD, FD_CLOEXEC);
		983	fcntl (fd, F_SETFL, O_NONBLOCK);
		984	#endif
		985	}
		986
		987	static void noinline
		988	evpipe_init (EV_P)
		989	{
		990	if (!ev_is_active (&pipeev))
		991	{
		992	#if EV_USE_EVENTFD
		993	if ((evfd = eventfd (0, 0)) >= 0)
		994	{
		995	evpipe [0] = -1;
		996	fd_intern (evfd);
		997	ev_io_set (&pipeev, evfd, EV_READ);
		998	}
		999	else
		1000	#endif
		1001	{
		1002	while (pipe (evpipe))
		1003	syserr ("(libev) error creating signal/async pipe");
		1004
		1005	fd_intern (evpipe [0]);
		1006	fd_intern (evpipe [1]);
		1007	ev_io_set (&pipeev, evpipe [0], EV_READ);
		1008	}
		1009
		1010	ev_io_start (EV_A_ &pipeev);
		1011	ev_unref (EV_A); /* watcher should not keep loop alive */
		1012	}
		1013	}
		1014
		1015	void inline_size
		1016	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
		1017	{
		1018	if (!*flag)
		1019	{
		1020	int old_errno = errno; /* save errno because write might clobber it */
		1021
		1022	*flag = 1;
		1023
		1024	#if EV_USE_EVENTFD
		1025	if (evfd >= 0)
		1026	{
		1027	uint64_t counter = 1;
		1028	write (evfd, &counter, sizeof (uint64_t));
		1029	}
		1030	else
		1031	#endif
		1032	write (evpipe [1], &old_errno, 1);
		1033
		1034	errno = old_errno;
		1035	}
		1036	}
92		1037
93	static void	1038	static void
94	anfds_init (ANFD *base, int count)	1039	pipecb (EV_P_ ev_io *iow, int revents)
95	{	1040	{
96	while (count--)	1041	#if EV_USE_EVENTFD
97	{	1042	if (evfd >= 0)
98	base->head = 0;
99	base->wev = base->rev = EV_NONE;
100	++base;
101	}	1043	{
102	}	1044	uint64_t counter;
		1045	read (evfd, &counter, sizeof (uint64_t));
		1046	}
		1047	else
		1048	#endif
		1049	{
		1050	char dummy;
		1051	read (evpipe [0], &dummy, 1);
		1052	}
103		1053
104	typedef struct	1054	if (gotsig && ev_is_default_loop (EV_A))
105	{	1055	{
106	struct ev_watcher *w;	1056	int signum;
107	int events;	1057	gotsig = 0;
108	} ANPENDING;
109		1058
110	static ANPENDING *pendings;	1059	for (signum = signalmax; signum--; )
111	static int pendingmax, pendingcnt;	1060	if (signals [signum].gotsig)
		1061	ev_feed_signal_event (EV_A_ signum + 1);
		1062	}
		1063
		1064	#if EV_ASYNC_ENABLE
		1065	if (gotasync)
		1066	{
		1067	int i;
		1068	gotasync = 0;
		1069
		1070	for (i = asynccnt; i--; )
		1071	if (asyncs [i]->sent)
		1072	{
		1073	asyncs [i]->sent = 0;
		1074	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
		1075	}
		1076	}
		1077	#endif
		1078	}
		1079
		1080	/*****************************************************************************/
112		1081
113	static void	1082	static void
114	event (struct ev_watcher *w, int events)	1083	ev_sighandler (int signum)
115	{	1084	{
116	w->pending = ++pendingcnt;	1085	#if EV_MULTIPLICITY
117	array_needsize (pendings, pendingmax, pendingcnt, );	1086	struct ev_loop *loop = &default_loop_struct;
118	pendings [pendingcnt - 1].w = w;	1087	#endif
119	pendings [pendingcnt - 1].events = events;	1088
		1089	#if _WIN32
		1090	signal (signum, ev_sighandler);
		1091	#endif
		1092
		1093	signals [signum - 1].gotsig = 1;
		1094	evpipe_write (EV_A_ &gotsig);
120	}	1095	}
		1096
		1097	void noinline
		1098	ev_feed_signal_event (EV_P_ int signum)
		1099	{
		1100	WL w;
		1101
		1102	#if EV_MULTIPLICITY
		1103	assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
		1104	#endif
		1105
		1106	--signum;
		1107
		1108	if (signum < 0 || signum >= signalmax)
		1109	return;
		1110
		1111	signals [signum].gotsig = 0;
		1112
		1113	for (w = signals [signum].head; w; w = w->next)
		1114	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
		1115	}
		1116
		1117	/*****************************************************************************/
		1118
		1119	static WL childs [EV_PID_HASHSIZE];
		1120
		1121	#ifndef _WIN32
		1122
		1123	static ev_signal childev;
		1124
		1125	#ifndef WIFCONTINUED
		1126	# define WIFCONTINUED(status) 0
		1127	#endif
		1128
		1129	void inline_speed
		1130	child_reap (EV_P_ int chain, int pid, int status)
		1131	{
		1132	ev_child *w;
		1133	int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
		1134
		1135	for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
		1136	{
		1137	if ((w->pid == pid || !w->pid)
		1138	&& (!traced || (w->flags & 1)))
		1139	{
		1140	ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
		1141	w->rpid = pid;
		1142	w->rstatus = status;
		1143	ev_feed_event (EV_A_ (W)w, EV_CHILD);
		1144	}
		1145	}
		1146	}
		1147
		1148	#ifndef WCONTINUED
		1149	# define WCONTINUED 0
		1150	#endif
121		1151
122	static void	1152	static void
123	fd_event (int fd, int events)	1153	childcb (EV_P_ ev_signal *sw, int revents)
124	{	1154	{
125	ANFD *anfd = anfds + fd;	1155	int pid, status;
126	struct ev_io *w;
127		1156
128	for (w = anfd->head; w; w = w->next)	1157	/* some systems define WCONTINUED but then fail to support it (linux 2.4) */
129	{	1158	if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
130	int ev = w->events & events;	1159	if (!WCONTINUED
		1160	|| errno != EINVAL
		1161	|| 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
		1162	return;
131		1163
132	if (ev)	1164	/* make sure we are called again until all children have been reaped */
133	event ((struct ev_watcher *)w, ev);	1165	/* we need to do it this way so that the callback gets called before we continue */
134	}	1166	ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
135	}
136		1167
137	static struct ev_timer **atimers;	1168	child_reap (EV_A_ pid, pid, status);
138	static int atimermax, atimercnt;	1169	if (EV_PID_HASHSIZE > 1)
139		1170	child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
140	static struct ev_timer **rtimers;
141	static int rtimermax, rtimercnt;
142
143	static void
144	upheap (struct ev_timer **timers, int k)
145	{
146	struct ev_timer *w = timers [k];
147
148	while (k && timers [k >> 1]->at > w->at)
149	{
150	timers [k] = timers [k >> 1];
151	timers [k]->active = k + 1;
152	k >>= 1;
153	}
154
155	timers [k] = w;
156	timers [k]->active = k + 1;
157
158	}	1171	}
159		1172
160	static void	1173	#endif
161	downheap (struct ev_timer **timers, int N, int k)
162	{
163	struct ev_timer *w = timers [k];
164		1174
165	while (k < (N >> 1))	1175	/*****************************************************************************/
166	{
167	int j = k << 1;
168		1176
169	if (j + 1 < N && timers [j]->at > timers [j + 1]->at)	1177	#if EV_USE_PORT
170	++j;	1178	# include "ev_port.c"
171		1179	#endif
172	if (w->at <= timers [j]->at)	1180	#if EV_USE_KQUEUE
173	break;	1181	# include "ev_kqueue.c"
174		1182	#endif
175	timers [k] = timers [j];
176	timers [k]->active = k + 1;
177	k = j;
178	}
179
180	timers [k] = w;
181	timers [k]->active = k + 1;
182	}
183
184	static struct ev_signal **signals;
185	static int signalmax;
186
187	static void
188	signals_init (struct ev_signal **base, int count)
189	{
190	while (count--)
191	*base++ = 0;
192	}
193
194	#if HAVE_EPOLL	1183	#if EV_USE_EPOLL
195	# include "ev_epoll.c"	1184	# include "ev_epoll.c"
196	#endif	1185	#endif
		1186	#if EV_USE_POLL
		1187	# include "ev_poll.c"
		1188	#endif
197	#if HAVE_SELECT	1189	#if EV_USE_SELECT
198	# include "ev_select.c"	1190	# include "ev_select.c"
199	#endif	1191	#endif
200		1192
201	int ev_init (int flags)	1193	int
		1194	ev_version_major (void)
202	{	1195	{
		1196	return EV_VERSION_MAJOR;
		1197	}
		1198
		1199	int
		1200	ev_version_minor (void)
		1201	{
		1202	return EV_VERSION_MINOR;
		1203	}
		1204
		1205	/* return true if we are running with elevated privileges and should ignore env variables */
		1206	int inline_size
		1207	enable_secure (void)
		1208	{
		1209	#ifdef _WIN32
		1210	return 0;
		1211	#else
		1212	return getuid () != geteuid ()
		1213	|| getgid () != getegid ();
		1214	#endif
		1215	}
		1216
		1217	unsigned int
		1218	ev_supported_backends (void)
		1219	{
		1220	unsigned int flags = 0;
		1221
		1222	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
		1223	if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
		1224	if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
		1225	if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
		1226	if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
		1227
		1228	return flags;
		1229	}
		1230
		1231	unsigned int
		1232	ev_recommended_backends (void)
		1233	{
		1234	unsigned int flags = ev_supported_backends ();
		1235
		1236	#ifndef __NetBSD__
		1237	/* kqueue is borked on everything but netbsd apparently */
		1238	/* it usually doesn't work correctly on anything but sockets and pipes */
		1239	flags &= ~EVBACKEND_KQUEUE;
		1240	#endif
		1241	#ifdef __APPLE__
		1242	// flags &= ~EVBACKEND_KQUEUE; for documentation
		1243	flags &= ~EVBACKEND_POLL;
		1244	#endif
		1245
		1246	return flags;
		1247	}
		1248
		1249	unsigned int
		1250	ev_embeddable_backends (void)
		1251	{
		1252	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
		1253
		1254	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
		1255	/* please fix it and tell me how to detect the fix */
		1256	flags &= ~EVBACKEND_EPOLL;
		1257
		1258	return flags;
		1259	}
		1260
		1261	unsigned int
		1262	ev_backend (EV_P)
		1263	{
		1264	return backend;
		1265	}
		1266
		1267	unsigned int
		1268	ev_loop_count (EV_P)
		1269	{
		1270	return loop_count;
		1271	}
		1272
		1273	void
		1274	ev_set_io_collect_interval (EV_P_ ev_tstamp interval)
		1275	{
		1276	io_blocktime = interval;
		1277	}
		1278
		1279	void
		1280	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval)
		1281	{
		1282	timeout_blocktime = interval;
		1283	}
		1284
		1285	static void noinline
		1286	loop_init (EV_P_ unsigned int flags)
		1287	{
		1288	if (!backend)
		1289	{
203	#if HAVE_MONOTONIC	1290	#if EV_USE_MONOTONIC
204	{	1291	{
205	struct timespec ts;	1292	struct timespec ts;
206	if (!clock_gettime (CLOCK_MONOTONIC, &ts))	1293	if (!clock_gettime (CLOCK_MONOTONIC, &ts))
207	have_monotonic = 1;	1294	have_monotonic = 1;
208	}	1295	}
209	#endif	1296	#endif
210		1297
211	ev_now = ev_time ();	1298	ev_rt_now = ev_time ();
212	now = get_clock ();	1299	mn_now = get_clock ();
213	diff = ev_now - now;	1300	now_floor = mn_now;
		1301	rtmn_diff = ev_rt_now - mn_now;
214		1302
		1303	io_blocktime = 0.;
		1304	timeout_blocktime = 0.;
		1305	backend = 0;
		1306	backend_fd = -1;
		1307	gotasync = 0;
		1308	#if EV_USE_INOTIFY
		1309	fs_fd = -2;
		1310	#endif
		1311
		1312	/* pid check not overridable via env */
		1313	#ifndef _WIN32
		1314	if (flags & EVFLAG_FORKCHECK)
		1315	curpid = getpid ();
		1316	#endif
		1317
		1318	if (!(flags & EVFLAG_NOENV)
		1319	&& !enable_secure ()
		1320	&& getenv ("LIBEV_FLAGS"))
		1321	flags = atoi (getenv ("LIBEV_FLAGS"));
		1322
		1323	if (!(flags & 0x0000ffffU))
		1324	flags |= ev_recommended_backends ();
		1325
		1326	#if EV_USE_PORT
		1327	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
		1328	#endif
		1329	#if EV_USE_KQUEUE
		1330	if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
		1331	#endif
215	#if HAVE_EPOLL	1332	#if EV_USE_EPOLL
216	if (epoll_init (flags))	1333	if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
217	return ev_method;
218	#endif	1334	#endif
		1335	#if EV_USE_POLL
		1336	if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
		1337	#endif
219	#if HAVE_SELECT	1338	#if EV_USE_SELECT
220	if (select_init (flags))	1339	if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
221	return ev_method;
222	#endif	1340	#endif
223		1341
224	ev_method = EVMETHOD_NONE;	1342	ev_init (&pipeev, pipecb);
225	return ev_method;	1343	ev_set_priority (&pipeev, EV_MAXPRI);
		1344	}
226	}	1345	}
227		1346
228	void ev_prefork (void)	1347	static void noinline
229	{	1348	loop_destroy (EV_P)
230	}
231
232	void ev_postfork_parent (void)
233	{
234	}
235
236	void ev_postfork_child (void)
237	{
238	#if HAVE_EPOLL
239	epoll_postfork_child ();
240	#endif
241	}
242
243	static void
244	call_pending ()
245	{	1349	{
246	int i;	1350	int i;
247		1351
248	for (i = 0; i < pendingcnt; ++i)	1352	if (ev_is_active (&pipeev))
249	{	1353	{
250	ANPENDING *p = pendings + i;	1354	ev_ref (EV_A); /* signal watcher */
		1355	ev_io_stop (EV_A_ &pipeev);
251		1356
252	if (p->w)	1357	#if EV_USE_EVENTFD
		1358	if (evfd >= 0)
		1359	close (evfd);
		1360	#endif
		1361
		1362	if (evpipe [0] >= 0)
253	{	1363	{
254	p->w->pending = 0;	1364	close (evpipe [0]);
255	p->w->cb (p->w, p->events);	1365	close (evpipe [1]);
256	}	1366	}
257	}	1367	}
258		1368
259	pendingcnt = 0;	1369	#if EV_USE_INOTIFY
260	}	1370	if (fs_fd >= 0)
		1371	close (fs_fd);
		1372	#endif
261		1373
262	static void	1374	if (backend_fd >= 0)
263	timers_reify (struct ev_timer **timers, int timercnt, ev_tstamp now)	1375	close (backend_fd);
		1376
		1377	#if EV_USE_PORT
		1378	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
		1379	#endif
		1380	#if EV_USE_KQUEUE
		1381	if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
		1382	#endif
		1383	#if EV_USE_EPOLL
		1384	if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
		1385	#endif
		1386	#if EV_USE_POLL
		1387	if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
		1388	#endif
		1389	#if EV_USE_SELECT
		1390	if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
		1391	#endif
		1392
		1393	for (i = NUMPRI; i--; )
		1394	{
		1395	array_free (pending, [i]);
		1396	#if EV_IDLE_ENABLE
		1397	array_free (idle, [i]);
		1398	#endif
		1399	}
		1400
		1401	ev_free (anfds); anfdmax = 0;
		1402
		1403	/* have to use the microsoft-never-gets-it-right macro */
		1404	array_free (fdchange, EMPTY);
		1405	array_free (timer, EMPTY);
		1406	#if EV_PERIODIC_ENABLE
		1407	array_free (periodic, EMPTY);
		1408	#endif
		1409	#if EV_FORK_ENABLE
		1410	array_free (fork, EMPTY);
		1411	#endif
		1412	array_free (prepare, EMPTY);
		1413	array_free (check, EMPTY);
		1414	#if EV_ASYNC_ENABLE
		1415	array_free (async, EMPTY);
		1416	#endif
		1417
		1418	backend = 0;
		1419	}
		1420
		1421	#if EV_USE_INOTIFY
		1422	void inline_size infy_fork (EV_P);
		1423	#endif
		1424
		1425	void inline_size
		1426	loop_fork (EV_P)
264	{	1427	{
265	while (timercnt && timers [0]->at <= now)	1428	#if EV_USE_PORT
		1429	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
		1430	#endif
		1431	#if EV_USE_KQUEUE
		1432	if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
		1433	#endif
		1434	#if EV_USE_EPOLL
		1435	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
		1436	#endif
		1437	#if EV_USE_INOTIFY
		1438	infy_fork (EV_A);
		1439	#endif
		1440
		1441	if (ev_is_active (&pipeev))
		1442	{
		1443	/* this "locks" the handlers against writing to the pipe */
		1444	/* while we modify the fd vars */
		1445	gotsig = 1;
		1446	#if EV_ASYNC_ENABLE
		1447	gotasync = 1;
		1448	#endif
		1449
		1450	ev_ref (EV_A);
		1451	ev_io_stop (EV_A_ &pipeev);
		1452
		1453	#if EV_USE_EVENTFD
		1454	if (evfd >= 0)
		1455	close (evfd);
		1456	#endif
		1457
		1458	if (evpipe [0] >= 0)
		1459	{
		1460	close (evpipe [0]);
		1461	close (evpipe [1]);
		1462	}
		1463
		1464	evpipe_init (EV_A);
		1465	/* now iterate over everything, in case we missed something */
		1466	pipecb (EV_A_ &pipeev, EV_READ);
		1467	}
		1468
		1469	postfork = 0;
		1470	}
		1471
		1472	#if EV_MULTIPLICITY
		1473
		1474	struct ev_loop *
		1475	ev_loop_new (unsigned int flags)
		1476	{
		1477	struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
		1478
		1479	memset (loop, 0, sizeof (struct ev_loop));
		1480
		1481	loop_init (EV_A_ flags);
		1482
		1483	if (ev_backend (EV_A))
		1484	return loop;
		1485
		1486	return 0;
		1487	}
		1488
		1489	void
		1490	ev_loop_destroy (EV_P)
		1491	{
		1492	loop_destroy (EV_A);
		1493	ev_free (loop);
		1494	}
		1495
		1496	void
		1497	ev_loop_fork (EV_P)
		1498	{
		1499	postfork = 1; /* must be in line with ev_default_fork */
		1500	}
		1501
		1502	#if EV_VERIFY
		1503	static void noinline
		1504	verify_watcher (EV_P_ W w)
		1505	{
		1506	assert (("watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
		1507
		1508	if (w->pending)
		1509	assert (("pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
		1510	}
		1511
		1512	static void noinline
		1513	verify_heap (EV_P_ ANHE *heap, int N)
		1514	{
		1515	int i;
		1516
		1517	for (i = HEAP0; i < N + HEAP0; ++i)
		1518	{
		1519	assert (("active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i));
		1520	assert (("heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i])));
		1521	assert (("heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i]))));
		1522
		1523	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
		1524	}
		1525	}
		1526
		1527	static void noinline
		1528	array_verify (EV_P_ W *ws, int cnt)
		1529	{
		1530	while (cnt--)
		1531	{
		1532	assert (("active index mismatch", ev_active (ws [cnt]) == cnt + 1));
		1533	verify_watcher (EV_A_ ws [cnt]);
		1534	}
		1535	}
		1536	#endif
		1537
		1538	void
		1539	ev_loop_verify (EV_P)
		1540	{
		1541	#if EV_VERIFY
		1542	int i;
		1543	WL w;
		1544
		1545	assert (activecnt >= -1);
		1546
		1547	assert (fdchangemax >= fdchangecnt);
		1548	for (i = 0; i < fdchangecnt; ++i)
		1549	assert (("negative fd in fdchanges", fdchanges [i] >= 0));
		1550
		1551	assert (anfdmax >= 0);
		1552	for (i = 0; i < anfdmax; ++i)
		1553	for (w = anfds [i].head; w; w = w->next)
266	{	1554	{
267	struct ev_timer *w = timers [0];	1555	verify_watcher (EV_A_ (W)w);
		1556	assert (("inactive fd watcher on anfd list", ev_active (w) == 1));
		1557	assert (("fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
		1558	}
		1559
		1560	assert (timermax >= timercnt);
		1561	verify_heap (EV_A_ timers, timercnt);
		1562
		1563	#if EV_PERIODIC_ENABLE
		1564	assert (periodicmax >= periodiccnt);
		1565	verify_heap (EV_A_ periodics, periodiccnt);
		1566	#endif
		1567
		1568	for (i = NUMPRI; i--; )
		1569	{
		1570	assert (pendingmax [i] >= pendingcnt [i]);
		1571	#if EV_IDLE_ENABLE
		1572	assert (idleall >= 0);
		1573	assert (idlemax [i] >= idlecnt [i]);
		1574	array_verify (EV_A_ (W *)idles [i], idlecnt [i]);
		1575	#endif
		1576	}
		1577
		1578	#if EV_FORK_ENABLE
		1579	assert (forkmax >= forkcnt);
		1580	array_verify (EV_A_ (W *)forks, forkcnt);
		1581	#endif
		1582
		1583	#if EV_ASYNC_ENABLE
		1584	assert (asyncmax >= asynccnt);
		1585	array_verify (EV_A_ (W *)asyncs, asynccnt);
		1586	#endif
		1587
		1588	assert (preparemax >= preparecnt);
		1589	array_verify (EV_A_ (W *)prepares, preparecnt);
		1590
		1591	assert (checkmax >= checkcnt);
		1592	array_verify (EV_A_ (W *)checks, checkcnt);
		1593
		1594	# if 0
		1595	for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
		1596	for (signum = signalmax; signum--; ) if (signals [signum].gotsig)
		1597	# endif
		1598	#endif
		1599	}
		1600
		1601	#endif /* multiplicity */
		1602
		1603	#if EV_MULTIPLICITY
		1604	struct ev_loop *
		1605	ev_default_loop_init (unsigned int flags)
		1606	#else
		1607	int
		1608	ev_default_loop (unsigned int flags)
		1609	#endif
		1610	{
		1611	if (!ev_default_loop_ptr)
		1612	{
		1613	#if EV_MULTIPLICITY
		1614	struct ev_loop *loop = ev_default_loop_ptr = &default_loop_struct;
		1615	#else
		1616	ev_default_loop_ptr = 1;
		1617	#endif
		1618
		1619	loop_init (EV_A_ flags);
		1620
		1621	if (ev_backend (EV_A))
		1622	{
		1623	#ifndef _WIN32
		1624	ev_signal_init (&childev, childcb, SIGCHLD);
		1625	ev_set_priority (&childev, EV_MAXPRI);
		1626	ev_signal_start (EV_A_ &childev);
		1627	ev_unref (EV_A); /* child watcher should not keep loop alive */
		1628	#endif
		1629	}
		1630	else
		1631	ev_default_loop_ptr = 0;
		1632	}
		1633
		1634	return ev_default_loop_ptr;
		1635	}
		1636
		1637	void
		1638	ev_default_destroy (void)
		1639	{
		1640	#if EV_MULTIPLICITY
		1641	struct ev_loop *loop = ev_default_loop_ptr;
		1642	#endif
		1643
		1644	ev_default_loop_ptr = 0;
		1645
		1646	#ifndef _WIN32
		1647	ev_ref (EV_A); /* child watcher */
		1648	ev_signal_stop (EV_A_ &childev);
		1649	#endif
		1650
		1651	loop_destroy (EV_A);
		1652	}
		1653
		1654	void
		1655	ev_default_fork (void)
		1656	{
		1657	#if EV_MULTIPLICITY
		1658	struct ev_loop *loop = ev_default_loop_ptr;
		1659	#endif
		1660
		1661	if (backend)
		1662	postfork = 1; /* must be in line with ev_loop_fork */
		1663	}
		1664
		1665	/*****************************************************************************/
		1666
		1667	void
		1668	ev_invoke (EV_P_ void *w, int revents)
		1669	{
		1670	EV_CB_INVOKE ((W)w, revents);
		1671	}
		1672
		1673	void inline_speed
		1674	call_pending (EV_P)
		1675	{
		1676	int pri;
		1677
		1678	for (pri = NUMPRI; pri--; )
		1679	while (pendingcnt [pri])
		1680	{
		1681	ANPENDING *p = pendings [pri] + --pendingcnt [pri];
		1682
		1683	if (expect_true (p->w))
		1684	{
		1685	/*assert (("non-pending watcher on pending list", p->w->pending));*/
		1686
		1687	p->w->pending = 0;
		1688	EV_CB_INVOKE (p->w, p->events);
		1689	EV_FREQUENT_CHECK;
		1690	}
		1691	}
		1692	}
		1693
		1694	#if EV_IDLE_ENABLE
		1695	void inline_size
		1696	idle_reify (EV_P)
		1697	{
		1698	if (expect_false (idleall))
		1699	{
		1700	int pri;
		1701
		1702	for (pri = NUMPRI; pri--; )
		1703	{
		1704	if (pendingcnt [pri])
		1705	break;
		1706
		1707	if (idlecnt [pri])
		1708	{
		1709	queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
		1710	break;
		1711	}
		1712	}
		1713	}
		1714	}
		1715	#endif
		1716
		1717	void inline_size
		1718	timers_reify (EV_P)
		1719	{
		1720	EV_FREQUENT_CHECK;
		1721
		1722	while (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
		1723	{
		1724	ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
		1725
		1726	/*assert (("inactive timer on timer heap detected", ev_is_active (w)));*/
268		1727
269	/* first reschedule or stop timer */	1728	/* first reschedule or stop timer */
270	if (w->repeat)	1729	if (w->repeat)
271	{	1730	{
272	if (w->is_abs)	1731	ev_at (w) += w->repeat;
273	w->at += floor ((now - w->at) / w->repeat + 1.) * w->repeat;	1732	if (ev_at (w) < mn_now)
274	else	1733	ev_at (w) = mn_now;
275	w->at = now + w->repeat;
276		1734
277	assert (w->at > now);	1735	assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
278		1736
		1737	ANHE_at_cache (timers [HEAP0]);
279	downheap (timers, timercnt, 0);	1738	downheap (timers, timercnt, HEAP0);
280	}	1739	}
281	else	1740	else
		1741	ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
		1742
		1743	EV_FREQUENT_CHECK;
		1744	ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
		1745	}
		1746	}
		1747
		1748	#if EV_PERIODIC_ENABLE
		1749	void inline_size
		1750	periodics_reify (EV_P)
		1751	{
		1752	EV_FREQUENT_CHECK;
		1753
		1754	while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
		1755	{
		1756	ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
		1757
		1758	/*assert (("inactive timer on periodic heap detected", ev_is_active (w)));*/
		1759
		1760	/* first reschedule or stop timer */
		1761	if (w->reschedule_cb)
282	{	1762	{
283	evtimer_stop (w); /* nonrepeating: stop timer */	1763	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
284	--timercnt; /* maybe pass by reference instead? */	1764
		1765	assert (("ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
		1766
		1767	ANHE_at_cache (periodics [HEAP0]);
		1768	downheap (periodics, periodiccnt, HEAP0);
285	}	1769	}
		1770	else if (w->interval)
		1771	{
		1772	ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
		1773	/* if next trigger time is not sufficiently in the future, put it there */
		1774	/* this might happen because of floating point inexactness */
		1775	if (ev_at (w) - ev_rt_now < TIME_EPSILON)
		1776	{
		1777	ev_at (w) += w->interval;
286		1778
287	event ((struct ev_watcher *)w, EV_TIMEOUT);	1779	/* if interval is unreasonably low we might still have a time in the past */
288	}	1780	/* so correct this. this will make the periodic very inexact, but the user */
289	}	1781	/* has effectively asked to get triggered more often than possible */
		1782	if (ev_at (w) < ev_rt_now)
		1783	ev_at (w) = ev_rt_now;
		1784	}
290		1785
291	static void	1786	ANHE_at_cache (periodics [HEAP0]);
292	time_update ()	1787	downheap (periodics, periodiccnt, HEAP0);
		1788	}
		1789	else
		1790	ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
		1791
		1792	EV_FREQUENT_CHECK;
		1793	ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
		1794	}
		1795	}
		1796
		1797	static void noinline
		1798	periodics_reschedule (EV_P)
293	{	1799	{
294	int i;	1800	int i;
295	ev_now = ev_time ();
296		1801
297	if (have_monotonic)	1802	/* adjust periodics after time jump */
		1803	for (i = HEAP0; i < periodiccnt + HEAP0; ++i)
		1804	{
		1805	ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
		1806
		1807	if (w->reschedule_cb)
		1808	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
		1809	else if (w->interval)
		1810	ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
		1811
		1812	ANHE_at_cache (periodics [i]);
298	{	1813	}
		1814
		1815	reheap (periodics, periodiccnt);
		1816	}
		1817	#endif
		1818
		1819	void inline_speed
		1820	time_update (EV_P_ ev_tstamp max_block)
		1821	{
		1822	int i;
		1823
		1824	#if EV_USE_MONOTONIC
		1825	if (expect_true (have_monotonic))
		1826	{
299	ev_tstamp odiff = diff;	1827	ev_tstamp odiff = rtmn_diff;
300		1828
301	/* detecting time jumps is much more difficult */	1829	mn_now = get_clock ();
302	for (i = 2; --i; ) /* loop a few times, before making important decisions */	1830
		1831	/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
		1832	/* interpolate in the meantime */
		1833	if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
303	{	1834	{
304	now = get_clock ();	1835	ev_rt_now = rtmn_diff + mn_now;
		1836	return;
		1837	}
		1838
		1839	now_floor = mn_now;
		1840	ev_rt_now = ev_time ();
		1841
		1842	/* loop a few times, before making important decisions.
		1843	* on the choice of "4": one iteration isn't enough,
		1844	* in case we get preempted during the calls to
		1845	* ev_time and get_clock. a second call is almost guaranteed
		1846	* to succeed in that case, though. and looping a few more times
		1847	* doesn't hurt either as we only do this on time-jumps or
		1848	* in the unlikely event of having been preempted here.
		1849	*/
		1850	for (i = 4; --i; )
		1851	{
305	diff = ev_now - now;	1852	rtmn_diff = ev_rt_now - mn_now;
306		1853
307	if (fabs (odiff - diff) < MIN_TIMEJUMP)	1854	if (expect_true (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP))
308	return; /* all is well */	1855	return; /* all is well */
309		1856
310	ev_now = ev_time ();	1857	ev_rt_now = ev_time ();
		1858	mn_now = get_clock ();
		1859	now_floor = mn_now;
311	}	1860	}
312		1861
313	/* time jump detected, reschedule atimers */	1862	# if EV_PERIODIC_ENABLE
314	for (i = 0; i < atimercnt; ++i)	1863	periodics_reschedule (EV_A);
		1864	# endif
		1865	/* no timer adjustment, as the monotonic clock doesn't jump */
		1866	/* timers_reschedule (EV_A_ rtmn_diff - odiff) */
		1867	}
		1868	else
		1869	#endif
		1870	{
		1871	ev_rt_now = ev_time ();
		1872
		1873	if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))
315	{	1874	{
316	struct ev_timer *w = atimers [i];	1875	#if EV_PERIODIC_ENABLE
317	w->at += ceil ((ev_now - w->at) / w->repeat + 1.) * w->repeat;	1876	periodics_reschedule (EV_A);
		1877	#endif
		1878	/* adjust timers. this is easy, as the offset is the same for all of them */
		1879	for (i = 0; i < timercnt; ++i)
		1880	{
		1881	ANHE *he = timers + i + HEAP0;
		1882	ANHE_w (*he)->at += ev_rt_now - mn_now;
		1883	ANHE_at_cache (*he);
		1884	}
318	}	1885	}
319	}
320	else
321	{
322	if (now > ev_now || now < ev_now - MAX_BLOCKTIME - MIN_TIMEJUMP)
323	/* time jump detected, adjust rtimers */
324	for (i = 0; i < rtimercnt; ++i)
325	rtimers [i]->at += ev_now - now;
326		1886
327	now = ev_now;	1887	mn_now = ev_rt_now;
328	}	1888	}
329	}	1889	}
330		1890
331	int ev_loop_done;	1891	void
		1892	ev_ref (EV_P)
		1893	{
		1894	++activecnt;
		1895	}
332		1896
		1897	void
		1898	ev_unref (EV_P)
		1899	{
		1900	--activecnt;
		1901	}
		1902
		1903	void
		1904	ev_now_update (EV_P)
		1905	{
		1906	time_update (EV_A_ 1e100);
		1907	}
		1908
		1909	static int loop_done;
		1910
		1911	void
333	void ev_loop (int flags)	1912	ev_loop (EV_P_ int flags)
334	{	1913	{
335	double block;	1914	loop_done = EVUNLOOP_CANCEL;
336	ev_loop_done = flags & EVLOOP_ONESHOT;	1915
		1916	call_pending (EV_A); /* in case we recurse, ensure ordering stays nice and clean */
337		1917
338	do	1918	do
339	{	1919	{
		1920	#if EV_VERIFY >= 2
		1921	ev_loop_verify (EV_A);
		1922	#endif
		1923
		1924	#ifndef _WIN32
		1925	if (expect_false (curpid)) /* penalise the forking check even more */
		1926	if (expect_false (getpid () != curpid))
		1927	{
		1928	curpid = getpid ();
		1929	postfork = 1;
		1930	}
		1931	#endif
		1932
		1933	#if EV_FORK_ENABLE
		1934	/* we might have forked, so queue fork handlers */
		1935	if (expect_false (postfork))
		1936	if (forkcnt)
		1937	{
		1938	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
		1939	call_pending (EV_A);
		1940	}
		1941	#endif
		1942
		1943	/* queue prepare watchers (and execute them) */
		1944	if (expect_false (preparecnt))
		1945	{
		1946	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
		1947	call_pending (EV_A);
		1948	}
		1949
		1950	if (expect_false (!activecnt))
		1951	break;
		1952
		1953	/* we might have forked, so reify kernel state if necessary */
		1954	if (expect_false (postfork))
		1955	loop_fork (EV_A);
		1956
340	/* update fd-related kernel structures */	1957	/* update fd-related kernel structures */
341	method_reify (); fdchangecnt = 0;	1958	fd_reify (EV_A);
342		1959
343	/* calculate blocking time */	1960	/* calculate blocking time */
344	if (flags & EVLOOP_NONBLOCK)	1961	{
345	block = 0.;	1962	ev_tstamp waittime = 0.;
346	else	1963	ev_tstamp sleeptime = 0.;
		1964
		1965	if (expect_true (!(flags & EVLOOP_NONBLOCK || idleall || !activecnt)))
347	{	1966	{
		1967	/* update time to cancel out callback processing overhead */
		1968	time_update (EV_A_ 1e100);
		1969
348	block = MAX_BLOCKTIME;	1970	waittime = MAX_BLOCKTIME;
349		1971
350	if (rtimercnt)	1972	if (timercnt)
351	{	1973	{
352	ev_tstamp to = rtimers [0]->at - get_clock () + method_fudge;	1974	ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge;
353	if (block > to) block = to;	1975	if (waittime > to) waittime = to;
354	}	1976	}
355		1977
		1978	#if EV_PERIODIC_ENABLE
356	if (atimercnt)	1979	if (periodiccnt)
357	{	1980	{
358	ev_tstamp to = atimers [0]->at - ev_time () + method_fudge;	1981	ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now + backend_fudge;
359	if (block > to) block = to;	1982	if (waittime > to) waittime = to;
360	}	1983	}
		1984	#endif
361		1985
362	if (block < 0.) block = 0.;	1986	if (expect_false (waittime < timeout_blocktime))
		1987	waittime = timeout_blocktime;
		1988
		1989	sleeptime = waittime - backend_fudge;
		1990
		1991	if (expect_true (sleeptime > io_blocktime))
		1992	sleeptime = io_blocktime;
		1993
		1994	if (sleeptime)
		1995	{
		1996	ev_sleep (sleeptime);
		1997	waittime -= sleeptime;
		1998	}
363	}	1999	}
364		2000
365	method_poll (block);	2001	++loop_count;
		2002	backend_poll (EV_A_ waittime);
366		2003
367	/* update ev_now, do magic */	2004	/* update ev_rt_now, do magic */
368	time_update ();	2005	time_update (EV_A_ waittime + sleeptime);
		2006	}
369		2007
370	/* put pending timers into pendign queue and reschedule them */	2008	/* queue pending timers and reschedule them */
371	/* absolute timers first */	2009	timers_reify (EV_A); /* relative timers called last */
372	timers_reify (atimers, atimercnt, ev_now);	2010	#if EV_PERIODIC_ENABLE
373	/* relative timers second */	2011	periodics_reify (EV_A); /* absolute timers called first */
374	timers_reify (rtimers, rtimercnt, now);	2012	#endif
375		2013
		2014	#if EV_IDLE_ENABLE
		2015	/* queue idle watchers unless other events are pending */
		2016	idle_reify (EV_A);
		2017	#endif
		2018
		2019	/* queue check watchers, to be executed first */
		2020	if (expect_false (checkcnt))
		2021	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
		2022
376	call_pending ();	2023	call_pending (EV_A);
377	}	2024	}
378	while (!ev_loop_done);	2025	while (expect_true (
379	}	2026	activecnt
		2027	&& !loop_done
		2028	&& !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK))
		2029	));
380		2030
381	static void	2031	if (loop_done == EVUNLOOP_ONE)
382	wlist_add (struct ev_watcher_list **head, struct ev_watcher_list *elem)	2032	loop_done = EVUNLOOP_CANCEL;
		2033	}
		2034
		2035	void
		2036	ev_unloop (EV_P_ int how)
		2037	{
		2038	loop_done = how;
		2039	}
		2040
		2041	/*****************************************************************************/
		2042
		2043	void inline_size
		2044	wlist_add (WL *head, WL elem)
383	{	2045	{
384	elem->next = *head;	2046	elem->next = *head;
385	*head = elem;	2047	*head = elem;
386	}	2048	}
387		2049
388	static void	2050	void inline_size
389	wlist_del (struct ev_watcher_list **head, struct ev_watcher_list *elem)	2051	wlist_del (WL *head, WL elem)
390	{	2052	{
391	while (*head)	2053	while (*head)
392	{	2054	{
393	if (*head == elem)	2055	if (*head == elem)
394	{	2056	{
…		…
398		2060
399	head = &(*head)->next;	2061	head = &(*head)->next;
400	}	2062	}
401	}	2063	}
402		2064
		2065	void inline_speed
		2066	clear_pending (EV_P_ W w)
		2067	{
		2068	if (w->pending)
		2069	{
		2070	pendings [ABSPRI (w)][w->pending - 1].w = 0;
		2071	w->pending = 0;
		2072	}
		2073	}
		2074
		2075	int
		2076	ev_clear_pending (EV_P_ void *w)
		2077	{
		2078	W w_ = (W)w;
		2079	int pending = w_->pending;
		2080
		2081	if (expect_true (pending))
		2082	{
		2083	ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
		2084	w_->pending = 0;
		2085	p->w = 0;
		2086	return p->events;
		2087	}
		2088	else
		2089	return 0;
		2090	}
		2091
		2092	void inline_size
		2093	pri_adjust (EV_P_ W w)
		2094	{
		2095	int pri = w->priority;
		2096	pri = pri < EV_MINPRI ? EV_MINPRI : pri;
		2097	pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
		2098	w->priority = pri;
		2099	}
		2100
		2101	void inline_speed
		2102	ev_start (EV_P_ W w, int active)
		2103	{
		2104	pri_adjust (EV_A_ w);
		2105	w->active = active;
		2106	ev_ref (EV_A);
		2107	}
		2108
		2109	void inline_size
		2110	ev_stop (EV_P_ W w)
		2111	{
		2112	ev_unref (EV_A);
		2113	w->active = 0;
		2114	}
		2115
		2116	/*****************************************************************************/
		2117
		2118	void noinline
		2119	ev_io_start (EV_P_ ev_io *w)
		2120	{
		2121	int fd = w->fd;
		2122
		2123	if (expect_false (ev_is_active (w)))
		2124	return;
		2125
		2126	assert (("ev_io_start called with negative fd", fd >= 0));
		2127	assert (("ev_io start called with illegal event mask", !(w->events & ~(EV_IOFDSET | EV_READ | EV_WRITE))));
		2128
		2129	EV_FREQUENT_CHECK;
		2130
		2131	ev_start (EV_A_ (W)w, 1);
		2132	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
		2133	wlist_add (&anfds[fd].head, (WL)w);
		2134
		2135	fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1);
		2136	w->events &= ~EV_IOFDSET;
		2137
		2138	EV_FREQUENT_CHECK;
		2139	}
		2140
		2141	void noinline
		2142	ev_io_stop (EV_P_ ev_io *w)
		2143	{
		2144	clear_pending (EV_A_ (W)w);
		2145	if (expect_false (!ev_is_active (w)))
		2146	return;
		2147
		2148	assert (("ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
		2149
		2150	EV_FREQUENT_CHECK;
		2151
		2152	wlist_del (&anfds[w->fd].head, (WL)w);
		2153	ev_stop (EV_A_ (W)w);
		2154
		2155	fd_change (EV_A_ w->fd, 1);
		2156
		2157	EV_FREQUENT_CHECK;
		2158	}
		2159
		2160	void noinline
		2161	ev_timer_start (EV_P_ ev_timer *w)
		2162	{
		2163	if (expect_false (ev_is_active (w)))
		2164	return;
		2165
		2166	ev_at (w) += mn_now;
		2167
		2168	assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
		2169
		2170	EV_FREQUENT_CHECK;
		2171
		2172	++timercnt;
		2173	ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
		2174	array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);
		2175	ANHE_w (timers [ev_active (w)]) = (WT)w;
		2176	ANHE_at_cache (timers [ev_active (w)]);
		2177	upheap (timers, ev_active (w));
		2178
		2179	EV_FREQUENT_CHECK;
		2180
		2181	/*assert (("internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
		2182	}
		2183
		2184	void noinline
		2185	ev_timer_stop (EV_P_ ev_timer *w)
		2186	{
		2187	clear_pending (EV_A_ (W)w);
		2188	if (expect_false (!ev_is_active (w)))
		2189	return;
		2190
		2191	EV_FREQUENT_CHECK;
		2192
		2193	{
		2194	int active = ev_active (w);
		2195
		2196	assert (("internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
		2197
		2198	--timercnt;
		2199
		2200	if (expect_true (active < timercnt + HEAP0))
		2201	{
		2202	timers [active] = timers [timercnt + HEAP0];
		2203	adjustheap (timers, timercnt, active);
		2204	}
		2205	}
		2206
		2207	EV_FREQUENT_CHECK;
		2208
		2209	ev_at (w) -= mn_now;
		2210
		2211	ev_stop (EV_A_ (W)w);
		2212	}
		2213
		2214	void noinline
		2215	ev_timer_again (EV_P_ ev_timer *w)
		2216	{
		2217	EV_FREQUENT_CHECK;
		2218
		2219	if (ev_is_active (w))
		2220	{
		2221	if (w->repeat)
		2222	{
		2223	ev_at (w) = mn_now + w->repeat;
		2224	ANHE_at_cache (timers [ev_active (w)]);
		2225	adjustheap (timers, timercnt, ev_active (w));
		2226	}
		2227	else
		2228	ev_timer_stop (EV_A_ w);
		2229	}
		2230	else if (w->repeat)
		2231	{
		2232	ev_at (w) = w->repeat;
		2233	ev_timer_start (EV_A_ w);
		2234	}
		2235
		2236	EV_FREQUENT_CHECK;
		2237	}
		2238
		2239	#if EV_PERIODIC_ENABLE
		2240	void noinline
		2241	ev_periodic_start (EV_P_ ev_periodic *w)
		2242	{
		2243	if (expect_false (ev_is_active (w)))
		2244	return;
		2245
		2246	if (w->reschedule_cb)
		2247	ev_at (w) = w->reschedule_cb (w, ev_rt_now);
		2248	else if (w->interval)
		2249	{
		2250	assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
		2251	/* this formula differs from the one in periodic_reify because we do not always round up */
		2252	ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
		2253	}
		2254	else
		2255	ev_at (w) = w->offset;
		2256
		2257	EV_FREQUENT_CHECK;
		2258
		2259	++periodiccnt;
		2260	ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
		2261	array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
		2262	ANHE_w (periodics [ev_active (w)]) = (WT)w;
		2263	ANHE_at_cache (periodics [ev_active (w)]);
		2264	upheap (periodics, ev_active (w));
		2265
		2266	EV_FREQUENT_CHECK;
		2267
		2268	/*assert (("internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
		2269	}
		2270
		2271	void noinline
		2272	ev_periodic_stop (EV_P_ ev_periodic *w)
		2273	{
		2274	clear_pending (EV_A_ (W)w);
		2275	if (expect_false (!ev_is_active (w)))
		2276	return;
		2277
		2278	EV_FREQUENT_CHECK;
		2279
		2280	{
		2281	int active = ev_active (w);
		2282
		2283	assert (("internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
		2284
		2285	--periodiccnt;
		2286
		2287	if (expect_true (active < periodiccnt + HEAP0))
		2288	{
		2289	periodics [active] = periodics [periodiccnt + HEAP0];
		2290	adjustheap (periodics, periodiccnt, active);
		2291	}
		2292	}
		2293
		2294	EV_FREQUENT_CHECK;
		2295
		2296	ev_stop (EV_A_ (W)w);
		2297	}
		2298
		2299	void noinline
		2300	ev_periodic_again (EV_P_ ev_periodic *w)
		2301	{
		2302	/* TODO: use adjustheap and recalculation */
		2303	ev_periodic_stop (EV_A_ w);
		2304	ev_periodic_start (EV_A_ w);
		2305	}
		2306	#endif
		2307
		2308	#ifndef SA_RESTART
		2309	# define SA_RESTART 0
		2310	#endif
		2311
		2312	void noinline
		2313	ev_signal_start (EV_P_ ev_signal *w)
		2314	{
		2315	#if EV_MULTIPLICITY
		2316	assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr));
		2317	#endif
		2318	if (expect_false (ev_is_active (w)))
		2319	return;
		2320
		2321	assert (("ev_signal_start called with illegal signal number", w->signum > 0));
		2322
		2323	evpipe_init (EV_A);
		2324
		2325	EV_FREQUENT_CHECK;
		2326
		2327	{
		2328	#ifndef _WIN32
		2329	sigset_t full, prev;
		2330	sigfillset (&full);
		2331	sigprocmask (SIG_SETMASK, &full, &prev);
		2332	#endif
		2333
		2334	array_needsize (ANSIG, signals, signalmax, w->signum, array_init_zero);
		2335
		2336	#ifndef _WIN32
		2337	sigprocmask (SIG_SETMASK, &prev, 0);
		2338	#endif
		2339	}
		2340
		2341	ev_start (EV_A_ (W)w, 1);
		2342	wlist_add (&signals [w->signum - 1].head, (WL)w);
		2343
		2344	if (!((WL)w)->next)
		2345	{
		2346	#if _WIN32
		2347	signal (w->signum, ev_sighandler);
		2348	#else
		2349	struct sigaction sa;
		2350	sa.sa_handler = ev_sighandler;
		2351	sigfillset (&sa.sa_mask);
		2352	sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
		2353	sigaction (w->signum, &sa, 0);
		2354	#endif
		2355	}
		2356
		2357	EV_FREQUENT_CHECK;
		2358	}
		2359
		2360	void noinline
		2361	ev_signal_stop (EV_P_ ev_signal *w)
		2362	{
		2363	clear_pending (EV_A_ (W)w);
		2364	if (expect_false (!ev_is_active (w)))
		2365	return;
		2366
		2367	EV_FREQUENT_CHECK;
		2368
		2369	wlist_del (&signals [w->signum - 1].head, (WL)w);
		2370	ev_stop (EV_A_ (W)w);
		2371
		2372	if (!signals [w->signum - 1].head)
		2373	signal (w->signum, SIG_DFL);
		2374
		2375	EV_FREQUENT_CHECK;
		2376	}
		2377
		2378	void
		2379	ev_child_start (EV_P_ ev_child *w)
		2380	{
		2381	#if EV_MULTIPLICITY
		2382	assert (("child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
		2383	#endif
		2384	if (expect_false (ev_is_active (w)))
		2385	return;
		2386
		2387	EV_FREQUENT_CHECK;
		2388
		2389	ev_start (EV_A_ (W)w, 1);
		2390	wlist_add (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
		2391
		2392	EV_FREQUENT_CHECK;
		2393	}
		2394
		2395	void
		2396	ev_child_stop (EV_P_ ev_child *w)
		2397	{
		2398	clear_pending (EV_A_ (W)w);
		2399	if (expect_false (!ev_is_active (w)))
		2400	return;
		2401
		2402	EV_FREQUENT_CHECK;
		2403
		2404	wlist_del (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
		2405	ev_stop (EV_A_ (W)w);
		2406
		2407	EV_FREQUENT_CHECK;
		2408	}
		2409
		2410	#if EV_STAT_ENABLE
		2411
		2412	# ifdef _WIN32
		2413	# undef lstat
		2414	# define lstat(a,b) _stati64 (a,b)
		2415	# endif
		2416
		2417	#define DEF_STAT_INTERVAL 5.0074891
		2418	#define MIN_STAT_INTERVAL 0.1074891
		2419
		2420	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
		2421
		2422	#if EV_USE_INOTIFY
		2423	# define EV_INOTIFY_BUFSIZE 8192
		2424
		2425	static void noinline
		2426	infy_add (EV_P_ ev_stat *w)
		2427	{
		2428	w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD);
		2429
		2430	if (w->wd < 0)
		2431	{
		2432	ev_timer_start (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
		2433
		2434	/* monitor some parent directory for speedup hints */
		2435	/* note that exceeding the hardcoded limit is not a correctness issue, */
		2436	/* but an efficiency issue only */
		2437	if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096)
		2438	{
		2439	char path [4096];
		2440	strcpy (path, w->path);
		2441
		2442	do
		2443	{
		2444	int mask = IN_MASK_ADD | IN_DELETE_SELF | IN_MOVE_SELF
		2445	| (errno == EACCES ? IN_ATTRIB : IN_CREATE | IN_MOVED_TO);
		2446
		2447	char *pend = strrchr (path, '/');
		2448
		2449	if (!pend)
		2450	break; /* whoops, no '/', complain to your admin */
		2451
		2452	*pend = 0;
		2453	w->wd = inotify_add_watch (fs_fd, path, mask);
		2454	}
		2455	while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
		2456	}
		2457	}
		2458	else
		2459	ev_timer_stop (EV_A_ &w->timer); /* we can watch this in a race-free way */
		2460
		2461	if (w->wd >= 0)
		2462	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
		2463	}
		2464
		2465	static void noinline
		2466	infy_del (EV_P_ ev_stat *w)
		2467	{
		2468	int slot;
		2469	int wd = w->wd;
		2470
		2471	if (wd < 0)
		2472	return;
		2473
		2474	w->wd = -2;
		2475	slot = wd & (EV_INOTIFY_HASHSIZE - 1);
		2476	wlist_del (&fs_hash [slot].head, (WL)w);
		2477
		2478	/* remove this watcher, if others are watching it, they will rearm */
		2479	inotify_rm_watch (fs_fd, wd);
		2480	}
		2481
		2482	static void noinline
		2483	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
		2484	{
		2485	if (slot < 0)
		2486	/* overflow, need to check for all hash slots */
		2487	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
		2488	infy_wd (EV_A_ slot, wd, ev);
		2489	else
		2490	{
		2491	WL w_;
		2492
		2493	for (w_ = fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head; w_; )
		2494	{
		2495	ev_stat *w = (ev_stat *)w_;
		2496	w_ = w_->next; /* lets us remove this watcher and all before it */
		2497
		2498	if (w->wd == wd || wd == -1)
		2499	{
		2500	if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF))
		2501	{
		2502	w->wd = -1;
		2503	infy_add (EV_A_ w); /* re-add, no matter what */
		2504	}
		2505
		2506	stat_timer_cb (EV_A_ &w->timer, 0);
		2507	}
		2508	}
		2509	}
		2510	}
		2511
403	static void	2512	static void
404	ev_start (struct ev_watcher *w, int active)	2513	infy_cb (EV_P_ ev_io *w, int revents)
405	{	2514	{
406	w->pending = 0;	2515	char buf [EV_INOTIFY_BUFSIZE];
407	w->active = active;	2516	struct inotify_event *ev = (struct inotify_event *)buf;
		2517	int ofs;
		2518	int len = read (fs_fd, buf, sizeof (buf));
		2519
		2520	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)
		2521	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		2522	}
		2523
		2524	void inline_size
		2525	infy_init (EV_P)
		2526	{
		2527	if (fs_fd != -2)
		2528	return;
		2529
		2530	/* kernels < 2.6.25 are borked
		2531	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
		2532	*/
		2533	{
		2534	struct utsname buf;
		2535	int major, minor, micro;
		2536
		2537	fs_fd = -1;
		2538
		2539	if (uname (&buf))
		2540	return;
		2541
		2542	if (sscanf (buf.release, "%d.%d.%d", &major, &minor, &micro) != 3)
		2543	return;
		2544
		2545	if (major < 2
		2546	|| (major == 2 && minor < 6)
		2547	|| (major == 2 && minor == 6 && micro < 25))
		2548	return;
		2549	}
		2550
		2551	fs_fd = inotify_init ();
		2552
		2553	if (fs_fd >= 0)
		2554	{
		2555	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
		2556	ev_set_priority (&fs_w, EV_MAXPRI);
		2557	ev_io_start (EV_A_ &fs_w);
		2558	}
		2559	}
		2560
		2561	void inline_size
		2562	infy_fork (EV_P)
		2563	{
		2564	int slot;
		2565
		2566	if (fs_fd < 0)
		2567	return;
		2568
		2569	close (fs_fd);
		2570	fs_fd = inotify_init ();
		2571
		2572	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
		2573	{
		2574	WL w_ = fs_hash [slot].head;
		2575	fs_hash [slot].head = 0;
		2576
		2577	while (w_)
		2578	{
		2579	ev_stat *w = (ev_stat *)w_;
		2580	w_ = w_->next; /* lets us add this watcher */
		2581
		2582	w->wd = -1;
		2583
		2584	if (fs_fd >= 0)
		2585	infy_add (EV_A_ w); /* re-add, no matter what */
		2586	else
		2587	ev_timer_start (EV_A_ &w->timer);
		2588	}
		2589	}
		2590	}
		2591
		2592	#endif
		2593
		2594	#ifdef _WIN32
		2595	# define EV_LSTAT(p,b) _stati64 (p, b)
		2596	#else
		2597	# define EV_LSTAT(p,b) lstat (p, b)
		2598	#endif
		2599
		2600	void
		2601	ev_stat_stat (EV_P_ ev_stat *w)
		2602	{
		2603	if (lstat (w->path, &w->attr) < 0)
		2604	w->attr.st_nlink = 0;
		2605	else if (!w->attr.st_nlink)
		2606	w->attr.st_nlink = 1;
		2607	}
		2608
		2609	static void noinline
		2610	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
		2611	{
		2612	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
		2613
		2614	/* we copy this here each the time so that */
		2615	/* prev has the old value when the callback gets invoked */
		2616	w->prev = w->attr;
		2617	ev_stat_stat (EV_A_ w);
		2618
		2619	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
		2620	if (
		2621	w->prev.st_dev != w->attr.st_dev
		2622	|| w->prev.st_ino != w->attr.st_ino
		2623	|| w->prev.st_mode != w->attr.st_mode
		2624	|| w->prev.st_nlink != w->attr.st_nlink
		2625	|| w->prev.st_uid != w->attr.st_uid
		2626	|| w->prev.st_gid != w->attr.st_gid
		2627	|| w->prev.st_rdev != w->attr.st_rdev
		2628	|| w->prev.st_size != w->attr.st_size
		2629	|| w->prev.st_atime != w->attr.st_atime
		2630	|| w->prev.st_mtime != w->attr.st_mtime
		2631	|| w->prev.st_ctime != w->attr.st_ctime
		2632	) {
		2633	#if EV_USE_INOTIFY
		2634	if (fs_fd >= 0)
		2635	{
		2636	infy_del (EV_A_ w);
		2637	infy_add (EV_A_ w);
		2638	ev_stat_stat (EV_A_ w); /* avoid race... */
		2639	}
		2640	#endif
		2641
		2642	ev_feed_event (EV_A_ w, EV_STAT);
		2643	}
		2644	}
		2645
		2646	void
		2647	ev_stat_start (EV_P_ ev_stat *w)
		2648	{
		2649	if (expect_false (ev_is_active (w)))
		2650	return;
		2651
		2652	/* since we use memcmp, we need to clear any padding data etc. */
		2653	memset (&w->prev, 0, sizeof (ev_statdata));
		2654	memset (&w->attr, 0, sizeof (ev_statdata));
		2655
		2656	ev_stat_stat (EV_A_ w);
		2657
		2658	if (w->interval < MIN_STAT_INTERVAL)
		2659	w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;
		2660
		2661	ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
		2662	ev_set_priority (&w->timer, ev_priority (w));
		2663
		2664	#if EV_USE_INOTIFY
		2665	infy_init (EV_A);
		2666
		2667	if (fs_fd >= 0)
		2668	infy_add (EV_A_ w);
		2669	else
		2670	#endif
		2671	ev_timer_start (EV_A_ &w->timer);
		2672
		2673	ev_start (EV_A_ (W)w, 1);
		2674
		2675	EV_FREQUENT_CHECK;
		2676	}
		2677
		2678	void
		2679	ev_stat_stop (EV_P_ ev_stat *w)
		2680	{
		2681	clear_pending (EV_A_ (W)w);
		2682	if (expect_false (!ev_is_active (w)))
		2683	return;
		2684
		2685	EV_FREQUENT_CHECK;
		2686
		2687	#if EV_USE_INOTIFY
		2688	infy_del (EV_A_ w);
		2689	#endif
		2690	ev_timer_stop (EV_A_ &w->timer);
		2691
		2692	ev_stop (EV_A_ (W)w);
		2693
		2694	EV_FREQUENT_CHECK;
		2695	}
		2696	#endif
		2697
		2698	#if EV_IDLE_ENABLE
		2699	void
		2700	ev_idle_start (EV_P_ ev_idle *w)
		2701	{
		2702	if (expect_false (ev_is_active (w)))
		2703	return;
		2704
		2705	pri_adjust (EV_A_ (W)w);
		2706
		2707	EV_FREQUENT_CHECK;
		2708
		2709	{
		2710	int active = ++idlecnt [ABSPRI (w)];
		2711
		2712	++idleall;
		2713	ev_start (EV_A_ (W)w, active);
		2714
		2715	array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
		2716	idles [ABSPRI (w)][active - 1] = w;
		2717	}
		2718
		2719	EV_FREQUENT_CHECK;
		2720	}
		2721
		2722	void
		2723	ev_idle_stop (EV_P_ ev_idle *w)
		2724	{
		2725	clear_pending (EV_A_ (W)w);
		2726	if (expect_false (!ev_is_active (w)))
		2727	return;
		2728
		2729	EV_FREQUENT_CHECK;
		2730
		2731	{
		2732	int active = ev_active (w);
		2733
		2734	idles [ABSPRI (w)][active - 1] = idles [ABSPRI (w)][--idlecnt [ABSPRI (w)]];
		2735	ev_active (idles [ABSPRI (w)][active - 1]) = active;
		2736
		2737	ev_stop (EV_A_ (W)w);
		2738	--idleall;
		2739	}
		2740
		2741	EV_FREQUENT_CHECK;
		2742	}
		2743	#endif
		2744
		2745	void
		2746	ev_prepare_start (EV_P_ ev_prepare *w)
		2747	{
		2748	if (expect_false (ev_is_active (w)))
		2749	return;
		2750
		2751	EV_FREQUENT_CHECK;
		2752
		2753	ev_start (EV_A_ (W)w, ++preparecnt);
		2754	array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
		2755	prepares [preparecnt - 1] = w;
		2756
		2757	EV_FREQUENT_CHECK;
		2758	}
		2759
		2760	void
		2761	ev_prepare_stop (EV_P_ ev_prepare *w)
		2762	{
		2763	clear_pending (EV_A_ (W)w);
		2764	if (expect_false (!ev_is_active (w)))
		2765	return;
		2766
		2767	EV_FREQUENT_CHECK;
		2768
		2769	{
		2770	int active = ev_active (w);
		2771
		2772	prepares [active - 1] = prepares [--preparecnt];
		2773	ev_active (prepares [active - 1]) = active;
		2774	}
		2775
		2776	ev_stop (EV_A_ (W)w);
		2777
		2778	EV_FREQUENT_CHECK;
		2779	}
		2780
		2781	void
		2782	ev_check_start (EV_P_ ev_check *w)
		2783	{
		2784	if (expect_false (ev_is_active (w)))
		2785	return;
		2786
		2787	EV_FREQUENT_CHECK;
		2788
		2789	ev_start (EV_A_ (W)w, ++checkcnt);
		2790	array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
		2791	checks [checkcnt - 1] = w;
		2792
		2793	EV_FREQUENT_CHECK;
		2794	}
		2795
		2796	void
		2797	ev_check_stop (EV_P_ ev_check *w)
		2798	{
		2799	clear_pending (EV_A_ (W)w);
		2800	if (expect_false (!ev_is_active (w)))
		2801	return;
		2802
		2803	EV_FREQUENT_CHECK;
		2804
		2805	{
		2806	int active = ev_active (w);
		2807
		2808	checks [active - 1] = checks [--checkcnt];
		2809	ev_active (checks [active - 1]) = active;
		2810	}
		2811
		2812	ev_stop (EV_A_ (W)w);
		2813
		2814	EV_FREQUENT_CHECK;
		2815	}
		2816
		2817	#if EV_EMBED_ENABLE
		2818	void noinline
		2819	ev_embed_sweep (EV_P_ ev_embed *w)
		2820	{
		2821	ev_loop (w->other, EVLOOP_NONBLOCK);
408	}	2822	}
409		2823
410	static void	2824	static void
411	ev_stop (struct ev_watcher *w)	2825	embed_io_cb (EV_P_ ev_io *io, int revents)
412	{	2826	{
413	if (w->pending)	2827	ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io));
414	pendings [w->pending - 1].w = 0;
415		2828
416	w->active = 0;
417	/* nop */
418	}
419
420	void
421	evio_start (struct ev_io *w)
422	{
423	if (ev_is_active (w))	2829	if (ev_cb (w))
		2830	ev_feed_event (EV_A_ (W)w, EV_EMBED);
		2831	else
		2832	ev_loop (w->other, EVLOOP_NONBLOCK);
		2833	}
		2834
		2835	static void
		2836	embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)
		2837	{
		2838	ev_embed *w = (ev_embed *)(((char *)prepare) - offsetof (ev_embed, prepare));
		2839
		2840	{
		2841	struct ev_loop *loop = w->other;
		2842
		2843	while (fdchangecnt)
		2844	{
		2845	fd_reify (EV_A);
		2846	ev_loop (EV_A_ EVLOOP_NONBLOCK);
		2847	}
		2848	}
		2849	}
		2850
		2851	static void
		2852	embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
		2853	{
		2854	ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
		2855
		2856	{
		2857	struct ev_loop *loop = w->other;
		2858
		2859	ev_loop_fork (EV_A);
		2860	}
		2861	}
		2862
		2863	#if 0
		2864	static void
		2865	embed_idle_cb (EV_P_ ev_idle *idle, int revents)
		2866	{
		2867	ev_idle_stop (EV_A_ idle);
		2868	}
		2869	#endif
		2870
		2871	void
		2872	ev_embed_start (EV_P_ ev_embed *w)
		2873	{
		2874	if (expect_false (ev_is_active (w)))
424	return;	2875	return;
425		2876
426	int fd = w->fd;	2877	{
		2878	struct ev_loop *loop = w->other;
		2879	assert (("loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
		2880	ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);
		2881	}
427		2882
428	ev_start ((struct ev_watcher *)w, 1);	2883	EV_FREQUENT_CHECK;
429	array_needsize (anfds, anfdmax, fd + 1, anfds_init);
430	wlist_add ((struct ev_watcher_list **)&anfds[fd].head, (struct ev_watcher_list *)w);
431		2884
432	++fdchangecnt;	2885	ev_set_priority (&w->io, ev_priority (w));
433	array_needsize (fdchanges, fdchangemax, fdchangecnt, );	2886	ev_io_start (EV_A_ &w->io);
434	fdchanges [fdchangecnt - 1] = fd;
435	}
436		2887
		2888	ev_prepare_init (&w->prepare, embed_prepare_cb);
		2889	ev_set_priority (&w->prepare, EV_MINPRI);
		2890	ev_prepare_start (EV_A_ &w->prepare);
		2891
		2892	ev_fork_init (&w->fork, embed_fork_cb);
		2893	ev_fork_start (EV_A_ &w->fork);
		2894
		2895	/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
		2896
		2897	ev_start (EV_A_ (W)w, 1);
		2898
		2899	EV_FREQUENT_CHECK;
		2900	}
		2901
437	void	2902	void
438	evio_stop (struct ev_io *w)	2903	ev_embed_stop (EV_P_ ev_embed *w)
439	{	2904	{
		2905	clear_pending (EV_A_ (W)w);
440	if (!ev_is_active (w))	2906	if (expect_false (!ev_is_active (w)))
441	return;	2907	return;
442		2908
443	wlist_del ((struct ev_watcher_list **)&anfds[w->fd].head, (struct ev_watcher_list *)w);	2909	EV_FREQUENT_CHECK;
444	ev_stop ((struct ev_watcher *)w);
445		2910
446	++fdchangecnt;	2911	ev_io_stop (EV_A_ &w->io);
447	array_needsize (fdchanges, fdchangemax, fdchangecnt, );	2912	ev_prepare_stop (EV_A_ &w->prepare);
448	fdchanges [fdchangecnt - 1] = w->fd;	2913	ev_fork_stop (EV_A_ &w->fork);
449	}
450		2914
		2915	EV_FREQUENT_CHECK;
		2916	}
		2917	#endif
		2918
		2919	#if EV_FORK_ENABLE
451	void	2920	void
452	evtimer_start (struct ev_timer *w)	2921	ev_fork_start (EV_P_ ev_fork *w)
453	{	2922	{
454	if (ev_is_active (w))	2923	if (expect_false (ev_is_active (w)))
455	return;	2924	return;
456		2925
457	if (w->is_abs)	2926	EV_FREQUENT_CHECK;
458	{
459	/* this formula differs from the one in timer_reify becuse we do not round up */
460	if (w->repeat)
461	w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat;
462		2927
463	ev_start ((struct ev_watcher *)w, ++atimercnt);	2928	ev_start (EV_A_ (W)w, ++forkcnt);
464	array_needsize (atimers, atimermax, atimercnt, );	2929	array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
465	atimers [atimercnt - 1] = w;	2930	forks [forkcnt - 1] = w;
466	upheap (atimers, atimercnt - 1);
467	}
468	else
469	{
470	w->at += now;
471		2931
472	ev_start ((struct ev_watcher *)w, ++rtimercnt);	2932	EV_FREQUENT_CHECK;
473	array_needsize (rtimers, rtimermax, rtimercnt, );
474	rtimers [rtimercnt - 1] = w;
475	upheap (rtimers, rtimercnt - 1);
476	}
477
478	}	2933	}
479		2934
480	void	2935	void
481	evtimer_stop (struct ev_timer *w)	2936	ev_fork_stop (EV_P_ ev_fork *w)
482	{	2937	{
		2938	clear_pending (EV_A_ (W)w);
483	if (!ev_is_active (w))	2939	if (expect_false (!ev_is_active (w)))
484	return;	2940	return;
485		2941
486	if (w->is_abs)	2942	EV_FREQUENT_CHECK;
		2943
487	{	2944	{
488	if (w->active < atimercnt--)	2945	int active = ev_active (w);
489	{	2946
490	atimers [w->active - 1] = atimers [atimercnt];	2947	forks [active - 1] = forks [--forkcnt];
491	downheap (atimers, atimercnt, w->active - 1);	2948	ev_active (forks [active - 1]) = active;
492	}
493	}	2949	}
494	else
495	{
496	if (w->active < rtimercnt--)
497	{
498	rtimers [w->active - 1] = rtimers [rtimercnt];
499	downheap (rtimers, rtimercnt, w->active - 1);
500	}
501	}
502		2950
503	ev_stop ((struct ev_watcher *)w);	2951	ev_stop (EV_A_ (W)w);
504	}
505		2952
		2953	EV_FREQUENT_CHECK;
		2954	}
		2955	#endif
		2956
		2957	#if EV_ASYNC_ENABLE
506	void	2958	void
507	evsignal_start (struct ev_signal *w)	2959	ev_async_start (EV_P_ ev_async *w)
508	{	2960	{
509	if (ev_is_active (w))	2961	if (expect_false (ev_is_active (w)))
510	return;	2962	return;
511		2963
512	ev_start ((struct ev_watcher *)w, 1);	2964	evpipe_init (EV_A);
513	array_needsize (signals, signalmax, w->signum, signals_init);
514	wlist_add ((struct ev_watcher_list **)&signals [w->signum - 1], (struct ev_watcher_list *)w);
515	}
516		2965
		2966	EV_FREQUENT_CHECK;
		2967
		2968	ev_start (EV_A_ (W)w, ++asynccnt);
		2969	array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);
		2970	asyncs [asynccnt - 1] = w;
		2971
		2972	EV_FREQUENT_CHECK;
		2973	}
		2974
517	void	2975	void
518	evsignal_stop (struct ev_signal *w)	2976	ev_async_stop (EV_P_ ev_async *w)
519	{	2977	{
		2978	clear_pending (EV_A_ (W)w);
520	if (!ev_is_active (w))	2979	if (expect_false (!ev_is_active (w)))
521	return;	2980	return;
522		2981
523	wlist_del ((struct ev_watcher_list **)&signals [w->signum - 1], (struct ev_watcher_list *)w);	2982	EV_FREQUENT_CHECK;
524	ev_stop ((struct ev_watcher *)w);	2983
		2984	{
		2985	int active = ev_active (w);
		2986
		2987	asyncs [active - 1] = asyncs [--asynccnt];
		2988	ev_active (asyncs [active - 1]) = active;
		2989	}
		2990
		2991	ev_stop (EV_A_ (W)w);
		2992
		2993	EV_FREQUENT_CHECK;
525	}	2994	}
		2995
		2996	void
		2997	ev_async_send (EV_P_ ev_async *w)
		2998	{
		2999	w->sent = 1;
		3000	evpipe_write (EV_A_ &gotasync);
		3001	}
		3002	#endif
526		3003
527	/*****************************************************************************/	3004	/*****************************************************************************/
528	#if 1	3005
		3006	struct ev_once
		3007	{
		3008	ev_io io;
		3009	ev_timer to;
		3010	void (*cb)(int revents, void *arg);
		3011	void *arg;
		3012	};
529		3013
530	static void	3014	static void
531	sin_cb (struct ev_io *w, int revents)	3015	once_cb (EV_P_ struct ev_once *once, int revents)
532	{	3016	{
533	fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);	3017	void (*cb)(int revents, void *arg) = once->cb;
		3018	void *arg = once->arg;
		3019
		3020	ev_io_stop (EV_A_ &once->io);
		3021	ev_timer_stop (EV_A_ &once->to);
		3022	ev_free (once);
		3023
		3024	cb (revents, arg);
534	}	3025	}
535		3026
536	static void	3027	static void
		3028	once_cb_io (EV_P_ ev_io *w, int revents)
		3029	{
		3030	struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io));
		3031
		3032	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->to));
		3033	}
		3034
		3035	static void
537	ocb (struct ev_timer *w, int revents)	3036	once_cb_to (EV_P_ ev_timer *w, int revents)
538	{	3037	{
539	//fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);	3038	struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to));
540	evtimer_stop (w);
541	evtimer_start (w);
542	}
543		3039
544	int main (void)	3040	once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
545	{	3041	}
546	struct ev_io sin;
547		3042
548	ev_init (0);	3043	void
		3044	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
		3045	{
		3046	struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
549		3047
550	evw_init (&sin, sin_cb, 55);	3048	if (expect_false (!once))
551	evio_set (&sin, 0, EV_READ);
552	evio_start (&sin);
553
554	struct ev_timer t[10000];
555
556	#if 1
557	int i;
558	for (i = 0; i < 10000; ++i)
559	{
560	struct ev_timer *w = t + i;
561	evw_init (w, ocb, i);
562	evtimer_set_abs (w, drand48 (), 0.99775533);
563	evtimer_start (w);
564	if (drand48 () < 0.5)
565	evtimer_stop (w);
566	}	3049	{
567	#endif	3050	cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
568
569	struct ev_timer t1;
570	evw_init (&t1, ocb, 0);
571	evtimer_set_abs (&t1, 5, 10);
572	evtimer_start (&t1);
573
574	ev_loop (0);
575
576	return 0;	3051	return;
577	}	3052	}
578		3053
579	#endif	3054	once->cb = cb;
		3055	once->arg = arg;
580		3056
		3057	ev_init (&once->io, once_cb_io);
		3058	if (fd >= 0)
		3059	{
		3060	ev_io_set (&once->io, fd, events);
		3061	ev_io_start (EV_A_ &once->io);
		3062	}
581		3063
		3064	ev_init (&once->to, once_cb_to);
		3065	if (timeout >= 0.)
		3066	{
		3067	ev_timer_set (&once->to, timeout, 0.);
		3068	ev_timer_start (EV_A_ &once->to);
		3069	}
		3070	}
582		3071
		3072	#if EV_MULTIPLICITY
		3073	#include "ev_wrap.h"
		3074	#endif
583		3075
		3076	#ifdef __cplusplus
		3077	}
		3078	#endif
		3079

Diff Legend

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