2011-03-01 22:19:30 +01:00
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
< html lang = "en" >
< head >
< meta http-equiv = "Content-Type" content = "text/html; charset=UTF-8" >
< title > LCOV - lcov.info - cmdline/snapraid.c< / title >
< link rel = "stylesheet" type = "text/css" href = "../gcov.css" >
< / head >
< body >
< table width = "100%" border = 0 cellspacing = 0 cellpadding = 0 >
< tr > < td class = "title" > LCOV - code coverage report< / td > < / tr >
< tr > < td class = "ruler" > < img src = "../glass.png" width = 3 height = 3 alt = "" > < / td > < / tr >
< tr >
< td width = "100%" >
< table cellpadding = 1 border = 0 width = "100%" >
< tr >
< td width = "10%" class = "headerItem" > Current view:< / td >
< td width = "35%" class = "headerValue" > < a href = "../index.html" > top level< / a > - < a href = "index.html" > cmdline< / a > - snapraid.c< span style = "font-size: 80%;" > (source / < a href = "snapraid.c.func.html" > functions< / a > )< / span > < / td >
< td width = "5%" > < / td >
< td width = "15%" > < / td >
< td width = "10%" class = "headerCovTableHead" > Hit< / td >
< td width = "10%" class = "headerCovTableHead" > Total< / td >
< td width = "15%" class = "headerCovTableHead" > Coverage< / td >
< / tr >
< tr >
< td class = "headerItem" > Test:< / td >
< td class = "headerValue" > lcov.info< / td >
< td > < / td >
< td class = "headerItem" > Lines:< / td >
2016-11-21 19:48:21 +01:00
< td class = "headerCovTableEntry" > 497< / td >
< td class = "headerCovTableEntry" > 544< / td >
< td class = "headerCovTableEntryHi" > 91.4 %< / td >
2011-03-01 22:19:30 +01:00
< / tr >
< tr >
< td class = "headerItem" > Date:< / td >
2016-11-21 19:48:21 +01:00
< td class = "headerValue" > 2016-11-21< / td >
2011-03-01 22:19:30 +01:00
< td > < / td >
< td class = "headerItem" > Functions:< / td >
2016-11-06 18:12:17 +01:00
< td class = "headerCovTableEntry" > 9< / td >
< td class = "headerCovTableEntry" > 9< / td >
2011-03-01 22:19:30 +01:00
< td class = "headerCovTableEntryHi" > 100.0 %< / td >
< / tr >
< tr > < td > < img src = "../glass.png" width = 3 height = 3 alt = "" > < / td > < / tr >
< / table >
< / td >
< / tr >
< tr > < td class = "ruler" > < img src = "../glass.png" width = 3 height = 3 alt = "" > < / td > < / tr >
< / table >
< table cellpadding = 0 cellspacing = 0 border = 0 >
< tr >
< td > < br > < / td >
< / tr >
< tr >
< td >
< pre class = "sourceHeading" > Line data Source code< / pre >
< pre class = "source" >
< a name = "1" > < span class = "lineNum" > 1 < / span > : /*< / a >
< span class = "lineNum" > 2 < / span > : * Copyright (C) 2011 Andrea Mazzoleni
< span class = "lineNum" > 3 < / span > : *
< span class = "lineNum" > 4 < / span > : * This program is free software: you can redistribute it and/or modify
< span class = "lineNum" > 5 < / span > : * it under the terms of the GNU General Public License as published by
< span class = "lineNum" > 6 < / span > : * the Free Software Foundation, either version 3 of the License, or
< span class = "lineNum" > 7 < / span > : * (at your option) any later version.
< span class = "lineNum" > 8 < / span > : *
< span class = "lineNum" > 9 < / span > : * This program is distributed in the hope that it will be useful,
< span class = "lineNum" > 10 < / span > : * but WITHOUT ANY WARRANTY; without even the implied warranty of
< span class = "lineNum" > 11 < / span > : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
< span class = "lineNum" > 12 < / span > : * GNU General Public License for more details.
< span class = "lineNum" > 13 < / span > : *
< span class = "lineNum" > 14 < / span > : * You should have received a copy of the GNU General Public License
< span class = "lineNum" > 15 < / span > : * along with this program. If not, see < http://www.gnu.org/licenses/> .
< span class = "lineNum" > 16 < / span > : */
< span class = "lineNum" > 17 < / span > :
< span class = "lineNum" > 18 < / span > : #include " portable.h"
< span class = "lineNum" > 19 < / span > :
< span class = "lineNum" > 20 < / span > : #include " snapraid.h"
< span class = "lineNum" > 21 < / span > : #include " support.h"
< span class = "lineNum" > 22 < / span > : #include " elem.h"
< span class = "lineNum" > 23 < / span > : #include " import.h"
< span class = "lineNum" > 24 < / span > : #include " search.h"
< span class = "lineNum" > 25 < / span > : #include " state.h"
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 26 < / span > : #include " io.h"
< span class = "lineNum" > 27 < / span > : #include " raid/raid.h"
< span class = "lineNum" > 28 < / span > :
< span class = "lineNum" > 29 < / span > : /****************************************************************************/
< a name = "30" > < span class = "lineNum" > 30 < / span > : /* main */< / a >
< span class = "lineNum" > 31 < / span > :
< span class = "lineNum" > 32 < / span > < span class = "lineCov" > 2 : void version(void)< / span >
< span class = "lineNum" > 33 < / span > : {
< span class = "lineNum" > 34 < / span > < span class = "lineCov" > 2 : msg_status(PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL " \n" );< / span >
< a name = "35" > < span class = "lineNum" > 35 < / span > < span class = "lineCov" > 2 : }< / span > < / a >
< span class = "lineNum" > 36 < / span > :
< span class = "lineNum" > 37 < / span > < span class = "lineCov" > 1 : void usage(void)< / span >
< span class = "lineNum" > 38 < / span > : {
< span class = "lineNum" > 39 < / span > < span class = "lineCov" > 1 : version();< / span >
< span class = "lineNum" > 40 < / span > :
< span class = "lineNum" > 41 < / span > < span class = "lineCov" > 1 : printf(" Usage: " PACKAGE " status|diff|sync|scrub|list|dup|up|down|smart|pool|check|fix [options]\n" );< / span >
< span class = "lineNum" > 42 < / span > < span class = "lineCov" > 1 : printf(" \n" );< / span >
< span class = "lineNum" > 43 < / span > < span class = "lineCov" > 1 : printf(" Commands:\n" );< / span >
< span class = "lineNum" > 44 < / span > < span class = "lineCov" > 1 : printf(" status Print the status of the array\n" );< / span >
< span class = "lineNum" > 45 < / span > < span class = "lineCov" > 1 : printf(" diff Show the changes that needs to be synchronized\n" );< / span >
< span class = "lineNum" > 46 < / span > < span class = "lineCov" > 1 : printf(" sync Synchronize the state of the array\n" );< / span >
< span class = "lineNum" > 47 < / span > < span class = "lineCov" > 1 : printf(" scrub Scrub the array\n" );< / span >
< span class = "lineNum" > 48 < / span > < span class = "lineCov" > 1 : printf(" list List the array content\n" );< / span >
< span class = "lineNum" > 49 < / span > < span class = "lineCov" > 1 : printf(" dup Find duplicate files\n" );< / span >
< span class = "lineNum" > 50 < / span > < span class = "lineCov" > 1 : printf(" up Spin-up the array\n" );< / span >
< span class = "lineNum" > 51 < / span > < span class = "lineCov" > 1 : printf(" down Spin-down the array\n" );< / span >
< span class = "lineNum" > 52 < / span > < span class = "lineCov" > 1 : printf(" smart SMART attributes of the array\n" );< / span >
< span class = "lineNum" > 53 < / span > < span class = "lineCov" > 1 : printf(" pool Create or update the virtual view of the array\n" );< / span >
< span class = "lineNum" > 54 < / span > < span class = "lineCov" > 1 : printf(" check Check the array\n" );< / span >
< span class = "lineNum" > 55 < / span > < span class = "lineCov" > 1 : printf(" fix Fix the array\n" );< / span >
< span class = "lineNum" > 56 < / span > < span class = "lineCov" > 1 : printf(" \n" );< / span >
< span class = "lineNum" > 57 < / span > < span class = "lineCov" > 1 : printf(" Options:\n" );< / span >
< span class = "lineNum" > 58 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -c, --conf FILE " , " -c" ) " Configuration file\n" );< / span >
< span class = "lineNum" > 59 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -f, --filter PATTERN " , " -f" ) " Process only files matching the pattern\n" );< / span >
< span class = "lineNum" > 60 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -d, --filter-disk NAME" , " -f" ) " Process only files in the specified disk\n" );< / span >
< span class = "lineNum" > 61 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -m, --filter-missing " , " -m" ) " Process only missing/deleted files\n" );< / span >
< span class = "lineNum" > 62 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -e, --filter-error " , " -e" ) " Process only files with errors\n" );< / span >
< span class = "lineNum" > 63 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -p, --plan PLAN " , " -p" ) " Define a scrub plan or percentage\n" );< / span >
< span class = "lineNum" > 64 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -o, --older-than DAYS " , " -o" ) " Process only the older part of the array\n" );< / span >
< span class = "lineNum" > 65 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -i, --import DIR " , " -i" ) " Import deleted files\n" );< / span >
< span class = "lineNum" > 66 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -l, --log FILE " , " -l" ) " Log file. Default none\n" );< / span >
< span class = "lineNum" > 67 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -a, --audit-only " , " -a" ) " Check only file data and not parity\n" );< / span >
< span class = "lineNum" > 68 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -h, --pre-hash " , " -h" ) " Pre-hash all the new data\n" );< / span >
< span class = "lineNum" > 69 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -Z, --force-zero " , " -Z" ) " Force syncing of files that get zero size\n" );< / span >
< span class = "lineNum" > 70 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -E, --force-empty " , " -E" ) " Force syncing of disks that get empty\n" );< / span >
< span class = "lineNum" > 71 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -U, --force-uuid " , " -U" ) " Force commands on disks with uuid changed\n" );< / span >
< span class = "lineNum" > 72 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -D, --force-device " , " -D" ) " Force commands with inaccessible/shared disks\n" );< / span >
< span class = "lineNum" > 73 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -N, --force-nocopy " , " -N" ) " Force commands disabling the copy detection\n" );< / span >
< span class = "lineNum" > 74 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -F, --force-full " , " -F" ) " Force a full parity computation in sync\n" );< / span >
< span class = "lineNum" > 75 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -R, --force-realloc " , " -R" ) " Force a full parity reallocation in sync\n" );< / span >
< span class = "lineNum" > 76 < / span > < span class = "lineCov" > 1 : printf(" " SWITCH_GETOPT_LONG(" -v, --verbose " , " -v" ) " Verbose\n" );< / span >
< a name = "77" > < span class = "lineNum" > 77 < / span > < span class = "lineCov" > 1 : }< / span > < / a >
< span class = "lineNum" > 78 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 79 < / span > < span class = "lineCov" > 238 : void memory(void)< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 80 < / span > : {
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 81 < / span > < span class = "lineCov" > 238 : log_tag(" memory:used:%" PRIu64 " \n" , (uint64_t)malloc_counter_get());< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 82 < / span > :
< span class = "lineNum" > 83 < / span > : /* size of the block */
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 84 < / span > < span class = "lineCov" > 238 : log_tag(" memory:block:%" PRIu64 " \n" , (uint64_t)(sizeof(struct snapraid_block)));< / span >
< span class = "lineNum" > 85 < / span > < span class = "lineCov" > 238 : log_tag(" memory:extent:%" PRIu64 " \n" , (uint64_t)(sizeof(struct snapraid_extent)));< / span >
< span class = "lineNum" > 86 < / span > < span class = "lineCov" > 238 : log_tag(" memory:file:%" PRIu64 " \n" , (uint64_t)(sizeof(struct snapraid_file)));< / span >
< span class = "lineNum" > 87 < / span > < span class = "lineCov" > 238 : log_tag(" memory:link:%" PRIu64 " \n" , (uint64_t)(sizeof(struct snapraid_link)));< / span >
< span class = "lineNum" > 88 < / span > < span class = "lineCov" > 238 : log_tag(" memory:dir:%" PRIu64 " \n" , (uint64_t)(sizeof(struct snapraid_dir)));< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 89 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 90 < / span > < span class = "lineCov" > 238 : msg_progress(" Using %u MiB of memory for the FileSystem.\n" , (unsigned)(malloc_counter_get() / MEBI));< / span >
< a name = "91" > < span class = "lineNum" > 91 < / span > < span class = "lineCov" > 238 : }< / span > < / a >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 92 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 93 < / span > < span class = "lineCov" > 277 : void test(int argc, char* argv[])< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 94 < / span > : {
< span class = "lineNum" > 95 < / span > : int i;
< span class = "lineNum" > 96 < / span > : char buffer[ESC_MAX];
< span class = "lineNum" > 97 < / span > :
< span class = "lineNum" > 98 < / span > : /* special testing code for quoting */
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 99 < / span > < span class = "lineCov" > 277 : if (argc < 2 || strcmp(argv[1], " test" ) != 0)< / span >
< span class = "lineNum" > 100 < / span > < span class = "lineCov" > 552 : return;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 101 < / span > :
< span class = "lineNum" > 102 < / span > < span class = "lineCov" > 1 : for (i = 2; i < argc; ++i) {< / span >
< span class = "lineNum" > 103 < / span > < span class = "lineNoCov" > 0 : printf(" argv[%d]\n" , i);< / span >
< span class = "lineNum" > 104 < / span > < span class = "lineNoCov" > 0 : printf(" \t#%s#\n" , argv[i]);< / span >
< span class = "lineNum" > 105 < / span > < span class = "lineNoCov" > 0 : printf(" \t#%s#\n" , esc_shell(argv[i], buffer));< / span >
< span class = "lineNum" > 106 < / span > : }
< span class = "lineNum" > 107 < / span > :
< span class = "lineNum" > 108 < / span > : #ifdef _WIN32
< span class = "lineNum" > 109 < / span > : assert(strcmp(esc_shell(" " , buffer), " \" \" " ) == 0);
< span class = "lineNum" > 110 < / span > : assert(strcmp(esc_shell(" \" " , buffer), " \" \" \\\" \" \" " ) == 0);
< span class = "lineNum" > 111 < / span > : assert(strcmp(esc_shell(" & |()< > ^" , buffer), " ^& ^|^(^)^< ^> ^^" ) == 0);
< span class = "lineNum" > 112 < / span > : assert(strcmp(esc_shell(" & |()< > ^ " , buffer), " \" & |()< > ^ \" " ) == 0);
< span class = "lineNum" > 113 < / span > : #else
< span class = "lineNum" > 114 < / span > < span class = "lineCov" > 1 : assert(strcmp(esc_shell(" ,._+:@%%/-" , buffer), " ,._+:@%%/-" ) == 0);< / span >
< span class = "lineNum" > 115 < / span > < span class = "lineCov" > 1 : assert(strcmp(esc_shell(" " , buffer), " \\ " ) == 0);< / span >
< span class = "lineNum" > 116 < / span > : #endif
< span class = "lineNum" > 117 < / span > :
< span class = "lineNum" > 118 < / span > < span class = "lineCov" > 1 : printf(" Everything OK\n" );< / span >
< span class = "lineNum" > 119 < / span > :
< span class = "lineNum" > 120 < / span > < span class = "lineCov" > 1 : exit(EXIT_SUCCESS);< / span >
< span class = "lineNum" > 121 < / span > : }
< span class = "lineNum" > 122 < / span > :
< span class = "lineNum" > 123 < / span > : /****************************************************************************/
< a name = "124" > < span class = "lineNum" > 124 < / span > : /* log */< / a >
< span class = "lineNum" > 125 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 126 < / span > < span class = "lineCov" > 266 : void log_open(const char* file)< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 127 < / span > : {
< span class = "lineNum" > 128 < / span > : char path[PATH_MAX];
< span class = "lineNum" > 129 < / span > : const char* mode;
< span class = "lineNum" > 130 < / span > : char text_T[32];
< span class = "lineNum" > 131 < / span > : char text_D[32];
< span class = "lineNum" > 132 < / span > : time_t t;
< span class = "lineNum" > 133 < / span > : struct tm* tm;
< span class = "lineNum" > 134 < / span > :
< span class = "lineNum" > 135 < / span > : /* leave stdlog at 0 if not specified */
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 136 < / span > < span class = "lineCov" > 266 : if (file == 0)< / span >
< span class = "lineNum" > 137 < / span > < span class = "lineCov" > 378 : return;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 138 < / span > :
< span class = "lineNum" > 139 < / span > < span class = "lineCov" > 80 : t = time(0);< / span >
< span class = "lineNum" > 140 < / span > < span class = "lineCov" > 80 : tm = localtime(& t);< / span >
< span class = "lineNum" > 141 < / span > < span class = "lineCov" > 80 : if (tm) {< / span >
< span class = "lineNum" > 142 < / span > < span class = "lineCov" > 80 : strftime(text_T, sizeof(text_T), " %H%M%S" , tm);< / span >
< span class = "lineNum" > 143 < / span > < span class = "lineCov" > 80 : strftime(text_D, sizeof(text_T), " %Y%m%d" , tm);< / span >
< span class = "lineNum" > 144 < / span > : } else {
< span class = "lineNum" > 145 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 146 < / span > : strcpy(text_T, " invalid" );
< span class = "lineNum" > 147 < / span > : strcpy(text_D, " invalid" );
< span class = "lineNum" > 148 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 149 < / span > : }
< span class = "lineNum" > 150 < / span > :
< span class = "lineNum" > 151 < / span > : /* file mode */
< span class = "lineNum" > 152 < / span > < span class = "lineCov" > 80 : mode = " wt" ;< / span >
< span class = "lineNum" > 153 < / span > < span class = "lineCov" > 80 : if (*file == '> ') {< / span >
< span class = "lineNum" > 154 < / span > < span class = "lineCov" > 7 : ++file;< / span >
< span class = "lineNum" > 155 < / span > :
< span class = "lineNum" > 156 < / span > < span class = "lineCov" > 7 : if (*file == '> ') {< / span >
< span class = "lineNum" > 157 < / span > < span class = "lineCov" > 1 : mode = " at" ;< / span >
< span class = "lineNum" > 158 < / span > < span class = "lineCov" > 1 : ++file;< / span >
< span class = "lineNum" > 159 < / span > : }
< span class = "lineNum" > 160 < / span > :
< span class = "lineNum" > 161 < / span > < span class = "lineCov" > 7 : if (file[0] == '& ' & & file[1] == '1') {< / span >
< span class = "lineNum" > 162 < / span > < span class = "lineCov" > 5 : stdlog = stdout;< / span >
< span class = "lineNum" > 163 < / span > < span class = "lineCov" > 5 : return;< / span >
< span class = "lineNum" > 164 < / span > : }
< span class = "lineNum" > 165 < / span > :
< span class = "lineNum" > 166 < / span > < span class = "lineCov" > 2 : if (file[0] == '& ' & & file[1] == '2') {< / span >
< span class = "lineNum" > 167 < / span > < span class = "lineCov" > 1 : stdlog = stderr;< / span >
< span class = "lineNum" > 168 < / span > < span class = "lineCov" > 1 : return;< / span >
< span class = "lineNum" > 169 < / span > : }
< span class = "lineNum" > 170 < / span > : }
< span class = "lineNum" > 171 < / span > :
< span class = "lineNum" > 172 < / span > : /* process the path */
< span class = "lineNum" > 173 < / span > < span class = "lineCov" > 938 : for (*path = 0; *file != 0; ) {< / span >
< span class = "lineNum" > 174 < / span > < span class = "lineCov" > 790 : switch (*file) {< / span >
< span class = "lineNum" > 175 < / span > : case '%' :
< span class = "lineNum" > 176 < / span > < span class = "lineCov" > 2 : ++file;< / span >
< span class = "lineNum" > 177 < / span > < span class = "lineCov" > 2 : switch (*file) {< / span >
< span class = "lineNum" > 178 < / span > : case '%' :
< span class = "lineNum" > 179 < / span > < span class = "lineNoCov" > 0 : pathcatc(path, sizeof(path), '%');< / span >
< span class = "lineNum" > 180 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 181 < / span > : case 'T' :
< span class = "lineNum" > 182 < / span > < span class = "lineCov" > 1 : pathcat(path, sizeof(path), text_T);< / span >
< span class = "lineNum" > 183 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 184 < / span > : case 'D' :
< span class = "lineNum" > 185 < / span > < span class = "lineCov" > 1 : pathcat(path, sizeof(path), text_D);< / span >
< span class = "lineNum" > 186 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 187 < / span > : default :
< span class = "lineNum" > 188 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 189 < / span > : log_fatal(" Invalid type specifier '%c' in the log file.\n" , *file);
< span class = "lineNum" > 190 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 191 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 192 < / span > : }
< span class = "lineNum" > 193 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 194 < / span > : default :
< span class = "lineNum" > 195 < / span > < span class = "lineCov" > 788 : pathcatc(path, sizeof(path), *file);< / span >
< span class = "lineNum" > 196 < / span > < span class = "lineCov" > 788 : break;< / span >
< span class = "lineNum" > 197 < / span > : }
< span class = "lineNum" > 198 < / span > < span class = "lineCov" > 790 : ++file;< / span >
< span class = "lineNum" > 199 < / span > : }
< span class = "lineNum" > 200 < / span > :
< span class = "lineNum" > 201 < / span > < span class = "lineCov" > 74 : stdlog = fopen(path, mode);< / span >
< span class = "lineNum" > 202 < / span > < span class = "lineCov" > 74 : if (!stdlog) {< / span >
< span class = "lineNum" > 203 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 204 < / span > : log_fatal(" Error opening the log file '%s'. %s.\n" , path, strerror(errno));
< span class = "lineNum" > 205 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 206 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 207 < / span > : }
< a name = "208" > < span class = "lineNum" > 208 < / span > : }< / a >
< span class = "lineNum" > 209 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 210 < / span > < span class = "lineCov" > 243 : void log_close(const char* file)< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 211 < / span > : {
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 212 < / span > < span class = "lineCov" > 243 : if (stdlog != stdout & & stdlog != stderr & & stdlog != 0) {< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 213 < / span > < span class = "lineCov" > 74 : if (fclose(stdlog) != 0) {< / span >
< span class = "lineNum" > 214 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 215 < / span > : log_fatal(" Error closing the log file '%s'. %s.\n" , file, strerror(errno));
< span class = "lineNum" > 216 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 217 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 218 < / span > : }
< span class = "lineNum" > 219 < / span > : }
< span class = "lineNum" > 220 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 221 < / span > < span class = "lineCov" > 243 : stdlog = 0;< / span >
< span class = "lineNum" > 222 < / span > < span class = "lineCov" > 243 : }< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 223 < / span > :
< span class = "lineNum" > 224 < / span > : /****************************************************************************/
< a name = "225" > < span class = "lineNum" > 225 < / span > : /* config */< / a >
< span class = "lineNum" > 226 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 227 < / span > < span class = "lineCov" > 276 : void config(char* conf, size_t conf_size, const char* argv0)< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 228 < / span > : {
< span class = "lineNum" > 229 < / span > : #ifdef _WIN32
< span class = "lineNum" > 230 < / span > : char* slash;
< span class = "lineNum" > 231 < / span > :
< span class = "lineNum" > 232 < / span > : pathimport(conf, conf_size, argv0);
< span class = "lineNum" > 233 < / span > :
< span class = "lineNum" > 234 < / span > : slash = strrchr(conf, '/');
< span class = "lineNum" > 235 < / span > : if (slash) {
< span class = "lineNum" > 236 < / span > : slash[1] = 0;
< span class = "lineNum" > 237 < / span > : pathcat(conf, conf_size, PACKAGE " .conf" );
< span class = "lineNum" > 238 < / span > : } else {
< span class = "lineNum" > 239 < / span > : pathcpy(conf, conf_size, PACKAGE " .conf" );
< span class = "lineNum" > 240 < / span > : }
< span class = "lineNum" > 241 < / span > : #else
< span class = "lineNum" > 242 < / span > : (void)argv0;
< span class = "lineNum" > 243 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 244 < / span > : #ifdef SYSCONFDIR
< span class = "lineNum" > 245 < / span > : /* if it exists, give precedence at sysconfdir, usually /usr/local/etc */
< span class = "lineNum" > 246 < / span > < span class = "lineCov" > 276 : if (access(SYSCONFDIR " /" PACKAGE " .conf" , F_OK) == 0)< / span >
< span class = "lineNum" > 247 < / span > < span class = "lineNoCov" > 0 : pathcpy(conf, conf_size, SYSCONFDIR " /" PACKAGE " .conf" );< / span >
< span class = "lineNum" > 248 < / span > : else /* otherwise fallback to plain /etc */
< span class = "lineNum" > 249 < / span > : #endif
< span class = "lineNum" > 250 < / span > < span class = "lineCov" > 276 : pathcpy(conf, conf_size, " /etc/" PACKAGE " .conf" );< / span >
< span class = "lineNum" > 251 < / span > : #endif
< span class = "lineNum" > 252 < / span > < span class = "lineCov" > 276 : }< / span >
< span class = "lineNum" > 253 < / span > :
< span class = "lineNum" > 254 < / span > : /****************************************************************************/
< span class = "lineNum" > 255 < / span > : /* main */
< span class = "lineNum" > 256 < / span > :
< span class = "lineNum" > 257 < / span > : #define OPT_TEST_SKIP_SELF 256
< span class = "lineNum" > 258 < / span > : #define OPT_TEST_KILL_AFTER_SYNC 257
< span class = "lineNum" > 259 < / span > : #define OPT_TEST_EXPECT_UNRECOVERABLE 258
< span class = "lineNum" > 260 < / span > : #define OPT_TEST_EXPECT_RECOVERABLE 259
< span class = "lineNum" > 261 < / span > : #define OPT_TEST_SKIP_SIGN 260
< span class = "lineNum" > 262 < / span > : #define OPT_TEST_SKIP_FALLOCATE 261
< span class = "lineNum" > 263 < / span > : #define OPT_TEST_SKIP_DEVICE 262
< span class = "lineNum" > 264 < / span > : #define OPT_TEST_FORCE_MURMUR3 264
< span class = "lineNum" > 265 < / span > : #define OPT_TEST_FORCE_SPOOKY2 265
< span class = "lineNum" > 266 < / span > : #define OPT_TEST_SKIP_LOCK 266
< span class = "lineNum" > 267 < / span > : #define OPT_TEST_FORCE_ORDER_PHYSICAL 267
< span class = "lineNum" > 268 < / span > : #define OPT_TEST_FORCE_ORDER_INODE 268
< span class = "lineNum" > 269 < / span > : #define OPT_TEST_FORCE_ORDER_ALPHA 269
< span class = "lineNum" > 270 < / span > : #define OPT_TEST_FORCE_ORDER_DIR 270
< span class = "lineNum" > 271 < / span > : #define OPT_TEST_FORCE_SCRUB_AT 271
< span class = "lineNum" > 272 < / span > : #define OPT_TEST_FORCE_SCRUB_EVEN 272
< span class = "lineNum" > 273 < / span > : #define OPT_TEST_FORCE_CONTENT_WRITE 273
< span class = "lineNum" > 274 < / span > : #define OPT_TEST_SKIP_CONTENT_CHECK 275
< span class = "lineNum" > 275 < / span > : #define OPT_TEST_SKIP_PARITY_ACCESS 276
< span class = "lineNum" > 276 < / span > : #define OPT_TEST_EXPECT_FAILURE 277
< span class = "lineNum" > 277 < / span > : #define OPT_TEST_RUN 278
< span class = "lineNum" > 278 < / span > : #define OPT_TEST_FORCE_SCAN_WINFIND 279
< span class = "lineNum" > 279 < / span > : #define OPT_TEST_IMPORT_CONTENT 280
< span class = "lineNum" > 280 < / span > : #define OPT_TEST_FORCE_PROGRESS 281
< span class = "lineNum" > 281 < / span > : #define OPT_TEST_SKIP_DISK_ACCESS 282
< span class = "lineNum" > 282 < / span > : #define OPT_TEST_FORCE_AUTOSAVE_AT 283
< span class = "lineNum" > 283 < / span > : #define OPT_TEST_FAKE_DEVICE 284
< span class = "lineNum" > 284 < / span > : #define OPT_TEST_EXPECT_NEED_SYNC 285
< span class = "lineNum" > 285 < / span > : #define OPT_NO_WARNINGS 286
< span class = "lineNum" > 286 < / span > : #define OPT_TEST_FAKE_UUID 287
< span class = "lineNum" > 287 < / span > : #define OPT_TEST_MATCH_FIRST_UUID 288
< span class = "lineNum" > 288 < / span > : #define OPT_TEST_FORCE_PARITY_UPDATE 289
< span class = "lineNum" > 289 < / span > : #define OPT_TEST_IO_CACHE 290
< span class = "lineNum" > 290 < / span > : #define OPT_TEST_IO_STATS 291
< span class = "lineNum" > 291 < / span > : #define OPT_TEST_COND_SIGNAL_OUTSIDE 292
< span class = "lineNum" > 292 < / span > : #define OPT_TEST_IO_ADVISE_NONE 293
< span class = "lineNum" > 293 < / span > : #define OPT_TEST_IO_ADVISE_SEQUENTIAL 294
< span class = "lineNum" > 294 < / span > : #define OPT_TEST_IO_ADVISE_FLUSH 295
< span class = "lineNum" > 295 < / span > : #define OPT_TEST_IO_ADVISE_FLUSH_WINDOW 296
< span class = "lineNum" > 296 < / span > : #define OPT_TEST_IO_ADVISE_DISCARD 297
< span class = "lineNum" > 297 < / span > : #define OPT_TEST_IO_ADVISE_DISCARD_WINDOW 298
< span class = "lineNum" > 298 < / span > : #define OPT_TEST_IO_ADVISE_DIRECT 299
< span class = "lineNum" > 299 < / span > : #define OPT_TEST_PARITY_LIMIT 301
< span class = "lineNum" > 300 < / span > : #define OPT_TEST_SKIP_CONTENT_WRITE 302
< span class = "lineNum" > 301 < / span > : #define OPT_TEST_SKIP_SPACE_HOLDER 303
< span class = "lineNum" > 302 < / span > : #define OPT_TEST_FORMAT 304
< span class = "lineNum" > 303 < / span > :
< span class = "lineNum" > 304 < / span > : #if HAVE_GETOPT_LONG
< span class = "lineNum" > 305 < / span > : struct option long_options[] = {
< span class = "lineNum" > 306 < / span > : { " conf" , 1, 0, 'c' },
< span class = "lineNum" > 307 < / span > : { " filter" , 1, 0, 'f' },
< span class = "lineNum" > 308 < / span > : { " filter-disk" , 1, 0, 'd' },
< span class = "lineNum" > 309 < / span > : { " filter-missing" , 0, 0, 'm' },
< span class = "lineNum" > 310 < / span > : { " filter-error" , 0, 0, 'e' },
< span class = "lineNum" > 311 < / span > : { " percentage" , 1, 0, 'p' }, /* legacy name for --plan */
< span class = "lineNum" > 312 < / span > : { " plan" , 1, 0, 'p' },
< span class = "lineNum" > 313 < / span > : { " older-than" , 1, 0, 'o' },
< span class = "lineNum" > 314 < / span > : { " start" , 1, 0, 'S' },
< span class = "lineNum" > 315 < / span > : { " count" , 1, 0, 'B' },
< span class = "lineNum" > 316 < / span > : { " error-limit" , 1, 0, 'L' },
< span class = "lineNum" > 317 < / span > : { " import" , 1, 0, 'i' },
< span class = "lineNum" > 318 < / span > : { " log" , 1, 0, 'l' },
< span class = "lineNum" > 319 < / span > : { " force-zero" , 0, 0, 'Z' },
< span class = "lineNum" > 320 < / span > : { " force-empty" , 0, 0, 'E' },
< span class = "lineNum" > 321 < / span > : { " force-uuid" , 0, 0, 'U' },
< span class = "lineNum" > 322 < / span > : { " force-device" , 0, 0, 'D' },
< span class = "lineNum" > 323 < / span > : { " force-nocopy" , 0, 0, 'N' },
< span class = "lineNum" > 324 < / span > : { " force-full" , 0, 0, 'F' },
< span class = "lineNum" > 325 < / span > : { " force-realloc" , 0, 0, 'R' },
< span class = "lineNum" > 326 < / span > : { " audit-only" , 0, 0, 'a' },
< span class = "lineNum" > 327 < / span > : { " pre-hash" , 0, 0, 'h' },
< span class = "lineNum" > 328 < / span > : { " speed-test" , 0, 0, 'T' }, /* undocumented speed test command */
< span class = "lineNum" > 329 < / span > : { " gen-conf" , 1, 0, 'C' },
< span class = "lineNum" > 330 < / span > : { " verbose" , 0, 0, 'v' },
< span class = "lineNum" > 331 < / span > : { " quiet" , 0, 0, 'q' }, /* undocumented quiet option */
< span class = "lineNum" > 332 < / span > : { " gui" , 0, 0, 'G' }, /* undocumented GUI interface option */
< span class = "lineNum" > 333 < / span > : { " help" , 0, 0, 'H' },
< span class = "lineNum" > 334 < / span > : { " version" , 0, 0, 'V' },
< span class = "lineNum" > 335 < / span > :
< span class = "lineNum" > 336 < / span > : /* The following are test specific options, DO NOT USE! */
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 337 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 338 < / span > : /* After syncing, do not write the new content file */
< span class = "lineNum" > 339 < / span > : { " test-kill-after-sync" , 0, 0, OPT_TEST_KILL_AFTER_SYNC },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 340 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 341 < / span > : /* Exit with failure if after check/fix there ARE NOT unrecoverable errors. */
< span class = "lineNum" > 342 < / span > : { " test-expect-unrecoverable" , 0, 0, OPT_TEST_EXPECT_UNRECOVERABLE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 343 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 344 < / span > : /* Exit with failure if after check/fix there ARE NOT recoverable errors. */
< span class = "lineNum" > 345 < / span > : { " test-expect-recoverable" , 0, 0, OPT_TEST_EXPECT_RECOVERABLE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 346 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 347 < / span > : /* Skip the initial self test */
< span class = "lineNum" > 348 < / span > : { " test-skip-self" , 0, 0, OPT_TEST_SKIP_SELF },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 349 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 350 < / span > : /* Skip the initial sign check when reading the content file */
< span class = "lineNum" > 351 < / span > : { " test-skip-sign" , 0, 0, OPT_TEST_SKIP_SIGN },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 352 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 353 < / span > : /* Skip the fallocate() when growing the parity files */
< span class = "lineNum" > 354 < / span > : { " test-skip-fallocate" , 0, 0, OPT_TEST_SKIP_FALLOCATE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 355 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 356 < / span > : /* Skip the device check */
< span class = "lineNum" > 357 < / span > : { " test-skip-device" , 0, 0, OPT_TEST_SKIP_DEVICE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 358 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 359 < / span > : /* Force Murmur3 hash */
< span class = "lineNum" > 360 < / span > : { " test-force-murmur3" , 0, 0, OPT_TEST_FORCE_MURMUR3 },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 361 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 362 < / span > : /* Force Spooky2 hash */
< span class = "lineNum" > 363 < / span > : { " test-force-spooky2" , 0, 0, OPT_TEST_FORCE_SPOOKY2 },
< span class = "lineNum" > 364 < / span > :
< span class = "lineNum" > 365 < / span > : /* Skip the use of lock file */
< span class = "lineNum" > 366 < / span > : { " test-skip-lock" , 0, 0, OPT_TEST_SKIP_LOCK },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 367 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 368 < / span > : /* Force a sort order for files */
< span class = "lineNum" > 369 < / span > : { " test-force-order-physical" , 0, 0, OPT_TEST_FORCE_ORDER_PHYSICAL },
< span class = "lineNum" > 370 < / span > : { " test-force-order-inode" , 0, 0, OPT_TEST_FORCE_ORDER_INODE },
< span class = "lineNum" > 371 < / span > : { " test-force-order-alpha" , 0, 0, OPT_TEST_FORCE_ORDER_ALPHA },
< span class = "lineNum" > 372 < / span > : { " test-force-order-dir" , 0, 0, OPT_TEST_FORCE_ORDER_DIR },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 373 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 374 < / span > : /* Force scrub of the specified number of blocks */
< span class = "lineNum" > 375 < / span > : { " test-force-scrub-at" , 1, 0, OPT_TEST_FORCE_SCRUB_AT },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 376 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 377 < / span > : /* Force scrub of all the even blocks. This is really for testing, don't try it */
< span class = "lineNum" > 378 < / span > : { " test-force-scrub-even" , 0, 0, OPT_TEST_FORCE_SCRUB_EVEN },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 379 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 380 < / span > : /* Force write of the content file even if no modification is done */
< span class = "lineNum" > 381 < / span > : { " test-force-content-write" , 0, 0, OPT_TEST_FORCE_CONTENT_WRITE },
2016-01-09 17:18:05 +01:00
< span class = "lineNum" > 382 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 383 < / span > : /* Relax the checks done at the content file */
< span class = "lineNum" > 384 < / span > : { " test-skip-content-check" , 0, 0, OPT_TEST_SKIP_CONTENT_CHECK },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 385 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 386 < / span > : /* Skip the parity access */
< span class = "lineNum" > 387 < / span > : { " test-skip-parity-access" , 0, 0, OPT_TEST_SKIP_PARITY_ACCESS },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 388 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 389 < / span > : /* Exit generic failure */
< span class = "lineNum" > 390 < / span > : { " test-expect-failure" , 0, 0, OPT_TEST_EXPECT_FAILURE },
2015-11-13 22:48:15 +01:00
< span class = "lineNum" > 391 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 392 < / span > : /* Exit generic need sync */
< span class = "lineNum" > 393 < / span > : { " test-expect-need-sync" , 0, 0, OPT_TEST_EXPECT_NEED_SYNC },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 394 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 395 < / span > : /* Run some command after loading the state and before the command */
< span class = "lineNum" > 396 < / span > : { " test-run" , 1, 0, OPT_TEST_RUN },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 397 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 398 < / span > : /* Use the FindFirst/Next approach in Windows to list files */
< span class = "lineNum" > 399 < / span > : { " test-force-scan-winfind" , 0, 0, OPT_TEST_FORCE_SCAN_WINFIND },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 400 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 401 < / span > : /* Alternative import working by data */
< span class = "lineNum" > 402 < / span > : { " test-import-content" , 1, 0, OPT_TEST_IMPORT_CONTENT },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 403 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 404 < / span > : /* Force immediate progress state update */
< span class = "lineNum" > 405 < / span > : { " test-force-progress" , 0, 0, OPT_TEST_FORCE_PROGRESS },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 406 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 407 < / span > : /* Skip the disk access */
< span class = "lineNum" > 408 < / span > : { " test-skip-disk-access" , 0, 0, OPT_TEST_SKIP_DISK_ACCESS },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 409 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 410 < / span > : /* Force autosave at the specified block */
< span class = "lineNum" > 411 < / span > : { " test-force-autosave-at" , 1, 0, OPT_TEST_FORCE_AUTOSAVE_AT },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 412 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 413 < / span > : /* Fake device data */
< span class = "lineNum" > 414 < / span > : { " test-fake-device" , 0, 0, OPT_TEST_FAKE_DEVICE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 415 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 416 < / span > : /* Disable annoying warnings */
< span class = "lineNum" > 417 < / span > : { " no-warnings" , 0, 0, OPT_NO_WARNINGS },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 418 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 419 < / span > : /* Fake UUID */
< span class = "lineNum" > 420 < / span > : { " test-fake-uuid" , 0, 0, OPT_TEST_FAKE_UUID },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 421 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 422 < / span > : /* Match first UUID */
< span class = "lineNum" > 423 < / span > : { " test-match-first-uuid" , 0, 0, OPT_TEST_MATCH_FIRST_UUID },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 424 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 425 < / span > : /* Force parity update even if all the data hash is already matching */
< span class = "lineNum" > 426 < / span > : { " test-force-parity-update" , 0, 0, OPT_TEST_FORCE_PARITY_UPDATE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 427 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 428 < / span > : /* Number of IO buffers */
< span class = "lineNum" > 429 < / span > : { " test-io-cache" , 1, 0, OPT_TEST_IO_CACHE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 430 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 431 < / span > : /* Print IO stats */
< span class = "lineNum" > 432 < / span > : { " test-io-stats" , 0, 0, OPT_TEST_IO_STATS },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 433 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 434 < / span > : /* Signal condition variable outside the mutex */
< span class = "lineNum" > 435 < / span > : { " test-cond-signal-outside" , 0, 0, OPT_TEST_COND_SIGNAL_OUTSIDE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 436 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 437 < / span > : /* Set the io advise to none */
< span class = "lineNum" > 438 < / span > : { " test-io-advise-none" , 0, 0, OPT_TEST_IO_ADVISE_NONE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 439 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 440 < / span > : /* Set the io advise to sequential */
< span class = "lineNum" > 441 < / span > : { " test-io-advise-sequential" , 0, 0, OPT_TEST_IO_ADVISE_SEQUENTIAL },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 442 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 443 < / span > : /* Set the io advise to flush */
< span class = "lineNum" > 444 < / span > : { " test-io-advise-flush" , 0, 0, OPT_TEST_IO_ADVISE_FLUSH },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 445 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 446 < / span > : /* Set the io advise to flush window */
< span class = "lineNum" > 447 < / span > : { " test-io-advise-flush-window" , 0, 0, OPT_TEST_IO_ADVISE_FLUSH_WINDOW },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 448 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 449 < / span > : /* Set the io advise to discard */
< span class = "lineNum" > 450 < / span > : { " test-io-advise-discard" , 0, 0, OPT_TEST_IO_ADVISE_DISCARD },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 451 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 452 < / span > : /* Set the io advise to discard window */
< span class = "lineNum" > 453 < / span > : { " test-io-advise-discard-window" , 0, 0, OPT_TEST_IO_ADVISE_DISCARD_WINDOW },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 454 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 455 < / span > : /* Set the io advise to direct */
< span class = "lineNum" > 456 < / span > : { " test-io-advise-direct" , 0, 0, OPT_TEST_IO_ADVISE_DIRECT },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 457 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 458 < / span > : /* Set an artificial parity limit */
< span class = "lineNum" > 459 < / span > : { " test-parity-limit" , 1, 0, OPT_TEST_PARITY_LIMIT },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 460 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 461 < / span > : /* Skip content write */
< span class = "lineNum" > 462 < / span > : { " test-skip-content-write" , 0, 0, OPT_TEST_SKIP_CONTENT_WRITE },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 463 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 464 < / span > : /* Skip space holder file in parity disks */
< span class = "lineNum" > 465 < / span > : { " test-skip-space-holder" , 0, 0, OPT_TEST_SKIP_SPACE_HOLDER },
< span class = "lineNum" > 466 < / span > :
< span class = "lineNum" > 467 < / span > : /* Set the ourput format */
< span class = "lineNum" > 468 < / span > : { " test-fmt" , 1, 0, OPT_TEST_FORMAT },
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 469 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 470 < / span > : { 0, 0, 0, 0 }
< span class = "lineNum" > 471 < / span > : };
< span class = "lineNum" > 472 < / span > : #endif
< span class = "lineNum" > 473 < / span > :
< span class = "lineNum" > 474 < / span > : #define OPTIONS " c:f:d:mep:o:S:B:L:i:l:ZEUDNFRahTC:vqHVG"
< span class = "lineNum" > 475 < / span > :
< span class = "lineNum" > 476 < / span > : volatile int global_interrupt = 0;
< span class = "lineNum" > 477 < / span > :
< span class = "lineNum" > 478 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 479 < / span > : void signal_handler(int signum)
< span class = "lineNum" > 480 < / span > : {
< span class = "lineNum" > 481 < / span > : (void)signum;
< span class = "lineNum" > 482 < / span > :
< span class = "lineNum" > 483 < / span > : /* report the request of interruption */
< span class = "lineNum" > 484 < / span > : global_interrupt = 1;
< span class = "lineNum" > 485 < / span > : }
< a name = "486" > < span class = "lineNum" > 486 < / span > : /* LCOV_EXCL_STOP */< / a >
< span class = "lineNum" > 487 < / span > :
< span class = "lineNum" > 488 < / span > < span class = "lineCov" > 223 : void signal_init(void)< / span >
< span class = "lineNum" > 489 < / span > : {
< span class = "lineNum" > 490 < / span > : #if HAVE_SIGACTION
< span class = "lineNum" > 491 < / span > : struct sigaction sa;
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 492 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 493 < / span > < span class = "lineCov" > 223 : sa.sa_handler = signal_handler;< / span >
< span class = "lineNum" > 494 < / span > < span class = "lineCov" > 223 : sigemptyset(& sa.sa_mask);< / span >
< span class = "lineNum" > 495 < / span > :
< span class = "lineNum" > 496 < / span > : /* use the SA_RESTART to automatically restart interrupted system calls */
< span class = "lineNum" > 497 < / span > < span class = "lineCov" > 223 : sa.sa_flags = SA_RESTART;< / span >
< span class = "lineNum" > 498 < / span > :
< span class = "lineNum" > 499 < / span > < span class = "lineCov" > 223 : sigaction(SIGHUP, & sa, 0);< / span >
< span class = "lineNum" > 500 < / span > < span class = "lineCov" > 223 : sigaction(SIGTERM, & sa, 0);< / span >
< span class = "lineNum" > 501 < / span > < span class = "lineCov" > 223 : sigaction(SIGINT, & sa, 0);< / span >
< span class = "lineNum" > 502 < / span > < span class = "lineCov" > 223 : sigaction(SIGQUIT, & sa, 0);< / span >
< span class = "lineNum" > 503 < / span > : #else
< span class = "lineNum" > 504 < / span > : signal(SIGINT, signal_handler);
< span class = "lineNum" > 505 < / span > : #endif
< span class = "lineNum" > 506 < / span > < span class = "lineCov" > 223 : }< / span >
< span class = "lineNum" > 507 < / span > :
< span class = "lineNum" > 508 < / span > : #define OPERATION_DIFF 0
< span class = "lineNum" > 509 < / span > : #define OPERATION_SYNC 1
< span class = "lineNum" > 510 < / span > : #define OPERATION_CHECK 2
< span class = "lineNum" > 511 < / span > : #define OPERATION_FIX 3
< span class = "lineNum" > 512 < / span > : #define OPERATION_DRY 4
< span class = "lineNum" > 513 < / span > : #define OPERATION_DUP 5
< span class = "lineNum" > 514 < / span > : #define OPERATION_LIST 6
< span class = "lineNum" > 515 < / span > : #define OPERATION_POOL 7
< span class = "lineNum" > 516 < / span > : #define OPERATION_REHASH 8
< span class = "lineNum" > 517 < / span > : #define OPERATION_SCRUB 9
< span class = "lineNum" > 518 < / span > : #define OPERATION_STATUS 10
< span class = "lineNum" > 519 < / span > : #define OPERATION_REWRITE 11
< span class = "lineNum" > 520 < / span > : #define OPERATION_READ 12
< span class = "lineNum" > 521 < / span > : #define OPERATION_TOUCH 13
< span class = "lineNum" > 522 < / span > : #define OPERATION_SPINUP 14
< span class = "lineNum" > 523 < / span > : #define OPERATION_SPINDOWN 15
< span class = "lineNum" > 524 < / span > : #define OPERATION_DEVICES 16
< a name = "525" > < span class = "lineNum" > 525 < / span > : #define OPERATION_SMART 17< / a >
< span class = "lineNum" > 526 < / span > :
< span class = "lineNum" > 527 < / span > < span class = "lineCov" > 277 : int main(int argc, char* argv[])< / span >
< span class = "lineNum" > 528 < / span > : {
< span class = "lineNum" > 529 < / span > : int c;
< span class = "lineNum" > 530 < / span > : struct snapraid_option opt;
< span class = "lineNum" > 531 < / span > : char conf[PATH_MAX];
< span class = "lineNum" > 532 < / span > : struct snapraid_state state;
< span class = "lineNum" > 533 < / span > : int operation;
< span class = "lineNum" > 534 < / span > : block_off_t blockstart;
< span class = "lineNum" > 535 < / span > : block_off_t blockcount;
< span class = "lineNum" > 536 < / span > : int ret;
< span class = "lineNum" > 537 < / span > : tommy_list filterlist_file;
< span class = "lineNum" > 538 < / span > : tommy_list filterlist_disk;
< span class = "lineNum" > 539 < / span > : int filter_missing;
< span class = "lineNum" > 540 < / span > : int filter_error;
< span class = "lineNum" > 541 < / span > : int plan;
< span class = "lineNum" > 542 < / span > : int olderthan;
< span class = "lineNum" > 543 < / span > : char* e;
< span class = "lineNum" > 544 < / span > : const char* command;
< span class = "lineNum" > 545 < / span > : const char* import_timestamp;
< span class = "lineNum" > 546 < / span > : const char* import_content;
< span class = "lineNum" > 547 < / span > : const char* log_file;
< span class = "lineNum" > 548 < / span > : int lock;
< span class = "lineNum" > 549 < / span > : const char* gen_conf;
< span class = "lineNum" > 550 < / span > : const char* run;
< span class = "lineNum" > 551 < / span > : int speedtest;
< span class = "lineNum" > 552 < / span > : int period;
< span class = "lineNum" > 553 < / span > : time_t t;
< span class = "lineNum" > 554 < / span > : struct tm* tm;
< span class = "lineNum" > 555 < / span > : int i;
< span class = "lineNum" > 556 < / span > :
< span class = "lineNum" > 557 < / span > < span class = "lineCov" > 277 : test(argc, argv);< / span >
< span class = "lineNum" > 558 < / span > :
< span class = "lineNum" > 559 < / span > < span class = "lineCov" > 276 : lock_init();< / span >
< span class = "lineNum" > 560 < / span > :
< span class = "lineNum" > 561 < / span > : /* defaults */
< span class = "lineNum" > 562 < / span > < span class = "lineCov" > 276 : config(conf, sizeof(conf), argv[0]);< / span >
< span class = "lineNum" > 563 < / span > < span class = "lineCov" > 276 : memset(& opt, 0, sizeof(opt));< / span >
< span class = "lineNum" > 564 < / span > < span class = "lineCov" > 276 : opt.io_error_limit = 100;< / span >
< span class = "lineNum" > 565 < / span > < span class = "lineCov" > 276 : blockstart = 0;< / span >
< span class = "lineNum" > 566 < / span > < span class = "lineCov" > 276 : blockcount = 0;< / span >
< span class = "lineNum" > 567 < / span > < span class = "lineCov" > 276 : tommy_list_init(& filterlist_file);< / span >
< span class = "lineNum" > 568 < / span > < span class = "lineCov" > 276 : tommy_list_init(& filterlist_disk);< / span >
< span class = "lineNum" > 569 < / span > < span class = "lineCov" > 276 : period = 1000;< / span >
< span class = "lineNum" > 570 < / span > < span class = "lineCov" > 276 : filter_missing = 0;< / span >
< span class = "lineNum" > 571 < / span > < span class = "lineCov" > 276 : filter_error = 0;< / span >
< span class = "lineNum" > 572 < / span > < span class = "lineCov" > 276 : plan = SCRUB_AUTO;< / span >
< span class = "lineNum" > 573 < / span > < span class = "lineCov" > 276 : olderthan = SCRUB_AUTO;< / span >
< span class = "lineNum" > 574 < / span > < span class = "lineCov" > 276 : import_timestamp = 0;< / span >
< span class = "lineNum" > 575 < / span > < span class = "lineCov" > 276 : import_content = 0;< / span >
< span class = "lineNum" > 576 < / span > < span class = "lineCov" > 276 : log_file = 0;< / span >
< span class = "lineNum" > 577 < / span > < span class = "lineCov" > 276 : lock = 0;< / span >
< span class = "lineNum" > 578 < / span > < span class = "lineCov" > 276 : gen_conf = 0;< / span >
< span class = "lineNum" > 579 < / span > < span class = "lineCov" > 276 : speedtest = 0;< / span >
< span class = "lineNum" > 580 < / span > < span class = "lineCov" > 276 : run = 0;< / span >
< span class = "lineNum" > 581 < / span > :
< span class = "lineNum" > 582 < / span > < span class = "lineCov" > 276 : opterr = 0;< / span >
< span class = "lineNum" > 583 < / span > < span class = "lineCov" > 3475 : while ((c =< / span >
< span class = "lineNum" > 584 < / span > : #if HAVE_GETOPT_LONG
< span class = "lineNum" > 585 < / span > : getopt_long(argc, argv, OPTIONS, long_options, 0))
< span class = "lineNum" > 586 < / span > : #else
< span class = "lineNum" > 587 < / span > : getopt(argc, argv, OPTIONS))
< span class = "lineNum" > 588 < / span > : #endif
< span class = "lineNum" > 589 < / span > : != EOF) {
< span class = "lineNum" > 590 < / span > < span class = "lineCov" > 2928 : switch (c) {< / span >
< span class = "lineNum" > 591 < / span > : case 'c' :
< span class = "lineNum" > 592 < / span > < span class = "lineCov" > 269 : pathimport(conf, sizeof(conf), optarg);< / span >
< span class = "lineNum" > 593 < / span > < span class = "lineCov" > 269 : break;< / span >
< span class = "lineNum" > 594 < / span > : case 'f' : {
< span class = "lineNum" > 595 < / span > < span class = "lineCov" > 6 : struct snapraid_filter* filter = filter_alloc_file(1, optarg);< / span >
< span class = "lineNum" > 596 < / span > < span class = "lineCov" > 6 : if (!filter) {< / span >
< span class = "lineNum" > 597 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 598 < / span > : log_fatal(" Invalid filter specification '%s'\n" , optarg);
< span class = "lineNum" > 599 < / span > : log_fatal(" Filters using relative paths are not supported. Ensure to add an initial slash\n" );
< span class = "lineNum" > 600 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 601 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 602 < / span > : }
< span class = "lineNum" > 603 < / span > < span class = "lineCov" > 3 : tommy_list_insert_tail(& filterlist_file, & filter-> node, filter);< / span >
< span class = "lineNum" > 604 < / span > < span class = "lineCov" > 3 : } break;< / span >
< span class = "lineNum" > 605 < / span > : case 'd' : {
< span class = "lineNum" > 606 < / span > < span class = "lineCov" > 10 : struct snapraid_filter* filter = filter_alloc_disk(1, optarg);< / span >
< span class = "lineNum" > 607 < / span > < span class = "lineCov" > 10 : if (!filter) {< / span >
< span class = "lineNum" > 608 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 609 < / span > : log_fatal(" Invalid filter specification '%s'\n" , optarg);
< span class = "lineNum" > 610 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 611 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 612 < / span > : }
< span class = "lineNum" > 613 < / span > < span class = "lineCov" > 10 : tommy_list_insert_tail(& filterlist_disk, & filter-> node, filter);< / span >
< span class = "lineNum" > 614 < / span > < span class = "lineCov" > 10 : } break;< / span >
< span class = "lineNum" > 615 < / span > : case 'm' :
< span class = "lineNum" > 616 < / span > < span class = "lineCov" > 2 : filter_missing = 1;< / span >
< span class = "lineNum" > 617 < / span > < span class = "lineCov" > 2 : opt.expected_missing = 1;< / span >
< span class = "lineNum" > 618 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 619 < / span > : case 'e' :
< span class = "lineNum" > 620 < / span > : /* when processing only error, we filter both files and blocks */
< span class = "lineNum" > 621 < / span > : /* and we apply fixes only to synced ones */
< span class = "lineNum" > 622 < / span > < span class = "lineCov" > 2 : filter_error = 1;< / span >
< span class = "lineNum" > 623 < / span > < span class = "lineCov" > 2 : opt.badonly = 1;< / span >
< span class = "lineNum" > 624 < / span > < span class = "lineCov" > 2 : opt.syncedonly = 1;< / span >
< span class = "lineNum" > 625 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 626 < / span > : case 'p' :
< span class = "lineNum" > 627 < / span > < span class = "lineCov" > 5 : if (strcmp(optarg, " bad" ) == 0) {< / span >
< span class = "lineNum" > 628 < / span > < span class = "lineCov" > 1 : plan = SCRUB_BAD;< / span >
< span class = "lineNum" > 629 < / span > < span class = "lineCov" > 4 : } else if (strcmp(optarg, " new" ) == 0) {< / span >
< span class = "lineNum" > 630 < / span > < span class = "lineCov" > 1 : plan = SCRUB_NEW;< / span >
< span class = "lineNum" > 631 < / span > < span class = "lineCov" > 3 : } else if (strcmp(optarg, " full" ) == 0) {< / span >
< span class = "lineNum" > 632 < / span > < span class = "lineCov" > 2 : plan = SCRUB_FULL;< / span >
< span class = "lineNum" > 633 < / span > : } else {
< span class = "lineNum" > 634 < / span > < span class = "lineCov" > 1 : plan = strtoul(optarg, & e, 10);< / span >
< span class = "lineNum" > 635 < / span > < span class = "lineCov" > 1 : if (!e || *e || plan > 100) {< / span >
< span class = "lineNum" > 636 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 637 < / span > : log_fatal(" Invalid plan/percentage '%s'\n" , optarg);
< span class = "lineNum" > 638 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 639 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 640 < / span > : }
< span class = "lineNum" > 641 < / span > : }
< span class = "lineNum" > 642 < / span > < span class = "lineCov" > 5 : break;< / span >
< span class = "lineNum" > 643 < / span > : case 'o' :
< span class = "lineNum" > 644 < / span > < span class = "lineCov" > 1 : olderthan = strtoul(optarg, & e, 10);< / span >
< span class = "lineNum" > 645 < / span > < span class = "lineCov" > 1 : if (!e || *e || olderthan > 1000) {< / span >
< span class = "lineNum" > 646 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 647 < / span > : log_fatal(" Invalid number of days '%s'\n" , optarg);
< span class = "lineNum" > 648 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 649 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 650 < / span > : }
< span class = "lineNum" > 651 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 652 < / span > : case 'S' :
< span class = "lineNum" > 653 < / span > < span class = "lineCov" > 2 : blockstart = strtoul(optarg, & e, 0);< / span >
< span class = "lineNum" > 654 < / span > < span class = "lineCov" > 2 : if (!e || *e) {< / span >
< span class = "lineNum" > 655 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 656 < / span > : log_fatal(" Invalid start position '%s'\n" , optarg);
< span class = "lineNum" > 657 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 658 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 659 < / span > : }
< span class = "lineNum" > 660 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 661 < / span > : case 'B' :
< span class = "lineNum" > 662 < / span > < span class = "lineCov" > 7 : blockcount = strtoul(optarg, & e, 0);< / span >
< span class = "lineNum" > 663 < / span > < span class = "lineCov" > 7 : if (!e || *e) {< / span >
< span class = "lineNum" > 664 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 665 < / span > : log_fatal(" Invalid count number '%s'\n" , optarg);
< span class = "lineNum" > 666 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 667 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 668 < / span > : }
< span class = "lineNum" > 669 < / span > < span class = "lineCov" > 7 : break;< / span >
< span class = "lineNum" > 670 < / span > : case 'L' :
< span class = "lineNum" > 671 < / span > < span class = "lineNoCov" > 0 : opt.io_error_limit = strtoul(optarg, & e, 0);< / span >
< span class = "lineNum" > 672 < / span > < span class = "lineNoCov" > 0 : if (!e || *e) {< / span >
< span class = "lineNum" > 673 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 674 < / span > : log_fatal(" Invalid error limit number '%s'\n" , optarg);
< span class = "lineNum" > 675 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 676 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 677 < / span > : }
< span class = "lineNum" > 678 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 679 < / span > : case 'i' :
< span class = "lineNum" > 680 < / span > < span class = "lineCov" > 1 : if (import_timestamp) {< / span >
< span class = "lineNum" > 681 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 682 < / span > : log_fatal(" Import directory '%s' already specified as '%s'\n" , optarg, import_timestamp);
< span class = "lineNum" > 683 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 684 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 685 < / span > : }
< span class = "lineNum" > 686 < / span > < span class = "lineCov" > 1 : import_timestamp = optarg;< / span >
< span class = "lineNum" > 687 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 688 < / span > : case OPT_TEST_IMPORT_CONTENT :
< span class = "lineNum" > 689 < / span > < span class = "lineCov" > 1 : if (import_content) {< / span >
< span class = "lineNum" > 690 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 691 < / span > : log_fatal(" Import directory '%s' already specified as '%s'\n" , optarg, import_content);
< span class = "lineNum" > 692 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 693 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 694 < / span > : }
< span class = "lineNum" > 695 < / span > < span class = "lineCov" > 1 : import_content = optarg;< / span >
< span class = "lineNum" > 696 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 697 < / span > : case 'l' :
< span class = "lineNum" > 698 < / span > < span class = "lineCov" > 80 : if (log_file) {< / span >
< span class = "lineNum" > 699 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 700 < / span > : log_fatal(" Log file '%s' already specified as '%s'\n" , optarg, log_file);
< span class = "lineNum" > 701 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 702 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 703 < / span > : }
< span class = "lineNum" > 704 < / span > < span class = "lineCov" > 80 : log_file = optarg;< / span >
< span class = "lineNum" > 705 < / span > < span class = "lineCov" > 80 : break;< / span >
< span class = "lineNum" > 706 < / span > : case 'Z' :
< span class = "lineNum" > 707 < / span > < span class = "lineNoCov" > 0 : opt.force_zero = 1;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 708 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 709 < / span > : case 'E' :
< span class = "lineNum" > 710 < / span > < span class = "lineCov" > 6 : opt.force_empty = 1;< / span >
< span class = "lineNum" > 711 < / span > < span class = "lineCov" > 6 : break;< / span >
< span class = "lineNum" > 712 < / span > : case 'U' :
< span class = "lineNum" > 713 < / span > < span class = "lineNoCov" > 0 : opt.force_uuid = 1;< / span >
< span class = "lineNum" > 714 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 715 < / span > : case 'D' :
< span class = "lineNum" > 716 < / span > < span class = "lineCov" > 1 : opt.force_device = 1;< / span >
< span class = "lineNum" > 717 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 718 < / span > : case 'N' :
< span class = "lineNum" > 719 < / span > < span class = "lineCov" > 1 : opt.force_nocopy = 1;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 720 < / span > < span class = "lineCov" > 1 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 721 < / span > : case 'F' :
< span class = "lineNum" > 722 < / span > < span class = "lineCov" > 6 : opt.force_full = 1;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 723 < / span > < span class = "lineCov" > 6 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 724 < / span > : case 'R' :
< span class = "lineNum" > 725 < / span > < span class = "lineCov" > 1 : opt.force_realloc = 1;< / span >
< span class = "lineNum" > 726 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 727 < / span > : case 'a' :
< span class = "lineNum" > 728 < / span > < span class = "lineCov" > 6 : opt.auditonly = 1;< / span >
< span class = "lineNum" > 729 < / span > < span class = "lineCov" > 6 : break;< / span >
< span class = "lineNum" > 730 < / span > : case 'h' :
< span class = "lineNum" > 731 < / span > < span class = "lineCov" > 7 : opt.prehash = 1;< / span >
< span class = "lineNum" > 732 < / span > < span class = "lineCov" > 7 : break;< / span >
< span class = "lineNum" > 733 < / span > : case 'v' :
< span class = "lineNum" > 734 < / span > < span class = "lineCov" > 26 : ++msg_level;< / span >
2016-11-06 19:57:56 +01:00
< span class = "lineNum" > 735 < / span > < span class = "lineCov" > 26 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 736 < / span > : case 'q' :
< span class = "lineNum" > 737 < / span > < span class = "lineCov" > 729 : --msg_level;< / span >
< span class = "lineNum" > 738 < / span > < span class = "lineCov" > 729 : break;< / span >
< span class = "lineNum" > 739 < / span > : case 'G' :
< span class = "lineNum" > 740 < / span > < span class = "lineCov" > 26 : opt.gui = 1;< / span >
< span class = "lineNum" > 741 < / span > < span class = "lineCov" > 26 : break;< / span >
< span class = "lineNum" > 742 < / span > : case 'H' :
< span class = "lineNum" > 743 < / span > < span class = "lineCov" > 1 : usage();< / span >
< span class = "lineNum" > 744 < / span > < span class = "lineCov" > 1 : exit(EXIT_SUCCESS);< / span >
< span class = "lineNum" > 745 < / span > : case 'V' :
< span class = "lineNum" > 746 < / span > < span class = "lineCov" > 1 : version();< / span >
< span class = "lineNum" > 747 < / span > < span class = "lineCov" > 1 : exit(EXIT_SUCCESS);< / span >
< span class = "lineNum" > 748 < / span > : case 'T' :
< span class = "lineNum" > 749 < / span > < span class = "lineCov" > 4 : speedtest = 1;< / span >
< span class = "lineNum" > 750 < / span > < span class = "lineCov" > 4 : break;< / span >
< span class = "lineNum" > 751 < / span > : case 'C' :
< span class = "lineNum" > 752 < / span > < span class = "lineCov" > 1 : gen_conf = optarg;< / span >
< span class = "lineNum" > 753 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 754 < / span > : case OPT_TEST_KILL_AFTER_SYNC :
< span class = "lineNum" > 755 < / span > < span class = "lineCov" > 10 : opt.kill_after_sync = 1;< / span >
< span class = "lineNum" > 756 < / span > < span class = "lineCov" > 10 : break;< / span >
< span class = "lineNum" > 757 < / span > : case OPT_TEST_EXPECT_UNRECOVERABLE :
< span class = "lineNum" > 758 < / span > < span class = "lineCov" > 13 : opt.expect_unrecoverable = 1;< / span >
< span class = "lineNum" > 759 < / span > < span class = "lineCov" > 13 : break;< / span >
< span class = "lineNum" > 760 < / span > : case OPT_TEST_EXPECT_RECOVERABLE :
< span class = "lineNum" > 761 < / span > < span class = "lineCov" > 23 : opt.expect_recoverable = 1;< / span >
< span class = "lineNum" > 762 < / span > < span class = "lineCov" > 23 : break;< / span >
< span class = "lineNum" > 763 < / span > : case OPT_TEST_SKIP_SELF :
< span class = "lineNum" > 764 < / span > < span class = "lineCov" > 269 : opt.skip_self = 1;< / span >
< span class = "lineNum" > 765 < / span > < span class = "lineCov" > 269 : break;< / span >
< span class = "lineNum" > 766 < / span > : case OPT_TEST_SKIP_SIGN :
< span class = "lineNum" > 767 < / span > < span class = "lineNoCov" > 0 : opt.skip_sign = 1;< / span >
< span class = "lineNum" > 768 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 769 < / span > : case OPT_TEST_SKIP_FALLOCATE :
< span class = "lineNum" > 770 < / span > < span class = "lineCov" > 1 : opt.skip_fallocate = 1;< / span >
< span class = "lineNum" > 771 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 772 < / span > : case OPT_TEST_SKIP_DEVICE :
< span class = "lineNum" > 773 < / span > < span class = "lineCov" > 276 : opt.skip_device = 1;< / span >
< span class = "lineNum" > 774 < / span > < span class = "lineCov" > 276 : period = 50; /* reduce period of the speed test */< / span >
< span class = "lineNum" > 775 < / span > < span class = "lineCov" > 276 : break;< / span >
< span class = "lineNum" > 776 < / span > : case OPT_TEST_SKIP_CONTENT_CHECK :
< span class = "lineNum" > 777 < / span > < span class = "lineNoCov" > 0 : opt.skip_content_check = 1;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 778 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 779 < / span > : case OPT_TEST_SKIP_PARITY_ACCESS :
< span class = "lineNum" > 780 < / span > < span class = "lineNoCov" > 0 : opt.skip_parity_access = 1;< / span >
< span class = "lineNum" > 781 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 782 < / span > : case OPT_TEST_SKIP_DISK_ACCESS :
< span class = "lineNum" > 783 < / span > < span class = "lineNoCov" > 0 : opt.skip_disk_access = 1;< / span >
< span class = "lineNum" > 784 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 785 < / span > : case OPT_TEST_FORCE_MURMUR3 :
< span class = "lineNum" > 786 < / span > < span class = "lineCov" > 1 : opt.force_murmur3 = 1;< / span >
< span class = "lineNum" > 787 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 788 < / span > : case OPT_TEST_FORCE_SPOOKY2 :
< span class = "lineNum" > 789 < / span > < span class = "lineCov" > 1 : opt.force_spooky2 = 1;< / span >
< span class = "lineNum" > 790 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 791 < / span > : case OPT_TEST_SKIP_LOCK :
< span class = "lineNum" > 792 < / span > < span class = "lineNoCov" > 0 : opt.skip_lock = 1;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 793 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 794 < / span > : case OPT_TEST_FORCE_ORDER_PHYSICAL :
< span class = "lineNum" > 795 < / span > < span class = "lineCov" > 2 : opt.force_order = SORT_PHYSICAL;< / span >
< span class = "lineNum" > 796 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 797 < / span > : case OPT_TEST_FORCE_ORDER_INODE :
< span class = "lineNum" > 798 < / span > < span class = "lineNoCov" > 0 : opt.force_order = SORT_INODE;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 799 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 800 < / span > : case OPT_TEST_FORCE_ORDER_ALPHA :
< span class = "lineNum" > 801 < / span > < span class = "lineCov" > 267 : opt.force_order = SORT_ALPHA;< / span >
< span class = "lineNum" > 802 < / span > < span class = "lineCov" > 267 : break;< / span >
< span class = "lineNum" > 803 < / span > : case OPT_TEST_FORCE_ORDER_DIR :
< span class = "lineNum" > 804 < / span > < span class = "lineNoCov" > 0 : opt.force_order = SORT_DIR;< / span >
< span class = "lineNum" > 805 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 806 < / span > : case OPT_TEST_FORCE_SCRUB_AT :
< span class = "lineNum" > 807 < / span > < span class = "lineCov" > 4 : opt.force_scrub_at = atoi(optarg);< / span >
< span class = "lineNum" > 808 < / span > < span class = "lineCov" > 4 : break;< / span >
< span class = "lineNum" > 809 < / span > : case OPT_TEST_FORCE_SCRUB_EVEN :
< span class = "lineNum" > 810 < / span > < span class = "lineCov" > 1 : opt.force_scrub_even = 1;< / span >
< span class = "lineNum" > 811 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 812 < / span > : case OPT_TEST_FORCE_CONTENT_WRITE :
< span class = "lineNum" > 813 < / span > < span class = "lineNoCov" > 0 : opt.force_content_write = 1;< / span >
< span class = "lineNum" > 814 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 815 < / span > : case OPT_TEST_EXPECT_FAILURE :
< span class = "lineNum" > 816 < / span > : /* invert the exit codes */
< span class = "lineNum" > 817 < / span > < span class = "lineCov" > 19 : exit_success = 1;< / span >
< span class = "lineNum" > 818 < / span > < span class = "lineCov" > 19 : exit_failure = 0;< / span >
< span class = "lineNum" > 819 < / span > < span class = "lineCov" > 19 : break;< / span >
< span class = "lineNum" > 820 < / span > : case OPT_TEST_EXPECT_NEED_SYNC :
< span class = "lineNum" > 821 < / span > : /* invert the exit codes */
< span class = "lineNum" > 822 < / span > < span class = "lineCov" > 7 : exit_success = 1;< / span >
< span class = "lineNum" > 823 < / span > < span class = "lineCov" > 7 : exit_sync_needed = 0;< / span >
< span class = "lineNum" > 824 < / span > < span class = "lineCov" > 7 : break;< / span >
< span class = "lineNum" > 825 < / span > : case OPT_TEST_RUN :
< span class = "lineNum" > 826 < / span > < span class = "lineCov" > 10 : run = optarg;< / span >
< span class = "lineNum" > 827 < / span > < span class = "lineCov" > 10 : break;< / span >
< span class = "lineNum" > 828 < / span > : case OPT_TEST_FORCE_SCAN_WINFIND :
< span class = "lineNum" > 829 < / span > < span class = "lineNoCov" > 0 : opt.force_scan_winfind = 1;< / span >
< span class = "lineNum" > 830 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 831 < / span > : case OPT_TEST_FORCE_PROGRESS :
< span class = "lineNum" > 832 < / span > < span class = "lineCov" > 269 : opt.force_progress = 1;< / span >
< span class = "lineNum" > 833 < / span > < span class = "lineCov" > 269 : break;< / span >
< span class = "lineNum" > 834 < / span > : case OPT_TEST_FORCE_AUTOSAVE_AT :
< span class = "lineNum" > 835 < / span > < span class = "lineCov" > 1 : opt.force_autosave_at = atoi(optarg);< / span >
< span class = "lineNum" > 836 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 837 < / span > : case OPT_TEST_FAKE_DEVICE :
< span class = "lineNum" > 838 < / span > < span class = "lineCov" > 1 : opt.fake_device = 1;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 839 < / span > < span class = "lineCov" > 1 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 840 < / span > : case OPT_NO_WARNINGS :
< span class = "lineNum" > 841 < / span > < span class = "lineCov" > 270 : opt.no_warnings = 1;< / span >
< span class = "lineNum" > 842 < / span > < span class = "lineCov" > 270 : break;< / span >
< span class = "lineNum" > 843 < / span > : case OPT_TEST_FAKE_UUID :
< span class = "lineNum" > 844 < / span > < span class = "lineCov" > 1 : opt.fake_uuid = 2;< / span >
< span class = "lineNum" > 845 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 846 < / span > : case OPT_TEST_MATCH_FIRST_UUID :
< span class = "lineNum" > 847 < / span > < span class = "lineCov" > 2 : opt.match_first_uuid = 1;< / span >
< span class = "lineNum" > 848 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 849 < / span > : case OPT_TEST_FORCE_PARITY_UPDATE :
< span class = "lineNum" > 850 < / span > < span class = "lineNoCov" > 0 : opt.force_parity_update = 1;< / span >
< span class = "lineNum" > 851 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 852 < / span > : case OPT_TEST_IO_CACHE :
< span class = "lineNum" > 853 < / span > < span class = "lineCov" > 1 : opt.io_cache = atoi(optarg);< / span >
< span class = "lineNum" > 854 < / span > < span class = "lineCov" > 1 : if (opt.io_cache != 1 & & (opt.io_cache < IO_MIN || opt.io_cache > IO_MAX)) {< / span >
< span class = "lineNum" > 855 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 856 < / span > : log_fatal(" The IO cache should be between %u and %u.\n" , IO_MIN, IO_MAX);
< span class = "lineNum" > 857 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 858 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 859 < / span > : }
< span class = "lineNum" > 860 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 861 < / span > : case OPT_TEST_IO_STATS :
< span class = "lineNum" > 862 < / span > < span class = "lineCov" > 1 : opt.force_stats = 1;< / span >
< span class = "lineNum" > 863 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 864 < / span > : case OPT_TEST_COND_SIGNAL_OUTSIDE :
< span class = "lineNum" > 865 < / span > : #if HAVE_PTHREAD
< span class = "lineNum" > 866 < / span > < span class = "lineNoCov" > 0 : thread_cond_signal_outside = 1;< / span >
< span class = "lineNum" > 867 < / span > : #endif
< span class = "lineNum" > 868 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 869 < / span > : case OPT_TEST_IO_ADVISE_NONE :
< span class = "lineNum" > 870 < / span > < span class = "lineCov" > 1 : opt.file_mode = ADVISE_NONE;< / span >
< span class = "lineNum" > 871 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 872 < / span > : case OPT_TEST_IO_ADVISE_SEQUENTIAL :
< span class = "lineNum" > 873 < / span > < span class = "lineCov" > 1 : opt.file_mode = ADVISE_SEQUENTIAL;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 874 < / span > < span class = "lineCov" > 1 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 875 < / span > : case OPT_TEST_IO_ADVISE_FLUSH :
< span class = "lineNum" > 876 < / span > < span class = "lineNoCov" > 0 : opt.file_mode = ADVISE_FLUSH;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 877 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 878 < / span > : case OPT_TEST_IO_ADVISE_FLUSH_WINDOW :
< span class = "lineNum" > 879 < / span > < span class = "lineCov" > 1 : opt.file_mode = ADVISE_FLUSH_WINDOW;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 880 < / span > < span class = "lineCov" > 1 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 881 < / span > : case OPT_TEST_IO_ADVISE_DISCARD :
< span class = "lineNum" > 882 < / span > < span class = "lineNoCov" > 0 : opt.file_mode = ADVISE_DISCARD;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 883 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 884 < / span > : case OPT_TEST_IO_ADVISE_DISCARD_WINDOW :
< span class = "lineNum" > 885 < / span > < span class = "lineCov" > 1 : opt.file_mode = ADVISE_DISCARD_WINDOW;< / span >
< span class = "lineNum" > 886 < / span > < span class = "lineCov" > 1 : break;< / span >
< span class = "lineNum" > 887 < / span > : case OPT_TEST_IO_ADVISE_DIRECT :
< span class = "lineNum" > 888 < / span > < span class = "lineNoCov" > 0 : opt.file_mode = ADVISE_DIRECT;< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 889 < / span > < span class = "lineNoCov" > 0 : break;< / span >
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 890 < / span > : case OPT_TEST_PARITY_LIMIT :
< span class = "lineNum" > 891 < / span > < span class = "lineCov" > 269 : opt.parity_limit_size = atoll(optarg);< / span >
< span class = "lineNum" > 892 < / span > < span class = "lineCov" > 269 : break;< / span >
< span class = "lineNum" > 893 < / span > : case OPT_TEST_SKIP_CONTENT_WRITE :
< span class = "lineNum" > 894 < / span > < span class = "lineNoCov" > 0 : opt.skip_content_write = 1;< / span >
< span class = "lineNum" > 895 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 896 < / span > : case OPT_TEST_SKIP_SPACE_HOLDER :
< span class = "lineNum" > 897 < / span > < span class = "lineNoCov" > 0 : opt.skip_space_holder = 1;< / span >
< span class = "lineNum" > 898 < / span > < span class = "lineNoCov" > 0 : break;< / span >
< span class = "lineNum" > 899 < / span > : case OPT_TEST_FORMAT :
< span class = "lineNum" > 900 < / span > < span class = "lineCov" > 3 : if (strcmp(optarg, " file" ) == 0)< / span >
< span class = "lineNum" > 901 < / span > < span class = "lineCov" > 1 : FMT_MODE = FMT_FILE;< / span >
< span class = "lineNum" > 902 < / span > < span class = "lineCov" > 2 : else if (strcmp(optarg, " disk" ) == 0)< / span >
< span class = "lineNum" > 903 < / span > < span class = "lineCov" > 1 : FMT_MODE = FMT_DISK;< / span >
< span class = "lineNum" > 904 < / span > < span class = "lineCov" > 1 : else if (strcmp(optarg, " path" ) == 0)< / span >
< span class = "lineNum" > 905 < / span > < span class = "lineCov" > 1 : FMT_MODE = FMT_PATH;< / span >
< span class = "lineNum" > 906 < / span > : else {
< span class = "lineNum" > 907 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 908 < / span > : log_fatal(" Unknown format '%s'\n" , optarg);
< span class = "lineNum" > 909 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 910 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 911 < / span > : }
< span class = "lineNum" > 912 < / span > < span class = "lineCov" > 3 : break;< / span >
< span class = "lineNum" > 913 < / span > : default :
< span class = "lineNum" > 914 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 915 < / span > : log_fatal(" Unknown option '%c'\n" , (char)c);
< span class = "lineNum" > 916 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 917 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 918 < / span > : }
< span class = "lineNum" > 919 < / span > : }
< span class = "lineNum" > 920 < / span > :
< span class = "lineNum" > 921 < / span > < span class = "lineCov" > 271 : os_init(opt.force_scan_winfind);< / span >
< span class = "lineNum" > 922 < / span > < span class = "lineCov" > 271 : raid_init();< / span >
< span class = "lineNum" > 923 < / span > < span class = "lineCov" > 271 : crc32c_init();< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 924 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 925 < / span > < span class = "lineCov" > 271 : if (speedtest != 0) {< / span >
< span class = "lineNum" > 926 < / span > < span class = "lineCov" > 4 : speed(period);< / span >
< span class = "lineNum" > 927 < / span > < span class = "lineCov" > 4 : os_done();< / span >
< span class = "lineNum" > 928 < / span > < span class = "lineCov" > 4 : exit(EXIT_SUCCESS);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 929 < / span > : }
< span class = "lineNum" > 930 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 931 < / span > < span class = "lineCov" > 267 : if (gen_conf != 0) {< / span >
< span class = "lineNum" > 932 < / span > < span class = "lineCov" > 1 : generate_configuration(gen_conf);< / span >
< span class = "lineNum" > 933 < / span > < span class = "lineCov" > 1 : os_done();< / span >
< span class = "lineNum" > 934 < / span > < span class = "lineCov" > 1 : exit(EXIT_SUCCESS);< / span >
< span class = "lineNum" > 935 < / span > : }
< span class = "lineNum" > 936 < / span > :
< span class = "lineNum" > 937 < / span > < span class = "lineCov" > 266 : if (optind + 1 != argc) {< / span >
< span class = "lineNum" > 938 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 939 < / span > : usage();
< span class = "lineNum" > 940 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 941 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 942 < / span > : }
< span class = "lineNum" > 943 < / span > :
< span class = "lineNum" > 944 < / span > < span class = "lineCov" > 266 : command = argv[optind];< / span >
< span class = "lineNum" > 945 < / span > < span class = "lineCov" > 266 : if (strcmp(command, " diff" ) == 0) {< / span >
< span class = "lineNum" > 946 < / span > < span class = "lineCov" > 8 : operation = OPERATION_DIFF;< / span >
< span class = "lineNum" > 947 < / span > < span class = "lineCov" > 258 : } else if (strcmp(argv[optind], " sync" ) == 0) {< / span >
< span class = "lineNum" > 948 < / span > < span class = "lineCov" > 89 : operation = OPERATION_SYNC;< / span >
< span class = "lineNum" > 949 < / span > < span class = "lineCov" > 169 : } else if (strcmp(argv[optind], " check" ) == 0) {< / span >
< span class = "lineNum" > 950 < / span > < span class = "lineCov" > 75 : operation = OPERATION_CHECK;< / span >
< span class = "lineNum" > 951 < / span > < span class = "lineCov" > 94 : } else if (strcmp(argv[optind], " fix" ) == 0) {< / span >
< span class = "lineNum" > 952 < / span > < span class = "lineCov" > 46 : operation = OPERATION_FIX;< / span >
< span class = "lineNum" > 953 < / span > < span class = "lineCov" > 48 : } else if (strcmp(argv[optind], " test-dry" ) == 0) {< / span >
< span class = "lineNum" > 954 < / span > < span class = "lineCov" > 2 : operation = OPERATION_DRY;< / span >
< span class = "lineNum" > 955 < / span > < span class = "lineCov" > 46 : } else if (strcmp(argv[optind], " dup" ) == 0) {< / span >
< span class = "lineNum" > 956 < / span > < span class = "lineCov" > 3 : operation = OPERATION_DUP;< / span >
< span class = "lineNum" > 957 < / span > < span class = "lineCov" > 43 : } else if (strcmp(argv[optind], " list" ) == 0) {< / span >
< span class = "lineNum" > 958 < / span > < span class = "lineCov" > 5 : operation = OPERATION_LIST;< / span >
< span class = "lineNum" > 959 < / span > < span class = "lineCov" > 38 : } else if (strcmp(argv[optind], " pool" ) == 0) {< / span >
< span class = "lineNum" > 960 < / span > < span class = "lineCov" > 3 : operation = OPERATION_POOL;< / span >
< span class = "lineNum" > 961 < / span > < span class = "lineCov" > 35 : } else if (strcmp(argv[optind], " rehash" ) == 0) {< / span >
< span class = "lineNum" > 962 < / span > < span class = "lineCov" > 1 : operation = OPERATION_REHASH;< / span >
< span class = "lineNum" > 963 < / span > < span class = "lineCov" > 34 : } else if (strcmp(argv[optind], " scrub" ) == 0) {< / span >
< span class = "lineNum" > 964 < / span > < span class = "lineCov" > 11 : operation = OPERATION_SCRUB;< / span >
< span class = "lineNum" > 965 < / span > < span class = "lineCov" > 23 : } else if (strcmp(argv[optind], " status" ) == 0) {< / span >
< span class = "lineNum" > 966 < / span > < span class = "lineCov" > 15 : operation = OPERATION_STATUS;< / span >
< span class = "lineNum" > 967 < / span > < span class = "lineCov" > 8 : } else if (strcmp(argv[optind], " test-rewrite" ) == 0) {< / span >
< span class = "lineNum" > 968 < / span > < span class = "lineCov" > 1 : operation = OPERATION_REWRITE;< / span >
< span class = "lineNum" > 969 < / span > < span class = "lineCov" > 7 : } else if (strcmp(argv[optind], " test-read" ) == 0) {< / span >
< span class = "lineNum" > 970 < / span > < span class = "lineCov" > 1 : operation = OPERATION_READ;< / span >
< span class = "lineNum" > 971 < / span > < span class = "lineCov" > 6 : } else if (strcmp(argv[optind], " touch" ) == 0) {< / span >
< span class = "lineNum" > 972 < / span > < span class = "lineCov" > 1 : operation = OPERATION_TOUCH;< / span >
< span class = "lineNum" > 973 < / span > < span class = "lineCov" > 5 : } else if (strcmp(argv[optind], " up" ) == 0) {< / span >
< span class = "lineNum" > 974 < / span > < span class = "lineCov" > 1 : operation = OPERATION_SPINUP;< / span >
< span class = "lineNum" > 975 < / span > < span class = "lineCov" > 4 : } else if (strcmp(argv[optind], " down" ) == 0) {< / span >
< span class = "lineNum" > 976 < / span > < span class = "lineCov" > 1 : operation = OPERATION_SPINDOWN;< / span >
< span class = "lineNum" > 977 < / span > < span class = "lineCov" > 3 : } else if (strcmp(argv[optind], " devices" ) == 0) {< / span >
< span class = "lineNum" > 978 < / span > < span class = "lineCov" > 1 : operation = OPERATION_DEVICES;< / span >
< span class = "lineNum" > 979 < / span > < span class = "lineCov" > 2 : } else if (strcmp(argv[optind], " smart" ) == 0) {< / span >
< span class = "lineNum" > 980 < / span > < span class = "lineCov" > 2 : operation = OPERATION_SMART;< / span >
< span class = "lineNum" > 981 < / span > : } else {
< span class = "lineNum" > 982 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 983 < / span > : log_fatal(" Unknown command '%s'\n" , argv[optind]);
< span class = "lineNum" > 984 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 985 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 986 < / span > : }
< span class = "lineNum" > 987 < / span > :
< span class = "lineNum" > 988 < / span > : /* check options compatibility */
< span class = "lineNum" > 989 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 990 < / span > : case OPERATION_CHECK :
< span class = "lineNum" > 991 < / span > < span class = "lineCov" > 75 : break;< / span >
< span class = "lineNum" > 992 < / span > : default :
< span class = "lineNum" > 993 < / span > < span class = "lineCov" > 191 : if (opt.auditonly) {< / span >
< span class = "lineNum" > 994 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 995 < / span > : log_fatal(" You cannot use -a, --audit-only with the '%s' command\n" , command);
< span class = "lineNum" > 996 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 997 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 998 < / span > : }
< span class = "lineNum" > 999 < / span > : }
< span class = "lineNum" > 1000 < / span > :
< span class = "lineNum" > 1001 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1002 < / span > : case OPERATION_FIX :
< span class = "lineNum" > 1003 < / span > : case OPERATION_CHECK :
< span class = "lineNum" > 1004 < / span > < span class = "lineCov" > 121 : break;< / span >
< span class = "lineNum" > 1005 < / span > : default :
< span class = "lineNum" > 1006 < / span > < span class = "lineCov" > 145 : if (opt.force_device) {< / span >
< span class = "lineNum" > 1007 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1008 < / span > : log_fatal(" You cannot use -D, --force-device with the '%s' command\n" , command);
< span class = "lineNum" > 1009 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1010 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1011 < / span > : }
< span class = "lineNum" > 1012 < / span > : }
< span class = "lineNum" > 1013 < / span > :
< span class = "lineNum" > 1014 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1015 < / span > : case OPERATION_SYNC :
< span class = "lineNum" > 1016 < / span > : case OPERATION_CHECK :
< span class = "lineNum" > 1017 < / span > : case OPERATION_FIX :
< span class = "lineNum" > 1018 < / span > < span class = "lineCov" > 210 : break;< / span >
< span class = "lineNum" > 1019 < / span > : default :
< span class = "lineNum" > 1020 < / span > < span class = "lineCov" > 56 : if (opt.force_nocopy) {< / span >
< span class = "lineNum" > 1021 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1022 < / span > : log_fatal(" You cannot use -N, --force-nocopy with the '%s' command\n" , command);
< span class = "lineNum" > 1023 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1024 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1025 < / span > : }
< span class = "lineNum" > 1026 < / span > : }
< span class = "lineNum" > 1027 < / span > :
< span class = "lineNum" > 1028 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1029 < / span > : case OPERATION_SYNC :
< span class = "lineNum" > 1030 < / span > < span class = "lineCov" > 89 : break;< / span >
< span class = "lineNum" > 1031 < / span > : default :
< span class = "lineNum" > 1032 < / span > < span class = "lineCov" > 177 : if (opt.prehash) {< / span >
< span class = "lineNum" > 1033 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1034 < / span > : log_fatal(" You cannot use -h, --pre-hash with the '%s' command\n" , command);
< span class = "lineNum" > 1035 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1036 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1037 < / span > : }
< span class = "lineNum" > 1038 < / span > :
< span class = "lineNum" > 1039 < / span > < span class = "lineCov" > 177 : if (opt.force_full) {< / span >
< span class = "lineNum" > 1040 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1041 < / span > : log_fatal(" You cannot use -F, --force-full with the '%s' command\n" , command);
< span class = "lineNum" > 1042 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1043 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1044 < / span > : }
< span class = "lineNum" > 1045 < / span > :
< span class = "lineNum" > 1046 < / span > < span class = "lineCov" > 177 : if (opt.force_realloc) {< / span >
< span class = "lineNum" > 1047 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1048 < / span > : log_fatal(" You cannot use -R, --force-realloc with the '%s' command\n" , command);
< span class = "lineNum" > 1049 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1050 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1051 < / span > : }
< span class = "lineNum" > 1052 < / span > : }
< span class = "lineNum" > 1053 < / span > :
< span class = "lineNum" > 1054 < / span > < span class = "lineCov" > 266 : if (opt.force_full & & opt.force_nocopy) {< / span >
< span class = "lineNum" > 1055 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1056 < / span > : log_fatal(" You cannot use the -F, --force-full and -N, --force-nocopy options at the same time\n" );
< span class = "lineNum" > 1057 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1058 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1059 < / span > : }
< span class = "lineNum" > 1060 < / span > :
< span class = "lineNum" > 1061 < / span > < span class = "lineCov" > 266 : if (opt.force_realloc & & opt.force_nocopy) {< / span >
< span class = "lineNum" > 1062 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1063 < / span > : log_fatal(" You cannot use the -R, --force-realloc and -N, --force-nocopy options at the same time\n" );
< span class = "lineNum" > 1064 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1065 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1066 < / span > : }
< span class = "lineNum" > 1067 < / span > :
< span class = "lineNum" > 1068 < / span > < span class = "lineCov" > 266 : if (opt.force_realloc & & opt.force_full) {< / span >
< span class = "lineNum" > 1069 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1070 < / span > : log_fatal(" You cannot use the -R, --force-realloc and -F, --force-full options at the same time\n" );
< span class = "lineNum" > 1071 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1072 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1073 < / span > : }
< span class = "lineNum" > 1074 < / span > :
< span class = "lineNum" > 1075 < / span > < span class = "lineCov" > 266 : if (opt.prehash & & opt.force_nocopy) {< / span >
< span class = "lineNum" > 1076 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1077 < / span > : log_fatal(" You cannot use the -h, --pre-hash and -N, --force-nocopy options at the same time\n" );
< span class = "lineNum" > 1078 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1079 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1080 < / span > : }
< span class = "lineNum" > 1081 < / span > :
< span class = "lineNum" > 1082 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1083 < / span > : case OPERATION_CHECK :
< span class = "lineNum" > 1084 < / span > : case OPERATION_FIX :
< span class = "lineNum" > 1085 < / span > : case OPERATION_DRY :
< span class = "lineNum" > 1086 < / span > < span class = "lineCov" > 123 : break;< / span >
< span class = "lineNum" > 1087 < / span > : default :
< span class = "lineNum" > 1088 < / span > < span class = "lineCov" > 141 : if (!tommy_list_empty(& filterlist_disk)) {< / span >
< span class = "lineNum" > 1089 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1090 < / span > : log_fatal(" You cannot use -d, --filter-disk with the '%s' command\n" , command);
< span class = "lineNum" > 1091 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1092 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1093 < / span > : }
< span class = "lineNum" > 1094 < / span > : /* follow */
< span class = "lineNum" > 1095 < / span > : case OPERATION_SPINUP :
< span class = "lineNum" > 1096 < / span > : case OPERATION_SPINDOWN :
< span class = "lineNum" > 1097 < / span > < span class = "lineCov" > 143 : if (!tommy_list_empty(& filterlist_file)) {< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1098 < / span > : /* LCOV_EXCL_START */
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1099 < / span > : log_fatal(" You cannot use -f, --filter with the '%s' command\n" , command);
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1100 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1101 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1102 < / span > : }
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1103 < / span > < span class = "lineCov" > 143 : if (filter_missing != 0) {< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1104 < / span > : /* LCOV_EXCL_START */
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1105 < / span > : log_fatal(" You cannot use -m, --filter-missing with the '%s' command\n" , command);
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1106 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1107 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1108 < / span > : }
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1109 < / span > < span class = "lineCov" > 143 : if (filter_error != 0) {< / span >
< span class = "lineNum" > 1110 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1111 < / span > : log_fatal(" You cannot use -e, --filter-error with the '%s' command\n" , command);
< span class = "lineNum" > 1112 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1113 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1114 < / span > : }
< span class = "lineNum" > 1115 < / span > : }
< span class = "lineNum" > 1116 < / span > :
< span class = "lineNum" > 1117 < / span > : /* errors must be always fixed on all disks */
< span class = "lineNum" > 1118 < / span > : /* because we don't keep the information on what disk is the error */
< span class = "lineNum" > 1119 < / span > < span class = "lineCov" > 266 : if (filter_error != 0 & & !tommy_list_empty(& filterlist_disk)) {< / span >
< span class = "lineNum" > 1120 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1121 < / span > : log_fatal(" You cannot use -e, --filter-error and -d, --filter-disk at the same time\n" );
< span class = "lineNum" > 1122 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1123 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1124 < / span > : }
< span class = "lineNum" > 1125 < / span > :
< span class = "lineNum" > 1126 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1127 < / span > : case OPERATION_CHECK :
< span class = "lineNum" > 1128 < / span > : case OPERATION_FIX :
< span class = "lineNum" > 1129 < / span > < span class = "lineCov" > 121 : break;< / span >
< span class = "lineNum" > 1130 < / span > : default :
< span class = "lineNum" > 1131 < / span > < span class = "lineCov" > 145 : if (import_timestamp != 0 || import_content != 0) {< / span >
< span class = "lineNum" > 1132 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1133 < / span > : log_fatal(" You cannot import with the '%s' command\n" , command);
< span class = "lineNum" > 1134 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1135 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1136 < / span > : }
< span class = "lineNum" > 1137 < / span > : }
< span class = "lineNum" > 1138 < / span > :
< span class = "lineNum" > 1139 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1140 < / span > : case OPERATION_LIST :
< span class = "lineNum" > 1141 < / span > : case OPERATION_DUP :
< span class = "lineNum" > 1142 < / span > : case OPERATION_STATUS :
< span class = "lineNum" > 1143 < / span > : case OPERATION_REWRITE :
< span class = "lineNum" > 1144 < / span > : case OPERATION_READ :
< span class = "lineNum" > 1145 < / span > : case OPERATION_REHASH :
< span class = "lineNum" > 1146 < / span > : case OPERATION_SPINUP : /* we want to do it in different threads to avoid blocking */
< span class = "lineNum" > 1147 < / span > : /* avoid to check and access data disks if not needed */
< span class = "lineNum" > 1148 < / span > < span class = "lineCov" > 27 : opt.skip_disk_access = 1;< / span >
< span class = "lineNum" > 1149 < / span > < span class = "lineCov" > 27 : break;< / span >
< span class = "lineNum" > 1150 < / span > : }
< span class = "lineNum" > 1151 < / span > :
< span class = "lineNum" > 1152 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1153 < / span > : case OPERATION_DIFF :
< span class = "lineNum" > 1154 < / span > : case OPERATION_LIST :
< span class = "lineNum" > 1155 < / span > : case OPERATION_DUP :
< span class = "lineNum" > 1156 < / span > : case OPERATION_POOL :
< span class = "lineNum" > 1157 < / span > : case OPERATION_STATUS :
< span class = "lineNum" > 1158 < / span > : case OPERATION_REWRITE :
< span class = "lineNum" > 1159 < / span > : case OPERATION_READ :
< span class = "lineNum" > 1160 < / span > : case OPERATION_REHASH :
< span class = "lineNum" > 1161 < / span > : case OPERATION_TOUCH :
< span class = "lineNum" > 1162 < / span > : case OPERATION_SPINUP : /* we want to do it in different threads to avoid blocking */
< span class = "lineNum" > 1163 < / span > : /* avoid to check and access parity disks if not needed */
< span class = "lineNum" > 1164 < / span > < span class = "lineCov" > 39 : opt.skip_parity_access = 1;< / span >
< span class = "lineNum" > 1165 < / span > < span class = "lineCov" > 39 : break;< / span >
< span class = "lineNum" > 1166 < / span > : }
< span class = "lineNum" > 1167 < / span > :
< span class = "lineNum" > 1168 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1169 < / span > : case OPERATION_FIX :
< span class = "lineNum" > 1170 < / span > : case OPERATION_CHECK :
< span class = "lineNum" > 1171 < / span > : /* avoid to stop processing if a content file is not accessible */
< span class = "lineNum" > 1172 < / span > < span class = "lineCov" > 121 : opt.skip_content_access = 1;< / span >
< span class = "lineNum" > 1173 < / span > < span class = "lineCov" > 121 : break;< / span >
< span class = "lineNum" > 1174 < / span > : }
< span class = "lineNum" > 1175 < / span > :
< span class = "lineNum" > 1176 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1177 < / span > : case OPERATION_DIFF :
< span class = "lineNum" > 1178 < / span > : case OPERATION_LIST :
< span class = "lineNum" > 1179 < / span > : case OPERATION_DUP :
< span class = "lineNum" > 1180 < / span > : case OPERATION_POOL :
< span class = "lineNum" > 1181 < / span > : case OPERATION_TOUCH :
< span class = "lineNum" > 1182 < / span > : case OPERATION_SPINUP :
< span class = "lineNum" > 1183 < / span > : case OPERATION_SPINDOWN :
< span class = "lineNum" > 1184 < / span > : case OPERATION_DEVICES :
< span class = "lineNum" > 1185 < / span > : case OPERATION_SMART :
< span class = "lineNum" > 1186 < / span > < span class = "lineCov" > 25 : opt.skip_self = 1;< / span >
< span class = "lineNum" > 1187 < / span > < span class = "lineCov" > 25 : break;< / span >
< span class = "lineNum" > 1188 < / span > : }
< span class = "lineNum" > 1189 < / span > :
< span class = "lineNum" > 1190 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1191 < / span > : #if HAVE_DIRECT_IO
< span class = "lineNum" > 1192 < / span > : case OPERATION_SYNC :
< span class = "lineNum" > 1193 < / span > : case OPERATION_SCRUB :
< span class = "lineNum" > 1194 < / span > : case OPERATION_DRY :
< span class = "lineNum" > 1195 < / span > < span class = "lineCov" > 102 : break;< / span >
< span class = "lineNum" > 1196 < / span > : #endif
< span class = "lineNum" > 1197 < / span > : default:
< span class = "lineNum" > 1198 < / span > : /* we allow direct IO only on some commands */
< span class = "lineNum" > 1199 < / span > < span class = "lineCov" > 164 : if (opt.file_mode == ADVISE_DIRECT)< / span >
< span class = "lineNum" > 1200 < / span > < span class = "lineNoCov" > 0 : opt.file_mode = ADVISE_SEQUENTIAL;< / span >
< span class = "lineNum" > 1201 < / span > < span class = "lineCov" > 164 : break;< / span >
< span class = "lineNum" > 1202 < / span > : }
< span class = "lineNum" > 1203 < / span > :
< span class = "lineNum" > 1204 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1205 < / span > : case OPERATION_DEVICES :
< span class = "lineNum" > 1206 < / span > : case OPERATION_SMART :
< span class = "lineNum" > 1207 < / span > : /* we may need to use these commands during operations */
< span class = "lineNum" > 1208 < / span > < span class = "lineCov" > 3 : opt.skip_lock = 1;< / span >
< span class = "lineNum" > 1209 < / span > < span class = "lineCov" > 3 : break;< / span >
< span class = "lineNum" > 1210 < / span > : }
< span class = "lineNum" > 1211 < / span > :
< span class = "lineNum" > 1212 < / span > < span class = "lineCov" > 266 : switch (operation) {< / span >
< span class = "lineNum" > 1213 < / span > : case OPERATION_SMART :
< span class = "lineNum" > 1214 < / span > : /* allow to run without configuration file */
< span class = "lineNum" > 1215 < / span > < span class = "lineCov" > 2 : opt.auto_conf = 1;< / span >
< span class = "lineNum" > 1216 < / span > < span class = "lineCov" > 2 : break;< / span >
< span class = "lineNum" > 1217 < / span > : }
< span class = "lineNum" > 1218 < / span > :
< span class = "lineNum" > 1219 < / span > : /* open the log file */
< span class = "lineNum" > 1220 < / span > < span class = "lineCov" > 266 : log_open(log_file);< / span >
< span class = "lineNum" > 1221 < / span > :
< span class = "lineNum" > 1222 < / span > : /* print generic info into the log */
< span class = "lineNum" > 1223 < / span > < span class = "lineCov" > 266 : t = time(0);< / span >
< span class = "lineNum" > 1224 < / span > < span class = "lineCov" > 266 : tm = localtime(& t);< / span >
< span class = "lineNum" > 1225 < / span > < span class = "lineCov" > 266 : log_tag(" version:%s\n" , PACKAGE_VERSION);< / span >
< span class = "lineNum" > 1226 < / span > < span class = "lineCov" > 266 : log_tag(" unixtime:%" PRIi64 " \n" , (int64_t)t);< / span >
< span class = "lineNum" > 1227 < / span > < span class = "lineCov" > 266 : if (tm) {< / span >
< span class = "lineNum" > 1228 < / span > : char datetime[64];
< span class = "lineNum" > 1229 < / span > < span class = "lineCov" > 266 : strftime(datetime, sizeof(datetime), " %Y-%m-%d %H:%M:%S" , tm);< / span >
< span class = "lineNum" > 1230 < / span > < span class = "lineCov" > 266 : log_tag(" time:%s\n" , datetime);< / span >
< span class = "lineNum" > 1231 < / span > : }
< span class = "lineNum" > 1232 < / span > < span class = "lineCov" > 266 : log_tag(" command:%s\n" , command);< / span >
< span class = "lineNum" > 1233 < / span > < span class = "lineCov" > 4066 : for (i = 0; i < argc; ++i)< / span >
< span class = "lineNum" > 1234 < / span > < span class = "lineCov" > 3800 : log_tag(" argv:%u:%s\n" , i, argv[i]);< / span >
< span class = "lineNum" > 1235 < / span > < span class = "lineCov" > 266 : log_flush();< / span >
< span class = "lineNum" > 1236 < / span > :
< span class = "lineNum" > 1237 < / span > < span class = "lineCov" > 266 : if (!opt.skip_self)< / span >
< span class = "lineNum" > 1238 < / span > < span class = "lineCov" > 1 : selftest();< / span >
< span class = "lineNum" > 1239 < / span > :
< span class = "lineNum" > 1240 < / span > < span class = "lineCov" > 266 : state_init(& state);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1241 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1242 < / span > : /* read the configuration file */
< span class = "lineNum" > 1243 < / span > < span class = "lineCov" > 266 : state_config(& state, conf, command, & opt, & filterlist_disk);< / span >
< span class = "lineNum" > 1244 < / span > :
< span class = "lineNum" > 1245 < / span > : /* set the raid mode */
< span class = "lineNum" > 1246 < / span > < span class = "lineCov" > 265 : raid_mode(state.raid_mode);< / span >
< span class = "lineNum" > 1247 < / span > :
< span class = "lineNum" > 1248 < / span > : #if HAVE_LOCKFILE
< span class = "lineNum" > 1249 < / span > : /* create the lock file */
< span class = "lineNum" > 1250 < / span > < span class = "lineCov" > 265 : if (!opt.skip_lock & & state.lockfile[0]) {< / span >
< span class = "lineNum" > 1251 < / span > < span class = "lineCov" > 262 : lock = lock_lock(state.lockfile);< / span >
< span class = "lineNum" > 1252 < / span > < span class = "lineCov" > 262 : if (lock == -1) {< / span >
< span class = "lineNum" > 1253 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1254 < / span > : if (errno != EWOULDBLOCK) {
< span class = "lineNum" > 1255 < / span > : log_fatal(" Error creating the lock file '%s'. %s.\n" , state.lockfile, strerror(errno));
< span class = "lineNum" > 1256 < / span > : } else {
< span class = "lineNum" > 1257 < / span > : log_fatal(" The lock file '%s' is already locked!\n" , state.lockfile);
< span class = "lineNum" > 1258 < / span > : log_fatal(" SnapRAID is already in use!\n" );
< span class = "lineNum" > 1259 < / span > : }
< span class = "lineNum" > 1260 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1261 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1262 < / span > : }
< span class = "lineNum" > 1263 < / span > : }
< span class = "lineNum" > 1264 < / span > : #else
< span class = "lineNum" > 1265 < / span > : (void)lock;
< span class = "lineNum" > 1266 < / span > : #endif
< span class = "lineNum" > 1267 < / span > :
< span class = "lineNum" > 1268 < / span > < span class = "lineCov" > 265 : if (operation == OPERATION_DIFF) {< / span >
< span class = "lineNum" > 1269 < / span > < span class = "lineCov" > 8 : state_read(& state);< / span >
< span class = "lineNum" > 1270 < / span > :
< span class = "lineNum" > 1271 < / span > < span class = "lineCov" > 8 : ret = state_diff(& state);< / span >
< span class = "lineNum" > 1272 < / span > :
< span class = "lineNum" > 1273 < / span > : /* abort if sync needed */
< span class = "lineNum" > 1274 < / span > < span class = "lineCov" > 8 : if (ret > 0)< / span >
< span class = "lineNum" > 1275 < / span > < span class = "lineCov" > 7 : exit(EXIT_SYNC_NEEDED);< / span >
< span class = "lineNum" > 1276 < / span > < span class = "lineCov" > 257 : } else if (operation == OPERATION_SYNC) {< / span >
< span class = "lineNum" > 1277 < / span > :
< span class = "lineNum" > 1278 < / span > : /* in the next state read ensures to clear all the past hashes in case */
< span class = "lineNum" > 1279 < / span > : /* we are reading from an incomplete sync */
< span class = "lineNum" > 1280 < / span > : /* The indeterminate hash are only for CHG/DELETED blocks for which we don't */
< span class = "lineNum" > 1281 < / span > : /* know if the previous interrupted sync was able to update or not the parity. */
< span class = "lineNum" > 1282 < / span > : /* The sync process instead needs to trust this information because it's used */
< span class = "lineNum" > 1283 < / span > : /* to avoid to recompute the parity if all the input are equals as before. */
< span class = "lineNum" > 1284 < / span > :
< span class = "lineNum" > 1285 < / span > : /* In these cases we don't know if the old state is still the one */
< span class = "lineNum" > 1286 < / span > : /* stored inside the parity, because after an aborted sync, the parity */
< span class = "lineNum" > 1287 < / span > : /* may be or may be not have been updated with the data that may be now */
< span class = "lineNum" > 1288 < / span > : /* deleted. Then we reset the hash to a bogus value. */
< span class = "lineNum" > 1289 < / span > :
< span class = "lineNum" > 1290 < / span > : /* An example for CHG blocks is: */
< span class = "lineNum" > 1291 < / span > : /* - One file is added creating a CHG block with ZERO state */
< span class = "lineNum" > 1292 < / span > : /* - Sync aborted after updating the parity to the new state, */
< span class = "lineNum" > 1293 < / span > : /* but without saving the content file representing this new BLK state. */
< span class = "lineNum" > 1294 < / span > : /* - File is now deleted after the aborted sync */
< span class = "lineNum" > 1295 < / span > : /* - Sync again, deleting the blocks over the CHG ones */
< span class = "lineNum" > 1296 < / span > : /* with the hash of CHG blocks not representing the real parity state */
< span class = "lineNum" > 1297 < / span > :
< span class = "lineNum" > 1298 < / span > : /* An example for DELETED blocks is: */
< span class = "lineNum" > 1299 < / span > : /* - One file is deleted creating DELETED blocks */
< span class = "lineNum" > 1300 < / span > : /* - Sync aborted after, updating the parity to the new state, */
< span class = "lineNum" > 1301 < / span > : /* but without saving the content file representing this new EMPTY state. */
< span class = "lineNum" > 1302 < / span > : /* - Another file is added again over the DELETE ones */
< span class = "lineNum" > 1303 < / span > : /* with the hash of DELETED blocks not representing the real parity state */
< span class = "lineNum" > 1304 < / span > < span class = "lineCov" > 89 : state.clear_past_hash = 1;< / span >
< span class = "lineNum" > 1305 < / span > :
< span class = "lineNum" > 1306 < / span > < span class = "lineCov" > 89 : state_read(& state);< / span >
< span class = "lineNum" > 1307 < / span > :
< span class = "lineNum" > 1308 < / span > < span class = "lineCov" > 88 : state_scan(& state);< / span >
< span class = "lineNum" > 1309 < / span > :
< span class = "lineNum" > 1310 < / span > : /* refresh the size info before the content write */
< span class = "lineNum" > 1311 < / span > < span class = "lineCov" > 87 : state_refresh(& state);< / span >
< span class = "lineNum" > 1312 < / span > :
< span class = "lineNum" > 1313 < / span > < span class = "lineCov" > 87 : memory();< / span >
< span class = "lineNum" > 1314 < / span > :
< span class = "lineNum" > 1315 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1316 < / span > < span class = "lineCov" > 87 : signal_init();< / span >
< span class = "lineNum" > 1317 < / span > :
< span class = "lineNum" > 1318 < / span > : /* run a test command if required */
< span class = "lineNum" > 1319 < / span > < span class = "lineCov" > 87 : if (run != 0) {< / span >
< span class = "lineNum" > 1320 < / span > < span class = "lineCov" > 10 : ret = system(run); /* ignore error */< / span >
< span class = "lineNum" > 1321 < / span > < span class = "lineCov" > 10 : if (ret != 0) {< / span >
< span class = "lineNum" > 1322 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1323 < / span > : log_fatal(" Error in running command '%s'.\n" , run);
< span class = "lineNum" > 1324 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1325 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1326 < / span > : }
< span class = "lineNum" > 1327 < / span > : }
< span class = "lineNum" > 1328 < / span > :
< span class = "lineNum" > 1329 < / span > : /* waits some time to ensure that any concurrent modification done at the files, */
< span class = "lineNum" > 1330 < / span > : /* using the same mtime read by the scan process, will be read by sync. */
< span class = "lineNum" > 1331 < / span > : /* Note that any later modification done, potentially not read by sync, will have */
< span class = "lineNum" > 1332 < / span > : /* a different mtime, and it will be synchronized at the next sync. */
< span class = "lineNum" > 1333 < / span > : /* The worst case is the FAT file-system with a two seconds resolution for mtime. */
< span class = "lineNum" > 1334 < / span > : /* If you don't use FAT, the wait is not needed, because most file-systems have now */
< span class = "lineNum" > 1335 < / span > : /* at least microseconds resolution, but better to be safe. */
< span class = "lineNum" > 1336 < / span > < span class = "lineCov" > 87 : if (!opt.skip_self)< / span >
< span class = "lineNum" > 1337 < / span > < span class = "lineNoCov" > 0 : sleep(2);< / span >
< span class = "lineNum" > 1338 < / span > :
< span class = "lineNum" > 1339 < / span > < span class = "lineCov" > 87 : ret = state_sync(& state, blockstart, blockcount);< / span >
< span class = "lineNum" > 1340 < / span > :
< span class = "lineNum" > 1341 < / span > : /* save the new state if required */
< span class = "lineNum" > 1342 < / span > < span class = "lineCov" > 87 : if (!opt.kill_after_sync) {< / span >
< span class = "lineNum" > 1343 < / span > < span class = "lineCov" > 77 : if ((state.need_write || state.opt.force_content_write))< / span >
< span class = "lineNum" > 1344 < / span > < span class = "lineCov" > 58 : state_write(& state);< / span >
< span class = "lineNum" > 1345 < / span > : } else {
< span class = "lineNum" > 1346 < / span > < span class = "lineCov" > 10 : log_fatal(" WARNING! Skipped state write for --test-kill-after-sync option.\n" );< / span >
< span class = "lineNum" > 1347 < / span > : }
< span class = "lineNum" > 1348 < / span > :
< span class = "lineNum" > 1349 < / span > : /* abort if required */
< span class = "lineNum" > 1350 < / span > < span class = "lineCov" > 87 : if (ret != 0) {< / span >
< span class = "lineNum" > 1351 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1352 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1353 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1354 < / span > : }
< span class = "lineNum" > 1355 < / span > < span class = "lineCov" > 168 : } else if (operation == OPERATION_DRY) {< / span >
< span class = "lineNum" > 1356 < / span > < span class = "lineCov" > 2 : state_read(& state);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1357 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1358 < / span > : /* filter */
< span class = "lineNum" > 1359 < / span > < span class = "lineCov" > 2 : state_skip(& state);< / span >
< span class = "lineNum" > 1360 < / span > < span class = "lineCov" > 2 : state_filter(& state, & filterlist_file, & filterlist_disk, filter_missing, filter_error);< / span >
< span class = "lineNum" > 1361 < / span > :
< span class = "lineNum" > 1362 < / span > < span class = "lineCov" > 2 : memory();< / span >
< span class = "lineNum" > 1363 < / span > :
< span class = "lineNum" > 1364 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1365 < / span > < span class = "lineCov" > 2 : signal_init();< / span >
< span class = "lineNum" > 1366 < / span > :
< span class = "lineNum" > 1367 < / span > < span class = "lineCov" > 2 : state_dry(& state, blockstart, blockcount);< / span >
< span class = "lineNum" > 1368 < / span > < span class = "lineCov" > 166 : } else if (operation == OPERATION_REHASH) {< / span >
< span class = "lineNum" > 1369 < / span > < span class = "lineCov" > 1 : state_read(& state);< / span >
< span class = "lineNum" > 1370 < / span > :
< span class = "lineNum" > 1371 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1372 < / span > < span class = "lineCov" > 1 : signal_init();< / span >
< span class = "lineNum" > 1373 < / span > :
< span class = "lineNum" > 1374 < / span > < span class = "lineCov" > 1 : state_rehash(& state);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1375 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1376 < / span > : /* save the new state if required */
< span class = "lineNum" > 1377 < / span > < span class = "lineCov" > 1 : if (state.need_write)< / span >
< span class = "lineNum" > 1378 < / span > < span class = "lineCov" > 1 : state_write(& state);< / span >
< span class = "lineNum" > 1379 < / span > < span class = "lineCov" > 165 : } else if (operation == OPERATION_SCRUB) {< / span >
< span class = "lineNum" > 1380 < / span > < span class = "lineCov" > 11 : state_read(& state);< / span >
< span class = "lineNum" > 1381 < / span > :
< span class = "lineNum" > 1382 < / span > < span class = "lineCov" > 11 : memory();< / span >
< span class = "lineNum" > 1383 < / span > :
< span class = "lineNum" > 1384 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1385 < / span > < span class = "lineCov" > 11 : signal_init();< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1386 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1387 < / span > < span class = "lineCov" > 11 : ret = state_scrub(& state, plan, olderthan);< / span >
< span class = "lineNum" > 1388 < / span > :
< span class = "lineNum" > 1389 < / span > : /* save the new state if required */
< span class = "lineNum" > 1390 < / span > < span class = "lineCov" > 11 : if (state.need_write || state.opt.force_content_write)< / span >
< span class = "lineNum" > 1391 < / span > < span class = "lineCov" > 10 : state_write(& state);< / span >
< span class = "lineNum" > 1392 < / span > :
< span class = "lineNum" > 1393 < / span > : /* abort if required */
< span class = "lineNum" > 1394 < / span > < span class = "lineCov" > 11 : if (ret != 0) {< / span >
< span class = "lineNum" > 1395 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1396 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1397 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1398 < / span > : }
< span class = "lineNum" > 1399 < / span > < span class = "lineCov" > 154 : } else if (operation == OPERATION_REWRITE) {< / span >
< span class = "lineNum" > 1400 < / span > < span class = "lineCov" > 1 : state_read(& state);< / span >
< span class = "lineNum" > 1401 < / span > :
< span class = "lineNum" > 1402 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1403 < / span > < span class = "lineCov" > 1 : signal_init();< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1404 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1405 < / span > < span class = "lineCov" > 1 : state_write(& state);< / span >
< span class = "lineNum" > 1406 < / span > :
< span class = "lineNum" > 1407 < / span > < span class = "lineCov" > 1 : memory();< / span >
< span class = "lineNum" > 1408 < / span > < span class = "lineCov" > 153 : } else if (operation == OPERATION_READ) {< / span >
< span class = "lineNum" > 1409 < / span > < span class = "lineCov" > 1 : state_read(& state);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1410 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1411 < / span > < span class = "lineCov" > 1 : memory();< / span >
< span class = "lineNum" > 1412 < / span > < span class = "lineCov" > 152 : } else if (operation == OPERATION_TOUCH) {< / span >
< span class = "lineNum" > 1413 < / span > < span class = "lineCov" > 1 : state_read(& state);< / span >
< span class = "lineNum" > 1414 < / span > :
< span class = "lineNum" > 1415 < / span > < span class = "lineCov" > 1 : state_touch(& state);< / span >
< span class = "lineNum" > 1416 < / span > :
< span class = "lineNum" > 1417 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1418 < / span > < span class = "lineCov" > 1 : signal_init();< / span >
< span class = "lineNum" > 1419 < / span > :
< span class = "lineNum" > 1420 < / span > < span class = "lineCov" > 1 : state_write(& state);< / span >
< span class = "lineNum" > 1421 < / span > :
< span class = "lineNum" > 1422 < / span > < span class = "lineCov" > 1 : memory();< / span >
< span class = "lineNum" > 1423 < / span > < span class = "lineCov" > 151 : } else if (operation == OPERATION_SPINUP) {< / span >
< span class = "lineNum" > 1424 < / span > < span class = "lineCov" > 1 : state_device(& state, DEVICE_UP, & filterlist_disk);< / span >
< span class = "lineNum" > 1425 < / span > < span class = "lineCov" > 150 : } else if (operation == OPERATION_SPINDOWN) {< / span >
< span class = "lineNum" > 1426 < / span > < span class = "lineCov" > 1 : state_device(& state, DEVICE_DOWN, & filterlist_disk);< / span >
< span class = "lineNum" > 1427 < / span > < span class = "lineCov" > 149 : } else if (operation == OPERATION_DEVICES) {< / span >
< span class = "lineNum" > 1428 < / span > < span class = "lineCov" > 1 : state_device(& state, DEVICE_LIST, 0);< / span >
< span class = "lineNum" > 1429 < / span > < span class = "lineCov" > 148 : } else if (operation == OPERATION_SMART) {< / span >
< span class = "lineNum" > 1430 < / span > < span class = "lineCov" > 2 : state_device(& state, DEVICE_SMART, 0);< / span >
< span class = "lineNum" > 1431 < / span > < span class = "lineCov" > 146 : } else if (operation == OPERATION_STATUS) {< / span >
< span class = "lineNum" > 1432 < / span > < span class = "lineCov" > 15 : state_read(& state);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1433 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1434 < / span > < span class = "lineCov" > 15 : memory();< / span >
< span class = "lineNum" > 1435 < / span > :
< span class = "lineNum" > 1436 < / span > < span class = "lineCov" > 15 : state_status(& state);< / span >
< span class = "lineNum" > 1437 < / span > < span class = "lineCov" > 131 : } else if (operation == OPERATION_DUP) {< / span >
< span class = "lineNum" > 1438 < / span > < span class = "lineCov" > 3 : state_read(& state);< / span >
< span class = "lineNum" > 1439 < / span > :
< span class = "lineNum" > 1440 < / span > < span class = "lineCov" > 3 : state_dup(& state);< / span >
< span class = "lineNum" > 1441 < / span > < span class = "lineCov" > 128 : } else if (operation == OPERATION_LIST) {< / span >
< span class = "lineNum" > 1442 < / span > < span class = "lineCov" > 5 : state_read(& state);< / span >
< span class = "lineNum" > 1443 < / span > :
< span class = "lineNum" > 1444 < / span > < span class = "lineCov" > 5 : state_list(& state);< / span >
< span class = "lineNum" > 1445 < / span > < span class = "lineCov" > 123 : } else if (operation == OPERATION_POOL) {< / span >
< span class = "lineNum" > 1446 < / span > < span class = "lineCov" > 3 : state_read(& state);< / span >
< span class = "lineNum" > 1447 < / span > :
< span class = "lineNum" > 1448 < / span > < span class = "lineCov" > 3 : state_pool(& state);< / span >
< span class = "lineNum" > 1449 < / span > : } else {
< span class = "lineNum" > 1450 < / span > < span class = "lineCov" > 120 : state_read(& state);< / span >
< span class = "lineNum" > 1451 < / span > :
< span class = "lineNum" > 1452 < / span > : /* if we are also trying to recover */
< span class = "lineNum" > 1453 < / span > < span class = "lineCov" > 120 : if (!state.opt.auditonly) {< / span >
< span class = "lineNum" > 1454 < / span > : /* import the user specified dirs */
< span class = "lineNum" > 1455 < / span > < span class = "lineCov" > 114 : if (import_timestamp != 0)< / span >
< span class = "lineNum" > 1456 < / span > < span class = "lineCov" > 1 : state_search(& state, import_timestamp);< / span >
< span class = "lineNum" > 1457 < / span > < span class = "lineCov" > 114 : if (import_content != 0)< / span >
< span class = "lineNum" > 1458 < / span > < span class = "lineCov" > 1 : state_import(& state, import_content);< / span >
< span class = "lineNum" > 1459 < / span > :
< span class = "lineNum" > 1460 < / span > : /* import from all the array */
< span class = "lineNum" > 1461 < / span > < span class = "lineCov" > 114 : if (!state.opt.force_nocopy)< / span >
< span class = "lineNum" > 1462 < / span > < span class = "lineCov" > 114 : state_search_array(& state);< / span >
< span class = "lineNum" > 1463 < / span > : }
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1464 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1465 < / span > : /* filter */
< span class = "lineNum" > 1466 < / span > < span class = "lineCov" > 120 : state_skip(& state);< / span >
< span class = "lineNum" > 1467 < / span > < span class = "lineCov" > 120 : state_filter(& state, & filterlist_file, & filterlist_disk, filter_missing, filter_error);< / span >
< span class = "lineNum" > 1468 < / span > :
< span class = "lineNum" > 1469 < / span > < span class = "lineCov" > 120 : memory();< / span >
< span class = "lineNum" > 1470 < / span > :
< span class = "lineNum" > 1471 < / span > : /* intercept signals while operating */
< span class = "lineNum" > 1472 < / span > < span class = "lineCov" > 120 : signal_init();< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1473 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1474 < / span > < span class = "lineCov" > 120 : if (operation == OPERATION_CHECK) {< / span >
< span class = "lineNum" > 1475 < / span > < span class = "lineCov" > 75 : ret = state_check(& state, 0, blockstart, blockcount);< / span >
< span class = "lineNum" > 1476 < / span > : } else { /* it's fix */
< span class = "lineNum" > 1477 < / span > < span class = "lineCov" > 45 : ret = state_check(& state, 1, blockstart, blockcount);< / span >
< span class = "lineNum" > 1478 < / span > : }
< span class = "lineNum" > 1479 < / span > :
< span class = "lineNum" > 1480 < / span > : /* abort if required */
< span class = "lineNum" > 1481 < / span > < span class = "lineCov" > 120 : if (ret != 0) {< / span >
< span class = "lineNum" > 1482 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1483 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1484 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1485 < / span > : }
< span class = "lineNum" > 1486 < / span > : }
< span class = "lineNum" > 1487 < / span > :
< span class = "lineNum" > 1488 < / span > : /* close log file */
< span class = "lineNum" > 1489 < / span > < span class = "lineCov" > 243 : log_close(log_file);< / span >
< span class = "lineNum" > 1490 < / span > :
< span class = "lineNum" > 1491 < / span > : #if HAVE_LOCKFILE
< span class = "lineNum" > 1492 < / span > < span class = "lineCov" > 243 : if (!opt.skip_lock & & state.lockfile[0]) {< / span >
< span class = "lineNum" > 1493 < / span > < span class = "lineCov" > 241 : if (lock_unlock(lock) == -1) {< / span >
< span class = "lineNum" > 1494 < / span > : /* LCOV_EXCL_START */
< span class = "lineNum" > 1495 < / span > : log_fatal(" Error closing the lock file '%s'. %s.\n" , state.lockfile, strerror(errno));
< span class = "lineNum" > 1496 < / span > : exit(EXIT_FAILURE);
< span class = "lineNum" > 1497 < / span > : /* LCOV_EXCL_STOP */
< span class = "lineNum" > 1498 < / span > : }
< span class = "lineNum" > 1499 < / span > : }
< span class = "lineNum" > 1500 < / span > : #endif
< span class = "lineNum" > 1501 < / span > :
< span class = "lineNum" > 1502 < / span > < span class = "lineCov" > 243 : state_done(& state);< / span >
< span class = "lineNum" > 1503 < / span > < span class = "lineCov" > 243 : tommy_list_foreach(& filterlist_file, (tommy_foreach_func*)filter_free);< / span >
< span class = "lineNum" > 1504 < / span > < span class = "lineCov" > 243 : tommy_list_foreach(& filterlist_disk, (tommy_foreach_func*)filter_free);< / span >
2016-11-06 18:12:17 +01:00
< span class = "lineNum" > 1505 < / span > :
2016-11-21 19:48:21 +01:00
< span class = "lineNum" > 1506 < / span > < span class = "lineCov" > 243 : os_done();< / span >
< span class = "lineNum" > 1507 < / span > < span class = "lineCov" > 243 : lock_done();< / span >
< span class = "lineNum" > 1508 < / span > :
< span class = "lineNum" > 1509 < / span > < span class = "lineCov" > 243 : return EXIT_SUCCESS;< / span >
< span class = "lineNum" > 1510 < / span > : }
< span class = "lineNum" > 1511 < / span > :
2011-03-01 22:19:30 +01:00
< / pre >
< / td >
< / tr >
< / table >
< br >
< table width = "100%" border = 0 cellspacing = 0 cellpadding = 0 >
< tr > < td class = "ruler" > < img src = "../glass.png" width = 3 height = 3 alt = "" > < / td > < / tr >
< tr > < td class = "versionInfo" > Generated by: < a href = "http://ltp.sourceforge.net/coverage/lcov.php" target = "_parent" > LCOV version 1.10< / a > < / td > < / tr >
< / table >
< br >
< / body >
< / html >