ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.185
Committed: Fri Dec 14 18:22:30 2007 UTC (16 years, 5 months ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: rel-1_85
Changes since 1.184: +6 -5 lines
Log Message:
minor fixes

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.87
32     #ifdef __cplusplus
33     extern "C" {
34     #endif
35    
36 root 1.59 #ifndef EV_STANDALONE
37 root 1.133 # ifdef EV_CONFIG_H
38     # include EV_CONFIG_H
39     # else
40     # include "config.h"
41     # endif
42 root 1.60
43     # if HAVE_CLOCK_GETTIME
44 root 1.97 # ifndef EV_USE_MONOTONIC
45     # define EV_USE_MONOTONIC 1
46     # endif
47     # ifndef EV_USE_REALTIME
48     # define EV_USE_REALTIME 1
49     # endif
50 root 1.126 # else
51     # ifndef EV_USE_MONOTONIC
52     # define EV_USE_MONOTONIC 0
53     # endif
54     # ifndef EV_USE_REALTIME
55     # define EV_USE_REALTIME 0
56     # endif
57 root 1.60 # endif
58    
59 root 1.127 # ifndef EV_USE_SELECT
60     # if HAVE_SELECT && HAVE_SYS_SELECT_H
61     # define EV_USE_SELECT 1
62     # else
63     # define EV_USE_SELECT 0
64     # endif
65 root 1.60 # endif
66    
67 root 1.127 # ifndef EV_USE_POLL
68     # if HAVE_POLL && HAVE_POLL_H
69     # define EV_USE_POLL 1
70     # else
71     # define EV_USE_POLL 0
72     # endif
73 root 1.60 # endif
74 root 1.127
75     # ifndef EV_USE_EPOLL
76     # if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
77     # define EV_USE_EPOLL 1
78     # else
79     # define EV_USE_EPOLL 0
80     # endif
81 root 1.60 # endif
82 root 1.127
83     # ifndef EV_USE_KQUEUE
84     # if HAVE_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
85     # define EV_USE_KQUEUE 1
86     # else
87     # define EV_USE_KQUEUE 0
88     # endif
89 root 1.60 # endif
90 root 1.127
91     # ifndef EV_USE_PORT
92     # if HAVE_PORT_H && HAVE_PORT_CREATE
93     # define EV_USE_PORT 1
94     # else
95     # define EV_USE_PORT 0
96     # endif
97 root 1.118 # endif
98    
99 root 1.152 # ifndef EV_USE_INOTIFY
100     # if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
101     # define EV_USE_INOTIFY 1
102     # else
103     # define EV_USE_INOTIFY 0
104     # endif
105     # endif
106    
107 root 1.29 #endif
108 root 1.17
109 root 1.1 #include <math.h>
110     #include <stdlib.h>
111 root 1.7 #include <fcntl.h>
112 root 1.16 #include <stddef.h>
113 root 1.1
114     #include <stdio.h>
115    
116 root 1.4 #include <assert.h>
117 root 1.1 #include <errno.h>
118 root 1.22 #include <sys/types.h>
119 root 1.71 #include <time.h>
120    
121 root 1.72 #include <signal.h>
122 root 1.71
123 root 1.152 #ifdef EV_H
124     # include EV_H
125     #else
126     # include "ev.h"
127     #endif
128    
129 root 1.103 #ifndef _WIN32
130 root 1.71 # include <sys/time.h>
131 root 1.45 # include <sys/wait.h>
132 root 1.140 # include <unistd.h>
133 root 1.103 #else
134     # define WIN32_LEAN_AND_MEAN
135     # include <windows.h>
136     # ifndef EV_SELECT_IS_WINSOCKET
137     # define EV_SELECT_IS_WINSOCKET 1
138     # endif
139 root 1.45 #endif
140 root 1.103
141 root 1.40 /**/
142    
143 root 1.29 #ifndef EV_USE_MONOTONIC
144 root 1.121 # define EV_USE_MONOTONIC 0
145 root 1.37 #endif
146    
147 root 1.118 #ifndef EV_USE_REALTIME
148 root 1.121 # define EV_USE_REALTIME 0
149 root 1.118 #endif
150    
151 root 1.29 #ifndef EV_USE_SELECT
152     # define EV_USE_SELECT 1
153 root 1.10 #endif
154    
155 root 1.59 #ifndef EV_USE_POLL
156 root 1.104 # ifdef _WIN32
157     # define EV_USE_POLL 0
158     # else
159     # define EV_USE_POLL 1
160     # endif
161 root 1.41 #endif
162    
163 root 1.29 #ifndef EV_USE_EPOLL
164     # define EV_USE_EPOLL 0
165 root 1.10 #endif
166    
167 root 1.44 #ifndef EV_USE_KQUEUE
168     # define EV_USE_KQUEUE 0
169     #endif
170    
171 root 1.118 #ifndef EV_USE_PORT
172     # define EV_USE_PORT 0
173 root 1.40 #endif
174    
175 root 1.152 #ifndef EV_USE_INOTIFY
176     # define EV_USE_INOTIFY 0
177     #endif
178    
179 root 1.149 #ifndef EV_PID_HASHSIZE
180     # if EV_MINIMAL
181     # define EV_PID_HASHSIZE 1
182     # else
183     # define EV_PID_HASHSIZE 16
184     # endif
185     #endif
186    
187 root 1.152 #ifndef EV_INOTIFY_HASHSIZE
188     # if EV_MINIMAL
189     # define EV_INOTIFY_HASHSIZE 1
190     # else
191     # define EV_INOTIFY_HASHSIZE 16
192     # endif
193     #endif
194    
195 root 1.40 /**/
196    
197     #ifndef CLOCK_MONOTONIC
198     # undef EV_USE_MONOTONIC
199     # define EV_USE_MONOTONIC 0
200     #endif
201    
202 root 1.31 #ifndef CLOCK_REALTIME
203 root 1.40 # undef EV_USE_REALTIME
204 root 1.31 # define EV_USE_REALTIME 0
205     #endif
206 root 1.40
207 root 1.152 #if !EV_STAT_ENABLE
208 root 1.185 # undef EV_USE_INOTIFY
209 root 1.152 # define EV_USE_INOTIFY 0
210     #endif
211    
212     #if EV_USE_INOTIFY
213     # include <sys/inotify.h>
214     #endif
215    
216 root 1.185 #if EV_SELECT_IS_WINSOCKET
217     # include <winsock.h>
218     #endif
219    
220 root 1.40 /**/
221 root 1.1
222 root 1.176 /*
223     * This is used to avoid floating point rounding problems.
224     * It is added to ev_rt_now when scheduling periodics
225     * to ensure progress, time-wise, even when rounding
226     * errors are against us.
227 root 1.177 * This value is good at least till the year 4000.
228 root 1.176 * Better solutions welcome.
229     */
230     #define TIME_EPSILON 0.0001220703125 /* 1/8192 */
231    
232 root 1.4 #define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
233 root 1.120 #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
234 root 1.176 /*#define CLEANUP_INTERVAL (MAX_BLOCKTIME * 5.) /* how often to try to free memory and re-check fds, TODO */
235 root 1.1
236 root 1.185 #if __GNUC__ >= 4
237 root 1.40 # define expect(expr,value) __builtin_expect ((expr),(value))
238 root 1.169 # define noinline __attribute__ ((noinline))
239 root 1.40 #else
240     # define expect(expr,value) (expr)
241 root 1.140 # define noinline
242 root 1.169 # if __STDC_VERSION__ < 199901L
243     # define inline
244     # endif
245 root 1.40 #endif
246    
247     #define expect_false(expr) expect ((expr) != 0, 0)
248     #define expect_true(expr) expect ((expr) != 0, 1)
249 root 1.169 #define inline_size static inline
250    
251     #if EV_MINIMAL
252     # define inline_speed static noinline
253     #else
254     # define inline_speed static inline
255     #endif
256 root 1.40
257 root 1.42 #define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
258 root 1.164 #define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
259 root 1.42
260 root 1.164 #define EMPTY /* required for microsofts broken pseudo-c compiler */
261 root 1.114 #define EMPTY2(a,b) /* used to suppress some warnings */
262 root 1.103
263 root 1.136 typedef ev_watcher *W;
264     typedef ev_watcher_list *WL;
265     typedef ev_watcher_time *WT;
266 root 1.10
267 root 1.54 static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
268    
269 root 1.103 #ifdef _WIN32
270 root 1.98 # include "ev_win32.c"
271     #endif
272 root 1.67
273 root 1.53 /*****************************************************************************/
274 root 1.1
275 root 1.70 static void (*syserr_cb)(const char *msg);
276 root 1.69
277 root 1.141 void
278     ev_set_syserr_cb (void (*cb)(const char *msg))
279 root 1.69 {
280     syserr_cb = cb;
281     }
282    
283 root 1.141 static void noinline
284 root 1.70 syserr (const char *msg)
285 root 1.69 {
286 root 1.70 if (!msg)
287     msg = "(libev) system error";
288    
289 root 1.69 if (syserr_cb)
290 root 1.70 syserr_cb (msg);
291 root 1.69 else
292     {
293 root 1.70 perror (msg);
294 root 1.69 abort ();
295     }
296     }
297    
298 root 1.155 static void *(*alloc)(void *ptr, long size);
299 root 1.69
300 root 1.141 void
301 root 1.155 ev_set_allocator (void *(*cb)(void *ptr, long size))
302 root 1.69 {
303     alloc = cb;
304     }
305    
306 root 1.150 inline_speed void *
307 root 1.155 ev_realloc (void *ptr, long size)
308 root 1.69 {
309 root 1.155 ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
310 root 1.69
311     if (!ptr && size)
312     {
313 root 1.155 fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
314 root 1.69 abort ();
315     }
316    
317     return ptr;
318     }
319    
320     #define ev_malloc(size) ev_realloc (0, (size))
321     #define ev_free(ptr) ev_realloc ((ptr), 0)
322    
323     /*****************************************************************************/
324    
325 root 1.53 typedef struct
326     {
327 root 1.68 WL head;
328 root 1.53 unsigned char events;
329     unsigned char reify;
330 root 1.103 #if EV_SELECT_IS_WINSOCKET
331     SOCKET handle;
332     #endif
333 root 1.53 } ANFD;
334 root 1.1
335 root 1.53 typedef struct
336     {
337     W w;
338     int events;
339     } ANPENDING;
340 root 1.51
341 root 1.155 #if EV_USE_INOTIFY
342 root 1.152 typedef struct
343     {
344     WL head;
345 root 1.155 } ANFS;
346 root 1.152 #endif
347    
348 root 1.55 #if EV_MULTIPLICITY
349 root 1.54
350 root 1.80 struct ev_loop
351     {
352 root 1.86 ev_tstamp ev_rt_now;
353 root 1.99 #define ev_rt_now ((loop)->ev_rt_now)
354 root 1.80 #define VAR(name,decl) decl;
355     #include "ev_vars.h"
356     #undef VAR
357     };
358     #include "ev_wrap.h"
359    
360 root 1.116 static struct ev_loop default_loop_struct;
361     struct ev_loop *ev_default_loop_ptr;
362 root 1.54
363 root 1.53 #else
364 root 1.54
365 root 1.86 ev_tstamp ev_rt_now;
366 root 1.80 #define VAR(name,decl) static decl;
367     #include "ev_vars.h"
368     #undef VAR
369    
370 root 1.116 static int ev_default_loop_ptr;
371 root 1.54
372 root 1.51 #endif
373 root 1.1
374 root 1.8 /*****************************************************************************/
375    
376 root 1.141 ev_tstamp
377 root 1.1 ev_time (void)
378     {
379 root 1.29 #if EV_USE_REALTIME
380 root 1.1 struct timespec ts;
381     clock_gettime (CLOCK_REALTIME, &ts);
382     return ts.tv_sec + ts.tv_nsec * 1e-9;
383     #else
384     struct timeval tv;
385     gettimeofday (&tv, 0);
386     return tv.tv_sec + tv.tv_usec * 1e-6;
387     #endif
388     }
389    
390 root 1.140 ev_tstamp inline_size
391 root 1.1 get_clock (void)
392     {
393 root 1.29 #if EV_USE_MONOTONIC
394 root 1.40 if (expect_true (have_monotonic))
395 root 1.1 {
396     struct timespec ts;
397     clock_gettime (CLOCK_MONOTONIC, &ts);
398     return ts.tv_sec + ts.tv_nsec * 1e-9;
399     }
400     #endif
401    
402     return ev_time ();
403     }
404    
405 root 1.85 #if EV_MULTIPLICITY
406 root 1.51 ev_tstamp
407     ev_now (EV_P)
408     {
409 root 1.85 return ev_rt_now;
410 root 1.51 }
411 root 1.85 #endif
412 root 1.51
413 root 1.163 int inline_size
414     array_nextsize (int elem, int cur, int cnt)
415     {
416     int ncur = cur + 1;
417    
418     do
419     ncur <<= 1;
420     while (cnt > ncur);
421    
422     /* if size > 4096, round to 4096 - 4 * longs to accomodate malloc overhead */
423     if (elem * ncur > 4096)
424     {
425     ncur *= elem;
426     ncur = (ncur + elem + 4095 + sizeof (void *) * 4) & ~4095;
427     ncur = ncur - sizeof (void *) * 4;
428     ncur /= elem;
429     }
430    
431     return ncur;
432     }
433    
434 root 1.171 static noinline void *
435 root 1.163 array_realloc (int elem, void *base, int *cur, int cnt)
436     {
437     *cur = array_nextsize (elem, *cur, cnt);
438     return ev_realloc (base, elem * *cur);
439     }
440 root 1.29
441 root 1.74 #define array_needsize(type,base,cur,cnt,init) \
442 root 1.163 if (expect_false ((cnt) > (cur))) \
443 root 1.69 { \
444 root 1.163 int ocur_ = (cur); \
445     (base) = (type *)array_realloc \
446     (sizeof (type), (base), &(cur), (cnt)); \
447     init ((base) + (ocur_), (cur) - ocur_); \
448 root 1.1 }
449    
450 root 1.163 #if 0
451 root 1.74 #define array_slim(type,stem) \
452 root 1.67 if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
453     { \
454     stem ## max = array_roundsize (stem ## cnt >> 1); \
455 root 1.74 base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
456 root 1.67 fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
457     }
458 root 1.163 #endif
459 root 1.67
460 root 1.65 #define array_free(stem, idx) \
461 root 1.69 ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
462 root 1.65
463 root 1.8 /*****************************************************************************/
464    
465 root 1.140 void noinline
466 root 1.78 ev_feed_event (EV_P_ void *w, int revents)
467 root 1.1 {
468 root 1.78 W w_ = (W)w;
469 root 1.171 int pri = ABSPRI (w_);
470 root 1.78
471 root 1.123 if (expect_false (w_->pending))
472 root 1.171 pendings [pri][w_->pending - 1].events |= revents;
473     else
474 root 1.32 {
475 root 1.171 w_->pending = ++pendingcnt [pri];
476     array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
477     pendings [pri][w_->pending - 1].w = w_;
478     pendings [pri][w_->pending - 1].events = revents;
479 root 1.32 }
480 root 1.1 }
481    
482 root 1.179 void inline_speed
483 root 1.51 queue_events (EV_P_ W *events, int eventcnt, int type)
484 root 1.27 {
485     int i;
486    
487     for (i = 0; i < eventcnt; ++i)
488 root 1.78 ev_feed_event (EV_A_ events [i], type);
489 root 1.27 }
490    
491 root 1.141 /*****************************************************************************/
492    
493     void inline_size
494     anfds_init (ANFD *base, int count)
495     {
496     while (count--)
497     {
498     base->head = 0;
499     base->events = EV_NONE;
500     base->reify = 0;
501    
502     ++base;
503     }
504     }
505    
506 root 1.140 void inline_speed
507 root 1.79 fd_event (EV_P_ int fd, int revents)
508 root 1.1 {
509     ANFD *anfd = anfds + fd;
510 root 1.136 ev_io *w;
511 root 1.1
512 root 1.136 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
513 root 1.1 {
514 root 1.79 int ev = w->events & revents;
515 root 1.1
516     if (ev)
517 root 1.78 ev_feed_event (EV_A_ (W)w, ev);
518 root 1.1 }
519     }
520    
521 root 1.79 void
522     ev_feed_fd_event (EV_P_ int fd, int revents)
523     {
524 root 1.168 if (fd >= 0 && fd < anfdmax)
525     fd_event (EV_A_ fd, revents);
526 root 1.79 }
527    
528 root 1.140 void inline_size
529 root 1.51 fd_reify (EV_P)
530 root 1.9 {
531     int i;
532    
533 root 1.27 for (i = 0; i < fdchangecnt; ++i)
534     {
535     int fd = fdchanges [i];
536     ANFD *anfd = anfds + fd;
537 root 1.136 ev_io *w;
538 root 1.27
539 root 1.184 unsigned char events = 0;
540 root 1.27
541 root 1.136 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
542 root 1.184 events |= (unsigned char)w->events;
543 root 1.27
544 root 1.103 #if EV_SELECT_IS_WINSOCKET
545     if (events)
546     {
547     unsigned long argp;
548     anfd->handle = _get_osfhandle (fd);
549     assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &argp) == 0));
550     }
551     #endif
552    
553 root 1.184 {
554     unsigned char o_events = anfd->events;
555     unsigned char o_reify = anfd->reify;
556    
557     anfd->reify = 0;
558     anfd->events = events;
559 root 1.27
560 root 1.184 if (o_events != events || o_reify & EV_IOFDSET)
561     backend_modify (EV_A_ fd, o_events, events);
562     }
563 root 1.27 }
564    
565     fdchangecnt = 0;
566     }
567    
568 root 1.140 void inline_size
569 root 1.183 fd_change (EV_P_ int fd, int flags)
570 root 1.27 {
571 root 1.183 unsigned char reify = anfds [fd].reify;
572 root 1.184 anfds [fd].reify |= flags;
573 root 1.27
574 root 1.183 if (expect_true (!reify))
575     {
576     ++fdchangecnt;
577     array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
578     fdchanges [fdchangecnt - 1] = fd;
579     }
580 root 1.9 }
581    
582 root 1.140 void inline_speed
583 root 1.51 fd_kill (EV_P_ int fd)
584 root 1.41 {
585 root 1.136 ev_io *w;
586 root 1.41
587 root 1.136 while ((w = (ev_io *)anfds [fd].head))
588 root 1.41 {
589 root 1.51 ev_io_stop (EV_A_ w);
590 root 1.78 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
591 root 1.41 }
592     }
593    
594 root 1.140 int inline_size
595 root 1.71 fd_valid (int fd)
596     {
597 root 1.103 #ifdef _WIN32
598     return _get_osfhandle (fd) != -1;
599 root 1.71 #else
600     return fcntl (fd, F_GETFD) != -1;
601     #endif
602     }
603    
604 root 1.19 /* called on EBADF to verify fds */
605 root 1.140 static void noinline
606 root 1.51 fd_ebadf (EV_P)
607 root 1.19 {
608     int fd;
609    
610     for (fd = 0; fd < anfdmax; ++fd)
611 root 1.27 if (anfds [fd].events)
612 root 1.71 if (!fd_valid (fd) == -1 && errno == EBADF)
613 root 1.51 fd_kill (EV_A_ fd);
614 root 1.41 }
615    
616     /* called on ENOMEM in select/poll to kill some fds and retry */
617 root 1.140 static void noinline
618 root 1.51 fd_enomem (EV_P)
619 root 1.41 {
620 root 1.62 int fd;
621 root 1.41
622 root 1.62 for (fd = anfdmax; fd--; )
623 root 1.41 if (anfds [fd].events)
624     {
625 root 1.51 fd_kill (EV_A_ fd);
626 root 1.41 return;
627     }
628 root 1.19 }
629    
630 root 1.130 /* usually called after fork if backend needs to re-arm all fds from scratch */
631 root 1.140 static void noinline
632 root 1.56 fd_rearm_all (EV_P)
633     {
634     int fd;
635    
636     for (fd = 0; fd < anfdmax; ++fd)
637     if (anfds [fd].events)
638     {
639     anfds [fd].events = 0;
640 root 1.184 fd_change (EV_A_ fd, EV_IOFDSET | 1);
641 root 1.56 }
642     }
643    
644 root 1.8 /*****************************************************************************/
645    
646 root 1.140 void inline_speed
647 root 1.54 upheap (WT *heap, int k)
648 root 1.1 {
649 root 1.54 WT w = heap [k];
650 root 1.1
651 root 1.179 while (k)
652 root 1.1 {
653 root 1.179 int p = (k - 1) >> 1;
654    
655     if (heap [p]->at <= w->at)
656     break;
657    
658     heap [k] = heap [p];
659 root 1.62 ((W)heap [k])->active = k + 1;
660 root 1.179 k = p;
661 root 1.1 }
662    
663 root 1.54 heap [k] = w;
664 root 1.62 ((W)heap [k])->active = k + 1;
665 root 1.1 }
666    
667 root 1.140 void inline_speed
668 root 1.54 downheap (WT *heap, int N, int k)
669 root 1.1 {
670 root 1.54 WT w = heap [k];
671 root 1.1
672 root 1.179 for (;;)
673 root 1.1 {
674 root 1.179 int c = (k << 1) + 1;
675    
676     if (c >= N)
677     break;
678 root 1.1
679 root 1.179 c += c + 1 < N && heap [c]->at > heap [c + 1]->at
680     ? 1 : 0;
681 root 1.1
682 root 1.179 if (w->at <= heap [c]->at)
683 root 1.1 break;
684    
685 root 1.179 heap [k] = heap [c];
686 root 1.62 ((W)heap [k])->active = k + 1;
687 root 1.179
688     k = c;
689 root 1.1 }
690    
691 root 1.54 heap [k] = w;
692 root 1.62 ((W)heap [k])->active = k + 1;
693 root 1.1 }
694    
695 root 1.140 void inline_size
696 root 1.99 adjustheap (WT *heap, int N, int k)
697 root 1.84 {
698 root 1.99 upheap (heap, k);
699     downheap (heap, N, k);
700 root 1.84 }
701    
702 root 1.8 /*****************************************************************************/
703    
704 root 1.7 typedef struct
705     {
706 root 1.68 WL head;
707 root 1.34 sig_atomic_t volatile gotsig;
708 root 1.7 } ANSIG;
709    
710     static ANSIG *signals;
711 root 1.4 static int signalmax;
712 root 1.1
713 root 1.7 static int sigpipe [2];
714 root 1.34 static sig_atomic_t volatile gotsig;
715 root 1.136 static ev_io sigev;
716 root 1.7
717 root 1.140 void inline_size
718 root 1.7 signals_init (ANSIG *base, int count)
719 root 1.1 {
720     while (count--)
721 root 1.7 {
722     base->head = 0;
723     base->gotsig = 0;
724 root 1.33
725 root 1.7 ++base;
726     }
727     }
728    
729     static void
730     sighandler (int signum)
731     {
732 root 1.103 #if _WIN32
733 root 1.67 signal (signum, sighandler);
734     #endif
735    
736 root 1.7 signals [signum - 1].gotsig = 1;
737    
738     if (!gotsig)
739     {
740 root 1.48 int old_errno = errno;
741 root 1.7 gotsig = 1;
742 root 1.34 write (sigpipe [1], &signum, 1);
743 root 1.48 errno = old_errno;
744 root 1.7 }
745     }
746    
747 root 1.140 void noinline
748 root 1.79 ev_feed_signal_event (EV_P_ int signum)
749     {
750 root 1.80 WL w;
751    
752 root 1.79 #if EV_MULTIPLICITY
753 root 1.116 assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
754 root 1.79 #endif
755    
756     --signum;
757    
758     if (signum < 0 || signum >= signalmax)
759     return;
760    
761     signals [signum].gotsig = 0;
762    
763     for (w = signals [signum].head; w; w = w->next)
764     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
765     }
766    
767 root 1.7 static void
768 root 1.136 sigcb (EV_P_ ev_io *iow, int revents)
769 root 1.7 {
770 root 1.38 int signum;
771 root 1.7
772 root 1.34 read (sigpipe [0], &revents, 1);
773 root 1.7 gotsig = 0;
774    
775 root 1.38 for (signum = signalmax; signum--; )
776     if (signals [signum].gotsig)
777 root 1.80 ev_feed_signal_event (EV_A_ signum + 1);
778 root 1.7 }
779    
780 root 1.171 void inline_speed
781 root 1.103 fd_intern (int fd)
782     {
783     #ifdef _WIN32
784     int arg = 1;
785     ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
786     #else
787     fcntl (fd, F_SETFD, FD_CLOEXEC);
788     fcntl (fd, F_SETFL, O_NONBLOCK);
789     #endif
790     }
791    
792 root 1.140 static void noinline
793 root 1.51 siginit (EV_P)
794 root 1.7 {
795 root 1.103 fd_intern (sigpipe [0]);
796     fd_intern (sigpipe [1]);
797 root 1.7
798 root 1.28 ev_io_set (&sigev, sigpipe [0], EV_READ);
799 root 1.54 ev_io_start (EV_A_ &sigev);
800 root 1.52 ev_unref (EV_A); /* child watcher should not keep loop alive */
801 root 1.1 }
802    
803 root 1.8 /*****************************************************************************/
804    
805 root 1.182 static WL childs [EV_PID_HASHSIZE];
806 root 1.71
807 root 1.103 #ifndef _WIN32
808 root 1.45
809 root 1.136 static ev_signal childev;
810 root 1.59
811 root 1.140 void inline_speed
812 root 1.136 child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status)
813 root 1.47 {
814 root 1.136 ev_child *w;
815 root 1.47
816 root 1.149 for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
817 root 1.47 if (w->pid == pid || !w->pid)
818     {
819 root 1.164 ev_set_priority (w, ev_priority (sw)); /* need to do it *now* */
820     w->rpid = pid;
821     w->rstatus = status;
822 root 1.78 ev_feed_event (EV_A_ (W)w, EV_CHILD);
823 root 1.47 }
824     }
825    
826 root 1.142 #ifndef WCONTINUED
827     # define WCONTINUED 0
828     #endif
829    
830 root 1.47 static void
831 root 1.136 childcb (EV_P_ ev_signal *sw, int revents)
832 root 1.22 {
833     int pid, status;
834    
835 root 1.142 /* some systems define WCONTINUED but then fail to support it (linux 2.4) */
836     if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
837     if (!WCONTINUED
838     || errno != EINVAL
839     || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
840     return;
841    
842     /* make sure we are called again until all childs have been reaped */
843     /* we need to do it this way so that the callback gets called before we continue */
844     ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
845 root 1.47
846 root 1.142 child_reap (EV_A_ sw, pid, pid, status);
847 root 1.149 if (EV_PID_HASHSIZE > 1)
848     child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
849 root 1.22 }
850    
851 root 1.45 #endif
852    
853 root 1.22 /*****************************************************************************/
854    
855 root 1.118 #if EV_USE_PORT
856     # include "ev_port.c"
857     #endif
858 root 1.44 #if EV_USE_KQUEUE
859     # include "ev_kqueue.c"
860     #endif
861 root 1.29 #if EV_USE_EPOLL
862 root 1.1 # include "ev_epoll.c"
863     #endif
864 root 1.59 #if EV_USE_POLL
865 root 1.41 # include "ev_poll.c"
866     #endif
867 root 1.29 #if EV_USE_SELECT
868 root 1.1 # include "ev_select.c"
869     #endif
870    
871 root 1.24 int
872     ev_version_major (void)
873     {
874     return EV_VERSION_MAJOR;
875     }
876    
877     int
878     ev_version_minor (void)
879     {
880     return EV_VERSION_MINOR;
881     }
882    
883 root 1.49 /* return true if we are running with elevated privileges and should ignore env variables */
884 root 1.140 int inline_size
885 root 1.51 enable_secure (void)
886 root 1.41 {
887 root 1.103 #ifdef _WIN32
888 root 1.49 return 0;
889     #else
890 root 1.41 return getuid () != geteuid ()
891     || getgid () != getegid ();
892 root 1.49 #endif
893 root 1.41 }
894    
895 root 1.111 unsigned int
896 root 1.129 ev_supported_backends (void)
897     {
898 root 1.130 unsigned int flags = 0;
899 root 1.129
900     if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
901     if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
902     if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
903     if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
904     if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
905    
906     return flags;
907     }
908    
909     unsigned int
910 root 1.130 ev_recommended_backends (void)
911 root 1.1 {
912 root 1.131 unsigned int flags = ev_supported_backends ();
913 root 1.129
914     #ifndef __NetBSD__
915     /* kqueue is borked on everything but netbsd apparently */
916     /* it usually doesn't work correctly on anything but sockets and pipes */
917     flags &= ~EVBACKEND_KQUEUE;
918     #endif
919     #ifdef __APPLE__
920     // flags &= ~EVBACKEND_KQUEUE; for documentation
921     flags &= ~EVBACKEND_POLL;
922     #endif
923    
924     return flags;
925 root 1.51 }
926    
927 root 1.130 unsigned int
928 root 1.134 ev_embeddable_backends (void)
929     {
930     return EVBACKEND_EPOLL
931     | EVBACKEND_KQUEUE
932     | EVBACKEND_PORT;
933     }
934    
935     unsigned int
936 root 1.130 ev_backend (EV_P)
937     {
938     return backend;
939     }
940    
941 root 1.162 unsigned int
942     ev_loop_count (EV_P)
943     {
944     return loop_count;
945     }
946    
947 root 1.151 static void noinline
948 root 1.108 loop_init (EV_P_ unsigned int flags)
949 root 1.51 {
950 root 1.130 if (!backend)
951 root 1.23 {
952 root 1.29 #if EV_USE_MONOTONIC
953 root 1.23 {
954     struct timespec ts;
955     if (!clock_gettime (CLOCK_MONOTONIC, &ts))
956     have_monotonic = 1;
957     }
958 root 1.1 #endif
959    
960 root 1.85 ev_rt_now = ev_time ();
961 root 1.51 mn_now = get_clock ();
962     now_floor = mn_now;
963 root 1.85 rtmn_diff = ev_rt_now - mn_now;
964 root 1.1
965 root 1.158 /* pid check not overridable via env */
966     #ifndef _WIN32
967     if (flags & EVFLAG_FORKCHECK)
968     curpid = getpid ();
969     #endif
970    
971 root 1.128 if (!(flags & EVFLAG_NOENV)
972     && !enable_secure ()
973     && getenv ("LIBEV_FLAGS"))
974 root 1.108 flags = atoi (getenv ("LIBEV_FLAGS"));
975    
976 root 1.129 if (!(flags & 0x0000ffffUL))
977     flags |= ev_recommended_backends ();
978 root 1.41
979 root 1.130 backend = 0;
980 root 1.152 backend_fd = -1;
981     #if EV_USE_INOTIFY
982     fs_fd = -2;
983     #endif
984    
985 root 1.118 #if EV_USE_PORT
986 root 1.130 if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
987 root 1.118 #endif
988 root 1.44 #if EV_USE_KQUEUE
989 root 1.130 if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
990 root 1.44 #endif
991 root 1.29 #if EV_USE_EPOLL
992 root 1.130 if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
993 root 1.41 #endif
994 root 1.59 #if EV_USE_POLL
995 root 1.130 if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
996 root 1.1 #endif
997 root 1.29 #if EV_USE_SELECT
998 root 1.130 if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
999 root 1.1 #endif
1000 root 1.70
1001 root 1.83 ev_init (&sigev, sigcb);
1002 root 1.70 ev_set_priority (&sigev, EV_MAXPRI);
1003 root 1.56 }
1004     }
1005    
1006 root 1.151 static void noinline
1007 root 1.56 loop_destroy (EV_P)
1008     {
1009 root 1.65 int i;
1010    
1011 root 1.152 #if EV_USE_INOTIFY
1012     if (fs_fd >= 0)
1013     close (fs_fd);
1014     #endif
1015    
1016     if (backend_fd >= 0)
1017     close (backend_fd);
1018    
1019 root 1.118 #if EV_USE_PORT
1020 root 1.130 if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
1021 root 1.118 #endif
1022 root 1.56 #if EV_USE_KQUEUE
1023 root 1.130 if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
1024 root 1.56 #endif
1025     #if EV_USE_EPOLL
1026 root 1.130 if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
1027 root 1.56 #endif
1028 root 1.59 #if EV_USE_POLL
1029 root 1.130 if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
1030 root 1.56 #endif
1031     #if EV_USE_SELECT
1032 root 1.130 if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
1033 root 1.56 #endif
1034 root 1.1
1035 root 1.65 for (i = NUMPRI; i--; )
1036 root 1.164 {
1037     array_free (pending, [i]);
1038     #if EV_IDLE_ENABLE
1039     array_free (idle, [i]);
1040     #endif
1041     }
1042 root 1.65
1043 root 1.71 /* have to use the microsoft-never-gets-it-right macro */
1044 root 1.164 array_free (fdchange, EMPTY);
1045     array_free (timer, EMPTY);
1046 root 1.140 #if EV_PERIODIC_ENABLE
1047 root 1.164 array_free (periodic, EMPTY);
1048 root 1.93 #endif
1049 root 1.164 array_free (prepare, EMPTY);
1050     array_free (check, EMPTY);
1051 root 1.65
1052 root 1.130 backend = 0;
1053 root 1.56 }
1054 root 1.22
1055 root 1.154 void inline_size infy_fork (EV_P);
1056    
1057 root 1.151 void inline_size
1058 root 1.56 loop_fork (EV_P)
1059     {
1060 root 1.118 #if EV_USE_PORT
1061 root 1.130 if (backend == EVBACKEND_PORT ) port_fork (EV_A);
1062 root 1.56 #endif
1063     #if EV_USE_KQUEUE
1064 root 1.130 if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
1065 root 1.45 #endif
1066 root 1.118 #if EV_USE_EPOLL
1067 root 1.130 if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
1068 root 1.118 #endif
1069 root 1.154 #if EV_USE_INOTIFY
1070     infy_fork (EV_A);
1071     #endif
1072 root 1.70
1073     if (ev_is_active (&sigev))
1074     {
1075     /* default loop */
1076    
1077     ev_ref (EV_A);
1078     ev_io_stop (EV_A_ &sigev);
1079     close (sigpipe [0]);
1080     close (sigpipe [1]);
1081    
1082 root 1.73 while (pipe (sigpipe))
1083 root 1.70 syserr ("(libev) error creating pipe");
1084    
1085     siginit (EV_A);
1086     }
1087    
1088     postfork = 0;
1089 root 1.1 }
1090    
1091 root 1.55 #if EV_MULTIPLICITY
1092 root 1.54 struct ev_loop *
1093 root 1.108 ev_loop_new (unsigned int flags)
1094 root 1.54 {
1095 root 1.69 struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
1096    
1097     memset (loop, 0, sizeof (struct ev_loop));
1098 root 1.54
1099 root 1.108 loop_init (EV_A_ flags);
1100 root 1.56
1101 root 1.130 if (ev_backend (EV_A))
1102 root 1.55 return loop;
1103 root 1.54
1104 root 1.55 return 0;
1105 root 1.54 }
1106    
1107     void
1108 root 1.56 ev_loop_destroy (EV_P)
1109 root 1.54 {
1110 root 1.56 loop_destroy (EV_A);
1111 root 1.69 ev_free (loop);
1112 root 1.54 }
1113    
1114 root 1.56 void
1115     ev_loop_fork (EV_P)
1116     {
1117 root 1.70 postfork = 1;
1118 root 1.56 }
1119    
1120     #endif
1121    
1122     #if EV_MULTIPLICITY
1123     struct ev_loop *
1124 root 1.125 ev_default_loop_init (unsigned int flags)
1125 root 1.54 #else
1126     int
1127 root 1.116 ev_default_loop (unsigned int flags)
1128 root 1.56 #endif
1129 root 1.54 {
1130 root 1.56 if (sigpipe [0] == sigpipe [1])
1131 root 1.73 if (pipe (sigpipe))
1132 root 1.56 return 0;
1133 root 1.54
1134 root 1.116 if (!ev_default_loop_ptr)
1135 root 1.56 {
1136     #if EV_MULTIPLICITY
1137 root 1.116 struct ev_loop *loop = ev_default_loop_ptr = &default_loop_struct;
1138 root 1.56 #else
1139 ayin 1.117 ev_default_loop_ptr = 1;
1140 root 1.54 #endif
1141    
1142 root 1.110 loop_init (EV_A_ flags);
1143 root 1.56
1144 root 1.130 if (ev_backend (EV_A))
1145 root 1.56 {
1146     siginit (EV_A);
1147    
1148 root 1.103 #ifndef _WIN32
1149 root 1.56 ev_signal_init (&childev, childcb, SIGCHLD);
1150     ev_set_priority (&childev, EV_MAXPRI);
1151     ev_signal_start (EV_A_ &childev);
1152     ev_unref (EV_A); /* child watcher should not keep loop alive */
1153     #endif
1154     }
1155     else
1156 root 1.116 ev_default_loop_ptr = 0;
1157 root 1.56 }
1158 root 1.8
1159 root 1.116 return ev_default_loop_ptr;
1160 root 1.1 }
1161    
1162 root 1.24 void
1163 root 1.56 ev_default_destroy (void)
1164 root 1.1 {
1165 root 1.57 #if EV_MULTIPLICITY
1166 root 1.116 struct ev_loop *loop = ev_default_loop_ptr;
1167 root 1.57 #endif
1168 root 1.56
1169 root 1.103 #ifndef _WIN32
1170 root 1.56 ev_ref (EV_A); /* child watcher */
1171     ev_signal_stop (EV_A_ &childev);
1172 root 1.71 #endif
1173 root 1.56
1174     ev_ref (EV_A); /* signal watcher */
1175     ev_io_stop (EV_A_ &sigev);
1176    
1177     close (sigpipe [0]); sigpipe [0] = 0;
1178     close (sigpipe [1]); sigpipe [1] = 0;
1179    
1180     loop_destroy (EV_A);
1181 root 1.1 }
1182    
1183 root 1.24 void
1184 root 1.60 ev_default_fork (void)
1185 root 1.1 {
1186 root 1.60 #if EV_MULTIPLICITY
1187 root 1.116 struct ev_loop *loop = ev_default_loop_ptr;
1188 root 1.60 #endif
1189    
1190 root 1.130 if (backend)
1191 root 1.70 postfork = 1;
1192 root 1.1 }
1193    
1194 root 1.8 /*****************************************************************************/
1195    
1196 root 1.168 void
1197     ev_invoke (EV_P_ void *w, int revents)
1198     {
1199     EV_CB_INVOKE ((W)w, revents);
1200     }
1201    
1202 root 1.140 void inline_speed
1203 root 1.51 call_pending (EV_P)
1204 root 1.1 {
1205 root 1.42 int pri;
1206    
1207     for (pri = NUMPRI; pri--; )
1208     while (pendingcnt [pri])
1209     {
1210     ANPENDING *p = pendings [pri] + --pendingcnt [pri];
1211 root 1.1
1212 root 1.122 if (expect_true (p->w))
1213 root 1.42 {
1214 root 1.151 /*assert (("non-pending watcher on pending list", p->w->pending));*/
1215 root 1.139
1216 root 1.42 p->w->pending = 0;
1217 root 1.82 EV_CB_INVOKE (p->w, p->events);
1218 root 1.42 }
1219     }
1220 root 1.1 }
1221    
1222 root 1.140 void inline_size
1223 root 1.51 timers_reify (EV_P)
1224 root 1.1 {
1225 root 1.63 while (timercnt && ((WT)timers [0])->at <= mn_now)
1226 root 1.1 {
1227 root 1.181 ev_timer *w = (ev_timer *)timers [0];
1228 root 1.1
1229 root 1.151 /*assert (("inactive timer on timer heap detected", ev_is_active (w)));*/
1230 root 1.61
1231 root 1.4 /* first reschedule or stop timer */
1232 root 1.1 if (w->repeat)
1233     {
1234 root 1.33 assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
1235 root 1.90
1236     ((WT)w)->at += w->repeat;
1237     if (((WT)w)->at < mn_now)
1238     ((WT)w)->at = mn_now;
1239    
1240 root 1.181 downheap (timers, timercnt, 0);
1241 root 1.12 }
1242     else
1243 root 1.51 ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
1244 root 1.30
1245 root 1.78 ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
1246 root 1.12 }
1247     }
1248 root 1.4
1249 root 1.140 #if EV_PERIODIC_ENABLE
1250     void inline_size
1251 root 1.51 periodics_reify (EV_P)
1252 root 1.12 {
1253 root 1.85 while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now)
1254 root 1.12 {
1255 root 1.181 ev_periodic *w = (ev_periodic *)periodics [0];
1256 root 1.1
1257 root 1.151 /*assert (("inactive timer on periodic heap detected", ev_is_active (w)));*/
1258 root 1.61
1259 root 1.12 /* first reschedule or stop timer */
1260 root 1.77 if (w->reschedule_cb)
1261     {
1262 root 1.176 ((WT)w)->at = w->reschedule_cb (w, ev_rt_now + TIME_EPSILON);
1263 root 1.85 assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now));
1264 root 1.181 downheap (periodics, periodiccnt, 0);
1265 root 1.77 }
1266     else if (w->interval)
1267 root 1.12 {
1268 root 1.177 ((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1269     if (((WT)w)->at - ev_rt_now <= TIME_EPSILON) ((WT)w)->at += w->interval;
1270 root 1.85 assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));
1271 root 1.181 downheap (periodics, periodiccnt, 0);
1272 root 1.1 }
1273     else
1274 root 1.51 ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
1275 root 1.12
1276 root 1.78 ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
1277 root 1.12 }
1278     }
1279    
1280 root 1.140 static void noinline
1281 root 1.54 periodics_reschedule (EV_P)
1282 root 1.12 {
1283     int i;
1284    
1285 root 1.13 /* adjust periodics after time jump */
1286 root 1.12 for (i = 0; i < periodiccnt; ++i)
1287     {
1288 root 1.181 ev_periodic *w = (ev_periodic *)periodics [i];
1289 root 1.12
1290 root 1.77 if (w->reschedule_cb)
1291 root 1.85 ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1292 root 1.77 else if (w->interval)
1293 root 1.173 ((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1294 root 1.77 }
1295 root 1.12
1296 root 1.77 /* now rebuild the heap */
1297     for (i = periodiccnt >> 1; i--; )
1298 root 1.181 downheap (periodics, periodiccnt, i);
1299 root 1.1 }
1300 root 1.93 #endif
1301 root 1.1
1302 root 1.164 #if EV_IDLE_ENABLE
1303     void inline_size
1304     idle_reify (EV_P)
1305     {
1306 root 1.165 if (expect_false (idleall))
1307 root 1.164 {
1308     int pri;
1309    
1310     for (pri = NUMPRI; pri--; )
1311     {
1312     if (pendingcnt [pri])
1313     break;
1314    
1315     if (idlecnt [pri])
1316     {
1317     queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
1318     break;
1319     }
1320     }
1321     }
1322     }
1323     #endif
1324    
1325 root 1.178 void inline_speed
1326     time_update (EV_P_ ev_tstamp max_block)
1327 root 1.4 {
1328     int i;
1329 root 1.12
1330 root 1.40 #if EV_USE_MONOTONIC
1331     if (expect_true (have_monotonic))
1332     {
1333 root 1.178 ev_tstamp odiff = rtmn_diff;
1334    
1335     mn_now = get_clock ();
1336    
1337     /* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
1338     /* interpolate in the meantime */
1339     if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
1340 root 1.40 {
1341 root 1.178 ev_rt_now = rtmn_diff + mn_now;
1342     return;
1343     }
1344    
1345     now_floor = mn_now;
1346     ev_rt_now = ev_time ();
1347 root 1.4
1348 root 1.178 /* loop a few times, before making important decisions.
1349     * on the choice of "4": one iteration isn't enough,
1350     * in case we get preempted during the calls to
1351     * ev_time and get_clock. a second call is almost guaranteed
1352     * to succeed in that case, though. and looping a few more times
1353     * doesn't hurt either as we only do this on time-jumps or
1354     * in the unlikely event of having been preempted here.
1355     */
1356     for (i = 4; --i; )
1357     {
1358     rtmn_diff = ev_rt_now - mn_now;
1359 root 1.4
1360 root 1.178 if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
1361     return; /* all is well */
1362 root 1.4
1363 root 1.178 ev_rt_now = ev_time ();
1364     mn_now = get_clock ();
1365     now_floor = mn_now;
1366     }
1367 root 1.4
1368 root 1.140 # if EV_PERIODIC_ENABLE
1369 root 1.178 periodics_reschedule (EV_A);
1370 root 1.93 # endif
1371 root 1.178 /* no timer adjustment, as the monotonic clock doesn't jump */
1372     /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
1373 root 1.4 }
1374     else
1375 root 1.40 #endif
1376 root 1.4 {
1377 root 1.85 ev_rt_now = ev_time ();
1378 root 1.40
1379 root 1.178 if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))
1380 root 1.13 {
1381 root 1.140 #if EV_PERIODIC_ENABLE
1382 root 1.54 periodics_reschedule (EV_A);
1383 root 1.93 #endif
1384 root 1.157 /* adjust timers. this is easy, as the offset is the same for all of them */
1385 root 1.13 for (i = 0; i < timercnt; ++i)
1386 root 1.85 ((WT)timers [i])->at += ev_rt_now - mn_now;
1387 root 1.13 }
1388 root 1.4
1389 root 1.85 mn_now = ev_rt_now;
1390 root 1.4 }
1391     }
1392    
1393 root 1.51 void
1394     ev_ref (EV_P)
1395     {
1396     ++activecnt;
1397     }
1398 root 1.1
1399 root 1.51 void
1400     ev_unref (EV_P)
1401     {
1402     --activecnt;
1403     }
1404    
1405     static int loop_done;
1406    
1407     void
1408     ev_loop (EV_P_ int flags)
1409 root 1.1 {
1410 root 1.135 loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)
1411     ? EVUNLOOP_ONE
1412     : EVUNLOOP_CANCEL;
1413 root 1.1
1414 root 1.158 call_pending (EV_A); /* in case we recurse, ensure ordering stays nice and clean */
1415    
1416 root 1.161 do
1417 root 1.9 {
1418 root 1.158 #ifndef _WIN32
1419     if (expect_false (curpid)) /* penalise the forking check even more */
1420     if (expect_false (getpid () != curpid))
1421     {
1422     curpid = getpid ();
1423     postfork = 1;
1424     }
1425     #endif
1426    
1427 root 1.157 #if EV_FORK_ENABLE
1428     /* we might have forked, so queue fork handlers */
1429     if (expect_false (postfork))
1430     if (forkcnt)
1431     {
1432     queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
1433     call_pending (EV_A);
1434     }
1435     #endif
1436 root 1.147
1437 root 1.170 /* queue prepare watchers (and execute them) */
1438 root 1.40 if (expect_false (preparecnt))
1439 root 1.20 {
1440 root 1.51 queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
1441     call_pending (EV_A);
1442 root 1.20 }
1443 root 1.9
1444 root 1.159 if (expect_false (!activecnt))
1445     break;
1446    
1447 root 1.70 /* we might have forked, so reify kernel state if necessary */
1448     if (expect_false (postfork))
1449     loop_fork (EV_A);
1450    
1451 root 1.1 /* update fd-related kernel structures */
1452 root 1.51 fd_reify (EV_A);
1453 root 1.1
1454     /* calculate blocking time */
1455 root 1.135 {
1456 root 1.157 ev_tstamp block;
1457 root 1.12
1458 root 1.164 if (expect_false (flags & EVLOOP_NONBLOCK || idleall || !activecnt))
1459 root 1.135 block = 0.; /* do not block at all */
1460     else
1461     {
1462     /* update time to cancel out callback processing overhead */
1463 root 1.178 time_update (EV_A_ 1e100);
1464 root 1.135
1465     block = MAX_BLOCKTIME;
1466    
1467     if (timercnt)
1468     {
1469     ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge;
1470     if (block > to) block = to;
1471     }
1472 root 1.4
1473 root 1.140 #if EV_PERIODIC_ENABLE
1474 root 1.135 if (periodiccnt)
1475     {
1476     ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge;
1477     if (block > to) block = to;
1478     }
1479 root 1.93 #endif
1480 root 1.4
1481 root 1.135 if (expect_false (block < 0.)) block = 0.;
1482     }
1483 root 1.1
1484 root 1.162 ++loop_count;
1485 root 1.135 backend_poll (EV_A_ block);
1486 root 1.178
1487     /* update ev_rt_now, do magic */
1488     time_update (EV_A_ block);
1489 root 1.135 }
1490 root 1.1
1491 root 1.9 /* queue pending timers and reschedule them */
1492 root 1.51 timers_reify (EV_A); /* relative timers called last */
1493 root 1.140 #if EV_PERIODIC_ENABLE
1494 root 1.51 periodics_reify (EV_A); /* absolute timers called first */
1495 root 1.93 #endif
1496 root 1.1
1497 root 1.164 #if EV_IDLE_ENABLE
1498 root 1.137 /* queue idle watchers unless other events are pending */
1499 root 1.164 idle_reify (EV_A);
1500     #endif
1501 root 1.9
1502 root 1.20 /* queue check watchers, to be executed first */
1503 root 1.123 if (expect_false (checkcnt))
1504 root 1.51 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
1505 root 1.9
1506 root 1.51 call_pending (EV_A);
1507 root 1.115
1508 root 1.1 }
1509 root 1.161 while (expect_true (activecnt && !loop_done));
1510 root 1.13
1511 root 1.135 if (loop_done == EVUNLOOP_ONE)
1512     loop_done = EVUNLOOP_CANCEL;
1513 root 1.51 }
1514    
1515     void
1516     ev_unloop (EV_P_ int how)
1517     {
1518     loop_done = how;
1519 root 1.1 }
1520    
1521 root 1.8 /*****************************************************************************/
1522    
1523 root 1.140 void inline_size
1524 root 1.10 wlist_add (WL *head, WL elem)
1525 root 1.1 {
1526     elem->next = *head;
1527     *head = elem;
1528     }
1529    
1530 root 1.140 void inline_size
1531 root 1.10 wlist_del (WL *head, WL elem)
1532 root 1.1 {
1533     while (*head)
1534     {
1535     if (*head == elem)
1536     {
1537     *head = elem->next;
1538     return;
1539     }
1540    
1541     head = &(*head)->next;
1542     }
1543     }
1544    
1545 root 1.140 void inline_speed
1546 root 1.166 clear_pending (EV_P_ W w)
1547 root 1.16 {
1548     if (w->pending)
1549     {
1550 root 1.42 pendings [ABSPRI (w)][w->pending - 1].w = 0;
1551 root 1.16 w->pending = 0;
1552     }
1553     }
1554    
1555 root 1.167 int
1556     ev_clear_pending (EV_P_ void *w)
1557 root 1.166 {
1558     W w_ = (W)w;
1559     int pending = w_->pending;
1560    
1561 root 1.172 if (expect_true (pending))
1562     {
1563     ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
1564     w_->pending = 0;
1565     p->w = 0;
1566     return p->events;
1567     }
1568     else
1569 root 1.167 return 0;
1570 root 1.166 }
1571    
1572 root 1.164 void inline_size
1573     pri_adjust (EV_P_ W w)
1574     {
1575     int pri = w->priority;
1576     pri = pri < EV_MINPRI ? EV_MINPRI : pri;
1577     pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
1578     w->priority = pri;
1579     }
1580    
1581 root 1.140 void inline_speed
1582 root 1.51 ev_start (EV_P_ W w, int active)
1583 root 1.1 {
1584 root 1.164 pri_adjust (EV_A_ w);
1585 root 1.1 w->active = active;
1586 root 1.51 ev_ref (EV_A);
1587 root 1.1 }
1588    
1589 root 1.140 void inline_size
1590 root 1.51 ev_stop (EV_P_ W w)
1591 root 1.1 {
1592 root 1.51 ev_unref (EV_A);
1593 root 1.1 w->active = 0;
1594     }
1595    
1596 root 1.8 /*****************************************************************************/
1597    
1598 root 1.171 void noinline
1599 root 1.136 ev_io_start (EV_P_ ev_io *w)
1600 root 1.1 {
1601 root 1.37 int fd = w->fd;
1602    
1603 root 1.123 if (expect_false (ev_is_active (w)))
1604 root 1.1 return;
1605    
1606 root 1.33 assert (("ev_io_start called with negative fd", fd >= 0));
1607    
1608 root 1.51 ev_start (EV_A_ (W)w, 1);
1609 root 1.74 array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
1610 root 1.182 wlist_add (&anfds[fd].head, (WL)w);
1611 root 1.1
1612 root 1.184 fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1);
1613     w->events &= ~EV_IOFDSET;
1614 root 1.1 }
1615    
1616 root 1.171 void noinline
1617 root 1.136 ev_io_stop (EV_P_ ev_io *w)
1618 root 1.1 {
1619 root 1.166 clear_pending (EV_A_ (W)w);
1620 root 1.123 if (expect_false (!ev_is_active (w)))
1621 root 1.1 return;
1622    
1623 root 1.89 assert (("ev_io_start called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
1624    
1625 root 1.182 wlist_del (&anfds[w->fd].head, (WL)w);
1626 root 1.51 ev_stop (EV_A_ (W)w);
1627 root 1.1
1628 root 1.184 fd_change (EV_A_ w->fd, 1);
1629 root 1.1 }
1630    
1631 root 1.171 void noinline
1632 root 1.136 ev_timer_start (EV_P_ ev_timer *w)
1633 root 1.1 {
1634 root 1.123 if (expect_false (ev_is_active (w)))
1635 root 1.1 return;
1636    
1637 root 1.63 ((WT)w)->at += mn_now;
1638 root 1.12
1639 root 1.33 assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
1640 root 1.13
1641 root 1.51 ev_start (EV_A_ (W)w, ++timercnt);
1642 root 1.181 array_needsize (WT, timers, timermax, timercnt, EMPTY2);
1643     timers [timercnt - 1] = (WT)w;
1644     upheap (timers, timercnt - 1);
1645 root 1.62
1646 root 1.151 /*assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));*/
1647 root 1.12 }
1648    
1649 root 1.171 void noinline
1650 root 1.136 ev_timer_stop (EV_P_ ev_timer *w)
1651 root 1.12 {
1652 root 1.166 clear_pending (EV_A_ (W)w);
1653 root 1.123 if (expect_false (!ev_is_active (w)))
1654 root 1.12 return;
1655    
1656 root 1.181 assert (("internal timer heap corruption", timers [((W)w)->active - 1] == (WT)w));
1657 root 1.62
1658 root 1.151 {
1659     int active = ((W)w)->active;
1660    
1661     if (expect_true (--active < --timercnt))
1662     {
1663     timers [active] = timers [timercnt];
1664 root 1.181 adjustheap (timers, timercnt, active);
1665 root 1.151 }
1666     }
1667 root 1.4
1668 root 1.91 ((WT)w)->at -= mn_now;
1669 root 1.14
1670 root 1.51 ev_stop (EV_A_ (W)w);
1671 root 1.12 }
1672 root 1.4
1673 root 1.171 void noinline
1674 root 1.136 ev_timer_again (EV_P_ ev_timer *w)
1675 root 1.14 {
1676     if (ev_is_active (w))
1677     {
1678     if (w->repeat)
1679 root 1.99 {
1680     ((WT)w)->at = mn_now + w->repeat;
1681 root 1.181 adjustheap (timers, timercnt, ((W)w)->active - 1);
1682 root 1.99 }
1683 root 1.14 else
1684 root 1.51 ev_timer_stop (EV_A_ w);
1685 root 1.14 }
1686     else if (w->repeat)
1687 root 1.112 {
1688     w->at = w->repeat;
1689     ev_timer_start (EV_A_ w);
1690     }
1691 root 1.14 }
1692    
1693 root 1.140 #if EV_PERIODIC_ENABLE
1694 root 1.171 void noinline
1695 root 1.136 ev_periodic_start (EV_P_ ev_periodic *w)
1696 root 1.12 {
1697 root 1.123 if (expect_false (ev_is_active (w)))
1698 root 1.12 return;
1699 root 1.1
1700 root 1.77 if (w->reschedule_cb)
1701 root 1.85 ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
1702 root 1.77 else if (w->interval)
1703     {
1704     assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1705     /* this formula differs from the one in periodic_reify because we do not always round up */
1706 root 1.173 ((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
1707 root 1.77 }
1708 root 1.173 else
1709     ((WT)w)->at = w->offset;
1710 root 1.12
1711 root 1.51 ev_start (EV_A_ (W)w, ++periodiccnt);
1712 root 1.181 array_needsize (WT, periodics, periodicmax, periodiccnt, EMPTY2);
1713     periodics [periodiccnt - 1] = (WT)w;
1714     upheap (periodics, periodiccnt - 1);
1715 root 1.62
1716 root 1.151 /*assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));*/
1717 root 1.1 }
1718    
1719 root 1.171 void noinline
1720 root 1.136 ev_periodic_stop (EV_P_ ev_periodic *w)
1721 root 1.1 {
1722 root 1.166 clear_pending (EV_A_ (W)w);
1723 root 1.123 if (expect_false (!ev_is_active (w)))
1724 root 1.1 return;
1725    
1726 root 1.181 assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == (WT)w));
1727 root 1.62
1728 root 1.151 {
1729     int active = ((W)w)->active;
1730    
1731     if (expect_true (--active < --periodiccnt))
1732     {
1733     periodics [active] = periodics [periodiccnt];
1734 root 1.181 adjustheap (periodics, periodiccnt, active);
1735 root 1.151 }
1736     }
1737 root 1.2
1738 root 1.51 ev_stop (EV_A_ (W)w);
1739 root 1.1 }
1740    
1741 root 1.171 void noinline
1742 root 1.136 ev_periodic_again (EV_P_ ev_periodic *w)
1743 root 1.77 {
1744 root 1.84 /* TODO: use adjustheap and recalculation */
1745 root 1.77 ev_periodic_stop (EV_A_ w);
1746     ev_periodic_start (EV_A_ w);
1747     }
1748 root 1.93 #endif
1749 root 1.77
1750 root 1.56 #ifndef SA_RESTART
1751     # define SA_RESTART 0
1752     #endif
1753    
1754 root 1.171 void noinline
1755 root 1.136 ev_signal_start (EV_P_ ev_signal *w)
1756 root 1.56 {
1757     #if EV_MULTIPLICITY
1758 root 1.116 assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr));
1759 root 1.56 #endif
1760 root 1.123 if (expect_false (ev_is_active (w)))
1761 root 1.56 return;
1762    
1763     assert (("ev_signal_start called with illegal signal number", w->signum > 0));
1764    
1765 root 1.180 {
1766     #ifndef _WIN32
1767     sigset_t full, prev;
1768     sigfillset (&full);
1769     sigprocmask (SIG_SETMASK, &full, &prev);
1770     #endif
1771    
1772     array_needsize (ANSIG, signals, signalmax, w->signum, signals_init);
1773    
1774     #ifndef _WIN32
1775     sigprocmask (SIG_SETMASK, &prev, 0);
1776     #endif
1777     }
1778    
1779 root 1.56 ev_start (EV_A_ (W)w, 1);
1780 root 1.182 wlist_add (&signals [w->signum - 1].head, (WL)w);
1781 root 1.56
1782 root 1.63 if (!((WL)w)->next)
1783 root 1.56 {
1784 root 1.103 #if _WIN32
1785 root 1.67 signal (w->signum, sighandler);
1786     #else
1787 root 1.56 struct sigaction sa;
1788     sa.sa_handler = sighandler;
1789     sigfillset (&sa.sa_mask);
1790     sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
1791     sigaction (w->signum, &sa, 0);
1792 root 1.67 #endif
1793 root 1.56 }
1794     }
1795    
1796 root 1.171 void noinline
1797 root 1.136 ev_signal_stop (EV_P_ ev_signal *w)
1798 root 1.56 {
1799 root 1.166 clear_pending (EV_A_ (W)w);
1800 root 1.123 if (expect_false (!ev_is_active (w)))
1801 root 1.56 return;
1802    
1803 root 1.182 wlist_del (&signals [w->signum - 1].head, (WL)w);
1804 root 1.56 ev_stop (EV_A_ (W)w);
1805    
1806     if (!signals [w->signum - 1].head)
1807     signal (w->signum, SIG_DFL);
1808     }
1809    
1810 root 1.28 void
1811 root 1.136 ev_child_start (EV_P_ ev_child *w)
1812 root 1.22 {
1813 root 1.56 #if EV_MULTIPLICITY
1814 root 1.116 assert (("child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
1815 root 1.56 #endif
1816 root 1.123 if (expect_false (ev_is_active (w)))
1817 root 1.22 return;
1818    
1819 root 1.51 ev_start (EV_A_ (W)w, 1);
1820 root 1.182 wlist_add (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
1821 root 1.22 }
1822    
1823 root 1.28 void
1824 root 1.136 ev_child_stop (EV_P_ ev_child *w)
1825 root 1.22 {
1826 root 1.166 clear_pending (EV_A_ (W)w);
1827 root 1.123 if (expect_false (!ev_is_active (w)))
1828 root 1.22 return;
1829    
1830 root 1.182 wlist_del (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
1831 root 1.51 ev_stop (EV_A_ (W)w);
1832 root 1.22 }
1833    
1834 root 1.140 #if EV_STAT_ENABLE
1835    
1836     # ifdef _WIN32
1837 root 1.146 # undef lstat
1838     # define lstat(a,b) _stati64 (a,b)
1839 root 1.140 # endif
1840    
1841 root 1.143 #define DEF_STAT_INTERVAL 5.0074891
1842     #define MIN_STAT_INTERVAL 0.1074891
1843    
1844 root 1.157 static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
1845 root 1.152
1846     #if EV_USE_INOTIFY
1847 root 1.153 # define EV_INOTIFY_BUFSIZE 8192
1848 root 1.152
1849     static void noinline
1850     infy_add (EV_P_ ev_stat *w)
1851     {
1852     w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD);
1853    
1854     if (w->wd < 0)
1855     {
1856     ev_timer_start (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
1857    
1858     /* monitor some parent directory for speedup hints */
1859 root 1.153 if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096)
1860 root 1.152 {
1861 root 1.153 char path [4096];
1862 root 1.152 strcpy (path, w->path);
1863    
1864     do
1865     {
1866     int mask = IN_MASK_ADD | IN_DELETE_SELF | IN_MOVE_SELF
1867     | (errno == EACCES ? IN_ATTRIB : IN_CREATE | IN_MOVED_TO);
1868    
1869     char *pend = strrchr (path, '/');
1870    
1871     if (!pend)
1872     break; /* whoops, no '/', complain to your admin */
1873    
1874     *pend = 0;
1875 root 1.153 w->wd = inotify_add_watch (fs_fd, path, mask);
1876 root 1.152 }
1877     while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
1878     }
1879     }
1880     else
1881     ev_timer_stop (EV_A_ &w->timer); /* we can watch this in a race-free way */
1882    
1883     if (w->wd >= 0)
1884     wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
1885     }
1886    
1887     static void noinline
1888     infy_del (EV_P_ ev_stat *w)
1889     {
1890     int slot;
1891     int wd = w->wd;
1892    
1893     if (wd < 0)
1894     return;
1895    
1896     w->wd = -2;
1897     slot = wd & (EV_INOTIFY_HASHSIZE - 1);
1898     wlist_del (&fs_hash [slot].head, (WL)w);
1899    
1900     /* remove this watcher, if others are watching it, they will rearm */
1901     inotify_rm_watch (fs_fd, wd);
1902     }
1903    
1904     static void noinline
1905     infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
1906     {
1907     if (slot < 0)
1908     /* overflow, need to check for all hahs slots */
1909     for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
1910     infy_wd (EV_A_ slot, wd, ev);
1911     else
1912     {
1913     WL w_;
1914    
1915     for (w_ = fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head; w_; )
1916     {
1917     ev_stat *w = (ev_stat *)w_;
1918     w_ = w_->next; /* lets us remove this watcher and all before it */
1919    
1920     if (w->wd == wd || wd == -1)
1921     {
1922     if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF))
1923     {
1924     w->wd = -1;
1925     infy_add (EV_A_ w); /* re-add, no matter what */
1926     }
1927    
1928 root 1.153 stat_timer_cb (EV_A_ &w->timer, 0);
1929 root 1.152 }
1930     }
1931     }
1932     }
1933    
1934     static void
1935     infy_cb (EV_P_ ev_io *w, int revents)
1936     {
1937     char buf [EV_INOTIFY_BUFSIZE];
1938     struct inotify_event *ev = (struct inotify_event *)buf;
1939     int ofs;
1940     int len = read (fs_fd, buf, sizeof (buf));
1941    
1942     for (ofs = 0; ofs < len; ofs += sizeof (struct inotify_event) + ev->len)
1943     infy_wd (EV_A_ ev->wd, ev->wd, ev);
1944     }
1945    
1946     void inline_size
1947     infy_init (EV_P)
1948     {
1949     if (fs_fd != -2)
1950     return;
1951    
1952     fs_fd = inotify_init ();
1953    
1954     if (fs_fd >= 0)
1955     {
1956     ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
1957     ev_set_priority (&fs_w, EV_MAXPRI);
1958     ev_io_start (EV_A_ &fs_w);
1959     }
1960     }
1961    
1962 root 1.154 void inline_size
1963     infy_fork (EV_P)
1964     {
1965     int slot;
1966    
1967     if (fs_fd < 0)
1968     return;
1969    
1970     close (fs_fd);
1971     fs_fd = inotify_init ();
1972    
1973     for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
1974     {
1975     WL w_ = fs_hash [slot].head;
1976     fs_hash [slot].head = 0;
1977    
1978     while (w_)
1979     {
1980     ev_stat *w = (ev_stat *)w_;
1981     w_ = w_->next; /* lets us add this watcher */
1982    
1983     w->wd = -1;
1984    
1985     if (fs_fd >= 0)
1986     infy_add (EV_A_ w); /* re-add, no matter what */
1987     else
1988     ev_timer_start (EV_A_ &w->timer);
1989     }
1990    
1991     }
1992     }
1993    
1994 root 1.152 #endif
1995    
1996 root 1.140 void
1997     ev_stat_stat (EV_P_ ev_stat *w)
1998     {
1999     if (lstat (w->path, &w->attr) < 0)
2000     w->attr.st_nlink = 0;
2001     else if (!w->attr.st_nlink)
2002     w->attr.st_nlink = 1;
2003     }
2004    
2005 root 1.157 static void noinline
2006 root 1.140 stat_timer_cb (EV_P_ ev_timer *w_, int revents)
2007     {
2008     ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
2009    
2010     /* we copy this here each the time so that */
2011     /* prev has the old value when the callback gets invoked */
2012     w->prev = w->attr;
2013     ev_stat_stat (EV_A_ w);
2014    
2015 root 1.156 /* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
2016     if (
2017     w->prev.st_dev != w->attr.st_dev
2018     || w->prev.st_ino != w->attr.st_ino
2019     || w->prev.st_mode != w->attr.st_mode
2020     || w->prev.st_nlink != w->attr.st_nlink
2021     || w->prev.st_uid != w->attr.st_uid
2022     || w->prev.st_gid != w->attr.st_gid
2023     || w->prev.st_rdev != w->attr.st_rdev
2024     || w->prev.st_size != w->attr.st_size
2025     || w->prev.st_atime != w->attr.st_atime
2026     || w->prev.st_mtime != w->attr.st_mtime
2027     || w->prev.st_ctime != w->attr.st_ctime
2028     ) {
2029 root 1.152 #if EV_USE_INOTIFY
2030     infy_del (EV_A_ w);
2031     infy_add (EV_A_ w);
2032     ev_stat_stat (EV_A_ w); /* avoid race... */
2033     #endif
2034    
2035     ev_feed_event (EV_A_ w, EV_STAT);
2036     }
2037 root 1.140 }
2038    
2039     void
2040     ev_stat_start (EV_P_ ev_stat *w)
2041     {
2042     if (expect_false (ev_is_active (w)))
2043     return;
2044    
2045     /* since we use memcmp, we need to clear any padding data etc. */
2046     memset (&w->prev, 0, sizeof (ev_statdata));
2047     memset (&w->attr, 0, sizeof (ev_statdata));
2048    
2049     ev_stat_stat (EV_A_ w);
2050    
2051 root 1.143 if (w->interval < MIN_STAT_INTERVAL)
2052     w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL;
2053    
2054 root 1.140 ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval);
2055     ev_set_priority (&w->timer, ev_priority (w));
2056 root 1.152
2057     #if EV_USE_INOTIFY
2058     infy_init (EV_A);
2059    
2060     if (fs_fd >= 0)
2061     infy_add (EV_A_ w);
2062     else
2063     #endif
2064     ev_timer_start (EV_A_ &w->timer);
2065 root 1.140
2066     ev_start (EV_A_ (W)w, 1);
2067     }
2068    
2069     void
2070     ev_stat_stop (EV_P_ ev_stat *w)
2071     {
2072 root 1.166 clear_pending (EV_A_ (W)w);
2073 root 1.140 if (expect_false (!ev_is_active (w)))
2074     return;
2075    
2076 root 1.152 #if EV_USE_INOTIFY
2077     infy_del (EV_A_ w);
2078     #endif
2079 root 1.140 ev_timer_stop (EV_A_ &w->timer);
2080    
2081 root 1.134 ev_stop (EV_A_ (W)w);
2082     }
2083     #endif
2084    
2085 root 1.164 #if EV_IDLE_ENABLE
2086 root 1.144 void
2087     ev_idle_start (EV_P_ ev_idle *w)
2088     {
2089     if (expect_false (ev_is_active (w)))
2090     return;
2091    
2092 root 1.164 pri_adjust (EV_A_ (W)w);
2093    
2094     {
2095     int active = ++idlecnt [ABSPRI (w)];
2096    
2097     ++idleall;
2098     ev_start (EV_A_ (W)w, active);
2099    
2100     array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
2101     idles [ABSPRI (w)][active - 1] = w;
2102     }
2103 root 1.144 }
2104    
2105     void
2106     ev_idle_stop (EV_P_ ev_idle *w)
2107     {
2108 root 1.166 clear_pending (EV_A_ (W)w);
2109 root 1.144 if (expect_false (!ev_is_active (w)))
2110     return;
2111    
2112     {
2113     int active = ((W)w)->active;
2114 root 1.164
2115     idles [ABSPRI (w)][active - 1] = idles [ABSPRI (w)][--idlecnt [ABSPRI (w)]];
2116     ((W)idles [ABSPRI (w)][active - 1])->active = active;
2117    
2118     ev_stop (EV_A_ (W)w);
2119     --idleall;
2120 root 1.144 }
2121     }
2122 root 1.164 #endif
2123 root 1.144
2124     void
2125     ev_prepare_start (EV_P_ ev_prepare *w)
2126     {
2127     if (expect_false (ev_is_active (w)))
2128     return;
2129    
2130     ev_start (EV_A_ (W)w, ++preparecnt);
2131     array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
2132     prepares [preparecnt - 1] = w;
2133     }
2134    
2135     void
2136     ev_prepare_stop (EV_P_ ev_prepare *w)
2137     {
2138 root 1.166 clear_pending (EV_A_ (W)w);
2139 root 1.144 if (expect_false (!ev_is_active (w)))
2140     return;
2141    
2142     {
2143     int active = ((W)w)->active;
2144     prepares [active - 1] = prepares [--preparecnt];
2145     ((W)prepares [active - 1])->active = active;
2146     }
2147    
2148     ev_stop (EV_A_ (W)w);
2149     }
2150    
2151     void
2152     ev_check_start (EV_P_ ev_check *w)
2153     {
2154     if (expect_false (ev_is_active (w)))
2155     return;
2156    
2157     ev_start (EV_A_ (W)w, ++checkcnt);
2158     array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
2159     checks [checkcnt - 1] = w;
2160     }
2161    
2162     void
2163     ev_check_stop (EV_P_ ev_check *w)
2164     {
2165 root 1.166 clear_pending (EV_A_ (W)w);
2166 root 1.144 if (expect_false (!ev_is_active (w)))
2167     return;
2168    
2169     {
2170     int active = ((W)w)->active;
2171     checks [active - 1] = checks [--checkcnt];
2172     ((W)checks [active - 1])->active = active;
2173     }
2174    
2175     ev_stop (EV_A_ (W)w);
2176     }
2177    
2178     #if EV_EMBED_ENABLE
2179     void noinline
2180     ev_embed_sweep (EV_P_ ev_embed *w)
2181     {
2182     ev_loop (w->loop, EVLOOP_NONBLOCK);
2183     }
2184    
2185     static void
2186     embed_cb (EV_P_ ev_io *io, int revents)
2187     {
2188     ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io));
2189    
2190     if (ev_cb (w))
2191     ev_feed_event (EV_A_ (W)w, EV_EMBED);
2192     else
2193     ev_embed_sweep (loop, w);
2194     }
2195    
2196     void
2197     ev_embed_start (EV_P_ ev_embed *w)
2198     {
2199     if (expect_false (ev_is_active (w)))
2200     return;
2201    
2202     {
2203     struct ev_loop *loop = w->loop;
2204     assert (("loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
2205     ev_io_init (&w->io, embed_cb, backend_fd, EV_READ);
2206     }
2207    
2208     ev_set_priority (&w->io, ev_priority (w));
2209     ev_io_start (EV_A_ &w->io);
2210    
2211     ev_start (EV_A_ (W)w, 1);
2212     }
2213    
2214     void
2215     ev_embed_stop (EV_P_ ev_embed *w)
2216     {
2217 root 1.166 clear_pending (EV_A_ (W)w);
2218 root 1.144 if (expect_false (!ev_is_active (w)))
2219     return;
2220    
2221     ev_io_stop (EV_A_ &w->io);
2222    
2223     ev_stop (EV_A_ (W)w);
2224     }
2225     #endif
2226    
2227 root 1.147 #if EV_FORK_ENABLE
2228     void
2229     ev_fork_start (EV_P_ ev_fork *w)
2230     {
2231     if (expect_false (ev_is_active (w)))
2232     return;
2233    
2234     ev_start (EV_A_ (W)w, ++forkcnt);
2235     array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
2236     forks [forkcnt - 1] = w;
2237     }
2238    
2239     void
2240     ev_fork_stop (EV_P_ ev_fork *w)
2241     {
2242 root 1.166 clear_pending (EV_A_ (W)w);
2243 root 1.147 if (expect_false (!ev_is_active (w)))
2244     return;
2245    
2246     {
2247     int active = ((W)w)->active;
2248     forks [active - 1] = forks [--forkcnt];
2249     ((W)forks [active - 1])->active = active;
2250     }
2251    
2252     ev_stop (EV_A_ (W)w);
2253     }
2254     #endif
2255    
2256 root 1.1 /*****************************************************************************/
2257 root 1.10
2258 root 1.16 struct ev_once
2259     {
2260 root 1.136 ev_io io;
2261     ev_timer to;
2262 root 1.16 void (*cb)(int revents, void *arg);
2263     void *arg;
2264     };
2265    
2266     static void
2267 root 1.51 once_cb (EV_P_ struct ev_once *once, int revents)
2268 root 1.16 {
2269     void (*cb)(int revents, void *arg) = once->cb;
2270     void *arg = once->arg;
2271    
2272 root 1.51 ev_io_stop (EV_A_ &once->io);
2273     ev_timer_stop (EV_A_ &once->to);
2274 root 1.69 ev_free (once);
2275 root 1.16
2276     cb (revents, arg);
2277     }
2278    
2279     static void
2280 root 1.136 once_cb_io (EV_P_ ev_io *w, int revents)
2281 root 1.16 {
2282 root 1.51 once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
2283 root 1.16 }
2284    
2285     static void
2286 root 1.136 once_cb_to (EV_P_ ev_timer *w, int revents)
2287 root 1.16 {
2288 root 1.51 once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
2289 root 1.16 }
2290    
2291     void
2292 root 1.51 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
2293 root 1.16 {
2294 root 1.74 struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
2295 root 1.16
2296 root 1.123 if (expect_false (!once))
2297 root 1.16 {
2298 root 1.123 cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
2299     return;
2300     }
2301    
2302     once->cb = cb;
2303     once->arg = arg;
2304 root 1.16
2305 root 1.123 ev_init (&once->io, once_cb_io);
2306     if (fd >= 0)
2307     {
2308     ev_io_set (&once->io, fd, events);
2309     ev_io_start (EV_A_ &once->io);
2310     }
2311 root 1.16
2312 root 1.123 ev_init (&once->to, once_cb_to);
2313     if (timeout >= 0.)
2314     {
2315     ev_timer_set (&once->to, timeout, 0.);
2316     ev_timer_start (EV_A_ &once->to);
2317 root 1.16 }
2318     }
2319    
2320 root 1.87 #ifdef __cplusplus
2321     }
2322     #endif
2323