[ViewVC] Diff of: cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.313 by root, Wed Aug 19 23:44:51 2009 UTC vs.
Revision 1.337 by root, Wed Mar 10 09:18:24 2010 UTC

…		…
1	/*	1	/*
2	* libev event processing core, watcher management	2	* libev event processing core, watcher management
3	*	3	*
4	* Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libev@schmorp.de>	4	* Copyright (c) 2007,2008,2009,2010 Marc Alexander Lehmann <libev@schmorp.de>
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without modifica-	7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:	8	* tion, are permitted provided that the following conditions are met:
9	*	9	*
110	# define EV_USE_EPOLL 0	110	# define EV_USE_EPOLL 0
111	# endif	111	# endif
112	# endif	112	# endif
113		113
114	# ifndef EV_USE_KQUEUE	114	# ifndef EV_USE_KQUEUE
115	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H	115	# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
116	# define EV_USE_KQUEUE 1	116	# define EV_USE_KQUEUE 1
117	# else	117	# else
118	# define EV_USE_KQUEUE 0	118	# define EV_USE_KQUEUE 0
119	# endif	119	# endif
120	# endif	120	# endif
…		…
153		153
154	#endif	154	#endif
155		155
156	#include <math.h>	156	#include <math.h>
157	#include <stdlib.h>	157	#include <stdlib.h>
		158	#include <string.h>
158	#include <fcntl.h>	159	#include <fcntl.h>
159	#include <stddef.h>	160	#include <stddef.h>
160		161
161	#include <stdio.h>	162	#include <stdio.h>
162		163
163	#include <assert.h>	164	#include <assert.h>
164	#include <errno.h>	165	#include <errno.h>
165	#include <sys/types.h>	166	#include <sys/types.h>
166	#include <time.h>	167	#include <time.h>
		168	#include <limits.h>
167		169
168	#include <signal.h>	170	#include <signal.h>
169		171
170	#ifdef EV_H	172	#ifdef EV_H
171	# include EV_H	173	# include EV_H
…		…
182	# define WIN32_LEAN_AND_MEAN	184	# define WIN32_LEAN_AND_MEAN
183	# include <windows.h>	185	# include <windows.h>
184	# ifndef EV_SELECT_IS_WINSOCKET	186	# ifndef EV_SELECT_IS_WINSOCKET
185	# define EV_SELECT_IS_WINSOCKET 1	187	# define EV_SELECT_IS_WINSOCKET 1
186	# endif	188	# endif
		189	# undef EV_AVOID_STDIO
187	#endif	190	#endif
188		191
189	/* this block tries to deduce configuration from header-defined symbols and defaults */	192	/* this block tries to deduce configuration from header-defined symbols and defaults */
190		193
191	/* try to deduce the maximum number of signals on this platform */	194	/* try to deduce the maximum number of signals on this platform */
…		…
204	#elif defined (MAXSIG)	207	#elif defined (MAXSIG)
205	# define EV_NSIG (MAXSIG+1)	208	# define EV_NSIG (MAXSIG+1)
206	#elif defined (MAX_SIG)	209	#elif defined (MAX_SIG)
207	# define EV_NSIG (MAX_SIG+1)	210	# define EV_NSIG (MAX_SIG+1)
208	#elif defined (SIGARRAYSIZE)	211	#elif defined (SIGARRAYSIZE)
209	# define EV_NSIG SIGARRAYSIZE /* Assume ary[SIGARRAYSIZE] */	212	# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
210	#elif defined (_sys_nsig)	213	#elif defined (_sys_nsig)
211	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */	214	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
212	#else	215	#else
213	# error "unable to find value for NSIG, please report"	216	# error "unable to find value for NSIG, please report"
214	/* to make it compile regardless, just remove the above line */	217	/* to make it compile regardless, just remove the above line, */
		218	/* but consider reporting it, too! :) */
215	# define EV_NSIG 65	219	# define EV_NSIG 65
216	#endif	220	#endif
217		221
218	#ifndef EV_USE_CLOCK_SYSCALL	222	#ifndef EV_USE_CLOCK_SYSCALL
219	# if __linux && __GLIBC__ >= 2	223	# if __linux && __GLIBC__ >= 2
…		…
302	# define EV_USE_EVENTFD 0	306	# define EV_USE_EVENTFD 0
303	# endif	307	# endif
304	#endif	308	#endif
305		309
306	#ifndef EV_USE_SIGNALFD	310	#ifndef EV_USE_SIGNALFD
307	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 9))	311	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
308	# define EV_USE_SIGNALFD 1	312	# define EV_USE_SIGNALFD 1
309	# else	313	# else
310	# define EV_USE_SIGNALFD 0	314	# define EV_USE_SIGNALFD 0
311	# endif	315	# endif
312	#endif	316	#endif
…		…
343	# endif	347	# endif
344	#endif	348	#endif
345		349
346	/* this block fixes any misconfiguration where we know we run into trouble otherwise */	350	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
347		351
		352	#ifdef _AIX
		353	/* AIX has a completely broken poll.h header */
		354	# undef EV_USE_POLL
		355	# define EV_USE_POLL 0
		356	#endif
		357
348	#ifndef CLOCK_MONOTONIC	358	#ifndef CLOCK_MONOTONIC
349	# undef EV_USE_MONOTONIC	359	# undef EV_USE_MONOTONIC
350	# define EV_USE_MONOTONIC 0	360	# define EV_USE_MONOTONIC 0
351	#endif	361	#endif
352		362
…		…
395	# endif	405	# endif
396	# endif	406	# endif
397	# ifdef __cplusplus	407	# ifdef __cplusplus
398	extern "C" {	408	extern "C" {
399	# endif	409	# endif
400	int eventfd (unsigned int initval, int flags);	410	int (eventfd) (unsigned int initval, int flags);
401	# ifdef __cplusplus	411	# ifdef __cplusplus
402	}	412	}
403	# endif	413	# endif
404	#endif	414	#endif
405		415
406	#if EV_USE_SIGNALFD	416	#if EV_USE_SIGNALFD
407	# include <sys/signalfd.h>	417	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
		418	# include <stdint.h>
		419	# ifndef SFD_NONBLOCK
		420	# define SFD_NONBLOCK O_NONBLOCK
408	#endif	421	# endif
		422	# ifndef SFD_CLOEXEC
		423	# ifdef O_CLOEXEC
		424	# define SFD_CLOEXEC O_CLOEXEC
		425	# else
		426	# define SFD_CLOEXEC 02000000
		427	# endif
		428	# endif
		429	# ifdef __cplusplus
		430	extern "C" {
		431	# endif
		432	int signalfd (int fd, const sigset_t *mask, int flags);
		433
		434	struct signalfd_siginfo
		435	{
		436	uint32_t ssi_signo;
		437	char pad[128 - sizeof (uint32_t)];
		438	};
		439	# ifdef __cplusplus
		440	}
		441	# endif
		442	#endif
		443
