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

Comparing libev/ev.c (file contents):
Revision 1.298 by root, Fri Jul 10 19:10:19 2009 UTC vs.
Revision 1.306 by root, Sun Jul 19 06:35:25 2009 UTC

…		…
133	# else	133	# else
134	# define EV_USE_INOTIFY 0	134	# define EV_USE_INOTIFY 0
135	# endif	135	# endif
136	# endif	136	# endif
137		137
		138	# ifndef EV_USE_SIGNALFD
		139	# if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
		140	# define EV_USE_SIGNALFD 1
		141	# else
		142	# define EV_USE_SIGNALFD 0
		143	# endif
		144	# endif
		145
138	# ifndef EV_USE_EVENTFD	146	# ifndef EV_USE_EVENTFD
139	# if HAVE_EVENTFD	147	# if HAVE_EVENTFD
140	# define EV_USE_EVENTFD 1	148	# define EV_USE_EVENTFD 1
141	# else	149	# else
142	# define EV_USE_EVENTFD 0	150	# define EV_USE_EVENTFD 0
…		…
178	# endif	186	# endif
179	#endif	187	#endif
180		188
181	/* this block tries to deduce configuration from header-defined symbols and defaults */	189	/* this block tries to deduce configuration from header-defined symbols and defaults */
182		190
		191	/* try to deduce the maximum number of signals on this platform */
		192	/* one some platforms, NSIG is one too large. we do not bother */
		193	#if defined (EV_NSIG)
		194	/* use what's provided */
		195	#elif defined (NSIG)
		196	# define EV_NSIG (NSIG)
		197	#elif defined(_NSIG)
		198	# define EV_NSIG (_NSIG)
		199	#elif defined (SIGMAX)
		200	# define EV_NSIG (SIGMAX+1)
		201	#elif defined (SIG_MAX)
		202	# define EV_NSIG (SIG_MAX+1)
		203	#elif defined (_SIG_MAX)
		204	# define EV_NSIG (_SIG_MAX+1)
		205	#elif defined (MAXSIG)
		206	# define EV_NSIG (MAXSIG+1)
		207	#elif defined (MAX_SIG)
		208	# define EV_NSIG (MAX_SIG+1)
		209	#elif defined (SIGARRAYSIZE)
		210	# define EV_NSIG SIGARRAYSIZE /* Assume ary[SIGARRAYSIZE] */
		211	#elif defined (_sys_nsig)
		212	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
		213	#else
		214	# error "unable to find value for NSIG, please report"
		215	/* to make it compile regardless, just remove the above line */
		216	# define EV_NSIG 65
		217	#endif
		218
183	#ifndef EV_USE_CLOCK_SYSCALL	219	#ifndef EV_USE_CLOCK_SYSCALL
184	# if __linux && __GLIBC__ >= 2	220	# if __linux && __GLIBC__ >= 2
185	# define EV_USE_CLOCK_SYSCALL 1	221	# define EV_USE_CLOCK_SYSCALL 1
186	# else	222	# else
187	# define EV_USE_CLOCK_SYSCALL 0	223	# define EV_USE_CLOCK_SYSCALL 0
…		…
263	#ifndef EV_USE_EVENTFD	299	#ifndef EV_USE_EVENTFD
264	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))	300	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
265	# define EV_USE_EVENTFD 1	301	# define EV_USE_EVENTFD 1
266	# else	302	# else
267	# define EV_USE_EVENTFD 0	303	# define EV_USE_EVENTFD 0
		304	# endif
		305	#endif
		306
		307	#ifndef EV_USE_SIGNALFD
		308	# if __linux && (__GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 9))
		309	# define EV_USE_SIGNALFD 1
		310	# else
		311	# define EV_USE_SIGNALFD 0
268	# endif	312	# endif
269	#endif	313	#endif
270		314
271	#if 0 /* debugging */	315	#if 0 /* debugging */
272	# define EV_VERIFY 3	316	# define EV_VERIFY 3
…		…
339	#endif	383	#endif
340		384
341	#if EV_USE_EVENTFD	385	#if EV_USE_EVENTFD
342	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */	386	/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
343	# include <stdint.h>	387	# include <stdint.h>
		388	# ifndef EFD_NONBLOCK
		389	# define EFD_NONBLOCK O_NONBLOCK
		390	# endif
		391	# ifndef EFD_CLOEXEC
		392	# define EFD_CLOEXEC O_CLOEXEC
		393	# endif
