X-Git-Url: https://git.llucax.com/software/libev.git/blobdiff_plain/678c8c54d0ce967d8f1db3e575aed61879279975..aa07e8dd0ad9aa9952a6eeba2ef2b15429c08831:/ev.c?ds=sidebyside diff --git a/ev.c b/ev.c index 300049e..9ef3d13 100644 --- a/ev.c +++ b/ev.c @@ -30,6 +30,28 @@ */ #ifndef EV_STANDALONE # include "config.h" + +# if HAVE_CLOCK_GETTIME +# define EV_USE_MONOTONIC 1 +# define EV_USE_REALTIME 1 +# endif + +# if HAVE_SELECT && HAVE_SYS_SELECT_H +# define EV_USE_SELECT 1 +# endif + +# if HAVE_POLL && HAVE_POLL_H +# define EV_USE_POLL 1 +# endif + +# if HAVE_EPOLL && HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H +# define EV_USE_EPOLL 1 +# endif + +# if HAVE_KQUEUE && HAVE_WORKING_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H +# define EV_USE_KQUEUE 1 +# endif + #endif #include @@ -60,8 +82,8 @@ # define EV_USE_SELECT 1 #endif -#ifndef EV_USEV_POLL -# define EV_USEV_POLL 0 /* poll is usually slower than select, and not as well tested */ +#ifndef EV_USE_POLL +# define EV_USE_POLL 0 /* poll is usually slower than select, and not as well tested */ #endif #ifndef EV_USE_EPOLL @@ -72,6 +94,14 @@ # define EV_USE_KQUEUE 0 #endif +#ifndef EV_USE_WIN32 +# ifdef WIN32 +# define EV_USE_WIN32 1 +# else +# define EV_USE_WIN32 0 +# endif +#endif + #ifndef EV_USE_REALTIME # define EV_USE_REALTIME 1 #endif @@ -132,7 +162,7 @@ typedef struct int events; } ANPENDING; -#ifdef EV_MULTIPLICITY +#if EV_MULTIPLICITY struct ev_loop { @@ -204,6 +234,9 @@ ev_now (EV_P) cur = newcnt; \ } +#define array_free(stem, idx) \ + free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; + /*****************************************************************************/ static void @@ -278,11 +311,8 @@ fd_reify (EV_P) anfd->reify = 0; - if (anfd->events != events) - { - method_modify (EV_A_ fd, anfd->events, events); - anfd->events = events; - } + method_modify (EV_A_ fd, anfd->events, events); + anfd->events = events; } fdchangecnt = 0; @@ -329,9 +359,9 @@ fd_ebadf (EV_P) static void fd_enomem (EV_P) { - int fd = anfdmax; + int fd; - while (fd--) + for (fd = anfdmax; fd--; ) if (anfds [fd].events) { close (fd); @@ -340,6 +370,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 (EV_A_ fd); + } +} + /*****************************************************************************/ static void @@ -350,12 +395,12 @@ upheap (WT *heap, int k) while (k && heap [k >> 1]->at > w->at) { heap [k] = heap [k >> 1]; - heap [k]->active = k + 1; + ((W)heap [k])->active = k + 1; k >>= 1; } heap [k] = w; - heap [k]->active = k + 1; + ((W)heap [k])->active = k + 1; } @@ -375,12 +420,12 @@ downheap (WT *heap, int N, int k) break; heap [k] = heap [j]; - heap [k]->active = k + 1; + ((W)heap [k])->active = k + 1; k = j; } heap [k] = w; - heap [k]->active = k + 1; + ((W)heap [k])->active = k + 1; } /*****************************************************************************/ @@ -396,6 +441,7 @@ static int signalmax; static int sigpipe [2]; static sig_atomic_t volatile gotsig; +static struct ev_io sigev; static void signals_init (ANSIG *base, int count) @@ -463,6 +509,9 @@ siginit (EV_P) #ifndef WIN32 +static struct ev_child *childs [PID_HASHSIZE]; +static struct ev_signal childev; + #ifndef WCONTINUED # define WCONTINUED 0 #endif @@ -475,9 +524,9 @@ child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status) for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next) if (w->pid == pid || !w->pid) { - w->priority = sw->priority; /* need to do it *now* */ - w->rpid = pid; - w->rstatus = status; + ev_priority (w) = ev_priority (sw); /* need to do it *now* */ + w->rpid = pid; + w->rstatus = status; event (EV_A_ (W)w, EV_CHILD); } } @@ -507,7 +556,7 @@ childcb (EV_P_ struct ev_signal *sw, int revents) #if EV_USE_EPOLL # include "ev_epoll.c" #endif -#if EV_USEV_POLL +#if EV_USE_POLL # include "ev_poll.c" #endif #if EV_USE_SELECT @@ -562,49 +611,79 @@ 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; method = 0; +#if EV_USE_WIN32 + if (!method && (methods & EVMETHOD_WIN32 )) method = win32_init (EV_A_ methods); +#endif #if EV_USE_KQUEUE if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods); #endif #if EV_USE_EPOLL if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init (EV_A_ methods); #endif -#if EV_USEV_POLL +#if EV_USE_POLL if (!method && (methods & EVMETHOD_POLL )) method = poll_init (EV_A_ methods); #endif #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); +void +loop_destroy (EV_P) +{ + int i; -#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 */ +#if EV_USE_WIN32 + if (method == EVMETHOD_WIN32 ) win32_destroy (EV_A); +#endif +#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_USE_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; + for (i = NUMPRI; i--; ) + array_free (pending, [i]); + + array_free (fdchange, ); + array_free (timer, ); + array_free (periodic, ); + array_free (idle, ); + array_free (prepare, ); + array_free (check, ); + + method = 0; + /*TODO*/ } -#ifdef 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) { @@ -612,56 +691,108 @@ ev_loop_new (int methods) loop_init (EV_A_ methods); - return loop; + if (ev_method (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) { - loop_init (); -} + 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 */ +#if EV_MULTIPLICITY + struct ev_loop *loop = default_loop; +#endif + + 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 (void) { - /*TODO*/ -#if !EV_MULTIPLICITY -#if EV_USE_EPOLL - if (method == EVMETHOD_EPOLL) - epoll_postfork_child (EV_A); +#if EV_MULTIPLICITY + struct ev_loop *loop = default_loop; #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 } /*****************************************************************************/ @@ -679,7 +810,8 @@ call_pending (EV_P) if (p->w) { p->w->pending = 0; - p->w->cb (EV_A_ p->w, p->events); + + ((void (*)(EV_P_ W, int))p->w->cb) (EV_A_ p->w, p->events); } } } @@ -687,15 +819,17 @@ call_pending (EV_P) static void timers_reify (EV_P) { - while (timercnt && timers [0]->at <= mn_now) + while (timercnt && ((WT)timers [0])->at <= mn_now) { struct ev_timer *w = timers [0]; + assert (("inactive timer on timer heap detected", ev_is_active (w))); + /* first reschedule or stop timer */ if (w->repeat) { assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.)); - w->at = mn_now + w->repeat; + ((WT)w)->at = mn_now + w->repeat; downheap ((WT *)timers, timercnt, 0); } else @@ -708,15 +842,17 @@ timers_reify (EV_P) static void periodics_reify (EV_P) { - while (periodiccnt && periodics [0]->at <= rt_now) + while (periodiccnt && ((WT)periodics [0])->at <= rt_now) { struct ev_periodic *w = periodics [0]; + assert (("inactive timer on periodic heap detected", ev_is_active (w))); + /* first reschedule or stop timer */ if (w->interval) { - w->at += floor ((rt_now - w->at) / w->interval + 1.) * w->interval; - assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", w->at > rt_now)); + ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval; + assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now)); downheap ((WT *)periodics, periodiccnt, 0); } else @@ -738,7 +874,7 @@ periodics_reschedule (EV_P) if (w->interval) { - ev_tstamp diff = ceil ((rt_now - w->at) / w->interval) * w->interval; + ev_tstamp diff = ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval; if (fabs (diff) >= 1e-4) { @@ -809,7 +945,7 @@ time_update (EV_P) /* adjust timers. this is easy, as the offset is the same for all */ for (i = 0; i < timercnt; ++i) - timers [i]->at += rt_now - mn_now; + ((WT)timers [i])->at += rt_now - mn_now; } mn_now = rt_now; @@ -870,13 +1006,13 @@ ev_loop (EV_P_ int flags) if (timercnt) { - ev_tstamp to = timers [0]->at - mn_now + method_fudge; + ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge; if (block > to) block = to; } if (periodiccnt) { - ev_tstamp to = periodics [0]->at - rt_now + method_fudge; + ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge; if (block > to) block = to; } @@ -1003,7 +1139,7 @@ ev_timer_start (EV_P_ struct ev_timer *w) if (ev_is_active (w)) return; - w->at += mn_now; + ((WT)w)->at += mn_now; assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.)); @@ -1011,6 +1147,8 @@ ev_timer_start (EV_P_ struct ev_timer *w) array_needsize (timers, timermax, timercnt, ); timers [timercnt - 1] = w; upheap ((WT *)timers, timercnt - 1); + + assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w)); } void @@ -1020,13 +1158,15 @@ ev_timer_stop (EV_P_ struct ev_timer *w) if (!ev_is_active (w)) return; - if (w->active < timercnt--) + assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w)); + + if (((W)w)->active < timercnt--) { - timers [w->active - 1] = timers [timercnt]; - downheap ((WT *)timers, timercnt, w->active - 1); + timers [((W)w)->active - 1] = timers [timercnt]; + downheap ((WT *)timers, timercnt, ((W)w)->active - 1); } - w->at = w->repeat; + ((WT)w)->at = w->repeat; ev_stop (EV_A_ (W)w); } @@ -1038,8 +1178,8 @@ ev_timer_again (EV_P_ struct ev_timer *w) { if (w->repeat) { - w->at = mn_now + w->repeat; - downheap ((WT *)timers, timercnt, w->active - 1); + ((WT)w)->at = mn_now + w->repeat; + downheap ((WT *)timers, timercnt, ((W)w)->active - 1); } else ev_timer_stop (EV_A_ w); @@ -1058,12 +1198,14 @@ ev_periodic_start (EV_P_ struct ev_periodic *w) /* this formula differs from the one in periodic_reify because we do not always round up */ if (w->interval) - w->at += ceil ((rt_now - w->at) / w->interval) * w->interval; + ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval; ev_start (EV_A_ (W)w, ++periodiccnt); array_needsize (periodics, periodicmax, periodiccnt, ); periodics [periodiccnt - 1] = w; upheap ((WT *)periodics, periodiccnt - 1); + + assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w)); } void @@ -1073,53 +1215,15 @@ ev_periodic_stop (EV_P_ struct ev_periodic *w) if (!ev_is_active (w)) return; - if (w->active < periodiccnt--) - { - periodics [w->active - 1] = periodics [periodiccnt]; - downheap ((WT *)periodics, periodiccnt, w->active - 1); - } + assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == 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) + if (((W)w)->active < periodiccnt--) { - 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); + periodics [((W)w)->active - 1] = periodics [periodiccnt]; + downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1); } -} - -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 @@ -1140,7 +1244,7 @@ ev_idle_stop (EV_P_ struct ev_idle *w) if (ev_is_active (w)) return; - idles [w->active - 1] = idles [--idlecnt]; + idles [((W)w)->active - 1] = idles [--idlecnt]; ev_stop (EV_A_ (W)w); } @@ -1162,7 +1266,7 @@ ev_prepare_stop (EV_P_ struct ev_prepare *w) if (ev_is_active (w)) return; - prepares [w->active - 1] = prepares [--preparecnt]; + prepares [((W)w)->active - 1] = prepares [--preparecnt]; ev_stop (EV_A_ (W)w); } @@ -1184,13 +1288,59 @@ ev_check_stop (EV_P_ struct ev_check *w) if (ev_is_active (w)) return; - checks [w->active - 1] = checks [--checkcnt]; + checks [((W)w)->active - 1] = checks [--checkcnt]; + 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 (!((WL)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; @@ -1272,86 +1422,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 - - - -