rt/snapraid
1
0
Fork 0
mirror of https://github.com/amadvance/snapraid.git synced 2026-10-26 02:49:02 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Make the hash size configurable

Browse source 
Only at source code level.
This commit is contained in:
Andrea Mazzoleni 2016-04-07 21:39:02 +02:00
parent 7c910af3f9
commit 5b06549ee3
16 changed files with 115 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

10
cmdline/check.c
View file

@ -69,7 +69,7 @@ struct failed_struct {
*/
static int blockcmp(struct snapraid_state* state, int rehash, struct snapraid_block* block, unsigned pos_size, unsigned char* buffer, unsigned char* buffer_zero)
{
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
/* now compute the hash of the valid part */
if (rehash) {
@ -79,7 +79,7 @@ static int blockcmp(struct snapraid_state* state, int rehash, struct snapraid_bl
}
/* compare the hash */
if (memcmp(hash, block->hash, HASH_SIZE) != 0) {
if (memcmp(hash, block->hash, BLOCK_HASH_SIZE) != 0) {
return -1;
}
@ -937,7 +937,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* for each disk, process the block */
for (j = 0; j < diskmax; ++j) {
int read_size;
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
struct snapraid_disk* disk;
struct snapraid_block* block;
struct snapraid_file* file;
@ -1166,8 +1166,8 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
}
/* compare the hash */
if (memcmp(hash, block->hash, HASH_SIZE) != 0) {
unsigned diff = memdiff(hash, block->hash, HASH_SIZE);
if (memcmp(hash, block->hash, BLOCK_HASH_SIZE) != 0) {
unsigned diff = memdiff(hash, block->hash, BLOCK_HASH_SIZE);
/* save the failed block for the check/fix */
failed[failed_count].is_bad = 1; /* it's bad because the hash doesn't match */

12
cmdline/dup.c
View file

@ -30,7 +30,7 @@
struct snapraid_hash {
struct snapraid_disk* disk; /**< Disk. */
struct snapraid_file* file; /**< File. */
unsigned char hash[HASH_SIZE]; /**< Hash of the whole file. */
unsigned char hash[HASH_MAX]; /**< Hash of the whole file. */
/* nodes for data structures */
tommy_hashdyn_node node;
@ -46,13 +46,13 @@ struct snapraid_hash* hash_alloc(struct snapraid_state* state, struct snapraid_d
hash->disk = disk;
hash->file = file;
buf = malloc_nofail(file->blockmax * HASH_SIZE);
buf = malloc_nofail(file->blockmax * BLOCK_HASH_SIZE);
/* set the back pointer */
for (i = 0; i < file->blockmax; ++i) {
struct snapraid_block* block = fs_file2block_get(file, i);
memcpy(buf + i * HASH_SIZE, block->hash, HASH_SIZE);
memcpy(buf + i * BLOCK_HASH_SIZE, block->hash, BLOCK_HASH_SIZE);
if (!block_has_updated_hash(block)) {
free(buf);
@ -61,7 +61,7 @@ struct snapraid_hash* hash_alloc(struct snapraid_state* state, struct snapraid_d
}
}
memhash(state->besthash, state->hashseed, hash->hash, buf, file->blockmax * HASH_SIZE);
memhash(state->besthash, state->hashseed, hash->hash, buf, file->blockmax * BLOCK_HASH_SIZE);
free(buf);
@ -70,7 +70,7 @@ struct snapraid_hash* hash_alloc(struct snapraid_state* state, struct snapraid_d
static inline tommy_uint32_t hash_hash(struct snapraid_hash* hash)
{
return tommy_hash_u32(0, hash->hash, HASH_SIZE);
return tommy_hash_u32(0, hash->hash, HASH_MAX);
}
void hash_free(struct snapraid_hash* hash)
@ -83,7 +83,7 @@ int hash_compare(const void* void_arg, const void* void_data)
const char* arg = void_arg;
const struct snapraid_hash* hash = void_data;
return memcmp(arg, hash->hash, HASH_SIZE);
return memcmp(arg, hash->hash, HASH_MAX);
}
void state_dup(struct snapraid_state* state)

23
cmdline/elem.c
View file

@ -24,6 +24,8 @@
/****************************************************************************/
/* snapraid */
int BLOCK_HASH_SIZE = HASH_MAX;
struct snapraid_content* content_alloc(const char* path, uint64_t dev)
{
struct snapraid_content* content;
@ -369,11 +371,12 @@ struct snapraid_file* file_alloc(unsigned block_size, const char* sub, data_off_
file->inode = inode;
file->physical = physical;
file->flag = 0;
file->blockvec = malloc_nofail(file->blockmax * sizeof(struct snapraid_block));
file->blockvec = malloc_nofail(file->blockmax * block_sizeof());
for (i = 0; i < file->blockmax; ++i) {
block_state_set(&file->blockvec[i], BLOCK_STATE_CHG);
hash_invalid_set(file->blockvec[i].hash);
struct snapraid_block* block = file_block(file, i);
block_state_set(block, BLOCK_STATE_CHG);
hash_invalid_set(block->hash);
}
return file;
@ -393,11 +396,13 @@ struct snapraid_file* file_dup(struct snapraid_file* copy)
file->inode = copy->inode;
file->physical = copy->physical;
file->flag = copy->flag;
file->blockvec = malloc_nofail(file->blockmax * sizeof(struct snapraid_block));
file->blockvec = malloc_nofail(file->blockmax * block_sizeof());
for (i = 0; i < file->blockmax; ++i) {
file->blockvec[i].state = copy->blockvec[i].state;
memcpy(file->blockvec[i].hash, copy->blockvec[i].hash, HASH_SIZE);
struct snapraid_block* block = file_block(file, i);
struct snapraid_block* copy_block = file_block(copy, i);
block->state = copy_block->state;
memcpy(block->hash, copy_block->hash, BLOCK_HASH_SIZE);
}
return file;
@ -445,10 +450,10 @@ void file_copy(struct snapraid_file* src_file, struct snapraid_file* dst_file)
for (i = 0; i < dst_file->blockmax; ++i) {
/* set a block with hash computed but without parity */
block_state_set(&dst_file->blockvec[i], BLOCK_STATE_REP);
block_state_set(file_block(dst_file, i), BLOCK_STATE_REP);
/* copy the hash */
memcpy(dst_file->blockvec[i].hash, src_file->blockvec[i].hash, HASH_SIZE);
memcpy(file_block(dst_file, i)->hash, file_block(src_file, i)->hash, BLOCK_HASH_SIZE);
}
file_flag_set(dst_file, FILE_IS_COPY);
@ -1363,7 +1368,7 @@ struct snapraid_block* fs_file2block_get(struct snapraid_file* file, block_off_t
/* LCOV_EXCL_STOP */
}
return &file->blockvec[file_pos];
return file_block(file, file_pos);
}
struct snapraid_block* fs_par2block_find(struct snapraid_disk* disk, block_off_t parity_pos)

47
cmdline/elem.h
View file

@ -164,12 +164,25 @@ struct snapraid_filter {
*/
#define BLOCK_STATE_DELETED 4
/**
* Block hash size.
*
* At max HASH_MAX.
*/
extern int BLOCK_HASH_SIZE;
/**
* Block of a file.
*/
struct snapraid_block {
unsigned char hash[HASH_SIZE]; /**< Hash of the block. */
unsigned char state; /**< State of the block. */
/**
* Hash of the block.
*
* The effective stored size is BLOCK_HASH_SIZE.
*/
unsigned char hash[HASH_MAX];
};
/**
@ -526,9 +539,9 @@ int filter_content(tommy_list* contentlist, const char* path);
*/
static inline int hash_is_invalid(const unsigned char* hash)
{
unsigned i;
int i;
for (i = 0; i < HASH_SIZE; ++i)
for (i = 0; i < BLOCK_HASH_SIZE; ++i)
if (hash[i] != 0x00)
return 0;
@ -542,9 +555,9 @@ static inline int hash_is_invalid(const unsigned char* hash)
*/
static inline int hash_is_zero(const unsigned char* hash)
{
unsigned i;
int i;
for (i = 0; i < HASH_SIZE; ++i)
for (i = 0; i < BLOCK_HASH_SIZE; ++i)
if (hash[i] != 0xFF)
return 0;
@ -564,7 +577,7 @@ static inline int hash_is_real(const unsigned char* hash)
*/
static inline void hash_invalid_set(unsigned char* hash)
{
memset(hash, 0x00, HASH_SIZE);
memset(hash, 0x00, BLOCK_HASH_SIZE);
}
/**
@ -572,7 +585,15 @@ static inline void hash_invalid_set(unsigned char* hash)
*/
static inline void hash_zero_set(unsigned char* hash)
{
memset(hash, 0xFF, HASH_SIZE);
memset(hash, 0xFF, BLOCK_HASH_SIZE);
}
/**
* Allocated space for block.
*/
static inline size_t block_sizeof(void)
{
return 1 + BLOCK_HASH_SIZE;
}
/**
@ -700,6 +721,18 @@ void file_rename(struct snapraid_file* file, const char* sub);
*/
void file_copy(struct snapraid_file* src_file, struct snapraid_file* dest_file);
/**
* Return the block at the specified position.
*
* Note that the block size if a runtime value.
*/
static inline struct snapraid_block* file_block(struct snapraid_file* file, size_t pos)
{
unsigned char* ptr = (unsigned char*)file->blockvec;
return (struct snapraid_block*)(ptr + pos * block_sizeof());
}
/**
* Return the name of the file, without the dir.
*/

8
cmdline/import.c
View file

@ -31,7 +31,7 @@ int import_block_hash_compare(const void* void_arg, const void* void_data)
const unsigned char* arg = void_arg;
const struct snapraid_import_block* block = void_data;
return memcmp(arg, block->hash, HASH_SIZE);
return memcmp(arg, block->hash, BLOCK_HASH_SIZE);
}
int import_block_prevhash_compare(const void* void_arg, const void* void_data)
@ -39,7 +39,7 @@ int import_block_prevhash_compare(const void* void_arg, const void* void_data)
const unsigned char* arg = void_arg;
const struct snapraid_import_block* block = void_data;
return memcmp(arg, block->prevhash, HASH_SIZE);
return memcmp(arg, block->prevhash, BLOCK_HASH_SIZE);
}
/**
@ -158,7 +158,7 @@ int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid
const unsigned char* hash = missing_block->hash;
unsigned block_size = state->block_size;
unsigned read_size;
unsigned char buffer_hash[HASH_SIZE];
unsigned char buffer_hash[HASH_MAX];
const char* path;
if (rehash) {
@ -212,7 +212,7 @@ int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid
else
memhash(state->hash, state->hashseed, buffer_hash, buffer, read_size);
if (memcmp(buffer_hash, hash, HASH_SIZE) != 0) {
if (memcmp(buffer_hash, hash, BLOCK_HASH_SIZE) != 0) {
/* LCOV_EXCL_START */
log_fatal("Error in data reading file '%s'.\n", path);
log_fatal("Please don't change imported files while running.\n");

4
cmdline/import.h
View file

@ -32,8 +32,8 @@ struct snapraid_import_block {
struct snapraid_import_file* file; /**< Back pointer to the file owning this block. */
unsigned size; /**< Size of the block. */
data_off_t offset; /**< Position of the block in the file. */
unsigned char hash[HASH_SIZE]; /**< Hash of the block. */
unsigned char prevhash[HASH_SIZE]; /**< Previous hash of the block. Valid only if we are in rehash state. */
unsigned char hash[HASH_MAX]; /**< Hash of the block. */
unsigned char prevhash[HASH_MAX]; /**< Previous hash of the block. Valid only if we are in rehash state. */
/* nodes for data structures */
tommy_hashdyn_node nodeset;

4
cmdline/rehash.c
View file

@ -52,11 +52,11 @@ void state_rehash(struct snapraid_state* state)
/* copy the present hash as previous one */
state->prevhash = state->hash;
memcpy(state->prevhashseed, state->hashseed, HASH_SIZE);
memcpy(state->prevhashseed, state->hashseed, HASH_MAX);
/* set the new hash and seed */
state->hash = state->besthash;
if (randomize(state->hashseed, HASH_SIZE) != 0) {
if (randomize(state->hashseed, HASH_MAX) != 0) {
/* LCOV_EXCL_START */
log_fatal("Failed to get random values.\n");
exit(EXIT_FAILURE);

2
cmdline/scan.c
View file

@ -220,7 +220,7 @@ static void scan_file_allocate(struct snapraid_scan* scan, struct snapraid_file*
assert(over_state == BLOCK_STATE_DELETED);
/* copy the past hash of the block */
memcpy(block->hash, over_block->hash, HASH_SIZE);
memcpy(block->hash, over_block->hash, BLOCK_HASH_SIZE);
/* if we have not already cleared the past hash */
if (!state->clear_past_hash) {

10
cmdline/scrub.c
View file

@ -32,7 +32,7 @@
* Buffer for storing the new hashes.
*/
struct snapraid_rehash {
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
struct snapraid_block* block;
};
@ -357,7 +357,7 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par
for (j = 0; j < diskmax; ++j) {
struct snapraid_task* task;
int read_size;
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
struct snapraid_block* block;
int file_is_unsynced;
struct snapraid_disk* disk;
@ -466,8 +466,8 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par
if (block_has_updated_hash(block)) {
/* compare the hash */
if (memcmp(hash, block->hash, HASH_SIZE) != 0) {
unsigned diff = memdiff(hash, block->hash, HASH_SIZE);
if (memcmp(hash, block->hash, BLOCK_HASH_SIZE) != 0) {
unsigned diff = memdiff(hash, block->hash, BLOCK_HASH_SIZE);
log_tag("error:%u:%s:%s: Data error at position %u, diff bits %u\n", blockcur, disk->name, esc(file->sub, esc_buffer), file_pos, diff);
@ -588,7 +588,7 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par
/* store all the new hash already computed */
for (j = 0; j < diskmax; ++j) {
if (rehandle[j].block)
memcpy(rehandle[j].block->hash, rehandle[j].hash, HASH_SIZE);
memcpy(rehandle[j].block->hash, rehandle[j].hash, BLOCK_HASH_SIZE);
}
}

4
cmdline/search.c
View file

@ -60,7 +60,7 @@ int search_file_compare(const void* void_arg, const void* void_data)
const struct search_file_compare_arg* arg = void_arg;
const struct snapraid_search_file* file = void_data;
const struct snapraid_state* state = arg->state;
unsigned char buffer_hash[HASH_SIZE];
unsigned char buffer_hash[HASH_MAX];
const char* path = file->path;
int f;
ssize_t ret;
@ -112,7 +112,7 @@ int search_file_compare(const void* void_arg, const void* void_data)
memhash(state->hash, state->hashseed, buffer_hash, arg->buffer, arg->read_size);
/* check if the hash is matching */
if (memcmp(buffer_hash, arg->block->hash, HASH_SIZE) != 0)
if (memcmp(buffer_hash, arg->block->hash, BLOCK_HASH_SIZE) != 0)
return -1;
if (arg->read_size != state->block_size) {

12
cmdline/selftest.c
View file

@ -48,7 +48,7 @@ struct hash64_test_vector {
struct hash_test_vector {
const char* data;
int len;
unsigned char digest[HASH_SIZE];
unsigned char digest[HASH_MAX];
};
/**
@ -131,7 +131,7 @@ static void test_hash(void)
uint32_t seed32;
uint64_t seed64;
seed_aligned = malloc_nofail_align(HASH_SIZE, &seed_alloc);
seed_aligned = malloc_nofail_align(HASH_MAX, &seed_alloc);
buffer_aligned = malloc_nofail_align(HASH_TEST_MAX, &buffer_alloc);
seed32 = 0xa766795d;
@ -180,10 +180,10 @@ static void test_hash(void)
for (i = 0; TEST_MURMUR3[i].data; ++i) {
unsigned char digest[HASH_SIZE];
unsigned char digest[HASH_MAX];
memcpy(buffer_aligned, TEST_MURMUR3[i].data, TEST_MURMUR3[i].len);
memhash(HASH_MURMUR3, seed_aligned, digest, buffer_aligned, TEST_MURMUR3[i].len);
if (memcmp(digest, TEST_MURMUR3[i].digest, HASH_SIZE) != 0) {
if (memcmp(digest, TEST_MURMUR3[i].digest, HASH_MAX) != 0) {
/* LCOV_EXCL_START */
log_fatal("Failed Murmur3 test\n");
exit(EXIT_FAILURE);
@ -192,10 +192,10 @@ static void test_hash(void)
}
for (i = 0; TEST_SPOOKY2[i].data; ++i) {
unsigned char digest[HASH_SIZE];
unsigned char digest[HASH_MAX];
memcpy(buffer_aligned, TEST_SPOOKY2[i].data, TEST_SPOOKY2[i].len);
memhash(HASH_SPOOKY2, seed_aligned, digest, buffer_aligned, TEST_SPOOKY2[i].len);
if (memcmp(digest, TEST_SPOOKY2[i].digest, HASH_SIZE) != 0) {
if (memcmp(digest, TEST_SPOOKY2[i].digest, HASH_MAX) != 0) {
/* LCOV_EXCL_START */
log_fatal("Failed Spooky2 test\n");
exit(EXIT_FAILURE);

6
cmdline/speed.c
View file

@ -82,8 +82,8 @@ void speed(int period)
int64_t ds;
int64_t dt;
int i, j;
unsigned char digest[HASH_SIZE];
unsigned char seed[HASH_SIZE];
unsigned char digest[HASH_MAX];
unsigned char seed[HASH_MAX];
int id[RAID_PARITY_MAX];
int ip[RAID_PARITY_MAX];
int count;
@ -107,7 +107,7 @@ void speed(int period)
raid_zero(v[nd + RAID_PARITY_MAX]);
/* hash seed */
for (i = 0; i < HASH_SIZE; ++i)
for (i = 0; i < HASH_MAX; ++i)
seed[i] = i;
/* basic disks and parity mapping */

20
cmdline/state.c
View file

@ -1150,7 +1150,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co
state->hash = state->besthash;
/* by default use a random hash seed */
if (randomize(state->hashseed, HASH_SIZE) != 0) {
if (randomize(state->hashseed, HASH_MAX) != 0) {
/* LCOV_EXCL_START */
log_fatal("Failed to get random values.\n");
exit(EXIT_FAILURE);
@ -1904,7 +1904,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
/* read the hash only for 'blk/chg/rep', and not for 'new' */
if (c != 'n') {
ret = sread(f, block->hash, HASH_SIZE);
ret = sread(f, block->hash, BLOCK_HASH_SIZE);
if (ret < 0) {
/* LCOV_EXCL_START */
decoding_error(path, f);
@ -2123,7 +2123,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
block_state_set(block, BLOCK_STATE_DELETED);
/* read the hash */
ret = sread(f, block->hash, HASH_SIZE);
ret = sread(f, block->hash, BLOCK_HASH_SIZE);
if (ret < 0) {
/* LCOV_EXCL_START */
decoding_error(path, f);
@ -2330,7 +2330,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
}
/* read the seed */
ret = sread(f, state->hashseed, HASH_SIZE);
ret = sread(f, state->hashseed, HASH_MAX);
if (ret < 0) {
/* LCOV_EXCL_START */
decoding_error(path, f);
@ -2357,7 +2357,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
}
/* read the seed */
ret = sread(f, state->prevhashseed, HASH_SIZE);
ret = sread(f, state->prevhashseed, HASH_MAX);
if (ret < 0) {
/* LCOV_EXCL_START */
decoding_error(path, f);
@ -2683,7 +2683,7 @@ static void* state_write_thread(void* arg)
return context;
/* LCOV_EXCL_STOP */
}
swrite(state->hashseed, HASH_SIZE, f);
swrite(state->hashseed, HASH_MAX, f);
if (serror(f)) {
/* LCOV_EXCL_START */
log_fatal("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno));
@ -2706,7 +2706,7 @@ static void* state_write_thread(void* arg)
return context;
/* LCOV_EXCL_STOP */
}
swrite(state->prevhashseed, HASH_SIZE, f);
swrite(state->prevhashseed, HASH_MAX, f);
if (serror(f)) {
/* LCOV_EXCL_START */
log_fatal("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno));
@ -2847,7 +2847,7 @@ static void* state_write_thread(void* arg)
for (idx = begin; idx < end; ++idx) {
struct snapraid_block* block = fs_file2block_get(file, idx);
swrite(block->hash, HASH_SIZE, f);
swrite(block->hash, BLOCK_HASH_SIZE, f);
}
if (serror(f)) {
@ -2941,7 +2941,7 @@ static void* state_write_thread(void* arg)
while (begin < end) {
struct snapraid_block* block = fs_par2block_get(disk, begin);
swrite(block->hash, HASH_SIZE, f);
swrite(block->hash, BLOCK_HASH_SIZE, f);
++begin;
}
@ -3457,7 +3457,7 @@ void state_read(struct snapraid_state* state)
state->hash = HASH_UNDEFINED;
/* start with a zero seed, it was the default in old versions */
memset(state->hashseed, 0, HASH_SIZE);
memset(state->hashseed, 0, HASH_MAX);
/* previous hash, start with an undefined value */
state->prevhash = HASH_UNDEFINED;

4
cmdline/state.h
View file

@ -134,8 +134,8 @@ struct snapraid_state {
char share[PATH_MAX]; /**< Path of the share tree. If !=0 pool links are created in a different way. */
char pool[PATH_MAX]; /**< Path of the pool tree. */
uint64_t pool_device; /**< Device identifier of the pool. */
unsigned char hashseed[HASH_SIZE]; /**< Hash seed. Just after a uint64 to provide a minimal alignment. */
unsigned char prevhashseed[HASH_SIZE]; /**< Previous hash seed. In case of rehash. */
unsigned char hashseed[HASH_MAX]; /**< Hash seed. Just after a uint64 to provide a minimal alignment. */
unsigned char prevhashseed[HASH_MAX]; /**< Previous hash seed. In case of rehash. */
char lockfile[PATH_MAX]; /**< Path of the lock file to use. */
unsigned level; /**< Number of parity levels. 1 for PAR1, 2 for PAR2. */
unsigned hash; /**< Hash kind used. */

24
cmdline/sync.c
View file

@ -103,7 +103,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
int rehash;
struct snapraid_block* block;
int read_size;
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
unsigned block_state;
struct snapraid_file* file;
block_off_t file_pos;
@ -262,7 +262,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
if (block_state == BLOCK_STATE_REP) {
/* compare the hash */
if (memcmp(hash, block->hash, HASH_SIZE) != 0) {
if (memcmp(hash, block->hash, BLOCK_HASH_SIZE) != 0) {
log_tag("error:%u:%s:%s: Unexpected data change\n", i, disk->name, esc(file->sub, esc_buffer));
log_error("Data change at file '%s' at position '%u'\n", handle[j].path, file_pos);
log_error("WARNING! Unexpected data modification of a file without parity!\n");
@ -288,7 +288,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
assert(block_state == BLOCK_STATE_CHG);
/* copy the hash in the block */
memcpy(block->hash, hash, HASH_SIZE);
memcpy(block->hash, hash, BLOCK_HASH_SIZE);
/* and mark the block as hashed */
block_state_set(block, BLOCK_STATE_REP);
@ -430,7 +430,7 @@ int failed_compare_by_index(const void* void_a, const void* void_b)
* Buffer for storing the new hashes.
*/
struct snapraid_rehash {
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
struct snapraid_block* block;
};
@ -820,7 +820,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
for (j = 0; j < diskmax; ++j) {
struct snapraid_task* task;
int read_size;
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
struct snapraid_block* block;
unsigned block_state;
struct snapraid_disk* disk;
@ -933,7 +933,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
if (block_has_updated_hash(block)) {
/* compare the hash */
if (memcmp(hash, block->hash, HASH_SIZE) != 0) {
if (memcmp(hash, block->hash, BLOCK_HASH_SIZE) != 0) {
/* if the file has invalid parity, it's a REP changed during the sync */
if (block_has_invalid_parity(block)) {
log_tag("error:%u:%s:%s: Unexpected data change\n", blockcur, disk->name, esc(file->sub, esc_buffer));
@ -956,7 +956,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
error_on_this_block = 1;
continue;
} else { /* otherwise it's a BLK with silent error */
unsigned diff = memdiff(hash, block->hash, HASH_SIZE);
unsigned diff = memdiff(hash, block->hash, BLOCK_HASH_SIZE);
log_tag("error:%u:%s:%s: Data error at position %u, diff bits %u\n", blockcur, disk->name, esc(file->sub, esc_buffer), file_pos, diff);
log_error("Data error in file '%s' at position '%u', diff bits %u\n", task->path, file_pos, diff);
@ -985,7 +985,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
/* if there is an hash */
if (hash_is_real(block->hash)) {
/* check if the hash is changed */
if (memcmp(hash, block->hash, HASH_SIZE) != 0) {
if (memcmp(hash, block->hash, BLOCK_HASH_SIZE) != 0) {
/* the block is different, and we must update parity */
parity_needs_to_be_updated = 1;
}
@ -997,7 +997,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
/* copy the hash in the block, but doesn't mark the block as hashed */
/* this allow in case of skipped block to do not save the failed computation */
memcpy(block->hash, hash, HASH_SIZE);
memcpy(block->hash, hash, BLOCK_HASH_SIZE);
/* note that in case of rehash, this is the wrong hash, */
/* but it will be overwritten later */
@ -1101,7 +1101,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
/* check the result and prepare the data */
for (j = 0; j < failed_count; ++j) {
unsigned char hash[HASH_SIZE];
unsigned char hash[HASH_MAX];
unsigned char* block_buffer = buffer[failed[j].index];
unsigned char* block_copy = copy[failed[j].index];
unsigned block_state = block_state_get(failed[j].block);
@ -1120,7 +1120,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
state_usage_hash(state);
/* if the hash doesn't match */
if (memcmp(hash, failed[j].block->hash, HASH_SIZE) != 0) {
if (memcmp(hash, failed[j].block->hash, BLOCK_HASH_SIZE) != 0) {
/* we have not recovered */
break;
}
@ -1197,7 +1197,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
/* store all the new hash already computed */
for (j = 0; j < diskmax; ++j) {
if (rehandle[j].block)
memcpy(rehandle[j].block->hash, rehandle[j].hash, HASH_SIZE);
memcpy(rehandle[j].block->hash, rehandle[j].hash, BLOCK_HASH_SIZE);
}
}

3
cmdline/util.h
View file

@ -169,8 +169,7 @@ void crc32c_init(void);
/**
* Size of the hash.
*/
#define HASH_SIZE 16
#define HASH_MAX 16
/**
* Hash kinds.