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

Comparing libev/ev.c (file contents):
Revision 1.151 by root, Tue Nov 27 19:59:08 2007 UTC vs.
Revision 1.156 by root, Wed Nov 28 17:50:13 2007 UTC

…		…
94	# else	94	# else
95	# define EV_USE_PORT 0	95	# define EV_USE_PORT 0
96	# endif	96	# endif
97	# endif	97	# endif
98		98
		99	# ifndef EV_USE_INOTIFY
		100	# if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
		101	# define EV_USE_INOTIFY 1
		102	# else
		103	# define EV_USE_INOTIFY 0
		104	# endif
		105	# endif
		106
99	#endif	107	#endif
100		108
101	#include <math.h>	109	#include <math.h>
102	#include <stdlib.h>	110	#include <stdlib.h>
103	#include <fcntl.h>	111	#include <fcntl.h>
…		…
109	#include <errno.h>	117	#include <errno.h>
110	#include <sys/types.h>	118	#include <sys/types.h>
111	#include <time.h>	119	#include <time.h>
112		120
113	#include <signal.h>	121	#include <signal.h>
		122
		123	#ifdef EV_H
		124	# include EV_H
		125	#else
		126	# include "ev.h"
		127	#endif
114		128
115	#ifndef _WIN32	129	#ifndef _WIN32
116	# include <sys/time.h>	130	# include <sys/time.h>
117	# include <sys/wait.h>	131	# include <sys/wait.h>
118	# include <unistd.h>	132	# include <unistd.h>
…		…
156		170
157	#ifndef EV_USE_PORT	171	#ifndef EV_USE_PORT
158	# define EV_USE_PORT 0	172	# define EV_USE_PORT 0
159	#endif	173	#endif
160		174
		175	#ifndef EV_USE_INOTIFY
		176	# define EV_USE_INOTIFY 0
		177	#endif
		178
161	#ifndef EV_PID_HASHSIZE	179	#ifndef EV_PID_HASHSIZE
162	# if EV_MINIMAL	180	# if EV_MINIMAL
163	# define EV_PID_HASHSIZE 1	181	# define EV_PID_HASHSIZE 1
164	# else	182	# else
165	# define EV_PID_HASHSIZE 16	183	# define EV_PID_HASHSIZE 16
166	# endif	184	# endif
167	#endif	185	#endif
168		186
		187	#ifndef EV_INOTIFY_HASHSIZE
		188	# if EV_MINIMAL
		189	# define EV_INOTIFY_HASHSIZE 1
		190	# else
		191	# define EV_INOTIFY_HASHSIZE 16
		192	# endif
		193	#endif
		194
169	/**/	195	/**/
170		196
171	#ifndef CLOCK_MONOTONIC	197	#ifndef CLOCK_MONOTONIC
172	# undef EV_USE_MONOTONIC	198	# undef EV_USE_MONOTONIC
173	# define EV_USE_MONOTONIC 0	199	# define EV_USE_MONOTONIC 0
…		…
180		206
181	#if EV_SELECT_IS_WINSOCKET	207	#if EV_SELECT_IS_WINSOCKET
182	# include <winsock.h>	208	# include <winsock.h>
183	#endif	209	#endif
184		210
		211	#if !EV_STAT_ENABLE
		212	# define EV_USE_INOTIFY 0
		213	#endif
		214
		215	#if EV_USE_INOTIFY
		216	# include <sys/inotify.h>
		217	#endif
		218
185	/**/	219	/**/
186		220
187	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */	221	#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
188	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */	222	#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
189	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds */	223	/#define CLEANUP_INTERVAL (MAX_BLOCKTIME 5.) /* how often to try to free memory and re-check fds */
190
191	#ifdef EV_H
192	# include EV_H
193	#else
194	# include "ev.h"
195	#endif
196		224
197	#if __GNUC__ >= 3	225	#if __GNUC__ >= 3
198	# define expect(expr,value) __builtin_expect ((expr),(value))	226	# define expect(expr,value) __builtin_expect ((expr),(value))
199	# define inline_size static inline /* inline for codesize */	227	# define inline_size static inline /* inline for codesize */
200	# if EV_MINIMAL	228	# if EV_MINIMAL
…		…
253	perror (msg);	281	perror (msg);
254	abort ();	282	abort ();
255	}	283	}
256	}	284	}
257		285
258	static void (alloc)(void *ptr, size_t size) = realloc;	286	static void (alloc)(void *ptr, long size);
259		287
260	void	288	void
261	ev_set_allocator (void (cb)(void *ptr, size_t size))	289	ev_set_allocator (void (cb)(void *ptr, long size))
262	{	290	{
263	alloc = cb;	291	alloc = cb;
264	}	292	}
265		293
266	inline_speed void *	294	inline_speed void *
267	ev_realloc (void *ptr, size_t size)	295	ev_realloc (void *ptr, long size)
268	{	296	{
269	ptr = alloc (ptr, size);	297	ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
270		298
271	if (!ptr && size)	299	if (!ptr && size)
272	{	300	{
273	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", (long)size);	301	fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
274	abort ();	302	abort ();
275	}	303	}
276		304
277	return ptr;	305	return ptr;
278	}	306	}
…		…
295	typedef struct	323	typedef struct
296	{	324	{
297	W w;	325	W w;
298	int events;	326	int events;
299	} ANPENDING;	327	} ANPENDING;
		328
		329	#if EV_USE_INOTIFY
		330	typedef struct
		331	{
		332	WL head;
		333	} ANFS;
		334	#endif
