[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.330 by root, Tue Mar 9 08:46:17 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
…		…
302	# define EV_USE_EVENTFD 0	304	# define EV_USE_EVENTFD 0
303	# endif	305	# endif
304	#endif	306	#endif
305		307
306	#ifndef EV_USE_SIGNALFD	308	#ifndef EV_USE_SIGNALFD
307	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 9))	309	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
308	# define EV_USE_SIGNALFD 1	310	# define EV_USE_SIGNALFD 1
309	# else	311	# else
310	# define EV_USE_SIGNALFD 0	312	# define EV_USE_SIGNALFD 0
311	# endif	313	# endif
312	#endif	314	#endif
…		…
343	# endif	345	# endif
344	#endif	346	#endif
345		347
346	/* this block fixes any misconfiguration where we know we run into trouble otherwise */	348	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
347		349
		350	#ifdef _AIX
		351	/* AIX has a completely broken poll.h header */
		352	# undef EV_USE_POLL
		353	# define EV_USE_POLL 0
		354	#endif
		355
348	#ifndef CLOCK_MONOTONIC	356	#ifndef CLOCK_MONOTONIC
349	# undef EV_USE_MONOTONIC	357	# undef EV_USE_MONOTONIC
350	# define EV_USE_MONOTONIC 0	358	# define EV_USE_MONOTONIC 0
351	#endif	359	#endif
352		360
…		…
395	# endif	403	# endif
396	# endif	404	# endif
397	# ifdef __cplusplus	405	# ifdef __cplusplus
398	extern "C" {	406	extern "C" {
399	# endif	407	# endif
400	int eventfd (unsigned int initval, int flags);	408	int (eventfd) (unsigned int initval, int flags);
401	# ifdef __cplusplus	409	# ifdef __cplusplus
402	}	410	}
403	# endif	411	# endif
404	#endif	412	#endif
405		413
406	#if EV_USE_SIGNALFD	414	#if EV_USE_SIGNALFD
407	# include <sys/signalfd.h>	415	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
		416	# include <stdint.h>
		417	# ifndef SFD_NONBLOCK
		418	# define SFD_NONBLOCK O_NONBLOCK
408	#endif	419	# endif
		420	# ifndef SFD_CLOEXEC
		421	# ifdef O_CLOEXEC
		422	# define SFD_CLOEXEC O_CLOEXEC
		423	# else
		424	# define SFD_CLOEXEC 02000000
		425	# endif
		426	# endif
		427	# ifdef __cplusplus
		428	extern "C" {
		429	# endif
		430	int signalfd (int fd, const sigset_t *mask, int flags);
		431
		432	struct signalfd_siginfo
		433	{
		434	uint32_t ssi_signo;
		435	char pad[128 - sizeof (uint32_t)];
		436	};
		437	# ifdef __cplusplus
		438	}
		439	# endif
		440	#endif
		441