409		444
410	/**/	445	/**/
411		446
412	#if EV_VERIFY >= 3	447	#if EV_VERIFY >= 3
413	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)	448	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
…		…
425	*/	460	*/
426	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */	461	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */
427		462
428	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	463	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
429	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	464	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
430	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds, TODO */
431		465
432	#if __GNUC__ >= 4	466	#if __GNUC__ >= 4
433	# define expect(expr,value) __builtin_expect ((expr),(value))	467	# define expect(expr,value) __builtin_expect ((expr),(value))
434	# define noinline __attribute__ ((noinline))	468	# define noinline __attribute__ ((noinline))
435	#else	469	#else
…		…
480		514
481	#ifndef EV_FD_TO_WIN32_HANDLE	515	#ifndef EV_FD_TO_WIN32_HANDLE
482	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)	516	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
483	#endif	517	#endif
484	#ifndef EV_WIN32_HANDLE_TO_FD	518	#ifndef EV_WIN32_HANDLE_TO_FD
485	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (fd, 0)	519	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
486	#endif	520	#endif
487	#ifndef EV_WIN32_CLOSE_FD	521	#ifndef EV_WIN32_CLOSE_FD
488	# define EV_WIN32_CLOSE_FD(fd) close (fd)	522	# define EV_WIN32_CLOSE_FD(fd) close (fd)
489	#endif	523	#endif
490		524
491	#ifdef _WIN32	525	#ifdef _WIN32
492	# include "ev_win32.c"	526	# include "ev_win32.c"
493	#endif	527	#endif
494		528
495	/*****************************************************************************/	529	/*****************************************************************************/
		530
		531	#if EV_AVOID_STDIO
		532	static void noinline
		533	ev_printerr (const char *msg)
		534	{
		535	write (STDERR_FILENO, msg, strlen (msg));
		536	}
		537	#endif
