Changeset 373 for trunk/src/sh_fInotify.c

Timestamp:

Nov 1, 2011, 9:29:51 PM (13 years ago)

Author:

katerina

Message:

Patch for ticket #265 (inotify). Handling of added subdirectories and file list rescan.

File:

• trunk/src/sh_fInotify.c (modified) (12 diffs)

trunk/src/sh_fInotify.c

@@ -42 +42 @@
 sh_watches sh_file_watches = SH_INOTIFY_INITIALIZER;
 
+#if defined(HAVE_SYS_INOTIFY_H) 
+
 static sh_watches sh_file_missing = SH_INOTIFY_INITIALIZER;
-
-#if defined(HAVE_SYS_INOTIFY_H) 
 
 #include <sys/inotify.h>
@@ -111 +111 @@
 static int sh_fInotify_process(struct inotify_event * event);
 static int sh_fInotify_report(struct inotify_event * event, char * filename,
-                              int class, unsigned long check_mask, int ftype);
+                              int class, unsigned long check_mask, int ftype, int rdepth);
 
 int sh_fInotify_init(struct mod_type * arg)
@@ -205 +205 @@
            return SH_MOD_FAILED;
         }
- 
-    }
+     }
 
   /* Re-scan 'dormant' list of sh_file_missing. 
@@ -218 +217 @@
     {
       count = 0; /* Re-expand glob patterns to discover added files. */
+      sh.flag.inotify |= SH_INOTIFY_INSCAN;
       sh_files_check_globFilePatterns();
+      sh.flag.inotify &= ~SH_INOTIFY_INSCAN;
+      sh.flag.inotify |= SH_INOTIFY_NEEDINIT;
     }
 
@@ -224 +226 @@
     {
       count2 = 0; /* Update baseline database. */
-      if (sh.flag.checkSum == SH_CHECK_CHECK && 
-          sh.flag.update == S_TRUE)
+      if (sh.flag.checkSum == SH_CHECK_CHECK && sh.flag.update == S_TRUE)
         sh_hash_writeout ();
     }
@@ -314 +315 @@
   int    class;
   int    type;
+  int    rdepth;
   unsigned long check_mask;
   int    retval;
@@ -334 +336 @@
 
   while (NULL != (filename = sh_inotify_pop_dormant(&sh_file_watches, 
-                                                    &class, &check_mask, &type)))
+                                                    &class, &check_mask, 
+                                                    &type, &rdepth)))
     {
       retval = sh_inotify_add_watch(filename, &sh_file_watches, &errnum,
-                                    class, check_mask, type);
+                                    class, check_mask, type, rdepth);
 
       if (retval < 0)
@@ -375 +378 @@
 }
 
