[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.336 by root, Wed Mar 10 08:19:38 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	}
…		…
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);
…		…
1870		1930
1871	assert (checkmax >= checkcnt);	1931	assert (checkmax >= checkcnt);
1872	array_verify (EV_A_ (W *)checks, checkcnt);	1932	array_verify (EV_A_ (W *)checks, checkcnt);
1873		1933
1874	# if 0	1934	# if 0
		1935	#if EV_CHILD_ENABLE
1875	for (w = (ev_child )childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child )((WL)w)->next)	1936	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)	1937	for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
		1938	#endif
1877	# endif	1939	# endif
1878	#endif	1940	#endif
1879	}	1941	}
1880	#endif	1942	#endif
1881		1943
…		…
1897		1959
1898	loop_init (EV_A_ flags);	1960	loop_init (EV_A_ flags);
1899		1961
1900	if (ev_backend (EV_A))	1962	if (ev_backend (EV_A))
1901	{	1963	{
1902	#ifndef _WIN32	1964	#if EV_CHILD_ENABLE
1903	ev_signal_init (&childev, childcb, SIGCHLD);	1965	ev_signal_init (&childev, childcb, SIGCHLD);
1904	ev_set_priority (&childev, EV_MAXPRI);	1966	ev_set_priority (&childev, EV_MAXPRI);
1905	ev_signal_start (EV_A_ &childev);	1967	ev_signal_start (EV_A_ &childev);
1906	ev_unref (EV_A); /* child watcher should not keep loop alive */	1968	ev_unref (EV_A); /* child watcher should not keep loop alive */
1907	#endif	1969	#endif
…		…
1920	EV_P = ev_default_loop_ptr;	1982	EV_P = ev_default_loop_ptr;
1921	#endif	1983	#endif
1922		1984
1923	ev_default_loop_ptr = 0;	1985	ev_default_loop_ptr = 0;
1924		1986
1925	#ifndef _WIN32	1987	#if EV_CHILD_ENABLE
1926	ev_ref (EV_A); /* child watcher */	1988	ev_ref (EV_A); /* child watcher */
1927	ev_signal_stop (EV_A_ &childev);	1989	ev_signal_stop (EV_A_ &childev);
1928	#endif	1990	#endif
1929		1991
1930	loop_destroy (EV_A);	1992	loop_destroy (EV_A);
…		…
2137	ANHE_at_cache (*he);	2199	ANHE_at_cache (*he);
2138	}	2200	}
2139	}	2201	}
2140		2202
2141	/* fetch new monotonic and realtime times from the kernel */	2203	/* fetch new monotonic and realtime times from the kernel */
2142	/* also detetc if there was a timejump, and act accordingly */	2204	/* also detect if there was a timejump, and act accordingly */
2143	inline_speed void	2205	inline_speed void
2144	time_update (EV_P_ ev_tstamp max_block)	2206	time_update (EV_P_ ev_tstamp max_block)
2145	{	2207	{
2146	#if EV_USE_MONOTONIC	2208	#if EV_USE_MONOTONIC
2147	if (expect_true (have_monotonic))	2209	if (expect_true (have_monotonic))
…		…
2481		2543
2482	if (expect_false (ev_is_active (w)))	2544	if (expect_false (ev_is_active (w)))
2483	return;	2545	return;
2484		2546
2485	assert (("libev: ev_io_start called with negative fd", fd >= 0));	2547	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))));	2548	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET \| EV_READ \| EV_WRITE))));
2487		2549
2488	EV_FREQUENT_CHECK;	2550	EV_FREQUENT_CHECK;
2489		2551
2490	ev_start (EV_A_ (W)w, 1);	2552	ev_start (EV_A_ (W)w, 1);
2491	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	2553	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
…		…
2561	timers [active] = timers [timercnt + HEAP0];	2623	timers [active] = timers [timercnt + HEAP0];
2562	adjustheap (timers, timercnt, active);	2624	adjustheap (timers, timercnt, active);
2563	}	2625	}
2564	}	2626	}
2565		2627
2566	EV_FREQUENT_CHECK;
2567
2568	ev_at (w) -= mn_now;	2628	ev_at (w) -= mn_now;
2569		2629
2570	ev_stop (EV_A_ (W)w);	2630	ev_stop (EV_A_ (W)w);
		2631
		2632	EV_FREQUENT_CHECK;
