[BACK]Return to hlink.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/hlink.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2012/02/17 15:09:30 version 1.1.1.4, 2021/03/17 00:32:36
Line 4 Line 4
  * Copyright (C) 1996 Andrew Tridgell   * Copyright (C) 1996 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras   * Copyright (C) 1996 Paul Mackerras
  * Copyright (C) 2002 Martin Pool <mbp@samba.org>   * Copyright (C) 2002 Martin Pool <mbp@samba.org>
 * Copyright (C) 2004-2009 Wayne Davison * Copyright (C) 2004-2020 Wayne Davison
  *   *
  * This program is free software; you can redistribute it and/or modify   * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
Line 21 Line 21
  */   */
   
 #include "rsync.h"  #include "rsync.h"
   #include "inums.h"
   #include "ifuncs.h"
   
 extern int verbose;  
 extern int dry_run;  extern int dry_run;
 extern int list_only;  extern int list_only;
 extern int am_sender;  extern int am_sender;
 extern int inc_recurse;  extern int inc_recurse;
 extern int do_xfers;  extern int do_xfers;
extern int link_dest;extern int alt_dest_type;
 extern int preserve_acls;  extern int preserve_acls;
 extern int preserve_xattrs;  extern int preserve_xattrs;
 extern int make_backups;  
 extern int protocol_version;  extern int protocol_version;
 extern int remove_source_files;  extern int remove_source_files;
 extern int stdout_format_has_i;  extern int stdout_format_has_i;
Line 48  extern struct file_list *cur_flist; Line 48  extern struct file_list *cur_flist;
  * we can avoid the pool of dev+inode data.  For incremental recursion mode,   * we can avoid the pool of dev+inode data.  For incremental recursion mode,
  * the receiver will use a ndx hash to remember old pathnames. */   * the receiver will use a ndx hash to remember old pathnames. */
   
   static void *data_when_new = "";
   
 static struct hashtable *dev_tbl;  static struct hashtable *dev_tbl;
   
 static struct hashtable *prior_hlinks;  static struct hashtable *prior_hlinks;
Line 57  static struct file_list *hlink_flist; Line 59  static struct file_list *hlink_flist;
 void init_hard_links(void)  void init_hard_links(void)
 {  {
         if (am_sender || protocol_version < 30)          if (am_sender || protocol_version < 30)
                dev_tbl = hashtable_create(16, 1);                dev_tbl = hashtable_create(16, HT_KEY64);
         else if (inc_recurse)          else if (inc_recurse)
                prior_hlinks = hashtable_create(1024, 0);                prior_hlinks = hashtable_create(1024, HT_KEY32);
 }  }
   
 struct ht_int64_node *idev_find(int64 dev, int64 ino)  struct ht_int64_node *idev_find(int64 dev, int64 ino)
 {  {
         static struct ht_int64_node *dev_node = NULL;          static struct ht_int64_node *dev_node = NULL;
         struct hashtable *tbl;  
   
         /* Note that some OSes have a dev == 0, so increment to avoid storing a 0. */          /* Note that some OSes have a dev == 0, so increment to avoid storing a 0. */
         if (!dev_node || dev_node->key != dev+1) {          if (!dev_node || dev_node->key != dev+1) {
                 /* We keep a separate hash table of inodes for every device. */                  /* We keep a separate hash table of inodes for every device. */
                dev_node = hashtable_find(dev_tbl, dev+1, 1);                dev_node = hashtable_find(dev_tbl, dev+1, data_when_new);
                if (!(tbl = dev_node->data))                if (dev_node->data == data_when_new) {
                        tbl = dev_node->data = hashtable_create(512, 1);                        dev_node->data = hashtable_create(512, HT_KEY64);
        } else                        if (DEBUG_GTE(HLINK, 3)) {
                tbl = dev_node->data;                                rprintf(FINFO, "[%s] created hashtable for dev %s\n",
                                         who_am_i(), big_num(dev));
                         }
                 }
         }
   
        return hashtable_find(tbl, ino, 1);        return hashtable_find(dev_node->data, ino, (void*)-1L);
 }  }
   
 void idev_destroy(void)  void idev_destroy(void)
