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

Comparing libev/ev.c (file contents):
Revision 1.314 by root, Wed Aug 26 17:31:20 2009 UTC vs.
Revision 1.326 by root, Tue Jan 26 04:19:37 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
…		…
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
…		…
450	*/	458	*/
451	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */	459	#define TIME_EPSILON 0.0001220703125 /* 1/8192 */
452		460
453	#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) */
454	#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) */
455	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds, TODO */
456		463
457	#if __GNUC__ >= 4	464	#if __GNUC__ >= 4
458	# define expect(expr,value) __builtin_expect ((expr),(value))	465	# define expect(expr,value) __builtin_expect ((expr),(value))
459	# define noinline __attribute__ ((noinline))	466	# define noinline __attribute__ ((noinline))
460	#else	467	#else
…		…
505		512
506	#ifndef EV_FD_TO_WIN32_HANDLE	513	#ifndef EV_FD_TO_WIN32_HANDLE
507	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)	514	# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
508	#endif	515	#endif
509	#ifndef EV_WIN32_HANDLE_TO_FD	516	#ifndef EV_WIN32_HANDLE_TO_FD
510	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (fd, 0)	517	# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
511	#endif	518	#endif
512	#ifndef EV_WIN32_CLOSE_FD	519	#ifndef EV_WIN32_CLOSE_FD
513	# define EV_WIN32_CLOSE_FD(fd) close (fd)	520	# define EV_WIN32_CLOSE_FD(fd) close (fd)
514	#endif	521	#endif
515		522
…		…
964	/* check whether the given fd is atcually valid, for error recovery */	971	/* check whether the given fd is atcually valid, for error recovery */
965	inline_size int	972	inline_size int
966	fd_valid (int fd)	973	fd_valid (int fd)
967	{	974	{
968	#ifdef _WIN32	975	#ifdef _WIN32
969	return _get_osfhandle (fd) != -1;	976	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
970	#else	977	#else
971	return fcntl (fd, F_GETFD) != -1;	978	return fcntl (fd, F_GETFD) != -1;
972	#endif	979	#endif
973	}	980	}
974		981
…		…
1179	inline_speed void	1186	inline_speed void
1180	fd_intern (int fd)	1187	fd_intern (int fd)
1181	{	1188	{
1182	#ifdef _WIN32	1189	#ifdef _WIN32
1183	unsigned long arg = 1;	1190	unsigned long arg = 1;
1184	ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);	1191	ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
1185	#else	1192	#else
1186	fcntl (fd, F_SETFD, FD_CLOEXEC);	1193	fcntl (fd, F_SETFD, FD_CLOEXEC);
1187	fcntl (fd, F_SETFL, O_NONBLOCK);	1194	fcntl (fd, F_SETFL, O_NONBLOCK);
1188	#endif	1195	#endif
1189	}	1196	}
…		…
1294	{	1301	{
1295	#if EV_MULTIPLICITY	1302	#if EV_MULTIPLICITY
1296	EV_P = signals [signum - 1].loop;	1303	EV_P = signals [signum - 1].loop;
1297	#endif	1304	#endif
1298		1305
1299	#if _WIN32	1306	#ifdef _WIN32
1300	signal (signum, ev_sighandler);	1307	signal (signum, ev_sighandler);
1301	#endif	1308	#endif
1302		1309
1303	signals [signum - 1].pending = 1;	1310	signals [signum - 1].pending = 1;
1304	evpipe_write (EV_A_ &sig_pending);	1311	evpipe_write (EV_A_ &sig_pending);
…		…
1605	#endif	1612	#endif
1606	#if EV_USE_INOTIFY	1613	#if EV_USE_INOTIFY
1607	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	1614	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
1608	#endif	1615	#endif
1609	#if EV_USE_SIGNALFD	1616	#if EV_USE_SIGNALFD
1610	sigfd = flags & EVFLAG_NOSIGFD ? -1 : -2;	1617	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
1611	#endif	1618	#endif
1612		1619
1613	if (!(flags & 0x0000ffffU))	1620	if (!(flags & 0x0000ffffU))
1614	flags \|= ev_recommended_backends ();	1621	flags \|= ev_recommended_backends ();
1615		1622
…		…
1659	}	1666	}
1660	}	1667	}
1661		1668
1662	#if EV_USE_SIGNALFD	1669	#if EV_USE_SIGNALFD
1663	if (ev_is_active (&sigfd_w))	1670	if (ev_is_active (&sigfd_w))
1664	{
1665	/ev_ref (EV_A);/
1666	/ev_io_stop (EV_A_ &sigfd_w);/
1667
1668	close (sigfd);	1671	close (sigfd);
1669	}
1670	#endif	1672	#endif
1671		1673
1672	#if EV_USE_INOTIFY	1674	#if EV_USE_INOTIFY
1673	if (fs_fd >= 0)	1675	if (fs_fd >= 0)
1674	close (fs_fd);	1676	close (fs_fd);
…		…
2162	ANHE_at_cache (*he);	2164	ANHE_at_cache (*he);
2163	}	2165	}
2164	}	2166	}
2165		2167
2166	/* fetch new monotonic and realtime times from the kernel */	2168	/* fetch new monotonic and realtime times from the kernel */
2167	/* also detetc if there was a timejump, and act accordingly */	2169	/* also detect if there was a timejump, and act accordingly */
2168	inline_speed void	2170	inline_speed void
2169	time_update (EV_P_ ev_tstamp max_block)	2171	time_update (EV_P_ ev_tstamp max_block)
2170	{	2172	{
2171	#if EV_USE_MONOTONIC	2173	#if EV_USE_MONOTONIC
2172	if (expect_true (have_monotonic))	2174	if (expect_true (have_monotonic))
…		…
2752	if (!((WL)w)->next)	2754	if (!((WL)w)->next)
2753	# if EV_USE_SIGNALFD	2755	# if EV_USE_SIGNALFD
2754	if (sigfd < 0) /TODO/	2756	if (sigfd < 0) /TODO/
2755	# endif	2757	# endif
2756	{	2758	{
2757	# if _WIN32	2759	# ifdef _WIN32
		2760	evpipe_init (EV_A);
		2761
2758	signal (w->signum, ev_sighandler);	2762	signal (w->signum, ev_sighandler);
2759	# else	2763	# else
2760	struct sigaction sa;	2764	struct sigaction sa;
2761		2765
2762	evpipe_init (EV_A);	2766	evpipe_init (EV_A);
…		…
2793	signals [w->signum - 1].loop = 0; /* unattach from signal */	2797	signals [w->signum - 1].loop = 0; /* unattach from signal */
2794	#endif	2798	#endif
2795	#if EV_USE_SIGNALFD	2799	#if EV_USE_SIGNALFD
2796	if (sigfd >= 0)	2800	if (sigfd >= 0)
2797	{	2801	{
2798	sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D	2802	sigset_t ss;
		2803
		2804	sigemptyset (&ss);
		2805	sigaddset (&ss, w->signum);
2799	sigdelset (&sigfd_set, w->signum);	2806	sigdelset (&sigfd_set, w->signum);
		2807
2800	signalfd (sigfd, &sigfd_set, 0);	2808	signalfd (sigfd, &sigfd_set, 0);
2801	sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D	2809	sigprocmask (SIG_UNBLOCK, &ss, 0);
2802	/TODO: maybe unblock signal? /
2803	}	2810	}
2804	else	2811	else
2805	#endif	2812	#endif
2806	signal (w->signum, SIG_DFL);	2813	signal (w->signum, SIG_DFL);
2807	}	2814	}
…		…
2853	#define MIN_STAT_INTERVAL 0.1074891	2860	#define MIN_STAT_INTERVAL 0.1074891
2854		2861
2855	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	2862	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
2856		2863
2857	#if EV_USE_INOTIFY	2864	#if EV_USE_INOTIFY
2858	# define EV_INOTIFY_BUFSIZE 8192	2865
		2866	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
		2867	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
2859		2868
2860	static void noinline	2869	static void noinline
2861	infy_add (EV_P_ ev_stat *w)	2870	infy_add (EV_P_ ev_stat *w)
2862	{	2871	{
2863	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);	2872	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);
2864		2873
2865	if (w->wd < 0)	2874	if (w->wd >= 0)
		2875	{
		2876	struct statfs sfs;
		2877
		2878	/* now local changes will be tracked by inotify, but remote changes won't */
		2879	/* unless the filesystem is known to be local, we therefore still poll */
		2880	/* also do poll on <2.6.25, but with normal frequency */
		2881
		2882	if (!fs_2625)
		2883	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		2884	else if (!statfs (w->path, &sfs)
		2885	&& (sfs.f_type == 0x1373 /* devfs */
		2886	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
		2887	\|\| sfs.f_type == 0x3153464a /* jfs */
		2888	\|\| sfs.f_type == 0x52654973 /* reiser3 */
		2889	\|\| sfs.f_type == 0x01021994 /* tempfs */
		2890	\|\| sfs.f_type == 0x58465342 /* xfs */))
		2891	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
		2892	else
		2893	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
2866	{	2894	}
		2895	else
		2896	{
		2897	/* can't use inotify, continue to stat */
2867	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	2898	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
2868	ev_timer_again (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
2869		2899
2870	/* monitor some parent directory for speedup hints */	2900	/* if path is not there, monitor some parent directory for speedup hints */
2871	/* note that exceeding the hardcoded path limit is not a correctness issue, */	2901	/* note that exceeding the hardcoded path limit is not a correctness issue, */
2872	/* but an efficiency issue only */	2902	/* but an efficiency issue only */
2873	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)	2903	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)
2874	{	2904	{
2875	char path [4096];	2905	char path [4096];
…		…
2891	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));	2921	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));
2892	}	2922	}
2893	}	2923	}
2894		2924
2895	if (w->wd >= 0)	2925	if (w->wd >= 0)
2896	{
2897	struct statfs sfs;
2898
2899	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);	2926	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
2900		2927
2901	/* now local changes will be tracked by inotify, but remote changes won't */	2928	/* now re-arm timer, if required */
2902	/* unless the filesystem it known to be local, we therefore still poll */	2929	if (ev_is_active (&w->timer)) ev_ref (EV_A);
2903	/* also do poll on <2.6.25, but with normal frequency */
2904
2905	if (fs_2625 && !statfs (w->path, &sfs))
2906	if (sfs.f_type == 0x1373 /* devfs */
2907	\|\| sfs.f_type == 0xEF53 /* ext2/3 */
2908	\|\| sfs.f_type == 0x3153464a /* jfs */
2909	\|\| sfs.f_type == 0x52654973 /* reiser3 */
2910	\|\| sfs.f_type == 0x01021994 /* tempfs */
2911	\|\| sfs.f_type == 0x58465342 /* xfs */)
2912	return;
2913
2914	w->timer.repeat = w->interval ? w->interval : fs_2625 ? NFS_STAT_INTERVAL : DEF_STAT_INTERVAL;
2915	ev_timer_again (EV_A_ &w->timer);	2930	ev_timer_again (EV_A_ &w->timer);
2916	}	2931	if (ev_is_active (&w->timer)) ev_unref (EV_A);
2917	}	2932	}
2918		2933
2919	static void noinline	2934	static void noinline
2920	infy_del (EV_P_ ev_stat *w)	2935	infy_del (EV_P_ ev_stat *w)
2921	{	2936	{
…		…
2966		2981
2967	static void	2982	static void
2968	infy_cb (EV_P_ ev_io *w, int revents)	2983	infy_cb (EV_P_ ev_io *w, int revents)
2969	{	2984	{
2970	char buf [EV_INOTIFY_BUFSIZE];	2985	char buf [EV_INOTIFY_BUFSIZE];
2971	struct inotify_event ev = (struct inotify_event )buf;
2972	int ofs;	2986	int ofs;
2973	int len = read (fs_fd, buf, sizeof (buf));	2987	int len = read (fs_fd, buf, sizeof (buf));
2974		2988
2975	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)	2989	for (ofs = 0; ofs < len; )
		2990	{
		2991	struct inotify_event ev = (struct inotify_event )(buf + ofs);
2976	infy_wd (EV_A_ ev->wd, ev->wd, ev);	2992	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		2993	ofs += sizeof (struct inotify_event) + ev->len;
		2994	}
2977	}	2995	}
2978		2996
2979	inline_size void	2997	inline_size void
2980	check_2625 (EV_P)	2998	check_2625 (EV_P)
2981	{	2999	{
…		…
2997	return;	3015	return;
2998		3016
2999	fs_2625 = 1;	3017	fs_2625 = 1;
3000	}	3018	}
3001		3019
		3020	inline_size int
		3021	infy_newfd (void)
		3022	{
		3023	#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK)
		3024	int fd = inotify_init1 (IN_CLOEXEC \| IN_NONBLOCK);
		3025	if (fd >= 0)
		3026	return fd;
		3027	#endif
		3028	return inotify_init ();
		3029	}
		3030
3002	inline_size void	3031	inline_size void
3003	infy_init (EV_P)	3032	infy_init (EV_P)
3004	{	3033	{
3005	if (fs_fd != -2)	3034	if (fs_fd != -2)
3006	return;	3035	return;
3007		3036
3008	fs_fd = -1;	3037	fs_fd = -1;
3009		3038
3010	check_2625 (EV_A);	3039	check_2625 (EV_A);
3011		3040
3012	fs_fd = inotify_init ();	3041	fs_fd = infy_newfd ();
3013		3042
3014	if (fs_fd >= 0)	3043	if (fs_fd >= 0)
3015	{	3044	{
		3045	fd_intern (fs_fd);
3016	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);	3046	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
3017	ev_set_priority (&fs_w, EV_MAXPRI);	3047	ev_set_priority (&fs_w, EV_MAXPRI);
3018	ev_io_start (EV_A_ &fs_w);	3048	ev_io_start (EV_A_ &fs_w);
		3049	ev_unref (EV_A);
3019	}	3050	}
3020	}	3051	}
3021		3052
3022	inline_size void	3053	inline_size void
3023	infy_fork (EV_P)	3054	infy_fork (EV_P)
…		…
3025	int slot;	3056	int slot;
3026		3057
3027	if (fs_fd < 0)	3058	if (fs_fd < 0)
3028	return;	3059	return;
3029		3060
		3061	ev_ref (EV_A);
		3062	ev_io_stop (EV_A_ &fs_w);
