diff options
| -rw-r--r-- | ev.c | 327 | ||||
| -rw-r--r-- | ev.h | 34 | ||||
| -rw-r--r-- | ev_epoll.c | 33 | ||||
| -rw-r--r-- | ev_kqueue.c | 25 | ||||
| -rw-r--r-- | ev_poll.c | 10 | ||||
| -rw-r--r-- | ev_select.c | 16 | ||||
| -rw-r--r-- | event.c | 12 |
7 files changed, 261 insertions, 196 deletions
@@ -340,6 +340,21 @@ fd_enomem (EV_P) } } +/* susually called after fork if method needs to re-arm all fds from scratch */ +static void +fd_rearm_all (EV_P) +{ + int fd; + + /* this should be highly optimised to not do anything but set a flag */ + for (fd = 0; fd < anfdmax; ++fd) + if (anfds [fd].events) + { + anfds [fd].events = 0; + fd_change (fd); + } +} + /*****************************************************************************/ static void @@ -544,7 +559,7 @@ ev_method (EV_P) return method; } -inline int +static void loop_init (EV_P_ int methods) { if (!method) @@ -562,12 +577,9 @@ loop_init (EV_P_ int methods) now_floor = mn_now; rtmn_diff = rt_now - mn_now; - if (pipe (sigpipe)) - return 0; - if (methods == EVMETHOD_AUTO) - if (!enable_secure () && getenv ("LIBmethodS")) - methods = atoi (getenv ("LIBmethodS")); + if (!enable_secure () && getenv ("LIBEV_METHODS")) + methods = atoi (getenv ("LIBEV_METHODS")); else methods = EVMETHOD_ANY; @@ -584,87 +596,145 @@ loop_init (EV_P_ int methods) #if EV_USE_SELECT if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods); #endif + } +} - if (method) - { - ev_watcher_init (&sigev, sigcb); - ev_set_priority (&sigev, EV_MAXPRI); - siginit (EV_A); - -#ifndef WIN32 - ev_signal_init (&childev, childcb, SIGCHLD); - ev_set_priority (&childev, EV_MAXPRI); - ev_signal_start (EV_A_ &childev); - ev_unref (EV_A); /* child watcher should not keep loop alive */ +void +loop_destroy (EV_P) +{ +#if EV_USE_KQUEUE + if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A); +#endif +#if EV_USE_EPOLL + if (method == EVMETHOD_EPOLL ) epoll_destroy (EV_A); +#endif +#if EV_USEV_POLL + if (method == EVMETHOD_POLL ) poll_destroy (EV_A); +#endif +#if EV_USE_SELECT + if (method == EVMETHOD_SELECT) select_destroy (EV_A); #endif - } - } - return method; + method = 0; + /*TODO*/ } -#if EV_MULTIPLICITY +void +loop_fork (EV_P) +{ + /*TODO*/ +#if EV_USE_EPOLL + if (method == EVMETHOD_EPOLL ) epoll_fork (EV_A); +#endif +#if EV_USE_KQUEUE + if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A); +#endif +} +#if EV_MULTIPLICITY struct ev_loop * ev_loop_new (int methods) { struct ev_loop *loop = (struct ev_loop *)calloc (1, sizeof (struct ev_loop)); - if (loop_init (EV_A_ methods)) - return loop; + loop_init (EV_A_ methods); - ev_loop_delete (loop); + if (ev_methods (EV_A)) + return loop; return 0; } void -ev_loop_delete (EV_P) +ev_loop_destroy (EV_P) { - /*TODO*/ + loop_destroy (EV_A); free (loop); } +void +ev_loop_fork (EV_P) +{ + loop_fork (EV_A); +} + +#endif + +#if EV_MULTIPLICITY +struct ev_loop default_loop_struct; +static struct ev_loop *default_loop; + +struct ev_loop * #else +static int default_loop; int -ev_init (int methods) +#endif +ev_default_loop (int methods) { - return loop_init (methods); -} + if (sigpipe [0] == sigpipe [1]) + if (pipe (sigpipe)) + return 0; + if (!default_loop) + { +#if EV_MULTIPLICITY + struct ev_loop *loop = default_loop = &default_loop_struct; +#else + default_loop = 1; #endif -/*****************************************************************************/ + loop_init (EV_A_ methods); -void -ev_fork_prepare (void) -{ - /* nop */ + if (ev_method (EV_A)) + { + ev_watcher_init (&sigev, sigcb); + ev_set_priority (&sigev, EV_MAXPRI); + siginit (EV_A); + +#ifndef WIN32 + ev_signal_init (&childev, childcb, SIGCHLD); + ev_set_priority (&childev, EV_MAXPRI); + ev_signal_start (EV_A_ &childev); + ev_unref (EV_A); /* child watcher should not keep loop alive */ +#endif + } + else + default_loop = 0; + } + + return default_loop; } void -ev_fork_parent (void) +ev_default_destroy (void) { - /* nop */ + struct ev_loop *loop = default_loop; + + ev_ref (EV_A); /* child watcher */ + ev_signal_stop (EV_A_ &childev); + + ev_ref (EV_A); /* signal watcher */ + ev_io_stop (EV_A_ &sigev); + + close (sigpipe [0]); sigpipe [0] = 0; + close (sigpipe [1]); sigpipe [1] = 0; + + loop_destroy (EV_A); } void -ev_fork_child (void) +ev_default_fork (EV_P) { - /*TODO*/ -#if !EV_MULTIPLICITY -#if EV_USE_EPOLL - if (method == EVMETHOD_EPOLL) - epoll_postfork_child (EV_A); -#endif + loop_fork (EV_A); ev_io_stop (EV_A_ &sigev); close (sigpipe [0]); close (sigpipe [1]); pipe (sigpipe); + + ev_ref (EV_A); /* signal watcher */ siginit (EV_A); -#endif } /*****************************************************************************/ @@ -1085,46 +1155,6 @@ ev_periodic_stop (EV_P_ struct ev_periodic *w) ev_stop (EV_A_ (W)w); } -#ifndef SA_RESTART -# define SA_RESTART 0 -#endif - -void -ev_signal_start (EV_P_ struct ev_signal *w) -{ - if (ev_is_active (w)) - return; - - assert (("ev_signal_start called with illegal signal number", w->signum > 0)); - - ev_start (EV_A_ (W)w, 1); - array_needsize (signals, signalmax, w->signum, signals_init); - wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w); - - if (!w->next) - { - struct sigaction sa; - sa.sa_handler = sighandler; - sigfillset (&sa.sa_mask); - sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */ - sigaction (w->signum, &sa, 0); - } -} - -void -ev_signal_stop (EV_P_ struct ev_signal *w) -{ - ev_clear_pending (EV_A_ (W)w); - if (!ev_is_active (w)) - return; - - wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w); - ev_stop (EV_A_ (W)w); - - if (!signals [w->signum - 1].head) - signal (w->signum, SIG_DFL); -} - void ev_idle_start (EV_P_ struct ev_idle *w) { @@ -1191,9 +1221,55 @@ ev_check_stop (EV_P_ struct ev_check *w) ev_stop (EV_A_ (W)w); } +#ifndef SA_RESTART +# define SA_RESTART 0 +#endif + +void +ev_signal_start (EV_P_ struct ev_signal *w) +{ +#if EV_MULTIPLICITY + assert (("signal watchers are only supported in the default loop", loop == default_loop)); +#endif + if (ev_is_active (w)) + return; + + assert (("ev_signal_start called with illegal signal number", w->signum > 0)); + + ev_start (EV_A_ (W)w, 1); + array_needsize (signals, signalmax, w->signum, signals_init); + wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w); + + if (!w->next) + { + struct sigaction sa; + sa.sa_handler = sighandler; + sigfillset (&sa.sa_mask); + sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */ + sigaction (w->signum, &sa, 0); + } +} + +void +ev_signal_stop (EV_P_ struct ev_signal *w) +{ + ev_clear_pending (EV_A_ (W)w); + if (!ev_is_active (w)) + return; + + wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w); + ev_stop (EV_A_ (W)w); + + if (!signals [w->signum - 1].head) + signal (w->signum, SIG_DFL); +} + void ev_child_start (EV_P_ struct ev_child *w) { +#if EV_MULTIPLICITY + assert (("child watchers are only supported in the default loop", loop == default_loop)); +#endif if (ev_is_active (w)) return; @@ -1275,86 +1351,3 @@ ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, vo } } -/*****************************************************************************/ - -#if 0 - -struct ev_io wio; - -static void -sin_cb (struct ev_io *w, int revents) -{ - fprintf (stderr, "sin %d, revents %d\n", w->fd, revents); -} - -static void -ocb (struct ev_timer *w, int revents) -{ - //fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data); - ev_timer_stop (w); - ev_timer_start (w); -} - -static void -scb (struct ev_signal *w, int revents) -{ - fprintf (stderr, "signal %x,%d\n", revents, w->signum); - ev_io_stop (&wio); - ev_io_start (&wio); -} - -static void -gcb (struct ev_signal *w, int revents) -{ - fprintf (stderr, "generic %x\n", revents); - -} - -int main (void) -{ - ev_init (0); - - ev_io_init (&wio, sin_cb, 0, EV_READ); - ev_io_start (&wio); - - struct ev_timer t[10000]; - -#if 0 - int i; - for (i = 0; i < 10000; ++i) - { - struct ev_timer *w = t + i; - ev_watcher_init (w, ocb, i); - ev_timer_init_abs (w, ocb, drand48 (), 0.99775533); - ev_timer_start (w); - if (drand48 () < 0.5) - ev_timer_stop (w); - } -#endif - - struct ev_timer t1; - ev_timer_init (&t1, ocb, 5, 10); - ev_timer_start (&t1); - - struct ev_signal sig; - ev_signal_init (&sig, scb, SIGQUIT); - ev_signal_start (&sig); - - struct ev_check cw; - ev_check_init (&cw, gcb); - ev_check_start (&cw); - - struct ev_idle iw; - ev_idle_init (&iw, gcb); - ev_idle_start (&iw); - - ev_loop (0); - - return 0; -} - -#endif - - - - @@ -212,22 +212,29 @@ struct ev_child int ev_version_major (void); int ev_version_minor (void); -/* these three calls are suitable for plugging into pthread_atfork */ -void ev_fork_prepare (void); -void ev_fork_parent (void); -void ev_fork_child (void); - ev_tstamp ev_time (void); # if EV_MULTIPLICITY +/* the default loop is the only one that handles signals and child watchers */ +/* you can call this as often as you like */ +struct ev_loop *ev_default_loop (int methods); /* returns default loop */ + +/* create and destroy alternative loops that don't handle signals */ struct ev_loop *ev_loop_new (int methods); -void ev_loop_delete (EV_P); +void ev_loop_destroy (EV_P); +void ev_loop_fork (EV_P); # else -int ev_init (int methods); /* returns ev_method */ +int ev_default_loop (int methods); /* returns true when successful */ # endif -int ev_method (EV_P); +void ev_default_destroy (void); /* destroy the default loop */ +/* this needs to be called after fork, to duplicate the default loop */ +/* if you create alternative loops you have to call ev_loop_fork on them */ +/* you can call it in either the parent or the child */ +/* you can actually call it at any time, anywhere :) */ +void ev_default_fork (void); +int ev_method (EV_P); #endif #define EVLOOP_NONBLOCK 1 /* do not block/wait */ @@ -287,14 +294,12 @@ void ev_io_stop (EV_P_ struct ev_io *w); void ev_timer_start (EV_P_ struct ev_timer *w); void ev_timer_stop (EV_P_ struct ev_timer *w); -void ev_timer_again (EV_P_ struct ev_timer *w); /* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */ +/* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */ +void ev_timer_again (EV_P_ struct ev_timer *w); void ev_periodic_start (EV_P_ struct ev_periodic *w); void ev_periodic_stop (EV_P_ struct ev_periodic *w); -void ev_signal_start (EV_P_ struct ev_signal *w); -void ev_signal_stop (EV_P_ struct ev_signal *w); - void ev_idle_start (EV_P_ struct ev_idle *w); void ev_idle_stop (EV_P_ struct ev_idle *w); @@ -304,6 +309,11 @@ void ev_prepare_stop (EV_P_ struct ev_prepare *w); void ev_check_start (EV_P_ struct ev_check *w); void ev_check_stop (EV_P_ struct ev_check *w); +/* only supported in the default loop */ +void ev_signal_start (EV_P_ struct ev_signal *w); +void ev_signal_stop (EV_P_ struct ev_signal *w); + +/* only supported in the default loop */ void ev_child_start (EV_P_ struct ev_child *w); void ev_child_stop (EV_P_ struct ev_child *w); #endif @@ -46,20 +46,6 @@ epoll_modify (EV_P_ int fd, int oev, int nev) } static void -epoll_postfork_child (EV_P) -{ - int fd; - - epoll_fd = epoll_create (256); - fcntl (epoll_fd, F_SETFD, FD_CLOEXEC); - - /* re-register interest in fds */ - for (fd = 0; fd < anfdmax; ++fd) - if (anfds [fd].events)//D - epoll_modify (EV_A_ fd, EV_NONE, anfds [fd].events); -} - -static void epoll_poll (EV_P_ ev_tstamp timeout) { int eventcnt = epoll_wait (epoll_fd, epoll_events, epoll_eventmax, ceil (timeout * 1000.)); @@ -105,3 +91,22 @@ epoll_init (EV_P_ int flags) return EVMETHOD_EPOLL; } +static void +epoll_destroy (EV_P) +{ + close (epoll_fd); + + free (epoll_events); +} + +static void +epoll_fork (EV_P) +{ + int fd; + + epoll_fd = epoll_create (256); + fcntl (epoll_fd, F_SETFD, FD_CLOEXEC); + + fd_rearm_all (); +} + diff --git a/ev_kqueue.c b/ev_kqueue.c index 8282fea..2de8874 100644 --- a/ev_kqueue.c +++ b/ev_kqueue.c @@ -133,6 +133,8 @@ kqueue_init (EV_P_ int flags) if ((kqueue_fd = kqueue ()) < 0) return 0; + fcntl (kqueue_fd, F_SETFD, FD_CLOEXEC); /* not sure if necessary, hopefully doesn't hurt */ + /* Check for Mac OS X kqueue bug. */ ch.ident = -1; ch.filter = EVFILT_READ; @@ -159,6 +161,29 @@ kqueue_init (EV_P_ int flags) kqueue_eventmax = 64; /* intiial number of events receivable per poll */ kqueue_events = malloc (sizeof (struct kevent) * kqueue_eventmax); + kqueue_changes = 0; + kqueue_changemax = 0; + kqueue_changecnt = 0; + return EVMETHOD_KQUEUE; } +static void +kqueue_destroy (EV_P) +{ + close (kqueue_fd); + + free (kqueue_events); + free (kqueue_changes); +} + +static void +kqueue_fork (EV_P) +{ + kqueue_fd = kqueue (); + fcntl (kqueue_fd, F_SETFD, FD_CLOEXEC); + + /* re-register interest in fds */ + fd_rearm_all (); +} + @@ -101,5 +101,15 @@ poll_init (EV_P_ int flags) method_modify = poll_modify; method_poll = poll_poll; + pollidxs = 0; pollidxmax = 0; + polls = 0; pollsmax = 0; pollscnt = 0; + return EVMETHOD_POLL; } + +static void +poll_destroy (EV_P) +{ + free (pollidxs); + free (polls); +} diff --git a/ev_select.c b/ev_select.c index 5738fe5..327c313 100644 --- a/ev_select.c +++ b/ev_select.c @@ -128,6 +128,22 @@ select_init (EV_P_ int flags) method_modify = select_modify; method_poll = select_poll; + vec_max = 0; + vec_ri = 0; + vec_ri = 0; + vec_wo = 0; + vec_wo = 0; + return EVMETHOD_SELECT; } +static void +select_destroy (EV_P) +{ + free (vec_ri); + free (vec_ro); + free (vec_wi); + free (vec_wo); +} + + @@ -32,6 +32,7 @@ #include <stddef.h> #include <stdlib.h> #include <sys/time.h> +#include <assert.h> #include "event.h" @@ -49,7 +50,7 @@ struct event_base int dummy; }; -static struct event_base x_base, *x_cur; +static struct event_base *x_cur; static void tv_set (struct timeval *tv, ev_tstamp at) @@ -82,9 +83,14 @@ const char *event_get_method (void) void *event_init (void) { #if EV_MULTIPLICITY - x_cur = (struct event_base *)ev_loop_new (EVMETHOD_AUTO); + if (x_cur) + x_cur = (struct event_base *)ev_loop_new (EVMETHOD_AUTO); + else + x_cur = ev_default_loop (EVMETHOD_AUTO); #else - x_cur = &x_base; + assert (("multiple event bases not supported when not compiled with EV_MULTIPLICITY", !x_cur)); + + x_cur = (struct event_base *)ev_default_loop (EVMETHOD_AUTO); #endif return x_cur; |