ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.15 by root, Wed Oct 31 11:56:34 2007 UTC vs.
Revision 1.68 by root, Mon Nov 5 20:19:00 2007 UTC

1/*
2 * libev event processing core, watcher management
3 *
4 * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer in the documentation and/or other materials provided
17 * with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31#ifndef EV_STANDALONE
32# include "config.h"
33
34# if HAVE_CLOCK_GETTIME
35# define EV_USE_MONOTONIC 1
36# define EV_USE_REALTIME 1
37# endif
38
39# if HAVE_SELECT && HAVE_SYS_SELECT_H
40# define EV_USE_SELECT 1
41# endif
42
43# if HAVE_POLL && HAVE_POLL_H
44# define EV_USE_POLL 1
45# endif
46
47# if HAVE_EPOLL && HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
48# define EV_USE_EPOLL 1
49# endif
50
51# if HAVE_KQUEUE && HAVE_WORKING_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
52# define EV_USE_KQUEUE 1
53# endif
54
55#endif
56
1#include <math.h> 57#include <math.h>
2#include <stdlib.h> 58#include <stdlib.h>
3#include <unistd.h> 59#include <unistd.h>
4#include <fcntl.h> 60#include <fcntl.h>
5#include <signal.h> 61#include <signal.h>
62#include <stddef.h>
6 63
7#include <stdio.h> 64#include <stdio.h>
8 65
9#include <assert.h> 66#include <assert.h>
10#include <errno.h> 67#include <errno.h>
68#include <sys/types.h>
69#ifndef WIN32
70# include <sys/wait.h>
71#endif
11#include <sys/time.h> 72#include <sys/time.h>
12#include <time.h> 73#include <time.h>
13 74
14#define HAVE_EPOLL 1 75/**/
15 76
16#ifndef HAVE_MONOTONIC 77#ifndef EV_USE_MONOTONIC
17# ifdef CLOCK_MONOTONIC
18# define HAVE_MONOTONIC 1 78# define EV_USE_MONOTONIC 1
79#endif
80
81#ifndef EV_USE_SELECT
82# define EV_USE_SELECT 1
83#endif
84
85#ifndef EV_USE_POLL
86# define EV_USE_POLL 0 /* poll is usually slower than select, and not as well tested */
87#endif
88
89#ifndef EV_USE_EPOLL
90# define EV_USE_EPOLL 0
91#endif
92
93#ifndef EV_USE_KQUEUE
94# define EV_USE_KQUEUE 0
95#endif
96
97#ifndef EV_USE_WIN32
98# ifdef WIN32
99# define EV_USE_WIN32 1
100# else
101# define EV_USE_WIN32 0
19# endif 102# endif
20#endif 103#endif
21 104
22#ifndef HAVE_SELECT
23# define HAVE_SELECT 1
24#endif
25
26#ifndef HAVE_EPOLL
27# define HAVE_EPOLL 0
28#endif
29
30#ifndef HAVE_REALTIME 105#ifndef EV_USE_REALTIME
31# define HAVE_REALTIME 1 /* posix requirement, but might be slower */ 106# define EV_USE_REALTIME 1
32#endif 107#endif
108
109/**/
110
111#ifndef CLOCK_MONOTONIC
112# undef EV_USE_MONOTONIC
113# define EV_USE_MONOTONIC 0
114#endif
115
116#ifndef CLOCK_REALTIME
117# undef EV_USE_REALTIME
118# define EV_USE_REALTIME 0
119#endif
120
121/**/
33 122
34#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */ 123#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
35#define MAX_BLOCKTIME 60. 124#define MAX_BLOCKTIME 59.731 /* never wait longer than this time (to detect time jumps) */
125#define PID_HASHSIZE 16 /* size of pid hash table, must be power of two */
126/*#define CLEANUP_INTERVAL 300. /* how often to try to free memory and re-check fds */
36 127
37#include "ev.h" 128#include "ev.h"
129
130#if __GNUC__ >= 3
131# define expect(expr,value) __builtin_expect ((expr),(value))
132# define inline inline
133#else
134# define expect(expr,value) (expr)
135# define inline static
136#endif
137
138#define expect_false(expr) expect ((expr) != 0, 0)
139#define expect_true(expr) expect ((expr) != 0, 1)
140
141#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
142#define ABSPRI(w) ((w)->priority - EV_MINPRI)
38 143
39typedef struct ev_watcher *W; 144typedef struct ev_watcher *W;
40typedef struct ev_watcher_list *WL; 145typedef struct ev_watcher_list *WL;
41typedef struct ev_watcher_time *WT; 146typedef struct ev_watcher_time *WT;
42 147
43static ev_tstamp now, diff; /* monotonic clock */ 148static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
44ev_tstamp ev_now;
45int ev_method;
46 149
47static int have_monotonic; /* runtime */ 150#if WIN32
48 151/* note: the comment below could not be substantiated, but what would I care */
49static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */ 152/* MSDN says this is required to handle SIGFPE */
50static void (*method_modify)(int fd, int oev, int nev); 153volatile double SIGFPE_REQ = 0.0f;
51static void (*method_poll)(ev_tstamp timeout); 154#endif
52 155
53/*****************************************************************************/ 156/*****************************************************************************/
54 157
55ev_tstamp 158typedef struct
159{
160 WL head;
161 unsigned char events;
162 unsigned char reify;
163} ANFD;
164
165typedef struct
166{
167 W w;
168 int events;
169} ANPENDING;
170
171#if EV_MULTIPLICITY
172
173struct ev_loop
174{
175# define VAR(name,decl) decl;
176# include "ev_vars.h"
177};
178# undef VAR
179# include "ev_wrap.h"
180
181#else
182
183# define VAR(name,decl) static decl;
184# include "ev_vars.h"
185# undef VAR
186
187#endif
188
189/*****************************************************************************/
190
191inline ev_tstamp
56ev_time (void) 192ev_time (void)
57{ 193{
58#if HAVE_REALTIME 194#if EV_USE_REALTIME
59 struct timespec ts; 195 struct timespec ts;
60 clock_gettime (CLOCK_REALTIME, &ts); 196 clock_gettime (CLOCK_REALTIME, &ts);
61 return ts.tv_sec + ts.tv_nsec * 1e-9; 197 return ts.tv_sec + ts.tv_nsec * 1e-9;
62#else 198#else
63 struct timeval tv; 199 struct timeval tv;
64 gettimeofday (&tv, 0); 200 gettimeofday (&tv, 0);
65 return tv.tv_sec + tv.tv_usec * 1e-6; 201 return tv.tv_sec + tv.tv_usec * 1e-6;
66#endif 202#endif
67} 203}
68 204
69static ev_tstamp 205inline ev_tstamp
70get_clock (void) 206get_clock (void)
71{ 207{
72#if HAVE_MONOTONIC 208#if EV_USE_MONOTONIC
73 if (have_monotonic) 209 if (expect_true (have_monotonic))
74 { 210 {
75 struct timespec ts; 211 struct timespec ts;
76 clock_gettime (CLOCK_MONOTONIC, &ts); 212 clock_gettime (CLOCK_MONOTONIC, &ts);
77 return ts.tv_sec + ts.tv_nsec * 1e-9; 213 return ts.tv_sec + ts.tv_nsec * 1e-9;
78 } 214 }
79#endif 215#endif
80 216
81 return ev_time (); 217 return ev_time ();
82} 218}
83 219
220ev_tstamp
221ev_now (EV_P)
222{
223 return rt_now;
224}
225
226#define array_roundsize(base,n) ((n) | 4 & ~3)
227
84#define array_needsize(base,cur,cnt,init) \ 228#define array_needsize(base,cur,cnt,init) \
85 if ((cnt) > cur) \ 229 if (expect_false ((cnt) > cur)) \
86 { \ 230 { \
87 int newcnt = cur ? cur << 1 : 16; \ 231 int newcnt = cur; \
232 do \
233 { \
234 newcnt = array_roundsize (base, newcnt << 1); \
235 } \
236 while ((cnt) > newcnt); \
237 \
88 base = realloc (base, sizeof (*base) * (newcnt)); \ 238 base = realloc (base, sizeof (*base) * (newcnt)); \
89 init (base + cur, newcnt - cur); \ 239 init (base + cur, newcnt - cur); \
90 cur = newcnt; \ 240 cur = newcnt; \
91 } 241 }
92 242
243#define array_slim(stem) \
244 if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
245 { \
246 stem ## max = array_roundsize (stem ## cnt >> 1); \
247 base = realloc (base, sizeof (*base) * (stem ## max)); \
248 fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
249 }
250
251#define array_free(stem, idx) \
252 free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
253
93/*****************************************************************************/ 254/*****************************************************************************/
94 255
95typedef struct
96{
97 struct ev_io *head;
98 unsigned char wev, rev; /* want, received event set */
99} ANFD;
100
101static ANFD *anfds;
102static int anfdmax;
103
104static int *fdchanges;
105static int fdchangemax, fdchangecnt;
106
107static void 256static void
108anfds_init (ANFD *base, int count) 257anfds_init (ANFD *base, int count)
109{ 258{
110 while (count--) 259 while (count--)
111 { 260 {
112 base->head = 0; 261 base->head = 0;
113 base->wev = base->rev = EV_NONE; 262 base->events = EV_NONE;
263 base->reify = 0;
264
114 ++base; 265 ++base;
115 } 266 }
116} 267}
117 268
118typedef struct
119{
120 W w;
121 int events;
122} ANPENDING;
123
124static ANPENDING *pendings;
125static int pendingmax, pendingcnt;
126
127static void 269static void
128event (W w, int events) 270event (EV_P_ W w, int events)
129{ 271{
272 if (w->pending)
273 {
274 pendings [ABSPRI (w)][w->pending - 1].events |= events;
275 return;
276 }
277
130 w->pending = ++pendingcnt; 278 w->pending = ++pendingcnt [ABSPRI (w)];
131 array_needsize (pendings, pendingmax, pendingcnt, ); 279 array_needsize (pendings [ABSPRI (w)], pendingmax [ABSPRI (w)], pendingcnt [ABSPRI (w)], );
132 pendings [pendingcnt - 1].w = w; 280 pendings [ABSPRI (w)][w->pending - 1].w = w;
133 pendings [pendingcnt - 1].events = events; 281 pendings [ABSPRI (w)][w->pending - 1].events = events;
134} 282}
135 283
136static void 284static void
285queue_events (EV_P_ W *events, int eventcnt, int type)
286{
287 int i;
288
289 for (i = 0; i < eventcnt; ++i)
290 event (EV_A_ events [i], type);
291}
292
293static void
137fd_event (int fd, int events) 294fd_event (EV_P_ int fd, int events)
138{ 295{
139 ANFD *anfd = anfds + fd; 296 ANFD *anfd = anfds + fd;
140 struct ev_io *w; 297 struct ev_io *w;
141 298
142 for (w = anfd->head; w; w = w->next) 299 for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
143 { 300 {
144 int ev = w->events & events; 301 int ev = w->events & events;
145 302
146 if (ev) 303 if (ev)
147 event ((W)w, ev); 304 event (EV_A_ (W)w, ev);
148 } 305 }
149} 306}
150 307
308/*****************************************************************************/
309
151static void 310static void
152queue_events (W *events, int eventcnt, int type) 311fd_reify (EV_P)
153{ 312{
154 int i; 313 int i;
155 314
156 for (i = 0; i < eventcnt; ++i) 315 for (i = 0; i < fdchangecnt; ++i)
157 event (events [i], type); 316 {
317 int fd = fdchanges [i];
318 ANFD *anfd = anfds + fd;
319 struct ev_io *w;
320
321 int events = 0;
322
323 for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next)
324 events |= w->events;
325
326 anfd->reify = 0;
327
328 method_modify (EV_A_ fd, anfd->events, events);
329 anfd->events = events;
330 }
331
332 fdchangecnt = 0;
333}
334
335static void
336fd_change (EV_P_ int fd)
337{
338 if (anfds [fd].reify || fdchangecnt < 0)
339 return;
340
341 anfds [fd].reify = 1;
342
343 ++fdchangecnt;
344 array_needsize (fdchanges, fdchangemax, fdchangecnt, );
345 fdchanges [fdchangecnt - 1] = fd;
346}
347
348static void
349fd_kill (EV_P_ int fd)
350{
351 struct ev_io *w;
352
353 while ((w = (struct ev_io *)anfds [fd].head))
354 {
355 ev_io_stop (EV_A_ w);
356 event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
357 }
358}
359
360/* called on EBADF to verify fds */
361static void
362fd_ebadf (EV_P)
363{
364 int fd;
365
366 for (fd = 0; fd < anfdmax; ++fd)
367 if (anfds [fd].events)
368 if (fcntl (fd, F_GETFD) == -1 && errno == EBADF)
369 fd_kill (EV_A_ fd);
370}
371
372/* called on ENOMEM in select/poll to kill some fds and retry */
373static void
374fd_enomem (EV_P)
375{
376 int fd;
377
378 for (fd = anfdmax; fd--; )
379 if (anfds [fd].events)
380 {
381 fd_kill (EV_A_ fd);
382 return;
383 }
384}
385
386/* susually called after fork if method needs to re-arm all fds from scratch */
387static void
388fd_rearm_all (EV_P)
389{
390 int fd;
391
392 /* this should be highly optimised to not do anything but set a flag */
393 for (fd = 0; fd < anfdmax; ++fd)
394 if (anfds [fd].events)
395 {
396 anfds [fd].events = 0;
397 fd_change (EV_A_ fd);
398 }
158} 399}
159 400
160/*****************************************************************************/ 401/*****************************************************************************/
161 402
162static struct ev_timer **timers;
163static int timermax, timercnt;
164
165static struct ev_periodic **periodics;
166static int periodicmax, periodiccnt;
167
168static void 403static void
169upheap (WT *timers, int k) 404upheap (WT *heap, int k)
170{ 405{
171 WT w = timers [k]; 406 WT w = heap [k];
172 407
173 while (k && timers [k >> 1]->at > w->at) 408 while (k && heap [k >> 1]->at > w->at)
174 { 409 {
175 timers [k] = timers [k >> 1]; 410 heap [k] = heap [k >> 1];
176 timers [k]->active = k + 1; 411 ((W)heap [k])->active = k + 1;
177 k >>= 1; 412 k >>= 1;
178 } 413 }
179 414
180 timers [k] = w; 415 heap [k] = w;
181 timers [k]->active = k + 1; 416 ((W)heap [k])->active = k + 1;
182 417
183} 418}
184 419
185static void 420static void
186downheap (WT *timers, int N, int k) 421downheap (WT *heap, int N, int k)
187{ 422{
188 WT w = timers [k]; 423 WT w = heap [k];
189 424
190 while (k < (N >> 1)) 425 while (k < (N >> 1))
191 { 426 {
192 int j = k << 1; 427 int j = k << 1;
193 428
194 if (j + 1 < N && timers [j]->at > timers [j + 1]->at) 429 if (j + 1 < N && heap [j]->at > heap [j + 1]->at)
195 ++j; 430 ++j;
196 431
197 if (w->at <= timers [j]->at) 432 if (w->at <= heap [j]->at)
198 break; 433 break;
199 434
200 timers [k] = timers [j]; 435 heap [k] = heap [j];
201 timers [k]->active = k + 1; 436 ((W)heap [k])->active = k + 1;
202 k = j; 437 k = j;
203 } 438 }
204 439
205 timers [k] = w; 440 heap [k] = w;
206 timers [k]->active = k + 1; 441 ((W)heap [k])->active = k + 1;
207} 442}
208 443
209/*****************************************************************************/ 444/*****************************************************************************/
210 445
211typedef struct 446typedef struct
212{ 447{
213 struct ev_signal *head; 448 WL head;
214 sig_atomic_t gotsig; 449 sig_atomic_t volatile gotsig;
215} ANSIG; 450} ANSIG;
216 451
217static ANSIG *signals; 452static ANSIG *signals;
218static int signalmax; 453static int signalmax;
219 454
220static int sigpipe [2]; 455static int sigpipe [2];
221static sig_atomic_t gotsig; 456static sig_atomic_t volatile gotsig;
222static struct ev_io sigev; 457static struct ev_io sigev;
223 458
224static void 459static void
225signals_init (ANSIG *base, int count) 460signals_init (ANSIG *base, int count)
226{ 461{
227 while (count--) 462 while (count--)
228 { 463 {
229 base->head = 0; 464 base->head = 0;
230 base->gotsig = 0; 465 base->gotsig = 0;
466
231 ++base; 467 ++base;
232 } 468 }
233} 469}
234 470
235static void 471static void
236sighandler (int signum) 472sighandler (int signum)
237{ 473{
474#if WIN32
475 signal (signum, sighandler);
476#endif
477
238 signals [signum - 1].gotsig = 1; 478 signals [signum - 1].gotsig = 1;
239 479
240 if (!gotsig) 480 if (!gotsig)
241 { 481 {
482 int old_errno = errno;
242 gotsig = 1; 483 gotsig = 1;
243 write (sigpipe [1], &gotsig, 1); 484 write (sigpipe [1], &signum, 1);
485 errno = old_errno;
244 } 486 }
245} 487}
246 488
247static void 489static void
248sigcb (struct ev_io *iow, int revents) 490sigcb (EV_P_ struct ev_io *iow, int revents)
249{ 491{
250 struct ev_signal *w; 492 WL w;
251 int sig; 493 int signum;
252 494
495 read (sigpipe [0], &revents, 1);
253 gotsig = 0; 496 gotsig = 0;
254 read (sigpipe [0], &revents, 1);
255 497
256 for (sig = signalmax; sig--; ) 498 for (signum = signalmax; signum--; )
257 if (signals [sig].gotsig) 499 if (signals [signum].gotsig)
258 { 500 {
259 signals [sig].gotsig = 0; 501 signals [signum].gotsig = 0;
260 502
261 for (w = signals [sig].head; w; w = w->next) 503 for (w = signals [signum].head; w; w = w->next)
262 event ((W)w, EV_SIGNAL); 504 event (EV_A_ (W)w, EV_SIGNAL);
263 } 505 }
264} 506}
265 507
266static void 508static void
267siginit (void) 509siginit (EV_P)
268{ 510{
511#ifndef WIN32
269 fcntl (sigpipe [0], F_SETFD, FD_CLOEXEC); 512 fcntl (sigpipe [0], F_SETFD, FD_CLOEXEC);
270 fcntl (sigpipe [1], F_SETFD, FD_CLOEXEC); 513 fcntl (sigpipe [1], F_SETFD, FD_CLOEXEC);
271 514
272 /* rather than sort out wether we really need nb, set it */ 515 /* rather than sort out wether we really need nb, set it */
273 fcntl (sigpipe [0], F_SETFL, O_NONBLOCK); 516 fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
274 fcntl (sigpipe [1], F_SETFL, O_NONBLOCK); 517 fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
518#endif
275 519
276 evio_set (&sigev, sigpipe [0], EV_READ); 520 ev_io_set (&sigev, sigpipe [0], EV_READ);
277 evio_start (&sigev); 521 ev_io_start (EV_A_ &sigev);
522 ev_unref (EV_A); /* child watcher should not keep loop alive */
278} 523}
279 524
280/*****************************************************************************/ 525/*****************************************************************************/
281 526
282static struct ev_idle **idles; 527#ifndef WIN32
283static int idlemax, idlecnt;
284 528
285static struct ev_check **checks; 529static struct ev_child *childs [PID_HASHSIZE];
286static int checkmax, checkcnt; 530static struct ev_signal childev;
531
532#ifndef WCONTINUED
533# define WCONTINUED 0
534#endif
535
536static void
537child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
538{
539 struct ev_child *w;
540
541 for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
542 if (w->pid == pid || !w->pid)
543 {
544 ev_priority (w) = ev_priority (sw); /* need to do it *now* */
545 w->rpid = pid;
546 w->rstatus = status;
547 event (EV_A_ (W)w, EV_CHILD);
548 }
549}
550
551static void
552childcb (EV_P_ struct ev_signal *sw, int revents)
553{
554 int pid, status;
555
556 if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
557 {
558 /* make sure we are called again until all childs have been reaped */
559 event (EV_A_ (W)sw, EV_SIGNAL);
560
561 child_reap (EV_A_ sw, pid, pid, status);
562 child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but event catches that */
563 }
564}
565
566#endif
287 567
288/*****************************************************************************/ 568/*****************************************************************************/
289 569
570#if EV_USE_KQUEUE
571# include "ev_kqueue.c"
572#endif
290#if HAVE_EPOLL 573#if EV_USE_EPOLL
291# include "ev_epoll.c" 574# include "ev_epoll.c"
292#endif 575#endif
576#if EV_USE_POLL
577# include "ev_poll.c"
578#endif
293#if HAVE_SELECT 579#if EV_USE_SELECT
294# include "ev_select.c" 580# include "ev_select.c"
295#endif 581#endif
296 582
297int ev_init (int flags) 583int
584ev_version_major (void)
298{ 585{
586 return EV_VERSION_MAJOR;
587}
588
589int
590ev_version_minor (void)
591{
592 return EV_VERSION_MINOR;
593}
594
595/* return true if we are running with elevated privileges and should ignore env variables */
596static int
597enable_secure (void)
598{
599#ifdef WIN32
600 return 0;
601#else
602 return getuid () != geteuid ()
603 || getgid () != getegid ();
604#endif
605}
606
607int
608ev_method (EV_P)
609{
610 return method;
611}
612
613static void
614loop_init (EV_P_ int methods)
615{
616 if (!method)
617 {
299#if HAVE_MONOTONIC 618#if EV_USE_MONOTONIC
300 { 619 {
301 struct timespec ts; 620 struct timespec ts;
302 if (!clock_gettime (CLOCK_MONOTONIC, &ts)) 621 if (!clock_gettime (CLOCK_MONOTONIC, &ts))
303 have_monotonic = 1; 622 have_monotonic = 1;
304 } 623 }
305#endif 624#endif
306 625
307 ev_now = ev_time (); 626 rt_now = ev_time ();
308 now = get_clock (); 627 mn_now = get_clock ();
309 diff = ev_now - now; 628 now_floor = mn_now;
629 rtmn_diff = rt_now - mn_now;
310 630
631 if (methods == EVMETHOD_AUTO)
632 if (!enable_secure () && getenv ("LIBEV_METHODS"))
633 methods = atoi (getenv ("LIBEV_METHODS"));
634 else
635 methods = EVMETHOD_ANY;
636
637 method = 0;
638#if EV_USE_WIN32
639 if (!method && (methods & EVMETHOD_WIN32 )) method = win32_init (EV_A_ methods);
640#endif
641#if EV_USE_KQUEUE
642 if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
643#endif
644#if EV_USE_EPOLL
645 if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init (EV_A_ methods);
646#endif
647#if EV_USE_POLL
648 if (!method && (methods & EVMETHOD_POLL )) method = poll_init (EV_A_ methods);
649#endif
650#if EV_USE_SELECT
651 if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
652#endif
653 }
654}
655
656void
657loop_destroy (EV_P)
658{
659 int i;
660
661#if EV_USE_WIN32
662 if (method == EVMETHOD_WIN32 ) win32_destroy (EV_A);
663#endif
664#if EV_USE_KQUEUE
665 if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
666#endif
667#if EV_USE_EPOLL
668 if (method == EVMETHOD_EPOLL ) epoll_destroy (EV_A);
669#endif
670#if EV_USE_POLL
671 if (method == EVMETHOD_POLL ) poll_destroy (EV_A);
672#endif
673#if EV_USE_SELECT
674 if (method == EVMETHOD_SELECT) select_destroy (EV_A);
675#endif
676
677 for (i = NUMPRI; i--; )
678 array_free (pending, [i]);
679
680 array_free (fdchange, );
681 array_free (timer, );
682 array_free (periodic, );
683 array_free (idle, );
684 array_free (prepare, );
685 array_free (check, );
686
687 method = 0;
688 /*TODO*/
689}
690
691void
692loop_fork (EV_P)
693{
694 /*TODO*/
695#if EV_USE_EPOLL
696 if (method == EVMETHOD_EPOLL ) epoll_fork (EV_A);
697#endif
698#if EV_USE_KQUEUE
699 if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
700#endif
701}
702
703#if EV_MULTIPLICITY
704struct ev_loop *
705ev_loop_new (int methods)
706{
707 struct ev_loop *loop = (struct ev_loop *)calloc (1, sizeof (struct ev_loop));
708
709 loop_init (EV_A_ methods);
710
711 if (ev_method (EV_A))
712 return loop;
713
714 return 0;
715}
716
717void
718ev_loop_destroy (EV_P)
719{
720 loop_destroy (EV_A);
721 free (loop);
722}
723
724void
725ev_loop_fork (EV_P)
726{
727 loop_fork (EV_A);
728}
729
730#endif
731
732#if EV_MULTIPLICITY
733struct ev_loop default_loop_struct;
734static struct ev_loop *default_loop;
735
736struct ev_loop *
737#else
738static int default_loop;
739
740int
741#endif
742ev_default_loop (int methods)
743{
744 if (sigpipe [0] == sigpipe [1])
311 if (pipe (sigpipe)) 745 if (pipe (sigpipe))
312 return 0; 746 return 0;
313 747
314 ev_method = EVMETHOD_NONE; 748 if (!default_loop)
315#if HAVE_EPOLL
316 if (ev_method == EVMETHOD_NONE) epoll_init (flags);
317#endif
318#if HAVE_SELECT
319 if (ev_method == EVMETHOD_NONE) select_init (flags);
320#endif
321
322 if (ev_method)
323 { 749 {
750#if EV_MULTIPLICITY
751 struct ev_loop *loop = default_loop = &default_loop_struct;
752#else
753 default_loop = 1;
754#endif
755
756 loop_init (EV_A_ methods);
757
758 if (ev_method (EV_A))
759 {
324 evw_init (&sigev, sigcb); 760 ev_watcher_init (&sigev, sigcb);
761 ev_set_priority (&sigev, EV_MAXPRI);
325 siginit (); 762 siginit (EV_A);
326 }
327 763
328 return ev_method; 764#ifndef WIN32
329} 765 ev_signal_init (&childev, childcb, SIGCHLD);
330 766 ev_set_priority (&childev, EV_MAXPRI);
331/*****************************************************************************/ 767 ev_signal_start (EV_A_ &childev);
332 768 ev_unref (EV_A); /* child watcher should not keep loop alive */
333void ev_prefork (void)
334{
335 /* nop */
336}
337
338void ev_postfork_parent (void)
339{
340 /* nop */
341}
342
343void ev_postfork_child (void)
344{
345#if HAVE_EPOLL
346 if (ev_method == EVMETHOD_EPOLL)
347 epoll_postfork_child ();
348#endif 769#endif
770 }
771 else
772 default_loop = 0;
773 }
349 774
775 return default_loop;
776}
777
778void
779ev_default_destroy (void)
780{
781#if EV_MULTIPLICITY
782 struct ev_loop *loop = default_loop;
783#endif
784
785 ev_ref (EV_A); /* child watcher */
786 ev_signal_stop (EV_A_ &childev);
787
788 ev_ref (EV_A); /* signal watcher */
350 evio_stop (&sigev); 789 ev_io_stop (EV_A_ &sigev);
790
791 close (sigpipe [0]); sigpipe [0] = 0;
792 close (sigpipe [1]); sigpipe [1] = 0;
793
794 loop_destroy (EV_A);
795}
796
797void
798ev_default_fork (void)
799{
800#if EV_MULTIPLICITY
801 struct ev_loop *loop = default_loop;
802#endif
803
804 loop_fork (EV_A);
805
806 ev_io_stop (EV_A_ &sigev);
351 close (sigpipe [0]); 807 close (sigpipe [0]);
352 close (sigpipe [1]); 808 close (sigpipe [1]);
353 pipe (sigpipe); 809 pipe (sigpipe);
810
811 ev_ref (EV_A); /* signal watcher */
354 siginit (); 812 siginit (EV_A);
355} 813}
356 814
357/*****************************************************************************/ 815/*****************************************************************************/
358 816
359static void 817static void
360fd_reify (void) 818call_pending (EV_P)
361{ 819{
362 int i; 820 int pri;
363 821
364 for (i = 0; i < fdchangecnt; ++i) 822 for (pri = NUMPRI; pri--; )
365 { 823 while (pendingcnt [pri])
366 int fd = fdchanges [i];
367 ANFD *anfd = anfds + fd;
368 struct ev_io *w;
369
370 int wev = 0;
371
372 for (w = anfd->head; w; w = w->next)
373 wev |= w->events;
374
375 if (anfd->wev != wev)
376 { 824 {
377 method_modify (fd, anfd->wev, wev); 825 ANPENDING *p = pendings [pri] + --pendingcnt [pri];
378 anfd->wev = wev;
379 }
380 }
381 826
382 fdchangecnt = 0;
383}
384
385static void
386call_pending ()
387{
388 int i;
389
390 for (i = 0; i < pendingcnt; ++i)
391 {
392 ANPENDING *p = pendings + i;
393
394 if (p->w) 827 if (p->w)
395 { 828 {
396 p->w->pending = 0; 829 p->w->pending = 0;
397 p->w->cb (p->w, p->events); 830 p->w->cb (EV_A_ p->w, p->events);
398 } 831 }
399 } 832 }
400
401 pendingcnt = 0;
402} 833}
403 834
404static void 835static void
405timers_reify () 836timers_reify (EV_P)
406{ 837{
407 while (timercnt && timers [0]->at <= now) 838 while (timercnt && ((WT)timers [0])->at <= mn_now)
408 { 839 {
409 struct ev_timer *w = timers [0]; 840 struct ev_timer *w = timers [0];
841
842 assert (("inactive timer on timer heap detected", ev_is_active (w)));
410 843
411 /* first reschedule or stop timer */ 844 /* first reschedule or stop timer */
412 if (w->repeat) 845 if (w->repeat)
413 { 846 {
847 assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
414 w->at = now + w->repeat; 848 ((WT)w)->at = mn_now + w->repeat;
415 assert (("timer timeout in the past, negative repeat?", w->at > now));
416 downheap ((WT *)timers, timercnt, 0); 849 downheap ((WT *)timers, timercnt, 0);
417 } 850 }
418 else 851 else
419 evtimer_stop (w); /* nonrepeating: stop timer */ 852 ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
420 853
421 event ((W)w, EV_TIMEOUT); 854 event (EV_A_ (W)w, EV_TIMEOUT);
422 } 855 }
423} 856}
424 857
425static void 858static void
426periodics_reify () 859periodics_reify (EV_P)
427{ 860{
428 while (periodiccnt && periodics [0]->at <= ev_now) 861 while (periodiccnt && ((WT)periodics [0])->at <= rt_now)
429 { 862 {
430 struct ev_periodic *w = periodics [0]; 863 struct ev_periodic *w = periodics [0];
864
865 assert (("inactive timer on periodic heap detected", ev_is_active (w)));
431 866
432 /* first reschedule or stop timer */ 867 /* first reschedule or stop timer */
433 if (w->interval) 868 if (w->interval)
434 { 869 {
435 w->at += floor ((ev_now - w->at) / w->interval + 1.) * w->interval; 870 ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
436 assert (("periodic timeout in the past, negative interval?", w->at > ev_now)); 871 assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
437 downheap ((WT *)periodics, periodiccnt, 0); 872 downheap ((WT *)periodics, periodiccnt, 0);
438 } 873 }
439 else 874 else
440 evperiodic_stop (w); /* nonrepeating: stop timer */ 875 ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
441 876
442 event ((W)w, EV_TIMEOUT); 877 event (EV_A_ (W)w, EV_PERIODIC);
443 } 878 }
444} 879}
445 880
446static void 881static void
447periodics_reschedule (ev_tstamp diff) 882periodics_reschedule (EV_P)
448{ 883{
449 int i; 884 int i;
450 885
451 /* adjust periodics after time jump */ 886 /* adjust periodics after time jump */
452 for (i = 0; i < periodiccnt; ++i) 887 for (i = 0; i < periodiccnt; ++i)
453 { 888 {
454 struct ev_periodic *w = periodics [i]; 889 struct ev_periodic *w = periodics [i];
455 890
456 if (w->interval) 891 if (w->interval)
457 { 892 {
458 ev_tstamp diff = ceil ((ev_now - w->at) / w->interval) * w->interval; 893 ev_tstamp diff = ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
459 894
460 if (fabs (diff) >= 1e-4) 895 if (fabs (diff) >= 1e-4)
461 { 896 {
462 evperiodic_stop (w); 897 ev_periodic_stop (EV_A_ w);
463 evperiodic_start (w); 898 ev_periodic_start (EV_A_ w);
464 899
465 i = 0; /* restart loop, inefficient, but time jumps should be rare */ 900 i = 0; /* restart loop, inefficient, but time jumps should be rare */
466 } 901 }
467 } 902 }
468 } 903 }
469} 904}
470 905
906inline int
907time_update_monotonic (EV_P)
908{
909 mn_now = get_clock ();
910
911 if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
912 {
913 rt_now = rtmn_diff + mn_now;
914 return 0;
915 }
916 else
917 {
918 now_floor = mn_now;
919 rt_now = ev_time ();
920 return 1;
921 }
922}
923
471static void 924static void
472time_update () 925time_update (EV_P)
473{ 926{
474 int i; 927 int i;
475 928
476 ev_now = ev_time (); 929#if EV_USE_MONOTONIC
477
478 if (have_monotonic) 930 if (expect_true (have_monotonic))
479 { 931 {
480 ev_tstamp odiff = diff; 932 if (time_update_monotonic (EV_A))
481
482 for (i = 4; --i; ) /* loop a few times, before making important decisions */
483 { 933 {
484 now = get_clock (); 934 ev_tstamp odiff = rtmn_diff;
935
936 for (i = 4; --i; ) /* loop a few times, before making important decisions */
937 {
485 diff = ev_now - now; 938 rtmn_diff = rt_now - mn_now;
486 939
487 if (fabs (odiff - diff) < MIN_TIMEJUMP) 940 if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
488 return; /* all is well */ 941 return; /* all is well */
489 942
490 ev_now = ev_time (); 943 rt_now = ev_time ();
944 mn_now = get_clock ();
945 now_floor = mn_now;
946 }
947
948 periodics_reschedule (EV_A);
949 /* no timer adjustment, as the monotonic clock doesn't jump */
950 /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
491 } 951 }
492
493 periodics_reschedule (diff - odiff);
494 /* no timer adjustment, as the monotonic clock doesn't jump */
495 } 952 }
496 else 953 else
954#endif
497 { 955 {
498 if (now > ev_now || now < ev_now - MAX_BLOCKTIME - MIN_TIMEJUMP) 956 rt_now = ev_time ();
957
958 if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
499 { 959 {
500 periodics_reschedule (ev_now - now); 960 periodics_reschedule (EV_A);
501 961
502 /* adjust timers. this is easy, as the offset is the same for all */ 962 /* adjust timers. this is easy, as the offset is the same for all */
503 for (i = 0; i < timercnt; ++i) 963 for (i = 0; i < timercnt; ++i)
504 timers [i]->at += diff; 964 ((WT)timers [i])->at += rt_now - mn_now;
505 } 965 }
506 966
507 now = ev_now; 967 mn_now = rt_now;
508 } 968 }
509} 969}
510 970
511int ev_loop_done; 971void
972ev_ref (EV_P)
973{
974 ++activecnt;
975}
512 976
977void
978ev_unref (EV_P)
979{
980 --activecnt;
981}
982
983static int loop_done;
984
985void
513void ev_loop (int flags) 986ev_loop (EV_P_ int flags)
514{ 987{
515 double block; 988 double block;
516 ev_loop_done = flags & EVLOOP_ONESHOT ? 1 : 0; 989 loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
517
518 if (checkcnt)
519 {
520 queue_events ((W *)checks, checkcnt, EV_CHECK);
521 call_pending ();
522 }
523 990
524 do 991 do
525 { 992 {
993 /* queue check watchers (and execute them) */
994 if (expect_false (preparecnt))
995 {
996 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
997 call_pending (EV_A);
998 }
999
526 /* update fd-related kernel structures */ 1000 /* update fd-related kernel structures */
527 fd_reify (); 1001 fd_reify (EV_A);
528 1002
529 /* calculate blocking time */ 1003 /* calculate blocking time */
530 1004
531 /* we only need this for !monotonic clock, but as we always have timers, we just calculate it every time */ 1005 /* we only need this for !monotonic clockor timers, but as we basically
1006 always have timers, we just calculate it always */
1007#if EV_USE_MONOTONIC
1008 if (expect_true (have_monotonic))
1009 time_update_monotonic (EV_A);
1010 else
1011#endif
1012 {
532 ev_now = ev_time (); 1013 rt_now = ev_time ();
1014 mn_now = rt_now;
1015 }
533 1016
534 if (flags & EVLOOP_NONBLOCK || idlecnt) 1017 if (flags & EVLOOP_NONBLOCK || idlecnt)
535 block = 0.; 1018 block = 0.;
536 else 1019 else
537 { 1020 {
538 block = MAX_BLOCKTIME; 1021 block = MAX_BLOCKTIME;
539 1022
540 if (timercnt) 1023 if (timercnt)
541 { 1024 {
542 ev_tstamp to = timers [0]->at - (have_monotonic ? get_clock () : ev_now) + method_fudge; 1025 ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
543 if (block > to) block = to; 1026 if (block > to) block = to;
544 } 1027 }
545 1028
546 if (periodiccnt) 1029 if (periodiccnt)
547 { 1030 {
548 ev_tstamp to = periodics [0]->at - ev_now + method_fudge; 1031 ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge;
549 if (block > to) block = to; 1032 if (block > to) block = to;
550 } 1033 }
551 1034
552 if (block < 0.) block = 0.; 1035 if (block < 0.) block = 0.;
553 } 1036 }
554 1037
555 method_poll (block); 1038 method_poll (EV_A_ block);
556 1039
557 /* update ev_now, do magic */ 1040 /* update rt_now, do magic */
558 time_update (); 1041 time_update (EV_A);
559 1042
560 /* queue pending timers and reschedule them */ 1043 /* queue pending timers and reschedule them */
1044 timers_reify (EV_A); /* relative timers called last */
561 periodics_reify (); /* absolute timers first */ 1045 periodics_reify (EV_A); /* absolute timers called first */
562 timers_reify (); /* relative timers second */
563 1046
564 /* queue idle watchers unless io or timers are pending */ 1047 /* queue idle watchers unless io or timers are pending */
565 if (!pendingcnt) 1048 if (!pendingcnt)
566 queue_events ((W *)idles, idlecnt, EV_IDLE); 1049 queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
567 1050
568 /* queue check and possibly idle watchers */ 1051 /* queue check watchers, to be executed first */
1052 if (checkcnt)
569 queue_events ((W *)checks, checkcnt, EV_CHECK); 1053 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
570 1054
571 call_pending (); 1055 call_pending (EV_A);
572 } 1056 }
573 while (!ev_loop_done); 1057 while (activecnt && !loop_done);
574 1058
575 if (ev_loop_done != 2) 1059 if (loop_done != 2)
576 ev_loop_done = 0; 1060 loop_done = 0;
1061}
1062
1063void
1064ev_unloop (EV_P_ int how)
1065{
1066 loop_done = how;
577} 1067}
578 1068
579/*****************************************************************************/ 1069/*****************************************************************************/
580 1070
581static void 1071inline void
582wlist_add (WL *head, WL elem) 1072wlist_add (WL *head, WL elem)
583{ 1073{
584 elem->next = *head; 1074 elem->next = *head;
585 *head = elem; 1075 *head = elem;
586} 1076}
587 1077
588static void 1078inline void
589wlist_del (WL *head, WL elem) 1079wlist_del (WL *head, WL elem)
590{ 1080{
591 while (*head) 1081 while (*head)
592 { 1082 {
593 if (*head == elem) 1083 if (*head == elem)
598 1088
599 head = &(*head)->next; 1089 head = &(*head)->next;
600 } 1090 }
601} 1091}
602 1092
603static void 1093inline void
1094ev_clear_pending (EV_P_ W w)
1095{
1096 if (w->pending)
1097 {
1098 pendings [ABSPRI (w)][w->pending - 1].w = 0;
1099 w->pending = 0;
1100 }
1101}
1102
1103inline void
604ev_start (W w, int active) 1104ev_start (EV_P_ W w, int active)
605{ 1105{
606 w->pending = 0; 1106 if (w->priority < EV_MINPRI) w->priority = EV_MINPRI;
1107 if (w->priority > EV_MAXPRI) w->priority = EV_MAXPRI;
1108
607 w->active = active; 1109 w->active = active;
1110 ev_ref (EV_A);
608} 1111}
609 1112
610static void 1113inline void
611ev_stop (W w) 1114ev_stop (EV_P_ W w)
612{ 1115{
613 if (w->pending) 1116 ev_unref (EV_A);
614 pendings [w->pending - 1].w = 0;
615
616 w->active = 0; 1117 w->active = 0;
617} 1118}
618 1119
619/*****************************************************************************/ 1120/*****************************************************************************/
620 1121
621void 1122void
622evio_start (struct ev_io *w) 1123ev_io_start (EV_P_ struct ev_io *w)
623{ 1124{
1125 int fd = w->fd;
1126
624 if (ev_is_active (w)) 1127 if (ev_is_active (w))
625 return; 1128 return;
626 1129
627 int fd = w->fd; 1130 assert (("ev_io_start called with negative fd", fd >= 0));
628 1131
629 ev_start ((W)w, 1); 1132 ev_start (EV_A_ (W)w, 1);
630 array_needsize (anfds, anfdmax, fd + 1, anfds_init); 1133 array_needsize (anfds, anfdmax, fd + 1, anfds_init);
631 wlist_add ((WL *)&anfds[fd].head, (WL)w); 1134 wlist_add ((WL *)&anfds[fd].head, (WL)w);
632 1135
633 ++fdchangecnt; 1136 fd_change (EV_A_ fd);
634 array_needsize (fdchanges, fdchangemax, fdchangecnt, );
635 fdchanges [fdchangecnt - 1] = fd;
636} 1137}
637 1138
638void 1139void
639evio_stop (struct ev_io *w) 1140ev_io_stop (EV_P_ struct ev_io *w)
640{ 1141{
1142 ev_clear_pending (EV_A_ (W)w);
641 if (!ev_is_active (w)) 1143 if (!ev_is_active (w))
642 return; 1144 return;
643 1145
644 wlist_del ((WL *)&anfds[w->fd].head, (WL)w); 1146 wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
645 ev_stop ((W)w); 1147 ev_stop (EV_A_ (W)w);
646 1148
647 ++fdchangecnt; 1149 fd_change (EV_A_ w->fd);
648 array_needsize (fdchanges, fdchangemax, fdchangecnt, );
649 fdchanges [fdchangecnt - 1] = w->fd;
650} 1150}
651 1151
652
653void 1152void
654evtimer_start (struct ev_timer *w) 1153ev_timer_start (EV_P_ struct ev_timer *w)
655{ 1154{
656 if (ev_is_active (w)) 1155 if (ev_is_active (w))
657 return; 1156 return;
658 1157
659 w->at += now; 1158 ((WT)w)->at += mn_now;
660 1159
661 assert (("timer repeat value less than zero not allowed", w->repeat >= 0.)); 1160 assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
662 1161
663 ev_start ((W)w, ++timercnt); 1162 ev_start (EV_A_ (W)w, ++timercnt);
664 array_needsize (timers, timermax, timercnt, ); 1163 array_needsize (timers, timermax, timercnt, );
665 timers [timercnt - 1] = w; 1164 timers [timercnt - 1] = w;
666 upheap ((WT *)timers, timercnt - 1); 1165 upheap ((WT *)timers, timercnt - 1);
667}
668 1166
1167 assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1168}
1169
669void 1170void
670evtimer_stop (struct ev_timer *w) 1171ev_timer_stop (EV_P_ struct ev_timer *w)
671{ 1172{
1173 ev_clear_pending (EV_A_ (W)w);
672 if (!ev_is_active (w)) 1174 if (!ev_is_active (w))
673 return; 1175 return;
674 1176
1177 assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
1178
675 if (w->active < timercnt--) 1179 if (((W)w)->active < timercnt--)
676 { 1180 {
677 timers [w->active - 1] = timers [timercnt]; 1181 timers [((W)w)->active - 1] = timers [timercnt];
678 downheap ((WT *)timers, timercnt, w->active - 1); 1182 downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
679 } 1183 }
680 1184
681 w->at = w->repeat; 1185 ((WT)w)->at = w->repeat;
682 1186
683 ev_stop ((W)w); 1187 ev_stop (EV_A_ (W)w);
684} 1188}
685 1189
686void 1190void
687evtimer_again (struct ev_timer *w) 1191ev_timer_again (EV_P_ struct ev_timer *w)
688{ 1192{
689 if (ev_is_active (w)) 1193 if (ev_is_active (w))
690 { 1194 {
691 if (w->repeat) 1195 if (w->repeat)
692 { 1196 {
693 w->at = now + w->repeat; 1197 ((WT)w)->at = mn_now + w->repeat;
694 downheap ((WT *)timers, timercnt, w->active - 1); 1198 downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
695 } 1199 }
696 else 1200 else
697 evtimer_stop (w); 1201 ev_timer_stop (EV_A_ w);
698 } 1202 }
699 else if (w->repeat) 1203 else if (w->repeat)
700 evtimer_start (w); 1204 ev_timer_start (EV_A_ w);
701} 1205}
702 1206
703void 1207void
704evperiodic_start (struct ev_periodic *w) 1208ev_periodic_start (EV_P_ struct ev_periodic *w)
705{ 1209{
706 if (ev_is_active (w)) 1210 if (ev_is_active (w))
707 return; 1211 return;
708 1212
709 assert (("periodic interval value less than zero not allowed", w->interval >= 0.)); 1213 assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
710 1214
711 /* this formula differs from the one in periodic_reify because we do not always round up */ 1215 /* this formula differs from the one in periodic_reify because we do not always round up */
712 if (w->interval) 1216 if (w->interval)
713 w->at += ceil ((ev_now - w->at) / w->interval) * w->interval; 1217 ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
714 1218
715 ev_start ((W)w, ++periodiccnt); 1219 ev_start (EV_A_ (W)w, ++periodiccnt);
716 array_needsize (periodics, periodicmax, periodiccnt, ); 1220 array_needsize (periodics, periodicmax, periodiccnt, );
717 periodics [periodiccnt - 1] = w; 1221 periodics [periodiccnt - 1] = w;
718 upheap ((WT *)periodics, periodiccnt - 1); 1222 upheap ((WT *)periodics, periodiccnt - 1);
719}
720 1223
1224 assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1225}
1226
721void 1227void
722evperiodic_stop (struct ev_periodic *w) 1228ev_periodic_stop (EV_P_ struct ev_periodic *w)
723{ 1229{
1230 ev_clear_pending (EV_A_ (W)w);
724 if (!ev_is_active (w)) 1231 if (!ev_is_active (w))
725 return; 1232 return;
726 1233
1234 assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
1235
727 if (w->active < periodiccnt--) 1236 if (((W)w)->active < periodiccnt--)
728 { 1237 {
729 periodics [w->active - 1] = periodics [periodiccnt]; 1238 periodics [((W)w)->active - 1] = periodics [periodiccnt];
730 downheap ((WT *)periodics, periodiccnt, w->active - 1); 1239 downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
731 } 1240 }
732 1241
733 ev_stop ((W)w); 1242 ev_stop (EV_A_ (W)w);
734} 1243}
735 1244
736void 1245void
737evsignal_start (struct ev_signal *w) 1246ev_idle_start (EV_P_ struct ev_idle *w)
738{ 1247{
739 if (ev_is_active (w)) 1248 if (ev_is_active (w))
740 return; 1249 return;
741 1250
1251 ev_start (EV_A_ (W)w, ++idlecnt);
1252 array_needsize (idles, idlemax, idlecnt, );
1253 idles [idlecnt - 1] = w;
1254}
1255
1256void
1257ev_idle_stop (EV_P_ struct ev_idle *w)
1258{
1259 ev_clear_pending (EV_A_ (W)w);
1260 if (ev_is_active (w))
1261 return;
1262
1263 idles [((W)w)->active - 1] = idles [--idlecnt];
1264 ev_stop (EV_A_ (W)w);
1265}
1266
1267void
1268ev_prepare_start (EV_P_ struct ev_prepare *w)
1269{
1270 if (ev_is_active (w))
1271 return;
1272
1273 ev_start (EV_A_ (W)w, ++preparecnt);
1274 array_needsize (prepares, preparemax, preparecnt, );
1275 prepares [preparecnt - 1] = w;
1276}
1277
1278void
1279ev_prepare_stop (EV_P_ struct ev_prepare *w)
1280{
1281 ev_clear_pending (EV_A_ (W)w);
1282 if (ev_is_active (w))
1283 return;
1284
1285 prepares [((W)w)->active - 1] = prepares [--preparecnt];
1286 ev_stop (EV_A_ (W)w);
1287}
1288
1289void
1290ev_check_start (EV_P_ struct ev_check *w)
1291{
1292 if (ev_is_active (w))
1293 return;
1294
1295 ev_start (EV_A_ (W)w, ++checkcnt);
1296 array_needsize (checks, checkmax, checkcnt, );
1297 checks [checkcnt - 1] = w;
1298}
1299
1300void
1301ev_check_stop (EV_P_ struct ev_check *w)
1302{
1303 ev_clear_pending (EV_A_ (W)w);
1304 if (ev_is_active (w))
1305 return;
1306
1307 checks [((W)w)->active - 1] = checks [--checkcnt];
1308 ev_stop (EV_A_ (W)w);
1309}
1310
1311#ifndef SA_RESTART
1312# define SA_RESTART 0
1313#endif
1314
1315void
1316ev_signal_start (EV_P_ struct ev_signal *w)
1317{
1318#if EV_MULTIPLICITY
1319 assert (("signal watchers are only supported in the default loop", loop == default_loop));
1320#endif
1321 if (ev_is_active (w))
1322 return;
1323
1324 assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1325
742 ev_start ((W)w, 1); 1326 ev_start (EV_A_ (W)w, 1);
743 array_needsize (signals, signalmax, w->signum, signals_init); 1327 array_needsize (signals, signalmax, w->signum, signals_init);
744 wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w); 1328 wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
745 1329
746 if (!w->next) 1330 if (!((WL)w)->next)
747 { 1331 {
1332#if WIN32
1333 signal (w->signum, sighandler);
1334#else
748 struct sigaction sa; 1335 struct sigaction sa;
749 sa.sa_handler = sighandler; 1336 sa.sa_handler = sighandler;
750 sigfillset (&sa.sa_mask); 1337 sigfillset (&sa.sa_mask);
751 sa.sa_flags = 0; 1338 sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
752 sigaction (w->signum, &sa, 0); 1339 sigaction (w->signum, &sa, 0);
1340#endif
753 } 1341 }
754} 1342}
755 1343
756void 1344void
757evsignal_stop (struct ev_signal *w) 1345ev_signal_stop (EV_P_ struct ev_signal *w)
758{ 1346{
1347 ev_clear_pending (EV_A_ (W)w);
759 if (!ev_is_active (w)) 1348 if (!ev_is_active (w))
760 return; 1349 return;
761 1350
762 wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w); 1351 wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
763 ev_stop ((W)w); 1352 ev_stop (EV_A_ (W)w);
764 1353
765 if (!signals [w->signum - 1].head) 1354 if (!signals [w->signum - 1].head)
766 signal (w->signum, SIG_DFL); 1355 signal (w->signum, SIG_DFL);
767} 1356}
768 1357
769void evidle_start (struct ev_idle *w) 1358void
1359ev_child_start (EV_P_ struct ev_child *w)
770{ 1360{
1361#if EV_MULTIPLICITY
1362 assert (("child watchers are only supported in the default loop", loop == default_loop));
1363#endif
771 if (ev_is_active (w)) 1364 if (ev_is_active (w))
772 return; 1365 return;
773 1366
774 ev_start ((W)w, ++idlecnt); 1367 ev_start (EV_A_ (W)w, 1);
775 array_needsize (idles, idlemax, idlecnt, ); 1368 wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
776 idles [idlecnt - 1] = w;
777} 1369}
778 1370
779void evidle_stop (struct ev_idle *w) 1371void
1372ev_child_stop (EV_P_ struct ev_child *w)
780{ 1373{
781 idles [w->active - 1] = idles [--idlecnt]; 1374 ev_clear_pending (EV_A_ (W)w);
782 ev_stop ((W)w);
783}
784
785void evcheck_start (struct ev_check *w)
786{
787 if (ev_is_active (w)) 1375 if (ev_is_active (w))
788 return; 1376 return;
789 1377
790 ev_start ((W)w, ++checkcnt); 1378 wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
791 array_needsize (checks, checkmax, checkcnt, );
792 checks [checkcnt - 1] = w;
793}
794
795void evcheck_stop (struct ev_check *w)
796{
797 checks [w->active - 1] = checks [--checkcnt];
798 ev_stop ((W)w); 1379 ev_stop (EV_A_ (W)w);
799} 1380}
800 1381
801/*****************************************************************************/ 1382/*****************************************************************************/
802 1383
803#if 0 1384struct ev_once
804 1385{
805struct ev_io wio; 1386 struct ev_io io;
806
807static void
808sin_cb (struct ev_io *w, int revents)
809{
810 fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);
811}
812
813static void
814ocb (struct ev_timer *w, int revents)
815{
816 //fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
817 evtimer_stop (w);
818 evtimer_start (w);
819}
820
821static void
822scb (struct ev_signal *w, int revents)
823{
824 fprintf (stderr, "signal %x,%d\n", revents, w->signum);
825 evio_stop (&wio);
826 evio_start (&wio);
827}
828
829static void
830gcb (struct ev_signal *w, int revents)
831{
832 fprintf (stderr, "generic %x\n", revents);
833
834}
835
836int main (void)
837{
838 ev_init (0);
839
840 evio_init (&wio, sin_cb, 0, EV_READ);
841 evio_start (&wio);
842
843 struct ev_timer t[10000];
844
845#if 0
846 int i;
847 for (i = 0; i < 10000; ++i)
848 {
849 struct ev_timer *w = t + i;
850 evw_init (w, ocb, i);
851 evtimer_init_abs (w, ocb, drand48 (), 0.99775533);
852 evtimer_start (w);
853 if (drand48 () < 0.5)
854 evtimer_stop (w);
855 }
856#endif
857
858 struct ev_timer t1; 1387 struct ev_timer to;
859 evtimer_init (&t1, ocb, 5, 10); 1388 void (*cb)(int revents, void *arg);
860 evtimer_start (&t1); 1389 void *arg;
1390};
861 1391
862 struct ev_signal sig; 1392static void
863 evsignal_init (&sig, scb, SIGQUIT); 1393once_cb (EV_P_ struct ev_once *once, int revents)
864 evsignal_start (&sig); 1394{
1395 void (*cb)(int revents, void *arg) = once->cb;
1396 void *arg = once->arg;
865 1397
866 struct ev_check cw; 1398 ev_io_stop (EV_A_ &once->io);
867 evcheck_init (&cw, gcb); 1399 ev_timer_stop (EV_A_ &once->to);
868 evcheck_start (&cw); 1400 free (once);
869 1401
870 struct ev_idle iw; 1402 cb (revents, arg);
871 evidle_init (&iw, gcb);
872 evidle_start (&iw);
873
874 ev_loop (0);
875
876 return 0;
877} 1403}
878 1404
879#endif 1405static void
1406once_cb_io (EV_P_ struct ev_io *w, int revents)
1407{
1408 once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
1409}
880 1410
1411static void
1412once_cb_to (EV_P_ struct ev_timer *w, int revents)
1413{
1414 once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
1415}
881 1416
1417void
1418ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
1419{
1420 struct ev_once *once = malloc (sizeof (struct ev_once));
882 1421
1422 if (!once)
1423 cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
1424 else
1425 {
1426 once->cb = cb;
1427 once->arg = arg;
883 1428
1429 ev_watcher_init (&once->io, once_cb_io);
1430 if (fd >= 0)
1431 {
1432 ev_io_set (&once->io, fd, events);
1433 ev_io_start (EV_A_ &once->io);
1434 }
1435
1436 ev_watcher_init (&once->to, once_cb_to);
1437 if (timeout >= 0.)
1438 {
1439 ev_timer_set (&once->to, timeout, 0.);
1440 ev_timer_start (EV_A_ &once->to);
1441 }
1442 }
1443}
1444

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines