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

Comparing libev/ev.c (file contents):
Revision 1.307 by root, Sun Jul 19 07:20:41 2009 UTC vs.
Revision 1.334 by root, Tue Mar 9 09:00:59 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 */
…		…
302	# define EV_USE_EVENTFD 0	305	# define EV_USE_EVENTFD 0
303	# endif	306	# endif
304	#endif	307	#endif
305		308
306	#ifndef EV_USE_SIGNALFD	309	#ifndef EV_USE_SIGNALFD
307	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 9))	310	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
308	# define EV_USE_SIGNALFD 1	311	# define EV_USE_SIGNALFD 1
309	# else	312	# else
310	# define EV_USE_SIGNALFD 0	313	# define EV_USE_SIGNALFD 0
311	# endif	314	# endif
312	#endif	315	#endif
…		…
343	# endif	346	# endif
344	#endif	347	#endif
345		348
346	/* this block fixes any misconfiguration where we know we run into trouble otherwise */	349	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
347		350
		351	#ifdef _AIX
		352	/* AIX has a completely broken poll.h header */
		353	# undef EV_USE_POLL
		354	# define EV_USE_POLL 0
		355	#endif
		356
348	#ifndef CLOCK_MONOTONIC	357	#ifndef CLOCK_MONOTONIC
349	# undef EV_USE_MONOTONIC	358	# undef EV_USE_MONOTONIC
350	# define EV_USE_MONOTONIC 0	359	# define EV_USE_MONOTONIC 0
351	#endif	360	#endif
352		361
…		…
386	# include <stdint.h>	395	# include <stdint.h>
387	# ifndef EFD_NONBLOCK	396	# ifndef EFD_NONBLOCK
388	# define EFD_NONBLOCK O_NONBLOCK	397	# define EFD_NONBLOCK O_NONBLOCK
389	# endif	398	# endif
390	# ifndef EFD_CLOEXEC	399	# ifndef EFD_CLOEXEC
		400	# ifdef O_CLOEXEC
391	# define EFD_CLOEXEC O_CLOEXEC	401	# define EFD_CLOEXEC O_CLOEXEC
		402	# else
		403	# define EFD_CLOEXEC 02000000
		404	# endif
392	# endif	405	# endif
393	# ifdef __cplusplus	406	# ifdef __cplusplus
394	extern "C" {	407	extern "C" {
395	# endif	408	# endif
396	int eventfd (unsigned int initval, int flags);	409	int (eventfd) (unsigned int initval, int flags);
397	# ifdef __cplusplus	410	# ifdef __cplusplus
398	}	411	}
399	# endif	412	# endif
400	#endif	413	#endif
401		414
402	#if EV_USE_SIGNALFD	415	#if EV_USE_SIGNALFD
403	# include <sys/signalfd.h>	416	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
		417	# include <stdint.h>
		418	# ifndef SFD_NONBLOCK
		419	# define SFD_NONBLOCK O_NONBLOCK
404	#endif	420	# endif
		421	# ifndef SFD_CLOEXEC
		422	# ifdef O_CLOEXEC
		423	# define SFD_CLOEXEC O_CLOEXEC
		424	# else
		425	# define SFD_CLOEXEC 02000000
		426	# endif
		427	# endif
		428	# ifdef __cplusplus
		429	extern "C" {
		430	# endif
		431	int signalfd (int fd, const sigset_t *mask, int flags);
		432
		433	struct signalfd_siginfo
		434	{
		435	uint32_t ssi_signo;
		436	char pad[128 - sizeof (uint32_t)];
		437	};
		438	# ifdef __cplusplus
		439	}
		440	# endif
		441	#endif
		442
405		443
406	/**/	444	/**/
407		445
408	#if EV_VERIFY >= 3	446	#if EV_VERIFY >= 3
409	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)	447	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
…		…
421	*/	459	*/
422	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */	460	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */
423		461
424	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	462	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
425	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	463	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
426	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds, TODO */
427		464
428	#if __GNUC__ >= 4	465	#if __GNUC__ >= 4
429	# define expect(expr,value) __builtin_expect ((expr),(value))	466	# define expect(expr,value) __builtin_expect ((expr),(value))
430	# define noinline __attribute__ ((noinline))	467	# define noinline __attribute__ ((noinline))
431	#else	468	#else
…		…
472		509
473	#if EV_USE_MONOTONIC	510	#if EV_USE_MONOTONIC
474	static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */	511	static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
475	#endif	512	#endif
476		513
		514	#ifndef EV_FD_TO_WIN32_HANDLE
		515	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
		516	#endif
		517	#ifndef EV_WIN32_HANDLE_TO_FD
		518	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
		519	#endif
		520	#ifndef EV_WIN32_CLOSE_FD
		521	# define EV_WIN32_CLOSE_FD(fd) close (fd)
		522	#endif
		523