409		442
410	/**/	443	/**/
411		444
412	#if EV_VERIFY >= 3	445	#if EV_VERIFY >= 3
413	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)	446	# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
…		…
425	*/	458	*/
426	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */	459	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */
427		460
428	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	461	#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) */	462	#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		463
432	#if __GNUC__ >= 4	464	#if __GNUC__ >= 4
433	# define expect(expr,value) __builtin_expect ((expr),(value))	465	# define expect(expr,value) __builtin_expect ((expr),(value))
434	# define noinline __attribute__ ((noinline))	466	# define noinline __attribute__ ((noinline))
435	#else	467	#else
…		…
480		512
481	#ifndef EV_FD_TO_WIN32_HANDLE	513	#ifndef EV_FD_TO_WIN32_HANDLE
482	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)	514	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
483	#endif	515	#endif
484	#ifndef EV_WIN32_HANDLE_TO_FD	516	#ifndef EV_WIN32_HANDLE_TO_FD
485	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (fd, 0)	517	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
486	#endif	518	#endif
487	#ifndef EV_WIN32_CLOSE_FD	519	#ifndef EV_WIN32_CLOSE_FD
488	# define EV_WIN32_CLOSE_FD(fd) close (fd)	520	# define EV_WIN32_CLOSE_FD(fd) close (fd)
489	#endif	521	#endif
490		522
…		…
510		542
511	if (syserr_cb)	543	if (syserr_cb)
512	syserr_cb (msg);	544	syserr_cb (msg);
513	else	545	else
514	{	546	{
		547	#if EV_AVOID_STDIO
		548	write (STDERR_FILENO, msg, strlen (msg));
		549	write (STDERR_FILENO, ": ", 2);
		550	msg = strerror (errno);
		551	write (STDERR_FILENO, msg, strlen (msg));
		552	write (STDERR_FILENO, "\n", 1);
		553	#else
515	perror (msg);	554	perror (msg);
		555	#endif
516	abort ();	556	abort ();
517	}	557	}
518	}	558	}
519		559
520	static void *	560	static void *
…		…
545	{	585	{
546	ptr = alloc (ptr, size);	586	ptr = alloc (ptr, size);
547		587
548	if (!ptr && size)	588	if (!ptr && size)
549	{	589	{
		590	#if EV_AVOID_STDIO
		591	write (STDERR_FILENO, "libev: memory allocation failed, aborting.",
		592	sizeof ("libev: memory allocation failed, aborting.") - 1);
		593	#else
550	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);	594	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
		595	#endif
551	abort ();	596	abort ();
552	}	597	}
553		598
554	return ptr;	599	return ptr;
555	}	600	}
…		…
939	/* check whether the given fd is atcually valid, for error recovery */	984	/* check whether the given fd is atcually valid, for error recovery */
940	inline_size int	985	inline_size int
941	fd_valid (int fd)	986	fd_valid (int fd)
942	{	987	{
943	#ifdef _WIN32	988	#ifdef _WIN32
944	return _get_osfhandle (fd) != -1;	989	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
945	#else	990	#else
946	return fcntl (fd, F_GETFD) != -1;	991	return fcntl (fd, F_GETFD) != -1;
947	#endif	992	#endif
948	}	993	}
949		994
…		…
1154	inline_speed void	1199	inline_speed void
1155	fd_intern (int fd)	1200	fd_intern (int fd)
1156	{	1201	{
1157	#ifdef _WIN32	1202	#ifdef _WIN32
1158	unsigned long arg = 1;	1203	unsigned long arg = 1;
1159	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);	1204	ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
1160	#else	1205	#else
1161	fcntl (fd, F_SETFD, FD_CLOEXEC);	1206	fcntl (fd, F_SETFD, FD_CLOEXEC);
1162	fcntl (fd, F_SETFL, O_NONBLOCK);	1207	fcntl (fd, F_SETFL, O_NONBLOCK);
1163	#endif	1208	#endif
1164	}	1209	}
…		…
1269	{	1314	{
1270	#if EV_MULTIPLICITY	1315	#if EV_MULTIPLICITY
1271	EV_P = signals [signum - 1].loop;	1316	EV_P = signals [signum - 1].loop;
1272	#endif	1317	#endif
1273		1318
1274	#if _WIN32	1319	#ifdef _WIN32
1275	signal (signum, ev_sighandler);	1320	signal (signum, ev_sighandler);
1276	#endif	1321	#endif
1277		1322
1278	signals [signum - 1].pending = 1;	1323	signals [signum - 1].pending = 1;
1279	evpipe_write (EV_A_ &sig_pending);	1324	evpipe_write (EV_A_ &sig_pending);
…		…
1580	#endif	1625	#endif
1581	#if EV_USE_INOTIFY	1626	#if EV_USE_INOTIFY
1582	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	1627	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
1583	#endif	1628	#endif
1584	#if EV_USE_SIGNALFD	1629	#if EV_USE_SIGNALFD
1585	sigfd = flags & EVFLAG_NOSIGFD ? -1 : -2;	1630	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
1586	#endif	1631	#endif
1587		1632
1588	if (!(flags & 0x0000ffffU))	1633	if (!(flags & 0x0000ffffU))
1589	flags \|= ev_recommended_backends ();	1634	flags \|= ev_recommended_backends ();
1590		1635
…		…
1634	}	1679	}
1635	}	1680	}
1636		1681
1637	#if EV_USE_SIGNALFD	1682	#if EV_USE_SIGNALFD
1638	if (ev_is_active (&sigfd_w))	1683	if (ev_is_active (&sigfd_w))
1639	{
1640	/ev_ref (EV_A);/
1641	/ev_io_stop (EV_A_ &sigfd_w);/
1642
1643	close (sigfd);	1684	close (sigfd);
1644	}
1645	#endif	1685	#endif
1646		1686
1647	#if EV_USE_INOTIFY	1687	#if EV_USE_INOTIFY
1648	if (fs_fd >= 0)	1688	if (fs_fd >= 0)
1649	close (fs_fd);	1689	close (fs_fd);
…		…
2137	ANHE_at_cache (*he);	2177	ANHE_at_cache (*he);
2138	}	2178	}
2139	}	2179	}
2140		2180
2141	/* fetch new monotonic and realtime times from the kernel */	2181	/* fetch new monotonic and realtime times from the kernel */
2142	/* also detetc if there was a timejump, and act accordingly */	2182	/* also detect if there was a timejump, and act accordingly */
2143	inline_speed void	2183	inline_speed void
2144	time_update (EV_P_ ev_tstamp max_block)	2184	time_update (EV_P_ ev_tstamp max_block)
2145	{	2185	{
2146	#if EV_USE_MONOTONIC	2186	#if EV_USE_MONOTONIC
2147	if (expect_true (have_monotonic))	2187	if (expect_true (have_monotonic))
…		…
2481		2521
2482	if (expect_false (ev_is_active (w)))	2522	if (expect_false (ev_is_active (w)))
2483	return;	2523	return;
2484		2524
2485	assert (("libev: ev_io_start called with negative fd", fd >= 0));	2525	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))));	2526	assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET \| EV_READ \| EV_WRITE))));
2487		2527
2488	EV_FREQUENT_CHECK;	2528	EV_FREQUENT_CHECK;
2489		2529
2490	ev_start (EV_A_ (W)w, 1);	2530	ev_start (EV_A_ (W)w, 1);
2491	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);	2531	array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
…		…
2561	timers [active] = timers [timercnt + HEAP0];	2601	timers [active] = timers [timercnt + HEAP0];
2562	adjustheap (timers, timercnt, active);	2602	adjustheap (timers, timercnt, active);
2563	}	2603	}
2564	}	2604	}
2565		2605
2566	EV_FREQUENT_CHECK;
2567
2568	ev_at (w) -= mn_now;	2606	ev_at (w) -= mn_now;
2569		2607
2570	ev_stop (EV_A_ (W)w);	2608	ev_stop (EV_A_ (W)w);
		2609
		2610	EV_FREQUENT_CHECK;