+static void sh_fInotify_logmask(struct inotify_event * event)
+{
+  char dbgbuf[256];
+  
+  sl_strlcpy (dbgbuf, "inotify mask: ", sizeof(dbgbuf));
+  
+  if (event->mask & IN_ACCESS) sl_strlcat(dbgbuf, "IN_ACCESS ", sizeof(dbgbuf));
+  if (event->mask & IN_ATTRIB) sl_strlcat(dbgbuf, "IN_ATTRIB ", sizeof(dbgbuf));
+  if (event->mask & IN_CLOSE_WRITE) sl_strlcat(dbgbuf, "IN_CLOSE_WRITE ", sizeof(dbgbuf));
+  if (event->mask & IN_CLOSE_NOWRITE) sl_strlcat(dbgbuf, "IN_CLOSE_NOWRITE ", sizeof(dbgbuf));
+  if (event->mask & IN_CREATE) sl_strlcat(dbgbuf, "IN_CREATE ", sizeof(dbgbuf));
+  if (event->mask & IN_DELETE) sl_strlcat(dbgbuf, "IN_DELETE ", sizeof(dbgbuf));
+  if (event->mask & IN_DELETE_SELF) sl_strlcat(dbgbuf, "IN_DELETE_SELF ", sizeof(dbgbuf));
+  if (event->mask & IN_MODIFY) sl_strlcat(dbgbuf, "IN_MODIFY ", sizeof(dbgbuf));
+  if (event->mask & IN_MOVE_SELF) sl_strlcat(dbgbuf, "IN_MOVE_SELF ", sizeof(dbgbuf));
+  if (event->mask & IN_MOVED_FROM) sl_strlcat(dbgbuf, "IN_MOVED_FROM ", sizeof(dbgbuf));
+  if (event->mask & IN_MOVED_TO) sl_strlcat(dbgbuf, "IN_MOVED_TO ", sizeof(dbgbuf));
+  if (event->mask & IN_OPEN) sl_strlcat(dbgbuf, "IN_OPEN ", sizeof(dbgbuf));
+  if (event->mask & IN_IGNORED) sl_strlcat(dbgbuf, "IN_IGNORED ", sizeof(dbgbuf));
+  if (event->mask & IN_ISDIR) sl_strlcat(dbgbuf, "IN_ISDIR ", sizeof(dbgbuf));
+  if (event->mask & IN_Q_OVERFLOW) sl_strlcat(dbgbuf, "IN_Q_OVERFLOW ", sizeof(dbgbuf));
+  if (event->mask & IN_UNMOUNT) sl_strlcat(dbgbuf, "IN_UNMOUNT ", sizeof(dbgbuf));
+  
+  /* fprintf(stderr, "FIXME: %s\n", dbgbuf); */
+  
+  SH_MUTEX_LOCK(mutex_thread_nolog);
+  sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN, 
+                  dbgbuf, _("sh_fInotify_process"));
+  SH_MUTEX_UNLOCK(mutex_thread_nolog);
+}
+
 static int sh_fInotify_process(struct inotify_event * event)
 {
   int class;
   int ftype;
+  int rdepth;
   unsigned long check_mask;
   char * filename;
@@ -385 +420 @@
   if (flag_err_debug == SL_TRUE)
     {
-      char dbgbuf[256];
-
-      sl_strlcpy (dbgbuf, "inotify mask: ", sizeof(dbgbuf));
-
-      if (event->mask & IN_ACCESS) sl_strlcat(dbgbuf, "IN_ACCESS ", sizeof(dbgbuf));
-      if (event->mask & IN_ATTRIB) sl_strlcat(dbgbuf, "IN_ATTRIB ", sizeof(dbgbuf));
-      if (event->mask & IN_CLOSE_WRITE) sl_strlcat(dbgbuf, "IN_CLOSE_WRITE ", sizeof(dbgbuf));
-      if (event->mask & IN_CLOSE_NOWRITE) sl_strlcat(dbgbuf, "IN_CLOSE_NOWRITE ", sizeof(dbgbuf));
-      if (event->mask & IN_CREATE) sl_strlcat(dbgbuf, "IN_CREATE ", sizeof(dbgbuf));
-      if (event->mask & IN_DELETE) sl_strlcat(dbgbuf, "IN_DELETE ", sizeof(dbgbuf));
-      if (event->mask & IN_DELETE_SELF) sl_strlcat(dbgbuf, "IN_DELETE_SELF ", sizeof(dbgbuf));
-      if (event->mask & IN_MODIFY) sl_strlcat(dbgbuf, "IN_MODIFY ", sizeof(dbgbuf));
-      if (event->mask & IN_MOVE_SELF) sl_strlcat(dbgbuf, "IN_MOVE_SELF ", sizeof(dbgbuf));
-      if (event->mask & IN_MOVED_FROM) sl_strlcat(dbgbuf, "IN_MOVED_FROM ", sizeof(dbgbuf));
-      if (event->mask & IN_MOVED_TO) sl_strlcat(dbgbuf, "IN_MOVED_TO ", sizeof(dbgbuf));
-      if (event->mask & IN_OPEN) sl_strlcat(dbgbuf, "IN_OPEN ", sizeof(dbgbuf));
-      if (event->mask & IN_IGNORED) sl_strlcat(dbgbuf, "IN_IGNORED ", sizeof(dbgbuf));
-      if (event->mask & IN_ISDIR) sl_strlcat(dbgbuf, "IN_ISDIR ", sizeof(dbgbuf));
-      if (event->mask & IN_Q_OVERFLOW) sl_strlcat(dbgbuf, "IN_Q_OVERFLOW ", sizeof(dbgbuf));
-      if (event->mask & IN_UNMOUNT) sl_strlcat(dbgbuf, "IN_UNMOUNT ", sizeof(dbgbuf));
-
-      SH_MUTEX_LOCK(mutex_thread_nolog);
-      sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN, 
-                      dbgbuf, _("sh_fInotify_process"));
-      SH_MUTEX_UNLOCK(mutex_thread_nolog);
-    }
-
+      sh_fInotify_logmask(event);
+    }
 
   if (event->wd >= 0)
     {
       filename = sh_inotify_search_item(&sh_file_watches, event->wd, 
-                                        &class, &check_mask, &ftype);
+                                        &class, &check_mask, &ftype, &rdepth);
 
       if (filename)
         {
-          sh_fInotify_report(event, filename, class, check_mask, ftype);
-
+          sh_fInotify_report(event, filename, class, check_mask, ftype, rdepth);
           SH_FREE(filename);
         }
