X-Git-Url: https://git.llucax.com/software/libev.git/blobdiff_plain/c896b553711ae963b01b7a602e8fb6718d107f6f..ba71cf07f3506b8e303130e981d3b5b3e9ea5dc8:/ev.c diff --git a/ev.c b/ev.c index fd82fbd..40e2292 100644 --- a/ev.c +++ b/ev.c @@ -113,9 +113,9 @@ extern "C" { #include #ifndef _WIN32 -# include # include # include +# include #else # define WIN32_LEAN_AND_MEAN # include @@ -189,10 +189,19 @@ extern "C" { #if __GNUC__ >= 3 # define expect(expr,value) __builtin_expect ((expr),(value)) -# define inline static inline +# define inline_size static inline /* inline for codesize */ +# if EV_MINIMAL +# define noinline __attribute__ ((noinline)) +# define inline_speed static noinline +# else +# define noinline +# define inline_speed static inline +# endif #else # define expect(expr,value) (expr) -# define inline static +# define inline_speed static +# define inline_size static +# define noinline #endif #define expect_false(expr) expect ((expr) != 0, 0) @@ -204,9 +213,9 @@ extern "C" { #define EMPTY0 /* required for microsofts broken pseudo-c compiler */ #define EMPTY2(a,b) /* used to suppress some warnings */ -typedef struct ev_watcher *W; -typedef struct ev_watcher_list *WL; -typedef struct ev_watcher_time *WT; +typedef ev_watcher *W; +typedef ev_watcher_list *WL; +typedef ev_watcher_time *WT; static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */ @@ -218,12 +227,13 @@ static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */ static void (*syserr_cb)(const char *msg); -void ev_set_syserr_cb (void (*cb)(const char *msg)) +void +ev_set_syserr_cb (void (*cb)(const char *msg)) { syserr_cb = cb; } -static void +static void noinline syserr (const char *msg) { if (!msg) @@ -240,7 +250,8 @@ syserr (const char *msg) static void *(*alloc)(void *ptr, long size); -void ev_set_allocator (void *(*cb)(void *ptr, long size)) +void +ev_set_allocator (void *(*cb)(void *ptr, long size)) { alloc = cb; } @@ -322,7 +333,7 @@ ev_time (void) #endif } -inline ev_tstamp +ev_tstamp inline_size get_clock (void) { #if EV_USE_MONOTONIC @@ -375,20 +386,7 @@ ev_now (EV_P) /*****************************************************************************/ -static void -anfds_init (ANFD *base, int count) -{ - while (count--) - { - base->head = 0; - base->events = EV_NONE; - base->reify = 0; - - ++base; - } -} - -void +void noinline ev_feed_event (EV_P_ void *w, int revents) { W w_ = (W)w; @@ -405,7 +403,7 @@ ev_feed_event (EV_P_ void *w, int revents) pendings [ABSPRI (w_)][w_->pending - 1].events = revents; } -static void +void inline_size queue_events (EV_P_ W *events, int eventcnt, int type) { int i; @@ -414,13 +412,28 @@ queue_events (EV_P_ W *events, int eventcnt, int type) ev_feed_event (EV_A_ events [i], type); } -inline void +/*****************************************************************************/ + +void inline_size +anfds_init (ANFD *base, int count) +{ + while (count--) + { + base->head = 0; + base->events = EV_NONE; + base->reify = 0; + + ++base; + } +} + +void inline_speed fd_event (EV_P_ int fd, int revents) { ANFD *anfd = anfds + fd; - struct ev_io *w; + ev_io *w; - for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next) + for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next) { int ev = w->events & revents; @@ -435,9 +448,7 @@ ev_feed_fd_event (EV_P_ int fd, int revents) fd_event (EV_A_ fd, revents); } -/*****************************************************************************/ - -inline void +void inline_size fd_reify (EV_P) { int i; @@ -446,11 +457,11 @@ fd_reify (EV_P) { int fd = fdchanges [i]; ANFD *anfd = anfds + fd; - struct ev_io *w; + ev_io *w; int events = 0; - for (w = (struct ev_io *)anfd->head; w; w = (struct ev_io *)((WL)w)->next) + for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next) events |= w->events; #if EV_SELECT_IS_WINSOCKET @@ -471,7 +482,7 @@ fd_reify (EV_P) fdchangecnt = 0; } -static void +void inline_size fd_change (EV_P_ int fd) { if (expect_false (anfds [fd].reify)) @@ -484,19 +495,19 @@ fd_change (EV_P_ int fd) fdchanges [fdchangecnt - 1] = fd; } -static void +void inline_speed fd_kill (EV_P_ int fd) { - struct ev_io *w; + ev_io *w; - while ((w = (struct ev_io *)anfds [fd].head)) + while ((w = (ev_io *)anfds [fd].head)) { ev_io_stop (EV_A_ w); ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE); } } -inline int +int inline_size fd_valid (int fd) { #ifdef _WIN32 @@ -507,7 +518,7 @@ fd_valid (int fd) } /* called on EBADF to verify fds */ -static void +static void noinline fd_ebadf (EV_P) { int fd; @@ -519,7 +530,7 @@ fd_ebadf (EV_P) } /* called on ENOMEM in select/poll to kill some fds and retry */ -static void +static void noinline fd_enomem (EV_P) { int fd; @@ -533,7 +544,7 @@ fd_enomem (EV_P) } /* usually called after fork if backend needs to re-arm all fds from scratch */ -static void +static void noinline fd_rearm_all (EV_P) { int fd; @@ -549,7 +560,7 @@ fd_rearm_all (EV_P) /*****************************************************************************/ -static void +void inline_speed upheap (WT *heap, int k) { WT w = heap [k]; @@ -566,7 +577,7 @@ upheap (WT *heap, int k) } -static void +void inline_speed downheap (WT *heap, int N, int k) { WT w = heap [k]; @@ -590,7 +601,7 @@ downheap (WT *heap, int N, int k) ((W)heap [k])->active = k + 1; } -inline void +void inline_size adjustheap (WT *heap, int N, int k) { upheap (heap, k); @@ -610,9 +621,9 @@ static int signalmax; static int sigpipe [2]; static sig_atomic_t volatile gotsig; -static struct ev_io sigev; +static ev_io sigev; -static void +void inline_size signals_init (ANSIG *base, int count) { while (count--) @@ -642,7 +653,7 @@ sighandler (int signum) } } -void +void noinline ev_feed_signal_event (EV_P_ int signum) { WL w; @@ -663,7 +674,7 @@ ev_feed_signal_event (EV_P_ int signum) } static void -sigcb (EV_P_ struct ev_io *iow, int revents) +sigcb (EV_P_ ev_io *iow, int revents) { int signum; @@ -675,7 +686,7 @@ sigcb (EV_P_ struct ev_io *iow, int revents) ev_feed_signal_event (EV_A_ signum + 1); } -static void +void inline_size fd_intern (int fd) { #ifdef _WIN32 @@ -687,7 +698,7 @@ fd_intern (int fd) #endif } -static void +static void noinline siginit (EV_P) { fd_intern (sigpipe [0]); @@ -700,22 +711,18 @@ siginit (EV_P) /*****************************************************************************/ -static struct ev_child *childs [PID_HASHSIZE]; +static ev_child *childs [PID_HASHSIZE]; #ifndef _WIN32 -static struct ev_signal childev; - -#ifndef WCONTINUED -# define WCONTINUED 0 -#endif +static ev_signal childev; -static void -child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status) +void inline_speed +child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status) { - struct ev_child *w; + ev_child *w; - for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next) + for (w = (ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next) if (w->pid == pid || !w->pid) { ev_priority (w) = ev_priority (sw); /* need to do it *now* */ @@ -725,20 +732,28 @@ child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status) } } +#ifndef WCONTINUED +# define WCONTINUED 0 +#endif + static void -childcb (EV_P_ struct ev_signal *sw, int revents) +childcb (EV_P_ ev_signal *sw, int revents) { int pid, status; - if (0 < (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED))) - { - /* make sure we are called again until all childs have been reaped */ - /* we need to do it this way so that the callback gets called before we continue */ - ev_feed_event (EV_A_ (W)sw, EV_SIGNAL); + /* some systems define WCONTINUED but then fail to support it (linux 2.4) */ + if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED))) + if (!WCONTINUED + || errno != EINVAL + || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED))) + return; - child_reap (EV_A_ sw, pid, pid, status); - child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */ - } + /* make sure we are called again until all childs have been reaped */ + /* we need to do it this way so that the callback gets called before we continue */ + ev_feed_event (EV_A_ (W)sw, EV_SIGNAL); + + child_reap (EV_A_ sw, pid, pid, status); + child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */ } #endif @@ -774,7 +789,7 @@ ev_version_minor (void) } /* return true if we are running with elevated privileges and should ignore env variables */ -static int +int inline_size enable_secure (void) { #ifdef _WIN32 @@ -817,6 +832,14 @@ ev_recommended_backends (void) return flags; } +unsigned int +ev_embeddable_backends (void) +{ + return EVBACKEND_EPOLL + | EVBACKEND_KQUEUE + | EVBACKEND_PORT; +} + unsigned int ev_backend (EV_P) { @@ -898,7 +921,7 @@ loop_destroy (EV_P) /* have to use the microsoft-never-gets-it-right macro */ array_free (fdchange, EMPTY0); array_free (timer, EMPTY0); -#if EV_PERIODICS +#if EV_PERIODIC_ENABLE array_free (periodic, EMPTY0); #endif array_free (idle, EMPTY0); @@ -1044,7 +1067,7 @@ ev_default_fork (void) /*****************************************************************************/ -static int +int inline_size any_pending (EV_P) { int pri; @@ -1056,7 +1079,7 @@ any_pending (EV_P) return 0; } -inline void +void inline_speed call_pending (EV_P) { int pri; @@ -1068,18 +1091,20 @@ call_pending (EV_P) if (expect_true (p->w)) { + assert (("non-pending watcher on pending list", p->w->pending)); + p->w->pending = 0; EV_CB_INVOKE (p->w, p->events); } } } -inline void +void inline_size timers_reify (EV_P) { while (timercnt && ((WT)timers [0])->at <= mn_now) { - struct ev_timer *w = timers [0]; + ev_timer *w = timers [0]; assert (("inactive timer on timer heap detected", ev_is_active (w))); @@ -1101,13 +1126,13 @@ timers_reify (EV_P) } } -#if EV_PERIODICS -inline void +#if EV_PERIODIC_ENABLE +void inline_size periodics_reify (EV_P) { while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now) { - struct ev_periodic *w = periodics [0]; + ev_periodic *w = periodics [0]; assert (("inactive timer on periodic heap detected", ev_is_active (w))); @@ -1131,7 +1156,7 @@ periodics_reify (EV_P) } } -static void +static void noinline periodics_reschedule (EV_P) { int i; @@ -1139,7 +1164,7 @@ periodics_reschedule (EV_P) /* adjust periodics after time jump */ for (i = 0; i < periodiccnt; ++i) { - struct ev_periodic *w = periodics [i]; + ev_periodic *w = periodics [i]; if (w->reschedule_cb) ((WT)w)->at = w->reschedule_cb (w, ev_rt_now); @@ -1153,7 +1178,7 @@ periodics_reschedule (EV_P) } #endif -inline int +int inline_size time_update_monotonic (EV_P) { mn_now = get_clock (); @@ -1171,7 +1196,7 @@ time_update_monotonic (EV_P) } } -inline void +void inline_size time_update (EV_P) { int i; @@ -1183,7 +1208,15 @@ time_update (EV_P) { ev_tstamp odiff = rtmn_diff; - for (i = 4; --i; ) /* loop a few times, before making important decisions */ + /* loop a few times, before making important decisions. + * on the choice of "4": one iteration isn't enough, + * in case we get preempted during the calls to + * ev_time and get_clock. a second call is almost guarenteed + * to succeed in that case, though. and looping a few more times + * doesn't hurt either as we only do this on time-jumps or + * in the unlikely event of getting preempted here. + */ + for (i = 4; --i; ) { rtmn_diff = ev_rt_now - mn_now; @@ -1195,7 +1228,7 @@ time_update (EV_P) now_floor = mn_now; } -# if EV_PERIODICS +# if EV_PERIODIC_ENABLE periodics_reschedule (EV_A); # endif /* no timer adjustment, as the monotonic clock doesn't jump */ @@ -1209,7 +1242,7 @@ time_update (EV_P) if (expect_false (mn_now > ev_rt_now || mn_now < ev_rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP)) { -#if EV_PERIODICS +#if EV_PERIODIC_ENABLE periodics_reschedule (EV_A); #endif @@ -1239,8 +1272,9 @@ static int loop_done; void ev_loop (EV_P_ int flags) { - double block; - loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0; + loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) + ? EVUNLOOP_ONE + : EVUNLOOP_CANCEL; while (activecnt) { @@ -1259,54 +1293,56 @@ ev_loop (EV_P_ int flags) fd_reify (EV_A); /* calculate blocking time */ + { + double block; - /* we only need this for !monotonic clock or timers, but as we basically - always have timers, we just calculate it always */ + if (flags & EVLOOP_NONBLOCK || idlecnt) + block = 0.; /* do not block at all */ + else + { + /* update time to cancel out callback processing overhead */ #if EV_USE_MONOTONIC - if (expect_true (have_monotonic)) - time_update_monotonic (EV_A); - else + if (expect_true (have_monotonic)) + time_update_monotonic (EV_A); + else #endif - { - ev_rt_now = ev_time (); - mn_now = ev_rt_now; - } + { + ev_rt_now = ev_time (); + mn_now = ev_rt_now; + } - if (flags & EVLOOP_NONBLOCK || idlecnt) - block = 0.; - else - { - block = MAX_BLOCKTIME; + block = MAX_BLOCKTIME; - if (timercnt) - { - ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge; - if (block > to) block = to; - } + if (timercnt) + { + ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge; + if (block > to) block = to; + } -#if EV_PERIODICS - if (periodiccnt) - { - ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge; - if (block > to) block = to; - } +#if EV_PERIODIC_ENABLE + if (periodiccnt) + { + ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge; + if (block > to) block = to; + } #endif - if (expect_false (block < 0.)) block = 0.; - } + if (expect_false (block < 0.)) block = 0.; + } - backend_poll (EV_A_ block); + backend_poll (EV_A_ block); + } /* update ev_rt_now, do magic */ time_update (EV_A); /* queue pending timers and reschedule them */ timers_reify (EV_A); /* relative timers called last */ -#if EV_PERIODICS +#if EV_PERIODIC_ENABLE periodics_reify (EV_A); /* absolute timers called first */ #endif - /* queue idle watchers unless io or timers are pending */ + /* queue idle watchers unless other events are pending */ if (idlecnt && !any_pending (EV_A)) queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE); @@ -1320,8 +1356,8 @@ ev_loop (EV_P_ int flags) break; } - if (loop_done != 2) - loop_done = 0; + if (loop_done == EVUNLOOP_ONE) + loop_done = EVUNLOOP_CANCEL; } void @@ -1332,14 +1368,14 @@ ev_unloop (EV_P_ int how) /*****************************************************************************/ -inline void +void inline_size wlist_add (WL *head, WL elem) { elem->next = *head; *head = elem; } -inline void +void inline_size wlist_del (WL *head, WL elem) { while (*head) @@ -1354,7 +1390,7 @@ wlist_del (WL *head, WL elem) } } -inline void +void inline_speed ev_clear_pending (EV_P_ W w) { if (w->pending) @@ -1364,7 +1400,7 @@ ev_clear_pending (EV_P_ W w) } } -inline void +void inline_speed ev_start (EV_P_ W w, int active) { if (w->priority < EV_MINPRI) w->priority = EV_MINPRI; @@ -1374,7 +1410,7 @@ ev_start (EV_P_ W w, int active) ev_ref (EV_A); } -inline void +void inline_size ev_stop (EV_P_ W w) { ev_unref (EV_A); @@ -1384,7 +1420,7 @@ ev_stop (EV_P_ W w) /*****************************************************************************/ void -ev_io_start (EV_P_ struct ev_io *w) +ev_io_start (EV_P_ ev_io *w) { int fd = w->fd; @@ -1401,7 +1437,7 @@ ev_io_start (EV_P_ struct ev_io *w) } void -ev_io_stop (EV_P_ struct ev_io *w) +ev_io_stop (EV_P_ ev_io *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -1416,7 +1452,7 @@ ev_io_stop (EV_P_ struct ev_io *w) } void -ev_timer_start (EV_P_ struct ev_timer *w) +ev_timer_start (EV_P_ ev_timer *w) { if (expect_false (ev_is_active (w))) return; @@ -1426,7 +1462,7 @@ ev_timer_start (EV_P_ struct ev_timer *w) assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.)); ev_start (EV_A_ (W)w, ++timercnt); - array_needsize (struct ev_timer *, timers, timermax, timercnt, EMPTY2); + array_needsize (ev_timer *, timers, timermax, timercnt, EMPTY2); timers [timercnt - 1] = w; upheap ((WT *)timers, timercnt - 1); @@ -1434,7 +1470,7 @@ ev_timer_start (EV_P_ struct ev_timer *w) } void -ev_timer_stop (EV_P_ struct ev_timer *w) +ev_timer_stop (EV_P_ ev_timer *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -1454,7 +1490,7 @@ ev_timer_stop (EV_P_ struct ev_timer *w) } void -ev_timer_again (EV_P_ struct ev_timer *w) +ev_timer_again (EV_P_ ev_timer *w) { if (ev_is_active (w)) { @@ -1473,9 +1509,9 @@ ev_timer_again (EV_P_ struct ev_timer *w) } } -#if EV_PERIODICS +#if EV_PERIODIC_ENABLE void -ev_periodic_start (EV_P_ struct ev_periodic *w) +ev_periodic_start (EV_P_ ev_periodic *w) { if (expect_false (ev_is_active (w))) return; @@ -1490,7 +1526,7 @@ ev_periodic_start (EV_P_ struct ev_periodic *w) } ev_start (EV_A_ (W)w, ++periodiccnt); - array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, EMPTY2); + array_needsize (ev_periodic *, periodics, periodicmax, periodiccnt, EMPTY2); periodics [periodiccnt - 1] = w; upheap ((WT *)periodics, periodiccnt - 1); @@ -1498,7 +1534,7 @@ ev_periodic_start (EV_P_ struct ev_periodic *w) } void -ev_periodic_stop (EV_P_ struct ev_periodic *w) +ev_periodic_stop (EV_P_ ev_periodic *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -1516,7 +1552,7 @@ ev_periodic_stop (EV_P_ struct ev_periodic *w) } void -ev_periodic_again (EV_P_ struct ev_periodic *w) +ev_periodic_again (EV_P_ ev_periodic *w) { /* TODO: use adjustheap and recalculation */ ev_periodic_stop (EV_A_ w); @@ -1524,149 +1560,281 @@ ev_periodic_again (EV_P_ struct ev_periodic *w) } #endif +#ifndef SA_RESTART +# define SA_RESTART 0 +#endif + void -ev_idle_start (EV_P_ struct ev_idle *w) +ev_signal_start (EV_P_ ev_signal *w) { +#if EV_MULTIPLICITY + assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr)); +#endif if (expect_false (ev_is_active (w))) return; - ev_start (EV_A_ (W)w, ++idlecnt); - array_needsize (struct ev_idle *, idles, idlemax, idlecnt, EMPTY2); - idles [idlecnt - 1] = w; + assert (("ev_signal_start called with illegal signal number", w->signum > 0)); + + ev_start (EV_A_ (W)w, 1); + array_needsize (ANSIG, signals, signalmax, w->signum, signals_init); + wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w); + + if (!((WL)w)->next) + { +#if _WIN32 + signal (w->signum, sighandler); +#else + 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); +#endif + } } void -ev_idle_stop (EV_P_ struct ev_idle *w) +ev_signal_stop (EV_P_ ev_signal *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) return; - idles [((W)w)->active - 1] = idles [--idlecnt]; + 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_prepare_start (EV_P_ struct ev_prepare *w) +ev_child_start (EV_P_ ev_child *w) { +#if EV_MULTIPLICITY + assert (("child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); +#endif if (expect_false (ev_is_active (w))) return; - ev_start (EV_A_ (W)w, ++preparecnt); - array_needsize (struct ev_prepare *, prepares, preparemax, preparecnt, EMPTY2); - prepares [preparecnt - 1] = w; + ev_start (EV_A_ (W)w, 1); + wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w); } void -ev_prepare_stop (EV_P_ struct ev_prepare *w) +ev_child_stop (EV_P_ ev_child *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) return; - prepares [((W)w)->active - 1] = prepares [--preparecnt]; + wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w); ev_stop (EV_A_ (W)w); } +#if EV_STAT_ENABLE + +# ifdef _WIN32 +# undef lstat +# define lstat(a,b) _stati64 (a,b) +# endif + +#define DEF_STAT_INTERVAL 5.0074891 +#define MIN_STAT_INTERVAL 0.1074891 + void -ev_check_start (EV_P_ struct ev_check *w) +ev_stat_stat (EV_P_ ev_stat *w) +{ + if (lstat (w->path, &w->attr) < 0) + w->attr.st_nlink = 0; + else if (!w->attr.st_nlink) + w->attr.st_nlink = 1; +} + +static void +stat_timer_cb (EV_P_ ev_timer *w_, int revents) +{ + ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer)); + + /* we copy this here each the time so that */ + /* prev has the old value when the callback gets invoked */ + w->prev = w->attr; + ev_stat_stat (EV_A_ w); + + if (memcmp (&w->prev, &w->attr, sizeof (ev_statdata))) + ev_feed_event (EV_A_ w, EV_STAT); +} + +void +ev_stat_start (EV_P_ ev_stat *w) { if (expect_false (ev_is_active (w))) return; - ev_start (EV_A_ (W)w, ++checkcnt); - array_needsize (struct ev_check *, checks, checkmax, checkcnt, EMPTY2); - checks [checkcnt - 1] = w; + /* since we use memcmp, we need to clear any padding data etc. */ + memset (&w->prev, 0, sizeof (ev_statdata)); + memset (&w->attr, 0, sizeof (ev_statdata)); + + ev_stat_stat (EV_A_ w); + + if (w->interval < MIN_STAT_INTERVAL) + w->interval = w->interval ? MIN_STAT_INTERVAL : DEF_STAT_INTERVAL; + + ev_timer_init (&w->timer, stat_timer_cb, w->interval, w->interval); + ev_set_priority (&w->timer, ev_priority (w)); + ev_timer_start (EV_A_ &w->timer); + + ev_start (EV_A_ (W)w, 1); } void -ev_check_stop (EV_P_ struct ev_check *w) +ev_stat_stop (EV_P_ ev_stat *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) return; - checks [((W)w)->active - 1] = checks [--checkcnt]; + ev_timer_stop (EV_A_ &w->timer); + ev_stop (EV_A_ (W)w); } - -#ifndef SA_RESTART -# define SA_RESTART 0 #endif void -ev_signal_start (EV_P_ struct ev_signal *w) +ev_idle_start (EV_P_ ev_idle *w) { -#if EV_MULTIPLICITY - assert (("signal watchers are only supported in the default loop", loop == ev_default_loop_ptr)); -#endif if (expect_false (ev_is_active (w))) return; - assert (("ev_signal_start called with illegal signal number", w->signum > 0)); + ev_start (EV_A_ (W)w, ++idlecnt); + array_needsize (ev_idle *, idles, idlemax, idlecnt, EMPTY2); + idles [idlecnt - 1] = w; +} - ev_start (EV_A_ (W)w, 1); - array_needsize (ANSIG, signals, signalmax, w->signum, signals_init); - wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w); +void +ev_idle_stop (EV_P_ ev_idle *w) +{ + ev_clear_pending (EV_A_ (W)w); + if (expect_false (!ev_is_active (w))) + return; - if (!((WL)w)->next) - { -#if _WIN32 - signal (w->signum, sighandler); -#else - 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); -#endif - } + { + int active = ((W)w)->active; + idles [active - 1] = idles [--idlecnt]; + ((W)idles [active - 1])->active = active; + } + + ev_stop (EV_A_ (W)w); } void -ev_signal_stop (EV_P_ struct ev_signal *w) +ev_prepare_start (EV_P_ ev_prepare *w) +{ + if (expect_false (ev_is_active (w))) + return; + + ev_start (EV_A_ (W)w, ++preparecnt); + array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2); + prepares [preparecnt - 1] = w; +} + +void +ev_prepare_stop (EV_P_ ev_prepare *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) return; - wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w); + { + int active = ((W)w)->active; + prepares [active - 1] = prepares [--preparecnt]; + ((W)prepares [active - 1])->active = active; + } + ev_stop (EV_A_ (W)w); +} - if (!signals [w->signum - 1].head) - signal (w->signum, SIG_DFL); +void +ev_check_start (EV_P_ ev_check *w) +{ + if (expect_false (ev_is_active (w))) + return; + + ev_start (EV_A_ (W)w, ++checkcnt); + array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2); + checks [checkcnt - 1] = w; } void -ev_child_start (EV_P_ struct ev_child *w) +ev_check_stop (EV_P_ ev_check *w) +{ + ev_clear_pending (EV_A_ (W)w); + if (expect_false (!ev_is_active (w))) + return; + + { + int active = ((W)w)->active; + checks [active - 1] = checks [--checkcnt]; + ((W)checks [active - 1])->active = active; + } + + ev_stop (EV_A_ (W)w); +} + +#if EV_EMBED_ENABLE +void noinline +ev_embed_sweep (EV_P_ ev_embed *w) +{ + ev_loop (w->loop, EVLOOP_NONBLOCK); +} + +static void +embed_cb (EV_P_ ev_io *io, int revents) +{ + ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io)); + + if (ev_cb (w)) + ev_feed_event (EV_A_ (W)w, EV_EMBED); + else + ev_embed_sweep (loop, w); +} + +void +ev_embed_start (EV_P_ ev_embed *w) { -#if EV_MULTIPLICITY - assert (("child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); -#endif if (expect_false (ev_is_active (w))) return; + { + struct ev_loop *loop = w->loop; + assert (("loop to be embedded is not embeddable", backend & ev_embeddable_backends ())); + ev_io_init (&w->io, embed_cb, backend_fd, EV_READ); + } + + ev_set_priority (&w->io, ev_priority (w)); + ev_io_start (EV_A_ &w->io); + ev_start (EV_A_ (W)w, 1); - wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w); } void -ev_child_stop (EV_P_ struct ev_child *w) +ev_embed_stop (EV_P_ ev_embed *w) { ev_clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) return; - wlist_del ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w); + ev_io_stop (EV_A_ &w->io); + ev_stop (EV_A_ (W)w); } +#endif /*****************************************************************************/ struct ev_once { - struct ev_io io; - struct ev_timer to; + ev_io io; + ev_timer to; void (*cb)(int revents, void *arg); void *arg; }; @@ -1685,13 +1853,13 @@ once_cb (EV_P_ struct ev_once *once, int revents) } static void -once_cb_io (EV_P_ struct ev_io *w, int revents) +once_cb_io (EV_P_ ev_io *w, int revents) { once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents); } static void -once_cb_to (EV_P_ struct ev_timer *w, int revents) +once_cb_to (EV_P_ ev_timer *w, int revents) { once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents); }