496		538
497	static void (syserr_cb)(const char msg);	539	static void (syserr_cb)(const char msg);
498		540
499	void	541	void
500	ev_set_syserr_cb (void (cb)(const char msg))	542	ev_set_syserr_cb (void (cb)(const char msg))
…		…
510		552
511	if (syserr_cb)	553	if (syserr_cb)
512	syserr_cb (msg);	554	syserr_cb (msg);
513	else	555	else
514	{	556	{
		557	#if EV_AVOID_STDIO
		558	const char *err = strerror (errno);
		559
		560	ev_printerr (msg);
		561	ev_printerr (": ");
		562	ev_printerr (err);
		563	ev_printerr ("\n");
		564	#else
515	perror (msg);	565	perror (msg);
		566	#endif
516	abort ();	567	abort ();
517	}	568	}
518	}	569	}
519		570
520	static void *	571	static void *
521	ev_realloc_emul (void *ptr, long size)	572	ev_realloc_emul (void *ptr, long size)
522	{	573	{
		574	#if __GLIBC__
		575	return realloc (ptr, size);
		576	#else
523	/* some systems, notably openbsd and darwin, fail to properly	577	/* some systems, notably openbsd and darwin, fail to properly
524	* implement realloc (x, 0) (as required by both ansi c-98 and	578	* implement realloc (x, 0) (as required by both ansi c-89 and
525	* the single unix specification, so work around them here.	579	* the single unix specification, so work around them here.
526	*/	580	*/
527		581
528	if (size)	582	if (size)
529	return realloc (ptr, size);	583	return realloc (ptr, size);
530		584
531	free (ptr);	585	free (ptr);
532	return 0;	586	return 0;
		587	#endif
533	}	588	}
534		589
535	static void (alloc)(void *ptr, long size) = ev_realloc_emul;	590	static void (alloc)(void *ptr, long size) = ev_realloc_emul;
536		591
537	void	592	void
…		…
545	{	600	{
546	ptr = alloc (ptr, size);	601	ptr = alloc (ptr, size);
547		602
548	if (!ptr && size)	603	if (!ptr && size)
549	{	604	{
		605	#if EV_AVOID_STDIO
		606	ev_printerr ("libev: memory allocation failed, aborting.\n");
		607	#else
550	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);	608	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
		609	#endif
551	abort ();	610	abort ();
552	}	611	}
553		612
554	return ptr;	613	return ptr;
555	}	614	}
…		…
832	}	891	}
833		892
834	/*****************************************************************************/	893	/*****************************************************************************/
835		894
836	inline_speed void	895	inline_speed void
837	fd_event_nc (EV_P_ int fd, int revents)	896	fd_event_nocheck (EV_P_ int fd, int revents)
838	{	897	{
839	ANFD *anfd = anfds + fd;	898	ANFD *anfd = anfds + fd;
840	ev_io *w;	899	ev_io *w;
841		900
842	for (w = (ev_io )anfd->head; w; w = (ev_io )((WL)w)->next)	901	for (w = (ev_io )anfd->head; w; w = (ev_io )((WL)w)->next)
…		…
854	fd_event (EV_P_ int fd, int revents)	913	fd_event (EV_P_ int fd, int revents)
855	{	914	{
856	ANFD *anfd = anfds + fd;	915	ANFD *anfd = anfds + fd;
857		916
858	if (expect_true (!anfd->reify))	917	if (expect_true (!anfd->reify))
859	fd_event_nc (EV_A_ fd, revents);	918	fd_event_nocheck (EV_A_ fd, revents);
860	}	919	}
861		920
862	void	921	void
863	ev_feed_fd_event (EV_P_ int fd, int revents)	922	ev_feed_fd_event (EV_P_ int fd, int revents)
864	{	923	{
865	if (fd >= 0 && fd < anfdmax)	924	if (fd >= 0 && fd < anfdmax)
866	fd_event_nc (EV_A_ fd, revents);	925	fd_event_nocheck (EV_A_ fd, revents);
867	}	926	}
868		927
869	/* make sure the external fd watch events are in-sync */	928	/* make sure the external fd watch events are in-sync */
870	/* with the kernel/libev internal state */	929	/* with the kernel/libev internal state */
871	inline_size void	930	inline_size void
…		…
934	ev_io_stop (EV_A_ w);	993	ev_io_stop (EV_A_ w);
935	ev_feed_event (EV_A_ (W)w, EV_ERROR \| EV_READ \| EV_WRITE);	994	ev_feed_event (EV_A_ (W)w, EV_ERROR \| EV_READ \| EV_WRITE);
936	}	995	}
937	}	996	}
938		997
939	/* check whether the given fd is atcually valid, for error recovery */	998	/* check whether the given fd is actually valid, for error recovery */
940	inline_size int	999	inline_size int
941	fd_valid (int fd)	1000	fd_valid (int fd)
942	{	1001	{
943	#ifdef _WIN32	1002	#ifdef _WIN32
944	return _get_osfhandle (fd) != -1;	1003	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
945	#else	1004	#else
946	return fcntl (fd, F_GETFD) != -1;	1005	return fcntl (fd, F_GETFD) != -1;
947	#endif	1006	#endif
948	}	1007	}
949		1008
…		…
984	{	1043	{
985	anfds [fd].events = 0;	1044	anfds [fd].events = 0;
986	anfds [fd].emask = 0;	1045	anfds [fd].emask = 0;
987	fd_change (EV_A_ fd, EV__IOFDSET \| EV_ANFD_REIFY);	1046	fd_change (EV_A_ fd, EV__IOFDSET \| EV_ANFD_REIFY);
988	}	1047	}
		1048	}
		1049
		1050	/* used to prepare libev internal fd's */
		1051	/* this is not fork-safe */
		1052	inline_speed void
		1053	fd_intern (int fd)
		1054	{
		1055	#ifdef _WIN32
		1056	unsigned long arg = 1;
		1057	ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
		1058	#else
		1059	fcntl (fd, F_SETFD, FD_CLOEXEC);
		1060	fcntl (fd, F_SETFL, O_NONBLOCK);
		1061	#endif
989	}	1062	}
990		1063
991	/*****************************************************************************/	1064	/*****************************************************************************/
992		1065
993	/*	1066	/*
…		…
1147		1220
1148	static ANSIG signals [EV_NSIG - 1];	1221	static ANSIG signals [EV_NSIG - 1];
1149		1222
1150	/*****************************************************************************/	1223	/*****************************************************************************/
1151		1224
1152	/* used to prepare libev internal fd's */	1225	#if EV_SIGNAL_ENABLE \|\| EV_ASYNC_ENABLE
1153	/* this is not fork-safe */
1154	inline_speed void
1155	fd_intern (int fd)
1156	{
1157	#ifdef _WIN32
1158	unsigned long arg = 1;
1159	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
1160	#else
1161	fcntl (fd, F_SETFD, FD_CLOEXEC);
1162	fcntl (fd, F_SETFL, O_NONBLOCK);
1163	#endif
1164	}
1165		1226
1166	static void noinline	1227	static void noinline
1167	evpipe_init (EV_P)	1228	evpipe_init (EV_P)
1168	{	1229	{
1169	if (!ev_is_active (&pipe_w))	1230	if (!ev_is_active (&pipe_w))
1170	{	1231	{
1171	#if EV_USE_EVENTFD	1232	# if EV_USE_EVENTFD
1172	evfd = eventfd (0, EFD_NONBLOCK \| EFD_CLOEXEC);	1233	evfd = eventfd (0, EFD_NONBLOCK \| EFD_CLOEXEC);
1173	if (evfd < 0 && errno == EINVAL)	1234	if (evfd < 0 && errno == EINVAL)
1174	evfd = eventfd (0, 0);	1235	evfd = eventfd (0, 0);
1175		1236
1176	if (evfd >= 0)	1237	if (evfd >= 0)
…		…
1178	evpipe [0] = -1;	1239	evpipe [0] = -1;
1179	fd_intern (evfd); /* doing it twice doesn't hurt */	1240	fd_intern (evfd); /* doing it twice doesn't hurt */
1180	ev_io_set (&pipe_w, evfd, EV_READ);	1241	ev_io_set (&pipe_w, evfd, EV_READ);
1181	}	1242	}
1182	else	1243	else
1183	#endif	1244	# endif
1184	{	1245	{
1185	while (pipe (evpipe))	1246	while (pipe (evpipe))
1186	ev_syserr ("(libev) error creating signal/async pipe");	1247	ev_syserr ("(libev) error creating signal/async pipe");
1187		1248
1188	fd_intern (evpipe [0]);	1249	fd_intern (evpipe [0]);
…		…
1199	evpipe_write (EV_P_ EV_ATOMIC_T *flag)	1260	evpipe_write (EV_P_ EV_ATOMIC_T *flag)
1200	{	1261	{
1201	if (!*flag)	1262	if (!*flag)
1202	{	1263	{
1203	int old_errno = errno; /* save errno because write might clobber it */	1264	int old_errno = errno; /* save errno because write might clobber it */
		1265	char dummy;
1204		1266
1205	*flag = 1;	1267	*flag = 1;
1206		1268
1207	#if EV_USE_EVENTFD	1269	#if EV_USE_EVENTFD
1208	if (evfd >= 0)	1270	if (evfd >= 0)
…		…
1210	uint64_t counter = 1;	1272	uint64_t counter = 1;
1211	write (evfd, &counter, sizeof (uint64_t));	1273	write (evfd, &counter, sizeof (uint64_t));
1212	}	1274	}
1213	else	1275	else
1214	#endif	1276	#endif
1215	write (evpipe [1], &old_errno, 1);	1277	write (evpipe [1], &dummy, 1);
1216		1278
1217	errno = old_errno;	1279	errno = old_errno;
1218	}	1280	}
1219	}	1281	}
1220		1282
…		…
1269	{	1331	{
1270	#if EV_MULTIPLICITY	1332	#if EV_MULTIPLICITY
1271	EV_P = signals [signum - 1].loop;	1333	EV_P = signals [signum - 1].loop;
1272	#endif	1334	#endif
1273		1335
1274	#if _WIN32	1336	#ifdef _WIN32
1275	signal (signum, ev_sighandler);	1337	signal (signum, ev_sighandler);
1276	#endif	1338	#endif
1277		1339
1278	signals [signum - 1].pending = 1;	1340	signals [signum - 1].pending = 1;
1279	evpipe_write (EV_A_ &sig_pending);	1341	evpipe_write (EV_A_ &sig_pending);
…		…
1321	break;	1383	break;
1322	}	1384	}
1323	}	1385	}
1324	#endif	1386	#endif
1325		1387
		1388	#endif
		1389
1326	/*****************************************************************************/	1390	/*****************************************************************************/
1327		1391
		1392	#if EV_CHILD_ENABLE
1328	static WL childs [EV_PID_HASHSIZE];	1393	static WL childs [EV_PID_HASHSIZE];
1329
1330	#ifndef _WIN32
1331		1394
1332	static ev_signal childev;	1395	static ev_signal childev;
1333		1396
1334	#ifndef WIFCONTINUED	1397	#ifndef WIFCONTINUED
1335	# define WIFCONTINUED(status) 0	1398	# define WIFCONTINUED(status) 0
…		…
1580	#endif	1643	#endif
1581	#if EV_USE_INOTIFY	1644	#if EV_USE_INOTIFY
1582	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	1645	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
1583	#endif	1646	#endif
1584	#if EV_USE_SIGNALFD	1647	#if EV_USE_SIGNALFD
1585	sigfd = flags & EVFLAG_NOSIGFD ? -1 : -2;	1648	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
1586	#endif	1649	#endif
1587		1650
1588	if (!(flags & 0x0000ffffU))	1651	if (!(flags & 0x0000ffffU))
1589	flags \|= ev_recommended_backends ();	1652	flags \|= ev_recommended_backends ();
1590		1653
…		…
1604	if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);	1667	if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
1605	#endif	1668	#endif
1606		1669
1607	ev_prepare_init (&pending_w, pendingcb);	1670	ev_prepare_init (&pending_w, pendingcb);
1608		1671
		1672	#if EV_SIGNAL_ENABLE \|\| EV_ASYNC_ENABLE
