ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.103
Committed: Mon Nov 12 00:31:08 2007 UTC (16 years, 8 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.102: +55 -53 lines
Log Message:
rewrite seletc backend, port again to msvc

File Contents

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