2571	}	2633	}
2572		2634
2573	void noinline	2635	void noinline
2574	ev_timer_again (EV_P_ ev_timer *w)	2636	ev_timer_again (EV_P_ ev_timer *w)
2575	{	2637	{
…		…
2654	periodics [active] = periodics [periodiccnt + HEAP0];	2716	periodics [active] = periodics [periodiccnt + HEAP0];
2655	adjustheap (periodics, periodiccnt, active);	2717	adjustheap (periodics, periodiccnt, active);
2656	}	2718	}
2657	}	2719	}
2658		2720
2659	EV_FREQUENT_CHECK;
2660
2661	ev_stop (EV_A_ (W)w);	2721	ev_stop (EV_A_ (W)w);
		2722
		2723	EV_FREQUENT_CHECK;
2662	}	2724	}
2663		2725
2664	void noinline	2726	void noinline
2665	ev_periodic_again (EV_P_ ev_periodic *w)	2727	ev_periodic_again (EV_P_ ev_periodic *w)
2666	{	2728	{
…		…
2671	#endif	2733	#endif
2672		2734
2673	#ifndef SA_RESTART	2735	#ifndef SA_RESTART
2674	# define SA_RESTART 0	2736	# define SA_RESTART 0
2675	#endif	2737	#endif
		2738
		2739	#if EV_SIGNAL_ENABLE
2676		2740
2677	void noinline	2741	void noinline
2678	ev_signal_start (EV_P_ ev_signal *w)	2742	ev_signal_start (EV_P_ ev_signal *w)
2679	{	2743	{
2680	if (expect_false (ev_is_active (w)))	2744	if (expect_false (ev_is_active (w)))
…		…
2727	if (!((WL)w)->next)	2791	if (!((WL)w)->next)
2728	# if EV_USE_SIGNALFD	2792	# if EV_USE_SIGNALFD
2729	if (sigfd < 0) /TODO/	2793	if (sigfd < 0) /TODO/
2730	# endif	2794	# endif
2731	{	2795	{
2732	# if _WIN32	2796	# ifdef _WIN32
		2797	evpipe_init (EV_A);
		2798
2733	signal (w->signum, ev_sighandler);	2799	signal (w->signum, ev_sighandler);
2734	# else	2800	# else
2735	struct sigaction sa;	2801	struct sigaction sa;
2736		2802
2737	evpipe_init (EV_A);	2803	evpipe_init (EV_A);
…		…
2768	signals [w->signum - 1].loop = 0; /* unattach from signal */	2834	signals [w->signum - 1].loop = 0; /* unattach from signal */
2769	#endif	2835	#endif
2770	#if EV_USE_SIGNALFD	2836	#if EV_USE_SIGNALFD
2771	if (sigfd >= 0)	2837	if (sigfd >= 0)
2772	{	2838	{
2773	sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D	2839	sigset_t ss;
		2840
		2841	sigemptyset (&ss);
		2842	sigaddset (&ss, w->signum);
2774	sigdelset (&sigfd_set, w->signum);	2843	sigdelset (&sigfd_set, w->signum);
		2844
2775	signalfd (sigfd, &sigfd_set, 0);	2845	signalfd (sigfd, &sigfd_set, 0);
2776	sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D	2846	sigprocmask (SIG_UNBLOCK, &ss, 0);
2777	/TODO: maybe unblock signal? /
2778	}	2847	}
2779	else	2848	else
2780	#endif	2849	#endif
2781	signal (w->signum, SIG_DFL);	2850	signal (w->signum, SIG_DFL);
2782	}	2851	}
2783		2852
2784	EV_FREQUENT_CHECK;	2853	EV_FREQUENT_CHECK;
2785	}	2854	}
		2855
		2856	#endif
		2857
		2858	#if EV_CHILD_ENABLE
2786		2859
2787	void	2860	void
2788	ev_child_start (EV_P_ ev_child *w)	2861	ev_child_start (EV_P_ ev_child *w)
2789	{	2862	{
2790	#if EV_MULTIPLICITY	2863	#if EV_MULTIPLICITY
…		…
2814	ev_stop (EV_A_ (W)w);	2887	ev_stop (EV_A_ (W)w);
2815		2888
2816	EV_FREQUENT_CHECK;	2889	EV_FREQUENT_CHECK;
2817	}	2890	}
2818		2891
		2892	#endif
		2893
2819	#if EV_STAT_ENABLE	2894	#if EV_STAT_ENABLE
2820		2895
2821	# ifdef _WIN32	2896	# ifdef _WIN32
2822	# undef lstat	2897	# undef lstat
2823	# define lstat(a,b) _stati64 (a,b)	2898	# define lstat(a,b) _stati64 (a,b)
…		…
2828	#define MIN_STAT_INTERVAL 0.1074891	2903	#define MIN_STAT_INTERVAL 0.1074891
2829		2904
2830	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	2905	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
2831		2906
2832	#if EV_USE_INOTIFY	2907	#if EV_USE_INOTIFY
2833	# define EV_INOTIFY_BUFSIZE 8192	2908
		2909	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
		2910	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
2834		2911
2835	static void noinline	2912	static void noinline
2836	infy_add (EV_P_ ev_stat *w)	2913	infy_add (EV_P_ ev_stat *w)
2837	{	2914	{
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);	2915	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		2916
2840	if (w->wd < 0)	2917	if (w->wd >= 0)
		2918	{
		2919	struct statfs sfs;
		2920
		2921	/* now local changes will be tracked by inotify, but remote changes won't */
		2922	/* unless the filesystem is known to be local, we therefore still poll */
		2923	/* also do poll on <2.6.25, but with normal frequency */
		2924
		2925	if (!fs_2625)
		2926	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		2927	else if (!statfs (w->path, &sfs)
		2928	&& (sfs.f_type == 0x1373 /* devfs */
		2929	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
		2930	\|\| sfs.f_type == 0x3153464a /* jfs */
		2931	\|\| sfs.f_type == 0x52654973 /* reiser3 */
		2932	\|\| sfs.f_type == 0x01021994 /* tempfs */
		2933	\|\| sfs.f_type == 0x58465342 /* xfs */))
		2934	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
		2935	else
		2936	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
2841	{	2937	}
		2938	else
		2939	{
		2940	/* can't use inotify, continue to stat */
2842	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	2941	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		2942
2845	/* monitor some parent directory for speedup hints */	2943	/* 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, */	2944	/* note that exceeding the hardcoded path limit is not a correctness issue, */
2847	/* but an efficiency issue only */	2945	/* but an efficiency issue only */
2848	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)	2946	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)
2849	{	2947	{
2850	char path [4096];	2948	char path [4096];
…		…
2866	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));	2964	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));
2867	}	2965	}
2868	}	2966	}
2869		2967
2870	if (w->wd >= 0)	2968	if (w->wd >= 0)
2871	{
2872	struct statfs sfs;
2873
2874	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);	2969	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
2875		2970
2876	/* now local changes will be tracked by inotify, but remote changes won't */	2971	/* now re-arm timer, if required */
2877	/* unless the filesystem it known to be local, we therefore still poll */	2972	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);	2973	ev_timer_again (EV_A_ &w->timer);
2891	}	2974	if (ev_is_active (&w->timer)) ev_unref (EV_A);
2892	}	2975	}
2893		2976
2894	static void noinline	2977	static void noinline
2895	infy_del (EV_P_ ev_stat *w)	2978	infy_del (EV_P_ ev_stat *w)
2896	{	2979	{
…		…
2941		3024
2942	static void	3025	static void
2943	infy_cb (EV_P_ ev_io *w, int revents)	3026	infy_cb (EV_P_ ev_io *w, int revents)
2944	{	3027	{
2945	char buf [EV_INOTIFY_BUFSIZE];	3028	char buf [EV_INOTIFY_BUFSIZE];
2946	struct inotify_event ev = (struct inotify_event )buf;
2947	int ofs;	3029	int ofs;
2948	int len = read (fs_fd, buf, sizeof (buf));	3030	int len = read (fs_fd, buf, sizeof (buf));
2949		3031
2950	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)	3032	for (ofs = 0; ofs < len; )
		3033	{
		3034	struct inotify_event ev = (struct inotify_event )(buf + ofs);
2951	infy_wd (EV_A_ ev->wd, ev->wd, ev);	3035	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		3036	ofs += sizeof (struct inotify_event) + ev->len;
		3037	}
		3038	}
		3039
		3040	inline_size unsigned int
		3041	ev_linux_version (void)
		3042	{
		3043	struct utsname buf;
		3044	unsigned int v;
		3045	int i;
		3046	char *p = buf.release;
		3047
		3048	if (uname (&buf))
		3049	return 0;
		3050
		3051	for (i = 3+1; --i; )
		3052	{
		3053	unsigned int c = 0;
		3054
		3055	for (;;)
		3056	{
		3057	if (p >= '0' && p <= '9')
		3058	c = c * 10 + *p++ - '0';
		3059	else
		3060	{
		3061	p += *p == '.';
		3062	break;
		3063	}
		3064	}
		3065
		3066	v = (v << 8) \| c;
		3067	}
		3068
		3069	return v;
2952	}	3070	}
2953		3071
2954	inline_size void	3072	inline_size void
2955	check_2625 (EV_P)	3073	ev_check_2625 (EV_P)
2956	{	3074	{
2957	/* kernels < 2.6.25 are borked	3075	/* kernels < 2.6.25 are borked
2958	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	3076	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2959	*/	3077	*/
2960	struct utsname buf;	3078	if (ev_linux_version () < 0x020619)
2961	int major, minor, micro;
2962
2963	if (uname (&buf))
2964	return;	3079	return;
2965		3080
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;	3081	fs_2625 = 1;
		3082	}
		3083
		3084	inline_size int
		3085	infy_newfd (void)
		3086	{
		3087	#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK)
		3088	int fd = inotify_init1 (IN_CLOEXEC \| IN_NONBLOCK);
		3089	if (fd >= 0)
		3090	return fd;
		3091	#endif
		3092	return inotify_init ();
2975	}	3093	}
2976		3094
2977	inline_size void	3095	inline_size void
2978	infy_init (EV_P)	3096	infy_init (EV_P)
2979	{	3097	{
2980	if (fs_fd != -2)	3098	if (fs_fd != -2)
2981	return;	3099	return;
2982		3100
2983	fs_fd = -1;	3101	fs_fd = -1;
2984		3102
2985	check_2625 (EV_A);	3103	ev_check_2625 (EV_A);
2986		3104
2987	fs_fd = inotify_init ();	3105	fs_fd = infy_newfd ();
2988		3106
2989	if (fs_fd >= 0)	3107	if (fs_fd >= 0)
2990	{	3108	{
		3109	fd_intern (fs_fd);
2991	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);	3110	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
2992	ev_set_priority (&fs_w, EV_MAXPRI);	3111	ev_set_priority (&fs_w, EV_MAXPRI);
2993	ev_io_start (EV_A_ &fs_w);	3112	ev_io_start (EV_A_ &fs_w);
		3113	ev_unref (EV_A);
2994	}	3114	}
2995	}	3115	}
2996		3116
2997	inline_size void	3117	inline_size void
2998	infy_fork (EV_P)	3118	infy_fork (EV_P)
…		…
3000	int slot;	3120	int slot;
3001		3121
3002	if (fs_fd < 0)	3122	if (fs_fd < 0)
3003	return;	3123	return;
3004		3124
		3125	ev_ref (EV_A);
		3126	ev_io_stop (EV_A_ &fs_w);
