*** empty log message ***

[software/libev.git] / ev.c

diff --git a/ev.c b/ev.c
index 7c312af961b30fbcc3e28d48e32882bdb515afd2..0457088e2507d52beb2606bcbf971525565b9064 100644 (file)
--- a/ev.c
+++ b/ev.c
@@ -155,6 +155,54 @@ volatile double SIGFPE_REQ = 0.0f;
 
 /*****************************************************************************/
 
+static void (*syserr_cb)(const char *msg);
+
+void ev_set_syserr_cb (void (*cb)(const char *msg))
+{
+  syserr_cb = cb;
+}
+
+static void
+syserr (const char *msg)
+{
+  if (!msg)
+    msg = "(libev) system error";
+
+  if (syserr_cb)
+    syserr_cb (msg);
+  else
+    {
+      perror (msg);
+      abort ();
+    }
+}
+
+static void *(*alloc)(void *ptr, long size);
+
+void ev_set_allocator (void *(*cb)(void *ptr, long size))
+{
+  alloc = cb;
+}
+
+static void *
+ev_realloc (void *ptr, long size)
+{
+  ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
+
+  if (!ptr && size)
+    {
+      fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
+      abort ();
+    }
+
+  return ptr;
+}
+
+#define ev_malloc(size) ev_realloc (0, (size))
+#define ev_free(ptr)    ev_realloc ((ptr), 0)
+
+/*****************************************************************************/
+
 typedef struct
 {
   WL head;
@@ -225,31 +273,31 @@ ev_now (EV_P)
 
 #define array_roundsize(base,n) ((n) | 4 & ~3)
 
-#define array_needsize(base,cur,cnt,init)              \
-  if (expect_false ((cnt) > cur))                      \
-    {                                                  \
-      int newcnt = cur;                                        \
-      do                                               \
-        {                                              \
-          newcnt = array_roundsize (base, newcnt << 1);        \
-        }                                              \
-      while ((cnt) > newcnt);                          \
-                                                       \
-      base = realloc (base, sizeof (*base) * (newcnt));        \
-      init (base + cur, newcnt - cur);                 \
-      cur = newcnt;                                    \
+#define array_needsize(base,cur,cnt,init)                      \
+  if (expect_false ((cnt) > cur))                              \
+    {                                                          \
+      int newcnt = cur;                                                \
+      do                                                       \
+        {                                                      \
+          newcnt = array_roundsize (base, newcnt << 1);                \
+        }                                                      \
+      while ((cnt) > newcnt);                                  \
+                                                               \
+      base = ev_realloc (base, sizeof (*base) * (newcnt));     \
+      init (base + cur, newcnt - cur);                         \
+      cur = newcnt;                                            \
     }
 
 #define array_slim(stem)                                       \
   if (stem ## max < array_roundsize (stem ## cnt >> 2))                \
     {                                                          \
       stem ## max = array_roundsize (stem ## cnt >> 1);                \
-      base = realloc (base, sizeof (*base) * (stem ## max));   \
+      base = ev_realloc (base, sizeof (*base) * (stem ## max));        \
       fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
     }
 
 #define array_free(stem, idx) \
-  free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
+  ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 
 /*****************************************************************************/
 
@@ -335,7 +383,7 @@ fd_reify (EV_P)
 static void
 fd_change (EV_P_ int fd)
 {
-  if (anfds [fd].reify || fdchangecnt < 0)
+  if (anfds [fd].reify)
     return;
 
   anfds [fd].reify = 1;
@@ -383,7 +431,7 @@ fd_enomem (EV_P)
       }
 }
 
-/* susually called after fork if method needs to re-arm all fds from scratch */
+/* usually called after fork if method needs to re-arm all fds from scratch */
 static void
 fd_rearm_all (EV_P)
 {
@@ -650,6 +698,9 @@ loop_init (EV_P_ int methods)
 #if EV_USE_SELECT
       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 #endif
+
+      ev_watcher_init (&sigev, sigcb);
+      ev_set_priority (&sigev, EV_MAXPRI);
     }
 }
 
@@ -685,26 +736,43 @@ loop_destroy (EV_P)
   array_free (check, );
 
   method = 0;
-  /*TODO*/
 }
 
-void
+static 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_is_active (&sigev))
+    {
+      /* default loop */
+
+      ev_ref (EV_A);
+      ev_io_stop (EV_A_ &sigev);
+      close (sigpipe [0]);
+      close (sigpipe [1]);
+
+      while (pipe (sigpipe))
+        syserr ("(libev) error creating pipe");
+
+      siginit (EV_A);
+    }
+
+  postfork = 0;
 }
 
 #if EV_MULTIPLICITY
 struct ev_loop *
 ev_loop_new (int methods)
 {
-  struct ev_loop *loop = (struct ev_loop *)calloc (1, sizeof (struct ev_loop));
+  struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
+
+  memset (loop, 0, sizeof (struct ev_loop));
 
   loop_init (EV_A_ methods);
 
@@ -718,13 +786,13 @@ void
 ev_loop_destroy (EV_P)
 {
   loop_destroy (EV_A);
-  free (loop);
+  ev_free (loop);
 }
 
 void
 ev_loop_fork (EV_P)
 {
-  loop_fork (EV_A);
+  postfork = 1;
 }
 
 #endif
@@ -757,8 +825,6 @@ ev_default_loop (int methods)
 
       if (ev_method (EV_A))
         {
-          ev_watcher_init (&sigev, sigcb);
-          ev_set_priority (&sigev, EV_MAXPRI);
           siginit (EV_A);
 
 #ifndef WIN32
@@ -801,15 +867,8 @@ ev_default_fork (void)
   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);
+  if (method)
+    postfork = 1;
 }
 
 /*****************************************************************************/
@@ -997,6 +1056,10 @@ ev_loop (EV_P_ int flags)
           call_pending (EV_A);
         }
 
+      /* we might have forked, so reify kernel state if necessary */
+      if (expect_false (postfork))
+        loop_fork (EV_A);
+
       /* update fd-related kernel structures */
       fd_reify (EV_A);
 
@@ -1397,7 +1460,7 @@ once_cb (EV_P_ struct ev_once *once, int revents)
 
   ev_io_stop (EV_A_ &once->io);
   ev_timer_stop (EV_A_ &once->to);
-  free (once);
+  ev_free (once);
 
   cb (revents, arg);
 }
@@ -1417,7 +1480,7 @@ once_cb_to (EV_P_ struct ev_timer *w, int revents)
 void
 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
 {
-  struct ev_once *once = malloc (sizeof (struct ev_once));
+  struct ev_once *once = ev_malloc (sizeof (struct ev_once));
 
   if (!once)
     cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);