Changeset 372


Ignore:
Timestamp:
Nov 1, 2011, 12:33:37 AM (13 years ago)
Author:
katerina
Message:

One more patch for ticket #265 (inotify). Handle dirs that are only specified as files.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/sh_inotify.h

    r371 r372  
    2323#define SH_INOTIFY_INITIALIZER { NULL, NULL, 0, 0 }
    2424
     25#define SH_INOTIFY_FILE 0
     26#define SH_INOTIFY_DIR  1
     27
    2528int sh_inotify_wait_for_change(char * filename, sh_watches * watches,
    2629                               int  * errnum,   int waitsec);
    … …  
    2932
    3033int sh_inotify_add_watch(char * filename, sh_watches * watches, int  * errnum,
    31                          int class, unsigned long check_mask);
     34                         int class, unsigned long check_mask, int type);
    3235
    3336int sh_inotify_add_watch_later(char * filename, sh_watches * watches, int  * errnum,
    34                                int class, unsigned long check_mask);
     37                               int class, unsigned long check_mask, int type);
    3538
    36 char * sh_inotify_pop_dormant(sh_watches * watches, int * class, unsigned long * check_mask);
     39char * sh_inotify_pop_dormant(sh_watches * watches, int * class, unsigned long * check_mask, int * type);
    3740
    3841void sh_inotify_purge_dormant(sh_watches * watches);
    … …  
    4144
    4245char * sh_inotify_search_item(sh_watches * watches, int watch,
    43                               int * class, unsigned long * check_mask);
     46                              int * class, unsigned long * check_mask, int * type);
    4447ssize_t sh_inotify_read(char * buffer, size_t count);
    4548ssize_t sh_inotify_read_timeout(char * buffer, size_t count, int timeout);

  • trunk/src/sh_fInotify.c

    r371 r372  
    111111static int sh_fInotify_process(struct inotify_event * event);
    112112static int sh_fInotify_report(struct inotify_event * event, char * filename,
    113                               int class, unsigned long check_mask);
     113                              int class, unsigned long check_mask, int ftype);
    114114
    115115int sh_fInotify_init(struct mod_type * arg)
    … …  
    168168  ssize_t len = -1;
    169169  char *  buffer = SH_ALLOC(16384);
    170   static int count = 0;
     170  static int count  = 0;
     171  static int count2 = 0;
    171172
    172173  if (ShfInotifyActive == S_FALSE)
    … …  
    211212  sh_inotify_recheck_watches (&sh_file_watches, &sh_file_missing);
    212213
    213   ++count;
     214  ++count;
     215  ++count2;
    214216
    215217  if (count >= 10)
    216218    {
    217       count = 0; /* Re-expand glob patterns to discover added files */
     219      count = 0; /* Re-expand glob patterns to discover added files. */
    218220      sh_files_check_globFilePatterns();
     221    }
     222
     223  if (count2 >= 300)
     224    {
     225      count2 = 0; /* Update baseline database. */
     226      if (sh.flag.checkSum == SH_CHECK_CHECK &&
     227          sh.flag.update == S_TRUE)
     228        sh_hash_writeout ();
    219229    }
    220230
    … …  
    303313  char * filename;
    304314  int    class;
     315  int    type;
    305316  unsigned long check_mask;
    306317  int    retval;
    … …  
    323334
    324335  while (NULL != (filename = sh_inotify_pop_dormant(&sh_file_watches,
    325                                                     &class, &check_mask)))
     336                                                    &class, &check_mask, &type)))
    326337    {
    327338      retval = sh_inotify_add_watch(filename, &sh_file_watches, &errnum,
    328                                     class, check_mask);
     339                                    class, check_mask, type);
    329340
    330341      if (retval < 0)
    … …  
    367378{
    368379  int class;
     380  int ftype;
    369381  unsigned long check_mask;
    370382  char * filename;
    … …  
    374386    {
    375387      char dbgbuf[256];
     388
    376389      sl_strlcpy (dbgbuf, "inotify mask: ", sizeof(dbgbuf));
     390
    377391      if (event->mask & IN_ACCESS) sl_strlcat(dbgbuf, "IN_ACCESS ", sizeof(dbgbuf));
    378392      if (event->mask & IN_ATTRIB) sl_strlcat(dbgbuf, "IN_ATTRIB ", sizeof(dbgbuf));
    … …  
    391405      if (event->mask & IN_Q_OVERFLOW) sl_strlcat(dbgbuf, "IN_Q_OVERFLOW ", sizeof(dbgbuf));
    392406      if (event->mask & IN_UNMOUNT) sl_strlcat(dbgbuf, "IN_UNMOUNT ", sizeof(dbgbuf));
     407
    393408      SH_MUTEX_LOCK(mutex_thread_nolog);
    394409      sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, 0, MSG_E_SUBGEN,
    … …  
    401416    {
    402417      filename = sh_inotify_search_item(&sh_file_watches, event->wd,
    403                                         &class, &check_mask);
     418                                        &class, &check_mask, &ftype);
    404419
    405420      if (filename)
    406421        {
    407           sh_fInotify_report(event, filename, class, check_mask);
     422          sh_fInotify_report(event, filename, class, check_mask, ftype);
    408423
    409424          SH_FREE(filename);
    … …  
    417432          /* Remove watch ? Seems reasonable. */
    418433          sh_inotify_rm_watch(NULL, NULL, event->wd);
     434
    419435          SH_MUTEX_LOCK(mutex_thread_nolog);
    420436          sh_error_handle((-1), FIL__, __LINE__, event->wd, MSG_E_SUBGEN,
    … …  
    466482
    467483static int sh_fInotify_report(struct inotify_event * event, char * filename,
    468                               int class, unsigned long check_mask)
     484                              int class, unsigned long check_mask, int ftype)
    469485{
    470486  char * fullpath = NULL;
    … …  
    484500  if ( (event->mask & (IN_ATTRIB|IN_MODIFY)) != 0)
    485501    {
    486       sh_files_search_file(path, &class, &check_mask, &reported);
    487 
    488       sh_files_filecheck (class, check_mask, filename,
    489                           (event->len > 0) ? event->name : NULL,
    490                           &reported, 0);
     502      int ret = sh_files_search_file(path, &class, &check_mask, &reported);
     503
     504      if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
     505        {
     506          ; /* do nothing */
     507        }
     508      else
     509        {
     510          sh_files_filecheck (class, check_mask, filename,
     511                              (event->len > 0) ? event->name : NULL,
     512                              &reported, 0);
     513        }
    491514    }
    492515  else if ((event->mask & (IN_DELETE|IN_DELETE_SELF|IN_MOVE_SELF|IN_MOVED_FROM)) != 0)
    … …  
    501524          if (0 != hashreport_missing(path, level))
    502525            {
    503               sh_fInotify_report_miss(path, level);
     526              int ret = sh_files_search_file(path, &class, &check_mask, &reported);
     527
     528              if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
     529                {
     530                  ; /* do nothing */
     531                }
     532              else
     533                {
     534                  sh_fInotify_report_miss(path, level);
     535                }
    504536            }
    505537        }
    … …  
    513545        sh_files_set_file_reported(path);
    514546
    515       /* Move to 'dormant' list.
     547      /* Move to 'dormant' list, if not file within directory.
    516548       */
    517       sh_inotify_rm_watch(&sh_file_watches, &sh_file_missing, event->wd);
     549      if (event->len == 0)
     550        sh_inotify_rm_watch(&sh_file_watches, &sh_file_missing, event->wd);
    518551    }
    519552  else if((event->mask & (IN_CREATE|IN_MOVED_TO)) != 0)
    … …  
    527560          ret = sh_files_search_file(path, &class, &check_mask, &reported);
    528561         
    529           sh_files_filecheck (class, check_mask, filename,
    530                               (event->len > 0) ? event->name : NULL,
    531                               &reported, 0);
     562          if ((ret == 0) && (event->len > 0) && (ftype == SH_INOTIFY_FILE))
     563            {
     564              ; /* do nothing */
     565            }
     566          else
     567            {
     568              sh_files_filecheck (class, check_mask, filename,
     569                                  (event->len > 0) ? event->name : NULL,
     570                                  &reported, 0);
     571            }
     572
    532573          if (SH_FFLAG_REPORTED_SET(reported))
    533574            sh_files_set_file_reported(path);
    … …  
    536577            {
    537578              sh_inotify_add_watch(path, &sh_file_watches, &ret,
    538                                    class, check_mask);
     579                                   class, check_mask, SH_INOTIFY_FILE);
    539580            }
    540581        }

  • trunk/src/sh_files.c

    r371 r372  
    370370            {
    371371              sh_inotify_add_watch_later(ptr->name, &sh_file_watches, NULL,
    372                                          ptr->class, ptr->check_mask);
     372                                         ptr->class, ptr->check_mask, SH_INOTIFY_FILE);
    373373            }
    374374
    … …  
    19071907    }
    19081908
    1909   if ((sh.flag.inotify & SH_INOTIFY_DOSCAN) != 0)
    1910     {
    1911       sh_inotify_add_watch_later(iname, &sh_file_watches, &status,
    1912                                  iclass, check_mask);
    1913     }
    1914    
    19151909  /* ---- stat the directory ----
    19161910   */
    … …  
    19551949    }
    19561950
     1951  if ((sh.flag.inotify & SH_INOTIFY_DOSCAN) != 0)
     1952    {
     1953      sh_inotify_add_watch_later(iname, &sh_file_watches, &status,
     1954                                 iclass, check_mask, SH_INOTIFY_DIR);
     1955    }
     1956   
    19571957  hardlink_num = theFile->hardlinks;
    19581958

  • trunk/src/sh_inotify.c

    r371 r372  
    125125{
    126126  int    watch;
    127   int    flag;
     127  short  flag;
     128  short  type;
    128129  int    class;
    129130  unsigned long check_mask;
    … …  
    355356
    356357char * sh_inotify_pop_dormant(sh_watches * watches,
    357                               int * class, unsigned long * check_mask)
     358                              int * class, unsigned long * check_mask, int * type)
    358359{
    359360  char * popret = NULL;
    … …  
    372373    {
    373374      *class = this->watch->class;
     375      *type  = this->watch->type;
    374376      *check_mask = this->watch->check_mask;
    375377      popret = sh_util_strdup(this->watch->file);
    … …  
    472474int sh_inotify_add_watch_later(char * filename, sh_watches * watches,
    473475                               int * errnum,
    474                                int class, unsigned long check_mask)
     476                               int class, unsigned long check_mask, int type)
    475477{
    476478  sh_watch   * item;
    … …  
    479481
    480482  item->class      = class;
     483  item->type       = (short) type;
    481484  item->check_mask = check_mask;
    482485
    … …  
    571574 */
    572575int sh_inotify_add_watch(char * filename, sh_watches * watches, int * errnum,
    573                          int class, unsigned long check_mask)
     576                         int class, unsigned long check_mask, int type)
    574577{
    575578  volatile int retval = 0;
    … …  
    614617
    615618          item->class      = class;
     619          item->type       = type;
    616620          item->check_mask = check_mask;
    617621         
    … …  
    651655
    652656char * sh_inotify_search_item(sh_watches * watches, int watch,
    653                               int * class, unsigned long * check_mask)
     657                              int * class, unsigned long * check_mask, int * type)
    654658{
    655659  sh_watch * item;
    … …  
    668672      *class      = item->class;
    669673      *check_mask = item->check_mask;
     674      *type       = item->type;
    670675      sret = sh_util_strdup(item->file);
    671676    }
    … …  
    705710      if (filename)
    706711        {
    707           if (sh_inotify_add_watch(filename, watches, errnum, 0, 0) < 0)
     712          if (sh_inotify_add_watch(filename, watches, errnum, 0, 0, SH_INOTIFY_FILE) < 0)
    708713            {
    709714              retry_msleep(waitsec, 0);

  • trunk/src/sh_modules.c

    r367 r372  
    178178    N_("INOTIFY"),
    179179    -1,
    180     SH_MODFL_NOTIMER,
     180    0,
    181181    sh_fInotify_init,
    182182    sh_fInotify_timer,
Note: See TracChangeset for help on using the changeset viewer.