Line 112  static void match_gnums(int32 *ndx_list, int ndx_count Line 117  static void match_gnums(int32 *ndx_list, int ndx_count
         struct ht_int32_node *node = NULL;          struct ht_int32_node *node = NULL;
         int32 gnum, gnum_next;          int32 gnum, gnum_next;
   
        qsort(ndx_list, ndx_count, sizeof ndx_list[0],        qsort(ndx_list, ndx_count, sizeof ndx_list[0], (int (*)()) hlink_compare_gnum);
             (int (*)()) hlink_compare_gnum); 
   
         for (from = 0; from < ndx_count; from++) {          for (from = 0; from < ndx_count; from++) {
                 file = hlink_flist->sorted[ndx_list[from]];                  file = hlink_flist->sorted[ndx_list[from]];
                 gnum = F_HL_GNUM(file);                  gnum = F_HL_GNUM(file);
                 if (inc_recurse) {                  if (inc_recurse) {
                        node = hashtable_find(prior_hlinks, gnum, 1);                        node = hashtable_find(prior_hlinks, gnum, data_when_new);
                        if (!node->data) {                        if (node->data == data_when_new) {
                                if (!(node->data = new_array0(char, 5)))                                node->data = new_array0(char, 5);
                                        out_of_memory("match_gnums"); 
                                 assert(gnum >= hlink_flist->ndx_start);                                  assert(gnum >= hlink_flist->ndx_start);
                                 file->flags |= FLAG_HLINK_FIRST;                                  file->flags |= FLAG_HLINK_FIRST;
                                 prev = -1;                                  prev = -1;
Line 186  void match_hard_links(struct file_list *flist) Line 189  void match_hard_links(struct file_list *flist)
                 int i, ndx_count = 0;                  int i, ndx_count = 0;
                 int32 *ndx_list;                  int32 *ndx_list;
   
                if (!(ndx_list = new_array(int32, flist->used)))                ndx_list = new_array(int32, flist->used);
                        out_of_memory("match_hard_links"); 
   
                 for (i = 0; i < flist->used; i++) {                  for (i = 0; i < flist->used; i++) {
                         if (F_IS_HLINKED(flist->sorted[i]))                          if (F_IS_HLINKED(flist->sorted[i]))
Line 206  void match_hard_links(struct file_list *flist) Line 208  void match_hard_links(struct file_list *flist)
 }  }
   
 static int maybe_hard_link(struct file_struct *file, int ndx,  static int maybe_hard_link(struct file_struct *file, int ndx,
                           const char *fname, int statret, stat_x *sxp,                           char *fname, int statret, stat_x *sxp,
                            const char *oldname, STRUCT_STAT *old_stp,                             const char *oldname, STRUCT_STAT *old_stp,
                            const char *realname, int itemizing, enum logcode code)                             const char *realname, int itemizing, enum logcode code)
 {  {
Line 218  static int maybe_hard_link(struct file_struct *file, i Line 220  static int maybe_hard_link(struct file_struct *file, i
                                         ITEM_LOCAL_CHANGE | ITEM_XNAME_FOLLOWS,                                          ITEM_LOCAL_CHANGE | ITEM_XNAME_FOLLOWS,
                                         0, "");                                          0, "");
                         }                          }
                        if (verbose > 1 && maybe_ATTRS_REPORT)                        if (INFO_GTE(NAME, 2) && maybe_ATTRS_REPORT)
                                 rprintf(FCLIENT, "%s is uptodate\n", fname);                                  rprintf(FCLIENT, "%s is uptodate\n", fname);
                         file->flags |= FLAG_HLINK_DONE;                          file->flags |= FLAG_HLINK_DONE;
                         return 0;                          return 0;
                 }                  }
                 if (make_backups > 0) {  
                         if (!make_backup(fname))  
                                 return -1;  
                 } else if (robust_unlink(fname)) {  
                         rsyserr(FERROR_XFER, errno, "unlink %s failed",  
                                 full_fname(fname));  
                         return -1;  
                 }  
         }          }
   
        if (hard_link_one(file, fname, oldname, 0)) {        if (atomic_create(file, fname, NULL, oldname, MAKEDEV(0, 0), sxp, statret == 0 ? DEL_FOR_FILE : 0)) {
                 if (itemizing) {                  if (itemizing) {
                         itemize(fname, file, ndx, statret, sxp,                          itemize(fname, file, ndx, statret, sxp,
                                 ITEM_LOCAL_CHANGE | ITEM_XNAME_FOLLOWS, 0,                                  ITEM_LOCAL_CHANGE | ITEM_XNAME_FOLLOWS, 0,
                                 realname);                                  realname);
                 }                  }
                if (code != FNONE && verbose)                if (code != FNONE && INFO_GTE(NAME, 1))
                         rprintf(code, "%s => %s\n", fname, realname);                          rprintf(code, "%s => %s\n", fname, realname);
                 return 0;                  return 0;
         }          }
   
         return -1;          return -1;
 }  }
   
Line 270  static char *check_prior(struct file_struct *file, int Line 265  static char *check_prior(struct file_struct *file, int
         }          }
   
         if (inc_recurse          if (inc_recurse
         && (node = hashtable_find(prior_hlinks, gnum, 0)) != NULL) {         && (node = hashtable_find(prior_hlinks, gnum, NULL)) != NULL) {
                 assert(node->data != NULL);                  assert(node->data != NULL);
                 if (CVAL(node->data, 0) != 0) {                  if (CVAL(node->data, 0) != 0) {
                         *prev_ndx_p = -1;                          *prev_ndx_p = -1;
Line 288  static char *check_prior(struct file_struct *file, int Line 283  static char *check_prior(struct file_struct *file, int
   
 /* Only called if FLAG_HLINKED is set and FLAG_HLINK_FIRST is not.  Returns:  /* Only called if FLAG_HLINKED is set and FLAG_HLINK_FIRST is not.  Returns:
  * 0 = process the file, 1 = skip the file, -1 = error occurred. */   * 0 = process the file, 1 = skip the file, -1 = error occurred. */
int hard_link_check(struct file_struct *file, int ndx, const char *fname,int hard_link_check(struct file_struct *file, int ndx, char *fname,
                     int statret, stat_x *sxp, int itemizing,                      int statret, stat_x *sxp, int itemizing,
                     enum logcode code)                      enum logcode code)
 {  {
Line 307  int hard_link_check(struct file_struct *file, int ndx, Line 302  int hard_link_check(struct file_struct *file, int ndx,
                 if (!flist) {                  if (!flist) {
                         /* The previous file was skipped, so this one is                          /* The previous file was skipped, so this one is
                          * treated as if it were the first in its group. */                           * treated as if it were the first in its group. */
                           if (DEBUG_GTE(HLINK, 2)) {
                                   rprintf(FINFO, "hlink for %d (%s,%d): virtual first\n",
                                           ndx, f_name(file, NULL), gnum);
                           }
                         return 0;                          return 0;
                 }                  }
   
Line 323  int hard_link_check(struct file_struct *file, int ndx, Line 322  int hard_link_check(struct file_struct *file, int ndx,
                                 F_HL_PREV(prev_file) = ndx;                                  F_HL_PREV(prev_file) = ndx;
                                 file->flags |= FLAG_FILE_SENT;                                  file->flags |= FLAG_FILE_SENT;
                                 cur_flist->in_progress++;                                  cur_flist->in_progress++;
                                   if (DEBUG_GTE(HLINK, 2)) {
                                           rprintf(FINFO, "hlink for %d (%s,%d): waiting for %d\n",
                                                   ndx, f_name(file, NULL), gnum, F_HL_PREV(file));
                                   }
                                 return 1;                                  return 1;
                         }                          }
                           if (DEBUG_GTE(HLINK, 2)) {
                                   rprintf(FINFO, "hlink for %d (%s,%d): looking for a leader\n",
                                           ndx, f_name(file, NULL), gnum);
                           }
                         return 0;                          return 0;
                 }                  }
   
Line 332  int hard_link_check(struct file_struct *file, int ndx, Line 339  int hard_link_check(struct file_struct *file, int ndx,
                 if (!(prev_file->flags & FLAG_HLINK_FIRST)) {                  if (!(prev_file->flags & FLAG_HLINK_FIRST)) {
                         /* The previous previous is FIRST when prev is not. */                          /* The previous previous is FIRST when prev is not. */
                         prev_name = realname = check_prior(prev_file, gnum, &prev_ndx, &flist);                          prev_name = realname = check_prior(prev_file, gnum, &prev_ndx, &flist);
                         assert(prev_name != NULL || flist != NULL);  
                         /* Update our previous pointer to point to the FIRST. */                          /* Update our previous pointer to point to the FIRST. */
                         F_HL_PREV(file) = prev_ndx;                          F_HL_PREV(file) = prev_ndx;
                 }                  }
Line 340  int hard_link_check(struct file_struct *file, int ndx, Line 346  int hard_link_check(struct file_struct *file, int ndx,
                 if (!prev_name) {                  if (!prev_name) {
                         int alt_dest;                          int alt_dest;
   
                           assert(flist != NULL);
                         prev_file = flist->files[prev_ndx - flist->ndx_start];                          prev_file = flist->files[prev_ndx - flist->ndx_start];
                         /* F_HL_PREV() is alt_dest value when DONE && FIRST. */                          /* F_HL_PREV() is alt_dest value when DONE && FIRST. */
                         alt_dest = F_HL_PREV(prev_file);                          alt_dest = F_HL_PREV(prev_file);
                           if (DEBUG_GTE(HLINK, 2)) {
                                   rprintf(FINFO, "hlink for %d (%s,%d): found flist match (alt %d)\n",
                                           ndx, f_name(file, NULL), gnum, alt_dest);
                           }
   
                         if (alt_dest >= 0 && dry_run) {                          if (alt_dest >= 0 && dry_run) {
                                 pathjoin(namebuf, MAXPATHLEN, basis_dir[alt_dest],                                  pathjoin(namebuf, MAXPATHLEN, basis_dir[alt_dest],
Line 356  int hard_link_check(struct file_struct *file, int ndx, Line 367  int hard_link_check(struct file_struct *file, int ndx,
                 }                  }
         }          }
   
           if (DEBUG_GTE(HLINK, 2)) {
                   rprintf(FINFO, "hlink for %d (%s,%d): leader is %d (%s)\n",
                           ndx, f_name(file, NULL), gnum, prev_ndx, prev_name);
           }
   
         if (link_stat(prev_name, &prev_st, 0) < 0) {          if (link_stat(prev_name, &prev_st, 0) < 0) {
                 if (!dry_run || errno != ENOENT) {                  if (!dry_run || errno != ENOENT) {
                         rsyserr(FERROR_XFER, errno, "stat %s failed", full_fname(prev_name));                          rsyserr(FERROR_XFER, errno, "stat %s failed", full_fname(prev_name));
Line 371  int hard_link_check(struct file_struct *file, int ndx, Line 387  int hard_link_check(struct file_struct *file, int ndx,
                 char cmpbuf[MAXPATHLEN];                  char cmpbuf[MAXPATHLEN];
                 stat_x alt_sx;                  stat_x alt_sx;
                 int j = 0;                  int j = 0;
#ifdef SUPPORT_ACLS                init_stat_x(&alt_sx);
                alt_sx.acc_acl = alt_sx.def_acl = NULL; 
#endif 
#ifdef SUPPORT_XATTRS 
                alt_sx.xattr = NULL; 
#endif 
                 do {                  do {
                         pathjoin(cmpbuf, MAXPATHLEN, basis_dir[j], fname);                          pathjoin(cmpbuf, MAXPATHLEN, basis_dir[j], fname);
                         if (link_stat(cmpbuf, &alt_sx.st, 0) < 0)                          if (link_stat(cmpbuf, &alt_sx.st, 0) < 0)
                                 continue;                                  continue;
                        if (link_dest) {                        if (alt_dest_type == LINK_DEST) {
                                 if (prev_st.st_dev != alt_sx.st.st_dev                                  if (prev_st.st_dev != alt_sx.st.st_dev
                                  || prev_st.st_ino != alt_sx.st.st_ino)                                   || prev_st.st_ino != alt_sx.st.st_ino)
                                         continue;                                          continue;
                                 statret = 1;                                  statret = 1;
                                 if (stdout_format_has_i == 0                                  if (stdout_format_has_i == 0
                                 || (verbose < 2 && stdout_format_has_i < 2)) {                                 || (!INFO_GTE(NAME, 2) && stdout_format_has_i < 2)) {
                                         itemizing = 0;                                          itemizing = 0;
                                         code = FNONE;                                          code = FNONE;
                                        if (verbose > 1 && maybe_ATTRS_REPORT)                                        if (INFO_GTE(NAME, 2) && maybe_ATTRS_REPORT)
                                                 rprintf(FCLIENT, "%s is uptodate\n", fname);                                                  rprintf(FCLIENT, "%s is uptodate\n", fname);
                                 }                                  }
                                 break;                                  break;
                         }                          }
                        if (!unchanged_file(cmpbuf, file, &alt_sx.st))                        if (!unchanged_file(cmpbuf, file, &alt_sx.st, j+1))
                                 continue;                                  continue;
                         statret = 1;                          statret = 1;
                         if (unchanged_attrs(cmpbuf, file, &alt_sx))                          if (unchanged_attrs(cmpbuf, file, &alt_sx))
Line 426  int hard_link_check(struct file_struct *file, int ndx, Line 437  int hard_link_check(struct file_struct *file, int ndx,
                                 }                                  }
                         }                          }
 #endif  #endif
                } else {                } else
#ifdef SUPPORT_ACLS                        free_stat_x(&alt_sx);
                        if (preserve_acls) 
                                free_acl(&alt_sx); 
#endif 
#ifdef SUPPORT_XATTRS 
                        if (preserve_xattrs) 
                                free_xattr(&alt_sx); 
#endif 
                } 
         }          }
   
         if (maybe_hard_link(file, ndx, fname, statret, sxp, prev_name, &prev_st,          if (maybe_hard_link(file, ndx, fname, statret, sxp, prev_name, &prev_st,
Line 454  int hard_link_one(struct file_struct *file, const char Line 457  int hard_link_one(struct file_struct *file, const char
         if (do_link(oldname, fname) < 0) {          if (do_link(oldname, fname) < 0) {
                 enum logcode code;                  enum logcode code;
                 if (terse) {                  if (terse) {
                        if (!verbose)                        if (!INFO_GTE(NAME, 1))
                                 return 0;                                  return 0;
                         code = FINFO;                          code = FINFO;
                 } else                  } else
Line 481  void finish_hard_link(struct file_struct *file, const  Line 484  void finish_hard_link(struct file_struct *file, const 
         int prev_statret, ndx, prev_ndx = F_HL_PREV(file);          int prev_statret, ndx, prev_ndx = F_HL_PREV(file);
   
         if (stp == NULL && prev_ndx >= 0) {          if (stp == NULL && prev_ndx >= 0) {
                if (link_stat(fname, &st, 0) < 0) {                if (link_stat(fname, &st, 0) < 0 && !dry_run) {
                         rsyserr(FERROR_XFER, errno, "stat %s failed",                          rsyserr(FERROR_XFER, errno, "stat %s failed",
                                 full_fname(fname));                                  full_fname(fname));
                         return;                          return;
Line 499  void finish_hard_link(struct file_struct *file, const  Line 502  void finish_hard_link(struct file_struct *file, const 
         } else          } else
                 our_name = fname;                  our_name = fname;
   
#ifdef SUPPORT_ACLS        init_stat_x(&prev_sx);
        prev_sx.acc_acl = prev_sx.def_acl = NULL; 
#endif 
#ifdef SUPPORT_XATTRS 
        prev_sx.xattr = NULL; 
#endif 
   
         while ((ndx = prev_ndx) >= 0) {          while ((ndx = prev_ndx) >= 0) {
                 int val;                  int val;
Line 517  void finish_hard_link(struct file_struct *file, const  Line 515  void finish_hard_link(struct file_struct *file, const 
                 val = maybe_hard_link(file, ndx, prev_name, prev_statret, &prev_sx,                  val = maybe_hard_link(file, ndx, prev_name, prev_statret, &prev_sx,
                                       our_name, stp, fname, itemizing, code);                                        our_name, stp, fname, itemizing, code);
                 flist->in_progress--;                  flist->in_progress--;
#ifdef SUPPORT_ACLS                free_stat_x(&prev_sx);
                if (preserve_acls) 
                        free_acl(&prev_sx); 
#endif 
#ifdef SUPPORT_XATTRS 
                if (preserve_xattrs) 
                        free_xattr(&prev_sx); 
#endif 
                 if (val < 0)                  if (val < 0)
                         continue;                          continue;
                 if (remove_source_files == 1 && do_xfers)                  if (remove_source_files == 1 && do_xfers)
Line 533  void finish_hard_link(struct file_struct *file, const  Line 524  void finish_hard_link(struct file_struct *file, const 
   
         if (inc_recurse) {          if (inc_recurse) {
                 int gnum = F_HL_GNUM(file);                  int gnum = F_HL_GNUM(file);
                struct ht_int32_node *node = hashtable_find(prior_hlinks, gnum, 0);                struct ht_int32_node *node = hashtable_find(prior_hlinks, gnum, NULL);
                 if (node == NULL) {                  if (node == NULL) {
                         rprintf(FERROR, "Unable to find a hlink node for %d (%s)\n", gnum, f_name(file, prev_name));                          rprintf(FERROR, "Unable to find a hlink node for %d (%s)\n", gnum, f_name(file, prev_name));
                         exit_cleanup(RERR_MESSAGEIO);                          exit_cleanup(RERR_MESSAGEIO);
Line 548  void finish_hard_link(struct file_struct *file, const  Line 539  void finish_hard_link(struct file_struct *file, const 
                         exit_cleanup(RERR_MESSAGEIO);                          exit_cleanup(RERR_MESSAGEIO);
                 }                  }
                 free(node->data);                  free(node->data);
                if (!(node->data = strdup(our_name)))                node->data = strdup(our_name);
                        out_of_memory("finish_hard_link"); 
         }          }
 }  }
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>