[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.3 and 1.1.1.4

version 1.1.1.3, 2016/11/01 09:54:32 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-2015 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 29  extern int list_only; Line 29  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 protocol_version;  extern int protocol_version;
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);
                         if (DEBUG_GTE(HLINK, 3)) {                          if (DEBUG_GTE(HLINK, 3)) {
                                rprintf(FINFO,                                rprintf(FINFO, "[%s] created hashtable for dev %s\n",
                                    "[%s] created hashtable for dev %s\n",                                        who_am_i(), big_num(dev));
                                    who_am_i(), big_num(dev)); 
                         }                          }
                 }                  }
        } else        }
                tbl = dev_node->data; 
   
        return hashtable_find(tbl, ino, 1);        return hashtable_find(dev_node->data, ino, (void*)-1L);
 }  }
   
 void idev_destroy(void)  void idev_destroy(void)
Line 118  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 192  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 269  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 396  int hard_link_check(struct file_struct *file, int ndx, Line 392  int hard_link_check(struct file_struct *file, int ndx,
                         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;
Line 410  int hard_link_check(struct file_struct *file, int ndx, Line 406  int hard_link_check(struct file_struct *file, int ndx,
                                 }                                  }
                                 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 422  int hard_link_check(struct file_struct *file, int ndx,
                                 else {                                  else {
                                         sxp->acc_acl = alt_sx.acc_acl;                                          sxp->acc_acl = alt_sx.acc_acl;
                                         sxp->def_acl = alt_sx.def_acl;                                          sxp->def_acl = alt_sx.def_acl;
                                         sxp->nfs4_acl = alt_sx.nfs4_acl;  
                                         alt_sx.acc_acl = alt_sx.def_acl = NULL;                                          alt_sx.acc_acl = alt_sx.def_acl = NULL;
                                         alt_sx.nfs4_acl = NULL;  
                                 }                                  }
                         }                          }
 #endif  #endif
Line 530  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 545  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.3  
changed lines
  Added in v.1.1.1.4

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