300		335
301	#if EV_MULTIPLICITY	336	#if EV_MULTIPLICITY
302		337
303	struct ev_loop	338	struct ev_loop
304	{	339	{
…		…
879		914
880	if (!(flags & 0x0000ffffUL))	915	if (!(flags & 0x0000ffffUL))
881	flags \|= ev_recommended_backends ();	916	flags \|= ev_recommended_backends ();
882		917
883	backend = 0;	918	backend = 0;
		919	backend_fd = -1;
		920	#if EV_USE_INOTIFY
		921	fs_fd = -2;
		922	#endif
		923
884	#if EV_USE_PORT	924	#if EV_USE_PORT
885	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);	925	if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
886	#endif	926	#endif
887	#if EV_USE_KQUEUE	927	#if EV_USE_KQUEUE
888	if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);	928	if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
…		…
904		944
905	static void noinline	945	static void noinline
906	loop_destroy (EV_P)	946	loop_destroy (EV_P)
907	{	947	{
908	int i;	948	int i;
		949
		950	#if EV_USE_INOTIFY
		951	if (fs_fd >= 0)
		952	close (fs_fd);
		953	#endif
		954
		955	if (backend_fd >= 0)
		956	close (backend_fd);
909		957
910	#if EV_USE_PORT	958	#if EV_USE_PORT
911	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);	959	if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
912	#endif	960	#endif
913	#if EV_USE_KQUEUE	961	#if EV_USE_KQUEUE
…		…
937	array_free (check, EMPTY0);	985	array_free (check, EMPTY0);
938		986
939	backend = 0;	987	backend = 0;
940	}	988	}
941		989
		990	void inline_size infy_fork (EV_P);
		991
942	void inline_size	992	void inline_size
943	loop_fork (EV_P)	993	loop_fork (EV_P)
944	{	994	{
945	#if EV_USE_PORT	995	#if EV_USE_PORT
946	if (backend == EVBACKEND_PORT ) port_fork (EV_A);	996	if (backend == EVBACKEND_PORT ) port_fork (EV_A);
…		…
948	#if EV_USE_KQUEUE	998	#if EV_USE_KQUEUE
949	if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);	999	if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
950	#endif	1000	#endif
951	#if EV_USE_EPOLL	1001	#if EV_USE_EPOLL
952	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);	1002	if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
		1003	#endif
		1004	#if EV_USE_INOTIFY
		1005	infy_fork (EV_A);