1609	ev_init (&pipe_w, pipecb);	1673	ev_init (&pipe_w, pipecb);
1610	ev_set_priority (&pipe_w, EV_MAXPRI);	1674	ev_set_priority (&pipe_w, EV_MAXPRI);
		1675	#endif
1611	}	1676	}
1612	}	1677	}
1613		1678
1614	/* free up a loop structure */	1679	/* free up a loop structure */
1615	static void noinline	1680	static void noinline
…		…
1634	}	1699	}
1635	}	1700	}
1636		1701
1637	#if EV_USE_SIGNALFD	1702	#if EV_USE_SIGNALFD
1638	if (ev_is_active (&sigfd_w))	1703	if (ev_is_active (&sigfd_w))
1639	{
1640	/ev_ref (EV_A);/
1641	/ev_io_stop (EV_A_ &sigfd_w);/
1642
1643	close (sigfd);	1704	close (sigfd);
1644	}
1645	#endif	1705	#endif
1646		1706
1647	#if EV_USE_INOTIFY	1707	#if EV_USE_INOTIFY
1648	if (fs_fd >= 0)	1708	if (fs_fd >= 0)
1649	close (fs_fd);	1709	close (fs_fd);
…		…
1738	{	1798	{
1739	EV_WIN32_CLOSE_FD (evpipe [0]);	1799	EV_WIN32_CLOSE_FD (evpipe [0]);
1740	EV_WIN32_CLOSE_FD (evpipe [1]);	1800	EV_WIN32_CLOSE_FD (evpipe [1]);
1741	}	1801	}
1742		1802
		1803	#if EV_SIGNAL_ENABLE \|\| EV_ASYNC_ENABLE
1743	evpipe_init (EV_A);	1804	evpipe_init (EV_A);
1744	/* now iterate over everything, in case we missed something */	1805	/* now iterate over everything, in case we missed something */
1745	pipecb (EV_A_ &pipe_w, EV_READ);	1806	pipecb (EV_A_ &pipe_w, EV_READ);
		1807	#endif
1746	}	1808	}
1747		1809
1748	postfork = 0;	1810	postfork = 0;
1749	}	1811	}
1750		1812
…		…
1863	#if EV_ASYNC_ENABLE	1925	#if EV_ASYNC_ENABLE
1864	assert (asyncmax >= asynccnt);	1926	assert (asyncmax >= asynccnt);
1865	array_verify (EV_A_ (W *)asyncs, asynccnt);	1927	array_verify (EV_A_ (W *)asyncs, asynccnt);
1866	#endif	1928	#endif
1867		1929
		1930	#if EV_PREPARE_ENABLE
1868	assert (preparemax >= preparecnt);	1931	assert (preparemax >= preparecnt);
1869	array_verify (EV_A_ (W *)prepares, preparecnt);	1932	array_verify (EV_A_ (W *)prepares, preparecnt);
		1933	#endif
1870		1934
		1935	#if EV_CHECK_ENABLE
1871	assert (checkmax >= checkcnt);	1936	assert (checkmax >= checkcnt);
1872	array_verify (EV_A_ (W *)checks, checkcnt);	1937	array_verify (EV_A_ (W *)checks, checkcnt);
		1938	#endif
1873		1939
1874	# if 0	1940	# if 0
		1941	#if EV_CHILD_ENABLE
1875	for (w = (ev_child )childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child )((WL)w)->next)	1942	for (w = (ev_child )childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child )((WL)w)->next)
1876	for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)	1943	for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
		1944	#endif
1877	# endif	1945	# endif
1878	#endif	1946	#endif
1879	}	1947	}
1880	#endif	1948	#endif
1881		1949
…		…
1897		1965
1898	loop_init (EV_A_ flags);	1966	loop_init (EV_A_ flags);
1899		1967
1900	if (ev_backend (EV_A))	1968	if (ev_backend (EV_A))
1901	{	1969	{
1902	#ifndef _WIN32	1970	#if EV_CHILD_ENABLE
1903	ev_signal_init (&childev, childcb, SIGCHLD);	1971	ev_signal_init (&childev, childcb, SIGCHLD);
1904	ev_set_priority (&childev, EV_MAXPRI);	1972	ev_set_priority (&childev, EV_MAXPRI);
1905	ev_signal_start (EV_A_ &childev);	1973	ev_signal_start (EV_A_ &childev);
1906	ev_unref (EV_A); /* child watcher should not keep loop alive */	1974	ev_unref (EV_A); /* child watcher should not keep loop alive */
1907	#endif	1975	#endif
…		…
1920	EV_P = ev_default_loop_ptr;	1988	EV_P = ev_default_loop_ptr;
1921	#endif	1989	#endif
1922		1990
1923	ev_default_loop_ptr = 0;	1991	ev_default_loop_ptr = 0;
1924		1992
1925	#ifndef _WIN32	1993	#if EV_CHILD_ENABLE
1926	ev_ref (EV_A); /* child watcher */	1994	ev_ref (EV_A); /* child watcher */
1927	ev_signal_stop (EV_A_ &childev);	1995	ev_signal_stop (EV_A_ &childev);
1928	#endif	1996	#endif
1929		1997
1930	loop_destroy (EV_A);	1998	loop_destroy (EV_A);
…		…
2137	ANHE_at_cache (*he);	2205	ANHE_at_cache (*he);
2138	}	2206	}
2139	}	2207	}
2140		2208
2141	/* fetch new monotonic and realtime times from the kernel */	2209	/* fetch new monotonic and realtime times from the kernel */
2142	/* also detetc if there was a timejump, and act accordingly */	2210	/* also detect if there was a timejump, and act accordingly */
2143	inline_speed void	2211	inline_speed void
2144	time_update (EV_P_ ev_tstamp max_block)	2212	time_update (EV_P_ ev_tstamp max_block)
2145	{	2213	{
2146	#if EV_USE_MONOTONIC	2214	#if EV_USE_MONOTONIC
2147	if (expect_true (have_monotonic))	2215	if (expect_true (have_monotonic))
…		…
2242	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);	2310	queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
2243	EV_INVOKE_PENDING;	2311	EV_INVOKE_PENDING;
2244	}	2312	}
2245	#endif	2313	#endif
2246		2314
		2315	#if EV_PREPARE_ENABLE