344	# ifdef __cplusplus	394	# ifdef __cplusplus
345	extern "C" {	395	extern "C" {
346	# endif	396	# endif
347	int eventfd (unsigned int initval, int flags);	397	int eventfd (unsigned int initval, int flags);
348	# ifdef __cplusplus	398	# ifdef __cplusplus
349	}	399	}
350	# endif	400	# endif
		401	#endif
		402
		403	#if EV_USE_SIGNALFD
		404	# include <sys/signalfd.h>
351	#endif	405	#endif
352		406
353	/**/	407	/**/
354		408
355	#if EV_VERIFY >= 3	409	#if EV_VERIFY >= 3
…		…
647		701
648	tv.tv_sec = (time_t)delay;	702	tv.tv_sec = (time_t)delay;
649	tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);	703	tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);
650		704
651	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */	705	/* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
652	/* somehting not guaranteed by newer posix versions, but guaranteed */	706	/* something not guaranteed by newer posix versions, but guaranteed */
653	/* by older ones */	707	/* by older ones */
654	select (0, 0, 0, 0, &tv);	708	select (0, 0, 0, 0, &tv);
655	#endif	709	#endif
656	}	710	}
657	}	711	}
…		…
1073	/*****************************************************************************/	1127	/*****************************************************************************/
1074		1128
1075	/* associate signal watchers to a signal signal */	1129	/* associate signal watchers to a signal signal */
1076	typedef struct	1130	typedef struct
1077	{	1131	{
		1132	#if EV_MULTIPLICITY
		1133	EV_P;
		1134	#endif
1078	WL head;	1135	WL head;
1079	EV_ATOMIC_T gotsig;	1136	EV_ATOMIC_T gotsig;
1080	} ANSIG;	1137	} ANSIG;
1081		1138
1082	static ANSIG *signals;	1139	static ANSIG signals [EV_NSIG - 1];
1083	static int signalmax;
1084
1085	static EV_ATOMIC_T gotsig;	1140	static EV_ATOMIC_T gotsig;
1086		1141
1087	/*****************************************************************************/	1142	/*****************************************************************************/
1088		1143
1089	/* used to prepare libev internal fd's */	1144	/* used to prepare libev internal fd's */
…		…
1104	evpipe_init (EV_P)	1159	evpipe_init (EV_P)
1105	{	1160	{
1106	if (!ev_is_active (&pipe_w))	1161	if (!ev_is_active (&pipe_w))
1107	{	1162	{
1108	#if EV_USE_EVENTFD	1163	#if EV_USE_EVENTFD
		1164	evfd = eventfd (0, EFD_NONBLOCK \| EFD_CLOEXEC);
		1165	if (evfd < 0 && errno == EINVAL)
1109	if ((evfd = eventfd (0, 0)) >= 0)	1166	evfd = eventfd (0, 0);
		1167
		1168	if (evfd >= 0)
1110	{	1169	{
1111	evpipe [0] = -1;	1170	evpipe [0] = -1;
1112	fd_intern (evfd);	1171	fd_intern (evfd); /* doing it twice doesn't hurt */
1113	ev_io_set (&pipe_w, evfd, EV_READ);	1172	ev_io_set (&pipe_w, evfd, EV_READ);
1114	}	1173	}
1115	else	1174	else
1116	#endif	1175	#endif
1117	{	1176	{
…		…
1172	if (gotsig && ev_is_default_loop (EV_A))	1231	if (gotsig && ev_is_default_loop (EV_A))
1173	{	1232	{
1174	int signum;	1233	int signum;
1175	gotsig = 0;	1234	gotsig = 0;
1176		1235
1177	for (signum = signalmax; signum--; )	1236	for (signum = EV_NSIG - 1; signum--; )
1178	if (signals [signum].gotsig)	1237	if (signals [signum].gotsig)
1179	ev_feed_signal_event (EV_A_ signum + 1);	1238	ev_feed_signal_event (EV_A_ signum + 1);
1180	}	1239	}
1181		1240
1182	#if EV_ASYNC_ENABLE	1241	#if EV_ASYNC_ENABLE
…		…
1199		1258
1200	static void	1259	static void
1201	ev_sighandler (int signum)	1260	ev_sighandler (int signum)
1202	{	1261	{
1203	#if EV_MULTIPLICITY	1262	#if EV_MULTIPLICITY
1204	struct ev_loop *loop = &default_loop_struct;	1263	EV_P = signals [signum - 1].loop;
1205	#endif	1264	#endif
1206		1265
1207	#if _WIN32	1266	#if _WIN32
1208	signal (signum, ev_sighandler);	1267	signal (signum, ev_sighandler);
1209	#endif	1268	#endif
…		…
1219		1278
1220	#if EV_MULTIPLICITY	1279	#if EV_MULTIPLICITY
1221	assert (("libev: feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));	1280	assert (("libev: feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
1222	#endif	1281	#endif
1223		1282
		1283	if (signum <= 0 \|\| signum > EV_NSIG)
		1284	return;
		1285
1224	--signum;	1286	--signum;
1225
1226	if (signum < 0 \|\| signum >= signalmax)
1227	return;
1228		1287
1229	signals [signum].gotsig = 0;	1288	signals [signum].gotsig = 0;
1230		1289
1231	for (w = signals [signum].head; w; w = w->next)	1290	for (w = signals [signum].head; w; w = w->next)
1232	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);	1291	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
1233	}	1292	}
		1293
		1294	#if EV_USE_SIGNALFD
		1295	static void
		1296	sigfdcb (EV_P_ ev_io *iow, int revents)
		1297	{
		1298	struct signalfd_siginfo si[2], sip; / these structs are big */
		1299
		1300	for (;;)
		1301	{
		1302	ssize_t res = read (sigfd, si, sizeof (si));
		1303
		1304	/* not ISO-C, as res might be -1, but works with SuS */
		1305	for (sip = si; (char )sip < (char )si + res; ++sip)
		1306	ev_feed_signal_event (EV_A_ sip->ssi_signo);
		1307
		1308	if (res < (ssize_t)sizeof (si))
		1309	break;
		1310	}
		1311	}
		1312	#endif
1234		1313
1235	/*****************************************************************************/	1314	/*****************************************************************************/
1236		1315
1237	static WL childs [EV_PID_HASHSIZE];	1316	static WL childs [EV_PID_HASHSIZE];
1238		1317
…		…
1458	if (!clock_gettime (CLOCK_MONOTONIC, &ts))	1537	if (!clock_gettime (CLOCK_MONOTONIC, &ts))
1459	have_monotonic = 1;	1538	have_monotonic = 1;
1460	}	1539	}
1461	#endif	1540	#endif
1462		1541
		1542	/* pid check not overridable via env */
		1543	#ifndef _WIN32
		1544	if (flags & EVFLAG_FORKCHECK)
		1545	curpid = getpid ();
		1546	#endif
		1547
		1548	if (!(flags & EVFLAG_NOENV)
		1549	&& !enable_secure ()
		1550	&& getenv ("LIBEV_FLAGS"))
		1551	flags = atoi (getenv ("LIBEV_FLAGS"));
		1552
1463	ev_rt_now = ev_time ();	1553	ev_rt_now = ev_time ();
1464	mn_now = get_clock ();	1554	mn_now = get_clock ();
1465	now_floor = mn_now;	1555	now_floor = mn_now;
1466	rtmn_diff = ev_rt_now - mn_now;	1556	rtmn_diff = ev_rt_now - mn_now;
1467	#if EV_MINIMAL < 2	1557	#if EV_MINIMAL < 2
…		…
1472	timeout_blocktime = 0.;	1562	timeout_blocktime = 0.;
1473	backend = 0;	1563	backend = 0;
1474	backend_fd = -1;	1564	backend_fd = -1;
1475	gotasync = 0;	1565	gotasync = 0;
1476	#if EV_USE_INOTIFY	1566	#if EV_USE_INOTIFY
1477	fs_fd = -2;	1567	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
1478	#endif	1568	#endif
1479		1569	#if EV_USE_SIGNALFD
1480	/* pid check not overridable via env */	1570	sigfd = flags & EVFLAG_NOSIGFD ? -1 : -2;
1481	#ifndef _WIN32
1482	if (flags & EVFLAG_FORKCHECK)
1483	curpid = getpid ();
1484	#endif	1571	#endif
1485
1486	if (!(flags & EVFLAG_NOENV)
1487	&& !enable_secure ()
1488	&& getenv ("LIBEV_FLAGS"))
1489	flags = atoi (getenv ("LIBEV_FLAGS"));
1490		1572
1491	if (!(flags & 0x0000ffffU))	1573	if (!(flags & 0x0000ffffU))
1492	flags \|= ev_recommended_backends ();	1574	flags \|= ev_recommended_backends ();
1493		1575
1494	#if EV_USE_PORT	1576	#if EV_USE_PORT
…		…
1520	{	1602	{
1521	int i;	1603	int i;
1522		1604
1523	if (ev_is_active (&pipe_w))	1605	if (ev_is_active (&pipe_w))
1524	{	1606	{
1525	ev_ref (EV_A); /* signal watcher */	1607	/ev_ref (EV_A);/
1526	ev_io_stop (EV_A_ &pipe_w);	1608	/ev_io_stop (EV_A_ &pipe_w);/
1527		1609
1528	#if EV_USE_EVENTFD	1610	#if EV_USE_EVENTFD
1529	if (evfd >= 0)	1611	if (evfd >= 0)
1530	close (evfd);	1612	close (evfd);
1531	#endif	1613	#endif
…		…
1535	close (evpipe [0]);	1617	close (evpipe [0]);
1536	close (evpipe [1]);	1618	close (evpipe [1]);
1537	}	1619	}
1538	}	1620	}
1539		1621
		1622	#if EV_USE_SIGNALFD
		1623	if (ev_is_active (&sigfd_w))
		1624	{
		1625	/ev_ref (EV_A);/
		1626	/ev_io_stop (EV_A_ &sigfd_w);/
		1627
		1628	close (sigfd);
		1629	}
		1630	#endif
		1631
1540	#if EV_USE_INOTIFY	1632	#if EV_USE_INOTIFY
1541	if (fs_fd >= 0)	1633	if (fs_fd >= 0)
1542	close (fs_fd);	1634	close (fs_fd);
1543	#endif	1635	#endif
1544		1636
…		…
1567	#if EV_IDLE_ENABLE	1659	#if EV_IDLE_ENABLE
1568	array_free (idle, [i]);	1660	array_free (idle, [i]);
1569	#endif	1661	#endif
1570	}	1662	}
1571		1663
1572	ev_free (anfds); anfdmax = 0;	1664	ev_free (anfds); anfds = 0; anfdmax = 0;
1573		1665
1574	/* have to use the microsoft-never-gets-it-right macro */	1666	/* have to use the microsoft-never-gets-it-right macro */
1575	array_free (rfeed, EMPTY);	1667	array_free (rfeed, EMPTY);
1576	array_free (fdchange, EMPTY);	1668	array_free (fdchange, EMPTY);
1577	array_free (timer, EMPTY);	1669	array_free (timer, EMPTY);
…		…
1644	#if EV_MULTIPLICITY	1736	#if EV_MULTIPLICITY
1645		1737
1646	struct ev_loop *	1738	struct ev_loop *
1647	ev_loop_new (unsigned int flags)	1739	ev_loop_new (unsigned int flags)
1648	{	1740	{
1649	struct ev_loop loop = (struct ev_loop )ev_malloc (sizeof (struct ev_loop));	1741	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
1650		1742
1651	memset (loop, 0, sizeof (struct ev_loop));	1743	memset (EV_A, 0, sizeof (struct ev_loop));
1652
1653	loop_init (EV_A_ flags);	1744	loop_init (EV_A_ flags);
1654		1745
1655	if (ev_backend (EV_A))	1746	if (ev_backend (EV_A))
1656	return loop;	1747	return EV_A;
1657		1748
1658	return 0;	1749	return 0;
1659	}	1750	}
1660		1751
1661	void	1752	void
…		…
1765	assert (checkmax >= checkcnt);	1856	assert (checkmax >= checkcnt);
1766	array_verify (EV_A_ (W *)checks, checkcnt);	1857	array_verify (EV_A_ (W *)checks, checkcnt);
1767		1858
1768	# if 0	1859	# if 0
1769	for (w = (ev_child )childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child )((WL)w)->next)	1860	for (w = (ev_child )childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child )((WL)w)->next)
1770	for (signum = signalmax; signum--; ) if (signals [signum].gotsig)	1861	for (signum = EV_NSIG; signum--; ) if (signals [signum].gotsig)
1771	# endif	1862	# endif
1772	#endif	1863	#endif
1773	}	1864	}
1774	#endif	1865	#endif
1775		1866
…		…
1782	#endif	1873	#endif
1783	{	1874	{
1784	if (!ev_default_loop_ptr)	1875	if (!ev_default_loop_ptr)
1785	{	1876	{
1786	#if EV_MULTIPLICITY	1877	#if EV_MULTIPLICITY
1787	struct ev_loop *loop = ev_default_loop_ptr = &default_loop_struct;	1878	EV_P = ev_default_loop_ptr = &default_loop_struct;
1788	#else	1879	#else
1789	ev_default_loop_ptr = 1;	1880	ev_default_loop_ptr = 1;
1790	#endif	1881	#endif
1791		1882
1792	loop_init (EV_A_ flags);	1883	loop_init (EV_A_ flags);
…		…
1809		1900
1810	void	1901	void
1811	ev_default_destroy (void)	1902	ev_default_destroy (void)
1812	{	1903	{
1813	#if EV_MULTIPLICITY	1904	#if EV_MULTIPLICITY
1814	struct ev_loop *loop = ev_default_loop_ptr;	1905	EV_P = ev_default_loop_ptr;
1815	#endif	1906	#endif
1816		1907
1817	ev_default_loop_ptr = 0;	1908	ev_default_loop_ptr = 0;
1818		1909
1819	#ifndef _WIN32	1910	#ifndef _WIN32
…		…
1826		1917
1827	void	1918	void
1828	ev_default_fork (void)	1919	ev_default_fork (void)
1829	{	1920	{
1830	#if EV_MULTIPLICITY	1921	#if EV_MULTIPLICITY
1831	struct ev_loop *loop = ev_default_loop_ptr;	1922	EV_P = ev_default_loop_ptr;
1832	#endif	1923	#endif
1833		1924
1834	postfork = 1; /* must be in line with ev_loop_fork */	1925	postfork = 1; /* must be in line with ev_loop_fork */
1835	}	1926	}
1836		1927
…		…
1838		1929
1839	void	1930	void
1840	ev_invoke (EV_P_ void *w, int revents)	1931	ev_invoke (EV_P_ void *w, int revents)
1841	{	1932	{
1842	EV_CB_INVOKE ((W)w, revents);	1933	EV_CB_INVOKE ((W)w, revents);
		1934	}
		1935
		1936	unsigned int
		1937	ev_pending_count (EV_P)
		1938	{
		1939	int pri;
		1940	unsigned int count = 0;
		1941
		1942	for (pri = NUMPRI; pri--; )
		1943	count += pendingcnt [pri];
		1944
		1945	return count;
1843	}	1946	}
1844		1947
1845	void noinline	1948	void noinline
1846	ev_invoke_pending (EV_P)	1949	ev_invoke_pending (EV_P)
1847	{	1950	{
…		…
2475	}	2578	}
2476		2579
2477	EV_FREQUENT_CHECK;	2580	EV_FREQUENT_CHECK;
2478	}	2581	}
2479		2582
		2583	ev_tstamp
		2584	ev_timer_remaining (EV_P_ ev_timer *w)
		2585	{
		2586	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
		2587	}
		2588
2480	#if EV_PERIODIC_ENABLE	2589	#if EV_PERIODIC_ENABLE
2481	void noinline	2590	void noinline
2482	ev_periodic_start (EV_P_ ev_periodic *w)	2591	ev_periodic_start (EV_P_ ev_periodic *w)
2483	{	2592	{
2484	if (expect_false (ev_is_active (w)))	2593	if (expect_false (ev_is_active (w)))
…		…
2551	#endif	2660	#endif
2552		2661
2553	void noinline	2662	void noinline
2554	ev_signal_start (EV_P_ ev_signal *w)	2663	ev_signal_start (EV_P_ ev_signal *w)
2555	{	2664	{
2556	#if EV_MULTIPLICITY
2557	assert (("libev: signal watchers are only supported in the default loop", loop == ev_default_loop_ptr));
2558	#endif
2559	if (expect_false (ev_is_active (w)))	2665	if (expect_false (ev_is_active (w)))
2560	return;	2666	return;
2561		2667
2562	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0));	2668	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
2563		2669
2564	evpipe_init (EV_A);	2670	#if EV_MULTIPLICITY
		2671	assert (("libev: tried to attach to a signal from two different loops",
		2672	!signals [w->signum - 1].loop \|\| signals [w->signum - 1].loop == loop));
2565		2673
2566	EV_FREQUENT_CHECK;	2674	signals [w->signum - 1].loop = EV_A;
		2675	#endif
2567		2676
		2677	EV_FREQUENT_CHECK;
		2678
		2679	#if EV_USE_SIGNALFD
		2680	if (sigfd == -2)
2568	{	2681	{
2569	#ifndef _WIN32	2682	sigfd = signalfd (-1, &sigfd_set, SFD_NONBLOCK \| SFD_CLOEXEC);
2570	sigset_t full, prev;	2683	if (sigfd < 0 && errno == EINVAL)
2571	sigfillset (&full);	2684	sigfd = signalfd (-1, &sigfd_set, 0); /* retry without flags */
2572	sigprocmask (SIG_SETMASK, &full, &prev);
2573	#endif
2574		2685
2575	array_needsize (ANSIG, signals, signalmax, w->signum, array_init_zero);	2686	if (sigfd >= 0)
		2687	{
		2688	fd_intern (sigfd); /* doing it twice will not hurt */
2576		2689
2577	#ifndef _WIN32	2690	sigemptyset (&sigfd_set);
2578	sigprocmask (SIG_SETMASK, &prev, 0);	2691
2579	#endif	2692	ev_io_init (&sigfd_w, sigfdcb, sigfd, EV_READ);
		2693	ev_set_priority (&sigfd_w, EV_MAXPRI);
		2694	ev_io_start (EV_A_ &sigfd_w);
		2695	ev_unref (EV_A); /* signalfd watcher should not keep loop alive */
		2696	}
2580	}	2697	}
		2698
		2699	if (sigfd >= 0)
		2700	{
		2701	/* TODO: check .head */
		2702	sigaddset (&sigfd_set, w->signum);
		2703	sigprocmask (SIG_BLOCK, &sigfd_set, 0);
		2704
		2705	signalfd (sigfd, &sigfd_set, 0);
		2706	}
		2707	#endif
2581		2708
2582	ev_start (EV_A_ (W)w, 1);	2709	ev_start (EV_A_ (W)w, 1);
2583	wlist_add (&signals [w->signum - 1].head, (WL)w);	2710	wlist_add (&signals [w->signum - 1].head, (WL)w);
2584		2711
2585	if (!((WL)w)->next)	2712	if (!((WL)w)->next)
		2713	# if EV_USE_SIGNALFD
		2714	if (sigfd < 0) /TODO/
		2715	# endif
2586	{	2716	{
2587	#if _WIN32	2717	# if _WIN32
2588	signal (w->signum, ev_sighandler);	2718	signal (w->signum, ev_sighandler);
2589	#else	2719	# else
2590	struct sigaction sa;	2720	struct sigaction sa;
		2721
		2722	evpipe_init (EV_A);
		2723
2591	sa.sa_handler = ev_sighandler;	2724	sa.sa_handler = ev_sighandler;
2592	sigfillset (&sa.sa_mask);	2725	sigfillset (&sa.sa_mask);
2593	sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */	2726	sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
2594	sigaction (w->signum, &sa, 0);	2727	sigaction (w->signum, &sa, 0);
		2728
		2729	sigemptyset (&sa.sa_mask);
		2730	sigaddset (&sa.sa_mask, w->signum);
		2731	sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
2595	#endif	2732	#endif
2596	}	2733	}
2597		2734
2598	EV_FREQUENT_CHECK;	2735	EV_FREQUENT_CHECK;
2599	}	2736	}
2600		2737
2601	void noinline	2738	void noinline
…		…
2609		2746
2610	wlist_del (&signals [w->signum - 1].head, (WL)w);	2747	wlist_del (&signals [w->signum - 1].head, (WL)w);
2611	ev_stop (EV_A_ (W)w);	2748	ev_stop (EV_A_ (W)w);
2612		2749
2613	if (!signals [w->signum - 1].head)	2750	if (!signals [w->signum - 1].head)
		2751	{
		2752	#if EV_MULTIPLICITY
		2753	signals [w->signum - 1].loop = 0; /* unattach from signal */
		2754	#endif
		2755	#if EV_USE_SIGNALFD
		2756	if (sigfd >= 0)
		2757	{
		2758	sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D
		2759	sigdelset (&sigfd_set, w->signum);
		2760	signalfd (sigfd, &sigfd_set, 0);
		2761	sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D
		2762	/TODO: maybe unblock signal? /
		2763	}
		2764	else
		2765	#endif
2614	signal (w->signum, SIG_DFL);	2766	signal (w->signum, SIG_DFL);
		2767	}
2615		2768
2616	EV_FREQUENT_CHECK;	2769	EV_FREQUENT_CHECK;
2617	}	2770	}
2618		2771
2619	void	2772	void
…		…
3099	embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)	3252	embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)
3100	{	3253	{
3101	ev_embed w = (ev_embed )(((char *)prepare) - offsetof (ev_embed, prepare));	3254	ev_embed w = (ev_embed )(((char *)prepare) - offsetof (ev_embed, prepare));
3102		3255
3103	{	3256	{
3104	struct ev_loop *loop = w->other;	3257	EV_P = w->other;
3105		3258
3106	while (fdchangecnt)	3259	while (fdchangecnt)
3107	{	3260	{
3108	fd_reify (EV_A);	3261	fd_reify (EV_A);
3109	ev_loop (EV_A_ EVLOOP_NONBLOCK);	3262	ev_loop (EV_A_ EVLOOP_NONBLOCK);
…		…
3117	ev_embed w = (ev_embed )(((char *)fork_w) - offsetof (ev_embed, fork));	3270	ev_embed w = (ev_embed )(((char *)fork_w) - offsetof (ev_embed, fork));
3118		3271
3119	ev_embed_stop (EV_A_ w);	3272	ev_embed_stop (EV_A_ w);
3120		3273
3121	{	3274	{
3122	struct ev_loop *loop = w->other;	3275	EV_P = w->other;
3123		3276
3124	ev_loop_fork (EV_A);	3277	ev_loop_fork (EV_A);
3125	ev_loop (EV_A_ EVLOOP_NONBLOCK);	3278	ev_loop (EV_A_ EVLOOP_NONBLOCK);
3126	}	3279	}
3127		3280
…		…
3141	{	3294	{
3142	if (expect_false (ev_is_active (w)))	3295	if (expect_false (ev_is_active (w)))
3143	return;	3296	return;
3144		3297
3145	{	3298	{
3146	struct ev_loop *loop = w->other;	3299	EV_P = w->other;
3147	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));	3300	assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
3148	ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);	3301	ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);
3149	}	3302	}
3150		3303
3151	EV_FREQUENT_CHECK;	3304	EV_FREQUENT_CHECK;
…		…
3422	if (types & EV_CHECK)	3575	if (types & EV_CHECK)
3423	for (i = checkcnt; i--; )	3576	for (i = checkcnt; i--; )
3424	cb (EV_A_ EV_CHECK, checks [i]);	3577	cb (EV_A_ EV_CHECK, checks [i]);
3425		3578
3426	if (types & EV_SIGNAL)	3579	if (types & EV_SIGNAL)
3427	for (i = 0; i < signalmax; ++i)	3580	for (i = 0; i < EV_NSIG - 1; ++i)
3428	for (wl = signals [i].head; wl; )	3581	for (wl = signals [i].head; wl; )
3429	{	3582	{
3430	wn = wl->next;	3583	wn = wl->next;
3431	cb (EV_A_ EV_SIGNAL, wl);	3584	cb (EV_A_ EV_SIGNAL, wl);
3432	wl = wn;	3585	wl = wn;

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.298 by root, Fri Jul 10 19:10:19 2009 UTC vs. Revision 1.306 by root, Sun Jul 19 06:35:25 2009 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.298 by root, Fri Jul 10 19:10:19 2009 UTC vs.
Revision 1.306 by root, Sun Jul 19 06:35:25 2009 UTC