ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.75
Committed: Tue Nov 6 19:29:20 2007 UTC (16 years, 6 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.74: +8 -0 lines
Log Message:
*** empty log message ***

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