3030	close (fs_fd);	3063	close (fs_fd);
3031	fs_fd = inotify_init ();	3064	fs_fd = infy_newfd ();
		3065
		3066	if (fs_fd >= 0)
		3067	{
		3068	fd_intern (fs_fd);
		3069	ev_io_set (&fs_w, fs_fd, EV_READ);
		3070	ev_io_start (EV_A_ &fs_w);
		3071	ev_unref (EV_A);
		3072	}
3032		3073
3033	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)	3074	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
3034	{	3075	{
3035	WL w_ = fs_hash [slot].head;	3076	WL w_ = fs_hash [slot].head;
3036	fs_hash [slot].head = 0;	3077	fs_hash [slot].head = 0;
…		…
3043	w->wd = -1;	3084	w->wd = -1;
3044		3085
3045	if (fs_fd >= 0)	3086	if (fs_fd >= 0)
3046	infy_add (EV_A_ w); /* re-add, no matter what */	3087	infy_add (EV_A_ w); /* re-add, no matter what */
3047	else	3088	else
		3089	{
		3090	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
		3091	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3048	ev_timer_again (EV_A_ &w->timer);	3092	ev_timer_again (EV_A_ &w->timer);
		3093	if (ev_is_active (&w->timer)) ev_unref (EV_A);
		3094	}
3049	}	3095	}
3050	}	3096	}
3051	}	3097	}
3052		3098
3053	#endif	3099	#endif
…		…
3070	static void noinline	3116	static void noinline
3071	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	3117	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3072	{	3118	{
3073	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));	3119	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));
3074		3120
3075	/* we copy this here each the time so that */	3121	ev_statdata prev = w->attr;
3076	/* prev has the old value when the callback gets invoked */
3077	w->prev = w->attr;
3078	ev_stat_stat (EV_A_ w);	3122	ev_stat_stat (EV_A_ w);
3079		3123
3080	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */	3124	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
3081	if (	3125	if (
3082	w->prev.st_dev != w->attr.st_dev	3126	prev.st_dev != w->attr.st_dev
3083	\|\| w->prev.st_ino != w->attr.st_ino	3127	\|\| prev.st_ino != w->attr.st_ino
3084	\|\| w->prev.st_mode != w->attr.st_mode	3128	\|\| prev.st_mode != w->attr.st_mode
3085	\|\| w->prev.st_nlink != w->attr.st_nlink	3129	\|\| prev.st_nlink != w->attr.st_nlink
3086	\|\| w->prev.st_uid != w->attr.st_uid	3130	\|\| prev.st_uid != w->attr.st_uid
3087	\|\| w->prev.st_gid != w->attr.st_gid	3131	\|\| prev.st_gid != w->attr.st_gid
3088	\|\| w->prev.st_rdev != w->attr.st_rdev	3132	\|\| prev.st_rdev != w->attr.st_rdev
3089	\|\| w->prev.st_size != w->attr.st_size	3133	\|\| prev.st_size != w->attr.st_size
3090	\|\| w->prev.st_atime != w->attr.st_atime	3134	\|\| prev.st_atime != w->attr.st_atime
3091	\|\| w->prev.st_mtime != w->attr.st_mtime	3135	\|\| prev.st_mtime != w->attr.st_mtime
3092	\|\| w->prev.st_ctime != w->attr.st_ctime	3136	\|\| prev.st_ctime != w->attr.st_ctime
3093	) {	3137	) {
		3138	/* we only update w->prev on actual differences */
		3139	/* in case we test more often than invoke the callback, */
		3140	/* to ensure that prev is always different to attr */
		3141	w->prev = prev;
		3142
3094	#if EV_USE_INOTIFY	3143	#if EV_USE_INOTIFY
3095	if (fs_fd >= 0)	3144	if (fs_fd >= 0)
3096	{	3145	{
3097	infy_del (EV_A_ w);	3146	infy_del (EV_A_ w);
3098	infy_add (EV_A_ w);	3147	infy_add (EV_A_ w);
…		…
3123		3172
3124	if (fs_fd >= 0)	3173	if (fs_fd >= 0)
3125	infy_add (EV_A_ w);	3174	infy_add (EV_A_ w);
3126	else	3175	else
3127	#endif	3176	#endif
		3177	{
3128	ev_timer_again (EV_A_ &w->timer);	3178	ev_timer_again (EV_A_ &w->timer);
		3179	ev_unref (EV_A);
		3180	}
3129		3181
3130	ev_start (EV_A_ (W)w, 1);	3182	ev_start (EV_A_ (W)w, 1);
3131		3183
3132	EV_FREQUENT_CHECK;	3184	EV_FREQUENT_CHECK;
3133	}	3185	}
…		…
3142	EV_FREQUENT_CHECK;	3194	EV_FREQUENT_CHECK;
3143		3195
3144	#if EV_USE_INOTIFY	3196	#if EV_USE_INOTIFY
3145	infy_del (EV_A_ w);	3197	infy_del (EV_A_ w);
3146	#endif	3198	#endif
		3199
		3200	if (ev_is_active (&w->timer))
		3201	{
		3202	ev_ref (EV_A);
3147	ev_timer_stop (EV_A_ &w->timer);	3203	ev_timer_stop (EV_A_ &w->timer);
		3204	}
3148		3205
3149	ev_stop (EV_A_ (W)w);	3206	ev_stop (EV_A_ (W)w);
3150		3207
3151	EV_FREQUENT_CHECK;	3208	EV_FREQUENT_CHECK;
3152	}	3209	}

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.314 by root, Wed Aug 26 17:31:20 2009 UTC vs. Revision 1.326 by root, Tue Jan 26 04:19:37 2010 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.314 by root, Wed Aug 26 17:31:20 2009 UTC vs.
Revision 1.326 by root, Tue Jan 26 04:19:37 2010 UTC