2247	/* queue prepare watchers (and execute them) */	2316	/* queue prepare watchers (and execute them) */
2248	if (expect_false (preparecnt))	2317	if (expect_false (preparecnt))
2249	{	2318	{
2250	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);	2319	queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
2251	EV_INVOKE_PENDING;	2320	EV_INVOKE_PENDING;
2252	}	2321	}
		2322	#endif
2253		2323
2254	if (expect_false (loop_done))	2324	if (expect_false (loop_done))
2255	break;	2325	break;
2256		2326
2257	/* we might have forked, so reify kernel state if necessary */	2327	/* we might have forked, so reify kernel state if necessary */
…		…
2330	#if EV_IDLE_ENABLE	2400	#if EV_IDLE_ENABLE
2331	/* queue idle watchers unless other events are pending */	2401	/* queue idle watchers unless other events are pending */
2332	idle_reify (EV_A);	2402	idle_reify (EV_A);
2333	#endif	2403	#endif
2334		2404
		2405	#if EV_CHECK_ENABLE
2335	/* queue check watchers, to be executed first */	2406	/* queue check watchers, to be executed first */
2336	if (expect_false (checkcnt))	2407	if (expect_false (checkcnt))
2337	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);	2408	queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
		2409	#endif
2338		2410
2339	EV_INVOKE_PENDING;	2411	EV_INVOKE_PENDING;
2340	}	2412	}
2341	while (expect_true (	2413	while (expect_true (
2342	activecnt	2414	activecnt
…		…
2481		2553
2482	if (expect_false (ev_is_active (w)))	2554	if (expect_false (ev_is_active (w)))
2483	return;	2555	return;
2484		2556
2485	assert (("libev: ev_io_start called with negative fd", fd >= 0));	2557	assert (("libev: ev_io_start called with negative fd", fd >= 0));
2486	assert (("libev: ev_io start called with illegal event mask", !(w->events & ~(EV__IOFDSET \| EV_READ \| EV_WRITE))));	2558	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET \| EV_READ \| EV_WRITE))));
2487		2559
2488	EV_FREQUENT_CHECK;	2560	EV_FREQUENT_CHECK;
2489		2561
2490	ev_start (EV_A_ (W)w, 1);	2562	ev_start (EV_A_ (W)w, 1);
2491	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	2563	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
…		…
2561	timers [active] = timers [timercnt + HEAP0];	2633	timers [active] = timers [timercnt + HEAP0];
2562	adjustheap (timers, timercnt, active);	2634	adjustheap (timers, timercnt, active);
2563	}	2635	}
2564	}	2636	}
2565		2637
2566	EV_FREQUENT_CHECK;
2567
2568	ev_at (w) -= mn_now;	2638	ev_at (w) -= mn_now;
2569		2639
2570	ev_stop (EV_A_ (W)w);	2640	ev_stop (EV_A_ (W)w);
		2641
		2642	EV_FREQUENT_CHECK;
2571	}	2643	}
2572		2644
2573	void noinline	2645	void noinline
2574	ev_timer_again (EV_P_ ev_timer *w)	2646	ev_timer_again (EV_P_ ev_timer *w)
2575	{	2647	{
…		…
2654	periodics [active] = periodics [periodiccnt + HEAP0];	2726	periodics [active] = periodics [periodiccnt + HEAP0];
2655	adjustheap (periodics, periodiccnt, active);	2727	adjustheap (periodics, periodiccnt, active);
2656	}	2728	}
2657	}	2729	}
2658		2730
2659	EV_FREQUENT_CHECK;
2660
2661	ev_stop (EV_A_ (W)w);	2731	ev_stop (EV_A_ (W)w);
		2732
		2733	EV_FREQUENT_CHECK;
