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

Comparing libev/ev.c (file contents):
Revision 1.314 by root, Wed Aug 26 17:31:20 2009 UTC vs.
Revision 1.324 by root, Sat Jan 23 20:15:57 2010 UTC

 #   define EV_USE_EPOLL 0
 #  endif
 # endif
 # ifndef EV_USE_KQUEUE
-#  if HAVE_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
+#  if HAVE_KQUEUE && HAVE_SYS_EVENT_H
 #   define EV_USE_KQUEUE 1
 #  else
 #   define EV_USE_KQUEUE 0
 #  endif
 # endif
 #endif
 #include <math.h>
 #include <stdlib.h>
+#include <string.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdio.h>
  */
 #define TIME_EPSILON  0.0001220703125 /* 1/8192 */
 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
-/*#define CLEANUP_INTERVAL (MAX_BLOCKTIME * 5.) /* how often to try to free memory and re-check fds, TODO */
 #if __GNUC__ >= 4
 # define expect(expr,value)         __builtin_expect ((expr),(value))
 # define noinline                   __attribute__ ((noinline))
 #else
 #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)
+# define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
 #endif
 #ifndef EV_WIN32_CLOSE_FD
 # define EV_WIN32_CLOSE_FD(fd) close (fd)
 #endif
 /* check whether the given fd is atcually valid, for error recovery */
 inline_size int
 fd_valid (int fd)
 {
 #ifdef _WIN32
-  return _get_osfhandle (fd) != -1;
+  return EV_FD_TO_WIN32_HANDLE (fd) != -1;
 #else
   return fcntl (fd, F_GETFD) != -1;
 #endif
 }
 inline_speed void
 fd_intern (int fd)
 {
 #ifdef _WIN32
   unsigned long arg = 1;
-  ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
+  ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
 #else
   fcntl (fd, F_SETFD, FD_CLOEXEC);
   fcntl (fd, F_SETFL, O_NONBLOCK);
 #endif
 }
 {
 #if EV_MULTIPLICITY
   EV_P = signals [signum - 1].loop;
 #endif
-#if _WIN32
+#ifdef _WIN32
   signal (signum, ev_sighandler);
 #endif
   signals [signum - 1].pending = 1;
   evpipe_write (EV_A_ &sig_pending);
 #endif
 #if EV_USE_INOTIFY
       fs_fd             = flags & EVFLAG_NOINOTIFY ? -1 : -2;
 #endif
 #if EV_USE_SIGNALFD
-      sigfd             = flags & EVFLAG_NOSIGFD   ? -1 : -2;
+      sigfd             = flags & EVFLAG_SIGNALFD  ? -2 : -1;
 #endif
       if (!(flags & 0x0000ffffU))
         flags |= ev_recommended_backends ();
         }
     }
 #if EV_USE_SIGNALFD
   if (ev_is_active (&sigfd_w))
-    {
-      /*ev_ref (EV_A);*/
-      /*ev_io_stop (EV_A_ &sigfd_w);*/
-      close (sigfd);
+    close (sigfd);
-    }
 #endif
 #if EV_USE_INOTIFY
   if (fs_fd >= 0)
     close (fs_fd);
       ANHE_at_cache (*he);
     }
 }
 /* fetch new monotonic and realtime times from the kernel */
