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

Switch esc_tag and path formatting to a contiguous thread-local circular pool to eliminate stack bloat
Some checks failed
Build / build-mac (push) Has been cancelled
Details
Build / build-linux (push) Has been cancelled
Details
Build / build-win (push) Has been cancelled
Details
CodeQL Advanced / Analyze (c-cpp) (push) Has been cancelled
Details
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
Details

Browse source
This commit is contained in:
Andrea Mazzoleni 2026-05-29 11:01:44 +02:00
parent aee71ad2d6
commit 96e20b3912
21 changed files with 283 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

137
cmdline/check.c
View file

@ -293,8 +293,6 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign
int n;
int something_to_recover;
int something_unsynced;
char esc_buffer[ESC_MAX];
error = 0;
/* if nothing failed, just recompute the parity */
@ -339,7 +337,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign
struct snapraid_file* file = failed[j].file;
block_off_t file_pos = failed[j].file_pos;
log_tag("repair_entry:%u:%s:%s:%s:%s:%s:%u:\n", j, desc, hash, data, disk->name, esc_tag(file->sub, esc_buffer), file_pos);
log_tag("repair_entry:%u:%s:%s:%s:%s:%s:%u:\n", j, desc, hash, data, disk->name, esc_tag(file->sub), file_pos);
} else {
log_tag("repair_entry:%u:%s:%s:%s:\n", j, desc, hash, data);
}
@ -601,9 +599,6 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
{
unsigned j;
int ret;
char esc_buffer[ESC_MAX];
char esc_buffer_alt[ESC_MAX];
/* for all the files print the final status, and do the final time fix */
/* we also ensure to close files after processing the last block */
for (j = 0; j < diskmax; ++j) {
@ -661,7 +656,7 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
ret = handle_close(&handle[j]);
if (ret != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
return -1;
/* LCOV_EXCL_STOP */
@ -672,14 +667,14 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error renaming '%s%s'. %s.\n", disk->dir, file->sub, strerror(errno));
log_tag("%s:%u:%s:%s: Rename error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Rename error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
return -1;
/* LCOV_EXCL_STOP */
}
log_tag("status:unrecoverable:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
msg_info("unrecoverable %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("status:unrecoverable:%s:%s\n", disk->name, esc_tag(file->sub));
msg_info("unrecoverable %s\n", fmt_term(disk, file->sub));
/* and do not set the time if damaged */
goto close_and_continue;
@ -699,7 +694,7 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
ret = handle_close(&handle[j]);
if (ret != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
return -1;
/* LCOV_EXCL_STOP */
@ -710,15 +705,15 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
ret = handle_open(&handle[j], file, state->file_mode, log_error, log_error); /* output a message for missing files */
if (ret != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
return -1;
/* LCOV_EXCL_STOP */
}
}
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
msg_info("recovered %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(file->sub));
msg_info("recovered %s\n", fmt_term(disk, file->sub));
inode = handle[j].st.st_ino;
@ -743,7 +738,7 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
ret = handle_utime(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Time error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Time error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
/* mark the file as damaged */
@ -752,22 +747,22 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s
/* LCOV_EXCL_STOP */
}
} else {
log_tag("collision:%s:%s:%s: Not setting modification time to avoid inode collision\n", disk->name, esc_tag(file->sub, esc_buffer), esc_tag(collide_file->sub, esc_buffer_alt));
log_tag("collision:%s:%s:%s: Not setting modification time to avoid inode collision\n", disk->name, esc_tag(file->sub), esc_tag(collide_file->sub));
}
} else {
/* we are not fixing, but only checking */
/* print just the final status */
if (file_flag_has(file, FILE_IS_DAMAGED)) {
log_tag("status:unrecoverable:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
msg_info("unrecoverable %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("status:unrecoverable:%s:%s\n", disk->name, esc_tag(file->sub));
msg_info("unrecoverable %s\n", fmt_term(disk, file->sub));
} else if (file_flag_has(file, FILE_IS_FIXED)) {
log_tag("status:recoverable:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
msg_info("recoverable %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("status:recoverable:%s:%s\n", disk->name, esc_tag(file->sub));
msg_info("recoverable %s\n", fmt_term(disk, file->sub));
} else {
/* we don't use msg_verbose() because it also goes into the log */
if (msg_level >= MSG_VERBOSE) {
log_tag("status:correct:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
msg_info("correct %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("status:correct:%s:%s\n", disk->name, esc_tag(file->sub));
msg_info("correct %s\n", fmt_term(disk, file->sub));
}
}
}
@ -782,7 +777,7 @@ close_and_continue:
ret = handle_close(&handle[j]);
if (ret != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
return -1;
/* LCOV_EXCL_STOP */
@ -887,8 +882,6 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
struct failed_struct* failed;
unsigned* failed_map;
unsigned l;
char esc_buffer[ESC_MAX];
char esc_buffer_alt[ESC_MAX];
bit_vect_t* block_enabled;
struct snapraid_bw bw;
@ -1062,7 +1055,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
ret = handle_close(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", i);
@ -1077,7 +1070,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
ret = handle_create(&handle[j], file, state->file_mode);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Create error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Create error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", i);
@ -1112,7 +1105,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
failed[failed_count].handle = &handle[j];
++failed_count;
log_tag("%s:%u:%s:%s: Open error at position %u. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), file_pos, strerror(errno));
log_tag("%s:%u:%s:%s: Open error at position %u. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), file_pos, strerror(errno));
if (is_hw(errno)) {
++io_error;
@ -1150,14 +1143,14 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
&& handle[j].st.st_size > file->size
) {
log_error(ESOFT, "File '%s' is larger than expected.\n", handle[j].path);
log_tag("error:%u:%s:%s: Size error\n", i, disk->name, esc_tag(file->sub, esc_buffer));
log_tag("error:%u:%s:%s: Size error\n", i, disk->name, esc_tag(file->sub));
++soft_error;
if (fix) {
ret = handle_truncate(&handle[j], file);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Truncate error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Truncate error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", i);
@ -1166,7 +1159,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* LCOV_EXCL_STOP */
}
log_tag("fixed:%u:%s:%s: Fixed size\n", i, disk->name, esc_tag(file->sub, esc_buffer));
log_tag("fixed:%u:%s:%s: Fixed size\n", i, disk->name, esc_tag(file->sub));
++recovered_error;
}
}
@ -1197,7 +1190,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
failed[failed_count].handle = &handle[j];
++failed_count;
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), file_pos, strerror(errno));
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), file_pos, strerror(errno));
if (is_hw(errno)) {
++io_error;
@ -1256,7 +1249,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
failed[failed_count].handle = &handle[j];
++failed_count;
log_tag("error:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", i, disk->name, esc_tag(file->sub, esc_buffer), file_pos, diff, BLOCK_HASH_SIZE * 8);
log_tag("error:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", i, disk->name, esc_tag(file->sub), file_pos, diff, BLOCK_HASH_SIZE * 8);
++silent_error;
continue;
}
@ -1323,7 +1316,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* print a list of all the errors in files */
for (j = 0; j < failed_count; ++j) {
if (failed[j].is_bad)
log_tag("unrecoverable:%u:%s:%s: Unrecoverable error at position %u\n", i, failed[j].disk->name, esc_tag(failed[j].file->sub, esc_buffer), failed[j].file_pos);
log_tag("unrecoverable:%u:%s:%s: Unrecoverable error at position %u\n", i, failed[j].disk->name, esc_tag(failed[j].file->sub), failed[j].file_pos);
}
/* keep track of damaged files */
@ -1341,7 +1334,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
for (j = 0; j < failed_count; ++j) {
if (failed[j].is_bad && failed[j].is_outofdate) {
++partial_recover_error;
log_tag("unrecoverable:%u:%s:%s: Unrecoverable unsynced error at position %u\n", i, failed[j].disk->name, esc_tag(failed[j].file->sub, esc_buffer), failed[j].file_pos);
log_tag("unrecoverable:%u:%s:%s: Unrecoverable unsynced error at position %u\n", i, failed[j].disk->name, esc_tag(failed[j].file->sub), failed[j].file_pos);
}
}
if (partial_recover_error != 0) {
@ -1389,7 +1382,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
ret = handle_write(failed[j].handle, failed[j].file_pos, buffer[failed[j].index], state->block_size);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Write error. %s.\n", es(errno), i, failed[j].disk->name, esc_tag(failed[j].file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Write error. %s.\n", es(errno), i, failed[j].disk->name, esc_tag(failed[j].file->sub), strerror(errno));
log_fatal_errno(errno, failed[j].disk->name);
log_fatal(errno, "Stopping at block %u\n", i);
@ -1412,7 +1405,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* note that it could be also marked as damaged in other iterations */
file_flag_set(failed[j].file, FILE_IS_FIXED);
log_tag("fixed:%u:%s:%s: Fixed data error at position %u\n", i, failed[j].disk->name, esc_tag(failed[j].file->sub, esc_buffer), failed[j].file_pos);
log_tag("fixed:%u:%s:%s: Fixed data error at position %u\n", i, failed[j].disk->name, esc_tag(failed[j].file->sub), failed[j].file_pos);
++recovered_error;
}
@ -1547,7 +1540,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(errno, "Error stating empty file '%s'. %s.\n", path, strerror(errno));
log_tag("empty_%s:%s:%s: Empty file stat error\n", es(errno), disk->name, esc_tag(file->sub, esc_buffer));
log_tag("empty_%s:%s:%s: Empty file stat error\n", es(errno), disk->name, esc_tag(file->sub));
if (is_hw(errno)) {
++io_error;
@ -1558,13 +1551,13 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(ESOFT, "Error stating empty file '%s' for not regular file.\n", path);
log_tag("empty_error:%s:%s: Empty file error for not regular file\n", disk->name, esc_tag(file->sub, esc_buffer));
log_tag("empty_error:%s:%s: Empty file error for not regular file\n", disk->name, esc_tag(file->sub));
++soft_error;
} else if (st.st_size != 0) {
unsuccessful = 1;
log_error(ESOFT, "Error stating empty file '%s' for not empty file.\n", path);
log_tag("empty_error:%s:%s: Empty file error for size '%" PRIu64 "'\n", disk->name, esc_tag(file->sub, esc_buffer), (uint64_t)st.st_size);
log_tag("empty_error:%s:%s: Empty file error for size '%" PRIu64 "'\n", disk->name, esc_tag(file->sub), (uint64_t)st.st_size);
++soft_error;
}
@ -1576,7 +1569,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error creating ancestor '%s%s'. %s.\n", disk->dir, file->sub, strerror(errno));
log_tag("empty_%s:%u:%s:%s: Create ancestor error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("empty_%s:%u:%s:%s: Create ancestor error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1591,7 +1584,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (f == -1) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error creating '%s%s'. %s.\n", disk->dir, file->sub, strerror(errno));
log_tag("empty_%s:%u:%s:%s: Create error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("empty_%s:%u:%s:%s: Create error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1605,7 +1598,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error timing '%s%s'. %s.\n", disk->dir, file->sub, strerror(errno));
log_tag("empty_%s:%u:%s:%s: Time error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("empty_%s:%u:%s:%s: Time error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1621,7 +1614,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error closing '%s%s'. %s.\n", disk->dir, file->sub, strerror(errno));
log_tag("empty_%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("empty_%s:%u:%s:%s: Close error. %s.\n", es(errno), i, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1630,11 +1623,11 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* LCOV_EXCL_STOP */
}
log_tag("empty_fixed:%s:%s: Fixed empty file\n", disk->name, esc_tag(file->sub, esc_buffer));
log_tag("empty_fixed:%s:%s: Fixed empty file\n", disk->name, esc_tag(file->sub));
++recovered_error;
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
msg_info("recovered %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(file->sub));
msg_info("recovered %s\n", fmt_term(disk, file->sub));
}
}
@ -1667,7 +1660,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(errno, "Error stating hardlink '%s'. %s.\n", path, strerror(errno));
log_tag("hardlink_%s:%s:%s:%s: Hardlink stat error. %s.\n", es(errno), disk->name, esc_tag(slink->sub, esc_buffer), esc_tag(slink->linkto, esc_buffer_alt), strerror(errno));
log_tag("hardlink_%s:%s:%s:%s: Hardlink stat error. %s.\n", es(errno), disk->name, esc_tag(slink->sub), esc_tag(slink->linkto), strerror(errno));
if (is_hw(errno)) {
++io_error;
@ -1678,7 +1671,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(ESOFT, "Error stating hardlink '%s' for not regular file.\n", path);
log_tag("hardlink_error:%s:%s:%s: Hardlink error for not regular file\n", disk->name, esc_tag(slink->sub, esc_buffer), esc_tag(slink->linkto, esc_buffer_alt));
log_tag("hardlink_error:%s:%s:%s: Hardlink error for not regular file\n", disk->name, esc_tag(slink->sub), esc_tag(slink->linkto));
++soft_error;
}
@ -1701,7 +1694,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
}
log_error(errno, "Error stating hardlink-to '%s'. %s.\n", pathto, strerror(errno));
log_tag("hardlink_%s:%s:%s:%s: Hardlink to stat error. %s.\n", es(errno), disk->name, esc_tag(slink->sub, esc_buffer), esc_tag(slink->linkto, esc_buffer_alt), strerror(errno));
log_tag("hardlink_%s:%s:%s:%s: Hardlink to stat error. %s.\n", es(errno), disk->name, esc_tag(slink->sub), esc_tag(slink->linkto), strerror(errno));
if (is_hw(errno)) {
++io_error;
@ -1712,13 +1705,13 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(ESOFT, "Error stating hardlink-to '%s' for not regular file.\n", path);
log_tag("hardlink_error:%s:%s:%s: Hardlink-to error for not regular file\n", disk->name, esc_tag(slink->sub, esc_buffer), esc_tag(slink->linkto, esc_buffer_alt));
log_tag("hardlink_error:%s:%s:%s: Hardlink-to error for not regular file\n", disk->name, esc_tag(slink->sub), esc_tag(slink->linkto));
++soft_error;
} else if (!unsuccessful && st.st_ino != stto.st_ino) {
unsuccessful = 1;
log_error(ESOFT, "Mismatch hardlink '%s' and '%s'. Different inode.\n", path, pathto);
log_tag("hardlink_error:%s:%s:%s: Hardlink mismatch for different inode\n", disk->name, esc_tag(slink->sub, esc_buffer), esc_tag(slink->linkto, esc_buffer_alt));
log_tag("hardlink_error:%s:%s:%s: Hardlink mismatch for different inode\n", disk->name, esc_tag(slink->sub), esc_tag(slink->linkto));
++soft_error;
}
} else {
@ -1729,7 +1722,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(errno, "Error reading symlink '%s'. %s.\n", path, strerror(errno));
log_tag("symlink_%s:%s:%s: Symlink read error. %s.\n", es(errno), disk->name, esc_tag(slink->sub, esc_buffer), strerror(errno));
log_tag("symlink_%s:%s:%s: Symlink read error. %s.\n", es(errno), disk->name, esc_tag(slink->sub), strerror(errno));
if (is_hw(errno)) {
++io_error;
@ -1740,7 +1733,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(ESOFT, "Error reading symlink '%s'. Symlink too long.\n", path);
log_tag("symlink_error:%s:%s: Symlink too long\n", disk->name, esc_tag(slink->sub, esc_buffer));
log_tag("symlink_error:%s:%s: Symlink too long\n", disk->name, esc_tag(slink->sub));
++soft_error;
} else {
linkto[ret] = 0;
@ -1748,7 +1741,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (strcmp(linkto, slink->linkto) != 0) {
unsuccessful = 1;
log_tag("symlink_error:%s:%s: Symlink data error '%s' instead of '%s'\n", disk->name, esc_tag(slink->sub, esc_buffer), linkto, slink->linkto);
log_tag("symlink_error:%s:%s: Symlink data error '%s' instead of '%s'\n", disk->name, esc_tag(slink->sub), linkto, slink->linkto);
++soft_error;
}
}
@ -1762,7 +1755,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error creating ancestor '%s%s'. %s.\n", disk->dir, slink->sub, strerror(errno));
log_tag("%slink_%s:%u:%s:%s: Create ancestor error. %s.\n", link, es(errno), i, disk->name, esc_tag(slink->sub, esc_buffer), strerror(errno));
log_tag("%slink_%s:%u:%s:%s: Create ancestor error. %s.\n", link, es(errno), i, disk->name, esc_tag(slink->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1776,7 +1769,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0 && errno != ENOENT) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error removing '%s%s'. %s.\n", disk->dir, slink->sub, strerror(errno));
log_tag("%slink_%s:%u:%s:%s: Remove error. %s.\n", link, es(errno), i, disk->name, esc_tag(slink->sub, esc_buffer), strerror(errno));
log_tag("%slink_%s:%u:%s:%s: Remove error. %s.\n", link, es(errno), i, disk->name, esc_tag(slink->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1791,7 +1784,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error writing hardlink '%s' to '%s'. %s.\n", path, pathto, strerror(errno));
log_tag("hardlink_%s:%u:%s:%s: Hardlink error. %s.\n", es(errno), i, disk->name, esc_tag(slink->sub, esc_buffer), strerror(errno));
log_tag("hardlink_%s:%u:%s:%s: Hardlink error. %s.\n", es(errno), i, disk->name, esc_tag(slink->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1800,14 +1793,14 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* LCOV_EXCL_STOP */
}
log_tag("hardlink_fixed:%s:%s: Fixed hardlink error\n", disk->name, esc_tag(slink->sub, esc_buffer));
log_tag("hardlink_fixed:%s:%s: Fixed hardlink error\n", disk->name, esc_tag(slink->sub));
++recovered_error;
} else {
ret = symlink(slink->linkto, path);
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error writing symlink '%s' to '%s'. %s.\n", path, slink->linkto, strerror(errno));
log_tag("symlink_%s:%u:%s:%s: Hardlink error. %s.\n", es(errno), i, disk->name, esc_tag(slink->sub, esc_buffer), strerror(errno));
log_tag("symlink_%s:%u:%s:%s: Hardlink error. %s.\n", es(errno), i, disk->name, esc_tag(slink->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1816,12 +1809,12 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* LCOV_EXCL_STOP */
}
log_tag("symlink_fixed:%s:%s: Fixed symlink error\n", disk->name, esc_tag(slink->sub, esc_buffer));
log_tag("symlink_fixed:%s:%s: Fixed symlink error\n", disk->name, esc_tag(slink->sub));
++recovered_error;
}
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(slink->sub, esc_buffer));
msg_info("recovered %s\n", fmt_term(disk, slink->sub, esc_buffer));
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(slink->sub));
msg_info("recovered %s\n", fmt_term(disk, slink->sub));
}
}
@ -1849,7 +1842,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
unsuccessful = 1;
log_error(errno, "Error stating dir '%s'. %s.\n", path, strerror(errno));
log_tag("dir_%s:%s:%s: Dir stat error. %s.\n", es(errno), disk->name, esc_tag(dir->sub, esc_buffer), strerror(errno));
log_tag("dir_%s:%s:%s: Dir stat error. %s.\n", es(errno), disk->name, esc_tag(dir->sub), strerror(errno));
if (is_hw(errno)) {
++io_error;
@ -1859,7 +1852,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
} else if (!S_ISDIR(st.st_mode)) {
unsuccessful = 1;
log_tag("dir_error:%s:%s: Dir error for not directory\n", disk->name, esc_tag(dir->sub, esc_buffer));
log_tag("dir_error:%s:%s: Dir error for not directory\n", disk->name, esc_tag(dir->sub));
++soft_error;
}
@ -1869,7 +1862,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error creating ancestor '%s%s'. %s.\n", disk->dir, dir->sub, strerror(errno));
log_tag("dir_%s:%u:%s:%s: Create ancestor error. %s.\n", es(errno), i, disk->name, esc_tag(dir->sub, esc_buffer), strerror(errno));
log_tag("dir_%s:%u:%s:%s: Create ancestor error. %s.\n", es(errno), i, disk->name, esc_tag(dir->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1883,7 +1876,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
if (ret != 0 && errno != EEXIST) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error creating directory '%s%s'. %s.\n", disk->dir, dir->sub, strerror(errno));
log_tag("dir_%s:%u:%s:%s: Create directory error. %s.\n", es(errno), i, disk->name, esc_tag(dir->sub, esc_buffer), strerror(errno));
log_tag("dir_%s:%u:%s:%s: Create directory error. %s.\n", es(errno), i, disk->name, esc_tag(dir->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping\n");
@ -1892,11 +1885,11 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna
/* LCOV_EXCL_STOP */
}
log_tag("dir_fixed:%s:%s: Fixed dir error\n", disk->name, esc_tag(dir->sub, esc_buffer));
log_tag("dir_fixed:%s:%s: Fixed dir error\n", disk->name, esc_tag(dir->sub));
++recovered_error;
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(dir->sub, esc_buffer));
msg_info("recovered %s\n", fmt_term(disk, dir->sub, esc_buffer));
log_tag("status:recovered:%s:%s\n", disk->name, esc_tag(dir->sub));
msg_info("recovered %s\n", fmt_term(disk, dir->sub));
}
}
}
@ -1912,7 +1905,7 @@ bail:
ret = handle_close(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockmax, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockmax, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
++unrecoverable_error;
@ -1963,7 +1956,7 @@ bail:
if (ret != 0) {
/* LCOV_EXCL_START */
log_fatal(errno, "Error removing '%s'. %s.\n", path, strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockmax, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockmax, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
++unrecoverable_error;

10
cmdline/device.c
View file

@ -510,17 +510,15 @@ static double raid_prob_of_one_or_more_failures(double array_failure_rate, doubl
static void state_info_log(devinfo_t* devinfo)
{
char esc_buffer[ESC_MAX];
log_tag("info:%s:%s\n", devinfo->file, devinfo->name);
if (devinfo->serial[0])
log_tag("attr:%s:%s:serial:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->serial, esc_buffer));
log_tag("attr:%s:%s:serial:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->serial));
if (devinfo->family[0])
log_tag("attr:%s:%s:family:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->family, esc_buffer));
log_tag("attr:%s:%s:family:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->family));
if (devinfo->model[0])
log_tag("attr:%s:%s:model:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->model, esc_buffer));
log_tag("attr:%s:%s:model:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->model));
if (devinfo->interf[0])
log_tag("attr:%s:%s:interface:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->interf, esc_buffer));
log_tag("attr:%s:%s:interface:%s\n", devinfo->file, devinfo->name, esc_tag(devinfo->interf));
if (devinfo->info[INFO_SIZE] != SMART_UNASSIGNED)
log_tag("attr:%s:%s:size:%" PRIu64 "\n", devinfo->file, devinfo->name, devinfo->info[INFO_SIZE]);
if (devinfo->info[INFO_ROTATION_RATE] != SMART_UNASSIGNED)

12
cmdline/dry.c
View file

@ -31,8 +31,6 @@ static void dry_data_reader(struct snapraid_worker* worker, struct snapraid_task
block_off_t blockcur = task->position;
unsigned char* buffer = task->buffer;
int ret;
char esc_buffer[ESC_MAX];
/* if the disk position is not used */
if (!disk) {
/* use an empty block */
@ -64,7 +62,7 @@ static void dry_data_reader(struct snapraid_worker* worker, struct snapraid_task
/* LCOV_EXCL_START */
/* This one is really an unexpected error, because we are only reading */
/* and closing a descriptor should never fail */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", blockcur);
@ -80,7 +78,7 @@ static void dry_data_reader(struct snapraid_worker* worker, struct snapraid_task
ret = handle_open(handle, task->file, state->file_mode, log_error, 0); /* for missing file don't output a message */
if (ret == -1) {
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub), strerror(errno));
if (is_hw(errno)) {
/* LCOV_EXCL_START */
log_fatal_errno(errno, disk->name);
@ -96,7 +94,7 @@ static void dry_data_reader(struct snapraid_worker* worker, struct snapraid_task
task->read_size = handle_read(handle, task->file_pos, buffer, state->block_size, log_error, 0);
if (task->read_size == -1) {
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub, esc_buffer), task->file_pos, strerror(errno));
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub), task->file_pos, strerror(errno));
if (is_hw(errno)) {
/* LCOV_EXCL_START */
log_error_errno(errno, disk->name);
@ -161,8 +159,6 @@ static int state_dry_process(struct snapraid_state* state, struct snapraid_parit
unsigned l;
unsigned* waiting_map;
unsigned waiting_mac;
char esc_buffer[ESC_MAX];
handle = handle_mapping(state, &diskmax);
/* we need 1 * data + 2 * parity */
@ -370,7 +366,7 @@ bail:
ret = handle_close(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
if (is_hw(errno)) {

7
cmdline/dup.c
View file

@ -79,9 +79,6 @@ void state_dup(struct snapraid_state* state)
tommy_node* i;
unsigned count;
data_off_t size;
char esc_buffer[ESC_MAX];
char esc_buffer_alt[ESC_MAX];
tommy_hashdyn_init(&hashset);
count = 0;
@ -116,8 +113,8 @@ void state_dup(struct snapraid_state* state)
if (found) {
++count;
size += found->file->size;
log_tag("dup:%s:%s:%s:%s:%" PRIu64 ": dup\n", disk->name, esc_tag(file->sub, esc_buffer), found->disk->name, esc_tag(found->file->sub, esc_buffer_alt), found->file->size);
printf("%12" PRIu64 " %s = %s\n", file->size, fmt_term(disk, file->sub, esc_buffer), fmt_term(found->disk, found->file->sub, esc_buffer_alt));
log_tag("dup:%s:%s:%s:%s:%" PRIu64 ": dup\n", disk->name, esc_tag(file->sub), found->disk->name, esc_tag(found->file->sub), found->file->size);
printf("%12" PRIu64 " %s = %s\n", file->size, fmt_term(disk, file->sub), fmt_term(found->disk, found->file->sub));
hash_free(hash);
} else {
tommy_hashdyn_insert(&hashset, &hash->node, hash, hash32);

12
cmdline/elem.c
View file

@ -1547,32 +1547,32 @@ int FMT_MODE = FMT_FILE;
/**
* Format a file path for poll reference
*/
const char* fmt_poll(const struct snapraid_disk* disk, const char* str, char* buffer)
const char* fmt_poll(const struct snapraid_disk* disk, const char* str)
{
(void)disk;
return esc_shell(str, buffer);
return esc_shell(str, esc_buf());
}
/**
* Format a path name for terminal reference
*/
const char* fmt_term(const struct snapraid_disk* disk, const char* str, char* buffer)
const char* fmt_term(const struct snapraid_disk* disk, const char* str)
{
const char* out[3];
switch (FMT_MODE) {
case FMT_FILE :
default :
return esc_shell(str, buffer);
return esc_shell(str, esc_buf());
case FMT_DISK :
out[0] = disk->name;
out[1] = ":";
out[2] = str;
return esc_shell_multi(out, 3, buffer);
return esc_shell_multi(out, 3, esc_buf());
case FMT_PATH :
out[0] = disk->dir;
out[1] = str;
return esc_shell_multi(out, 2, buffer);
return esc_shell_multi(out, 2, esc_buf());
}
}

4
cmdline/elem.h
View file

@ -1314,12 +1314,12 @@ extern int FMT_MODE;
/**
* Format a file path for poll reference
*/
const char* fmt_poll(const struct snapraid_disk* disk, const char* str, char* buffer);
const char* fmt_poll(const struct snapraid_disk* disk, const char* str);
/**
* Format a path name for terminal reference
*/
const char* fmt_term(const struct snapraid_disk* disk, const char* str, char* buffer);
const char* fmt_term(const struct snapraid_disk* disk, const char* str);
/**
* Format a size adding suffix K/M/G/T

11
cmdline/list.c
View file

@ -18,9 +18,6 @@ void state_list(struct snapraid_state* state)
unsigned file_count;
data_off_t file_size;
unsigned link_count;
char esc_buffer[ESC_MAX];
char esc_buffer_alt[ESC_MAX];
file_count = 0;
file_size = 0;
link_count = 0;
@ -48,7 +45,7 @@ void state_list(struct snapraid_state* state)
file_size += file->size;
if (state->opt.gui_verbose)
log_tag("file:%s:%s:%" PRIu64 ":%" PRIi64 ":%u:%" PRIu64 "\n", disk->name, esc_tag(file->sub, esc_buffer), file->size, file->mtime_sec, file->mtime_nsec, file->inode);
log_tag("file:%s:%s:%" PRIu64 ":%" PRIi64 ":%u:%" PRIu64 "\n", disk->name, esc_tag(file->sub), file->size, file->mtime_sec, file->mtime_nsec, file->inode);
t = file->mtime_sec;
#if HAVE_LOCALTIME_R
@ -64,7 +61,7 @@ void state_list(struct snapraid_state* state)
printf(":%02u.%09u", tm->tm_sec, file->mtime_nsec);
printf(" ");
}
printf("%s\n", fmt_term(disk, file->sub, esc_buffer));
printf("%s\n", fmt_term(disk, file->sub));
}
/* sort by name */
@ -88,13 +85,13 @@ void state_list(struct snapraid_state* state)
++link_count;
if (state->opt.gui_verbose)
log_tag("link_%s:%s:%s:%s\n", type, disk->name, esc_tag(slink->sub, esc_buffer), esc_tag(slink->linkto, esc_buffer_alt));
log_tag("link_%s:%s:%s:%s\n", type, disk->name, esc_tag(slink->sub), esc_tag(slink->linkto));
printf("%12s ", type);
printf(" ");
if (msg_level >= MSG_VERBOSE)
printf(" ");
printf("%s -> %s\n", fmt_term(disk, slink->sub, esc_buffer), fmt_term(disk, slink->linkto, esc_buffer_alt));
printf("%s -> %s\n", fmt_term(disk, slink->sub), fmt_term(disk, slink->linkto));
}
}

3
cmdline/locate.c
View file

@ -46,12 +46,11 @@ static int parity_entry_compare(const void* void_a, const void* void_b)
static void dump_entry(void* void_entry)
{
char esc_buffer[ESC_MAX];
struct snapraid_parity_entry* entry = void_entry;
printf("%12" PRIu64 " ", entry->low * (uint64_t)entry->block_size);
printf("%12" PRIu64 " ", (entry->high - entry->low + 1) * (uint64_t)entry->block_size);
printf("%8u ", entry->fragments);
printf("%s\n", fmt_term(entry->disk, entry->file->sub, esc_buffer));
printf("%s\n", fmt_term(entry->disk, entry->file->sub));
}
static void add_size_to_sum(void* arg, void* void_entry)

4
cmdline/mingw.c
View file

@ -3225,13 +3225,11 @@ int devmap(void)
h = CreateFileW(convert(conv_buf, wfile), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH, 0);
if (h == INVALID_HANDLE_VALUE)
continue;
char esc_buffer[ESC_MAX];
char serial[SMART_MAX];
serial[0] = 0;
devattr_property(h, serial, 0, 0);
if (serial[0]) {
log_tag("map:/dev/pd%d:%s\n", i, esc_tag(serial, esc_buffer));
log_tag("map:/dev/pd%d:%s\n", i, esc_tag(serial));
}
CloseHandle(h);

5
cmdline/mingw.h
View file

@ -393,6 +393,7 @@ typedef void* windows_key_t;
#define thread_id_t windows_thread_t
#define thread_mutex_t windows_mutex_t
#define thread_cond_t windows_cond_t
#define thread_key_t windows_key_t
#define pthread_mutex_init windows_mutex_init
#define pthread_mutex_destroy windows_mutex_destroy
#define pthread_mutex_lock windows_mutex_lock
@ -404,6 +405,10 @@ typedef void* windows_key_t;
#define pthread_cond_wait windows_cond_wait
#define pthread_create windows_create
#define pthread_join windows_join
#define pthread_key_create windows_key_create
#define pthread_key_delete windows_key_delete
#define pthread_getspecific windows_getspecific
#define pthread_setspecific windows_setspecific
/**
* Like the pthread_* equivalent.

4
cmdline/parity.c
View file

@ -75,8 +75,6 @@ void parity_overflow(struct snapraid_state* state, data_off_t size)
tommy_node* i;
block_off_t blockalloc;
int found = 0;
char esc_buffer[ESC_MAX];
/* don't report if everything is outside or if the file is not accessible */
if (size == 0) {
return;
@ -97,7 +95,7 @@ void parity_overflow(struct snapraid_state* state, data_off_t size)
block_off_t parity_pos = fs_file2par_get(disk, file, file->blockmax - 1);
if (parity_pos >= blockalloc) {
found = 1;
log_tag("outofparity:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
log_tag("outofparity:%s:%s\n", disk->name, esc_tag(file->sub));
log_fatal(ESOFT, "outofparity %s%s\n", disk->dir, file->sub);
}
}

96
cmdline/scan.c
View file

@ -142,8 +142,6 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub,
struct snapraid_state* state = scan->state;
struct snapraid_disk* disk = scan->disk;
struct snapraid_link* slink;
char esc_buffer[ESC_MAX];
/* check if the link already exists */
slink = tommy_hashdyn_search(&disk->linkset, link_name_compare_to_arg, sub, link_name_hash(sub));
if (slink) {
@ -164,7 +162,7 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub,
++scan->count_equal;
if (state->opt.gui_verbose) {
log_tag("scan:equal:%s:%s\n", disk->name, esc_tag(slink->sub, esc_buffer));
log_tag("scan:equal:%s:%s\n", disk->name, esc_tag(slink->sub));
}
} else {
/* it's an update */
@ -174,9 +172,9 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub,
++scan->count_change;
log_tag("scan:update:%s:%s\n", disk->name, esc_tag(slink->sub, esc_buffer));
log_tag("scan:update:%s:%s\n", disk->name, esc_tag(slink->sub));
if (is_diff) {
msg_info("update %s\n", fmt_term(disk, slink->sub, esc_buffer));
msg_info("update %s\n", fmt_term(disk, slink->sub));
}
/* update it */
@ -191,9 +189,9 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub,
/* create the new link */
++scan->count_insert;
log_tag("scan:add:%s:%s\n", disk->name, esc_tag(sub, esc_buffer));
log_tag("scan:add:%s:%s\n", disk->name, esc_tag(sub));
if (is_diff) {
msg_info("add %s\n", fmt_term(disk, sub, esc_buffer));
msg_info("add %s\n", fmt_term(disk, sub));
}
/* and continue to insert it */
@ -390,7 +388,6 @@ static void scan_file_deallocate(struct snapraid_scan* scan, struct snapraid_fil
static void scan_file_delayed_allocate(struct snapraid_scan* scan, struct snapraid_file* file)
{
char esc_buffer[ESC_MAX];
struct snapraid_state* state = scan->state;
struct snapraid_disk* disk = scan->disk;
@ -404,7 +401,7 @@ static void scan_file_delayed_allocate(struct snapraid_scan* scan, struct snapra
if (filephy(path_next, file->size, &file->physical) != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: File physycal offset error. %s.\n", es(errno), 0, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: File physycal offset error. %s.\n", es(errno), 0, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal(errno, "Error in getting the physical offset of file '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -525,7 +522,6 @@ static int file_is_full_hashed_and_stable(struct snapraid_state* state, struct s
static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struct stat* st, uint64_t* physical)
{
#if HAVE_LSTAT_SYNC
char esc_buffer[ESC_MAX];
struct snapraid_state* state = scan->state;
struct snapraid_disk* disk = scan->disk;
@ -547,7 +543,7 @@ static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struc
if (lstat_sync(path_next, &synced_st, physical) != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error in stat file '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -570,7 +566,7 @@ static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struc
* Why is the file size reported incorrectly for files that are still being written to?
* http://blogs.msdn.com/b/oldnewthing/archive/2011/12/26/10251026.aspx
*/
log_tag("%s:%u:%s:%s: Uncached time change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub, esc_buffer));
log_tag("%s:%u:%s:%s: Uncached time change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub));
log_fatal(ESOFT, "WARNING! Detected uncached time change from %" PRIu64 ".%09u to %" PRIu64 ".%09u for file '%s'\n",
(uint64_t)st->st_mtime, (uint32_t)st->st_mtimensec, (uint64_t)synced_st.st_mtime, (uint32_t)synced_st.st_mtimensec, sub);
log_fatal(ESOFT, "It's better if you run SnapRAID without other processes running.\n");
@ -581,7 +577,7 @@ static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struc
if (st->st_size != synced_st.st_size) {
#ifndef _WIN32
log_tag("%s:%u:%s:%s: Uncached size change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub, esc_buffer));
log_tag("%s:%u:%s:%s: Uncached size change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub));
log_fatal(ESOFT, "WARNING! Detected uncached size change from %" PRIu64 " to %" PRIu64 " for file '%s'\n",
(uint64_t)st->st_size, (uint64_t)synced_st.st_size, sub);
log_fatal(ESOFT, "It's better if you run SnapRAID without other processes running.\n");
@ -591,7 +587,7 @@ static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struc
if (st->st_nlink != synced_st.st_nlink) {
#ifndef _WIN32
log_tag("%s:%u:%s:%s: Uncached nlink change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub, esc_buffer));
log_tag("%s:%u:%s:%s: Uncached nlink change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub));
log_fatal(ESOFT, "WARNING! Detected uncached nlink change from %u to %u for file '%s'\n",
(uint32_t)st->st_nlink, (uint32_t)synced_st.st_nlink, sub);
log_fatal(ESOFT, "It's better if you run SnapRAID without other processes running.\n");
@ -600,7 +596,7 @@ static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struc
}
if (st->st_ino != synced_st.st_ino) {
log_tag("%s:%u:%s:%s: Uncached inode change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub, esc_buffer));
log_tag("%s:%u:%s:%s: Uncached inode change error.\n", es(ESOFT), 0, disk->name, esc_tag(sub));
log_fatal(ESOFT, "DANGER! Detected uncached inode change from %" PRIu64 " to %" PRIu64 " for file '%s'\n",
(uint64_t)st->st_ino, (uint64_t)synced_st.st_ino, sub);
log_fatal(ESOFT, "It's better if you run SnapRAID without other processes running.\n");
@ -702,9 +698,6 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
int64_t file_already_present_mtime_sec;
int file_already_present_mtime_nsec;
int is_file_reported;
char esc_buffer[ESC_MAX];
char esc_buffer_alt[ESC_MAX];
/*
* If the disk has persistent inodes and UUID, try a search on the past inodes,
* to detect moved files.
@ -784,9 +777,9 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
/* if the path is different, it means a moved file with the same inode */
++scan->count_move;
log_tag("scan:move:%s:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer), esc_tag(sub, esc_buffer_alt));
log_tag("scan:move:%s:%s:%s\n", disk->name, esc_tag(file->sub), esc_tag(sub));
if (is_diff) {
msg_info("move %s -> %s\n", fmt_term(disk, file->sub, esc_buffer), fmt_term(disk, sub, esc_buffer_alt));
msg_info("move %s -> %s\n", fmt_term(disk, file->sub), fmt_term(disk, sub));
}
/* remove from the name set */
@ -805,7 +798,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
++scan->count_equal;
if (state->opt.gui_verbose) {
log_tag("scan:equal:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
log_tag("scan:equal:%s:%s\n", disk->name, esc_tag(file->sub));
}
}
@ -947,9 +940,9 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
/* like when restoring a backup that restores also the timestamp */
++scan->count_restore;
log_tag("scan:restore:%s:%s\n", disk->name, esc_tag(sub, esc_buffer));
log_tag("scan:restore:%s:%s\n", disk->name, esc_tag(sub));
if (is_diff) {
msg_info("restore %s\n", fmt_term(disk, sub, esc_buffer));
msg_info("restore %s\n", fmt_term(disk, sub));
}
/* remove from the inode set */
@ -970,7 +963,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
++scan->count_equal;
if (state->opt.gui_verbose) {
log_tag("scan:equal:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
log_tag("scan:equal:%s:%s\n", disk->name, esc_tag(file->sub));
}
}
@ -1015,7 +1008,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
/* LCOV_EXCL_START */
log_fatal(ESOFT, "The file '%s%s' has unexpected zero size!\n", disk->dir, sub);
log_fatal(ESOFT, "It's possible that after a kernel crash this file was lost,\n");
log_fatal(ESOFT, "and you can use 'snapraid fix -f /%s' to recover it.\n", fmt_poll(disk, sub, esc_buffer));
log_fatal(ESOFT, "and you can use 'snapraid fix -f /%s' to recover it.\n", fmt_poll(disk, sub));
if (!is_diff) {
log_fatal(ESOFT, "If this an expected condition you can '%s' anyway using 'snapraid --force-zero %s'\n", state->command, state->command);
exit(EXIT_FAILURE);
@ -1080,16 +1073,16 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
if (lstat(path_other, &other_st) == 0) {
++scan->count_copy;
log_tag("scan:copy:%s:%s:%s:%s\n", other_disk->name, esc_tag(other_file->sub, esc_buffer), disk->name, esc_tag(file->sub, esc_buffer_alt));
log_tag("scan:copy:%s:%s:%s:%s\n", other_disk->name, esc_tag(other_file->sub), disk->name, esc_tag(file->sub));
if (is_diff) {
msg_info("copy %s -> %s\n", fmt_term(other_disk, other_file->sub, esc_buffer), fmt_term(disk, file->sub, esc_buffer_alt));
msg_info("copy %s -> %s\n", fmt_term(other_disk, other_file->sub), fmt_term(disk, file->sub));
}
} else {
++scan->count_relocate;
log_tag("scan:relocate:%s:%s:%s:%s\n", other_disk->name, esc_tag(other_file->sub, esc_buffer), disk->name, esc_tag(file->sub, esc_buffer_alt));
log_tag("scan:relocate:%s:%s:%s:%s\n", other_disk->name, esc_tag(other_file->sub), disk->name, esc_tag(file->sub));
if (is_diff) {
msg_info("relocate %s -> %s\n", fmt_term(other_disk, other_file->sub, esc_buffer), fmt_term(disk, file->sub, esc_buffer_alt));
msg_info("relocate %s -> %s\n", fmt_term(other_disk, other_file->sub), fmt_term(disk, file->sub));
}
}
@ -1108,20 +1101,20 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub,
if (is_file_already_present) {
++scan->count_change;
log_tag("scan:update:%s:%s: %" PRIu64 " %" PRIu64 ".%d -> %" PRIu64 " %" PRIu64 ".%d\n", disk->name, esc_tag(sub, esc_buffer),
log_tag("scan:update:%s:%s: %" PRIu64 " %" PRIu64 ".%d -> %" PRIu64 " %" PRIu64 ".%d\n", disk->name, esc_tag(sub),
file_already_present_size, file_already_present_mtime_sec, file_already_present_mtime_nsec,
file->size, file->mtime_sec, file->mtime_nsec
);
if (is_diff) {
msg_info("update %s\n", fmt_term(disk, sub, esc_buffer));
msg_info("update %s\n", fmt_term(disk, sub));
}
} else {
++scan->count_insert;
log_tag("scan:add:%s:%s\n", disk->name, esc_tag(sub, esc_buffer));
log_tag("scan:add:%s:%s\n", disk->name, esc_tag(sub));
if (is_diff) {
msg_info("add %s\n", fmt_term(disk, sub, esc_buffer));
msg_info("add %s\n", fmt_term(disk, sub));
}
}
}
@ -1253,10 +1246,9 @@ struct stat* dstat(struct dirent_sorted* dd)
#define DSTAT(file, dd, buf) dstat(disk, file, buf)
struct stat* dstat(struct snapraid_disk* disk, const char* file, struct stat* st)
{
char esc_buffer[ESC_MAX];
if (lstat(file, st) != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(file, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(file), strerror(errno));
log_fatal(errno, "Error in stat file/directory '%s'. %s.\n", file, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1271,7 +1263,6 @@ struct stat* dstat(struct snapraid_disk* disk, const char* file, struct stat* st
*/
static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* path_next, char* sub_next, char* tmp)
{
char esc_buffer[ESC_MAX];
struct snapraid_state* state = scan->state;
struct snapraid_disk* disk = scan->disk;
int processed = 0;
@ -1289,7 +1280,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
d = opendir(path_next);
if (!d) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Open dir error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Open dir error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error opening directory '%s'. %s.\n", path_next, strerror(errno));
if (level == 0)
log_fatal(errno, "If this is the disk mount point, remember to create it manually\n");
@ -1320,7 +1311,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
/* restore removing additions */
path_next[path_len] = 0;
sub_next[sub_len] = 0;
log_tag("%s:%u:%s:%s: Read dir error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Read dir error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error reading directory '%s'. %s.\n", path_next, strerror(errno));
log_fatal(errno, "You can exclude it in the config file with: exclude /%s\n", sub_next);
exit(EXIT_FAILURE);
@ -1340,7 +1331,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
/* check for not supported file names */
if (name[0] == 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Unsupported name error.\n", es(ESOFT), 0, disk->name, esc_tag(path_next, esc_buffer));
log_tag("%s:%u:%s:%s: Unsupported name error.\n", es(ESOFT), 0, disk->name, esc_tag(path_next));
log_fatal(ESOFT, "Unsupported name '%s' in file '%s'.\n", name, path_next);
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1388,7 +1379,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
/* LCOV_EXCL_START */
/* restore removing additions */
path_next[path_len] = 0;
log_tag("%s:%u:%s:%s: Close dir error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close dir error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error closing directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1453,7 +1444,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
if (st->st_mode == 0) {
if (lstat(path_next, st) != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1485,7 +1476,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
if (st->st_ino == 0 || st->st_nlink == 0) {
if (lstat_sync(path_next, st, 0) != 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Stat error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error in stat file '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1506,14 +1497,14 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
ret = readlink(path_next, tmp, PATH_MAX);
if (ret >= PATH_MAX) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Readlink error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Readlink error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(EINTERNAL, "Error in readlink file '%s'. Symlink too long.\n", path_next);
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
}
if (ret < 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Readlink error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Readlink error. %s.\n", es(errno), 0, disk->name, esc_tag(path_next), strerror(errno));
log_fatal(errno, "Error in readlink file '%s'. %s.\n", path_next, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1543,7 +1534,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
* in Windows we are already skipping them reporting them as special files
*/
if ((uint64_t)st->st_dev != disk->device) {
log_tag("%s:%u:%s:%s: Ignoring mount point.\n", es(ESOFT), 0, disk->name, esc_tag(path_next, esc_buffer));
log_tag("%s:%u:%s:%s: Ignoring mount point.\n", es(ESOFT), 0, disk->name, esc_tag(path_next));
log_fatal(ESOFT, "WARNING! Ignoring mount point '%s' because it appears to be in a different device\n", path_next);
} else
#endif
@ -1570,7 +1561,7 @@ static int scan_sub(struct snapraid_scan* scan, int level, int is_diff, char* pa
if (!st)
st = DSTAT(path_next, dd, &st_buf);
log_tag("%s:%u:%s:%s: Ignoring special file.\n", es(ESOFT), 0, disk->name, esc_tag(path_next, esc_buffer));
log_tag("%s:%u:%s:%s: Ignoring special file.\n", es(ESOFT), 0, disk->name, esc_tag(path_next));
log_fatal(ESOFT, "WARNING! Ignoring special '%s' file '%s'\n", stat_desc(st), path_next);
} else {
msg_verbose("Excluding special file '%s' for rule '%s'\n", path_next, filter_type(reason, tmp, PATH_MAX));
@ -1606,7 +1597,6 @@ static int scan_dir(struct snapraid_scan* scan, int level, int is_diff, const ch
static void* scan_disk(void* arg)
{
char esc_buffer[ESC_MAX];
struct snapraid_scan* scan = arg;
struct snapraid_disk* disk = scan->disk;
int ret;
@ -1618,7 +1608,7 @@ static void* scan_disk(void* arg)
ret = fsinfo(disk->dir, &has_persistent_inodes, &has_syncronized_hardlinks, 0, 0, 0, 0, 0, 0);
if (ret < 0) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Filesystem info error. %s.\n", es(errno), 0, disk->name, esc_tag(disk->dir, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Filesystem info error. %s.\n", es(errno), 0, disk->name, esc_tag(disk->dir), strerror(errno));
log_fatal(errno, "Error accessing disk '%s' to get file-system info. %s.\n", disk->dir, strerror(errno));
exit(EXIT_FAILURE);
/* LCOV_EXCL_STOP */
@ -1672,8 +1662,6 @@ static int state_diffscan(struct snapraid_state* state, int is_diff)
msg_ptr* msg;
struct snapraid_scan total;
int no_difference;
char esc_buffer[ESC_MAX];
tommy_list_init(&scanlist);
if (is_diff)
@ -1745,9 +1733,9 @@ static int state_diffscan(struct snapraid_state* state, int is_diff)
if (!file_flag_has(file, FILE_IS_RELOCATED)) {
++scan->count_remove;
log_tag("scan:remove:%s:%s\n", disk->name, esc_tag(file->sub, esc_buffer));
log_tag("scan:remove:%s:%s\n", disk->name, esc_tag(file->sub));
if (is_diff) {
msg_info("remove %s\n", fmt_term(disk, file->sub, esc_buffer));
msg_info("remove %s\n", fmt_term(disk, file->sub));
}
}
@ -1767,9 +1755,9 @@ static int state_diffscan(struct snapraid_state* state, int is_diff)
if (!link_flag_has(slink, FILE_IS_PRESENT)) {
++scan->count_remove;
log_tag("scan:remove:%s:%s\n", disk->name, esc_tag(slink->sub, esc_buffer));
log_tag("scan:remove:%s:%s\n", disk->name, esc_tag(slink->sub));
if (is_diff) {
msg_info("remove %s\n", fmt_term(disk, slink->sub, esc_buffer));
msg_info("remove %s\n", fmt_term(disk, slink->sub));
}
scan_link_remove(scan, slink);

15
cmdline/scrub.c
View file

@ -103,8 +103,6 @@ static void scrub_data_reader(struct snapraid_worker* worker, struct snapraid_ta
block_off_t blockcur = task->position;
unsigned char* buffer = task->buffer;
int ret;
char esc_buffer[ESC_MAX];
/* if the disk position is not used */
if (!disk) {
/* use an empty block */
@ -136,7 +134,7 @@ static void scrub_data_reader(struct snapraid_worker* worker, struct snapraid_ta
/* LCOV_EXCL_START */
/* This one is really an unexpected error, because we are only reading */
/* and closing a descriptor should never fail */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", blockcur);
@ -152,7 +150,7 @@ static void scrub_data_reader(struct snapraid_worker* worker, struct snapraid_ta
ret = handle_open(handle, task->file, state->file_mode, log_error, 0); /* for missing file don't output a message */
if (ret == -1) {
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub), strerror(errno));
if (is_hw(errno)) {
/* LCOV_EXCL_START */
log_fatal_errno(errno, disk->name);
@ -183,7 +181,7 @@ static void scrub_data_reader(struct snapraid_worker* worker, struct snapraid_ta
task->read_size = handle_read(handle, task->file_pos, buffer, state->block_size, log_error, 0);
if (task->read_size == -1) {
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub, esc_buffer), task->file_pos, strerror(errno));
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub), task->file_pos, strerror(errno));
if (is_hw(errno)) {
/* LCOV_EXCL_START */
log_error_errno(errno, disk->name);
@ -255,7 +253,6 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par
unsigned l;
unsigned* waiting_map;
unsigned waiting_mac;
char esc_buffer[ESC_MAX];
bit_vect_t* block_enabled;
/* maps the disks to handles */
@ -476,11 +473,11 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par
/* it's a silent error only if we are dealing with synced files */
if (file_is_unsynced) {
log_tag("error:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer), file_pos, diff, BLOCK_HASH_SIZE * 8);
log_tag("error:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", blockcur, disk->name, esc_tag(file->sub), file_pos, diff, BLOCK_HASH_SIZE * 8);
++soft_error;
error_on_this_block = 1;
} else {
log_tag("error_data:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer), file_pos, diff, BLOCK_HASH_SIZE * 8);
log_tag("error_data:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", blockcur, disk->name, esc_tag(file->sub), file_pos, diff, BLOCK_HASH_SIZE * 8);
log_error(EDATA, "Data error in file '%s' at position '%u', diff hash bits %u/%u\n", task->path, file_pos, diff, BLOCK_HASH_SIZE * 8);
++silent_error;
silent_error_on_this_block = 1;
@ -706,7 +703,7 @@ bail:
ret = handle_close(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
if (is_hw(errno)) {

21
cmdline/snapraid.c
View file

@ -106,15 +106,15 @@ void test(int argc, char* argv[])
assert(worddigitstr("needle2string", "needle") != 0);
assert(worddigitstr("needle", "needle") != 0);
assert(strcmp(esc_tag("simple", buffer), "simple") == 0);
assert(strcmp(esc_tag("line1\nline2", buffer), "line1\\nline2") == 0);
assert(strcmp(esc_tag("line1\rline2", buffer), "line1\\rline2") == 0);
assert(strcmp(esc_tag("key:value", buffer), "key\\dvalue") == 0);
assert(strcmp(esc_tag("C:\\path\\file", buffer), "C\\d\\\\path\\\\file") == 0);
assert(strcmp(esc_tag("A\nB\rC:D\\E", buffer), "A\\nB\\rC\\dD\\\\E") == 0);
assert(strcmp(esc_tag("endwith\\", buffer), "endwith\\\\") == 0);
assert(strcmp(esc_tag("", buffer), "") == 0);
assert(strcmp(esc_tag("\n\r:\\\\", buffer), "\\n\\r\\d\\\\\\\\") == 0);
assert(strcmp(esc_tag("simple"), "simple") == 0);
assert(strcmp(esc_tag("line1\nline2"), "line1\\nline2") == 0);
assert(strcmp(esc_tag("line1\rline2"), "line1\\rline2") == 0);
assert(strcmp(esc_tag("key:value"), "key\\dvalue") == 0);
assert(strcmp(esc_tag("C:\\path\\file"), "C\\d\\\\path\\\\file") == 0);
assert(strcmp(esc_tag("A\nB\rC:D\\E"), "A\\nB\\rC\\dD\\\\E") == 0);
assert(strcmp(esc_tag("endwith\\"), "endwith\\\\") == 0);
assert(strcmp(esc_tag(""), "") == 0);
assert(strcmp(esc_tag("\n\r:\\\\"), "\\n\\r\\d\\\\\\\\") == 0);
for (i = 2; i < argc; ++i) {
printf("argv[%d]\n", i);
@ -935,7 +935,6 @@ void signal_init(void)
int snapraid_main(int argc, char* argv[])
{
char esc_buffer[ESC_MAX];
int c;
struct snapraid_option opt;
char conf[PATH_MAX];
@ -1750,7 +1749,7 @@ int snapraid_main(int argc, char* argv[])
}
log_tag("command:%s\n", command);
for (i = 0; i < argc; ++i)
log_tag("argv:%u:%s\n", i, esc_tag(argv[i], esc_buffer));
log_tag("argv:%u:%s\n", i, esc_tag(argv[i]));
log_flush();
if (!opt.skip_self)

49
cmdline/state.c
View file

@ -546,9 +546,6 @@ void state_config(struct snapraid_state* state, const char* path, const char* co
unsigned line;
tommy_node* i;
unsigned l, s;
char esc_buffer[ESC_MAX];
char esc_buffer1[ESC_MAX];
/* copy the options */
state->opt = *opt;
@ -567,7 +564,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co
/* store current command */
state->command = command;
log_tag("conf:file:%s\n", esc_tag(path, esc_buffer));
log_tag("conf:file:%s\n", esc_tag(path));
f = sopen_read(path, 0);
if (!f) {
@ -1482,30 +1479,30 @@ void state_config(struct snapraid_state* state, const char* path, const char* co
log_tag("blocksize:%u\n", state->block_size);
for (i = state->disklist; i != 0; i = i->next) {
struct snapraid_disk* disk = i->data;
log_tag("data:%s:%s:%s\n", esc_tag(disk->name, esc_buffer), esc_tag(disk->dir, esc_buffer1), disk->uuid);
log_tag("data:%s:%s:%s\n", esc_tag(disk->name), esc_tag(disk->dir), disk->uuid);
}
for (i = state->extralist; i != 0; i = i->next) {
struct snapraid_extra* extra = i->data;
log_tag("extra:%s:%s:%s\n", esc_tag(extra->name, esc_buffer), esc_tag(extra->dir, esc_buffer1), extra->uuid);
log_tag("extra:%s:%s:%s\n", esc_tag(extra->name), esc_tag(extra->dir), extra->uuid);
}
log_tag("mode:%s\n", lev_raid_name(state->raid_mode, state->level));
for (l = 0; l < state->level; ++l) {
log_tag("%s:%s:%s\n", lev_config_name(l), esc_tag(state->parity[l].split_map[0].path, esc_buffer), state->parity[l].split_map[0].uuid);
log_tag("%s:%s:%s\n", lev_config_name(l), esc_tag(state->parity[l].split_map[0].path), state->parity[l].split_map[0].uuid);
for (s = 1; s < state->parity[l].split_mac; ++s) {
log_tag("%s/%u:%s:%s\n", lev_config_name(l), s, esc_tag(state->parity[l].split_map[s].path, esc_buffer), state->parity[l].split_map[s].uuid);
log_tag("%s/%u:%s:%s\n", lev_config_name(l), s, esc_tag(state->parity[l].split_map[s].path), state->parity[l].split_map[s].uuid);
}
}
if (state->pool[0] != 0)
log_tag("pool:%s\n", esc_tag(state->pool, esc_buffer));
log_tag("pool:%s\n", esc_tag(state->pool));
if (state->share[0] != 0)
log_tag("share:%s\n", esc_tag(state->share, esc_buffer));
log_tag("share:%s\n", esc_tag(state->share));
if (state->autosave != 0)
log_tag("autosave:%" PRIu64 "\n", state->autosave);
for (i = tommy_list_head(&state->filterlist); i != 0; i = i->next) {
char out[PATH_MAX];
struct snapraid_filter* filter = i->data;
log_tag("filter:%s\n", esc_tag(filter_type(filter, out, sizeof(out)), esc_buffer));
log_tag("filter:%s\n", esc_tag(filter_type(filter, out, sizeof(out))));
}
if (state->filter_hidden)
log_tag("filter:nohidden:\n");
@ -1785,7 +1782,6 @@ static void state_map(struct snapraid_state* state)
void state_refresh(struct snapraid_state* state)
{
char esc_buffer[ESC_MAX];
tommy_node* i;
unsigned l, s;
uint64_t bs = (uint64_t)state->block_size;
@ -1825,8 +1821,8 @@ void state_refresh(struct snapraid_state* state)
disk->total_blocks = map->total_blocks;
disk->free_blocks = map->free_blocks;
log_tag("fsinfo_data_split:%s:%" PRIu64 ":%" PRIu64 ":%s:%s\n", esc_tag(disk->name, esc_buffer), disk->total_blocks * bs, disk->free_blocks * bs, disk->fstype, disk->fslabel);
log_tag("fsinfo_data:%s:%" PRIu64 ":%" PRIu64 "\n", esc_tag(disk->name, esc_buffer), disk->total_blocks * bs, disk->free_blocks * bs);
log_tag("fsinfo_data_split:%s:%" PRIu64 ":%" PRIu64 ":%s:%s\n", esc_tag(disk->name), disk->total_blocks * bs, disk->free_blocks * bs, disk->fstype, disk->fslabel);
log_tag("fsinfo_data:%s:%" PRIu64 ":%" PRIu64 "\n", esc_tag(disk->name), disk->total_blocks * bs, disk->free_blocks * bs);
}
/* for all parities */
@ -1894,7 +1890,7 @@ void state_refresh(struct snapraid_state* state)
/* LCOV_EXCL_STOP */
}
log_tag("fsinfo_extra:%s:%" PRIu64 ":%" PRIu64 "\n", esc_tag(extra->name, esc_buffer), total_space, free_space);
log_tag("fsinfo_extra:%s:%" PRIu64 ":%" PRIu64 "\n", esc_tag(extra->name), total_space, free_space);
}
@ -2091,7 +2087,6 @@ static void decoding_error(const char* path, STREAM* f)
static void state_read_content(struct snapraid_state* state, const char* path, STREAM* f)
{
char esc_buffer[ESC_MAX];
block_off_t blockmax;
unsigned count_file;
unsigned count_hardlink;
@ -2926,7 +2921,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
}
log_tag("content_data:%s:%" PRIi64 ":%" PRIi64 "\n",
esc_tag(buffer, esc_buffer),
esc_tag(buffer),
v_total_blocks * (uint64_t)state->block_size,
v_free_blocks * (uint64_t)state->block_size);
} else {
@ -2944,7 +2939,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
}
log_tag("content_data_split:%s:%s\n",
esc_tag(buffer, esc_buffer),
esc_tag(buffer),
uuid);
/* find the disk */
@ -3051,7 +3046,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
log_tag("content_parity_split:%s:%s:%s:%" PRIi64 "\n",
lev_config_name(v_level), /* P command always has a single split */
state->parity[v_level].split_map[0].uuid,
esc_tag(state->parity[v_level].split_map[0].path, esc_buffer),
esc_tag(state->parity[v_level].split_map[0].path),
state->parity[v_level].split_map[0].size);
}
} else if (c == 'Q') {
@ -3193,7 +3188,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S
log_tag("content_parity_split:%s:%s:%s:%" PRIi64 "\n",
parity_name,
state->parity[v_level].split_map[s].uuid,
esc_tag(state->parity[v_level].split_map[s].path, esc_buffer),
esc_tag(state->parity[v_level].split_map[s].path),
state->parity[v_level].split_map[s].size);
}
}
@ -3327,7 +3322,6 @@ struct state_write_thread_context {
static void* state_write_thread(void* arg)
{
char esc_buffer[ESC_MAX];
struct state_write_thread_context* context = arg;
struct snapraid_state* state = context->state;
block_off_t blockmax = context->blockmax;
@ -3454,11 +3448,11 @@ static void* state_write_thread(void* arg)
sputbs(map->uuid, f);
if (context->first) {
log_tag("content_data:%s:%" PRIi64 ":%" PRIi64 "\n",
esc_tag(map->name, esc_buffer),
esc_tag(map->name),
map->total_blocks * (uint64_t)state->block_size,
map->free_blocks * (uint64_t)state->block_size);
log_tag("content_data_split:%s:%s\n",
esc_tag(map->name, esc_buffer),
esc_tag(map->name),
map->uuid);
}
if (serror(f)) {
@ -3949,11 +3943,10 @@ static void state_write_content(struct snapraid_state* state, uint32_t* out_crc)
struct snapraid_content* content = i->data;
struct state_write_thread_context* context;
char tmp[PATH_MAX];
char esc_buffer[ESC_MAX];
STREAM* f;
msg_progress("Saving state to %s...\n", content->content);
log_tag("content_write:%s\n", esc_tag(content->content, esc_buffer));
log_tag("content_write:%s\n", esc_tag(content->content));
pathprint(tmp, sizeof(tmp), "%s.tmp", content->content);
@ -4308,8 +4301,7 @@ void state_read(struct snapraid_state* state)
}
if (!state->no_conf) {
char esc_buffer[ESC_MAX];
log_tag("content:%s\n", esc_tag(path, esc_buffer));
log_tag("content:%s\n", esc_tag(path));
log_tag("content_info:read_unixtime:%" PRId64 "\n", (int64_t)st.st_mtime);
log_flush();
}
@ -5442,7 +5434,6 @@ void generate_configuration(const char* path)
{
struct snapraid_state state;
struct snapraid_content* content;
char esc_buffer[ESC_MAX];
unsigned l, s;
tommy_node* j;
@ -5510,7 +5501,7 @@ void generate_configuration(const char* path)
if (disk && disk->filelist) {
struct snapraid_file* file = disk->filelist->data;
if (file) {
printf("# and containing: %s\n", fmt_poll(disk, file->sub, esc_buffer));
printf("# and containing: %s\n", fmt_poll(disk, file->sub));
}
}
printf("data %s ENTER_HERE_THE_DIR\n", map->name);

70
cmdline/support.c
View file

@ -5,6 +5,45 @@
#include "support.h"
/****************************************************************************/
/* esc */
struct esc_thread_pool {
char pool[ESC_POOL_MAX][ESC_MAX];
unsigned idx;
};
#if HAVE_THREAD
static thread_key_t esc_key;
static void esc_pool_free(void* ptr)
{
free(ptr);
}
#else
static struct esc_thread_pool esc_single_pool;
#endif
char* esc_buf(void)
{
struct esc_thread_pool* tp;
#if HAVE_THREAD
tp = thread_getspecific(esc_key);
if (!tp) {
tp = calloc_nofail(1, sizeof(*tp));
thread_setspecific(esc_key, tp);
}
#else
tp = &esc_single_pool;
#endif
char* buffer = tp->pool[tp->idx];
tp->idx = (tp->idx + 1) % ESC_POOL_MAX;
return buffer;
}
/****************************************************************************/
/* lock */
@ -59,7 +98,6 @@ void unlock_random(void)
#endif
}
void lock_init(void)
{
#if HAVE_THREAD
@ -67,12 +105,19 @@ void lock_init(void)
thread_mutex_init(&msg_lock);
thread_mutex_init(&memory_lock);
thread_mutex_init(&random_lock);
thread_key_create(&esc_key, esc_pool_free);
#endif
}
void lock_done(void)
{
#if HAVE_THREAD
void* tp = thread_getspecific(esc_key);
if (tp) {
esc_pool_free(tp);
thread_setspecific(esc_key, NULL);
}
thread_key_delete(esc_key);
thread_mutex_destroy(&msg_lock);
thread_mutex_destroy(&memory_lock);
thread_mutex_destroy(&random_lock);
@ -637,8 +682,9 @@ void printp(double v, size_t pad)
*p++ = (c); \
} while (0)
const char* esc_tag(const char* str, char* buffer)
const char* esc_tag(const char* str)
{
char* buffer = esc_buf();
char* begin = buffer;
char* end = begin + ESC_MAX;
char* p = begin;
@ -2565,6 +2611,26 @@ void thread_yield(void)
}
#endif
int thread_key_create(thread_key_t* key, void (*destructor)(void*))
{
return pthread_key_create(key, destructor);
}
int thread_key_delete(thread_key_t key)
{
return pthread_key_delete(key);
}
void* thread_getspecific(thread_key_t key)
{
return pthread_getspecific(key);
}
int thread_setspecific(thread_key_t key, void* value)
{
return pthread_setspecific(key, value);
}
/****************************************************************************/
/* wnmatch */

14
cmdline/support.h
View file

@ -241,15 +241,19 @@ void printp(double v, size_t pad);
/* string */
#define ESC_MAX (PATH_MAX * 2 + 1)
#define ESC_POOL_MAX 8
/**
* Escape a string for the log.
*
* \param buffer Preallocated buffer of ESC_MAX size.
*
* Chars ':', '\n', '\r' and '\' are escaped to '\d', '\\n', '\\r' and '\\'.
*/
const char* esc_tag(const char* str, char* buffer);
const char* esc_tag(const char* str);
/**
* Get a dynamically allocated buffer of ESC_MAX size from a circular pool.
*/
char* esc_buf(void);
/**
* Escape a string for the shell.
@ -502,6 +506,10 @@ void thread_cond_broadcast_and_unlock(thread_cond_t* cond, thread_mutex_t* mutex
void thread_create(thread_id_t* thread, void* (*func)(void*), void* arg);
void thread_join(thread_id_t thread, void** retval);
void thread_yield(void);
int thread_key_create(thread_key_t* key, void (*destructor)(void*));
int thread_key_delete(thread_key_t key);
void* thread_getspecific(thread_key_t key);
int thread_setspecific(thread_key_t key, void* value);
#endif
/****************************************************************************/

45
cmdline/sync.c
View file

@ -37,8 +37,6 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
unsigned soft_error;
unsigned silent_error;
unsigned io_error;
char esc_buffer[ESC_MAX];
/* maps the disks to handles */
handle = handle_mapping(state, &diskmax);
@ -137,7 +135,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
/* LCOV_EXCL_START */
/* This one is really an unexpected error, because we are only reading */
/* and closing a descriptor should never fail */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", blockcur);
@ -153,7 +151,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
ret = handle_open(&handle[j], file, state->file_mode, log_error, log_error); /* output a message for missing files */
if (ret == -1) {
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub), strerror(errno));
if (errno == ENOENT) {
log_error_errno(errno, disk->name);
@ -178,7 +176,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
log_fatal(errno, "Stopping at block %u\n", blockcur);
++io_error;
} else {
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, file->sub, esc_buffer));
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, file->sub));
++soft_error;
}
goto bail;
@ -192,14 +190,14 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
|| handle[j].st.st_ino != file->inode
) {
if (handle[j].st.st_size != file->size) {
log_tag("error:%u:%s:%s: Unexpected size change\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer));
log_tag("error:%u:%s:%s: Unexpected size change\n", blockcur, disk->name, esc_tag(file->sub));
log_error(ESOFT, "Unexpected size change at file '%s' from %" PRIu64 " to %" PRIu64 ".\n", handle[j].path, file->size, (uint64_t)handle[j].st.st_size);
} else if (handle[j].st.st_mtime != file->mtime_sec
|| STAT_NSEC(&handle[j].st) != file->mtime_nsec) {
log_tag("error:%u:%s:%s: Unexpected time change\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer));
log_tag("error:%u:%s:%s: Unexpected time change\n", blockcur, disk->name, esc_tag(file->sub));
log_error(ESOFT, "Unexpected time change at file '%s' from %" PRIu64 ".%d to %" PRIu64 ".%d.\n", handle[j].path, file->mtime_sec, file->mtime_nsec, (uint64_t)handle[j].st.st_mtime, STAT_NSEC(&handle[j].st));
} else {
log_tag("error:%u:%s:%s: Unexpected inode change\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer));
log_tag("error:%u:%s:%s: Unexpected inode change\n", blockcur, disk->name, esc_tag(file->sub));
log_error(ESOFT, "Unexpected inode change from %" PRIu64 " to %" PRIu64 " at file '%s'.\n", file->inode, (uint64_t)handle[j].st.st_ino, handle[j].path);
}
log_error_errno(ENOENT, disk->name); /* same message for ENOENT */
@ -214,14 +212,14 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
read_size = handle_read(&handle[j], file_pos, buffer, state->block_size, log_fatal, 0);
if (read_size == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub, esc_buffer), file_pos, strerror(errno));
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub), file_pos, strerror(errno));
log_fatal_errno(errno, disk->name);
if (is_hw(errno)) {
log_fatal(errno, "Stopping at block %u\n", blockcur);
++io_error;
} else {
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, file->sub, esc_buffer));
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, file->sub));
++soft_error;
}
goto bail;
@ -248,7 +246,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, BLOCK_HASH_SIZE) != 0) {
log_tag("error_data:%u:%s:%s: Unexpected data change\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer));
log_tag("error_data:%u:%s:%s: Unexpected data change\n", blockcur, disk->name, esc_tag(file->sub));
log_error(EDATA, "Data change at file '%s' at position '%u'\n", handle[j].path, file_pos);
log_error(EDATA, "WARNING! Unexpected data modification of a file without parity!\n");
@ -299,7 +297,7 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta
/* LCOV_EXCL_START */
/* This one is really an unexpected error, because we are only reading */
/* and closing a descriptor should never fail */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockmax, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockmax, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", blockmax);
@ -346,7 +344,7 @@ bail:
ret = handle_close(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
if (is_hw(errno)) {
@ -462,8 +460,6 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
block_off_t blockcur = task->position;
unsigned char* buffer = task->buffer;
int ret;
char esc_buffer[ESC_MAX];
/* if the disk position is not used */
if (!disk) {
/* use an empty block */
@ -496,7 +492,7 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
/* LCOV_EXCL_START */
/* This one is really an unexpected error, because we are only reading */
/* and closing a descriptor should never fail */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(report->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping at block %u\n", blockcur);
@ -512,7 +508,7 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
ret = handle_open(handle, task->file, state->file_mode, log_error, log_error); /* output a message for missing files */
if (ret == -1) {
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Open error. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub), strerror(errno));
if (errno == ENOENT) {
log_error_errno(errno, disk->name);
@ -537,7 +533,7 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
log_fatal(errno, "Stopping at block %u\n", blockcur);
task->state = TASK_STATE_IOERROR;
} else {
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, task->file->sub, esc_buffer));
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, task->file->sub));
task->state = TASK_STATE_ERROR;
}
return;
@ -550,7 +546,7 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
|| STAT_NSEC(&handle->st) != task->file->mtime_nsec
|| handle->st.st_ino != task->file->inode
) {
log_tag("error:%u:%s:%s: Unexpected attribute change\n", blockcur, disk->name, esc_tag(task->file->sub, esc_buffer));
log_tag("error:%u:%s:%s: Unexpected attribute change\n", blockcur, disk->name, esc_tag(task->file->sub));
if (handle->st.st_size != task->file->size) {
log_error(ESOFT, "Unexpected size change at file '%s' from %" PRIu64 " to %" PRIu64 ".\n", handle->path, task->file->size, (uint64_t)handle->st.st_size);
} else if (handle->st.st_mtime != task->file->mtime_sec
@ -570,7 +566,7 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
task->read_size = handle_read(handle, task->file_pos, buffer, state->block_size, log_error, 0);
if (task->read_size == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub, esc_buffer), task->file_pos, strerror(errno));
log_tag("%s:%u:%s:%s: Read error at position %u. %s.\n", es(errno), blockcur, disk->name, esc_tag(task->file->sub), task->file_pos, strerror(errno));
if (is_hw(errno)) {
log_error_errno(errno, disk->name);
@ -578,7 +574,7 @@ static void sync_data_reader(struct snapraid_worker* worker, struct snapraid_tas
task->state = TASK_STATE_IOERROR_CONTINUE;
} else {
log_fatal_errno(errno, disk->name);
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, task->file->sub, esc_buffer));
log_fatal(errno, "Stopping to allow recovery. Try with 'snapraid check -f /%s'\n", fmt_poll(disk, task->file->sub));
task->state = TASK_STATE_ERROR;
}
return;
@ -654,7 +650,6 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
unsigned l;
unsigned* waiting_map;
unsigned waiting_mac;
char esc_buffer[ESC_MAX];
bit_vect_t* block_enabled;
/* the sync process assumes that all the hashes are correct */
@ -919,7 +914,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
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_tag(file->sub, esc_buffer));
log_tag("error:%u:%s:%s: Unexpected data change\n", blockcur, disk->name, esc_tag(file->sub));
log_error(ESOFT, "Data change at file '%s' at position '%u'\n", task->path, file_pos);
log_error(ESOFT, "WARNING! Unexpected data modification of a file without parity!\n");
@ -940,7 +935,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari
continue;
} else { /* otherwise it's a BLK with silent error */
unsigned diff = memdiff(hash, block->hash, BLOCK_HASH_SIZE);
log_tag("error_data:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", blockcur, disk->name, esc_tag(file->sub, esc_buffer), file_pos, diff, BLOCK_HASH_SIZE * 8);
log_tag("error_data:%u:%s:%s: Data error at position %u, diff hash bits %u/%u\n", blockcur, disk->name, esc_tag(file->sub), file_pos, diff, BLOCK_HASH_SIZE * 8);
log_error(EDATA, "Data error in file '%s' at position '%u', diff hash bits %u/%u\n", task->path, file_pos, diff, BLOCK_HASH_SIZE * 8);
/* save the failed block for the fix */
@ -1390,7 +1385,7 @@ bail:
ret = handle_close(&handle[j]);
if (ret == -1) {
/* LCOV_EXCL_START */
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub, esc_buffer), strerror(errno));
log_tag("%s:%u:%s:%s: Close error. %s.\n", es(errno), blockcur, disk->name, esc_tag(file->sub), strerror(errno));
log_fatal_errno(errno, disk->name);
if (is_hw(errno)) {

6
cmdline/touch.c
View file

@ -11,8 +11,6 @@
void state_touch(struct snapraid_state* state)
{
tommy_node* i;
char esc_buffer[ESC_MAX];
msg_progress("Setting sub-second timestamps...\n");
/* for all disks */
@ -123,8 +121,8 @@ void state_touch(struct snapraid_state* state)
/* state changed, we need to update it */
state->need_write = 1;
log_tag("touch:%s:%s: %" PRIu64 ".%d\n", disk->name, esc_tag(file->sub, esc_buffer), (uint64_t)st.st_mtime, STAT_NSEC(&st));
msg_info("touch %s\n", fmt_term(disk, file->sub, esc_buffer));
log_tag("touch:%s:%s: %" PRIu64 ".%d\n", disk->name, esc_tag(file->sub), (uint64_t)st.st_mtime, STAT_NSEC(&st));
msg_info("touch %s\n", fmt_term(disk, file->sub));
}
}
}

17
cmdline/unix.c
View file

@ -2710,7 +2710,6 @@ int ambient_temperature(void)
int devmap(void)
{
#if HAVE_LINUX_DEVICE
char esc_buffer[ESC_MAX];
char path[PATH_MAX];
DIR* d = opendir("/sys/block");
if (!d)
@ -2735,49 +2734,49 @@ int devmap(void)
/* device/serial */
pathprint(path, sizeof(path), "/sys/block/%s/device/serial", dd->d_name);
if (sysattr(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
/* device/vpd_pg80 */
pathprint(path, sizeof(path), "/sys/block/%s/device/vpd_pg80", dd->d_name);
if (sysattr_vpd_pg80(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
/* device/vpd_pg83 */
pathprint(path, sizeof(path), "/sys/block/%s/device/vpd_pg83", dd->d_name);
if (sysattr_vpd_pg83(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:naa.%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:naa.%s\n", dd->d_name, esc_tag(buf));
}
/* device/WWN */
pathprint(path, sizeof(path), "/sys/block/%s/device/wwn", dd->d_name);
if (sysattr(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
/* device/WWID */
pathprint(path, sizeof(path), "/sys/block/%s/device/wwid", dd->d_name);
if (sysattr(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
/* WWN */
pathprint(path, sizeof(path), "/sys/block/%s/wwn", dd->d_name);
if (sysattr(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
/* WWID */
pathprint(path, sizeof(path), "/sys/block/%s/wwid", dd->d_name);
if (sysattr(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
/* uuid */
pathprint(path, sizeof(path), "/sys/block/%s/uuid", dd->d_name);
if (sysattr(path, buf, sizeof(buf)) == 0 && buf[0] != 0) {
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf, esc_buffer));
log_tag("map:/dev/%s:%s\n", dd->d_name, esc_tag(buf));
}
}

1
cmdline/unix.h
View file

@ -66,6 +66,7 @@ size_t direct_size(void);
typedef pthread_t thread_id_t;
typedef pthread_mutex_t thread_mutex_t;
typedef pthread_cond_t thread_cond_t;
typedef pthread_key_t thread_key_t;
#endif
#endif