953	#endif	1006	#endif
954		1007
955	if (ev_is_active (&sigev))	1008	if (ev_is_active (&sigev))
956	{	1009	{
957	/* default loop */	1010	/* default loop */
…		…
1665	# endif	1718	# endif
1666		1719
1667	#define DEF_STAT_INTERVAL 5.0074891	1720	#define DEF_STAT_INTERVAL 5.0074891
1668	#define MIN_STAT_INTERVAL 0.1074891	1721	#define MIN_STAT_INTERVAL 0.1074891
1669		1722
		1723	void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
		1724
		1725	#if EV_USE_INOTIFY
		1726	# define EV_INOTIFY_BUFSIZE 8192
		1727
		1728	static void noinline
		1729	infy_add (EV_P_ ev_stat *w)
		1730	{
		1731	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);
		1732
		1733	if (w->wd < 0)
		1734	{
		1735	ev_timer_start (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
		1736
		1737	/* monitor some parent directory for speedup hints */
		1738	if ((errno == ENOENT \|\| errno == EACCES) && strlen (w->path) < 4096)
		1739	{
		1740	char path [4096];
		1741	strcpy (path, w->path);
		1742
		1743	do
		1744	{
		1745	int mask = IN_MASK_ADD \| IN_DELETE_SELF \| IN_MOVE_SELF
		1746	\| (errno == EACCES ? IN_ATTRIB : IN_CREATE \| IN_MOVED_TO);
		1747
		1748	char *pend = strrchr (path, '/');
		1749
		1750	if (!pend)
		1751	break; /* whoops, no '/', complain to your admin */
		1752
		1753	*pend = 0;
		1754	w->wd = inotify_add_watch (fs_fd, path, mask);
		1755	}
		1756	while (w->wd < 0 && (errno == ENOENT \|\| errno == EACCES));
		1757	}
		1758	}
		1759	else
		1760	ev_timer_stop (EV_A_ &w->timer); /* we can watch this in a race-free way */
		1761
		1762	if (w->wd >= 0)
		1763	wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
		1764	}
		1765
		1766	static void noinline
		1767	infy_del (EV_P_ ev_stat *w)
		1768	{
		1769	int slot;
		1770	int wd = w->wd;
		1771
		1772	if (wd < 0)
		1773	return;
		1774
		1775	w->wd = -2;
		1776	slot = wd & (EV_INOTIFY_HASHSIZE - 1);
		1777	wlist_del (&fs_hash [slot].head, (WL)w);
		1778
		1779	/* remove this watcher, if others are watching it, they will rearm */
		1780	inotify_rm_watch (fs_fd, wd);
		1781	}
		1782
		1783	static void noinline
		1784	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
		1785	{
		1786	if (slot < 0)
		1787	/* overflow, need to check for all hahs slots */
		1788	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
		1789	infy_wd (EV_A_ slot, wd, ev);
		1790	else
		1791	{
		1792	WL w_;
		1793
		1794	for (w_ = fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head; w_; )
		1795	{
		1796	ev_stat w = (ev_stat )w_;
		1797	w_ = w_->next; /* lets us remove this watcher and all before it */
		1798
		1799	if (w->wd == wd \|\| wd == -1)
		1800	{
		1801	if (ev->mask & (IN_IGNORED \| IN_UNMOUNT \| IN_DELETE_SELF))
		1802	{
		1803	w->wd = -1;
		1804	infy_add (EV_A_ w); /* re-add, no matter what */
		1805	}
		1806
		1807	stat_timer_cb (EV_A_ &w->timer, 0);
		1808	}
		1809	}
		1810	}
		1811	}
		1812
		1813	static void
		1814	infy_cb (EV_P_ ev_io *w, int revents)
		1815	{
		1816	char buf [EV_INOTIFY_BUFSIZE];
		1817	struct inotify_event ev = (struct inotify_event )buf;
		1818	int ofs;
		1819	int len = read (fs_fd, buf, sizeof (buf));
		1820
		1821	for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)
		1822	infy_wd (EV_A_ ev->wd, ev->wd, ev);
		1823	}
		1824
		1825	void inline_size
		1826	infy_init (EV_P)
		1827	{
		1828	if (fs_fd != -2)
		1829	return;
		1830
		1831	fs_fd = inotify_init ();
		1832
		1833	if (fs_fd >= 0)
		1834	{
		1835	ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
		1836	ev_set_priority (&fs_w, EV_MAXPRI);
		1837	ev_io_start (EV_A_ &fs_w);
		1838	}
		1839	}
		1840
		1841	void inline_size
		1842	infy_fork (EV_P)
		1843	{
		1844	int slot;
		1845
		1846	if (fs_fd < 0)
		1847	return;
		1848
		1849	close (fs_fd);
		1850	fs_fd = inotify_init ();
		1851
		1852	for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
		1853	{
		1854	WL w_ = fs_hash [slot].head;
		1855	fs_hash [slot].head = 0;
		1856
		1857	while (w_)
		1858	{
		1859	ev_stat w = (ev_stat )w_;
		1860	w_ = w_->next; /* lets us add this watcher */
		1861
		1862	w->wd = -1;
		1863
		1864	if (fs_fd >= 0)
		1865	infy_add (EV_A_ w); /* re-add, no matter what */
		1866	else
		1867	ev_timer_start (EV_A_ &w->timer);
		1868	}
		1869
		1870	}
		1871	}
		1872
		1873	#endif
		1874
1670	void	1875	void
1671	ev_stat_stat (EV_P_ ev_stat *w)	1876	ev_stat_stat (EV_P_ ev_stat *w)
1672	{	1877	{
1673	if (lstat (w->path, &w->attr) < 0)	1878	if (lstat (w->path, &w->attr) < 0)
1674	w->attr.st_nlink = 0;	1879	w->attr.st_nlink = 0;
1675	else if (!w->attr.st_nlink)	1880	else if (!w->attr.st_nlink)
1676	w->attr.st_nlink = 1;	1881	w->attr.st_nlink = 1;
1677	}	1882	}
1678		1883
1679	static void	1884	void noinline
1680	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	1885	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
1681	{	1886	{
1682	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));	1887	ev_stat w = (ev_stat )(((char *)w_) - offsetof (ev_stat, timer));
1683		1888
1684	/* we copy this here each the time so that */	1889	/* we copy this here each the time so that */
1685	/* prev has the old value when the callback gets invoked */	1890	/* prev has the old value when the callback gets invoked */
1686	w->prev = w->attr;	1891	w->prev = w->attr;
1687	ev_stat_stat (EV_A_ w);	1892	ev_stat_stat (EV_A_ w);
1688		1893
1689	if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata)))	1894	/* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
		1895	if (
		1896	w->prev.st_dev != w->attr.st_dev
		1897	\|\| w->prev.st_ino != w->attr.st_ino
		1898	\|\| w->prev.st_mode != w->attr.st_mode
		1899	\|\| w->prev.st_nlink != w->attr.st_nlink
		1900	\|\| w->prev.st_uid != w->attr.st_uid
		1901	\|\| w->prev.st_gid != w->attr.st_gid
		1902	\|\| w->prev.st_rdev != w->attr.st_rdev
		1903	\|\| w->prev.st_size != w->attr.st_size
		1904	\|\| w->prev.st_atime != w->attr.st_atime
		1905	\|\| w->prev.st_mtime != w->attr.st_mtime
		1906	\|\| w->prev.st_ctime != w->attr.st_ctime
		1907	) {
		1908	#if EV_USE_INOTIFY
		1909	infy_del (EV_A_ w);
		1910	infy_add (EV_A_ w);
		1911	ev_stat_stat (EV_A_ w); /* avoid race... */
		1912	#endif
		1913
