From e56de653dac2f3a993d3e57b260844ea67e07bbb Mon Sep 17 00:00:00 2001 From: Andrea Mazzoleni Date: Sun, 22 Feb 2015 14:31:03 +0100 Subject: [PATCH] Introduce a new messaging system --- HISTORY | 41 +-- Makefile.am | 4 +- cmdline/check.c | 356 ++++++++++--------- cmdline/device.c | 24 +- cmdline/dry.c | 38 ++- cmdline/dup.c | 24 +- cmdline/elem.c | 12 +- cmdline/elem.h | 4 +- cmdline/handle.c | 20 +- cmdline/import.c | 32 +- cmdline/list.c | 29 +- cmdline/mingw.c | 66 ++-- cmdline/mktest.c | 80 ++--- cmdline/nano.c | 18 +- cmdline/parity.c | 44 +-- cmdline/pool.c | 42 ++- cmdline/rehash.c | 14 +- cmdline/scan.c | 283 ++++++++------- cmdline/scrub.c | 135 ++++---- cmdline/search.c | 38 +-- cmdline/selftest.c | 38 +-- cmdline/snapraid.c | 154 ++++----- cmdline/state.c | 831 ++++++++++++++++++++++----------------------- cmdline/state.h | 2 - cmdline/status.c | 76 ++--- cmdline/support.c | 159 ++++++--- cmdline/support.h | 112 ++++-- cmdline/sync.c | 355 +++++++++---------- cmdline/unix.c | 60 ++-- cmdline/util.c | 6 +- snapraid.1 | 21 +- snapraid.d | 21 +- snapraid.txt | 21 +- 33 files changed, 1642 insertions(+), 1518 deletions(-) diff --git a/HISTORY b/HISTORY index 305925ba..4ca75d54 100644 --- a/HISTORY +++ b/HISTORY @@ -3,32 +3,35 @@ SnapRAID HISTORY 8.0 2015/02 BETA ================ - * Changes the log handling. If no log file is specified, all the - log goes to stderr. If a log file is specified, only the most - serious errors are printed on the screen. - This applies to all commands. + * Allows "sync" and "scrub" to continue after the first bunch of disk + errors. Blocks with errors are marked as bad, and you can fix them + with the "fix -e" command. + The fix is expected to force the disk firmware to reallocate the + bad sector, likely fixing the problem. + You can control the number of allowed errors with the new + -L, --error-limit option. The default is 100. + * The -e, --filter-error option doesn't write anymore fixes to + unsynced files. This helps in case you are running it on a not + synced array, removing the risk to revert some files to an old state. + * The -e, --filter-error option is now optimal and read only the minimal + amount of data necessary to fix the errors. * Adds new "smart" command to print a SMART report of the array. * Adds new "up" and "down" commands to spin up and down the disks of the array. - * Allows "sync" and "scrub" to continue after the first - bunch of disk errors. Blocks with errors are marked as bad, - and you can fix them with the "fix -e" command. - The fix is expected to force the disk firmware to reallocate - the bad sector, likely fixing the problem. - You can control the number of allowed errors with the new - -L, --error-limit option. The default is 100. - * The -e, --filter-error option doesn't write anymore fixes - to unsynced files. This helps in case you are running it on a - not synced array, removing the risk to revert some files to an - old state. - * The -e, --filter-error option is more efficient and triggers - a lot less data to be read. + * Changes the log handling. If no log file is specified, all the + warnings and not fatal errors messages goes to stderr. If a log file + is specified, only fatal error messages are printed on the screen. + You can control the amount of informative messages on stdout with + the -q, --quiet and -v, --verbose options, that can be specified + multiple times to be more quiet or verbose. * In the "status" command the "Wasted" column now shows a negative - number for the amount of space that you can still waste. + number for the amount of space that you can still waste without + filling up the parity. * Renames the -s and -t options to -S and -B as they are intended to be manual only operations. * Windows binary built with gcc 4.8.1 using the MXE cross compiler 2.23, - with targets i686-w64-mingw32 and x86_64-w64-mingw32. + with targets i686-w64-mingw32 and x86_64-w64-mingw32. Before the x86 + target was i686-pc-mingw32. 7.1 2015/01 =========== diff --git a/Makefile.am b/Makefile.am index 8b2d7ab1..e3972dac 100644 --- a/Makefile.am +++ b/Makefile.am @@ -150,13 +150,13 @@ maintainer-clean-local: CHECKFLAGS_BASE = --test-skip-device --test-skip-self --test-force-order-alpha --test-force-progress # Physical offset options -CHECKFLAGS_PHYSICAL = --test-skip-device --test-skip-self --test-force-order-physical -q +CHECKFLAGS_PHYSICAL = --test-skip-device --test-skip-self --test-force-order-physical -q -q -q # Verbose options CHECKFLAGS_VERBOSE = $(CHECKFLAGS_BASE) -v -G # Quiet options -CHECKFLAGS = $(CHECKFLAGS_BASE) -q +CHECKFLAGS = $(CHECKFLAGS_BASE) -q -q -q # Number of files to create CHECKCOUNT = 1000 diff --git a/cmdline/check.c b/cmdline/check.c index c19c5baf..4f9a9006 100644 --- a/cmdline/check.c +++ b/cmdline/check.c @@ -112,7 +112,7 @@ static int is_hash_matching(struct snapraid_state* state, int rehash, unsigned d ) { /* if a hash doesn't match, fail the check */ if (blockcmp(state, rehash, failed[failed_map[j]].block, buffer[failed[failed_map[j]].index], buffer_zero) != 0) { - ftag("hash_error: Hash mismatch on entry %u\n", failed_map[j]); + msg_tag("hash_error: Hash mismatch on entry %u\n", failed_map[j]); return 0; } @@ -223,13 +223,13 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u return 0; /* log */ - ftag("parity_error:%u:", pos); + msg_tag("parity_error:%u:", pos); for (i = 0; i < r; ++i) { if (i != 0) - ftag("/"); - ftag("%s", lev_config_name(ip[i])); + msg_tag("/"); + msg_tag("%s", lev_config_name(ip[i])); } - ftag(":parity: Parity mismatch\n"); + msg_tag(":parity: Parity mismatch\n"); ++error; } while (combination_next(r, n, ip)); } @@ -263,13 +263,13 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u return 0; /* log */ - ftag("parity_error:%u:", pos); + msg_tag("parity_error:%u:", pos); for (i = 0; i < r; ++i) { if (i != 0) - ftag("/"); - ftag("%s", lev_config_name(ip[i])); + msg_tag("/"); + msg_tag("%s", lev_config_name(ip[i])); } - ftag(":hash: Hash mismatch\n"); + msg_tag(":hash: Hash mismatch\n"); ++error; } while (combination_next(r, n, ip)); } @@ -278,7 +278,7 @@ static int repair_step(struct snapraid_state* state, int rehash, unsigned pos, u if (error) return error; - ftag("strategy_error:%u: No strategy to recover from %u failures with %u parity %s hash\n", + msg_tag("strategy_error:%u: No strategy to recover from %u failures with %u parity %s hash\n", pos, failed_count, n, has_hash ? "with" : "without"); return -1; } @@ -338,9 +338,9 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign disk = handle->disk->name; sub = block_file_get(block)->sub; - ftag("entry:%u:%s:%s:%s:%s:%s:%u:\n", j, state, hash, data, disk, esc(sub), block_file_pos(block)); + msg_tag("entry:%u:%s:%s:%s:%s:%s:%u:\n", j, state, hash, data, disk, esc(sub), block_file_pos(block)); } else { - ftag("entry:%u:%s:%s:%s:\n", j, state, hash, data); + msg_tag("entry:%u:%s:%s:%s:\n", j, state, hash, data); } } @@ -375,7 +375,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign || state_search_fetch(state, rehash, failed[j].block, buffer[failed[j].index]) == 0) ) { /* we already have corrected it! */ - ftag("hash_import: Fixed entry %u\n", j); + msg_tag("hash_import: Fixed entry %u\n", j); } else { /* otherwise try to recover it */ failed_map[n] = j; @@ -389,7 +389,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign /* if nothing to fix */ if (!something_to_recover) { - ftag("recover_sync:%u:%u: Skipped for already recovered\n", pos, n); + msg_tag("recover_sync:%u:%u: Skipped for already recovered\n", pos, n); /* recompute only the parity */ raid_gen(diskmax, state->level, state->block_size, buffer); @@ -423,7 +423,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign /* it may contain garbage */ failed[j].is_outofdate = 1; - ftag("hash_unknown: Unknown hash on entry %u\n", j); + msg_tag("hash_unknown: Unknown hash on entry %u\n", j); } else if (hash_is_zero(failed[j].block->hash)) { /* if the block is not filled with 0, we are sure to have */ /* restored it to the state after the 'sync' */ @@ -434,7 +434,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign /* it may contain garbage */ failed[j].is_outofdate = 1; - ftag("hash_unknown: Maybe old zero on entry %u\n", j); + msg_tag("hash_unknown: Maybe old zero on entry %u\n", j); } } else { /* if the hash is different than the previous one, we are sure to have */ @@ -446,7 +446,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign /* it may contain garbage */ failed[j].is_outofdate = 1; - ftag("hash_unknown: Maybe old data on entry %u\n", j); + msg_tag("hash_unknown: Maybe old data on entry %u\n", j); } } } @@ -458,9 +458,9 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign error += ret; if (ret < 0) - ftag("recover_sync:%u:%u: Failed with no attempts\n", pos, n); + msg_tag("recover_sync:%u:%u: Failed with no attempts\n", pos, n); else - ftag("recover_sync:%u:%u: Failed with %d attempts\n", pos, n, ret); + msg_tag("recover_sync:%u:%u: Failed with %d attempts\n", pos, n, ret); /* Now assume that the parity IS NOT updated at the current state, */ /* but still represent the state before the last 'sync' process. */ @@ -556,7 +556,7 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign /* and we don't want to write it to the disk */ failed[j].is_outofdate = 1; - ftag("hash_unknown: Surely old data on entry %u\n", j); + msg_tag("hash_unknown: Surely old data on entry %u\n", j); } } } @@ -567,11 +567,11 @@ static int repair(struct snapraid_state* state, int rehash, unsigned pos, unsign error += ret; if (ret < 0) - ftag("recover_unsync:%u:%u: Failed with no attempts\n", pos, n); + msg_tag("recover_unsync:%u:%u: Failed with no attempts\n", pos, n); else - ftag("recover_unsync:%u:%u: Failed with %d attempts\n", pos, n, ret); + msg_tag("recover_unsync:%u:%u: Failed with %d attempts\n", pos, n, ret); } else { - ftag("recover_unsync:%u:%u: Skipped for%s%s\n", pos, n, + msg_tag("recover_unsync:%u:%u: Skipped for%s%s\n", pos, n, !something_to_recover ? " nothing to recover" : "", !something_unsynced ? " nothing unsynched" : "" ); @@ -636,7 +636,7 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s /* or at least pointing to NULL, in case it cannot be opened. */ if (handle[j].file != 0 && handle[j].file != file) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in opened file for block %u\n", block->parity_pos); + msg_error("Internal inconsistency in opened file for block %u\n", block->parity_pos); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -658,8 +658,8 @@ 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 */ - ferr("Error closing '%s'. %s.\n", path, strerror(errno)); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Error closing '%s'. %s.\n", path, strerror(errno)); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); return -1; /* LCOV_EXCL_STOP */ } @@ -667,16 +667,14 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s ret = rename(path, path_to); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error renaming '%s' to '%s'. %s.\n", path, path_to, strerror(errno)); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Error renaming '%s' to '%s'. %s.\n", path, path_to, strerror(errno)); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); return -1; /* LCOV_EXCL_STOP */ } - ftag("status:unrecoverable:%s:%s\n", disk->name, esc(file->sub)); - if (!state->opt.quiet) { - fout("unrecoverable %s\n", path); - } + msg_tag("status:unrecoverable:%s:%s\n", disk->name, esc(file->sub)); + msg_info("unrecoverable %s\n", path); /* and do not set the time if damaged */ goto close_and_continue; @@ -688,10 +686,8 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s goto close_and_continue; } - ftag("status:recovered:%s:%s\n", disk->name, esc(file->sub)); - if (!state->opt.quiet) { - fout("recovered %s\n", path); - } + msg_tag("status:recovered:%s:%s\n", disk->name, esc(file->sub)); + msg_info("recovered %s\n", path); inode = handle[j].st.st_ino; @@ -718,38 +714,32 @@ static int file_post(struct snapraid_state* state, int fix, unsigned i, struct s /* LCOV_EXCL_START */ /* mark the file as damaged */ file_flag_set(file, FILE_IS_DAMAGED); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); return -1; /* LCOV_EXCL_STOP */ } } else { - ftag("collision:%s:%s:%s: Not setting modification time to avoid inode collision\n", disk->name, esc(file->sub), esc(collide_file->sub)); + msg_tag("collision:%s:%s:%s: Not setting modification time to avoid inode collision\n", disk->name, esc(file->sub), esc(collide_file->sub)); } } else { /* we are not fixing, but only checking */ /* print just the final status */ if (file_flag_has(file, FILE_IS_DAMAGED)) { if (state->opt.auditonly) { - ftag("status:damaged:%s:%s\n", disk->name, esc(file->sub)); - if (!state->opt.quiet) { - fout("damaged %s\n", path); - } + msg_tag("status:damaged:%s:%s\n", disk->name, esc(file->sub)); + msg_info("damaged %s\n", path); } else { - ftag("status:unrecoverable:%s:%s\n", disk->name, esc(file->sub)); - if (!state->opt.quiet) { - fout("unrecoverable %s\n", path); - } + msg_tag("status:unrecoverable:%s:%s\n", disk->name, esc(file->sub)); + msg_info("unrecoverable %s\n", path); } } else if (file_flag_has(file, FILE_IS_FIXED)) { - ftag("status:recoverable:%s:%s\n", disk->name, esc(file->sub)); - if (!state->opt.quiet) { - fout("recoverable %s\n", path); - } + msg_tag("status:recoverable:%s:%s\n", disk->name, esc(file->sub)); + msg_info("recoverable %s\n", path); } else { - ftag("status:correct:%s:%s\n", disk->name, esc(file->sub)); - if (state->opt.verbose) { - fout("correct %s\n", path); - } + msg_tag("status:correct:%s:%s\n", disk->name, esc(file->sub)); + /* we don't use msg_verbose() because it also goes into the log */ + if (msg_level >= MSG_VERBOSE) + msg_info("correct %s\n", path); } } @@ -762,8 +752,8 @@ close_and_continue: ret = handle_close(&handle[j]); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error closing '%s'. %s.\n", path, strerror(errno)); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Error closing '%s'. %s.\n", path, strerror(errno)); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); return -1; /* LCOV_EXCL_STOP */ } @@ -882,7 +872,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna /* post process the files */ ret = file_post(state, fix, i, handle, diskmax); if (ret == -1) { - ferr("Stopping at block %u\n", i); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; } @@ -977,8 +967,8 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = handle_close(&handle[j]); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected close error in a data disk, it isn't possible to check.\n"); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected close error in a data disk, it isn't possible to check.\n"); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -991,11 +981,11 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (ret == -1) { /* LCOV_EXCL_START */ if (errno == EACCES) { - ferr("WARNING! Please give write permission to the file.\n"); + msg_error("WARNING! Please give write permission to the file.\n"); } else { - ferr("DANGER! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("DANGER! Without a working data disk, it isn't possible to fix errors on it.\n"); } - ferr("Stopping at block %u\n", i); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1009,7 +999,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna } } else { /* otherwise, open the file only for reading */ - ret = handle_open(&handle[j], file, state->file_mode, flog); + ret = handle_open(&handle[j], file, state->file_mode, msg_warning); if (ret == -1) { /* save the failed block for the check/fix */ failed[failed_count].is_bad = 1; @@ -1019,7 +1009,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna failed[failed_count].handle = &handle[j]; ++failed_count; - ftag("error:%u:%s:%s: Open error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); + msg_tag("error:%u:%s:%s: Open error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); ++error; continue; } @@ -1046,22 +1036,22 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna && !(state->opt.syncedonly && file_flag_has(file, FILE_IS_UNSYNCED)) && handle[j].st.st_size > file->size ) { - flog("File '%s' is larger than expected.\n", handle[j].path); - ftag("error:%u:%s:%s: Size error\n", i, disk->name, esc(file->sub)); + msg_warning("File '%s' is larger than expected.\n", handle[j].path); + msg_tag("error:%u:%s:%s: Size error\n", i, disk->name, esc(file->sub)); ++error; if (fix) { ret = handle_truncate(&handle[j], file); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected truncate error in a data disk, it isn't possible to fix.\n"); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected truncate error in a data disk, it isn't possible to fix.\n"); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("fixed:%u:%s:%s: Fixed size\n", i, disk->name, esc(file->sub)); + msg_tag("fixed:%u:%s:%s: Fixed size\n", i, disk->name, esc(file->sub)); ++recovered_error; } } @@ -1073,7 +1063,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna } /* read from the file */ - read_size = handle_read(&handle[j], block, buffer[j], state->block_size, flog); + read_size = handle_read(&handle[j], block, buffer[j], state->block_size, msg_warning); if (read_size == -1) { /* save the failed block for the check/fix */ failed[failed_count].is_bad = 1; /* it's bad because we cannot read it */ @@ -1083,7 +1073,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna failed[failed_count].handle = &handle[j]; ++failed_count; - ftag("error:%u:%s:%s: Read error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); + msg_tag("error:%u:%s:%s: Read error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); ++error; continue; } @@ -1124,7 +1114,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna failed[failed_count].handle = &handle[j]; ++failed_count; - ftag("error:%u:%s:%s: Data error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); + msg_tag("error:%u:%s:%s: Data error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); ++error; continue; } @@ -1160,11 +1150,11 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna /* read the parity */ for (l = 0; l < state->level; ++l) { if (parity[l]) { - ret = parity_read(parity[l], i, buffer_recov[l], state->block_size, flog); + ret = parity_read(parity[l], i, buffer_recov[l], state->block_size, msg_warning); if (ret == -1) { buffer_recov[l] = 0; /* no parity to use */ - ftag("parity_error:%u:%s: Read error\n", i, lev_config_name(l)); + msg_tag("parity_error:%u:%s: Read error\n", i, lev_config_name(l)); ++error; } } else { @@ -1183,7 +1173,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) - ftag("unrecoverable:%u:%s:%s: Unrecoverable error at position %u\n", i, failed[j].handle->disk->name, esc(block_file_get(failed[j].block)->sub), block_file_pos(failed[j].block)); + msg_tag("unrecoverable:%u:%s:%s: Unrecoverable error at position %u\n", i, failed[j].handle->disk->name, esc(block_file_get(failed[j].block)->sub), block_file_pos(failed[j].block)); } /* keep track of damaged files */ @@ -1201,7 +1191,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; - ftag("unrecoverable:%u:%s:%s: Unrecoverable unsynced error at position %u\n", i, failed[j].handle->disk->name, esc(block_file_get(failed[j].block)->sub), block_file_pos(failed[j].block)); + msg_tag("unrecoverable:%u:%s:%s: Unrecoverable unsynced error at position %u\n", i, failed[j].handle->disk->name, esc(block_file_get(failed[j].block)->sub), block_file_pos(failed[j].block)); } } if (partial_recover_error != 0) { @@ -1218,7 +1208,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (buffer_recov[l] != 0 && memcmp(buffer_recov[l], buffer[diskmax + l], state->block_size) != 0) { buffer_recov[l] = 0; - ftag("parity_error:%u:%s: Data error\n", i, lev_config_name(l)); + msg_tag("parity_error:%u:%s: Data error\n", i, lev_config_name(l)); ++error; } } @@ -1244,12 +1234,12 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna file_flag_set(block_file_get(failed[j].block), FILE_IS_DAMAGED); if (errno == EACCES) { - ferr("WARNING! Please give write permission to the file.\n"); + msg_error("WARNING! Please give write permission to the file.\n"); } else { /* we do not use DANGER because it could be ENOSPC which is not always correctly reported */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); } - ferr("Stopping at block %u\n", i); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1266,7 +1256,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(block_file_get(failed[j].block), FILE_IS_FIXED); - ftag("fixed:%u:%s:%s: Fixed data error at position %u\n", i, failed[j].handle->disk->name, esc(block_file_get(failed[j].block)->sub), block_file_pos(failed[j].block)); + msg_tag("fixed:%u:%s:%s: Fixed data error at position %u\n", i, failed[j].handle->disk->name, esc(block_file_get(failed[j].block)->sub), block_file_pos(failed[j].block)); ++recovered_error; } @@ -1281,14 +1271,14 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (ret == -1) { /* LCOV_EXCL_START */ /* we do not use DANGER because it could be ENOSPC which is not always correctly reported */ - ferr("WARNING! Without a working %s disk, it isn't possible to fix errors on it.\n", lev_name(l)); - ferr("Stopping at block %u\n", i); + msg_error("WARNING! Without a working %s disk, it isn't possible to fix errors on it.\n", lev_name(l)); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("parity_fixed:%u:%s: Fixed data error\n", i, lev_config_name(l)); + msg_tag("parity_fixed:%u:%s: Fixed data error\n", i, lev_config_name(l)); ++recovered_error; } } @@ -1316,7 +1306,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna /* post process the files */ ret = file_post(state, fix, i, handle, diskmax); if (ret == -1) { - ferr("Stopping at block %u\n", i); + msg_error("Stopping at block %u\n", i); ++unrecoverable_error; goto bail; } @@ -1368,18 +1358,18 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (ret == -1) { unsuccesful = 1; - flog("Error stating empty file '%s'. %s.\n", path, strerror(errno)); - ftag("error:%s:%s: Empty file stat error\n", disk->name, esc(file->sub)); + msg_warning("Error stating empty file '%s'. %s.\n", path, strerror(errno)); + msg_tag("error:%s:%s: Empty file stat error\n", disk->name, esc(file->sub)); ++error; } else if (!S_ISREG(st.st_mode)) { unsuccesful = 1; - ftag("error:%s:%s: Empty file error for not regular file\n", disk->name, esc(file->sub)); + msg_tag("error:%s:%s: Empty file error for not regular file\n", disk->name, esc(file->sub)); ++error; } else if (st.st_size != 0) { unsuccesful = 1; - ftag("error:%s:%s: Empty file error for size '%" PRIu64 "'\n", disk->name, esc(file->sub), st.st_size); + msg_tag("error:%s:%s: Empty file error for size '%" PRIu64 "'\n", disk->name, esc(file->sub), st.st_size); ++error; } @@ -1390,8 +1380,8 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = mkancestor(path); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); - ferr("Stopping\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1402,14 +1392,14 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna f = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_NOFOLLOW, 0600); if (f == -1) { /* LCOV_EXCL_START */ - ferr("Error creating empty file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error creating empty file '%s'. %s.\n", path, strerror(errno)); if (errno == EACCES) { - ferr("WARNING! Please give write permission to the file.\n"); + msg_error("WARNING! Please give write permission to the file.\n"); } else { /* we do not use DANGER because it could be ENOSPC which is not always correctly reported */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); } - ferr("Stopping\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1421,9 +1411,9 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna /* LCOV_EXCL_START */ close(f); - ferr("Error timing file '%s'. %s.\n", file->sub, strerror(errno)); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); - ferr("Stopping\n"); + msg_error("Error timing file '%s'. %s.\n", file->sub, strerror(errno)); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1433,20 +1423,18 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = close(f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); - ferr("Stopping\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("fixed:%s:%s: Fixed empty file\n", disk->name, esc(file->sub)); + msg_tag("fixed:%s:%s: Fixed empty file\n", disk->name, esc(file->sub)); ++recovered_error; - ftag("status:recovered:%s:%s\n", disk->name, esc(file->sub)); - if (!state->opt.quiet) { - fout("recovered %s%s\n", disk->dir, file->sub); - } + msg_tag("status:recovered:%s:%s\n", disk->name, esc(file->sub)); + msg_info("recovered %s%s\n", disk->dir, file->sub); } } @@ -1478,13 +1466,13 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (ret == -1) { unsuccesful = 1; - flog("Error stating hardlink '%s'. %s.\n", path, strerror(errno)); - ftag("hardlinkerror:%s:%s:%s: Hardlink stat error\n", disk->name, esc(link->sub), esc(link->linkto)); + msg_warning("Error stating hardlink '%s'. %s.\n", path, strerror(errno)); + msg_tag("hardlinkerror:%s:%s:%s: Hardlink stat error\n", disk->name, esc(link->sub), esc(link->linkto)); ++error; } else if (!S_ISREG(st.st_mode)) { unsuccesful = 1; - ftag("hardlinkerror:%s:%s:%s: Hardlink error for not regular file\n", disk->name, esc(link->sub), esc(link->linkto)); + msg_tag("hardlinkerror:%s:%s:%s: Hardlink error for not regular file\n", disk->name, esc(link->sub), esc(link->linkto)); ++error; } @@ -1508,19 +1496,19 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna } } - flog("Error stating hardlink-to '%s'. %s.\n", pathto, strerror(errno)); - ftag("hardlinkerror:%s:%s:%s: Hardlink to stat error\n", disk->name, esc(link->sub), esc(link->linkto)); + msg_warning("Error stating hardlink-to '%s'. %s.\n", pathto, strerror(errno)); + msg_tag("hardlinkerror:%s:%s:%s: Hardlink to stat error\n", disk->name, esc(link->sub), esc(link->linkto)); ++error; } else if (!S_ISREG(stto.st_mode)) { unsuccesful = 1; - ftag("hardlinkerror:%s:%s:%s: Hardlink-to error for not regular file\n", disk->name, esc(link->sub), esc(link->linkto)); + msg_tag("hardlinkerror:%s:%s:%s: Hardlink-to error for not regular file\n", disk->name, esc(link->sub), esc(link->linkto)); ++error; } else if (!unsuccesful && st.st_ino != stto.st_ino) { unsuccesful = 1; - flog("Mismatch hardlink '%s' and '%s'. Different inode.\n", path, pathto); - ftag("hardlinkerror:%s:%s:%s: Hardlink mismatch for different inode\n", disk->name, esc(link->sub), esc(link->linkto)); + msg_warning("Mismatch hardlink '%s' and '%s'. Different inode.\n", path, pathto); + msg_tag("hardlinkerror:%s:%s:%s: Hardlink mismatch for different inode\n", disk->name, esc(link->sub), esc(link->linkto)); ++error; } } else { @@ -1530,14 +1518,14 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (ret < 0) { unsuccesful = 1; - flog("Error reading symlink '%s'. %s.\n", path, strerror(errno)); - ftag("symlinkerror:%s:%s: Symlink read error\n", disk->name, esc(link->sub)); + msg_warning("Error reading symlink '%s'. %s.\n", path, strerror(errno)); + msg_tag("symlinkerror:%s:%s: Symlink read error\n", disk->name, esc(link->sub)); ++error; } else if (ret >= PATH_MAX) { unsuccesful = 1; - flog("Error reading symlink '%s'. Symlink too long.\n", path); - ftag("symlinkerror:%s:%s: Symlink read error\n", disk->name, esc(link->sub)); + msg_warning("Error reading symlink '%s'. Symlink too long.\n", path); + msg_tag("symlinkerror:%s:%s: Symlink read error\n", disk->name, esc(link->sub)); ++error; } else { linkto[ret] = 0; @@ -1545,7 +1533,7 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (strcmp(linkto, link->linkto) != 0) { unsuccesful = 1; - ftag("symlinkerror:%s:%s: Symlink data error '%s' instead of '%s'\n", disk->name, esc(link->sub), linkto, link->linkto); + msg_tag("symlinkerror:%s:%s: Symlink data error '%s' instead of '%s'\n", disk->name, esc(link->sub), linkto, link->linkto); ++error; } } @@ -1556,8 +1544,8 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = mkancestor(path); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); - ferr("Stopping\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1567,9 +1555,9 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = remove(path); if (ret != 0 && errno != ENOENT) { /* LCOV_EXCL_START */ - ferr("Error removing '%s'. %s.\n", path, strerror(errno)); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); - ferr("Stopping\n"); + msg_error("Error removing '%s'. %s.\n", path, strerror(errno)); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1580,46 +1568,44 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = hardlink(pathto, path); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error writing hardlink '%s' to '%s'. %s.\n", path, pathto, strerror(errno)); + msg_error("Error writing hardlink '%s' to '%s'. %s.\n", path, pathto, strerror(errno)); if (errno == EACCES) { - ferr("WARNING! Please give write permission to the hardlink.\n"); + msg_error("WARNING! Please give write permission to the hardlink.\n"); } else { /* we do not use DANGER because it could be ENOSPC which is not always correctly reported */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); } - ferr("Stopping\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("hardlinkfixed:%s:%s: Fixed hardlink error\n", disk->name, esc(link->sub)); + msg_tag("hardlinkfixed:%s:%s: Fixed hardlink error\n", disk->name, esc(link->sub)); ++recovered_error; } else { ret = symlink(link->linkto, path); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error writing symlink '%s' to '%s'. %s.\n", path, link->linkto, strerror(errno)); + msg_error("Error writing symlink '%s' to '%s'. %s.\n", path, link->linkto, strerror(errno)); if (errno == EACCES) { - ferr("WARNING! Please give write permission to the symlink.\n"); + msg_error("WARNING! Please give write permission to the symlink.\n"); } else { /* we do not use DANGER because it could be ENOSPC which is not always correctly reported */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); } - ferr("Stopping\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("symlinkfixed:%s:%s: Fixed symlink error\n", disk->name, esc(link->sub)); + msg_tag("symlinkfixed:%s:%s: Fixed symlink error\n", disk->name, esc(link->sub)); ++recovered_error; } - ftag("status:recovered:%s:%s\n", disk->name, esc(link->sub)); - if (!state->opt.quiet) { - fout("recovered %s%s\n", disk->dir, link->sub); - } + msg_tag("status:recovered:%s:%s\n", disk->name, esc(link->sub)); + msg_info("recovered %s%s\n", disk->dir, link->sub); } } @@ -1646,13 +1632,13 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna if (ret == -1) { unsuccesful = 1; - flog("Error stating dir '%s'. %s.\n", path, strerror(errno)); - ftag("dir_error:%s:%s: Dir stat error\n", disk->name, esc(dir->sub)); + msg_warning("Error stating dir '%s'. %s.\n", path, strerror(errno)); + msg_tag("dir_error:%s:%s: Dir stat error\n", disk->name, esc(dir->sub)); ++error; } else if (!S_ISDIR(st.st_mode)) { unsuccesful = 1; - ftag("dir_error:%s:%s: Dir error for not directory\n", disk->name, esc(dir->sub)); + msg_tag("dir_error:%s:%s: Dir error for not directory\n", disk->name, esc(dir->sub)); ++error; } @@ -1661,8 +1647,8 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = mkancestor(path); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); - ferr("Stopping\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ @@ -1672,26 +1658,24 @@ static int state_check_process(struct snapraid_state* state, int fix, struct sna ret = mkdir(path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error creating dir '%s'. %s.\n", path, strerror(errno)); + msg_error("Error creating dir '%s'. %s.\n", path, strerror(errno)); if (errno == EACCES) { - ferr("WARNING! Please give write permission to the dir.\n"); + msg_error("WARNING! Please give write permission to the dir.\n"); } else { /* we do not use DANGER because it could be ENOSPC which is not always correctly reported */ - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); } - ferr("Stopping\n"); + msg_error("Stopping\n"); ++unrecoverable_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("dir_fixed:%s:%s: Fixed dir error\n", disk->name, esc(dir->sub)); + msg_tag("dir_fixed:%s:%s: Fixed dir error\n", disk->name, esc(dir->sub)); ++recovered_error; - ftag("status:recovered:%s:%s\n", disk->name, esc(dir->sub)); - if (!state->opt.quiet) { - fout("recovered %s%s\n", disk->dir, dir->sub); - } + msg_tag("status:recovered:%s:%s\n", disk->name, esc(dir->sub)); + msg_info("recovered %s%s\n", disk->dir, dir->sub); } } } @@ -1704,7 +1688,7 @@ bail: ret = handle_close(&handle[j]); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected close error in a data disk.\n"); + msg_error("DANGER! Unexpected close error in a data disk.\n"); ++unrecoverable_error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ @@ -1752,8 +1736,8 @@ bail: ret = remove(path); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error removing '%s'. %s.\n", path, strerror(errno)); - ferr("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); + msg_error("Error removing '%s'. %s.\n", path, strerror(errno)); + msg_error("WARNING! Without a working data disk, it isn't possible to fix errors on it.\n"); ++unrecoverable_error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ @@ -1763,53 +1747,55 @@ bail: } if (error || recovered_error || unrecoverable_error) { - fout("\n"); - fout("%8u read/data errors\n", error); + msg_status("\n"); + msg_status("%8u errors\n", error); if (fix) { - fout("%8u recovered errors\n", recovered_error); + msg_status("%8u recovered errors\n", recovered_error); } if (unrecoverable_error) { - fout("%8u UNRECOVERABLE errors\n", unrecoverable_error); - fout("DANGER! There are unrecoverable errors!\n"); + msg_status("%8u UNRECOVERABLE errors\n", unrecoverable_error); } else { /* without checking, we don't know if they are really recoverable or not */ if (!state->opt.auditonly) - fout("%8u unrecoverable errors\n", unrecoverable_error); + msg_status("%8u unrecoverable errors\n", unrecoverable_error); if (fix) - fout("Everything OK\n"); - else - fout("WARNING! There are errors!\n"); + msg_status("Everything OK\n"); } } else { - fout("Everything OK\n"); + msg_status("Everything OK\n"); } - ftag("summary:error:%u\n", error); + if (error && !fix) + msg_error("WARNING! There are errors!\n"); + if (unrecoverable_error) + msg_error("DANGER! There are unrecoverable errors!\n"); + + msg_tag("summary:error:%u\n", error); if (fix) - ftag("summary:error_recovered:%u\n", recovered_error); + msg_tag("summary:error_recovered:%u\n", recovered_error); if (!state->opt.auditonly) - ftag("summary:error_unrecoverable:%u\n", unrecoverable_error); + msg_tag("summary:error_unrecoverable:%u\n", unrecoverable_error); if (fix) { if (error + recovered_error + unrecoverable_error == 0) - ftag("summary:exit:ok\n"); + msg_tag("summary:exit:ok\n"); else if (unrecoverable_error == 0) - ftag("summary:exit:recovered\n"); + msg_tag("summary:exit:recovered\n"); else - ftag("summary:exit:unrecoverable\n"); + msg_tag("summary:exit:unrecoverable\n"); } else if (!state->opt.auditonly) { if (error + unrecoverable_error == 0) - ftag("summary:exit:ok\n"); + msg_tag("summary:exit:ok\n"); else if (unrecoverable_error == 0) - ftag("summary:exit:recoverable\n"); + msg_tag("summary:exit:recoverable\n"); else - ftag("summary:exit:unrecoverable\n"); + msg_tag("summary:exit:unrecoverable\n"); } else { /* audit only */ if (error == 0) - ftag("summary:exit:ok\n"); + msg_tag("summary:exit:ok\n"); else - ftag("summary:exit:error\n"); + msg_tag("summary:exit:error\n"); } - fflush_log(); + msg_flush(); free(failed); free(failed_map); @@ -1853,14 +1839,14 @@ int state_check(struct snapraid_state* state, int fix, block_off_t blockstart, b unsigned error; unsigned l; - fout("Initializing...\n"); + msg_progress("Initializing...\n"); blockmax = parity_allocated_size(state); size = blockmax * (data_off_t)state->block_size; if (blockstart > blockmax) { /* LCOV_EXCL_START */ - ferr("Error in the specified starting block %u. It's bigger than the parity size %u.\n", blockstart, blockmax); + msg_error("Error in the specified starting block %u. It's bigger than the parity size %u.\n", blockstart, blockmax); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1878,7 +1864,7 @@ int state_check(struct snapraid_state* state, int fix, block_off_t blockstart, b ret = parity_create(parity_ptr[l], state->parity[l].path, &out_size, state->file_mode); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("WARNING! Without an accessible %s file, it isn't possible to fix any error.\n", lev_name(l)); + msg_error("WARNING! Without an accessible %s file, it isn't possible to fix any error.\n", lev_name(l)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1886,7 +1872,7 @@ int state_check(struct snapraid_state* state, int fix, block_off_t blockstart, b ret = parity_chsize(parity_ptr[l], size, &out_size, state->opt.skip_fallocate); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("WARNING! Without an accessible %s file, it isn't possible to sync.\n", lev_name(l)); + msg_error("WARNING! Without an accessible %s file, it isn't possible to sync.\n", lev_name(l)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1898,7 +1884,7 @@ int state_check(struct snapraid_state* state, int fix, block_off_t blockstart, b parity_ptr[l] = &parity[l]; ret = parity_open(parity_ptr[l], state->parity[l].path, state->file_mode); if (ret == -1) { - fout("No accessible %s file, only files will be checked.\n", lev_name(l)); + msg_status("No accessible %s file, only files will be checked.\n", lev_name(l)); /* continue anyway */ parity_ptr[l] = 0; } @@ -1910,11 +1896,11 @@ int state_check(struct snapraid_state* state, int fix, block_off_t blockstart, b } if (fix) - fout("Fixing...\n"); + msg_progress("Fixing...\n"); else if (!state->opt.auditonly) - fout("Checking...\n"); + msg_progress("Checking...\n"); else - fout("Hashing...\n"); + msg_progress("Hashing...\n"); error = 0; @@ -1935,7 +1921,7 @@ int state_check(struct snapraid_state* state, int fix, block_off_t blockstart, b ret = parity_close(parity_ptr[l]); /* LCOV_EXCL_START */ if (ret == -1) { - ferr("DANGER! Unexpected close error in %s disk.\n", lev_name(l)); + msg_error("DANGER! Unexpected close error in %s disk.\n", lev_name(l)); ++error; /* continue, as we are already exiting */ } diff --git a/cmdline/device.c b/cmdline/device.c index e849d1f9..4faab803 100644 --- a/cmdline/device.c +++ b/cmdline/device.c @@ -710,7 +710,7 @@ static void printp(double v, size_t pad) printl(buf, pad); } -static void state_smart(int verbose, unsigned n, tommy_list* low) +static void state_smart(unsigned n, tommy_list* low) { tommy_node* i; unsigned j; @@ -846,17 +846,17 @@ static void state_smart(int verbose, unsigned n, tommy_list* low) printf("\n"); - ftag("smart:%s:%s:%s:%g\n", devinfo->file, devinfo->name, esc(devinfo->smart_serial), afr); + msg_tag("smart:%s:%s:%s:%g\n", devinfo->file, devinfo->name, esc(devinfo->smart_serial), afr); for (j = 0; j < 256; ++j) { if (devinfo->smart[j] != SMART_UNASSIGNED) - ftag("attr:%s:%u:%" PRIu64 "\n", devinfo->file, j, devinfo->smart[j]); + msg_tag("attr:%s:%u:%" PRIu64 "\n", devinfo->file, j, devinfo->smart[j]); } if (devinfo->smart[SMART_SIZE] != SMART_UNASSIGNED) - ftag("attr:%s:size:%" PRIu64 "\n", devinfo->file, devinfo->smart[SMART_SIZE]); + msg_tag("attr:%s:size:%" PRIu64 "\n", devinfo->file, devinfo->smart[SMART_SIZE]); if (devinfo->smart[SMART_ERROR] != SMART_UNASSIGNED) - ftag("attr:%s:error:%" PRIu64 "\n", devinfo->file, devinfo->smart[SMART_ERROR]); + msg_tag("attr:%s:error:%" PRIu64 "\n", devinfo->file, devinfo->smart[SMART_ERROR]); if (devinfo->smart[SMART_ROTATION_RATE] != SMART_UNASSIGNED) - ftag("attr:%s:rotationrate:%" PRIu64 "\n", devinfo->file, devinfo->smart[SMART_ROTATION_RATE]); + msg_tag("attr:%s:rotationrate:%" PRIu64 "\n", devinfo->file, devinfo->smart[SMART_ROTATION_RATE]); } printf("\n"); @@ -873,10 +873,10 @@ static void state_smart(int verbose, unsigned n, tommy_list* low) p_at_least_one_failure = poisson_prob_n_or_more_failures(array_failure_rate, 1); printf("Probability that one disk is going to fail in the next year is %.0f%%,\n", p_at_least_one_failure * 100); - ftag("summary:array_failure:%g:%g\n", array_failure_rate, p_at_least_one_failure); + msg_tag("summary:array_failure:%g:%g\n", array_failure_rate, p_at_least_one_failure); /* prints extra stats only in verbose mode */ - if (!verbose) + if (msg_level < MSG_VERBOSE) return; /* |<##################################################################72>|####80>| */ @@ -923,8 +923,8 @@ void state_device(struct snapraid_state* state, int operation) tommy_list low; switch (operation) { - case DEVICE_UP : printf("Spinup...\n"); break; - case DEVICE_DOWN : printf("Spindown...\n"); break; + case DEVICE_UP : msg_progress("Spinup...\n"); break; + case DEVICE_DOWN : msg_progress("Spindown...\n"); break; } tommy_list_init(&high); @@ -966,7 +966,7 @@ void state_device(struct snapraid_state* state, int operation) case DEVICE_LIST : ope = "List"; break; case DEVICE_SMART : ope = "SMART"; break; } - ferr("%s unsupported in this platform.\n", ope); + msg_error("%s unsupported in this platform.\n", ope); } else { if (operation == DEVICE_LIST) { for (i = tommy_list_head(&low); i != 0; i = i->next) { @@ -981,7 +981,7 @@ void state_device(struct snapraid_state* state, int operation) } if (operation == DEVICE_SMART) - state_smart(state->opt.verbose, state->level + tommy_list_count(&state->disklist), &low); + state_smart(state->level + tommy_list_count(&state->disklist), &low); } tommy_list_foreach(&high, free); diff --git a/cmdline/dry.c b/cmdline/dry.c index 0d2058e0..a6fbc109 100644 --- a/cmdline/dry.c +++ b/cmdline/dry.c @@ -82,20 +82,20 @@ static int state_dry_process(struct snapraid_state* state, struct snapraid_parit ret = handle_close(&handle[j]); if (ret == -1) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected close error in a data disk, it isn't possible to dry.\n"); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected close error in a data disk, it isn't possible to dry.\n"); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ } /* open the file only for reading */ - ret = handle_open(&handle[j], block_file_get(block), state->file_mode, ferr); + ret = handle_open(&handle[j], block_file_get(block), state->file_mode, msg_error); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected open error in a data disk, it isn't possible to dry.\n"); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected open error in a data disk, it isn't possible to dry.\n"); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -103,9 +103,9 @@ static int state_dry_process(struct snapraid_state* state, struct snapraid_parit } /* read from the file */ - read_size = handle_read(&handle[j], block, buffer_aligned, state->block_size, flog); + read_size = handle_read(&handle[j], block, buffer_aligned, state->block_size, msg_warning); if (read_size == -1) { - ftag("error:%u:%s:%s: Read error at position %u\n", i, disk->name, esc(block_file_get(block)->sub), block_file_pos(block)); + msg_tag("error:%u:%s:%s: Read error at position %u\n", i, disk->name, esc(block_file_get(block)->sub), block_file_pos(block)); ++error; continue; } @@ -122,9 +122,9 @@ static int state_dry_process(struct snapraid_state* state, struct snapraid_parit /* until now is CPU */ state_usage_cpu(state); - ret = parity_read(parity[l], i, buffer_aligned, state->block_size, flog); + ret = parity_read(parity[l], i, buffer_aligned, state->block_size, msg_warning); if (ret == -1) { - ftag("parity_error:%u:%s: Read error\n", i, lev_config_name(l)); + msg_tag("parity_error:%u:%s: Read error\n", i, lev_config_name(l)); ++error; } @@ -156,8 +156,8 @@ bail: ret = handle_close(&handle[j]); if (ret == -1) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected close error in a data disk.\n"); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected close error in a data disk.\n"); ++error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ @@ -165,11 +165,15 @@ bail: } if (error) { - fout("%u read errors\n", error); + msg_status("\n"); + msg_status("%8u errors\n", error); } else { - fout("Everything OK\n"); + msg_status("Everything OK\n"); } + if (error) + msg_error("DANGER! Unexpected errors!\n"); + free(handle); free(buffer_alloc); @@ -189,13 +193,13 @@ void state_dry(struct snapraid_state* state, block_off_t blockstart, block_off_t unsigned error; unsigned l; - fout("Drying...\n"); + msg_progress("Drying...\n"); blockmax = parity_allocated_size(state); if (blockstart > blockmax) { /* LCOV_EXCL_START */ - ferr("Error in the specified starting block %u. It's bigger than the parity size %u.\n", blockstart, blockmax); + msg_error("Error in the specified starting block %u. It's bigger than the parity size %u.\n", blockstart, blockmax); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -211,7 +215,7 @@ void state_dry(struct snapraid_state* state, block_off_t blockstart, block_off_t parity_ptr[l] = &parity[l]; ret = parity_open(parity_ptr[l], state->parity[l].path, state->file_mode); if (ret == -1) { - fout("No accessible %s file.\n", lev_name(l)); + msg_status("No accessible %s file.\n", lev_name(l)); /* continue anyway */ parity_ptr[l] = 0; } diff --git a/cmdline/dup.c b/cmdline/dup.c index d0402155..a4f2c3de 100644 --- a/cmdline/dup.c +++ b/cmdline/dup.c @@ -96,7 +96,7 @@ void state_dup(struct snapraid_state* state) count = 0; size = 0; - fout("Comparing...\n"); + msg_progress("Comparing...\n"); /* for each disk */ for (i = state->disklist; i != 0; i = i->next) { @@ -125,8 +125,8 @@ void state_dup(struct snapraid_state* state) if (dup) { ++count; size += dup->file->size; - ftag("dup:%s:%s:%s:%s:%" PRIu64 ": dup\n", disk->name, esc(file->sub), dup->disk->name, esc(dup->file->sub), dup->file->size); - fout("%12" PRIu64 " %s%s = %s%s\n", file->size, disk->dir, file->sub, dup->disk->dir, dup->file->sub); + msg_tag("dup:%s:%s:%s:%s:%" PRIu64 ": dup\n", disk->name, esc(file->sub), dup->disk->name, esc(dup->file->sub), dup->file->size); + printf("%12" PRIu64 " %s%s = %s%s\n", file->size, disk->dir, file->sub, dup->disk->dir, dup->file->sub); hash_free(hash); } else { tommy_hashdyn_insert(&hashset, &hash->node, hash, hash32); @@ -137,20 +137,20 @@ void state_dup(struct snapraid_state* state) tommy_hashdyn_foreach(&hashset, (tommy_foreach_func*)hash_free); tommy_hashdyn_done(&hashset); - fout("\n"); - fout("%8u duplicates, for %" PRIu64 " MiB\n", count, size / (1024 * 1024)); + msg_status("\n"); + msg_status("%8u duplicates, for %" PRIu64 " MiB\n", count, size / (1024 * 1024)); if (count) - fout("There are duplicates!\n"); + msg_status("There are duplicates!\n"); else - fout("No duplicates\n"); + msg_status("No duplicates\n"); - ftag("summary:dup_count:%u\n", count); - ftag("summary:dup_size:%" PRIu64 "\n", size); + msg_tag("summary:dup_count:%u\n", count); + msg_tag("summary:dup_size:%" PRIu64 "\n", size); if (count == 0) { - ftag("summary:exit:unique\n"); + msg_tag("summary:exit:unique\n"); } else { - ftag("summary:exit:dup\n"); + msg_tag("summary:exit:dup\n"); } - fflush_log(); + msg_flush(); } diff --git a/cmdline/elem.c b/cmdline/elem.c index 53884f29..103ae645 100644 --- a/cmdline/elem.c +++ b/cmdline/elem.c @@ -277,7 +277,7 @@ int filter_existence(int filter_missing, const char* dir, const char* sub) if (errno == ENOENT) return 0; /* LCOV_EXCL_START */ - ferr("Error in stat file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error in stat file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -342,7 +342,7 @@ block_off_t block_file_pos(struct snapraid_block* block) if (block < file->blockvec || block >= file->blockvec + file->blockmax) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in block %u ownership\n", block->parity_pos); + msg_error("Internal inconsistency in block %u ownership\n", block->parity_pos); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -456,21 +456,21 @@ void file_copy(struct snapraid_file* src_file, struct snapraid_file* dst_file) if (src_file->size != dst_file->size) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in copy file with different size\n"); + msg_error("Internal inconsistency in copy file with different size\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (src_file->mtime_sec != dst_file->mtime_sec) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in copy file with different mtime_sec\n"); + msg_error("Internal inconsistency in copy file with different mtime_sec\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (src_file->mtime_nsec != dst_file->mtime_nsec) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in copy file with different mtime_nsec\n"); + msg_error("Internal inconsistency in copy file with different mtime_nsec\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -747,7 +747,7 @@ int disk_is_empty(struct snapraid_disk* disk, block_off_t blockmax) return 0; default : /* LCOV_EXCL_START */ - ferr("Internal inconsistency for used block in disk '%s' without files\n", disk->name); + msg_error("Internal inconsistency for used block in disk '%s' without files\n", disk->name); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } diff --git a/cmdline/elem.h b/cmdline/elem.h index 57929c11..89c8e9b2 100644 --- a/cmdline/elem.h +++ b/cmdline/elem.h @@ -496,7 +496,7 @@ static inline void block_file_set(struct snapraid_block* block, struct snapraid_ /* ensure that the pointer doesn't use the flag space */ if ((ptr & (uintptr_t)BLOCK_STATE_MASK) != 0) { /* LCOV_EXCL_START */ - ferr("Internal error for pointer not aligned\n"); + msg_error("Internal error for pointer not aligned\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -523,7 +523,7 @@ static inline void block_state_set(struct snapraid_block* block, unsigned state) /* ensure that the state can be stored inside the file pointer */ if ((state & BLOCK_STATE_MASK) != state) { /* LCOV_EXCL_START */ - ferr("Internal error when setting the block state %u\n", state); + msg_error("Internal error when setting the block state %u\n", state); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } diff --git a/cmdline/handle.c b/cmdline/handle.c index db1a3d36..79a16278 100644 --- a/cmdline/handle.c +++ b/cmdline/handle.c @@ -90,7 +90,7 @@ int handle_create(struct snapraid_handle* handle, struct snapraid_file* file, in handle->f = -1; handle->valid_size = 0; - ferr("Error opening file '%s'. %s.\n", handle->path, strerror(errno)); + msg_error("Error opening file '%s'. %s.\n", handle->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -102,7 +102,7 @@ int handle_create(struct snapraid_handle* handle, struct snapraid_file* file, in ret = fstat(handle->f, &handle->st); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing file '%s'. %s.\n", handle->path, strerror(errno)); + msg_error("Error accessing file '%s'. %s.\n", handle->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -116,7 +116,7 @@ int handle_create(struct snapraid_handle* handle, struct snapraid_file* file, in ret = posix_fadvise(handle->f, 0, 0, POSIX_FADV_SEQUENTIAL); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error advising file '%s'. %s.\n", handle->path, strerror(ret)); + msg_error("Error advising file '%s'. %s.\n", handle->path, strerror(ret)); return -1; /* LCOV_EXCL_STOP */ } @@ -134,9 +134,9 @@ int handle_truncate(struct snapraid_handle* handle, struct snapraid_file* file) if (ret != 0) { /* LCOV_EXCL_START */ if (errno == EACCES) { - ferr("Failed to truncate file '%s' for missing write permission.\n", handle->path); + msg_error("Failed to truncate file '%s' for missing write permission.\n", handle->path); } else { - ferr("Error truncating file '%s'. %s.\n", handle->path, strerror(errno)); + msg_error("Error truncating file '%s'. %s.\n", handle->path, strerror(errno)); } return -1; /* LCOV_EXCL_STOP */ @@ -223,7 +223,7 @@ int handle_close(struct snapraid_handle* handle) ret = close(handle->f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file '%s'. %s.\n", handle->file->sub, strerror(errno)); + msg_error("Error closing file '%s'. %s.\n", handle->file->sub, strerror(errno)); /* invalidate for error */ handle->file = 0; @@ -325,7 +325,7 @@ int handle_write(struct snapraid_handle* handle, struct snapraid_block* block, u #else if (lseek(handle->f, offset, SEEK_SET) != offset) { /* LCOV_EXCL_START */ - ferr("Error seeking file '%s'. %s.\n", handle->path, strerror(errno)); + msg_error("Error seeking file '%s'. %s.\n", handle->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -334,7 +334,7 @@ int handle_write(struct snapraid_handle* handle, struct snapraid_block* block, u #endif if (write_ret != (ssize_t)write_size) { /* conversion is safe because block_size is always small */ /* LCOV_EXCL_START */ - ferr("Error writing file '%s'. %s.\n", handle->path, strerror(errno)); + msg_error("Error writing file '%s'. %s.\n", handle->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -362,7 +362,7 @@ int handle_utime(struct snapraid_handle* handle) if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error timing file '%s'. %s.\n", handle->file->sub, strerror(errno)); + msg_error("Error timing file '%s'. %s.\n", handle->file->sub, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -410,7 +410,7 @@ struct snapraid_handle* handle_map(struct snapraid_state* state, unsigned* handl } if (k == 0) { /* LCOV_EXCL_START */ - ferr("Internal error for inconsistent disk mapping.\n"); + msg_error("Internal error for inconsistent disk mapping.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } diff --git a/cmdline/import.c b/cmdline/import.c index c67ef43a..c4dfb715 100644 --- a/cmdline/import.c +++ b/cmdline/import.c @@ -78,7 +78,7 @@ static void import_file(struct snapraid_state* state, const char* path, uint64_t f = open(path, flags); if (f == -1) { /* LCOV_EXCL_START */ - ferr("Error opening file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -89,7 +89,7 @@ static void import_file(struct snapraid_state* state, const char* path, uint64_t ret = posix_fadvise(f, 0, 0, POSIX_FADV_SEQUENTIAL); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error advising file '%s'. %s.\n", path, strerror(ret)); + msg_error("Error advising file '%s'. %s.\n", path, strerror(ret)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -106,7 +106,7 @@ static void import_file(struct snapraid_state* state, const char* path, uint64_t ret = read(f, buffer, read_size); if (ret < 0 || (unsigned)ret != read_size) { /* LCOV_EXCL_START */ - ferr("Error reading file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error reading file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -132,7 +132,7 @@ static void import_file(struct snapraid_state* state, const char* path, uint64_t ret = close(f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error closing file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -174,14 +174,14 @@ int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid f = open(path, O_RDONLY | O_BINARY); if (f == -1) { /* LCOV_EXCL_START */ - ferr("Error opening file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (lseek(f, block->offset, SEEK_SET) != block->offset) { /* LCOV_EXCL_START */ - ferr("Error seeking file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error seeking file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -189,7 +189,7 @@ int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid ret = read(f, buffer, read_size); if (ret < 0 || (unsigned)ret != read_size) { /* LCOV_EXCL_START */ - ferr("Error reading file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error reading file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -197,7 +197,7 @@ int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid ret = close(f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error closing file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -215,8 +215,8 @@ int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid if (memcmp(buffer_hash, hash, HASH_SIZE) != 0) { /* LCOV_EXCL_START */ - ferr("Error in data reading file '%s'.\n", path); - ferr("Please don't change imported files while running.\n"); + msg_error("Error in data reading file '%s'.\n", path); + msg_error("Please don't change imported files while running.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -231,7 +231,7 @@ static void import_dir(struct snapraid_state* state, const char* dir) d = opendir(dir); if (!d) { /* LCOV_EXCL_START */ - ferr("Error opening directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error opening directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -247,7 +247,7 @@ static void import_dir(struct snapraid_state* state, const char* dir) dd = readdir(d); if (dd == 0 && errno != 0) { /* LCOV_EXCL_START */ - ferr("Error reading directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error reading directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -274,7 +274,7 @@ static void import_dir(struct snapraid_state* state, const char* dir) if (st.st_mode == 0) { if (lstat(path_next, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -283,7 +283,7 @@ static void import_dir(struct snapraid_state* state, const char* dir) /* get lstat info about the file */ if (lstat(path_next, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -299,7 +299,7 @@ static void import_dir(struct snapraid_state* state, const char* dir) if (closedir(d) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error closing directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -309,7 +309,7 @@ void state_import(struct snapraid_state* state, const char* dir) { char path[PATH_MAX]; - fout("Importing...\n"); + msg_progress("Importing...\n"); /* add the final slash */ pathimport(path, sizeof(path), dir); diff --git a/cmdline/list.c b/cmdline/list.c index 5800a74a..30bd40db 100644 --- a/cmdline/list.c +++ b/cmdline/list.c @@ -37,7 +37,7 @@ void state_list(struct snapraid_state* state) file_size = 0; link_count = 0; - fout("Listing...\n"); + msg_progress("Listing...\n"); /* for each disk */ for (i = state->disklist; i != 0; i = i->next) { @@ -59,7 +59,7 @@ void state_list(struct snapraid_state* state) ++file_count; file_size += file->size; - ftag("file:%s:%s:%" PRIu64 ":%" PRIi64 ":%u:%" PRIi64 "\n", disk->name, esc(file->sub), file->size, file->mtime_sec, file->mtime_nsec, file->inode); + msg_tag("file:%s:%s:%" PRIu64 ":%" PRIi64 ":%u:%" PRIi64 "\n", disk->name, esc(file->sub), file->size, file->mtime_sec, file->mtime_nsec, file->inode); t = file->mtime_sec; #if HAVE_LOCALTIME_R @@ -71,9 +71,8 @@ void state_list(struct snapraid_state* state) printf("%12" PRIu64 " ", file->size); if (tm) { printf("%04u/%02u/%02u %02u:%02u", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min); - if (state->opt.verbose) { + if (msg_level >= MSG_VERBOSE) printf(":%02u.%03u", tm->tm_sec, file->mtime_nsec / 1000000); - } printf(" "); } printf("%s%s\n", disk->dir, file->sub); @@ -99,24 +98,24 @@ void state_list(struct snapraid_state* state) ++link_count; - ftag("link_%s:%s:%s:%s\n", type, disk->name, esc(link->sub), esc(link->linkto)); + msg_tag("link_%s:%s:%s:%s\n", type, disk->name, esc(link->sub), esc(link->linkto)); printf("%12s ", type); printf(" "); - if (state->opt.verbose) { + if (msg_level >= MSG_VERBOSE) printf(" "); - } printf("%s%s -> %s%s\n", disk->dir, link->sub, disk->dir, link->linkto); } } - fout("\n"); - fout("%8u files, for %" PRIu64 " GiB\n", file_count, file_size / (1024 * 1024 * 1024)); - fout("%8u links\n", link_count); - ftag("summary:file_count:%u\n", file_count); - ftag("summary:file_size:%" PRIu64 "\n", file_size); - ftag("summary:link_count:%u\n", link_count); - ftag("summary:exit:ok\n"); - fflush_log(); + msg_status("\n"); + msg_status("%8u files, for %" PRIu64 " GiB\n", file_count, file_size / (1024 * 1024 * 1024)); + msg_status("%8u links\n", link_count); + + msg_tag("summary:file_count:%u\n", file_count); + msg_tag("summary:file_size:%" PRIu64 "\n", file_size); + msg_tag("summary:link_count:%u\n", link_count); + msg_tag("summary:exit:ok\n"); + msg_flush(); } diff --git a/cmdline/mingw.c b/cmdline/mingw.c index d98b12b4..1046c352 100644 --- a/cmdline/mingw.c +++ b/cmdline/mingw.c @@ -185,19 +185,19 @@ void os_init(int opt) ntdll = GetModuleHandle("NTDLL.DLL"); if (!ntdll) { - ferr("Error loading the NTDLL module.\n"); + msg_error("Error loading the NTDLL module.\n"); exit(EXIT_FAILURE); } kernel32 = GetModuleHandle("KERNEL32.DLL"); if (!kernel32) { - ferr("Error loading the KERNEL32 module.\n"); + msg_error("Error loading the KERNEL32 module.\n"); exit(EXIT_FAILURE); } dll_advapi32 = LoadLibrary("ADVAPI32.DLL"); if (!dll_advapi32) { - ferr("Error loading the ADVAPI32 module.\n"); + msg_error("Error loading the ADVAPI32 module.\n"); exit(EXIT_FAILURE); } @@ -210,7 +210,7 @@ void os_init(int opt) ptr_RtlGenRandom = (void*)GetProcAddress(dll_advapi32, "SystemFunction036"); if (!ptr_RtlGenRandom) { - ferr("Error loading RtlGenRandom() from the ADVAPI32 module.\n"); + msg_error("Error loading RtlGenRandom() from the ADVAPI32 module.\n"); exit(EXIT_FAILURE); } @@ -280,7 +280,7 @@ static wchar_t* u8tou16(const char* src) ret = MultiByteToWideChar(CP_UTF8, 0, src, -1, conv_utf16_buffer[roll], sizeof(conv_utf16_buffer[0]) / sizeof(wchar_t)); if (ret <= 0) { - ferr("Error converting name '%s' from UTF-8 to UTF-16\n", src); + msg_error("Error converting name '%s' from UTF-8 to UTF-16\n", src); exit(EXIT_FAILURE); } @@ -303,7 +303,7 @@ static char* u16tou8ex(const wchar_t* src, size_t number_of_wchar, size_t* resul ret = WideCharToMultiByte(CP_UTF8, 0, src, number_of_wchar, conv_utf8_buffer[roll], sizeof(conv_utf8_buffer[0]), 0, 0); if (ret <= 0) { - ferr("Error converting from UTF-16 to UTF-8\n"); + msg_error("Error converting from UTF-16 to UTF-8\n"); exit(EXIT_FAILURE); } @@ -398,7 +398,7 @@ static wchar_t* convert_arg(const char* src, int only_if_required) ret = MultiByteToWideChar(CP_UTF8, 0, src, -1, dst, sizeof(conv_utf16_buffer[0]) / sizeof(wchar_t) - count); if (ret <= 0) { - ferr("Error converting name '%s' from UTF-8 to UTF-16\n", src); + msg_error("Error converting name '%s' from UTF-8 to UTF-16\n", src); exit(EXIT_FAILURE); } @@ -632,7 +632,7 @@ static void windows_finddata2dirent(const WIN32_FIND_DATAW* info, struct windows name = u16tou8ex(info->cFileName, wcslen(info->cFileName), &len); if (len + 1 >= sizeof(dirent->d_name)) { - ferr("Name too long\n"); + msg_error("Name too long\n"); exit(EXIT_FAILURE); } @@ -650,7 +650,7 @@ static void windows_stream2dirent(const BY_HANDLE_FILE_INFORMATION* info, const name = u16tou8ex(stream->FileName, stream->FileNameLength / 2, &len); if (len + 1 >= sizeof(dirent->d_name)) { - ferr("Name too long\n"); + msg_error("Name too long\n"); exit(EXIT_FAILURE); } @@ -701,7 +701,7 @@ static void windows_errno(DWORD error) errno = EPERM; break; default : - ferr("Unexpected Windows error %d.\n", (int)error); + msg_error("Unexpected Windows error %d.\n", (int)error); errno = EIO; break; } @@ -1005,8 +1005,8 @@ int windows_fsync(int fd) * this error, but not enough sure to ignore it. * So, we use now an extended error reporting. */ - ferr("Unexpected Windows INVALID_HANDLE error in FlushFileBuffers().\n"); - ferr("Are you using ATA-over-Ethernet ? Please report it.\n"); + msg_error("Unexpected Windows INVALID_HANDLE error in FlushFileBuffers().\n"); + msg_error("Are you using ATA-over-Ethernet ? Please report it.\n"); /* normal error processing */ windows_errno(error); @@ -1137,7 +1137,7 @@ static windows_dir* windows_opendir_find(const char* dir) dirstream = malloc(sizeof(windows_dir)); if (!dirstream) { - ferr("Low memory\n"); + msg_error("Low memory\n"); exit(EXIT_FAILURE); } @@ -1274,7 +1274,7 @@ static windows_dir* windows_opendir_stream(const char* dir) dirstream = malloc(sizeof(windows_dir)); if (!dirstream) { - ferr("Low memory\n"); + msg_error("Low memory\n"); exit(EXIT_FAILURE); } @@ -1284,7 +1284,7 @@ static windows_dir* windows_opendir_stream(const char* dir) dirstream->buffer_size = 64 * 1024; dirstream->buffer = malloc(dirstream->buffer_size); if (!dirstream->buffer) { - ferr("Low memory\n"); + msg_error("Low memory\n"); exit(EXIT_FAILURE); } @@ -1761,7 +1761,7 @@ retry: * https://sourceforge.net/p/snapraid/discussion/1677233/thread/a7c25ba9/ */ if (err == ERROR_NO_SYSTEM_RESOURCES) { - ferr("Unexpected Windows ERROR_NO_SYSTEM_RESOURCES in pread(), retrying...\n"); + msg_error("Unexpected Windows ERROR_NO_SYSTEM_RESOURCES in pread(), retrying...\n"); Sleep(50); goto retry; } @@ -1801,7 +1801,7 @@ retry: DWORD err = GetLastError(); /* See windows_pread() for comments on this error management */ if (err == ERROR_NO_SYSTEM_RESOURCES) { - ferr("Unexpected Windows ERROR_NO_SYSTEM_RESOURCES in pwrite(), retrying...\n"); + msg_error("Unexpected Windows ERROR_NO_SYSTEM_RESOURCES in pwrite(), retrying...\n"); Sleep(50); goto retry; } @@ -2046,7 +2046,7 @@ static int devscan(tommy_list* list) f = _wpopen(cmd, L"rt"); if (!f) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' (from popen).\n", u16tou8(cmd)); + msg_error("Failed to run '%s' (from popen).\n", u16tou8(cmd)); return -1; /* LCOV_EXCL_STOP */ } @@ -2061,13 +2061,13 @@ static int devscan(tommy_list* list) ret = pclose(f); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' (from pclose).\n", u16tou8(cmd)); + msg_error("Failed to run '%s' (from pclose).\n", u16tou8(cmd)); return -1; /* LCOV_EXCL_STOP */ } if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' with return code %xh.\n", u16tou8(cmd), ret); + msg_error("Failed to run '%s' with return code %xh.\n", u16tou8(cmd), ret); return -1; /* LCOV_EXCL_STOP */ } @@ -2089,7 +2089,7 @@ static int devsmart(uint64_t device, uint64_t* smart, char* serial) f = _wpopen(cmd, L"rt"); if (!f) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' (from popen).\n", u16tou8(cmd)); + msg_error("Failed to run '%s' (from popen).\n", u16tou8(cmd)); return -1; /* LCOV_EXCL_STOP */ } @@ -2104,7 +2104,7 @@ static int devsmart(uint64_t device, uint64_t* smart, char* serial) ret = pclose(f); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' (from pclose).\n", u16tou8(cmd)); + msg_error("Failed to run '%s' (from pclose).\n", u16tou8(cmd)); return -1; /* LCOV_EXCL_STOP */ } @@ -2128,13 +2128,13 @@ static int devdown(uint64_t device) ret = _wsystem(cmd); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' (from system).\n", u16tou8(cmd)); + msg_error("Failed to run '%s' (from system).\n", u16tou8(cmd)); return -1; /* LCOV_EXCL_STOP */ } if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Failed to run '%s' with return code %xh.\n", u16tou8(cmd), ret); + msg_error("Failed to run '%s' with return code %xh.\n", u16tou8(cmd), ret); return -1; /* LCOV_EXCL_STOP */ } @@ -2184,7 +2184,7 @@ static void* thread_spinup(void* arg) if (lstat_sync(devinfo->mount, &st, 0) != 0) { /* LCOV_EXCL_START */ pthread_mutex_lock(&io_lock); - ferr("Failed to stat path '%s'. %s.\n", devinfo->mount, strerror(errno)); + msg_error("Failed to stat path '%s'. %s.\n", devinfo->mount, strerror(errno)); pthread_mutex_unlock(&io_lock); return (void*)-1; /* LCOV_EXCL_STOP */ @@ -2196,7 +2196,7 @@ static void* thread_spinup(void* arg) if (devresolve(devinfo->mount, devinfo->file, sizeof(devinfo->file), devinfo->wfile, sizeof(devinfo->wfile)) != 0) { /* LCOV_EXCL_START */ pthread_mutex_lock(&io_lock); - ferr("Failed to resolve path '%s'.\n", devinfo->mount); + msg_error("Failed to resolve path '%s'.\n", devinfo->mount); pthread_mutex_unlock(&io_lock); return (void*)-1; /* LCOV_EXCL_STOP */ @@ -2209,7 +2209,7 @@ static void* thread_spinup(void* arg) } pthread_mutex_lock(&io_lock); - fprintf(stdout, "Spunup device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); + msg_status("Spunup device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); pthread_mutex_unlock(&io_lock); return 0; @@ -2232,7 +2232,7 @@ static void* thread_spindown(void* arg) } pthread_mutex_lock(&io_lock); - fprintf(stdout, "Spundown device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); + msg_status("Spundown device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); pthread_mutex_unlock(&io_lock); return 0; @@ -2265,7 +2265,7 @@ static int device_thread(tommy_list* list, void* (*func)(void* arg)) if (pthread_create(&devinfo->thread, 0, func, devinfo) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to create thread.\n"); + msg_error("Failed to create thread.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2278,7 +2278,7 @@ static int device_thread(tommy_list* list, void* (*func)(void* arg)) if (pthread_join(devinfo->thread, &retval) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to join thread.\n"); + msg_error("Failed to join thread.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2308,7 +2308,7 @@ int devquery(tommy_list* high, tommy_list* low, int operation) if (devresolve(devinfo->mount, devinfo->file, sizeof(devinfo->file), devinfo->wfile, sizeof(devinfo->wfile)) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to resolve path '%s'.\n", devinfo->mount); + msg_error("Failed to resolve path '%s'.\n", devinfo->mount); return -1; /* LCOV_EXCL_STOP */ } @@ -2316,7 +2316,7 @@ int devquery(tommy_list* high, tommy_list* low, int operation) /* expand the tree of devices */ if (devtree(devinfo->name, devinfo->wfile, devinfo, low) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to expand device '%s'.\n", devinfo->file); + msg_error("Failed to expand device '%s'.\n", devinfo->file); return -1; /* LCOV_EXCL_STOP */ } @@ -2344,7 +2344,7 @@ int devquery(tommy_list* high, tommy_list* low, int operation) if (operation == DEVICE_SMART) { if (devscan(low) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to list other devices.\n"); + msg_error("Failed to list other devices.\n"); return -1; /* LCOV_EXCL_STOP */ } diff --git a/cmdline/mktest.c b/cmdline/mktest.c index 8de03b0d..4abec970 100644 --- a/cmdline/mktest.c +++ b/cmdline/mktest.c @@ -149,7 +149,7 @@ void cmd_generate_file(const char* path, int size) if (remove(path) != 0) { if (errno != ENOENT) { /* LCOV_EXCL_START */ - ferr("Error removing file %s\n", path); + msg_error("Error removing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -171,21 +171,21 @@ void cmd_generate_file(const char* path, int size) f = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_NOFOLLOW, 0600); if (f < 0) { /* LCOV_EXCL_START */ - ferr("Error creating file %s\n", path); + msg_error("Error creating file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (write(f, data, size) != size) { /* LCOV_EXCL_START */ - ferr("Error writing file %s\n", path); + msg_error("Error writing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (close(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file %s\n", path); + msg_error("Error closing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -203,7 +203,7 @@ void cmd_generate_symlink(const char* path, const char* linkto) if (remove(path) != 0) { if (errno != ENOENT) { /* LCOV_EXCL_START */ - ferr("Error removing file %s\n", path); + msg_error("Error removing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -211,7 +211,7 @@ void cmd_generate_symlink(const char* path, const char* linkto) if (symlink(linkto, path) != 0) { /* LCOV_EXCL_START */ - ferr("Error writing symlink %s\n", path); + msg_error("Error writing symlink %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -236,7 +236,7 @@ void cmd_generate(int disk, int size) if (mkdir(path, 0777) != 0) { if (errno != EEXIST) { /* LCOV_EXCL_START */ - ferr("Error creating directory %s\n", path); + msg_error("Error creating directory %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -294,7 +294,7 @@ void cmd_write(const char* path, int size) if (lstat(path, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing %s\n", path); + msg_error("Error accessing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -321,28 +321,28 @@ void cmd_write(const char* path, int size) f = open(path, O_WRONLY | O_BINARY | O_NOFOLLOW); if (f < 0) { /* LCOV_EXCL_START */ - ferr("Error creating file %s\n", path); + msg_error("Error creating file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (lseek(f, off, SEEK_SET) != off) { /* LCOV_EXCL_START */ - ferr("Error seeking file %s\n", path); + msg_error("Error seeking file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (write(f, data, size) != size) { /* LCOV_EXCL_START */ - ferr("Error writing file %s\n", path); + msg_error("Error writing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (close(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file %s\n", path); + msg_error("Error closing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -370,7 +370,7 @@ void cmd_damage(const char* path, int size) if (lstat(path, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing %s\n", path); + msg_error("Error accessing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -398,21 +398,21 @@ void cmd_damage(const char* path, int size) f = open(path, O_RDWR | O_BINARY | O_NOFOLLOW); if (f < 0) { /* LCOV_EXCL_START */ - ferr("Error creating file %s\n", path); + msg_error("Error creating file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (lseek(f, off, SEEK_SET) != off) { /* LCOV_EXCL_START */ - ferr("Error seeking file %s\n", path); + msg_error("Error seeking file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (read(f, data, size) != size) { /* LCOV_EXCL_START */ - ferr("Error writing file %s\n", path); + msg_error("Error writing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -421,28 +421,28 @@ void cmd_damage(const char* path, int size) if (lseek(f, off, SEEK_SET) != off) { /* LCOV_EXCL_START */ - ferr("Error seeking file %s\n", path); + msg_error("Error seeking file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (write(f, data, size) != size) { /* LCOV_EXCL_START */ - ferr("Error writing file %s\n", path); + msg_error("Error writing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (fallback(f, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error setting time for file %s\n", path); + msg_error("Error setting time for file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (close(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file %s\n", path); + msg_error("Error closing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -462,7 +462,7 @@ void cmd_append(const char* path, int size) if (lstat(path, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing %s\n", path); + msg_error("Error accessing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -478,21 +478,21 @@ void cmd_append(const char* path, int size) f = open(path, O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW); if (f < 0) { /* LCOV_EXCL_START */ - ferr("Error opening file %s\n", path); + msg_error("Error opening file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (write(f, data, size) != size) { /* LCOV_EXCL_START */ - ferr("Error writing file %s\n", path); + msg_error("Error writing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (close(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file %s\n", path); + msg_error("Error closing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -513,7 +513,7 @@ void cmd_truncate(const char* path, int size) if (lstat(path, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing %s\n", path); + msg_error("Error accessing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -536,21 +536,21 @@ void cmd_truncate(const char* path, int size) f = open(path, O_WRONLY | O_BINARY | O_NOFOLLOW); if (f < 0) { /* LCOV_EXCL_START */ - ferr("Error opening file %s\n", path); + msg_error("Error opening file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (ftruncate(f, off) != 0) { /* LCOV_EXCL_START */ - ferr("Error truncating file %s\n", path); + msg_error("Error truncating file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (close(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file %s\n", path); + msg_error("Error closing file %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -565,7 +565,7 @@ void cmd_delete(const char* path) { if (remove(path) != 0) { /* LCOV_EXCL_START */ - ferr("Error removing %s\n", path); + msg_error("Error removing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -584,7 +584,7 @@ void cmd_change(const char* path, int size) if (lstat(path, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing %s\n", path); + msg_error("Error accessing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -595,7 +595,7 @@ void cmd_change(const char* path, int size) /* delete */ if (remove(path) != 0) { /* LCOV_EXCL_START */ - ferr("Error removing %s\n", path); + msg_error("Error removing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -605,7 +605,7 @@ void cmd_change(const char* path, int size) if (remove(path) != 0) { /* LCOV_EXCL_START */ - ferr("Error removing %s\n", path); + msg_error("Error removing %s\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -633,14 +633,14 @@ void cmd_change(const char* path, int size) void help(void) { - fout("Test for " PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL "\n"); - fout("Usage:\n"); - fout("\tmktest generate SEED DISK_NUM FILE_NUM FILE_SIZE\n"); - fout("\tmktest damage SEED NUM SIZE FILE\n"); - fout("\tmktest write SEED NUM SIZE FILE\n"); - fout("\tmktest change SEED SIZE FILE\n"); - fout("\tmktest append SEED SIZE FILE\n"); - fout("\tmktest truncate SEED SIZE FILE\n"); + printf("Test for " PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL "\n"); + printf("Usage:\n"); + printf("\tmktest generate SEED DISK_NUM FILE_NUM FILE_SIZE\n"); + printf("\tmktest damage SEED NUM SIZE FILE\n"); + printf("\tmktest write SEED NUM SIZE FILE\n"); + printf("\tmktest change SEED SIZE FILE\n"); + printf("\tmktest append SEED SIZE FILE\n"); + printf("\tmktest truncate SEED SIZE FILE\n"); } int main(int argc, char* argv[]) diff --git a/cmdline/nano.c b/cmdline/nano.c index afcad737..7a449aba 100644 --- a/cmdline/nano.c +++ b/cmdline/nano.c @@ -26,7 +26,7 @@ void state_nano(struct snapraid_state* state) { tommy_node* i; - fout("Setting nanosecond timestamps...\n"); + msg_progress("Setting nanosecond timestamps...\n"); /* for all disks */ for (i = state->disklist; i != 0; i = i->next) { @@ -56,7 +56,7 @@ void state_nano(struct snapraid_state* state) /* get a random nanosecond value */ if (randomize(&nano, sizeof(nano)) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to get random values.\n"); + msg_error("Failed to get random values.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -69,7 +69,7 @@ void state_nano(struct snapraid_state* state) f = open(path, O_RDONLY | O_BINARY | O_NOFOLLOW); if (f == -1) { /* LCOV_EXCL_START */ - ferr("Error opening file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening file '%s'. %s.\n", path, strerror(errno)); continue; /* LCOV_EXCL_STOP */ } @@ -80,7 +80,7 @@ void state_nano(struct snapraid_state* state) if (ret == -1) { /* LCOV_EXCL_START */ close(f); - ferr("Error accessing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error accessing file '%s'. %s.\n", path, strerror(errno)); continue; /* LCOV_EXCL_STOP */ } @@ -90,7 +90,7 @@ void state_nano(struct snapraid_state* state) if (ret != 0) { /* LCOV_EXCL_START */ close(f); - ferr("Error timing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error timing file '%s'. %s.\n", path, strerror(errno)); continue; /* LCOV_EXCL_STOP */ } @@ -102,7 +102,7 @@ void state_nano(struct snapraid_state* state) if (ret == -1) { /* LCOV_EXCL_START */ close(f); - ferr("Error accessing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error accessing file '%s'. %s.\n", path, strerror(errno)); continue; /* LCOV_EXCL_STOP */ } @@ -111,7 +111,7 @@ void state_nano(struct snapraid_state* state) ret = close(f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error closing file '%s'. %s.\n", path, strerror(errno)); continue; /* LCOV_EXCL_STOP */ } @@ -125,8 +125,8 @@ void state_nano(struct snapraid_state* state) /* state changed, we need to update it */ state->need_write = 1; - ftag("nano:%s:%s\n", disk->name, esc(file->sub)); - fout("nano %s%s\n", disk->dir, file->sub); + msg_tag("nano:%s:%s\n", disk->name, esc(file->sub)); + msg_info("nano %s%s\n", disk->dir, file->sub); } } } diff --git a/cmdline/parity.c b/cmdline/parity.c index d1028dde..40457128 100644 --- a/cmdline/parity.c +++ b/cmdline/parity.c @@ -102,14 +102,14 @@ void parity_overflow(struct snapraid_state* state, data_off_t size) if (file->blockmax > 0) { if (file->blockvec[file->blockmax - 1].parity_pos >= blockalloc) { - ftag("outofparity:%s:%s\n", disk->name, esc(file->sub)); - fflush_log(); + msg_tag("outofparity:%s:%s\n", disk->name, esc(file->sub)); + msg_flush(); if (first) { first = 0; - fout("\nYour data requires more parity than the available space.\n"); - fout("Please move the following files to another data disk:\n"); + msg_warning("\nYour data requires more parity than the available space.\n"); + msg_warning("Please move the files 'outofparity' to another data disk:\n"); } - fout("outofparity %s%s\n", disk->dir, file->sub); + msg_warning("outofparity %s%s\n", disk->dir, file->sub); } } } @@ -131,7 +131,7 @@ int parity_create(struct snapraid_parity_handle* parity, const char* path, data_ parity->f = open(parity->path, flags, 0600); if (parity->f == -1) { /* LCOV_EXCL_START */ - ferr("Error opening parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error opening parity file '%s'. %s.\n", parity->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -140,7 +140,7 @@ int parity_create(struct snapraid_parity_handle* parity, const char* path, data_ ret = fstat(parity->f, &parity->st); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); goto bail; /* LCOV_EXCL_STOP */ } @@ -151,7 +151,7 @@ int parity_create(struct snapraid_parity_handle* parity, const char* path, data_ ret = posix_fadvise(parity->f, 0, 0, POSIX_FADV_SEQUENTIAL); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error advising parity file '%s'. %s.\n", parity->path, strerror(ret)); + msg_error("Error advising parity file '%s'. %s.\n", parity->path, strerror(ret)); goto bail; /* LCOV_EXCL_STOP */ } @@ -227,7 +227,7 @@ int parity_chsize(struct snapraid_parity_handle* parity, data_off_t size, data_o ret = fstat(parity->f, &parity->st); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); goto bail; /* LCOV_EXCL_STOP */ } @@ -239,9 +239,9 @@ int parity_chsize(struct snapraid_parity_handle* parity, data_off_t size, data_o if (f_ret != 0) { /* LCOV_EXCL_START */ if (f_errno == ENOSPC) { - ferr("Failed to grow parity file '%s' to size %" PRIu64 " using %s due lack of space.\n", parity->path, size, call); + msg_error("Failed to grow parity file '%s' to size %" PRIu64 " using %s due lack of space.\n", parity->path, size, call); } else { - ferr("Error growing parity file '%s' to size %" PRIu64 " using %s. Do you have enough space? %s.\n", parity->path, size, call, strerror(f_errno)); + msg_error("Error growing parity file '%s' to size %" PRIu64 " using %s. Do you have enough space? %s.\n", parity->path, size, call, strerror(f_errno)); } goto bail; /* LCOV_EXCL_STOP */ @@ -261,7 +261,7 @@ int parity_chsize(struct snapraid_parity_handle* parity, data_off_t size, data_o ret = fstat(parity->f, &parity->st); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); goto bail; /* LCOV_EXCL_STOP */ } @@ -272,7 +272,7 @@ int parity_chsize(struct snapraid_parity_handle* parity, data_off_t size, data_o /* now check the error */ if (f_ret != 0) { /* LCOV_EXCL_START */ - ferr("Error truncating parity file '%s' to size %" PRIu64 ". %s.\n", parity->path, size, strerror(f_errno)); + msg_error("Error truncating parity file '%s' to size %" PRIu64 ". %s.\n", parity->path, size, strerror(f_errno)); goto bail; /* LCOV_EXCL_STOP */ } @@ -305,7 +305,7 @@ int parity_open(struct snapraid_parity_handle* parity, const char* path, int mod flags |= O_SEQUENTIAL; parity->f = open_noatime(parity->path, flags); if (parity->f == -1) { - ferr("Error opening parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error opening parity file '%s'. %s.\n", parity->path, strerror(errno)); return -1; } @@ -313,7 +313,7 @@ int parity_open(struct snapraid_parity_handle* parity, const char* path, int mod ret = fstat(parity->f, &parity->st); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error accessing parity file '%s'. %s.\n", parity->path, strerror(errno)); goto bail; /* LCOV_EXCL_STOP */ } @@ -327,7 +327,7 @@ int parity_open(struct snapraid_parity_handle* parity, const char* path, int mod ret = posix_fadvise(parity->f, 0, 0, POSIX_FADV_SEQUENTIAL); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error advising parity file '%s'. %s.\n", parity->path, strerror(ret)); + msg_error("Error advising parity file '%s'. %s.\n", parity->path, strerror(ret)); goto bail; /* LCOV_EXCL_STOP */ } @@ -356,7 +356,7 @@ int parity_sync(struct snapraid_parity_handle* parity) ret = fsync(parity->f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error synching parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error synching parity file '%s'. %s.\n", parity->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -379,7 +379,7 @@ int parity_close(struct snapraid_parity_handle* parity) /* This is a serious error, as it may be the result of a failed write */ /* identified at later time. */ /* In a normal filesystem (not NFS) it should never happen */ - ferr("Error closing parity file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error closing parity file '%s'. %s.\n", parity->path, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -404,9 +404,9 @@ int parity_write(struct snapraid_parity_handle* parity, block_off_t pos, unsigne if (lseek(parity->f, offset, SEEK_SET) != offset) { /* LCOV_EXCL_START */ if (errno == ENOSPC) { - ferr("Failed to grow parity file '%s' using lseek due lack of space.\n", parity->path); + msg_error("Failed to grow parity file '%s' using lseek due lack of space.\n", parity->path); } else { - ferr("Error seeking file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error seeking file '%s'. %s.\n", parity->path, strerror(errno)); } return -1; /* LCOV_EXCL_STOP */ @@ -417,9 +417,9 @@ int parity_write(struct snapraid_parity_handle* parity, block_off_t pos, unsigne if (write_ret != (ssize_t)block_size) { /* conversion is safe because block_size is always small */ /* LCOV_EXCL_START */ if (errno == ENOSPC) { - ferr("Failed to grow parity file '%s' using write due lack of space.\n", parity->path); + msg_error("Failed to grow parity file '%s' using write due lack of space.\n", parity->path); } else { - ferr("Error writing file '%s'. %s.\n", parity->path, strerror(errno)); + msg_error("Error writing file '%s'. %s.\n", parity->path, strerror(errno)); } return -1; /* LCOV_EXCL_STOP */ diff --git a/cmdline/pool.c b/cmdline/pool.c index 58eb3641..b481d833 100644 --- a/cmdline/pool.c +++ b/cmdline/pool.c @@ -33,7 +33,7 @@ static int clean_dir(struct snapraid_state* state, const char* dir) d = opendir(dir); if (!d) { /* LCOV_EXCL_START */ - ferr("Error opening pool directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error opening pool directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -49,7 +49,7 @@ static int clean_dir(struct snapraid_state* state, const char* dir) dd = readdir(d); if (dd == 0 && errno != 0) { /* LCOV_EXCL_START */ - ferr("Error reading pool directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error reading pool directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -73,7 +73,7 @@ static int clean_dir(struct snapraid_state* state, const char* dir) if (st.st_mode == 0) { if (lstat(path_next, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -82,7 +82,7 @@ static int clean_dir(struct snapraid_state* state, const char* dir) /* get lstat info about the file */ if (lstat(path_next, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -95,7 +95,7 @@ static int clean_dir(struct snapraid_state* state, const char* dir) ret = remove(path_next); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Error removing symlink '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error removing symlink '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -113,13 +113,13 @@ static int clean_dir(struct snapraid_state* state, const char* dir) /* in Windows just ignore EACCES errors removing directories */ /* because it could happen that the directory is in use */ /* and it cannot be removed */ - ferr("Directory '%s' not removed because it's in use.\n", path_next); + msg_error("Directory '%s' not removed because it's in use.\n", path_next); ignored = 1; } else #endif { /* LCOV_EXCL_START */ - ferr("Error removing pool directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error removing pool directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -130,15 +130,13 @@ static int clean_dir(struct snapraid_state* state, const char* dir) } } else { ignored = 1; - if (state->opt.verbose) { - fout("Ignoring pool file '%s'\n", path_next); - } + msg_verbose("Ignoring pool file '%s'\n", path_next); } } if (closedir(d) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing pool directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error closing pool directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -183,17 +181,17 @@ static void make_link(const char* pool_dir, const char* share_dir, struct snapra ret = symlink(linkto_exported, path); if (ret != 0) { if (errno == EEXIST) { - ferr("WARNING! Duplicate pooling for '%s'\n", path); + msg_warning("WARNING! Duplicate pooling for '%s'\n", path); #ifdef _WIN32 } else if (errno == EPERM) { /* LCOV_EXCL_START */ - ferr("You must run as Adminstrator to be able to create symlinks.\n"); + msg_error("You must run as Adminstrator to be able to create symlinks.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ #endif } else { /* LCOV_EXCL_START */ - ferr("Error writing symlink '%s'. %s.\n", path, strerror(errno)); + msg_error("Error writing symlink '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -209,12 +207,12 @@ void state_pool(struct snapraid_state* state) if (state->pool[0] == 0) { /* LCOV_EXCL_START */ - ferr("To use the 'pool' command you must set the pool directory in the configuration file\n"); + msg_error("To use the 'pool' command you must set the pool directory in the configuration file\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } - fout("Cleaning...\n"); + msg_progress("Cleaning...\n"); /* pool directory with final slash */ pathprint(pool_dir, sizeof(pool_dir), "%s", state->pool); @@ -227,7 +225,7 @@ void state_pool(struct snapraid_state* state) /* first clear the previous pool tree */ clean_dir(state, pool_dir); - fout("Pooling...\n"); + msg_progress("Pooling...\n"); /* for each disk */ count = 0; @@ -253,12 +251,12 @@ void state_pool(struct snapraid_state* state) } if (count) - fout("%u links created\n", count); + msg_status("%u links created\n", count); else - fout("No link created\n"); + msg_status("No link created\n"); - ftag("summary:link_count::%u\n", count); - ftag("summary:exit:ok\n"); - fflush_log(); + msg_tag("summary:link_count::%u\n", count); + msg_tag("summary:exit:ok\n"); + msg_flush(); } diff --git a/cmdline/rehash.c b/cmdline/rehash.c index 154a6563..79151648 100644 --- a/cmdline/rehash.c +++ b/cmdline/rehash.c @@ -38,14 +38,14 @@ void state_rehash(struct snapraid_state* state) /* check if a rehash is already in progress */ if (state->prevhash != HASH_UNDEFINED) { /* LCOV_EXCL_START */ - ferr("You already have a rehash in progress.\n"); + msg_error("You already have a rehash in progress.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (state->hash == state->besthash) { /* LCOV_EXCL_START */ - ferr("You are already using the best hash for your platform.\n"); + msg_error("You are already using the best hash for your platform.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -58,7 +58,7 @@ void state_rehash(struct snapraid_state* state) state->hash = state->besthash; if (randomize(state->hashseed, HASH_SIZE) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to get random values.\n"); + msg_error("Failed to get random values.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -76,7 +76,7 @@ void state_rehash(struct snapraid_state* state) if (info_get_rehash(info)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for a rehash already in progress\n"); + msg_error("Internal inconsistency for a rehash already in progress\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -91,8 +91,8 @@ void state_rehash(struct snapraid_state* state) /* save the new content file */ state->need_write = 1; - fout("A rehash is now scheduled. It will take place progressively in the next\n"); - fout("'sync' and 'scrub' commands. You can check the rehash progress using the\n"); - fout("'status' command.\n"); + msg_status("A rehash is now scheduled. It will take place progressively in the next\n"); + msg_status("'sync' and 'scrub' commands. You can check the rehash progress using the\n"); + msg_status("'status' command.\n"); } diff --git a/cmdline/scan.c b/cmdline/scan.c index 88dcdfd7..16bc98b6 100644 --- a/cmdline/scan.c +++ b/cmdline/scan.c @@ -94,7 +94,7 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub, /* check if multiple files have the same name */ if (link_flag_has(link, FILE_IS_PRESENT)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for link '%s%s'\n", disk->dir, sub); + msg_error("Internal inconsistency for link '%s%s'\n", disk->dir, sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -108,7 +108,7 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub, ++scan->count_equal; if (state->opt.gui) { - ftag("scan:equal:%s:%s\n", disk->name, esc(link->sub)); + msg_tag("scan:equal:%s:%s\n", disk->name, esc(link->sub)); } } else { /* it's an update */ @@ -118,9 +118,9 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub, ++scan->count_change; - ftag("scan:update:%s:%s\n", disk->name, esc(link->sub)); + msg_tag("scan:update:%s:%s\n", disk->name, esc(link->sub)); if (is_diff) { - fout("update %s%s\n", disk->dir, link->sub); + printf("update %s%s\n", disk->dir, link->sub); } /* update it */ @@ -135,9 +135,9 @@ static void scan_link(struct snapraid_scan* scan, int is_diff, const char* sub, /* create the new link */ ++scan->count_insert; - ftag("scan:add:%s:%s\n", disk->name, esc(sub)); + msg_tag("scan:add:%s:%s\n", disk->name, esc(sub)); if (is_diff) { - fout("add %s%s\n", disk->dir, sub); + printf("add %s%s\n", disk->dir, sub); } /* and continue to insert it */ @@ -213,7 +213,7 @@ static void scan_file_deallocate(struct snapraid_scan* scan, struct snapraid_fil break; default : /* LCOV_EXCL_START */ - ferr("Internal inconsistency in deallocating for block %u state %u\n", block->parity_pos, block_state); + msg_error("Internal inconsistency in deallocating for block %u state %u\n", block->parity_pos, block_state); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -305,7 +305,7 @@ static void scan_file_delayed_insert(struct snapraid_scan* scan, struct snapraid if (filephy(path_next, file->size, &file->physical) != 0) { /* LCOV_EXCL_START */ - ferr("Error in getting the physical offset of file '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in getting the physical offset of file '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -347,7 +347,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 */ - ferr("Error in stat file '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -365,8 +365,8 @@ 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 */ - ferr("WARNING! Detected uncached time change for file '%s'\n", sub); - ferr("It's better if you run SnapRAID without other processes running.\n"); + msg_error("WARNING! Detected uncached time change for file '%s'\n", sub); + msg_error("It's better if you run SnapRAID without other processes running.\n"); #endif st->st_mtime = synced_st.st_mtime; st->st_mtimensec = synced_st.st_mtimensec; @@ -374,15 +374,15 @@ static void scan_file_refresh(struct snapraid_scan* scan, const char* sub, struc if (st->st_size != synced_st.st_size) { #ifndef _WIN32 - ferr("WARNING! Detected uncached size change for file '%s'\n", sub); - ferr("It's better if you run SnapRAID without other processes running.\n"); + msg_error("WARNING! Detected uncached size change for file '%s'\n", sub); + msg_error("It's better if you run SnapRAID without other processes running.\n"); #endif st->st_size = synced_st.st_size; } if (st->st_ino != synced_st.st_ino) { - ferr("DANGER! Detected uncached inode change for file '%s'\n", sub); - ferr("Please ensure to run SnapRAID without other processes running.\n"); + msg_error("DANGER! Detected uncached inode change for file '%s'\n", sub); + msg_error("Please ensure to run SnapRAID without other processes running.\n"); /* at this point, it's too late to change inode */ /* and having inconsistent inodes may result to internal failures */ /* so, it's better to abort */ @@ -610,7 +610,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, #if HAVE_STRUCT_STAT_ST_NLINK if (st->st_nlink <= 1) { /* LCOV_EXCL_START */ - ferr("Internal inode '%" PRIu64 "' inconsistency for file '%s%s' already present\n", (uint64_t)st->st_ino, disk->dir, sub); + msg_error("Internal inode '%" PRIu64 "' inconsistency for file '%s%s' already present\n", (uint64_t)st->st_ino, disk->dir, sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -638,9 +638,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; - ftag("scan:move:%s:%s:%s\n", disk->name, esc(file->sub), esc(sub)); + msg_tag("scan:move:%s:%s:%s\n", disk->name, esc(file->sub), esc(sub)); if (is_diff) { - fout("move %s%s -> %s%s\n", disk->dir, file->sub, disk->dir, sub); + printf("move %s%s -> %s%s\n", disk->dir, file->sub, disk->dir, sub); } /* remove from the name set */ @@ -659,7 +659,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, ++scan->count_equal; if (state->opt.gui) { - ftag("scan:equal:%s:%s\n", disk->name, esc(file->sub)); + msg_tag("scan:equal:%s:%s\n", disk->name, esc(file->sub)); } } @@ -678,7 +678,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, /* for sure it cannot be already present */ if (file_flag_has(file, FILE_IS_PRESENT)) { /* LCOV_EXCL_START */ - ferr("Internal inode '%" PRIu64 "' inconsistency for files '%s%s' and '%s%s' matching and already present but different\n", file->inode, disk->dir, sub, disk->dir, file->sub); + msg_error("Internal inode '%" PRIu64 "' inconsistency for files '%s%s' and '%s%s' matching and already present but different\n", file->inode, disk->dir, sub, disk->dir, file->sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -728,7 +728,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, /* here the inode has to be different, otherwise we would have found it before */ if (file->inode == st->st_ino) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in inode '%" PRIu64 "' for files '%s%s' as unexpected matching\n", file->inode, disk->dir, sub); + msg_error("Internal inconsistency in inode '%" PRIu64 "' for files '%s%s' as unexpected matching\n", file->inode, disk->dir, sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -737,7 +737,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, /* for sure it cannot be already present */ if (file_flag_has(file, FILE_IS_PRESENT)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in path for file '%s%s' matching and already present\n", disk->dir, sub); + msg_error("Internal inconsistency in path for file '%s%s' matching and already present\n", disk->dir, sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -775,9 +775,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; - ftag("scan:restore:%s:%s\n", disk->name, esc(sub)); + msg_tag("scan:restore:%s:%s\n", disk->name, esc(sub)); if (is_diff) { - fout("restore %s%s\n", disk->dir, sub); + printf("restore %s%s\n", disk->dir, sub); } /* remove from the inode set */ @@ -798,7 +798,7 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, ++scan->count_equal; if (state->opt.gui) { - ftag("scan:equal:%s:%s\n", disk->name, esc(file->sub)); + msg_tag("scan:equal:%s:%s\n", disk->name, esc(file->sub)); } } @@ -830,11 +830,11 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, if (is_original_file_size_different_than_zero && st->st_size == 0) { if (!state->opt.force_zero) { /* LCOV_EXCL_START */ - ferr("The file '%s%s' has unexpected zero size!\n", disk->dir, sub); - ferr("It's possible that after a kernel crash this file was lost,\n"); - ferr("and you can use 'snapraid --filter %s fix' to recover it.\n", sub); + msg_error("The file '%s%s' has unexpected zero size!\n", disk->dir, sub); + msg_error("It's possible that after a kernel crash this file was lost,\n"); + msg_error("and you can use 'snapraid --filter %s fix' to recover it.\n", sub); if (!is_diff) { - ferr("If this an expected condition you can '%s' anyway using 'snapraid --force-zero %s'\n", state->command, state->command); + msg_error("If this an expected condition you can '%s' anyway using 'snapraid --force-zero %s'\n", state->command, state->command); exit(EXIT_FAILURE); } /* LCOV_EXCL_STOP */ @@ -875,9 +875,9 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, /* revert old counter and use the copy one */ ++scan->count_copy; - ftag("scan:copy:%s:%s:%s:%s\n", other_disk->name, esc(other_file->sub), disk->name, esc(file->sub)); + msg_tag("scan:copy:%s:%s:%s:%s\n", other_disk->name, esc(other_file->sub), disk->name, esc(file->sub)); if (is_diff) { - fout("copy %s%s -> %s%s\n", other_disk->dir, other_file->sub, disk->dir, file->sub); + printf("copy %s%s -> %s%s\n", other_disk->dir, other_file->sub, disk->dir, file->sub); } /* mark it as reported */ @@ -894,16 +894,16 @@ static void scan_file(struct snapraid_scan* scan, int is_diff, const char* sub, if (is_file_already_present) { ++scan->count_change; - ftag("scan:update:%s:%s\n", disk->name, esc(sub)); + msg_tag("scan:update:%s:%s\n", disk->name, esc(sub)); if (is_diff) { - fout("update %s%s\n", disk->dir, sub); + printf("update %s%s\n", disk->dir, sub); } } else { ++scan->count_insert; - ftag("scan:add:%s:%s\n", disk->name, esc(sub)); + msg_tag("scan:add:%s:%s\n", disk->name, esc(sub)); if (is_diff) { - fout("add %s%s\n", disk->dir, sub); + printf("add %s%s\n", disk->dir, sub); } } } @@ -966,7 +966,7 @@ static void scan_emptydir(struct snapraid_scan* scan, const char* sub) /* check if multiple files have the same name */ if (dir_flag_has(dir, FILE_IS_PRESENT)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for dir '%s%s'\n", disk->dir, sub); + msg_error("Internal inconsistency for dir '%s%s'\n", disk->dir, sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1044,7 +1044,7 @@ struct stat* dstat(const char* file, struct stat* st) { if (lstat(file, st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", file, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", file, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1070,8 +1070,8 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co d = opendir(dir); if (!d) { /* LCOV_EXCL_START */ - ferr("Error opening directory '%s'. %s.\n", dir, strerror(errno)); - ferr("You can exclude it in the config file with:\n\texclude /%s\n", sub); + msg_error("Error opening directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("You can exclude it in the config file with:\n\texclude /%s\n", sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1090,8 +1090,8 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co dd = readdir(d); if (dd == 0 && errno != 0) { /* LCOV_EXCL_START */ - ferr("Error reading directory '%s'. %s.\n", dir, strerror(errno)); - ferr("You can exclude it in the config file with:\n\texclude /%s\n", sub); + msg_error("Error reading directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("You can exclude it in the config file with:\n\texclude /%s\n", sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1110,24 +1110,20 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co /* check for not supported file names */ if (name[0] == 0) { /* LCOV_EXCL_START */ - ferr("Unsupported name '%s' in file '%s'.\n", name, path_next); + msg_error("Unsupported name '%s' in file '%s'.\n", name, path_next); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } /* exclude hidden files even before calling lstat() */ if (filter_hidden(state->filter_hidden, dd) != 0) { - if (state->opt.verbose) { - fout("Excluding hidden '%s'\n", path_next); - } + msg_verbose("Excluding hidden '%s'\n", path_next); continue; } /* exclude content files even before calling lstat() */ if (filter_content(&state->contentlist, path_next) != 0) { - if (state->opt.verbose) { - fout("Excluding content '%s'\n", path_next); - } + msg_verbose("Excluding content '%s'\n", path_next); continue; } @@ -1155,7 +1151,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co if (closedir(d) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error closing directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1222,7 +1218,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co if (st->st_mode == 0) { if (lstat(path_next, st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1252,7 +1248,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co if (st->st_ino == 0) { if (lstat_sync(path_next, st, 0) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1262,9 +1258,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co scan_file(scan, is_diff, sub_next, st, FILEPHY_UNREAD_OFFSET); processed = 1; } else { - if (state->opt.verbose) { - fout("Excluding file '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); - } + msg_verbose("Excluding file '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); } } else if (type == 1) { /* LNK */ if (filter_path(&state->filterlist, &reason, disk->name, sub_next) == 0) { @@ -1274,13 +1268,13 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co ret = readlink(path_next, subnew, sizeof(subnew)); if (ret >= PATH_MAX) { /* LCOV_EXCL_START */ - ferr("Error in readlink file '%s'. Symlink too long.\n", path_next); + msg_error("Error in readlink file '%s'. Symlink too long.\n", path_next); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Error in readlink file '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in readlink file '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1292,9 +1286,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co scan_link(scan, is_diff, sub_next, subnew, FILE_IS_SYMLINK); processed = 1; } else { - if (state->opt.verbose) { - fout("Excluding link '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); - } + msg_verbose("Excluding link '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); } } else if (type == 2) { /* DIR */ if (filter_dir(&state->filterlist, &reason, disk->name, sub_next) == 0) { @@ -1306,7 +1298,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co /* in Unix don't follow mount points in different devices */ /* in Windows we are already skipping them reporting them as special files */ if ((uint64_t)st->st_dev != disk->device) { - ferr("WARNING! Ignoring mount point '%s' because it appears to be in a different device\n", path_next); + msg_error("WARNING! Ignoring mount point '%s' because it appears to be in a different device\n", path_next); } else #endif { @@ -1324,9 +1316,7 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co processed = 1; } } else { - if (state->opt.verbose) { - fout("Excluding directory '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); - } + msg_verbose("Excluding directory '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); } } else { if (filter_path(&state->filterlist, &reason, disk->name, sub_next) == 0) { @@ -1334,11 +1324,9 @@ static int scan_dir(struct snapraid_scan* scan, int is_diff, const char* dir, co if (!st) st = DSTAT(path_next, dd, &st_buf); - ferr("WARNING! Ignoring special '%s' file '%s'\n", stat_desc(st), path_next); + msg_error("WARNING! Ignoring special '%s' file '%s'\n", stat_desc(st), path_next); } else { - if (state->opt.verbose) { - fout("Excluding special file '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); - } + msg_verbose("Excluding special file '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); } } @@ -1358,11 +1346,14 @@ void state_scan(struct snapraid_state* state, int is_diff) tommy_node* j; tommy_list scanlist; int done; + fptr* msg; + struct snapraid_scan total; + int no_difference; tommy_list_init(&scanlist); if (is_diff) - fout("Comparing...\n"); + msg_progress("Comparing...\n"); /* first scan all the directory and find new and deleted files */ for (i = state->disklist; i != 0; i = i->next) { @@ -1389,13 +1380,13 @@ void state_scan(struct snapraid_state* state, int is_diff) tommy_list_insert_tail(&scanlist, &scan->node, scan); if (!is_diff) - fout("Scanning disk %s...\n", disk->name); + msg_progress("Scanning disk %s...\n", disk->name); /* check if the disk supports persistent inodes */ ret = fsinfo(disk->dir, &has_persistent_inode, 0, 0); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Error accessing disk '%s' to get filesystem info. %s.\n", disk->dir, strerror(errno)); + msg_error("Error accessing disk '%s' to get filesystem info. %s.\n", disk->dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1455,9 +1446,9 @@ void state_scan(struct snapraid_state* state, int is_diff) if (!file_flag_has(file, FILE_IS_PRESENT)) { ++scan->count_remove; - ftag("scan:remove:%s:%s\n", disk->name, esc(file->sub)); + msg_tag("scan:remove:%s:%s\n", disk->name, esc(file->sub)); if (is_diff) { - fout("remove %s%s\n", disk->dir, file->sub); + printf("remove %s%s\n", disk->dir, file->sub); } scan_file_remove(scan, file); @@ -1476,9 +1467,9 @@ void state_scan(struct snapraid_state* state, int is_diff) if (!link_flag_has(link, FILE_IS_PRESENT)) { ++scan->count_remove; - ftag("scan:remove:%s:%s\n", disk->name, esc(link->sub)); + msg_tag("scan:remove:%s:%s\n", disk->name, esc(link->sub)); if (is_diff) { - fout("remove %s%s\n", disk->dir, link->sub); + printf("remove %s%s\n", disk->dir, link->sub); } scan_link_remove(scan, link); @@ -1536,8 +1527,8 @@ void state_scan(struct snapraid_state* state, int is_diff) ) { /* if verbose, prints the list of duplicates real offsets */ /* other cases are for offsets not supported, so we don't need to report them file by file */ - if (state->opt.verbose && phy_last >= FILEPHY_REAL_OFFSET) { - ferr("WARNING! Files '%s%s' and '%s%s' have the same physical offset %" PRId64 ".\n", disk->dir, phy_file_last->sub, disk->dir, file->sub, phy_last); + if (phy_last >= FILEPHY_REAL_OFFSET) { + msg_warning("WARNING! Files '%s%s' and '%s%s' have the same physical offset %" PRId64 ".\n", disk->dir, phy_file_last->sub, disk->dir, file->sub, phy_last); } ++phy_dup; } @@ -1594,20 +1585,20 @@ void state_scan(struct snapraid_state* state, int is_diff) if (scan->count_equal == 0 && scan->count_move == 0 && scan->count_restore == 0 && (scan->count_remove != 0 || scan->count_change != 0)) { if (!done) { done = 1; - ferr("WARNING! All the files previously present in disk '%s' at dir '%s'", disk->name, disk->dir); + msg_error("WARNING! All the files previously present in disk '%s' at dir '%s'", disk->name, disk->dir); } else { - ferr(", disk '%s' at dir '%s'", disk->name, disk->dir); + msg_error(", disk '%s' at dir '%s'", disk->name, disk->dir); } } } if (done) { - ferr("\nare now missing or rewritten!\n"); - ferr("This could happen when deleting all the files from a disk,\n"); - ferr("and restoring them with a program that it's not setting\n"); - ferr("correctly the timestamps.\n"); - ferr("It's also possible that you have some disks not mounted.\n"); + msg_error("\nare now missing or rewritten!\n"); + msg_error("This could happen when deleting all the files from a disk,\n"); + msg_error("and restoring them with a program that it's not setting\n"); + msg_error("correctly the timestamps.\n"); + msg_error("It's also possible that you have some disks not mounted.\n"); if (!is_diff) { - ferr("If you want to '%s' anyway, use 'snapraid --force-empty %s'.", state->command, state->command); + msg_error("If you want to '%s' anyway, use 'snapraid --force-empty %s'.", state->command, state->command); exit(EXIT_FAILURE); } } @@ -1622,14 +1613,14 @@ void state_scan(struct snapraid_state* state, int is_diff) if (disk->has_unreliable_physical) { if (!done) { done = 1; - ferr("WARNING! Physical offsets not supported for disk '%s'", disk->name); + msg_error("WARNING! Physical offsets not supported for disk '%s'", disk->name); } else { - ferr(", '%s'", disk->name); + msg_error(", '%s'", disk->name); } } } if (done) { - ferr(". Files order won't be optimal.\n"); + msg_error(". Files order won't be optimal.\n"); } } @@ -1641,14 +1632,14 @@ void state_scan(struct snapraid_state* state, int is_diff) if (disk->has_volatile_inodes) { if (!done) { done = 1; - ferr("WARNING! Inodes are not persistent for disks: '%s'", disk->name); + msg_error("WARNING! Inodes are not persistent for disks: '%s'", disk->name); } else { - ferr(", '%s'", disk->name); + msg_error(", '%s'", disk->name); } } } if (done) { - ferr(". Move operations won't be optimal.\n"); + msg_error(". Move operations won't be optimal.\n"); } /* checks for disks with changed UUID */ @@ -1663,14 +1654,14 @@ void state_scan(struct snapraid_state* state, int is_diff) if (disk->has_different_uuid && !disk->had_empty_uuid) { if (!done) { done = 1; - ferr("WARNING! UUID is changed for disks: '%s'", disk->name); + msg_error("WARNING! UUID is changed for disks: '%s'", disk->name); } else { - ferr(", '%s'", disk->name); + msg_error(", '%s'", disk->name); } } } if (done) { - ferr(". Move operations won't be optimal.\n"); + msg_error(". Move operations won't be optimal.\n"); } /* checks for disks with unsupported UUID */ @@ -1681,78 +1672,76 @@ void state_scan(struct snapraid_state* state, int is_diff) if (disk->has_unsupported_uuid) { if (!done) { done = 1; - ferr("WARNING! UUID is unsupported for disks: '%s'", disk->name); + msg_error("WARNING! UUID is unsupported for disks: '%s'", disk->name); } else { - ferr(", '%s'", disk->name); + msg_error(", '%s'", disk->name); } } } if (done) { - ferr(". Move operations won't be optimal.\n"); + msg_error(". Move operations won't be optimal.\n"); } - if (state->opt.verbose || is_diff) { - struct snapraid_scan total; - int no_difference; + total.count_equal = 0; + total.count_move = 0; + total.count_copy = 0; + total.count_restore = 0; + total.count_change = 0; + total.count_remove = 0; + total.count_insert = 0; - total.count_equal = 0; - total.count_move = 0; - total.count_copy = 0; - total.count_restore = 0; - total.count_change = 0; - total.count_remove = 0; - total.count_insert = 0; + for (i = scanlist; i != 0; i = i->next) { + struct snapraid_scan* scan = i->data; + total.count_equal += scan->count_equal; + total.count_move += scan->count_move; + total.count_copy += scan->count_copy; + total.count_restore += scan->count_restore; + total.count_change += scan->count_change; + total.count_remove += scan->count_remove; + total.count_insert += scan->count_insert; + } - for (i = scanlist; i != 0; i = i->next) { - struct snapraid_scan* scan = i->data; - total.count_equal += scan->count_equal; - total.count_move += scan->count_move; - total.count_copy += scan->count_copy; - total.count_restore += scan->count_restore; - total.count_change += scan->count_change; - total.count_remove += scan->count_remove; - total.count_insert += scan->count_insert; - } + if (is_diff) { + msg_status("\n"); + msg = msg_status; + } else { + msg = msg_verbose; + } - if (state->opt.verbose || is_diff) { - if (is_diff) - fout("\n"); - fout("%8u equal\n", total.count_equal); - fout("%8u moved\n", total.count_move); - fout("%8u copied\n", total.count_copy); - fout("%8u restored\n", total.count_restore); - fout("%8u updated\n", total.count_change); - fout("%8u removed\n", total.count_remove); - fout("%8u added\n", total.count_insert); - } + msg("%8u equal\n", total.count_equal); + msg("%8u moved\n", total.count_move); + msg("%8u copied\n", total.count_copy); + msg("%8u restored\n", total.count_restore); + msg("%8u updated\n", total.count_change); + msg("%8u removed\n", total.count_remove); + msg("%8u added\n", total.count_insert); - ftag("summary:equal:%u\n", total.count_equal); - ftag("summary:moved:%u\n", total.count_move); - ftag("summary:copied:%u\n", total.count_copy); - ftag("summary:restored:%u\n", total.count_restore); - ftag("summary:updated:%u\n", total.count_change); - ftag("summary:removed:%u\n", total.count_remove); - ftag("summary:added:%u\n", total.count_insert); + msg_tag("summary:equal:%u\n", total.count_equal); + msg_tag("summary:moved:%u\n", total.count_move); + msg_tag("summary:copied:%u\n", total.count_copy); + msg_tag("summary:restored:%u\n", total.count_restore); + msg_tag("summary:updated:%u\n", total.count_change); + msg_tag("summary:removed:%u\n", total.count_remove); + msg_tag("summary:added:%u\n", total.count_insert); - no_difference = !total.count_move && !total.count_copy && !total.count_restore - && !total.count_change && !total.count_remove && !total.count_insert; - - if (is_diff) { - if (no_difference) { - fout("No differences\n"); - } else { - fout("There are differences!\n"); - } - } + no_difference = !total.count_move && !total.count_copy && !total.count_restore + && !total.count_change && !total.count_remove && !total.count_insert; + if (is_diff) { if (no_difference) { - ftag("summary:exit:equal\n"); + msg_status("No differences\n"); } else { - ftag("summary:exit:diff\n"); + msg_status("There are differences!\n"); } - fflush_log(); } + if (no_difference) { + msg_tag("summary:exit:equal\n"); + } else { + msg_tag("summary:exit:diff\n"); + } + msg_flush(); + tommy_list_foreach(&scanlist, (tommy_foreach_func*)free); } diff --git a/cmdline/scrub.c b/cmdline/scrub.c index 4d3d1f23..0c70489e 100644 --- a/cmdline/scrub.c +++ b/cmdline/scrub.c @@ -228,40 +228,40 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par /* This one is really an unexpected error, because we are only reading */ /* and closing a descriptor should never fail */ if (errno == EIO) { - ftag("error:%u:%s:%s: Close EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output close error in a data disk, it isn't possible to scrub.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output close error in a data disk, it isn't possible to scrub.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("WARNING! Unexpected close error in a data disk, it isn't possible to scrub.\n"); - ferr("Ensure that file '%s' can be accessed.\n", handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("WARNING! Unexpected close error in a data disk, it isn't possible to scrub.\n"); + msg_error("Ensure that file '%s' can be accessed.\n", handle[j].path); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ } } - ret = handle_open(&handle[j], block_file_get(block), state->file_mode, flog); + ret = handle_open(&handle[j], block_file_get(block), state->file_mode, msg_warning); if (ret == -1) { /* file we have tried to open for error reporting */ struct snapraid_file* file = block_file_get(block); if (errno == EIO) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Open EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output open error in a data disk, it isn't possible to scrub.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Open EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output open error in a data disk, it isn't possible to scrub.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; /* LCOV_EXCL_STOP */ } - ftag("error:%u:%s:%s: Open error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_tag("error:%u:%s:%s: Open error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); ++error; error_on_this_block = 1; continue; @@ -283,29 +283,29 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par /* from the last sync, as we are expected to return errors if running */ /* in an unsynced array. This is just like the check command. */ - read_size = handle_read(&handle[j], block, buffer[j], state->block_size, flog); + read_size = handle_read(&handle[j], block, buffer[j], state->block_size, msg_warning); if (read_size == -1) { /* file we are processing for error reporting */ struct snapraid_file* file = block_file_get(block); if (errno == EIO) { - ftag("error:%u:%s:%s: Read EIO error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); + msg_tag("error:%u:%s:%s: Read EIO error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); if (io_error >= state->opt.io_error_limit) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected input/output read error in a data disk, it isn't possible to scrub.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected input/output read error in a data disk, it isn't possible to scrub.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; /* LCOV_EXCL_STOP */ } - flog("Input/Output error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); + msg_warning("Input/Output error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); ++io_error; io_error_on_this_block = 1; continue; } - ftag("error:%u:%s:%s: Read error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); + msg_tag("error:%u:%s:%s: Read error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); ++error; error_on_this_block = 1; continue; @@ -330,14 +330,14 @@ 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) { - ftag("error:%u:%s:%s: Data error at position %u\n", i, disk->name, esc(handle[j].file->sub), block_file_pos(block)); + msg_tag("error:%u:%s:%s: Data error at position %u\n", i, disk->name, esc(handle[j].file->sub), block_file_pos(block)); /* it's a silent error only if we are dealing with synced files */ if (file_is_unsynced) { ++error; error_on_this_block = 1; } else { - flog("Data error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); + msg_warning("Data error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); ++silent_error; silent_error_on_this_block = 1; } @@ -361,29 +361,29 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par /* read the parity */ for (l = 0; l < state->level; ++l) { - ret = parity_read(parity[l], i, buffer_recov[l], state->block_size, flog); + ret = parity_read(parity[l], i, buffer_recov[l], state->block_size, msg_warning); if (ret == -1) { buffer_recov[l] = 0; if (errno == EIO) { - ftag("parity_error:%u:%s: Read EIO error. %s\n", i, lev_config_name(l), strerror(errno)); + msg_tag("parity_error:%u:%s: Read EIO error. %s\n", i, lev_config_name(l), strerror(errno)); if (io_error >= state->opt.io_error_limit) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected input/output read error in the %s disk, it isn't possible to scrub.\n", lev_name(l)); - ferr("Ensure that disk '%s' is sane and can be read.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected input/output read error in the %s disk, it isn't possible to scrub.\n", lev_name(l)); + msg_error("Ensure that disk '%s' is sane and can be read.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; /* LCOV_EXCL_STOP */ } - flog("Input/Output error in parity '%s' at position '%u'\n", lev_config_name(l), i); + msg_warning("Input/Output error in parity '%s' at position '%u'\n", lev_config_name(l), i); ++io_error; io_error_on_this_block = 1; continue; } - ftag("parity_error:%u:%s: Read error. %s\n", i, lev_config_name(l), strerror(errno)); + msg_tag("parity_error:%u:%s: Read error. %s\n", i, lev_config_name(l), strerror(errno)); ++error; error_on_this_block = 1; continue; @@ -399,14 +399,14 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par /* compare the parity */ for (l = 0; l < state->level; ++l) { if (buffer_recov[l] && memcmp(buffer[diskmax + l], buffer_recov[l], state->block_size) != 0) { - ftag("parity_error:%u:%s: Data error\n", i, lev_config_name(l)); + msg_tag("parity_error:%u:%s: Data error\n", i, lev_config_name(l)); /* it's a silent error only if we are dealing with synced blocks */ if (block_is_unsynced) { ++error; error_on_this_block = 1; } else { - ferr("Data error in parity '%s' at position '%u'\n", lev_config_name(l), i); + msg_error("Data error in parity '%s' at position '%u'\n", lev_config_name(l), i); ++silent_error; silent_error_on_this_block = 1; } @@ -460,7 +460,7 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par state_progress_stop(state); - fout("Autosaving...\n"); + msg_progress("Autosaving...\n"); state_write(state); state_progress_restart(state); @@ -474,35 +474,36 @@ static int state_scrub_process(struct snapraid_state* state, struct snapraid_par state_usage_print(state); - if (io_error) - ferr("WARNING! Unexpected input/output errors! The failing blocks are now marked as bad!\n"); - if (silent_error) - ferr("WARNING! Unexpected data errors! The failing blocks are now marked as bad!\n"); - if (io_error || silent_error) { - ferr("Use 'snapraid status' to list the bad blocks.\n"); - ferr("Use 'snapraid -e fix' to recover.\n"); - } - if (error || silent_error || io_error) { - fout("\n"); - fout("%8u file errors\n", error); - fout("%8u io errors\n", io_error); - fout("%8u data errors\n", silent_error); - fout("WARNING! There are errors!\n"); + msg_status("\n"); + msg_status("%8u file errors\n", error); + msg_status("%8u io errors\n", io_error); + msg_status("%8u data errors\n", silent_error); } else { /* print the result only if processed something */ if (countpos != 0) - fout("Everything OK\n"); + msg_status("Everything OK\n"); } - ftag("summary:error_file:%u\n", error); - ftag("summary:error_io:%u\n", io_error); - ftag("summary:error_data:%u\n", silent_error); + if (error) + msg_error("WARNING! Unexpected file errors!\n"); + if (io_error) + msg_error("DANGER! Unexpected input/output errors! The failing blocks are now marked as bad!\n"); + if (silent_error) + msg_error("DANGER! Unexpected data errors! The failing blocks are now marked as bad!\n"); + if (io_error || silent_error) { + msg_error("Use 'snapraid status' to list the bad blocks.\n"); + msg_error("Use 'snapraid -e fix' to recover.\n"); + } + + msg_tag("summary:error_file:%u\n", error); + msg_tag("summary:error_io:%u\n", io_error); + msg_tag("summary:error_data:%u\n", silent_error); if (error + silent_error + io_error == 0) - ftag("summary:exit:ok\n"); + msg_tag("summary:exit:ok\n"); else - ftag("summary:exit:error\n"); - fflush_log(); + msg_tag("summary:exit:error\n"); + msg_flush(); bail: for (j = 0; j < diskmax; ++j) { @@ -511,8 +512,8 @@ bail: ret = handle_close(&handle[j]); if (ret == -1) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected close error in a data disk.\n"); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected close error in a data disk.\n"); ++error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ @@ -568,7 +569,7 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) /* get the present time */ now = time(0); - fout("Initializing...\n"); + msg_progress("Initializing...\n"); blockmax = parity_allocated_size(state); @@ -601,7 +602,7 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) /* copy the info in the temp vector */ count = 0; - ftag("block_count:%u\n", blockmax); + msg_tag("block_count:%u\n", blockmax); for (i = 0; i < blockmax; ++i) { snapraid_info info = info_get(&state->infoarr, i); @@ -614,7 +615,7 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) if (!count) { /* LCOV_EXCL_START */ - ferr("The array appears to be empty.\n"); + msg_error("The array appears to be empty.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -624,12 +625,12 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) /* output the info map */ i = 0; - ftag("info_count:%u\n", count); + msg_tag("info_count:%u\n", count); while (i < count) { unsigned j = i + 1; while (j < count && info_get_time(infomap[i]) == info_get_time(infomap[j])) ++j; - ftag("info_time:%" PRIu64 ":%u\n", (uint64_t)info_get_time(infomap[i]), j - i); + msg_tag("info_time:%" PRIu64 ":%u\n", (uint64_t)info_get_time(infomap[i]), j - i); i = j; } @@ -657,9 +658,9 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) lastlimit = 0; } - ftag("count_limit:%u\n", countlimit); - ftag("time_limit:%" PRIu64 "\n", (uint64_t)timelimit); - ftag("last_limit:%u\n", lastlimit); + msg_tag("count_limit:%u\n", countlimit); + msg_tag("time_limit:%" PRIu64 "\n", (uint64_t)timelimit); + msg_tag("last_limit:%u\n", lastlimit); /* free the temp vector */ free(infomap); @@ -670,13 +671,13 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) ret = parity_open(parity_ptr[l], state->parity[l].path, state->file_mode); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("WARNING! Without an accessible %s file, it isn't possible to scrub.\n", lev_name(l)); + msg_error("WARNING! Without an accessible %s file, it isn't possible to scrub.\n", lev_name(l)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } - fout("Scrubbing...\n"); + msg_progress("Scrubbing...\n"); error = 0; @@ -690,7 +691,7 @@ int state_scrub(struct snapraid_state* state, int percentage, int olderthan) ret = parity_close(parity_ptr[l]); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected close error in %s disk.\n", lev_name(l)); + msg_error("DANGER! Unexpected close error in %s disk.\n", lev_name(l)); ++error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ diff --git a/cmdline/search.c b/cmdline/search.c index b25af91b..7f0f2142 100644 --- a/cmdline/search.c +++ b/cmdline/search.c @@ -79,14 +79,14 @@ int search_file_compare(const void* void_arg, const void* void_data) f = open(path, O_RDONLY | O_BINARY); if (f == -1) { /* LCOV_EXCL_START */ - ferr("Error opening file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (lseek(f, arg->offset, SEEK_SET) != arg->offset) { /* LCOV_EXCL_START */ - ferr("Error seeking file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error seeking file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -94,7 +94,7 @@ int search_file_compare(const void* void_arg, const void* void_data) ret = read(f, arg->buffer, arg->read_size); if (ret < 0 || (unsigned)ret != arg->read_size) { /* LCOV_EXCL_START */ - ferr("Error reading file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error reading file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -102,7 +102,7 @@ int search_file_compare(const void* void_arg, const void* void_data) ret = close(f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error closing file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error closing file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -157,7 +157,7 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, d = opendir(dir); if (!d) { /* LCOV_EXCL_START */ - ferr("Error opening directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error opening directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -176,7 +176,7 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, dd = readdir(d); if (dd == 0 && errno != 0) { /* LCOV_EXCL_START */ - ferr("Error reading directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error reading directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -194,17 +194,13 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, /* exclude hidden files even before calling lstat() */ if (disk != 0 && filter_hidden(state->filter_hidden, dd) != 0) { - if (state->opt.verbose) { - fout("Excluding hidden '%s'\n", path_next); - } + msg_verbose("Excluding hidden '%s'\n", path_next); continue; } /* exclude content files even before calling lstat() */ if (disk != 0 && filter_content(&state->contentlist, path_next) != 0) { - if (state->opt.verbose) { - fout("Excluding content '%s'\n", path_next); - } + msg_verbose("Excluding content '%s'\n", path_next); continue; } @@ -220,7 +216,7 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, if (st.st_mode == 0) { if (lstat(path_next, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -229,7 +225,7 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, /* get lstat info about the file */ if (lstat(path_next, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); + msg_error("Error in stat file/directory '%s'. %s.\n", path_next, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -239,9 +235,7 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, if (disk == 0 || filter_path(&state->filterlist, &reason, disk->name, sub_next) == 0) { search_file(state, path_next, st.st_size, st.st_mtime, STAT_NSEC(&st)); } else { - if (state->opt.verbose) { - fout("Excluding link '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); - } + msg_verbose("Excluding link '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); } } else if (S_ISDIR(st.st_mode)) { if (disk == 0 || filter_dir(&state->filterlist, &reason, disk->name, sub_next) == 0) { @@ -249,16 +243,14 @@ static void search_dir(struct snapraid_state* state, struct snapraid_disk* disk, pathslash(sub_next, sizeof(sub_next)); search_dir(state, disk, path_next, sub_next); } else { - if (state->opt.verbose) { - fout("Excluding directory '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); - } + msg_verbose("Excluding directory '%s' for rule '%s'\n", path_next, filter_type(reason, out, sizeof(out))); } } } if (closedir(d) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error closing directory '%s'. %s.\n", dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -268,7 +260,7 @@ void state_search(struct snapraid_state* state, const char* dir) { char path[PATH_MAX]; - fout("Importing...\n"); + msg_progress("Importing...\n"); /* add the final slash */ pathimport(path, sizeof(path), dir); @@ -285,7 +277,7 @@ void state_search_array(struct snapraid_state* state) for (i = state->disklist; i != 0; i = i->next) { struct snapraid_disk* disk = i->data; - fout("Scanning disk %s...\n", disk->name); + msg_progress("Scanning disk %s...\n", disk->name); search_dir(state, disk, disk->dir, ""); } diff --git a/cmdline/selftest.c b/cmdline/selftest.c index c4dee6e4..78ca5f2c 100644 --- a/cmdline/selftest.c +++ b/cmdline/selftest.c @@ -160,7 +160,7 @@ static void test_hash(void) digest = tommy_hash_u32(seed32, buffer_aligned, TEST_MURMUR3[i].len); if (digest != TEST_HASH32[i].digest) { /* LCOV_EXCL_START */ - ferr("Failed hash32 test\n"); + msg_error("Failed hash32 test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -172,7 +172,7 @@ static void test_hash(void) digest = tommy_hash_u64(seed64, buffer_aligned, TEST_MURMUR3[i].len); if (digest != TEST_HASH64[i].digest) { /* LCOV_EXCL_START */ - ferr("Failed hash64 test\n"); + msg_error("Failed hash64 test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -185,7 +185,7 @@ static void test_hash(void) memhash(HASH_MURMUR3, seed_aligned, digest, buffer_aligned, TEST_MURMUR3[i].len); if (memcmp(digest, TEST_MURMUR3[i].digest, HASH_SIZE) != 0) { /* LCOV_EXCL_START */ - ferr("Failed Murmur3 test\n"); + msg_error("Failed Murmur3 test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -197,7 +197,7 @@ static void test_hash(void) memhash(HASH_SPOOKY2, seed_aligned, digest, buffer_aligned, TEST_SPOOKY2[i].len); if (memcmp(digest, TEST_SPOOKY2[i].digest, HASH_SIZE) != 0) { /* LCOV_EXCL_START */ - ferr("Failed Spooky2 test\n"); + msg_error("Failed Spooky2 test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -246,7 +246,7 @@ static void test_crc32c(void) digest = crc32c(0, (const unsigned char*)TEST_CRC32C[i].data, TEST_CRC32C[i].len); if (digest != TEST_CRC32C[i].digest) { /* LCOV_EXCL_START */ - ferr("Failed CRC32C test\n"); + msg_error("Failed CRC32C test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -373,22 +373,22 @@ static void test_tommy(void) return; bail: /* LCOV_EXCL_START */ - ferr("Failed tommy test\n"); + msg_error("Failed tommy test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } void selftest(void) { - ftag("selftest:\n"); - fflush_log(); + msg_tag("selftest:\n"); + msg_flush(); - fout("Self test...\n"); + msg_progress("Self test...\n"); /* large file check */ if (sizeof(off_t) < sizeof(uint64_t)) { /* LCOV_EXCL_START */ - ferr("Missing support for large files\n"); + msg_error("Missing support for large files\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -398,55 +398,55 @@ void selftest(void) test_tommy(); if (raid_selftest() != 0) { /* LCOV_EXCL_START */ - ferr("Failed SELF test\n"); + msg_error("Failed SELF test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_sort() != 0) { /* LCOV_EXCL_START */ - ferr("Failed SORT test\n"); + msg_error("Failed SORT test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_insert() != 0) { /* LCOV_EXCL_START */ - ferr("Failed INSERT test\n"); + msg_error("Failed INSERT test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_combo() != 0) { /* LCOV_EXCL_START */ - ferr("Failed COMBO test\n"); + msg_error("Failed COMBO test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_par(RAID_MODE_VANDERMONDE, 32, 256) != 0) { /* LCOV_EXCL_START */ - ferr("Failed GEN Vandermonde test\n"); + msg_error("Failed GEN Vandermonde test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_rec(RAID_MODE_VANDERMONDE, 12, 256) != 0) { /* LCOV_EXCL_START */ - ferr("Failed REC Vandermonde test\n"); + msg_error("Failed REC Vandermonde test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_par(RAID_MODE_CAUCHY, 32, 256) != 0) { /* LCOV_EXCL_START */ - ferr("Failed GEN Cauchy test\n"); + msg_error("Failed GEN Cauchy test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_rec(RAID_MODE_CAUCHY, 12, 256) != 0) { /* LCOV_EXCL_START */ - ferr("Failed REC Cauchy test\n"); + msg_error("Failed REC Cauchy test\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (raid_test_par(RAID_MODE_CAUCHY, 1, 256) != 0) { /* LCOV_EXCL_START */ - ferr("Failed GEN Cauchy test sigle data disk\n"); + msg_error("Failed GEN Cauchy test sigle data disk\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } diff --git a/cmdline/snapraid.c b/cmdline/snapraid.c index f7090016..053b7fd4 100644 --- a/cmdline/snapraid.c +++ b/cmdline/snapraid.c @@ -30,54 +30,54 @@ void version(void) { - fout(PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL "\n"); + msg_status(PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL "\n"); } void usage(void) { version(); - fout("Usage: " PACKAGE " status|diff|sync|scrub|list|dup|up|down|smart|pool|check|fix [options]\n"); - fout("\n"); - fout("Commands:\n"); - fout(" status Print the status of the array\n"); - fout(" diff Show the changes that needs to be syncronized\n"); - fout(" sync Syncronize the state of the array\n"); - fout(" scrub Scrub the array\n"); - fout(" list List the array content\n"); - fout(" dup Find duplicate files\n"); - fout(" up Spinup the array\n"); - fout(" down Spindown the array\n"); - fout(" smart SMART attributes of the array\n"); - fout(" pool Create or update the virtual view of the array\n"); - fout(" check Check the array\n"); - fout(" fix Fix the array\n"); - fout("\n"); - fout("Options:\n"); - fout(" " SWITCH_GETOPT_LONG("-c, --conf FILE ", "-c") " Configuration file\n"); - fout(" " SWITCH_GETOPT_LONG("-f, --filter PATTERN ", "-f") " Process only files matching the pattern\n"); - fout(" " SWITCH_GETOPT_LONG("-d, --filter-disk NAME", "-f") " Process only files in the specified disk\n"); - fout(" " SWITCH_GETOPT_LONG("-m, --filter-missing ", "-m") " Process only missing/deleted files\n"); - fout(" " SWITCH_GETOPT_LONG("-e, --filter-error ", "-e") " Process only files with errors\n"); - fout(" " SWITCH_GETOPT_LONG("-p, --percentage PERC ", "-p") " Process only a part of the array\n"); - fout(" " SWITCH_GETOPT_LONG("-o, --older-than DAYS ", "-o") " Process only the older part of the array\n"); - fout(" " SWITCH_GETOPT_LONG("-i, --import DIR ", "-i") " Import deleted files\n"); - fout(" " SWITCH_GETOPT_LONG("-l, --log FILE ", "-l") " Log file. Default none\n"); - fout(" " SWITCH_GETOPT_LONG("-a, --audit-only ", "-a") " Check only file data and not parity\n"); - fout(" " SWITCH_GETOPT_LONG("-h, --pre-hash ", "-h") " Pre hash all the new data\n"); - fout(" " SWITCH_GETOPT_LONG("-Z, --force-zero ", "-Z") " Force synching of files that get zero size\n"); - fout(" " SWITCH_GETOPT_LONG("-E, --force-empty ", "-E") " Force synching of disks that get empty\n"); - fout(" " SWITCH_GETOPT_LONG("-U, --force-uuid ", "-U") " Force commands on disks with uuid changed\n"); - fout(" " SWITCH_GETOPT_LONG("-D, --force-device ", "-D") " Force commands on disks with same device id\n"); - fout(" " SWITCH_GETOPT_LONG("-N, --force-nocopy ", "-N") " Force commands disabling the copy detection\n"); - fout(" " SWITCH_GETOPT_LONG("-F, --force-full ", "-F") " Force commands requiring a full sync\n"); - fout(" " SWITCH_GETOPT_LONG("-v, --verbose ", "-v") " Verbose\n"); + printf("Usage: " PACKAGE " status|diff|sync|scrub|list|dup|up|down|smart|pool|check|fix [options]\n"); + printf("\n"); + printf("Commands:\n"); + printf(" status Print the status of the array\n"); + printf(" diff Show the changes that needs to be syncronized\n"); + printf(" sync Syncronize the state of the array\n"); + printf(" scrub Scrub the array\n"); + printf(" list List the array content\n"); + printf(" dup Find duplicate files\n"); + printf(" up Spinup the array\n"); + printf(" down Spindown the array\n"); + printf(" smart SMART attributes of the array\n"); + printf(" pool Create or update the virtual view of the array\n"); + printf(" check Check the array\n"); + printf(" fix Fix the array\n"); + printf("\n"); + printf("Options:\n"); + printf(" " SWITCH_GETOPT_LONG("-c, --conf FILE ", "-c") " Configuration file\n"); + printf(" " SWITCH_GETOPT_LONG("-f, --filter PATTERN ", "-f") " Process only files matching the pattern\n"); + printf(" " SWITCH_GETOPT_LONG("-d, --filter-disk NAME", "-f") " Process only files in the specified disk\n"); + printf(" " SWITCH_GETOPT_LONG("-m, --filter-missing ", "-m") " Process only missing/deleted files\n"); + printf(" " SWITCH_GETOPT_LONG("-e, --filter-error ", "-e") " Process only files with errors\n"); + printf(" " SWITCH_GETOPT_LONG("-p, --percentage PERC ", "-p") " Process only a part of the array\n"); + printf(" " SWITCH_GETOPT_LONG("-o, --older-than DAYS ", "-o") " Process only the older part of the array\n"); + printf(" " SWITCH_GETOPT_LONG("-i, --import DIR ", "-i") " Import deleted files\n"); + printf(" " SWITCH_GETOPT_LONG("-l, --log FILE ", "-l") " Log file. Default none\n"); + printf(" " SWITCH_GETOPT_LONG("-a, --audit-only ", "-a") " Check only file data and not parity\n"); + printf(" " SWITCH_GETOPT_LONG("-h, --pre-hash ", "-h") " Pre hash all the new data\n"); + printf(" " SWITCH_GETOPT_LONG("-Z, --force-zero ", "-Z") " Force synching of files that get zero size\n"); + printf(" " SWITCH_GETOPT_LONG("-E, --force-empty ", "-E") " Force synching of disks that get empty\n"); + printf(" " SWITCH_GETOPT_LONG("-U, --force-uuid ", "-U") " Force commands on disks with uuid changed\n"); + printf(" " SWITCH_GETOPT_LONG("-D, --force-device ", "-D") " Force commands on disks with same device id\n"); + printf(" " SWITCH_GETOPT_LONG("-N, --force-nocopy ", "-N") " Force commands disabling the copy detection\n"); + printf(" " SWITCH_GETOPT_LONG("-F, --force-full ", "-F") " Force commands requiring a full sync\n"); + printf(" " SWITCH_GETOPT_LONG("-v, --verbose ", "-v") " Verbose\n"); } void memory(void) { - ftag("memory:used:%" PRIu64 "\n", (uint64_t)malloc_counter()); - fout("Using %u MiB of memory.\n", (unsigned)(malloc_counter() / 1024 / 1024)); + msg_tag("memory:used:%" PRIu64 "\n", (uint64_t)malloc_counter()); + msg_progress("Using %u MiB of memory.\n", (unsigned)(malloc_counter() / 1024 / 1024)); } /****************************************************************************/ @@ -146,7 +146,7 @@ void log_open(const char* log) break; default : /* LCOV_EXCL_START */ - ferr("Invalid type specifier '%c' in the log file.\n", *log); + msg_error("Invalid type specifier '%c' in the log file.\n", *log); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -161,7 +161,7 @@ void log_open(const char* log) stdlog = fopen(path, mode); if (!stdlog) { /* LCOV_EXCL_START */ - ferr("Error opening the log file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening the log file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -172,7 +172,7 @@ void log_close(const char* log) if (stdlog != stdout && stdlog != stderr && stdlog != 0) { if (fclose(stdlog) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing the log file '%s'. %s.\n", log, strerror(errno)); + msg_error("Error closing the log file '%s'. %s.\n", log, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -451,7 +451,7 @@ int main(int argc, char* argv[]) struct snapraid_filter* filter = filter_alloc_file(1, optarg); if (!filter) { /* LCOV_EXCL_START */ - ferr("Invalid filter specification '%s'\n", optarg); + msg_error("Invalid filter specification '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -461,7 +461,7 @@ int main(int argc, char* argv[]) struct snapraid_filter* filter = filter_alloc_disk(1, optarg); if (!filter) { /* LCOV_EXCL_START */ - ferr("Invalid filter specification '%s'\n", optarg); + msg_error("Invalid filter specification '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -481,7 +481,7 @@ int main(int argc, char* argv[]) percentage = strtoul(optarg, &e, 10); if (!e || *e || percentage > 100) { /* LCOV_EXCL_START */ - ferr("Invalid percentage '%s'\n", optarg); + msg_error("Invalid percentage '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -490,7 +490,7 @@ int main(int argc, char* argv[]) olderthan = strtoul(optarg, &e, 10); if (!e || *e || olderthan > 1000) { /* LCOV_EXCL_START */ - ferr("Invalid number of days '%s'\n", optarg); + msg_error("Invalid number of days '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -499,7 +499,7 @@ int main(int argc, char* argv[]) blockstart = strtoul(optarg, &e, 0); if (!e || *e) { /* LCOV_EXCL_START */ - ferr("Invalid start position '%s'\n", optarg); + msg_error("Invalid start position '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -508,7 +508,7 @@ int main(int argc, char* argv[]) blockcount = strtoul(optarg, &e, 0); if (!e || *e) { /* LCOV_EXCL_START */ - ferr("Invalid count number '%s'\n", optarg); + msg_error("Invalid count number '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -517,7 +517,7 @@ int main(int argc, char* argv[]) opt.io_error_limit = strtoul(optarg, &e, 0); if (!e || *e) { /* LCOV_EXCL_START */ - ferr("Invalid error limit number '%s'\n", optarg); + msg_error("Invalid error limit number '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -525,7 +525,7 @@ int main(int argc, char* argv[]) case 'i' : if (import_timestamp) { /* LCOV_EXCL_START */ - ferr("Import directory '%s' already specified as '%s'\n", optarg, import_timestamp); + msg_error("Import directory '%s' already specified as '%s'\n", optarg, import_timestamp); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -534,7 +534,7 @@ int main(int argc, char* argv[]) case OPT_TEST_IMPORT_CONTENT : if (import_content) { /* LCOV_EXCL_START */ - ferr("Import directory '%s' already specified as '%s'\n", optarg, import_content); + msg_error("Import directory '%s' already specified as '%s'\n", optarg, import_content); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -543,7 +543,7 @@ int main(int argc, char* argv[]) case 'l' : if (log) { /* LCOV_EXCL_START */ - ferr("Log file '%s' already specified as '%s'\n", optarg, log); + msg_error("Log file '%s' already specified as '%s'\n", optarg, log); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -574,10 +574,10 @@ int main(int argc, char* argv[]) opt.prehash = 1; break; case 'v' : - opt.verbose = 1; + ++msg_level; break; case 'q' : - opt.quiet = 1; + --msg_level; break; case 'G' : opt.gui = 1; @@ -680,7 +680,7 @@ int main(int argc, char* argv[]) break; default : /* LCOV_EXCL_START */ - ferr("Unknown option '%c'\n", (char)c); + msg_error("Unknown option '%c'\n", (char)c); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -746,7 +746,7 @@ int main(int argc, char* argv[]) operation = OPERATION_SMART; } else { /* LCOV_EXCL_START */ - ferr("Unknown command '%s'\n", argv[optind]); + msg_error("Unknown command '%s'\n", argv[optind]); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -758,7 +758,7 @@ int main(int argc, char* argv[]) default : if (opt.auditonly) { /* LCOV_EXCL_START */ - ferr("You cannot use -a, --audit-only with the '%s' command\n", command); + msg_error("You cannot use -a, --audit-only with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -772,7 +772,7 @@ int main(int argc, char* argv[]) default : if (opt.force_nocopy) { /* LCOV_EXCL_START */ - ferr("You cannot use -N, --force-nocopy with the '%s' command\n", command); + msg_error("You cannot use -N, --force-nocopy with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -784,14 +784,14 @@ int main(int argc, char* argv[]) default : if (opt.prehash) { /* LCOV_EXCL_START */ - ferr("You cannot use -h, --pre-hash with the '%s' command\n", command); + msg_error("You cannot use -h, --pre-hash with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (opt.force_full) { /* LCOV_EXCL_START */ - ferr("You cannot use -F, --force-full with the '%s' command\n", command); + msg_error("You cannot use -F, --force-full with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -799,14 +799,14 @@ int main(int argc, char* argv[]) if (opt.force_full && opt.force_nocopy) { /* LCOV_EXCL_START */ - ferr("You cannot use the -F, --force-full and -N, --force-nocopy options at the same time\n"); + msg_error("You cannot use the -F, --force-full and -N, --force-nocopy options at the same time\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (opt.prehash && opt.force_nocopy) { /* LCOV_EXCL_START */ - ferr("You cannot use the -h, --pre-hash and -N, --force-nocopy options at the same time\n"); + msg_error("You cannot use the -h, --pre-hash and -N, --force-nocopy options at the same time\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -819,25 +819,25 @@ int main(int argc, char* argv[]) default : if (!tommy_list_empty(&filterlist_file)) { /* LCOV_EXCL_START */ - ferr("You cannot use -f, --filter with the '%s' command\n", command); + msg_error("You cannot use -f, --filter with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!tommy_list_empty(&filterlist_disk)) { /* LCOV_EXCL_START */ - ferr("You cannot use -d, --filter-disk with the '%s' command\n", command); + msg_error("You cannot use -d, --filter-disk with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (filter_missing != 0) { /* LCOV_EXCL_START */ - ferr("You cannot use -m, --filter-missing with the '%s' command\n", command); + msg_error("You cannot use -m, --filter-missing with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (filter_error != 0) { /* LCOV_EXCL_START */ - ferr("You cannot use -e, --filter-error with the '%s' command\n", command); + msg_error("You cannot use -e, --filter-error with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -850,7 +850,7 @@ int main(int argc, char* argv[]) default : if (import_timestamp != 0 || import_content != 0) { /* LCOV_EXCL_START */ - ferr("You cannot import with the '%s' command\n", command); + msg_error("You cannot import with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -911,17 +911,17 @@ int main(int argc, char* argv[]) /* print generic info into the log */ t = time(0); tm = localtime(&t); - ftag("version:%s\n", PACKAGE_VERSION); - ftag("unixtime:%" PRIi64 "\n", (int64_t)t); + msg_tag("version:%s\n", PACKAGE_VERSION); + msg_tag("unixtime:%" PRIi64 "\n", (int64_t)t); if (tm) { char datetime[64]; strftime(datetime, sizeof(datetime), "%Y-%m-%d %H:%M:%S", tm); - ftag("time:%s\n", datetime); + msg_tag("time:%s\n", datetime); } - ftag("command:%s\n", command); + msg_tag("command:%s\n", command); for (i = 0; i < argc; ++i) - ftag("argv:%u:%s\n", i, argv[i]); - fflush_log(); + msg_tag("argv:%u:%s\n", i, argv[i]); + msg_flush(); if (!opt.skip_self) selftest(); @@ -941,10 +941,10 @@ int main(int argc, char* argv[]) if (lock == -1) { /* LCOV_EXCL_START */ if (errno != EWOULDBLOCK) { - ferr("Error creating the lock file '%s'. %s.\n", state.lockfile, strerror(errno)); + msg_error("Error creating the lock file '%s'. %s.\n", state.lockfile, strerror(errno)); } else { - ferr("The lock file '%s' is already locked!\n", state.lockfile); - ferr("SnapRAID is already in use!\n"); + msg_error("The lock file '%s' is already locked!\n", state.lockfile); + msg_error("SnapRAID is already in use!\n"); } exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -1002,7 +1002,7 @@ int main(int argc, char* argv[]) ret = system(run); /* ignore error */ if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error in running command '%s'.\n", run); + msg_error("Error in running command '%s'.\n", run); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1158,7 +1158,7 @@ int main(int argc, char* argv[]) if (!opt.skip_lock) { if (lock_unlock(lock) == -1) { /* LCOV_EXCL_START */ - ferr("Error closing the lock file '%s'. %s.\n", state.lockfile, strerror(errno)); + msg_error("Error closing the lock file '%s'. %s.\n", state.lockfile, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } diff --git a/cmdline/state.c b/cmdline/state.c index 88bdc61f..4de88cd9 100644 --- a/cmdline/state.c +++ b/cmdline/state.c @@ -140,7 +140,7 @@ static void state_config_check(struct snapraid_state* state, const char* path, t if (state->raid_mode == RAID_MODE_VANDERMONDE) { if (state->level > 3) { /* LCOV_EXCL_START */ - ferr("If you use the z-parity you cannot have more than 3 parities.\n"); + msg_error("If you use the z-parity you cannot have more than 3 parities.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STIO */ } @@ -149,7 +149,7 @@ static void state_config_check(struct snapraid_state* state, const char* path, t for (l = 0; l < state->level; ++l) { if (state->parity[l].path[0] == 0) { /* LCOV_EXCL_START */ - ferr("No '%s' specification in '%s'\n", lev_config_name(l), path); + msg_error("No '%s' specification in '%s'\n", lev_config_name(l), path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -157,7 +157,7 @@ static void state_config_check(struct snapraid_state* state, const char* path, t if (tommy_list_empty(&state->contentlist)) { /* LCOV_EXCL_START */ - ferr("No 'content' specification in '%s'\n", path); + msg_error("No 'content' specification in '%s'\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -169,7 +169,7 @@ static void state_config_check(struct snapraid_state* state, const char* path, t for (l = 0; l < state->level; ++l) { if (pathcmp(state->parity[l].path, content->content) == 0) { /* LCOV_EXCL_START */ - ferr("Same path used for '%s' and 'content' as '%s'\n", lev_config_name(l), content->content); + msg_error("Same path used for '%s' and 'content' as '%s'\n", lev_config_name(l), content->content); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -185,10 +185,10 @@ static void state_config_check(struct snapraid_state* state, const char* path, t #ifdef _WIN32 if (disk->device == 0) { /* LCOV_EXCL_START */ - ferr("Disk '%s' has a zero serial number.\n", disk->dir); - ferr("This is not necessarely wrong, but for using SnapRAID\n"); - ferr("it's better to change the serial number of the disk.\n"); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'.\n"); + msg_error("Disk '%s' has a zero serial number.\n", disk->dir); + msg_error("This is not necessarely wrong, but for using SnapRAID\n"); + msg_error("it's better to change the serial number of the disk.\n"); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -199,15 +199,15 @@ static void state_config_check(struct snapraid_state* state, const char* path, t struct snapraid_disk* other = j->data; if (disk->device == other->device) { /* LCOV_EXCL_START */ - ferr("Disks '%s' and '%s' are on the same device.\n", disk->dir, other->dir); + msg_error("Disks '%s' and '%s' are on the same device.\n", disk->dir, other->dir); #ifdef _WIN32 - ferr("Both have the serial number '%" PRIx64 "'.\n", disk->device); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); - ferr("to change one of the disk serial.\n"); + msg_error("Both have the serial number '%" PRIx64 "'.\n", disk->device); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); + msg_error("to change one of the disk serial.\n"); #endif /* in "fix" we allow to continue anyway */ if (strcmp(state->command, "fix") == 0) { - ferr("You can '%s' anyway, using 'snapraid --force-device %s'.\n", state->command, state->command); + msg_error("You can '%s' anyway, using 'snapraid --force-device %s'.\n", state->command, state->command); } exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -219,11 +219,11 @@ static void state_config_check(struct snapraid_state* state, const char* path, t for (l = 0; l < state->level; ++l) { if (disk->device == state->parity[l].device) { /* LCOV_EXCL_START */ - ferr("Disk '%s' and %s '%s' are on the same device.\n", disk->dir, lev_name(l), state->parity[l].path); + msg_error("Disk '%s' and %s '%s' are on the same device.\n", disk->dir, lev_name(l), state->parity[l].path); #ifdef _WIN32 - ferr("Both have the serial number '%" PRIx64 "'.\n", disk->device); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); - ferr("to change one of the disk serial.\n"); + msg_error("Both have the serial number '%" PRIx64 "'.\n", disk->device); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); + msg_error("to change one of the disk serial.\n"); #endif exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -233,11 +233,11 @@ static void state_config_check(struct snapraid_state* state, const char* path, t if (state->pool[0] != 0 && disk->device == state->pool_device) { /* LCOV_EXCL_START */ - ferr("Disk '%s' and pool '%s' are on the same device.\n", disk->dir, state->pool); + msg_error("Disk '%s' and pool '%s' are on the same device.\n", disk->dir, state->pool); #ifdef _WIN32 - ferr("Both have the serial number '%" PRIx64 "'.\n", disk->device); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); - ferr("to change one of the disk serial.\n"); + msg_error("Both have the serial number '%" PRIx64 "'.\n", disk->device); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); + msg_error("to change one of the disk serial.\n"); #endif exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -251,10 +251,10 @@ static void state_config_check(struct snapraid_state* state, const char* path, t for (l = 0; l < state->level; ++l) { if (state->parity[l].device == 0) { /* LCOV_EXCL_START */ - ferr("Disk '%s' has a zero serial number.\n", state->parity[l].path); - ferr("This is not necessarely wrong, but for using SnapRAID\n"); - ferr("it's better to change the serial number of the disk.\n"); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'.\n"); + msg_error("Disk '%s' has a zero serial number.\n", state->parity[l].path); + msg_error("This is not necessarely wrong, but for using SnapRAID\n"); + msg_error("it's better to change the serial number of the disk.\n"); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -266,11 +266,11 @@ static void state_config_check(struct snapraid_state* state, const char* path, t for (j = l + 1; j < state->level; ++j) { if (state->parity[l].device == state->parity[j].device) { /* LCOV_EXCL_START */ - ferr("Parity '%s' and '%s' are on the same device.\n", state->parity[l].path, state->parity[j].path); + msg_error("Parity '%s' and '%s' are on the same device.\n", state->parity[l].path, state->parity[j].path); #ifdef _WIN32 - ferr("Both have the serial number '%" PRIx64 "'.\n", state->parity[l].device); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); - ferr("to change one of the disk serial.\n"); + msg_error("Both have the serial number '%" PRIx64 "'.\n", state->parity[l].device); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); + msg_error("to change one of the disk serial.\n"); #endif exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -281,11 +281,11 @@ static void state_config_check(struct snapraid_state* state, const char* path, t for (l = 0; l < state->level; ++l) { if (state->pool[0] != 0 && state->pool_device == state->parity[l].device) { /* LCOV_EXCL_START */ - ferr("Pool '%s' and parity '%s' are on the same device.\n", state->pool, state->parity[l].path); + msg_error("Pool '%s' and parity '%s' are on the same device.\n", state->pool, state->parity[l].path); #ifdef _WIN32 - ferr("Both have the serial number '%" PRIx64 "'.\n", state->pool_device); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); - ferr("to change one of the disk serial.\n"); + msg_error("Both have the serial number '%" PRIx64 "'.\n", state->pool_device); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'\n"); + msg_error("to change one of the disk serial.\n"); #endif exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -298,10 +298,10 @@ static void state_config_check(struct snapraid_state* state, const char* path, t if (!state->opt.skip_device) { if (state->pool[0] != 0 && state->pool_device == 0) { /* LCOV_EXCL_START */ - ferr("Disk '%s' has a zero serial number.\n", state->pool); - ferr("This is not necessarely wrong, but for using SnapRAID\n"); - ferr("it's better to change the serial number of the disk.\n"); - ferr("Try using the 'VolumeID' tool by 'Mark Russinovich'.\n"); + msg_error("Disk '%s' has a zero serial number.\n", state->pool); + msg_error("This is not necessarely wrong, but for using SnapRAID\n"); + msg_error("it's better to change the serial number of the disk.\n"); + msg_error("Try using the 'VolumeID' tool by 'Mark Russinovich'.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -334,7 +334,7 @@ static void state_config_check(struct snapraid_state* state, const char* path, t if (content_count < state->level + 1) { /* LCOV_EXCL_START */ - ferr("You must have at least %d 'content' files in different disks.\n", state->level + 1); + msg_error("You must have at least %d 'content' files in different disks.\n", state->level + 1); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -346,11 +346,11 @@ static void state_config_check(struct snapraid_state* state, const char* path, t #endif if (state->raid_mode == RAID_MODE_CAUCHY) { if (state->level == 3) { - ferr("WARNING! Your CPU doesn't have a fast implementation for triple parity.\n"); - ferr("WARNING! It's recommended to switch to 'z-parity' instead than '3-parity'.\n"); + msg_warning("WARNING! Your CPU doesn't have a fast implementation for triple parity.\n"); + msg_warning("WARNING! It's recommended to switch to 'z-parity' instead than '3-parity'.\n"); } else if (state->level > 3) { - ferr("WARNING! Your CPU doesn't have a fast implementation beyond triple parity.\n"); - ferr("WARNING! It's recommended to reduce the parity levels to triple parity.\n"); + msg_warning("WARNING! Your CPU doesn't have a fast implementation beyond triple parity.\n"); + msg_warning("WARNING! It's recommended to reduce the parity levels to triple parity.\n"); } } @@ -365,7 +365,7 @@ static void state_config_check(struct snapraid_state* state, const char* path, t } if (j == 0) { /* LCOV_EXCL_START */ - ferr("Option -d, --filter-disk %s doesn't match any disk.\n", filter->pattern); + msg_error("Option -d, --filter-disk %s doesn't match any disk.\n", filter->pattern); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -393,17 +393,17 @@ void state_config(struct snapraid_state* state, const char* path, const char* co /* store current command */ state->command = command; - ftag("conf:%s\n", path); + msg_tag("conf:%s\n", path); f = sopen_read(path); if (!f) { /* LCOV_EXCL_START */ if (errno == ENOENT) { - ferr("No configuration file found at '%s'\n", path); + msg_error("No configuration file found at '%s'\n", path); } else if (errno == EACCES) { - ferr("You do not have rights to access the configuration file '%s'\n", path); + msg_error("You do not have rights to access the configuration file '%s'\n", path); } else { - ferr("Error opening the configuration file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening the configuration file '%s'. %s.\n", path, strerror(errno)); } exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -423,7 +423,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgettok(f, tag, sizeof(tag)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Error reading the configuration file '%s' at line %u\n", path, line); + msg_error("Error reading the configuration file '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -438,26 +438,26 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetu32(f, &state->block_size); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'blocksize' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'blocksize' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (state->block_size < 1) { /* LCOV_EXCL_START */ - ferr("Too small 'blocksize' specification in '%s' at line %u\n", path, line); + msg_error("Too small 'blocksize' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (state->block_size > 16 * 1024) { /* LCOV_EXCL_START */ - ferr("Too big 'blocksize' specification in '%s' at line %u\n", path, line); + msg_error("Too big 'blocksize' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } /* check if it's a power of 2 */ if ((state->block_size & (state->block_size - 1)) != 0) { /* LCOV_EXCL_START */ - ferr("Not power of 2 'blocksize' specification in '%s' at line %u\n", path, line); + msg_error("Not power of 2 'blocksize' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -493,14 +493,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co break; default : /* LCOV_EXCL_START */ - ferr("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (*state->parity[level].path) { /* LCOV_EXCL_START */ - ferr("Multiple '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Multiple '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -508,14 +508,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Empty '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -534,7 +534,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co pathcpy(device, sizeof(device), "."); if (stat(device, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing 'parity' dir '%s' specification in '%s' at line %u\n", device, path, line); + msg_error("Error accessing 'parity' dir '%s' specification in '%s' at line %u\n", device, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -551,7 +551,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co } else if (strcmp(tag, "share") == 0) { if (*state->share) { /* LCOV_EXCL_START */ - ferr("Multiple 'share' specification in '%s' at line %u\n", path, line); + msg_error("Multiple 'share' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -559,14 +559,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'share' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'share' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'share' specification in '%s' at line %u\n", path, line); + msg_error("Empty 'share' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -577,7 +577,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co if (*state->pool) { /* LCOV_EXCL_START */ - ferr("Multiple 'pool' specification in '%s' at line %u\n", path, line); + msg_error("Multiple 'pool' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -585,14 +585,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'pool' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'pool' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'pool' specification in '%s' at line %u\n", path, line); + msg_error("Empty 'pool' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -602,7 +602,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co /* get the device of the directory containing the pool tree */ if (stat(buffer, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing 'pool' dir '%s' specification in '%s' at line %u\n", buffer, path, line); + msg_error("Error accessing 'pool' dir '%s' specification in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -617,21 +617,21 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'content' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'content' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (pathcmp(buffer, "/dev/null") == 0 || pathcmp(buffer, "NUL") == 0) { /* LCOV_EXCL_START */ - ferr("You cannot use the null device as 'content' specification in '%s' at line %u\n", path, line); + msg_error("You cannot use the null device as 'content' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'content' specification in '%s' at line %u\n", path, line); + msg_error("Empty 'content' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -644,7 +644,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co } if (i) { /* LCOV_EXCL_START */ - ferr("Duplicate 'content' specification in '%s' at line %u\n", path, line); + msg_error("Duplicate 'content' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -658,7 +658,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co pathcpy(device, sizeof(device), "."); if (stat(device, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing 'content' dir '%s' specification in '%s' at line %u\n", device, path, line); + msg_error("Error accessing 'content' dir '%s' specification in '%s' at line %u\n", device, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -681,14 +681,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'disk' name specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'disk' name specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'disk' name specification in '%s' at line %u\n", path, line); + msg_error("Empty 'disk' name specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -698,14 +698,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, dir, sizeof(dir)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'disk' dir specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'disk' dir specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*dir) { /* LCOV_EXCL_START */ - ferr("Empty 'disk' dir specification in '%s' at line %u\n", path, line); + msg_error("Empty 'disk' dir specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -721,7 +721,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co } if (i) { /* LCOV_EXCL_START */ - ferr("Duplicate disk name '%s' at line %u\n", buffer, line); + msg_error("Duplicate disk name '%s' at line %u\n", buffer, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -731,7 +731,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co if (stat(device, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing 'disk' '%s' specification in '%s' at line %u\n", dir, device, line); + msg_error("Error accessing 'disk' '%s' specification in '%s' at line %u\n", dir, device, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -753,14 +753,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'exclude' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'exclude' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'exclude' specification in '%s' at line %u\n", path, line); + msg_error("Empty 'exclude' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -768,7 +768,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co filter = filter_alloc_file(-1, buffer); if (!filter) { /* LCOV_EXCL_START */ - ferr("Invalid 'exclude' specification '%s' in '%s' at line %u\n", buffer, path, line); + msg_error("Invalid 'exclude' specification '%s' in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -779,14 +779,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'include' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'include' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'include' specification in '%s' at line %u\n", path, line); + msg_error("Empty 'include' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -794,7 +794,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co filter = filter_alloc_file(1, buffer); if (!filter) { /* LCOV_EXCL_START */ - ferr("Invalid 'include' specification '%s' in '%s' at line %u\n", buffer, path, line); + msg_error("Invalid 'include' specification '%s' in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -805,14 +805,14 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetlasttok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'autosave' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'autosave' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*buffer) { /* LCOV_EXCL_START */ - ferr("Empty 'autosave' specification in '%s' at line %u\n", path, line); + msg_error("Empty 'autosave' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -821,7 +821,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co if (!e || *e) { /* LCOV_EXCL_START */ - ferr("Invalid 'autosave' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'autosave' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -834,13 +834,13 @@ void state_config(struct snapraid_state* state, const char* path, const char* co ret = sgetline(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid comment in '%s' at line %u\n", path, line); + msg_error("Invalid comment in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } else { /* LCOV_EXCL_START */ - ferr("Invalid command '%s' in '%s' at line %u\n", tag, path, line); + msg_error("Invalid command '%s' in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -855,7 +855,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co } if (c != '\n') { /* LCOV_EXCL_START */ - ferr("Extra data in '%s' at line %u\n", path, line); + msg_error("Extra data in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -864,7 +864,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error reading the configuration file '%s' at line %u\n", path, line); + msg_error("Error reading the configuration file '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -898,7 +898,7 @@ void state_config(struct snapraid_state* state, const char* path, const char* co /* by default use a random hash seed */ if (randomize(state->hashseed, HASH_SIZE) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to get random values.\n"); + msg_error("Failed to get random values.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -908,30 +908,30 @@ void state_config(struct snapraid_state* state, const char* path, const char* co /* intentionally not set the prevhashseed, if used valgrind will warn about it */ - ftag("blocksize:%u\n", state->block_size); + msg_tag("blocksize:%u\n", state->block_size); for (i = state->disklist; i != 0; i = i->next) { struct snapraid_disk* disk = i->data; - ftag("disk:%s:%s\n", disk->name, disk->dir); + msg_tag("disk:%s:%s\n", disk->name, disk->dir); } - ftag("mode:%s\n", lev_raid_name(state->raid_mode, state->level)); + msg_tag("mode:%s\n", lev_raid_name(state->raid_mode, state->level)); for (l = 0; l < state->level; ++l) - ftag("%s:%s\n", lev_config_name(l), state->parity[l].path); + msg_tag("%s:%s\n", lev_config_name(l), state->parity[l].path); if (state->pool[0] != 0) - ftag("pool:%s\n", state->pool); + msg_tag("pool:%s\n", state->pool); if (state->share[0] != 0) - ftag("share:%s\n", state->share); + msg_tag("share:%s\n", state->share); if (state->autosave != 0) - ftag("autosave:%" PRIu64 "\n", state->autosave); + msg_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; - ftag("filter:%s\n", filter_type(filter, out, sizeof(out))); + msg_tag("filter:%s\n", filter_type(filter, out, sizeof(out))); } if (state->filter_hidden) - ftag("filter:nohidden:\n"); + msg_tag("filter:nohidden:\n"); - fflush_log(); + msg_flush(); } /** @@ -1057,7 +1057,7 @@ static void state_map(struct snapraid_state* state) disk = find_disk(state, map->name); if (disk == 0) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for mapping '%s'\n", map->name); + msg_error("Internal inconsistency for mapping '%s'\n", map->name); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1078,7 +1078,7 @@ static void state_map(struct snapraid_state* state) if (map->uuid[0] != 0) { /* count the number of uuid change */ ++uuid_mismatch; - ferr("UUID change for disk '%s' from '%s' to '%s'\n", disk->name, map->uuid, uuid); + msg_error("UUID change for disk '%s' from '%s' to '%s'\n", disk->name, map->uuid, uuid); } else { /* no message here, because having a disk without */ /* UUID is the normal state of an empty disk */ @@ -1112,7 +1112,7 @@ static void state_map(struct snapraid_state* state) if (state->parity[l].uuid[0] != 0) { /* count the number of uuid change */ ++uuid_mismatch; - ferr("UUID change for parity '%s' from '%s' to '%s'\n", lev_config_name(l), state->parity[l].uuid, uuid); + msg_error("UUID change for parity '%s' from '%s' to '%s'\n", lev_config_name(l), state->parity[l].uuid, uuid); } /* update the uuid */ @@ -1126,11 +1126,11 @@ static void state_map(struct snapraid_state* state) if (!state->opt.force_uuid && uuid_mismatch > state->level) { /* LCOV_EXCL_START */ - ferr("Too many disks have UUID changed from the latest 'sync'.\n"); - ferr("If this happens because you really replaced them,\n"); - ferr("you can '%s' anyway, using 'snapraid --force-uuid %s'.\n", state->command, state->command); - ferr("Instead, it's possible that you messed up the disk mount points,\n"); - ferr("and you have to restore the mount points at the state of the latest sync.\n"); + msg_error("Too many disks have UUID changed from the latest 'sync'.\n"); + msg_error("If this happens because you really replaced them,\n"); + msg_error("you can '%s' anyway, using 'snapraid --force-uuid %s'.\n", state->command, state->command); + msg_error("Instead, it's possible that you messed up the disk mount points,\n"); + msg_error("and you have to restore the mount points at the state of the latest sync.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1147,7 +1147,7 @@ static void state_map(struct snapraid_state* state) /* ensure to don't go over the limit of the RAID engine */ if (diskcount > RAID_DATA_MAX) { /* LCOV_EXCL_START */ - ferr("Too many data disks. No more than %u.\n", RAID_DATA_MAX); + msg_error("Too many data disks. No more than %u.\n", RAID_DATA_MAX); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1157,15 +1157,15 @@ static void state_map(struct snapraid_state* state) /* recommend number of parities */ if (diskcount >= 36 && state->level < 6) { - ferr("WARNING! With %u disks it's recommended to use six parity levels.\n", diskcount); + msg_warning("WARNING! With %u disks it's recommended to use six parity levels.\n", diskcount); } else if (diskcount >= 29 && state->level < 5) { - ferr("WARNING! With %u disks it's recommended to use five parity levels.\n", diskcount); + msg_warning("WARNING! With %u disks it's recommended to use five parity levels.\n", diskcount); } else if (diskcount >= 22 && state->level < 4) { - ferr("WARNING! With %u disks it's recommended to use four parity levels.\n", diskcount); + msg_warning("WARNING! With %u disks it's recommended to use four parity levels.\n", diskcount); } else if (diskcount >= 15 && state->level < 3) { - ferr("WARNING! With %u disks it's recommended to use three parity levels.\n", diskcount); + msg_warning("WARNING! With %u disks it's recommended to use three parity levels.\n", diskcount); } else if (diskcount >= 5 && state->level < 2) { - ferr("WARNING! With %u disks it's recommended to use two parity levels.\n", diskcount); + msg_warning("WARNING! With %u disks it's recommended to use two parity levels.\n", diskcount); } } @@ -1185,7 +1185,7 @@ void state_refresh(struct snapraid_state* state) disk = find_disk(state, map->name); if (disk == 0) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for mapping '%s'\n", map->name); + msg_error("Internal inconsistency for mapping '%s'\n", map->name); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1193,7 +1193,7 @@ void state_refresh(struct snapraid_state* state) ret = fsinfo(disk->dir, 0, &total_space, &free_space); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing disk '%s' to get filesystem info. %s.\n", disk->dir, strerror(errno)); + msg_error("Error accessing disk '%s' to get filesystem info. %s.\n", disk->dir, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1216,7 +1216,7 @@ void state_refresh(struct snapraid_state* state) ret = fsinfo(state->parity[l].path, 0, &total_space, &free_space); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error accessing file '%s' to get filesystem info. %s.\n", state->parity[l].path, strerror(errno)); + msg_error("Error accessing file '%s' to get filesystem info. %s.\n", state->parity[l].path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1245,13 +1245,13 @@ static void state_content_check(struct snapraid_state* state, const char* path) struct snapraid_map* other = j->data; if (strcmp(map->name, other->name) == 0) { /* LCOV_EXCL_START */ - ferr("Colliding 'map' disk specification in '%s'\n", path); + msg_error("Colliding 'map' disk specification in '%s'\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (map->position == other->position) { /* LCOV_EXCL_START */ - ferr("Colliding 'map' index specification in '%s'\n", path); + msg_error("Colliding 'map' index specification in '%s'\n", path); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1370,7 +1370,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, tag, sizeof(tag)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Error reading the configuration file '%s' at line %u\n", path, line); + msg_error("Error reading the configuration file '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1390,7 +1390,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (!file) { /* LCOV_EXCL_START */ - ferr("Unexpected '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Unexpected '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1398,14 +1398,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_pos); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (blockidx >= file->blockmax) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Internal inconsistency in '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1414,7 +1414,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (block->parity_pos != POS_INVALID) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Internal inconsistency in '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1447,7 +1447,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1455,7 +1455,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgethex(f, block->hash, HASH_SIZE); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Invalid '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1500,7 +1500,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE /* we must not overwrite existing blocks */ if (disk_block_get(disk, v_pos) != BLOCK_EMPTY) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for '%s' specification in '%s' at line %u\n", tag, path, line); + msg_error("Internal inconsistency for '%s' specification in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1526,14 +1526,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_pos); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'inf' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'inf' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (v_pos >= blockmax) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in position for 'inf' specification in '%s' at line %u\n", path, line); + msg_error("Internal inconsistency in position for 'inf' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1541,7 +1541,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'inf' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'inf' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1549,7 +1549,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &t); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'inf' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'inf' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1562,7 +1562,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'inf' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'inf' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1574,13 +1574,13 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (state->prevhash == HASH_UNDEFINED) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for missing previous checksum in '%s' at line %u\n", path, line); + msg_error("Internal inconsistency for missing previous checksum in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } else { /* LCOV_EXCL_START */ - ferr("Invalid 'inf' specification '%s' in '%s' at line %u\n", buffer, path, line); + msg_error("Invalid 'inf' specification '%s' in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1600,7 +1600,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (!disk) { /* LCOV_EXCL_START */ - ferr("Unexpected 'off' specification in '%s' at line %u\n", path, line); + msg_error("Unexpected 'off' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1611,7 +1611,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_pos); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'off' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'off' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1622,7 +1622,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'off' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'off' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1631,7 +1631,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgethex(f, deleted->block.hash, HASH_SIZE); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'off' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'off' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1645,7 +1645,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE /* we must not overwrite existing blocks */ if (disk_block_get(disk, v_pos) != BLOCK_EMPTY) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for 'off' specification in '%s' at line %u\n", path, line); + msg_error("Internal inconsistency for 'off' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1666,7 +1666,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (file) { /* LCOV_EXCL_START */ - ferr("Missing 'blk' specification in '%s' at line %u\n", path, line); + msg_error("Missing 'blk' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1674,7 +1674,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1682,7 +1682,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1690,7 +1690,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu64(f, &v_size); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1698,7 +1698,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1706,7 +1706,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu64(f, &v_mtime_sec); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1716,7 +1716,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_mtime_nsec); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1729,7 +1729,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1737,7 +1737,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu64(f, &v_inode); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1745,7 +1745,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1753,14 +1753,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, sub, sizeof(sub)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*sub) { /* LCOV_EXCL_START */ - ferr("Invalid 'file' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'file' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1769,7 +1769,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE disk = find_disk(state, buffer); if (!disk) { /* LCOV_EXCL_START */ - ferr("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); + msg_error("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1799,7 +1799,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (file) { /* LCOV_EXCL_START */ - ferr("Missing 'blk' specification in '%s' at line %u\n", path, line); + msg_error("Missing 'blk' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1807,7 +1807,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'hole' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hole' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1816,7 +1816,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE disk = find_disk(state, buffer); if (!disk) { /* LCOV_EXCL_START */ - ferr("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); + msg_error("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1830,7 +1830,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1838,7 +1838,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1846,7 +1846,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, sub, sizeof(sub)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1854,7 +1854,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgeteol(f); if (c != '\n') { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1863,13 +1863,13 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, tokento, sizeof(tokento)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (strcmp(tokento, "to") != 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1877,7 +1877,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1885,14 +1885,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, linkto, sizeof(linkto)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*sub || !*linkto) { /* LCOV_EXCL_START */ - ferr("Invalid 'symlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'symlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1901,7 +1901,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE disk = find_disk(state, buffer); if (!disk) { /* LCOV_EXCL_START */ - ferr("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); + msg_error("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1925,7 +1925,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1933,7 +1933,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1941,7 +1941,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, sub, sizeof(sub)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1949,7 +1949,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgeteol(f); if (c != '\n') { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1958,13 +1958,13 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, tokento, sizeof(tokento)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (strcmp(tokento, "to") != 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1972,7 +1972,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1980,14 +1980,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, linkto, sizeof(linkto)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*sub || !*linkto) { /* LCOV_EXCL_START */ - ferr("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'hardlink' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1996,7 +1996,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE disk = find_disk(state, buffer); if (!disk) { /* LCOV_EXCL_START */ - ferr("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); + msg_error("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2018,7 +2018,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'dir' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'dir' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2026,7 +2026,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'dir' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'dir' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2034,14 +2034,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, sub, sizeof(sub)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'dir' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'dir' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!*sub) { /* LCOV_EXCL_START */ - ferr("Invalid 'dir' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'dir' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2050,7 +2050,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE disk = find_disk(state, buffer); if (!disk) { /* LCOV_EXCL_START */ - ferr("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); + msg_error("Disk named '%s' not found in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2069,7 +2069,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'checksum' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'checksum' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2080,7 +2080,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE state->hash = HASH_SPOOKY2; } else { /* LCOV_EXCL_START */ - ferr("Invalid 'checksum' specification '%s' in '%s' at line %u\n", buffer, path, line); + msg_error("Invalid 'checksum' specification '%s' in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2091,7 +2091,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgethex(f, state->hashseed, HASH_SIZE); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'seed' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'seed' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2104,7 +2104,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'prevchecksum' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'prevchecksum' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2115,7 +2115,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE state->prevhash = HASH_SPOOKY2; } else { /* LCOV_EXCL_START */ - ferr("Invalid 'prevchecksum' specification '%s' in '%s' at line %u\n", buffer, path, line); + msg_error("Invalid 'prevchecksum' specification '%s' in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2123,7 +2123,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'prevchecksum' specification '%s' in '%s' at line %u\n", buffer, path, line); + msg_error("Invalid 'prevchecksum' specification '%s' in '%s' at line %u\n", buffer, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2132,7 +2132,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgethex(f, state->prevhashseed, HASH_SIZE); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'seed' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'seed' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2142,7 +2142,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &blksize); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'blksize' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'blksize' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2154,8 +2154,8 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (blksize != state->block_size) { /* LCOV_EXCL_START */ - ferr("Mismatching 'blksize' and 'blocksize' specification in '%s' at line %u\n", path, line); - ferr("Please restore the 'blocksize' value in the configuration file to '%u'\n", blksize / 1024); + msg_error("Mismatching 'blksize' and 'blocksize' specification in '%s' at line %u\n", path, line); + msg_error("Please restore the 'blocksize' value in the configuration file to '%u'\n", blksize / 1024); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2169,7 +2169,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2177,7 +2177,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2185,7 +2185,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_pos); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2195,7 +2195,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2203,7 +2203,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_total_blocks); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2211,7 +2211,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2219,7 +2219,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_free_blocks); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2239,7 +2239,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, uuid, sizeof(uuid)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2258,7 +2258,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_level); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'parity' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'parity' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2266,7 +2266,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'parity' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'parity' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2274,7 +2274,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_total_blocks); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'parity' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'parity' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2282,7 +2282,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE c = sgetc(f); if (c != ' ') { /* LCOV_EXCL_START */ - ferr("Invalid 'parity' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'parity' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2290,7 +2290,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &v_free_blocks); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'parity' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'parity' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2306,7 +2306,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgettok(f, uuid, sizeof(uuid)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'map' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'map' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2329,7 +2329,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetu32(f, &sign); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid 'sign' specification in '%s' at line %u\n", path, line); + msg_error("Invalid 'sign' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2342,13 +2342,13 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE ret = sgetline(f, buffer, sizeof(buffer)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Invalid comment in '%s' at line %u\n", path, line); + msg_error("Invalid comment in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } else { /* LCOV_EXCL_START */ - ferr("Invalid command '%s' in '%s' at line %u\n", tag, path, line); + msg_error("Invalid command '%s' in '%s' at line %u\n", tag, path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2360,7 +2360,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE } if (c != '\n') { /* LCOV_EXCL_START */ - ferr("Extra data in '%s' at line %u\n", path, line); + msg_error("Extra data in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2369,14 +2369,14 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error reading the content file '%s' at line %u\n", path, line); + msg_error("Error reading the content file '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (file) { /* LCOV_EXCL_START */ - ferr("Missing 'blk' specification in '%s' at line %u\n", path, line); + msg_error("Missing 'blk' specification in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2384,7 +2384,7 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE /* check that the stored parity size matches the loaded state */ if (blockmax != parity_allocated_size(state)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in parity size in '%s' at line %u\n", path, line); + msg_error("Internal inconsistency in parity size in '%s' at line %u\n", path, line); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2409,12 +2409,10 @@ static void state_read_text(struct snapraid_state* state, const char* path, STRE } } - if (state->opt.verbose) { - fout("%8u files\n", count_file); - fout("%8u hardlinks\n", count_hardlink); - fout("%8u symlinks\n", count_symlink); - fout("%8u empty dirs\n", count_dir); - } + msg_verbose("%8u files\n", count_file); + msg_verbose("%8u hardlinks\n", count_hardlink); + msg_verbose("%8u symlinks\n", count_symlink); + msg_verbose("%8u empty dirs\n", count_dir); } static void state_write_text(struct snapraid_state* state, STREAM* f) @@ -2464,7 +2462,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2475,7 +2473,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputsl("checksum spooky2", f); } else { /* LCOV_EXCL_START */ - ferr("Unexpected hash when writing the content file '%s'.\n", serrorfile(f)); + msg_error("Unexpected hash when writing the content file '%s'.\n", serrorfile(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2484,7 +2482,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2499,7 +2497,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputsl("prevchecksum spooky2", f); } else { /* LCOV_EXCL_START */ - ferr("Unexpected prevhash when writing the content file '%s'.\n", serrorfile(f)); + msg_error("Unexpected prevhash when writing the content file '%s'.\n", serrorfile(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2508,7 +2506,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2524,7 +2522,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) disk = find_disk(state, map->name); if (!disk) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for unmapped disk '%s'\n", map->name); + msg_error("Internal inconsistency for unmapped disk '%s'\n", map->name); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2549,7 +2547,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2580,7 +2578,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2625,7 +2623,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2638,7 +2636,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) /* consistency check */ if (block != disk_block_get(disk, block->parity_pos)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency mismatch for block %u state %u in file '%s'\n", block->parity_pos, block_state, file->sub); + msg_error("Internal inconsistency mismatch for block %u state %u in file '%s'\n", block->parity_pos, block_state, file->sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2655,7 +2653,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) break; default : /* LCOV_EXCL_START */ - ferr("Internal inconsistency in state for block %u state %u\n", block->parity_pos, block_state); + msg_error("Internal inconsistency in state for block %u state %u\n", block->parity_pos, block_state); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2668,7 +2666,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2701,7 +2699,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2718,7 +2716,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2732,7 +2730,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2743,7 +2741,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) /* consistency check */ if (block->parity_pos != b) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in delete position %u/%u!\n", block->parity_pos, b); + msg_error("Internal inconsistency in delete position %u/%u!\n", block->parity_pos, b); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2755,7 +2753,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2783,7 +2781,7 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) sputeol(f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2792,17 +2790,15 @@ static void state_write_text(struct snapraid_state* state, STREAM* f) if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } - if (state->opt.verbose) { - fout("%8u files\n", count_file); - fout("%8u hardlinks\n", count_hardlink); - fout("%8u symlinks\n", count_symlink); - fout("%8u empty dirs\n", count_dir); - } + msg_verbose("%8u files\n", count_file); + msg_verbose("%8u hardlinks\n", count_hardlink); + msg_verbose("%8u symlinks\n", count_symlink); + msg_verbose("%8u empty dirs\n", count_dir); } /** @@ -2817,20 +2813,20 @@ static void decoding_error(const char* path, STREAM* f) if (seof(f)) { /* LCOV_EXCL_START */ - ferr("Unexpected end of content file '%s' at offset %" PRIi64 "\n", path, stell(f)); - ferr("This content file is truncated. Use an alternate copy.\n"); + msg_error("Unexpected end of content file '%s' at offset %" PRIi64 "\n", path, stell(f)); + msg_error("This content file is truncated. Use an alternate copy.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error reading the content file '%s' at offset %" PRIi64 "\n", path, stell(f)); + msg_error("Error reading the content file '%s' at offset %" PRIi64 "\n", path, stell(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } - ferr("Decoding error in '%s' at offset %" PRIi64 "\n", path, stell(f)); + msg_error("Decoding error in '%s' at offset %" PRIi64 "\n", path, stell(f)); buf[0] = 0; buf[1] = 0; @@ -2853,7 +2849,7 @@ static void decoding_error(const char* path, STREAM* f) if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error flushing the content file '%s' at offset %" PRIi64 "\n", path, stell(f)); + msg_error("Error flushing the content file '%s' at offset %" PRIi64 "\n", path, stell(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2868,11 +2864,11 @@ static void decoding_error(const char* path, STREAM* f) crc_stored = crc32c(crc_stored, buf, 4); if (crc_computed != crc_stored) { - ferr("Mismatching CRC in '%s'\n", path); - ferr("This content file is damaged! Use an alternate copy.\n"); + msg_error("Mismatching CRC in '%s'\n", path); + msg_error("This content file is damaged! Use an alternate copy.\n"); exit(EXIT_FAILURE); } else { - ferr("The file CRC is correct!\n"); + msg_error("The file CRC is correct!\n"); } } @@ -2902,7 +2898,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Invalid header!\n"); + msg_error("Invalid header!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2919,9 +2915,9 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST /* LCOV_EXCL_START */ if (memcmp(buffer, "SNAPCNT", 7) != 0) { decoding_error(path, f); - ferr("Invalid header!\n"); + msg_error("Invalid header!\n"); } else { - ferr("The content file '%s' was generated with a newer version of SnapRAID!\n", path); + msg_error("The content file '%s' was generated with a newer version of SnapRAID!\n", path); } exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -2952,7 +2948,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0 || mapping >= mapping_max) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in mapping index!\n"); + msg_error("Internal inconsistency in mapping index!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -2970,7 +2966,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (v_size / state->block_size > blockmax) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in file size too big!\n"); + msg_error("Internal inconsistency in file size too big!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3056,14 +3052,14 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (v_idx + v_count > file->blockmax) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in block number!\n"); + msg_error("Internal inconsistency in block number!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (v_pos + v_count > blockmax) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in block size %u/%u!\n", blockmax, v_pos + v_count); + msg_error("Internal inconsistency in block size %u/%u!\n", blockmax, v_pos + v_count); decoding_error(path, f); exit(EXIT_FAILURE); /* LCOV_EXCL_START */ @@ -3079,7 +3075,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (block->parity_pos != POS_INVALID) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in block position!\n"); + msg_error("Internal inconsistency in block position!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3101,7 +3097,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST default : /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Invalid block type!\n"); + msg_error("Invalid block type!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3159,7 +3155,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (disk_block_get(disk, v_pos) != BLOCK_EMPTY) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in block existence!\n"); + msg_error("Internal inconsistency in block existence!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3208,7 +3204,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (v_pos + v_count > blockmax) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in info size %u/%u!\n", blockmax, v_pos + v_count); + msg_error("Internal inconsistency in info size %u/%u!\n", blockmax, v_pos + v_count); decoding_error(path, f); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -3240,7 +3236,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (rehash && state->prevhash == HASH_UNDEFINED) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency for missing previous checksum!\n"); + msg_error("Internal inconsistency for missing previous checksum!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3259,7 +3255,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (!info) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency for missing info!\n"); + msg_error("Internal inconsistency for missing info!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3283,7 +3279,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0 || mapping >= mapping_max) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in mapping index!\n"); + msg_error("Internal inconsistency in mapping index!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3303,7 +3299,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (v_pos + v_count > blockmax) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in hole size %u/%u!\n", blockmax, v_pos + v_count); + msg_error("Internal inconsistency in hole size %u/%u!\n", blockmax, v_pos + v_count); decoding_error(path, f); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -3345,9 +3341,9 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST /* we must not overwrite existing blocks */ if (disk_block_get(disk, v_pos) != BLOCK_EMPTY) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for used hole at pos %u!\n", v_pos); + msg_error("Internal inconsistency for used hole at pos %u!\n", v_pos); if (state->opt.skip_content_check) { - ferr("Overriding as used.\n"); + msg_error("Overriding as used.\n"); deleted_free(deleted); } else { decoding_error(path, f); @@ -3374,7 +3370,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST default : /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Invalid hole type!\n"); + msg_error("Invalid hole type!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3391,7 +3387,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0 || mapping >= mapping_max) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in mapping index!\n"); + msg_error("Internal inconsistency in mapping index!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3441,7 +3437,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0 || mapping >= mapping_max) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in mapping index!\n"); + msg_error("Internal inconsistency in mapping index!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3490,7 +3486,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0 || mapping >= mapping_max) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Internal inconsistency in mapping index!\n"); + msg_error("Internal inconsistency in mapping index!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3534,7 +3530,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST default : /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Invalid checksum!\n"); + msg_error("Invalid checksum!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3561,7 +3557,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST default : /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Invalid checksum!\n"); + msg_error("Invalid checksum!\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3593,8 +3589,8 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (blksize != state->block_size) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Mismatching 'blksize' and 'blocksize' specification!\n"); - ferr("Please restore the 'blocksize' value in the configuration file to '%u'\n", blksize / 1024); + msg_error("Mismatching 'blksize' and 'blocksize' specification!\n"); + msg_error("Please restore the 'blocksize' value in the configuration file to '%u'\n", blksize / 1024); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3670,8 +3666,8 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (!disk) { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Disk named '%s' not present in the configuration file!\n", buffer); - ferr("If you have removed it from the configuration file, please restore it\n"); + msg_error("Disk named '%s' not present in the configuration file!\n", buffer); + msg_error("If you have removed it from the configuration file, please restore it\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3741,8 +3737,8 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (ret < 0) { /* LCOV_EXCL_START */ /* here don't call decoding_error() because it's too late to get the crc */ - ferr("Error reading the CRC in '%s' at offset %" PRIi64 "\n", path, stell(f)); - ferr("This content file is damaged! Use an alternate copy.\n"); + msg_error("Error reading the CRC in '%s' at offset %" PRIi64 "\n", path, stell(f)); + msg_error("This content file is damaged! Use an alternate copy.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3750,8 +3746,8 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (crc_stored != crc_computed) { /* LCOV_EXCL_START */ /* here don't call decoding_error() because it's too late to get the crc */ - ferr("Mismatching CRC in '%s'\n", path); - ferr("This content file is damaged! Use an alternate copy.\n"); + msg_error("Mismatching CRC in '%s'\n", path); + msg_error("This content file is damaged! Use an alternate copy.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3760,7 +3756,7 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST } else { /* LCOV_EXCL_START */ decoding_error(path, f); - ferr("Invalid command '%c'!\n", (char)c); + msg_error("Invalid command '%c'!\n", (char)c); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3770,15 +3766,15 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error reading the content file '%s' at offset %" PRIi64 "\n", path, stell(f)); + msg_error("Error reading the content file '%s' at offset %" PRIi64 "\n", path, stell(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!crc_checked) { /* LCOV_EXCL_START */ - ferr("Finished reading '%s' without finding the CRC\n", path); - ferr("This content file is truncated or damaged! Use an alternate copy.\n"); + msg_error("Finished reading '%s' without finding the CRC\n", path); + msg_error("This content file is truncated or damaged! Use an alternate copy.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3786,9 +3782,9 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST /* check that the stored parity size matches the loaded state */ if (blockmax != parity_allocated_size(state)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in parity size %u/%u in '%s' at offset %" PRIi64 "\n", blockmax, parity_allocated_size(state), path, stell(f)); + msg_error("Internal inconsistency in parity size %u/%u in '%s' at offset %" PRIi64 "\n", blockmax, parity_allocated_size(state), path, stell(f)); if (state->opt.skip_content_check) { - ferr("Overriding.\n"); + msg_error("Overriding.\n"); blockmax = parity_allocated_size(state); } else { exit(EXIT_FAILURE); @@ -3796,12 +3792,10 @@ static void state_read_binary(struct snapraid_state* state, const char* path, ST /* LCOV_EXCL_STOP */ } - if (state->opt.verbose) { - fout("%8u files\n", count_file); - fout("%8u hardlinks\n", count_hardlink); - fout("%8u symlinks\n", count_symlink); - fout("%8u empty dirs\n", count_dir); - } + msg_verbose("%8u files\n", count_file); + msg_verbose("%8u hardlinks\n", count_hardlink); + msg_verbose("%8u symlinks\n", count_symlink); + msg_verbose("%8u empty dirs\n", count_dir); } static void state_write_binary(struct snapraid_state* state, STREAM* f) @@ -3866,7 +3860,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputb32(blockmax, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3878,14 +3872,14 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputc('k', f); } else { /* LCOV_EXCL_START */ - ferr("Unexpected hash when writing the content file '%s'.\n", serrorfile(f)); + msg_error("Unexpected hash when writing the content file '%s'.\n", serrorfile(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } swrite(state->hashseed, HASH_SIZE, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3901,14 +3895,14 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputc('k', f); } else { /* LCOV_EXCL_START */ - ferr("Unexpected prevhash when writing the content file '%s'.\n", serrorfile(f)); + msg_error("Unexpected prevhash when writing the content file '%s'.\n", serrorfile(f)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } swrite(state->prevhashseed, HASH_SIZE, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3925,7 +3919,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) disk = find_disk(state, map->name); if (!disk) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency for unmapped disk '%s'\n", map->name); + msg_error("Internal inconsistency for unmapped disk '%s'\n", map->name); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3940,7 +3934,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputbs(map->uuid, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -3963,7 +3957,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputbs(state->parity[l].uuid, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4005,7 +3999,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputbs(file->sub, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4040,7 +4034,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) break; default : /* LCOV_EXCL_START */ - ferr("Internal inconsistency in state for block %u state %u\n", v_pos, block_state); + msg_error("Internal inconsistency in state for block %u state %u\n", v_pos, block_state); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4057,7 +4051,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) /* consistency check */ if (block != disk_block_get(disk, block->parity_pos)) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in mismatch for block %u state %u in file '%s'\n", block->parity_pos, block_state, file->sub); + msg_error("Internal inconsistency in mismatch for block %u state %u in file '%s'\n", block->parity_pos, block_state, file->sub); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4067,7 +4061,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4099,7 +4093,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputbs(link->linkto, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4114,7 +4108,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputbs(dir->sub, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4127,7 +4121,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputb32(disk->mapping_idx, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4159,7 +4153,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) /* consistency check */ if (block->parity_pos != begin) { /* LCOV_EXCL_START */ - ferr("Internal inconsistency in delete position %u/%u!\n", block->parity_pos, begin); + msg_error("Internal inconsistency in delete position %u/%u!\n", block->parity_pos, begin); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4179,7 +4173,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4227,7 +4221,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4241,7 +4235,7 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) /* flush data written to the disk */ if (sflush(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s' (in flush before crc). %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s' (in flush before crc). %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4253,9 +4247,9 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) /* with the one of the data written to the stream */ if (crc != scrc_stream(f)) { /* LCOV_EXCL_START */ - ferr("CRC mismatch writing the content stream.\n"); - ferr("DANGER! Your RAM memory is broken! DO NOT PROCEED UNTIL FIXED!\n"); - ferr("Try running a memory test like http://www.memtest86.com/\n"); + msg_error("CRC mismatch writing the content stream.\n"); + msg_error("DANGER! Your RAM memory is broken! DO NOT PROCEED UNTIL FIXED!\n"); + msg_error("Try running a memory test like http://www.memtest86.com/\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4263,17 +4257,15 @@ static void state_write_binary(struct snapraid_state* state, STREAM* f) sputble32(crc, f); if (serror(f)) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s'. %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } - if (state->opt.verbose) { - fout("%8u files\n", count_file); - fout("%8u hardlinks\n", count_hardlink); - fout("%8u symlinks\n", count_symlink); - fout("%8u empty dirs\n", count_dir); - } + msg_verbose("%8u files\n", count_file); + msg_verbose("%8u hardlinks\n", count_hardlink); + msg_verbose("%8u symlinks\n", count_symlink); + msg_verbose("%8u empty dirs\n", count_dir); } void state_read(struct snapraid_state* state) @@ -4293,10 +4285,10 @@ void state_read(struct snapraid_state* state) pathcpy(path, sizeof(path), content->content); if (!state->no_conf) { - ftag("content:%s\n", path); - fflush_log(); + msg_tag("content:%s\n", path); + msg_flush(); } - fout("Loading state from %s...\n", path); + msg_progress("Loading state from %s...\n", path); f = sopen_read(path); if (f != 0) { @@ -4306,14 +4298,14 @@ void state_read(struct snapraid_state* state) /* if it's real error of an existing file, abort */ if (errno != ENOENT) { /* LCOV_EXCL_START */ - ferr("Error opening the content file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error opening the content file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } /* otherwise continue */ if (node->next) { - ferr("WARNING! Content file '%s' not found, trying with another copy...\n", path); + msg_warning("WARNING! Content file '%s' not found, trying with another copy...\n", path); /* ensure to rewrite all the content files */ state->need_write = 1; @@ -4326,7 +4318,7 @@ void state_read(struct snapraid_state* state) /* if not found, assume empty */ if (!f) { - ferr("No content file found. Assuming empty.\n"); + msg_error("No content file found. Assuming empty.\n"); /* create the initial mapping */ state_map(state); @@ -4337,7 +4329,7 @@ void state_read(struct snapraid_state* state) ret = fstat(shandle(f), &st); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Error stating the content file '%s'. %s.\n", path, strerror(errno)); + msg_error("Error stating the content file '%s'. %s.\n", path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4354,7 +4346,7 @@ void state_read(struct snapraid_state* state) /* allow missing content files, but not any other kind of error */ if (errno != ENOENT) { /* LCOV_EXCL_START */ - ferr("Error stating the content file '%s'. %s.\n", other_path, strerror(errno)); + msg_error("Error stating the content file '%s'. %s.\n", other_path, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4364,8 +4356,8 @@ void state_read(struct snapraid_state* state) } else { /* if the size is different */ if (other_st.st_size != st.st_size) { - ferr("WARNING! Content files '%s' and '%s' have a different size!\n", path, other_path); - ferr("Likely one of the two is broken!\n"); + msg_warning("WARNING! Content files '%s' and '%s' have a different size!\n", path, other_path); + msg_warning("Likely one of the two is broken!\n"); /* ensure to rewrite all the content files */ state->need_write = 1; @@ -4406,10 +4398,10 @@ void state_read(struct snapraid_state* state) if (state->hash == HASH_UNDEFINED) { /* LCOV_EXCL_START */ - ferr("The checksum to use is not specified.\n"); - ferr("This happens because you are likely upgrading from SnapRAID 1.0.\n"); - ferr("To use a new SnapRAID you must restart from scratch,\n"); - ferr("deleting all the content and parity files.\n"); + msg_error("The checksum to use is not specified.\n"); + msg_error("This happens because you are likely upgrading from SnapRAID 1.0.\n"); + msg_error("To use a new SnapRAID you must restart from scratch,\n"); + msg_error("deleting all the content and parity files.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4435,7 +4427,7 @@ void state_write(struct snapraid_state* state) i = tommy_list_head(&state->contentlist); while (i) { struct snapraid_content* content = i->data; - fout("Saving state to %s...\n", content->content); + msg_progress("Saving state to %s...\n", content->content); ++count_content; i = i->next; } @@ -4444,7 +4436,7 @@ void state_write(struct snapraid_state* state) f = sopen_multi_write(count_content); if (!f) { /* LCOV_EXCL_START */ - ferr("Error opening the content files.\n"); + msg_error("Error opening the content files.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4457,7 +4449,7 @@ void state_write(struct snapraid_state* state) pathprint(tmp, sizeof(tmp), "%s.tmp", content->content); if (sopen_multi_file(f, k, tmp) != 0) { /* LCOV_EXCL_START */ - ferr("Error opening the content file '%s'. %s.\n", tmp, strerror(errno)); + msg_error("Error opening the content file '%s'. %s.\n", tmp, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4475,7 +4467,7 @@ void state_write(struct snapraid_state* state) if (sflush(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s', in flush(). %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s', in flush(). %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4483,7 +4475,7 @@ void state_write(struct snapraid_state* state) #if HAVE_FSYNC if (ssync(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error writing the content file '%s' in sync(). %s.\n", serrorfile(f), strerror(errno)); + msg_error("Error writing the content file '%s' in sync(). %s.\n", serrorfile(f), strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4491,7 +4483,7 @@ void state_write(struct snapraid_state* state) if (sclose(f) != 0) { /* LCOV_EXCL_START */ - ferr("Error closing the content files in close(). %s.\n", strerror(errno)); + msg_error("Error closing the content files in close(). %s.\n", strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4505,7 +4497,7 @@ void state_write(struct snapraid_state* state) pathprint(tmp, sizeof(tmp), "%s.tmp", content->content); if (rename(tmp, content->content) != 0) { /* LCOV_EXCL_START */ - ferr("Error renaming the content file '%s' to '%s' in rename(). %s.\n", tmp, content->content, strerror(errno)); + msg_error("Error renaming the content file '%s' to '%s' in rename(). %s.\n", tmp, content->content, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -4525,23 +4517,20 @@ void state_filter(struct snapraid_state* state, tommy_list* filterlist_file, tom if (!filter_missing && !filter_error && tommy_list_empty(filterlist_file) && tommy_list_empty(filterlist_disk)) return; - fout("Filtering...\n"); + msg_progress("Filtering...\n"); - if (state->opt.verbose) { - tommy_node* k; - for (k = tommy_list_head(filterlist_disk); k != 0; k = k->next) { - struct snapraid_filter* filter = k->data; - fout("\t%s%s\n", filter->pattern, filter->is_disk ? "//" : ""); - } - for (k = tommy_list_head(filterlist_file); k != 0; k = k->next) { - struct snapraid_filter* filter = k->data; - fout("\t%s%s\n", filter->pattern, filter->is_dir ? "/" : ""); - } - if (filter_missing) - fout("\t\n"); - if (filter_error) - fout("\t\n"); + for (i = tommy_list_head(filterlist_disk); i != 0; i = i->next) { + struct snapraid_filter* filter = i->data; + msg_verbose("\t%s%s\n", filter->pattern, filter->is_disk ? "//" : ""); } + for (i = tommy_list_head(filterlist_file); i != 0; i = i->next) { + struct snapraid_filter* filter = i->data; + msg_verbose("\t%s%s\n", filter->pattern, filter->is_dir ? "/" : ""); + } + if (filter_missing) + msg_verbose("\t\n"); + if (filter_error) + msg_verbose("\t\n"); /* for each disk */ for (i = state->disklist; i != 0; i = i->next) { @@ -4550,7 +4539,7 @@ void state_filter(struct snapraid_state* state, tommy_list* filterlist_file, tom /* if we filter for presence, we have to access the disk, so better to print something */ if (filter_missing) - fout("Scanning disk %s...\n", disk->name); + msg_progress("Scanning disk %s...\n", disk->name); /* for each file */ for (j = tommy_list_head(&disk->filelist); j != 0; j = j->next) { @@ -4596,8 +4585,8 @@ int state_progress_begin(struct snapraid_state* state, block_off_t blockstart, b time_t now; if (state->opt.gui) { - ftag("run:begin:%u:%u:%u\n", blockstart, blockmax, countmax); - fflush_log(); + msg_tag("run:begin:%u:%u:%u\n", blockstart, blockmax, countmax); + msg_flush(); } now = time(0); @@ -4612,10 +4601,10 @@ int state_progress_begin(struct snapraid_state* state, block_off_t blockstart, b if (global_interrupt) { /* LCOV_EXCL_START */ if (!state->opt.gui) { - fout("Not starting for interruption\n"); + msg_status("Not starting for interruption\n"); } - ftag("sigint:0: SIGINT received\n"); - fflush_log(); + msg_tag("sigint:0: SIGINT received\n"); + msg_flush(); return 0; /* LCOV_EXCL_STOP */ } @@ -4626,11 +4615,11 @@ int state_progress_begin(struct snapraid_state* state, block_off_t blockstart, b void state_progress_end(struct snapraid_state* state, block_off_t countpos, block_off_t countmax, data_off_t countsize) { if (state->opt.gui) { - ftag("run:end\n"); - fflush_log(); + msg_tag("run:end\n"); + msg_flush(); } else if (countmax == 0) { - fout("Nothing to do\n"); - } else if (!state->opt.quiet) { + msg_status("Nothing to do\n"); + } else { time_t now; time_t elapsed; @@ -4640,10 +4629,10 @@ void state_progress_end(struct snapraid_state* state, block_off_t countpos, bloc elapsed = now - state->progress_whole_start - state->progress_wasted; - printf("%u%% completed, %u MiB processed", countpos * 100 / countmax, countsize_MiB); + msg_bar("%u%% completed, %u MiB processed", countpos * 100 / countmax, countsize_MiB); if (elapsed >= 60) - printf(" in %u:%02u", (unsigned)(elapsed / 3600), (unsigned)((elapsed % 3600) / 60)); - printf("\n"); + msg_bar(" in %u:%02u", (unsigned)(elapsed / 3600), (unsigned)((elapsed % 3600) / 60)); + msg_bar("\n"); } } @@ -4653,8 +4642,8 @@ void state_progress_stop(struct snapraid_state* state) now = time(0); - if (!state->opt.gui && !state->opt.quiet) - printf("\n"); + if (!state->opt.gui) + msg_bar("\n"); state->progress_interruption = now; } @@ -4759,18 +4748,17 @@ int state_progress(struct snapraid_state* state, block_off_t blockpos, block_off } if (state->opt.gui) { - ftag("run:pos:%u:%u:%" PRIu64 ":%u:%u:%u:%u:%" PRIu64 "\n", blockpos, countpos, countsize, out_perc, out_eta, out_speed, out_cpu, (uint64_t)elapsed); - fflush_log(); - } else if (!state->opt.quiet) { - /* note that here we don't use fout() becase we don't want this in the log */ - printf("%u%%, %u MiB", out_perc, (unsigned)(countsize / (1024 * 1024))); + msg_tag("run:pos:%u:%u:%" PRIu64 ":%u:%u:%u:%u:%" PRIu64 "\n", blockpos, countpos, countsize, out_perc, out_eta, out_speed, out_cpu, (uint64_t)elapsed); + msg_flush(); + } else { + msg_bar("%u%%, %u MiB", out_perc, (unsigned)(countsize / (1024 * 1024))); if (out_speed) - printf(", %u MiB/s", out_speed); + msg_bar(", %u MiB/s", out_speed); if (out_cpu) - printf(", CPU %u%%", out_cpu); + msg_bar(", CPU %u%%", out_cpu); if (out_eta) - printf(", %u:%02u ETA", out_eta / 60, out_eta % 60); - printf("%s\r", PROGRESS_CLEAR); + msg_bar(", %u:%02u ETA", out_eta / 60, out_eta % 60); + msg_bar("%s\r", PROGRESS_CLEAR); fflush(stdout); } @@ -4794,11 +4782,11 @@ int state_progress(struct snapraid_state* state, block_off_t blockpos, block_off if (global_interrupt) { /* LCOV_EXCL_START */ if (!state->opt.gui) { - ferr("\n"); - ferr("Stopping for interruption at block %u\n", blockpos); + msg_error("\n"); + msg_error("Stopping for interruption at block %u\n", blockpos); } - ftag("sigint:%u: SIGINT received\n", blockpos); - fflush_log(); + msg_tag("sigint:%u: SIGINT received\n", blockpos); + msg_flush(); return 1; /* LCOV_EXCL_STOP */ } @@ -4830,26 +4818,29 @@ void state_usage_print(struct snapraid_state* state) if (!tick_total) return; - printf("Time for disk:"); - for (i = state->disklist; i != 0; i = i->next) { - struct snapraid_disk* disk = i->data; - if (disk->tick == tick_max) - printf(" %s:", disk->name); - else - printf(" "); - printf("%" PRIu64 "%%", disk->tick * 100U / tick_total); - } - printf("\n"); + if (msg_level >= MSG_PROGRESS) { + /* here we don't use msg_progress() because it doesn't allow partial output */ + printf("Time for disk:"); + for (i = state->disklist; i != 0; i = i->next) { + struct snapraid_disk* disk = i->data; + if (disk->tick == tick_max) + printf(" %s:", disk->name); + else + printf(" "); + printf("%" PRIu64 "%%", disk->tick * 100U / tick_total); + } + printf("\n"); - printf("Time for parity:"); - for (l = 0; l < state->level; ++l) { - if (state->parity[l].tick == tick_max) - printf(" %s:", lev_config_name(l)); - else - printf(" "); - printf("%" PRIu64 "%%", state->parity[l].tick * 100U / tick_total); + printf("Time for parity:"); + for (l = 0; l < state->level; ++l) { + if (state->parity[l].tick == tick_max) + printf(" %s:", lev_config_name(l)); + else + printf(" "); + printf("%" PRIu64 "%%", state->parity[l].tick * 100U / tick_total); + } + printf("\n"); } - printf("\n"); } void generate_configuration(const char* path) @@ -4874,36 +4865,36 @@ void generate_configuration(const char* path) state_read(&state); /* output a dummy configuration file */ - fout("# Configuration file generated from %s\n", path); - fout("\n"); - fout("# Use this blocksize\n"); - fout("blocksize %u\n", state.block_size / 1024); - fout("\n"); + printf("# Configuration file generated from %s\n", path); + printf("\n"); + printf("# Use this blocksize\n"); + printf("blocksize %u\n", state.block_size / 1024); + printf("\n"); for (i = 0; i < state.level; ++i) { - fout("# Set the correct path for the %s file\n", lev_name(i)); + printf("# Set the correct path for the %s file\n", lev_name(i)); if (state.parity[i].uuid[0]) - fout("# The file was in the disk with id '%s'\n", state.parity[i].uuid); - fout("%s ENTER_HERE_THE_PARITY_FILE\n", lev_config_name(i)); - fout("\n"); + printf("# The file was in the disk with id '%s'\n", state.parity[i].uuid); + printf("%s ENTER_HERE_THE_PARITY_FILE\n", lev_config_name(i)); + printf("\n"); } - fout("# Add any other content file\n"); - fout("content %s\n", path); - fout("\n"); + printf("# Add any other content file\n"); + printf("content %s\n", path); + printf("\n"); for (j = state.maplist; j; j = j->next) { struct snapraid_map* map = j->data; struct snapraid_disk* disk; - fout("# Set the correct dir for disk '%s'\n", map->name); + printf("# Set the correct dir for disk '%s'\n", map->name); if (map->uuid[0]) - fout("# Disk '%s' is the one with id '%s'\n", map->name, map->uuid); + printf("# Disk '%s' is the one with id '%s'\n", map->name, map->uuid); disk = find_disk(&state, map->name); if (disk && disk->filelist) { struct snapraid_file* file = disk->filelist->data; if (file) { - fout("# and containing: %s\n", file->sub); + printf("# and containing: %s\n", file->sub); } } - fout("disk %s ENTER_HERE_THE_DIR\n", map->name); - fout("\n"); + printf("disk %s ENTER_HERE_THE_DIR\n", map->name); + printf("\n"); } state_done(&state); diff --git a/cmdline/state.h b/cmdline/state.h index 2a74f54a..7969084b 100644 --- a/cmdline/state.h +++ b/cmdline/state.h @@ -61,8 +61,6 @@ extern volatile int global_interrupt; * For all these options a value of 0 means nothing set, and to use the default. */ struct snapraid_option { - int verbose; /**< Verbose output. */ - int quiet; /**< Quiet output. */ int gui; /**< Gui output. */ int auditonly; /**< In check, checks only the hash and not the parity. */ int badonly; /**< In fix, fixes only the blocks marked as bad. */ diff --git a/cmdline/status.c b/cmdline/status.c index 803f329e..b4cc41be 100644 --- a/cmdline/status.c +++ b/cmdline/status.c @@ -82,20 +82,20 @@ int state_status(struct snapraid_state* state) blockmax = parity_allocated_size(state); - ftag("summary:block_size:%u\n", state->block_size); - ftag("summary:parity_block_count:%u\n", blockmax); + msg_tag("summary:block_size:%u\n", state->block_size); + msg_tag("summary:parity_block_count:%u\n", blockmax); /* get the minimum parity free space */ parity_block_free = state->parity[0].free_blocks; for (l = 0; l < state->level; ++l) { - ftag("summary:parity_block_total:%s:%u\n", lev_config_name(l), state->parity[l].total_blocks); - ftag("summary:parity_block_free:%s:%u\n", lev_config_name(l), state->parity[l].free_blocks); + msg_tag("summary:parity_block_total:%s:%u\n", lev_config_name(l), state->parity[l].total_blocks); + msg_tag("summary:parity_block_free:%s:%u\n", lev_config_name(l), state->parity[l].free_blocks); if (state->parity[l].free_blocks < parity_block_free) parity_block_free = state->parity[l].free_blocks; if (state->parity[l].free_blocks != 0) free_not_zero = 1; } - ftag("summary:parity_block_free_min:%u\n", parity_block_free); + msg_tag("summary:parity_block_free_min:%u\n", parity_block_free); printf("SnapRAID status report:\n"); printf("\n"); @@ -211,18 +211,18 @@ int state_status(struct snapraid_state* state) printf(" %3u%%", perc(disk_block_count, disk_block_max)); printf(" %s\n", disk->name); - ftag("summary:disk_file_count:%s:%u\n", disk->name, disk_file_count); - ftag("summary:disk_block_count:%s:%u\n", disk->name, disk_block_count); - ftag("summary:disk_fragmented_file_count:%s:%u\n", disk->name, disk_file_fragmented); - ftag("summary:disk_excess_fragment_count:%s:%u\n", disk->name, disk_extra_fragment); - ftag("summary:disk_file_size:%s:%" PRIu64 "\n", disk->name, disk_file_size); - ftag("summary:disk_block_allocated:%s:%u\n", disk->name, disk_block_latest_used + 1); - ftag("summary:disk_block_total:%s:%u\n", disk->name, disk->total_blocks); - ftag("summary:disk_block_free:%s:%u\n", disk->name, disk->free_blocks); - ftag("summary:disk_block_max_by_space:%s:%u\n", disk->name, disk_block_max_by_space); - ftag("summary:disk_block_max_by_parity:%s:%u\n", disk->name, disk_block_max_by_parity); - ftag("summary:disk_block_max:%s:%u\n", disk->name, disk_block_max); - ftag("summary:disk_space_wasted:%s:%" PRId64 "\n", disk->name, wasted); + msg_tag("summary:disk_file_count:%s:%u\n", disk->name, disk_file_count); + msg_tag("summary:disk_block_count:%s:%u\n", disk->name, disk_block_count); + msg_tag("summary:disk_fragmented_file_count:%s:%u\n", disk->name, disk_file_fragmented); + msg_tag("summary:disk_excess_fragment_count:%s:%u\n", disk->name, disk_extra_fragment); + msg_tag("summary:disk_file_size:%s:%" PRIu64 "\n", disk->name, disk_file_size); + msg_tag("summary:disk_block_allocated:%s:%u\n", disk->name, disk_block_latest_used + 1); + msg_tag("summary:disk_block_total:%s:%u\n", disk->name, disk->total_blocks); + msg_tag("summary:disk_block_free:%s:%u\n", disk->name, disk->free_blocks); + msg_tag("summary:disk_block_max_by_space:%s:%u\n", disk->name, disk_block_max_by_space); + msg_tag("summary:disk_block_max_by_parity:%s:%u\n", disk->name, disk_block_max_by_parity); + msg_tag("summary:disk_block_max:%s:%u\n", disk->name, disk_block_max); + msg_tag("summary:disk_space_wasted:%s:%" PRId64 "\n", disk->name, wasted); } /* totals */ @@ -240,17 +240,17 @@ int state_status(struct snapraid_state* state) if (!free_not_zero) printf("\nWARNING! Free space info will be valid after the first sync.\n"); - ftag("summary:file_count:%u\n", file_count); - ftag("summary:file_block_count:%" PRIu64 "\n", file_block_count); - ftag("summary:fragmented_file_count:%u\n", file_fragmented); - ftag("summary:excess_fragment_count:%u\n", extra_fragment); - ftag("summary:file_size:%" PRIu64 "\n", file_size); - ftag("summary:parity_size:%" PRIu64 "\n", blockmax * (uint64_t)state->block_size); - ftag("summary:parity_size_max:%" PRIu64 "\n", (blockmax + parity_block_free) * (uint64_t)state->block_size); - ftag("summary:hash:%s\n", hash_config_name(state->hash)); - ftag("summary:prev_hash:%s\n", hash_config_name(state->prevhash)); - ftag("summary:best_hash:%s\n", hash_config_name(state->besthash)); - fflush_log(); + msg_tag("summary:file_count:%u\n", file_count); + msg_tag("summary:file_block_count:%" PRIu64 "\n", file_block_count); + msg_tag("summary:fragmented_file_count:%u\n", file_fragmented); + msg_tag("summary:excess_fragment_count:%u\n", extra_fragment); + msg_tag("summary:file_size:%" PRIu64 "\n", file_size); + msg_tag("summary:parity_size:%" PRIu64 "\n", blockmax * (uint64_t)state->block_size); + msg_tag("summary:parity_size_max:%" PRIu64 "\n", (blockmax + parity_block_free) * (uint64_t)state->block_size); + msg_tag("summary:hash:%s\n", hash_config_name(state->hash)); + msg_tag("summary:prev_hash:%s\n", hash_config_name(state->prevhash)); + msg_tag("summary:best_hash:%s\n", hash_config_name(state->besthash)); + msg_flush(); /* copy the info a temp vector, and count bad/rehash/unsynced blocks */ infomap = malloc_nofail(blockmax * sizeof(snapraid_info)); @@ -260,7 +260,7 @@ int state_status(struct snapraid_state* state) count = 0; rehash = 0; unsynced_blocks = 0; - ftag("block_count:%u\n", blockmax); + msg_tag("block_count:%u\n", blockmax); for (i = 0; i < blockmax; ++i) { int one_invalid; int one_valid; @@ -302,19 +302,19 @@ int state_status(struct snapraid_state* state) if (state->opt.gui) { if (info != 0) - ftag("block:%u:%" PRIu64 ":%s:%s:%s:%s\n", i, (uint64_t)info_get_time(info), one_valid ? "used" : "", one_invalid ? "unsynced" : "", info_get_bad(info) ? "bad" : "", info_get_rehash(info) ? "rehash" : ""); + msg_tag("block:%u:%" PRIu64 ":%s:%s:%s:%s\n", i, (uint64_t)info_get_time(info), one_valid ? "used" : "", one_invalid ? "unsynced" : "", info_get_bad(info) ? "bad" : "", info_get_rehash(info) ? "rehash" : ""); else - ftag("block_noinfo:%u:%s:%s\n", i, one_valid ? "used" : "", one_invalid ? "unsynced" : ""); + msg_tag("block_noinfo:%u:%s:%s\n", i, one_valid ? "used" : "", one_invalid ? "unsynced" : ""); } } - ftag("summary:has_unsynced:%u\n", unsynced_blocks); - ftag("summary:has_rehash:%u\n", rehash); - ftag("summary:has_bad:%u:%u:%u\n", bad, bad_first, bad_last); - fflush_log(); + msg_tag("summary:has_unsynced:%u\n", unsynced_blocks); + msg_tag("summary:has_rehash:%u\n", rehash); + msg_tag("summary:has_bad:%u:%u:%u\n", bad, bad_first, bad_last); + msg_flush(); if (!count) { - ferr("The array is empty.\n"); + msg_error("The array is empty.\n"); free(infomap); return 0; } @@ -324,12 +324,12 @@ int state_status(struct snapraid_state* state) /* output the info map */ i = 0; - ftag("info_count:%u\n", count); + msg_tag("info_count:%u\n", count); while (i < count) { unsigned j = i + 1; while (j < count && info_get_time(infomap[i]) == info_get_time(infomap[j])) ++j; - ftag("info_time:%" PRIu64 ":%u\n", (uint64_t)info_get_time(infomap[i]), j - i); + msg_tag("info_time:%" PRIu64 ":%u\n", (uint64_t)info_get_time(infomap[i]), j - i); i = j; } diff --git a/cmdline/support.c b/cmdline/support.c index 0a56cd72..4e6349fd 100644 --- a/cmdline/support.c +++ b/cmdline/support.c @@ -22,34 +22,18 @@ /****************************************************************************/ /* print */ -void fout(const char* format, ...) +int msg_level = 0; + +void msg_error(const char* format, ...) { va_list ap; /* first output the same message to stdlog and flush it */ - /* to have the same behaviour of stdout */ + /* to avoid to mix messages in case streams are redirected */ + /* to the same file */ if (stdlog) { va_start(ap, format); - fprintf(stdlog, "stdout: "); - vfprintf(stdlog, format, ap); - va_end(ap); - fflush(stdlog); - } - - va_start(ap, format); - vfprintf(stdout, format, ap); - va_end(ap); -} - -void ferr(const char* format, ...) -{ - va_list ap; - - /* first output the same message to stdlog and flush it */ - /* to have the same behaviour of stderr */ - if (stdlog) { - va_start(ap, format); - fprintf(stdlog, "stderr: "); + fprintf(stdlog, "msg:error: "); vfprintf(stdlog, format, ap); fflush(stdlog); va_end(ap); @@ -60,13 +44,13 @@ void ferr(const char* format, ...) va_end(ap); } -void flog(const char* format, ...) +void msg_warning(const char* format, ...) { va_list ap; if (stdlog) { va_start(ap, format); - fprintf(stdlog, "stdlog: "); + fprintf(stdlog, "msg:warning: "); vfprintf(stdlog, format, ap); va_start(ap, format); } else { @@ -76,13 +60,7 @@ void flog(const char* format, ...) } } -void fflush_log(void) -{ - if (stdlog) - fflush(stdlog); -} - -void ftag(const char* format, ...) +void msg_tag(const char* format, ...) { va_list ap; @@ -93,6 +71,107 @@ void ftag(const char* format, ...) } } +void msg_status(const char* format, ...) +{ + va_list ap; + + /* first output the same message to stdlog and flush it */ + /* to avoid to mix messages in case streams are redirected */ + /* to the same file */ + if (stdlog) { + va_start(ap, format); + fprintf(stdlog, "msg:status: "); + vfprintf(stdlog, format, ap); + va_end(ap); + fflush(stdlog); + } + + if (msg_level >= MSG_STATUS) { + va_start(ap, format); + vfprintf(stdout, format, ap); + va_end(ap); + } +} + +void msg_info(const char* format, ...) +{ + va_list ap; + + /* don't output in stdlog as these messages */ + /* are always paired with a msg_tag() call */ + + if (msg_level >= MSG_INFO) { + va_start(ap, format); + vfprintf(stdout, format, ap); + va_end(ap); + } +} + +void msg_progress(const char* format, ...) +{ + va_list ap; + + /* first output the same message to stdlog and flush it */ + /* to avoid to mix messages in case streams are redirected */ + /* to the same file */ + if (stdlog) { + va_start(ap, format); + fprintf(stdlog, "msg:progress: "); + vfprintf(stdlog, format, ap); + va_end(ap); + fflush(stdlog); + } + + if (msg_level >= MSG_PROGRESS) { + va_start(ap, format); + vfprintf(stdout, format, ap); + va_end(ap); + } +} + +void msg_bar(const char* format, ...) +{ + va_list ap; + + /* don't output in stdlog as these messages */ + /* are intended for screen only */ + + if (msg_level >= MSG_BAR) { + va_start(ap, format); + vfprintf(stdout, format, ap); + va_end(ap); + } +} + +void msg_verbose(const char* format, ...) +{ + va_list ap; + + /* first output the same message to stdlog and flush it */ + /* to avoid to mix messages in case streams are redirected */ + /* to the same file */ + if (stdlog) { + va_start(ap, format); + fprintf(stdlog, "msg:verbose: "); + vfprintf(stdlog, format, ap); + va_end(ap); + fflush(stdlog); + } + + if (msg_level >= MSG_VERBOSE) { + va_start(ap, format); + vfprintf(stdout, format, ap); + va_end(ap); + } +} + +void msg_flush(void) +{ + if (stdlog) + fflush(stdlog); + fflush(stdout); +} + /** * Number of buffers for esc(). */ @@ -157,7 +236,7 @@ const char* esc(const char* str) bail: /* LCOV_EXCL_START */ - ferr("Escape too long\n"); + msg_error("Escape too long\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -171,7 +250,7 @@ void pathcpy(char* dst, size_t size, const char* src) if (len + 1 > size) { /* LCOV_EXCL_START */ - ferr("Path too long\n"); + msg_error("Path too long\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -186,7 +265,7 @@ void pathcat(char* dst, size_t size, const char* src) if (dst_len + src_len + 1 > size) { /* LCOV_EXCL_START */ - ferr("Path too long\n"); + msg_error("Path too long\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -200,7 +279,7 @@ void pathcatc(char* dst, size_t size, char c) if (dst_len + 2 > size) { /* LCOV_EXCL_START */ - ferr("Path too long\n"); + msg_error("Path too long\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -248,7 +327,7 @@ void pathprint(char* dst, size_t size, const char* format, ...) if (len >= size) { /* LCOV_EXCL_START */ - ferr("Path too long\n"); + msg_error("Path too long\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -261,7 +340,7 @@ void pathslash(char* dst, size_t size) if (len > 0 && dst[len - 1] != '/') { if (len + 2 >= size) { /* LCOV_EXCL_START */ - ferr("Path too long\n"); + msg_error("Path too long\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -356,7 +435,7 @@ int mkancestor(const char* file) /* create it */ if (mkdir(dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) { /* LCOV_EXCL_START */ - ferr("Error creating directory '%s'. %s.\n", dir, strerror(errno)); + msg_error("Error creating directory '%s'. %s.\n", dir, strerror(errno)); return -1; /* LCOV_EXCL_STOP */ } @@ -612,14 +691,14 @@ int smartctl_attribute(FILE* f, uint64_t* smart, char* serial) } else if (inside) { if (sscanf(s, "%u %*s %*s %*s %*s %*s %*s %*s %*s %" SCNu64, &id, &raw) != 2) { /* LCOV_EXCL_START */ - ferr("Invalid smartctl line '%s'.\n", s); + msg_error("Invalid smartctl line '%s'.\n", s); return -1; /* LCOV_EXCL_STOP */ } if (id >= 256) { /* LCOV_EXCL_START */ - ferr("Invalid SMART id '%u'.\n", id); + msg_error("Invalid SMART id '%u'.\n", id); return -1; /* LCOV_EXCL_STOP */ } diff --git a/cmdline/support.h b/cmdline/support.h index b462d721..196eea36 100644 --- a/cmdline/support.h +++ b/cmdline/support.h @@ -22,48 +22,106 @@ /* log */ /** - * Output messages targgeted for the screen. + * Fatal messages. * - * Messages are in human readable format. - * They must include the full line output and terminate with '\n'. + * Messages printed before an early termination. * - * These messages go in the log file and in stdout. + * These messages go in the log file and in stderr inconditionally. */ -void fout(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); +void msg_error(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); /** - * Error messages printed before an early termination. + * Warning messages. * - * Messages are in human readable format. - * They must include the full line output and terminate with '\n'. + * Messages reporting warnings or error conditions that don't prevent the program to run. * - * These messages go in the log file and in stderr. + * Some of them could be also serious errors, like "silent errors". + * The summary results is anyway always printed with as errors. + * + * These messages go in the log file if specified, otherwise they go in stderr. */ -void ferr(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); - -/** - * Log messages printed after an error. - * - * Messages are in human readable format. - * They must include the full line output and terminate with '\n'. - * - * These messages go in the log file if specified, otherwise in stderr. - */ -void flog(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); - -/** - * Flush the log output. - */ -void fflush_log(void); +void msg_warning(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); /** * Tag messages. * * Messages are in tag format, like "tag:entry:...". * - * These messages go in the log file. + * These messages neves go on the screen, but only in the log file if specified. + * + * Note that this function, allows not \n terminated strings. */ -void ftag(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); +void msg_tag(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); + +/** + * Message levels. + * + * The levels control the amount of information printed on the screen. + * Note that msg_error(), msg_warning() and msg_tag() are not influenced by this option. + * + * From the most quiet to the most verbose. + */ +#define MSG_STATUS -3 +#define MSG_INFO -2 +#define MSG_PROGRESS -1 +#define MSG_BAR 0 +#define MSG_VERBOSE 1 + +/** + * Selected message level. + */ +extern int msg_level; + +/** + * State messages. + * + * Messages that tell what the program is doing or did, but limited to few lines. + * They are status information, and summary results. + */ +void msg_status(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); + +/** + * Info messages. + * + * Messages that tell what was done. + * Potentially a lot of messages are possible. They can still be on the screen, + * as losing them we don't lose information. + * + * These messages never go in the log file, becauae there is always a corresponding msg_tag(). + */ +void msg_info(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); + +/** + * Progress messages. + * + * Message that tell the progress of program. + * + * These messages also go in the log file. + */ +void msg_progress(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); + +/** + * Progress bar messages. + * + * Message that show the percentage of the progress. + * + * These messages never go in the log file. + */ +void msg_bar(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); + +/** + * Verbose messages. + * + * Message that tell what is already expected. + * + * These messages also go in the log file. + */ +void msg_verbose(const char* format, ...) __attribute__((format(attribute_printf, 1, 2))); + +/** + * Flush the output. + */ +void msg_flush(void); /** * Pointer to log function. diff --git a/cmdline/sync.c b/cmdline/sync.c index 906767d6..2f819781 100644 --- a/cmdline/sync.c +++ b/cmdline/sync.c @@ -132,44 +132,44 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta /* This one is really an unexpected error, because we are only reading */ /* and closing a descriptor should never fail */ if (errno == EIO) { - ftag("error:%u:%s:%s: Close EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output close error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output close error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("WARNING! Unexpected close error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be accessed.\n", handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("WARNING! Unexpected close error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be accessed.\n", handle[j].path); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ } } - ret = handle_open(&handle[j], block_file_get(block), state->file_mode, flog); + ret = handle_open(&handle[j], block_file_get(block), state->file_mode, msg_warning); if (ret == -1) { /* file we have tried to open for error reporting */ struct snapraid_file* file = block_file_get(block); if (errno == EIO) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Open EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output open error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Open EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output open error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; /* LCOV_EXCL_STOP */ } if (errno == ENOENT) { - ftag("error:%u:%s:%s: Open ENOENT error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - flog("Missing file '%s'.\n", handle[j].path); - flog("WARNING! You cannot modify data disk during a sync.\n"); - flog("Rerun the sync command when finished.\n"); + msg_tag("error:%u:%s:%s: Open ENOENT error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_warning("Missing file '%s'.\n", handle[j].path); + msg_warning("WARNING! You cannot modify data disk during a sync.\n"); + msg_warning("Rerun the sync command when finished.\n"); ++error; /* if the file is missing, it means that it was removed during sync */ /* this isn't a serious error, so we skip this block, and continue with others */ @@ -177,20 +177,20 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta } if (errno == EACCES) { - ftag("error:%u:%s:%s: Open EACCES error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - flog("No access at file '%s'.\n", handle[j].path); - flog("WARNING! Please fix the access permission in the data disk.\n"); - flog("Rerun the sync command when finished.\n"); + msg_tag("error:%u:%s:%s: Open EACCES error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_warning("No access at file '%s'.\n", handle[j].path); + msg_warning("WARNING! Please fix the access permission in the data disk.\n"); + msg_warning("Rerun the sync command when finished.\n"); ++error; /* this isn't a serious error, so we skip this block, and continue with others */ continue; } /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Open error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("WARNING! Unexpected open error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be accessed.\n", handle[j].path); - ferr("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); + msg_tag("error:%u:%s:%s: Open error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("WARNING! Unexpected open error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be accessed.\n", handle[j].path); + msg_error("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -204,41 +204,41 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta ) { /* file we are processing for error reporting */ struct snapraid_file* file = block_file_get(block); - ftag("error:%u:%s:%s: Unexpected attribute change\n", i, disk->name, esc(file->sub)); + msg_tag("error:%u:%s:%s: Unexpected attribute change\n", i, disk->name, esc(file->sub)); if (handle[j].st.st_size != file->size) { - flog("Unexpected size change at file '%s' from %" PRIu64 " to %" PRIu64 ".\n", handle[j].path, file->size, handle[j].st.st_size); + msg_warning("Unexpected size change at file '%s' from %" PRIu64 " to %" PRIu64 ".\n", handle[j].path, file->size, handle[j].st.st_size); } else if (handle[j].st.st_mtime != file->mtime_sec || STAT_NSEC(&handle[j].st) != file->mtime_nsec) { - flog("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, (uint32_t)STAT_NSEC(&handle[j].st)); + msg_warning("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, (uint32_t)STAT_NSEC(&handle[j].st)); } else { - flog("Unexpected inode change from %" PRIu64 " to %" PRIu64 " at file '%s'.\n", file->inode, (uint64_t)handle[j].st.st_ino, handle[j].path); + msg_warning("Unexpected inode change from %" PRIu64 " to %" PRIu64 " at file '%s'.\n", file->inode, (uint64_t)handle[j].st.st_ino, handle[j].path); } - flog("WARNING! You cannot modify files during a sync.\n"); - flog("Rerun the sync command when finished.\n"); + msg_warning("WARNING! You cannot modify files during a sync.\n"); + msg_warning("Rerun the sync command when finished.\n"); ++error; /* if the file is changed, it means that it was modified during sync */ /* this isn't a serious error, so we skip this block, and continue with others */ continue; } - read_size = handle_read(&handle[j], block, buffer, state->block_size, ferr); + read_size = handle_read(&handle[j], block, buffer, state->block_size, msg_error); if (read_size == -1) { /* LCOV_EXCL_START */ /* file we are processing for error reporting */ struct snapraid_file* file = block_file_get(block); if (errno == EIO) { - ftag("error:%u:%s:%s: Read EIO error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); - ferr("DANGER! Unexpected input/output read error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be read.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Read EIO error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); + msg_error("DANGER! Unexpected input/output read error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be read.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - ftag("error:%u:%s:%s: Read error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); - ferr("WARNING! Unexpected read error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be read.\n", handle[j].path); - ferr("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); + msg_tag("error:%u:%s:%s: Read error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); + msg_error("WARNING! Unexpected read error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be read.\n", handle[j].path); + msg_error("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -287,18 +287,18 @@ static int state_hash_process(struct snapraid_state* state, block_off_t blocksta /* This one is really an unexpected error, because we are only reading */ /* and closing a descriptor should never fail */ if (errno == EIO) { - ftag("error:%u:%s:%s: Close EIO error. %s\n", blockmax, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output close error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", blockmax); + msg_tag("error:%u:%s:%s: Close EIO error. %s\n", blockmax, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output close error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", blockmax); ++io_error; goto bail; } - ftag("error:%u:%s:%s: Close error. %s\n", blockmax, disk->name, esc(file->sub), strerror(errno)); - ferr("WARNING! Unexpected close error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be accessed.\n", handle[j].path); - ferr("Stopping at block %u\n", blockmax); + msg_tag("error:%u:%s:%s: Close error. %s\n", blockmax, disk->name, esc(file->sub), strerror(errno)); + msg_error("WARNING! Unexpected close error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be accessed.\n", handle[j].path); + msg_error("Stopping at block %u\n", blockmax); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -310,18 +310,22 @@ end: state_progress_end(state, countpos, countmax, countsize); if (error || io_error) { - fout("\n"); - fout("%8u file errors\n", error); - fout("%8u io errors\n", io_error); - fout("WARNING! There are errors!\n"); + msg_status("\n"); + msg_status("%8u file errors\n", error); + msg_status("%8u io errors\n", io_error); } else { /* print the result only if processed something */ if (countpos != 0) - fout("Everything OK\n"); + msg_status("Everything OK\n"); } - ftag("hash_summary:error_file:%u\n", error); - ftag("hash_summary:error_io:%u\n", io_error); + if (error) + msg_error("WARNING! Unexpected file errors!\n"); + if (io_error) + msg_error("DANGER! Unexpected input/output errors! The failing blocks are now marked as bad!\n"); + + msg_tag("hash_summary:error_file:%u\n", error); + msg_tag("hash_summary:error_io:%u\n", io_error); /* proceed without bailing out */ goto finish; @@ -336,8 +340,8 @@ bail: struct snapraid_disk* disk = handle[j].disk; ret = handle_close(&handle[j]); if (ret == -1) { - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected close error in a data disk.\n"); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected close error in a data disk.\n"); ++error; /* continue, as we are already exiting */ } @@ -602,44 +606,44 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari /* This one is really an unexpected error, because we are only reading */ /* and closing a descriptor should never fail */ if (errno == EIO) { - ftag("error:%u:%s:%s: Close EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output close error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output close error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("WARNING! Unexpected close error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be accessed.\n", handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("WARNING! Unexpected close error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be accessed.\n", handle[j].path); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ } } - ret = handle_open(&handle[j], block_file_get(block), state->file_mode, flog); + ret = handle_open(&handle[j], block_file_get(block), state->file_mode, msg_warning); if (ret == -1) { /* file we have tried to open for error reporting */ struct snapraid_file* file = block_file_get(block); if (errno == EIO) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Open EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected input/output open error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_tag("error:%u:%s:%s: Open EIO error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected input/output open error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be accessed.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; /* LCOV_EXCL_STOP */ } if (errno == ENOENT) { - ftag("error:%u:%s:%s: Open ENOENT error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - flog("Missing file '%s'.\n", handle[j].path); - flog("WARNING! You cannot modify data disk during a sync.\n"); - flog("Rerun the sync command when finished.\n"); + msg_tag("error:%u:%s:%s: Open ENOENT error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_warning("Missing file '%s'.\n", handle[j].path); + msg_warning("WARNING! You cannot modify data disk during a sync.\n"); + msg_warning("Rerun the sync command when finished.\n"); ++error; /* if the file is missing, it means that it was removed during sync */ /* this isn't a serious error, so we skip this block, and continue with others */ @@ -648,10 +652,10 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari } if (errno == EACCES) { - ftag("error:%u:%s:%s: Open EACCES error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - flog("No access at file '%s'.\n", handle[j].path); - flog("WARNING! Please fix the access permission in the data disk.\n"); - flog("Rerun the sync command when finished.\n"); + msg_tag("error:%u:%s:%s: Open EACCES error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_warning("No access at file '%s'.\n", handle[j].path); + msg_warning("WARNING! Please fix the access permission in the data disk.\n"); + msg_warning("Rerun the sync command when finished.\n"); ++error; /* this isn't a serious error, so we skip this block, and continue with others */ error_on_this_block = 1; @@ -659,10 +663,10 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari } /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Open error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("WARNING! Unexpected open error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be accessed.\n", handle[j].path); - ferr("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); + msg_tag("error:%u:%s:%s: Open error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("WARNING! Unexpected open error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be accessed.\n", handle[j].path); + msg_error("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -676,17 +680,17 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari ) { /* file we are processing for error reporting */ struct snapraid_file* file = block_file_get(block); - ftag("error:%u:%s:%s: Unexpected attribute change\n", i, disk->name, esc(file->sub)); + msg_tag("error:%u:%s:%s: Unexpected attribute change\n", i, disk->name, esc(file->sub)); if (handle[j].st.st_size != file->size) { - flog("Unexpected size change at file '%s' from %" PRIu64 " to %" PRIu64 ".\n", handle[j].path, file->size, handle[j].st.st_size); + msg_warning("Unexpected size change at file '%s' from %" PRIu64 " to %" PRIu64 ".\n", handle[j].path, file->size, handle[j].st.st_size); } else if (handle[j].st.st_mtime != file->mtime_sec || STAT_NSEC(&handle[j].st) != file->mtime_nsec) { - flog("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, (uint32_t)STAT_NSEC(&handle[j].st)); + msg_warning("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, (uint32_t)STAT_NSEC(&handle[j].st)); } else { - flog("Unexpected inode change from %" PRIu64 " to %" PRIu64 " at file '%s'.\n", file->inode, (uint64_t)handle[j].st.st_ino, handle[j].path); + msg_warning("Unexpected inode change from %" PRIu64 " to %" PRIu64 " at file '%s'.\n", file->inode, (uint64_t)handle[j].st.st_ino, handle[j].path); } - flog("WARNING! You cannot modify files during a sync.\n"); - flog("Rerun the sync command when finished.\n"); + msg_warning("WARNING! You cannot modify files during a sync.\n"); + msg_warning("Rerun the sync command when finished.\n"); ++error; /* if the file is changed, it means that it was modified during sync */ /* this isn't a serious error, so we skip this block, and continue with others */ @@ -694,31 +698,31 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari continue; } - read_size = handle_read(&handle[j], block, buffer[j], state->block_size, flog); + read_size = handle_read(&handle[j], block, buffer[j], state->block_size, msg_warning); if (read_size == -1) { /* LCOV_EXCL_START */ /* file we are processing for error reporting */ struct snapraid_file* file = block_file_get(block); if (errno == EIO) { - ftag("error:%u:%s:%s: Read EIO error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); + msg_tag("error:%u:%s:%s: Read EIO error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); if (io_error >= state->opt.io_error_limit) { - ferr("DANGER! Unexpected input/output read error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that disk '%s' is sane and that file '%s' can be read.\n", disk->dir, handle[j].path); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected input/output read error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that disk '%s' is sane and that file '%s' can be read.\n", disk->dir, handle[j].path); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - flog("Input/Output error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); + msg_warning("Input/Output error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); ++io_error; io_error_on_this_block = 1; continue; } - ftag("error:%u:%s:%s: Read error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); - ferr("WARNING! Unexpected read error in a data disk, it isn't possible to sync.\n"); - ferr("Ensure that file '%s' can be read.\n", handle[j].path); - ferr("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); + msg_tag("error:%u:%s:%s: Read error at position %u. %s\n", i, disk->name, esc(file->sub), block_file_pos(block), strerror(errno)); + msg_error("WARNING! Unexpected read error in a data disk, it isn't possible to sync.\n"); + msg_error("Ensure that file '%s' can be read.\n", handle[j].path); + msg_error("Stopping to allow recovery. Try with 'snapraid check -f %s'\n", file->sub); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -748,17 +752,17 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari /* if the file has invalid parity, it's a REP changed during the sync */ if (block_has_invalid_parity(block)) { - ftag("error:%u:%s:%s: Unexpected data change\n", i, disk->name, esc(file->sub)); - flog("Data change at file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); - flog("WARNING! Unexpected data modification of a file without parity!\n"); + msg_tag("error:%u:%s:%s: Unexpected data change\n", i, disk->name, esc(file->sub)); + msg_warning("Data change at file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); + msg_warning("WARNING! Unexpected data modification of a file without parity!\n"); if (file_flag_has(file, FILE_IS_COPY)) { - flog("This file was detected as a copy of another file with the same name, size,\n"); - flog("and timestamp, but the file data isn't matching the assumed copy.\n"); - flog("If this is a false positive, and the files are expected to be different,\n"); - flog("you can 'sync' anyway using 'snapraid --force-nocopy sync'\n"); + msg_warning("This file was detected as a copy of another file with the same name, size,\n"); + msg_warning("and timestamp, but the file data isn't matching the assumed copy.\n"); + msg_warning("If this is a false positive, and the files are expected to be different,\n"); + msg_warning("you can 'sync' anyway using 'snapraid --force-nocopy sync'\n"); } else { - flog("Try removing the file from the array and rerun the 'sync' command!\n"); + msg_warning("Try removing the file from the array and rerun the 'sync' command!\n"); } ++error; @@ -768,8 +772,8 @@ 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 */ - ftag("error:%u:%s:%s: Data error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); - flog("Data error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); + msg_tag("error:%u:%s:%s: Data error at position %u\n", i, disk->name, esc(file->sub), block_file_pos(block)); + msg_warning("Data error in file '%s' at position '%u'\n", handle[j].path, block_file_pos(block)); /* save the failed block for the fix */ failed[failed_count].index = j; @@ -862,29 +866,29 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari /* we are sure that parity exists because */ /* we have at least one BLK block */ for (l = 0; l < state->level; ++l) { - ret = parity_read(parity[l], i, buffer[diskmax + l], state->block_size, flog); + ret = parity_read(parity[l], i, buffer[diskmax + l], state->block_size, msg_warning); if (ret == -1) { /* LCOV_EXCL_START */ if (errno == EIO) { - ftag("parity_error:%u:%s: Read EIO error. %s\n", i, lev_config_name(l), strerror(errno)); + msg_tag("parity_error:%u:%s: Read EIO error. %s\n", i, lev_config_name(l), strerror(errno)); if (io_error >= state->opt.io_error_limit) { - ferr("DANGER! Unexpected input/output read error in the %s disk, it isn't possible to sync.\n", lev_name(l)); - ferr("Ensure that disk '%s' is sane and can be read.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected input/output read error in the %s disk, it isn't possible to sync.\n", lev_name(l)); + msg_error("Ensure that disk '%s' is sane and can be read.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - flog("Input/Output error in parity '%s' at position '%u'\n", lev_config_name(l), i); + msg_warning("Input/Output error in parity '%s' at position '%u'\n", lev_config_name(l), i); ++io_error; io_error_on_this_block = 1; continue; } - ftag("parity_error:%u:%s: Read error. %s\n", i, lev_config_name(l), strerror(errno)); - ferr("WARNING! Unexpected read error in the %s disk, it isn't possible to sync.\n", lev_name(l)); - ferr("Ensure that disk '%s' can be read.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_tag("parity_error:%u:%s: Read error. %s\n", i, lev_config_name(l), strerror(errno)); + msg_error("WARNING! Unexpected read error in the %s disk, it isn't possible to sync.\n", lev_name(l)); + msg_error("Ensure that disk '%s' can be read.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -961,25 +965,25 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari if (ret == -1) { /* LCOV_EXCL_START */ if (errno == EIO) { - ftag("parity_error:%u:%s: Write EIO error. %s\n", i, lev_config_name(l), strerror(errno)); + msg_tag("parity_error:%u:%s: Write EIO error. %s\n", i, lev_config_name(l), strerror(errno)); if (io_error >= state->opt.io_error_limit) { - ferr("DANGER! Unexpected input/output write error in the %s disk, it isn't possible to sync.\n", lev_name(l)); - ferr("Ensure that disk '%s' is sane and can be written.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_error("DANGER! Unexpected input/output write error in the %s disk, it isn't possible to sync.\n", lev_name(l)); + msg_error("Ensure that disk '%s' is sane and can be written.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++io_error; goto bail; } - flog("Input/Output error in parity '%s' at position '%u'\n", lev_config_name(l), i); + msg_warning("Input/Output error in parity '%s' at position '%u'\n", lev_config_name(l), i); ++io_error; io_error_on_this_block = 1; continue; } - ftag("parity_error:%u:%s: Write error. %s\n", i, lev_config_name(l), strerror(errno)); - ferr("WARNING! Unexpected write error in the %s disk, it isn't possible to sync.\n", lev_name(l)); - ferr("Ensure that disk '%s' has some free space available.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_tag("parity_error:%u:%s: Write error. %s\n", i, lev_config_name(l), strerror(errno)); + msg_error("WARNING! Unexpected write error in the %s disk, it isn't possible to sync.\n", lev_name(l)); + msg_error("Ensure that disk '%s' has some free space available.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -1074,7 +1078,7 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari state_progress_stop(state); - fout("Autosaving...\n"); + msg_progress("Autosaving...\n"); /* before writing the new content file we ensure that */ /* the parity is really written flushing the disk cache */ @@ -1082,10 +1086,10 @@ static int state_sync_process(struct snapraid_state* state, struct snapraid_pari ret = parity_sync(parity[l]); if (ret == -1) { /* LCOV_EXCL_START */ - ftag("parity_error:%u:%s: Sync error\n", i, lev_config_name(l)); - ferr("DANGER! Unexpected sync error in %s disk.\n", lev_name(l)); - ferr("Ensure that disk '%s' is sane.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_tag("parity_error:%u:%s: Sync error\n", i, lev_config_name(l)); + msg_error("DANGER! Unexpected sync error in %s disk.\n", lev_name(l)); + msg_error("Ensure that disk '%s' is sane.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ @@ -1113,45 +1117,46 @@ end: ret = parity_sync(parity[l]); if (ret == -1) { /* LCOV_EXCL_START */ - ftag("parity_error:%u:%s: Sync error\n", i, lev_config_name(l)); - ferr("DANGER! Unexpected sync error in %s disk.\n", lev_name(l)); - ferr("Ensure that disk '%s' is sane.\n", lev_config_name(l)); - ferr("Stopping at block %u\n", i); + msg_tag("parity_error:%u:%s: Sync error\n", i, lev_config_name(l)); + msg_error("DANGER! Unexpected sync error in %s disk.\n", lev_name(l)); + msg_error("Ensure that disk '%s' is sane.\n", lev_config_name(l)); + msg_error("Stopping at block %u\n", i); ++error; goto bail; /* LCOV_EXCL_STOP */ } } - if (io_error) - ferr("WARNING! Unexpected input/output errors! The failing blocks are now marked as bad!\n"); - if (silent_error) - ferr("WARNING! Unexpected data errors! The failing blocks are now marked as bad!\n"); - if (io_error || silent_error) { - ferr("Use 'snapraid status' to list the bad blocks.\n"); - ferr("Use 'snapraid -e fix' to recover.\n"); - } - if (error || silent_error || io_error) { - fout("\n"); - fout("%8u file errors\n", error); - fout("%8u io errors\n", io_error); - fout("%8u data errors\n", silent_error); - fout("WARNING! There are errors!\n"); + msg_status("\n"); + msg_status("%8u file errors\n", error); + msg_status("%8u io errors\n", io_error); + msg_status("%8u data errors\n", silent_error); } else { /* print the result only if processed something */ if (countpos != 0) - fout("Everything OK\n"); + msg_status("Everything OK\n"); } - ftag("summary:error_file:%u\n", error); - ftag("summary:error_io:%u\n", io_error); - ftag("summary:error_data:%u\n", silent_error); + if (error) + msg_error("WARNING! Unexpected file errors!\n"); + if (io_error) + msg_error("DANGER! Unexpected input/output errors! The failing blocks are now marked as bad!\n"); + if (silent_error) + msg_error("DANGER! Unexpected data errors! The failing blocks are now marked as bad!\n"); + if (io_error || silent_error) { + msg_error("Use 'snapraid status' to list the bad blocks.\n"); + msg_error("Use 'snapraid -e fix' to recover.\n"); + } + + msg_tag("summary:error_file:%u\n", error); + msg_tag("summary:error_io:%u\n", io_error); + msg_tag("summary:error_data:%u\n", silent_error); if (error + silent_error + io_error == 0) - ftag("summary:exit:ok\n"); + msg_tag("summary:exit:ok\n"); else - ftag("summary:exit:error\n"); - fflush_log(); + msg_tag("summary:exit:error\n"); + msg_flush(); bail: for (j = 0; j < diskmax; ++j) { @@ -1160,8 +1165,8 @@ bail: ret = handle_close(&handle[j]); if (ret == -1) { /* LCOV_EXCL_START */ - ftag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); - ferr("DANGER! Unexpected close error in a data disk.\n"); + msg_tag("error:%u:%s:%s: Close error. %s\n", i, disk->name, esc(file->sub), strerror(errno)); + msg_error("DANGER! Unexpected close error in a data disk.\n"); ++error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ @@ -1201,7 +1206,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t unsigned l; int skip_sync = 0; - fout("Initializing...\n"); + msg_progress("Initializing...\n"); blockmax = parity_allocated_size(state); size = blockmax * (data_off_t)state->block_size; @@ -1214,7 +1219,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t if (blockstart > blockmax) { /* LCOV_EXCL_START */ - ferr("Error in the starting block %u. It's bigger than the parity size %u.\n", blockstart, blockmax); + msg_error("Error in the starting block %u. It's bigger than the parity size %u.\n", blockstart, blockmax); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1232,7 +1237,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t ret = parity_create(parity_ptr[l], state->parity[l].path, &out_size, state->file_mode); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("WARNING! Without an accessible %s file, it isn't possible to sync.\n", lev_name(l)); + msg_error("WARNING! Without an accessible %s file, it isn't possible to sync.\n", lev_name(l)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1242,7 +1247,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t /* if the file is too small */ if (parityblocks < used_paritymax) { - ferr("WARNING! The %s file %s has data only %u blocks instead of %u.\n", lev_name(l), state->parity[l].path, parityblocks, used_paritymax); + msg_error("WARNING! The %s file %s has data only %u blocks instead of %u.\n", lev_name(l), state->parity[l].path, parityblocks, used_paritymax); } /* keep the smallest parity number of blocks */ @@ -1255,15 +1260,15 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t /* if the parities are too small */ if (file_paritymax < used_paritymax) { /* LCOV_EXCL_START */ - ferr("DANGER! One or more the parity files are smaller than expected!\n"); + msg_error("DANGER! One or more the parity files are smaller than expected!\n"); if (file_paritymax != 0) { - ferr("If this happens because you are using an old content file,\n"); - ferr("you can 'sync' anyway using 'snapraid --force-full sync'\n"); - ferr("to force a full rebuild of the parity.\n"); + msg_error("If this happens because you are using an old content file,\n"); + msg_error("you can 'sync' anyway using 'snapraid --force-full sync'\n"); + msg_error("to force a full rebuild of the parity.\n"); } else { - ferr("It's possible that the parity disks are not mounted.\n"); - ferr("If instead you are adding a new parity level, you can 'sync' using\n"); - ferr("'snapraid --force-full sync' to force a full rebuild of the parity.\n"); + msg_error("It's possible that the parity disks are not mounted.\n"); + msg_error("If instead you are adding a new parity level, you can 'sync' using\n"); + msg_error("'snapraid --force-full sync' to force a full rebuild of the parity.\n"); } exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ @@ -1279,7 +1284,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t if (ret == -1) { /* LCOV_EXCL_START */ parity_overflow(state, out_size); - ferr("WARNING! Without an accessible %s file, it isn't possible to sync.\n", lev_name(l)); + msg_error("WARNING! Without an accessible %s file, it isn't possible to sync.\n", lev_name(l)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -1291,7 +1296,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t unrecoverable_error = 0; if (state->opt.prehash) { - fout("Hashing...\n"); + msg_progress("Hashing...\n"); ret = state_hash_process(state, blockstart, blockmax, &skip_sync); if (ret == -1) { @@ -1306,7 +1311,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t } if (!skip_sync) { - fout("Syncing...\n"); + msg_progress("Syncing...\n"); /* skip degenerated cases of empty parity, or skipping all */ if (blockstart < blockmax) { @@ -1318,7 +1323,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t /* LCOV_EXCL_STOP */ } } else { - fout("Nothing to do\n"); + msg_status("Nothing to do\n"); } } @@ -1326,7 +1331,7 @@ int state_sync(struct snapraid_state* state, block_off_t blockstart, block_off_t ret = parity_close(parity_ptr[l]); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("DANGER! Unexpected close error in %s disk.\n", lev_name(l)); + msg_error("DANGER! Unexpected close error in %s disk.\n", lev_name(l)); ++unrecoverable_error; /* continue, as we are already exiting */ /* LCOV_EXCL_STOP */ diff --git a/cmdline/unix.c b/cmdline/unix.c index 407efe7f..04789407 100644 --- a/cmdline/unix.c +++ b/cmdline/unix.c @@ -341,7 +341,7 @@ static dev_t devread(const char* path) f = open(path, O_RDONLY); if (f == -1) { /* LCOV_EXCL_START */ - ferr("Failed to open '%s'.\n", path); + msg_error("Failed to open '%s'.\n", path); return 0; /* LCOV_EXCL_STOP */ } @@ -350,14 +350,14 @@ static dev_t devread(const char* path) if (ret < 0) { /* LCOV_EXCL_START */ close(f); - ferr("Failed to read '%s'.\n", path); + msg_error("Failed to read '%s'.\n", path); return 0; /* LCOV_EXCL_STOP */ } if (ret == sizeof(buf)) { /* LCOV_EXCL_START */ close(f); - ferr("Too long read '%s'.\n", path); + msg_error("Too long read '%s'.\n", path); return 0; /* LCOV_EXCL_STOP */ } @@ -368,7 +368,7 @@ static dev_t devread(const char* path) if (*e != ':') { /* LCOV_EXCL_START */ close(f); - ferr("Invalid format in '%s' for '%s'.\n", path, buf); + msg_error("Invalid format in '%s' for '%s'.\n", path, buf); return 0; /* LCOV_EXCL_STOP */ } @@ -377,7 +377,7 @@ static dev_t devread(const char* path) if (*e != 0 && !isspace(*e)) { /* LCOV_EXCL_START */ close(f); - ferr("Invalid format in '%s' for '%s'.\n", path, buf); + msg_error("Invalid format in '%s' for '%s'.\n", path, buf); return 0; /* LCOV_EXCL_STOP */ } @@ -385,7 +385,7 @@ static dev_t devread(const char* path) ret = close(f); if (ret != 0) { /* LCOV_EXCL_START */ - ferr("Failed to close '%s'.\n", path); + msg_error("Failed to close '%s'.\n", path); return 0; /* LCOV_EXCL_STOP */ } @@ -411,13 +411,13 @@ static int devresolve(dev_t device, char* path, size_t path_size) ret = readlink(path, buf, sizeof(buf)); if (ret < 0) { /* LCOV_EXCL_START */ - ferr("Failed to readlink '%s'.\n", path); + msg_error("Failed to readlink '%s'.\n", path); return -1; /* LCOV_EXCL_STOP */ } if (ret == sizeof(buf)) { /* LCOV_EXCL_START */ - ferr("Too long readlink '%s'.\n", path); + msg_error("Too long readlink '%s'.\n", path); return -1; /* LCOV_EXCL_STOP */ } @@ -426,7 +426,7 @@ static int devresolve(dev_t device, char* path, size_t path_size) if (buf[0] != '.' || buf[1] != '.' || buf[2] != '/') { /* LCOV_EXCL_START */ - ferr("Unexpected link '%s' at '%s'.\n", buf, path); + msg_error("Unexpected link '%s' at '%s'.\n", buf, path); return -1; /* LCOV_EXCL_STOP */ } @@ -437,13 +437,13 @@ static int devresolve(dev_t device, char* path, size_t path_size) /* check the device */ if (stat(path, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to stat '%s'.\n", path); + msg_error("Failed to stat '%s'.\n", path); return -1; /* LCOV_EXCL_STOP */ } if (st.st_rdev != device) { /* LCOV_EXCL_START */ - ferr("Unexpected device '%u:%u' instead of '%u:%u' for '%s'.\n", major(st.st_rdev), minor(st.st_rdev), major(device), minor(device), path); + msg_error("Unexpected device '%u:%u' instead of '%u:%u' for '%s'.\n", major(st.st_rdev), minor(st.st_rdev), major(device), minor(device), path); return -1; /* LCOV_EXCL_STOP */ } @@ -555,7 +555,7 @@ static int devscan(tommy_list* list) d = opendir(dir); if (d == 0) { /* LCOV_EXCL_START */ - ferr("Failed to open dir '%s'.\n", dir); + msg_error("Failed to open dir '%s'.\n", dir); return -1; /* LCOV_EXCL_STOP */ } @@ -631,7 +631,7 @@ static int devsmart(dev_t device, uint64_t* smart, char* serial) f = popen(cmd, "r"); if (!f) { /* LCOV_EXCL_START */ - ferr("Failed to run smartctl -a on device '%u:%u' (from popen).\n", major(device), minor(device)); + msg_error("Failed to run smartctl -a on device '%u:%u' (from popen).\n", major(device), minor(device)); return -1; /* LCOV_EXCL_STOP */ } @@ -646,13 +646,13 @@ static int devsmart(dev_t device, uint64_t* smart, char* serial) ret = pclose(f); if (!WIFEXITED(ret)) { /* LCOV_EXCL_START */ - ferr("Failed to run smartctl -a on device '%u:%u' (not exited).\n", major(device), minor(device)); + msg_error("Failed to run smartctl -a on device '%u:%u' (not exited).\n", major(device), minor(device)); return -1; /* LCOV_EXCL_STOP */ } if (WEXITSTATUS(ret) == 127) { /* LCOV_EXCL_START */ - ferr("Failed to run smartctl -a on device '%u:%u' (from sh).\n", major(device), minor(device)); + msg_error("Failed to run smartctl -a on device '%u:%u' (from sh).\n", major(device), minor(device)); return -1; /* LCOV_EXCL_STOP */ } @@ -677,25 +677,25 @@ static int devdown(dev_t device) ret = system(cmd); if (ret == -1) { /* LCOV_EXCL_START */ - ferr("Failed to run hdparm -y on device '%u:%u' (from system).\n", major(device), minor(device)); + msg_error("Failed to run hdparm -y on device '%u:%u' (from system).\n", major(device), minor(device)); return -1; /* LCOV_EXCL_STOP */ } if (!WIFEXITED(ret)) { /* LCOV_EXCL_START */ - ferr("Failed to run hdparm -y on device '%u:%u' (not exited).\n", major(device), minor(device)); + msg_error("Failed to run hdparm -y on device '%u:%u' (not exited).\n", major(device), minor(device)); return -1; /* LCOV_EXCL_STOP */ } if (WEXITSTATUS(ret) == 127) { /* LCOV_EXCL_START */ - ferr("Failed to run hdparm -y on device '%u:%u' (from sh).\n", major(device), minor(device)); + msg_error("Failed to run hdparm -y on device '%u:%u' (from sh).\n", major(device), minor(device)); return -1; /* LCOV_EXCL_STOP */ } if (WEXITSTATUS(ret) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to run hdparm -y on device '%u:%u' with return code %xh.\n", major(device), minor(device), WEXITSTATUS(ret)); + msg_error("Failed to run hdparm -y on device '%u:%u' with return code %xh.\n", major(device), minor(device), WEXITSTATUS(ret)); return -1; /* LCOV_EXCL_STOP */ } @@ -722,7 +722,7 @@ static int devup(const char* mount) ret = mkdir(path, 0); if (ret != 0 && errno != EEXIST) { /* LCOV_EXCL_START */ - ferr("Failed to create dir '%s'.\n", path); + msg_error("Failed to create dir '%s'.\n", path); return -1; /* LCOV_EXCL_STOP */ } @@ -751,7 +751,7 @@ static void* thread_spinup(void* arg) /* first get the device number, this usually doesn't trigger a thread_spinup */ if (stat(devinfo->mount, &st) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to stat device '%s'.\n", devinfo->mount); + msg_error("Failed to stat device '%s'.\n", devinfo->mount); return (void*)-1; /* LCOV_EXCL_STOP */ } @@ -772,7 +772,7 @@ static void* thread_spinup(void* arg) /* LCOV_EXCL_STOP */ } - fout("Spunup device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); + msg_status("Spunup device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); return 0; } @@ -794,7 +794,7 @@ static void* thread_spindown(void* arg) /* LCOV_EXCL_STOP */ } - fout("Spundown device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); + msg_status("Spundown device '%s' for disk '%s' in %" PRIu64 " ms.\n", devinfo->file, devinfo->name, tick_ms() - start); return 0; #else @@ -831,7 +831,7 @@ static int device_thread(tommy_list* list, void* (*func)(void* arg)) if (pthread_create(&devinfo->thread, 0, func, devinfo) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to create thread.\n"); + msg_error("Failed to create thread.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -844,7 +844,7 @@ static int device_thread(tommy_list* list, void* (*func)(void* arg)) if (pthread_join(devinfo->thread, &retval) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to join thread.\n"); + msg_error("Failed to join thread.\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -880,13 +880,13 @@ int devquery(tommy_list* high, tommy_list* low, int operation) /* sysfs and devfs interfaces are required */ if (stat("/sys/dev/block", &st) != 0) { /* LCOV_EXCL_START */ - ferr("Missing interface /sys/dev/block.\n"); + msg_error("Missing interface /sys/dev/block.\n"); return -1; /* LCOV_EXCL_STOP */ } if (stat("/dev/block", &st) != 0) { /* LCOV_EXCL_START */ - ferr("Missing interface /dev/block.\n"); + msg_error("Missing interface /dev/block.\n"); return -1; /* LCOV_EXCL_STOP */ } @@ -898,7 +898,7 @@ int devquery(tommy_list* high, tommy_list* low, int operation) /* get the device file */ if (devresolve(devinfo->device, devinfo->file, sizeof(devinfo->file)) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to resolve device '%u:%u'.\n", major(devinfo->device), minor(devinfo->device)); + msg_error("Failed to resolve device '%u:%u'.\n", major(devinfo->device), minor(devinfo->device)); return -1; /* LCOV_EXCL_STOP */ } @@ -906,7 +906,7 @@ int devquery(tommy_list* high, tommy_list* low, int operation) /* expand the tree of devices */ if (devtree(devinfo->name, devinfo->device, devinfo, low) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to expand device '%u:%u'.\n", major(devinfo->device), minor(devinfo->device)); + msg_error("Failed to expand device '%u:%u'.\n", major(devinfo->device), minor(devinfo->device)); return -1; /* LCOV_EXCL_STOP */ } @@ -936,7 +936,7 @@ int devquery(tommy_list* high, tommy_list* low, int operation) if (operation == DEVICE_SMART) { if (devscan(low) != 0) { /* LCOV_EXCL_START */ - ferr("Failed to list other devices.\n"); + msg_error("Failed to list other devices.\n"); return -1; /* LCOV_EXCL_STOP */ } diff --git a/cmdline/util.c b/cmdline/util.c index 74646107..98158797 100644 --- a/cmdline/util.c +++ b/cmdline/util.c @@ -72,8 +72,8 @@ void mtest_vector(int n, size_t size, void** vv) { if (raid_mtest_vector(n, size, vv) != 0) { /* LCOV_EXCL_START */ - ferr("DANGER! Your RAM memory is broken! DO NOT PROCEED UNTIL FIXED!\n"); - ferr("Try running a memory test like http://www.memtest86.com/\n"); + msg_error("DANGER! Your RAM memory is broken! DO NOT PROCEED UNTIL FIXED!\n"); + msg_error("Try running a memory test like http://www.memtest86.com/\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } @@ -492,7 +492,7 @@ void memhash(unsigned kind, const unsigned char* seed, void* digest, const void* break; default : /* LCOV_EXCL_START */ - ferr("Internal inconsistency in hash function %u\n", kind); + msg_error("Internal inconsistency in hash function %u\n", kind); exit(EXIT_FAILURE); break; /* LCOV_EXCL_STOP */ diff --git a/snapraid.1 b/snapraid.1 index 3981d5c4..9fc300c2 100644 --- a/snapraid.1 +++ b/snapraid.1 @@ -46,7 +46,7 @@ snapraid [\-c, \-\-conf CONFIG] .PD 0 .PP .PD - [\-v, \-\-verbose] + [\-v, \-\-verbose] [\-q, \-\-quiet] .PD 0 .PP .PD @@ -998,11 +998,11 @@ the old content file and the parity data you have. This option can be used only with \[dq]sync\[dq]. .TP .B \-l, \-\-log FILE -Write a detailed log of errors encoutered. -If this option is not specified, the errors are printed on -the screen, likely resulting in too much output in case -of many errors. -If the specified path starts with \'>>\' the file is opened +Write a detailed log in the specified file. +If this option is not specified, the warnings and not fatal +errors are printed on the screen, likely resulting in too much +output in case of many errors. +If the path starts with \'>>\' the file is opened in append mode. Occurrences of \'%D\' and \'%T\' in the name are replaced with the date and time in the format YYYYMMDD and HHMMSS. Note that in Windows batch files, you\'ll have to double @@ -1041,7 +1041,14 @@ needed to reconstruct the disk mount points, in case you lose the entire system. .TP .B \-v, \-\-verbose -Prints more information in the processing. +Prints more information on the screen. +.TP +.B \-q, \-\-quiet +Prints less information on the screen. +If specified one time, removes the progress bar, if two +times, the running operations, three times, the info +messages, four times the status messages. +Fatal errors are always printed. .TP .B \-H, \-\-help Prints a short help screen. diff --git a/snapraid.d b/snapraid.d index a3b11bb6..40a43301 100644 --- a/snapraid.d +++ b/snapraid.d @@ -13,7 +13,7 @@ Synopsis : [-N, --force-nocopy] [-F, --force-full] : [-S, --start BLKSTART] [-B, --count BLKCOUNT] : [-L, --error-limit NUMBER] - : [-v, --verbose] + : [-v, --verbose] [-q, --quiet] : status|smart|up|down|diff|sync|scrub|fix|check|list|dup|up|down|pool|rehash :snapraid [-V, --version] [-H, --help] [-C, --gen-conf CONTENT] @@ -739,11 +739,11 @@ Options This option can be used only with "sync". -l, --log FILE - Write a detailed log of errors encoutered. - If this option is not specified, the errors are printed on - the screen, likely resulting in too much output in case - of many errors. - If the specified path starts with '>>' the file is opened + Write a detailed log in the specified file. + If this option is not specified, the warnings and not fatal + errors are printed on the screen, likely resulting in too much + output in case of many errors. + If the path starts with '>>' the file is opened in append mode. Occurrences of '%D' and '%T' in the name are replaced with the date and time in the format YYYYMMDD and HHMMSS. Note that in Windows batch files, you'll have to double @@ -782,7 +782,14 @@ Options lose the entire system. -v, --verbose - Prints more information in the processing. + Prints more information on the screen. + + -q, --quiet + Prints less information on the screen. + If specified one time, removes the progress bar, if two + times, the running operations, three times, the info + messages, four times the status messages. + Fatal errors are always printed. -H, --help Prints a short help screen. diff --git a/snapraid.txt b/snapraid.txt index 8090eb1c..7f60d1c6 100644 --- a/snapraid.txt +++ b/snapraid.txt @@ -17,7 +17,7 @@ snapraid [-c, --conf CONFIG] [-N, --force-nocopy] [-F, --force-full] [-S, --start BLKSTART] [-B, --count BLKCOUNT] [-L, --error-limit NUMBER] - [-v, --verbose] + [-v, --verbose] [-q, --quiet] status|smart|up|down|diff|sync|scrub|fix|check|list|dup|up|down|pool|rehash snapraid [-V, --version] [-H, --help] [-C, --gen-conf CONTENT] @@ -796,11 +796,11 @@ SnapRAID provides the following options: This option can be used only with "sync". -l, --log FILE - Write a detailed log of errors encoutered. - If this option is not specified, the errors are printed on - the screen, likely resulting in too much output in case - of many errors. - If the specified path starts with '>>' the file is opened + Write a detailed log in the specified file. + If this option is not specified, the warnings and not fatal + errors are printed on the screen, likely resulting in too much + output in case of many errors. + If the path starts with '>>' the file is opened in append mode. Occurrences of '%D' and '%T' in the name are replaced with the date and time in the format YYYYMMDD and HHMMSS. Note that in Windows batch files, you'll have to double @@ -839,7 +839,14 @@ SnapRAID provides the following options: lose the entire system. -v, --verbose - Prints more information in the processing. + Prints more information on the screen. + + -q, --quiet + Prints less information on the screen. + If specified one time, removes the progress bar, if two + times, the running operations, three times, the info + messages, four times the status messages. + Fatal errors are always printed. -H, --help Prints a short help screen.