477	#ifdef _WIN32	524	#ifdef _WIN32
478	# include "ev_win32.c"	525	# include "ev_win32.c"
479	#endif	526	#endif
480		527
481	/*****************************************************************************/	528	/*****************************************************************************/
		529
		530	#if EV_AVOID_STDIO
		531	static void noinline
		532	ev_printerr (const char *msg)
		533	{
		534	write (STDERR_FILENO, msg, strlen (msg));
		535	}
		536	#endif
482		537
483	static void (syserr_cb)(const char msg);	538	static void (syserr_cb)(const char msg);
484		539
485	void	540	void
486	ev_set_syserr_cb (void (cb)(const char msg))	541	ev_set_syserr_cb (void (cb)(const char msg))
…		…
496		551
497	if (syserr_cb)	552	if (syserr_cb)
498	syserr_cb (msg);	553	syserr_cb (msg);
499	else	554	else
500	{	555	{
		556	#if EV_AVOID_STDIO
		557	const char *err = strerror (errno);
		558
		559	ev_printerr (msg);
		560	ev_printerr (": ");
		561	ev_printerr (err);
		562	ev_printerr ("\n");
		563	#else
501	perror (msg);	564	perror (msg);
		565	#endif
502	abort ();	566	abort ();
503	}	567	}
504	}	568	}
505		569
506	static void *	570	static void *
507	ev_realloc_emul (void *ptr, long size)	571	ev_realloc_emul (void *ptr, long size)
508	{	572	{
		573	#if __GLIBC__
		574	return realloc (ptr, size);
		575	#else
509	/* some systems, notably openbsd and darwin, fail to properly	576	/* some systems, notably openbsd and darwin, fail to properly
510	* implement realloc (x, 0) (as required by both ansi c-98 and	577	* implement realloc (x, 0) (as required by both ansi c-98 and
511	* the single unix specification, so work around them here.	578	* the single unix specification, so work around them here.
512	*/	579	*/
513		580
514	if (size)	581	if (size)
515	return realloc (ptr, size);	582	return realloc (ptr, size);
516		583
517	free (ptr);	584	free (ptr);
518	return 0;	585	return 0;
		586	#endif
519	}	587	}
520		588
521	static void (alloc)(void *ptr, long size) = ev_realloc_emul;	589	static void (alloc)(void *ptr, long size) = ev_realloc_emul;
522		590
523	void	591	void
…		…
531	{	599	{
532	ptr = alloc (ptr, size);	600	ptr = alloc (ptr, size);
533		601
534	if (!ptr && size)	602	if (!ptr && size)
535	{	603	{
		604	#if EV_AVOID_STDIO
		605	ev_printerr ("libev: memory allocation failed, aborting.\n");
		606	#else
536	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);	607	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
		608	#endif
537	abort ();	609	abort ();
538	}	610	}
539		611
540	return ptr;	612	return ptr;
541	}	613	}
…		…
872		944
873	#if EV_SELECT_IS_WINSOCKET	945	#if EV_SELECT_IS_WINSOCKET
874	if (events)	946	if (events)
875	{	947	{
876	unsigned long arg;	948	unsigned long arg;
877	#ifdef EV_FD_TO_WIN32_HANDLE
878	anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);	949	anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
879	#else
880	anfd->handle = _get_osfhandle (fd);
881	#endif
882	assert (("libev: only socket fds supported in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));	950	assert (("libev: only socket fds supported in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
883	}	951	}
884	#endif	952	#endif
885		953
886	{	954	{
…		…
929	/* check whether the given fd is atcually valid, for error recovery */	997	/* check whether the given fd is atcually valid, for error recovery */
930	inline_size int	998	inline_size int
931	fd_valid (int fd)	999	fd_valid (int fd)
932	{	1000	{
933	#ifdef _WIN32	1001	#ifdef _WIN32
934	return _get_osfhandle (fd) != -1;	1002	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
935	#else	1003	#else
936	return fcntl (fd, F_GETFD) != -1;	1004	return fcntl (fd, F_GETFD) != -1;
937	#endif	1005	#endif
938	}	1006	}
939		1007
…		…
1057		1125
1058	for (;;)	1126	for (;;)
1059	{	1127	{
1060	int c = k << 1;	1128	int c = k << 1;
1061		1129
1062	if (c > N + HEAP0 - 1)	1130	if (c >= N + HEAP0)
1063	break;	1131	break;
1064		1132
1065	c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])	1133	c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
1066	? 1 : 0;	1134	? 1 : 0;
1067		1135
…		…
1103		1171
1104	/* move an element suitably so it is in a correct place */	1172	/* move an element suitably so it is in a correct place */
1105	inline_size void	1173	inline_size void
1106	adjustheap (ANHE *heap, int N, int k)	1174	adjustheap (ANHE *heap, int N, int k)
1107	{	1175	{
1108	if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k]))	1176	if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)]))
1109	upheap (heap, k);	1177	upheap (heap, k);
1110	else	1178	else
1111	downheap (heap, N, k);	1179	downheap (heap, N, k);
1112	}	1180	}
1113		1181
…		…
1144	inline_speed void	1212	inline_speed void
1145	fd_intern (int fd)	1213	fd_intern (int fd)
1146	{	1214	{
1147	#ifdef _WIN32	1215	#ifdef _WIN32
1148	unsigned long arg = 1;	1216	unsigned long arg = 1;
1149	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);	1217	ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
1150	#else	1218	#else
1151	fcntl (fd, F_SETFD, FD_CLOEXEC);	1219	fcntl (fd, F_SETFD, FD_CLOEXEC);
1152	fcntl (fd, F_SETFL, O_NONBLOCK);	1220	fcntl (fd, F_SETFL, O_NONBLOCK);
1153	#endif	1221	#endif
1154	}	1222	}
…		…
1259	{	1327	{
1260	#if EV_MULTIPLICITY	1328	#if EV_MULTIPLICITY
1261	EV_P = signals [signum - 1].loop;	1329	EV_P = signals [signum - 1].loop;
1262	#endif	1330	#endif
1263		1331
1264	#if _WIN32	1332	#ifdef _WIN32
1265	signal (signum, ev_sighandler);	1333	signal (signum, ev_sighandler);
1266	#endif	1334	#endif
1267		1335
1268	signals [signum - 1].pending = 1;	1336	signals [signum - 1].pending = 1;
1269	evpipe_write (EV_A_ &sig_pending);	1337	evpipe_write (EV_A_ &sig_pending);
…		…
1570	#endif	1638	#endif
1571	#if EV_USE_INOTIFY	1639	#if EV_USE_INOTIFY
1572	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	1640	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
1573	#endif	1641	#endif
1574	#if EV_USE_SIGNALFD	1642	#if EV_USE_SIGNALFD
1575	sigfd = flags & EVFLAG_NOSIGFD ? -1 : -2;	1643	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
1576	#endif	1644	#endif
1577		1645
1578	if (!(flags & 0x0000ffffU))	1646	if (!(flags & 0x0000ffffU))
1579	flags \|= ev_recommended_backends ();	1647	flags \|= ev_recommended_backends ();
1580		1648
…		…
1617	close (evfd);	1685	close (evfd);
1618	#endif	1686	#endif
1619		1687
1620	if (evpipe [0] >= 0)	1688	if (evpipe [0] >= 0)
1621	{	1689	{
1622	close (evpipe [0]);	1690	EV_WIN32_CLOSE_FD (evpipe [0]);
1623	close (evpipe [1]);	1691	EV_WIN32_CLOSE_FD (evpipe [1]);
1624	}	1692	}
1625	}	1693	}
1626		1694
1627	#if EV_USE_SIGNALFD	1695	#if EV_USE_SIGNALFD
1628	if (ev_is_active (&sigfd_w))	1696	if (ev_is_active (&sigfd_w))
1629	{
1630	/ev_ref (EV_A);/
1631	/ev_io_stop (EV_A_ &sigfd_w);/
1632
1633	close (sigfd);	1697	close (sigfd);
1634	}
1635	#endif	1698	#endif
1636		1699
1637	#if EV_USE_INOTIFY	1700	#if EV_USE_INOTIFY
1638	if (fs_fd >= 0)	1701	if (fs_fd >= 0)
1639	close (fs_fd);	1702	close (fs_fd);
…		…
1724	close (evfd);	1787	close (evfd);
1725	#endif	1788	#endif
1726		1789
1727	if (evpipe [0] >= 0)	1790	if (evpipe [0] >= 0)
1728	{	1791	{
1729	close (evpipe [0]);	1792	EV_WIN32_CLOSE_FD (evpipe [0]);
1730	close (evpipe [1]);	1793	EV_WIN32_CLOSE_FD (evpipe [1]);
1731	}	1794	}
1732		1795
1733	evpipe_init (EV_A);	1796	evpipe_init (EV_A);
1734	/* now iterate over everything, in case we missed something */	1797	/* now iterate over everything, in case we missed something */
1735	pipecb (EV_A_ &pipe_w, EV_READ);	1798	pipecb (EV_A_ &pipe_w, EV_READ);
…		…
2127	ANHE_at_cache (*he);	2190	ANHE_at_cache (*he);
2128	}	2191	}
2129	}	2192	}
2130		2193
2131	/* fetch new monotonic and realtime times from the kernel */	2194	/* fetch new monotonic and realtime times from the kernel */
2132	/* also detetc if there was a timejump, and act accordingly */	2195	/* also detect if there was a timejump, and act accordingly */
2133	inline_speed void	2196	inline_speed void
2134	time_update (EV_P_ ev_tstamp max_block)	2197	time_update (EV_P_ ev_tstamp max_block)
2135	{	2198	{
2136	#if EV_USE_MONOTONIC	2199	#if EV_USE_MONOTONIC
2137	if (expect_true (have_monotonic))	2200	if (expect_true (have_monotonic))
…		…
2471		2534
2472	if (expect_false (ev_is_active (w)))	2535	if (expect_false (ev_is_active (w)))
2473	return;	2536	return;
2474		2537
2475	assert (("libev: ev_io_start called with negative fd", fd >= 0));	2538	assert (("libev: ev_io_start called with negative fd", fd >= 0));
2476	assert (("libev: ev_io start called with illegal event mask", !(w->events & ~(EV__IOFDSET \| EV_READ \| EV_WRITE))));	2539	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET \| EV_READ \| EV_WRITE))));
2477		2540
2478	EV_FREQUENT_CHECK;	2541	EV_FREQUENT_CHECK;
2479		2542
2480	ev_start (EV_A_ (W)w, 1);	2543	ev_start (EV_A_ (W)w, 1);
2481	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	2544	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
…		…
2551	timers [active] = timers [timercnt + HEAP0];	2614	timers [active] = timers [timercnt + HEAP0];
2552	adjustheap (timers, timercnt, active);	2615	adjustheap (timers, timercnt, active);
2553	}	2616	}
2554	}	2617	}
2555		2618
2556	EV_FREQUENT_CHECK;
2557
2558	ev_at (w) -= mn_now;	2619	ev_at (w) -= mn_now;
2559		2620
2560	ev_stop (EV_A_ (W)w);	2621	ev_stop (EV_A_ (W)w);
		2622
		2623	EV_FREQUENT_CHECK;