3005	close (fs_fd);	3127	close (fs_fd);
3006	fs_fd = inotify_init ();	3128	fs_fd = infy_newfd ();
		3129
		3130	if (fs_fd >= 0)
		3131	{
		3132	fd_intern (fs_fd);
		3133	ev_io_set (&fs_w, fs_fd, EV_READ);
		3134	ev_io_start (EV_A_ &fs_w);
		3135	ev_unref (EV_A);
		3136	}
3007		3137
3008	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)	3138	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
3009	{	3139	{
3010	WL w_ = fs_hash [slot].head;	3140	WL w_ = fs_hash [slot].head;
3011	fs_hash [slot].head = 0;	3141	fs_hash [slot].head = 0;
…		…
3018	w->wd = -1;	3148	w->wd = -1;
3019		3149
3020	if (fs_fd >= 0)	3150	if (fs_fd >= 0)
3021	infy_add (EV_A_ w); /* re-add, no matter what */	3151	infy_add (EV_A_ w); /* re-add, no matter what */
3022	else	3152	else
		3153	{
		3154	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		3155	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3023	ev_timer_again (EV_A_ &w->timer);	3156	ev_timer_again (EV_A_ &w->timer);
		3157	if (ev_is_active (&w->timer)) ev_unref (EV_A);
		3158	}
3024	}	3159	}
3025	}	3160	}
3026	}	3161	}
3027		3162
3028	#endif	3163	#endif
…		…
3045	static void noinline	3180	static void noinline
3046	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	3181	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3047	{	3182	{
3048	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));	3183	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));
3049		3184
3050	/* we copy this here each the time so that */	3185	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);	3186	ev_stat_stat (EV_A_ w);
3054		3187
3055	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */	3188	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
3056	if (	3189	if (
3057	w->prev.st_dev != w->attr.st_dev	3190	prev.st_dev != w->attr.st_dev
3058	\|\| w->prev.st_ino != w->attr.st_ino	3191	\|\| prev.st_ino != w->attr.st_ino
3059	\|\| w->prev.st_mode != w->attr.st_mode	3192	\|\| prev.st_mode != w->attr.st_mode
3060	\|\| w->prev.st_nlink != w->attr.st_nlink	3193	\|\| prev.st_nlink != w->attr.st_nlink
3061	\|\| w->prev.st_uid != w->attr.st_uid	3194	\|\| prev.st_uid != w->attr.st_uid
3062	\|\| w->prev.st_gid != w->attr.st_gid	3195	\|\| prev.st_gid != w->attr.st_gid
3063	\|\| w->prev.st_rdev != w->attr.st_rdev	3196	\|\| prev.st_rdev != w->attr.st_rdev
3064	\|\| w->prev.st_size != w->attr.st_size	3197	\|\| prev.st_size != w->attr.st_size
3065	\|\| w->prev.st_atime != w->attr.st_atime	3198	\|\| prev.st_atime != w->attr.st_atime
3066	\|\| w->prev.st_mtime != w->attr.st_mtime	3199	\|\| prev.st_mtime != w->attr.st_mtime
3067	\|\| w->prev.st_ctime != w->attr.st_ctime	3200	\|\| prev.st_ctime != w->attr.st_ctime
3068	) {	3201	) {
		3202	/* we only update w->prev on actual differences */
		3203	/* in case we test more often than invoke the callback, */
		3204	/* to ensure that prev is always different to attr */
		3205	w->prev = prev;
		3206
3069	#if EV_USE_INOTIFY	3207	#if EV_USE_INOTIFY
3070	if (fs_fd >= 0)	3208	if (fs_fd >= 0)
3071	{	3209	{
3072	infy_del (EV_A_ w);	3210	infy_del (EV_A_ w);
3073	infy_add (EV_A_ w);	3211	infy_add (EV_A_ w);
…		…
3098		3236
3099	if (fs_fd >= 0)	3237	if (fs_fd >= 0)
3100	infy_add (EV_A_ w);	3238	infy_add (EV_A_ w);
3101	else	3239	else
3102	#endif	3240	#endif
		3241	{
3103	ev_timer_again (EV_A_ &w->timer);	3242	ev_timer_again (EV_A_ &w->timer);
		3243	ev_unref (EV_A);
		3244	}
3104		3245
3105	ev_start (EV_A_ (W)w, 1);	3246	ev_start (EV_A_ (W)w, 1);
3106		3247
3107	EV_FREQUENT_CHECK;	3248	EV_FREQUENT_CHECK;
3108	}	3249	}
…		…
3117	EV_FREQUENT_CHECK;	3258	EV_FREQUENT_CHECK;
3118		3259
3119	#if EV_USE_INOTIFY	3260	#if EV_USE_INOTIFY
3120	infy_del (EV_A_ w);	3261	infy_del (EV_A_ w);
3121	#endif	3262	#endif
		3263
		3264	if (ev_is_active (&w->timer))
		3265	{
		3266	ev_ref (EV_A);
3122	ev_timer_stop (EV_A_ &w->timer);	3267	ev_timer_stop (EV_A_ &w->timer);
		3268	}
3123		3269
3124	ev_stop (EV_A_ (W)w);	3270	ev_stop (EV_A_ (W)w);
3125		3271
3126	EV_FREQUENT_CHECK;	3272	EV_FREQUENT_CHECK;
3127	}	3273	}
…		…
3346	EV_FREQUENT_CHECK;	3492	EV_FREQUENT_CHECK;
3347		3493
3348	ev_io_stop (EV_A_ &w->io);	3494	ev_io_stop (EV_A_ &w->io);
3349	ev_prepare_stop (EV_A_ &w->prepare);	3495	ev_prepare_stop (EV_A_ &w->prepare);
3350	ev_fork_stop (EV_A_ &w->fork);	3496	ev_fork_stop (EV_A_ &w->fork);
		3497
		3498	ev_stop (EV_A_ (W)w);
3351		3499
3352	EV_FREQUENT_CHECK;	3500	EV_FREQUENT_CHECK;
3353	}	3501	}
3354	#endif	3502	#endif
3355		3503

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.336 by root, Wed Mar 10 08:19:38 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.336 by root, Wed Mar 10 08:19:38 2010 UTC