2662	}	2734	}
2663		2735
2664	void noinline	2736	void noinline
2665	ev_periodic_again (EV_P_ ev_periodic *w)	2737	ev_periodic_again (EV_P_ ev_periodic *w)
2666	{	2738	{
…		…
2671	#endif	2743	#endif
2672		2744
2673	#ifndef SA_RESTART	2745	#ifndef SA_RESTART
2674	# define SA_RESTART 0	2746	# define SA_RESTART 0
2675	#endif	2747	#endif
		2748
		2749	#if EV_SIGNAL_ENABLE
2676		2750
2677	void noinline	2751	void noinline
2678	ev_signal_start (EV_P_ ev_signal *w)	2752	ev_signal_start (EV_P_ ev_signal *w)
2679	{	2753	{
2680	if (expect_false (ev_is_active (w)))	2754	if (expect_false (ev_is_active (w)))
…		…
2727	if (!((WL)w)->next)	2801	if (!((WL)w)->next)
2728	# if EV_USE_SIGNALFD	2802	# if EV_USE_SIGNALFD
2729	if (sigfd < 0) /TODO/	2803	if (sigfd < 0) /TODO/
2730	# endif	2804	# endif
2731	{	2805	{
2732	# if _WIN32	2806	# ifdef _WIN32
		2807	evpipe_init (EV_A);
		2808
2733	signal (w->signum, ev_sighandler);	2809	signal (w->signum, ev_sighandler);
2734	# else	2810	# else
2735	struct sigaction sa;	2811	struct sigaction sa;
2736		2812
2737	evpipe_init (EV_A);	2813	evpipe_init (EV_A);
…		…
2768	signals [w->signum - 1].loop = 0; /* unattach from signal */	2844	signals [w->signum - 1].loop = 0; /* unattach from signal */
2769	#endif	2845	#endif
2770	#if EV_USE_SIGNALFD	2846	#if EV_USE_SIGNALFD
2771	if (sigfd >= 0)	2847	if (sigfd >= 0)
2772	{	2848	{
2773	sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D	2849	sigset_t ss;
		2850
		2851	sigemptyset (&ss);
		2852	sigaddset (&ss, w->signum);
2774	sigdelset (&sigfd_set, w->signum);	2853	sigdelset (&sigfd_set, w->signum);
		2854
2775	signalfd (sigfd, &sigfd_set, 0);	2855	signalfd (sigfd, &sigfd_set, 0);
2776	sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D	2856	sigprocmask (SIG_UNBLOCK, &ss, 0);
2777	/TODO: maybe unblock signal? /
2778	}	2857	}
2779	else	2858	else
2780	#endif	2859	#endif
2781	signal (w->signum, SIG_DFL);	2860	signal (w->signum, SIG_DFL);
2782	}	2861	}
2783		2862
2784	EV_FREQUENT_CHECK;	2863	EV_FREQUENT_CHECK;
2785	}	2864	}
		2865
		2866	#endif
		2867
		2868	#if EV_CHILD_ENABLE
2786		2869
2787	void	2870	void
2788	ev_child_start (EV_P_ ev_child *w)	2871	ev_child_start (EV_P_ ev_child *w)
2789	{	2872	{
2790	#if EV_MULTIPLICITY	2873	#if EV_MULTIPLICITY
…		…
2814	ev_stop (EV_A_ (W)w);	2897	ev_stop (EV_A_ (W)w);
2815		2898
2816	EV_FREQUENT_CHECK;	2899	EV_FREQUENT_CHECK;
2817	}	2900	}
2818		2901
		2902	#endif
		2903
2819	#if EV_STAT_ENABLE	2904	#if EV_STAT_ENABLE
2820		2905
2821	# ifdef _WIN32	2906	# ifdef _WIN32
2822	# undef lstat	2907	# undef lstat
2823	# define lstat(a,b) _stati64 (a,b)	2908	# define lstat(a,b) _stati64 (a,b)
…		…
2828	#define MIN_STAT_INTERVAL 0.1074891	2913	#define MIN_STAT_INTERVAL 0.1074891
2829		2914
2830	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	2915	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
2831		2916
2832	#if EV_USE_INOTIFY	2917	#if EV_USE_INOTIFY
2833	# define EV_INOTIFY_BUFSIZE 8192	2918
		2919	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
		2920	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
2834		2921
2835	static void noinline	2922	static void noinline
2836	infy_add (EV_P_ ev_stat *w)	2923	infy_add (EV_P_ ev_stat *w)
2837	{	2924	{
2838	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);	2925	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);
2839		2926
2840	if (w->wd < 0)	2927	if (w->wd >= 0)
		2928	{
		2929	struct statfs sfs;
		2930
		2931	/* now local changes will be tracked by inotify, but remote changes won't */
		2932	/* unless the filesystem is known to be local, we therefore still poll */
		2933	/* also do poll on <2.6.25, but with normal frequency */
		2934
		2935	if (!fs_2625)
		2936	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		2937	else if (!statfs (w->path, &sfs)
		2938	&& (sfs.f_type == 0x1373 /* devfs */
		2939	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
		2940	\|\| sfs.f_type == 0x3153464a /* jfs */
		2941	\|\| sfs.f_type == 0x52654973 /* reiser3 */
		2942	\|\| sfs.f_type == 0x01021994 /* tempfs */
		2943	\|\| sfs.f_type == 0x58465342 /* xfs */))
		2944	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
		2945	else
		2946	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
2841	{	2947	}
		2948	else
		2949	{
		2950	/* can't use inotify, continue to stat */
2842	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	2951	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
2843	ev_timer_again (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
2844		2952
2845	/* monitor some parent directory for speedup hints */	2953	/* if path is not there, monitor some parent directory for speedup hints */
2846	/* note that exceeding the hardcoded path limit is not a correctness issue, */	2954	/* note that exceeding the hardcoded path limit is not a correctness issue, */
2847	/* but an efficiency issue only */	2955	/* but an efficiency issue only */
2848	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)	2956	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)
2849	{	2957	{
2850	char path [4096];	2958	char path [4096];
…		…
2866	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));	2974	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));
2867	}	2975	}
2868	}	2976	}
2869		2977
2870	if (w->wd >= 0)	2978	if (w->wd >= 0)
2871	{
2872	struct statfs sfs;
2873
2874	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);	2979	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
2875		2980
2876	/* now local changes will be tracked by inotify, but remote changes won't */	2981	/* now re-arm timer, if required */
2877	/* unless the filesystem it known to be local, we therefore still poll */	2982	if (ev_is_active (&w->timer)) ev_ref (EV_A);
2878	/* also do poll on <2.6.25, but with normal frequency */
2879
2880	if (fs_2625 && !statfs (w->path, &sfs))
2881	if (sfs.f_type == 0x1373 /* devfs */
2882	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
2883	\|\| sfs.f_type == 0x3153464a /* jfs */
2884	\|\| sfs.f_type == 0x52654973 /* reiser3 */
2885	\|\| sfs.f_type == 0x01021994 /* tempfs */
2886	\|\| sfs.f_type == 0x58465342 /* xfs */)
2887	return;
2888
2889	w->timer.repeat = w->interval ? w->interval : fs_2625 ? NFS_STAT_INTERVAL : DEF_STAT_INTERVAL;
2890	ev_timer_again (EV_A_ &w->timer);	2983	ev_timer_again (EV_A_ &w->timer);
2891	}	2984	if (ev_is_active (&w->timer)) ev_unref (EV_A);
2892	}	2985	}
2893		2986
2894	static void noinline	2987	static void noinline
2895	infy_del (EV_P_ ev_stat *w)	2988	infy_del (EV_P_ ev_stat *w)
2896	{	2989	{
…		…
2941		3034
2942	static void	3035	static void
2943	infy_cb (EV_P_ ev_io *w, int revents)	3036	infy_cb (EV_P_ ev_io *w, int revents)
2944	{	3037	{
2945	char buf [EV_INOTIFY_BUFSIZE];	3038	char buf [EV_INOTIFY_BUFSIZE];
2946	struct inotify_event ev = (struct inotify_event )buf;
2947	int ofs;	3039	int ofs;
2948	int len = read (fs_fd, buf, sizeof (buf));	3040	int len = read (fs_fd, buf, sizeof (buf));
2949		3041
2950	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)	3042	for (ofs = 0; ofs < len; )
		3043	{
		3044	struct inotify_event ev = (struct inotify_event )(buf + ofs);
2951	infy_wd (EV_A_ ev->wd, ev->wd, ev);	3045	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		3046	ofs += sizeof (struct inotify_event) + ev->len;
		3047	}
		3048	}
		3049
		3050	inline_size unsigned int
		3051	ev_linux_version (void)
		3052	{
		3053	struct utsname buf;
		3054	unsigned int v;
		3055	int i;
		3056	char *p = buf.release;
		3057
		3058	if (uname (&buf))
		3059	return 0;
		3060
		3061	for (i = 3+1; --i; )
		3062	{
		3063	unsigned int c = 0;
		3064
		3065	for (;;)
		3066	{
		3067	if (p >= '0' && p <= '9')
		3068	c = c * 10 + *p++ - '0';
		3069	else
		3070	{
		3071	p += *p == '.';
		3072	break;
		3073	}
		3074	}
		3075
		3076	v = (v << 8) \| c;
		3077	}
		3078
		3079	return v;
2952	}	3080	}
2953		3081
2954	inline_size void	3082	inline_size void
2955	check_2625 (EV_P)	3083	ev_check_2625 (EV_P)
2956	{	3084	{
2957	/* kernels < 2.6.25 are borked	3085	/* kernels < 2.6.25 are borked
2958	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	3086	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2959	*/	3087	*/
2960	struct utsname buf;	3088	if (ev_linux_version () < 0x020619)
2961	int major, minor, micro;
2962
2963	if (uname (&buf))
2964	return;	3089	return;
2965		3090
2966	if (sscanf (buf.release, "%d.%d.%d", &major, &minor, &micro) != 3)
2967	return;
2968
2969	if (major < 2
2970	\|\| (major == 2 && minor < 6)
2971	\|\| (major == 2 && minor == 6 && micro < 25))
2972	return;
2973
2974	fs_2625 = 1;	3091	fs_2625 = 1;
		3092	}
		3093
		3094	inline_size int
		3095	infy_newfd (void)
		3096	{
		3097	#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK)
		3098	int fd = inotify_init1 (IN_CLOEXEC \| IN_NONBLOCK);
		3099	if (fd >= 0)
		3100	return fd;
		3101	#endif
		3102	return inotify_init ();
2975	}	3103	}
2976		3104
2977	inline_size void	3105	inline_size void
2978	infy_init (EV_P)	3106	infy_init (EV_P)
2979	{	3107	{
2980	if (fs_fd != -2)	3108	if (fs_fd != -2)
2981	return;	3109	return;
2982		3110
2983	fs_fd = -1;	3111	fs_fd = -1;
2984		3112
2985	check_2625 (EV_A);	3113	ev_check_2625 (EV_A);
2986		3114
2987	fs_fd = inotify_init ();	3115	fs_fd = infy_newfd ();
2988		3116
2989	if (fs_fd >= 0)	3117	if (fs_fd >= 0)
2990	{	3118	{
		3119	fd_intern (fs_fd);
2991	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);	3120	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
2992	ev_set_priority (&fs_w, EV_MAXPRI);	3121	ev_set_priority (&fs_w, EV_MAXPRI);
2993	ev_io_start (EV_A_ &fs_w);	3122	ev_io_start (EV_A_ &fs_w);
		3123	ev_unref (EV_A);
2994	}	3124	}
2995	}	3125	}
2996		3126
2997	inline_size void	3127	inline_size void
2998	infy_fork (EV_P)	3128	infy_fork (EV_P)
…		…
3000	int slot;	3130	int slot;
3001		3131
3002	if (fs_fd < 0)	3132	if (fs_fd < 0)
3003	return;	3133	return;
3004		3134
		3135	ev_ref (EV_A);
		3136	ev_io_stop (EV_A_ &fs_w);