1690	ev_feed_event (EV_A_ w, EV_STAT);	1914	ev_feed_event (EV_A_ w, EV_STAT);
		1915	}
1691	}	1916	}
1692		1917
1693	void	1918	void
1694	ev_stat_start (EV_P_ ev_stat *w)	1919	ev_stat_start (EV_P_ ev_stat *w)
1695	{	1920	{
…		…
1705	if (w->interval < MIN_STAT_INTERVAL)	1930	if (w->interval < MIN_STAT_INTERVAL)
1706	w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;	1931	w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;
1707		1932
1708	ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);	1933	ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
1709	ev_set_priority (&w->timer, ev_priority (w));	1934	ev_set_priority (&w->timer, ev_priority (w));
		1935
		1936	#if EV_USE_INOTIFY
		1937	infy_init (EV_A);
		1938
		1939	if (fs_fd >= 0)
		1940	infy_add (EV_A_ w);
		1941	else
		1942	#endif
1710	ev_timer_start (EV_A_ &w->timer);	1943	ev_timer_start (EV_A_ &w->timer);
1711		1944
1712	ev_start (EV_A_ (W)w, 1);	1945	ev_start (EV_A_ (W)w, 1);
1713	}	1946	}
1714		1947
1715	void	1948	void
…		…
1717	{	1950	{
1718	ev_clear_pending (EV_A_ (W)w);	1951	ev_clear_pending (EV_A_ (W)w);
1719	if (expect_false (!ev_is_active (w)))	1952	if (expect_false (!ev_is_active (w)))
1720	return;	1953	return;
1721		1954
		1955	#if EV_USE_INOTIFY
		1956	infy_del (EV_A_ w);
		1957	#endif
1722	ev_timer_stop (EV_A_ &w->timer);	1958	ev_timer_stop (EV_A_ &w->timer);
1723		1959
1724	ev_stop (EV_A_ (W)w);	1960	ev_stop (EV_A_ (W)w);
1725	}	1961	}
1726	#endif	1962	#endif

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.151 by root, Tue Nov 27 19:59:08 2007 UTC vs. Revision 1.156 by root, Wed Nov 28 17:50:13 2007 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.151 by root, Tue Nov 27 19:59:08 2007 UTC vs.
Revision 1.156 by root, Wed Nov 28 17:50:13 2007 UTC