2571	}	2611	}
2572		2612
2573	void noinline	2613	void noinline
2574	ev_timer_again (EV_P_ ev_timer *w)	2614	ev_timer_again (EV_P_ ev_timer *w)
2575	{	2615	{
…		…
2654	periodics [active] = periodics [periodiccnt + HEAP0];	2694	periodics [active] = periodics [periodiccnt + HEAP0];
2655	adjustheap (periodics, periodiccnt, active);	2695	adjustheap (periodics, periodiccnt, active);
2656	}	2696	}
2657	}	2697	}
2658		2698
2659	EV_FREQUENT_CHECK;
2660
2661	ev_stop (EV_A_ (W)w);	2699	ev_stop (EV_A_ (W)w);
		2700
		2701	EV_FREQUENT_CHECK;
2662	}	2702	}
2663		2703
2664	void noinline	2704	void noinline
2665	ev_periodic_again (EV_P_ ev_periodic *w)	2705	ev_periodic_again (EV_P_ ev_periodic *w)
2666	{	2706	{
…		…
2727	if (!((WL)w)->next)	2767	if (!((WL)w)->next)
2728	# if EV_USE_SIGNALFD	2768	# if EV_USE_SIGNALFD
2729	if (sigfd < 0) /TODO/	2769	if (sigfd < 0) /TODO/
2730	# endif	2770	# endif
2731	{	2771	{
2732	# if _WIN32	2772	# ifdef _WIN32
		2773	evpipe_init (EV_A);
		2774
2733	signal (w->signum, ev_sighandler);	2775	signal (w->signum, ev_sighandler);
2734	# else	2776	# else
2735	struct sigaction sa;	2777	struct sigaction sa;
2736		2778
2737	evpipe_init (EV_A);	2779	evpipe_init (EV_A);
…		…
2768	signals [w->signum - 1].loop = 0; /* unattach from signal */	2810	signals [w->signum - 1].loop = 0; /* unattach from signal */
2769	#endif	2811	#endif
2770	#if EV_USE_SIGNALFD	2812	#if EV_USE_SIGNALFD
2771	if (sigfd >= 0)	2813	if (sigfd >= 0)
2772	{	2814	{
2773	sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D	2815	sigset_t ss;
		2816
		2817	sigemptyset (&ss);
		2818	sigaddset (&ss, w->signum);
2774	sigdelset (&sigfd_set, w->signum);	2819	sigdelset (&sigfd_set, w->signum);
		2820
2775	signalfd (sigfd, &sigfd_set, 0);	2821	signalfd (sigfd, &sigfd_set, 0);
2776	sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D	2822	sigprocmask (SIG_UNBLOCK, &ss, 0);
2777	/TODO: maybe unblock signal? /
2778	}	2823	}
2779	else	2824	else
2780	#endif	2825	#endif
2781	signal (w->signum, SIG_DFL);	2826	signal (w->signum, SIG_DFL);
2782	}	2827	}
…		…
2828	#define MIN_STAT_INTERVAL 0.1074891	2873	#define MIN_STAT_INTERVAL 0.1074891
2829		2874
2830	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	2875	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
2831		2876
2832	#if EV_USE_INOTIFY	2877	#if EV_USE_INOTIFY
2833	# define EV_INOTIFY_BUFSIZE 8192	2878
		2879	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
		2880	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
2834		2881
2835	static void noinline	2882	static void noinline
2836	infy_add (EV_P_ ev_stat *w)	2883	infy_add (EV_P_ ev_stat *w)
2837	{	2884	{
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);	2885	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		2886
2840	if (w->wd < 0)	2887	if (w->wd >= 0)
		2888	{
		2889	struct statfs sfs;
		2890
		2891	/* now local changes will be tracked by inotify, but remote changes won't */
		2892	/* unless the filesystem is known to be local, we therefore still poll */
		2893	/* also do poll on <2.6.25, but with normal frequency */
		2894
		2895	if (!fs_2625)
		2896	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		2897	else if (!statfs (w->path, &sfs)
		2898	&& (sfs.f_type == 0x1373 /* devfs */
		2899	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
		2900	\|\| sfs.f_type == 0x3153464a /* jfs */
		2901	\|\| sfs.f_type == 0x52654973 /* reiser3 */
		2902	\|\| sfs.f_type == 0x01021994 /* tempfs */
		2903	\|\| sfs.f_type == 0x58465342 /* xfs */))
		2904	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
		2905	else
		2906	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
2841	{	2907	}
		2908	else
		2909	{
		2910	/* can't use inotify, continue to stat */
2842	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	2911	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		2912
2845	/* monitor some parent directory for speedup hints */	2913	/* 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, */	2914	/* note that exceeding the hardcoded path limit is not a correctness issue, */
2847	/* but an efficiency issue only */	2915	/* but an efficiency issue only */
2848	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)	2916	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)
2849	{	2917	{
2850	char path [4096];	2918	char path [4096];
…		…
2866	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));	2934	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));
2867	}	2935	}
2868	}	2936	}
2869		2937
2870	if (w->wd >= 0)	2938	if (w->wd >= 0)
2871	{
2872	struct statfs sfs;
2873
2874	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);	2939	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
2875		2940
2876	/* now local changes will be tracked by inotify, but remote changes won't */	2941	/* now re-arm timer, if required */
2877	/* unless the filesystem it known to be local, we therefore still poll */	2942	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);	2943	ev_timer_again (EV_A_ &w->timer);
2891	}	2944	if (ev_is_active (&w->timer)) ev_unref (EV_A);
2892	}	2945	}
2893		2946
2894	static void noinline	2947	static void noinline
2895	infy_del (EV_P_ ev_stat *w)	2948	infy_del (EV_P_ ev_stat *w)
2896	{	2949	{
…		…
2941		2994
2942	static void	2995	static void
2943	infy_cb (EV_P_ ev_io *w, int revents)	2996	infy_cb (EV_P_ ev_io *w, int revents)
2944	{	2997	{
2945	char buf [EV_INOTIFY_BUFSIZE];	2998	char buf [EV_INOTIFY_BUFSIZE];
2946	struct inotify_event ev = (struct inotify_event )buf;
2947	int ofs;	2999	int ofs;
2948	int len = read (fs_fd, buf, sizeof (buf));	3000	int len = read (fs_fd, buf, sizeof (buf));
2949		3001
2950	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)	3002	for (ofs = 0; ofs < len; )
		3003	{
		3004	struct inotify_event ev = (struct inotify_event )(buf + ofs);
2951	infy_wd (EV_A_ ev->wd, ev->wd, ev);	3005	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		3006	ofs += sizeof (struct inotify_event) + ev->len;
		3007	}
		3008	}
		3009
		3010	inline_size unsigned int
		3011	ev_linux_version (void)
		3012	{
		3013	struct utsname buf;
		3014	unsigned int v;
		3015	int i;
		3016	char *p = buf.release;
		3017
		3018	if (uname (&buf))
		3019	return 0;
		3020
		3021	for (i = 3+1; --i; )
		3022	{
		3023	unsigned int c = 0;
		3024
		3025	for (;;)
		3026	{
		3027	if (p >= '0' && p <= '9')
		3028	c = c * 10 + *p++ - '0';
		3029	else
		3030	{
		3031	p += *p == '.';
		3032	break;
		3033	}
		3034	}
		3035
		3036	v = (v << 8) \| c;
		3037	}
		3038
		3039	return v;
2952	}	3040	}
2953		3041
2954	inline_size void	3042	inline_size void
2955	check_2625 (EV_P)	3043	ev_check_2625 (EV_P)
2956	{	3044	{
2957	/* kernels < 2.6.25 are borked	3045	/* kernels < 2.6.25 are borked
2958	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	3046	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2959	*/	3047	*/
2960	struct utsname buf;	3048	if (ev_linux_version () < 0x020619)
2961	int major, minor, micro;
2962
2963	if (uname (&buf))
2964	return;	3049	return;
2965		3050
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;	3051	fs_2625 = 1;
		3052	}
		3053
		3054	inline_size int
		3055	infy_newfd (void)
		3056	{
		3057	#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK)
		3058	int fd = inotify_init1 (IN_CLOEXEC \| IN_NONBLOCK);
		3059	if (fd >= 0)
		3060	return fd;
		3061	#endif
		3062	return inotify_init ();
2975	}	3063	}
2976		3064
2977	inline_size void	3065	inline_size void
2978	infy_init (EV_P)	3066	infy_init (EV_P)
2979	{	3067	{
2980	if (fs_fd != -2)	3068	if (fs_fd != -2)
2981	return;	3069	return;
2982		3070
2983	fs_fd = -1;	3071	fs_fd = -1;
2984		3072
2985	check_2625 (EV_A);	3073	ev_check_2625 (EV_A);
2986		3074
2987	fs_fd = inotify_init ();	3075	fs_fd = infy_newfd ();
2988		3076
2989	if (fs_fd >= 0)	3077	if (fs_fd >= 0)
2990	{	3078	{
		3079	fd_intern (fs_fd);
2991	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);	3080	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
2992	ev_set_priority (&fs_w, EV_MAXPRI);	3081	ev_set_priority (&fs_w, EV_MAXPRI);
2993	ev_io_start (EV_A_ &fs_w);	3082	ev_io_start (EV_A_ &fs_w);
		3083	ev_unref (EV_A);
2994	}	3084	}
2995	}	3085	}
2996		3086
2997	inline_size void	3087	inline_size void
2998	infy_fork (EV_P)	3088	infy_fork (EV_P)
…		…
3000	int slot;	3090	int slot;
3001		3091
3002	if (fs_fd < 0)	3092	if (fs_fd < 0)
3003	return;	3093	return;
3004		3094
		3095	ev_ref (EV_A);
		3096	ev_io_stop (EV_A_ &fs_w);