3005	close (fs_fd);	3137	close (fs_fd);
3006	fs_fd = inotify_init ();	3138	fs_fd = infy_newfd ();
		3139
		3140	if (fs_fd >= 0)
		3141	{
		3142	fd_intern (fs_fd);
		3143	ev_io_set (&fs_w, fs_fd, EV_READ);
		3144	ev_io_start (EV_A_ &fs_w);
		3145	ev_unref (EV_A);
		3146	}
3007		3147
3008	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)	3148	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
3009	{	3149	{
3010	WL w_ = fs_hash [slot].head;	3150	WL w_ = fs_hash [slot].head;
3011	fs_hash [slot].head = 0;	3151	fs_hash [slot].head = 0;
…		…
3018	w->wd = -1;	3158	w->wd = -1;
3019		3159
3020	if (fs_fd >= 0)	3160	if (fs_fd >= 0)
3021	infy_add (EV_A_ w); /* re-add, no matter what */	3161	infy_add (EV_A_ w); /* re-add, no matter what */
3022	else	3162	else
		3163	{
		3164	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		3165	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3023	ev_timer_again (EV_A_ &w->timer);	3166	ev_timer_again (EV_A_ &w->timer);
		3167	if (ev_is_active (&w->timer)) ev_unref (EV_A);
		3168	}
3024	}	3169	}
3025	}	3170	}
3026	}	3171	}
3027		3172
3028	#endif	3173	#endif
…		…
3045	static void noinline	3190	static void noinline
3046	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	3191	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3047	{	3192	{
3048	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));	3193	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));
3049		3194
3050	/* we copy this here each the time so that */	3195	ev_statdata prev = w->attr;
3051	/* prev has the old value when the callback gets invoked */
3052	w->prev = w->attr;
3053	ev_stat_stat (EV_A_ w);	3196	ev_stat_stat (EV_A_ w);
3054		3197
3055	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */	3198	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
3056	if (	3199	if (
3057	w->prev.st_dev != w->attr.st_dev	3200	prev.st_dev != w->attr.st_dev
3058	\|\| w->prev.st_ino != w->attr.st_ino	3201	\|\| prev.st_ino != w->attr.st_ino
3059	\|\| w->prev.st_mode != w->attr.st_mode	3202	\|\| prev.st_mode != w->attr.st_mode
3060	\|\| w->prev.st_nlink != w->attr.st_nlink	3203	\|\| prev.st_nlink != w->attr.st_nlink
3061	\|\| w->prev.st_uid != w->attr.st_uid	3204	\|\| prev.st_uid != w->attr.st_uid
3062	\|\| w->prev.st_gid != w->attr.st_gid	3205	\|\| prev.st_gid != w->attr.st_gid
3063	\|\| w->prev.st_rdev != w->attr.st_rdev	3206	\|\| prev.st_rdev != w->attr.st_rdev
3064	\|\| w->prev.st_size != w->attr.st_size	3207	\|\| prev.st_size != w->attr.st_size
3065	\|\| w->prev.st_atime != w->attr.st_atime	3208	\|\| prev.st_atime != w->attr.st_atime
3066	\|\| w->prev.st_mtime != w->attr.st_mtime	3209	\|\| prev.st_mtime != w->attr.st_mtime
3067	\|\| w->prev.st_ctime != w->attr.st_ctime	3210	\|\| prev.st_ctime != w->attr.st_ctime
3068	) {	3211	) {
		3212	/* we only update w->prev on actual differences */
		3213	/* in case we test more often than invoke the callback, */
		3214	/* to ensure that prev is always different to attr */
		3215	w->prev = prev;
		3216
3069	#if EV_USE_INOTIFY	3217	#if EV_USE_INOTIFY
3070	if (fs_fd >= 0)	3218	if (fs_fd >= 0)
3071	{	3219	{
3072	infy_del (EV_A_ w);	3220	infy_del (EV_A_ w);
3073	infy_add (EV_A_ w);	3221	infy_add (EV_A_ w);
…		…
3098		3246
3099	if (fs_fd >= 0)	3247	if (fs_fd >= 0)
3100	infy_add (EV_A_ w);	3248	infy_add (EV_A_ w);
3101	else	3249	else
3102	#endif	3250	#endif
		3251	{
3103	ev_timer_again (EV_A_ &w->timer);	3252	ev_timer_again (EV_A_ &w->timer);
		3253	ev_unref (EV_A);
		3254	}
3104		3255
3105	ev_start (EV_A_ (W)w, 1);	3256	ev_start (EV_A_ (W)w, 1);
3106		3257
3107	EV_FREQUENT_CHECK;	3258	EV_FREQUENT_CHECK;
3108	}	3259	}
…		…
3117	EV_FREQUENT_CHECK;	3268	EV_FREQUENT_CHECK;
3118		3269
3119	#if EV_USE_INOTIFY	3270	#if EV_USE_INOTIFY
3120	infy_del (EV_A_ w);	3271	infy_del (EV_A_ w);
3121	#endif	3272	#endif
		3273
		3274	if (ev_is_active (&w->timer))
		3275	{
		3276	ev_ref (EV_A);
3122	ev_timer_stop (EV_A_ &w->timer);	3277	ev_timer_stop (EV_A_ &w->timer);
		3278	}
3123		3279
3124	ev_stop (EV_A_ (W)w);	3280	ev_stop (EV_A_ (W)w);
3125		3281
3126	EV_FREQUENT_CHECK;	3282	EV_FREQUENT_CHECK;
3127	}	3283	}
…		…
3172		3328
3173	EV_FREQUENT_CHECK;	3329	EV_FREQUENT_CHECK;
3174	}	3330	}
3175	#endif	3331	#endif
3176		3332
		3333	#if EV_PREPARE_ENABLE