2561	}	2624	}
2562		2625
2563	void noinline	2626	void noinline
2564	ev_timer_again (EV_P_ ev_timer *w)	2627	ev_timer_again (EV_P_ ev_timer *w)
2565	{	2628	{
…		…
2644	periodics [active] = periodics [periodiccnt + HEAP0];	2707	periodics [active] = periodics [periodiccnt + HEAP0];
2645	adjustheap (periodics, periodiccnt, active);	2708	adjustheap (periodics, periodiccnt, active);
2646	}	2709	}
2647	}	2710	}
2648		2711
2649	EV_FREQUENT_CHECK;
2650
2651	ev_stop (EV_A_ (W)w);	2712	ev_stop (EV_A_ (W)w);
		2713
		2714	EV_FREQUENT_CHECK;
2652	}	2715	}
2653		2716
2654	void noinline	2717	void noinline
2655	ev_periodic_again (EV_P_ ev_periodic *w)	2718	ev_periodic_again (EV_P_ ev_periodic *w)
2656	{	2719	{
…		…
2671	return;	2734	return;
2672		2735
2673	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	2736	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
2674		2737
2675	#if EV_MULTIPLICITY	2738	#if EV_MULTIPLICITY
2676	assert (("libev: tried to attach to a signal from two different loops",	2739	assert (("libev: a signal must not be attached to two different loops",
2677	!signals [w->signum - 1].loop \|\| signals [w->signum - 1].loop == loop));	2740	!signals [w->signum - 1].loop \|\| signals [w->signum - 1].loop == loop));
2678		2741
2679	signals [w->signum - 1].loop = EV_A;	2742	signals [w->signum - 1].loop = EV_A;
2680	#endif	2743	#endif
2681		2744
…		…
2717	if (!((WL)w)->next)	2780	if (!((WL)w)->next)
2718	# if EV_USE_SIGNALFD	2781	# if EV_USE_SIGNALFD
2719	if (sigfd < 0) /TODO/	2782	if (sigfd < 0) /TODO/
2720	# endif	2783	# endif
2721	{	2784	{
2722	# if _WIN32	2785	# ifdef _WIN32
		2786	evpipe_init (EV_A);
		2787
2723	signal (w->signum, ev_sighandler);	2788	signal (w->signum, ev_sighandler);
2724	# else	2789	# else
2725	struct sigaction sa;	2790	struct sigaction sa;
2726		2791
2727	evpipe_init (EV_A);	2792	evpipe_init (EV_A);
…		…
2758	signals [w->signum - 1].loop = 0; /* unattach from signal */	2823	signals [w->signum - 1].loop = 0; /* unattach from signal */
2759	#endif	2824	#endif
2760	#if EV_USE_SIGNALFD	2825	#if EV_USE_SIGNALFD
2761	if (sigfd >= 0)	2826	if (sigfd >= 0)
2762	{	2827	{
2763	sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D	2828	sigset_t ss;
		2829
		2830	sigemptyset (&ss);
		2831	sigaddset (&ss, w->signum);
2764	sigdelset (&sigfd_set, w->signum);	2832	sigdelset (&sigfd_set, w->signum);
		2833
2765	signalfd (sigfd, &sigfd_set, 0);	2834	signalfd (sigfd, &sigfd_set, 0);
2766	sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D	2835	sigprocmask (SIG_UNBLOCK, &ss, 0);
2767	/TODO: maybe unblock signal? /
2768	}	2836	}
2769	else	2837	else
2770	#endif	2838	#endif
2771	signal (w->signum, SIG_DFL);	2839	signal (w->signum, SIG_DFL);
2772	}	2840	}
…		…
2818	#define MIN_STAT_INTERVAL 0.1074891	2886	#define MIN_STAT_INTERVAL 0.1074891
2819		2887
2820	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	2888	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
2821		2889
2822	#if EV_USE_INOTIFY	2890	#if EV_USE_INOTIFY
2823	# define EV_INOTIFY_BUFSIZE 8192	2891
		2892	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
		2893	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
2824		2894
2825	static void noinline	2895	static void noinline
2826	infy_add (EV_P_ ev_stat *w)	2896	infy_add (EV_P_ ev_stat *w)
2827	{	2897	{
2828	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);	2898	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);
2829		2899
2830	if (w->wd < 0)	2900	if (w->wd >= 0)
		2901	{
		2902	struct statfs sfs;
		2903
		2904	/* now local changes will be tracked by inotify, but remote changes won't */
		2905	/* unless the filesystem is known to be local, we therefore still poll */
		2906	/* also do poll on <2.6.25, but with normal frequency */
		2907
		2908	if (!fs_2625)
		2909	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		2910	else if (!statfs (w->path, &sfs)
		2911	&& (sfs.f_type == 0x1373 /* devfs */
		2912	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
		2913	\|\| sfs.f_type == 0x3153464a /* jfs */
		2914	\|\| sfs.f_type == 0x52654973 /* reiser3 */
		2915	\|\| sfs.f_type == 0x01021994 /* tempfs */
		2916	\|\| sfs.f_type == 0x58465342 /* xfs */))
		2917	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
		2918	else
		2919	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
2831	{	2920	}
		2921	else
		2922	{
		2923	/* can't use inotify, continue to stat */
2832	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	2924	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
2833	ev_timer_again (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
2834		2925
2835	/* monitor some parent directory for speedup hints */	2926	/* if path is not there, monitor some parent directory for speedup hints */
2836	/* note that exceeding the hardcoded path limit is not a correctness issue, */	2927	/* note that exceeding the hardcoded path limit is not a correctness issue, */
2837	/* but an efficiency issue only */	2928	/* but an efficiency issue only */
2838	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)	2929	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)
2839	{	2930	{
2840	char path [4096];	2931	char path [4096];
…		…
2856	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));	2947	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));
2857	}	2948	}
2858	}	2949	}
2859		2950
2860	if (w->wd >= 0)	2951	if (w->wd >= 0)
2861	{
2862	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);	2952	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
2863		2953
2864	/* now local changes will be tracked by inotify, but remote changes won't */	2954	/* now re-arm timer, if required */
2865	/* unless the filesystem it known to be local, we therefore still poll */	2955	if (ev_is_active (&w->timer)) ev_ref (EV_A);
2866	/* also do poll on <2.6.25, but with normal frequency */
2867	struct statfs sfs;
2868
2869	if (fs_2625 && !statfs (w->path, &sfs))
2870	if (sfs.f_type == 0x1373 /* devfs */
2871	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
2872	\|\| sfs.f_type == 0x3153464a /* jfs */
2873	\|\| sfs.f_type == 0x52654973 /* reiser3 */
2874	\|\| sfs.f_type == 0x01021994 /* tempfs */
2875	\|\| sfs.f_type == 0x58465342 /* xfs */)
2876	return;
2877
2878	w->timer.repeat = w->interval ? w->interval : fs_2625 ? NFS_STAT_INTERVAL : DEF_STAT_INTERVAL;
2879	ev_timer_again (EV_A_ &w->timer);	2956	ev_timer_again (EV_A_ &w->timer);
2880	}	2957	if (ev_is_active (&w->timer)) ev_unref (EV_A);
2881	}	2958	}
2882		2959
2883	static void noinline	2960	static void noinline
2884	infy_del (EV_P_ ev_stat *w)	2961	infy_del (EV_P_ ev_stat *w)
2885	{	2962	{
…		…
2930		3007
2931	static void	3008	static void
2932	infy_cb (EV_P_ ev_io *w, int revents)	3009	infy_cb (EV_P_ ev_io *w, int revents)
2933	{	3010	{
2934	char buf [EV_INOTIFY_BUFSIZE];	3011	char buf [EV_INOTIFY_BUFSIZE];
2935	struct inotify_event ev = (struct inotify_event )buf;
2936	int ofs;	3012	int ofs;
2937	int len = read (fs_fd, buf, sizeof (buf));	3013	int len = read (fs_fd, buf, sizeof (buf));
2938		3014
2939	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)	3015	for (ofs = 0; ofs < len; )
		3016	{
		3017	struct inotify_event ev = (struct inotify_event )(buf + ofs);
2940	infy_wd (EV_A_ ev->wd, ev->wd, ev);	3018	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		3019	ofs += sizeof (struct inotify_event) + ev->len;
		3020	}
		3021	}
		3022
		3023	inline_size unsigned int
		3024	ev_linux_version (void)
		3025	{
		3026	struct utsname buf;
		3027	unsigned int v;
		3028	int i;
		3029	char *p = buf.release;
		3030
		3031	if (uname (&buf))
		3032	return 0;
		3033
		3034	for (i = 3+1; --i; )
		3035	{
		3036	unsigned int c = 0;
		3037
		3038	for (;;)
		3039	{
		3040	if (p >= '0' && p <= '9')
		3041	c = c * 10 + *p++ - '0';
		3042	else
		3043	{
		3044	p += *p == '.';
		3045	break;
		3046	}
		3047	}
		3048
		3049	v = (v << 8) \| c;
		3050	}
		3051
		3052	return v;
2941	}	3053	}
2942		3054
2943	inline_size void	3055	inline_size void
2944	check_2625 (EV_P)	3056	ev_check_2625 (EV_P)
2945	{	3057	{
2946	/* kernels < 2.6.25 are borked	3058	/* kernels < 2.6.25 are borked
2947	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	3059	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2948	*/	3060	*/
2949	struct utsname buf;	3061	if (ev_linux_version () < 0x020619)
2950	int major, minor, micro;
2951
2952	if (uname (&buf))
2953	return;	3062	return;
2954		3063
2955	if (sscanf (buf.release, "%d.%d.%d", &major, &minor, &micro) != 3)
2956	return;
2957
2958	if (major < 2
2959	\|\| (major == 2 && minor < 6)
2960	\|\| (major == 2 && minor == 6 && micro < 25))
2961	return;
2962
2963	fs_2625 = 1;	3064	fs_2625 = 1;
		3065	}
		3066
		3067	inline_size int
		3068	infy_newfd (void)
		3069	{
		3070	#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK)
		3071	int fd = inotify_init1 (IN_CLOEXEC \| IN_NONBLOCK);
		3072	if (fd >= 0)
		3073	return fd;
		3074	#endif
		3075	return inotify_init ();
2964	}	3076	}
2965		3077
2966	inline_size void	3078	inline_size void
2967	infy_init (EV_P)	3079	infy_init (EV_P)
2968	{	3080	{
2969	if (fs_fd != -2)	3081	if (fs_fd != -2)
2970	return;	3082	return;
2971		3083
2972	fs_fd = -1;	3084	fs_fd = -1;
2973		3085
2974	check_2625 (EV_A);	3086	ev_check_2625 (EV_A);
2975		3087
2976	fs_fd = inotify_init ();	3088	fs_fd = infy_newfd ();
2977		3089
2978	if (fs_fd >= 0)	3090	if (fs_fd >= 0)
2979	{	3091	{
		3092	fd_intern (fs_fd);
2980	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);	3093	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
2981	ev_set_priority (&fs_w, EV_MAXPRI);	3094	ev_set_priority (&fs_w, EV_MAXPRI);
2982	ev_io_start (EV_A_ &fs_w);	3095	ev_io_start (EV_A_ &fs_w);
		3096	ev_unref (EV_A);
2983	}	3097	}
2984	}	3098	}
2985		3099
2986	inline_size void	3100	inline_size void
2987	infy_fork (EV_P)	3101	infy_fork (EV_P)
…		…
2989	int slot;	3103	int slot;
2990		3104
2991	if (fs_fd < 0)	3105	if (fs_fd < 0)
2992	return;	3106	return;
2993		3107
		3108	ev_ref (EV_A);
		3109	ev_io_stop (EV_A_ &fs_w);
