bugfixes

[software/libev.git] / ev.c

diff --git a/ev.c b/ev.c
index 790baee1ed219276382f7d9c2abc6b5aef162001..5756bb73d7bce066330fd047a860700517b62e29 100644 (file)
--- 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 <math.h>
@@ -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
@@ -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);
@@ -351,7 +381,7 @@ fd_rearm_all (EV_P)
     if (anfds [fd].events)
       {
         anfds [fd].events = 0;
-        fd_change (fd);
+        fd_change (EV_A_ fd);
       }
 }
 
@@ -365,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;
 
 }
 
@@ -390,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;
 }
 
 /*****************************************************************************/
@@ -411,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)
@@ -478,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
@@ -490,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);
       }
 }
@@ -522,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
@@ -584,13 +618,16 @@ loop_init (EV_P_ int methods)
           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
@@ -602,13 +639,16 @@ loop_init (EV_P_ int methods)
 void
 loop_destroy (EV_P)
 {
+#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_USEV_POLL
+#if EV_USE_POLL
   if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
 #endif
 #if EV_USE_SELECT
@@ -639,7 +679,7 @@ ev_loop_new (int methods)
 
   loop_init (EV_A_ methods);
 
-  if (ev_methods (EV_A))
+  if (ev_method (EV_A))
     return loop;
 
   return 0;
@@ -726,8 +766,12 @@ ev_default_destroy (void)
 }
 
 void
-ev_default_fork (EV_P)
+ev_default_fork (void)
 {
+#if EV_MULTIPLICITY
+  struct ev_loop *loop = default_loop;
+#endif
+
   loop_fork (EV_A);
 
   ev_io_stop (EV_A_ &sigev);
@@ -754,7 +798,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);
           }
       }
 }
@@ -762,15 +807,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
@@ -783,15 +830,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
@@ -813,7 +862,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)
             {
@@ -884,7 +933,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;
@@ -945,13 +994,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;
             }
 
@@ -1078,7 +1127,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.));
 
@@ -1086,6 +1135,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
@@ -1095,13 +1146,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);
 }
@@ -1113,8 +1166,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);
@@ -1133,12 +1186,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
@@ -1148,10 +1203,12 @@ ev_periodic_stop (EV_P_ struct ev_periodic *w)
   if (!ev_is_active (w))
     return;
 
-  if (w->active < periodiccnt--)
+  assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
+
+  if (((W)w)->active < periodiccnt--)
     {
-      periodics [w->active - 1] = periodics [periodiccnt];
-      downheap ((WT *)periodics, periodiccnt, w->active - 1);
+      periodics [((W)w)->active - 1] = periodics [periodiccnt];
+      downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
     }
 
   ev_stop (EV_A_ (W)w);
@@ -1175,7 +1232,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);
 }
 
@@ -1197,7 +1254,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);
 }
 
@@ -1219,7 +1276,7 @@ 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);
 }
 
@@ -1242,7 +1299,7 @@ ev_signal_start (EV_P_ struct ev_signal *w)
   array_needsize (signals, signalmax, w->signum, signals_init);
   wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
 
-  if (!w->next)
+  if (!((WL)w)->next)
     {
       struct sigaction sa;
       sa.sa_handler = sighandler;