[ViewVC] Diff of: cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.306 by root, Sun Jul 19 06:35:25 2009 UTC vs.
Revision 1.313 by root, Wed Aug 19 23:44:51 2009 UTC

 #endif
 /* this block tries to deduce configuration from header-defined symbols and defaults */
 /* try to deduce the maximum number of signals on this platform */
-/* one some platforms, NSIG is one too large. we do not bother */
 #if defined (EV_NSIG)
 /* use what's provided */
 #elif defined (NSIG)
 # define EV_NSIG (NSIG)
 #elif defined(_NSIG)
 # include <stdint.h>
 # ifndef EFD_NONBLOCK
 #  define EFD_NONBLOCK O_NONBLOCK
 # endif
 # ifndef EFD_CLOEXEC
+#  ifdef O_CLOEXEC
-#  define EFD_CLOEXEC O_CLOEXEC
+#   define EFD_CLOEXEC O_CLOEXEC
+#  else
+#   define EFD_CLOEXEC 02000000
+#  endif
 # endif
 # ifdef __cplusplus
 extern "C" {
 # endif
 int eventfd (unsigned int initval, int flags);
 #if EV_USE_MONOTONIC
 static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 #endif
+#ifndef EV_FD_TO_WIN32_HANDLE
+# define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
+#endif
+#ifndef EV_WIN32_HANDLE_TO_FD
+# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (fd, 0)
+#endif
+#ifndef EV_WIN32_CLOSE_FD
+# define EV_WIN32_CLOSE_FD(fd) close (fd)
+#endif
 #ifdef _WIN32
 # include "ev_win32.c"
 #endif
 /*****************************************************************************/
 #if EV_SELECT_IS_WINSOCKET
       if (events)
         {
           unsigned long arg;
-          #ifdef EV_FD_TO_WIN32_HANDLE
-            anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
+          anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
-          #else
-            anfd->handle = _get_osfhandle (fd);
-          #endif
           assert (("libev: only socket fds supported in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
         }
 #endif
       {
   for (fd = anfdmax; fd--; )
     if (anfds [fd].events)
       {
         fd_kill (EV_A_ fd);
-        return;
+        break;
       }
 }
 /* usually called after fork if backend needs to re-arm all fds from scratch */
 static void noinline
   for (;;)
     {
       int c = k << 1;
-      if (c > N + HEAP0 - 1)
+      if (c >= N + HEAP0)
         break;
       c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
            ? 1 : 0;
 /* move an element suitably so it is in a correct place */
 inline_size void
 adjustheap (ANHE *heap, int N, int k)
 {
-  if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k]))
+  if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)]))
     upheap (heap, k);
   else
     downheap (heap, N, k);
 }
 /*****************************************************************************/
 /* associate signal watchers to a signal signal */
 typedef struct
 {
+  EV_ATOMIC_T pending;
 #if EV_MULTIPLICITY
   EV_P;
 #endif
   WL head;
-  EV_ATOMIC_T gotsig;
 } ANSIG;
 static ANSIG signals [EV_NSIG - 1];