-/* also detetc if there was a timejump, and act accordingly */
+/* also detect if there was a timejump, and act accordingly */
 inline_speed void
 time_update (EV_P_ ev_tstamp max_block)
 {
 #if EV_USE_MONOTONIC
   if (expect_true (have_monotonic))
   if (!((WL)w)->next)
 # if EV_USE_SIGNALFD
     if (sigfd < 0) /*TODO*/
 # endif
       {
-# if _WIN32
+# ifdef _WIN32
+        evpipe_init (EV_A);
         signal (w->signum, ev_sighandler);
 # else
         struct sigaction sa;
         evpipe_init (EV_A);
       signals [w->signum - 1].loop = 0; /* unattach from signal */
 #endif
 #if EV_USE_SIGNALFD
       if (sigfd >= 0)
         {
-          sigprocmask (SIG_UNBLOCK, &sigfd_set, 0);//D
+          sigset_t ss;
+          sigemptyset (&ss);
+          sigaddset (&ss, w->signum);
           sigdelset (&sigfd_set, w->signum);
           signalfd (sigfd, &sigfd_set, 0);
-          sigprocmask (SIG_BLOCK, &sigfd_set, 0);//D
+          sigprocmask (SIG_UNBLOCK, &ss, 0);
-          /*TODO: maybe unblock signal? */
         }
       else
 #endif
         signal (w->signum, SIG_DFL);
     }
 static void noinline
 infy_add (EV_P_ ev_stat *w)
 {
   w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD);
-  if (w->wd < 0)
+  if (w->wd >= 0)
+    {
+      struct statfs sfs;
+      /* now local changes will be tracked by inotify, but remote changes won't */
+      /* unless the filesystem is known to be local, we therefore still poll */
+      /* also do poll on <2.6.25, but with normal frequency */
+      if (!fs_2625)
+        w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
+      else if (!statfs (w->path, &sfs)
+               && (sfs.f_type == 0x1373 /* devfs */
+                   || sfs.f_type == 0xEF53 /* ext2/3 */
+                   || sfs.f_type == 0x3153464a /* jfs */
+                   || sfs.f_type == 0x52654973 /* reiser3 */
+                   || sfs.f_type == 0x01021994 /* tempfs */
+                   || sfs.f_type == 0x58465342 /* xfs */))
+        w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
+      else
+        w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
-    {
+    }
+  else
+    {
+      /* can't use inotify, continue to stat */
       w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
-      ev_timer_again (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
-      /* monitor some parent directory for speedup hints */
+      /* if path is not there, monitor some parent directory for speedup hints */
       /* note that exceeding the hardcoded path limit is not a correctness issue, */
       /* but an efficiency issue only */
       if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096)
         {
           char path [4096];
           while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
         }
     }
   if (w->wd >= 0)
-    {
-      struct statfs sfs;
-      wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
+    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 */
+  /* now re-arm timer, if required */
-      /* unless the filesystem it known to be local, we therefore still poll */
+  if (ev_is_active (&w->timer)) ev_ref (EV_A);
-      /* also do poll on <2.6.25, but with normal frequency */
-      if (fs_2625 && !statfs (w->path, &sfs))
-        if (sfs.f_type == 0x1373 /* devfs */
-            || sfs.f_type == 0xEF53 /* ext2/3 */
-            || sfs.f_type == 0x3153464a /* jfs */
-            || sfs.f_type == 0x52654973 /* reiser3 */
-            || sfs.f_type == 0x01021994 /* tempfs */
-            || sfs.f_type == 0x58465342 /* xfs */)
-          return;
-      w->timer.repeat = w->interval ? w->interval : fs_2625 ? NFS_STAT_INTERVAL : DEF_STAT_INTERVAL;
-      ev_timer_again (EV_A_ &w->timer);
+  ev_timer_again (EV_A_ &w->timer);
-    }
+  if (ev_is_active (&w->timer)) ev_unref (EV_A);
 }
 static void noinline
 infy_del (EV_P_ ev_stat *w)
 {
     return;
   fs_2625 = 1;
 }
+inline_size int
+infy_newfd (void)
+{
+#if defined (IN_CLOEXEC) && defined (IN_NONBLOCK)
+  int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK);
+  if (fd >= 0)
+    return fd;
+#endif
+  return inotify_init ();
+}
 inline_size void
 infy_init (EV_P)
 {
   if (fs_fd != -2)
     return;
   fs_fd = -1;
   check_2625 (EV_A);
-  fs_fd = inotify_init ();
+  fs_fd = infy_newfd ();
   if (fs_fd >= 0)
     {
+      fd_intern (fs_fd);
       ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
       ev_set_priority (&fs_w, EV_MAXPRI);
       ev_io_start (EV_A_ &fs_w);
+      ev_unref (EV_A);
     }
 }
 inline_size void
 infy_fork (EV_P)
   int slot;
   if (fs_fd < 0)
     return;
