--- embedaddon/rsync/match.c 2012/02/17 15:09:30 1.1.1.1 +++ embedaddon/rsync/match.c 2021/03/17 00:32:36 1.1.1.4 @@ -3,7 +3,7 @@ * * Copyright (C) 1996 Andrew Tridgell * Copyright (C) 1996 Paul Mackerras - * Copyright (C) 2003-2009 Wayne Davison + * Copyright (C) 2003-2020 Wayne Davison * * 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 @@ -20,13 +20,14 @@ */ #include "rsync.h" +#include "inums.h" -extern int verbose; -extern int do_progress; extern int checksum_seed; extern int append_mode; +extern int xfersum_type; int updating_basis_file; +char sender_file_sum[MAX_DIGEST_LEN]; static int false_alarms; static int hash_hits; @@ -64,8 +65,6 @@ static void build_hash_table(struct sum_struct *s) if (hash_table) free(hash_table); hash_table = new_array(int32, tablesize); - if (!hash_table) - out_of_memory("build_hash_table"); alloc_size = tablesize; } @@ -101,16 +100,15 @@ static OFF_T last_match; * If i >= 0, the number of a matched token. If < 0, indicates we have * only literal data. A -1 will send a 0-token-int too, and a -2 sends * only literal data, w/o any token-int. */ -static void matched(int f, struct sum_struct *s, struct map_struct *buf, - OFF_T offset, int32 i) +static void matched(int f, struct sum_struct *s, struct map_struct *buf, OFF_T offset, int32 i) { int32 n = (int32)(offset - last_match); /* max value: block_size (int32) */ int32 j; - if (verbose > 2 && i >= 0) { + if (DEBUG_GTE(DELTASUM, 2) && i >= 0) { rprintf(FINFO, - "match at %.0f last_match=%.0f j=%d len=%ld n=%ld\n", - (double)offset, (double)last_match, i, + "match at %s last_match=%s j=%d len=%ld n=%ld\n", + big_num(offset), big_num(last_match), i, (long)s->sums[i].len, (long)n); } @@ -132,7 +130,7 @@ static void matched(int f, struct sum_struct *s, struc else last_match = offset; - if (buf && do_progress) + if (buf && INFO_GTE(PROGRESS, 1)) show_progress(last_match, buf->file_size); } @@ -151,9 +149,9 @@ static void hash_search(int f,struct sum_struct *s, * coding of the output to work more efficiently. */ want_i = 0; - if (verbose > 2) { - rprintf(FINFO, "hash search b=%ld len=%.0f\n", - (long)s->blength, (double)len); + if (DEBUG_GTE(DELTASUM, 2)) { + rprintf(FINFO, "hash search b=%ld len=%s\n", + (long)s->blength, big_num(len)); } k = (int32)MIN(len, (OFF_T)s->blength); @@ -163,41 +161,57 @@ static void hash_search(int f,struct sum_struct *s, sum = get_checksum1((char *)map, k); s1 = sum & 0xFFFF; s2 = sum >> 16; - if (verbose > 3) + if (DEBUG_GTE(DELTASUM, 3)) rprintf(FINFO, "sum=%.8x k=%ld\n", sum, (long)k); + checksum2_enable_prefetch(buf, len, s->blength); + offset = aligned_offset = aligned_i = 0; end = len + 1 - s->sums[s->count-1].len; - if (verbose > 3) { - rprintf(FINFO, "hash search s->blength=%ld len=%.0f count=%.0f\n", - (long)s->blength, (double)len, (double)s->count); + if (DEBUG_GTE(DELTASUM, 3)) { + rprintf(FINFO, "hash search s->blength=%ld len=%s count=%s\n", + (long)s->blength, big_num(len), big_num(s->count)); } do { int done_csum2 = 0; - int32 i; + uint32 hash_entry; + int32 i, *prev; - if (verbose > 4) { - rprintf(FINFO, "offset=%.0f sum=%04x%04x\n", - (double)offset, s2 & 0xFFFF, s1 & 0xFFFF); + if (DEBUG_GTE(DELTASUM, 4)) { + rprintf(FINFO, "offset=%s sum=%04x%04x\n", + big_num(offset), s2 & 0xFFFF, s1 & 0xFFFF); } if (tablesize == TRADITIONAL_TABLESIZE) { - if ((i = hash_table[SUM2HASH2(s1,s2)]) < 0) + hash_entry = SUM2HASH2(s1,s2); + if ((i = hash_table[hash_entry]) < 0) goto null_hash; sum = (s1 & 0xffff) | (s2 << 16); } else { sum = (s1 & 0xffff) | (s2 << 16); - if ((i = hash_table[BIG_SUM2HASH(sum)]) < 0) + hash_entry = BIG_SUM2HASH(sum); + if ((i = hash_table[hash_entry]) < 0) goto null_hash; } + prev = &hash_table[hash_entry]; hash_hits++; do { int32 l; + /* When updating in-place, the chunk's offset must be + * either >= our offset or identical data at that offset. + * Remove any bypassed entries that we can never use. */ + if (updating_basis_file && s->sums[i].offset < offset + && !(s->sums[i].flags & SUMFLG_SAME_OFFSET)) { + *prev = s->sums[i].chain; + continue; + } + prev = &s->sums[i].chain; + if (sum != s->sums[i].sum1) continue; @@ -206,21 +220,15 @@ static void hash_search(int f,struct sum_struct *s, if (l != s->sums[i].len) continue; - /* in-place: ensure chunk's offset is either >= our - * offset or that the data didn't move. */ - if (updating_basis_file && s->sums[i].offset < offset - && !(s->sums[i].flags & SUMFLG_SAME_OFFSET)) - continue; - - if (verbose > 3) { + if (DEBUG_GTE(DELTASUM, 3)) { rprintf(FINFO, - "potential match at %.0f i=%ld sum=%08x\n", - (double)offset, (long)i, sum); + "potential match at %s i=%ld sum=%08x\n", + big_num(offset), (long)i, sum); } if (!done_csum2) { map = (schar *)map_ptr(buf,offset,l); - get_checksum2((char *)map,l,sum2); + get_checksum2((char *)map, l, sum2, offset); done_csum2 = 1; } @@ -238,7 +246,9 @@ static void hash_search(int f,struct sum_struct *s, aligned_offset += s->blength; aligned_i++; } - if (offset == aligned_offset && aligned_i < s->count) { + if ((offset == aligned_offset + || (sum == 0 && l == s->blength && aligned_offset + l <= len)) + && aligned_i < s->count) { if (i != aligned_i) { if (sum != s->sums[aligned_i].sum1 || l != s->sums[aligned_i].len @@ -246,6 +256,27 @@ static void hash_search(int f,struct sum_struct *s, goto check_want_i; i = aligned_i; } + if (offset != aligned_offset) { + /* We've matched some zeros in a spot that is also zeros + * further along in the basis file, if we find zeros ahead + * in the sender's file, we'll output enough literal data + * to re-align with the basis file, and get back to seeking + * instead of writing. */ + backup = (int32)(aligned_offset - last_match); + if (backup < 0) + backup = 0; + map = (schar *)map_ptr(buf, aligned_offset - backup, l + backup) + + backup; + sum = get_checksum1((char *)map, l); + if (sum != s->sums[i].sum1) + goto check_want_i; + get_checksum2((char *)map, l, sum2, aligned_offset); + if (memcmp(sum2, s->sums[i].sum2, s->s2length) != 0) + goto check_want_i; + /* OK, we have a re-alignment match. Bump the offset + * forward to the new match point. */ + offset = aligned_offset; + } /* This identical chunk is in the same spot in the old and new file. */ s->sums[i].flags |= SUMFLG_SAME_OFFSET; want_i = i; @@ -256,10 +287,10 @@ static void hash_search(int f,struct sum_struct *s, /* we've found a match, but now check to see * if want_i can hint at a better match. */ if (i != want_i && want_i < s->count - && (!updating_basis_file || s->sums[want_i].offset >= offset - || s->sums[want_i].flags & SUMFLG_SAME_OFFSET) - && sum == s->sums[want_i].sum1 - && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) { + && (!updating_basis_file || s->sums[want_i].offset >= offset + || s->sums[want_i].flags & SUMFLG_SAME_OFFSET) + && sum == s->sums[want_i].sum1 + && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) { /* we've found an adjacent match - the RLL coder * will be happy */ i = want_i; @@ -285,8 +316,7 @@ static void hash_search(int f,struct sum_struct *s, /* Trim off the first byte from the checksum */ more = offset + k < len; - map = (schar *)map_ptr(buf, offset - backup, k + more + backup) - + backup; + map = (schar *)map_ptr(buf, offset - backup, k + more + backup) + backup; s1 -= map[0] + CHAR_OFFSET; s2 -= k * (map[0]+CHAR_OFFSET); @@ -307,6 +337,8 @@ static void hash_search(int f,struct sum_struct *s, matched(f, s, buf, offset - s->blength, -2); } while (++offset < end); + checksum2_disable_prefetch(); + matched(f, s, buf, len, -1); map_ptr(buf, len-1, 1); } @@ -328,7 +360,6 @@ static void hash_search(int f,struct sum_struct *s, **/ void match_sums(int f, struct sum_struct *s, struct map_struct *buf, OFF_T len) { - char file_sum[MAX_DIGEST_LEN]; int sum_len; last_match = 0; @@ -337,13 +368,13 @@ void match_sums(int f, struct sum_struct *s, struct ma matches = 0; data_transfer = 0; - sum_init(checksum_seed); + sum_init(xfersum_type, checksum_seed); if (append_mode > 0) { if (append_mode == 2) { OFF_T j = 0; for (j = CHUNK_SIZE; j < s->flength; j += CHUNK_SIZE) { - if (buf && do_progress) + if (buf && INFO_GTE(PROGRESS, 1)) show_progress(last_match, buf->file_size); sum_update(map_ptr(buf, last_match, CHUNK_SIZE), CHUNK_SIZE); @@ -351,7 +382,7 @@ void match_sums(int f, struct sum_struct *s, struct ma } if (last_match < s->flength) { int32 n = (int32)(s->flength - last_match); - if (buf && do_progress) + if (buf && INFO_GTE(PROGRESS, 1)) show_progress(last_match, buf->file_size); sum_update(map_ptr(buf, last_match, n), n); } @@ -363,12 +394,12 @@ void match_sums(int f, struct sum_struct *s, struct ma if (len > 0 && s->count > 0) { build_hash_table(s); - if (verbose > 2) + if (DEBUG_GTE(DELTASUM, 2)) rprintf(FINFO,"built hash table\n"); hash_search(f, s, buf, len); - if (verbose > 2) + if (DEBUG_GTE(DELTASUM, 2)) rprintf(FINFO,"done hash search\n"); } else { OFF_T j; @@ -378,18 +409,27 @@ void match_sums(int f, struct sum_struct *s, struct ma matched(f, s, buf, len, -1); } - sum_len = sum_end(file_sum); - /* If we had a read error, send a bad checksum. */ - if (buf && buf->status != 0) - file_sum[0]++; + sum_len = sum_end(sender_file_sum); - if (verbose > 2) + /* If we had a read error, send a bad checksum. We use all bits + * off as long as the checksum doesn't happen to be that, in + * which case we turn the last 0 bit into a 1. */ + if (buf && buf->status != 0) { + int i; + for (i = 0; i < sum_len && sender_file_sum[i] == 0; i++) {} + memset(sender_file_sum, 0, sum_len); + if (i == sum_len) + sender_file_sum[i-1]++; + } + + if (DEBUG_GTE(DELTASUM, 2)) rprintf(FINFO,"sending file_sum\n"); - write_buf(f, file_sum, sum_len); + write_buf(f, sender_file_sum, sum_len); - if (verbose > 2) + if (DEBUG_GTE(DELTASUM, 2)) { rprintf(FINFO, "false_alarms=%d hash_hits=%d matches=%d\n", false_alarms, hash_hits, matches); + } total_hash_hits += hash_hits; total_false_alarms += false_alarms; @@ -399,11 +439,11 @@ void match_sums(int f, struct sum_struct *s, struct ma void match_report(void) { - if (verbose <= 1) + if (!DEBUG_GTE(DELTASUM, 1)) return; rprintf(FINFO, - "total: matches=%d hash_hits=%d false_alarms=%d data=%.0f\n", + "total: matches=%d hash_hits=%d false_alarms=%d data=%s\n", total_matches, total_hash_hits, total_false_alarms, - (double)stats.literal_data); + big_num(stats.literal_data)); }