2994	close (fs_fd);	3110	close (fs_fd);
2995	fs_fd = inotify_init ();	3111	fs_fd = infy_newfd ();
		3112
		3113	if (fs_fd >= 0)
		3114	{
		3115	fd_intern (fs_fd);
		3116	ev_io_set (&fs_w, fs_fd, EV_READ);
		3117	ev_io_start (EV_A_ &fs_w);
		3118	ev_unref (EV_A);
		3119	}
2996		3120
2997	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)	3121	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
2998	{	3122	{
2999	WL w_ = fs_hash [slot].head;	3123	WL w_ = fs_hash [slot].head;
3000	fs_hash [slot].head = 0;	3124	fs_hash [slot].head = 0;
…		…
3007	w->wd = -1;	3131	w->wd = -1;
3008		3132
3009	if (fs_fd >= 0)	3133	if (fs_fd >= 0)
3010	infy_add (EV_A_ w); /* re-add, no matter what */	3134	infy_add (EV_A_ w); /* re-add, no matter what */
3011	else	3135	else
		3136	{
		3137	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		3138	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3012	ev_timer_again (EV_A_ &w->timer);	3139	ev_timer_again (EV_A_ &w->timer);
		3140	if (ev_is_active (&w->timer)) ev_unref (EV_A);
		3141	}
3013	}	3142	}
3014	}	3143	}
3015	}	3144	}
3016		3145
3017	#endif	3146	#endif
…		…
3034	static void noinline	3163	static void noinline
3035	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	3164	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3036	{	3165	{
3037	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));	3166	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));
3038		3167
3039	/* we copy this here each the time so that */	3168	ev_statdata prev = w->attr;
3040	/* prev has the old value when the callback gets invoked */
3041	w->prev = w->attr;
3042	ev_stat_stat (EV_A_ w);	3169	ev_stat_stat (EV_A_ w);
3043		3170
3044	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */	3171	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
3045	if (	3172	if (
3046	w->prev.st_dev != w->attr.st_dev	3173	prev.st_dev != w->attr.st_dev
3047	\|\| w->prev.st_ino != w->attr.st_ino	3174	\|\| prev.st_ino != w->attr.st_ino
3048	\|\| w->prev.st_mode != w->attr.st_mode	3175	\|\| prev.st_mode != w->attr.st_mode
3049	\|\| w->prev.st_nlink != w->attr.st_nlink	3176	\|\| prev.st_nlink != w->attr.st_nlink
3050	\|\| w->prev.st_uid != w->attr.st_uid	3177	\|\| prev.st_uid != w->attr.st_uid
3051	\|\| w->prev.st_gid != w->attr.st_gid	3178	\|\| prev.st_gid != w->attr.st_gid
3052	\|\| w->prev.st_rdev != w->attr.st_rdev	3179	\|\| prev.st_rdev != w->attr.st_rdev
3053	\|\| w->prev.st_size != w->attr.st_size	3180	\|\| prev.st_size != w->attr.st_size
3054	\|\| w->prev.st_atime != w->attr.st_atime	3181	\|\| prev.st_atime != w->attr.st_atime
3055	\|\| w->prev.st_mtime != w->attr.st_mtime	3182	\|\| prev.st_mtime != w->attr.st_mtime
3056	\|\| w->prev.st_ctime != w->attr.st_ctime	3183	\|\| prev.st_ctime != w->attr.st_ctime
3057	) {	3184	) {
		3185	/* we only update w->prev on actual differences */
		3186	/* in case we test more often than invoke the callback, */
		3187	/* to ensure that prev is always different to attr */
		3188	w->prev = prev;
		3189
3058	#if EV_USE_INOTIFY	3190	#if EV_USE_INOTIFY
3059	if (fs_fd >= 0)	3191	if (fs_fd >= 0)
3060	{	3192	{
3061	infy_del (EV_A_ w);	3193	infy_del (EV_A_ w);
3062	infy_add (EV_A_ w);	3194	infy_add (EV_A_ w);
…		…
3087		3219
3088	if (fs_fd >= 0)	3220	if (fs_fd >= 0)
3089	infy_add (EV_A_ w);	3221	infy_add (EV_A_ w);
3090	else	3222	else
3091	#endif	3223	#endif
		3224	{
3092	ev_timer_again (EV_A_ &w->timer);	3225	ev_timer_again (EV_A_ &w->timer);
		3226	ev_unref (EV_A);
		3227	}
3093		3228
3094	ev_start (EV_A_ (W)w, 1);	3229	ev_start (EV_A_ (W)w, 1);
3095		3230
3096	EV_FREQUENT_CHECK;	3231	EV_FREQUENT_CHECK;
3097	}	3232	}
…		…
3106	EV_FREQUENT_CHECK;	3241	EV_FREQUENT_CHECK;
3107		3242
3108	#if EV_USE_INOTIFY	3243	#if EV_USE_INOTIFY
3109	infy_del (EV_A_ w);	3244	infy_del (EV_A_ w);
3110	#endif	3245	#endif
		3246
		3247	if (ev_is_active (&w->timer))
		3248	{
		3249	ev_ref (EV_A);
3111	ev_timer_stop (EV_A_ &w->timer);	3250	ev_timer_stop (EV_A_ &w->timer);
		3251	}
3112		3252
3113	ev_stop (EV_A_ (W)w);	3253	ev_stop (EV_A_ (W)w);
3114		3254
3115	EV_FREQUENT_CHECK;	3255	EV_FREQUENT_CHECK;
3116	}	3256	}
…		…
3335	EV_FREQUENT_CHECK;	3475	EV_FREQUENT_CHECK;
3336		3476
3337	ev_io_stop (EV_A_ &w->io);	3477	ev_io_stop (EV_A_ &w->io);
3338	ev_prepare_stop (EV_A_ &w->prepare);	3478	ev_prepare_stop (EV_A_ &w->prepare);
3339	ev_fork_stop (EV_A_ &w->fork);	3479	ev_fork_stop (EV_A_ &w->fork);
		3480
		3481	ev_stop (EV_A_ (W)w);
3340		3482
3341	EV_FREQUENT_CHECK;	3483	EV_FREQUENT_CHECK;
3342	}	3484	}
3343	#endif	3485	#endif
3344		3486

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.307 by root, Sun Jul 19 07:20:41 2009 UTC vs. Revision 1.334 by root, Tue Mar 9 09:00:59 2010 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.307 by root, Sun Jul 19 07:20:41 2009 UTC vs.
Revision 1.334 by root, Tue Mar 9 09:00:59 2010 UTC