-static EV_ATOMIC_T gotsig;
 /*****************************************************************************/
 /* used to prepare libev internal fd's */
 /* this is not fork-safe */
 /* called whenever the libev signal pipe */
 /* got some events (signal, async) */
 static void
 pipecb (EV_P_ ev_io *iow, int revents)
 {
+  int i;
 #if EV_USE_EVENTFD
   if (evfd >= 0)
     {
       uint64_t counter;
       read (evfd, &counter, sizeof (uint64_t));
     {
       char dummy;
       read (evpipe [0], &dummy, 1);
     }
-  if (gotsig && ev_is_default_loop (EV_A))
+  if (sig_pending)
     {
-      int signum;
+      sig_pending = 0;
-      gotsig = 0;
-      for (signum = EV_NSIG - 1; signum--; )
+      for (i = EV_NSIG - 1; i--; )
-        if (signals [signum].gotsig)
+        if (expect_false (signals [i].pending))
-          ev_feed_signal_event (EV_A_ signum + 1);
+          ev_feed_signal_event (EV_A_ i + 1);
     }
 #if EV_ASYNC_ENABLE
-  if (gotasync)
+  if (async_pending)
     {
-      int i;
+      async_pending = 0;
-      gotasync = 0;
       for (i = asynccnt; i--; )
         if (asyncs [i]->sent)
           {
             asyncs [i]->sent = 0;
 #if _WIN32
   signal (signum, ev_sighandler);
 #endif
-  signals [signum - 1].gotsig = 1;
+  signals [signum - 1].pending = 1;
-  evpipe_write (EV_A_ &gotsig);
+  evpipe_write (EV_A_ &sig_pending);
 }
 void noinline
 ev_feed_signal_event (EV_P_ int signum)
 {
   WL w;
+  if (expect_false (signum <= 0 || signum > EV_NSIG))
+    return;
+  --signum;
 #if EV_MULTIPLICITY
-  assert (("libev: feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
+  /* it is permissible to try to feed a signal to the wrong loop */
-#endif
+  /* or, likely more useful, feeding a signal nobody is waiting for */
-  if (signum <= 0 || signum > EV_NSIG)
+  if (expect_false (signals [signum].loop != EV_A))
     return;
+#endif
-  --signum;
-  signals [signum].gotsig = 0;
+  signals [signum].pending = 0;
   for (w = signals [signum].head; w; w = w->next)
     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
 }
       io_blocktime      = 0.;
       timeout_blocktime = 0.;
       backend           = 0;
       backend_fd        = -1;
-      gotasync          = 0;
+      sig_pending       = 0;
+#if EV_ASYNC_ENABLE
+      async_pending     = 0;
+#endif
 #if EV_USE_INOTIFY
       fs_fd             = flags & EVFLAG_NOINOTIFY ? -1 : -2;
 #endif
 #if EV_USE_SIGNALFD
       sigfd             = flags & EVFLAG_NOSIGFD   ? -1 : -2;
         close (evfd);
 #endif
       if (evpipe [0] >= 0)
         {
-          close (evpipe [0]);
+          EV_WIN32_CLOSE_FD (evpipe [0]);
-          close (evpipe [1]);
+          EV_WIN32_CLOSE_FD (evpipe [1]);
         }
     }
 #if EV_USE_SIGNALFD
   if (ev_is_active (&sigfd_w))
   if (ev_is_active (&pipe_w))
     {
       /* this "locks" the handlers against writing to the pipe */
       /* while we modify the fd vars */
-      gotsig = 1;
+      sig_pending   = 1;
 #if EV_ASYNC_ENABLE
-      gotasync = 1;
+      async_pending = 1;
 #endif
       ev_ref (EV_A);
       ev_io_stop (EV_A_ &pipe_w);
         close (evfd);
 #endif
       if (evpipe [0] >= 0)
         {
-          close (evpipe [0]);
+          EV_WIN32_CLOSE_FD (evpipe [0]);
-          close (evpipe [1]);
+          EV_WIN32_CLOSE_FD (evpipe [1]);
         }
       evpipe_init (EV_A);
       /* now iterate over everything, in case we missed something */
       pipecb (EV_A_ &pipe_w, EV_READ);
   assert (checkmax >= checkcnt);
   array_verify (EV_A_ (W *)checks, checkcnt);
 # if 0
   for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
-  for (signum = EV_NSIG; signum--; ) if (signals [signum].gotsig)
+  for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
 # endif
 #endif
 }
 #endif
 inline_size void
 wlist_del (WL *head, WL elem)
 {
   while (*head)
     {
-      if (*head == elem)
+      if (expect_true (*head == elem))
         {
           *head = elem->next;
-          return;
+          break;
         }
       head = &(*head)->next;
     }
 }
     return;
   assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
 #if EV_MULTIPLICITY
-  assert (("libev: tried to attach to a signal from two different loops",
+  assert (("libev: a signal must not be attached to two different loops",
            !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
   signals [w->signum - 1].loop = EV_A;
 #endif
   wlist_del (&signals [w->signum - 1].head, (WL)w);
   ev_stop (EV_A_ (W)w);
   if (!signals [w->signum - 1].head)
     {
-      #if EV_MULTIPLICITY
+#if EV_MULTIPLICITY
       signals [w->signum - 1].loop = 0; /* unattach from signal */
-      #endif
+#endif
-      #if EV_USE_SIGNALFD
+#if EV_USE_SIGNALFD
       if (sigfd >= 0)
         {
           sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D
           sigdelset (&sigfd_set, w->signum);
           signalfd (sigfd, &sigfd_set, 0);
           sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D
           /*TODO: maybe unblock signal? */
         }
       else
-      #endif
+#endif
         signal (w->signum, SIG_DFL);
     }
   EV_FREQUENT_CHECK;
 }
         }
     }
   if (w->wd >= 0)
     {
+      struct statfs sfs;
       wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
       /* now local changes will be tracked by inotify, but remote changes won't */
       /* unless the filesystem it known to be local, we therefore still poll */
       /* also do poll on <2.6.25, but with normal frequency */
-      struct statfs sfs;
       if (fs_2625 && !statfs (w->path, &sfs))
         if (sfs.f_type == 0x1373 /* devfs */
             || sfs.f_type == 0xEF53 /* ext2/3 */
             || sfs.f_type == 0x3153464a /* jfs */
 void
 ev_async_send (EV_P_ ev_async *w)
 {
   w->sent = 1;
-  evpipe_write (EV_A_ &gotasync);
+  evpipe_write (EV_A_ &async_pending);
 }
 #endif
 /*****************************************************************************/

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.c (file contents): Revision 1.306 by root, Sun Jul 19 06:35:25 2009 UTC vs. Revision 1.313 by root, Wed Aug 19 23:44:51 2009 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.306 by root, Sun Jul 19 06:35:25 2009 UTC vs.
Revision 1.313 by root, Wed Aug 19 23:44:51 2009 UTC