+  ev_ref (EV_A);
+  ev_io_stop (EV_A_ &fs_w);
   close (fs_fd);
-  fs_fd = inotify_init ();
+  fs_fd = infy_newfd ();
+  if (fs_fd >= 0)
+    {
+      fd_intern (fs_fd);
+      ev_io_set (&fs_w, fs_fd, EV_READ);
+      ev_io_start (EV_A_ &fs_w);
+      ev_unref (EV_A);
+    }
   for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
     {
       WL w_ = fs_hash [slot].head;
       fs_hash [slot].head = 0;
           w->wd = -1;
           if (fs_fd >= 0)
             infy_add (EV_A_ w); /* re-add, no matter what */
           else
+            {
+              w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
+              if (ev_is_active (&w->timer)) ev_ref (EV_A);
-            ev_timer_again (EV_A_ &w->timer);
+              ev_timer_again (EV_A_ &w->timer);
+              if (ev_is_active (&w->timer)) ev_unref (EV_A);
+            }
         }
     }
 }
 #endif
 static void noinline
 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 */
+  ev_statdata prev = w->attr;
-  /* prev has the old value when the callback gets invoked */
-  w->prev = w->attr;
   ev_stat_stat (EV_A_ w);
   /* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
   if (
-    w->prev.st_dev      != w->attr.st_dev
+    prev.st_dev      != w->attr.st_dev
-    || w->prev.st_ino   != w->attr.st_ino
+    || prev.st_ino   != w->attr.st_ino
-    || w->prev.st_mode  != w->attr.st_mode
+    || prev.st_mode  != w->attr.st_mode
-    || w->prev.st_nlink != w->attr.st_nlink
+    || prev.st_nlink != w->attr.st_nlink
-    || w->prev.st_uid   != w->attr.st_uid
+    || prev.st_uid   != w->attr.st_uid
-    || w->prev.st_gid   != w->attr.st_gid
+    || prev.st_gid   != w->attr.st_gid
-    || w->prev.st_rdev  != w->attr.st_rdev
+    || prev.st_rdev  != w->attr.st_rdev
-    || w->prev.st_size  != w->attr.st_size
+    || prev.st_size  != w->attr.st_size
-    || w->prev.st_atime != w->attr.st_atime
+    || prev.st_atime != w->attr.st_atime
-    || w->prev.st_mtime != w->attr.st_mtime
+    || prev.st_mtime != w->attr.st_mtime
-    || w->prev.st_ctime != w->attr.st_ctime
+    || prev.st_ctime != w->attr.st_ctime
   ) {
+      /* we only update w->prev on actual differences */
+      /* in case we test more often than invoke the callback, */
+      /* to ensure that prev is always different to attr */
+      w->prev = prev;
       #if EV_USE_INOTIFY
         if (fs_fd >= 0)
           {
             infy_del (EV_A_ w);
             infy_add (EV_A_ w);
   if (fs_fd >= 0)
     infy_add (EV_A_ w);
   else
 #endif
+    {
-    ev_timer_again (EV_A_ &w->timer);
+      ev_timer_again (EV_A_ &w->timer);
+      ev_unref (EV_A);
+    }
   ev_start (EV_A_ (W)w, 1);
   EV_FREQUENT_CHECK;
 }
   EV_FREQUENT_CHECK;
 #if EV_USE_INOTIFY
   infy_del (EV_A_ w);
 #endif
+  if (ev_is_active (&w->timer))
+    {
+      ev_ref (EV_A);
-  ev_timer_stop (EV_A_ &w->timer);
+      ev_timer_stop (EV_A_ &w->timer);
+    }
   ev_stop (EV_A_ (W)w);
   EV_FREQUENT_CHECK;
 }

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.314 by root, Wed Aug 26 17:31:20 2009 UTC vs. Revision 1.324 by root, Sat Jan 23 20:15:57 2010 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.314 by root, Wed Aug 26 17:31:20 2009 UTC vs.
Revision 1.324 by root, Sat Jan 23 20:15:57 2010 UTC