@@ -435 +444 @@
           SH_MUTEX_LOCK(mutex_thread_nolog);
           sh_error_handle((-1), FIL__, __LINE__, event->wd, MSG_E_SUBGEN, 
-                          _("Watch removed: internal error - file path unknown"), 
+                          _("Watch removed: file path unknown"), 
                           _("sh_fInotify_process"));
           SH_MUTEX_UNLOCK(mutex_thread_nolog);
@@ -444 +453 @@
       sh.flag.inotify |= SH_INOTIFY_DOSCAN;
       sh.flag.inotify |= SH_INOTIFY_NEEDINIT;
+      SH_MUTEX_LOCK(mutex_thread_nolog);
+      sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, event->wd, MSG_E_SUBGEN, 
+                      _("Inotify queue overflow"), 
+                      _("sh_fInotify_process"));
+      SH_MUTEX_UNLOCK(mutex_thread_nolog);
       return 1;
     }
@@ -481 +495 @@
 }
 
-static int sh_fInotify_report(struct inotify_event * event, char * filename,
-                              int class, unsigned long check_mask, int ftype)
-{
-  char * fullpath = NULL;
-  char * path;
+static int sh_fInotify_report_change (struct inotify_event * event, 
+                                      char * path, char * filename,
+                                      int class, unsigned long check_mask, int ftype)
+{
   int    reported;
-
-  if (event->len > 0)
-    {
-      fullpath = sh_util_strconcat(filename, "/", event->name, NULL);
-      path = fullpath;
+  int ret = sh_files_search_file(path, &class, &check_mask, &reported);
+
+  if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
+    {
+      ; /* do nothing, watch was for directory monitored as file only */
     }
   else
     {
-      path = filename;
-    }
-
-  if ( (event->mask & (IN_ATTRIB|IN_MODIFY)) != 0)
-    {
-      int ret = sh_files_search_file(path, &class, &check_mask, &reported);
-
+      sh_files_filecheck (class, check_mask, filename,
+                          (event->len > 0) ? event->name : NULL,
+                          &reported, 0);
+    }
+  return 0;
+}
+
+
+static int sh_fInotify_report_missing (struct inotify_event * event, 
+                                       char * path,
+                                       int class, unsigned long check_mask, int ftype)
+{
+  int    reported;
+  int isdir = (event->mask & IN_ISDIR);
+  int level = (class == SH_LEVEL_ALLIGNORE) ? 
+    ShDFLevel[class] : 
+    ShDFLevel[(isdir == 0) ? SH_ERR_T_FILE : SH_ERR_T_DIR];
+
+  if (S_FALSE == sh_ignore_chk_del(path))
+    {
+      if (0 != hashreport_missing(path, level))
+        {
+          int ret = sh_files_search_file(path, &class, &check_mask, &reported);
+          
+          if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
+            {
+              ; /* do nothing, watch was for directory monitored as file only */
+            }
+          else
+            {
+              /* Removal of a directory triggers:
+               * (1) IN_DELETE IN_ISDIR
+               * (2) IN_DELETE_SELF
+               */
+              if ((event->mask & IN_DELETE_SELF) == 0)
+                sh_fInotify_report_miss(path, level);
+            }
+        }
+    }
+
+#ifndef REPLACE_OLD
+  sh_hash_set_visited_true(path);
+#else
+  sh_hash_set_missing(path);
+#endif
+  if (sh.flag.reportonce == S_TRUE)
+    sh_files_set_file_reported(path);
+
+  /* Move to 'dormant' list, if not file within directory. 
+   */
+  if (event->len == 0)
+    sh_inotify_rm_watch(&sh_file_watches, &sh_file_missing, event->wd);
+
+  return 0;
+}
+
+static int sh_fInotify_report_added (struct inotify_event * event, 
+                                     char * path, char * filename,
+                                     int class, unsigned long check_mask, 
+                                     int ftype, int rdepth)
+{
+  if (S_FALSE == sh_ignore_chk_new(path))
+    {
+      int reported;
+      int ret;
+      int retD = 0;
+      int rdepthD = rdepth;
+      
+      sh_files_clear_file_reported(path);
+          
+      ret = sh_files_search_file(path, &class, &check_mask, &reported);
+      
       if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
         {
-          ; /* do nothing */
+          ; /* do nothing, watch was for directory monitored as file only */
         }
       else
         {
+          int classD = class;
+          int reportedD = reported; 
+          unsigned long check_maskD = check_mask;
+          
+          if (event->mask & IN_ISDIR)
+            {
+              retD = sh_files_search_dir(path, &classD, &check_maskD, 
+                                         &reportedD, &rdepthD);
+              if (retD != 0)
+                {
+                  if (ret == 0)
+                    {
+                      class      = classD;
+                      check_mask = check_maskD;
+                    }
+                }
+            }
+          
           sh_files_filecheck (class, check_mask, filename,
                               (event->len > 0) ? event->name : NULL,
                               &reported, 0);
-        }
+          
+          if (event->mask & IN_ISDIR)
+            {
+              sh.flag.inotify |= SH_INOTIFY_INSCAN;
+              sh_files_checkdir (classD, check_maskD, rdepthD, 
+                                 path, (event->len > 0) ? event->name : NULL);
+              sh.flag.inotify &= ~SH_INOTIFY_INSCAN;
+              sh.flag.inotify |= SH_INOTIFY_NEEDINIT;
+              sh_dirs_reset  ();
+              sh_files_reset ();
+            }
+          
+        }
+      
+      if (SH_FFLAG_REPORTED_SET(reported))
+        sh_files_set_file_reported(path);
+      
+      if ((ret != 0) || (event->mask & IN_ISDIR))
+        {
+          sh_inotify_add_watch(path, &sh_file_watches, &ret,
+                               class, check_mask, 
+                               (event->mask & IN_ISDIR)?SH_INOTIFY_DIR:SH_INOTIFY_FILE, 
+                               rdepthD);
+        }
+    }
+  return 0;
+}
+
+static int sh_fInotify_report(struct inotify_event * event, char * filename,
+                              int class, unsigned long check_mask, int ftype, int rdepth)
+{
+  char * fullpath = NULL;
+  char * path;
+
+  if (event->len > 0)
+    {
+      fullpath = sh_util_strconcat(filename, "/", event->name, NULL);
+      path = fullpath;
+    }
+  else
+    {
+      path = filename;
+    }
+
+  if ( (event->mask & (IN_ATTRIB|IN_MODIFY)) != 0)
+    {
+      sh_fInotify_report_change (event, path, filename,
+                                 class, check_mask, ftype);
     }
   else if ((event->mask & (IN_DELETE|IN_DELETE_SELF|IN_MOVE_SELF|IN_MOVED_FROM)) != 0)
     {
-      int isdir = (event->mask & IN_ISDIR);
-      int level = (class == SH_LEVEL_ALLIGNORE) ? 
-        ShDFLevel[class] : 
-        ShDFLevel[(isdir == 0) ? SH_ERR_T_FILE : SH_ERR_T_DIR];
-
-      if (S_FALSE == sh_ignore_chk_del(path))
-        {
-          if (0 != hashreport_missing(path, level))
-            {
-              int ret = sh_files_search_file(path, &class, &check_mask, &reported);
-
-              if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
-                {
-                  ; /* do nothing */
-                }
-              else
-                {
-                  sh_fInotify_report_miss(path, level);
-                }
-            }
-        }
-
-#ifndef REPLACE_OLD
-      sh_hash_set_visited_true(path);
-#else
-      sh_hash_set_missing(path);
+      sh_fInotify_report_missing (event, path,
+                                  class, check_mask, ftype);
+   }
+  else if((event->mask & (IN_CREATE|IN_MOVED_TO)) != 0)
+    {
+      sh_fInotify_report_added (event, path, filename,
+                                class, check_mask, 
+                                ftype, rdepth);
+    }
+
+  if (fullpath)
+    SH_FREE(fullpath);
+
+  return 0;
+}
+
+
 #endif
-      if (sh.flag.reportonce == S_TRUE)
-        sh_files_set_file_reported(path);
-
-      /* Move to 'dormant' list, if not file within directory. 
-       */
-      if (event->len == 0)
-        sh_inotify_rm_watch(&sh_file_watches, &sh_file_missing, event->wd);
-    }
-  else if((event->mask & (IN_CREATE|IN_MOVED_TO)) != 0)
-    {
-      if (S_FALSE == sh_ignore_chk_new(path))
-        {
-          int ret;
-
-          sh_files_clear_file_reported(path);
-          
-          ret = sh_files_search_file(path, &class, &check_mask, &reported);
-          
-          if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
-            {
-              ; /* do nothing */
-            }
-          else
-            {
-              sh_files_filecheck (class, check_mask, filename,
-                                  (event->len > 0) ? event->name : NULL,
-                                  &reported, 0);
-            }
-
-          if (SH_FFLAG_REPORTED_SET(reported))
-            sh_files_set_file_reported(path);
-
-          if (ret != 0)
-            {
-              sh_inotify_add_watch(path, &sh_file_watches, &ret,
-                                   class, check_mask, SH_INOTIFY_FILE);
-            }
-        }
-    }
-
-  return 0;
-}
-
 
 #endif
-
-#endif