3005	close (fs_fd);	3097	close (fs_fd);
3006	fs_fd = inotify_init ();	3098	fs_fd = infy_newfd ();
		3099
		3100	if (fs_fd >= 0)
		3101	{
		3102	fd_intern (fs_fd);
		3103	ev_io_set (&fs_w, fs_fd, EV_READ);
		3104	ev_io_start (EV_A_ &fs_w);
		3105	ev_unref (EV_A);
		3106	}
3007		3107
3008	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)	3108	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
3009	{	3109	{
3010	WL w_ = fs_hash [slot].head;	3110	WL w_ = fs_hash [slot].head;
3011	fs_hash [slot].head = 0;	3111	fs_hash [slot].head = 0;
…		…
3018	w->wd = -1;	3118	w->wd = -1;
3019		3119
3020	if (fs_fd >= 0)	3120	if (fs_fd >= 0)
3021	infy_add (EV_A_ w); /* re-add, no matter what */	3121	infy_add (EV_A_ w); /* re-add, no matter what */
3022	else	3122	else
		3123	{
		3124	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		3125	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3023	ev_timer_again (EV_A_ &w->timer);	3126	ev_timer_again (EV_A_ &w->timer);
		3127	if (ev_is_active (&w->timer)) ev_unref (EV_A);
		3128	}
3024	}	3129	}
3025	}	3130	}
3026	}	3131	}
3027		3132
3028	#endif	3133	#endif
…		…
3045	static void noinline	3150	static void noinline
3046	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	3151	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3047	{	3152	{
3048	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));	3153	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));
3049		3154
3050	/* we copy this here each the time so that */	3155	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);	3156	ev_stat_stat (EV_A_ w);
3054		3157
3055	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */	3158	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
3056	if (	3159	if (
3057	w->prev.st_dev != w->attr.st_dev	3160	prev.st_dev != w->attr.st_dev
3058	\|\| w->prev.st_ino != w->attr.st_ino	3161	\|\| prev.st_ino != w->attr.st_ino
3059	\|\| w->prev.st_mode != w->attr.st_mode	3162	\|\| prev.st_mode != w->attr.st_mode
3060	\|\| w->prev.st_nlink != w->attr.st_nlink	3163	\|\| prev.st_nlink != w->attr.st_nlink
3061	\|\| w->prev.st_uid != w->attr.st_uid	3164	\|\| prev.st_uid != w->attr.st_uid
3062	\|\| w->prev.st_gid != w->attr.st_gid	3165	\|\| prev.st_gid != w->attr.st_gid
3063	\|\| w->prev.st_rdev != w->attr.st_rdev	3166	\|\| prev.st_rdev != w->attr.st_rdev
3064	\|\| w->prev.st_size != w->attr.st_size	3167	\|\| prev.st_size != w->attr.st_size
3065	\|\| w->prev.st_atime != w->attr.st_atime	3168	\|\| prev.st_atime != w->attr.st_atime
3066	\|\| w->prev.st_mtime != w->attr.st_mtime	3169	\|\| prev.st_mtime != w->attr.st_mtime
3067	\|\| w->prev.st_ctime != w->attr.st_ctime	3170	\|\| prev.st_ctime != w->attr.st_ctime
3068	) {	3171	) {
		3172	/* we only update w->prev on actual differences */
		3173	/* in case we test more often than invoke the callback, */
		3174	/* to ensure that prev is always different to attr */
		3175	w->prev = prev;
		3176
3069	#if EV_USE_INOTIFY	3177	#if EV_USE_INOTIFY
3070	if (fs_fd >= 0)	3178	if (fs_fd >= 0)
3071	{	3179	{
3072	infy_del (EV_A_ w);	3180	infy_del (EV_A_ w);
3073	infy_add (EV_A_ w);	3181	infy_add (EV_A_ w);
…		…
3098		3206
3099	if (fs_fd >= 0)	3207	if (fs_fd >= 0)
3100	infy_add (EV_A_ w);	3208	infy_add (EV_A_ w);
3101	else	3209	else
3102	#endif	3210	#endif
		3211	{
3103	ev_timer_again (EV_A_ &w->timer);	3212	ev_timer_again (EV_A_ &w->timer);
		3213	ev_unref (EV_A);
		3214	}
3104		3215
3105	ev_start (EV_A_ (W)w, 1);	3216	ev_start (EV_A_ (W)w, 1);
3106		3217
3107	EV_FREQUENT_CHECK;	3218	EV_FREQUENT_CHECK;
3108	}	3219	}
…		…
3117	EV_FREQUENT_CHECK;	3228	EV_FREQUENT_CHECK;
3118		3229
3119	#if EV_USE_INOTIFY	3230	#if EV_USE_INOTIFY
3120	infy_del (EV_A_ w);	3231	infy_del (EV_A_ w);
3121	#endif	3232	#endif
		3233
		3234	if (ev_is_active (&w->timer))
		3235	{
		3236	ev_ref (EV_A);
3122	ev_timer_stop (EV_A_ &w->timer);	3237	ev_timer_stop (EV_A_ &w->timer);
		3238	}
3123		3239
3124	ev_stop (EV_A_ (W)w);	3240	ev_stop (EV_A_ (W)w);
3125		3241
3126	EV_FREQUENT_CHECK;	3242	EV_FREQUENT_CHECK;
3127	}	3243	}
…		…
3346	EV_FREQUENT_CHECK;	3462	EV_FREQUENT_CHECK;
3347		3463
3348	ev_io_stop (EV_A_ &w->io);	3464	ev_io_stop (EV_A_ &w->io);
3349	ev_prepare_stop (EV_A_ &w->prepare);	3465	ev_prepare_stop (EV_A_ &w->prepare);
3350	ev_fork_stop (EV_A_ &w->fork);	3466	ev_fork_stop (EV_A_ &w->fork);
		3467
		3468	ev_stop (EV_A_ (W)w);
3351		3469
3352	EV_FREQUENT_CHECK;	3470	EV_FREQUENT_CHECK;
3353	}	3471	}
3354	#endif	3472	#endif
3355		3473

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.330 by root, Tue Mar 9 08:46:17 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.330 by root, Tue Mar 9 08:46:17 2010 UTC