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

Comparing libev/event.c (file contents):
Revision 1.3 by root, Fri Nov 2 11:02:23 2007 UTC vs.
Revision 1.24 by root, Fri Nov 9 17:07:59 2007 UTC

…		…
29	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	29	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30	*/	30	*/
31		31
32	#include <stddef.h>	32	#include <stddef.h>
33	#include <stdlib.h>	33	#include <stdlib.h>
		34	#include <assert.h>
		35
		36	#ifndef WIN32
34	#include <sys/time.h>	37	# include <sys/time.h>
		38	#endif
35		39
		40	#ifdef EV_EVENT_H
		41	# include EV_EVENT_H
		42	#else
36	#include "event.h"	43	# include "event.h"
		44	#endif
37		45
		46	#if EV_MULTIPLICITY
		47	# define dLOOPev struct ev_loop loop = (struct ev_loop )ev->ev_base
		48	# define dLOOPbase struct ev_loop loop = (struct ev_loop )base
		49	#else
		50	# define dLOOPev
		51	# define dLOOPbase
		52	#endif
		53
		54	/* never accessed, will always be cast from/to ev_loop */
38	struct event_base	55	struct event_base
39	{	56	{
40	int dummy;	57	int dummy;
41	};	58	};
42		59
43	static int x_actives;
44
45	static struct event_base x_base, *x_cur;	60	static struct event_base *x_cur;
46		61
47	static void	62	static void
48	tv_set (struct timeval *tv, ev_tstamp at)	63	tv_set (struct timeval *tv, ev_tstamp at)
49	{	64	{
50	tv->tv_sec = (long)at;	65	tv->tv_sec = (long)at;
…		…
72	return "libev";	87	return "libev";
73	}	88	}
74		89
75	void *event_init (void)	90	void *event_init (void)
76	{	91	{
77	if (ev_init (0))	92	#if EV_MULTIPLICITY
78	return x_cur = &x_base;	93	if (x_cur)
		94	x_cur = (struct event_base *)ev_loop_new (EVMETHOD_AUTO);
		95	else
		96	x_cur = (struct event_base *)ev_default_loop (EVMETHOD_AUTO);
		97	#else
		98	assert (("multiple event bases not supported when not compiled with EV_MULTIPLICITY", !x_cur));
79		99
		100	x_cur = (struct event_base *)(long)ev_default_loop (EVMETHOD_AUTO);
		101	#endif
		102
80	return 0;	103	return x_cur;
81	}	104	}
82		105
83	void event_base_free (struct event_base *base)	106	void event_base_free (struct event_base *base)
84	{	107	{
		108	dLOOPbase;
		109
		110	#if EV_MULTIPLICITY
		111	if (ev_default_loop (EVMETHOD_AUTO) != loop)
		112	ev_loop_destroy (loop);
		113	#endif
		114	}
		115
		116	int event_dispatch (void)
		117	{
		118	return event_base_dispatch (x_cur);
		119	}
		120
		121	#ifdef EV_STANDALONE
		122	void event_set_log_callback (event_log_cb cb)
		123	{
85	/* nop */	124	/* nop */
86	}	125	}
87		126	#endif
88	int event_dispatch (void)
89	{
90	return event_base_dispatch (x_cur);
91	}
92
93	void event_set_log_callback (event_log_cb cb)
94	{
95	/* nop */
96	}
97		127
98	int event_loop (int flags)	128	int event_loop (int flags)
99	{	129	{
100	return event_base_loop (x_cur, flags);	130	return event_base_loop (x_cur, flags);
101	}	131	}
102		132
103	int event_loopexit (struct timeval *tv)	133	int event_loopexit (struct timeval *tv)
104	{	134	{
105	event_base_loopexit (x_cur, tv);	135	return event_base_loopexit (x_cur, tv);
106	}	136	}
107		137
108	static void	138	static void
109	x_cb (struct event *ev, int revents)	139	x_cb (struct event *ev, int revents)
110	{	140	{
111	if (ev_is_active (&ev->sig))
112	{
113	ev_signal_stop (&ev->sig);
114	--x_actives;
115	}
116
117	if (!(ev->ev_events & EV_PERSIST) && ev_is_active (&ev->io))
118	{
119	ev_io_stop (&ev->io);
120	--x_actives;
121	}
122
123	revents &= EV_READ \| EV_WRITE \| EV_TIMEOUT \| EV_SIGNAL;	141	revents &= EV_READ \| EV_WRITE \| EV_TIMEOUT \| EV_SIGNAL;
124
125	if (revents & EV_TIMEOUT)
126	--x_actives;
127		142
128	ev->ev_res = revents;	143	ev->ev_res = revents;
129	ev->ev_callback (ev->ev_fd, revents, ev->ev_arg);	144	ev->ev_callback (ev->ev_fd, revents, ev->ev_arg);
130	}	145	}
131		146
132	static void	147	static void
133	x_cb_io (struct ev_io *w, int revents)
134	{
135	x_cb ((struct event )(((char )w) - offsetof (struct event, io)), revents);
136	}
137
138	static void
139	x_cb_to (struct ev_timer *w, int revents)
140	{
141	x_cb ((struct event )(((char )w) - offsetof (struct event, to)), revents);
142	}
143
144	static void
145	x_cb_sig (struct ev_signal *w, int revents)	148	x_cb_sig (EV_P_ struct ev_signal *w, int revents)
146	{	149	{
		150	struct event ev = (struct event )(((char *)w) - offsetof (struct event, iosig.sig));
		151
		152	if (revents & EV_ERROR)
		153	event_del (ev);
		154
		155	x_cb (ev, revents);
		156	}
		157
		158	static void
		159	x_cb_io (EV_P_ struct ev_io *w, int revents)
		160	{
147	x_cb ((struct event )(((char )w) - offsetof (struct event, sig)), revents);	161	struct event ev = (struct event )(((char *)w) - offsetof (struct event, iosig.io));
		162
		163	if (revents & EV_ERROR)
		164	event_del (ev);
		165	else if (!(ev->ev_events & EV_PERSIST) && ev_is_active (w))
		166	ev_io_stop (EV_A_ w);
		167
		168	x_cb (ev, revents);
		169	}
		170
		171	static void
		172	x_cb_to (EV_P_ struct ev_timer *w, int revents)
		173	{
		174	struct event ev = (struct event )(((char *)w) - offsetof (struct event, to));
		175
		176	event_del (ev);
		177
		178	x_cb (ev, revents);
148	}	179	}
149		180
150	void event_set (struct event ev, int fd, short events, void (cb)(int, short, void ), void arg)	181	void event_set (struct event ev, int fd, short events, void (cb)(int, short, void ), void arg)
151	{	182	{
		183	if (events & EV_SIGNAL)
		184	ev_watcher_init (&ev->iosig.sig, x_cb_sig);
		185	else
152	ev_watcher_init (&ev->io, x_cb_io);	186	ev_watcher_init (&ev->iosig.io, x_cb_io);
		187
153	ev_watcher_init (&ev->to, x_cb_to);	188	ev_watcher_init (&ev->to, x_cb_to);
154	ev_watcher_init (&ev->sig, x_cb_sig);
155		189
156	ev->ev_base = x_cur;	190	ev->ev_base = x_cur; /* not threadsafe, but its like libevent works */
157	ev->ev_fd = fd;	191	ev->ev_fd = fd;
158	ev->ev_events = events;	192	ev->ev_events = events;
159	ev->ev_pri = 0;	193	ev->ev_pri = 0;
160	ev->ev_callback = cb;	194	ev->ev_callback = cb;
161	ev->ev_arg = arg;	195	ev->ev_arg = arg;
162	ev->ev_res = 0;	196	ev->ev_res = 0;
163	}	197	}
164		198
165	int event_once (int fd, short events, void (cb)(int, short, void ), void arg, struct timeval tv)	199	int event_once (int fd, short events, void (cb)(int, short, void ), void arg, struct timeval tv)
166	{	200	{
167	event_base_once (x_cur, fd, events, cb, arg, tv);	201	return event_base_once (x_cur, fd, events, cb, arg, tv);
168	}	202	}
169		203
170	int event_add (struct event ev, struct timeval tv)	204	int event_add (struct event ev, struct timeval tv)
171	{	205	{
		206	dLOOPev;
		207
		208	/* disable all watchers */
		209	event_del (ev);
		210
		211	if (ev->ev_events & EV_SIGNAL)
		212	{
		213	ev_signal_set (&ev->iosig.sig, ev->ev_fd);
		214	ev_signal_start (EV_A_ &ev->iosig.sig);
		215	}
		216	else if (ev->ev_events & (EV_READ \| EV_WRITE))
		217	{
		218	ev_io_set (&ev->iosig.io, ev->ev_fd, ev->ev_events & (EV_READ \| EV_WRITE));
		219	ev_io_start (EV_A_ &ev->iosig.io);
		220	}
		221
172	if (tv)	222	if (tv)
173	{	223	{
174	if (ev_is_active (&ev->to))
175	{
176	ev_timer_stop (&ev->to);
177	--x_actives;
178	}
179
180	ev_timer_set (&ev->to, tv_get (tv), 0.);	224	ev_timer_set (&ev->to, tv_get (tv), 0.);
181	ev_timer_start (&ev->to);	225	ev_timer_start (EV_A_ &ev->to);
182	++x_actives;
183	}
184
185	if (ev->ev_events & (EV_READ \| EV_WRITE))
186	{	226	}
187	if (ev_is_active (&ev->io))
188	{
189	ev_io_stop (&ev->io);
190	--x_actives;
191	}
192		227
193	ev_io_set (&ev->io, ev->ev_fd, ev->ev_events & (EV_READ \| EV_WRITE));	228	return 0;
194	ev_io_start (&ev->io);	229	}
195	++x_actives;	230
196	}	231	int event_del (struct event *ev)
		232	{
		233	dLOOPev;
197		234
198	if (ev->ev_events & EV_SIGNAL)	235	if (ev->ev_events & EV_SIGNAL)
199	{	236	{
		237	/* sig */
		238	if (ev_is_active (&ev->iosig.sig))
		239	ev_signal_stop (EV_A_ &ev->iosig.sig);
		240	}
		241	else if (ev->ev_events & (EV_READ \| EV_WRITE))
		242	{
		243	/* io */
200	if (ev_is_active (&ev->sig))	244	if (ev_is_active (&ev->iosig.io))
201	{
202	ev_signal_stop (&ev->sig);
203	--x_actives;
204	}
205
206	ev_signal_set (&ev->sig, ev->ev_fd);
207	ev_signal_start (&ev->sig);
208	++x_actives;
209	}
210
211	return 0;
212	}
213
214	int event_del (struct event *ev)
215	{
216	if (ev_is_active (&ev->io))
217	{
218	ev_io_stop (&ev->io);	245	ev_io_stop (EV_A_ &ev->iosig.io);
219	--x_actives;
220	}	246	}
221		247
222	if (ev_is_active (&ev->to))	248	if (ev_is_active (&ev->to))
223	{
224	ev_timer_stop (&ev->to);	249	ev_timer_stop (EV_A_ &ev->to);
225	--x_actives;
226	}
227		250
228	if (ev_is_active (&ev->sig))
229	{
230	ev_signal_stop (&ev->sig);
231	--x_actives;
232	}
233
234	return 0;	251	return 0;
		252	}
		253
		254	void event_active (struct event *ev, int res, short ncalls)
		255	{
		256	dLOOPev;
		257
		258	if (res & EV_TIMEOUT)
		259	ev_feed_event (EV_A_ &ev->to, res & EV_TIMEOUT);
		260
		261	if (res & EV_SIGNAL)
		262	ev_feed_event (EV_A_ &ev->iosig.sig, res & EV_SIGNAL);
		263
		264	if (res & (EV_READ \| EV_WRITE))
		265	ev_feed_event (EV_A_ &ev->iosig.io, res & (EV_READ \| EV_WRITE));
235	}	266	}
236		267
237	int event_pending (struct event ev, short events, struct timeval tv)	268	int event_pending (struct event ev, short events, struct timeval tv)
238	{	269	{
239	short revents;	270	short revents = 0;
		271	dLOOPev;
240		272
241	if (ev->io.pending)	273
		274	if (ev->ev_events & EV_SIGNAL)
		275	{
		276	/* sig */
		277	if (ev_is_active (&ev->iosig.sig) \|\| ev_is_pending (&ev->iosig.sig))
		278	revents \|= EV_SIGNAL;
		279	}
		280	else if (ev->ev_events & (EV_READ \| EV_WRITE))
		281	{
		282	/* io */
		283	if (ev_is_active (&ev->iosig.io) \|\| ev_is_pending (&ev->iosig.io))
242	revents \|= ev->ev_events & (EV_READ \| EV_WRITE);	284	revents \|= ev->ev_events & (EV_READ \| EV_WRITE);
		285	}
243		286
244	if (ev->to.pending)	287	if (ev->ev_events & EV_TIMEOUT \|\| ev_is_active (&ev->to) \|\| ev_is_pending (&ev->to))
245	{	288	{
246	revents \|= EV_TIMEOUT;	289	revents \|= EV_TIMEOUT;
247		290
248	if (tv)	291	if (tv)
249	tv_set (tv, ev_now); /* not sure if this is right :) */	292	tv_set (tv, ev_now (EV_A)); /* not sure if this is right :) */
250	}	293	}
251
252	if (ev->sig.pending)
253	revents \|= EV_SIGNAL;
254		294
255	return events & revents;	295	return events & revents;
256	}	296	}
257		297
258	int event_priority_init (int npri)	298	int event_priority_init (int npri)
…		…
274	return 0;	314	return 0;
275	}	315	}
276		316
277	int event_base_loop (struct event_base *base, int flags)	317	int event_base_loop (struct event_base *base, int flags)
278	{	318	{
279	do	319	dLOOPbase;
280	{	320
281	ev_loop (flags \| EVLOOP_ONESHOT);	321	ev_loop (EV_A_ flags);
282	}
283	while (!(flags & (EVLOOP_ONESHOT \| EVLOOP_NONBLOCK)) && x_actives && !ev_loop_done);
284		322
285	return 0;	323	return 0;
286	}	324	}
287		325
288	int event_base_dispatch (struct event_base *base)	326	int event_base_dispatch (struct event_base *base)
289	{	327	{
290	return event_base_loop (base, 0);	328	return event_base_loop (base, 0);
291	}	329	}
292		330
293	static void	331	static void
294	x_loopexit_cb (int revents, void *arg)	332	x_loopexit_cb (int revents, void *base)
295	{	333	{
296	ev_loop_done = 2;	334	dLOOPbase;
		335
		336	ev_unloop (EV_A_ EVUNLOOP_ONCE);
297	}	337	}
298		338
299	int event_base_loopexit (struct event_base base, struct timeval tv)	339	int event_base_loopexit (struct event_base base, struct timeval tv)
300	{	340	{
301	ev_tstamp after = tv_get (tv);	341	ev_tstamp after = tv_get (tv);
		342	dLOOPbase;
302		343
303	ev_once (-1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);	344	ev_once (EV_A_ -1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);
		345
		346	return -1;
304	}	347	}
305		348
306	struct x_once	349	struct x_once
307	{	350	{
308	int fd;	351	int fd;
…		…
311	};	354	};
312		355
313	static void	356	static void
314	x_once_cb (int revents, void *arg)	357	x_once_cb (int revents, void *arg)
315	{	358	{
316	struct x_once *once = arg;	359	struct x_once once = (struct x_once )arg;
317		360
318	once->cb (once->fd, revents, once->arg);	361	once->cb (once->fd, revents, once->arg);
319	free (once);	362	free (once);
320	}	363	}
321		364
322	int event_base_once (struct event_base base, int fd, short events, void (cb)(int, short, void ), void arg, struct timeval *tv)	365	int event_base_once (struct event_base base, int fd, short events, void (cb)(int, short, void ), void arg, struct timeval *tv)
323	{	366	{
324	struct x_once *once = malloc (sizeof (struct x_once));	367	struct x_once once = (struct x_once )malloc (sizeof (struct x_once));
		368	dLOOPbase;
325		369
326	if (!once)	370	if (!once)
327	return -1;	371	return -1;
328		372
329	once->fd = fd;	373	once->fd = fd;
330	once->cb = cb;	374	once->cb = cb;
331	once->arg = arg;	375	once->arg = arg;
332		376
333	ev_once (fd, events & (EV_READ \| EV_WRITE), tv_get (tv), x_once_cb, (void *)once);	377	ev_once (EV_A_ fd, events & (EV_READ \| EV_WRITE), tv_get (tv), x_once_cb, (void *)once);
334		378
335	return 0;	379	return 0;
336	}	380	}
337		381
338	int event_base_priority_init (struct event_base *base, int npri)	382	int event_base_priority_init (struct event_base *base, int npri)
339	{	383	{
340	return 0;	384	/dLOOPbase;/
341	}
342		385
		386	return 0;
		387	}
		388

Diff Legend

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

Comparing libev/event.c (file contents): Revision 1.3 by root, Fri Nov 2 11:02:23 2007 UTC vs. Revision 1.24 by root, Fri Nov 9 17:07:59 2007 UTC

Diff Legend

Comparing libev/event.c (file contents):
Revision 1.3 by root, Fri Nov 2 11:02:23 2007 UTC vs.
Revision 1.24 by root, Fri Nov 9 17:07:59 2007 UTC