ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.35 by root, Thu Nov 1 11:55:54 2007 UTC vs.
Revision 1.293 by root, Mon Jun 29 18:46:52 2009 UTC

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

Diff Legend

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