ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.53
Committed: Sat Nov 3 22:31:11 2007 UTC (16 years, 6 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.52: +26 -77 lines
Log Message:
initial support for multiplicity

File Contents

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