3177	void	3334	void
3178	ev_prepare_start (EV_P_ ev_prepare *w)	3335	ev_prepare_start (EV_P_ ev_prepare *w)
3179	{	3336	{
3180	if (expect_false (ev_is_active (w)))	3337	if (expect_false (ev_is_active (w)))
3181	return;	3338	return;
…		…
3207		3364
3208	ev_stop (EV_A_ (W)w);	3365	ev_stop (EV_A_ (W)w);
3209		3366
3210	EV_FREQUENT_CHECK;	3367	EV_FREQUENT_CHECK;
3211	}	3368	}
		3369	#endif
3212		3370
		3371	#if EV_CHECK_ENABLE
3213	void	3372	void
3214	ev_check_start (EV_P_ ev_check *w)	3373	ev_check_start (EV_P_ ev_check *w)
3215	{	3374	{
3216	if (expect_false (ev_is_active (w)))	3375	if (expect_false (ev_is_active (w)))
3217	return;	3376	return;
…		…
3243		3402
3244	ev_stop (EV_A_ (W)w);	3403	ev_stop (EV_A_ (W)w);
3245		3404
3246	EV_FREQUENT_CHECK;	3405	EV_FREQUENT_CHECK;
3247	}	3406	}
		3407	#endif
3248		3408
3249	#if EV_EMBED_ENABLE	3409	#if EV_EMBED_ENABLE
3250	void noinline	3410	void noinline
3251	ev_embed_sweep (EV_P_ ev_embed *w)	3411	ev_embed_sweep (EV_P_ ev_embed *w)
3252	{	3412	{
…		…
3346	EV_FREQUENT_CHECK;	3506	EV_FREQUENT_CHECK;
3347		3507
3348	ev_io_stop (EV_A_ &w->io);	3508	ev_io_stop (EV_A_ &w->io);
3349	ev_prepare_stop (EV_A_ &w->prepare);	3509	ev_prepare_stop (EV_A_ &w->prepare);
3350	ev_fork_stop (EV_A_ &w->fork);	3510	ev_fork_stop (EV_A_ &w->fork);
		3511
		3512	ev_stop (EV_A_ (W)w);
3351		3513
3352	EV_FREQUENT_CHECK;	3514	EV_FREQUENT_CHECK;
3353	}	3515	}
3354	#endif	3516	#endif
3355		3517
…		…
3579	if (types & EV_ASYNC)	3741	if (types & EV_ASYNC)
3580	for (i = asynccnt; i--; )	3742	for (i = asynccnt; i--; )
3581	cb (EV_A_ EV_ASYNC, asyncs [i]);	3743	cb (EV_A_ EV_ASYNC, asyncs [i]);
3582	#endif	3744	#endif
3583		3745
		3746	#if EV_PREPARE_ENABLE
3584	if (types & EV_PREPARE)	3747	if (types & EV_PREPARE)
3585	for (i = preparecnt; i--; )	3748	for (i = preparecnt; i--; )
3586	#if EV_EMBED_ENABLE	3749	# if EV_EMBED_ENABLE
3587	if (ev_cb (prepares [i]) != embed_prepare_cb)	3750	if (ev_cb (prepares [i]) != embed_prepare_cb)
3588	#endif	3751	# endif
3589	cb (EV_A_ EV_PREPARE, prepares [i]);	3752	cb (EV_A_ EV_PREPARE, prepares [i]);
		3753	#endif
3590		3754
		3755	#if EV_CHECK_ENABLE
3591	if (types & EV_CHECK)	3756	if (types & EV_CHECK)
3592	for (i = checkcnt; i--; )	3757	for (i = checkcnt; i--; )
3593	cb (EV_A_ EV_CHECK, checks [i]);	3758	cb (EV_A_ EV_CHECK, checks [i]);
		3759	#endif
3594		3760
		3761	#if EV_SIGNAL_ENABLE
3595	if (types & EV_SIGNAL)	3762	if (types & EV_SIGNAL)
3596	for (i = 0; i < EV_NSIG - 1; ++i)	3763	for (i = 0; i < EV_NSIG - 1; ++i)
3597	for (wl = signals [i].head; wl; )	3764	for (wl = signals [i].head; wl; )
3598	{	3765	{
3599	wn = wl->next;	3766	wn = wl->next;
3600	cb (EV_A_ EV_SIGNAL, wl);	3767	cb (EV_A_ EV_SIGNAL, wl);
3601	wl = wn;	3768	wl = wn;
3602	}	3769	}
		3770	#endif
3603		3771
		3772	#if EV_CHILD_ENABLE
3604	if (types & EV_CHILD)	3773	if (types & EV_CHILD)
3605	for (i = EV_PID_HASHSIZE; i--; )	3774	for (i = EV_PID_HASHSIZE; i--; )
3606	for (wl = childs [i]; wl; )	3775	for (wl = childs [i]; wl; )
3607	{	3776	{
3608	wn = wl->next;	3777	wn = wl->next;
3609	cb (EV_A_ EV_CHILD, wl);	3778	cb (EV_A_ EV_CHILD, wl);
3610	wl = wn;	3779	wl = wn;
3611	}	3780	}
		3781	#endif
3612	/* EV_STAT 0x00001000 /* stat data changed */	3782	/* EV_STAT 0x00001000 /* stat data changed */
3613	/* EV_EMBED 0x00010000 /* embedded event loop needs sweep */	3783	/* EV_EMBED 0x00010000 /* embedded event loop needs sweep */
3614	}	3784	}
3615	#endif	3785	#endif
3616		3786

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.313 by root, Wed Aug 19 23:44:51 2009 UTC vs. Revision 1.337 by root, Wed Mar 10 09:18:24 2010 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.313 by root, Wed Aug 19 23:44:51 2009 UTC vs.
Revision 1.337 by root, Wed Mar 10 09:18:24 2010 UTC