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

Auto update

Browse source
This commit is contained in:
Andrea Mazzoleni 2016-11-06 19:57:56 +01:00
parent 4db5a06233
commit 2752f8ef22
146 changed files with 8250 additions and 8210 deletions
Download patch file Download diff file Expand all files Collapse all files

12
cov/cmdline/check.c.func-sort-c.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">709</td>
<td class="headerCovTableEntry">781</td>
<td class="headerCovTableEntryHi">90.8 %</td>
<td class="headerCovTableEntry">775</td>
<td class="headerCovTableEntryHi">91.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -73,18 +73,18 @@
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#68">blockcmp</a></td>
<td class="coverFnHi">473403</td>
<td class="coverFnHi">473381</td>
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#160">repair_step</a></td>
<td class="coverFnHi">252742</td>
<td class="coverFnHi">252815</td>
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#97">is_hash_matching</a></td>
<td class="coverFnHi">214689</td>
<td class="coverFnHi">214888</td>
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#1910">state_check</a></td>
<td class="coverFn"><a href="check.c.gcov.html#1914">state_check</a></td>
<td class="coverFnHi">120</td>
</tr>
<tr>

12
cov/cmdline/check.c.func.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">709</td>
<td class="headerCovTableEntry">781</td>
<td class="headerCovTableEntryHi">90.8 %</td>
<td class="headerCovTableEntry">775</td>
<td class="headerCovTableEntryHi">91.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -65,7 +65,7 @@
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#68">blockcmp</a></td>
<td class="coverFnHi">473403</td>
<td class="coverFnHi">473381</td>
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#595">file_post</a></td>
@ -73,7 +73,7 @@
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#97">is_hash_matching</a></td>
<td class="coverFnHi">214689</td>
<td class="coverFnHi">214888</td>
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#140">is_parity_matching</a></td>
@ -85,10 +85,10 @@
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#160">repair_step</a></td>
<td class="coverFnHi">252742</td>
<td class="coverFnHi">252815</td>
</tr>
<tr>
<td class="coverFn"><a href="check.c.gcov.html#1910">state_check</a></td>
<td class="coverFn"><a href="check.c.gcov.html#1914">state_check</a></td>
<td class="coverFnHi">120</td>
</tr>
<tr>

2524
cov/cmdline/check.c.gcov.html
View file

File diff suppressed because it is too large Load diff

10
cov/cmdline/dry.c.func-sort-c.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">120</td>
<td class="headerCovTableEntry">165</td>
<td class="headerCovTableEntryLo">72.7 %</td>
<td class="headerCovTableEntry">157</td>
<td class="headerCovTableEntryMed">76.4 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -61,18 +61,18 @@
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#139">dry_parity_reader</a></td>
<td class="coverFnHi">42604</td>
<td class="coverFnHi">42601</td>
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#40">dry_data_reader</a></td>
<td class="coverFnHi">42590</td>
<td class="coverFnHi">42596</td>
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#32">block_is_enabled</a></td>
<td class="coverFnHi">7102</td>
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#391">state_dry</a></td>
<td class="coverFn"><a href="dry.c.gcov.html#399">state_dry</a></td>
<td class="coverFnHi">2</td>
</tr>
<tr>

10
cov/cmdline/dry.c.func.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">120</td>
<td class="headerCovTableEntry">165</td>
<td class="headerCovTableEntryLo">72.7 %</td>
<td class="headerCovTableEntry">157</td>
<td class="headerCovTableEntryMed">76.4 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -65,14 +65,14 @@
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#40">dry_data_reader</a></td>
<td class="coverFnHi">42590</td>
<td class="coverFnHi">42596</td>
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#139">dry_parity_reader</a></td>
<td class="coverFnHi">42604</td>
<td class="coverFnHi">42601</td>
</tr>
<tr>
<td class="coverFn"><a href="dry.c.gcov.html#391">state_dry</a></td>
<td class="coverFn"><a href="dry.c.gcov.html#399">state_dry</a></td>
<td class="coverFnHi">2</td>
</tr>
<tr>

474
cov/cmdline/dry.c.gcov.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">120</td>
<td class="headerCovTableEntry">165</td>
<td class="headerCovTableEntryLo">72.7 %</td>
<td class="headerCovTableEntry">157</td>
<td class="headerCovTableEntryMed">76.4 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -101,30 +101,30 @@
<span class="lineNum"> 39 </span><span class="lineCov"> 7102 : return 1;</span>
<a name="40"><span class="lineNum"> 40 </span> : }</a>
<span class="lineNum"> 41 </span> :
<span class="lineNum"> 42 </span><span class="lineCov"> 42590 : static void dry_data_reader(struct snapraid_worker* worker, struct snapraid_task* task)</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 42596 : static void dry_data_reader(struct snapraid_worker* worker, struct snapraid_task* task)</span>
<span class="lineNum"> 43 </span> : {
<span class="lineNum"> 44 </span><span class="lineCov"> 42590 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 42590 : struct snapraid_state* state = io-&gt;state;</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 42590 : struct snapraid_handle* handle = worker-&gt;handle;</span>
<span class="lineNum"> 47 </span><span class="lineCov"> 42590 : struct snapraid_disk* disk = handle-&gt;disk;</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 42590 : block_off_t blockcur = task-&gt;position;</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 42590 : unsigned char* buffer = task-&gt;buffer;</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 42596 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 42596 : struct snapraid_state* state = io-&gt;state;</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 42596 : struct snapraid_handle* handle = worker-&gt;handle;</span>
<span class="lineNum"> 47 </span><span class="lineCov"> 42596 : struct snapraid_disk* disk = handle-&gt;disk;</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 42596 : block_off_t blockcur = task-&gt;position;</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 42596 : unsigned char* buffer = task-&gt;buffer;</span>
<span class="lineNum"> 50 </span> : int ret;
<span class="lineNum"> 51 </span> : char esc_buffer[ESC_MAX];
<span class="lineNum"> 52 </span> :
<span class="lineNum"> 53 </span> : /* if the disk position is not used */
<span class="lineNum"> 54 </span><span class="lineCov"> 42590 : if (!disk) {</span>
<span class="lineNum"> 54 </span><span class="lineCov"> 42596 : if (!disk) {</span>
<span class="lineNum"> 55 </span> : /* use an empty block */
<span class="lineNum"> 56 </span><span class="lineCov"> 4686 : memset(buffer, 0, state-&gt;block_size);</span>
<span class="lineNum"> 57 </span><span class="lineCov"> 4686 : task-&gt;state = TASK_STATE_DONE;</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 9916 : return;</span>
<span class="lineNum"> 56 </span><span class="lineCov"> 4687 : memset(buffer, 0, state-&gt;block_size);</span>
<span class="lineNum"> 57 </span><span class="lineCov"> 4687 : task-&gt;state = TASK_STATE_DONE;</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 9918 : return;</span>
<span class="lineNum"> 59 </span> : }
<span class="lineNum"> 60 </span> :
<span class="lineNum"> 61 </span> : /* get the block */
<span class="lineNum"> 62 </span><span class="lineCov"> 37904 : task-&gt;block = fs_par2block_find(disk, blockcur);</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 37909 : task-&gt;block = fs_par2block_find(disk, blockcur);</span>
<span class="lineNum"> 63 </span> :
<span class="lineNum"> 64 </span> : /* if the block is not used */
<span class="lineNum"> 65 </span><span class="lineCov"> 37878 : if (!block_has_file(task-&gt;block)) {</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 37865 : if (!block_has_file(task-&gt;block)) {</span>
<span class="lineNum"> 66 </span> : /* use an empty block */
<span class="lineNum"> 67 </span><span class="lineCov"> 544 : memset(buffer, 0, state-&gt;block_size);</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 544 : task-&gt;state = TASK_STATE_DONE;</span>
@ -132,14 +132,14 @@
<span class="lineNum"> 70 </span> : }
<span class="lineNum"> 71 </span> :
<span class="lineNum"> 72 </span> : /* get the file of this block */
<span class="lineNum"> 73 </span><span class="lineCov"> 37320 : task-&gt;file = fs_par2file_get(disk, blockcur, &amp;task-&gt;file_pos);</span>
<span class="lineNum"> 73 </span><span class="lineCov"> 37325 : task-&gt;file = fs_par2file_get(disk, blockcur, &amp;task-&gt;file_pos);</span>
<span class="lineNum"> 74 </span> :
<span class="lineNum"> 75 </span> : /* if the file is different than the current one, close it */
<span class="lineNum"> 76 </span><span class="lineCov"> 37335 : if (handle-&gt;file != 0 &amp;&amp; handle-&gt;file != task-&gt;file) {</span>
<span class="lineNum"> 76 </span><span class="lineCov"> 37355 : if (handle-&gt;file != 0 &amp;&amp; handle-&gt;file != task-&gt;file) {</span>
<span class="lineNum"> 77 </span> : /* keep a pointer at the file we are going to close for error reporting */
<span class="lineNum"> 78 </span><span class="lineCov"> 15082 : struct snapraid_file* report = handle-&gt;file;</span>
<span class="lineNum"> 79 </span><span class="lineCov"> 15082 : ret = handle_close(handle);</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 15071 : if (ret == -1) {</span>
<span class="lineNum"> 78 </span><span class="lineCov"> 15077 : struct snapraid_file* report = handle-&gt;file;</span>
<span class="lineNum"> 79 </span><span class="lineCov"> 15077 : ret = handle_close(handle);</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 15079 : if (ret == -1) {</span>
<span class="lineNum"> 81 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 82 </span> : /* This one is really an unexpected error, because we are only reading */
<span class="lineNum"> 83 </span> : /* and closing a descriptor should never fail */
@ -162,8 +162,8 @@
<span class="lineNum"> 100 </span> : }
<span class="lineNum"> 101 </span> : }
<span class="lineNum"> 102 </span> :
<span class="lineNum"> 103 </span><span class="lineCov"> 37324 : ret = handle_open(handle, task-&gt;file, state-&gt;file_mode, log_error, 0);</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 37350 : if (ret == -1) {</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 37357 : ret = handle_open(handle, task-&gt;file, state-&gt;file_mode, log_error, 0);</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 37369 : if (ret == -1) {</span>
<span class="lineNum"> 105 </span><span class="lineNoCov"> 0 : if (errno == EIO) {</span>
<span class="lineNum"> 106 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 107 </span> : log_tag(&quot;error:%u:%s:%s: Open EIO error. %s\n&quot;, blockcur, disk-&gt;name, esc_tag(task-&gt;file-&gt;sub, esc_buffer), strerror(errno));
@ -180,8 +180,8 @@
<span class="lineNum"> 118 </span><span class="lineNoCov"> 0 : return;</span>
<span class="lineNum"> 119 </span> : }
<span class="lineNum"> 120 </span> :
<span class="lineNum"> 121 </span><span class="lineCov"> 37350 : task-&gt;read_size = handle_read(handle, task-&gt;file_pos, buffer, state-&gt;block_size, log_error, 0);</span>
<span class="lineNum"> 122 </span><span class="lineCov"> 37281 : if (task-&gt;read_size == -1) {</span>
<span class="lineNum"> 121 </span><span class="lineCov"> 37369 : task-&gt;read_size = handle_read(handle, task-&gt;file_pos, buffer, state-&gt;block_size, log_error, 0);</span>
<span class="lineNum"> 122 </span><span class="lineCov"> 37250 : if (task-&gt;read_size == -1) {</span>
<span class="lineNum"> 123 </span><span class="lineNoCov"> 0 : if (errno == EIO) {</span>
<span class="lineNum"> 124 </span><span class="lineNoCov"> 0 : log_tag(&quot;error:%u:%s:%s: Read EIO error at position %u. %s\n&quot;, blockcur, disk-&gt;name, esc_tag(task-&gt;file-&gt;sub, esc_buffer), task-&gt;file_pos, strerror(errno));</span>
<span class="lineNum"> 125 </span><span class="lineNoCov"> 0 : log_error(&quot;Input/Output error in file '%s' at position '%u'\n&quot;, handle-&gt;path, task-&gt;file_pos);</span>
@ -195,24 +195,24 @@
<span class="lineNum"> 133 </span> : }
<span class="lineNum"> 134 </span> :
<span class="lineNum"> 135 </span> : /* store the path of the opened file */
<span class="lineNum"> 136 </span><span class="lineCov"> 37281 : pathcpy(task-&gt;path, sizeof(task-&gt;path), handle-&gt;path);</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 37250 : pathcpy(task-&gt;path, sizeof(task-&gt;path), handle-&gt;path);</span>
<span class="lineNum"> 137 </span> :
<span class="lineNum"> 138 </span><span class="lineCov"> 37299 : task-&gt;state = TASK_STATE_DONE;</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 37319 : task-&gt;state = TASK_STATE_DONE;</span>
<a name="139"><span class="lineNum"> 139 </span> : }</a>
<span class="lineNum"> 140 </span> :
<span class="lineNum"> 141 </span><span class="lineCov"> 42604 : static void dry_parity_reader(struct snapraid_worker* worker, struct snapraid_task* task)</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 42601 : static void dry_parity_reader(struct snapraid_worker* worker, struct snapraid_task* task)</span>
<span class="lineNum"> 142 </span> : {
<span class="lineNum"> 143 </span><span class="lineCov"> 42604 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 42604 : struct snapraid_state* state = io-&gt;state;</span>
<span class="lineNum"> 145 </span><span class="lineCov"> 42604 : struct snapraid_parity_handle* parity_handle = worker-&gt;parity_handle;</span>
<span class="lineNum"> 146 </span><span class="lineCov"> 42604 : unsigned level = parity_handle-&gt;level;</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 42604 : block_off_t blockcur = task-&gt;position;</span>
<span class="lineNum"> 148 </span><span class="lineCov"> 42604 : unsigned char* buffer = task-&gt;buffer;</span>
<span class="lineNum"> 143 </span><span class="lineCov"> 42601 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 42601 : struct snapraid_state* state = io-&gt;state;</span>
<span class="lineNum"> 145 </span><span class="lineCov"> 42601 : struct snapraid_parity_handle* parity_handle = worker-&gt;parity_handle;</span>
<span class="lineNum"> 146 </span><span class="lineCov"> 42601 : unsigned level = parity_handle-&gt;level;</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 42601 : block_off_t blockcur = task-&gt;position;</span>
<span class="lineNum"> 148 </span><span class="lineCov"> 42601 : unsigned char* buffer = task-&gt;buffer;</span>
<span class="lineNum"> 149 </span> : int ret;
<span class="lineNum"> 150 </span> :
<span class="lineNum"> 151 </span> : /* read the parity */
<span class="lineNum"> 152 </span><span class="lineCov"> 42604 : ret = parity_read(parity_handle, blockcur, buffer, state-&gt;block_size, log_error);</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 42568 : if (ret == -1) {</span>
<span class="lineNum"> 152 </span><span class="lineCov"> 42601 : ret = parity_read(parity_handle, blockcur, buffer, state-&gt;block_size, log_error);</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 42575 : if (ret == -1) {</span>
<span class="lineNum"> 154 </span><span class="lineNoCov"> 0 : if (errno == EIO) {</span>
<span class="lineNum"> 155 </span><span class="lineNoCov"> 0 : log_tag(&quot;parity_error:%u:%s: Read EIO error. %s\n&quot;, blockcur, lev_config_name(level), strerror(errno));</span>
<span class="lineNum"> 156 </span><span class="lineNoCov"> 0 : log_error(&quot;Input/Output error in parity '%s' at position '%u'\n&quot;, lev_config_name(level), blockcur);</span>
@ -225,7 +225,7 @@
<span class="lineNum"> 163 </span><span class="lineNoCov"> 0 : return;</span>
<span class="lineNum"> 164 </span> : }
<span class="lineNum"> 165 </span> :
<span class="lineNum"> 166 </span><span class="lineCov"> 42568 : task-&gt;state = TASK_STATE_DONE;</span>
<span class="lineNum"> 166 </span><span class="lineCov"> 42575 : task-&gt;state = TASK_STATE_DONE;</span>
<a name="167"><span class="lineNum"> 167 </span> : }</a>
<span class="lineNum"> 168 </span> :
<span class="lineNum"> 169 </span><span class="lineCov"> 2 : static int state_dry_process(struct snapraid_state* state, struct snapraid_parity_handle* parity_handle, block_off_t blockstart, block_off_t blockmax)</span>
@ -316,210 +316,218 @@
<span class="lineNum"> 254 </span> :
<span class="lineNum"> 255 </span> : /* handle error conditions */
<span class="lineNum"> 256 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_IOERROR) {</span>
<span class="lineNum"> 257 </span><span class="lineNoCov"> 0 : ++io_error;</span>
<span class="lineNum"> 258 </span><span class="lineNoCov"> 0 : goto bail;</span>
<span class="lineNum"> 259 </span> : }
<span class="lineNum"> 260 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_ERROR) {</span>
<span class="lineNum"> 261 </span><span class="lineNoCov"> 0 : ++error;</span>
<span class="lineNum"> 262 </span><span class="lineNoCov"> 0 : goto bail;</span>
<span class="lineNum"> 263 </span> : }
<span class="lineNum"> 264 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_ERROR_CONTINUE) {</span>
<span class="lineNum"> 265 </span><span class="lineNoCov"> 0 : ++error;</span>
<span class="lineNum"> 266 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 257 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 258 </span> : ++io_error;
<span class="lineNum"> 259 </span> : goto bail;
<span class="lineNum"> 260 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 261 </span> : }
<span class="lineNum"> 262 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_ERROR) {</span>
<span class="lineNum"> 263 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 264 </span> : ++error;
<span class="lineNum"> 265 </span> : goto bail;
<span class="lineNum"> 266 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 267 </span> : }
<span class="lineNum"> 268 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_IOERROR_CONTINUE) {</span>
<span class="lineNum"> 269 </span><span class="lineNoCov"> 0 : ++io_error;</span>
<span class="lineNum"> 270 </span><span class="lineNoCov"> 0 : if (io_error &gt;= state-&gt;opt.io_error_limit) {</span>
<span class="lineNum"> 271 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 272 </span> : log_fatal(&quot;DANGER! Too many input/output read error in a data disk, it isn't possible to scrub.\n&quot;);
<span class="lineNum"> 273 </span> : log_fatal(&quot;Ensure that disk '%s' is sane and that file '%s' can be accessed.\n&quot;, disk-&gt;dir, task-&gt;path);
<span class="lineNum"> 274 </span> : log_fatal(&quot;Stopping at block %u\n&quot;, blockcur);
<span class="lineNum"> 275 </span> : goto bail;
<span class="lineNum"> 276 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 277 </span> : }
<span class="lineNum"> 278 </span> :
<span class="lineNum"> 279 </span> : /* otherwise continue */
<span class="lineNum"> 280 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 281 </span> : }
<span class="lineNum"> 282 </span><span class="lineCov"> 37380 : if (task-&gt;state != TASK_STATE_DONE) {</span>
<span class="lineNum"> 283 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 284 </span> : log_fatal(&quot;Internal inconsistency in task state\n&quot;);
<span class="lineNum"> 285 </span> : os_abort();
<span class="lineNum"> 286 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 287 </span> : }
<span class="lineNum"> 288 </span> :
<span class="lineNum"> 289 </span><span class="lineCov"> 37380 : countsize += read_size;</span>
<span class="lineNum"> 290 </span> : }
<span class="lineNum"> 291 </span> :
<span class="lineNum"> 292 </span> : /* until now is misc */
<span class="lineNum"> 293 </span><span class="lineCov"> 7102 : state_usage_misc(state);</span>
<span class="lineNum"> 294 </span> :
<span class="lineNum"> 295 </span> : /* read the parity */
<span class="lineNum"> 296 </span><span class="lineCov"> 49714 : for (l = 0; l &lt; state-&gt;level; ++l) {</span>
<span class="lineNum"> 297 </span> : struct snapraid_task* task;
<span class="lineNum"> 298 </span> : unsigned levcur;
<span class="lineNum"> 299 </span> :
<span class="lineNum"> 300 </span><span class="lineCov"> 42612 : task = io_parity_read(&amp;io, &amp;levcur, waiting_map, &amp;waiting_mac);</span>
<span class="lineNum"> 301 </span> :
<span class="lineNum"> 302 </span> : /* until now is parity */
<span class="lineNum"> 303 </span><span class="lineCov"> 42612 : state_usage_parity(state, waiting_map, waiting_mac);</span>
<span class="lineNum"> 304 </span> :
<span class="lineNum"> 305 </span> : /* handle error conditions */
<span class="lineNum"> 306 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_IOERROR) {</span>
<span class="lineNum"> 307 </span><span class="lineNoCov"> 0 : ++io_error;</span>
<span class="lineNum"> 308 </span><span class="lineNoCov"> 0 : goto bail;</span>
<span class="lineNum"> 309 </span> : }
<span class="lineNum"> 310 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_ERROR) {</span>
<span class="lineNum"> 311 </span><span class="lineNoCov"> 0 : ++error;</span>
<span class="lineNum"> 312 </span><span class="lineNoCov"> 0 : goto bail;</span>
<span class="lineNum"> 313 </span> : }
<span class="lineNum"> 314 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_ERROR_CONTINUE) {</span>
<span class="lineNum"> 315 </span><span class="lineNoCov"> 0 : ++error;</span>
<span class="lineNum"> 316 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 317 </span> : }
<span class="lineNum"> 318 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_IOERROR_CONTINUE) {</span>
<span class="lineNum"> 319 </span><span class="lineNoCov"> 0 : ++io_error;</span>
<span class="lineNum"> 320 </span><span class="lineNoCov"> 0 : if (io_error &gt;= state-&gt;opt.io_error_limit) {</span>
<span class="lineNum"> 321 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 322 </span> : log_fatal(&quot;DANGER! Too many input/output read error in the %s disk, it isn't possible to scrub.\n&quot;, lev_name(levcur));
<span class="lineNum"> 323 </span> : log_fatal(&quot;Ensure that disk '%s' is sane and can be read.\n&quot;, lev_config_name(levcur));
<span class="lineNum"> 324 </span> : log_fatal(&quot;Stopping at block %u\n&quot;, blockcur);
<span class="lineNum"> 325 </span> : goto bail;
<span class="lineNum"> 326 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 327 </span> : }
<span class="lineNum"> 328 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 329 </span> : }
<span class="lineNum"> 330 </span><span class="lineCov"> 42612 : if (task-&gt;state != TASK_STATE_DONE) {</span>
<span class="lineNum"> 331 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 332 </span> : log_fatal(&quot;Internal inconsistency in task state\n&quot;);
<span class="lineNum"> 333 </span> : os_abort();
<span class="lineNum"> 334 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 335 </span> : }
<span class="lineNum"> 336 </span> : }
<span class="lineNum"> 337 </span> :
<span class="lineNum"> 338 </span> : /* count the number of processed block */
<span class="lineNum"> 339 </span><span class="lineCov"> 7102 : ++countpos;</span>
<span class="lineNum"> 340 </span> :
<span class="lineNum"> 341 </span> : /* progress */
<span class="lineNum"> 342 </span><span class="lineCov"> 7102 : if (state_progress(state, &amp;io, blockcur, countpos, countmax, countsize)) {</span>
<span class="lineNum"> 343 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 344 </span> : break;
<span class="lineNum"> 345 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 346 </span> : }
<span class="lineNum"> 347 </span><span class="lineCov"> 7102 : }</span>
<span class="lineNum"> 268 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_ERROR_CONTINUE) {</span>
<span class="lineNum"> 269 </span><span class="lineNoCov"> 0 : ++error;</span>
<span class="lineNum"> 270 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 271 </span> : }
<span class="lineNum"> 272 </span><span class="lineCov"> 37380 : if (task-&gt;state == TASK_STATE_IOERROR_CONTINUE) {</span>
<span class="lineNum"> 273 </span><span class="lineNoCov"> 0 : ++io_error;</span>
<span class="lineNum"> 274 </span><span class="lineNoCov"> 0 : if (io_error &gt;= state-&gt;opt.io_error_limit) {</span>
<span class="lineNum"> 275 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 276 </span> : log_fatal(&quot;DANGER! Too many input/output read error in a data disk, it isn't possible to scrub.\n&quot;);
<span class="lineNum"> 277 </span> : log_fatal(&quot;Ensure that disk '%s' is sane and that file '%s' can be accessed.\n&quot;, disk-&gt;dir, task-&gt;path);
<span class="lineNum"> 278 </span> : log_fatal(&quot;Stopping at block %u\n&quot;, blockcur);
<span class="lineNum"> 279 </span> : goto bail;
<span class="lineNum"> 280 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 281 </span> : }
<span class="lineNum"> 282 </span> :
<span class="lineNum"> 283 </span> : /* otherwise continue */
<span class="lineNum"> 284 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 285 </span> : }
<span class="lineNum"> 286 </span><span class="lineCov"> 37380 : if (task-&gt;state != TASK_STATE_DONE) {</span>
<span class="lineNum"> 287 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 288 </span> : log_fatal(&quot;Internal inconsistency in task state\n&quot;);
<span class="lineNum"> 289 </span> : os_abort();
<span class="lineNum"> 290 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 291 </span> : }
<span class="lineNum"> 292 </span> :
<span class="lineNum"> 293 </span><span class="lineCov"> 37380 : countsize += read_size;</span>
<span class="lineNum"> 294 </span> : }
<span class="lineNum"> 295 </span> :
<span class="lineNum"> 296 </span> : /* until now is misc */
<span class="lineNum"> 297 </span><span class="lineCov"> 7102 : state_usage_misc(state);</span>
<span class="lineNum"> 298 </span> :
<span class="lineNum"> 299 </span> : /* read the parity */
<span class="lineNum"> 300 </span><span class="lineCov"> 49714 : for (l = 0; l &lt; state-&gt;level; ++l) {</span>
<span class="lineNum"> 301 </span> : struct snapraid_task* task;
<span class="lineNum"> 302 </span> : unsigned levcur;
<span class="lineNum"> 303 </span> :
<span class="lineNum"> 304 </span><span class="lineCov"> 42612 : task = io_parity_read(&amp;io, &amp;levcur, waiting_map, &amp;waiting_mac);</span>
<span class="lineNum"> 305 </span> :
<span class="lineNum"> 306 </span> : /* until now is parity */
<span class="lineNum"> 307 </span><span class="lineCov"> 42612 : state_usage_parity(state, waiting_map, waiting_mac);</span>
<span class="lineNum"> 308 </span> :
<span class="lineNum"> 309 </span> : /* handle error conditions */
<span class="lineNum"> 310 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_IOERROR) {</span>
<span class="lineNum"> 311 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 312 </span> : ++io_error;
<span class="lineNum"> 313 </span> : goto bail;
<span class="lineNum"> 314 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 315 </span> : }
<span class="lineNum"> 316 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_ERROR) {</span>
<span class="lineNum"> 317 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 318 </span> : ++error;
<span class="lineNum"> 319 </span> : goto bail;
<span class="lineNum"> 320 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 321 </span> : }
<span class="lineNum"> 322 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_ERROR_CONTINUE) {</span>
<span class="lineNum"> 323 </span><span class="lineNoCov"> 0 : ++error;</span>
<span class="lineNum"> 324 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 325 </span> : }
<span class="lineNum"> 326 </span><span class="lineCov"> 42612 : if (task-&gt;state == TASK_STATE_IOERROR_CONTINUE) {</span>
<span class="lineNum"> 327 </span><span class="lineNoCov"> 0 : ++io_error;</span>
<span class="lineNum"> 328 </span><span class="lineNoCov"> 0 : if (io_error &gt;= state-&gt;opt.io_error_limit) {</span>
<span class="lineNum"> 329 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 330 </span> : log_fatal(&quot;DANGER! Too many input/output read error in the %s disk, it isn't possible to scrub.\n&quot;, lev_name(levcur));
<span class="lineNum"> 331 </span> : log_fatal(&quot;Ensure that disk '%s' is sane and can be read.\n&quot;, lev_config_name(levcur));
<span class="lineNum"> 332 </span> : log_fatal(&quot;Stopping at block %u\n&quot;, blockcur);
<span class="lineNum"> 333 </span> : goto bail;
<span class="lineNum"> 334 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 335 </span> : }
<span class="lineNum"> 336 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 337 </span> : }
<span class="lineNum"> 338 </span><span class="lineCov"> 42612 : if (task-&gt;state != TASK_STATE_DONE) {</span>
<span class="lineNum"> 339 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 340 </span> : log_fatal(&quot;Internal inconsistency in task state\n&quot;);
<span class="lineNum"> 341 </span> : os_abort();
<span class="lineNum"> 342 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 343 </span> : }
<span class="lineNum"> 344 </span> : }
<span class="lineNum"> 345 </span> :
<span class="lineNum"> 346 </span> : /* count the number of processed block */
<span class="lineNum"> 347 </span><span class="lineCov"> 7102 : ++countpos;</span>
<span class="lineNum"> 348 </span> :
<span class="lineNum"> 349 </span><span class="lineCov"> 2 : state_progress_end(state, countpos, countmax, countsize);</span>
<span class="lineNum"> 350 </span> :
<span class="lineNum"> 351 </span><span class="lineCov"> 2 : state_usage_print(state);</span>
<span class="lineNum"> 352 </span> :
<span class="lineNum"> 353 </span> : bail:
<span class="lineNum"> 354 </span> : /* stop all the worker threads */
<span class="lineNum"> 355 </span><span class="lineCov"> 2 : io_stop(&amp;io);</span>
<span class="lineNum"> 349 </span> : /* progress */
<span class="lineNum"> 350 </span><span class="lineCov"> 7102 : if (state_progress(state, &amp;io, blockcur, countpos, countmax, countsize)) {</span>
<span class="lineNum"> 351 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 352 </span> : break;
<span class="lineNum"> 353 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 354 </span> : }
<span class="lineNum"> 355 </span><span class="lineCov"> 7102 : }</span>
<span class="lineNum"> 356 </span> :
<span class="lineNum"> 357 </span><span class="lineCov"> 14 : for (j = 0; j &lt; diskmax; ++j) {</span>
<span class="lineNum"> 358 </span><span class="lineCov"> 12 : struct snapraid_file* file = handle[j].file;</span>
<span class="lineNum"> 359 </span><span class="lineCov"> 12 : struct snapraid_disk* disk = handle[j].disk;</span>
<span class="lineNum"> 360 </span><span class="lineCov"> 12 : ret = handle_close(&amp;handle[j]);</span>
<span class="lineNum"> 361 </span><span class="lineCov"> 12 : if (ret == -1) {</span>
<span class="lineNum"> 362 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 363 </span> : log_tag(&quot;error:%u:%s:%s: Close error. %s\n&quot;, blockmax, disk-&gt;name, esc_tag(file-&gt;sub, esc_buffer), strerror(errno));
<span class="lineNum"> 364 </span> : log_fatal(&quot;DANGER! Unexpected close error in a data disk.\n&quot;);
<span class="lineNum"> 365 </span> : ++error;
<span class="lineNum"> 366 </span> : /* continue, as we are already exiting */
<span class="lineNum"> 367 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 368 </span> : }
<span class="lineNum"> 369 </span> : }
<span class="lineNum"> 370 </span> :
<span class="lineNum"> 371 </span><span class="lineCov"> 2 : if (error || io_error) {</span>
<span class="lineNum"> 372 </span><span class="lineNoCov"> 0 : msg_status(&quot;\n&quot;);</span>
<span class="lineNum"> 373 </span><span class="lineNoCov"> 0 : msg_status(&quot;%8u file errors\n&quot;, error);</span>
<span class="lineNum"> 374 </span><span class="lineNoCov"> 0 : msg_status(&quot;%8u io errors\n&quot;, io_error);</span>
<span class="lineNum"> 375 </span> : } else {
<span class="lineNum"> 376 </span><span class="lineCov"> 2 : msg_status(&quot;Everything OK\n&quot;);</span>
<span class="lineNum"> 357 </span><span class="lineCov"> 2 : state_progress_end(state, countpos, countmax, countsize);</span>
<span class="lineNum"> 358 </span> :
<span class="lineNum"> 359 </span><span class="lineCov"> 2 : state_usage_print(state);</span>
<span class="lineNum"> 360 </span> :
<span class="lineNum"> 361 </span> : bail:
<span class="lineNum"> 362 </span> : /* stop all the worker threads */
<span class="lineNum"> 363 </span><span class="lineCov"> 2 : io_stop(&amp;io);</span>
<span class="lineNum"> 364 </span> :
<span class="lineNum"> 365 </span><span class="lineCov"> 14 : for (j = 0; j &lt; diskmax; ++j) {</span>
<span class="lineNum"> 366 </span><span class="lineCov"> 12 : struct snapraid_file* file = handle[j].file;</span>
<span class="lineNum"> 367 </span><span class="lineCov"> 12 : struct snapraid_disk* disk = handle[j].disk;</span>
<span class="lineNum"> 368 </span><span class="lineCov"> 12 : ret = handle_close(&amp;handle[j]);</span>
<span class="lineNum"> 369 </span><span class="lineCov"> 12 : if (ret == -1) {</span>
<span class="lineNum"> 370 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 371 </span> : log_tag(&quot;error:%u:%s:%s: Close error. %s\n&quot;, blockmax, disk-&gt;name, esc_tag(file-&gt;sub, esc_buffer), strerror(errno));
<span class="lineNum"> 372 </span> : log_fatal(&quot;DANGER! Unexpected close error in a data disk.\n&quot;);
<span class="lineNum"> 373 </span> : ++error;
<span class="lineNum"> 374 </span> : /* continue, as we are already exiting */
<span class="lineNum"> 375 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 376 </span> : }
<span class="lineNum"> 377 </span> : }
<span class="lineNum"> 378 </span> :
<span class="lineNum"> 379 </span><span class="lineCov"> 2 : if (error)</span>
<span class="lineNum"> 380 </span><span class="lineNoCov"> 0 : log_fatal(&quot;DANGER! Unexpected errors!\n&quot;);</span>
<span class="lineNum"> 381 </span><span class="lineCov"> 2 : if (io_error)</span>
<span class="lineNum"> 382 </span><span class="lineNoCov"> 0 : log_fatal(&quot;DANGER! Unexpected input/output errors!\n&quot;);</span>
<span class="lineNum"> 383 </span> :
<span class="lineNum"> 384 </span><span class="lineCov"> 2 : free(handle);</span>
<span class="lineNum"> 385 </span><span class="lineCov"> 2 : free(waiting_map);</span>
<span class="lineNum"> 386 </span><span class="lineCov"> 2 : io_done(&amp;io);</span>
<span class="lineNum"> 387 </span> :
<span class="lineNum"> 388 </span><span class="lineCov"> 2 : if (error + io_error != 0)</span>
<span class="lineNum"> 389 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 390 </span><span class="lineCov"> 2 : return 0;</span>
<a name="391"><span class="lineNum"> 391 </span> : }</a>
<span class="lineNum"> 392 </span> :
<span class="lineNum"> 393 </span><span class="lineCov"> 2 : void state_dry(struct snapraid_state* state, block_off_t blockstart, block_off_t blockcount)</span>
<span class="lineNum"> 394 </span> : {
<span class="lineNum"> 395 </span> : block_off_t blockmax;
<span class="lineNum"> 396 </span> : int ret;
<span class="lineNum"> 397 </span> : struct snapraid_parity_handle parity_handle[LEV_MAX];
<span class="lineNum"> 398 </span> : unsigned error;
<span class="lineNum"> 399 </span> : unsigned l;
<span class="lineNum"> 379 </span><span class="lineCov"> 2 : if (error || io_error) {</span>
<span class="lineNum"> 380 </span><span class="lineNoCov"> 0 : msg_status(&quot;\n&quot;);</span>
<span class="lineNum"> 381 </span><span class="lineNoCov"> 0 : msg_status(&quot;%8u file errors\n&quot;, error);</span>
<span class="lineNum"> 382 </span><span class="lineNoCov"> 0 : msg_status(&quot;%8u io errors\n&quot;, io_error);</span>
<span class="lineNum"> 383 </span> : } else {
<span class="lineNum"> 384 </span><span class="lineCov"> 2 : msg_status(&quot;Everything OK\n&quot;);</span>
<span class="lineNum"> 385 </span> : }
<span class="lineNum"> 386 </span> :
<span class="lineNum"> 387 </span><span class="lineCov"> 2 : if (error)</span>
<span class="lineNum"> 388 </span><span class="lineNoCov"> 0 : log_fatal(&quot;DANGER! Unexpected errors!\n&quot;);</span>
<span class="lineNum"> 389 </span><span class="lineCov"> 2 : if (io_error)</span>
<span class="lineNum"> 390 </span><span class="lineNoCov"> 0 : log_fatal(&quot;DANGER! Unexpected input/output errors!\n&quot;);</span>
<span class="lineNum"> 391 </span> :
<span class="lineNum"> 392 </span><span class="lineCov"> 2 : free(handle);</span>
<span class="lineNum"> 393 </span><span class="lineCov"> 2 : free(waiting_map);</span>
<span class="lineNum"> 394 </span><span class="lineCov"> 2 : io_done(&amp;io);</span>
<span class="lineNum"> 395 </span> :
<span class="lineNum"> 396 </span><span class="lineCov"> 2 : if (error + io_error != 0)</span>
<span class="lineNum"> 397 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 398 </span><span class="lineCov"> 2 : return 0;</span>
<a name="399"><span class="lineNum"> 399 </span> : }</a>
<span class="lineNum"> 400 </span> :
<span class="lineNum"> 401 </span><span class="lineCov"> 2 : msg_progress(&quot;Drying...\n&quot;);</span>
<span class="lineNum"> 402 </span> :
<span class="lineNum"> 403 </span><span class="lineCov"> 2 : blockmax = parity_allocated_size(state);</span>
<span class="lineNum"> 404 </span> :
<span class="lineNum"> 405 </span><span class="lineCov"> 2 : if (blockstart &gt; blockmax) {</span>
<span class="lineNum"> 406 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 407 </span> : log_fatal(&quot;Error in the specified starting block %u. It's bigger than the parity size %u.\n&quot;, blockstart, blockmax);
<span class="lineNum"> 408 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 409 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 410 </span> : }
<span class="lineNum"> 411 </span> :
<span class="lineNum"> 412 </span> : /* adjust the number of block to process */
<span class="lineNum"> 413 </span><span class="lineCov"> 2 : if (blockcount != 0 &amp;&amp; blockstart + blockcount &lt; blockmax) {</span>
<span class="lineNum"> 414 </span><span class="lineNoCov"> 0 : blockmax = blockstart + blockcount;</span>
<span class="lineNum"> 415 </span> : }
<span class="lineNum"> 416 </span> :
<span class="lineNum"> 417 </span> : /* open the file for reading */
<span class="lineNum"> 418 </span> : /* it may fail if the file doesn't exist, in this case we continue to dry the files */
<span class="lineNum"> 419 </span><span class="lineCov"> 14 : for (l = 0; l &lt; state-&gt;level; ++l) {</span>
<span class="lineNum"> 420 </span><span class="lineCov"> 12 : ret = parity_open(&amp;parity_handle[l], &amp;state-&gt;parity[l], l, state-&gt;file_mode, state-&gt;block_size, state-&gt;opt.parity_limit_size);</span>
<span class="lineNum"> 421 </span><span class="lineCov"> 12 : if (ret == -1) {</span>
<span class="lineNum"> 422 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 423 </span> : log_fatal(&quot;WARNING! Without an accessible %s file, it isn't possible to dry.\n&quot;, lev_name(l));
<span class="lineNum"> 424 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 425 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 426 </span> : }
<span class="lineNum"> 427 </span> : }
<span class="lineNum"> 428 </span> :
<span class="lineNum"> 429 </span><span class="lineCov"> 2 : error = 0;</span>
<span class="lineNum"> 430 </span> :
<span class="lineNum"> 431 </span> : /* skip degenerated cases of empty parity, or skipping all */
<span class="lineNum"> 432 </span><span class="lineCov"> 2 : if (blockstart &lt; blockmax) {</span>
<span class="lineNum"> 433 </span><span class="lineCov"> 2 : ret = state_dry_process(state, parity_handle, blockstart, blockmax);</span>
<span class="lineNum"> 434 </span><span class="lineCov"> 2 : if (ret == -1) {</span>
<span class="lineNum"> 435 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 436 </span> : ++error;
<span class="lineNum"> 437 </span> : /* continue, as we are already exiting */
<span class="lineNum"> 438 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 439 </span> : }
<span class="lineNum"> 440 </span> : }
<span class="lineNum"> 441 </span> :
<span class="lineNum"> 442 </span> : /* try to close only if opened */
<span class="lineNum"> 443 </span><span class="lineCov"> 14 : for (l = 0; l &lt; state-&gt;level; ++l) {</span>
<span class="lineNum"> 444 </span><span class="lineCov"> 12 : ret = parity_close(&amp;parity_handle[l]);</span>
<span class="lineNum"> 445 </span><span class="lineCov"> 12 : if (ret == -1) {</span>
<span class="lineNum"> 446 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 447 </span> : ++error;
<span class="lineNum"> 448 </span> : /* continue, as we are already exiting */
<span class="lineNum"> 449 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 450 </span> : }
<span class="lineNum"> 451 </span> : }
<span class="lineNum"> 452 </span> :
<span class="lineNum"> 453 </span> : /* abort if required */
<span class="lineNum"> 454 </span><span class="lineCov"> 2 : if (error != 0) {</span>
<span class="lineNum"> 455 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 456 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 457 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 458 </span> : }
<span class="lineNum"> 459 </span><span class="lineCov"> 2 : }</span>
<span class="lineNum"> 401 </span><span class="lineCov"> 2 : void state_dry(struct snapraid_state* state, block_off_t blockstart, block_off_t blockcount)</span>
<span class="lineNum"> 402 </span> : {
<span class="lineNum"> 403 </span> : block_off_t blockmax;
<span class="lineNum"> 404 </span> : int ret;
<span class="lineNum"> 405 </span> : struct snapraid_parity_handle parity_handle[LEV_MAX];
<span class="lineNum"> 406 </span> : unsigned error;
<span class="lineNum"> 407 </span> : unsigned l;
<span class="lineNum"> 408 </span> :
<span class="lineNum"> 409 </span><span class="lineCov"> 2 : msg_progress(&quot;Drying...\n&quot;);</span>
<span class="lineNum"> 410 </span> :
<span class="lineNum"> 411 </span><span class="lineCov"> 2 : blockmax = parity_allocated_size(state);</span>
<span class="lineNum"> 412 </span> :
<span class="lineNum"> 413 </span><span class="lineCov"> 2 : if (blockstart &gt; blockmax) {</span>
<span class="lineNum"> 414 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 415 </span> : log_fatal(&quot;Error in the specified starting block %u. It's bigger than the parity size %u.\n&quot;, blockstart, blockmax);
<span class="lineNum"> 416 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 417 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 418 </span> : }
<span class="lineNum"> 419 </span> :
<span class="lineNum"> 420 </span> : /* adjust the number of block to process */
<span class="lineNum"> 421 </span><span class="lineCov"> 2 : if (blockcount != 0 &amp;&amp; blockstart + blockcount &lt; blockmax) {</span>
<span class="lineNum"> 422 </span><span class="lineNoCov"> 0 : blockmax = blockstart + blockcount;</span>
<span class="lineNum"> 423 </span> : }
<span class="lineNum"> 424 </span> :
<span class="lineNum"> 425 </span> : /* open the file for reading */
<span class="lineNum"> 426 </span> : /* it may fail if the file doesn't exist, in this case we continue to dry the files */
<span class="lineNum"> 427 </span><span class="lineCov"> 14 : for (l = 0; l &lt; state-&gt;level; ++l) {</span>
<span class="lineNum"> 428 </span><span class="lineCov"> 12 : ret = parity_open(&amp;parity_handle[l], &amp;state-&gt;parity[l], l, state-&gt;file_mode, state-&gt;block_size, state-&gt;opt.parity_limit_size);</span>
<span class="lineNum"> 429 </span><span class="lineCov"> 12 : if (ret == -1) {</span>
<span class="lineNum"> 430 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 431 </span> : log_fatal(&quot;WARNING! Without an accessible %s file, it isn't possible to dry.\n&quot;, lev_name(l));
<span class="lineNum"> 432 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 433 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 434 </span> : }
<span class="lineNum"> 435 </span> : }
<span class="lineNum"> 436 </span> :
<span class="lineNum"> 437 </span><span class="lineCov"> 2 : error = 0;</span>
<span class="lineNum"> 438 </span> :
<span class="lineNum"> 439 </span> : /* skip degenerated cases of empty parity, or skipping all */
<span class="lineNum"> 440 </span><span class="lineCov"> 2 : if (blockstart &lt; blockmax) {</span>
<span class="lineNum"> 441 </span><span class="lineCov"> 2 : ret = state_dry_process(state, parity_handle, blockstart, blockmax);</span>
<span class="lineNum"> 442 </span><span class="lineCov"> 2 : if (ret == -1) {</span>
<span class="lineNum"> 443 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 444 </span> : ++error;
<span class="lineNum"> 445 </span> : /* continue, as we are already exiting */
<span class="lineNum"> 446 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 447 </span> : }
<span class="lineNum"> 448 </span> : }
<span class="lineNum"> 449 </span> :
<span class="lineNum"> 450 </span> : /* try to close only if opened */
<span class="lineNum"> 451 </span><span class="lineCov"> 14 : for (l = 0; l &lt; state-&gt;level; ++l) {</span>
<span class="lineNum"> 452 </span><span class="lineCov"> 12 : ret = parity_close(&amp;parity_handle[l]);</span>
<span class="lineNum"> 453 </span><span class="lineCov"> 12 : if (ret == -1) {</span>
<span class="lineNum"> 454 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 455 </span> : ++error;
<span class="lineNum"> 456 </span> : /* continue, as we are already exiting */
<span class="lineNum"> 457 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 458 </span> : }
<span class="lineNum"> 459 </span> : }
<span class="lineNum"> 460 </span> :
<span class="lineNum"> 461 </span> : /* abort if required */
<span class="lineNum"> 462 </span><span class="lineCov"> 2 : if (error != 0) {</span>
<span class="lineNum"> 463 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 464 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 465 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 466 </span> : }
<span class="lineNum"> 467 </span><span class="lineCov"> 2 : }</span>
<span class="lineNum"> 468 </span> :
</pre>
</td>
</tr>

94
cov/cmdline/elem.c.func-sort-c.html
View file

@ -61,71 +61,71 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1098">extent_parity_inside_compare_unlock</a></td>
<td class="coverFnHi">113816358</td>
<td class="coverFnHi">113835807</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#803">fs_lock</a></td>
<td class="coverFnHi">53194369</td>
<td class="coverFnHi">53196480</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#812">fs_unlock</a></td>
<td class="coverFnHi">53193869</td>
<td class="coverFnHi">53196096</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#659">extent_file_compare</a></td>
<td class="coverFnHi">45007856</td>
<td class="coverFnHi">45007274</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1366">fs_file2block_get</a></td>
<td class="coverFnHi">44945080</td>
<td class="coverFnHi">44946613</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#646">extent_parity_compare</a></td>
<td class="coverFnHi">44511012</td>
<td class="coverFnHi">44510782</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1116">fs_par2extent_get_unlock</a></td>
<td class="coverFnHi">39142093</td>
<td class="coverFnHi">39144459</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1196">fs_par2file_find</a></td>
<td class="coverFnHi">39035232</td>
<td class="coverFnHi">39037806</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1378">fs_par2block_find</a></td>
<td class="coverFnHi">27312315</td>
<td class="coverFnHi">27314040</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1148">extent_file_inside_compare_unlock</a></td>
<td class="coverFnHi">21314053</td>
<td class="coverFnHi">21310663</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#170">filter_apply</a></td>
<td class="coverFnHi">12456124</td>
<td class="coverFnHi">12456904</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1171">fs_file2extent_get_unlock</a></td>
<td class="coverFnHi">10336325</td>
<td class="coverFnHi">10336351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1238">fs_allocate</a></td>
<td class="coverFnHi">9175619</td>
<td class="coverFnHi">9175524</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#477">file_block_size</a></td>
<td class="coverFnHi">6823060</td>
<td class="coverFnHi">6823791</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#957">extent_file_check_foreach_unlock</a></td>
<td class="coverFnHi">6584437</td>
<td class="coverFnHi">6584417</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#907">extent_parity_check_foreach_unlock</a></td>
<td class="coverFnHi">6584437</td>
<td class="coverFnHi">6584417</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#195">filter_recurse</a></td>
<td class="coverFnHi">6236157</td>
<td class="coverFnHi">6236559</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#493">file_block_is_last</a></td>
@ -133,55 +133,55 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1219">fs_file2par_find</a></td>
<td class="coverFnHi">4869535</td>
<td class="coverFnHi">4869582</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#615">extent_alloc</a></td>
<td class="coverFnHi">3735492</td>
<td class="coverFnHi">3735396</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#364">file_alloc</a></td>
<td class="coverFnHi">3691209</td>
<td class="coverFnHi">3691126</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#641">extent_free</a></td>
<td class="coverFnHi">3564805</td>
<td class="coverFnHi">3564840</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#415">file_free</a></td>
<td class="coverFnHi">3543765</td>
<td class="coverFnHi">3543814</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#229">filter_element</a></td>
<td class="coverFnHi">3332623</td>
<td class="coverFnHi">3332824</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#278">filter_path</a></td>
<td class="coverFnHi">3329526</td>
<td class="coverFnHi">3329727</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#339">filter_content</a></td>
<td class="coverFnHi">3173124</td>
<td class="coverFnHi">3173351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#508">file_inode_compare_to_arg</a></td>
<td class="coverFnHi">987050</td>
<td class="coverFnHi">987099</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1409">time_compare</a></td>
<td class="coverFnHi">684987</td>
<td class="coverFnHi">684203</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1438">fmt_term</a></td>
<td class="coverFnHi">356004</td>
<td class="coverFnHi">356075</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#532">file_path_compare</a></td>
<td class="coverFnHi">189434</td>
<td class="coverFnHi">189486</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#151">filter_type</a></td>
<td class="coverFnHi">125245</td>
<td class="coverFnHi">125255</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#677">link_alloc</a></td>
@ -193,27 +193,27 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1287">fs_deallocate</a></td>
<td class="coverFnHi">106126</td>
<td class="coverFnHi">106308</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#552">file_path_compare_to_arg</a></td>
<td class="coverFnHi">97552</td>
<td class="coverFnHi">97531</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#293">filter_existence</a></td>
<td class="coverFnHi">80691</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#540">file_physical_compare</a></td>
<td class="coverFnHi">63430</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#876">extent_disk_size_compare_unlock</a></td>
<td class="coverFnHi">50483</td>
<td class="coverFnHi">50510</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#466">file_name</a></td>
<td class="coverFnHi">47954</td>
<td class="coverFnHi">47922</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#540">file_physical_compare</a></td>
<td class="coverFnHi">44202</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#318">filter_correctness</a></td>
@ -225,11 +225,11 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#593">file_namestamp_compare</a></td>
<td class="coverFnHi">23977</td>
<td class="coverFnHi">23961</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#560">file_name_compare</a></td>
<td class="coverFnHi">23977</td>
<td class="coverFnHi">23961</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#570">file_stamp_compare</a></td>
@ -241,11 +241,11 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#389">file_dup</a></td>
<td class="coverFnHi">22680</td>
<td class="coverFnHi">22687</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#889">fs_size</a></td>
<td class="coverFnHi">4339</td>
<td class="coverFnHi">4351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#704">link_alpha_compare</a></td>
@ -257,19 +257,19 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1066">fs_check</a></td>
<td class="coverFnHi">2970</td>
<td class="coverFnHi">2982</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#737">disk_alloc</a></td>
<td class="coverFnHi">1579</td>
<td class="coverFnHi">1585</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1390">map_alloc</a></td>
<td class="coverFnHi">1549</td>
<td class="coverFnHi">1555</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#27">content_alloc</a></td>
<td class="coverFnHi">1523</td>
<td class="coverFnHi">1525</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#783">disk_free</a></td>
@ -297,7 +297,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#43">filter_alloc_file</a></td>
<td class="coverFnHi">532</td>
<td class="coverFnHi">534</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#146">filter_free</a></td>

88
cov/cmdline/elem.c.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#27">content_alloc</a></td>
<td class="coverFnHi">1523</td>
<td class="coverFnHi">1525</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#38">content_free</a></td>
@ -81,7 +81,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#737">disk_alloc</a></td>
<td class="coverFnHi">1579</td>
<td class="coverFnHi">1585</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#783">disk_free</a></td>
@ -89,7 +89,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#615">extent_alloc</a></td>
<td class="coverFnHi">3735492</td>
<td class="coverFnHi">3735396</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#828">extent_disk_empty_compare_unlock</a></td>
@ -97,39 +97,39 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#876">extent_disk_size_compare_unlock</a></td>
<td class="coverFnHi">50483</td>
<td class="coverFnHi">50510</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#957">extent_file_check_foreach_unlock</a></td>
<td class="coverFnHi">6584437</td>
<td class="coverFnHi">6584417</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#659">extent_file_compare</a></td>
<td class="coverFnHi">45007856</td>
<td class="coverFnHi">45007274</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1148">extent_file_inside_compare_unlock</a></td>
<td class="coverFnHi">21314053</td>
<td class="coverFnHi">21310663</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#641">extent_free</a></td>
<td class="coverFnHi">3564805</td>
<td class="coverFnHi">3564840</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#907">extent_parity_check_foreach_unlock</a></td>
<td class="coverFnHi">6584437</td>
<td class="coverFnHi">6584417</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#646">extent_parity_compare</a></td>
<td class="coverFnHi">44511012</td>
<td class="coverFnHi">44510782</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1098">extent_parity_inside_compare_unlock</a></td>
<td class="coverFnHi">113816358</td>
<td class="coverFnHi">113835807</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#364">file_alloc</a></td>
<td class="coverFnHi">3691209</td>
<td class="coverFnHi">3691126</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#493">file_block_is_last</a></td>
@ -137,7 +137,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#477">file_block_size</a></td>
<td class="coverFnHi">6823060</td>
<td class="coverFnHi">6823791</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#430">file_copy</a></td>
@ -145,11 +145,11 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#389">file_dup</a></td>
<td class="coverFnHi">22680</td>
<td class="coverFnHi">22687</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#415">file_free</a></td>
<td class="coverFnHi">3543765</td>
<td class="coverFnHi">3543814</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#520">file_inode_compare</a></td>
@ -157,27 +157,27 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#508">file_inode_compare_to_arg</a></td>
<td class="coverFnHi">987050</td>
<td class="coverFnHi">987099</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#466">file_name</a></td>
<td class="coverFnHi">47954</td>
<td class="coverFnHi">47922</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#560">file_name_compare</a></td>
<td class="coverFnHi">23977</td>
<td class="coverFnHi">23961</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#593">file_namestamp_compare</a></td>
<td class="coverFnHi">23977</td>
<td class="coverFnHi">23961</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#532">file_path_compare</a></td>
<td class="coverFnHi">189434</td>
<td class="coverFnHi">189486</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#552">file_path_compare_to_arg</a></td>
<td class="coverFnHi">97552</td>
<td class="coverFnHi">97531</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#604">file_pathstamp_compare</a></td>
@ -185,7 +185,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#540">file_physical_compare</a></td>
<td class="coverFnHi">63430</td>
<td class="coverFnHi">44202</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#424">file_rename</a></td>
@ -201,15 +201,15 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#43">filter_alloc_file</a></td>
<td class="coverFnHi">532</td>
<td class="coverFnHi">534</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#170">filter_apply</a></td>
<td class="coverFnHi">12456124</td>
<td class="coverFnHi">12456904</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#339">filter_content</a></td>
<td class="coverFnHi">3173124</td>
<td class="coverFnHi">3173351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#318">filter_correctness</a></td>
@ -217,7 +217,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#229">filter_element</a></td>
<td class="coverFnHi">3332623</td>
<td class="coverFnHi">3332824</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#288">filter_emptydir</a></td>
@ -233,11 +233,11 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#278">filter_path</a></td>
<td class="coverFnHi">3329526</td>
<td class="coverFnHi">3329727</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#195">filter_recurse</a></td>
<td class="coverFnHi">6236157</td>
<td class="coverFnHi">6236559</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#283">filter_subdir</a></td>
@ -245,7 +245,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#151">filter_type</a></td>
<td class="coverFnHi">125245</td>
<td class="coverFnHi">125255</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1429">fmt_poll</a></td>
@ -253,31 +253,31 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1438">fmt_term</a></td>
<td class="coverFnHi">356004</td>
<td class="coverFnHi">356075</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1238">fs_allocate</a></td>
<td class="coverFnHi">9175619</td>
<td class="coverFnHi">9175524</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1066">fs_check</a></td>
<td class="coverFnHi">2970</td>
<td class="coverFnHi">2982</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1287">fs_deallocate</a></td>
<td class="coverFnHi">106126</td>
<td class="coverFnHi">106308</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1366">fs_file2block_get</a></td>
<td class="coverFnHi">44945080</td>
<td class="coverFnHi">44946613</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1171">fs_file2extent_get_unlock</a></td>
<td class="coverFnHi">10336325</td>
<td class="coverFnHi">10336351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1219">fs_file2par_find</a></td>
<td class="coverFnHi">4869535</td>
<td class="coverFnHi">4869582</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#841">fs_is_empty</a></td>
@ -285,27 +285,27 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#803">fs_lock</a></td>
<td class="coverFnHi">53194369</td>
<td class="coverFnHi">53196480</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1378">fs_par2block_find</a></td>
<td class="coverFnHi">27312315</td>
<td class="coverFnHi">27314040</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1116">fs_par2extent_get_unlock</a></td>
<td class="coverFnHi">39142093</td>
<td class="coverFnHi">39144459</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1196">fs_par2file_find</a></td>
<td class="coverFnHi">39035232</td>
<td class="coverFnHi">39037806</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#889">fs_size</a></td>
<td class="coverFnHi">4339</td>
<td class="coverFnHi">4351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#812">fs_unlock</a></td>
<td class="coverFnHi">53193869</td>
<td class="coverFnHi">53196096</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#677">link_alloc</a></td>
@ -325,7 +325,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1390">map_alloc</a></td>
<td class="coverFnHi">1549</td>
<td class="coverFnHi">1555</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1404">map_free</a></td>
@ -333,7 +333,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.c.gcov.html#1409">time_compare</a></td>
<td class="coverFnHi">684987</td>
<td class="coverFnHi">684203</td>
</tr>
</table>
<br>

822
cov/cmdline/elem.c.gcov.html
View file

File diff suppressed because it is too large Load diff

58
cov/cmdline/elem.h.func-sort-c.html
View file

@ -61,99 +61,99 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#637">block_sizeof</a></td>
<td class="coverFnHi">58065323</td>
<td class="coverFnHi">58066767</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#772">file_block</a></td>
<td class="coverFnHi">54351240</td>
<td class="coverFnHi">54352792</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#648">block_state_get</a></td>
<td class="coverFnHi">52304798</td>
<td class="coverFnHi">52307392</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#727">file_flag_has</a></td>
<td class="coverFnHi">34094547</td>
<td class="coverFnHi">34094426</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#659">block_state_set</a></td>
<td class="coverFnHi">19117787</td>
<td class="coverFnHi">19118268</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#694">block_has_file</a></td>
<td class="coverFnHi">14590544</td>
<td class="coverFnHi">14591728</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#707">block_has_invalid_parity</a></td>
<td class="coverFnHi">12320061</td>
<td class="coverFnHi">12320606</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1027">fs_par2file_get</a></td>
<td class="coverFnHi">11723736</td>
<td class="coverFnHi">11723986</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#621">hash_invalid_set</a></td>
<td class="coverFnHi">9234472</td>
<td class="coverFnHi">9234413</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#847">file_stamp_hash</a></td>
<td class="coverFnHi">6275914</td>
<td class="coverFnHi">6275808</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#732">file_flag_set</a></td>
<td class="coverFnHi">5301349</td>
<td class="coverFnHi">5301067</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1193">info_get</a></td>
<td class="coverFnHi">5098374</td>
<td class="coverFnHi">5098627</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#818">file_inode_hash</a></td>
<td class="coverFnHi">5047846</td>
<td class="coverFnHi">5047758</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1051">fs_file2par_get</a></td>
<td class="coverFnHi">4755380</td>
<td class="coverFnHi">4755371</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#839">file_path_hash</a></td>
<td class="coverFnHi">3886074</td>
<td class="coverFnHi">3885977</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#510">filter_hidden</a></td>
<td class="coverFnHi">3173124</td>
<td class="coverFnHi">3173351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#682">block_has_past_hash</a></td>
<td class="coverFnHi">2542743</td>
<td class="coverFnHi">2542370</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#669">block_has_updated_hash</a></td>
<td class="coverFnHi">2217692</td>
<td class="coverFnHi">2218141</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1148">info_get_rehash</a></td>
<td class="coverFnHi">2046653</td>
<td class="coverFnHi">2046724</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1182">info_set</a></td>
<td class="coverFnHi">1697965</td>
<td class="coverFnHi">1698098</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1130">info_get_time</a></td>
<td class="coverFnHi">883104</td>
<td class="coverFnHi">883015</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#589">hash_is_zero</a></td>
<td class="coverFnHi">760617</td>
<td class="coverFnHi">760471</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#567">hash_is_invalid</a></td>
<td class="coverFnHi">759156</td>
<td class="coverFnHi">759009</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1139">info_get_bad</a></td>
<td class="coverFnHi">351943</td>
<td class="coverFnHi">351958</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#720">block_has_file_and_valid_parity</a></td>
@ -161,11 +161,11 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#872">link_flag_has</a></td>
<td class="coverFnHi">209329</td>
<td class="coverFnHi">209328</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1111">info_make</a></td>
<td class="coverFnHi">194583</td>
<td class="coverFnHi">194355</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#921">link_name_hash</a></td>
@ -181,11 +181,11 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1157">info_get_justsynced</a></td>
<td class="coverFnHi">68535</td>
<td class="coverFnHi">68446</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#609">hash_is_unique</a></td>
<td class="coverFnHi">44219</td>
<td class="coverFnHi">44333</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#877">link_flag_set</a></td>
@ -193,7 +193,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#737">file_flag_clear</a></td>
<td class="coverFnHi">16739</td>
<td class="coverFnHi">16745</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1075">fs_par2block_get</a></td>

58
cov/cmdline/elem.h.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#694">block_has_file</a></td>
<td class="coverFnHi">14590544</td>
<td class="coverFnHi">14591728</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#720">block_has_file_and_valid_parity</a></td>
@ -69,27 +69,27 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#707">block_has_invalid_parity</a></td>
<td class="coverFnHi">12320061</td>
<td class="coverFnHi">12320606</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#682">block_has_past_hash</a></td>
<td class="coverFnHi">2542743</td>
<td class="coverFnHi">2542370</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#669">block_has_updated_hash</a></td>
<td class="coverFnHi">2217692</td>
<td class="coverFnHi">2218141</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#637">block_sizeof</a></td>
<td class="coverFnHi">58065323</td>
<td class="coverFnHi">58066767</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#648">block_state_get</a></td>
<td class="coverFnHi">52304798</td>
<td class="coverFnHi">52307392</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#659">block_state_set</a></td>
<td class="coverFnHi">19117787</td>
<td class="coverFnHi">19118268</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#926">dir_flag_has</a></td>
@ -105,39 +105,39 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#772">file_block</a></td>
<td class="coverFnHi">54351240</td>
<td class="coverFnHi">54352792</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#737">file_flag_clear</a></td>
<td class="coverFnHi">16739</td>
<td class="coverFnHi">16745</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#727">file_flag_has</a></td>
<td class="coverFnHi">34094547</td>
<td class="coverFnHi">34094426</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#732">file_flag_set</a></td>
<td class="coverFnHi">5301349</td>
<td class="coverFnHi">5301067</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#818">file_inode_hash</a></td>
<td class="coverFnHi">5047846</td>
<td class="coverFnHi">5047758</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#839">file_path_hash</a></td>
<td class="coverFnHi">3886074</td>
<td class="coverFnHi">3885977</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#847">file_stamp_hash</a></td>
<td class="coverFnHi">6275914</td>
<td class="coverFnHi">6275808</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#510">filter_hidden</a></td>
<td class="coverFnHi">3173124</td>
<td class="coverFnHi">3173351</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1051">fs_file2par_get</a></td>
<td class="coverFnHi">4755380</td>
<td class="coverFnHi">4755371</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1075">fs_par2block_get</a></td>
@ -145,23 +145,23 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1027">fs_par2file_get</a></td>
<td class="coverFnHi">11723736</td>
<td class="coverFnHi">11723986</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#621">hash_invalid_set</a></td>
<td class="coverFnHi">9234472</td>
<td class="coverFnHi">9234413</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#567">hash_is_invalid</a></td>
<td class="coverFnHi">759156</td>
<td class="coverFnHi">759009</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#609">hash_is_unique</a></td>
<td class="coverFnHi">44219</td>
<td class="coverFnHi">44333</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#589">hash_is_zero</a></td>
<td class="coverFnHi">760617</td>
<td class="coverFnHi">760471</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#629">hash_zero_set</a></td>
@ -169,31 +169,31 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1193">info_get</a></td>
<td class="coverFnHi">5098374</td>
<td class="coverFnHi">5098627</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1139">info_get_bad</a></td>
<td class="coverFnHi">351943</td>
<td class="coverFnHi">351958</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1157">info_get_justsynced</a></td>
<td class="coverFnHi">68535</td>
<td class="coverFnHi">68446</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1148">info_get_rehash</a></td>
<td class="coverFnHi">2046653</td>
<td class="coverFnHi">2046724</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1130">info_get_time</a></td>
<td class="coverFnHi">883104</td>
<td class="coverFnHi">883015</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1111">info_make</a></td>
<td class="coverFnHi">194583</td>
<td class="coverFnHi">194355</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1182">info_set</a></td>
<td class="coverFnHi">1697965</td>
<td class="coverFnHi">1698098</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#1165">info_set_bad</a></td>
@ -209,7 +209,7 @@
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#872">link_flag_has</a></td>
<td class="coverFnHi">209329</td>
<td class="coverFnHi">209328</td>
</tr>
<tr>
<td class="coverFn"><a href="elem.h.gcov.html#887">link_flag_let</a></td>

190
cov/cmdline/elem.h.gcov.html
View file

@ -571,13 +571,13 @@
<span class="lineNum"> 509 </span> : * Filter hidden files.
<a name="510"><span class="lineNum"> 510 </span> : * Return !=0 if it matches and it should be excluded.</a>
<span class="lineNum"> 511 </span> : */
<span class="lineNum"> 512 </span><span class="lineCov"> 3173124 : static inline int filter_hidden(int enable, struct dirent* dd)</span>
<span class="lineNum"> 512 </span><span class="lineCov"> 3173351 : static inline int filter_hidden(int enable, struct dirent* dd)</span>
<span class="lineNum"> 513 </span> : {
<span class="lineNum"> 514 </span><span class="lineCov"> 3173124 : if (enable &amp;&amp; dirent_hidden(dd)) {</span>
<span class="lineNum"> 514 </span><span class="lineCov"> 3173351 : if (enable &amp;&amp; dirent_hidden(dd)) {</span>
<span class="lineNum"> 515 </span><span class="lineNoCov"> 0 : return 1; /* filter out */</span>
<span class="lineNum"> 516 </span> : }
<span class="lineNum"> 517 </span> :
<span class="lineNum"> 518 </span><span class="lineCov"> 3173124 : return 0;</span>
<span class="lineNum"> 518 </span><span class="lineCov"> 3173351 : return 0;</span>
<span class="lineNum"> 519 </span> : }
<span class="lineNum"> 520 </span> :
<span class="lineNum"> 521 </span> : /**
@ -628,19 +628,19 @@
<span class="lineNum"> 566 </span> : *
<a name="567"><span class="lineNum"> 567 </span> : * If working with reduced hash lengths, this function always return 0.</a>
<span class="lineNum"> 568 </span> : */
<span class="lineNum"> 569 </span><span class="lineCov"> 759156 : static inline int hash_is_invalid(const unsigned char* hash)</span>
<span class="lineNum"> 569 </span><span class="lineCov"> 759009 : static inline int hash_is_invalid(const unsigned char* hash)</span>
<span class="lineNum"> 570 </span> : {
<span class="lineNum"> 571 </span> : int i;
<span class="lineNum"> 572 </span> :
<span class="lineNum"> 573 </span> : /* if the hash is reduced, we cannot grant that it's a specific kind of hash */
<span class="lineNum"> 574 </span><span class="lineCov"> 759156 : if (BLOCK_HASH_SIZE != HASH_MAX)</span>
<span class="lineNum"> 574 </span><span class="lineCov"> 759009 : if (BLOCK_HASH_SIZE != HASH_MAX)</span>
<span class="lineNum"> 575 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 576 </span> :
<span class="lineNum"> 577 </span><span class="lineCov"> 1179374 : for (i = 0; i &lt; BLOCK_HASH_SIZE; ++i)</span>
<span class="lineNum"> 578 </span><span class="lineCov"> 1153310 : if (hash[i] != 0x00)</span>
<span class="lineNum"> 579 </span><span class="lineCov"> 733092 : return 0;</span>
<span class="lineNum"> 577 </span><span class="lineCov"> 1178755 : for (i = 0; i &lt; BLOCK_HASH_SIZE; ++i)</span>
<span class="lineNum"> 578 </span><span class="lineCov"> 1152696 : if (hash[i] != 0x00)</span>
<span class="lineNum"> 579 </span><span class="lineCov"> 732950 : return 0;</span>
<span class="lineNum"> 580 </span> :
<span class="lineNum"> 581 </span><span class="lineCov"> 26064 : return 1;</span>
<span class="lineNum"> 581 </span><span class="lineCov"> 26059 : return 1;</span>
<span class="lineNum"> 582 </span> : }
<span class="lineNum"> 583 </span> :
<span class="lineNum"> 584 </span> : /**
@ -650,19 +650,19 @@
<span class="lineNum"> 588 </span> : *
<a name="589"><span class="lineNum"> 589 </span> : * If working with reduced hash lengths, this function always return 0.</a>
<span class="lineNum"> 590 </span> : */
<span class="lineNum"> 591 </span><span class="lineCov"> 760617 : static inline int hash_is_zero(const unsigned char* hash)</span>
<span class="lineNum"> 591 </span><span class="lineCov"> 760471 : static inline int hash_is_zero(const unsigned char* hash)</span>
<span class="lineNum"> 592 </span> : {
<span class="lineNum"> 593 </span> : int i;
<span class="lineNum"> 594 </span> :
<span class="lineNum"> 595 </span> : /* if the hash is reduced, we cannot grant that it's a specific kind of hash */
<span class="lineNum"> 596 </span><span class="lineCov"> 760617 : if (BLOCK_HASH_SIZE != HASH_MAX)</span>
<span class="lineNum"> 596 </span><span class="lineCov"> 760471 : if (BLOCK_HASH_SIZE != HASH_MAX)</span>
<span class="lineNum"> 597 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 598 </span> :
<span class="lineNum"> 599 </span><span class="lineCov"> 994968 : for (i = 0; i &lt; BLOCK_HASH_SIZE; ++i)</span>
<span class="lineNum"> 600 </span><span class="lineCov"> 980500 : if (hash[i] != 0xFF)</span>
<span class="lineNum"> 601 </span><span class="lineCov"> 746149 : return 0;</span>
<span class="lineNum"> 599 </span><span class="lineCov"> 994894 : for (i = 0; i &lt; BLOCK_HASH_SIZE; ++i)</span>
<span class="lineNum"> 600 </span><span class="lineCov"> 980425 : if (hash[i] != 0xFF)</span>
<span class="lineNum"> 601 </span><span class="lineCov"> 746002 : return 0;</span>
<span class="lineNum"> 602 </span> :
<span class="lineNum"> 603 </span><span class="lineCov"> 14468 : return 1;</span>
<span class="lineNum"> 603 </span><span class="lineCov"> 14469 : return 1;</span>
<span class="lineNum"> 604 </span> : }
<span class="lineNum"> 605 </span> :
<span class="lineNum"> 606 </span> : /**
@ -670,22 +670,22 @@
<span class="lineNum"> 608 </span> : *
<a name="609"><span class="lineNum"> 609 </span> : * If working with reduced hash lengths, this function always return 0.</a>
<span class="lineNum"> 610 </span> : */
<span class="lineNum"> 611 </span><span class="lineCov"> 44219 : static inline int hash_is_unique(const unsigned char* hash)</span>
<span class="lineNum"> 611 </span><span class="lineCov"> 44333 : static inline int hash_is_unique(const unsigned char* hash)</span>
<span class="lineNum"> 612 </span> : {
<span class="lineNum"> 613 </span> : /* if the hash is reduced, we cannot grant that it's a specific kind of hash */
<span class="lineNum"> 614 </span><span class="lineCov"> 44219 : if (BLOCK_HASH_SIZE != HASH_MAX)</span>
<span class="lineNum"> 614 </span><span class="lineCov"> 44333 : if (BLOCK_HASH_SIZE != HASH_MAX)</span>
<span class="lineNum"> 615 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 616 </span> :
<span class="lineNum"> 617 </span><span class="lineCov"> 44219 : return !hash_is_zero(hash) &amp;&amp; !hash_is_invalid(hash);</span>
<span class="lineNum"> 617 </span><span class="lineCov"> 44333 : return !hash_is_zero(hash) &amp;&amp; !hash_is_invalid(hash);</span>
<span class="lineNum"> 618 </span> : }
<span class="lineNum"> 619 </span> :
<span class="lineNum"> 620 </span> : /**
<a name="621"><span class="lineNum"> 621 </span> : * Set the hash to the special INVALID value.</a>
<span class="lineNum"> 622 </span> : */
<span class="lineNum"> 623 </span><span class="lineCov"> 9234472 : static inline void hash_invalid_set(unsigned char* hash)</span>
<span class="lineNum"> 623 </span><span class="lineCov"> 9234413 : static inline void hash_invalid_set(unsigned char* hash)</span>
<span class="lineNum"> 624 </span> : {
<span class="lineNum"> 625 </span><span class="lineCov"> 9234472 : memset(hash, 0x00, BLOCK_HASH_SIZE);</span>
<span class="lineNum"> 626 </span><span class="lineCov"> 9234472 : }</span>
<span class="lineNum"> 625 </span><span class="lineCov"> 9234413 : memset(hash, 0x00, BLOCK_HASH_SIZE);</span>
<span class="lineNum"> 626 </span><span class="lineCov"> 9234413 : }</span>
<span class="lineNum"> 627 </span> :
<span class="lineNum"> 628 </span> : /**
<a name="629"><span class="lineNum"> 629 </span> : * Set the hash to the special ZERO value.</a>
@ -698,9 +698,9 @@
<span class="lineNum"> 636 </span> : /**
<a name="637"><span class="lineNum"> 637 </span> : * Allocated space for block.</a>
<span class="lineNum"> 638 </span> : */
<span class="lineNum"> 639 </span><span class="lineCov"> 58065323 : static inline size_t block_sizeof(void)</span>
<span class="lineNum"> 639 </span><span class="lineCov"> 58066767 : static inline size_t block_sizeof(void)</span>
<span class="lineNum"> 640 </span> : {
<span class="lineNum"> 641 </span><span class="lineCov"> 58065323 : return 1 + BLOCK_HASH_SIZE;</span>
<span class="lineNum"> 641 </span><span class="lineCov"> 58066767 : return 1 + BLOCK_HASH_SIZE;</span>
<span class="lineNum"> 642 </span> : }
<span class="lineNum"> 643 </span> :
<span class="lineNum"> 644 </span> : /**
@ -709,32 +709,32 @@
<span class="lineNum"> 647 </span> : * For this function, it's allowed to pass a NULL block
<a name="648"><span class="lineNum"> 648 </span> : * pointer than results in the BLOCK_STATE_EMPTY state.</a>
<span class="lineNum"> 649 </span> : */
<span class="lineNum"> 650 </span><span class="lineCov"> 52304798 : static inline unsigned block_state_get(const struct snapraid_block* block)</span>
<span class="lineNum"> 650 </span><span class="lineCov"> 52307392 : static inline unsigned block_state_get(const struct snapraid_block* block)</span>
<span class="lineNum"> 651 </span> : {
<span class="lineNum"> 652 </span><span class="lineCov"> 52304798 : if (block == BLOCK_NULL)</span>
<span class="lineNum"> 653 </span><span class="lineCov"> 1721706 : return BLOCK_STATE_EMPTY;</span>
<span class="lineNum"> 652 </span><span class="lineCov"> 52307392 : if (block == BLOCK_NULL)</span>
<span class="lineNum"> 653 </span><span class="lineCov"> 1721808 : return BLOCK_STATE_EMPTY;</span>
<span class="lineNum"> 654 </span> :
<span class="lineNum"> 655 </span><span class="lineCov"> 50583092 : return block-&gt;state;</span>
<span class="lineNum"> 655 </span><span class="lineCov"> 50585584 : return block-&gt;state;</span>
<span class="lineNum"> 656 </span> : }
<span class="lineNum"> 657 </span> :
<span class="lineNum"> 658 </span> : /**
<a name="659"><span class="lineNum"> 659 </span> : * Set the state of the block.</a>
<span class="lineNum"> 660 </span> : */
<span class="lineNum"> 661 </span><span class="lineCov"> 19117787 : static inline void block_state_set(struct snapraid_block* block, unsigned state)</span>
<span class="lineNum"> 661 </span><span class="lineCov"> 19118268 : static inline void block_state_set(struct snapraid_block* block, unsigned state)</span>
<span class="lineNum"> 662 </span> : {
<span class="lineNum"> 663 </span><span class="lineCov"> 19117787 : block-&gt;state = state;</span>
<span class="lineNum"> 664 </span><span class="lineCov"> 19117787 : }</span>
<span class="lineNum"> 663 </span><span class="lineCov"> 19118268 : block-&gt;state = state;</span>
<span class="lineNum"> 664 </span><span class="lineCov"> 19118268 : }</span>
<span class="lineNum"> 665 </span> :
<span class="lineNum"> 666 </span> : /**
<span class="lineNum"> 667 </span> : * Check if the specified block has an updated hash.
<span class="lineNum"> 668 </span> : *
<a name="669"><span class="lineNum"> 669 </span> : * Note that EMPTY / CHG / DELETED return 0.</a>
<span class="lineNum"> 670 </span> : */
<span class="lineNum"> 671 </span><span class="lineCov"> 2217692 : static inline int block_has_updated_hash(const struct snapraid_block* block)</span>
<span class="lineNum"> 671 </span><span class="lineCov"> 2218141 : static inline int block_has_updated_hash(const struct snapraid_block* block)</span>
<span class="lineNum"> 672 </span> : {
<span class="lineNum"> 673 </span><span class="lineCov"> 2217692 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 673 </span><span class="lineCov"> 2218141 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 674 </span> :
<span class="lineNum"> 675 </span><span class="lineCov"> 2217692 : return state == BLOCK_STATE_BLK || state == BLOCK_STATE_REP;</span>
<span class="lineNum"> 675 </span><span class="lineCov"> 2218141 : return state == BLOCK_STATE_BLK || state == BLOCK_STATE_REP;</span>
<span class="lineNum"> 676 </span> : }
<span class="lineNum"> 677 </span> :
<span class="lineNum"> 678 </span> : /**
@ -743,11 +743,11 @@
<span class="lineNum"> 681 </span> : *
<a name="682"><span class="lineNum"> 682 </span> : * Note that EMPTY / BLK / REP return 0.</a>
<span class="lineNum"> 683 </span> : */
<span class="lineNum"> 684 </span><span class="lineCov"> 2542743 : static inline int block_has_past_hash(const struct snapraid_block* block)</span>
<span class="lineNum"> 684 </span><span class="lineCov"> 2542370 : static inline int block_has_past_hash(const struct snapraid_block* block)</span>
<span class="lineNum"> 685 </span> : {
<span class="lineNum"> 686 </span><span class="lineCov"> 2542743 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 686 </span><span class="lineCov"> 2542370 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 687 </span> :
<span class="lineNum"> 688 </span><span class="lineCov"> 2542743 : return state == BLOCK_STATE_CHG || state == BLOCK_STATE_DELETED;</span>
<span class="lineNum"> 688 </span><span class="lineCov"> 2542370 : return state == BLOCK_STATE_CHG || state == BLOCK_STATE_DELETED;</span>
<span class="lineNum"> 689 </span> : }
<span class="lineNum"> 690 </span> :
<span class="lineNum"> 691 </span> : /**
@ -755,12 +755,12 @@
<span class="lineNum"> 693 </span> : *
<a name="694"><span class="lineNum"> 694 </span> : * Note that EMPTY / DELETED return 0.</a>
<span class="lineNum"> 695 </span> : */
<span class="lineNum"> 696 </span><span class="lineCov"> 14590544 : static inline int block_has_file(const struct snapraid_block* block)</span>
<span class="lineNum"> 696 </span><span class="lineCov"> 14591728 : static inline int block_has_file(const struct snapraid_block* block)</span>
<span class="lineNum"> 697 </span> : {
<span class="lineNum"> 698 </span><span class="lineCov"> 14590544 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 698 </span><span class="lineCov"> 14591728 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 699 </span> :
<span class="lineNum"> 700 </span><span class="lineCov"> 14590800 : return state == BLOCK_STATE_BLK</span>
<span class="lineNum"> 701 </span><span class="lineCov"> 14590800 : || state == BLOCK_STATE_CHG || state == BLOCK_STATE_REP;</span>
<span class="lineNum"> 700 </span><span class="lineCov"> 14591975 : return state == BLOCK_STATE_BLK</span>
<span class="lineNum"> 701 </span><span class="lineCov"> 14591975 : || state == BLOCK_STATE_CHG || state == BLOCK_STATE_REP;</span>
<span class="lineNum"> 702 </span> : }
<span class="lineNum"> 703 </span> :
<span class="lineNum"> 704 </span> : /**
@ -768,12 +768,12 @@
<span class="lineNum"> 706 </span> : *
<a name="707"><span class="lineNum"> 707 </span> : * Note that EMPTY / BLK return 0.</a>
<span class="lineNum"> 708 </span> : */
<span class="lineNum"> 709 </span><span class="lineCov"> 12320061 : static inline int block_has_invalid_parity(const struct snapraid_block* block)</span>
<span class="lineNum"> 709 </span><span class="lineCov"> 12320606 : static inline int block_has_invalid_parity(const struct snapraid_block* block)</span>
<span class="lineNum"> 710 </span> : {
<span class="lineNum"> 711 </span><span class="lineCov"> 12320061 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 711 </span><span class="lineCov"> 12320606 : unsigned state = block_state_get(block);</span>
<span class="lineNum"> 712 </span> :
<span class="lineNum"> 713 </span><span class="lineCov"> 12320061 : return state == BLOCK_STATE_DELETED</span>
<span class="lineNum"> 714 </span><span class="lineCov"> 12320061 : || state == BLOCK_STATE_CHG || state == BLOCK_STATE_REP;</span>
<span class="lineNum"> 713 </span><span class="lineCov"> 12320606 : return state == BLOCK_STATE_DELETED</span>
<span class="lineNum"> 714 </span><span class="lineCov"> 12320606 : || state == BLOCK_STATE_CHG || state == BLOCK_STATE_REP;</span>
<span class="lineNum"> 715 </span> : }
<span class="lineNum"> 716 </span> :
<span class="lineNum"> 717 </span> : /**
@ -788,20 +788,20 @@
<span class="lineNum"> 726 </span><span class="lineCov"> 220959 : return state == BLOCK_STATE_BLK;</span>
<a name="727"><span class="lineNum"> 727 </span> : }</a>
<span class="lineNum"> 728 </span> :
<span class="lineNum"> 729 </span><span class="lineCov"> 34094547 : static inline int file_flag_has(const struct snapraid_file* file, unsigned mask)</span>
<span class="lineNum"> 729 </span><span class="lineCov"> 34094426 : static inline int file_flag_has(const struct snapraid_file* file, unsigned mask)</span>
<span class="lineNum"> 730 </span> : {
<span class="lineNum"> 731 </span><span class="lineCov"> 34094547 : return (file-&gt;flag &amp; mask) == mask;</span>
<span class="lineNum"> 731 </span><span class="lineCov"> 34094426 : return (file-&gt;flag &amp; mask) == mask;</span>
<a name="732"><span class="lineNum"> 732 </span> : }</a>
<span class="lineNum"> 733 </span> :
<span class="lineNum"> 734 </span><span class="lineCov"> 5301349 : static inline void file_flag_set(struct snapraid_file* file, unsigned mask)</span>
<span class="lineNum"> 734 </span><span class="lineCov"> 5301067 : static inline void file_flag_set(struct snapraid_file* file, unsigned mask)</span>
<span class="lineNum"> 735 </span> : {
<span class="lineNum"> 736 </span><span class="lineCov"> 5301349 : file-&gt;flag |= mask;</span>
<a name="737"><span class="lineNum"> 737 </span><span class="lineCov"> 5301349 : }</span></a>
<span class="lineNum"> 736 </span><span class="lineCov"> 5301067 : file-&gt;flag |= mask;</span>
<a name="737"><span class="lineNum"> 737 </span><span class="lineCov"> 5301067 : }</span></a>
<span class="lineNum"> 738 </span> :
<span class="lineNum"> 739 </span><span class="lineCov"> 16739 : static inline void file_flag_clear(struct snapraid_file* file, unsigned mask)</span>
<span class="lineNum"> 739 </span><span class="lineCov"> 16745 : static inline void file_flag_clear(struct snapraid_file* file, unsigned mask)</span>
<span class="lineNum"> 740 </span> : {
<span class="lineNum"> 741 </span><span class="lineCov"> 16739 : file-&gt;flag &amp;= ~mask;</span>
<span class="lineNum"> 742 </span><span class="lineCov"> 16739 : }</span>
<span class="lineNum"> 741 </span><span class="lineCov"> 16745 : file-&gt;flag &amp;= ~mask;</span>
<span class="lineNum"> 742 </span><span class="lineCov"> 16745 : }</span>
<span class="lineNum"> 743 </span> :
<span class="lineNum"> 744 </span> : /**
<span class="lineNum"> 745 </span> : * Allocate a file.
@ -833,11 +833,11 @@
<span class="lineNum"> 771 </span> : *
<a name="772"><span class="lineNum"> 772 </span> : * Note that the block size if a runtime value.</a>
<span class="lineNum"> 773 </span> : */
<span class="lineNum"> 774 </span><span class="lineCov"> 54351240 : static inline struct snapraid_block* file_block(struct snapraid_file* file, size_t pos)</span>
<span class="lineNum"> 774 </span><span class="lineCov"> 54352792 : static inline struct snapraid_block* file_block(struct snapraid_file* file, size_t pos)</span>
<span class="lineNum"> 775 </span> : {
<span class="lineNum"> 776 </span><span class="lineCov"> 54351240 : unsigned char* ptr = (unsigned char*)file-&gt;blockvec;</span>
<span class="lineNum"> 776 </span><span class="lineCov"> 54352792 : unsigned char* ptr = (unsigned char*)file-&gt;blockvec;</span>
<span class="lineNum"> 777 </span> :
<span class="lineNum"> 778 </span><span class="lineCov"> 54351240 : return (struct snapraid_block*)(ptr + pos * block_sizeof());</span>
<span class="lineNum"> 778 </span><span class="lineCov"> 54352792 : return (struct snapraid_block*)(ptr + pos * block_sizeof());</span>
<span class="lineNum"> 779 </span> : }
<span class="lineNum"> 780 </span> :
<span class="lineNum"> 781 </span> : /**
@ -879,9 +879,9 @@
<span class="lineNum"> 817 </span> : /**
<a name="818"><span class="lineNum"> 818 </span> : * Compute the hash of a file inode.</a>
<span class="lineNum"> 819 </span> : */
<span class="lineNum"> 820 </span><span class="lineCov"> 5047846 : static inline tommy_uint32_t file_inode_hash(uint64_t inode)</span>
<span class="lineNum"> 820 </span><span class="lineCov"> 5047758 : static inline tommy_uint32_t file_inode_hash(uint64_t inode)</span>
<span class="lineNum"> 821 </span> : {
<span class="lineNum"> 822 </span><span class="lineCov"> 5047846 : return (tommy_uint32_t)tommy_inthash_u64(inode);</span>
<span class="lineNum"> 822 </span><span class="lineCov"> 5047758 : return (tommy_uint32_t)tommy_inthash_u64(inode);</span>
<span class="lineNum"> 823 </span> : }
<span class="lineNum"> 824 </span> :
<span class="lineNum"> 825 </span> : /**
@ -900,17 +900,17 @@
<span class="lineNum"> 838 </span> : /**
<a name="839"><span class="lineNum"> 839 </span> : * Compute the hash of a file path.</a>
<span class="lineNum"> 840 </span> : */
<span class="lineNum"> 841 </span><span class="lineCov"> 3886074 : static inline tommy_uint32_t file_path_hash(const char* sub)</span>
<span class="lineNum"> 841 </span><span class="lineCov"> 3885977 : static inline tommy_uint32_t file_path_hash(const char* sub)</span>
<span class="lineNum"> 842 </span> : {
<span class="lineNum"> 843 </span><span class="lineCov"> 3886074 : return tommy_hash_u32(0, sub, strlen(sub));</span>
<span class="lineNum"> 843 </span><span class="lineCov"> 3885977 : return tommy_hash_u32(0, sub, strlen(sub));</span>
<span class="lineNum"> 844 </span> : }
<span class="lineNum"> 845 </span> :
<span class="lineNum"> 846 </span> : /**
<a name="847"><span class="lineNum"> 847 </span> : * Compute the hash of a file stamp.</a>
<span class="lineNum"> 848 </span> : */
<span class="lineNum"> 849 </span><span class="lineCov"> 6275914 : static inline tommy_uint32_t file_stamp_hash(data_off_t size, int64_t mtime_sec, int mtime_nsec)</span>
<span class="lineNum"> 849 </span><span class="lineCov"> 6275808 : static inline tommy_uint32_t file_stamp_hash(data_off_t size, int64_t mtime_sec, int mtime_nsec)</span>
<span class="lineNum"> 850 </span> : {
<span class="lineNum"> 851 </span><span class="lineCov"> 6275914 : return tommy_inthash_u32((tommy_uint32_t)size ^ tommy_inthash_u32(mtime_sec ^ tommy_inthash_u32(mtime_nsec)));</span>
<span class="lineNum"> 851 </span><span class="lineCov"> 6275808 : return tommy_inthash_u32((tommy_uint32_t)size ^ tommy_inthash_u32(mtime_sec ^ tommy_inthash_u32(mtime_nsec)));</span>
<span class="lineNum"> 852 </span> : }
<span class="lineNum"> 853 </span> :
<span class="lineNum"> 854 </span> : /**
@ -933,9 +933,9 @@
<span class="lineNum"> 871 </span> : */
<a name="872"><span class="lineNum"> 872 </span> : int extent_file_compare(const void* void_a, const void* void_b);</a>
<span class="lineNum"> 873 </span> :
<span class="lineNum"> 874 </span><span class="lineCov"> 209329 : static inline int link_flag_has(const struct snapraid_link* slink, unsigned mask)</span>
<span class="lineNum"> 874 </span><span class="lineCov"> 209328 : static inline int link_flag_has(const struct snapraid_link* slink, unsigned mask)</span>
<span class="lineNum"> 875 </span> : {
<span class="lineNum"> 876 </span><span class="lineCov"> 209329 : return (slink-&gt;flag &amp; mask) == mask;</span>
<span class="lineNum"> 876 </span><span class="lineCov"> 209328 : return (slink-&gt;flag &amp; mask) == mask;</span>
<a name="877"><span class="lineNum"> 877 </span> : }</a>
<span class="lineNum"> 878 </span> :
<span class="lineNum"> 879 </span><span class="lineCov"> 39461 : static inline void link_flag_set(struct snapraid_link* slink, unsigned mask)</span>
@ -1088,19 +1088,19 @@
<span class="lineNum"> 1026 </span> : /**
<a name="1027"><span class="lineNum"> 1027 </span> : * Get the file position from the parity position.</a>
<span class="lineNum"> 1028 </span> : */
<span class="lineNum"> 1029 </span><span class="lineCov"> 11723736 : static inline struct snapraid_file* fs_par2file_get(struct snapraid_disk* disk, block_off_t parity_pos, block_off_t* file_pos)</span>
<span class="lineNum"> 1029 </span><span class="lineCov"> 11723986 : static inline struct snapraid_file* fs_par2file_get(struct snapraid_disk* disk, block_off_t parity_pos, block_off_t* file_pos)</span>
<span class="lineNum"> 1030 </span> : {
<span class="lineNum"> 1031 </span> : struct snapraid_file* ret;
<span class="lineNum"> 1032 </span> :
<span class="lineNum"> 1033 </span><span class="lineCov"> 11723736 : ret = fs_par2file_find(disk, parity_pos, file_pos);</span>
<span class="lineNum"> 1034 </span><span class="lineCov"> 11723887 : if (ret == 0) {</span>
<span class="lineNum"> 1033 </span><span class="lineCov"> 11723986 : ret = fs_par2file_find(disk, parity_pos, file_pos);</span>
<span class="lineNum"> 1034 </span><span class="lineCov"> 11724450 : if (ret == 0) {</span>
<span class="lineNum"> 1035 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1036 </span> : log_fatal(&quot;Internal inconsistency when deresolving parity to file at position '%u' in disk '%s'\n&quot;, parity_pos, disk-&gt;name);
<span class="lineNum"> 1037 </span> : os_abort();
<span class="lineNum"> 1038 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1039 </span> : }
<span class="lineNum"> 1040 </span> :
<span class="lineNum"> 1041 </span><span class="lineCov"> 11723887 : return ret;</span>
<span class="lineNum"> 1041 </span><span class="lineCov"> 11724450 : return ret;</span>
<span class="lineNum"> 1042 </span> : }
<span class="lineNum"> 1043 </span> :
<span class="lineNum"> 1044 </span> : /**
@ -1112,19 +1112,19 @@
<span class="lineNum"> 1050 </span> : /**
<a name="1051"><span class="lineNum"> 1051 </span> : * Get the parity position from the file position.</a>
<span class="lineNum"> 1052 </span> : */
<span class="lineNum"> 1053 </span><span class="lineCov"> 4755380 : static inline block_off_t fs_file2par_get(struct snapraid_disk* disk, struct snapraid_file* file, block_off_t file_pos)</span>
<span class="lineNum"> 1053 </span><span class="lineCov"> 4755371 : static inline block_off_t fs_file2par_get(struct snapraid_disk* disk, struct snapraid_file* file, block_off_t file_pos)</span>
<span class="lineNum"> 1054 </span> : {
<span class="lineNum"> 1055 </span> : block_off_t ret;
<span class="lineNum"> 1056 </span> :
<span class="lineNum"> 1057 </span><span class="lineCov"> 4755380 : ret = fs_file2par_find(disk, file, file_pos);</span>
<span class="lineNum"> 1058 </span><span class="lineCov"> 4755380 : if (ret == POS_NULL) {</span>
<span class="lineNum"> 1057 </span><span class="lineCov"> 4755371 : ret = fs_file2par_find(disk, file, file_pos);</span>
<span class="lineNum"> 1058 </span><span class="lineCov"> 4755371 : if (ret == POS_NULL) {</span>
<span class="lineNum"> 1059 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1060 </span> : log_fatal(&quot;Internal inconsistency when resolving file '%s' at position '%u/%u' in disk '%s'\n&quot;, file-&gt;sub, file_pos, file-&gt;blockmax, disk-&gt;name);
<span class="lineNum"> 1061 </span> : os_abort();
<span class="lineNum"> 1062 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1063 </span> : }
<span class="lineNum"> 1064 </span> :
<span class="lineNum"> 1065 </span><span class="lineCov"> 4755380 : return ret;</span>
<span class="lineNum"> 1065 </span><span class="lineCov"> 4755371 : return ret;</span>
<span class="lineNum"> 1066 </span> : }
<span class="lineNum"> 1067 </span> :
<span class="lineNum"> 1068 </span> : /**
@ -1172,18 +1172,18 @@
<span class="lineNum"> 1110 </span> : /**
<a name="1111"><span class="lineNum"> 1111 </span> : * Make an info.</a>
<span class="lineNum"> 1112 </span> : */
<span class="lineNum"> 1113 </span><span class="lineCov"> 194583 : static inline snapraid_info info_make(time_t last_access, int error, int rehash, int justsynced)</span>
<span class="lineNum"> 1113 </span><span class="lineCov"> 194355 : static inline snapraid_info info_make(time_t last_access, int error, int rehash, int justsynced)</span>
<span class="lineNum"> 1114 </span> : {
<span class="lineNum"> 1115 </span> : /* clear the lowest bits as reserved for other information */
<span class="lineNum"> 1116 </span><span class="lineCov"> 194583 : snapraid_info info = last_access &amp; ~INFO_MASK;</span>
<span class="lineNum"> 1116 </span><span class="lineCov"> 194355 : snapraid_info info = last_access &amp; ~INFO_MASK;</span>
<span class="lineNum"> 1117 </span> :
<span class="lineNum"> 1118 </span><span class="lineCov"> 194583 : if (error != 0)</span>
<span class="lineNum"> 1119 </span><span class="lineCov"> 5380 : info |= 0x1;</span>
<span class="lineNum"> 1120 </span><span class="lineCov"> 194583 : if (rehash != 0)</span>
<span class="lineNum"> 1118 </span><span class="lineCov"> 194355 : if (error != 0)</span>
<span class="lineNum"> 1119 </span><span class="lineCov"> 5306 : info |= 0x1;</span>
<span class="lineNum"> 1120 </span><span class="lineCov"> 194355 : if (rehash != 0)</span>
<span class="lineNum"> 1121 </span><span class="lineCov"> 14426 : info |= 0x2;</span>
<span class="lineNum"> 1122 </span><span class="lineCov"> 194583 : if (justsynced != 0)</span>
<span class="lineNum"> 1123 </span><span class="lineCov"> 142978 : info |= 0x4;</span>
<span class="lineNum"> 1124 </span><span class="lineCov"> 194583 : return info;</span>
<span class="lineNum"> 1122 </span><span class="lineCov"> 194355 : if (justsynced != 0)</span>
<span class="lineNum"> 1123 </span><span class="lineCov"> 142922 : info |= 0x4;</span>
<span class="lineNum"> 1124 </span><span class="lineCov"> 194355 : return info;</span>
<span class="lineNum"> 1125 </span> : }
<span class="lineNum"> 1126 </span> :
<span class="lineNum"> 1127 </span> : /**
@ -1191,36 +1191,36 @@
<span class="lineNum"> 1129 </span> : * This is the last time when the block was know to be correct.
<a name="1130"><span class="lineNum"> 1130 </span> : * The &quot;scrubbed&quot; info tells if the time is referreing at the latest sync or scrub.</a>
<span class="lineNum"> 1131 </span> : */
<span class="lineNum"> 1132 </span><span class="lineCov"> 883104 : static inline time_t info_get_time(snapraid_info info)</span>
<span class="lineNum"> 1132 </span><span class="lineCov"> 883015 : static inline time_t info_get_time(snapraid_info info)</span>
<span class="lineNum"> 1133 </span> : {
<span class="lineNum"> 1134 </span><span class="lineCov"> 883104 : return info &amp; ~INFO_MASK;</span>
<span class="lineNum"> 1134 </span><span class="lineCov"> 883015 : return info &amp; ~INFO_MASK;</span>
<span class="lineNum"> 1135 </span> : }
<span class="lineNum"> 1136 </span> :
<span class="lineNum"> 1137 </span> : /**
<span class="lineNum"> 1138 </span> : * Extract the error information.
<a name="1139"><span class="lineNum"> 1139 </span> : * Report if the block address had some problem.</a>
<span class="lineNum"> 1140 </span> : */
<span class="lineNum"> 1141 </span><span class="lineCov"> 351943 : static inline int info_get_bad(snapraid_info info)</span>
<span class="lineNum"> 1141 </span><span class="lineCov"> 351958 : static inline int info_get_bad(snapraid_info info)</span>
<span class="lineNum"> 1142 </span> : {
<span class="lineNum"> 1143 </span><span class="lineCov"> 351943 : return (info &amp; 0x1) != 0;</span>
<span class="lineNum"> 1143 </span><span class="lineCov"> 351958 : return (info &amp; 0x1) != 0;</span>
<span class="lineNum"> 1144 </span> : }
<span class="lineNum"> 1145 </span> :
<span class="lineNum"> 1146 </span> : /**
<span class="lineNum"> 1147 </span> : * Extract the rehash information.
<a name="1148"><span class="lineNum"> 1148 </span> : * Report if the block address is using the old hash and needs to be rehashed.</a>
<span class="lineNum"> 1149 </span> : */
<span class="lineNum"> 1150 </span><span class="lineCov"> 2046653 : static inline int info_get_rehash(snapraid_info info)</span>
<span class="lineNum"> 1150 </span><span class="lineCov"> 2046724 : static inline int info_get_rehash(snapraid_info info)</span>
<span class="lineNum"> 1151 </span> : {
<span class="lineNum"> 1152 </span><span class="lineCov"> 2046653 : return (info &amp; 0x2) != 0;</span>
<span class="lineNum"> 1152 </span><span class="lineCov"> 2046724 : return (info &amp; 0x2) != 0;</span>
<span class="lineNum"> 1153 </span> : }
<span class="lineNum"> 1154 </span> :
<span class="lineNum"> 1155 </span> : /**
<span class="lineNum"> 1156 </span> : * Extract the scrubbed information.
<a name="1157"><span class="lineNum"> 1157 </span> : * Report if the block address was never scrubbed.</a>
<span class="lineNum"> 1158 </span> : */
<span class="lineNum"> 1159 </span><span class="lineCov"> 68535 : static inline int info_get_justsynced(snapraid_info info)</span>
<span class="lineNum"> 1159 </span><span class="lineCov"> 68446 : static inline int info_get_justsynced(snapraid_info info)</span>
<span class="lineNum"> 1160 </span> : {
<span class="lineNum"> 1161 </span><span class="lineCov"> 68535 : return (info &amp; 0x4) != 0;</span>
<span class="lineNum"> 1161 </span><span class="lineCov"> 68446 : return (info &amp; 0x4) != 0;</span>
<span class="lineNum"> 1162 </span> : }
<span class="lineNum"> 1163 </span> :
<span class="lineNum"> 1164 </span> : /**
@ -1243,27 +1243,27 @@
<span class="lineNum"> 1181 </span> : * Set the info at the specified position.
<a name="1182"><span class="lineNum"> 1182 </span> : * The position is allocated if not yet done.</a>
<span class="lineNum"> 1183 </span> : */
<span class="lineNum"> 1184 </span><span class="lineCov"> 1697965 : static inline void info_set(tommy_arrayblkof* array, block_off_t pos, snapraid_info info)</span>
<span class="lineNum"> 1184 </span><span class="lineCov"> 1698098 : static inline void info_set(tommy_arrayblkof* array, block_off_t pos, snapraid_info info)</span>
<span class="lineNum"> 1185 </span> : {
<span class="lineNum"> 1186 </span><span class="lineCov"> 1697965 : tommy_arrayblkof_grow(array, pos + 1);</span>
<span class="lineNum"> 1186 </span><span class="lineCov"> 1698098 : tommy_arrayblkof_grow(array, pos + 1);</span>
<span class="lineNum"> 1187 </span> :
<span class="lineNum"> 1188 </span><span class="lineCov"> 1697965 : memcpy(tommy_arrayblkof_ref(array, pos), &amp;info, sizeof(snapraid_info));</span>
<span class="lineNum"> 1189 </span><span class="lineCov"> 1697965 : }</span>
<span class="lineNum"> 1188 </span><span class="lineCov"> 1698098 : memcpy(tommy_arrayblkof_ref(array, pos), &amp;info, sizeof(snapraid_info));</span>
<span class="lineNum"> 1189 </span><span class="lineCov"> 1698098 : }</span>
<span class="lineNum"> 1190 </span> :
<span class="lineNum"> 1191 </span> : /**
<span class="lineNum"> 1192 </span> : * Get the info at the specified position.
<a name="1193"><span class="lineNum"> 1193 </span> : * For not allocated position, 0 is returned.</a>
<span class="lineNum"> 1194 </span> : */
<span class="lineNum"> 1195 </span><span class="lineCov"> 5098374 : static inline snapraid_info info_get(tommy_arrayblkof* array, block_off_t pos)</span>
<span class="lineNum"> 1195 </span><span class="lineCov"> 5098627 : static inline snapraid_info info_get(tommy_arrayblkof* array, block_off_t pos)</span>
<span class="lineNum"> 1196 </span> : {
<span class="lineNum"> 1197 </span> : snapraid_info info;
<span class="lineNum"> 1198 </span> :
<span class="lineNum"> 1199 </span><span class="lineCov"> 5098374 : if (pos &gt;= tommy_arrayblkof_size(array))</span>
<span class="lineNum"> 1199 </span><span class="lineCov"> 5098627 : if (pos &gt;= tommy_arrayblkof_size(array))</span>
<span class="lineNum"> 1200 </span><span class="lineCov"> 262643 : return 0;</span>
<span class="lineNum"> 1201 </span> :
<span class="lineNum"> 1202 </span><span class="lineCov"> 4835731 : memcpy(&amp;info, tommy_arrayblkof_ref(array, pos), sizeof(snapraid_info));</span>
<span class="lineNum"> 1202 </span><span class="lineCov"> 4835984 : memcpy(&amp;info, tommy_arrayblkof_ref(array, pos), sizeof(snapraid_info));</span>
<span class="lineNum"> 1203 </span> :
<span class="lineNum"> 1204 </span><span class="lineCov"> 4835731 : return info;</span>
<span class="lineNum"> 1204 </span><span class="lineCov"> 4835984 : return info;</span>
<span class="lineNum"> 1205 </span> : }
<span class="lineNum"> 1206 </span> :
<span class="lineNum"> 1207 </span> : /**

14
cov/cmdline/handle.c.func-sort-c.html
View file

@ -61,31 +61,31 @@
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#235">handle_read</a></td>
<td class="coverFnHi">5855349</td>
<td class="coverFnHi">5856319</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#207">handle_close</a></td>
<td class="coverFnHi">4647511</td>
<td class="coverFnHi">4647370</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#142">handle_open</a></td>
<td class="coverFnHi">2185867</td>
<td class="coverFnHi">2186388</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#25">handle_create</a></td>
<td class="coverFnHi">771311</td>
<td class="coverFnHi">771305</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#294">handle_write</a></td>
<td class="coverFnHi">288562</td>
<td class="coverFnHi">288483</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#329">handle_utime</a></td>
<td class="coverFnHi">119431</td>
<td class="coverFnHi">119471</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#120">handle_truncate</a></td>
<td class="coverFnHi">3222</td>
<td class="coverFnHi">3180</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#349">handle_mapping</a></td>

14
cov/cmdline/handle.c.func.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#207">handle_close</a></td>
<td class="coverFnHi">4647511</td>
<td class="coverFnHi">4647370</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#25">handle_create</a></td>
<td class="coverFnHi">771311</td>
<td class="coverFnHi">771305</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#349">handle_mapping</a></td>
@ -73,23 +73,23 @@
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#142">handle_open</a></td>
<td class="coverFnHi">2185867</td>
<td class="coverFnHi">2186388</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#235">handle_read</a></td>
<td class="coverFnHi">5855349</td>
<td class="coverFnHi">5856319</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#120">handle_truncate</a></td>
<td class="coverFnHi">3222</td>
<td class="coverFnHi">3180</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#329">handle_utime</a></td>
<td class="coverFnHi">119431</td>
<td class="coverFnHi">119471</td>
</tr>
<tr>
<td class="coverFn"><a href="handle.c.gcov.html#294">handle_write</a></td>
<td class="coverFnHi">288562</td>
<td class="coverFnHi">288483</td>
</tr>
</table>
<br>

200
cov/cmdline/handle.c.gcov.html
View file

@ -86,64 +86,64 @@
<span class="lineNum"> 24 </span> : /****************************************************************************/
<a name="25"><span class="lineNum"> 25 </span> : /* handle */</a>
<span class="lineNum"> 26 </span> :
<span class="lineNum"> 27 </span><span class="lineCov"> 771311 : int handle_create(struct snapraid_handle* handle, struct snapraid_file* file, int mode)</span>
<span class="lineNum"> 27 </span><span class="lineCov"> 771305 : int handle_create(struct snapraid_handle* handle, struct snapraid_file* file, int mode)</span>
<span class="lineNum"> 28 </span> : {
<span class="lineNum"> 29 </span> : int ret;
<span class="lineNum"> 30 </span> : int flags;
<span class="lineNum"> 31 </span> :
<span class="lineNum"> 32 </span> : /* if it's the same file, and already opened, nothing to do */
<span class="lineNum"> 33 </span><span class="lineCov"> 771311 : if (handle-&gt;file == file &amp;&amp; handle-&gt;f != -1) {</span>
<span class="lineNum"> 33 </span><span class="lineCov"> 771305 : if (handle-&gt;file == file &amp;&amp; handle-&gt;f != -1) {</span>
<span class="lineNum"> 34 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 35 </span> : }
<span class="lineNum"> 36 </span> :
<span class="lineNum"> 37 </span><span class="lineCov"> 771311 : advise_init(&amp;handle-&gt;advise, mode);</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 771311 : pathprint(handle-&gt;path, sizeof(handle-&gt;path), &quot;%s%s&quot;, handle-&gt;disk-&gt;dir, file-&gt;sub);</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 771305 : advise_init(&amp;handle-&gt;advise, mode);</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 771305 : pathprint(handle-&gt;path, sizeof(handle-&gt;path), &quot;%s%s&quot;, handle-&gt;disk-&gt;dir, file-&gt;sub);</span>
<span class="lineNum"> 39 </span> :
<span class="lineNum"> 40 </span><span class="lineCov"> 771311 : ret = mkancestor(handle-&gt;path);</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 771311 : if (ret != 0) {</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 771305 : ret = mkancestor(handle-&gt;path);</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 771305 : if (ret != 0) {</span>
<span class="lineNum"> 42 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 43 </span> : return -1;
<span class="lineNum"> 44 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 45 </span> : }
<span class="lineNum"> 46 </span> :
<span class="lineNum"> 47 </span> : /* initial values, changed later if required */
<span class="lineNum"> 48 </span><span class="lineCov"> 771311 : handle-&gt;created = 0;</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 771305 : handle-&gt;created = 0;</span>
<span class="lineNum"> 49 </span> :
<span class="lineNum"> 50 </span> : /* flags for opening */
<span class="lineNum"> 51 </span> : /* O_BINARY: open as binary file (Windows only) */
<span class="lineNum"> 52 </span> : /* O_NOFOLLOW: do not follow links to ensure to open the real file */
<span class="lineNum"> 53 </span><span class="lineCov"> 771311 : flags = O_BINARY | O_NOFOLLOW | advise_flags(&amp;handle-&gt;advise);</span>
<span class="lineNum"> 53 </span><span class="lineCov"> 771305 : flags = O_BINARY | O_NOFOLLOW | advise_flags(&amp;handle-&gt;advise);</span>
<span class="lineNum"> 54 </span> :
<span class="lineNum"> 55 </span> : /* open for read write */
<span class="lineNum"> 56 </span><span class="lineCov"> 771311 : handle-&gt;f = open(handle-&gt;path, flags | O_RDWR);</span>
<span class="lineNum"> 56 </span><span class="lineCov"> 771305 : handle-&gt;f = open(handle-&gt;path, flags | O_RDWR);</span>
<span class="lineNum"> 57 </span> :
<span class="lineNum"> 58 </span> : /* if failed for missing write permission */
<span class="lineNum"> 59 </span><span class="lineCov"> 771311 : if (handle-&gt;f == -1 &amp;&amp; (errno == EACCES || errno == EROFS)) {</span>
<span class="lineNum"> 59 </span><span class="lineCov"> 771305 : if (handle-&gt;f == -1 &amp;&amp; (errno == EACCES || errno == EROFS)) {</span>
<span class="lineNum"> 60 </span> : /* open for real-only */
<span class="lineNum"> 61 </span><span class="lineNoCov"> 0 : handle-&gt;f = open(handle-&gt;path, flags | O_RDONLY);</span>
<span class="lineNum"> 62 </span> : }
<span class="lineNum"> 63 </span> :
<span class="lineNum"> 64 </span> : /* if failed for missing file */
<span class="lineNum"> 65 </span><span class="lineCov"> 771311 : if (handle-&gt;f == -1 &amp;&amp; errno == ENOENT) {</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 771305 : if (handle-&gt;f == -1 &amp;&amp; errno == ENOENT) {</span>
<span class="lineNum"> 66 </span> : char path_from[PATH_MAX];
<span class="lineNum"> 67 </span> :
<span class="lineNum"> 68 </span> : /* check if exists a .unrecoverable copy, and rename to the real one */
<span class="lineNum"> 69 </span><span class="lineCov"> 176417 : pathprint(path_from, sizeof(path_from), &quot;%s.unrecoverable&quot;, handle-&gt;path);</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 176353 : pathprint(path_from, sizeof(path_from), &quot;%s.unrecoverable&quot;, handle-&gt;path);</span>
<span class="lineNum"> 70 </span> :
<span class="lineNum"> 71 </span><span class="lineCov"> 176417 : if (rename(path_from, handle-&gt;path) == 0) {</span>
<span class="lineNum"> 71 </span><span class="lineCov"> 176353 : if (rename(path_from, handle-&gt;path) == 0) {</span>
<span class="lineNum"> 72 </span> : /* open for read write */
<span class="lineNum"> 73 </span><span class="lineCov"> 63282 : handle-&gt;f = open(handle-&gt;path, flags | O_RDWR);</span>
<span class="lineNum"> 73 </span><span class="lineCov"> 63286 : handle-&gt;f = open(handle-&gt;path, flags | O_RDWR);</span>
<span class="lineNum"> 74 </span> : } else {
<span class="lineNum"> 75 </span> : /* create it */
<span class="lineNum"> 76 </span><span class="lineCov"> 113135 : handle-&gt;f = open(handle-&gt;path, flags | O_RDWR | O_CREAT, 0600);</span>
<span class="lineNum"> 77 </span><span class="lineCov"> 113135 : if (handle-&gt;f != -1) {</span>
<span class="lineNum"> 76 </span><span class="lineCov"> 113067 : handle-&gt;f = open(handle-&gt;path, flags | O_RDWR | O_CREAT, 0600);</span>
<span class="lineNum"> 77 </span><span class="lineCov"> 113067 : if (handle-&gt;f != -1) {</span>
<span class="lineNum"> 78 </span> : /* mark it as created if really done */
<span class="lineNum"> 79 </span><span class="lineCov"> 113135 : handle-&gt;created = 1;</span>
<span class="lineNum"> 79 </span><span class="lineCov"> 113067 : handle-&gt;created = 1;</span>
<span class="lineNum"> 80 </span> : }
<span class="lineNum"> 81 </span> : }
<span class="lineNum"> 82 </span> : }
<span class="lineNum"> 83 </span> :
<span class="lineNum"> 84 </span><span class="lineCov"> 771311 : if (handle-&gt;f == -1) {</span>
<span class="lineNum"> 84 </span><span class="lineCov"> 771305 : if (handle-&gt;f == -1) {</span>
<span class="lineNum"> 85 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 86 </span> : /* invalidate for error */
<span class="lineNum"> 87 </span> : handle-&gt;file = 0;
@ -156,11 +156,11 @@
<span class="lineNum"> 94 </span> : }
<span class="lineNum"> 95 </span> :
<span class="lineNum"> 96 </span> : /* just opened */
<span class="lineNum"> 97 </span><span class="lineCov"> 771311 : handle-&gt;file = file;</span>
<span class="lineNum"> 97 </span><span class="lineCov"> 771305 : handle-&gt;file = file;</span>
<span class="lineNum"> 98 </span> :
<span class="lineNum"> 99 </span> : /* get the stat info */
<span class="lineNum"> 100 </span><span class="lineCov"> 771311 : ret = fstat(handle-&gt;f, &amp;handle-&gt;st);</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 771311 : if (ret != 0) {</span>
<span class="lineNum"> 100 </span><span class="lineCov"> 771305 : ret = fstat(handle-&gt;f, &amp;handle-&gt;st);</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 771305 : if (ret != 0) {</span>
<span class="lineNum"> 102 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 103 </span> : log_fatal(&quot;Error accessing file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 104 </span> : return -1;
@ -168,25 +168,25 @@
<span class="lineNum"> 106 </span> : }
<span class="lineNum"> 107 </span> :
<span class="lineNum"> 108 </span> : /* get the size of the existing data */
<span class="lineNum"> 109 </span><span class="lineCov"> 771311 : handle-&gt;valid_size = handle-&gt;st.st_size;</span>
<span class="lineNum"> 109 </span><span class="lineCov"> 771305 : handle-&gt;valid_size = handle-&gt;st.st_size;</span>
<span class="lineNum"> 110 </span> :
<span class="lineNum"> 111 </span><span class="lineCov"> 771311 : ret = advise_open(&amp;handle-&gt;advise, handle-&gt;f);</span>
<span class="lineNum"> 112 </span><span class="lineCov"> 771311 : if (ret != 0) {</span>
<span class="lineNum"> 111 </span><span class="lineCov"> 771305 : ret = advise_open(&amp;handle-&gt;advise, handle-&gt;f);</span>
<span class="lineNum"> 112 </span><span class="lineCov"> 771305 : if (ret != 0) {</span>
<span class="lineNum"> 113 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 114 </span> : log_fatal(&quot;Error advising file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 115 </span> : return -1;
<span class="lineNum"> 116 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 117 </span> : }
<span class="lineNum"> 118 </span> :
<span class="lineNum"> 119 </span><span class="lineCov"> 771311 : return 0;</span>
<span class="lineNum"> 119 </span><span class="lineCov"> 771305 : return 0;</span>
<a name="120"><span class="lineNum"> 120 </span> : }</a>
<span class="lineNum"> 121 </span> :
<span class="lineNum"> 122 </span><span class="lineCov"> 3222 : int handle_truncate(struct snapraid_handle* handle, struct snapraid_file* file)</span>
<span class="lineNum"> 122 </span><span class="lineCov"> 3180 : int handle_truncate(struct snapraid_handle* handle, struct snapraid_file* file)</span>
<span class="lineNum"> 123 </span> : {
<span class="lineNum"> 124 </span> : int ret;
<span class="lineNum"> 125 </span> :
<span class="lineNum"> 126 </span><span class="lineCov"> 3222 : ret = ftruncate(handle-&gt;f, file-&gt;size);</span>
<span class="lineNum"> 127 </span><span class="lineCov"> 3222 : if (ret != 0) {</span>
<span class="lineNum"> 126 </span><span class="lineCov"> 3180 : ret = ftruncate(handle-&gt;f, file-&gt;size);</span>
<span class="lineNum"> 127 </span><span class="lineCov"> 3180 : if (ret != 0) {</span>
<span class="lineNum"> 128 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 129 </span> : if (errno == EACCES) {
<span class="lineNum"> 130 </span> : log_fatal(&quot;Failed to truncate file '%s' for missing write permission.\n&quot;, handle-&gt;path);
@ -198,56 +198,56 @@
<span class="lineNum"> 136 </span> : }
<span class="lineNum"> 137 </span> :
<span class="lineNum"> 138 </span> : /* adjust the size to the truncated size */
<span class="lineNum"> 139 </span><span class="lineCov"> 3222 : handle-&gt;valid_size = file-&gt;size;</span>
<span class="lineNum"> 139 </span><span class="lineCov"> 3180 : handle-&gt;valid_size = file-&gt;size;</span>
<span class="lineNum"> 140 </span> :
<span class="lineNum"> 141 </span><span class="lineCov"> 3222 : return 0;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 3180 : return 0;</span>
<a name="142"><span class="lineNum"> 142 </span> : }</a>
<span class="lineNum"> 143 </span> :
<span class="lineNum"> 144 </span><span class="lineCov"> 2185867 : int handle_open(struct snapraid_handle* handle, struct snapraid_file* file, int mode, fptr* out, fptr* out_missing)</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 2186388 : int handle_open(struct snapraid_handle* handle, struct snapraid_file* file, int mode, fptr* out, fptr* out_missing)</span>
<span class="lineNum"> 145 </span> : {
<span class="lineNum"> 146 </span> : int ret;
<span class="lineNum"> 147 </span> : int flags;
<span class="lineNum"> 148 </span> :
<span class="lineNum"> 149 </span><span class="lineCov"> 2185867 : if (!out_missing)</span>
<span class="lineNum"> 150 </span><span class="lineCov"> 2185464 : out_missing = out;</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 2186388 : if (!out_missing)</span>
<span class="lineNum"> 150 </span><span class="lineCov"> 2185969 : out_missing = out;</span>
<span class="lineNum"> 151 </span> :
<span class="lineNum"> 152 </span> : /* if already opened, nothing to do */
<span class="lineNum"> 153 </span><span class="lineCov"> 2185867 : if (handle-&gt;file == file &amp;&amp; handle-&gt;file != 0 &amp;&amp; handle-&gt;f != -1) {</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 468345 : return 0;</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 2186388 : if (handle-&gt;file == file &amp;&amp; handle-&gt;file != 0 &amp;&amp; handle-&gt;f != -1) {</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 468756 : return 0;</span>
<span class="lineNum"> 155 </span> : }
<span class="lineNum"> 156 </span> :
<span class="lineNum"> 157 </span><span class="lineCov"> 1717522 : advise_init(&amp;handle-&gt;advise, mode);</span>
<span class="lineNum"> 158 </span><span class="lineCov"> 1717676 : pathprint(handle-&gt;path, sizeof(handle-&gt;path), &quot;%s%s&quot;, handle-&gt;disk-&gt;dir, file-&gt;sub);</span>
<span class="lineNum"> 157 </span><span class="lineCov"> 1717632 : advise_init(&amp;handle-&gt;advise, mode);</span>
<span class="lineNum"> 158 </span><span class="lineCov"> 1717806 : pathprint(handle-&gt;path, sizeof(handle-&gt;path), &quot;%s%s&quot;, handle-&gt;disk-&gt;dir, file-&gt;sub);</span>
<span class="lineNum"> 159 </span> :
<span class="lineNum"> 160 </span> : /* for sure not created */
<span class="lineNum"> 161 </span><span class="lineCov"> 1717807 : handle-&gt;created = 0;</span>
<span class="lineNum"> 161 </span><span class="lineCov"> 1717916 : handle-&gt;created = 0;</span>
<span class="lineNum"> 162 </span> :
<span class="lineNum"> 163 </span> : /* flags for opening */
<span class="lineNum"> 164 </span> : /* O_BINARY: open as binary file (Windows only) */
<span class="lineNum"> 165 </span> : /* O_NOFOLLOW: do not follow links to ensure to open the real file */
<span class="lineNum"> 166 </span><span class="lineCov"> 1717807 : flags = O_BINARY | O_NOFOLLOW | advise_flags(&amp;handle-&gt;advise);</span>
<span class="lineNum"> 166 </span><span class="lineCov"> 1717916 : flags = O_BINARY | O_NOFOLLOW | advise_flags(&amp;handle-&gt;advise);</span>
<span class="lineNum"> 167 </span> :
<span class="lineNum"> 168 </span> : /* open for read */
<span class="lineNum"> 169 </span><span class="lineCov"> 1717764 : handle-&gt;f = open_noatime(handle-&gt;path, flags | O_RDONLY);</span>
<span class="lineNum"> 170 </span><span class="lineCov"> 1717748 : if (handle-&gt;f == -1) {</span>
<span class="lineNum"> 169 </span><span class="lineCov"> 1717861 : handle-&gt;f = open_noatime(handle-&gt;path, flags | O_RDONLY);</span>
<span class="lineNum"> 170 </span><span class="lineCov"> 1717874 : if (handle-&gt;f == -1) {</span>
<span class="lineNum"> 171 </span> : /* invalidate for error */
<span class="lineNum"> 172 </span><span class="lineCov"> 78757 : handle-&gt;file = 0;</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 78757 : handle-&gt;f = -1;</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 78757 : handle-&gt;valid_size = 0;</span>
<span class="lineNum"> 172 </span><span class="lineCov"> 78666 : handle-&gt;file = 0;</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 78666 : handle-&gt;f = -1;</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 78666 : handle-&gt;valid_size = 0;</span>
<span class="lineNum"> 175 </span> :
<span class="lineNum"> 176 </span><span class="lineCov"> 78757 : if (errno == ENOENT)</span>
<span class="lineNum"> 177 </span><span class="lineCov"> 78745 : out_missing(&quot;Missing file '%s'.\n&quot;, handle-&gt;path);</span>
<span class="lineNum"> 176 </span><span class="lineCov"> 78666 : if (errno == ENOENT)</span>
<span class="lineNum"> 177 </span><span class="lineCov"> 78654 : out_missing(&quot;Missing file '%s'.\n&quot;, handle-&gt;path);</span>
<span class="lineNum"> 178 </span> : else
<span class="lineNum"> 179 </span><span class="lineCov"> 12 : out(&quot;Error opening file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));</span>
<span class="lineNum"> 180 </span><span class="lineCov"> 78757 : return -1;</span>
<span class="lineNum"> 180 </span><span class="lineCov"> 78666 : return -1;</span>
<span class="lineNum"> 181 </span> : }
<span class="lineNum"> 182 </span> :
<span class="lineNum"> 183 </span> : /* just opened */
<span class="lineNum"> 184 </span><span class="lineCov"> 1638991 : handle-&gt;file = file;</span>
<span class="lineNum"> 184 </span><span class="lineCov"> 1639208 : handle-&gt;file = file;</span>
<span class="lineNum"> 185 </span> :
<span class="lineNum"> 186 </span> : /* get the stat info */
<span class="lineNum"> 187 </span><span class="lineCov"> 1638991 : ret = fstat(handle-&gt;f, &amp;handle-&gt;st);</span>
<span class="lineNum"> 188 </span><span class="lineCov"> 1639031 : if (ret != 0) {</span>
<span class="lineNum"> 187 </span><span class="lineCov"> 1639208 : ret = fstat(handle-&gt;f, &amp;handle-&gt;st);</span>
<span class="lineNum"> 188 </span><span class="lineCov"> 1639257 : if (ret != 0) {</span>
<span class="lineNum"> 189 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 190 </span> : out(&quot;Error accessing file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 191 </span> : return -1;
@ -255,27 +255,27 @@
<span class="lineNum"> 193 </span> : }
<span class="lineNum"> 194 </span> :
<span class="lineNum"> 195 </span> : /* get the size of the existing data */
<span class="lineNum"> 196 </span><span class="lineCov"> 1639031 : handle-&gt;valid_size = handle-&gt;st.st_size;</span>
<span class="lineNum"> 196 </span><span class="lineCov"> 1639257 : handle-&gt;valid_size = handle-&gt;st.st_size;</span>
<span class="lineNum"> 197 </span> :
<span class="lineNum"> 198 </span><span class="lineCov"> 1639031 : ret = advise_open(&amp;handle-&gt;advise, handle-&gt;f);</span>
<span class="lineNum"> 199 </span><span class="lineCov"> 1639026 : if (ret != 0) {</span>
<span class="lineNum"> 198 </span><span class="lineCov"> 1639257 : ret = advise_open(&amp;handle-&gt;advise, handle-&gt;f);</span>
<span class="lineNum"> 199 </span><span class="lineCov"> 1639264 : if (ret != 0) {</span>
<span class="lineNum"> 200 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 201 </span> : out(&quot;Error advising file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 202 </span> : return -1;
<span class="lineNum"> 203 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 204 </span> : }
<span class="lineNum"> 205 </span> :
<span class="lineNum"> 206 </span><span class="lineCov"> 1639026 : return 0;</span>
<span class="lineNum"> 206 </span><span class="lineCov"> 1639264 : return 0;</span>
<a name="207"><span class="lineNum"> 207 </span> : }</a>
<span class="lineNum"> 208 </span> :
<span class="lineNum"> 209 </span><span class="lineCov"> 4647511 : int handle_close(struct snapraid_handle* handle)</span>
<span class="lineNum"> 209 </span><span class="lineCov"> 4647370 : int handle_close(struct snapraid_handle* handle)</span>
<span class="lineNum"> 210 </span> : {
<span class="lineNum"> 211 </span> : int ret;
<span class="lineNum"> 212 </span> :
<span class="lineNum"> 213 </span> : /* close if open */
<span class="lineNum"> 214 </span><span class="lineCov"> 4647511 : if (handle-&gt;f != -1) {</span>
<span class="lineNum"> 215 </span><span class="lineCov"> 2410343 : ret = close(handle-&gt;f);</span>
<span class="lineNum"> 216 </span><span class="lineCov"> 2410377 : if (ret != 0) {</span>
<span class="lineNum"> 214 </span><span class="lineCov"> 4647370 : if (handle-&gt;f != -1) {</span>
<span class="lineNum"> 215 </span><span class="lineCov"> 2410548 : ret = close(handle-&gt;f);</span>
<span class="lineNum"> 216 </span><span class="lineCov"> 2410591 : if (ret != 0) {</span>
<span class="lineNum"> 217 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 218 </span> : log_fatal(&quot;Error closing file '%s'. %s.\n&quot;, handle-&gt;file-&gt;sub, strerror(errno));
<span class="lineNum"> 219 </span> :
@ -289,14 +289,14 @@
<span class="lineNum"> 227 </span> : }
<span class="lineNum"> 228 </span> :
<span class="lineNum"> 229 </span> : /* reset the descriptor */
<span class="lineNum"> 230 </span><span class="lineCov"> 4647545 : handle-&gt;file = 0;</span>
<span class="lineNum"> 231 </span><span class="lineCov"> 4647545 : handle-&gt;f = -1;</span>
<span class="lineNum"> 232 </span><span class="lineCov"> 4647545 : handle-&gt;valid_size = 0;</span>
<span class="lineNum"> 230 </span><span class="lineCov"> 4647413 : handle-&gt;file = 0;</span>
<span class="lineNum"> 231 </span><span class="lineCov"> 4647413 : handle-&gt;f = -1;</span>
<span class="lineNum"> 232 </span><span class="lineCov"> 4647413 : handle-&gt;valid_size = 0;</span>
<span class="lineNum"> 233 </span> :
<span class="lineNum"> 234 </span><span class="lineCov"> 4647545 : return 0;</span>
<span class="lineNum"> 234 </span><span class="lineCov"> 4647413 : return 0;</span>
<a name="235"><span class="lineNum"> 235 </span> : }</a>
<span class="lineNum"> 236 </span> :
<span class="lineNum"> 237 </span><span class="lineCov"> 5855349 : int handle_read(struct snapraid_handle* handle, block_off_t file_pos, unsigned char* block_buffer, unsigned block_size, fptr* out, fptr* out_missing)</span>
<span class="lineNum"> 237 </span><span class="lineCov"> 5856319 : int handle_read(struct snapraid_handle* handle, block_off_t file_pos, unsigned char* block_buffer, unsigned block_size, fptr* out, fptr* out_missing)</span>
<span class="lineNum"> 238 </span> : {
<span class="lineNum"> 239 </span> : ssize_t read_ret;
<span class="lineNum"> 240 </span> : data_off_t offset;
@ -304,70 +304,70 @@
<span class="lineNum"> 242 </span> : unsigned count;
<span class="lineNum"> 243 </span> : int ret;
<span class="lineNum"> 244 </span> :
<span class="lineNum"> 245 </span><span class="lineCov"> 5855349 : offset = file_pos * (data_off_t)block_size;</span>
<span class="lineNum"> 245 </span><span class="lineCov"> 5856319 : offset = file_pos * (data_off_t)block_size;</span>
<span class="lineNum"> 246 </span> :
<span class="lineNum"> 247 </span><span class="lineCov"> 5855349 : if (!out_missing)</span>
<span class="lineNum"> 248 </span><span class="lineCov"> 5842393 : out_missing = out;</span>
<span class="lineNum"> 247 </span><span class="lineCov"> 5856319 : if (!out_missing)</span>
<span class="lineNum"> 248 </span><span class="lineCov"> 5843379 : out_missing = out;</span>
<span class="lineNum"> 249 </span> :
<span class="lineNum"> 250 </span> : /* check if we are going to read only not initialized data */
<span class="lineNum"> 251 </span><span class="lineCov"> 5855349 : if (offset &gt;= handle-&gt;valid_size) {</span>
<span class="lineNum"> 251 </span><span class="lineCov"> 5856319 : if (offset &gt;= handle-&gt;valid_size) {</span>
<span class="lineNum"> 252 </span> : /* if the file is missing, it's at 0 size, or it's rebuilt while reading */
<span class="lineNum"> 253 </span><span class="lineCov"> 433464 : if (offset == handle-&gt;valid_size || handle-&gt;valid_size == 0)</span>
<span class="lineNum"> 254 </span><span class="lineCov"> 432215 : out_missing(&quot;Reading data from missing file '%s' at offset %&quot; PRIu64 &quot;.\n&quot;, handle-&gt;path, offset);</span>
<span class="lineNum"> 253 </span><span class="lineCov"> 433352 : if (offset == handle-&gt;valid_size || handle-&gt;valid_size == 0)</span>
<span class="lineNum"> 254 </span><span class="lineCov"> 431991 : out_missing(&quot;Reading data from missing file '%s' at offset %&quot; PRIu64 &quot;.\n&quot;, handle-&gt;path, offset);</span>
<span class="lineNum"> 255 </span> : else
<span class="lineNum"> 256 </span><span class="lineCov"> 1249 : out(&quot;Reading missing data from file '%s' at offset %&quot; PRIu64 &quot;.\n&quot;, handle-&gt;path, offset);</span>
<span class="lineNum"> 257 </span><span class="lineCov"> 433464 : return -1;</span>
<span class="lineNum"> 256 </span><span class="lineCov"> 1361 : out(&quot;Reading missing data from file '%s' at offset %&quot; PRIu64 &quot;.\n&quot;, handle-&gt;path, offset);</span>
<span class="lineNum"> 257 </span><span class="lineCov"> 433352 : return -1;</span>
<span class="lineNum"> 258 </span> : }
<span class="lineNum"> 259 </span> :
<span class="lineNum"> 260 </span><span class="lineCov"> 5421885 : read_size = file_block_size(handle-&gt;file, file_pos, block_size);</span>
<span class="lineNum"> 260 </span><span class="lineCov"> 5422967 : read_size = file_block_size(handle-&gt;file, file_pos, block_size);</span>
<span class="lineNum"> 261 </span> :
<span class="lineNum"> 262 </span><span class="lineCov"> 5421858 : count = 0;</span>
<span class="lineNum"> 262 </span><span class="lineCov"> 5422979 : count = 0;</span>
<span class="lineNum"> 263 </span> : do {
<span class="lineNum"> 264 </span> : /* read the full block to support O_DIRECT */
<span class="lineNum"> 265 </span><span class="lineCov"> 5430464 : read_ret = pread(handle-&gt;f, block_buffer + count, block_size - count, offset + count);</span>
<span class="lineNum"> 266 </span><span class="lineCov"> 5430098 : if (read_ret &lt; 0) {</span>
<span class="lineNum"> 265 </span><span class="lineCov"> 5431676 : read_ret = pread(handle-&gt;f, block_buffer + count, block_size - count, offset + count);</span>
<span class="lineNum"> 266 </span><span class="lineCov"> 5431334 : if (read_ret &lt; 0) {</span>
<span class="lineNum"> 267 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 268 </span> : out(&quot;Error reading file '%s' at offset %&quot; PRIu64 &quot; for size %u. %s.\n&quot;, handle-&gt;path, offset + count, block_size - count, strerror(errno));
<span class="lineNum"> 269 </span> : return -1;
<span class="lineNum"> 270 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 271 </span> : }
<span class="lineNum"> 272 </span><span class="lineCov"> 5430098 : if (read_ret == 0) {</span>
<span class="lineNum"> 273 </span><span class="lineCov"> 8705 : out(&quot;Unexpected end of file '%s' at offset %&quot; PRIu64 &quot;. %s.\n&quot;, handle-&gt;path, offset, strerror(errno));</span>
<span class="lineNum"> 274 </span><span class="lineCov"> 8705 : return -1;</span>
<span class="lineNum"> 272 </span><span class="lineCov"> 5431334 : if (read_ret == 0) {</span>
<span class="lineNum"> 273 </span><span class="lineCov"> 8919 : out(&quot;Unexpected end of file '%s' at offset %&quot; PRIu64 &quot;. %s.\n&quot;, handle-&gt;path, offset, strerror(errno));</span>
<span class="lineNum"> 274 </span><span class="lineCov"> 8919 : return -1;</span>
<span class="lineNum"> 275 </span> : }
<span class="lineNum"> 276 </span> :
<span class="lineNum"> 277 </span><span class="lineCov"> 5421393 : count += read_ret;</span>
<span class="lineNum"> 278 </span><span class="lineCov"> 5421393 : } while (count &lt; read_size);</span>
<span class="lineNum"> 277 </span><span class="lineCov"> 5422415 : count += read_ret;</span>
<span class="lineNum"> 278 </span><span class="lineCov"> 5422415 : } while (count &lt; read_size);</span>
<span class="lineNum"> 279 </span> :
<span class="lineNum"> 280 </span> : /* pad with 0 */
<span class="lineNum"> 281 </span><span class="lineCov"> 5412787 : if (read_size &lt; block_size) {</span>
<span class="lineNum"> 282 </span><span class="lineCov"> 2188487 : memset(block_buffer + read_size, 0, block_size - read_size);</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 5413718 : if (read_size &lt; block_size) {</span>
<span class="lineNum"> 282 </span><span class="lineCov"> 2188617 : memset(block_buffer + read_size, 0, block_size - read_size);</span>
<span class="lineNum"> 283 </span> : }
<span class="lineNum"> 284 </span> :
<span class="lineNum"> 285 </span><span class="lineCov"> 5412787 : ret = advise_read(&amp;handle-&gt;advise, handle-&gt;f, offset, block_size);</span>
<span class="lineNum"> 286 </span><span class="lineCov"> 5412784 : if (ret != 0) {</span>
<span class="lineNum"> 285 </span><span class="lineCov"> 5413718 : ret = advise_read(&amp;handle-&gt;advise, handle-&gt;f, offset, block_size);</span>
<span class="lineNum"> 286 </span><span class="lineCov"> 5413674 : if (ret != 0) {</span>
<span class="lineNum"> 287 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 288 </span> : out(&quot;Error advising file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 289 </span> : return -1;
<span class="lineNum"> 290 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 291 </span> : }
<span class="lineNum"> 292 </span> :
<span class="lineNum"> 293 </span><span class="lineCov"> 5412784 : return read_size;</span>
<span class="lineNum"> 293 </span><span class="lineCov"> 5413674 : return read_size;</span>
<a name="294"><span class="lineNum"> 294 </span> : }</a>
<span class="lineNum"> 295 </span> :
<span class="lineNum"> 296 </span><span class="lineCov"> 288562 : int handle_write(struct snapraid_handle* handle, block_off_t file_pos, unsigned char* block_buffer, unsigned block_size)</span>
<span class="lineNum"> 296 </span><span class="lineCov"> 288483 : int handle_write(struct snapraid_handle* handle, block_off_t file_pos, unsigned char* block_buffer, unsigned block_size)</span>
<span class="lineNum"> 297 </span> : {
<span class="lineNum"> 298 </span> : ssize_t write_ret;
<span class="lineNum"> 299 </span> : data_off_t offset;
<span class="lineNum"> 300 </span> : unsigned write_size;
<span class="lineNum"> 301 </span> : int ret;
<span class="lineNum"> 302 </span> :
<span class="lineNum"> 303 </span><span class="lineCov"> 288562 : offset = file_pos * (data_off_t)block_size;</span>
<span class="lineNum"> 303 </span><span class="lineCov"> 288483 : offset = file_pos * (data_off_t)block_size;</span>
<span class="lineNum"> 304 </span> :
<span class="lineNum"> 305 </span><span class="lineCov"> 288562 : write_size = file_block_size(handle-&gt;file, file_pos, block_size);</span>
<span class="lineNum"> 305 </span><span class="lineCov"> 288483 : write_size = file_block_size(handle-&gt;file, file_pos, block_size);</span>
<span class="lineNum"> 306 </span> :
<span class="lineNum"> 307 </span><span class="lineCov"> 288562 : write_ret = pwrite(handle-&gt;f, block_buffer, write_size, offset);</span>
<span class="lineNum"> 308 </span><span class="lineCov"> 288562 : if (write_ret != (ssize_t)write_size) { /* conversion is safe because block_size is always small */</span>
<span class="lineNum"> 307 </span><span class="lineCov"> 288483 : write_ret = pwrite(handle-&gt;f, block_buffer, write_size, offset);</span>
<span class="lineNum"> 308 </span><span class="lineCov"> 288483 : if (write_ret != (ssize_t)write_size) { /* conversion is safe because block_size is always small */</span>
<span class="lineNum"> 309 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 310 </span> : log_fatal(&quot;Error writing file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 311 </span> : return -1;
@ -375,39 +375,39 @@
<span class="lineNum"> 313 </span> : }
<span class="lineNum"> 314 </span> :
<span class="lineNum"> 315 </span> : /* adjust the size of the valid data */
<span class="lineNum"> 316 </span><span class="lineCov"> 288562 : if (handle-&gt;valid_size &lt; offset + write_size) {</span>
<span class="lineNum"> 317 </span><span class="lineCov"> 282510 : handle-&gt;valid_size = offset + write_size;</span>
<span class="lineNum"> 316 </span><span class="lineCov"> 288483 : if (handle-&gt;valid_size &lt; offset + write_size) {</span>
<span class="lineNum"> 317 </span><span class="lineCov"> 282399 : handle-&gt;valid_size = offset + write_size;</span>
<span class="lineNum"> 318 </span> : }
<span class="lineNum"> 319 </span> :
<span class="lineNum"> 320 </span><span class="lineCov"> 288562 : ret = advise_write(&amp;handle-&gt;advise, handle-&gt;f, offset, block_size);</span>
<span class="lineNum"> 321 </span><span class="lineCov"> 288562 : if (ret != 0) {</span>
<span class="lineNum"> 320 </span><span class="lineCov"> 288483 : ret = advise_write(&amp;handle-&gt;advise, handle-&gt;f, offset, block_size);</span>
<span class="lineNum"> 321 </span><span class="lineCov"> 288483 : if (ret != 0) {</span>
<span class="lineNum"> 322 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 323 </span> : log_fatal(&quot;Error advising file '%s'. %s.\n&quot;, handle-&gt;path, strerror(errno));
<span class="lineNum"> 324 </span> : return -1;
<span class="lineNum"> 325 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 326 </span> : }
<span class="lineNum"> 327 </span> :
<span class="lineNum"> 328 </span><span class="lineCov"> 288562 : return 0;</span>
<span class="lineNum"> 328 </span><span class="lineCov"> 288483 : return 0;</span>
<a name="329"><span class="lineNum"> 329 </span> : }</a>
<span class="lineNum"> 330 </span> :
<span class="lineNum"> 331 </span><span class="lineCov"> 119431 : int handle_utime(struct snapraid_handle* handle)</span>
<span class="lineNum"> 331 </span><span class="lineCov"> 119471 : int handle_utime(struct snapraid_handle* handle)</span>
<span class="lineNum"> 332 </span> : {
<span class="lineNum"> 333 </span> : int ret;
<span class="lineNum"> 334 </span> :
<span class="lineNum"> 335 </span> : /* do nothing if not opened */
<span class="lineNum"> 336 </span><span class="lineCov"> 119431 : if (handle-&gt;f == -1)</span>
<span class="lineNum"> 336 </span><span class="lineCov"> 119471 : if (handle-&gt;f == -1)</span>
<span class="lineNum"> 337 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 338 </span> :
<span class="lineNum"> 339 </span><span class="lineCov"> 119431 : ret = fmtime(handle-&gt;f, handle-&gt;file-&gt;mtime_sec, handle-&gt;file-&gt;mtime_nsec);</span>
<span class="lineNum"> 339 </span><span class="lineCov"> 119471 : ret = fmtime(handle-&gt;f, handle-&gt;file-&gt;mtime_sec, handle-&gt;file-&gt;mtime_nsec);</span>
<span class="lineNum"> 340 </span> :
<span class="lineNum"> 341 </span><span class="lineCov"> 119431 : if (ret != 0) {</span>
<span class="lineNum"> 341 </span><span class="lineCov"> 119471 : if (ret != 0) {</span>
<span class="lineNum"> 342 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 343 </span> : log_fatal(&quot;Error timing file '%s'. %s.\n&quot;, handle-&gt;file-&gt;sub, strerror(errno));
<span class="lineNum"> 344 </span> : return -1;
<span class="lineNum"> 345 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 346 </span> : }
<span class="lineNum"> 347 </span> :
<span class="lineNum"> 348 </span><span class="lineCov"> 119431 : return 0;</span>
<span class="lineNum"> 348 </span><span class="lineCov"> 119471 : return 0;</span>
<a name="349"><span class="lineNum"> 349 </span> : }</a>
<span class="lineNum"> 350 </span> :
<span class="lineNum"> 351 </span><span class="lineCov"> 221 : struct snapraid_handle* handle_mapping(struct snapraid_state* state, unsigned* handlemax)</span>

4
cov/cmdline/import.c.func-sort-c.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="import.c.gcov.html#47">import_block_hash</a></td>
<td class="coverFnHi">657164</td>
<td class="coverFnHi">656904</td>
</tr>
<tr>
<td class="coverFn"><a href="import.c.gcov.html#146">state_import_fetch</a></td>
<td class="coverFnHi">652692</td>
<td class="coverFnHi">652432</td>
</tr>
<tr>
<td class="coverFn"><a href="import.c.gcov.html#27">import_block_hash_compare</a></td>

4
cov/cmdline/import.c.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="import.c.gcov.html#47">import_block_hash</a></td>
<td class="coverFnHi">657164</td>
<td class="coverFnHi">656904</td>
</tr>
<tr>
<td class="coverFn"><a href="import.c.gcov.html#27">import_block_hash_compare</a></td>
@ -89,7 +89,7 @@
</tr>
<tr>
<td class="coverFn"><a href="import.c.gcov.html#146">state_import_fetch</a></td>
<td class="coverFnHi">652692</td>
<td class="coverFnHi">652432</td>
</tr>
</table>
<br>

18
cov/cmdline/import.c.gcov.html
View file

@ -108,10 +108,10 @@
<span class="lineNum"> 46 </span> : * Compute the hash of the hash for an import block.
<a name="47"><span class="lineNum"> 47 </span> : * We just use the first 32 bit of the hash itself.</a>
<span class="lineNum"> 48 </span> : */
<span class="lineNum"> 49 </span><span class="lineCov"> 657164 : static inline tommy_uint32_t import_block_hash(const unsigned char* hash)</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 656904 : static inline tommy_uint32_t import_block_hash(const unsigned char* hash)</span>
<span class="lineNum"> 50 </span> : {
<span class="lineNum"> 51 </span> : /* the hash data is not aligned, and we cannot access it with a direct cast */
<span class="lineNum"> 52 </span><span class="lineCov"> 657164 : return hash[0] | ((uint32_t)hash[1] &lt;&lt; 8) | ((uint32_t)hash[2] &lt;&lt; 16) | ((uint32_t)hash[3] &lt;&lt; 24);</span>
<span class="lineNum"> 52 </span><span class="lineCov"> 656904 : return hash[0] | ((uint32_t)hash[1] &lt;&lt; 8) | ((uint32_t)hash[2] &lt;&lt; 16) | ((uint32_t)hash[3] &lt;&lt; 24);</span>
<a name="53"><span class="lineNum"> 53 </span> : }</a>
<span class="lineNum"> 54 </span> :
<span class="lineNum"> 55 </span><span class="lineCov"> 1750 : static void import_file(struct snapraid_state* state, const char* path, uint64_t size)</span>
@ -207,24 +207,24 @@
<span class="lineNum"> 145 </span><span class="lineCov"> 1750 : free(file);</span>
<a name="146"><span class="lineNum"> 146 </span><span class="lineCov"> 1750 : }</span></a>
<span class="lineNum"> 147 </span> :
<span class="lineNum"> 148 </span><span class="lineCov"> 652692 : int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid_block* missing_block, unsigned char* buffer)</span>
<span class="lineNum"> 148 </span><span class="lineCov"> 652432 : int state_import_fetch(struct snapraid_state* state, int rehash, struct snapraid_block* missing_block, unsigned char* buffer)</span>
<span class="lineNum"> 149 </span> : {
<span class="lineNum"> 150 </span> : struct snapraid_import_block* block;
<span class="lineNum"> 151 </span> : int ret;
<span class="lineNum"> 152 </span> : int f;
<span class="lineNum"> 153 </span><span class="lineCov"> 652692 : const unsigned char* hash = missing_block-&gt;hash;</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 652692 : unsigned block_size = state-&gt;block_size;</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 652432 : const unsigned char* hash = missing_block-&gt;hash;</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 652432 : unsigned block_size = state-&gt;block_size;</span>
<span class="lineNum"> 155 </span> : unsigned read_size;
<span class="lineNum"> 156 </span> : unsigned char buffer_hash[HASH_MAX];
<span class="lineNum"> 157 </span> : const char* path;
<span class="lineNum"> 158 </span> :
<span class="lineNum"> 159 </span><span class="lineCov"> 652692 : if (rehash) {</span>
<span class="lineNum"> 159 </span><span class="lineCov"> 652432 : if (rehash) {</span>
<span class="lineNum"> 160 </span><span class="lineNoCov"> 0 : block = tommy_hashdyn_search(&amp;state-&gt;previmportset, import_block_prevhash_compare, hash, import_block_hash(hash));</span>
<span class="lineNum"> 161 </span> : } else {
<span class="lineNum"> 162 </span><span class="lineCov"> 652692 : block = tommy_hashdyn_search(&amp;state-&gt;importset, import_block_hash_compare, hash, import_block_hash(hash));</span>
<span class="lineNum"> 162 </span><span class="lineCov"> 652432 : block = tommy_hashdyn_search(&amp;state-&gt;importset, import_block_hash_compare, hash, import_block_hash(hash));</span>
<span class="lineNum"> 163 </span> : }
<span class="lineNum"> 164 </span><span class="lineCov"> 652692 : if (!block)</span>
<span class="lineNum"> 165 </span><span class="lineCov"> 648220 : return -1;</span>
<span class="lineNum"> 164 </span><span class="lineCov"> 652432 : if (!block)</span>
<span class="lineNum"> 165 </span><span class="lineCov"> 647960 : return -1;</span>
<span class="lineNum"> 166 </span> :
<span class="lineNum"> 167 </span><span class="lineCov"> 4472 : path = block-&gt;file-&gt;path;</span>
<span class="lineNum"> 168 </span><span class="lineCov"> 4472 : read_size = block-&gt;size;</span>

48
cov/cmdline/index-sort-f.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">8598</td>
<td class="headerCovTableEntry">9589</td>
<td class="headerCovTableEntryMed">89.7 %</td>
<td class="headerCovTableEntry">8613</td>
<td class="headerCovTableEntry">9548</td>
<td class="headerCovTableEntryHi">90.2 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -122,10 +122,10 @@
<tr>
<td class="coverFile"><a href="parity.c.gcov.html">parity.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=86 height=10 alt="85.8%"><img src="../snow.png" width=14 height=10 alt="85.8%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.9%"><img src="../snow.png" width=8 height=10 alt="91.9%"></td></tr></table>
</td>
<td class="coverPerMed">85.8&nbsp;%</td>
<td class="coverNumMed">206 / 240</td>
<td class="coverPerHi">91.9&nbsp;%</td>
<td class="coverNumHi">217 / 236</td>
<td class="coverPerHi">94.7&nbsp;%</td>
<td class="coverNumHi">18 / 19</td>
</tr>
@ -292,10 +292,10 @@
<tr>
<td class="coverFile"><a href="dry.c.gcov.html">dry.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../ruby.png" width=73 height=10 alt="72.7%"><img src="../snow.png" width=27 height=10 alt="72.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=76 height=10 alt="76.4%"><img src="../snow.png" width=24 height=10 alt="76.4%"></td></tr></table>
</td>
<td class="coverPerLo">72.7&nbsp;%</td>
<td class="coverNumLo">120 / 165</td>
<td class="coverPerMed">76.4&nbsp;%</td>
<td class="coverNumMed">120 / 157</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">5 / 5</td>
</tr>
@ -312,10 +312,10 @@
<tr>
<td class="coverFile"><a href="scrub.c.gcov.html">scrub.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=79 height=10 alt="78.7%"><img src="../snow.png" width=21 height=10 alt="78.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=81 height=10 alt="80.5%"><img src="../snow.png" width=19 height=10 alt="80.5%"></td></tr></table>
</td>
<td class="coverPerMed">78.7&nbsp;%</td>
<td class="coverNumMed">281 / 357</td>
<td class="coverPerMed">80.5&nbsp;%</td>
<td class="coverNumMed">281 / 349</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">6 / 6</td>
</tr>
@ -332,10 +332,10 @@
<tr>
<td class="coverFile"><a href="sync.c.gcov.html">sync.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=89 height=10 alt="89.5%"><img src="../snow.png" width=11 height=10 alt="89.5%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.9%"><img src="../snow.png" width=8 height=10 alt="91.9%"></td></tr></table>
</td>
<td class="coverPerMed">89.5&nbsp;%</td>
<td class="coverNumMed">502 / 561</td>
<td class="coverPerHi">91.9&nbsp;%</td>
<td class="coverNumHi">502 / 546</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">7 / 7</td>
</tr>
@ -372,20 +372,20 @@
<tr>
<td class="coverFile"><a href="check.c.gcov.html">check.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="90.8%"><img src="../snow.png" width=9 height=10 alt="90.8%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="91.5%"><img src="../snow.png" width=9 height=10 alt="91.5%"></td></tr></table>
</td>
<td class="coverPerHi">90.8&nbsp;%</td>
<td class="coverNumHi">709 / 781</td>
<td class="coverPerHi">91.5&nbsp;%</td>
<td class="coverNumHi">709 / 775</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
<tr>
<td class="coverFile"><a href="snapraid.c.gcov.html">snapraid.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="91.1%"><img src="../snow.png" width=9 height=10 alt="91.1%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.5%"><img src="../snow.png" width=8 height=10 alt="91.5%"></td></tr></table>
</td>
<td class="coverPerHi">91.1&nbsp;%</td>
<td class="coverNumHi">494 / 542</td>
<td class="coverPerHi">91.5&nbsp;%</td>
<td class="coverNumHi">496 / 542</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
@ -402,10 +402,10 @@
<tr>
<td class="coverFile"><a href="scan.c.gcov.html">scan.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=89 height=10 alt="89.2%"><img src="../snow.png" width=11 height=10 alt="89.2%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=90 height=10 alt="89.5%"><img src="../snow.png" width=10 height=10 alt="89.5%"></td></tr></table>
</td>
<td class="coverPerMed">89.2&nbsp;%</td>
<td class="coverNumMed">563 / 631</td>
<td class="coverPerMed">89.5&nbsp;%</td>
<td class="coverNumMed">565 / 631</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">23 / 23</td>
</tr>

98
cov/cmdline/index-sort-l.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">8598</td>
<td class="headerCovTableEntry">9589</td>
<td class="headerCovTableEntryMed">89.7 %</td>
<td class="headerCovTableEntry">8613</td>
<td class="headerCovTableEntry">9548</td>
<td class="headerCovTableEntryHi">90.2 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -82,23 +82,13 @@
<tr>
<td class="coverFile"><a href="dry.c.gcov.html">dry.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../ruby.png" width=73 height=10 alt="72.7%"><img src="../snow.png" width=27 height=10 alt="72.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=76 height=10 alt="76.4%"><img src="../snow.png" width=24 height=10 alt="76.4%"></td></tr></table>
</td>
<td class="coverPerLo">72.7&nbsp;%</td>
<td class="coverNumLo">120 / 165</td>
<td class="coverPerMed">76.4&nbsp;%</td>
<td class="coverNumMed">120 / 157</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">5 / 5</td>
</tr>
<tr>
<td class="coverFile"><a href="scrub.c.gcov.html">scrub.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=79 height=10 alt="78.7%"><img src="../snow.png" width=21 height=10 alt="78.7%"></td></tr></table>
</td>
<td class="coverPerMed">78.7&nbsp;%</td>
<td class="coverNumMed">281 / 357</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">6 / 6</td>
</tr>
<tr>
<td class="coverFile"><a href="support.c.gcov.html">support.c</a></td>
<td class="coverBar" align="center">
@ -110,34 +100,24 @@
<td class="coverNumHi">60 / 62</td>
</tr>
<tr>
<td class="coverFile"><a href="parity.c.gcov.html">parity.c</a></td>
<td class="coverFile"><a href="scrub.c.gcov.html">scrub.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=86 height=10 alt="85.8%"><img src="../snow.png" width=14 height=10 alt="85.8%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=81 height=10 alt="80.5%"><img src="../snow.png" width=19 height=10 alt="80.5%"></td></tr></table>
</td>
<td class="coverPerMed">85.8&nbsp;%</td>
<td class="coverNumMed">206 / 240</td>
<td class="coverPerHi">94.7&nbsp;%</td>
<td class="coverNumHi">18 / 19</td>
<td class="coverPerMed">80.5&nbsp;%</td>
<td class="coverNumMed">281 / 349</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">6 / 6</td>
</tr>
<tr>
<td class="coverFile"><a href="scan.c.gcov.html">scan.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=89 height=10 alt="89.2%"><img src="../snow.png" width=11 height=10 alt="89.2%"></td></tr></table>
</td>
<td class="coverPerMed">89.2&nbsp;%</td>
<td class="coverNumMed">563 / 631</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">23 / 23</td>
</tr>
<tr>
<td class="coverFile"><a href="sync.c.gcov.html">sync.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=89 height=10 alt="89.5%"><img src="../snow.png" width=11 height=10 alt="89.5%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=90 height=10 alt="89.5%"><img src="../snow.png" width=10 height=10 alt="89.5%"></td></tr></table>
</td>
<td class="coverPerMed">89.5&nbsp;%</td>
<td class="coverNumMed">502 / 561</td>
<td class="coverNumMed">565 / 631</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">7 / 7</td>
<td class="coverNumHi">23 / 23</td>
</tr>
<tr>
<td class="coverFile"><a href="state.c.gcov.html">state.c</a></td>
@ -169,16 +149,6 @@
<td class="coverPerMed">87.5&nbsp;%</td>
<td class="coverNumMed">7 / 8</td>
</tr>
<tr>
<td class="coverFile"><a href="check.c.gcov.html">check.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="90.8%"><img src="../snow.png" width=9 height=10 alt="90.8%"></td></tr></table>
</td>
<td class="coverPerHi">90.8&nbsp;%</td>
<td class="coverNumHi">709 / 781</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
<tr>
<td class="coverFile"><a href="stream.c.gcov.html">stream.c</a></td>
<td class="coverBar" align="center">
@ -200,15 +170,45 @@
<td class="coverNumHi">7 / 7</td>
</tr>
<tr>
<td class="coverFile"><a href="snapraid.c.gcov.html">snapraid.c</a></td>
<td class="coverFile"><a href="check.c.gcov.html">check.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="91.1%"><img src="../snow.png" width=9 height=10 alt="91.1%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="91.5%"><img src="../snow.png" width=9 height=10 alt="91.5%"></td></tr></table>
</td>
<td class="coverPerHi">91.1&nbsp;%</td>
<td class="coverNumHi">494 / 542</td>
<td class="coverPerHi">91.5&nbsp;%</td>
<td class="coverNumHi">709 / 775</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
<tr>
<td class="coverFile"><a href="snapraid.c.gcov.html">snapraid.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.5%"><img src="../snow.png" width=8 height=10 alt="91.5%"></td></tr></table>
</td>
<td class="coverPerHi">91.5&nbsp;%</td>
<td class="coverNumHi">496 / 542</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
<tr>
<td class="coverFile"><a href="parity.c.gcov.html">parity.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.9%"><img src="../snow.png" width=8 height=10 alt="91.9%"></td></tr></table>
</td>
<td class="coverPerHi">91.9&nbsp;%</td>
<td class="coverNumHi">217 / 236</td>
<td class="coverPerHi">94.7&nbsp;%</td>
<td class="coverNumHi">18 / 19</td>
</tr>
<tr>
<td class="coverFile"><a href="sync.c.gcov.html">sync.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.9%"><img src="../snow.png" width=8 height=10 alt="91.9%"></td></tr></table>
</td>
<td class="coverPerHi">91.9&nbsp;%</td>
<td class="coverNumHi">502 / 546</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">7 / 7</td>
</tr>
<tr>
<td class="coverFile"><a href="io.c.gcov.html">io.c</a></td>
<td class="coverBar" align="center">

48
cov/cmdline/index.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">8598</td>
<td class="headerCovTableEntry">9589</td>
<td class="headerCovTableEntryMed">89.7 %</td>
<td class="headerCovTableEntry">8613</td>
<td class="headerCovTableEntry">9548</td>
<td class="headerCovTableEntryHi">90.2 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -72,10 +72,10 @@
<tr>
<td class="coverFile"><a href="check.c.gcov.html">check.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="90.8%"><img src="../snow.png" width=9 height=10 alt="90.8%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="91.5%"><img src="../snow.png" width=9 height=10 alt="91.5%"></td></tr></table>
</td>
<td class="coverPerHi">90.8&nbsp;%</td>
<td class="coverNumHi">709 / 781</td>
<td class="coverPerHi">91.5&nbsp;%</td>
<td class="coverNumHi">709 / 775</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
@ -92,10 +92,10 @@
<tr>
<td class="coverFile"><a href="dry.c.gcov.html">dry.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../ruby.png" width=73 height=10 alt="72.7%"><img src="../snow.png" width=27 height=10 alt="72.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=76 height=10 alt="76.4%"><img src="../snow.png" width=24 height=10 alt="76.4%"></td></tr></table>
</td>
<td class="coverPerLo">72.7&nbsp;%</td>
<td class="coverNumLo">120 / 165</td>
<td class="coverPerMed">76.4&nbsp;%</td>
<td class="coverNumMed">120 / 157</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">5 / 5</td>
</tr>
@ -202,10 +202,10 @@
<tr>
<td class="coverFile"><a href="parity.c.gcov.html">parity.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=86 height=10 alt="85.8%"><img src="../snow.png" width=14 height=10 alt="85.8%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.9%"><img src="../snow.png" width=8 height=10 alt="91.9%"></td></tr></table>
</td>
<td class="coverPerMed">85.8&nbsp;%</td>
<td class="coverNumMed">206 / 240</td>
<td class="coverPerHi">91.9&nbsp;%</td>
<td class="coverNumHi">217 / 236</td>
<td class="coverPerHi">94.7&nbsp;%</td>
<td class="coverNumHi">18 / 19</td>
</tr>
@ -242,20 +242,20 @@
<tr>
<td class="coverFile"><a href="scan.c.gcov.html">scan.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=89 height=10 alt="89.2%"><img src="../snow.png" width=11 height=10 alt="89.2%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=90 height=10 alt="89.5%"><img src="../snow.png" width=10 height=10 alt="89.5%"></td></tr></table>
</td>
<td class="coverPerMed">89.2&nbsp;%</td>
<td class="coverNumMed">563 / 631</td>
<td class="coverPerMed">89.5&nbsp;%</td>
<td class="coverNumMed">565 / 631</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">23 / 23</td>
</tr>
<tr>
<td class="coverFile"><a href="scrub.c.gcov.html">scrub.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=79 height=10 alt="78.7%"><img src="../snow.png" width=21 height=10 alt="78.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=81 height=10 alt="80.5%"><img src="../snow.png" width=19 height=10 alt="80.5%"></td></tr></table>
</td>
<td class="coverPerMed">78.7&nbsp;%</td>
<td class="coverNumMed">281 / 357</td>
<td class="coverPerMed">80.5&nbsp;%</td>
<td class="coverNumMed">281 / 349</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">6 / 6</td>
</tr>
@ -282,10 +282,10 @@
<tr>
<td class="coverFile"><a href="snapraid.c.gcov.html">snapraid.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=91 height=10 alt="91.1%"><img src="../snow.png" width=9 height=10 alt="91.1%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.5%"><img src="../snow.png" width=8 height=10 alt="91.5%"></td></tr></table>
</td>
<td class="coverPerHi">91.1&nbsp;%</td>
<td class="coverNumHi">494 / 542</td>
<td class="coverPerHi">91.5&nbsp;%</td>
<td class="coverNumHi">496 / 542</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">9 / 9</td>
</tr>
@ -372,10 +372,10 @@
<tr>
<td class="coverFile"><a href="sync.c.gcov.html">sync.c</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../amber.png" width=89 height=10 alt="89.5%"><img src="../snow.png" width=11 height=10 alt="89.5%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="../emerald.png" width=92 height=10 alt="91.9%"><img src="../snow.png" width=8 height=10 alt="91.9%"></td></tr></table>
</td>
<td class="coverPerMed">89.5&nbsp;%</td>
<td class="coverNumMed">502 / 561</td>
<td class="coverPerHi">91.9&nbsp;%</td>
<td class="coverNumHi">502 / 546</td>
<td class="coverPerHi">100.0&nbsp;%</td>
<td class="coverNumHi">7 / 7</td>
</tr>

28
cov/cmdline/io.c.func-sort-c.html
View file

@ -61,27 +61,27 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#270">io_reader_step</a></td>
<td class="coverFnHi">1162427</td>
<td class="coverFnHi">1163270</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#516">io_task_read_thread</a></td>
<td class="coverFnHi">1081698</td>
<td class="coverFnHi">1082226</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#679">io_reader_worker</a></td>
<td class="coverFnHi">1081680</td>
<td class="coverFnHi">1082209</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#594">io_data_read_thread</a></td>
<td class="coverFnHi">870894</td>
<td class="coverFnHi">871422</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#326">io_writer_step</a></td>
<td class="coverFnHi">553871</td>
<td class="coverFnHi">554398</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#604">io_parity_write_thread</a></td>
<td class="coverFnHi">553420</td>
<td class="coverFnHi">553948</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#599">io_parity_read_thread</a></td>
@ -89,27 +89,27 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#23">io_position_next</a></td>
<td class="coverFnHi">161997</td>
<td class="coverFnHi">162085</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#42">io_reader_sched</a></td>
<td class="coverFnHi">161997</td>
<td class="coverFnHi">162085</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#388">io_read_next_thread</a></td>
<td class="coverFnHi">145244</td>
<td class="coverFnHi">145332</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#74">io_writer_sched</a></td>
<td class="coverFnHi">112401</td>
<td class="coverFnHi">112474</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#425">io_write_preset_thread</a></td>
<td class="coverFnHi">110015</td>
<td class="coverFnHi">110103</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#432">io_write_next_thread</a></td>
<td class="coverFnHi">110015</td>
<td class="coverFnHi">110103</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#179">io_task_read_mono</a></td>
@ -137,11 +137,11 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#99">io_writer_sched_empty</a></td>
<td class="coverFnHi">2301</td>
<td class="coverFnHi">2316</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#690">io_reader_thread</a></td>
<td class="coverFnHi">647</td>
<td class="coverFnHi">648</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#720">io_writer_thread</a></td>

28
cov/cmdline/io.c.func.html
View file

@ -65,7 +65,7 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#594">io_data_read_thread</a></td>
<td class="coverFnHi">870894</td>
<td class="coverFnHi">871422</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#980">io_done</a></td>
@ -89,11 +89,11 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#604">io_parity_write_thread</a></td>
<td class="coverFnHi">553420</td>
<td class="coverFnHi">553948</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#23">io_position_next</a></td>
<td class="coverFnHi">161997</td>
<td class="coverFnHi">162085</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#124">io_read_next_mono</a></td>
@ -101,23 +101,23 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#388">io_read_next_thread</a></td>
<td class="coverFnHi">145244</td>
<td class="coverFnHi">145332</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#42">io_reader_sched</a></td>
<td class="coverFnHi">161997</td>
<td class="coverFnHi">162085</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#270">io_reader_step</a></td>
<td class="coverFnHi">1162427</td>
<td class="coverFnHi">1163270</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#690">io_reader_thread</a></td>
<td class="coverFnHi">647</td>
<td class="coverFnHi">648</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#679">io_reader_worker</a></td>
<td class="coverFnHi">1081680</td>
<td class="coverFnHi">1082209</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#174">io_refresh_mono</a></td>
@ -149,7 +149,7 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#516">io_task_read_thread</a></td>
<td class="coverFnHi">1081698</td>
<td class="coverFnHi">1082226</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#162">io_write_next_mono</a></td>
@ -157,7 +157,7 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#432">io_write_next_thread</a></td>
<td class="coverFnHi">110015</td>
<td class="coverFnHi">110103</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#142">io_write_preset_mono</a></td>
@ -165,19 +165,19 @@
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#425">io_write_preset_thread</a></td>
<td class="coverFnHi">110015</td>
<td class="coverFnHi">110103</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#74">io_writer_sched</a></td>
<td class="coverFnHi">112401</td>
<td class="coverFnHi">112474</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#99">io_writer_sched_empty</a></td>
<td class="coverFnHi">2301</td>
<td class="coverFnHi">2316</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#326">io_writer_step</a></td>
<td class="coverFnHi">553871</td>
<td class="coverFnHi">554398</td>
</tr>
<tr>
<td class="coverFn"><a href="io.c.gcov.html#720">io_writer_thread</a></td>

384
cov/cmdline/io.c.gcov.html
View file

@ -84,103 +84,103 @@
<span class="lineNum"> 22 </span> : /**
<a name="23"><span class="lineNum"> 23 </span> : * Get the next block position to process.</a>
<span class="lineNum"> 24 </span> : */
<span class="lineNum"> 25 </span><span class="lineCov"> 161997 : static block_off_t io_position_next(struct snapraid_io* io)</span>
<span class="lineNum"> 25 </span><span class="lineCov"> 162085 : static block_off_t io_position_next(struct snapraid_io* io)</span>
<span class="lineNum"> 26 </span> : {
<span class="lineNum"> 27 </span> : block_off_t blockcur;
<span class="lineNum"> 28 </span> :
<span class="lineNum"> 29 </span> : /* get the next position */
<span class="lineNum"> 30 </span><span class="lineCov"> 647430 : while (io-&gt;block_next &lt; io-&gt;block_max &amp;&amp; !io-&gt;block_is_enabled(io-&gt;block_arg, io-&gt;block_next))</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 323436 : ++io-&gt;block_next;</span>
<span class="lineNum"> 30 </span><span class="lineCov"> 647518 : while (io-&gt;block_next &lt; io-&gt;block_max &amp;&amp; !io-&gt;block_is_enabled(io-&gt;block_arg, io-&gt;block_next))</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 323348 : ++io-&gt;block_next;</span>
<span class="lineNum"> 32 </span> :
<span class="lineNum"> 33 </span><span class="lineCov"> 161997 : blockcur = io-&gt;block_next;</span>
<span class="lineNum"> 33 </span><span class="lineCov"> 162085 : blockcur = io-&gt;block_next;</span>
<span class="lineNum"> 34 </span> :
<span class="lineNum"> 35 </span> : /* next block for the next call */
<span class="lineNum"> 36 </span><span class="lineCov"> 161997 : ++io-&gt;block_next;</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 162085 : ++io-&gt;block_next;</span>
<span class="lineNum"> 37 </span> :
<span class="lineNum"> 38 </span><span class="lineCov"> 161997 : return blockcur;</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 162085 : return blockcur;</span>
<span class="lineNum"> 39 </span> : }
<span class="lineNum"> 40 </span> :
<span class="lineNum"> 41 </span> : /**
<a name="42"><span class="lineNum"> 42 </span> : * Setup the next pending task for all readers.</a>
<span class="lineNum"> 43 </span> : */
<span class="lineNum"> 44 </span><span class="lineCov"> 161997 : static void io_reader_sched(struct snapraid_io* io, int task_index, block_off_t blockcur)</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 162085 : static void io_reader_sched(struct snapraid_io* io, int task_index, block_off_t blockcur)</span>
<span class="lineNum"> 45 </span> : {
<span class="lineNum"> 46 </span> : unsigned i;
<span class="lineNum"> 47 </span> :
<span class="lineNum"> 48 </span><span class="lineCov"> 1354767 : for (i = 0; i &lt; io-&gt;reader_max; ++i) {</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 1192770 : struct snapraid_worker* worker = &amp;io-&gt;reader_map[i];</span>
<span class="lineNum"> 50 </span><span class="lineCov"> 1192770 : struct snapraid_task* task = &amp;worker-&gt;task_map[task_index];</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 1355383 : for (i = 0; i &lt; io-&gt;reader_max; ++i) {</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 1193298 : struct snapraid_worker* worker = &amp;io-&gt;reader_map[i];</span>
<span class="lineNum"> 50 </span><span class="lineCov"> 1193298 : struct snapraid_task* task = &amp;worker-&gt;task_map[task_index];</span>
<span class="lineNum"> 51 </span> :
<span class="lineNum"> 52 </span> : /* setup the new pending task */
<span class="lineNum"> 53 </span><span class="lineCov"> 1192770 : if (blockcur &lt; io-&gt;block_max)</span>
<span class="lineNum"> 54 </span><span class="lineCov"> 1109820 : task-&gt;state = TASK_STATE_READY;</span>
<span class="lineNum"> 53 </span><span class="lineCov"> 1193298 : if (blockcur &lt; io-&gt;block_max)</span>
<span class="lineNum"> 54 </span><span class="lineCov"> 1110348 : task-&gt;state = TASK_STATE_READY;</span>
<span class="lineNum"> 55 </span> : else
<span class="lineNum"> 56 </span><span class="lineCov"> 82950 : task-&gt;state = TASK_STATE_EMPTY;</span>
<span class="lineNum"> 57 </span> :
<span class="lineNum"> 58 </span><span class="lineCov"> 1192770 : task-&gt;path[0] = 0;</span>
<span class="lineNum"> 59 </span><span class="lineCov"> 1192770 : if (worker-&gt;handle)</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 971982 : task-&gt;disk = worker-&gt;handle-&gt;disk;</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 1193298 : task-&gt;path[0] = 0;</span>
<span class="lineNum"> 59 </span><span class="lineCov"> 1193298 : if (worker-&gt;handle)</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 972510 : task-&gt;disk = worker-&gt;handle-&gt;disk;</span>
<span class="lineNum"> 61 </span> : else
<span class="lineNum"> 62 </span><span class="lineCov"> 220788 : task-&gt;disk = 0;</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 1192770 : task-&gt;buffer = io-&gt;buffer_map[task_index][worker-&gt;buffer_skew + i];</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 1192770 : task-&gt;position = blockcur;</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 1192770 : task-&gt;block = 0;</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 1192770 : task-&gt;file = 0;</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 1192770 : task-&gt;file_pos = 0;</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 1192770 : task-&gt;read_size = 0;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 1192770 : task-&gt;is_timestamp_different = 0;</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 1193298 : task-&gt;buffer = io-&gt;buffer_map[task_index][worker-&gt;buffer_skew + i];</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 1193298 : task-&gt;position = blockcur;</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 1193298 : task-&gt;block = 0;</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 1193298 : task-&gt;file = 0;</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 1193298 : task-&gt;file_pos = 0;</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 1193298 : task-&gt;read_size = 0;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 1193298 : task-&gt;is_timestamp_different = 0;</span>
<span class="lineNum"> 70 </span> : }
<span class="lineNum"> 71 </span><span class="lineCov"> 161997 : }</span>
<span class="lineNum"> 71 </span><span class="lineCov"> 162085 : }</span>
<span class="lineNum"> 72 </span> :
<span class="lineNum"> 73 </span> : /**
<a name="74"><span class="lineNum"> 74 </span> : * Setup the next pending task for all writers.</a>
<span class="lineNum"> 75 </span> : */
<span class="lineNum"> 76 </span><span class="lineCov"> 112401 : static void io_writer_sched(struct snapraid_io* io, int task_index, block_off_t blockcur)</span>
<span class="lineNum"> 76 </span><span class="lineCov"> 112474 : static void io_writer_sched(struct snapraid_io* io, int task_index, block_off_t blockcur)</span>
<span class="lineNum"> 77 </span> : {
<span class="lineNum"> 78 </span> : unsigned i;
<span class="lineNum"> 79 </span> :
<span class="lineNum"> 80 </span><span class="lineCov"> 656702 : for (i = 0; i &lt; io-&gt;writer_max; ++i) {</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 544301 : struct snapraid_worker* worker = &amp;io-&gt;writer_map[i];</span>
<span class="lineNum"> 82 </span><span class="lineCov"> 544301 : struct snapraid_task* task = &amp;worker-&gt;task_map[task_index];</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 657213 : for (i = 0; i &lt; io-&gt;writer_max; ++i) {</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 544739 : struct snapraid_worker* worker = &amp;io-&gt;writer_map[i];</span>
<span class="lineNum"> 82 </span><span class="lineCov"> 544739 : struct snapraid_task* task = &amp;worker-&gt;task_map[task_index];</span>
<span class="lineNum"> 83 </span> :
<span class="lineNum"> 84 </span> : /* setup the new pending task */
<span class="lineNum"> 85 </span><span class="lineCov"> 544301 : task-&gt;state = TASK_STATE_READY;</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 544301 : task-&gt;path[0] = 0;</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 544301 : task-&gt;disk = 0;</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 544301 : task-&gt;buffer = io-&gt;buffer_map[task_index][worker-&gt;buffer_skew + i];</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 544301 : task-&gt;position = blockcur;</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 544301 : task-&gt;block = 0;</span>
<span class="lineNum"> 91 </span><span class="lineCov"> 544301 : task-&gt;file = 0;</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 544301 : task-&gt;file_pos = 0;</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 544301 : task-&gt;read_size = 0;</span>
<span class="lineNum"> 94 </span><span class="lineCov"> 544301 : task-&gt;is_timestamp_different = 0;</span>
<span class="lineNum"> 85 </span><span class="lineCov"> 544739 : task-&gt;state = TASK_STATE_READY;</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 544739 : task-&gt;path[0] = 0;</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 544739 : task-&gt;disk = 0;</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 544739 : task-&gt;buffer = io-&gt;buffer_map[task_index][worker-&gt;buffer_skew + i];</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 544739 : task-&gt;position = blockcur;</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 544739 : task-&gt;block = 0;</span>
<span class="lineNum"> 91 </span><span class="lineCov"> 544739 : task-&gt;file = 0;</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 544739 : task-&gt;file_pos = 0;</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 544739 : task-&gt;read_size = 0;</span>
<span class="lineNum"> 94 </span><span class="lineCov"> 544739 : task-&gt;is_timestamp_different = 0;</span>
<span class="lineNum"> 95 </span> : }
<span class="lineNum"> 96 </span><span class="lineCov"> 112401 : }</span>
<span class="lineNum"> 96 </span><span class="lineCov"> 112474 : }</span>
<span class="lineNum"> 97 </span> :
<span class="lineNum"> 98 </span> : /**
<a name="99"><span class="lineNum"> 99 </span> : * Setup an empty next pending task for all writers.</a>
<span class="lineNum"> 100 </span> : */
<span class="lineNum"> 101 </span><span class="lineCov"> 2301 : static void io_writer_sched_empty(struct snapraid_io* io, int task_index, block_off_t blockcur)</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 2316 : static void io_writer_sched_empty(struct snapraid_io* io, int task_index, block_off_t blockcur)</span>
<span class="lineNum"> 102 </span> : {
<span class="lineNum"> 103 </span> : unsigned i;
<span class="lineNum"> 104 </span> :
<span class="lineNum"> 105 </span><span class="lineCov"> 16107 : for (i = 0; i &lt; io-&gt;writer_max; ++i) {</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 13806 : struct snapraid_worker* worker = &amp;io-&gt;writer_map[i];</span>
<span class="lineNum"> 107 </span><span class="lineCov"> 13806 : struct snapraid_task* task = &amp;worker-&gt;task_map[task_index];</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 16212 : for (i = 0; i &lt; io-&gt;writer_max; ++i) {</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 13896 : struct snapraid_worker* worker = &amp;io-&gt;writer_map[i];</span>
<span class="lineNum"> 107 </span><span class="lineCov"> 13896 : struct snapraid_task* task = &amp;worker-&gt;task_map[task_index];</span>
<span class="lineNum"> 108 </span> :
<span class="lineNum"> 109 </span> : /* setup the new pending task */
<span class="lineNum"> 110 </span><span class="lineCov"> 13806 : task-&gt;state = TASK_STATE_EMPTY;</span>
<span class="lineNum"> 111 </span><span class="lineCov"> 13806 : task-&gt;path[0] = 0;</span>
<span class="lineNum"> 112 </span><span class="lineCov"> 13806 : task-&gt;disk = 0;</span>
<span class="lineNum"> 113 </span><span class="lineCov"> 13806 : task-&gt;buffer = 0;</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 13806 : task-&gt;position = blockcur;</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 13806 : task-&gt;block = 0;</span>
<span class="lineNum"> 116 </span><span class="lineCov"> 13806 : task-&gt;file = 0;</span>
<span class="lineNum"> 117 </span><span class="lineCov"> 13806 : task-&gt;file_pos = 0;</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 13806 : task-&gt;read_size = 0;</span>
<span class="lineNum"> 119 </span><span class="lineCov"> 13806 : task-&gt;is_timestamp_different = 0;</span>
<span class="lineNum"> 110 </span><span class="lineCov"> 13896 : task-&gt;state = TASK_STATE_EMPTY;</span>
<span class="lineNum"> 111 </span><span class="lineCov"> 13896 : task-&gt;path[0] = 0;</span>
<span class="lineNum"> 112 </span><span class="lineCov"> 13896 : task-&gt;disk = 0;</span>
<span class="lineNum"> 113 </span><span class="lineCov"> 13896 : task-&gt;buffer = 0;</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 13896 : task-&gt;position = blockcur;</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 13896 : task-&gt;block = 0;</span>
<span class="lineNum"> 116 </span><span class="lineCov"> 13896 : task-&gt;file = 0;</span>
<span class="lineNum"> 117 </span><span class="lineCov"> 13896 : task-&gt;file_pos = 0;</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 13896 : task-&gt;read_size = 0;</span>
<span class="lineNum"> 119 </span><span class="lineCov"> 13896 : task-&gt;is_timestamp_different = 0;</span>
<span class="lineNum"> 120 </span> : }
<span class="lineNum"> 121 </span><span class="lineCov"> 2301 : }</span>
<span class="lineNum"> 121 </span><span class="lineCov"> 2316 : }</span>
<span class="lineNum"> 122 </span> :
<span class="lineNum"> 123 </span> : /*****************************************************************************/
<a name="124"><span class="lineNum"> 124 </span> : /* mono thread */</a>
@ -331,55 +331,55 @@
<span class="lineNum"> 269 </span> : *
<a name="270"><span class="lineNum"> 270 </span> : * This is the synchronization point for workers with the io.</a>
<span class="lineNum"> 271 </span> : */
<span class="lineNum"> 272 </span><span class="lineCov"> 1162427 : static struct snapraid_task* io_reader_step(struct snapraid_worker* worker)</span>
<span class="lineNum"> 272 </span><span class="lineCov"> 1163270 : static struct snapraid_task* io_reader_step(struct snapraid_worker* worker)</span>
<span class="lineNum"> 273 </span> : {
<span class="lineNum"> 274 </span><span class="lineCov"> 1162427 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 274 </span><span class="lineCov"> 1163270 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 275 </span> :
<span class="lineNum"> 276 </span> : /* the synchronization is protected by the io mutex */
<span class="lineNum"> 277 </span><span class="lineCov"> 1162427 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 277 </span><span class="lineCov"> 1163270 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 278 </span> :
<span class="lineNum"> 279 </span> : while (1) {
<span class="lineNum"> 280 </span> : unsigned next_index;
<span class="lineNum"> 281 </span> :
<span class="lineNum"> 282 </span> : /* check if the worker has to exit */
<span class="lineNum"> 283 </span> : /* even if there is work to do */
<span class="lineNum"> 284 </span><span class="lineCov"> 2113405 : if (io-&gt;done) {</span>
<span class="lineNum"> 284 </span><span class="lineCov"> 2115537 : if (io-&gt;done) {</span>
<span class="lineNum"> 285 </span><span class="lineCov"> 648 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 286 </span><span class="lineCov"> 648 : return 0;</span>
<span class="lineNum"> 287 </span> : }
<span class="lineNum"> 288 </span> :
<span class="lineNum"> 289 </span> : /* get the next pending task */
<span class="lineNum"> 290 </span><span class="lineCov"> 2112757 : next_index = (worker-&gt;index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 290 </span><span class="lineCov"> 2114889 : next_index = (worker-&gt;index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 291 </span> :
<span class="lineNum"> 292 </span> : /* if the queue of pending tasks is not empty */
<span class="lineNum"> 293 </span><span class="lineCov"> 2112757 : if (next_index != io-&gt;reader_index) {</span>
<span class="lineNum"> 293 </span><span class="lineCov"> 2114889 : if (next_index != io-&gt;reader_index) {</span>
<span class="lineNum"> 294 </span> : struct snapraid_task* task;
<span class="lineNum"> 295 </span> :
<span class="lineNum"> 296 </span> : /* the index that the IO may be waiting for */
<span class="lineNum"> 297 </span><span class="lineCov"> 1162458 : unsigned waiting_index = io-&gt;reader_index;</span>
<span class="lineNum"> 297 </span><span class="lineCov"> 1163467 : unsigned waiting_index = io-&gt;reader_index;</span>
<span class="lineNum"> 298 </span> :
<span class="lineNum"> 299 </span> : /* the index that worker just completed */
<span class="lineNum"> 300 </span><span class="lineCov"> 1162458 : unsigned done_index = worker-&gt;index;</span>
<span class="lineNum"> 300 </span><span class="lineCov"> 1163467 : unsigned done_index = worker-&gt;index;</span>
<span class="lineNum"> 301 </span> :
<span class="lineNum"> 302 </span> : /* get the new working task */
<span class="lineNum"> 303 </span><span class="lineCov"> 1162458 : worker-&gt;index = next_index;</span>
<span class="lineNum"> 304 </span><span class="lineCov"> 1162458 : task = &amp;worker-&gt;task_map[worker-&gt;index];</span>
<span class="lineNum"> 303 </span><span class="lineCov"> 1163467 : worker-&gt;index = next_index;</span>
<span class="lineNum"> 304 </span><span class="lineCov"> 1163467 : task = &amp;worker-&gt;task_map[worker-&gt;index];</span>
<span class="lineNum"> 305 </span> :
<span class="lineNum"> 306 </span> : /* if the just completed task is at this index */
<span class="lineNum"> 307 </span><span class="lineCov"> 1162458 : if (done_index == waiting_index) {</span>
<span class="lineNum"> 307 </span><span class="lineCov"> 1163467 : if (done_index == waiting_index) {</span>
<span class="lineNum"> 308 </span> : /* notify the IO that a new read is complete */
<span class="lineNum"> 309 </span><span class="lineCov"> 2144 : thread_cond_signal_and_unlock(&amp;io-&gt;read_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 309 </span><span class="lineCov"> 1460 : thread_cond_signal_and_unlock(&amp;io-&gt;read_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 310 </span> : } else {
<span class="lineNum"> 311 </span><span class="lineCov"> 1160314 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 311 </span><span class="lineCov"> 1162007 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 312 </span> : }
<span class="lineNum"> 313 </span> :
<span class="lineNum"> 314 </span> : /* return the new task */
<span class="lineNum"> 315 </span><span class="lineCov"> 1162363 : return task;</span>
<span class="lineNum"> 315 </span><span class="lineCov"> 1163329 : return task;</span>
<span class="lineNum"> 316 </span> : }
<span class="lineNum"> 317 </span> :
<span class="lineNum"> 318 </span> : /* otherwise wait for a read_sched event */
<span class="lineNum"> 319 </span><span class="lineCov"> 950299 : thread_cond_wait(&amp;io-&gt;read_sched, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 320 </span><span class="lineCov"> 950299 : }</span>
<span class="lineNum"> 319 </span><span class="lineCov"> 951422 : thread_cond_wait(&amp;io-&gt;read_sched, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 320 </span><span class="lineCov"> 951422 : }</span>
<span class="lineNum"> 321 </span> : }
<span class="lineNum"> 322 </span> :
<span class="lineNum"> 323 </span> : /**
@ -387,61 +387,61 @@
<span class="lineNum"> 325 </span> : *
<a name="326"><span class="lineNum"> 326 </span> : * This is the synchronization point for workers with the io.</a>
<span class="lineNum"> 327 </span> : */
<span class="lineNum"> 328 </span><span class="lineCov"> 553871 : static struct snapraid_task* io_writer_step(struct snapraid_worker* worker, int state)</span>
<span class="lineNum"> 328 </span><span class="lineCov"> 554398 : static struct snapraid_task* io_writer_step(struct snapraid_worker* worker, int state)</span>
<span class="lineNum"> 329 </span> : {
<span class="lineNum"> 330 </span><span class="lineCov"> 553871 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 330 </span><span class="lineCov"> 554398 : struct snapraid_io* io = worker-&gt;io;</span>
<span class="lineNum"> 331 </span> : int error_index;
<span class="lineNum"> 332 </span> :
<span class="lineNum"> 333 </span> : /* the synchronization is protected by the io mutex */
<span class="lineNum"> 334 </span><span class="lineCov"> 553871 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 334 </span><span class="lineCov"> 554398 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 335 </span> :
<span class="lineNum"> 336 </span> : /* counts the number of errors in the global state */
<span class="lineNum"> 337 </span><span class="lineCov"> 553882 : error_index = state - IO_WRITER_ERROR_BASE;</span>
<span class="lineNum"> 338 </span><span class="lineCov"> 553882 : if (error_index &gt;= 0 &amp;&amp; error_index &lt; IO_WRITER_ERROR_MAX)</span>
<span class="lineNum"> 337 </span><span class="lineCov"> 554410 : error_index = state - IO_WRITER_ERROR_BASE;</span>
<span class="lineNum"> 338 </span><span class="lineCov"> 554410 : if (error_index &gt;= 0 &amp;&amp; error_index &lt; IO_WRITER_ERROR_MAX)</span>
<span class="lineNum"> 339 </span><span class="lineNoCov"> 0 : ++io-&gt;writer_error[error_index];</span>
<span class="lineNum"> 340 </span> :
<span class="lineNum"> 341 </span> : while (1) {
<span class="lineNum"> 342 </span> : unsigned next_index;
<span class="lineNum"> 343 </span> :
<span class="lineNum"> 344 </span> : /* get the next pending task */
<span class="lineNum"> 345 </span><span class="lineCov"> 630858 : next_index = (worker-&gt;index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 345 </span><span class="lineCov"> 631068 : next_index = (worker-&gt;index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 346 </span> :
<span class="lineNum"> 347 </span> : /* if the queue of pending tasks is not empty */
<span class="lineNum"> 348 </span><span class="lineCov"> 630858 : if (next_index != io-&gt;writer_index) {</span>
<span class="lineNum"> 348 </span><span class="lineCov"> 631068 : if (next_index != io-&gt;writer_index) {</span>
<span class="lineNum"> 349 </span> : struct snapraid_task* task;
<span class="lineNum"> 350 </span> :
<span class="lineNum"> 351 </span> : /* the index that the IO may be waiting for */
<span class="lineNum"> 352 </span><span class="lineCov"> 553420 : unsigned waiting_index = (io-&gt;writer_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 553948 : unsigned waiting_index = (io-&gt;writer_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 353 </span> :
<span class="lineNum"> 354 </span> : /* the index that worker just completed */
<span class="lineNum"> 355 </span><span class="lineCov"> 553420 : unsigned done_index = worker-&gt;index;</span>
<span class="lineNum"> 355 </span><span class="lineCov"> 553948 : unsigned done_index = worker-&gt;index;</span>
<span class="lineNum"> 356 </span> :
<span class="lineNum"> 357 </span> : /* get the new working task */
<span class="lineNum"> 358 </span><span class="lineCov"> 553420 : worker-&gt;index = next_index;</span>
<span class="lineNum"> 359 </span><span class="lineCov"> 553420 : task = &amp;worker-&gt;task_map[worker-&gt;index];</span>
<span class="lineNum"> 358 </span><span class="lineCov"> 553948 : worker-&gt;index = next_index;</span>
<span class="lineNum"> 359 </span><span class="lineCov"> 553948 : task = &amp;worker-&gt;task_map[worker-&gt;index];</span>
<span class="lineNum"> 360 </span> :
<span class="lineNum"> 361 </span> : /* if the just completed task is at this index */
<span class="lineNum"> 362 </span><span class="lineCov"> 553420 : if (done_index == waiting_index) {</span>
<span class="lineNum"> 362 </span><span class="lineCov"> 553948 : if (done_index == waiting_index) {</span>
<span class="lineNum"> 363 </span> : /* notify the IO that a new write is complete */
<span class="lineNum"> 364 </span><span class="lineCov"> 82404 : thread_cond_signal_and_unlock(&amp;io-&gt;write_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 364 </span><span class="lineCov"> 81705 : thread_cond_signal_and_unlock(&amp;io-&gt;write_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 365 </span> : } else {
<span class="lineNum"> 366 </span><span class="lineCov"> 471016 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 366 </span><span class="lineCov"> 472243 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 367 </span> : }
<span class="lineNum"> 368 </span> :
<span class="lineNum"> 369 </span> : /* return the new task */
<span class="lineNum"> 370 </span><span class="lineCov"> 553404 : return task;</span>
<span class="lineNum"> 370 </span><span class="lineCov"> 553938 : return task;</span>
<span class="lineNum"> 371 </span> : }
<span class="lineNum"> 372 </span> :
<span class="lineNum"> 373 </span> : /* check if the worker has to exit */
<span class="lineNum"> 374 </span> : /* but only if there is no work to do */
<span class="lineNum"> 375 </span><span class="lineCov"> 77438 : if (io-&gt;done) {</span>
<span class="lineNum"> 375 </span><span class="lineCov"> 77120 : if (io-&gt;done) {</span>
<span class="lineNum"> 376 </span><span class="lineCov"> 462 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 377 </span><span class="lineCov"> 462 : return 0;</span>
<span class="lineNum"> 378 </span> : }
<span class="lineNum"> 379 </span> :
<span class="lineNum"> 380 </span> : /* otherwise wait for a write_sched event */
<span class="lineNum"> 381 </span><span class="lineCov"> 76976 : thread_cond_wait(&amp;io-&gt;write_sched, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 382 </span><span class="lineCov"> 76976 : }</span>
<span class="lineNum"> 381 </span><span class="lineCov"> 76658 : thread_cond_wait(&amp;io-&gt;write_sched, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 382 </span><span class="lineCov"> 76658 : }</span>
<span class="lineNum"> 383 </span> : }
<span class="lineNum"> 384 </span> :
<span class="lineNum"> 385 </span> : /**
@ -449,87 +449,87 @@
<span class="lineNum"> 387 </span> : *
<a name="388"><span class="lineNum"> 388 </span> : * This is the synchronization point for workers with the io.</a>
<span class="lineNum"> 389 </span> : */
<span class="lineNum"> 390 </span><span class="lineCov"> 145244 : static block_off_t io_read_next_thread(struct snapraid_io* io, void*** buffer)</span>
<span class="lineNum"> 390 </span><span class="lineCov"> 145332 : static block_off_t io_read_next_thread(struct snapraid_io* io, void*** buffer)</span>
<span class="lineNum"> 391 </span> : {
<span class="lineNum"> 392 </span> : block_off_t blockcur_schedule;
<span class="lineNum"> 393 </span> : block_off_t blockcur_caller;
<span class="lineNum"> 394 </span> : unsigned i;
<span class="lineNum"> 395 </span> :
<span class="lineNum"> 396 </span> : /* get the next parity position to process */
<span class="lineNum"> 397 </span><span class="lineCov"> 145244 : blockcur_schedule = io_position_next(io);</span>
<span class="lineNum"> 397 </span><span class="lineCov"> 145332 : blockcur_schedule = io_position_next(io);</span>
<span class="lineNum"> 398 </span> :
<span class="lineNum"> 399 </span> : /* ensure that all data/parity was read */
<span class="lineNum"> 400 </span><span class="lineCov"> 145244 : assert(io-&gt;reader_list[0] == io-&gt;reader_max);</span>
<span class="lineNum"> 400 </span><span class="lineCov"> 145332 : assert(io-&gt;reader_list[0] == io-&gt;reader_max);</span>
<span class="lineNum"> 401 </span> :
<span class="lineNum"> 402 </span> : /* setup the list of workers to process */
<span class="lineNum"> 403 </span><span class="lineCov"> 1372834 : for (i = 0; i &lt;= io-&gt;reader_max; ++i)</span>
<span class="lineNum"> 404 </span><span class="lineCov"> 1227590 : io-&gt;reader_list[i] = i;</span>
<span class="lineNum"> 403 </span><span class="lineCov"> 1373538 : for (i = 0; i &lt;= io-&gt;reader_max; ++i)</span>
<span class="lineNum"> 404 </span><span class="lineCov"> 1228206 : io-&gt;reader_list[i] = i;</span>
<span class="lineNum"> 405 </span> :
<span class="lineNum"> 406 </span> : /* the synchronization is protected by the io mutex */
<span class="lineNum"> 407 </span><span class="lineCov"> 145244 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 407 </span><span class="lineCov"> 145332 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 408 </span> :
<span class="lineNum"> 409 </span> : /* schedule the next read */
<span class="lineNum"> 410 </span><span class="lineCov"> 145244 : io_reader_sched(io, io-&gt;reader_index, blockcur_schedule);</span>
<span class="lineNum"> 410 </span><span class="lineCov"> 145332 : io_reader_sched(io, io-&gt;reader_index, blockcur_schedule);</span>
<span class="lineNum"> 411 </span> :
<span class="lineNum"> 412 </span> : /* set the index for the tasks to return to the caller */
<span class="lineNum"> 413 </span><span class="lineCov"> 145244 : io-&gt;reader_index = (io-&gt;reader_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 413 </span><span class="lineCov"> 145332 : io-&gt;reader_index = (io-&gt;reader_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 414 </span> :
<span class="lineNum"> 415 </span> : /* get the position to operate at high level from one task */
<span class="lineNum"> 416 </span><span class="lineCov"> 145244 : blockcur_caller = io-&gt;reader_map[0].task_map[io-&gt;reader_index].position;</span>
<span class="lineNum"> 416 </span><span class="lineCov"> 145332 : blockcur_caller = io-&gt;reader_map[0].task_map[io-&gt;reader_index].position;</span>
<span class="lineNum"> 417 </span> :
<span class="lineNum"> 418 </span> : /* set the buffer to use */
<span class="lineNum"> 419 </span><span class="lineCov"> 145244 : *buffer = io-&gt;buffer_map[io-&gt;reader_index];</span>
<span class="lineNum"> 419 </span><span class="lineCov"> 145332 : *buffer = io-&gt;buffer_map[io-&gt;reader_index];</span>
<span class="lineNum"> 420 </span> :
<span class="lineNum"> 421 </span> : /* signal all the workers that there is a new pending task */
<span class="lineNum"> 422 </span><span class="lineCov"> 145244 : thread_cond_broadcast_and_unlock(&amp;io-&gt;read_sched, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 422 </span><span class="lineCov"> 145332 : thread_cond_broadcast_and_unlock(&amp;io-&gt;read_sched, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 423 </span> :
<span class="lineNum"> 424 </span><span class="lineCov"> 145244 : return blockcur_caller;</span>
<span class="lineNum"> 424 </span><span class="lineCov"> 145332 : return blockcur_caller;</span>
<a name="425"><span class="lineNum"> 425 </span> : }</a>
<span class="lineNum"> 426 </span> :
<span class="lineNum"> 427 </span><span class="lineCov"> 110015 : static void io_write_preset_thread(struct snapraid_io* io, block_off_t blockcur, int skip)</span>
<span class="lineNum"> 427 </span><span class="lineCov"> 110103 : static void io_write_preset_thread(struct snapraid_io* io, block_off_t blockcur, int skip)</span>
<span class="lineNum"> 428 </span> : {
<span class="lineNum"> 429 </span> : (void)io;
<span class="lineNum"> 430 </span> : (void)blockcur;
<span class="lineNum"> 431 </span> : (void)skip;
<a name="432"><span class="lineNum"> 432 </span><span class="lineCov"> 110015 : }</span></a>
<a name="432"><span class="lineNum"> 432 </span><span class="lineCov"> 110103 : }</span></a>
<span class="lineNum"> 433 </span> :
<span class="lineNum"> 434 </span><span class="lineCov"> 110015 : static void io_write_next_thread(struct snapraid_io* io, block_off_t blockcur, int skip, int* writer_error)</span>
<span class="lineNum"> 434 </span><span class="lineCov"> 110103 : static void io_write_next_thread(struct snapraid_io* io, block_off_t blockcur, int skip, int* writer_error)</span>
<span class="lineNum"> 435 </span> : {
<span class="lineNum"> 436 </span> : unsigned i;
<span class="lineNum"> 437 </span> :
<span class="lineNum"> 438 </span> : /* ensure that all parity was written */
<span class="lineNum"> 439 </span><span class="lineCov"> 110015 : assert(io-&gt;writer_list[0] == io-&gt;writer_max);</span>
<span class="lineNum"> 439 </span><span class="lineCov"> 110103 : assert(io-&gt;writer_list[0] == io-&gt;writer_max);</span>
<span class="lineNum"> 440 </span> :
<span class="lineNum"> 441 </span> : /* setup the list of workers to process */
<span class="lineNum"> 442 </span><span class="lineCov"> 773450 : for (i = 0; i &lt;= io-&gt;writer_max; ++i)</span>
<span class="lineNum"> 443 </span><span class="lineCov"> 663435 : io-&gt;writer_list[i] = i;</span>
<span class="lineNum"> 442 </span><span class="lineCov"> 774154 : for (i = 0; i &lt;= io-&gt;writer_max; ++i)</span>
<span class="lineNum"> 443 </span><span class="lineCov"> 664051 : io-&gt;writer_list[i] = i;</span>
<span class="lineNum"> 444 </span> :
<span class="lineNum"> 445 </span> : /* the synchronization is protected by the io mutex */
<span class="lineNum"> 446 </span><span class="lineCov"> 110015 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 446 </span><span class="lineCov"> 110103 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 447 </span> :
<span class="lineNum"> 448 </span> : /* report errors */
<span class="lineNum"> 449 </span><span class="lineCov"> 550075 : for (i = 0; i &lt; IO_WRITER_ERROR_MAX; ++i) {</span>
<span class="lineNum"> 450 </span><span class="lineCov"> 440060 : writer_error[i] = io-&gt;writer_error[i];</span>
<span class="lineNum"> 451 </span><span class="lineCov"> 440060 : io-&gt;writer_error[i] = 0;</span>
<span class="lineNum"> 449 </span><span class="lineCov"> 550515 : for (i = 0; i &lt; IO_WRITER_ERROR_MAX; ++i) {</span>
<span class="lineNum"> 450 </span><span class="lineCov"> 440412 : writer_error[i] = io-&gt;writer_error[i];</span>
<span class="lineNum"> 451 </span><span class="lineCov"> 440412 : io-&gt;writer_error[i] = 0;</span>
<span class="lineNum"> 452 </span> : }
<span class="lineNum"> 453 </span> :
<span class="lineNum"> 454 </span><span class="lineCov"> 110015 : if (skip) {</span>
<span class="lineNum"> 454 </span><span class="lineCov"> 110103 : if (skip) {</span>
<span class="lineNum"> 455 </span> : /* skip the next write */
<span class="lineNum"> 456 </span><span class="lineCov"> 2301 : io_writer_sched_empty(io, io-&gt;writer_index, blockcur);</span>
<span class="lineNum"> 456 </span><span class="lineCov"> 2316 : io_writer_sched_empty(io, io-&gt;writer_index, blockcur);</span>
<span class="lineNum"> 457 </span> : } else {
<span class="lineNum"> 458 </span> : /* schedule the next write */
<span class="lineNum"> 459 </span><span class="lineCov"> 107714 : io_writer_sched(io, io-&gt;writer_index, blockcur);</span>
<span class="lineNum"> 459 </span><span class="lineCov"> 107787 : io_writer_sched(io, io-&gt;writer_index, blockcur);</span>
<span class="lineNum"> 460 </span> : }
<span class="lineNum"> 461 </span> :
<span class="lineNum"> 462 </span> : /* at this point the writers must be in sync with the readers */
<span class="lineNum"> 463 </span><span class="lineCov"> 110015 : assert(io-&gt;writer_index == io-&gt;reader_index);</span>
<span class="lineNum"> 463 </span><span class="lineCov"> 110103 : assert(io-&gt;writer_index == io-&gt;reader_index);</span>
<span class="lineNum"> 464 </span> :
<span class="lineNum"> 465 </span> : /* set the index to be used for the next write */
<span class="lineNum"> 466 </span><span class="lineCov"> 110015 : io-&gt;writer_index = (io-&gt;writer_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 466 </span><span class="lineCov"> 110103 : io-&gt;writer_index = (io-&gt;writer_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 467 </span> :
<span class="lineNum"> 468 </span> : /* signal all the workers that there is a new pending task */
<span class="lineNum"> 469 </span><span class="lineCov"> 110015 : thread_cond_broadcast_and_unlock(&amp;io-&gt;write_sched, &amp;io-&gt;io_mutex);</span>
<a name="470"><span class="lineNum"> 470 </span><span class="lineCov"> 110015 : }</span></a>
<span class="lineNum"> 469 </span><span class="lineCov"> 110103 : thread_cond_broadcast_and_unlock(&amp;io-&gt;write_sched, &amp;io-&gt;io_mutex);</span>
<a name="470"><span class="lineNum"> 470 </span><span class="lineCov"> 110103 : }</span></a>
<span class="lineNum"> 471 </span> :
<span class="lineNum"> 472 </span><span class="lineNoCov"> 0 : static void io_refresh_thread(struct snapraid_io* io)</span>
<span class="lineNum"> 473 </span> : {
@ -577,18 +577,18 @@
<span class="lineNum"> 515 </span><span class="lineNoCov"> 0 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<a name="516"><span class="lineNum"> 516 </span><span class="lineNoCov"> 0 : }</span></a>
<span class="lineNum"> 517 </span> :
<span class="lineNum"> 518 </span><span class="lineCov"> 1081698 : static struct snapraid_task* io_task_read_thread(struct snapraid_io* io, unsigned base, unsigned count, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
<span class="lineNum"> 518 </span><span class="lineCov"> 1082226 : static struct snapraid_task* io_task_read_thread(struct snapraid_io* io, unsigned base, unsigned count, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
<span class="lineNum"> 519 </span> : {
<span class="lineNum"> 520 </span> : unsigned waiting_cycle;
<span class="lineNum"> 521 </span> :
<span class="lineNum"> 522 </span> : /* count the waiting cycle */
<span class="lineNum"> 523 </span><span class="lineCov"> 1081698 : waiting_cycle = 0;</span>
<span class="lineNum"> 523 </span><span class="lineCov"> 1082226 : waiting_cycle = 0;</span>
<span class="lineNum"> 524 </span> :
<span class="lineNum"> 525 </span> : /* clear the waiting indexes */
<span class="lineNum"> 526 </span><span class="lineCov"> 1081698 : *waiting_mac = 0;</span>
<span class="lineNum"> 526 </span><span class="lineCov"> 1082226 : *waiting_mac = 0;</span>
<span class="lineNum"> 527 </span> :
<span class="lineNum"> 528 </span> : /* the synchronization is protected by the io mutex */
<span class="lineNum"> 529 </span><span class="lineCov"> 1081698 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 529 </span><span class="lineCov"> 1082226 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 530 </span> :
<span class="lineNum"> 531 </span> : while (1) {
<span class="lineNum"> 532 </span> : unsigned char* let;
@ -597,67 +597,67 @@
<span class="lineNum"> 535 </span> : /* get the index the IO is using */
<span class="lineNum"> 536 </span> : /* we must ensure that this index has not a read in progress */
<span class="lineNum"> 537 </span> : /* to avoid a concurrent access */
<span class="lineNum"> 538 </span><span class="lineCov"> 1083699 : busy_index = io-&gt;reader_index;</span>
<span class="lineNum"> 538 </span><span class="lineCov"> 1083535 : busy_index = io-&gt;reader_index;</span>
<span class="lineNum"> 539 </span> :
<span class="lineNum"> 540 </span> : /* search for a worker that has already finished */
<span class="lineNum"> 541 </span><span class="lineCov"> 1083699 : let = &amp;io-&gt;reader_list[0];</span>
<span class="lineNum"> 541 </span><span class="lineCov"> 1083535 : let = &amp;io-&gt;reader_list[0];</span>
<span class="lineNum"> 542 </span> : while (1) {
<span class="lineNum"> 543 </span><span class="lineCov"> 1091880 : unsigned i = *let;</span>
<span class="lineNum"> 543 </span><span class="lineCov"> 1090052 : unsigned i = *let;</span>
<span class="lineNum"> 544 </span> :
<span class="lineNum"> 545 </span> : /* if we are at the end */
<span class="lineNum"> 546 </span><span class="lineCov"> 1091880 : if (i == io-&gt;reader_max)</span>
<span class="lineNum"> 547 </span><span class="lineCov"> 2001 : break;</span>
<span class="lineNum"> 546 </span><span class="lineCov"> 1090052 : if (i == io-&gt;reader_max)</span>
<span class="lineNum"> 547 </span><span class="lineCov"> 1309 : break;</span>
<span class="lineNum"> 548 </span> :
<span class="lineNum"> 549 </span> : /* if it's in range */
<span class="lineNum"> 550 </span><span class="lineCov"> 1089879 : if (base &lt;= i &amp;&amp; i &lt; base + count) {</span>
<span class="lineNum"> 550 </span><span class="lineCov"> 1088743 : if (base &lt;= i &amp;&amp; i &lt; base + count) {</span>
<span class="lineNum"> 551 </span> : struct snapraid_worker* worker;
<span class="lineNum"> 552 </span> :
<span class="lineNum"> 553 </span> : /* if it's the first cycle */
<span class="lineNum"> 554 </span><span class="lineCov"> 1088355 : if (waiting_cycle == 0) {</span>
<span class="lineNum"> 554 </span><span class="lineCov"> 1087753 : if (waiting_cycle == 0) {</span>
<span class="lineNum"> 555 </span> : /* store the waiting indexes */
<span class="lineNum"> 556 </span><span class="lineCov"> 1085928 : waiting_map[(*waiting_mac)++] = i - base;</span>
<span class="lineNum"> 556 </span><span class="lineCov"> 1086091 : waiting_map[(*waiting_mac)++] = i - base;</span>
<span class="lineNum"> 557 </span> : }
<span class="lineNum"> 558 </span> :
<span class="lineNum"> 559 </span><span class="lineCov"> 1088355 : worker = &amp;io-&gt;reader_map[i];</span>
<span class="lineNum"> 559 </span><span class="lineCov"> 1087753 : worker = &amp;io-&gt;reader_map[i];</span>
<span class="lineNum"> 560 </span> :
<span class="lineNum"> 561 </span> : /* if the worker has finished this index */
<span class="lineNum"> 562 </span><span class="lineCov"> 1088355 : if (busy_index != worker-&gt;index) {</span>
<span class="lineNum"> 562 </span><span class="lineCov"> 1087753 : if (busy_index != worker-&gt;index) {</span>
<span class="lineNum"> 563 </span> : struct snapraid_task* task;
<span class="lineNum"> 564 </span> :
<span class="lineNum"> 565 </span><span class="lineCov"> 1081698 : task = &amp;worker-&gt;task_map[io-&gt;reader_index];</span>
<span class="lineNum"> 565 </span><span class="lineCov"> 1082226 : task = &amp;worker-&gt;task_map[io-&gt;reader_index];</span>
<span class="lineNum"> 566 </span> :
<span class="lineNum"> 567 </span><span class="lineCov"> 1081698 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 567 </span><span class="lineCov"> 1082226 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 568 </span> :
<span class="lineNum"> 569 </span> : /* mark the worker as processed */
<span class="lineNum"> 570 </span> : /* setting the previous one to point at the next one */
<span class="lineNum"> 571 </span><span class="lineCov"> 1081698 : *let = io-&gt;reader_list[i + 1];</span>
<span class="lineNum"> 571 </span><span class="lineCov"> 1082226 : *let = io-&gt;reader_list[i + 1];</span>
<span class="lineNum"> 572 </span> :
<span class="lineNum"> 573 </span> : /* return the position */
<span class="lineNum"> 574 </span><span class="lineCov"> 1081698 : *pos = i - base;</span>
<span class="lineNum"> 574 </span><span class="lineCov"> 1082226 : *pos = i - base;</span>
<span class="lineNum"> 575 </span> :
<span class="lineNum"> 576 </span> : /* on the first cycle, no one is waiting */
<span class="lineNum"> 577 </span><span class="lineCov"> 1081698 : if (waiting_cycle == 0)</span>
<span class="lineNum"> 578 </span><span class="lineCov"> 1079732 : *waiting_mac = 0;</span>
<span class="lineNum"> 577 </span><span class="lineCov"> 1082226 : if (waiting_cycle == 0)</span>
<span class="lineNum"> 578 </span><span class="lineCov"> 1080944 : *waiting_mac = 0;</span>
<span class="lineNum"> 579 </span> :
<span class="lineNum"> 580 </span><span class="lineCov"> 2163396 : return task;</span>
<span class="lineNum"> 580 </span><span class="lineCov"> 2164452 : return task;</span>
<span class="lineNum"> 581 </span> : }
<span class="lineNum"> 582 </span> : }
<span class="lineNum"> 583 </span> :
<span class="lineNum"> 584 </span> : /* next position to check */
<span class="lineNum"> 585 </span><span class="lineCov"> 8181 : let = &amp;io-&gt;reader_list[i + 1];</span>
<span class="lineNum"> 586 </span><span class="lineCov"> 8181 : }</span>
<span class="lineNum"> 585 </span><span class="lineCov"> 6517 : let = &amp;io-&gt;reader_list[i + 1];</span>
<span class="lineNum"> 586 </span><span class="lineCov"> 6517 : }</span>
<span class="lineNum"> 587 </span> :
<span class="lineNum"> 588 </span> : /* if no worker is ready, wait for an event */
<span class="lineNum"> 589 </span><span class="lineCov"> 2001 : thread_cond_wait(&amp;io-&gt;read_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 589 </span><span class="lineCov"> 1309 : thread_cond_wait(&amp;io-&gt;read_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 590 </span> :
<span class="lineNum"> 591 </span> : /* count the cycles */
<span class="lineNum"> 592 </span><span class="lineCov"> 2001 : ++waiting_cycle;</span>
<span class="lineNum"> 593 </span><span class="lineCov"> 2001 : }</span>
<span class="lineNum"> 592 </span><span class="lineCov"> 1309 : ++waiting_cycle;</span>
<span class="lineNum"> 593 </span><span class="lineCov"> 1309 : }</span>
<a name="594"><span class="lineNum"> 594 </span> : }</a>
<span class="lineNum"> 595 </span> :
<span class="lineNum"> 596 </span><span class="lineCov"> 870894 : static struct snapraid_task* io_data_read_thread(struct snapraid_io* io, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
<span class="lineNum"> 596 </span><span class="lineCov"> 871422 : static struct snapraid_task* io_data_read_thread(struct snapraid_io* io, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
<span class="lineNum"> 597 </span> : {
<span class="lineNum"> 598 </span><span class="lineCov"> 870894 : return io_task_read_thread(io, io-&gt;data_base, io-&gt;data_count, pos, waiting_map, waiting_mac);</span>
<span class="lineNum"> 598 </span><span class="lineCov"> 871422 : return io_task_read_thread(io, io-&gt;data_base, io-&gt;data_count, pos, waiting_map, waiting_mac);</span>
<a name="599"><span class="lineNum"> 599 </span> : }</a>
<span class="lineNum"> 600 </span> :
<span class="lineNum"> 601 </span><span class="lineCov"> 210804 : static struct snapraid_task* io_parity_read_thread(struct snapraid_io* io, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
@ -665,18 +665,18 @@
<span class="lineNum"> 603 </span><span class="lineCov"> 210804 : return io_task_read_thread(io, io-&gt;parity_base, io-&gt;parity_count, pos, waiting_map, waiting_mac);</span>
<a name="604"><span class="lineNum"> 604 </span> : }</a>
<span class="lineNum"> 605 </span> :
<span class="lineNum"> 606 </span><span class="lineCov"> 553420 : static void io_parity_write_thread(struct snapraid_io* io, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
<span class="lineNum"> 606 </span><span class="lineCov"> 553948 : static void io_parity_write_thread(struct snapraid_io* io, unsigned* pos, unsigned* waiting_map, unsigned* waiting_mac)</span>
<span class="lineNum"> 607 </span> : {
<span class="lineNum"> 608 </span> : unsigned waiting_cycle;
<span class="lineNum"> 609 </span> :
<span class="lineNum"> 610 </span> : /* count the waiting cycle */
<span class="lineNum"> 611 </span><span class="lineCov"> 553420 : waiting_cycle = 0;</span>
<span class="lineNum"> 611 </span><span class="lineCov"> 553948 : waiting_cycle = 0;</span>
<span class="lineNum"> 612 </span> :
<span class="lineNum"> 613 </span> : /* clear the waiting indexes */
<span class="lineNum"> 614 </span><span class="lineCov"> 553420 : *waiting_mac = 0;</span>
<span class="lineNum"> 614 </span><span class="lineCov"> 553948 : *waiting_mac = 0;</span>
<span class="lineNum"> 615 </span> :
<span class="lineNum"> 616 </span> : /* the synchronization is protected by the io mutex */
<span class="lineNum"> 617 </span><span class="lineCov"> 553420 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 617 </span><span class="lineCov"> 553948 : thread_mutex_lock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 618 </span> :
<span class="lineNum"> 619 </span> : while (1) {
<span class="lineNum"> 620 </span> : unsigned char* let;
@ -687,96 +687,96 @@
<span class="lineNum"> 625 </span> : /* to avoid a concurrent access */
<span class="lineNum"> 626 </span> : /* note that we are already sure that a write is not in progress */
<span class="lineNum"> 627 </span> : /* at the index the IO is using at now */
<span class="lineNum"> 628 </span><span class="lineCov"> 619337 : busy_index = (io-&gt;writer_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 628 </span><span class="lineCov"> 619618 : busy_index = (io-&gt;writer_index + 1) % io-&gt;io_max;</span>
<span class="lineNum"> 629 </span> :
<span class="lineNum"> 630 </span> : /* search for a worker that has already finished */
<span class="lineNum"> 631 </span><span class="lineCov"> 619337 : let = &amp;io-&gt;writer_list[0];</span>
<span class="lineNum"> 631 </span><span class="lineCov"> 619618 : let = &amp;io-&gt;writer_list[0];</span>
<span class="lineNum"> 632 </span> : while (1) {
<span class="lineNum"> 633 </span><span class="lineCov"> 866114 : unsigned i = *let;</span>
<span class="lineNum"> 633 </span><span class="lineCov"> 802324 : unsigned i = *let;</span>
<span class="lineNum"> 634 </span> : struct snapraid_worker* worker;
<span class="lineNum"> 635 </span> :
<span class="lineNum"> 636 </span> : /* if we are at the end */
<span class="lineNum"> 637 </span><span class="lineCov"> 866114 : if (i == io-&gt;writer_max)</span>
<span class="lineNum"> 638 </span><span class="lineCov"> 65917 : break;</span>
<span class="lineNum"> 637 </span><span class="lineCov"> 802324 : if (i == io-&gt;writer_max)</span>
<span class="lineNum"> 638 </span><span class="lineCov"> 65670 : break;</span>
<span class="lineNum"> 639 </span> :
<span class="lineNum"> 640 </span> : /* if it's the first cycle */
<span class="lineNum"> 641 </span><span class="lineCov"> 800197 : if (waiting_cycle == 0) {</span>
<span class="lineNum"> 641 </span><span class="lineCov"> 736654 : if (waiting_cycle == 0) {</span>
<span class="lineNum"> 642 </span> : /* store the waiting indexes */
<span class="lineNum"> 643 </span><span class="lineCov"> 733517 : waiting_map[(*waiting_mac)++] = i;</span>
<span class="lineNum"> 643 </span><span class="lineCov"> 670497 : waiting_map[(*waiting_mac)++] = i;</span>
<span class="lineNum"> 644 </span> : }
<span class="lineNum"> 645 </span> :
<span class="lineNum"> 646 </span><span class="lineCov"> 800197 : worker = &amp;io-&gt;writer_map[i];</span>
<span class="lineNum"> 646 </span><span class="lineCov"> 736654 : worker = &amp;io-&gt;writer_map[i];</span>
<span class="lineNum"> 647 </span> :
<span class="lineNum"> 648 </span> : /* the two indexes cannot be equal */
<span class="lineNum"> 649 </span><span class="lineCov"> 800197 : assert(io-&gt;writer_index != worker-&gt;index);</span>
<span class="lineNum"> 649 </span><span class="lineCov"> 736654 : assert(io-&gt;writer_index != worker-&gt;index);</span>
<span class="lineNum"> 650 </span> :
<span class="lineNum"> 651 </span> : /* if the worker has finished this index */
<span class="lineNum"> 652 </span><span class="lineCov"> 800197 : if (busy_index != worker-&gt;index) {</span>
<span class="lineNum"> 653 </span><span class="lineCov"> 553420 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 652 </span><span class="lineCov"> 736654 : if (busy_index != worker-&gt;index) {</span>
<span class="lineNum"> 653 </span><span class="lineCov"> 553948 : thread_mutex_unlock(&amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 654 </span> :
<span class="lineNum"> 655 </span> : /* mark the worker as processed */
<span class="lineNum"> 656 </span> : /* setting the previous one to point at the next one */
<span class="lineNum"> 657 </span><span class="lineCov"> 553420 : *let = io-&gt;writer_list[i + 1];</span>
<span class="lineNum"> 657 </span><span class="lineCov"> 553948 : *let = io-&gt;writer_list[i + 1];</span>
<span class="lineNum"> 658 </span> :
<span class="lineNum"> 659 </span> : /* return the position */
<span class="lineNum"> 660 </span><span class="lineCov"> 553420 : *pos = i;</span>
<span class="lineNum"> 660 </span><span class="lineCov"> 553948 : *pos = i;</span>
<span class="lineNum"> 661 </span> :
<span class="lineNum"> 662 </span> : /* on the first cycle, no one is waiting */
<span class="lineNum"> 663 </span><span class="lineCov"> 553420 : if (waiting_cycle == 0)</span>
<span class="lineNum"> 664 </span><span class="lineCov"> 487503 : *waiting_mac = 0;</span>
<span class="lineNum"> 663 </span><span class="lineCov"> 553948 : if (waiting_cycle == 0)</span>
<span class="lineNum"> 664 </span><span class="lineCov"> 488278 : *waiting_mac = 0;</span>
<span class="lineNum"> 665 </span> :
<span class="lineNum"> 666 </span><span class="lineCov"> 1106840 : return;</span>
<span class="lineNum"> 666 </span><span class="lineCov"> 1107896 : return;</span>
<span class="lineNum"> 667 </span> : }
<span class="lineNum"> 668 </span> :
<span class="lineNum"> 669 </span> : /* next position to check */
<span class="lineNum"> 670 </span><span class="lineCov"> 246777 : let = &amp;io-&gt;writer_list[i + 1];</span>
<span class="lineNum"> 671 </span><span class="lineCov"> 246777 : }</span>
<span class="lineNum"> 670 </span><span class="lineCov"> 182706 : let = &amp;io-&gt;writer_list[i + 1];</span>
<span class="lineNum"> 671 </span><span class="lineCov"> 182706 : }</span>
<span class="lineNum"> 672 </span> :
<span class="lineNum"> 673 </span> : /* if no worker is ready, wait for an event */
<span class="lineNum"> 674 </span><span class="lineCov"> 65917 : thread_cond_wait(&amp;io-&gt;write_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 674 </span><span class="lineCov"> 65670 : thread_cond_wait(&amp;io-&gt;write_done, &amp;io-&gt;io_mutex);</span>
<span class="lineNum"> 675 </span> :
<span class="lineNum"> 676 </span> : /* count the cycles */
<span class="lineNum"> 677 </span><span class="lineCov"> 65917 : ++waiting_cycle;</span>
<span class="lineNum"> 678 </span><span class="lineCov"> 65917 : }</span>
<span class="lineNum"> 677 </span><span class="lineCov"> 65670 : ++waiting_cycle;</span>
<span class="lineNum"> 678 </span><span class="lineCov"> 65670 : }</span>
<a name="679"><span class="lineNum"> 679 </span> : }</a>
<span class="lineNum"> 680 </span> :
<span class="lineNum"> 681 </span><span class="lineCov"> 1081680 : static void io_reader_worker(struct snapraid_worker* worker, struct snapraid_task* task)</span>
<span class="lineNum"> 681 </span><span class="lineCov"> 1082209 : static void io_reader_worker(struct snapraid_worker* worker, struct snapraid_task* task)</span>
<span class="lineNum"> 682 </span> : {
<span class="lineNum"> 683 </span> : /* if we reached the end */
<span class="lineNum"> 684 </span><span class="lineCov"> 1081680 : if (task-&gt;position &gt;= worker-&gt;io-&gt;block_max) {</span>
<span class="lineNum"> 684 </span><span class="lineCov"> 1082209 : if (task-&gt;position &gt;= worker-&gt;io-&gt;block_max) {</span>
<span class="lineNum"> 685 </span> : /* complete a dummy task */
<span class="lineNum"> 686 </span><span class="lineCov"> 120 : task-&gt;state = TASK_STATE_EMPTY;</span>
<span class="lineNum"> 687 </span> : } else {
<span class="lineNum"> 688 </span><span class="lineCov"> 1081560 : worker-&gt;func(worker, task);</span>
<span class="lineNum"> 688 </span><span class="lineCov"> 1082089 : worker-&gt;func(worker, task);</span>
<span class="lineNum"> 689 </span> : }
<a name="690"><span class="lineNum"> 690 </span><span class="lineCov"> 1081228 : }</span></a>
<a name="690"><span class="lineNum"> 690 </span><span class="lineCov"> 1081822 : }</span></a>
<span class="lineNum"> 691 </span> :
<span class="lineNum"> 692 </span><span class="lineCov"> 647 : static void* io_reader_thread(void* arg)</span>
<span class="lineNum"> 692 </span><span class="lineCov"> 648 : static void* io_reader_thread(void* arg)</span>
<span class="lineNum"> 693 </span> : {
<span class="lineNum"> 694 </span><span class="lineCov"> 647 : struct snapraid_worker* worker = arg;</span>
<span class="lineNum"> 694 </span><span class="lineCov"> 648 : struct snapraid_worker* worker = arg;</span>
<span class="lineNum"> 695 </span> :
<span class="lineNum"> 696 </span> : /* force completion of the first task */
<span class="lineNum"> 697 </span><span class="lineCov"> 647 : io_reader_worker(worker, &amp;worker-&gt;task_map[0]);</span>
<span class="lineNum"> 697 </span><span class="lineCov"> 648 : io_reader_worker(worker, &amp;worker-&gt;task_map[0]);</span>
<span class="lineNum"> 698 </span> :
<span class="lineNum"> 699 </span> : while (1) {
<span class="lineNum"> 700 </span> : struct snapraid_task* task;
<span class="lineNum"> 701 </span> :
<span class="lineNum"> 702 </span> : /* get the new task */
<span class="lineNum"> 703 </span><span class="lineCov"> 1162533 : task = io_reader_step(worker);</span>
<span class="lineNum"> 703 </span><span class="lineCov"> 1163504 : task = io_reader_step(worker);</span>
<span class="lineNum"> 704 </span> :
<span class="lineNum"> 705 </span> : /* if no task, it means to exit */
<span class="lineNum"> 706 </span><span class="lineCov"> 1162963 : if (!task)</span>
<span class="lineNum"> 706 </span><span class="lineCov"> 1163910 : if (!task)</span>
<span class="lineNum"> 707 </span><span class="lineCov"> 648 : break;</span>
<span class="lineNum"> 708 </span> :
<span class="lineNum"> 709 </span> : /* nothing more to do */
<span class="lineNum"> 710 </span><span class="lineCov"> 1162315 : if (task-&gt;state == TASK_STATE_EMPTY)</span>
<span class="lineNum"> 711 </span><span class="lineCov"> 81255 : continue;</span>
<span class="lineNum"> 710 </span><span class="lineCov"> 1163262 : if (task-&gt;state == TASK_STATE_EMPTY)</span>
<span class="lineNum"> 711 </span><span class="lineCov"> 81670 : continue;</span>
<span class="lineNum"> 712 </span> :
<span class="lineNum"> 713 </span><span class="lineCov"> 1081060 : assert(task-&gt;state == TASK_STATE_READY);</span>
<span class="lineNum"> 713 </span><span class="lineCov"> 1081592 : assert(task-&gt;state == TASK_STATE_READY);</span>
<span class="lineNum"> 714 </span> :
<span class="lineNum"> 715 </span> : /* work on the assigned task */
<span class="lineNum"> 716 </span><span class="lineCov"> 1081060 : io_reader_worker(worker, task);</span>
<span class="lineNum"> 717 </span><span class="lineCov"> 1161887 : }</span>
<span class="lineNum"> 716 </span><span class="lineCov"> 1081592 : io_reader_worker(worker, task);</span>
<span class="lineNum"> 717 </span><span class="lineCov"> 1162859 : }</span>
<span class="lineNum"> 718 </span> :
<span class="lineNum"> 719 </span><span class="lineCov"> 648 : return 0;</span>
<a name="720"><span class="lineNum"> 720 </span> : }</a>
@ -790,26 +790,26 @@
<span class="lineNum"> 728 </span> : struct snapraid_task* task;
<span class="lineNum"> 729 </span> :
<span class="lineNum"> 730 </span> : /* get the new task */
<span class="lineNum"> 731 </span><span class="lineCov"> 553873 : task = io_writer_step(worker, latest_state);</span>
<span class="lineNum"> 731 </span><span class="lineCov"> 554402 : task = io_writer_step(worker, latest_state);</span>
<span class="lineNum"> 732 </span> :
<span class="lineNum"> 733 </span> : /* if no task, it means to exit */
<span class="lineNum"> 734 </span><span class="lineCov"> 553876 : if (!task)</span>
<span class="lineNum"> 734 </span><span class="lineCov"> 554405 : if (!task)</span>
<span class="lineNum"> 735 </span><span class="lineCov"> 462 : break;</span>
<span class="lineNum"> 736 </span> :
<span class="lineNum"> 737 </span> : /* nothing more to do */
<span class="lineNum"> 738 </span><span class="lineCov"> 553414 : if (task-&gt;state == TASK_STATE_EMPTY) {</span>
<span class="lineNum"> 739 </span><span class="lineCov"> 13808 : latest_state = TASK_STATE_DONE;</span>
<span class="lineNum"> 740 </span><span class="lineCov"> 13808 : continue;</span>
<span class="lineNum"> 738 </span><span class="lineCov"> 553943 : if (task-&gt;state == TASK_STATE_EMPTY) {</span>
<span class="lineNum"> 739 </span><span class="lineCov"> 13898 : latest_state = TASK_STATE_DONE;</span>
<span class="lineNum"> 740 </span><span class="lineCov"> 13898 : continue;</span>
<span class="lineNum"> 741 </span> : }
<span class="lineNum"> 742 </span> :
<span class="lineNum"> 743 </span><span class="lineCov"> 539606 : assert(task-&gt;state == TASK_STATE_READY);</span>
<span class="lineNum"> 743 </span><span class="lineCov"> 540045 : assert(task-&gt;state == TASK_STATE_READY);</span>
<span class="lineNum"> 744 </span> :
<span class="lineNum"> 745 </span> : /* work on the assigned task */
<span class="lineNum"> 746 </span><span class="lineCov"> 539606 : worker-&gt;func(worker, task);</span>
<span class="lineNum"> 746 </span><span class="lineCov"> 540045 : worker-&gt;func(worker, task);</span>
<span class="lineNum"> 747 </span> :
<span class="lineNum"> 748 </span> : /* save the resulting state */
<span class="lineNum"> 749 </span><span class="lineCov"> 539603 : latest_state = task-&gt;state;</span>
<span class="lineNum"> 750 </span><span class="lineCov"> 553411 : }</span>
<span class="lineNum"> 749 </span><span class="lineCov"> 540042 : latest_state = task-&gt;state;</span>
<span class="lineNum"> 750 </span><span class="lineCov"> 553940 : }</span>
<span class="lineNum"> 751 </span> :
<span class="lineNum"> 752 </span><span class="lineCov"> 462 : return 0;</span>
<a name="753"><span class="lineNum"> 753 </span> : }</a>

26
cov/cmdline/mktest.c.func-sort-c.html
View file

@ -61,23 +61,23 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#28">rnd</a></td>
<td class="coverFnHi">56057797</td>
<td class="coverFnHi">56068924</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#35">rndnz</a></td>
<td class="coverFnHi">55646605</td>
<td class="coverFnHi">55657385</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#84">file_cmp</a></td>
<td class="coverFnHi">146556</td>
<td class="coverFnHi">146572</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#43">rndnz_range</a></td>
<td class="coverFnHi">32690</td>
<td class="coverFnHi">32675</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#70">rnd_name</a></td>
<td class="coverFnHi">26841</td>
<td class="coverFnHi">26852</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#221">cmd_generate</a></td>
@ -93,19 +93,19 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#289">cmd_write</a></td>
<td class="coverFnHi">6226</td>
<td class="coverFnHi">6254</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#457">cmd_append</a></td>
<td class="coverFnHi">3224</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#562">cmd_delete</a></td>
<td class="coverFnHi">3222</td>
<td class="coverFnHi">3181</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#508">cmd_truncate</a></td>
<td class="coverFnHi">3082</td>
<td class="coverFnHi">3162</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#562">cmd_delete</a></td>
<td class="coverFnHi">3155</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#360">cmd_damage</a></td>
@ -121,7 +121,7 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#198">cmd_generate_symlink</a></td>
<td class="coverFnHi">932</td>
<td class="coverFnHi">943</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#644">main</a></td>

20
cov/cmdline/mktest.c.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#457">cmd_append</a></td>
<td class="coverFnHi">3224</td>
<td class="coverFnHi">3181</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#576">cmd_change</a></td>
@ -73,7 +73,7 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#562">cmd_delete</a></td>
<td class="coverFnHi">3222</td>
<td class="coverFnHi">3155</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#221">cmd_generate</a></td>
@ -85,15 +85,15 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#198">cmd_generate_symlink</a></td>
<td class="coverFnHi">932</td>
<td class="coverFnHi">943</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#508">cmd_truncate</a></td>
<td class="coverFnHi">3082</td>
<td class="coverFnHi">3162</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#289">cmd_write</a></td>
<td class="coverFnHi">6226</td>
<td class="coverFnHi">6254</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#89">fallback</a></td>
@ -101,7 +101,7 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#84">file_cmp</a></td>
<td class="coverFnHi">146556</td>
<td class="coverFnHi">146572</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#632">help</a></td>
@ -113,15 +113,15 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#28">rnd</a></td>
<td class="coverFnHi">56057797</td>
<td class="coverFnHi">56068924</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#70">rnd_name</a></td>
<td class="coverFnHi">26841</td>
<td class="coverFnHi">26852</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#35">rndnz</a></td>
<td class="coverFnHi">55646605</td>
<td class="coverFnHi">55657385</td>
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#51">rndnz_damage</a></td>
@ -129,7 +129,7 @@
</tr>
<tr>
<td class="coverFn"><a href="mktest.c.gcov.html#43">rndnz_range</a></td>
<td class="coverFnHi">32690</td>
<td class="coverFnHi">32675</td>
</tr>
</table>
<br>

170
cov/cmdline/mktest.c.gcov.html
View file

@ -89,28 +89,28 @@
<span class="lineNum"> 27 </span> : */
<a name="28"><span class="lineNum"> 28 </span> : unsigned long long seed = 0;</a>
<span class="lineNum"> 29 </span> :
<span class="lineNum"> 30 </span><span class="lineCov"> 56057797 : unsigned rnd(unsigned max)</span>
<span class="lineNum"> 30 </span><span class="lineCov"> 56068924 : unsigned rnd(unsigned max)</span>
<span class="lineNum"> 31 </span> : {
<span class="lineNum"> 32 </span><span class="lineCov"> 56057797 : seed = seed * 6364136223846793005LL + 1442695040888963407LL;</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 56068924 : seed = seed * 6364136223846793005LL + 1442695040888963407LL;</span>
<span class="lineNum"> 33 </span> :
<span class="lineNum"> 34 </span><span class="lineCov"> 56057797 : return (seed &gt;&gt; 32) % max;</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 56068924 : return (seed &gt;&gt; 32) % max;</span>
<a name="35"><span class="lineNum"> 35 </span> : }</a>
<span class="lineNum"> 36 </span> :
<span class="lineNum"> 37 </span><span class="lineCov"> 55646605 : unsigned rndnz(unsigned max)</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 55657385 : unsigned rndnz(unsigned max)</span>
<span class="lineNum"> 38 </span> : {
<span class="lineNum"> 39 </span><span class="lineCov"> 55646605 : if (max &lt;= 1)</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 55657385 : if (max &lt;= 1)</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 2831 : return 1;</span>
<span class="lineNum"> 41 </span> : else
<span class="lineNum"> 42 </span><span class="lineCov"> 55643774 : return rnd(max - 1) + 1;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 55654554 : return rnd(max - 1) + 1;</span>
<a name="43"><span class="lineNum"> 43 </span> : }</a>
<span class="lineNum"> 44 </span> :
<span class="lineNum"> 45 </span><span class="lineCov"> 32690 : void rndnz_range(unsigned char* data, int size)</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 32675 : void rndnz_range(unsigned char* data, int size)</span>
<span class="lineNum"> 46 </span> : {
<span class="lineNum"> 47 </span> : int i;
<span class="lineNum"> 48 </span> :
<span class="lineNum"> 49 </span><span class="lineCov"> 55672532 : for (i = 0; i &lt; size; ++i)</span>
<span class="lineNum"> 50 </span><span class="lineCov"> 55639842 : data[i] = rndnz(256);</span>
<a name="51"><span class="lineNum"> 51 </span><span class="lineCov"> 32690 : }</span></a>
<span class="lineNum"> 49 </span><span class="lineCov"> 55683297 : for (i = 0; i &lt; size; ++i)</span>
<span class="lineNum"> 50 </span><span class="lineCov"> 55650622 : data[i] = rndnz(256);</span>
<a name="51"><span class="lineNum"> 51 </span><span class="lineCov"> 32675 : }</span></a>
<span class="lineNum"> 52 </span> :
<span class="lineNum"> 53 </span><span class="lineCov"> 1821 : void rndnz_damage(unsigned char* data, int size)</span>
<span class="lineNum"> 54 </span> : {
@ -131,23 +131,23 @@
<span class="lineNum"> 69 </span> : char CHARSET[] = &quot;qwertyuiopasdfghjklzxcvbnm1234567890 .-+&quot;;
<a name="70"><span class="lineNum"> 70 </span> : #define CHARSET_LEN (sizeof(CHARSET) - 1)</a>
<span class="lineNum"> 71 </span> :
<span class="lineNum"> 72 </span><span class="lineCov"> 26841 : void rnd_name(char* file)</span>
<span class="lineNum"> 72 </span><span class="lineCov"> 26852 : void rnd_name(char* file)</span>
<span class="lineNum"> 73 </span> : {
<span class="lineNum"> 74 </span><span class="lineCov"> 26841 : int l = 1 + rnd(20);</span>
<span class="lineNum"> 74 </span><span class="lineCov"> 26852 : int l = 1 + rnd(20);</span>
<span class="lineNum"> 75 </span> :
<span class="lineNum"> 76 </span><span class="lineCov"> 335354 : while (l) {</span>
<span class="lineNum"> 77 </span><span class="lineCov"> 281672 : *file++ = CHARSET[rnd(CHARSET_LEN)];</span>
<span class="lineNum"> 78 </span><span class="lineCov"> 281672 : --l;</span>
<span class="lineNum"> 76 </span><span class="lineCov"> 335716 : while (l) {</span>
<span class="lineNum"> 77 </span><span class="lineCov"> 282012 : *file++ = CHARSET[rnd(CHARSET_LEN)];</span>
<span class="lineNum"> 78 </span><span class="lineCov"> 282012 : --l;</span>
<span class="lineNum"> 79 </span> : }
<span class="lineNum"> 80 </span><span class="lineCov"> 26841 : *file = 0;</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 26841 : }</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 26852 : *file = 0;</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 26852 : }</span>
<span class="lineNum"> 82 </span> :
<span class="lineNum"> 83 </span> : /****************************************************************************/
<a name="84"><span class="lineNum"> 84 </span> : /* file */</a>
<span class="lineNum"> 85 </span> :
<span class="lineNum"> 86 </span><span class="lineCov"> 146556 : int file_cmp(const void* a, const void* b)</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 146572 : int file_cmp(const void* a, const void* b)</span>
<span class="lineNum"> 87 </span> : {
<span class="lineNum"> 88 </span><span class="lineCov"> 146556 : return strcmp(a, b);</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 146572 : return strcmp(a, b);</span>
<a name="89"><span class="lineNum"> 89 </span> : }</a>
<span class="lineNum"> 90 </span> :
<span class="lineNum"> 91 </span><span class="lineCov"> 1821 : int fallback(int f, struct stat* st)</span>
@ -259,11 +259,11 @@
<span class="lineNum"> 197 </span> : * Create a symlink.
<a name="198"><span class="lineNum"> 198 </span> : * - If the file already exists, it's removed.</a>
<span class="lineNum"> 199 </span> : */
<span class="lineNum"> 200 </span><span class="lineCov"> 932 : void cmd_generate_symlink(const char* path, const char* linkto)</span>
<span class="lineNum"> 200 </span><span class="lineCov"> 943 : void cmd_generate_symlink(const char* path, const char* linkto)</span>
<span class="lineNum"> 201 </span> : {
<span class="lineNum"> 202 </span> : /* remove the existing file/symlink if any */
<span class="lineNum"> 203 </span><span class="lineCov"> 932 : if (remove(path) != 0) {</span>
<span class="lineNum"> 204 </span><span class="lineCov"> 911 : if (errno != ENOENT) {</span>
<span class="lineNum"> 203 </span><span class="lineCov"> 943 : if (remove(path) != 0) {</span>
<span class="lineNum"> 204 </span><span class="lineCov"> 922 : if (errno != ENOENT) {</span>
<span class="lineNum"> 205 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 206 </span> : log_fatal(&quot;Error removing file %s\n&quot;, path);
<span class="lineNum"> 207 </span> : exit(EXIT_FAILURE);
@ -271,13 +271,13 @@
<span class="lineNum"> 209 </span> : }
<span class="lineNum"> 210 </span> : }
<span class="lineNum"> 211 </span> :
<span class="lineNum"> 212 </span><span class="lineCov"> 932 : if (symlink(linkto, path) != 0) {</span>
<span class="lineNum"> 212 </span><span class="lineCov"> 943 : if (symlink(linkto, path) != 0) {</span>
<span class="lineNum"> 213 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 214 </span> : log_fatal(&quot;Error writing symlink %s\n&quot;, path);
<span class="lineNum"> 215 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 216 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 217 </span> : }
<span class="lineNum"> 218 </span><span class="lineCov"> 932 : }</span>
<span class="lineNum"> 218 </span><span class="lineCov"> 943 : }</span>
<span class="lineNum"> 219 </span> :
<span class="lineNum"> 220 </span> : /**
<a name="221"><span class="lineNum"> 221 </span> : * Create a file or a symlink with a random name.</a>
@ -350,68 +350,68 @@
<span class="lineNum"> 288 </span> : * - The written data may be equal or not at the already existing one.
<a name="289"><span class="lineNum"> 289 </span> : * - If it's a symlink nothing is done.</a>
<span class="lineNum"> 290 </span> : */
<span class="lineNum"> 291 </span><span class="lineCov"> 6226 : void cmd_write(const char* path, int size)</span>
<span class="lineNum"> 291 </span><span class="lineCov"> 6254 : void cmd_write(const char* path, int size)</span>
<span class="lineNum"> 292 </span> : {
<span class="lineNum"> 293 </span> : struct stat st;
<span class="lineNum"> 294 </span> :
<span class="lineNum"> 295 </span><span class="lineCov"> 6226 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 295 </span><span class="lineCov"> 6254 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 296 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 297 </span> : log_fatal(&quot;Error accessing %s\n&quot;, path);
<span class="lineNum"> 298 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 299 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 300 </span> : }
<span class="lineNum"> 301 </span> :
<span class="lineNum"> 302 </span><span class="lineCov"> 6226 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 302 </span><span class="lineCov"> 6254 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 303 </span> : unsigned char* data;
<span class="lineNum"> 304 </span> : off_t off;
<span class="lineNum"> 305 </span> : int f;
<span class="lineNum"> 306 </span> :
<span class="lineNum"> 307 </span> : /* not over the end */
<span class="lineNum"> 308 </span><span class="lineCov"> 6199 : if (size &gt; st.st_size)</span>
<span class="lineNum"> 309 </span><span class="lineCov"> 687 : size = st.st_size;</span>
<span class="lineNum"> 308 </span><span class="lineCov"> 6227 : if (size &gt; st.st_size)</span>
<span class="lineNum"> 309 </span><span class="lineCov"> 716 : size = st.st_size;</span>
<span class="lineNum"> 310 </span> :
<span class="lineNum"> 311 </span> : /* start at random position inside the file */
<span class="lineNum"> 312 </span><span class="lineCov"> 6199 : if (size &lt; st.st_size)</span>
<span class="lineNum"> 313 </span><span class="lineCov"> 5511 : off = rnd(st.st_size - size);</span>
<span class="lineNum"> 312 </span><span class="lineCov"> 6227 : if (size &lt; st.st_size)</span>
<span class="lineNum"> 313 </span><span class="lineCov"> 5510 : off = rnd(st.st_size - size);</span>
<span class="lineNum"> 314 </span> : else
<span class="lineNum"> 315 </span><span class="lineCov"> 688 : off = 0;</span>
<span class="lineNum"> 315 </span><span class="lineCov"> 717 : off = 0;</span>
<span class="lineNum"> 316 </span> :
<span class="lineNum"> 317 </span><span class="lineCov"> 6199 : data = malloc(size);</span>
<span class="lineNum"> 317 </span><span class="lineCov"> 6227 : data = malloc(size);</span>
<span class="lineNum"> 318 </span> :
<span class="lineNum"> 319 </span><span class="lineCov"> 6199 : rndnz_range(data, size);</span>
<span class="lineNum"> 319 </span><span class="lineCov"> 6227 : rndnz_range(data, size);</span>
<span class="lineNum"> 320 </span> :
<span class="lineNum"> 321 </span><span class="lineCov"> 6199 : f = open(path, O_WRONLY | O_BINARY | O_NOFOLLOW);</span>
<span class="lineNum"> 322 </span><span class="lineCov"> 6199 : if (f &lt; 0) {</span>
<span class="lineNum"> 321 </span><span class="lineCov"> 6227 : f = open(path, O_WRONLY | O_BINARY | O_NOFOLLOW);</span>
<span class="lineNum"> 322 </span><span class="lineCov"> 6227 : if (f &lt; 0) {</span>
<span class="lineNum"> 323 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 324 </span> : log_fatal(&quot;Error creating file %s\n&quot;, path);
<span class="lineNum"> 325 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 326 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 327 </span> : }
<span class="lineNum"> 328 </span> :
<span class="lineNum"> 329 </span><span class="lineCov"> 6199 : if (lseek(f, off, SEEK_SET) != off) {</span>
<span class="lineNum"> 329 </span><span class="lineCov"> 6227 : if (lseek(f, off, SEEK_SET) != off) {</span>
<span class="lineNum"> 330 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 331 </span> : log_fatal(&quot;Error seeking file %s\n&quot;, path);
<span class="lineNum"> 332 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 333 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 334 </span> : }
<span class="lineNum"> 335 </span> :
<span class="lineNum"> 336 </span><span class="lineCov"> 6199 : if (write(f, data, size) != size) {</span>
<span class="lineNum"> 336 </span><span class="lineCov"> 6227 : if (write(f, data, size) != size) {</span>
<span class="lineNum"> 337 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 338 </span> : log_fatal(&quot;Error writing file %s\n&quot;, path);
<span class="lineNum"> 339 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 340 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 341 </span> : }
<span class="lineNum"> 342 </span> :
<span class="lineNum"> 343 </span><span class="lineCov"> 6199 : if (close(f) != 0) {</span>
<span class="lineNum"> 343 </span><span class="lineCov"> 6227 : if (close(f) != 0) {</span>
<span class="lineNum"> 344 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 345 </span> : log_fatal(&quot;Error closing file %s\n&quot;, path);
<span class="lineNum"> 346 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 347 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 348 </span> : }
<span class="lineNum"> 349 </span> :
<span class="lineNum"> 350 </span><span class="lineCov"> 6199 : free(data);</span>
<span class="lineNum"> 350 </span><span class="lineCov"> 6227 : free(data);</span>
<span class="lineNum"> 351 </span> : }
<span class="lineNum"> 352 </span><span class="lineCov"> 6226 : }</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 6254 : }</span>
<span class="lineNum"> 353 </span> :
<span class="lineNum"> 354 </span> : /**
<span class="lineNum"> 355 </span> : * Damage a file.
@ -518,50 +518,50 @@
<span class="lineNum"> 456 </span> : * - The file must exist.
<a name="457"><span class="lineNum"> 457 </span> : * - If it's a symlink nothing is done.</a>
<span class="lineNum"> 458 </span> : */
<span class="lineNum"> 459 </span><span class="lineCov"> 3224 : void cmd_append(const char* path, int size)</span>
<span class="lineNum"> 459 </span><span class="lineCov"> 3181 : void cmd_append(const char* path, int size)</span>
<span class="lineNum"> 460 </span> : {
<span class="lineNum"> 461 </span> : struct stat st;
<span class="lineNum"> 462 </span> :
<span class="lineNum"> 463 </span><span class="lineCov"> 3224 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 463 </span><span class="lineCov"> 3181 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 464 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 465 </span> : log_fatal(&quot;Error accessing %s\n&quot;, path);
<span class="lineNum"> 466 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 467 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 468 </span> : }
<span class="lineNum"> 469 </span> :
<span class="lineNum"> 470 </span><span class="lineCov"> 3224 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 470 </span><span class="lineCov"> 3181 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 471 </span> : unsigned char* data;
<span class="lineNum"> 472 </span> : int f;
<span class="lineNum"> 473 </span> :
<span class="lineNum"> 474 </span><span class="lineCov"> 3224 : data = malloc(size);</span>
<span class="lineNum"> 474 </span><span class="lineCov"> 3181 : data = malloc(size);</span>
<span class="lineNum"> 475 </span> :
<span class="lineNum"> 476 </span><span class="lineCov"> 3224 : rndnz_range(data, size);</span>
<span class="lineNum"> 476 </span><span class="lineCov"> 3181 : rndnz_range(data, size);</span>
<span class="lineNum"> 477 </span> :
<span class="lineNum"> 478 </span><span class="lineCov"> 3224 : f = open(path, O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW);</span>
<span class="lineNum"> 479 </span><span class="lineCov"> 3224 : if (f &lt; 0) {</span>
<span class="lineNum"> 478 </span><span class="lineCov"> 3181 : f = open(path, O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW);</span>
<span class="lineNum"> 479 </span><span class="lineCov"> 3181 : if (f &lt; 0) {</span>
<span class="lineNum"> 480 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 481 </span> : log_fatal(&quot;Error opening file %s\n&quot;, path);
<span class="lineNum"> 482 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 483 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 484 </span> : }
<span class="lineNum"> 485 </span> :
<span class="lineNum"> 486 </span><span class="lineCov"> 3224 : if (write(f, data, size) != size) {</span>
<span class="lineNum"> 486 </span><span class="lineCov"> 3181 : if (write(f, data, size) != size) {</span>
<span class="lineNum"> 487 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 488 </span> : log_fatal(&quot;Error writing file %s\n&quot;, path);
<span class="lineNum"> 489 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 490 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 491 </span> : }
<span class="lineNum"> 492 </span> :
<span class="lineNum"> 493 </span><span class="lineCov"> 3224 : if (close(f) != 0) {</span>
<span class="lineNum"> 493 </span><span class="lineCov"> 3181 : if (close(f) != 0) {</span>
<span class="lineNum"> 494 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 495 </span> : log_fatal(&quot;Error closing file %s\n&quot;, path);
<span class="lineNum"> 496 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 497 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 498 </span> : }
<span class="lineNum"> 499 </span> :
<span class="lineNum"> 500 </span><span class="lineCov"> 3224 : free(data);</span>
<span class="lineNum"> 500 </span><span class="lineCov"> 3181 : free(data);</span>
<span class="lineNum"> 501 </span> : }
<span class="lineNum"> 502 </span><span class="lineCov"> 3224 : }</span>
<span class="lineNum"> 502 </span><span class="lineCov"> 3181 : }</span>
<span class="lineNum"> 503 </span> :
<span class="lineNum"> 504 </span> : /**
<span class="lineNum"> 505 </span> : * Truncate a file.
@ -569,69 +569,69 @@
<span class="lineNum"> 507 </span> : * - The file is NEVER truncated to 0.
<a name="508"><span class="lineNum"> 508 </span> : * - If it's a symlink nothing is done.</a>
<span class="lineNum"> 509 </span> : */
<span class="lineNum"> 510 </span><span class="lineCov"> 3082 : void cmd_truncate(const char* path, int size)</span>
<span class="lineNum"> 510 </span><span class="lineCov"> 3162 : void cmd_truncate(const char* path, int size)</span>
<span class="lineNum"> 511 </span> : {
<span class="lineNum"> 512 </span> : struct stat st;
<span class="lineNum"> 513 </span> :
<span class="lineNum"> 514 </span><span class="lineCov"> 3082 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 514 </span><span class="lineCov"> 3162 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 515 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 516 </span> : log_fatal(&quot;Error accessing %s\n&quot;, path);
<span class="lineNum"> 517 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 518 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 519 </span> : }
<span class="lineNum"> 520 </span> :
<span class="lineNum"> 521 </span><span class="lineCov"> 3082 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 521 </span><span class="lineCov"> 3162 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 522 </span> : off_t off;
<span class="lineNum"> 523 </span> : int f;
<span class="lineNum"> 524 </span> :
<span class="lineNum"> 525 </span> : /* if file is empty, just rewrite it */
<span class="lineNum"> 526 </span><span class="lineCov"> 3082 : if (st.st_size == 0) {</span>
<span class="lineNum"> 527 </span><span class="lineCov"> 7 : size = 0;</span>
<span class="lineNum"> 526 </span><span class="lineCov"> 3162 : if (st.st_size == 0) {</span>
<span class="lineNum"> 527 </span><span class="lineCov"> 4 : size = 0;</span>
<span class="lineNum"> 528 </span> : } else {
<span class="lineNum"> 529 </span> : /* don't truncate files to 0 size to avoid ZERO file size protection */
<span class="lineNum"> 530 </span><span class="lineCov"> 3075 : if (size &gt;= st.st_size)</span>
<span class="lineNum"> 531 </span><span class="lineCov"> 185 : size = st.st_size - 1;</span>
<span class="lineNum"> 530 </span><span class="lineCov"> 3158 : if (size &gt;= st.st_size)</span>
<span class="lineNum"> 531 </span><span class="lineCov"> 209 : size = st.st_size - 1;</span>
<span class="lineNum"> 532 </span> : }
<span class="lineNum"> 533 </span> :
<span class="lineNum"> 534 </span><span class="lineCov"> 3082 : off = st.st_size - size;</span>
<span class="lineNum"> 534 </span><span class="lineCov"> 3162 : off = st.st_size - size;</span>
<span class="lineNum"> 535 </span> :
<span class="lineNum"> 536 </span><span class="lineCov"> 3082 : f = open(path, O_WRONLY | O_BINARY | O_NOFOLLOW);</span>
<span class="lineNum"> 537 </span><span class="lineCov"> 3082 : if (f &lt; 0) {</span>
<span class="lineNum"> 536 </span><span class="lineCov"> 3162 : f = open(path, O_WRONLY | O_BINARY | O_NOFOLLOW);</span>
<span class="lineNum"> 537 </span><span class="lineCov"> 3162 : if (f &lt; 0) {</span>
<span class="lineNum"> 538 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 539 </span> : log_fatal(&quot;Error opening file %s\n&quot;, path);
<span class="lineNum"> 540 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 541 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 542 </span> : }
<span class="lineNum"> 543 </span> :
<span class="lineNum"> 544 </span><span class="lineCov"> 3082 : if (ftruncate(f, off) != 0) {</span>
<span class="lineNum"> 544 </span><span class="lineCov"> 3162 : if (ftruncate(f, off) != 0) {</span>
<span class="lineNum"> 545 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 546 </span> : log_fatal(&quot;Error truncating file %s\n&quot;, path);
<span class="lineNum"> 547 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 548 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 549 </span> : }
<span class="lineNum"> 550 </span> :
<span class="lineNum"> 551 </span><span class="lineCov"> 3082 : if (close(f) != 0) {</span>
<span class="lineNum"> 551 </span><span class="lineCov"> 3162 : if (close(f) != 0) {</span>
<span class="lineNum"> 552 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 553 </span> : log_fatal(&quot;Error closing file %s\n&quot;, path);
<span class="lineNum"> 554 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 555 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 556 </span> : }
<span class="lineNum"> 557 </span> : }
<span class="lineNum"> 558 </span><span class="lineCov"> 3082 : }</span>
<span class="lineNum"> 558 </span><span class="lineCov"> 3162 : }</span>
<span class="lineNum"> 559 </span> :
<span class="lineNum"> 560 </span> : /**
<span class="lineNum"> 561 </span> : * Delete a file.
<a name="562"><span class="lineNum"> 562 </span> : * - The file must exist.</a>
<span class="lineNum"> 563 </span> : */
<span class="lineNum"> 564 </span><span class="lineCov"> 3222 : void cmd_delete(const char* path)</span>
<span class="lineNum"> 564 </span><span class="lineCov"> 3155 : void cmd_delete(const char* path)</span>
<span class="lineNum"> 565 </span> : {
<span class="lineNum"> 566 </span><span class="lineCov"> 3222 : if (remove(path) != 0) {</span>
<span class="lineNum"> 566 </span><span class="lineCov"> 3155 : if (remove(path) != 0) {</span>
<span class="lineNum"> 567 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 568 </span> : log_fatal(&quot;Error removing %s\n&quot;, path);
<span class="lineNum"> 569 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 570 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 571 </span> : }
<span class="lineNum"> 572 </span><span class="lineCov"> 3222 : }</span>
<span class="lineNum"> 572 </span><span class="lineCov"> 3155 : }</span>
<span class="lineNum"> 573 </span> :
<span class="lineNum"> 574 </span> : /**
<span class="lineNum"> 575 </span> : * Change a file. Or deleted/truncated/append/created.
@ -642,20 +642,20 @@
<span class="lineNum"> 580 </span> : struct stat st;
<span class="lineNum"> 581 </span> :
<span class="lineNum"> 582 </span><span class="lineCov"> 13128 : if (!size)</span>
<span class="lineNum"> 583 </span><span class="lineCov"> 13157 : return;</span>
<span class="lineNum"> 583 </span><span class="lineCov"> 13160 : return;</span>
<span class="lineNum"> 584 </span> :
<span class="lineNum"> 585 </span><span class="lineCov"> 13099 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 585 </span><span class="lineCov"> 13096 : if (lstat(path, &amp;st) != 0) {</span>
<span class="lineNum"> 586 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 587 </span> : log_fatal(&quot;Error accessing %s\n&quot;, path);
<span class="lineNum"> 588 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 589 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 590 </span> : }
<span class="lineNum"> 591 </span> :
<span class="lineNum"> 592 </span><span class="lineCov"> 13099 : if (S_ISLNK(st.st_mode)) {</span>
<span class="lineNum"> 592 </span><span class="lineCov"> 13096 : if (S_ISLNK(st.st_mode)) {</span>
<span class="lineNum"> 593 </span> : /* symlink */
<span class="lineNum"> 594 </span><span class="lineCov"> 394 : if (rnd(2) == 0) {</span>
<span class="lineNum"> 594 </span><span class="lineCov"> 393 : if (rnd(2) == 0) {</span>
<span class="lineNum"> 595 </span> : /* delete */
<span class="lineNum"> 596 </span><span class="lineCov"> 195 : if (remove(path) != 0) {</span>
<span class="lineNum"> 596 </span><span class="lineCov"> 183 : if (remove(path) != 0) {</span>
<span class="lineNum"> 597 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 598 </span> : log_fatal(&quot;Error removing %s\n&quot;, path);
<span class="lineNum"> 599 </span> : exit(EXIT_FAILURE);
@ -665,30 +665,30 @@
<span class="lineNum"> 603 </span> : /* recreate */
<span class="lineNum"> 604 </span> : char linkto[PATH_MAX];
<span class="lineNum"> 605 </span> :
<span class="lineNum"> 606 </span><span class="lineCov"> 199 : if (remove(path) != 0) {</span>
<span class="lineNum"> 606 </span><span class="lineCov"> 210 : if (remove(path) != 0) {</span>
<span class="lineNum"> 607 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 608 </span> : log_fatal(&quot;Error removing %s\n&quot;, path);
<span class="lineNum"> 609 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 610 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 611 </span> : }
<span class="lineNum"> 612 </span> :
<span class="lineNum"> 613 </span><span class="lineCov"> 199 : rnd_name(linkto);</span>
<span class="lineNum"> 613 </span><span class="lineCov"> 210 : rnd_name(linkto);</span>
<span class="lineNum"> 614 </span> :
<span class="lineNum"> 615 </span><span class="lineCov"> 199 : cmd_generate_symlink(path, linkto);</span>
<span class="lineNum"> 615 </span><span class="lineCov"> 210 : cmd_generate_symlink(path, linkto);</span>
<span class="lineNum"> 616 </span> : }
<span class="lineNum"> 617 </span><span class="lineCov"> 12705 : } else if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 617 </span><span class="lineCov"> 12703 : } else if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 618 </span> : int r;
<span class="lineNum"> 619 </span> :
<span class="lineNum"> 620 </span><span class="lineCov"> 12705 : r = rnd(4);</span>
<span class="lineNum"> 620 </span><span class="lineCov"> 12703 : r = rnd(4);</span>
<span class="lineNum"> 621 </span> :
<span class="lineNum"> 622 </span><span class="lineCov"> 12705 : if (r == 0) {</span>
<span class="lineNum"> 623 </span><span class="lineCov"> 3177 : cmd_write(path, size);</span>
<span class="lineNum"> 624 </span><span class="lineCov"> 9528 : } else if (r == 1) {</span>
<span class="lineNum"> 625 </span><span class="lineCov"> 3224 : cmd_append(path, size);</span>
<span class="lineNum"> 626 </span><span class="lineCov"> 6304 : } else if (r == 2) {</span>
<span class="lineNum"> 627 </span><span class="lineCov"> 3082 : cmd_truncate(path, size);</span>
<span class="lineNum"> 622 </span><span class="lineCov"> 12703 : if (r == 0) {</span>
<span class="lineNum"> 623 </span><span class="lineCov"> 3205 : cmd_write(path, size);</span>
<span class="lineNum"> 624 </span><span class="lineCov"> 9498 : } else if (r == 1) {</span>
<span class="lineNum"> 625 </span><span class="lineCov"> 3181 : cmd_append(path, size);</span>
<span class="lineNum"> 626 </span><span class="lineCov"> 6317 : } else if (r == 2) {</span>
<span class="lineNum"> 627 </span><span class="lineCov"> 3162 : cmd_truncate(path, size);</span>
<span class="lineNum"> 628 </span> : } else {
<span class="lineNum"> 629 </span><span class="lineCov"> 3222 : cmd_delete(path);</span>
<span class="lineNum"> 629 </span><span class="lineCov"> 3155 : cmd_delete(path);</span>
<span class="lineNum"> 630 </span> : }
<span class="lineNum"> 631 </span> : }
<a name="632"><span class="lineNum"> 632 </span> : }</a>

4
cov/cmdline/murmur3.c.func-sort-c.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="murmur3.c.gcov.html#30">fmix32</a></td>
<td class="coverFnHi">8307308</td>
<td class="coverFnHi">8307416</td>
</tr>
<tr>
<td class="coverFn"><a href="murmur3.c.gcov.html#76">MurmurHash3_x86_128</a></td>
<td class="coverFnHi">2076827</td>
<td class="coverFnHi">2076854</td>
</tr>
</table>
<br>

4
cov/cmdline/murmur3.c.func.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="murmur3.c.gcov.html#76">MurmurHash3_x86_128</a></td>
<td class="coverFnHi">2076827</td>
<td class="coverFnHi">2076854</td>
</tr>
<tr>
<td class="coverFn"><a href="murmur3.c.gcov.html#30">fmix32</a></td>
<td class="coverFnHi">8307308</td>
<td class="coverFnHi">8307416</td>
</tr>
</table>
<br>

140
cov/cmdline/murmur3.c.gcov.html
View file

@ -91,14 +91,14 @@
<span class="lineNum"> 29 </span> : // domain. The author hereby disclaims copyright to this source code.
<a name="30"><span class="lineNum"> 30 </span> : </a>
<span class="lineNum"> 31 </span> : /* Finalization mix - force all bits of a hash block to avalanche */
<span class="lineNum"> 32 </span><span class="lineCov"> 8307308 : static inline uint32_t fmix32(uint32_t h)</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 8307416 : static inline uint32_t fmix32(uint32_t h)</span>
<span class="lineNum"> 33 </span> : {
<span class="lineNum"> 34 </span><span class="lineCov"> 8307308 : h ^= h &gt;&gt; 16;</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 8307308 : h *= 0x85ebca6b;</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 8307308 : h ^= h &gt;&gt; 13;</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 8307308 : h *= 0xc2b2ae35;</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 8307308 : h ^= h &gt;&gt; 16;</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 8307308 : return h;</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 8307416 : h ^= h &gt;&gt; 16;</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 8307416 : h *= 0x85ebca6b;</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 8307416 : h ^= h &gt;&gt; 13;</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 8307416 : h *= 0xc2b2ae35;</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 8307416 : h ^= h &gt;&gt; 16;</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 8307416 : return h;</span>
<span class="lineNum"> 40 </span> : }
<span class="lineNum"> 41 </span> :
<span class="lineNum"> 42 </span> : /*
@ -137,17 +137,17 @@
<span class="lineNum"> 75 </span> : uint32_t c3 = 0x38b34ae5;
<a name="76"><span class="lineNum"> 76 </span> : uint32_t c4 = 0xa1e38b93;</a>
<span class="lineNum"> 77 </span> :
<span class="lineNum"> 78 </span><span class="lineCov"> 2076827 : void MurmurHash3_x86_128(const void* data, size_t size, const uint8_t* seed, void* digest)</span>
<span class="lineNum"> 78 </span><span class="lineCov"> 2076854 : void MurmurHash3_x86_128(const void* data, size_t size, const uint8_t* seed, void* digest)</span>
<span class="lineNum"> 79 </span> : {
<span class="lineNum"> 80 </span> : size_t nblocks;
<span class="lineNum"> 81 </span> : const uint32_t* blocks;
<span class="lineNum"> 82 </span> : const uint32_t* end;
<span class="lineNum"> 83 </span> : size_t size_remainder;
<span class="lineNum"> 84 </span> :
<span class="lineNum"> 85 </span><span class="lineCov"> 2076827 : uint32_t h1 = ((const uint32_t*)seed)[0];</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 2076827 : uint32_t h2 = ((const uint32_t*)seed)[1];</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 2076827 : uint32_t h3 = ((const uint32_t*)seed)[2];</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 2076827 : uint32_t h4 = ((const uint32_t*)seed)[3];</span>
<span class="lineNum"> 85 </span><span class="lineCov"> 2076854 : uint32_t h1 = ((const uint32_t*)seed)[0];</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 2076854 : uint32_t h2 = ((const uint32_t*)seed)[1];</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 2076854 : uint32_t h3 = ((const uint32_t*)seed)[2];</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 2076854 : uint32_t h4 = ((const uint32_t*)seed)[3];</span>
<span class="lineNum"> 89 </span> :
<span class="lineNum"> 90 </span> : #if WORDS_BIGENDIAN
<span class="lineNum"> 91 </span> : h1 = util_swap32(h1);
@ -156,16 +156,16 @@
<span class="lineNum"> 94 </span> : h4 = util_swap32(h4);
<span class="lineNum"> 95 </span> : #endif
<span class="lineNum"> 96 </span> :
<span class="lineNum"> 97 </span><span class="lineCov"> 2076827 : nblocks = size / 16;</span>
<span class="lineNum"> 98 </span><span class="lineCov"> 2076827 : blocks = data;</span>
<span class="lineNum"> 99 </span><span class="lineCov"> 2076827 : end = blocks + nblocks * 4;</span>
<span class="lineNum"> 97 </span><span class="lineCov"> 2076854 : nblocks = size / 16;</span>
<span class="lineNum"> 98 </span><span class="lineCov"> 2076854 : blocks = data;</span>
<span class="lineNum"> 99 </span><span class="lineCov"> 2076854 : end = blocks + nblocks * 4;</span>
<span class="lineNum"> 100 </span> :
<span class="lineNum"> 101 </span> : /* body */
<span class="lineNum"> 102 </span><span class="lineCov"> 110683413 : while (blocks &lt; end) {</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 106529759 : uint32_t k1 = blocks[0];</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 106529759 : uint32_t k2 = blocks[1];</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 106529759 : uint32_t k3 = blocks[2];</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 106529759 : uint32_t k4 = blocks[3];</span>
<span class="lineNum"> 102 </span><span class="lineCov"> 110685610 : while (blocks &lt; end) {</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 106531902 : uint32_t k1 = blocks[0];</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 106531902 : uint32_t k2 = blocks[1];</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 106531902 : uint32_t k3 = blocks[2];</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 106531902 : uint32_t k4 = blocks[3];</span>
<span class="lineNum"> 107 </span> :
<span class="lineNum"> 108 </span> : #if WORDS_BIGENDIAN
<span class="lineNum"> 109 </span> : k1 = util_swap32(k1);
@ -174,71 +174,71 @@
<span class="lineNum"> 112 </span> : k4 = util_swap32(k4);
<span class="lineNum"> 113 </span> : #endif
<span class="lineNum"> 114 </span> :
<span class="lineNum"> 115 </span><span class="lineCov"> 106529759 : k1 *= c1; k1 = util_rotl32(k1, 15); k1 *= c2; h1 ^= k1;</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 106531902 : k1 *= c1; k1 = util_rotl32(k1, 15); k1 *= c2; h1 ^= k1;</span>
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span><span class="lineCov"> 106529759 : h1 = util_rotl32(h1, 19); h1 += h2; h1 = h1 * 5 + 0x561ccd1b;</span>
<span class="lineNum"> 117 </span><span class="lineCov"> 106531902 : h1 = util_rotl32(h1, 19); h1 += h2; h1 = h1 * 5 + 0x561ccd1b;</span>
<span class="lineNum"> 118 </span> :
<span class="lineNum"> 119 </span><span class="lineCov"> 106529759 : k2 *= c2; k2 = util_rotl32(k2, 16); k2 *= c3; h2 ^= k2;</span>
<span class="lineNum"> 119 </span><span class="lineCov"> 106531902 : k2 *= c2; k2 = util_rotl32(k2, 16); k2 *= c3; h2 ^= k2;</span>
<span class="lineNum"> 120 </span> :
<span class="lineNum"> 121 </span><span class="lineCov"> 106529759 : h2 = util_rotl32(h2, 17); h2 += h3; h2 = h2 * 5 + 0x0bcaa747;</span>
<span class="lineNum"> 121 </span><span class="lineCov"> 106531902 : h2 = util_rotl32(h2, 17); h2 += h3; h2 = h2 * 5 + 0x0bcaa747;</span>
<span class="lineNum"> 122 </span> :
<span class="lineNum"> 123 </span><span class="lineCov"> 106529759 : k3 *= c3; k3 = util_rotl32(k3, 17); k3 *= c4; h3 ^= k3;</span>
<span class="lineNum"> 123 </span><span class="lineCov"> 106531902 : k3 *= c3; k3 = util_rotl32(k3, 17); k3 *= c4; h3 ^= k3;</span>
<span class="lineNum"> 124 </span> :
<span class="lineNum"> 125 </span><span class="lineCov"> 106529759 : h3 = util_rotl32(h3, 15); h3 += h4; h3 = h3 * 5 + 0x96cd1c35;</span>
<span class="lineNum"> 125 </span><span class="lineCov"> 106531902 : h3 = util_rotl32(h3, 15); h3 += h4; h3 = h3 * 5 + 0x96cd1c35;</span>
<span class="lineNum"> 126 </span> :
<span class="lineNum"> 127 </span><span class="lineCov"> 106529759 : k4 *= c4; k4 = util_rotl32(k4, 18); k4 *= c1; h4 ^= k4;</span>
<span class="lineNum"> 127 </span><span class="lineCov"> 106531902 : k4 *= c4; k4 = util_rotl32(k4, 18); k4 *= c1; h4 ^= k4;</span>
<span class="lineNum"> 128 </span> :
<span class="lineNum"> 129 </span><span class="lineCov"> 106529759 : h4 = util_rotl32(h4, 13); h4 += h1; h4 = h4 * 5 + 0x32ac3b17;</span>
<span class="lineNum"> 129 </span><span class="lineCov"> 106531902 : h4 = util_rotl32(h4, 13); h4 += h1; h4 = h4 * 5 + 0x32ac3b17;</span>
<span class="lineNum"> 130 </span> :
<span class="lineNum"> 131 </span><span class="lineCov"> 106529759 : blocks += 4;</span>
<span class="lineNum"> 131 </span><span class="lineCov"> 106531902 : blocks += 4;</span>
<span class="lineNum"> 132 </span> : }
<span class="lineNum"> 133 </span> :
<span class="lineNum"> 134 </span> : /* tail */
<span class="lineNum"> 135 </span><span class="lineCov"> 2076827 : size_remainder = size &amp; 15;</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 2076827 : if (size_remainder != 0) {</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 779267 : const uint8_t* tail = (const uint8_t*)blocks;</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 2076854 : size_remainder = size &amp; 15;</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 2076854 : if (size_remainder != 0) {</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 779239 : const uint8_t* tail = (const uint8_t*)blocks;</span>
<span class="lineNum"> 138 </span> :
<span class="lineNum"> 139 </span><span class="lineCov"> 779267 : uint32_t k1 = 0;</span>
<span class="lineNum"> 140 </span><span class="lineCov"> 779267 : uint32_t k2 = 0;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 779267 : uint32_t k3 = 0;</span>
<span class="lineNum"> 142 </span><span class="lineCov"> 779267 : uint32_t k4 = 0;</span>
<span class="lineNum"> 139 </span><span class="lineCov"> 779239 : uint32_t k1 = 0;</span>
<span class="lineNum"> 140 </span><span class="lineCov"> 779239 : uint32_t k2 = 0;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 779239 : uint32_t k3 = 0;</span>
<span class="lineNum"> 142 </span><span class="lineCov"> 779239 : uint32_t k4 = 0;</span>
<span class="lineNum"> 143 </span> :
<span class="lineNum"> 144 </span><span class="lineCov"> 779267 : switch (size_remainder) {</span>
<span class="lineNum"> 145 </span><span class="lineCov"> 51305 : case 15 : k4 ^= (uint32_t)tail[14] &lt;&lt; 16;</span>
<span class="lineNum"> 146 </span><span class="lineCov"> 104040 : case 14 : k4 ^= (uint32_t)tail[13] &lt;&lt; 8;</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 156243 : case 13 : k4 ^= (uint32_t)tail[12] &lt;&lt; 0;</span>
<span class="lineNum"> 148 </span><span class="lineCov"> 156243 : k4 *= c4; k4 = util_rotl32(k4, 18); k4 *= c1; h4 ^= k4;</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 209005 : case 12 : k3 ^= (uint32_t)tail[11] &lt;&lt; 24;</span>
<span class="lineNum"> 150 </span><span class="lineCov"> 261544 : case 11 : k3 ^= (uint32_t)tail[10] &lt;&lt; 16;</span>
<span class="lineNum"> 151 </span><span class="lineCov"> 313728 : case 10 : k3 ^= (uint32_t)tail[ 9] &lt;&lt; 8;</span>
<span class="lineNum"> 152 </span><span class="lineCov"> 367016 : case 9 : k3 ^= (uint32_t)tail[ 8] &lt;&lt; 0;</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 367016 : k3 *= c3; k3 = util_rotl32(k3, 17); k3 *= c4; h3 ^= k3;</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 420940 : case 8 : k2 ^= (uint32_t)tail[ 7] &lt;&lt; 24;</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 470460 : case 7 : k2 ^= (uint32_t)tail[ 6] &lt;&lt; 16;</span>
<span class="lineNum"> 156 </span><span class="lineCov"> 523118 : case 6 : k2 ^= (uint32_t)tail[ 5] &lt;&lt; 8;</span>
<span class="lineNum"> 157 </span><span class="lineCov"> 573626 : case 5 : k2 ^= (uint32_t)tail[ 4] &lt;&lt; 0;</span>
<span class="lineNum"> 158 </span><span class="lineCov"> 573626 : k2 *= c2; k2 = util_rotl32(k2, 16); k2 *= c3; h2 ^= k2;</span>
<span class="lineNum"> 159 </span><span class="lineCov"> 625593 : case 4 : k1 ^= (uint32_t)tail[ 3] &lt;&lt; 24;</span>
<span class="lineNum"> 160 </span><span class="lineCov"> 675926 : case 3 : k1 ^= (uint32_t)tail[ 2] &lt;&lt; 16;</span>
<span class="lineNum"> 161 </span><span class="lineCov"> 726993 : case 2 : k1 ^= (uint32_t)tail[ 1] &lt;&lt; 8;</span>
<span class="lineNum"> 162 </span><span class="lineCov"> 779267 : case 1 : k1 ^= (uint32_t)tail[ 0] &lt;&lt; 0;</span>
<span class="lineNum"> 163 </span><span class="lineCov"> 779267 : k1 *= c1; k1 = util_rotl32(k1, 15); k1 *= c2; h1 ^= k1;</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 779239 : switch (size_remainder) {</span>
<span class="lineNum"> 145 </span><span class="lineCov"> 51287 : case 15 : k4 ^= (uint32_t)tail[14] &lt;&lt; 16;</span>
<span class="lineNum"> 146 </span><span class="lineCov"> 104028 : case 14 : k4 ^= (uint32_t)tail[13] &lt;&lt; 8;</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 156205 : case 13 : k4 ^= (uint32_t)tail[12] &lt;&lt; 0;</span>
<span class="lineNum"> 148 </span><span class="lineCov"> 156205 : k4 *= c4; k4 = util_rotl32(k4, 18); k4 *= c1; h4 ^= k4;</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 208993 : case 12 : k3 ^= (uint32_t)tail[11] &lt;&lt; 24;</span>
<span class="lineNum"> 150 </span><span class="lineCov"> 261517 : case 11 : k3 ^= (uint32_t)tail[10] &lt;&lt; 16;</span>
<span class="lineNum"> 151 </span><span class="lineCov"> 313718 : case 10 : k3 ^= (uint32_t)tail[ 9] &lt;&lt; 8;</span>
<span class="lineNum"> 152 </span><span class="lineCov"> 367026 : case 9 : k3 ^= (uint32_t)tail[ 8] &lt;&lt; 0;</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 367026 : k3 *= c3; k3 = util_rotl32(k3, 17); k3 *= c4; h3 ^= k3;</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 420982 : case 8 : k2 ^= (uint32_t)tail[ 7] &lt;&lt; 24;</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 470474 : case 7 : k2 ^= (uint32_t)tail[ 6] &lt;&lt; 16;</span>
<span class="lineNum"> 156 </span><span class="lineCov"> 523130 : case 6 : k2 ^= (uint32_t)tail[ 5] &lt;&lt; 8;</span>
<span class="lineNum"> 157 </span><span class="lineCov"> 573642 : case 5 : k2 ^= (uint32_t)tail[ 4] &lt;&lt; 0;</span>
<span class="lineNum"> 158 </span><span class="lineCov"> 573642 : k2 *= c2; k2 = util_rotl32(k2, 16); k2 *= c3; h2 ^= k2;</span>
<span class="lineNum"> 159 </span><span class="lineCov"> 625581 : case 4 : k1 ^= (uint32_t)tail[ 3] &lt;&lt; 24;</span>
<span class="lineNum"> 160 </span><span class="lineCov"> 675936 : case 3 : k1 ^= (uint32_t)tail[ 2] &lt;&lt; 16;</span>
<span class="lineNum"> 161 </span><span class="lineCov"> 726983 : case 2 : k1 ^= (uint32_t)tail[ 1] &lt;&lt; 8;</span>
<span class="lineNum"> 162 </span><span class="lineCov"> 779239 : case 1 : k1 ^= (uint32_t)tail[ 0] &lt;&lt; 0;</span>
<span class="lineNum"> 163 </span><span class="lineCov"> 779239 : k1 *= c1; k1 = util_rotl32(k1, 15); k1 *= c2; h1 ^= k1;</span>
<span class="lineNum"> 164 </span> : }
<span class="lineNum"> 165 </span> : }
<span class="lineNum"> 166 </span> :
<span class="lineNum"> 167 </span> : /* finalization */
<span class="lineNum"> 168 </span><span class="lineCov"> 2076827 : h1 ^= size; h2 ^= size; h3 ^= size; h4 ^= size;</span>
<span class="lineNum"> 168 </span><span class="lineCov"> 2076854 : h1 ^= size; h2 ^= size; h3 ^= size; h4 ^= size;</span>
<span class="lineNum"> 169 </span> :
<span class="lineNum"> 170 </span><span class="lineCov"> 2076827 : h1 += h2; h1 += h3; h1 += h4;</span>
<span class="lineNum"> 171 </span><span class="lineCov"> 2076827 : h2 += h1; h3 += h1; h4 += h1;</span>
<span class="lineNum"> 170 </span><span class="lineCov"> 2076854 : h1 += h2; h1 += h3; h1 += h4;</span>
<span class="lineNum"> 171 </span><span class="lineCov"> 2076854 : h2 += h1; h3 += h1; h4 += h1;</span>
<span class="lineNum"> 172 </span> :
<span class="lineNum"> 173 </span><span class="lineCov"> 2076827 : h1 = fmix32(h1);</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 2076827 : h2 = fmix32(h2);</span>
<span class="lineNum"> 175 </span><span class="lineCov"> 2076827 : h3 = fmix32(h3);</span>
<span class="lineNum"> 176 </span><span class="lineCov"> 2076827 : h4 = fmix32(h4);</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 2076854 : h1 = fmix32(h1);</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 2076854 : h2 = fmix32(h2);</span>
<span class="lineNum"> 175 </span><span class="lineCov"> 2076854 : h3 = fmix32(h3);</span>
<span class="lineNum"> 176 </span><span class="lineCov"> 2076854 : h4 = fmix32(h4);</span>
<span class="lineNum"> 177 </span> :
<span class="lineNum"> 178 </span><span class="lineCov"> 2076827 : h1 += h2; h1 += h3; h1 += h4;</span>
<span class="lineNum"> 179 </span><span class="lineCov"> 2076827 : h2 += h1; h3 += h1; h4 += h1;</span>
<span class="lineNum"> 178 </span><span class="lineCov"> 2076854 : h1 += h2; h1 += h3; h1 += h4;</span>
<span class="lineNum"> 179 </span><span class="lineCov"> 2076854 : h2 += h1; h3 += h1; h4 += h1;</span>
<span class="lineNum"> 180 </span> :
<span class="lineNum"> 181 </span> : #if WORDS_BIGENDIAN
<span class="lineNum"> 182 </span> : h1 = util_swap32(h1);
@ -247,11 +247,11 @@
<span class="lineNum"> 185 </span> : h4 = util_swap32(h4);
<span class="lineNum"> 186 </span> : #endif
<span class="lineNum"> 187 </span> :
<span class="lineNum"> 188 </span><span class="lineCov"> 2076827 : ((uint32_t*)digest)[0] = h1;</span>
<span class="lineNum"> 189 </span><span class="lineCov"> 2076827 : ((uint32_t*)digest)[1] = h2;</span>
<span class="lineNum"> 190 </span><span class="lineCov"> 2076827 : ((uint32_t*)digest)[2] = h3;</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 2076827 : ((uint32_t*)digest)[3] = h4;</span>
<span class="lineNum"> 192 </span><span class="lineCov"> 2076827 : }</span>
<span class="lineNum"> 188 </span><span class="lineCov"> 2076854 : ((uint32_t*)digest)[0] = h1;</span>
<span class="lineNum"> 189 </span><span class="lineCov"> 2076854 : ((uint32_t*)digest)[1] = h2;</span>
<span class="lineNum"> 190 </span><span class="lineCov"> 2076854 : ((uint32_t*)digest)[2] = h3;</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 2076854 : ((uint32_t*)digest)[3] = h4;</span>
<span class="lineNum"> 192 </span><span class="lineCov"> 2076854 : }</span>
<span class="lineNum"> 193 </span> :
</pre>
</td>

26
cov/cmdline/parity.c.func-sort-c.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">206</td>
<td class="headerCovTableEntry">240</td>
<td class="headerCovTableEntryMed">85.8 %</td>
<td class="headerCovTableEntry">217</td>
<td class="headerCovTableEntry">236</td>
<td class="headerCovTableEntryHi">91.9 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -60,16 +60,16 @@
<td width="20%" class="tableHead">Hit count <span class="tableHeadSort"><img src="../glass.png" width=10 height=14 alt="Sort by hit count" title="Sort by hit count" border=0></span></td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#757">parity_split_find</a></td>
<td class="coverFnHi">4113567</td>
<td class="coverFn"><a href="parity.c.gcov.html#765">parity_split_find</a></td>
<td class="coverFnHi">4114025</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#816">parity_read</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#824">parity_read</a></td>
<td class="coverFnHi">3501825</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#776">parity_write</a></td>
<td class="coverFnHi">611751</td>
<td class="coverFn"><a href="parity.c.gcov.html#784">parity_write</a></td>
<td class="coverFnHi">612195</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#457">parity_handle_chsize</a></td>
@ -80,7 +80,7 @@
<td class="coverFnHi">2460</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#728">parity_close</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#736">parity_close</a></td>
<td class="coverFnHi">1022</td>
</tr>
<tr>
@ -93,7 +93,7 @@
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#33">parity_allocated_size</a></td>
<td class="coverFnHi">638</td>
<td class="coverFnHi">640</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#175">parity_create</a></td>
@ -108,11 +108,11 @@
<td class="coverFnHi">487</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#703">parity_sync</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#711">parity_sync</a></td>
<td class="coverFnHi">469</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#619">parity_open</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#627">parity_open</a></td>
<td class="coverFnHi">402</td>
</tr>
<tr>
@ -129,7 +129,7 @@
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#85">parity_is_invalid</a></td>
<td class="coverFnHi">1</td>
<td class="coverFnHi">2</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#118">parity_overflow</a></td>

26
cov/cmdline/parity.c.func.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">206</td>
<td class="headerCovTableEntry">240</td>
<td class="headerCovTableEntryMed">85.8 %</td>
<td class="headerCovTableEntry">217</td>
<td class="headerCovTableEntry">236</td>
<td class="headerCovTableEntryHi">91.9 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -65,14 +65,14 @@
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#33">parity_allocated_size</a></td>
<td class="coverFnHi">638</td>
<td class="coverFnHi">640</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#522">parity_chsize</a></td>
<td class="coverFnHi">615</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#728">parity_close</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#736">parity_close</a></td>
<td class="coverFnHi">1022</td>
</tr>
<tr>
@ -97,10 +97,10 @@
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#85">parity_is_invalid</a></td>
<td class="coverFnHi">1</td>
<td class="coverFnHi">2</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#619">parity_open</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#627">parity_open</a></td>
<td class="coverFnHi">402</td>
</tr>
<tr>
@ -108,7 +108,7 @@
<td class="coverFnLo">0</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#816">parity_read</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#824">parity_read</a></td>
<td class="coverFnHi">3501825</td>
</tr>
<tr>
@ -116,15 +116,15 @@
<td class="coverFnHi">487</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#757">parity_split_find</a></td>
<td class="coverFnHi">4113567</td>
<td class="coverFn"><a href="parity.c.gcov.html#765">parity_split_find</a></td>
<td class="coverFnHi">4114025</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#506">parity_split_is_fixed</a></td>
<td class="coverFnHi">2460</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#703">parity_sync</a></td>
<td class="coverFn"><a href="parity.c.gcov.html#711">parity_sync</a></td>
<td class="coverFnHi">469</td>
</tr>
<tr>
@ -132,8 +132,8 @@
<td class="coverFnHi">87</td>
</tr>
<tr>
<td class="coverFn"><a href="parity.c.gcov.html#776">parity_write</a></td>
<td class="coverFnHi">611751</td>
<td class="coverFn"><a href="parity.c.gcov.html#784">parity_write</a></td>
<td class="coverFnHi">612195</td>
</tr>
</table>
<br>

688
cov/cmdline/parity.c.gcov.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">206</td>
<td class="headerCovTableEntry">240</td>
<td class="headerCovTableEntryMed">85.8 %</td>
<td class="headerCovTableEntry">217</td>
<td class="headerCovTableEntry">236</td>
<td class="headerCovTableEntryHi">91.9 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -94,31 +94,31 @@
<span class="lineNum"> 32 </span> : /****************************************************************************/
<a name="33"><span class="lineNum"> 33 </span> : /* parity */</a>
<span class="lineNum"> 34 </span> :
<span class="lineNum"> 35 </span><span class="lineCov"> 638 : block_off_t parity_allocated_size(struct snapraid_state* state)</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 640 : block_off_t parity_allocated_size(struct snapraid_state* state)</span>
<span class="lineNum"> 36 </span> : {
<span class="lineNum"> 37 </span> : block_off_t parity_block;
<span class="lineNum"> 38 </span> : tommy_node* i;
<span class="lineNum"> 39 </span> :
<span class="lineNum"> 40 </span> : /* compute the size of the parity file */
<span class="lineNum"> 41 </span><span class="lineCov"> 638 : parity_block = 0;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 4456 : for (i = state-&gt;disklist; i != 0; i = i-&gt;next) {</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 3818 : struct snapraid_disk* disk = i-&gt;data;</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 640 : parity_block = 0;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 4470 : for (i = state-&gt;disklist; i != 0; i = i-&gt;next) {</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 3830 : struct snapraid_disk* disk = i-&gt;data;</span>
<span class="lineNum"> 44 </span> :
<span class="lineNum"> 45 </span> : /* start from the declared size */
<span class="lineNum"> 46 </span><span class="lineCov"> 3818 : block_off_t block = fs_size(disk);</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 3830 : block_off_t block = fs_size(disk);</span>
<span class="lineNum"> 47 </span> :
<span class="lineNum"> 48 </span> : /* decrease the block until an allocated one, but part of a file */
<span class="lineNum"> 49 </span> : /* we don't stop at deleted blocks, because we want to have them cleared */
<span class="lineNum"> 50 </span> : /* if they are at the end of the parity */
<span class="lineNum"> 51 </span><span class="lineCov"> 190184 : while (block &gt; parity_block &amp;&amp; !block_has_file(fs_par2block_find(disk, block - 1)))</span>
<span class="lineNum"> 51 </span><span class="lineCov"> 190208 : while (block &gt; parity_block &amp;&amp; !block_has_file(fs_par2block_find(disk, block - 1)))</span>
<span class="lineNum"> 52 </span><span class="lineCov"> 182548 : --block;</span>
<span class="lineNum"> 53 </span> :
<span class="lineNum"> 54 </span> : /* get the highest value */
<span class="lineNum"> 55 </span><span class="lineCov"> 3818 : if (block &gt; parity_block)</span>
<span class="lineNum"> 56 </span><span class="lineCov"> 2263 : parity_block = block;</span>
<span class="lineNum"> 55 </span><span class="lineCov"> 3830 : if (block &gt; parity_block)</span>
<span class="lineNum"> 56 </span><span class="lineCov"> 2265 : parity_block = block;</span>
<span class="lineNum"> 57 </span> : }
<span class="lineNum"> 58 </span> :
<span class="lineNum"> 59 </span><span class="lineCov"> 638 : return parity_block;</span>
<span class="lineNum"> 59 </span><span class="lineCov"> 640 : return parity_block;</span>
<a name="60"><span class="lineNum"> 60 </span> : }</a>
<span class="lineNum"> 61 </span> :
<span class="lineNum"> 62 </span><span class="lineCov"> 87 : block_off_t parity_used_size(struct snapraid_state* state)</span>
@ -146,34 +146,34 @@
<span class="lineNum"> 84 </span><span class="lineCov"> 87 : return parity_block;</span>
<a name="85"><span class="lineNum"> 85 </span> : }</a>
<span class="lineNum"> 86 </span> :
<span class="lineNum"> 87 </span><span class="lineCov"> 1 : int parity_is_invalid(struct snapraid_state* state)</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 2 : int parity_is_invalid(struct snapraid_state* state)</span>
<span class="lineNum"> 88 </span> : {
<span class="lineNum"> 89 </span> : block_off_t blockmax;
<span class="lineNum"> 90 </span> : block_off_t i;
<span class="lineNum"> 91 </span> :
<span class="lineNum"> 92 </span><span class="lineCov"> 1 : blockmax = parity_allocated_size(state);</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 2 : blockmax = parity_allocated_size(state);</span>
<span class="lineNum"> 93 </span> :
<span class="lineNum"> 94 </span><span class="lineCov"> 1 : for (i = 0; i &lt; blockmax; ++i) {</span>
<span class="lineNum"> 94 </span><span class="lineCov"> 2 : for (i = 0; i &lt; blockmax; ++i) {</span>
<span class="lineNum"> 95 </span> : tommy_node* node_disk;
<span class="lineNum"> 96 </span> : int one_invalid;
<span class="lineNum"> 97 </span> : int one_valid;
<span class="lineNum"> 98 </span> :
<span class="lineNum"> 99 </span> : /* for each disk */
<span class="lineNum"> 100 </span><span class="lineNoCov"> 0 : one_invalid = 0;</span>
<span class="lineNum"> 101 </span><span class="lineNoCov"> 0 : one_valid = 0;</span>
<span class="lineNum"> 102 </span><span class="lineNoCov"> 0 : for (node_disk = state-&gt;disklist; node_disk != 0; node_disk = node_disk-&gt;next) {</span>
<span class="lineNum"> 103 </span><span class="lineNoCov"> 0 : struct snapraid_disk* disk = node_disk-&gt;data;</span>
<span class="lineNum"> 104 </span><span class="lineNoCov"> 0 : struct snapraid_block* block = fs_par2block_find(disk, i);</span>
<span class="lineNum"> 100 </span><span class="lineCov"> 1 : one_invalid = 0;</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 1 : one_valid = 0;</span>
<span class="lineNum"> 102 </span><span class="lineCov"> 7 : for (node_disk = state-&gt;disklist; node_disk != 0; node_disk = node_disk-&gt;next) {</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 6 : struct snapraid_disk* disk = node_disk-&gt;data;</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 6 : struct snapraid_block* block = fs_par2block_find(disk, i);</span>
<span class="lineNum"> 105 </span> :
<span class="lineNum"> 106 </span><span class="lineNoCov"> 0 : if (block_has_file(block))</span>
<span class="lineNum"> 107 </span><span class="lineNoCov"> 0 : one_valid = 1;</span>
<span class="lineNum"> 108 </span><span class="lineNoCov"> 0 : if (block_has_invalid_parity(block))</span>
<span class="lineNum"> 109 </span><span class="lineNoCov"> 0 : one_invalid = 1;</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 6 : if (block_has_file(block))</span>
<span class="lineNum"> 107 </span><span class="lineCov"> 5 : one_valid = 1;</span>
<span class="lineNum"> 108 </span><span class="lineCov"> 6 : if (block_has_invalid_parity(block))</span>
<span class="lineNum"> 109 </span><span class="lineCov"> 2 : one_invalid = 1;</span>
<span class="lineNum"> 110 </span> : }
<span class="lineNum"> 111 </span> :
<span class="lineNum"> 112 </span> : /* if both valid and invalid, we need to update */
<span class="lineNum"> 113 </span><span class="lineNoCov"> 0 : if (one_invalid &amp;&amp; one_valid)</span>
<span class="lineNum"> 114 </span><span class="lineNoCov"> 0 : return 1;</span>
<span class="lineNum"> 113 </span><span class="lineCov"> 1 : if (one_invalid &amp;&amp; one_valid)</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 1 : return 1;</span>
<span class="lineNum"> 115 </span> : }
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span><span class="lineCov"> 1 : return 0;</span>
@ -592,339 +592,347 @@
<span class="lineNum"> 530 </span> : /* mask of bits used by the block size */
<span class="lineNum"> 531 </span><span class="lineCov"> 615 : block_mask = ((data_off_t)block_size) - 1;</span>
<span class="lineNum"> 532 </span> :
<span class="lineNum"> 533 </span><span class="lineCov"> 615 : if (size &lt; 0)</span>
<span class="lineNum"> 534 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 535 </span> :
<span class="lineNum"> 536 </span><span class="lineCov"> 3075 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 537 </span><span class="lineCov"> 2460 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 538 </span><span class="lineCov"> 2460 : int is_fixed = parity_split_is_fixed(handle, s);</span>
<span class="lineNum"> 539 </span> : data_off_t run;
<span class="lineNum"> 540 </span> :
<span class="lineNum"> 541 </span><span class="lineCov"> 2460 : if (is_fixed) {</span>
<span class="lineNum"> 542 </span> : /* if the required size is smaller, we have to reduce also the file */
<span class="lineNum"> 543 </span> : /* ignoring the previous size */
<span class="lineNum"> 544 </span><span class="lineCov"> 611 : if (size &lt;= split-&gt;size) {</span>
<span class="lineNum"> 545 </span> : /* mark it as not fixed anymore for the later check */
<span class="lineNum"> 546 </span><span class="lineCov"> 10 : is_fixed = 0;</span>
<span class="lineNum"> 547 </span> :
<span class="lineNum"> 548 </span><span class="lineCov"> 10 : run = size; /* allocate only the needed size */</span>
<span class="lineNum"> 549 </span> : } else {
<span class="lineNum"> 550 </span> : /* if the size cannot be changed, use the fixed one */
<span class="lineNum"> 551 </span><span class="lineCov"> 601 : run = split-&gt;size;</span>
<span class="lineNum"> 552 </span> :
<span class="lineNum"> 553 </span><span class="lineCov"> 601 : if ((run &amp; block_mask) != 0) {</span>
<span class="lineNum"> 554 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 555 </span> : log_fatal(&quot;Internal inconsistency in split '%s' size with extra '%&quot; PRIu64 &quot;' bytes.\n&quot;, split-&gt;path, run &amp; block_mask);
<span class="lineNum"> 556 </span> : return -1;
<span class="lineNum"> 557 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 558 </span> : }
<span class="lineNum"> 559 </span> : }
<span class="lineNum"> 560 </span> : } else {
<span class="lineNum"> 561 </span> : /* otherwise tries to allocate all the needed remaining size */
<span class="lineNum"> 562 </span><span class="lineCov"> 1849 : run = size;</span>
<span class="lineNum"> 563 </span> : }
<span class="lineNum"> 564 </span> :
<span class="lineNum"> 565 </span><span class="lineCov"> 2460 : ret = parity_handle_chsize(split, run, block_size, skip_fallocate, skip_space_holder);</span>
<span class="lineNum"> 566 </span><span class="lineCov"> 2460 : if (ret != 0)</span>
<span class="lineNum"> 567 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 568 </span> :
<span class="lineNum"> 569 </span><span class="lineCov"> 2460 : if (split-&gt;st.st_size &gt; run) {</span>
<span class="lineNum"> 533 </span><span class="lineCov"> 615 : if (size &lt; 0) {</span>
<span class="lineNum"> 534 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 535 </span> : return -1;
<span class="lineNum"> 536 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 537 </span> : }
<span class="lineNum"> 538 </span> :
<span class="lineNum"> 539 </span><span class="lineCov"> 3075 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 540 </span><span class="lineCov"> 2460 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 541 </span><span class="lineCov"> 2460 : int is_fixed = parity_split_is_fixed(handle, s);</span>
<span class="lineNum"> 542 </span> : data_off_t run;
<span class="lineNum"> 543 </span> :
<span class="lineNum"> 544 </span><span class="lineCov"> 2460 : if (is_fixed) {</span>
<span class="lineNum"> 545 </span> : /* if the required size is smaller, we have to reduce also the file */
<span class="lineNum"> 546 </span> : /* ignoring the previous size */
<span class="lineNum"> 547 </span><span class="lineCov"> 611 : if (size &lt;= split-&gt;size) {</span>
<span class="lineNum"> 548 </span> : /* mark it as not fixed anymore for the later check */
<span class="lineNum"> 549 </span><span class="lineCov"> 10 : is_fixed = 0;</span>
<span class="lineNum"> 550 </span> :
<span class="lineNum"> 551 </span><span class="lineCov"> 10 : run = size; /* allocate only the needed size */</span>
<span class="lineNum"> 552 </span> : } else {
<span class="lineNum"> 553 </span> : /* if the size cannot be changed, use the fixed one */
<span class="lineNum"> 554 </span><span class="lineCov"> 601 : run = split-&gt;size;</span>
<span class="lineNum"> 555 </span> :
<span class="lineNum"> 556 </span><span class="lineCov"> 601 : if ((run &amp; block_mask) != 0) {</span>
<span class="lineNum"> 557 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 558 </span> : log_fatal(&quot;Internal inconsistency in split '%s' size with extra '%&quot; PRIu64 &quot;' bytes.\n&quot;, split-&gt;path, run &amp; block_mask);
<span class="lineNum"> 559 </span> : return -1;
<span class="lineNum"> 560 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 561 </span> : }
<span class="lineNum"> 562 </span> : }
<span class="lineNum"> 563 </span> : } else {
<span class="lineNum"> 564 </span> : /* otherwise tries to allocate all the needed remaining size */
<span class="lineNum"> 565 </span><span class="lineCov"> 1849 : run = size;</span>
<span class="lineNum"> 566 </span> : }
<span class="lineNum"> 567 </span> :
<span class="lineNum"> 568 </span><span class="lineCov"> 2460 : ret = parity_handle_chsize(split, run, block_size, skip_fallocate, skip_space_holder);</span>
<span class="lineNum"> 569 </span><span class="lineCov"> 2460 : if (ret != 0) {</span>
<span class="lineNum"> 570 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 571 </span> : log_fatal(&quot;Unexpected over resizing parity file '%s' to size %&quot; PRIu64 &quot; resulting in size %&quot; PRIu64 &quot;.\n&quot;, split-&gt;path, run, split-&gt;st.st_size);
<span class="lineNum"> 572 </span> : return -1;
<span class="lineNum"> 573 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 574 </span><span class="lineCov"> 2460 : } else if (is_fixed &amp;&amp; split-&gt;st.st_size &lt; run) {</span>
<span class="lineNum"> 575 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 576 </span> : log_fatal(&quot;Failed restoring parity file '%s' to size %&quot; PRIu64 &quot; resulting in size %&quot; PRIu64 &quot;.\n&quot;, split-&gt;path, run, split-&gt;st.st_size);
<span class="lineNum"> 577 </span> : return -1;
<span class="lineNum"> 578 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 579 </span> : } else {
<span class="lineNum"> 580 </span> : /* here it's possible to get less than the requested size */
<span class="lineNum"> 581 </span><span class="lineCov"> 2460 : run = split-&gt;st.st_size;</span>
<span class="lineNum"> 582 </span> :
<span class="lineNum"> 583 </span><span class="lineCov"> 2460 : if ((run &amp; block_mask) != 0) {</span>
<span class="lineNum"> 584 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 585 </span> : log_fatal(&quot;Internal inconsistency in final parity size %&quot; PRIu64 &quot; with block size %u\n&quot;, run, block_size);
<span class="lineNum"> 586 </span> : os_abort();
<span class="lineNum"> 587 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 588 </span> : }
<span class="lineNum"> 589 </span> :
<span class="lineNum"> 590 </span> : /* store what we have allocated */
<span class="lineNum"> 591 </span><span class="lineCov"> 2460 : split-&gt;size = run;</span>
<span class="lineNum"> 592 </span> :
<span class="lineNum"> 593 </span> : /* decrease the remaining size */
<span class="lineNum"> 594 </span><span class="lineCov"> 2460 : size -= run;</span>
<span class="lineNum"> 595 </span> : }
<span class="lineNum"> 596 </span> : }
<span class="lineNum"> 597 </span> :
<span class="lineNum"> 598 </span> : /* if we cannot allocate all the space */
<span class="lineNum"> 599 </span><span class="lineCov"> 615 : if (size != 0) {</span>
<span class="lineNum"> 600 </span><span class="lineNoCov"> 0 : log_fatal(&quot;Failed to allocate all the required parity space. You miss %&quot; PRIu64 &quot; bytes.\n&quot;, size);</span>
<span class="lineNum"> 601 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 571 </span> : return -1;
<span class="lineNum"> 572 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 573 </span> : }
<span class="lineNum"> 574 </span> :
<span class="lineNum"> 575 </span><span class="lineCov"> 2460 : if (split-&gt;st.st_size &gt; run) {</span>
<span class="lineNum"> 576 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 577 </span> : log_fatal(&quot;Unexpected over resizing parity file '%s' to size %&quot; PRIu64 &quot; resulting in size %&quot; PRIu64 &quot;.\n&quot;, split-&gt;path, run, split-&gt;st.st_size);
<span class="lineNum"> 578 </span> : return -1;
<span class="lineNum"> 579 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 580 </span><span class="lineCov"> 2460 : } else if (is_fixed &amp;&amp; split-&gt;st.st_size &lt; run) {</span>
<span class="lineNum"> 581 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 582 </span> : log_fatal(&quot;Failed restoring parity file '%s' to size %&quot; PRIu64 &quot; resulting in size %&quot; PRIu64 &quot;.\n&quot;, split-&gt;path, run, split-&gt;st.st_size);
<span class="lineNum"> 583 </span> : return -1;
<span class="lineNum"> 584 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 585 </span> : } else {
<span class="lineNum"> 586 </span> : /* here it's possible to get less than the requested size */
<span class="lineNum"> 587 </span><span class="lineCov"> 2460 : run = split-&gt;st.st_size;</span>
<span class="lineNum"> 588 </span> :
<span class="lineNum"> 589 </span><span class="lineCov"> 2460 : if ((run &amp; block_mask) != 0) {</span>
<span class="lineNum"> 590 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 591 </span> : log_fatal(&quot;Internal inconsistency in final parity size %&quot; PRIu64 &quot; with block size %u\n&quot;, run, block_size);
<span class="lineNum"> 592 </span> : os_abort();
<span class="lineNum"> 593 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 594 </span> : }
<span class="lineNum"> 595 </span> :
<span class="lineNum"> 596 </span> : /* store what we have allocated */
<span class="lineNum"> 597 </span><span class="lineCov"> 2460 : split-&gt;size = run;</span>
<span class="lineNum"> 598 </span> :
<span class="lineNum"> 599 </span> : /* decrease the remaining size */
<span class="lineNum"> 600 </span><span class="lineCov"> 2460 : size -= run;</span>
<span class="lineNum"> 601 </span> : }
<span class="lineNum"> 602 </span> : }
<span class="lineNum"> 603 </span> :
<span class="lineNum"> 604 </span> : /* now copy the new size in the parity data */
<span class="lineNum"> 605 </span><span class="lineCov"> 615 : if (is_modified)</span>
<span class="lineNum"> 606 </span><span class="lineCov"> 481 : *is_modified = 0;</span>
<span class="lineNum"> 607 </span> :
<span class="lineNum"> 608 </span><span class="lineCov"> 3075 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 609 </span><span class="lineCov"> 2460 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 610 </span> :
<span class="lineNum"> 611 </span><span class="lineCov"> 2460 : if (parity-&gt;split_map[s].size != split-&gt;size) {</span>
<span class="lineNum"> 612 </span><span class="lineCov"> 320 : parity-&gt;split_map[s].size = split-&gt;size;</span>
<span class="lineNum"> 613 </span><span class="lineCov"> 320 : if (is_modified)</span>
<span class="lineNum"> 614 </span><span class="lineCov"> 264 : *is_modified = 1;</span>
<span class="lineNum"> 615 </span> : }
<span class="lineNum"> 616 </span> : }
<span class="lineNum"> 617 </span> :
<span class="lineNum"> 618 </span><span class="lineCov"> 615 : return 0;</span>
<a name="619"><span class="lineNum"> 619 </span> : }</a>
<span class="lineNum"> 620 </span> :
<span class="lineNum"> 621 </span><span class="lineCov"> 402 : int parity_open(struct snapraid_parity_handle* handle, const struct snapraid_parity* parity, unsigned level, int mode, uint32_t block_size, data_off_t limit_size)</span>
<span class="lineNum"> 622 </span> : {
<span class="lineNum"> 623 </span> : unsigned s;
<span class="lineNum"> 624 </span> : data_off_t block_mask;
<span class="lineNum"> 604 </span> : /* if we cannot allocate all the space */
<span class="lineNum"> 605 </span><span class="lineCov"> 615 : if (size != 0) {</span>
<span class="lineNum"> 606 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 607 </span> : log_fatal(&quot;Failed to allocate all the required parity space. You miss %&quot; PRIu64 &quot; bytes.\n&quot;, size);
<span class="lineNum"> 608 </span> : return -1;
<span class="lineNum"> 609 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 610 </span> : }
<span class="lineNum"> 611 </span> :
<span class="lineNum"> 612 </span> : /* now copy the new size in the parity data */
<span class="lineNum"> 613 </span><span class="lineCov"> 615 : if (is_modified)</span>
<span class="lineNum"> 614 </span><span class="lineCov"> 481 : *is_modified = 0;</span>
<span class="lineNum"> 615 </span> :
<span class="lineNum"> 616 </span><span class="lineCov"> 3075 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 617 </span><span class="lineCov"> 2460 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 618 </span> :
<span class="lineNum"> 619 </span><span class="lineCov"> 2460 : if (parity-&gt;split_map[s].size != split-&gt;size) {</span>
<span class="lineNum"> 620 </span><span class="lineCov"> 320 : parity-&gt;split_map[s].size = split-&gt;size;</span>
<span class="lineNum"> 621 </span><span class="lineCov"> 320 : if (is_modified)</span>
<span class="lineNum"> 622 </span><span class="lineCov"> 264 : *is_modified = 1;</span>
<span class="lineNum"> 623 </span> : }
<span class="lineNum"> 624 </span> : }
<span class="lineNum"> 625 </span> :
<span class="lineNum"> 626 </span><span class="lineCov"> 402 : handle-&gt;level = level;</span>
<span class="lineNum"> 627 </span><span class="lineCov"> 402 : handle-&gt;split_mac = 0;</span>
<span class="lineNum"> 626 </span><span class="lineCov"> 615 : return 0;</span>
<a name="627"><span class="lineNum"> 627 </span> : }</a>
<span class="lineNum"> 628 </span> :
<span class="lineNum"> 629 </span> : /* mask of bits used by the block size */
<span class="lineNum"> 630 </span><span class="lineCov"> 402 : block_mask = ((data_off_t)block_size) - 1;</span>
<span class="lineNum"> 631 </span> :
<span class="lineNum"> 632 </span><span class="lineCov"> 2006 : for (s = 0;s &lt; parity-&gt;split_mac;++s) {</span>
<span class="lineNum"> 633 </span><span class="lineCov"> 1605 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 634 </span> : int ret;
<span class="lineNum"> 635 </span> : int flags;
<span class="lineNum"> 629 </span><span class="lineCov"> 402 : int parity_open(struct snapraid_parity_handle* handle, const struct snapraid_parity* parity, unsigned level, int mode, uint32_t block_size, data_off_t limit_size)</span>
<span class="lineNum"> 630 </span> : {
<span class="lineNum"> 631 </span> : unsigned s;
<span class="lineNum"> 632 </span> : data_off_t block_mask;
<span class="lineNum"> 633 </span> :
<span class="lineNum"> 634 </span><span class="lineCov"> 402 : handle-&gt;level = level;</span>
<span class="lineNum"> 635 </span><span class="lineCov"> 402 : handle-&gt;split_mac = 0;</span>
<span class="lineNum"> 636 </span> :
<span class="lineNum"> 637 </span><span class="lineCov"> 1605 : advise_init(&amp;split-&gt;advise, mode);</span>
<span class="lineNum"> 638 </span><span class="lineCov"> 1605 : pathcpy(split-&gt;path, sizeof(split-&gt;path), parity-&gt;split_map[s].path);</span>
<span class="lineNum"> 639 </span><span class="lineCov"> 1605 : split-&gt;size = parity-&gt;split_map[s].size;</span>
<span class="lineNum"> 640 </span><span class="lineCov"> 1605 : split-&gt;limit_size = PARITY_LIMIT(limit_size, s, level);</span>
<span class="lineNum"> 641 </span> :
<span class="lineNum"> 642 </span> : /* open for read */
<span class="lineNum"> 643 </span> : /* O_NOATIME: do not change access time */
<span class="lineNum"> 644 </span><span class="lineCov"> 1605 : flags = O_RDONLY | O_BINARY | advise_flags(&amp;split-&gt;advise);</span>
<span class="lineNum"> 645 </span> :
<span class="lineNum"> 646 </span><span class="lineCov"> 1605 : split-&gt;f = open_noatime(split-&gt;path, flags);</span>
<span class="lineNum"> 647 </span><span class="lineCov"> 1605 : if (split-&gt;f == -1) {</span>
<span class="lineNum"> 648 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 649 </span> : log_fatal(&quot;Error opening parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 650 </span> : goto bail;
<span class="lineNum"> 651 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 652 </span> : }
<span class="lineNum"> 637 </span> : /* mask of bits used by the block size */
<span class="lineNum"> 638 </span><span class="lineCov"> 402 : block_mask = ((data_off_t)block_size) - 1;</span>
<span class="lineNum"> 639 </span> :
<span class="lineNum"> 640 </span><span class="lineCov"> 2006 : for (s = 0;s &lt; parity-&gt;split_mac;++s) {</span>
<span class="lineNum"> 641 </span><span class="lineCov"> 1605 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 642 </span> : int ret;
<span class="lineNum"> 643 </span> : int flags;
<span class="lineNum"> 644 </span> :
<span class="lineNum"> 645 </span><span class="lineCov"> 1605 : advise_init(&amp;split-&gt;advise, mode);</span>
<span class="lineNum"> 646 </span><span class="lineCov"> 1605 : pathcpy(split-&gt;path, sizeof(split-&gt;path), parity-&gt;split_map[s].path);</span>
<span class="lineNum"> 647 </span><span class="lineCov"> 1605 : split-&gt;size = parity-&gt;split_map[s].size;</span>
<span class="lineNum"> 648 </span><span class="lineCov"> 1605 : split-&gt;limit_size = PARITY_LIMIT(limit_size, s, level);</span>
<span class="lineNum"> 649 </span> :
<span class="lineNum"> 650 </span> : /* open for read */
<span class="lineNum"> 651 </span> : /* O_NOATIME: do not change access time */
<span class="lineNum"> 652 </span><span class="lineCov"> 1605 : flags = O_RDONLY | O_BINARY | advise_flags(&amp;split-&gt;advise);</span>
<span class="lineNum"> 653 </span> :
<span class="lineNum"> 654 </span> : /* we have a valid file handle */
<span class="lineNum"> 655 </span><span class="lineCov"> 1604 : ++handle-&gt;split_mac;</span>
<span class="lineNum"> 656 </span> :
<span class="lineNum"> 657 </span> : /* get the stat info */
<span class="lineNum"> 658 </span><span class="lineCov"> 1604 : ret = fstat(split-&gt;f, &amp;split-&gt;st);</span>
<span class="lineNum"> 659 </span><span class="lineCov"> 1604 : if (ret != 0) {</span>
<span class="lineNum"> 660 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 661 </span> : log_fatal(&quot;Error accessing parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 662 </span> : goto bail;
<span class="lineNum"> 663 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 664 </span> : }
<span class="lineNum"> 665 </span> :
<span class="lineNum"> 666 </span> : /**
<span class="lineNum"> 667 </span> : * If the parity size is not yet set, set it now.
<span class="lineNum"> 668 </span> : * This happens when expanding the number of parities,
<span class="lineNum"> 669 </span> : * or when upgrading from a content file that has not split-&gt;size data.
<span class="lineNum"> 670 </span> : */
<span class="lineNum"> 671 </span><span class="lineCov"> 1604 : if (split-&gt;size == PARITY_SIZE_INVALID) {</span>
<span class="lineNum"> 672 </span><span class="lineCov"> 40 : split-&gt;size = split-&gt;st.st_size;</span>
<span class="lineNum"> 654 </span><span class="lineCov"> 1605 : split-&gt;f = open_noatime(split-&gt;path, flags);</span>
<span class="lineNum"> 655 </span><span class="lineCov"> 1605 : if (split-&gt;f == -1) {</span>
<span class="lineNum"> 656 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 657 </span> : log_fatal(&quot;Error opening parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 658 </span> : goto bail;
<span class="lineNum"> 659 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 660 </span> : }
<span class="lineNum"> 661 </span> :
<span class="lineNum"> 662 </span> : /* we have a valid file handle */
<span class="lineNum"> 663 </span><span class="lineCov"> 1604 : ++handle-&gt;split_mac;</span>
<span class="lineNum"> 664 </span> :
<span class="lineNum"> 665 </span> : /* get the stat info */
<span class="lineNum"> 666 </span><span class="lineCov"> 1604 : ret = fstat(split-&gt;f, &amp;split-&gt;st);</span>
<span class="lineNum"> 667 </span><span class="lineCov"> 1604 : if (ret != 0) {</span>
<span class="lineNum"> 668 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 669 </span> : log_fatal(&quot;Error accessing parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 670 </span> : goto bail;
<span class="lineNum"> 671 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 672 </span> : }
<span class="lineNum"> 673 </span> :
<span class="lineNum"> 674 </span> : /* ensure that the resulting size if block aligned */
<span class="lineNum"> 675 </span><span class="lineCov"> 40 : if ((split-&gt;size &amp; block_mask) != 0) {</span>
<span class="lineNum"> 676 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 677 </span> : log_fatal(&quot;Error in preallocated size of parity file '%s' with size %&quot; PRIu64 &quot; and block %u .\n&quot;, split-&gt;path, split-&gt;size, block_size);
<span class="lineNum"> 678 </span> : goto bail;
<span class="lineNum"> 679 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 680 </span> : }
<span class="lineNum"> 681 </span> : }
<span class="lineNum"> 682 </span> :
<span class="lineNum"> 683 </span><span class="lineCov"> 1604 : ret = advise_open(&amp;split-&gt;advise, split-&gt;f);</span>
<span class="lineNum"> 684 </span><span class="lineCov"> 1604 : if (ret != 0) {</span>
<span class="lineNum"> 685 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 686 </span> : log_fatal(&quot;Error advising parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 687 </span> : goto bail;
<span class="lineNum"> 688 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 674 </span> : /**
<span class="lineNum"> 675 </span> : * If the parity size is not yet set, set it now.
<span class="lineNum"> 676 </span> : * This happens when expanding the number of parities,
<span class="lineNum"> 677 </span> : * or when upgrading from a content file that has not split-&gt;size data.
<span class="lineNum"> 678 </span> : */
<span class="lineNum"> 679 </span><span class="lineCov"> 1604 : if (split-&gt;size == PARITY_SIZE_INVALID) {</span>
<span class="lineNum"> 680 </span><span class="lineCov"> 40 : split-&gt;size = split-&gt;st.st_size;</span>
<span class="lineNum"> 681 </span> :
<span class="lineNum"> 682 </span> : /* ensure that the resulting size if block aligned */
<span class="lineNum"> 683 </span><span class="lineCov"> 40 : if ((split-&gt;size &amp; block_mask) != 0) {</span>
<span class="lineNum"> 684 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 685 </span> : log_fatal(&quot;Error in preallocated size of parity file '%s' with size %&quot; PRIu64 &quot; and block %u .\n&quot;, split-&gt;path, split-&gt;size, block_size);
<span class="lineNum"> 686 </span> : goto bail;
<span class="lineNum"> 687 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 688 </span> : }
<span class="lineNum"> 689 </span> : }
<span class="lineNum"> 690 </span> : }
<span class="lineNum"> 691 </span> :
<span class="lineNum"> 692 </span><span class="lineCov"> 401 : return 0;</span>
<span class="lineNum"> 693 </span> :
<span class="lineNum"> 694 </span> : bail:
<span class="lineNum"> 695 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 696 </span> : for (s = 0;s &lt; handle-&gt;split_mac;++s) {
<span class="lineNum"> 697 </span> : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];
<span class="lineNum"> 698 </span> : close(split-&gt;f);
<span class="lineNum"> 699 </span> : split-&gt;f = -1;
<span class="lineNum"> 700 </span> : }
<span class="lineNum"> 701 </span> : return -1;
<span class="lineNum"> 702 </span> : /* LCOV_EXCL_STOP */
<a name="703"><span class="lineNum"> 703 </span> : }</a>
<span class="lineNum"> 704 </span> :
<span class="lineNum"> 705 </span><span class="lineCov"> 469 : int parity_sync(struct snapraid_parity_handle* handle)</span>
<span class="lineNum"> 706 </span> : {
<span class="lineNum"> 707 </span> : #if HAVE_FSYNC
<span class="lineNum"> 708 </span> : unsigned s;
<span class="lineNum"> 709 </span> :
<span class="lineNum"> 710 </span><span class="lineCov"> 2345 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 711 </span><span class="lineCov"> 1876 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 712 </span> : int ret;
<span class="lineNum"> 713 </span> :
<span class="lineNum"> 714 </span> : /* Ensure that data changes are written to disk. */
<span class="lineNum"> 715 </span> : /* This is required to ensure that parity is more updated than content */
<span class="lineNum"> 716 </span> : /* in case of a system crash. */
<span class="lineNum"> 717 </span><span class="lineCov"> 1876 : ret = fsync(split-&gt;f);</span>
<span class="lineNum"> 718 </span><span class="lineCov"> 1876 : if (ret != 0) {</span>
<span class="lineNum"> 719 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 720 </span> : log_fatal(&quot;Error synching parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 721 </span> : return -1;
<span class="lineNum"> 722 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 723 </span> : }
<span class="lineNum"> 724 </span> : }
<span class="lineNum"> 725 </span> : #endif
<span class="lineNum"> 726 </span> :
<span class="lineNum"> 727 </span><span class="lineCov"> 469 : return 0;</span>
<a name="728"><span class="lineNum"> 728 </span> : }</a>
<span class="lineNum"> 729 </span> :
<span class="lineNum"> 730 </span><span class="lineCov"> 1022 : int parity_close(struct snapraid_parity_handle* handle)</span>
<span class="lineNum"> 731 </span> : {
<span class="lineNum"> 732 </span> : unsigned s;
<span class="lineNum"> 733 </span><span class="lineCov"> 1022 : int f_ret = 0;</span>
<span class="lineNum"> 690 </span> :
<span class="lineNum"> 691 </span><span class="lineCov"> 1604 : ret = advise_open(&amp;split-&gt;advise, split-&gt;f);</span>
<span class="lineNum"> 692 </span><span class="lineCov"> 1604 : if (ret != 0) {</span>
<span class="lineNum"> 693 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 694 </span> : log_fatal(&quot;Error advising parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 695 </span> : goto bail;
<span class="lineNum"> 696 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 697 </span> : }
<span class="lineNum"> 698 </span> : }
<span class="lineNum"> 699 </span> :
<span class="lineNum"> 700 </span><span class="lineCov"> 401 : return 0;</span>
<span class="lineNum"> 701 </span> :
<span class="lineNum"> 702 </span> : bail:
<span class="lineNum"> 703 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 704 </span> : for (s = 0;s &lt; handle-&gt;split_mac;++s) {
<span class="lineNum"> 705 </span> : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];
<span class="lineNum"> 706 </span> : close(split-&gt;f);
<span class="lineNum"> 707 </span> : split-&gt;f = -1;
<span class="lineNum"> 708 </span> : }
<span class="lineNum"> 709 </span> : return -1;
<span class="lineNum"> 710 </span> : /* LCOV_EXCL_STOP */
<a name="711"><span class="lineNum"> 711 </span> : }</a>
<span class="lineNum"> 712 </span> :
<span class="lineNum"> 713 </span><span class="lineCov"> 469 : int parity_sync(struct snapraid_parity_handle* handle)</span>
<span class="lineNum"> 714 </span> : {
<span class="lineNum"> 715 </span> : #if HAVE_FSYNC
<span class="lineNum"> 716 </span> : unsigned s;
<span class="lineNum"> 717 </span> :
<span class="lineNum"> 718 </span><span class="lineCov"> 2345 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 719 </span><span class="lineCov"> 1876 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 720 </span> : int ret;
<span class="lineNum"> 721 </span> :
<span class="lineNum"> 722 </span> : /* Ensure that data changes are written to disk. */
<span class="lineNum"> 723 </span> : /* This is required to ensure that parity is more updated than content */
<span class="lineNum"> 724 </span> : /* in case of a system crash. */
<span class="lineNum"> 725 </span><span class="lineCov"> 1876 : ret = fsync(split-&gt;f);</span>
<span class="lineNum"> 726 </span><span class="lineCov"> 1876 : if (ret != 0) {</span>
<span class="lineNum"> 727 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 728 </span> : log_fatal(&quot;Error synching parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 729 </span> : return -1;
<span class="lineNum"> 730 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 731 </span> : }
<span class="lineNum"> 732 </span> : }
<span class="lineNum"> 733 </span> : #endif
<span class="lineNum"> 734 </span> :
<span class="lineNum"> 735 </span><span class="lineCov"> 5110 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 736 </span><span class="lineCov"> 4088 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 737 </span> : int ret;
<span class="lineNum"> 738 </span> :
<span class="lineNum"> 739 </span><span class="lineCov"> 4088 : ret = close(split-&gt;f);</span>
<span class="lineNum"> 740 </span><span class="lineCov"> 4088 : if (ret != 0) {</span>
<span class="lineNum"> 741 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 742 </span> : /* This is a serious error, as it may be the result of a failed write */
<span class="lineNum"> 743 </span> : /* identified at later time. */
<span class="lineNum"> 744 </span> : /* In a normal file-system (not NFS) it should never happen */
<span class="lineNum"> 745 </span> : log_fatal(&quot;Error closing parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 746 </span> : f_ret = -1;
<span class="lineNum"> 747 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 748 </span> :
<span class="lineNum"> 749 </span> : /* continue to close the others */
<span class="lineNum"> 750 </span> : }
<span class="lineNum"> 751 </span> :
<span class="lineNum"> 752 </span> : /* reset the descriptor */
<span class="lineNum"> 753 </span><span class="lineCov"> 4088 : split-&gt;f = -1;</span>
<span class="lineNum"> 754 </span> : }
<span class="lineNum"> 755 </span> :
<span class="lineNum"> 756 </span><span class="lineCov"> 1022 : return f_ret;</span>
<a name="757"><span class="lineNum"> 757 </span> : }</a>
<span class="lineNum"> 758 </span> :
<span class="lineNum"> 759 </span><span class="lineCov"> 4113567 : struct snapraid_split_handle* parity_split_find(struct snapraid_parity_handle* handle, data_off_t* offset)</span>
<span class="lineNum"> 760 </span> : {
<span class="lineNum"> 761 </span> : unsigned s;
<span class="lineNum"> 762 </span> :
<span class="lineNum"> 763 </span><span class="lineCov"> 4113567 : if (*offset &lt; 0)</span>
<span class="lineNum"> 764 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 765 </span> :
<span class="lineNum"> 766 </span><span class="lineCov"> 6501737 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 767 </span><span class="lineCov"> 6490377 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 768 </span> :
<span class="lineNum"> 769 </span><span class="lineCov"> 6490377 : if (*offset &lt; split-&gt;size)</span>
<span class="lineNum"> 770 </span><span class="lineCov"> 4102207 : return split;</span>
<span class="lineNum"> 771 </span> :
<span class="lineNum"> 772 </span><span class="lineCov"> 2388170 : *offset -= split-&gt;size;</span>
<span class="lineNum"> 773 </span> : }
<span class="lineNum"> 774 </span> :
<span class="lineNum"> 775 </span><span class="lineCov"> 11360 : return 0;</span>
<a name="776"><span class="lineNum"> 776 </span> : }</a>
<span class="lineNum"> 777 </span> :
<span class="lineNum"> 778 </span><span class="lineCov"> 611751 : int parity_write(struct snapraid_parity_handle* handle, block_off_t pos, unsigned char* block_buffer, unsigned block_size)</span>
<span class="lineNum"> 779 </span> : {
<span class="lineNum"> 780 </span> : ssize_t write_ret;
<span class="lineNum"> 781 </span> : data_off_t offset;
<span class="lineNum"> 782 </span> : struct snapraid_split_handle* split;
<span class="lineNum"> 783 </span> : int ret;
<span class="lineNum"> 784 </span> :
<span class="lineNum"> 785 </span><span class="lineCov"> 611751 : offset = pos * (data_off_t)block_size;</span>
<span class="lineNum"> 786 </span> :
<span class="lineNum"> 787 </span><span class="lineCov"> 611751 : split = parity_split_find(handle, &amp;offset);</span>
<span class="lineNum"> 788 </span><span class="lineCov"> 611746 : if (!split) {</span>
<span class="lineNum"> 789 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 790 </span> : log_fatal(&quot;Writing parity data outside range at extra offset %&quot; PRIu64 &quot;.\n&quot;, offset);
<span class="lineNum"> 791 </span> : return -1;
<span class="lineNum"> 792 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 793 </span> : }
<span class="lineNum"> 735 </span><span class="lineCov"> 469 : return 0;</span>
<a name="736"><span class="lineNum"> 736 </span> : }</a>
<span class="lineNum"> 737 </span> :
<span class="lineNum"> 738 </span><span class="lineCov"> 1022 : int parity_close(struct snapraid_parity_handle* handle)</span>
<span class="lineNum"> 739 </span> : {
<span class="lineNum"> 740 </span> : unsigned s;
<span class="lineNum"> 741 </span><span class="lineCov"> 1022 : int f_ret = 0;</span>
<span class="lineNum"> 742 </span> :
<span class="lineNum"> 743 </span><span class="lineCov"> 5110 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 744 </span><span class="lineCov"> 4088 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 745 </span> : int ret;
<span class="lineNum"> 746 </span> :
<span class="lineNum"> 747 </span><span class="lineCov"> 4088 : ret = close(split-&gt;f);</span>
<span class="lineNum"> 748 </span><span class="lineCov"> 4088 : if (ret != 0) {</span>
<span class="lineNum"> 749 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 750 </span> : /* This is a serious error, as it may be the result of a failed write */
<span class="lineNum"> 751 </span> : /* identified at later time. */
<span class="lineNum"> 752 </span> : /* In a normal file-system (not NFS) it should never happen */
<span class="lineNum"> 753 </span> : log_fatal(&quot;Error closing parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 754 </span> : f_ret = -1;
<span class="lineNum"> 755 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 756 </span> :
<span class="lineNum"> 757 </span> : /* continue to close the others */
<span class="lineNum"> 758 </span> : }
<span class="lineNum"> 759 </span> :
<span class="lineNum"> 760 </span> : /* reset the descriptor */
<span class="lineNum"> 761 </span><span class="lineCov"> 4088 : split-&gt;f = -1;</span>
<span class="lineNum"> 762 </span> : }
<span class="lineNum"> 763 </span> :
<span class="lineNum"> 764 </span><span class="lineCov"> 1022 : return f_ret;</span>
<a name="765"><span class="lineNum"> 765 </span> : }</a>
<span class="lineNum"> 766 </span> :
<span class="lineNum"> 767 </span><span class="lineCov"> 4114025 : struct snapraid_split_handle* parity_split_find(struct snapraid_parity_handle* handle, data_off_t* offset)</span>
<span class="lineNum"> 768 </span> : {
<span class="lineNum"> 769 </span> : unsigned s;
<span class="lineNum"> 770 </span> :
<span class="lineNum"> 771 </span><span class="lineCov"> 4114025 : if (*offset &lt; 0)</span>
<span class="lineNum"> 772 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 773 </span> :
<span class="lineNum"> 774 </span><span class="lineCov"> 6502383 : for (s = 0;s &lt; handle-&gt;split_mac;++s) {</span>
<span class="lineNum"> 775 </span><span class="lineCov"> 6491023 : struct snapraid_split_handle* split = &amp;handle-&gt;split_map[s];</span>
<span class="lineNum"> 776 </span> :
<span class="lineNum"> 777 </span><span class="lineCov"> 6491023 : if (*offset &lt; split-&gt;size)</span>
<span class="lineNum"> 778 </span><span class="lineCov"> 4102665 : return split;</span>
<span class="lineNum"> 779 </span> :
<span class="lineNum"> 780 </span><span class="lineCov"> 2388358 : *offset -= split-&gt;size;</span>
<span class="lineNum"> 781 </span> : }
<span class="lineNum"> 782 </span> :
<span class="lineNum"> 783 </span><span class="lineCov"> 11360 : return 0;</span>
<a name="784"><span class="lineNum"> 784 </span> : }</a>
<span class="lineNum"> 785 </span> :
<span class="lineNum"> 786 </span><span class="lineCov"> 612195 : int parity_write(struct snapraid_parity_handle* handle, block_off_t pos, unsigned char* block_buffer, unsigned block_size)</span>
<span class="lineNum"> 787 </span> : {
<span class="lineNum"> 788 </span> : ssize_t write_ret;
<span class="lineNum"> 789 </span> : data_off_t offset;
<span class="lineNum"> 790 </span> : struct snapraid_split_handle* split;
<span class="lineNum"> 791 </span> : int ret;
<span class="lineNum"> 792 </span> :
<span class="lineNum"> 793 </span><span class="lineCov"> 612195 : offset = pos * (data_off_t)block_size;</span>
<span class="lineNum"> 794 </span> :
<span class="lineNum"> 795 </span><span class="lineCov"> 611746 : write_ret = pwrite(split-&gt;f, block_buffer, block_size, offset);</span>
<span class="lineNum"> 796 </span><span class="lineCov"> 611756 : if (write_ret != (ssize_t)block_size) { /* conversion is safe because block_size is always small */</span>
<span class="lineNum"> 795 </span><span class="lineCov"> 612195 : split = parity_split_find(handle, &amp;offset);</span>
<span class="lineNum"> 796 </span><span class="lineCov"> 612196 : if (!split) {</span>
<span class="lineNum"> 797 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 798 </span> : if (errno == ENOSPC) {
<span class="lineNum"> 799 </span> : log_fatal(&quot;Failed to grow parity file '%s' using write due lack of space.\n&quot;, split-&gt;path);
<span class="lineNum"> 800 </span> : } else {
<span class="lineNum"> 801 </span> : log_fatal(&quot;Error writing file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 802 </span> : }
<span class="lineNum"> 803 </span> : return -1;
<span class="lineNum"> 804 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 805 </span> : }
<span class="lineNum"> 806 </span> :
<span class="lineNum"> 807 </span><span class="lineCov"> 611756 : ret = advise_write(&amp;split-&gt;advise, split-&gt;f, offset, block_size);</span>
<span class="lineNum"> 808 </span><span class="lineCov"> 611756 : if (ret != 0) {</span>
<span class="lineNum"> 809 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 810 </span> : log_fatal(&quot;Error advising parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 798 </span> : log_fatal(&quot;Writing parity data outside range at extra offset %&quot; PRIu64 &quot;.\n&quot;, offset);
<span class="lineNum"> 799 </span> : return -1;
<span class="lineNum"> 800 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 801 </span> : }
<span class="lineNum"> 802 </span> :
<span class="lineNum"> 803 </span><span class="lineCov"> 612196 : write_ret = pwrite(split-&gt;f, block_buffer, block_size, offset);</span>
<span class="lineNum"> 804 </span><span class="lineCov"> 612199 : if (write_ret != (ssize_t)block_size) { /* conversion is safe because block_size is always small */</span>
<span class="lineNum"> 805 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 806 </span> : if (errno == ENOSPC) {
<span class="lineNum"> 807 </span> : log_fatal(&quot;Failed to grow parity file '%s' using write due lack of space.\n&quot;, split-&gt;path);
<span class="lineNum"> 808 </span> : } else {
<span class="lineNum"> 809 </span> : log_fatal(&quot;Error writing file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 810 </span> : }
<span class="lineNum"> 811 </span> : return -1;
<span class="lineNum"> 812 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 813 </span> : }
<span class="lineNum"> 814 </span> :
<span class="lineNum"> 815 </span><span class="lineCov"> 611756 : return 0;</span>
<a name="816"><span class="lineNum"> 816 </span> : }</a>
<span class="lineNum"> 817 </span> :
<span class="lineNum"> 818 </span><span class="lineCov"> 3501825 : int parity_read(struct snapraid_parity_handle* handle, block_off_t pos, unsigned char* block_buffer, unsigned block_size, fptr* out)</span>
<span class="lineNum"> 819 </span> : {
<span class="lineNum"> 820 </span> : ssize_t read_ret;
<span class="lineNum"> 821 </span> : data_off_t offset;
<span class="lineNum"> 822 </span> : unsigned count;
<span class="lineNum"> 823 </span> : struct snapraid_split_handle* split;
<span class="lineNum"> 824 </span> : int ret;
<span class="lineNum"> 815 </span><span class="lineCov"> 612199 : ret = advise_write(&amp;split-&gt;advise, split-&gt;f, offset, block_size);</span>
<span class="lineNum"> 816 </span><span class="lineCov"> 612194 : if (ret != 0) {</span>
<span class="lineNum"> 817 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 818 </span> : log_fatal(&quot;Error advising parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 819 </span> : return -1;
<span class="lineNum"> 820 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 821 </span> : }
<span class="lineNum"> 822 </span> :
<span class="lineNum"> 823 </span><span class="lineCov"> 612194 : return 0;</span>
<a name="824"><span class="lineNum"> 824 </span> : }</a>
<span class="lineNum"> 825 </span> :
<span class="lineNum"> 826 </span><span class="lineCov"> 3501825 : offset = pos * (data_off_t)block_size;</span>
<span class="lineNum"> 827 </span> :
<span class="lineNum"> 828 </span><span class="lineCov"> 3501825 : split = parity_split_find(handle, &amp;offset);</span>
<span class="lineNum"> 829 </span><span class="lineCov"> 3501816 : if (!split) {</span>
<span class="lineNum"> 830 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 831 </span> : out(&quot;Reading parity data outside range at extra offset %&quot; PRIu64 &quot;.\n&quot;, offset);
<span class="lineNum"> 832 </span> : return -1;
<span class="lineNum"> 833 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 834 </span> : }
<span class="lineNum"> 826 </span><span class="lineCov"> 3501825 : int parity_read(struct snapraid_parity_handle* handle, block_off_t pos, unsigned char* block_buffer, unsigned block_size, fptr* out)</span>
<span class="lineNum"> 827 </span> : {
<span class="lineNum"> 828 </span> : ssize_t read_ret;
<span class="lineNum"> 829 </span> : data_off_t offset;
<span class="lineNum"> 830 </span> : unsigned count;
<span class="lineNum"> 831 </span> : struct snapraid_split_handle* split;
<span class="lineNum"> 832 </span> : int ret;
<span class="lineNum"> 833 </span> :
<span class="lineNum"> 834 </span><span class="lineCov"> 3501825 : offset = pos * (data_off_t)block_size;</span>
<span class="lineNum"> 835 </span> :
<span class="lineNum"> 836 </span><span class="lineCov"> 3490456 : count = 0;</span>
<span class="lineNum"> 837 </span> : do {
<span class="lineNum"> 838 </span><span class="lineCov"> 3490442 : read_ret = pread(split-&gt;f, block_buffer + count, block_size - count, offset + count);</span>
<span class="lineNum"> 839 </span><span class="lineCov"> 3490403 : if (read_ret &lt; 0) {</span>
<span class="lineNum"> 840 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 841 </span> : out(&quot;Error reading file '%s' at offset %&quot; PRIu64 &quot; for size %u. %s.\n&quot;, split-&gt;path, offset + count, block_size - count, strerror(errno));
<span class="lineNum"> 842 </span> : return -1;
<span class="lineNum"> 843 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 844 </span> : }
<span class="lineNum"> 845 </span><span class="lineCov"> 3490403 : if (read_ret == 0) {</span>
<span class="lineNum"> 846 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 847 </span> : out(&quot;Unexpected end of file '%s' at offset %&quot; PRIu64 &quot;. %s.\n&quot;, split-&gt;path, offset, strerror(errno));
<span class="lineNum"> 848 </span> : return -1;
<span class="lineNum"> 849 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 850 </span> : }
<span class="lineNum"> 851 </span> :
<span class="lineNum"> 852 </span><span class="lineCov"> 3490403 : count += read_ret;</span>
<span class="lineNum"> 853 </span><span class="lineCov"> 3490403 : } while (count &lt; block_size);</span>
<span class="lineNum"> 854 </span> :
<span class="lineNum"> 855 </span><span class="lineCov"> 3490417 : ret = advise_read(&amp;split-&gt;advise, split-&gt;f, offset, block_size);</span>
<span class="lineNum"> 856 </span><span class="lineCov"> 3490399 : if (ret != 0) {</span>
<span class="lineNum"> 857 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 858 </span> : out(&quot;Error advising parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 859 </span> : return -1;
<span class="lineNum"> 860 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 861 </span> : }
<span class="lineNum"> 836 </span><span class="lineCov"> 3501825 : split = parity_split_find(handle, &amp;offset);</span>
<span class="lineNum"> 837 </span><span class="lineCov"> 3501814 : if (!split) {</span>
<span class="lineNum"> 838 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 839 </span> : out(&quot;Reading parity data outside range at extra offset %&quot; PRIu64 &quot;.\n&quot;, offset);
<span class="lineNum"> 840 </span> : return -1;
<span class="lineNum"> 841 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 842 </span> : }
<span class="lineNum"> 843 </span> :
<span class="lineNum"> 844 </span><span class="lineCov"> 3490454 : count = 0;</span>
<span class="lineNum"> 845 </span> : do {
<span class="lineNum"> 846 </span><span class="lineCov"> 3490458 : read_ret = pread(split-&gt;f, block_buffer + count, block_size - count, offset + count);</span>
<span class="lineNum"> 847 </span><span class="lineCov"> 3490424 : if (read_ret &lt; 0) {</span>
<span class="lineNum"> 848 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 849 </span> : out(&quot;Error reading file '%s' at offset %&quot; PRIu64 &quot; for size %u. %s.\n&quot;, split-&gt;path, offset + count, block_size - count, strerror(errno));
<span class="lineNum"> 850 </span> : return -1;
<span class="lineNum"> 851 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 852 </span> : }
<span class="lineNum"> 853 </span><span class="lineCov"> 3490424 : if (read_ret == 0) {</span>
<span class="lineNum"> 854 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 855 </span> : out(&quot;Unexpected end of file '%s' at offset %&quot; PRIu64 &quot;. %s.\n&quot;, split-&gt;path, offset, strerror(errno));
<span class="lineNum"> 856 </span> : return -1;
<span class="lineNum"> 857 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 858 </span> : }
<span class="lineNum"> 859 </span> :
<span class="lineNum"> 860 </span><span class="lineCov"> 3490424 : count += read_ret;</span>
<span class="lineNum"> 861 </span><span class="lineCov"> 3490424 : } while (count &lt; block_size);</span>
<span class="lineNum"> 862 </span> :
<span class="lineNum"> 863 </span><span class="lineCov"> 3490399 : return block_size;</span>
<span class="lineNum"> 864 </span> : }
<span class="lineNum"> 865 </span> :
<span class="lineNum"> 863 </span><span class="lineCov"> 3490420 : ret = advise_read(&amp;split-&gt;advise, split-&gt;f, offset, block_size);</span>
<span class="lineNum"> 864 </span><span class="lineCov"> 3490421 : if (ret != 0) {</span>
<span class="lineNum"> 865 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 866 </span> : out(&quot;Error advising parity file '%s'. %s.\n&quot;, split-&gt;path, strerror(errno));
<span class="lineNum"> 867 </span> : return -1;
<span class="lineNum"> 868 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 869 </span> : }
<span class="lineNum"> 870 </span> :
<span class="lineNum"> 871 </span><span class="lineCov"> 3490421 : return block_size;</span>
<span class="lineNum"> 872 </span> : }
<span class="lineNum"> 873 </span> :
</pre>
</td>
</tr>

32
cov/cmdline/scan.c.func-sort-c.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">563</td>
<td class="headerCovTableEntry">565</td>
<td class="headerCovTableEntry">631</td>
<td class="headerCovTableEntryMed">89.2 %</td>
<td class="headerCovTableEntryMed">89.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -61,23 +61,23 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1096">dd_name_compare</a></td>
<td class="coverFnHi">11526102</td>
<td class="coverFnHi">11526118</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1115">dstat</a></td>
<td class="coverFnHi">1106198</td>
<td class="coverFnHi">1106210</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#604">scan_file</a></td>
<td class="coverFnHi">1104927</td>
<td class="coverFnHi">1104939</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#585">scan_file_keep</a></td>
<td class="coverFnHi">1025576</td>
<td class="coverFnHi">1025539</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#361">file_is_full_invalid_parity_and_stable</a></td>
<td class="coverFnHi">1025576</td>
<td class="coverFnHi">1025539</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1082">dd_ino_compare</a></td>
@ -85,27 +85,27 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#332">scan_file_delayed_allocate</a></td>
<td class="coverFnHi">101836</td>
<td class="coverFnHi">101892</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#541">scan_file_insert</a></td>
<td class="coverFnHi">101836</td>
<td class="coverFnHi">101892</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#159">scan_file_allocate</a></td>
<td class="coverFnHi">101836</td>
<td class="coverFnHi">101892</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#464">scan_file_refresh</a></td>
<td class="coverFnHi">79156</td>
<td class="coverFnHi">79205</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#560">scan_file_remove</a></td>
<td class="coverFnHi">56970</td>
<td class="coverFnHi">57026</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#258">scan_file_deallocate</a></td>
<td class="coverFnHi">56970</td>
<td class="coverFnHi">57026</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#84">scan_link</a></td>
@ -121,7 +121,7 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1131">scan_dir</a></td>
<td class="coverFnHi">1840</td>
<td class="coverFnHi">1846</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#49">scan_link_remove</a></td>
@ -133,7 +133,7 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1426">state_diffscan</a></td>
<td class="coverFnHi">95</td>
<td class="coverFnHi">96</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1874">state_scan</a></td>
@ -145,7 +145,7 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1869">state_diff</a></td>
<td class="coverFnHi">7</td>
<td class="coverFnHi">8</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#995">scan_emptydir_remove</a></td>

32
cov/cmdline/scan.c.func.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">563</td>
<td class="headerCovTableEntry">565</td>
<td class="headerCovTableEntry">631</td>
<td class="headerCovTableEntryMed">89.2 %</td>
<td class="headerCovTableEntryMed">89.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -65,11 +65,11 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1096">dd_name_compare</a></td>
<td class="coverFnHi">11526102</td>
<td class="coverFnHi">11526118</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1115">dstat</a></td>
<td class="coverFnHi">1106198</td>
<td class="coverFnHi">1106210</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#407">file_is_full_hashed_and_stable</a></td>
@ -77,11 +77,11 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#361">file_is_full_invalid_parity_and_stable</a></td>
<td class="coverFnHi">1025576</td>
<td class="coverFnHi">1025539</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1131">scan_dir</a></td>
<td class="coverFnHi">1840</td>
<td class="coverFnHi">1846</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1030">scan_emptydir</a></td>
@ -97,35 +97,35 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#604">scan_file</a></td>
<td class="coverFnHi">1104927</td>
<td class="coverFnHi">1104939</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#159">scan_file_allocate</a></td>
<td class="coverFnHi">101836</td>
<td class="coverFnHi">101892</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#258">scan_file_deallocate</a></td>
<td class="coverFnHi">56970</td>
<td class="coverFnHi">57026</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#332">scan_file_delayed_allocate</a></td>
<td class="coverFnHi">101836</td>
<td class="coverFnHi">101892</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#541">scan_file_insert</a></td>
<td class="coverFnHi">101836</td>
<td class="coverFnHi">101892</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#585">scan_file_keep</a></td>
<td class="coverFnHi">1025576</td>
<td class="coverFnHi">1025539</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#464">scan_file_refresh</a></td>
<td class="coverFnHi">79156</td>
<td class="coverFnHi">79205</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#560">scan_file_remove</a></td>
<td class="coverFnHi">56970</td>
<td class="coverFnHi">57026</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#84">scan_link</a></td>
@ -141,11 +141,11 @@
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1869">state_diff</a></td>
<td class="coverFnHi">7</td>
<td class="coverFnHi">8</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1426">state_diffscan</a></td>
<td class="coverFnHi">95</td>
<td class="coverFnHi">96</td>
</tr>
<tr>
<td class="coverFn"><a href="scan.c.gcov.html#1874">state_scan</a></td>

716
cov/cmdline/scan.c.gcov.html
View file

File diff suppressed because it is too large Load diff

12
cov/cmdline/scrub.c.func-sort-c.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">281</td>
<td class="headerCovTableEntry">357</td>
<td class="headerCovTableEntryMed">78.7 %</td>
<td class="headerCovTableEntry">349</td>
<td class="headerCovTableEntryMed">80.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#217">scrub_parity_reader</a></td>
<td class="coverFnHi">168183</td>
<td class="coverFnHi">168187</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#103">scrub_data_reader</a></td>
<td class="coverFnHi">168180</td>
<td class="coverFnHi">168181</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#51">block_is_enabled</a></td>
@ -76,11 +76,11 @@
<td class="coverFnHi">11</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#715">state_scrub</a></td>
<td class="coverFn"><a href="scrub.c.gcov.html#723">state_scrub</a></td>
<td class="coverFnHi">11</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#704">md</a></td>
<td class="coverFn"><a href="scrub.c.gcov.html#712">md</a></td>
<td class="coverFnHi">2</td>
</tr>
</table>

12
cov/cmdline/scrub.c.func.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">281</td>
<td class="headerCovTableEntry">357</td>
<td class="headerCovTableEntryMed">78.7 %</td>
<td class="headerCovTableEntry">349</td>
<td class="headerCovTableEntryMed">80.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -64,19 +64,19 @@
<td class="coverFnHi">112170</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#704">md</a></td>
<td class="coverFn"><a href="scrub.c.gcov.html#712">md</a></td>
<td class="coverFnHi">2</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#103">scrub_data_reader</a></td>
<td class="coverFnHi">168180</td>
<td class="coverFnHi">168181</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#217">scrub_parity_reader</a></td>
<td class="coverFnHi">168183</td>
<td class="coverFnHi">168187</td>
</tr>
<tr>
<td class="coverFn"><a href="scrub.c.gcov.html#715">state_scrub</a></td>
<td class="coverFn"><a href="scrub.c.gcov.html#723">state_scrub</a></td>
<td class="coverFnHi">11</td>
</tr>
<tr>

1022
cov/cmdline/scrub.c.gcov.html
View file

File diff suppressed because it is too large Load diff

8
cov/cmdline/search.c.func-sort-c.html
View file

@ -61,19 +61,19 @@
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#24">search_file</a></td>
<td class="coverFnHi">1843728</td>
<td class="coverFnHi">1843909</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#40">search_file_free</a></td>
<td class="coverFnHi">1843728</td>
<td class="coverFnHi">1843909</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#124">state_search_fetch</a></td>
<td class="coverFnHi">639176</td>
<td class="coverFnHi">638916</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#56">search_file_compare</a></td>
<td class="coverFnHi">20130</td>
<td class="coverFnHi">20183</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#149">search_dir</a></td>

8
cov/cmdline/search.c.func.html
View file

@ -65,15 +65,15 @@
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#24">search_file</a></td>
<td class="coverFnHi">1843728</td>
<td class="coverFnHi">1843909</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#56">search_file_compare</a></td>
<td class="coverFnHi">20130</td>
<td class="coverFnHi">20183</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#40">search_file_free</a></td>
<td class="coverFnHi">1843728</td>
<td class="coverFnHi">1843909</td>
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#255">state_search</a></td>
@ -85,7 +85,7 @@
</tr>
<tr>
<td class="coverFn"><a href="search.c.gcov.html#124">state_search_fetch</a></td>
<td class="coverFnHi">639176</td>
<td class="coverFnHi">638916</td>
</tr>
</table>
<br>

122
cov/cmdline/search.c.gcov.html
View file

@ -85,27 +85,27 @@
<span class="lineNum"> 23 </span> : /****************************************************************************/
<a name="24"><span class="lineNum"> 24 </span> : /* search */</a>
<span class="lineNum"> 25 </span> :
<span class="lineNum"> 26 </span><span class="lineCov"> 1843728 : static void search_file(struct snapraid_state* state, const char* path, data_off_t size, int64_t mtime_sec, int mtime_nsec)</span>
<span class="lineNum"> 26 </span><span class="lineCov"> 1843909 : static void search_file(struct snapraid_state* state, const char* path, data_off_t size, int64_t mtime_sec, int mtime_nsec)</span>
<span class="lineNum"> 27 </span> : {
<span class="lineNum"> 28 </span> : struct snapraid_search_file* file;
<span class="lineNum"> 29 </span> : tommy_uint32_t file_hash;
<span class="lineNum"> 30 </span> :
<span class="lineNum"> 31 </span><span class="lineCov"> 1843728 : file = malloc_nofail(sizeof(struct snapraid_search_file));</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 1843728 : file-&gt;path = strdup_nofail(path);</span>
<span class="lineNum"> 33 </span><span class="lineCov"> 1843728 : file-&gt;size = size;</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 1843728 : file-&gt;mtime_sec = mtime_sec;</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 1843728 : file-&gt;mtime_nsec = mtime_nsec;</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 1843909 : file = malloc_nofail(sizeof(struct snapraid_search_file));</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 1843909 : file-&gt;path = strdup_nofail(path);</span>
<span class="lineNum"> 33 </span><span class="lineCov"> 1843909 : file-&gt;size = size;</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 1843909 : file-&gt;mtime_sec = mtime_sec;</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 1843909 : file-&gt;mtime_nsec = mtime_nsec;</span>
<span class="lineNum"> 36 </span> :
<span class="lineNum"> 37 </span><span class="lineCov"> 1843728 : file_hash = file_stamp_hash(file-&gt;size, file-&gt;mtime_sec, file-&gt;mtime_nsec);</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 1843909 : file_hash = file_stamp_hash(file-&gt;size, file-&gt;mtime_sec, file-&gt;mtime_nsec);</span>
<span class="lineNum"> 38 </span> :
<span class="lineNum"> 39 </span><span class="lineCov"> 1843728 : tommy_hashdyn_insert(&amp;state-&gt;searchset, &amp;file-&gt;node, file, file_hash);</span>
<a name="40"><span class="lineNum"> 40 </span><span class="lineCov"> 1843728 : }</span></a>
<span class="lineNum"> 39 </span><span class="lineCov"> 1843909 : tommy_hashdyn_insert(&amp;state-&gt;searchset, &amp;file-&gt;node, file, file_hash);</span>
<a name="40"><span class="lineNum"> 40 </span><span class="lineCov"> 1843909 : }</span></a>
<span class="lineNum"> 41 </span> :
<span class="lineNum"> 42 </span><span class="lineCov"> 1843728 : void search_file_free(struct snapraid_search_file* file)</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 1843909 : void search_file_free(struct snapraid_search_file* file)</span>
<span class="lineNum"> 43 </span> : {
<span class="lineNum"> 44 </span><span class="lineCov"> 1843728 : free(file-&gt;path);</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 1843728 : free(file);</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 1843728 : }</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 1843909 : free(file-&gt;path);</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 1843909 : free(file);</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 1843909 : }</span>
<span class="lineNum"> 47 </span> :
<span class="lineNum"> 48 </span> : struct search_file_compare_arg {
<span class="lineNum"> 49 </span> : const struct snapraid_state* state;
@ -117,29 +117,29 @@
<span class="lineNum"> 55 </span> : int prevhash;
<a name="56"><span class="lineNum"> 56 </span> : };</a>
<span class="lineNum"> 57 </span> :
<span class="lineNum"> 58 </span><span class="lineCov"> 20130 : int search_file_compare(const void* void_arg, const void* void_data)</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 20183 : int search_file_compare(const void* void_arg, const void* void_data)</span>
<span class="lineNum"> 59 </span> : {
<span class="lineNum"> 60 </span><span class="lineCov"> 20130 : const struct search_file_compare_arg* arg = void_arg;</span>
<span class="lineNum"> 61 </span><span class="lineCov"> 20130 : const struct snapraid_search_file* file = void_data;</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 20130 : const struct snapraid_state* state = arg-&gt;state;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 20183 : const struct search_file_compare_arg* arg = void_arg;</span>
<span class="lineNum"> 61 </span><span class="lineCov"> 20183 : const struct snapraid_search_file* file = void_data;</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 20183 : const struct snapraid_state* state = arg-&gt;state;</span>
<span class="lineNum"> 63 </span> : unsigned char buffer_hash[HASH_MAX];
<span class="lineNum"> 64 </span><span class="lineCov"> 20130 : const char* path = file-&gt;path;</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 20183 : const char* path = file-&gt;path;</span>
<span class="lineNum"> 65 </span> : int f;
<span class="lineNum"> 66 </span> : ssize_t ret;
<span class="lineNum"> 67 </span> :
<span class="lineNum"> 68 </span> : /* compare file info */
<span class="lineNum"> 69 </span><span class="lineCov"> 20130 : if (arg-&gt;file-&gt;size != file-&gt;size)</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 20183 : if (arg-&gt;file-&gt;size != file-&gt;size)</span>
<span class="lineNum"> 70 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 71 </span> :
<span class="lineNum"> 72 </span><span class="lineCov"> 20130 : if (arg-&gt;file-&gt;mtime_sec != file-&gt;mtime_sec)</span>
<span class="lineNum"> 72 </span><span class="lineCov"> 20183 : if (arg-&gt;file-&gt;mtime_sec != file-&gt;mtime_sec)</span>
<span class="lineNum"> 73 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 74 </span> :
<span class="lineNum"> 75 </span><span class="lineCov"> 20130 : if (arg-&gt;file-&gt;mtime_nsec != file-&gt;mtime_nsec)</span>
<span class="lineNum"> 75 </span><span class="lineCov"> 20183 : if (arg-&gt;file-&gt;mtime_nsec != file-&gt;mtime_nsec)</span>
<span class="lineNum"> 76 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 77 </span> :
<span class="lineNum"> 78 </span> : /* read the block and compare the hash */
<span class="lineNum"> 79 </span><span class="lineCov"> 20130 : f = open(path, O_RDONLY | O_BINARY);</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 20130 : if (f == -1) {</span>
<span class="lineNum"> 79 </span><span class="lineCov"> 20183 : f = open(path, O_RDONLY | O_BINARY);</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 20183 : if (f == -1) {</span>
<span class="lineNum"> 81 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 82 </span> : if (errno == ENOENT) {
<span class="lineNum"> 83 </span> : log_fatal(&quot;DANGER! file '%s' disappeared.\n&quot;, path);
@ -151,16 +151,16 @@
<span class="lineNum"> 89 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 90 </span> : }
<span class="lineNum"> 91 </span> :
<span class="lineNum"> 92 </span><span class="lineCov"> 20130 : ret = pread(f, arg-&gt;buffer, arg-&gt;read_size, arg-&gt;offset);</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 20130 : if (ret &lt; 0 || (unsigned)ret != arg-&gt;read_size) {</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 20183 : ret = pread(f, arg-&gt;buffer, arg-&gt;read_size, arg-&gt;offset);</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 20183 : if (ret &lt; 0 || (unsigned)ret != arg-&gt;read_size) {</span>
<span class="lineNum"> 94 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 95 </span> : log_fatal(&quot;Error reading file '%s'. %s.\n&quot;, path, strerror(errno));
<span class="lineNum"> 96 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 97 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 98 </span> : }
<span class="lineNum"> 99 </span> :
<span class="lineNum"> 100 </span><span class="lineCov"> 20130 : ret = close(f);</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 20130 : if (ret != 0) {</span>
<span class="lineNum"> 100 </span><span class="lineCov"> 20183 : ret = close(f);</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 20183 : if (ret != 0) {</span>
<span class="lineNum"> 102 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 103 </span> : log_fatal(&quot;Error closing file '%s'. %s.\n&quot;, path, strerror(errno));
<span class="lineNum"> 104 </span> : exit(EXIT_FAILURE);
@ -168,14 +168,14 @@
<span class="lineNum"> 106 </span> : }
<span class="lineNum"> 107 </span> :
<span class="lineNum"> 108 </span> : /* compute the hash */
<span class="lineNum"> 109 </span><span class="lineCov"> 20130 : if (arg-&gt;prevhash)</span>
<span class="lineNum"> 109 </span><span class="lineCov"> 20183 : if (arg-&gt;prevhash)</span>
<span class="lineNum"> 110 </span><span class="lineNoCov"> 0 : memhash(state-&gt;prevhash, state-&gt;prevhashseed, buffer_hash, arg-&gt;buffer, arg-&gt;read_size);</span>
<span class="lineNum"> 111 </span> : else
<span class="lineNum"> 112 </span><span class="lineCov"> 20130 : memhash(state-&gt;hash, state-&gt;hashseed, buffer_hash, arg-&gt;buffer, arg-&gt;read_size);</span>
<span class="lineNum"> 112 </span><span class="lineCov"> 20183 : memhash(state-&gt;hash, state-&gt;hashseed, buffer_hash, arg-&gt;buffer, arg-&gt;read_size);</span>
<span class="lineNum"> 113 </span> :
<span class="lineNum"> 114 </span> : /* check if the hash is matching */
<span class="lineNum"> 115 </span><span class="lineCov"> 20130 : if (memcmp(buffer_hash, arg-&gt;block-&gt;hash, BLOCK_HASH_SIZE) != 0)</span>
<span class="lineNum"> 116 </span><span class="lineCov"> 2220 : return -1;</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 20183 : if (memcmp(buffer_hash, arg-&gt;block-&gt;hash, BLOCK_HASH_SIZE) != 0)</span>
<span class="lineNum"> 116 </span><span class="lineCov"> 2273 : return -1;</span>
<span class="lineNum"> 117 </span> :
<span class="lineNum"> 118 </span><span class="lineCov"> 17910 : if (arg-&gt;read_size != state-&gt;block_size) {</span>
<span class="lineNum"> 119 </span> : /* fill the remaining with 0 */
@ -185,26 +185,26 @@
<span class="lineNum"> 123 </span><span class="lineCov"> 17910 : return 0;</span>
<a name="124"><span class="lineNum"> 124 </span> : }</a>
<span class="lineNum"> 125 </span> :
<span class="lineNum"> 126 </span><span class="lineCov"> 639176 : int state_search_fetch(struct snapraid_state* state, int prevhash, struct snapraid_file* missing_file, block_off_t missing_file_pos, struct snapraid_block* missing_block, unsigned char* buffer)</span>
<span class="lineNum"> 126 </span><span class="lineCov"> 638916 : int state_search_fetch(struct snapraid_state* state, int prevhash, struct snapraid_file* missing_file, block_off_t missing_file_pos, struct snapraid_block* missing_block, unsigned char* buffer)</span>
<span class="lineNum"> 127 </span> : {
<span class="lineNum"> 128 </span> : struct snapraid_search_file* file;
<span class="lineNum"> 129 </span> : tommy_uint32_t file_hash;
<span class="lineNum"> 130 </span> : struct search_file_compare_arg arg;
<span class="lineNum"> 131 </span> :
<span class="lineNum"> 132 </span><span class="lineCov"> 639176 : arg.state = state;</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 639176 : arg.block = missing_block;</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 639176 : arg.file = missing_file;</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 639176 : arg.buffer = buffer;</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 639176 : arg.offset = state-&gt;block_size * (data_off_t)missing_file_pos;</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 639176 : arg.read_size = file_block_size(missing_file, missing_file_pos, state-&gt;block_size);</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 639176 : arg.prevhash = prevhash;</span>
<span class="lineNum"> 132 </span><span class="lineCov"> 638916 : arg.state = state;</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 638916 : arg.block = missing_block;</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 638916 : arg.file = missing_file;</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 638916 : arg.buffer = buffer;</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 638916 : arg.offset = state-&gt;block_size * (data_off_t)missing_file_pos;</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 638916 : arg.read_size = file_block_size(missing_file, missing_file_pos, state-&gt;block_size);</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 638916 : arg.prevhash = prevhash;</span>
<span class="lineNum"> 139 </span> :
<span class="lineNum"> 140 </span><span class="lineCov"> 639176 : file_hash = file_stamp_hash(arg.file-&gt;size, arg.file-&gt;mtime_sec, arg.file-&gt;mtime_nsec);</span>
<span class="lineNum"> 140 </span><span class="lineCov"> 638916 : file_hash = file_stamp_hash(arg.file-&gt;size, arg.file-&gt;mtime_sec, arg.file-&gt;mtime_nsec);</span>
<span class="lineNum"> 141 </span> :
<span class="lineNum"> 142 </span> : /* search in the hashtable, and also check if the data matches the hash */
<span class="lineNum"> 143 </span><span class="lineCov"> 639176 : file = tommy_hashdyn_search(&amp;state-&gt;searchset, search_file_compare, &amp;arg, file_hash);</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 639176 : if (!file)</span>
<span class="lineNum"> 145 </span><span class="lineCov"> 621266 : return -1;</span>
<span class="lineNum"> 143 </span><span class="lineCov"> 638916 : file = tommy_hashdyn_search(&amp;state-&gt;searchset, search_file_compare, &amp;arg, file_hash);</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 638916 : if (!file)</span>
<span class="lineNum"> 145 </span><span class="lineCov"> 621006 : return -1;</span>
<span class="lineNum"> 146 </span> :
<span class="lineNum"> 147 </span> : /* if found, buffer is already set with data */
<span class="lineNum"> 148 </span><span class="lineCov"> 17910 : return 0;</span>
@ -226,40 +226,40 @@
<span class="lineNum"> 164 </span> : char path_next[PATH_MAX];
<span class="lineNum"> 165 </span> : char sub_next[PATH_MAX];
<span class="lineNum"> 166 </span> : char out[PATH_MAX];
<span class="lineNum"> 167 </span><span class="lineCov"> 2040132 : struct snapraid_filter* reason = 0;</span>
<span class="lineNum"> 167 </span><span class="lineCov"> 2040347 : struct snapraid_filter* reason = 0;</span>
<span class="lineNum"> 168 </span> : struct stat st;
<span class="lineNum"> 169 </span> : const char* name;
<span class="lineNum"> 170 </span> : struct dirent* dd;
<span class="lineNum"> 171 </span> :
<span class="lineNum"> 172 </span> : /* clear errno to detect erroneous conditions */
<span class="lineNum"> 173 </span><span class="lineCov"> 2040132 : errno = 0;</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 2040132 : dd = readdir(d);</span>
<span class="lineNum"> 175 </span><span class="lineCov"> 2040132 : if (dd == 0 &amp;&amp; errno != 0) {</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 2040347 : errno = 0;</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 2040347 : dd = readdir(d);</span>
<span class="lineNum"> 175 </span><span class="lineCov"> 2040347 : if (dd == 0 &amp;&amp; errno != 0) {</span>
<span class="lineNum"> 176 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 177 </span> : log_fatal(&quot;Error reading directory '%s'. %s.\n&quot;, dir, strerror(errno));
<span class="lineNum"> 178 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 179 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 180 </span> : }
<span class="lineNum"> 181 </span><span class="lineCov"> 2040132 : if (dd == 0) {</span>
<span class="lineNum"> 181 </span><span class="lineCov"> 2040347 : if (dd == 0) {</span>
<span class="lineNum"> 182 </span><span class="lineCov"> 2462 : break; /* finished */</span>
<span class="lineNum"> 183 </span> : }
<span class="lineNum"> 184 </span> :
<span class="lineNum"> 185 </span> : /* skip &quot;.&quot; and &quot;..&quot; files */
<span class="lineNum"> 186 </span><span class="lineCov"> 2037670 : name = dd-&gt;d_name;</span>
<span class="lineNum"> 187 </span><span class="lineCov"> 2037670 : if (name[0] == '.' &amp;&amp; (name[1] == 0 || (name[1] == '.' &amp;&amp; name[2] == 0)))</span>
<span class="lineNum"> 186 </span><span class="lineCov"> 2037885 : name = dd-&gt;d_name;</span>
<span class="lineNum"> 187 </span><span class="lineCov"> 2037885 : if (name[0] == '.' &amp;&amp; (name[1] == 0 || (name[1] == '.' &amp;&amp; name[2] == 0)))</span>
<span class="lineNum"> 188 </span><span class="lineCov"> 9848 : continue;</span>
<span class="lineNum"> 189 </span> :
<span class="lineNum"> 190 </span><span class="lineCov"> 2032746 : pathprint(path_next, sizeof(path_next), &quot;%s%s&quot;, dir, name);</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 2032746 : pathprint(sub_next, sizeof(sub_next), &quot;%s%s&quot;, sub, name);</span>
<span class="lineNum"> 190 </span><span class="lineCov"> 2032961 : pathprint(path_next, sizeof(path_next), &quot;%s%s&quot;, dir, name);</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 2032961 : pathprint(sub_next, sizeof(sub_next), &quot;%s%s&quot;, sub, name);</span>
<span class="lineNum"> 192 </span> :
<span class="lineNum"> 193 </span> : /* exclude hidden files even before calling lstat() */
<span class="lineNum"> 194 </span><span class="lineCov"> 2032746 : if (disk != 0 &amp;&amp; filter_hidden(state-&gt;filter_hidden, dd) != 0) {</span>
<span class="lineNum"> 194 </span><span class="lineCov"> 2032961 : if (disk != 0 &amp;&amp; filter_hidden(state-&gt;filter_hidden, dd) != 0) {</span>
<span class="lineNum"> 195 </span><span class="lineNoCov"> 0 : msg_verbose(&quot;Excluding hidden '%s'\n&quot;, path_next);</span>
<span class="lineNum"> 196 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 197 </span> : }
<span class="lineNum"> 198 </span> :
<span class="lineNum"> 199 </span> : /* exclude content files even before calling lstat() */
<span class="lineNum"> 200 </span><span class="lineCov"> 2032746 : if (disk != 0 &amp;&amp; filter_content(&amp;state-&gt;contentlist, path_next) != 0) {</span>
<span class="lineNum"> 200 </span><span class="lineCov"> 2032961 : if (disk != 0 &amp;&amp; filter_content(&amp;state-&gt;contentlist, path_next) != 0) {</span>
<span class="lineNum"> 201 </span><span class="lineNoCov"> 0 : msg_verbose(&quot;Excluding content '%s'\n&quot;, path_next);</span>
<span class="lineNum"> 202 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 203 </span> : }
@ -283,7 +283,7 @@
<span class="lineNum"> 221 </span> : }
<span class="lineNum"> 222 </span> : #else
<span class="lineNum"> 223 </span> : /* get lstat info about the file */
<span class="lineNum"> 224 </span><span class="lineCov"> 2032746 : if (lstat(path_next, &amp;st) != 0) {</span>
<span class="lineNum"> 224 </span><span class="lineCov"> 2032961 : if (lstat(path_next, &amp;st) != 0) {</span>
<span class="lineNum"> 225 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 226 </span> : log_fatal(&quot;Error in stat file/directory '%s'. %s.\n&quot;, path_next, strerror(errno));
<span class="lineNum"> 227 </span> : exit(EXIT_FAILURE);
@ -291,13 +291,13 @@
<span class="lineNum"> 229 </span> : }
<span class="lineNum"> 230 </span> : #endif
<span class="lineNum"> 231 </span> :
<span class="lineNum"> 232 </span><span class="lineCov"> 2032746 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 233 </span><span class="lineCov"> 1968447 : if (disk == 0 || filter_path(&amp;state-&gt;filterlist, &amp;reason, disk-&gt;name, sub_next) == 0) {</span>
<span class="lineNum"> 234 </span><span class="lineCov"> 1843728 : search_file(state, path_next, st.st_size, st.st_mtime, STAT_NSEC(&amp;st));</span>
<span class="lineNum"> 232 </span><span class="lineCov"> 2032961 : if (S_ISREG(st.st_mode)) {</span>
<span class="lineNum"> 233 </span><span class="lineCov"> 1968636 : if (disk == 0 || filter_path(&amp;state-&gt;filterlist, &amp;reason, disk-&gt;name, sub_next) == 0) {</span>
<span class="lineNum"> 234 </span><span class="lineCov"> 1843909 : search_file(state, path_next, st.st_size, st.st_mtime, STAT_NSEC(&amp;st));</span>
<span class="lineNum"> 235 </span> : } else {
<span class="lineNum"> 236 </span><span class="lineCov"> 124719 : msg_verbose(&quot;Excluding link '%s' for rule '%s'\n&quot;, path_next, filter_type(reason, out, sizeof(out)));</span>
<span class="lineNum"> 236 </span><span class="lineCov"> 124727 : msg_verbose(&quot;Excluding link '%s' for rule '%s'\n&quot;, path_next, filter_type(reason, out, sizeof(out)));</span>
<span class="lineNum"> 237 </span> : }
<span class="lineNum"> 238 </span><span class="lineCov"> 64299 : } else if (S_ISDIR(st.st_mode)) {</span>
<span class="lineNum"> 238 </span><span class="lineCov"> 64325 : } else if (S_ISDIR(st.st_mode)) {</span>
<span class="lineNum"> 239 </span><span class="lineCov"> 1781 : if (disk == 0 || filter_subdir(&amp;state-&gt;filterlist, &amp;reason, disk-&gt;name, sub_next) == 0) {</span>
<span class="lineNum"> 240 </span><span class="lineCov"> 1781 : pathslash(path_next, sizeof(path_next));</span>
<span class="lineNum"> 241 </span><span class="lineCov"> 1781 : pathslash(sub_next, sizeof(sub_next));</span>
@ -306,7 +306,7 @@
<span class="lineNum"> 244 </span><span class="lineNoCov"> 0 : msg_verbose(&quot;Excluding directory '%s' for rule '%s'\n&quot;, path_next, filter_type(reason, out, sizeof(out)));</span>
<span class="lineNum"> 245 </span> : }
<span class="lineNum"> 246 </span> : }
<span class="lineNum"> 247 </span><span class="lineCov"> 2037670 : }</span>
<span class="lineNum"> 247 </span><span class="lineCov"> 2037885 : }</span>
<span class="lineNum"> 248 </span> :
<span class="lineNum"> 249 </span><span class="lineCov"> 2462 : if (closedir(d) != 0) {</span>
<span class="lineNum"> 250 </span> : /* LCOV_EXCL_START */

12
cov/cmdline/snapraid.c.func-sort-c.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">494</td>
<td class="headerCovTableEntry">496</td>
<td class="headerCovTableEntry">542</td>
<td class="headerCovTableEntryHi">91.1 %</td>
<td class="headerCovTableEntryHi">91.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -61,19 +61,19 @@
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#91">test</a></td>
<td class="coverFnHi">275</td>
<td class="coverFnHi">276</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#519">main</a></td>
<td class="coverFnHi">275</td>
<td class="coverFnHi">276</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#225">config</a></td>
<td class="coverFnHi">274</td>
<td class="coverFnHi">275</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#124">log_open</a></td>
<td class="coverFnHi">264</td>
<td class="coverFnHi">265</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#208">log_close</a></td>

12
cov/cmdline/snapraid.c.func.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">494</td>
<td class="headerCovTableEntry">496</td>
<td class="headerCovTableEntry">542</td>
<td class="headerCovTableEntryHi">91.1 %</td>
<td class="headerCovTableEntryHi">91.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#225">config</a></td>
<td class="coverFnHi">274</td>
<td class="coverFnHi">275</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#208">log_close</a></td>
@ -69,11 +69,11 @@
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#124">log_open</a></td>
<td class="coverFnHi">264</td>
<td class="coverFnHi">265</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#519">main</a></td>
<td class="coverFnHi">275</td>
<td class="coverFnHi">276</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#77">memory</a></td>
@ -85,7 +85,7 @@
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#91">test</a></td>
<td class="coverFnHi">275</td>
<td class="coverFnHi">276</td>
</tr>
<tr>
<td class="coverFn"><a href="snapraid.c.gcov.html#35">usage</a></td>

256
cov/cmdline/snapraid.c.gcov.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">494</td>
<td class="headerCovTableEntry">496</td>
<td class="headerCovTableEntry">542</td>
<td class="headerCovTableEntryHi">91.1 %</td>
<td class="headerCovTableEntryHi">91.5 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -152,14 +152,14 @@
<span class="lineNum"> 90 </span><span class="lineCov"> 237 : msg_progress(&quot;Using %u MiB of memory for the FileSystem.\n&quot;, (unsigned)(malloc_counter_get() / MEBI));</span>
<a name="91"><span class="lineNum"> 91 </span><span class="lineCov"> 237 : }</span></a>
<span class="lineNum"> 92 </span> :
<span class="lineNum"> 93 </span><span class="lineCov"> 275 : void test(int argc, char* argv[])</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 276 : void test(int argc, char* argv[])</span>
<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 */
<span class="lineNum"> 99 </span><span class="lineCov"> 275 : if (argc &lt; 2 || strcmp(argv[1], &quot;test&quot;) != 0)</span>
<span class="lineNum"> 100 </span><span class="lineCov"> 548 : return;</span>
<span class="lineNum"> 99 </span><span class="lineCov"> 276 : if (argc &lt; 2 || strcmp(argv[1], &quot;test&quot;) != 0)</span>
<span class="lineNum"> 100 </span><span class="lineCov"> 550 : return;</span>
<span class="lineNum"> 101 </span> :
<span class="lineNum"> 102 </span><span class="lineCov"> 1 : for (i = 2; i &lt; argc; ++i) {</span>
<span class="lineNum"> 103 </span><span class="lineNoCov"> 0 : printf(&quot;argv[%d]\n&quot;, i);</span>
@ -185,7 +185,7 @@
<span class="lineNum"> 123 </span> : /****************************************************************************/
<a name="124"><span class="lineNum"> 124 </span> : /* log */</a>
<span class="lineNum"> 125 </span> :
<span class="lineNum"> 126 </span><span class="lineCov"> 264 : void log_open(const char* file)</span>
<span class="lineNum"> 126 </span><span class="lineCov"> 265 : void log_open(const char* file)</span>
<span class="lineNum"> 127 </span> : {
<span class="lineNum"> 128 </span> : char path[PATH_MAX];
<span class="lineNum"> 129 </span> : const char* mode;
@ -195,8 +195,8 @@
<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 */
<span class="lineNum"> 136 </span><span class="lineCov"> 264 : if (file == 0)</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 374 : return;</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 265 : if (file == 0)</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 376 : return;</span>
<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(&amp;t);</span>
@ -286,7 +286,7 @@
<span class="lineNum"> 224 </span> : /****************************************************************************/
<a name="225"><span class="lineNum"> 225 </span> : /* config */</a>
<span class="lineNum"> 226 </span> :
<span class="lineNum"> 227 </span><span class="lineCov"> 274 : void config(char* conf, size_t conf_size, const char* argv0)</span>
<span class="lineNum"> 227 </span><span class="lineCov"> 275 : void config(char* conf, size_t conf_size, const char* argv0)</span>
<span class="lineNum"> 228 </span> : {
<span class="lineNum"> 229 </span> : #ifdef _WIN32
<span class="lineNum"> 230 </span> : char* slash;
@ -303,9 +303,9 @@
<span class="lineNum"> 241 </span> : #else
<span class="lineNum"> 242 </span> : (void)argv0;
<span class="lineNum"> 243 </span> :
<span class="lineNum"> 244 </span><span class="lineCov"> 274 : pathcpy(conf, conf_size, &quot;/etc/&quot; PACKAGE &quot;.conf&quot;);</span>
<span class="lineNum"> 244 </span><span class="lineCov"> 275 : pathcpy(conf, conf_size, &quot;/etc/&quot; PACKAGE &quot;.conf&quot;);</span>
<span class="lineNum"> 245 </span> : #endif
<span class="lineNum"> 246 </span><span class="lineCov"> 274 : }</span>
<span class="lineNum"> 246 </span><span class="lineCov"> 275 : }</span>
<span class="lineNum"> 247 </span> :
<span class="lineNum"> 248 </span> : /****************************************************************************/
<span class="lineNum"> 249 </span> : /* main */
@ -580,7 +580,7 @@
<span class="lineNum"> 518 </span> : #define OPERATION_DEVICES 16
<a name="519"><span class="lineNum"> 519 </span> : #define OPERATION_SMART 17</a>
<span class="lineNum"> 520 </span> :
<span class="lineNum"> 521 </span><span class="lineCov"> 275 : int main(int argc, char* argv[])</span>
<span class="lineNum"> 521 </span><span class="lineCov"> 276 : int main(int argc, char* argv[])</span>
<span class="lineNum"> 522 </span> : {
<span class="lineNum"> 523 </span> : int c;
<span class="lineNum"> 524 </span> : struct snapraid_option opt;
@ -610,43 +610,43 @@
<span class="lineNum"> 548 </span> : struct tm* tm;
<span class="lineNum"> 549 </span> : int i;
<span class="lineNum"> 550 </span> :
<span class="lineNum"> 551 </span><span class="lineCov"> 275 : test(argc, argv);</span>
<span class="lineNum"> 551 </span><span class="lineCov"> 276 : test(argc, argv);</span>
<span class="lineNum"> 552 </span> :
<span class="lineNum"> 553 </span><span class="lineCov"> 274 : lock_init();</span>
<span class="lineNum"> 553 </span><span class="lineCov"> 275 : lock_init();</span>
<span class="lineNum"> 554 </span> :
<span class="lineNum"> 555 </span> : /* defaults */
<span class="lineNum"> 556 </span><span class="lineCov"> 274 : config(conf, sizeof(conf), argv[0]);</span>
<span class="lineNum"> 557 </span><span class="lineCov"> 274 : memset(&amp;opt, 0, sizeof(opt));</span>
<span class="lineNum"> 558 </span><span class="lineCov"> 274 : opt.io_error_limit = 100;</span>
<span class="lineNum"> 559 </span><span class="lineCov"> 274 : blockstart = 0;</span>
<span class="lineNum"> 560 </span><span class="lineCov"> 274 : blockcount = 0;</span>
<span class="lineNum"> 561 </span><span class="lineCov"> 274 : tommy_list_init(&amp;filterlist_file);</span>
<span class="lineNum"> 562 </span><span class="lineCov"> 274 : tommy_list_init(&amp;filterlist_disk);</span>
<span class="lineNum"> 563 </span><span class="lineCov"> 274 : period = 1000;</span>
<span class="lineNum"> 564 </span><span class="lineCov"> 274 : filter_missing = 0;</span>
<span class="lineNum"> 565 </span><span class="lineCov"> 274 : filter_error = 0;</span>
<span class="lineNum"> 566 </span><span class="lineCov"> 274 : plan = SCRUB_AUTO;</span>
<span class="lineNum"> 567 </span><span class="lineCov"> 274 : olderthan = SCRUB_AUTO;</span>
<span class="lineNum"> 568 </span><span class="lineCov"> 274 : import_timestamp = 0;</span>
<span class="lineNum"> 569 </span><span class="lineCov"> 274 : import_content = 0;</span>
<span class="lineNum"> 570 </span><span class="lineCov"> 274 : log_file = 0;</span>
<span class="lineNum"> 571 </span><span class="lineCov"> 274 : lock = 0;</span>
<span class="lineNum"> 572 </span><span class="lineCov"> 274 : gen_conf = 0;</span>
<span class="lineNum"> 573 </span><span class="lineCov"> 274 : speedtest = 0;</span>
<span class="lineNum"> 574 </span><span class="lineCov"> 274 : run = 0;</span>
<span class="lineNum"> 556 </span><span class="lineCov"> 275 : config(conf, sizeof(conf), argv[0]);</span>
<span class="lineNum"> 557 </span><span class="lineCov"> 275 : memset(&amp;opt, 0, sizeof(opt));</span>
<span class="lineNum"> 558 </span><span class="lineCov"> 275 : opt.io_error_limit = 100;</span>
<span class="lineNum"> 559 </span><span class="lineCov"> 275 : blockstart = 0;</span>
<span class="lineNum"> 560 </span><span class="lineCov"> 275 : blockcount = 0;</span>
<span class="lineNum"> 561 </span><span class="lineCov"> 275 : tommy_list_init(&amp;filterlist_file);</span>
<span class="lineNum"> 562 </span><span class="lineCov"> 275 : tommy_list_init(&amp;filterlist_disk);</span>
<span class="lineNum"> 563 </span><span class="lineCov"> 275 : period = 1000;</span>
<span class="lineNum"> 564 </span><span class="lineCov"> 275 : filter_missing = 0;</span>
<span class="lineNum"> 565 </span><span class="lineCov"> 275 : filter_error = 0;</span>
<span class="lineNum"> 566 </span><span class="lineCov"> 275 : plan = SCRUB_AUTO;</span>
<span class="lineNum"> 567 </span><span class="lineCov"> 275 : olderthan = SCRUB_AUTO;</span>
<span class="lineNum"> 568 </span><span class="lineCov"> 275 : import_timestamp = 0;</span>
<span class="lineNum"> 569 </span><span class="lineCov"> 275 : import_content = 0;</span>
<span class="lineNum"> 570 </span><span class="lineCov"> 275 : log_file = 0;</span>
<span class="lineNum"> 571 </span><span class="lineCov"> 275 : lock = 0;</span>
<span class="lineNum"> 572 </span><span class="lineCov"> 275 : gen_conf = 0;</span>
<span class="lineNum"> 573 </span><span class="lineCov"> 275 : speedtest = 0;</span>
<span class="lineNum"> 574 </span><span class="lineCov"> 275 : run = 0;</span>
<span class="lineNum"> 575 </span> :
<span class="lineNum"> 576 </span><span class="lineCov"> 274 : opterr = 0;</span>
<span class="lineNum"> 577 </span><span class="lineCov"> 3450 : while ((c =</span>
<span class="lineNum"> 576 </span><span class="lineCov"> 275 : opterr = 0;</span>
<span class="lineNum"> 577 </span><span class="lineCov"> 3463 : while ((c =</span>
<span class="lineNum"> 578 </span> : #if HAVE_GETOPT_LONG
<span class="lineNum"> 579 </span> : getopt_long(argc, argv, OPTIONS, long_options, 0))
<span class="lineNum"> 580 </span> : #else
<span class="lineNum"> 581 </span> : getopt(argc, argv, OPTIONS))
<span class="lineNum"> 582 </span> : #endif
<span class="lineNum"> 583 </span> : != EOF) {
<span class="lineNum"> 584 </span><span class="lineCov"> 2907 : switch (c) {</span>
<span class="lineNum"> 584 </span><span class="lineCov"> 2918 : switch (c) {</span>
<span class="lineNum"> 585 </span> : case 'c' :
<span class="lineNum"> 586 </span><span class="lineCov"> 267 : pathimport(conf, sizeof(conf), optarg);</span>
<span class="lineNum"> 587 </span><span class="lineCov"> 267 : break;</span>
<span class="lineNum"> 586 </span><span class="lineCov"> 268 : pathimport(conf, sizeof(conf), optarg);</span>
<span class="lineNum"> 587 </span><span class="lineCov"> 268 : break;</span>
<span class="lineNum"> 588 </span> : case 'f' : {
<span class="lineNum"> 589 </span><span class="lineCov"> 6 : struct snapraid_filter* filter = filter_alloc_file(1, optarg);</span>
<span class="lineNum"> 590 </span><span class="lineCov"> 6 : if (!filter) {</span>
@ -787,14 +787,14 @@
<span class="lineNum"> 725 </span><span class="lineCov"> 7 : opt.prehash = 1;</span>
<span class="lineNum"> 726 </span><span class="lineCov"> 7 : break;</span>
<span class="lineNum"> 727 </span> : case 'v' :
<span class="lineNum"> 728 </span><span class="lineCov"> 25 : ++msg_level;</span>
<span class="lineNum"> 729 </span><span class="lineCov"> 25 : break;</span>
<span class="lineNum"> 728 </span><span class="lineCov"> 26 : ++msg_level;</span>
<span class="lineNum"> 729 </span><span class="lineCov"> 26 : break;</span>
<span class="lineNum"> 730 </span> : case 'q' :
<span class="lineNum"> 731 </span><span class="lineCov"> 726 : --msg_level;</span>
<span class="lineNum"> 732 </span><span class="lineCov"> 726 : break;</span>
<span class="lineNum"> 733 </span> : case 'G' :
<span class="lineNum"> 734 </span><span class="lineCov"> 25 : opt.gui = 1;</span>
<span class="lineNum"> 735 </span><span class="lineCov"> 25 : break;</span>
<span class="lineNum"> 734 </span><span class="lineCov"> 26 : opt.gui = 1;</span>
<span class="lineNum"> 735 </span><span class="lineCov"> 26 : break;</span>
<span class="lineNum"> 736 </span> : case 'H' :
<span class="lineNum"> 737 </span><span class="lineCov"> 1 : usage();</span>
<span class="lineNum"> 738 </span><span class="lineCov"> 1 : exit(EXIT_SUCCESS);</span>
@ -817,8 +817,8 @@
<span class="lineNum"> 755 </span><span class="lineCov"> 23 : opt.expect_recoverable = 1;</span>
<span class="lineNum"> 756 </span><span class="lineCov"> 23 : break;</span>
<span class="lineNum"> 757 </span> : case OPT_TEST_SKIP_SELF :
<span class="lineNum"> 758 </span><span class="lineCov"> 267 : opt.skip_self = 1;</span>
<span class="lineNum"> 759 </span><span class="lineCov"> 267 : break;</span>
<span class="lineNum"> 758 </span><span class="lineCov"> 268 : opt.skip_self = 1;</span>
<span class="lineNum"> 759 </span><span class="lineCov"> 268 : break;</span>
<span class="lineNum"> 760 </span> : case OPT_TEST_SKIP_SIGN :
<span class="lineNum"> 761 </span><span class="lineNoCov"> 0 : opt.skip_sign = 1;</span>
<span class="lineNum"> 762 </span><span class="lineNoCov"> 0 : break;</span>
@ -826,9 +826,9 @@
<span class="lineNum"> 764 </span><span class="lineCov"> 1 : opt.skip_fallocate = 1;</span>
<span class="lineNum"> 765 </span><span class="lineCov"> 1 : break;</span>
<span class="lineNum"> 766 </span> : case OPT_TEST_SKIP_DEVICE :
<span class="lineNum"> 767 </span><span class="lineCov"> 274 : opt.skip_device = 1;</span>
<span class="lineNum"> 768 </span><span class="lineCov"> 274 : period = 50; /* reduce period of the speed test */</span>
<span class="lineNum"> 769 </span><span class="lineCov"> 274 : break;</span>
<span class="lineNum"> 767 </span><span class="lineCov"> 275 : opt.skip_device = 1;</span>
<span class="lineNum"> 768 </span><span class="lineCov"> 275 : period = 50; /* reduce period of the speed test */</span>
<span class="lineNum"> 769 </span><span class="lineCov"> 275 : break;</span>
<span class="lineNum"> 770 </span> : case OPT_TEST_SKIP_CONTENT_CHECK :
<span class="lineNum"> 771 </span><span class="lineNoCov"> 0 : opt.skip_content_check = 1;</span>
<span class="lineNum"> 772 </span><span class="lineNoCov"> 0 : break;</span>
@ -854,8 +854,8 @@
<span class="lineNum"> 792 </span><span class="lineNoCov"> 0 : opt.force_order = SORT_INODE;</span>
<span class="lineNum"> 793 </span><span class="lineNoCov"> 0 : break;</span>
<span class="lineNum"> 794 </span> : case OPT_TEST_FORCE_ORDER_ALPHA :
<span class="lineNum"> 795 </span><span class="lineCov"> 265 : opt.force_order = SORT_ALPHA;</span>
<span class="lineNum"> 796 </span><span class="lineCov"> 265 : break;</span>
<span class="lineNum"> 795 </span><span class="lineCov"> 266 : opt.force_order = SORT_ALPHA;</span>
<span class="lineNum"> 796 </span><span class="lineCov"> 266 : break;</span>
<span class="lineNum"> 797 </span> : case OPT_TEST_FORCE_ORDER_DIR :
<span class="lineNum"> 798 </span><span class="lineNoCov"> 0 : opt.force_order = SORT_DIR;</span>
<span class="lineNum"> 799 </span><span class="lineNoCov"> 0 : break;</span>
@ -875,9 +875,9 @@
<span class="lineNum"> 813 </span><span class="lineCov"> 19 : break;</span>
<span class="lineNum"> 814 </span> : case OPT_TEST_EXPECT_NEED_SYNC :
<span class="lineNum"> 815 </span> : /* invert the exit codes */
<span class="lineNum"> 816 </span><span class="lineCov"> 6 : exit_success = 1;</span>
<span class="lineNum"> 817 </span><span class="lineCov"> 6 : exit_sync_needed = 0;</span>
<span class="lineNum"> 818 </span><span class="lineCov"> 6 : break;</span>
<span class="lineNum"> 816 </span><span class="lineCov"> 7 : exit_success = 1;</span>
<span class="lineNum"> 817 </span><span class="lineCov"> 7 : exit_sync_needed = 0;</span>
<span class="lineNum"> 818 </span><span class="lineCov"> 7 : break;</span>
<span class="lineNum"> 819 </span> : case OPT_TEST_RUN :
<span class="lineNum"> 820 </span><span class="lineCov"> 10 : run = optarg;</span>
<span class="lineNum"> 821 </span><span class="lineCov"> 10 : break;</span>
@ -885,8 +885,8 @@
<span class="lineNum"> 823 </span><span class="lineNoCov"> 0 : opt.force_scan_winfind = 1;</span>
<span class="lineNum"> 824 </span><span class="lineNoCov"> 0 : break;</span>
<span class="lineNum"> 825 </span> : case OPT_TEST_FORCE_PROGRESS :
<span class="lineNum"> 826 </span><span class="lineCov"> 267 : opt.force_progress = 1;</span>
<span class="lineNum"> 827 </span><span class="lineCov"> 267 : break;</span>
<span class="lineNum"> 826 </span><span class="lineCov"> 268 : opt.force_progress = 1;</span>
<span class="lineNum"> 827 </span><span class="lineCov"> 268 : break;</span>
<span class="lineNum"> 828 </span> : case OPT_TEST_FORCE_AUTOSAVE_AT :
<span class="lineNum"> 829 </span><span class="lineCov"> 1 : opt.force_autosave_at = atoi(optarg);</span>
<span class="lineNum"> 830 </span><span class="lineCov"> 1 : break;</span>
@ -894,8 +894,8 @@
<span class="lineNum"> 832 </span><span class="lineCov"> 1 : opt.fake_device = 1;</span>
<span class="lineNum"> 833 </span><span class="lineCov"> 1 : break;</span>
<span class="lineNum"> 834 </span> : case OPT_NO_WARNINGS :
<span class="lineNum"> 835 </span><span class="lineCov"> 268 : opt.no_warnings = 1;</span>
<span class="lineNum"> 836 </span><span class="lineCov"> 268 : break;</span>
<span class="lineNum"> 835 </span><span class="lineCov"> 269 : opt.no_warnings = 1;</span>
<span class="lineNum"> 836 </span><span class="lineCov"> 269 : break;</span>
<span class="lineNum"> 837 </span> : case OPT_TEST_FAKE_UUID :
<span class="lineNum"> 838 </span><span class="lineCov"> 1 : opt.fake_uuid = 2;</span>
<span class="lineNum"> 839 </span><span class="lineCov"> 1 : break;</span>
@ -915,8 +915,8 @@
<span class="lineNum"> 853 </span> : }
<span class="lineNum"> 854 </span><span class="lineCov"> 1 : break;</span>
<span class="lineNum"> 855 </span> : case OPT_TEST_IO_STATS :
<span class="lineNum"> 856 </span><span class="lineNoCov"> 0 : opt.force_stats = 1;</span>
<span class="lineNum"> 857 </span><span class="lineNoCov"> 0 : break;</span>
<span class="lineNum"> 856 </span><span class="lineCov"> 1 : opt.force_stats = 1;</span>
<span class="lineNum"> 857 </span><span class="lineCov"> 1 : break;</span>
<span class="lineNum"> 858 </span> : case OPT_TEST_COND_SIGNAL_OUTSIDE :
<span class="lineNum"> 859 </span> : #if HAVE_PTHREAD
<span class="lineNum"> 860 </span><span class="lineNoCov"> 0 : thread_cond_signal_outside = 1;</span>
@ -944,8 +944,8 @@
<span class="lineNum"> 882 </span><span class="lineNoCov"> 0 : opt.file_mode = ADVISE_DIRECT;</span>
<span class="lineNum"> 883 </span><span class="lineNoCov"> 0 : break;</span>
<span class="lineNum"> 884 </span> : case OPT_TEST_PARITY_LIMIT :
<span class="lineNum"> 885 </span><span class="lineCov"> 267 : opt.parity_limit_size = atoll(optarg);</span>
<span class="lineNum"> 886 </span><span class="lineCov"> 267 : break;</span>
<span class="lineNum"> 885 </span><span class="lineCov"> 268 : opt.parity_limit_size = atoll(optarg);</span>
<span class="lineNum"> 886 </span><span class="lineCov"> 268 : break;</span>
<span class="lineNum"> 887 </span> : case OPT_TEST_SKIP_CONTENT_WRITE :
<span class="lineNum"> 888 </span><span class="lineNoCov"> 0 : opt.skip_content_write = 1;</span>
<span class="lineNum"> 889 </span><span class="lineNoCov"> 0 : break;</span>
@ -974,32 +974,32 @@
<span class="lineNum"> 912 </span> : }
<span class="lineNum"> 913 </span> : }
<span class="lineNum"> 914 </span> :
<span class="lineNum"> 915 </span><span class="lineCov"> 269 : os_init(opt.force_scan_winfind);</span>
<span class="lineNum"> 916 </span><span class="lineCov"> 269 : raid_init();</span>
<span class="lineNum"> 917 </span><span class="lineCov"> 269 : crc32c_init();</span>
<span class="lineNum"> 915 </span><span class="lineCov"> 270 : os_init(opt.force_scan_winfind);</span>
<span class="lineNum"> 916 </span><span class="lineCov"> 270 : raid_init();</span>
<span class="lineNum"> 917 </span><span class="lineCov"> 270 : crc32c_init();</span>
<span class="lineNum"> 918 </span> :
<span class="lineNum"> 919 </span><span class="lineCov"> 269 : if (speedtest != 0) {</span>
<span class="lineNum"> 919 </span><span class="lineCov"> 270 : if (speedtest != 0) {</span>
<span class="lineNum"> 920 </span><span class="lineCov"> 4 : speed(period);</span>
<span class="lineNum"> 921 </span><span class="lineCov"> 4 : os_done();</span>
<span class="lineNum"> 922 </span><span class="lineCov"> 4 : exit(EXIT_SUCCESS);</span>
<span class="lineNum"> 923 </span> : }
<span class="lineNum"> 924 </span> :
<span class="lineNum"> 925 </span><span class="lineCov"> 265 : if (gen_conf != 0) {</span>
<span class="lineNum"> 925 </span><span class="lineCov"> 266 : if (gen_conf != 0) {</span>
<span class="lineNum"> 926 </span><span class="lineCov"> 1 : generate_configuration(gen_conf);</span>
<span class="lineNum"> 927 </span><span class="lineCov"> 1 : os_done();</span>
<span class="lineNum"> 928 </span><span class="lineCov"> 1 : exit(EXIT_SUCCESS);</span>
<span class="lineNum"> 929 </span> : }
<span class="lineNum"> 930 </span> :
<span class="lineNum"> 931 </span><span class="lineCov"> 264 : if (optind + 1 != argc) {</span>
<span class="lineNum"> 931 </span><span class="lineCov"> 265 : if (optind + 1 != argc) {</span>
<span class="lineNum"> 932 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 933 </span> : usage();
<span class="lineNum"> 934 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 935 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 936 </span> : }
<span class="lineNum"> 937 </span> :
<span class="lineNum"> 938 </span><span class="lineCov"> 264 : command = argv[optind];</span>
<span class="lineNum"> 939 </span><span class="lineCov"> 264 : if (strcmp(command, &quot;diff&quot;) == 0) {</span>
<span class="lineNum"> 940 </span><span class="lineCov"> 7 : operation = OPERATION_DIFF;</span>
<span class="lineNum"> 938 </span><span class="lineCov"> 265 : command = argv[optind];</span>
<span class="lineNum"> 939 </span><span class="lineCov"> 265 : if (strcmp(command, &quot;diff&quot;) == 0) {</span>
<span class="lineNum"> 940 </span><span class="lineCov"> 8 : operation = OPERATION_DIFF;</span>
<span class="lineNum"> 941 </span><span class="lineCov"> 257 : } else if (strcmp(argv[optind], &quot;sync&quot;) == 0) {</span>
<span class="lineNum"> 942 </span><span class="lineCov"> 89 : operation = OPERATION_SYNC;</span>
<span class="lineNum"> 943 </span><span class="lineCov"> 168 : } else if (strcmp(argv[optind], &quot;check&quot;) == 0) {</span>
@ -1042,11 +1042,11 @@
<span class="lineNum"> 980 </span> : }
<span class="lineNum"> 981 </span> :
<span class="lineNum"> 982 </span> : /* check options compatibility */
<span class="lineNum"> 983 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 983 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 984 </span> : case OPERATION_CHECK :
<span class="lineNum"> 985 </span><span class="lineCov"> 75 : break;</span>
<span class="lineNum"> 986 </span> : default :
<span class="lineNum"> 987 </span><span class="lineCov"> 189 : if (opt.auditonly) {</span>
<span class="lineNum"> 987 </span><span class="lineCov"> 190 : if (opt.auditonly) {</span>
<span class="lineNum"> 988 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 989 </span> : log_fatal(&quot;You cannot use -a, --audit-only with the '%s' command\n&quot;, command);
<span class="lineNum"> 990 </span> : exit(EXIT_FAILURE);
@ -1054,12 +1054,12 @@
<span class="lineNum"> 992 </span> : }
<span class="lineNum"> 993 </span> : }
<span class="lineNum"> 994 </span> :
<span class="lineNum"> 995 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 995 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 996 </span> : case OPERATION_FIX :
<span class="lineNum"> 997 </span> : case OPERATION_CHECK :
<span class="lineNum"> 998 </span><span class="lineCov"> 121 : break;</span>
<span class="lineNum"> 999 </span> : default :
<span class="lineNum"> 1000 </span><span class="lineCov"> 143 : if (opt.force_device) {</span>
<span class="lineNum"> 1000 </span><span class="lineCov"> 144 : if (opt.force_device) {</span>
<span class="lineNum"> 1001 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1002 </span> : log_fatal(&quot;You cannot use -D, --force-device with the '%s' command\n&quot;, command);
<span class="lineNum"> 1003 </span> : exit(EXIT_FAILURE);
@ -1067,13 +1067,13 @@
<span class="lineNum"> 1005 </span> : }
<span class="lineNum"> 1006 </span> : }
<span class="lineNum"> 1007 </span> :
<span class="lineNum"> 1008 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1008 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1009 </span> : case OPERATION_SYNC :
<span class="lineNum"> 1010 </span> : case OPERATION_CHECK :
<span class="lineNum"> 1011 </span> : case OPERATION_FIX :
<span class="lineNum"> 1012 </span><span class="lineCov"> 210 : break;</span>
<span class="lineNum"> 1013 </span> : default :
<span class="lineNum"> 1014 </span><span class="lineCov"> 54 : if (opt.force_nocopy) {</span>
<span class="lineNum"> 1014 </span><span class="lineCov"> 55 : if (opt.force_nocopy) {</span>
<span class="lineNum"> 1015 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1016 </span> : log_fatal(&quot;You cannot use -N, --force-nocopy with the '%s' command\n&quot;, command);
<span class="lineNum"> 1017 </span> : exit(EXIT_FAILURE);
@ -1081,25 +1081,25 @@
<span class="lineNum"> 1019 </span> : }
<span class="lineNum"> 1020 </span> : }
<span class="lineNum"> 1021 </span> :
<span class="lineNum"> 1022 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1022 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1023 </span> : case OPERATION_SYNC :
<span class="lineNum"> 1024 </span><span class="lineCov"> 89 : break;</span>
<span class="lineNum"> 1025 </span> : default :
<span class="lineNum"> 1026 </span><span class="lineCov"> 175 : if (opt.prehash) {</span>
<span class="lineNum"> 1026 </span><span class="lineCov"> 176 : if (opt.prehash) {</span>
<span class="lineNum"> 1027 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1028 </span> : log_fatal(&quot;You cannot use -h, --pre-hash with the '%s' command\n&quot;, command);
<span class="lineNum"> 1029 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1030 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1031 </span> : }
<span class="lineNum"> 1032 </span> :
<span class="lineNum"> 1033 </span><span class="lineCov"> 175 : if (opt.force_full) {</span>
<span class="lineNum"> 1033 </span><span class="lineCov"> 176 : if (opt.force_full) {</span>
<span class="lineNum"> 1034 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1035 </span> : log_fatal(&quot;You cannot use -F, --force-full with the '%s' command\n&quot;, command);
<span class="lineNum"> 1036 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1037 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1038 </span> : }
<span class="lineNum"> 1039 </span> :
<span class="lineNum"> 1040 </span><span class="lineCov"> 175 : if (opt.force_realloc) {</span>
<span class="lineNum"> 1040 </span><span class="lineCov"> 176 : if (opt.force_realloc) {</span>
<span class="lineNum"> 1041 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1042 </span> : log_fatal(&quot;You cannot use -R, --force-realloc with the '%s' command\n&quot;, command);
<span class="lineNum"> 1043 </span> : exit(EXIT_FAILURE);
@ -1107,41 +1107,41 @@
<span class="lineNum"> 1045 </span> : }
<span class="lineNum"> 1046 </span> : }
<span class="lineNum"> 1047 </span> :
<span class="lineNum"> 1048 </span><span class="lineCov"> 264 : if (opt.force_full &amp;&amp; opt.force_nocopy) {</span>
<span class="lineNum"> 1048 </span><span class="lineCov"> 265 : if (opt.force_full &amp;&amp; opt.force_nocopy) {</span>
<span class="lineNum"> 1049 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1050 </span> : log_fatal(&quot;You cannot use the -F, --force-full and -N, --force-nocopy options at the same time\n&quot;);
<span class="lineNum"> 1051 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1052 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1053 </span> : }
<span class="lineNum"> 1054 </span> :
<span class="lineNum"> 1055 </span><span class="lineCov"> 264 : if (opt.force_realloc &amp;&amp; opt.force_nocopy) {</span>
<span class="lineNum"> 1055 </span><span class="lineCov"> 265 : if (opt.force_realloc &amp;&amp; opt.force_nocopy) {</span>
<span class="lineNum"> 1056 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1057 </span> : log_fatal(&quot;You cannot use the -R, --force-realloc and -N, --force-nocopy options at the same time\n&quot;);
<span class="lineNum"> 1058 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1059 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1060 </span> : }
<span class="lineNum"> 1061 </span> :
<span class="lineNum"> 1062 </span><span class="lineCov"> 264 : if (opt.force_realloc &amp;&amp; opt.force_full) {</span>
<span class="lineNum"> 1062 </span><span class="lineCov"> 265 : if (opt.force_realloc &amp;&amp; opt.force_full) {</span>
<span class="lineNum"> 1063 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1064 </span> : log_fatal(&quot;You cannot use the -R, --force-realloc and -F, --force-full options at the same time\n&quot;);
<span class="lineNum"> 1065 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1066 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1067 </span> : }
<span class="lineNum"> 1068 </span> :
<span class="lineNum"> 1069 </span><span class="lineCov"> 264 : if (opt.prehash &amp;&amp; opt.force_nocopy) {</span>
<span class="lineNum"> 1069 </span><span class="lineCov"> 265 : if (opt.prehash &amp;&amp; opt.force_nocopy) {</span>
<span class="lineNum"> 1070 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1071 </span> : log_fatal(&quot;You cannot use the -h, --pre-hash and -N, --force-nocopy options at the same time\n&quot;);
<span class="lineNum"> 1072 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1073 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1074 </span> : }
<span class="lineNum"> 1075 </span> :
<span class="lineNum"> 1076 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1076 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1077 </span> : case OPERATION_CHECK :
<span class="lineNum"> 1078 </span> : case OPERATION_FIX :
<span class="lineNum"> 1079 </span> : case OPERATION_DRY :
<span class="lineNum"> 1080 </span><span class="lineCov"> 123 : break;</span>
<span class="lineNum"> 1081 </span> : default :
<span class="lineNum"> 1082 </span><span class="lineCov"> 139 : if (!tommy_list_empty(&amp;filterlist_disk)) {</span>
<span class="lineNum"> 1082 </span><span class="lineCov"> 140 : if (!tommy_list_empty(&amp;filterlist_disk)) {</span>
<span class="lineNum"> 1083 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1084 </span> : log_fatal(&quot;You cannot use -d, --filter-disk with the '%s' command\n&quot;, command);
<span class="lineNum"> 1085 </span> : exit(EXIT_FAILURE);
@ -1150,19 +1150,19 @@
<span class="lineNum"> 1088 </span> : /* follow */
<span class="lineNum"> 1089 </span> : case OPERATION_SPINUP :
<span class="lineNum"> 1090 </span> : case OPERATION_SPINDOWN :
<span class="lineNum"> 1091 </span><span class="lineCov"> 141 : if (!tommy_list_empty(&amp;filterlist_file)) {</span>
<span class="lineNum"> 1091 </span><span class="lineCov"> 142 : if (!tommy_list_empty(&amp;filterlist_file)) {</span>
<span class="lineNum"> 1092 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1093 </span> : log_fatal(&quot;You cannot use -f, --filter with the '%s' command\n&quot;, command);
<span class="lineNum"> 1094 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1095 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1096 </span> : }
<span class="lineNum"> 1097 </span><span class="lineCov"> 141 : if (filter_missing != 0) {</span>
<span class="lineNum"> 1097 </span><span class="lineCov"> 142 : if (filter_missing != 0) {</span>
<span class="lineNum"> 1098 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1099 </span> : log_fatal(&quot;You cannot use -m, --filter-missing with the '%s' command\n&quot;, command);
<span class="lineNum"> 1100 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1101 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1102 </span> : }
<span class="lineNum"> 1103 </span><span class="lineCov"> 141 : if (filter_error != 0) {</span>
<span class="lineNum"> 1103 </span><span class="lineCov"> 142 : if (filter_error != 0) {</span>
<span class="lineNum"> 1104 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1105 </span> : log_fatal(&quot;You cannot use -e, --filter-error with the '%s' command\n&quot;, command);
<span class="lineNum"> 1106 </span> : exit(EXIT_FAILURE);
@ -1172,19 +1172,19 @@
<span class="lineNum"> 1110 </span> :
<span class="lineNum"> 1111 </span> : /* errors must be always fixed on all disks */
<span class="lineNum"> 1112 </span> : /* because we don't keep the information on what disk is the error */
<span class="lineNum"> 1113 </span><span class="lineCov"> 264 : if (filter_error != 0 &amp;&amp; !tommy_list_empty(&amp;filterlist_disk)) {</span>
<span class="lineNum"> 1113 </span><span class="lineCov"> 265 : if (filter_error != 0 &amp;&amp; !tommy_list_empty(&amp;filterlist_disk)) {</span>
<span class="lineNum"> 1114 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1115 </span> : log_fatal(&quot;You cannot use -e, --filter-error and -d, --filter-disk at the same time\n&quot;);
<span class="lineNum"> 1116 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 1117 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 1118 </span> : }
<span class="lineNum"> 1119 </span> :
<span class="lineNum"> 1120 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1120 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1121 </span> : case OPERATION_CHECK :
<span class="lineNum"> 1122 </span> : case OPERATION_FIX :
<span class="lineNum"> 1123 </span><span class="lineCov"> 121 : break;</span>
<span class="lineNum"> 1124 </span> : default :
<span class="lineNum"> 1125 </span><span class="lineCov"> 143 : if (import_timestamp != 0 || import_content != 0) {</span>
<span class="lineNum"> 1125 </span><span class="lineCov"> 144 : if (import_timestamp != 0 || import_content != 0) {</span>
<span class="lineNum"> 1126 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1127 </span> : log_fatal(&quot;You cannot import with the '%s' command\n&quot;, command);
<span class="lineNum"> 1128 </span> : exit(EXIT_FAILURE);
@ -1192,7 +1192,7 @@
<span class="lineNum"> 1130 </span> : }
<span class="lineNum"> 1131 </span> : }
<span class="lineNum"> 1132 </span> :
<span class="lineNum"> 1133 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1133 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1134 </span> : case OPERATION_LIST :
<span class="lineNum"> 1135 </span> : case OPERATION_DUP :
<span class="lineNum"> 1136 </span> : case OPERATION_STATUS :
@ -1205,7 +1205,7 @@
<span class="lineNum"> 1143 </span><span class="lineCov"> 26 : break;</span>
<span class="lineNum"> 1144 </span> : }
<span class="lineNum"> 1145 </span> :
<span class="lineNum"> 1146 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1146 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1147 </span> : case OPERATION_DIFF :
<span class="lineNum"> 1148 </span> : case OPERATION_LIST :
<span class="lineNum"> 1149 </span> : case OPERATION_DUP :
@ -1217,11 +1217,11 @@
<span class="lineNum"> 1155 </span> : case OPERATION_TOUCH :
<span class="lineNum"> 1156 </span> : case OPERATION_SPINUP : /* we want to do it in different threads to avoid blocking */
<span class="lineNum"> 1157 </span> : /* avoid to check and access parity disks if not needed */
<span class="lineNum"> 1158 </span><span class="lineCov"> 37 : opt.skip_parity_access = 1;</span>
<span class="lineNum"> 1159 </span><span class="lineCov"> 37 : break;</span>
<span class="lineNum"> 1158 </span><span class="lineCov"> 38 : opt.skip_parity_access = 1;</span>
<span class="lineNum"> 1159 </span><span class="lineCov"> 38 : break;</span>
<span class="lineNum"> 1160 </span> : }
<span class="lineNum"> 1161 </span> :
<span class="lineNum"> 1162 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1162 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1163 </span> : case OPERATION_FIX :
<span class="lineNum"> 1164 </span> : case OPERATION_CHECK :
<span class="lineNum"> 1165 </span> : /* avoid to stop processing if a content file is not accessible */
@ -1229,7 +1229,7 @@
<span class="lineNum"> 1167 </span><span class="lineCov"> 121 : break;</span>
<span class="lineNum"> 1168 </span> : }
<span class="lineNum"> 1169 </span> :
<span class="lineNum"> 1170 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1170 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1171 </span> : case OPERATION_DIFF :
<span class="lineNum"> 1172 </span> : case OPERATION_LIST :
<span class="lineNum"> 1173 </span> : case OPERATION_DUP :
@ -1239,11 +1239,11 @@
<span class="lineNum"> 1177 </span> : case OPERATION_SPINDOWN :
<span class="lineNum"> 1178 </span> : case OPERATION_DEVICES :
<span class="lineNum"> 1179 </span> : case OPERATION_SMART :
<span class="lineNum"> 1180 </span><span class="lineCov"> 24 : opt.skip_self = 1;</span>
<span class="lineNum"> 1181 </span><span class="lineCov"> 24 : break;</span>
<span class="lineNum"> 1180 </span><span class="lineCov"> 25 : opt.skip_self = 1;</span>
<span class="lineNum"> 1181 </span><span class="lineCov"> 25 : break;</span>
<span class="lineNum"> 1182 </span> : }
<span class="lineNum"> 1183 </span> :
<span class="lineNum"> 1184 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1184 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1185 </span> : #if HAVE_DIRECT_IO
<span class="lineNum"> 1186 </span> : case OPERATION_SYNC :
<span class="lineNum"> 1187 </span> : case OPERATION_SCRUB :
@ -1252,12 +1252,12 @@
<span class="lineNum"> 1190 </span> : #endif
<span class="lineNum"> 1191 </span> : default:
<span class="lineNum"> 1192 </span> : /* we allow direct IO only on some commands */
<span class="lineNum"> 1193 </span><span class="lineCov"> 162 : if (opt.file_mode == ADVISE_DIRECT)</span>
<span class="lineNum"> 1193 </span><span class="lineCov"> 163 : if (opt.file_mode == ADVISE_DIRECT)</span>
<span class="lineNum"> 1194 </span><span class="lineNoCov"> 0 : opt.file_mode = ADVISE_SEQUENTIAL;</span>
<span class="lineNum"> 1195 </span><span class="lineCov"> 162 : break;</span>
<span class="lineNum"> 1195 </span><span class="lineCov"> 163 : break;</span>
<span class="lineNum"> 1196 </span> : }
<span class="lineNum"> 1197 </span> :
<span class="lineNum"> 1198 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1198 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1199 </span> : case OPERATION_DEVICES :
<span class="lineNum"> 1200 </span> : case OPERATION_SMART :
<span class="lineNum"> 1201 </span> : /* we may need to use these commands during operations */
@ -1265,7 +1265,7 @@
<span class="lineNum"> 1203 </span><span class="lineCov"> 3 : break;</span>
<span class="lineNum"> 1204 </span> : }
<span class="lineNum"> 1205 </span> :
<span class="lineNum"> 1206 </span><span class="lineCov"> 264 : switch (operation) {</span>
<span class="lineNum"> 1206 </span><span class="lineCov"> 265 : switch (operation) {</span>
<span class="lineNum"> 1207 </span> : case OPERATION_SMART :
<span class="lineNum"> 1208 </span> : /* allow to run without configuration file */
<span class="lineNum"> 1209 </span><span class="lineCov"> 2 : opt.auto_conf = 1;</span>
@ -1273,39 +1273,39 @@
<span class="lineNum"> 1211 </span> : }
<span class="lineNum"> 1212 </span> :
<span class="lineNum"> 1213 </span> : /* open the log file */
<span class="lineNum"> 1214 </span><span class="lineCov"> 264 : log_open(log_file);</span>
<span class="lineNum"> 1214 </span><span class="lineCov"> 265 : log_open(log_file);</span>
<span class="lineNum"> 1215 </span> :
<span class="lineNum"> 1216 </span> : /* print generic info into the log */
<span class="lineNum"> 1217 </span><span class="lineCov"> 264 : t = time(0);</span>
<span class="lineNum"> 1218 </span><span class="lineCov"> 264 : tm = localtime(&amp;t);</span>
<span class="lineNum"> 1219 </span><span class="lineCov"> 264 : log_tag(&quot;version:%s\n&quot;, PACKAGE_VERSION);</span>
<span class="lineNum"> 1220 </span><span class="lineCov"> 264 : log_tag(&quot;unixtime:%&quot; PRIi64 &quot;\n&quot;, (int64_t)t);</span>
<span class="lineNum"> 1221 </span><span class="lineCov"> 264 : if (tm) {</span>
<span class="lineNum"> 1217 </span><span class="lineCov"> 265 : t = time(0);</span>
<span class="lineNum"> 1218 </span><span class="lineCov"> 265 : tm = localtime(&amp;t);</span>
<span class="lineNum"> 1219 </span><span class="lineCov"> 265 : log_tag(&quot;version:%s\n&quot;, PACKAGE_VERSION);</span>
<span class="lineNum"> 1220 </span><span class="lineCov"> 265 : log_tag(&quot;unixtime:%&quot; PRIi64 &quot;\n&quot;, (int64_t)t);</span>
<span class="lineNum"> 1221 </span><span class="lineCov"> 265 : if (tm) {</span>
<span class="lineNum"> 1222 </span> : char datetime[64];
<span class="lineNum"> 1223 </span><span class="lineCov"> 264 : strftime(datetime, sizeof(datetime), &quot;%Y-%m-%d %H:%M:%S&quot;, tm);</span>
<span class="lineNum"> 1224 </span><span class="lineCov"> 264 : log_tag(&quot;time:%s\n&quot;, datetime);</span>
<span class="lineNum"> 1223 </span><span class="lineCov"> 265 : strftime(datetime, sizeof(datetime), &quot;%Y-%m-%d %H:%M:%S&quot;, tm);</span>
<span class="lineNum"> 1224 </span><span class="lineCov"> 265 : log_tag(&quot;time:%s\n&quot;, datetime);</span>
<span class="lineNum"> 1225 </span> : }
<span class="lineNum"> 1226 </span><span class="lineCov"> 264 : log_tag(&quot;command:%s\n&quot;, command);</span>
<span class="lineNum"> 1227 </span><span class="lineCov"> 4037 : for (i = 0; i &lt; argc; ++i)</span>
<span class="lineNum"> 1228 </span><span class="lineCov"> 3773 : log_tag(&quot;argv:%u:%s\n&quot;, i, argv[i]);</span>
<span class="lineNum"> 1229 </span><span class="lineCov"> 264 : log_flush();</span>
<span class="lineNum"> 1226 </span><span class="lineCov"> 265 : log_tag(&quot;command:%s\n&quot;, command);</span>
<span class="lineNum"> 1227 </span><span class="lineCov"> 4052 : for (i = 0; i &lt; argc; ++i)</span>
<span class="lineNum"> 1228 </span><span class="lineCov"> 3787 : log_tag(&quot;argv:%u:%s\n&quot;, i, argv[i]);</span>
<span class="lineNum"> 1229 </span><span class="lineCov"> 265 : log_flush();</span>
<span class="lineNum"> 1230 </span> :
<span class="lineNum"> 1231 </span><span class="lineCov"> 264 : if (!opt.skip_self)</span>
<span class="lineNum"> 1231 </span><span class="lineCov"> 265 : if (!opt.skip_self)</span>
<span class="lineNum"> 1232 </span><span class="lineCov"> 1 : selftest();</span>
<span class="lineNum"> 1233 </span> :
<span class="lineNum"> 1234 </span><span class="lineCov"> 264 : state_init(&amp;state);</span>
<span class="lineNum"> 1234 </span><span class="lineCov"> 265 : state_init(&amp;state);</span>
<span class="lineNum"> 1235 </span> :
<span class="lineNum"> 1236 </span> : /* read the configuration file */
<span class="lineNum"> 1237 </span><span class="lineCov"> 264 : state_config(&amp;state, conf, command, &amp;opt, &amp;filterlist_disk);</span>
<span class="lineNum"> 1237 </span><span class="lineCov"> 265 : state_config(&amp;state, conf, command, &amp;opt, &amp;filterlist_disk);</span>
<span class="lineNum"> 1238 </span> :
<span class="lineNum"> 1239 </span> : /* set the raid mode */
<span class="lineNum"> 1240 </span><span class="lineCov"> 263 : raid_mode(state.raid_mode);</span>
<span class="lineNum"> 1240 </span><span class="lineCov"> 264 : raid_mode(state.raid_mode);</span>
<span class="lineNum"> 1241 </span> :
<span class="lineNum"> 1242 </span> : #if HAVE_LOCKFILE
<span class="lineNum"> 1243 </span> : /* create the lock file */
<span class="lineNum"> 1244 </span><span class="lineCov"> 263 : if (!opt.skip_lock &amp;&amp; state.lockfile[0]) {</span>
<span class="lineNum"> 1245 </span><span class="lineCov"> 260 : lock = lock_lock(state.lockfile);</span>
<span class="lineNum"> 1246 </span><span class="lineCov"> 260 : if (lock == -1) {</span>
<span class="lineNum"> 1244 </span><span class="lineCov"> 264 : if (!opt.skip_lock &amp;&amp; state.lockfile[0]) {</span>
<span class="lineNum"> 1245 </span><span class="lineCov"> 261 : lock = lock_lock(state.lockfile);</span>
<span class="lineNum"> 1246 </span><span class="lineCov"> 261 : if (lock == -1) {</span>
<span class="lineNum"> 1247 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1248 </span> : if (errno != EWOULDBLOCK) {
<span class="lineNum"> 1249 </span> : log_fatal(&quot;Error creating the lock file '%s'. %s.\n&quot;, state.lockfile, strerror(errno));
@ -1321,14 +1321,14 @@
<span class="lineNum"> 1259 </span> : (void)lock;
<span class="lineNum"> 1260 </span> : #endif
<span class="lineNum"> 1261 </span> :
<span class="lineNum"> 1262 </span><span class="lineCov"> 263 : if (operation == OPERATION_DIFF) {</span>
<span class="lineNum"> 1263 </span><span class="lineCov"> 7 : state_read(&amp;state);</span>
<span class="lineNum"> 1262 </span><span class="lineCov"> 264 : if (operation == OPERATION_DIFF) {</span>
<span class="lineNum"> 1263 </span><span class="lineCov"> 8 : state_read(&amp;state);</span>
<span class="lineNum"> 1264 </span> :
<span class="lineNum"> 1265 </span><span class="lineCov"> 7 : ret = state_diff(&amp;state);</span>
<span class="lineNum"> 1265 </span><span class="lineCov"> 8 : ret = state_diff(&amp;state);</span>
<span class="lineNum"> 1266 </span> :
<span class="lineNum"> 1267 </span> : /* abort if sync needed */
<span class="lineNum"> 1268 </span><span class="lineCov"> 7 : if (ret &gt; 0)</span>
<span class="lineNum"> 1269 </span><span class="lineCov"> 6 : exit(EXIT_SYNC_NEEDED);</span>
<span class="lineNum"> 1268 </span><span class="lineCov"> 8 : if (ret &gt; 0)</span>
<span class="lineNum"> 1269 </span><span class="lineCov"> 7 : exit(EXIT_SYNC_NEEDED);</span>
<span class="lineNum"> 1270 </span><span class="lineCov"> 256 : } else if (operation == OPERATION_SYNC) {</span>
<span class="lineNum"> 1271 </span> :
<span class="lineNum"> 1272 </span> : /* in the next state read ensures to clear all the past hashes in case */

2
cov/cmdline/speed.c.func-sort-c.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="speed.c.gcov.html#39">diffgettimeofday</a></td>
<td class="coverFnHi">1840</td>
<td class="coverFnHi">1834</td>
</tr>
<tr>
<td class="coverFn"><a href="speed.c.gcov.html#76">speed</a></td>

2
cov/cmdline/speed.c.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="speed.c.gcov.html#39">diffgettimeofday</a></td>
<td class="coverFnHi">1840</td>
<td class="coverFnHi">1834</td>
</tr>
<tr>
<td class="coverFn"><a href="speed.c.gcov.html#76">speed</a></td>

104
cov/cmdline/speed.c.gcov.html
View file

@ -100,14 +100,14 @@
<span class="lineNum"> 38 </span> : /**
<a name="39"><span class="lineNum"> 39 </span> : * Differential us of two timeval.</a>
<span class="lineNum"> 40 </span> : */
<span class="lineNum"> 41 </span><span class="lineCov"> 1840 : static int64_t diffgettimeofday(struct timeval *start, struct timeval *stop)</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 1834 : static int64_t diffgettimeofday(struct timeval *start, struct timeval *stop)</span>
<span class="lineNum"> 42 </span> : {
<span class="lineNum"> 43 </span> : int64_t d;
<span class="lineNum"> 44 </span> :
<span class="lineNum"> 45 </span><span class="lineCov"> 1840 : d = 1000000LL * (stop-&gt;tv_sec - start-&gt;tv_sec);</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 1840 : d += stop-&gt;tv_usec - start-&gt;tv_usec;</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 1834 : d = 1000000LL * (stop-&gt;tv_sec - start-&gt;tv_sec);</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 1834 : d += stop-&gt;tv_usec - start-&gt;tv_usec;</span>
<span class="lineNum"> 47 </span> :
<span class="lineNum"> 48 </span><span class="lineCov"> 1840 : return d;</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 1834 : return d;</span>
<span class="lineNum"> 49 </span> : }
<span class="lineNum"> 50 </span> :
<span class="lineNum"> 51 </span> : /**
@ -232,10 +232,10 @@
<span class="lineNum"> 170 </span><span class="lineCov"> 4 : printf(&quot;%8s&quot;, &quot;memset&quot;);</span>
<span class="lineNum"> 171 </span><span class="lineCov"> 4 : fflush(stdout);</span>
<span class="lineNum"> 172 </span> :
<span class="lineNum"> 173 </span><span class="lineCov"> 380 : SPEED_START {</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 3384 : for (j = 0; j &lt; nd; ++j)</span>
<span class="lineNum"> 175 </span><span class="lineCov"> 3008 : memset(v[j], j, size);</span>
<span class="lineNum"> 176 </span><span class="lineCov"> 376 : } SPEED_STOP</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 386 : SPEED_START {</span>
<span class="lineNum"> 174 </span><span class="lineCov"> 3438 : for (j = 0; j &lt; nd; ++j)</span>
<span class="lineNum"> 175 </span><span class="lineCov"> 3056 : memset(v[j], j, size);</span>
<span class="lineNum"> 176 </span><span class="lineCov"> 382 : } SPEED_STOP</span>
<span class="lineNum"> 177 </span> :
<span class="lineNum"> 178 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 179 </span><span class="lineCov"> 4 : printf(&quot;\n&quot;);</span>
@ -247,10 +247,10 @@
<span class="lineNum"> 185 </span><span class="lineCov"> 4 : printf(&quot;%8s&quot;, &quot;table&quot;);</span>
<span class="lineNum"> 186 </span><span class="lineCov"> 4 : fflush(stdout);</span>
<span class="lineNum"> 187 </span> :
<span class="lineNum"> 188 </span><span class="lineCov"> 47 : SPEED_START {</span>
<span class="lineNum"> 189 </span><span class="lineCov"> 387 : for (j = 0; j &lt; nd; ++j)</span>
<span class="lineNum"> 190 </span><span class="lineCov"> 344 : side_effect += crc32c_gen(0, v[j], size);</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 43 : } SPEED_STOP</span>
<span class="lineNum"> 188 </span><span class="lineCov"> 45 : SPEED_START {</span>
<span class="lineNum"> 189 </span><span class="lineCov"> 369 : for (j = 0; j &lt; nd; ++j)</span>
<span class="lineNum"> 190 </span><span class="lineCov"> 328 : side_effect += crc32c_gen(0, v[j], size);</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 41 : } SPEED_STOP</span>
<span class="lineNum"> 192 </span> :
<span class="lineNum"> 193 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 194 </span><span class="lineCov"> 4 : printf(&quot;\n&quot;);</span>
@ -260,10 +260,10 @@
<span class="lineNum"> 198 </span> :
<span class="lineNum"> 199 </span> : #if HAVE_SSE42
<span class="lineNum"> 200 </span><span class="lineCov"> 4 : if (raid_cpu_has_crc32()) {</span>
<span class="lineNum"> 201 </span><span class="lineCov"> 60 : SPEED_START {</span>
<span class="lineNum"> 202 </span><span class="lineCov"> 522 : for (j = 0; j &lt; nd; ++j)</span>
<span class="lineNum"> 203 </span><span class="lineCov"> 464 : side_effect += crc32c_x86(0, v[j], size);</span>
<span class="lineNum"> 204 </span><span class="lineCov"> 58 : } SPEED_STOP</span>
<span class="lineNum"> 201 </span><span class="lineCov"> 59 : SPEED_START {</span>
<span class="lineNum"> 202 </span><span class="lineCov"> 513 : for (j = 0; j &lt; nd; ++j)</span>
<span class="lineNum"> 203 </span><span class="lineCov"> 456 : side_effect += crc32c_x86(0, v[j], size);</span>
<span class="lineNum"> 204 </span><span class="lineCov"> 57 : } SPEED_STOP</span>
<span class="lineNum"> 205 </span> :
<span class="lineNum"> 206 </span><span class="lineCov"> 2 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 207 </span> : }
@ -341,16 +341,16 @@
<span class="lineNum"> 279 </span> :
<span class="lineNum"> 280 </span><span class="lineCov"> 4 : printf(&quot;%8s&quot;, &quot;&quot;);</span>
<span class="lineNum"> 281 </span> :
<span class="lineNum"> 282 </span><span class="lineCov"> 113 : SPEED_START {</span>
<span class="lineNum"> 283 </span><span class="lineCov"> 109 : raid_gen1_int32(nd, size, v);</span>
<span class="lineNum"> 284 </span><span class="lineCov"> 109 : } SPEED_STOP</span>
<span class="lineNum"> 282 </span><span class="lineCov"> 118 : SPEED_START {</span>
<span class="lineNum"> 283 </span><span class="lineCov"> 114 : raid_gen1_int32(nd, size, v);</span>
<span class="lineNum"> 284 </span><span class="lineCov"> 114 : } SPEED_STOP</span>
<span class="lineNum"> 285 </span> :
<span class="lineNum"> 286 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 287 </span><span class="lineCov"> 4 : fflush(stdout);</span>
<span class="lineNum"> 288 </span> :
<span class="lineNum"> 289 </span><span class="lineCov"> 185 : SPEED_START {</span>
<span class="lineNum"> 290 </span><span class="lineCov"> 181 : raid_gen1_int64(nd, size, v);</span>
<span class="lineNum"> 291 </span><span class="lineCov"> 181 : } SPEED_STOP</span>
<span class="lineNum"> 289 </span><span class="lineCov"> 183 : SPEED_START {</span>
<span class="lineNum"> 290 </span><span class="lineCov"> 179 : raid_gen1_int64(nd, size, v);</span>
<span class="lineNum"> 291 </span><span class="lineCov"> 179 : } SPEED_STOP</span>
<span class="lineNum"> 292 </span> :
<span class="lineNum"> 293 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 294 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -358,9 +358,9 @@
<span class="lineNum"> 296 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 297 </span> : #ifdef CONFIG_SSE2
<span class="lineNum"> 298 </span><span class="lineCov"> 4 : if (raid_cpu_has_sse2()) {</span>
<span class="lineNum"> 299 </span><span class="lineCov"> 303 : SPEED_START {</span>
<span class="lineNum"> 300 </span><span class="lineCov"> 299 : raid_gen1_sse2(nd, size, v);</span>
<span class="lineNum"> 301 </span><span class="lineCov"> 299 : } SPEED_STOP</span>
<span class="lineNum"> 299 </span><span class="lineCov"> 304 : SPEED_START {</span>
<span class="lineNum"> 300 </span><span class="lineCov"> 300 : raid_gen1_sse2(nd, size, v);</span>
<span class="lineNum"> 301 </span><span class="lineCov"> 300 : } SPEED_STOP</span>
<span class="lineNum"> 302 </span> :
<span class="lineNum"> 303 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 304 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -401,9 +401,9 @@
<span class="lineNum"> 339 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 340 </span><span class="lineCov"> 4 : fflush(stdout);</span>
<span class="lineNum"> 341 </span> :
<span class="lineNum"> 342 </span><span class="lineCov"> 48 : SPEED_START {</span>
<span class="lineNum"> 343 </span><span class="lineCov"> 44 : raid_gen2_int64(nd, size, v);</span>
<span class="lineNum"> 344 </span><span class="lineCov"> 44 : } SPEED_STOP</span>
<span class="lineNum"> 342 </span><span class="lineCov"> 46 : SPEED_START {</span>
<span class="lineNum"> 343 </span><span class="lineCov"> 42 : raid_gen2_int64(nd, size, v);</span>
<span class="lineNum"> 344 </span><span class="lineCov"> 42 : } SPEED_STOP</span>
<span class="lineNum"> 345 </span> :
<span class="lineNum"> 346 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 347 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -411,9 +411,9 @@
<span class="lineNum"> 349 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 350 </span> : #ifdef CONFIG_SSE2
<span class="lineNum"> 351 </span><span class="lineCov"> 4 : if (raid_cpu_has_sse2()) {</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 144 : SPEED_START {</span>
<span class="lineNum"> 353 </span><span class="lineCov"> 140 : raid_gen2_sse2(nd, size, v);</span>
<span class="lineNum"> 354 </span><span class="lineCov"> 140 : } SPEED_STOP</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 141 : SPEED_START {</span>
<span class="lineNum"> 353 </span><span class="lineCov"> 137 : raid_gen2_sse2(nd, size, v);</span>
<span class="lineNum"> 354 </span><span class="lineCov"> 137 : } SPEED_STOP</span>
<span class="lineNum"> 355 </span> :
<span class="lineNum"> 356 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 357 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -453,9 +453,9 @@
<span class="lineNum"> 391 </span> :
<span class="lineNum"> 392 </span><span class="lineCov"> 4 : printf(&quot;%8s&quot;, &quot;&quot;);</span>
<span class="lineNum"> 393 </span> :
<span class="lineNum"> 394 </span><span class="lineCov"> 32 : SPEED_START {</span>
<span class="lineNum"> 395 </span><span class="lineCov"> 28 : raid_genz_int32(nd, size, v);</span>
<span class="lineNum"> 396 </span><span class="lineCov"> 28 : } SPEED_STOP</span>
<span class="lineNum"> 394 </span><span class="lineCov"> 31 : SPEED_START {</span>
<span class="lineNum"> 395 </span><span class="lineCov"> 27 : raid_genz_int32(nd, size, v);</span>
<span class="lineNum"> 396 </span><span class="lineCov"> 27 : } SPEED_STOP</span>
<span class="lineNum"> 397 </span> :
<span class="lineNum"> 398 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 399 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -470,9 +470,9 @@
<span class="lineNum"> 408 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 409 </span> : #ifdef CONFIG_SSE2
<span class="lineNum"> 410 </span><span class="lineCov"> 4 : if (raid_cpu_has_sse2()) {</span>
<span class="lineNum"> 411 </span><span class="lineCov"> 86 : SPEED_START {</span>
<span class="lineNum"> 412 </span><span class="lineCov"> 82 : raid_genz_sse2(nd, size, v);</span>
<span class="lineNum"> 413 </span><span class="lineCov"> 82 : } SPEED_STOP</span>
<span class="lineNum"> 411 </span><span class="lineCov"> 85 : SPEED_START {</span>
<span class="lineNum"> 412 </span><span class="lineCov"> 81 : raid_genz_sse2(nd, size, v);</span>
<span class="lineNum"> 413 </span><span class="lineCov"> 81 : } SPEED_STOP</span>
<span class="lineNum"> 414 </span> :
<span class="lineNum"> 415 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 416 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -537,9 +537,9 @@
<span class="lineNum"> 475 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 476 </span> : #ifdef CONFIG_SSSE3
<span class="lineNum"> 477 </span><span class="lineCov"> 4 : if (raid_cpu_has_ssse3()) {</span>
<span class="lineNum"> 478 </span><span class="lineCov"> 53 : SPEED_START {</span>
<span class="lineNum"> 479 </span><span class="lineCov"> 50 : raid_gen3_ssse3(nd, size, v);</span>
<span class="lineNum"> 480 </span><span class="lineCov"> 50 : } SPEED_STOP</span>
<span class="lineNum"> 478 </span><span class="lineCov"> 52 : SPEED_START {</span>
<span class="lineNum"> 479 </span><span class="lineCov"> 49 : raid_gen3_ssse3(nd, size, v);</span>
<span class="lineNum"> 480 </span><span class="lineCov"> 49 : } SPEED_STOP</span>
<span class="lineNum"> 481 </span> :
<span class="lineNum"> 482 </span><span class="lineCov"> 3 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 483 </span><span class="lineCov"> 3 : fflush(stdout);</span>
@ -602,9 +602,9 @@
<span class="lineNum"> 540 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 541 </span> : #ifdef CONFIG_SSSE3
<span class="lineNum"> 542 </span><span class="lineCov"> 4 : if (raid_cpu_has_ssse3()) {</span>
<span class="lineNum"> 543 </span><span class="lineCov"> 36 : SPEED_START {</span>
<span class="lineNum"> 544 </span><span class="lineCov"> 33 : raid_gen4_ssse3(nd, size, v);</span>
<span class="lineNum"> 545 </span><span class="lineCov"> 33 : } SPEED_STOP</span>
<span class="lineNum"> 543 </span><span class="lineCov"> 35 : SPEED_START {</span>
<span class="lineNum"> 544 </span><span class="lineCov"> 32 : raid_gen4_ssse3(nd, size, v);</span>
<span class="lineNum"> 545 </span><span class="lineCov"> 32 : } SPEED_STOP</span>
<span class="lineNum"> 546 </span> :
<span class="lineNum"> 547 </span><span class="lineCov"> 3 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 548 </span><span class="lineCov"> 3 : fflush(stdout);</span>
@ -642,9 +642,9 @@
<span class="lineNum"> 580 </span><span class="lineCov"> 4 : printf(&quot;%8s&quot;, raid_gen5_tag());</span>
<span class="lineNum"> 581 </span><span class="lineCov"> 4 : fflush(stdout);</span>
<span class="lineNum"> 582 </span> :
<span class="lineNum"> 583 </span><span class="lineCov"> 12 : SPEED_START {</span>
<span class="lineNum"> 584 </span><span class="lineCov"> 8 : raid_gen5_int8(nd, size, v);</span>
<span class="lineNum"> 585 </span><span class="lineCov"> 8 : } SPEED_STOP</span>
<span class="lineNum"> 583 </span><span class="lineCov"> 11 : SPEED_START {</span>
<span class="lineNum"> 584 </span><span class="lineCov"> 7 : raid_gen5_int8(nd, size, v);</span>
<span class="lineNum"> 585 </span><span class="lineCov"> 7 : } SPEED_STOP</span>
<span class="lineNum"> 586 </span> :
<span class="lineNum"> 587 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 588 </span><span class="lineCov"> 4 : fflush(stdout);</span>
@ -667,9 +667,9 @@
<span class="lineNum"> 605 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 606 </span> : #ifdef CONFIG_SSSE3
<span class="lineNum"> 607 </span><span class="lineCov"> 4 : if (raid_cpu_has_ssse3()) {</span>
<span class="lineNum"> 608 </span><span class="lineCov"> 25 : SPEED_START {</span>
<span class="lineNum"> 609 </span><span class="lineCov"> 22 : raid_gen5_ssse3(nd, size, v);</span>
<span class="lineNum"> 610 </span><span class="lineCov"> 22 : } SPEED_STOP</span>
<span class="lineNum"> 608 </span><span class="lineCov"> 24 : SPEED_START {</span>
<span class="lineNum"> 609 </span><span class="lineCov"> 21 : raid_gen5_ssse3(nd, size, v);</span>
<span class="lineNum"> 610 </span><span class="lineCov"> 21 : } SPEED_STOP</span>
<span class="lineNum"> 611 </span> :
<span class="lineNum"> 612 </span><span class="lineCov"> 3 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 613 </span><span class="lineCov"> 3 : fflush(stdout);</span>
@ -707,9 +707,9 @@
<span class="lineNum"> 645 </span><span class="lineCov"> 4 : printf(&quot;%8s&quot;, raid_gen6_tag());</span>
<span class="lineNum"> 646 </span><span class="lineCov"> 4 : fflush(stdout);</span>
<span class="lineNum"> 647 </span> :
<span class="lineNum"> 648 </span><span class="lineCov"> 11 : SPEED_START {</span>
<span class="lineNum"> 649 </span><span class="lineCov"> 7 : raid_gen6_int8(nd, size, v);</span>
<span class="lineNum"> 650 </span><span class="lineCov"> 7 : } SPEED_STOP</span>
<span class="lineNum"> 648 </span><span class="lineCov"> 9 : SPEED_START {</span>
<span class="lineNum"> 649 </span><span class="lineCov"> 5 : raid_gen6_int8(nd, size, v);</span>
<span class="lineNum"> 650 </span><span class="lineCov"> 5 : } SPEED_STOP</span>
<span class="lineNum"> 651 </span> :
<span class="lineNum"> 652 </span><span class="lineCov"> 4 : printf(&quot;%8&quot; PRIu64, ds / dt);</span>
<span class="lineNum"> 653 </span><span class="lineCov"> 4 : fflush(stdout);</span>

2
cov/cmdline/spooky2.c.func-sort-c.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="spooky2.c.gcov.html#109">SpookyHash128</a></td>
<td class="coverFnHi">3860981</td>
<td class="coverFnHi">3861869</td>
</tr>
</table>
<br>

2
cov/cmdline/spooky2.c.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="spooky2.c.gcov.html#109">SpookyHash128</a></td>
<td class="coverFnHi">3860981</td>
<td class="coverFnHi">3861869</td>
</tr>
</table>
<br>

40
cov/cmdline/spooky2.c.gcov.html
View file

@ -170,7 +170,7 @@
<span class="lineNum"> 108 </span> : //
<a name="109"><span class="lineNum"> 109 </span> : #define sc_const 0xdeadbeefdeadbeefLL</a>
<span class="lineNum"> 110 </span> :
<span class="lineNum"> 111 </span><span class="lineCov"> 3860981 : void SpookyHash128(const void* data, size_t size, const uint8_t* seed, uint8_t* digest)</span>
<span class="lineNum"> 111 </span><span class="lineCov"> 3861869 : void SpookyHash128(const void* data, size_t size, const uint8_t* seed, uint8_t* digest)</span>
<span class="lineNum"> 112 </span> : {
<span class="lineNum"> 113 </span> : uint64_t h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11;
<span class="lineNum"> 114 </span> : uint64_t buf[sc_numVars];
@ -183,39 +183,39 @@
<span class="lineNum"> 121 </span> : unsigned i;
<span class="lineNum"> 122 </span> : #endif
<span class="lineNum"> 123 </span> :
<span class="lineNum"> 124 </span><span class="lineCov"> 3860981 : h9 = ((const uint64_t*)seed)[0];</span>
<span class="lineNum"> 125 </span><span class="lineCov"> 3860981 : h10 = ((const uint64_t*)seed)[1];</span>
<span class="lineNum"> 124 </span><span class="lineCov"> 3861869 : h9 = ((const uint64_t*)seed)[0];</span>
<span class="lineNum"> 125 </span><span class="lineCov"> 3861869 : h10 = ((const uint64_t*)seed)[1];</span>
<span class="lineNum"> 126 </span> :
<span class="lineNum"> 127 </span> : #if WORDS_BIGENDIAN
<span class="lineNum"> 128 </span> : h9 = util_swap64(h9);
<span class="lineNum"> 129 </span> : h10 = util_swap64(h10);
<span class="lineNum"> 130 </span> : #endif
<span class="lineNum"> 131 </span> :
<span class="lineNum"> 132 </span><span class="lineCov"> 3860981 : h0 = h3 = h6 = h9;</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 3860981 : h1 = h4 = h7 = h10;</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 3860981 : h2 = h5 = h8 = h11 = sc_const;</span>
<span class="lineNum"> 132 </span><span class="lineCov"> 3861869 : h0 = h3 = h6 = h9;</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 3861869 : h1 = h4 = h7 = h10;</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 3861869 : h2 = h5 = h8 = h11 = sc_const;</span>
<span class="lineNum"> 135 </span> :
<span class="lineNum"> 136 </span><span class="lineCov"> 3860981 : nblocks = size / sc_blockSize;</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 3860981 : blocks = data;</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 3860981 : end = blocks + nblocks * sc_numVars;</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 3861869 : nblocks = size / sc_blockSize;</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 3861869 : blocks = data;</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 3861869 : end = blocks + nblocks * sc_numVars;</span>
<span class="lineNum"> 139 </span> :
<span class="lineNum"> 140 </span> : /* body */
<span class="lineNum"> 141 </span><span class="lineCov"> 38823778 : while (blocks &lt; end) {</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 38833261 : while (blocks &lt; end) {</span>
<span class="lineNum"> 142 </span> : #if WORDS_BIGENDIAN
<span class="lineNum"> 143 </span> : for (i = 0; i &lt; sc_numVars; ++i)
<span class="lineNum"> 144 </span> : buf[i] = util_swap64(blocks[i]);
<span class="lineNum"> 145 </span> : Mix(buf, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);
<span class="lineNum"> 146 </span> : #else
<span class="lineNum"> 147 </span><span class="lineCov"> 31101816 : Mix(blocks, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 31109523 : Mix(blocks, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);</span>
<span class="lineNum"> 148 </span> : #endif
<span class="lineNum"> 149 </span><span class="lineCov"> 31101816 : blocks += sc_numVars;</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 31109523 : blocks += sc_numVars;</span>
<span class="lineNum"> 150 </span> : }
<span class="lineNum"> 151 </span> :
<span class="lineNum"> 152 </span> : /* tail */
<span class="lineNum"> 153 </span><span class="lineCov"> 3860981 : size_remainder = (size - ((const uint8_t*)end - (const uint8_t*)data));</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 3860981 : memcpy(buf, end, size_remainder);</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 3860981 : memset(((uint8_t*)buf) + size_remainder, 0, sc_blockSize - size_remainder);</span>
<span class="lineNum"> 156 </span><span class="lineCov"> 3860981 : ((uint8_t*)buf)[sc_blockSize - 1] = size_remainder;</span>
<span class="lineNum"> 153 </span><span class="lineCov"> 3861869 : size_remainder = (size - ((const uint8_t*)end - (const uint8_t*)data));</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 3861869 : memcpy(buf, end, size_remainder);</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 3861869 : memset(((uint8_t*)buf) + size_remainder, 0, sc_blockSize - size_remainder);</span>
<span class="lineNum"> 156 </span><span class="lineCov"> 3861869 : ((uint8_t*)buf)[sc_blockSize - 1] = size_remainder;</span>
<span class="lineNum"> 157 </span> :
<span class="lineNum"> 158 </span> : /* finalization */
<span class="lineNum"> 159 </span> : #if WORDS_BIGENDIAN
@ -223,16 +223,16 @@
<span class="lineNum"> 161 </span> : buf[i] = util_swap64(buf[i]);
<span class="lineNum"> 162 </span> : #endif
<span class="lineNum"> 163 </span> :
<span class="lineNum"> 164 </span><span class="lineCov"> 3860981 : End(buf, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);</span>
<span class="lineNum"> 164 </span><span class="lineCov"> 3861869 : End(buf, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11);</span>
<span class="lineNum"> 165 </span> :
<span class="lineNum"> 166 </span> : #if WORDS_BIGENDIAN
<span class="lineNum"> 167 </span> : h0 = util_swap64(h0);
<span class="lineNum"> 168 </span> : h1 = util_swap64(h1);
<span class="lineNum"> 169 </span> : #endif
<span class="lineNum"> 170 </span> :
<span class="lineNum"> 171 </span><span class="lineCov"> 3860981 : ((uint64_t*)digest)[0] = h0;</span>
<span class="lineNum"> 172 </span><span class="lineCov"> 3860981 : ((uint64_t*)digest)[1] = h1;</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 3860981 : }</span>
<span class="lineNum"> 171 </span><span class="lineCov"> 3861869 : ((uint64_t*)digest)[0] = h0;</span>
<span class="lineNum"> 172 </span><span class="lineCov"> 3861869 : ((uint64_t*)digest)[1] = h1;</span>
<span class="lineNum"> 173 </span><span class="lineCov"> 3861869 : }</span>
<span class="lineNum"> 174 </span> :
</pre>
</td>

42
cov/cmdline/state.c.func-sort-c.html
View file

@ -65,27 +65,27 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1646">fs_info_is_required</a></td>
<td class="coverFnHi">1547811</td>
<td class="coverFnHi">1547867</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4334">state_progress</a></td>
<td class="coverFnHi">1073409</td>
<td class="coverFnHi">1073497</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4490">state_usage_misc</a></td>
<td class="coverFnHi">1063055</td>
<td class="coverFnHi">1063671</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4534">state_usage_disk</a></td>
<td class="coverFnHi">912357</td>
<td class="coverFnHi">912885</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4523">state_usage_hash</a></td>
<td class="coverFnHi">776808</td>
<td class="coverFnHi">777357</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4554">state_usage_parity</a></td>
<td class="coverFnHi">774023</td>
<td class="coverFnHi">774551</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1617">fs_position_is_required</a></td>
@ -93,23 +93,23 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#64">lev_config_name</a></td>
<td class="coverFnHi">186548</td>
<td class="coverFnHi">186570</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4501">state_usage_sched</a></td>
<td class="coverFnHi">149836</td>
<td class="coverFnHi">149924</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4512">state_usage_raid</a></td>
<td class="coverFnHi">140365</td>
<td class="coverFnHi">140438</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1251">find_disk_by_name</a></td>
<td class="coverFnHi">7021</td>
<td class="coverFnHi">7037</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#78">lev_config_scan</a></td>
<td class="coverFnHi">6301</td>
<td class="coverFnHi">6318</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#3789">state_verify_thread</a></td>
@ -117,11 +117,11 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4580">state_fscheck</a></td>
<td class="coverFnHi">496</td>
<td class="coverFnHi">498</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4168">state_progress_latest</a></td>
<td class="coverFnHi">495</td>
<td class="coverFnHi">477</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#494">validate_smartctl</a></td>
@ -129,35 +129,35 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#137">state_init</a></td>
<td class="coverFnHi">265</td>
<td class="coverFnHi">266</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#519">state_config</a></td>
<td class="coverFnHi">264</td>
<td class="coverFnHi">265</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#120">lev_raid_name</a></td>
<td class="coverFnHi">263</td>
<td class="coverFnHi">264</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#207">state_config_check</a></td>
<td class="coverFnHi">263</td>
<td class="coverFnHi">264</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#3628">state_read</a></td>
<td class="coverFnHi">259</td>
<td class="coverFnHi">260</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1311">state_map</a></td>
<td class="coverFnHi">258</td>
<td class="coverFnHi">259</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1742">state_read_content</a></td>
<td class="coverFnHi">252</td>
<td class="coverFnHi">253</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1586">state_content_check</a></td>
<td class="coverFnHi">251</td>
<td class="coverFnHi">252</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#190">state_done</a></td>

46
cov/cmdline/state.c.func.html
View file

@ -65,7 +65,7 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1251">find_disk_by_name</a></td>
<td class="coverFnHi">7021</td>
<td class="coverFnHi">7037</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1278">find_disk_by_uuid</a></td>
@ -73,7 +73,7 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1646">fs_info_is_required</a></td>
<td class="coverFnHi">1547811</td>
<td class="coverFnHi">1547867</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1683">fs_is_block_deleted</a></td>
@ -93,11 +93,11 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#64">lev_config_name</a></td>
<td class="coverFnHi">186548</td>
<td class="coverFnHi">186570</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#78">lev_config_scan</a></td>
<td class="coverFnHi">6301</td>
<td class="coverFnHi">6318</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#50">lev_name</a></td>
@ -105,19 +105,19 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#120">lev_raid_name</a></td>
<td class="coverFnHi">263</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#519">state_config</a></td>
<td class="coverFnHi">264</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#519">state_config</a></td>
<td class="coverFnHi">265</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#207">state_config_check</a></td>
<td class="coverFnHi">263</td>
<td class="coverFnHi">264</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1586">state_content_check</a></td>
<td class="coverFnHi">251</td>
<td class="coverFnHi">252</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#190">state_done</a></td>
@ -129,19 +129,19 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4580">state_fscheck</a></td>
<td class="coverFnHi">496</td>
<td class="coverFnHi">498</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#137">state_init</a></td>
<td class="coverFnHi">265</td>
<td class="coverFnHi">266</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1311">state_map</a></td>
<td class="coverFnHi">258</td>
<td class="coverFnHi">259</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4334">state_progress</a></td>
<td class="coverFnHi">1073409</td>
<td class="coverFnHi">1073497</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4078">state_progress_begin</a></td>
@ -157,7 +157,7 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4168">state_progress_latest</a></td>
<td class="coverFnHi">495</td>
<td class="coverFnHi">477</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4149">state_progress_restart</a></td>
@ -169,11 +169,11 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#3628">state_read</a></td>
<td class="coverFnHi">259</td>
<td class="coverFnHi">260</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1742">state_read_content</a></td>
<td class="coverFnHi">252</td>
<td class="coverFnHi">253</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#1516">state_refresh</a></td>
@ -189,19 +189,19 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4534">state_usage_disk</a></td>
<td class="coverFnHi">912357</td>
<td class="coverFnHi">912885</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4523">state_usage_hash</a></td>
<td class="coverFnHi">776808</td>
<td class="coverFnHi">777357</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4490">state_usage_misc</a></td>
<td class="coverFnHi">1063055</td>
<td class="coverFnHi">1063671</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4554">state_usage_parity</a></td>
<td class="coverFnHi">774023</td>
<td class="coverFnHi">774551</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4568">state_usage_print</a></td>
@ -209,11 +209,11 @@
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4512">state_usage_raid</a></td>
<td class="coverFnHi">140365</td>
<td class="coverFnHi">140438</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4501">state_usage_sched</a></td>
<td class="coverFnHi">149836</td>
<td class="coverFnHi">149924</td>
</tr>
<tr>
<td class="coverFn"><a href="state.c.gcov.html#4483">state_usage_waste</a></td>

1402
cov/cmdline/state.c.gcov.html
View file

File diff suppressed because it is too large Load diff

48
cov/cmdline/status.c.gcov.html
View file

@ -395,10 +395,10 @@
<span class="lineNum"> 333 </span><span class="lineCov"> 39752 : scrub_time = info_get_time(info);</span>
<span class="lineNum"> 334 </span> :
<span class="lineNum"> 335 </span><span class="lineCov"> 39752 : if (info_get_justsynced(info)) {</span>
<span class="lineNum"> 336 </span><span class="lineCov"> 20453 : ++unscrubbed_blocks;</span>
<span class="lineNum"> 336 </span><span class="lineCov"> 20456 : ++unscrubbed_blocks;</span>
<span class="lineNum"> 337 </span> :
<span class="lineNum"> 338 </span> : /* mark the time as not scrubbed */
<span class="lineNum"> 339 </span><span class="lineCov"> 20453 : scrub_time |= TIME_NEW;</span>
<span class="lineNum"> 339 </span><span class="lineCov"> 20456 : scrub_time |= TIME_NEW;</span>
<span class="lineNum"> 340 </span> : }
<span class="lineNum"> 341 </span> :
<span class="lineNum"> 342 </span><span class="lineCov"> 39752 : timemap[count++] = scrub_time;</span>
@ -430,16 +430,16 @@
<span class="lineNum"> 368 </span> : /* output the info map */
<span class="lineNum"> 369 </span><span class="lineCov"> 8 : i = 0;</span>
<span class="lineNum"> 370 </span><span class="lineCov"> 8 : log_tag(&quot;info_count:%u\n&quot;, count);</span>
<span class="lineNum"> 371 </span><span class="lineCov"> 35 : while (i &lt; count) {</span>
<span class="lineNum"> 372 </span><span class="lineCov"> 19 : unsigned j = i + 1;</span>
<span class="lineNum"> 373 </span><span class="lineCov"> 39771 : while (j &lt; count &amp;&amp; timemap[i] == timemap[j])</span>
<span class="lineNum"> 374 </span><span class="lineCov"> 39733 : ++j;</span>
<span class="lineNum"> 375 </span><span class="lineCov"> 19 : if ((timemap[i] &amp; TIME_NEW) == 0) {</span>
<span class="lineNum"> 371 </span><span class="lineCov"> 33 : while (i &lt; count) {</span>
<span class="lineNum"> 372 </span><span class="lineCov"> 17 : unsigned j = i + 1;</span>
<span class="lineNum"> 373 </span><span class="lineCov"> 39769 : while (j &lt; count &amp;&amp; timemap[i] == timemap[j])</span>
<span class="lineNum"> 374 </span><span class="lineCov"> 39735 : ++j;</span>
<span class="lineNum"> 375 </span><span class="lineCov"> 17 : if ((timemap[i] &amp; TIME_NEW) == 0) {</span>
<span class="lineNum"> 376 </span><span class="lineCov"> 7 : log_tag(&quot;info_time:%&quot; PRIu64 &quot;:%u:scrubbed\n&quot;, (uint64_t)timemap[i], j - i);</span>
<span class="lineNum"> 377 </span> : } else {
<span class="lineNum"> 378 </span><span class="lineCov"> 12 : log_tag(&quot;info_time:%&quot; PRIu64 &quot;:%u:new\n&quot;, (uint64_t)(timemap[i] &amp; ~TIME_NEW), j - i);</span>
<span class="lineNum"> 378 </span><span class="lineCov"> 10 : log_tag(&quot;info_time:%&quot; PRIu64 &quot;:%u:new\n&quot;, (uint64_t)(timemap[i] &amp; ~TIME_NEW), j - i);</span>
<span class="lineNum"> 379 </span> : }
<span class="lineNum"> 380 </span><span class="lineCov"> 19 : i = j;</span>
<span class="lineNum"> 380 </span><span class="lineCov"> 17 : i = j;</span>
<span class="lineNum"> 381 </span> : }
<span class="lineNum"> 382 </span> :
<span class="lineNum"> 383 </span><span class="lineCov"> 8 : oldest = timemap[0];</span>
@ -462,9 +462,9 @@
<span class="lineNum"> 400 </span><span class="lineCov"> 560 : step_new = 0;</span>
<span class="lineNum"> 401 </span><span class="lineCov"> 40872 : while (barpos &lt; count &amp;&amp; timemap[barpos] &lt;= limit) {</span>
<span class="lineNum"> 402 </span><span class="lineCov"> 39752 : if ((timemap[barpos] &amp; TIME_NEW) != 0)</span>
<span class="lineNum"> 403 </span><span class="lineCov"> 20453 : ++step_new;</span>
<span class="lineNum"> 403 </span><span class="lineCov"> 20456 : ++step_new;</span>
<span class="lineNum"> 404 </span> : else
<span class="lineNum"> 405 </span><span class="lineCov"> 19299 : ++step_scrubbed;</span>
<span class="lineNum"> 405 </span><span class="lineCov"> 19296 : ++step_scrubbed;</span>
<span class="lineNum"> 406 </span><span class="lineCov"> 39752 : ++barpos;</span>
<span class="lineNum"> 407 </span> : }
<span class="lineNum"> 408 </span> :
@ -494,20 +494,20 @@
<span class="lineNum"> 432 </span><span class="lineCov"> 8400 : unsigned scrubbed = bar_scrubbed[x];</span>
<span class="lineNum"> 433 </span> :
<span class="lineNum"> 434 </span><span class="lineCov"> 8400 : if (both &gt; pivot_upper) {</span>
<span class="lineNum"> 435 </span><span class="lineCov"> 145 : if (scrubbed &gt; pivot_lower)</span>
<span class="lineNum"> 435 </span><span class="lineCov"> 144 : if (scrubbed &gt; pivot_lower)</span>
<span class="lineNum"> 436 </span><span class="lineCov"> 63 : printf(&quot;*&quot;);</span>
<span class="lineNum"> 437 </span> : else
<span class="lineNum"> 438 </span><span class="lineCov"> 82 : printf(&quot;o&quot;);</span>
<span class="lineNum"> 439 </span><span class="lineCov"> 8255 : } else if (both &gt; pivot_lower) {</span>
<span class="lineNum"> 440 </span><span class="lineCov"> 19 : if (scrubbed == both)</span>
<span class="lineNum"> 438 </span><span class="lineCov"> 81 : printf(&quot;o&quot;);</span>
<span class="lineNum"> 439 </span><span class="lineCov"> 8256 : } else if (both &gt; pivot_lower) {</span>
<span class="lineNum"> 440 </span><span class="lineCov"> 17 : if (scrubbed == both)</span>
<span class="lineNum"> 441 </span><span class="lineCov"> 7 : printf(&quot;*&quot;);</span>
<span class="lineNum"> 442 </span> : else
<span class="lineNum"> 443 </span><span class="lineCov"> 12 : printf(&quot;o&quot;);</span>
<span class="lineNum"> 443 </span><span class="lineCov"> 10 : printf(&quot;o&quot;);</span>
<span class="lineNum"> 444 </span> : } else {
<span class="lineNum"> 445 </span><span class="lineCov"> 8236 : if (y == GRAPH_ROW - 1)</span>
<span class="lineNum"> 446 </span><span class="lineCov"> 541 : printf(&quot;_&quot;);</span>
<span class="lineNum"> 445 </span><span class="lineCov"> 8239 : if (y == GRAPH_ROW - 1)</span>
<span class="lineNum"> 446 </span><span class="lineCov"> 543 : printf(&quot;_&quot;);</span>
<span class="lineNum"> 447 </span> : else
<span class="lineNum"> 448 </span><span class="lineCov"> 7695 : printf(&quot; &quot;);</span>
<span class="lineNum"> 448 </span><span class="lineCov"> 7696 : printf(&quot; &quot;);</span>
<span class="lineNum"> 449 </span> : }
<span class="lineNum"> 450 </span> : }
<span class="lineNum"> 451 </span><span class="lineCov"> 120 : printf(&quot;\n&quot;);</span>
@ -559,19 +559,19 @@
<span class="lineNum"> 497 </span> :
<span class="lineNum"> 498 </span> : /* print some of the errors */
<span class="lineNum"> 499 </span><span class="lineCov"> 2 : bad_print = 0;</span>
<span class="lineNum"> 500 </span><span class="lineCov"> 720 : for (i = 0; i &lt; blockmax; ++i) {</span>
<span class="lineNum"> 501 </span><span class="lineCov"> 720 : snapraid_info info = info_get(&amp;state-&gt;infoarr, i);</span>
<span class="lineNum"> 500 </span><span class="lineCov"> 723 : for (i = 0; i &lt; blockmax; ++i) {</span>
<span class="lineNum"> 501 </span><span class="lineCov"> 723 : snapraid_info info = info_get(&amp;state-&gt;infoarr, i);</span>
<span class="lineNum"> 502 </span> :
<span class="lineNum"> 503 </span> : /* skip unused blocks */
<span class="lineNum"> 504 </span><span class="lineCov"> 720 : if (info == 0)</span>
<span class="lineNum"> 504 </span><span class="lineCov"> 723 : if (info == 0)</span>
<span class="lineNum"> 505 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 506 </span> :
<span class="lineNum"> 507 </span><span class="lineCov"> 720 : if (info_get_bad(info)) {</span>
<span class="lineNum"> 507 </span><span class="lineCov"> 723 : if (info_get_bad(info)) {</span>
<span class="lineNum"> 508 </span><span class="lineCov"> 202 : printf(&quot; %u&quot;, i);</span>
<span class="lineNum"> 509 </span><span class="lineCov"> 202 : ++bad_print;</span>
<span class="lineNum"> 510 </span> : }
<span class="lineNum"> 511 </span> :
<span class="lineNum"> 512 </span><span class="lineCov"> 720 : if (bad_print &gt; 100) {</span>
<span class="lineNum"> 512 </span><span class="lineCov"> 723 : if (bad_print &gt; 100) {</span>
<span class="lineNum"> 513 </span><span class="lineCov"> 2 : printf(&quot; and %u more...&quot;, bad - bad_print);</span>
<span class="lineNum"> 514 </span><span class="lineCov"> 2 : break;</span>
<span class="lineNum"> 515 </span> : }

36
cov/cmdline/stream.c.func-sort-c.html
View file

@ -61,23 +61,23 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#633">swrite</a></td>
<td class="coverFnHi">20725275</td>
<td class="coverFnHi">20724964</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#525">sgetb32</a></td>
<td class="coverFnHi">18668535</td>
<td class="coverFnHi">18667054</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#384">sread</a></td>
<td class="coverFnHi">12810720</td>
<td class="coverFnHi">12810372</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#561">sgetb64</a></td>
<td class="coverFnHi">10849874</td>
<td class="coverFnHi">10849502</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#670">sputb32</a></td>
<td class="coverFnHi">9127648</td>
<td class="coverFnHi">9127337</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#691">sputb64</a></td>
@ -85,7 +85,7 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#612">sgetbs</a></td>
<td class="coverFnHi">3877236</td>
<td class="coverFnHi">3877163</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#724">sputbs</a></td>
@ -93,11 +93,11 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#202">sfill</a></td>
<td class="coverFnHi">607111</td>
<td class="coverFnHi">607122</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#339">sgetc_uncached</a></td>
<td class="coverFnHi">298847</td>
<td class="coverFnHi">298855</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#277">sflush</a></td>
@ -105,31 +105,31 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#347">sgettok</a></td>
<td class="coverFnHi">8138</td>
<td class="coverFnHi">8162</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#415">sgetline</a></td>
<td class="coverFnHi">5410</td>
<td class="coverFnHi">5425</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#477">sgetlasttok</a></td>
<td class="coverFnHi">5370</td>
<td class="coverFnHi">5384</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#153">sclose</a></td>
<td class="coverFnHi">1949</td>
<td class="coverFnHi">1951</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#27">sopen_read</a></td>
<td class="coverFnHi">1834</td>
<td class="coverFnHi">1836</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#329">scrc</a></td>
<td class="coverFnHi">1687</td>
<td class="coverFnHi">1688</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#239">sdeplete</a></td>
<td class="coverFnHi">1142</td>
<td class="coverFnHi">1144</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#104">sopen_multi_file</a></td>
@ -137,15 +137,15 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#597">sgetble32</a></td>
<td class="coverFnHi">379</td>
<td class="coverFnHi">380</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#496">sgetu32</a></td>
<td class="coverFnHi">264</td>
<td class="coverFnHi">265</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#187">shandle</a></td>
<td class="coverFnHi">252</td>
<td class="coverFnHi">253</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#334">scrc_stream</a></td>

36
cov/cmdline/stream.c.func.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#153">sclose</a></td>
<td class="coverFnHi">1949</td>
<td class="coverFnHi">1951</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#329">scrc</a></td>
<td class="coverFnHi">1687</td>
<td class="coverFnHi">1688</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#334">scrc_stream</a></td>
@ -73,11 +73,11 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#239">sdeplete</a></td>
<td class="coverFnHi">1142</td>
<td class="coverFnHi">1144</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#202">sfill</a></td>
<td class="coverFnHi">607111</td>
<td class="coverFnHi">607122</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#277">sflush</a></td>
@ -85,43 +85,43 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#525">sgetb32</a></td>
<td class="coverFnHi">18668535</td>
<td class="coverFnHi">18667054</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#561">sgetb64</a></td>
<td class="coverFnHi">10849874</td>
<td class="coverFnHi">10849502</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#597">sgetble32</a></td>
<td class="coverFnHi">379</td>
<td class="coverFnHi">380</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#612">sgetbs</a></td>
<td class="coverFnHi">3877236</td>
<td class="coverFnHi">3877163</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#339">sgetc_uncached</a></td>
<td class="coverFnHi">298847</td>
<td class="coverFnHi">298855</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#477">sgetlasttok</a></td>
<td class="coverFnHi">5370</td>
<td class="coverFnHi">5384</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#415">sgetline</a></td>
<td class="coverFnHi">5410</td>
<td class="coverFnHi">5425</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#347">sgettok</a></td>
<td class="coverFnHi">8138</td>
<td class="coverFnHi">8162</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#496">sgetu32</a></td>
<td class="coverFnHi">264</td>
<td class="coverFnHi">265</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#187">shandle</a></td>
<td class="coverFnHi">252</td>
<td class="coverFnHi">253</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#104">sopen_multi_file</a></td>
@ -133,7 +133,7 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#27">sopen_read</a></td>
<td class="coverFnHi">1834</td>
<td class="coverFnHi">1836</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#141">sopen_write</a></td>
@ -141,7 +141,7 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#670">sputb32</a></td>
<td class="coverFnHi">9127648</td>
<td class="coverFnHi">9127337</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#691">sputb64</a></td>
@ -157,7 +157,7 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#384">sread</a></td>
<td class="coverFnHi">12810720</td>
<td class="coverFnHi">12810372</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#738">ssync</a></td>
@ -169,7 +169,7 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.c.gcov.html#633">swrite</a></td>
<td class="coverFnHi">20725275</td>
<td class="coverFnHi">20724964</td>
</tr>
</table>
<br>

370
cov/cmdline/stream.c.gcov.html
View file

@ -88,19 +88,19 @@
<span class="lineNum"> 26 </span> :
<a name="27"><span class="lineNum"> 27 </span> : unsigned STREAM_SIZE = 64 * 1024;</a>
<span class="lineNum"> 28 </span> :
<span class="lineNum"> 29 </span><span class="lineCov"> 1834 : STREAM* sopen_read(const char* file)</span>
<span class="lineNum"> 29 </span><span class="lineCov"> 1836 : STREAM* sopen_read(const char* file)</span>
<span class="lineNum"> 30 </span> : {
<span class="lineNum"> 31 </span> : #if HAVE_POSIX_FADVISE
<span class="lineNum"> 32 </span> : int ret;
<span class="lineNum"> 33 </span> : #endif
<span class="lineNum"> 34 </span><span class="lineCov"> 1834 : STREAM* s = malloc_nofail(sizeof(STREAM));</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 1836 : STREAM* s = malloc_nofail(sizeof(STREAM));</span>
<span class="lineNum"> 35 </span> :
<span class="lineNum"> 36 </span><span class="lineCov"> 1834 : s-&gt;handle_size = 1;</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 1834 : s-&gt;handle = malloc_nofail(sizeof(struct stream_handle));</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 1836 : s-&gt;handle_size = 1;</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 1836 : s-&gt;handle = malloc_nofail(sizeof(struct stream_handle));</span>
<span class="lineNum"> 38 </span> :
<span class="lineNum"> 39 </span><span class="lineCov"> 1834 : pathcpy(s-&gt;handle[0].path, sizeof(s-&gt;handle[0].path), file);</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 1834 : s-&gt;handle[0].f = open(file, O_RDONLY | O_BINARY | O_SEQUENTIAL);</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 1834 : if (s-&gt;handle[0].f == -1) {</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 1836 : pathcpy(s-&gt;handle[0].path, sizeof(s-&gt;handle[0].path), file);</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 1836 : s-&gt;handle[0].f = open(file, O_RDONLY | O_BINARY | O_SEQUENTIAL);</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 1836 : if (s-&gt;handle[0].f == -1) {</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 50 : free(s-&gt;handle);</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 50 : free(s);</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 50 : return 0;</span>
@ -108,13 +108,13 @@
<span class="lineNum"> 46 </span> :
<span class="lineNum"> 47 </span> : #if HAVE_POSIX_FADVISE
<span class="lineNum"> 48 </span> : /* advise sequential access */
<span class="lineNum"> 49 </span><span class="lineCov"> 1784 : ret = posix_fadvise(s-&gt;handle[0].f, 0, 0, POSIX_FADV_SEQUENTIAL);</span>
<span class="lineNum"> 50 </span><span class="lineCov"> 1784 : if (ret == ENOSYS) {</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 1786 : ret = posix_fadvise(s-&gt;handle[0].f, 0, 0, POSIX_FADV_SEQUENTIAL);</span>
<span class="lineNum"> 50 </span><span class="lineCov"> 1786 : if (ret == ENOSYS) {</span>
<span class="lineNum"> 51 </span><span class="lineNoCov"> 0 : log_fatal(&quot;WARNING! fadvise() is not supported in this platform. Performance may not be optimal!\n&quot;);</span>
<span class="lineNum"> 52 </span> : /* call is not supported, like in armhf, see posix_fadvise manpage */
<span class="lineNum"> 53 </span><span class="lineNoCov"> 0 : ret = 0;</span>
<span class="lineNum"> 54 </span> : }
<span class="lineNum"> 55 </span><span class="lineCov"> 1784 : if (ret != 0) {</span>
<span class="lineNum"> 55 </span><span class="lineCov"> 1786 : if (ret != 0) {</span>
<span class="lineNum"> 56 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 57 </span> : close(s-&gt;handle[0].f);
<span class="lineNum"> 58 </span> : free(s-&gt;handle);
@ -125,18 +125,18 @@
<span class="lineNum"> 63 </span> : }
<span class="lineNum"> 64 </span> : #endif
<span class="lineNum"> 65 </span> :
<span class="lineNum"> 66 </span><span class="lineCov"> 1784 : s-&gt;buffer = malloc_nofail_test(STREAM_SIZE);</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 1784 : s-&gt;pos = s-&gt;buffer;</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 1784 : s-&gt;end = s-&gt;buffer;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 1784 : s-&gt;state = STREAM_STATE_READ;</span>
<span class="lineNum"> 70 </span><span class="lineCov"> 1784 : s-&gt;state_index = 0;</span>
<span class="lineNum"> 71 </span><span class="lineCov"> 1784 : s-&gt;offset = 0;</span>
<span class="lineNum"> 72 </span><span class="lineCov"> 1784 : s-&gt;offset_uncached = 0;</span>
<span class="lineNum"> 73 </span><span class="lineCov"> 1784 : s-&gt;crc = 0;</span>
<span class="lineNum"> 74 </span><span class="lineCov"> 1784 : s-&gt;crc_uncached = 0;</span>
<span class="lineNum"> 75 </span><span class="lineCov"> 1784 : s-&gt;crc_stream = CRC_IV;</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 1786 : s-&gt;buffer = malloc_nofail_test(STREAM_SIZE);</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 1786 : s-&gt;pos = s-&gt;buffer;</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 1786 : s-&gt;end = s-&gt;buffer;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 1786 : s-&gt;state = STREAM_STATE_READ;</span>
<span class="lineNum"> 70 </span><span class="lineCov"> 1786 : s-&gt;state_index = 0;</span>
<span class="lineNum"> 71 </span><span class="lineCov"> 1786 : s-&gt;offset = 0;</span>
<span class="lineNum"> 72 </span><span class="lineCov"> 1786 : s-&gt;offset_uncached = 0;</span>
<span class="lineNum"> 73 </span><span class="lineCov"> 1786 : s-&gt;crc = 0;</span>
<span class="lineNum"> 74 </span><span class="lineCov"> 1786 : s-&gt;crc_uncached = 0;</span>
<span class="lineNum"> 75 </span><span class="lineCov"> 1786 : s-&gt;crc_stream = CRC_IV;</span>
<span class="lineNum"> 76 </span> :
<span class="lineNum"> 77 </span><span class="lineCov"> 1784 : return s;</span>
<span class="lineNum"> 77 </span><span class="lineCov"> 1786 : return s;</span>
<a name="78"><span class="lineNum"> 78 </span> : }</a>
<span class="lineNum"> 79 </span> :
<span class="lineNum"> 80 </span><span class="lineCov"> 167 : STREAM* sopen_multi_write(unsigned count)</span>
@ -214,12 +214,12 @@
<span class="lineNum"> 152 </span><span class="lineNoCov"> 0 : return s;</span>
<a name="153"><span class="lineNum"> 153 </span> : }</a>
<span class="lineNum"> 154 </span> :
<span class="lineNum"> 155 </span><span class="lineCov"> 1949 : int sclose(STREAM* s)</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 1951 : int sclose(STREAM* s)</span>
<span class="lineNum"> 156 </span> : {
<span class="lineNum"> 157 </span><span class="lineCov"> 1949 : int fail = 0;</span>
<span class="lineNum"> 157 </span><span class="lineCov"> 1951 : int fail = 0;</span>
<span class="lineNum"> 158 </span> : unsigned i;
<span class="lineNum"> 159 </span> :
<span class="lineNum"> 160 </span><span class="lineCov"> 1949 : if (s-&gt;state == STREAM_STATE_WRITE) {</span>
<span class="lineNum"> 160 </span><span class="lineCov"> 1951 : if (s-&gt;state == STREAM_STATE_WRITE) {</span>
<span class="lineNum"> 161 </span><span class="lineCov"> 167 : if (sflush(s) != 0) {</span>
<span class="lineNum"> 162 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 163 </span> : fail = 1;
@ -227,102 +227,102 @@
<span class="lineNum"> 165 </span> : }
<span class="lineNum"> 166 </span> : }
<span class="lineNum"> 167 </span> :
<span class="lineNum"> 168 </span><span class="lineCov"> 4871 : for (i = 0; i &lt; s-&gt;handle_size; ++i) {</span>
<span class="lineNum"> 169 </span><span class="lineCov"> 2922 : if (close(s-&gt;handle[i].f) != 0) {</span>
<span class="lineNum"> 168 </span><span class="lineCov"> 4875 : for (i = 0; i &lt; s-&gt;handle_size; ++i) {</span>
<span class="lineNum"> 169 </span><span class="lineCov"> 2924 : if (close(s-&gt;handle[i].f) != 0) {</span>
<span class="lineNum"> 170 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 171 </span> : fail = 1;
<span class="lineNum"> 172 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 173 </span> : }
<span class="lineNum"> 174 </span> : }
<span class="lineNum"> 175 </span> :
<span class="lineNum"> 176 </span><span class="lineCov"> 1949 : free(s-&gt;handle);</span>
<span class="lineNum"> 177 </span><span class="lineCov"> 1949 : free(s-&gt;buffer);</span>
<span class="lineNum"> 178 </span><span class="lineCov"> 1949 : free(s);</span>
<span class="lineNum"> 176 </span><span class="lineCov"> 1951 : free(s-&gt;handle);</span>
<span class="lineNum"> 177 </span><span class="lineCov"> 1951 : free(s-&gt;buffer);</span>
<span class="lineNum"> 178 </span><span class="lineCov"> 1951 : free(s);</span>
<span class="lineNum"> 179 </span> :
<span class="lineNum"> 180 </span><span class="lineCov"> 1949 : if (fail) {</span>
<span class="lineNum"> 180 </span><span class="lineCov"> 1951 : if (fail) {</span>
<span class="lineNum"> 181 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 182 </span> : return -1;
<span class="lineNum"> 183 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 184 </span> : }
<span class="lineNum"> 185 </span> :
<span class="lineNum"> 186 </span><span class="lineCov"> 1949 : return 0;</span>
<span class="lineNum"> 186 </span><span class="lineCov"> 1951 : return 0;</span>
<a name="187"><span class="lineNum"> 187 </span> : }</a>
<span class="lineNum"> 188 </span> :
<span class="lineNum"> 189 </span><span class="lineCov"> 252 : int shandle(STREAM* s)</span>
<span class="lineNum"> 189 </span><span class="lineCov"> 253 : int shandle(STREAM* s)</span>
<span class="lineNum"> 190 </span> : {
<span class="lineNum"> 191 </span><span class="lineCov"> 252 : if (!s-&gt;handle_size) {</span>
<span class="lineNum"> 191 </span><span class="lineCov"> 253 : if (!s-&gt;handle_size) {</span>
<span class="lineNum"> 192 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 193 </span> : return -1;
<span class="lineNum"> 194 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 195 </span> : }
<span class="lineNum"> 196 </span> :
<span class="lineNum"> 197 </span><span class="lineCov"> 252 : return s-&gt;handle[0].f;</span>
<span class="lineNum"> 197 </span><span class="lineCov"> 253 : return s-&gt;handle[0].f;</span>
<span class="lineNum"> 198 </span> : }
<span class="lineNum"> 199 </span> :
<span class="lineNum"> 200 </span> : /**
<span class="lineNum"> 201 </span> : * Fill the read stream buffer.
<a name="202"><span class="lineNum"> 202 </span> : * \return 0 if at least on char is read, or EOF on error.</a>
<span class="lineNum"> 203 </span> : */
<span class="lineNum"> 204 </span><span class="lineCov"> 607111 : static int sfill(STREAM* s)</span>
<span class="lineNum"> 204 </span><span class="lineCov"> 607122 : static int sfill(STREAM* s)</span>
<span class="lineNum"> 205 </span> : {
<span class="lineNum"> 206 </span> : ssize_t ret;
<span class="lineNum"> 207 </span> :
<span class="lineNum"> 208 </span><span class="lineCov"> 607111 : if (s-&gt;state != STREAM_STATE_READ) {</span>
<span class="lineNum"> 208 </span><span class="lineCov"> 607122 : if (s-&gt;state != STREAM_STATE_READ) {</span>
<span class="lineNum"> 209 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 210 </span> : return EOF;
<span class="lineNum"> 211 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 212 </span> : }
<span class="lineNum"> 213 </span> :
<span class="lineNum"> 214 </span><span class="lineCov"> 606059 : ret = read(s-&gt;handle[0].f, s-&gt;buffer, STREAM_SIZE);</span>
<span class="lineNum"> 214 </span><span class="lineCov"> 606066 : ret = read(s-&gt;handle[0].f, s-&gt;buffer, STREAM_SIZE);</span>
<span class="lineNum"> 215 </span> :
<span class="lineNum"> 216 </span><span class="lineCov"> 606062 : if (ret &lt; 0) {</span>
<span class="lineNum"> 216 </span><span class="lineCov"> 606066 : if (ret &lt; 0) {</span>
<span class="lineNum"> 217 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 218 </span> : s-&gt;state = STREAM_STATE_ERROR;
<span class="lineNum"> 219 </span> : return EOF;
<span class="lineNum"> 220 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 221 </span> : }
<span class="lineNum"> 222 </span><span class="lineCov"> 606062 : if (ret == 0) {</span>
<span class="lineNum"> 223 </span><span class="lineCov"> 1655 : s-&gt;state = STREAM_STATE_EOF;</span>
<span class="lineNum"> 224 </span><span class="lineCov"> 1655 : return EOF;</span>
<span class="lineNum"> 222 </span><span class="lineCov"> 606066 : if (ret == 0) {</span>
<span class="lineNum"> 223 </span><span class="lineCov"> 1657 : s-&gt;state = STREAM_STATE_EOF;</span>
<span class="lineNum"> 224 </span><span class="lineCov"> 1657 : return EOF;</span>
<span class="lineNum"> 225 </span> : }
<span class="lineNum"> 226 </span> :
<span class="lineNum"> 227 </span> : /* update the crc */
<span class="lineNum"> 228 </span><span class="lineCov"> 604407 : s-&gt;crc_uncached = s-&gt;crc;</span>
<span class="lineNum"> 229 </span><span class="lineCov"> 604407 : s-&gt;crc = crc32c(s-&gt;crc, s-&gt;buffer, ret);</span>
<span class="lineNum"> 228 </span><span class="lineCov"> 604409 : s-&gt;crc_uncached = s-&gt;crc;</span>
<span class="lineNum"> 229 </span><span class="lineCov"> 604409 : s-&gt;crc = crc32c(s-&gt;crc, s-&gt;buffer, ret);</span>
<span class="lineNum"> 230 </span> :
<span class="lineNum"> 231 </span> : /* update the offset */
<span class="lineNum"> 232 </span><span class="lineCov"> 604404 : s-&gt;offset_uncached = s-&gt;offset;</span>
<span class="lineNum"> 233 </span><span class="lineCov"> 604404 : s-&gt;offset += ret;</span>
<span class="lineNum"> 232 </span><span class="lineCov"> 604407 : s-&gt;offset_uncached = s-&gt;offset;</span>
<span class="lineNum"> 233 </span><span class="lineCov"> 604407 : s-&gt;offset += ret;</span>
<span class="lineNum"> 234 </span> :
<span class="lineNum"> 235 </span><span class="lineCov"> 604404 : s-&gt;pos = s-&gt;buffer;</span>
<span class="lineNum"> 236 </span><span class="lineCov"> 604404 : s-&gt;end = s-&gt;buffer + ret;</span>
<span class="lineNum"> 235 </span><span class="lineCov"> 604407 : s-&gt;pos = s-&gt;buffer;</span>
<span class="lineNum"> 236 </span><span class="lineCov"> 604407 : s-&gt;end = s-&gt;buffer + ret;</span>
<span class="lineNum"> 237 </span> :
<span class="lineNum"> 238 </span><span class="lineCov"> 604404 : return 0;</span>
<span class="lineNum"> 238 </span><span class="lineCov"> 604407 : return 0;</span>
<a name="239"><span class="lineNum"> 239 </span> : }</a>
<span class="lineNum"> 240 </span> :
<span class="lineNum"> 241 </span><span class="lineCov"> 1142 : int sdeplete(STREAM* s, unsigned char* last)</span>
<span class="lineNum"> 241 </span><span class="lineCov"> 1144 : int sdeplete(STREAM* s, unsigned char* last)</span>
<span class="lineNum"> 242 </span> : {
<span class="lineNum"> 243 </span> : /* last four bytes */
<span class="lineNum"> 244 </span><span class="lineCov"> 1142 : last[0] = 0;</span>
<span class="lineNum"> 245 </span><span class="lineCov"> 1142 : last[1] = 0;</span>
<span class="lineNum"> 246 </span><span class="lineCov"> 1142 : last[2] = 0;</span>
<span class="lineNum"> 247 </span><span class="lineCov"> 1142 : last[3] = 0;</span>
<span class="lineNum"> 244 </span><span class="lineCov"> 1144 : last[0] = 0;</span>
<span class="lineNum"> 245 </span><span class="lineCov"> 1144 : last[1] = 0;</span>
<span class="lineNum"> 246 </span><span class="lineCov"> 1144 : last[2] = 0;</span>
<span class="lineNum"> 247 </span><span class="lineCov"> 1144 : last[3] = 0;</span>
<span class="lineNum"> 248 </span> :
<span class="lineNum"> 249 </span> : while (1) {
<span class="lineNum"> 250 </span> : /* increase the position up to 4 bytes before the end */
<span class="lineNum"> 251 </span><span class="lineCov"> 308265 : if (s-&gt;pos + 4 &lt;= s-&gt;end)</span>
<span class="lineNum"> 251 </span><span class="lineCov"> 308267 : if (s-&gt;pos + 4 &lt;= s-&gt;end)</span>
<span class="lineNum"> 252 </span><span class="lineCov"> 148388 : s-&gt;pos = s-&gt;end - 4;</span>
<span class="lineNum"> 253 </span> :
<span class="lineNum"> 254 </span> : /* insert the last 4 bytes */
<span class="lineNum"> 255 </span><span class="lineCov"> 1469850 : while (s-&gt;pos &lt; s-&gt;end) {</span>
<span class="lineNum"> 256 </span><span class="lineCov"> 853320 : last[0] = last[1];</span>
<span class="lineNum"> 257 </span><span class="lineCov"> 853320 : last[1] = last[2];</span>
<span class="lineNum"> 258 </span><span class="lineCov"> 853320 : last[2] = last[3];</span>
<span class="lineNum"> 259 </span><span class="lineCov"> 853320 : last[3] = *s-&gt;pos++;</span>
<span class="lineNum"> 255 </span><span class="lineCov"> 1469851 : while (s-&gt;pos &lt; s-&gt;end) {</span>
<span class="lineNum"> 256 </span><span class="lineCov"> 853317 : last[0] = last[1];</span>
<span class="lineNum"> 257 </span><span class="lineCov"> 853317 : last[1] = last[2];</span>
<span class="lineNum"> 258 </span><span class="lineCov"> 853317 : last[2] = last[3];</span>
<span class="lineNum"> 259 </span><span class="lineCov"> 853317 : last[3] = *s-&gt;pos++;</span>
<span class="lineNum"> 260 </span> : }
<span class="lineNum"> 261 </span> :
<span class="lineNum"> 262 </span> : /* fill again the buffer until the end of the file */
<span class="lineNum"> 263 </span><span class="lineCov"> 308265 : if (sfill(s) != 0) {</span>
<span class="lineNum"> 263 </span><span class="lineCov"> 308267 : if (sfill(s) != 0) {</span>
<span class="lineNum"> 264 </span> : /* on error fail */
<span class="lineNum"> 265 </span><span class="lineCov"> 1141 : if (serror(s)) {</span>
<span class="lineNum"> 266 </span> : /* LCOV_EXCL_START */
@ -331,11 +331,11 @@
<span class="lineNum"> 269 </span> : }
<span class="lineNum"> 270 </span> :
<span class="lineNum"> 271 </span> : /* on EOF terminate */
<span class="lineNum"> 272 </span><span class="lineCov"> 1141 : break;</span>
<span class="lineNum"> 272 </span><span class="lineCov"> 1140 : break;</span>
<span class="lineNum"> 273 </span> : }
<span class="lineNum"> 274 </span><span class="lineCov"> 307123 : }</span>
<span class="lineNum"> 275 </span> :
<span class="lineNum"> 276 </span><span class="lineCov"> 1141 : return 0;</span>
<span class="lineNum"> 276 </span><span class="lineCov"> 1140 : return 0;</span>
<a name="277"><span class="lineNum"> 277 </span> : }</a>
<span class="lineNum"> 278 </span> :
<span class="lineNum"> 279 </span><span class="lineCov"> 39049 : int sflush(STREAM* s)</span>
@ -390,9 +390,9 @@
<span class="lineNum"> 328 </span><span class="lineCov"> 1 : return s-&gt;offset_uncached + (s-&gt;pos - s-&gt;buffer);</span>
<a name="329"><span class="lineNum"> 329 </span> : }</a>
<span class="lineNum"> 330 </span> :
<span class="lineNum"> 331 </span><span class="lineCov"> 1687 : uint32_t scrc(STREAM*s)</span>
<span class="lineNum"> 331 </span><span class="lineCov"> 1688 : uint32_t scrc(STREAM*s)</span>
<span class="lineNum"> 332 </span> : {
<span class="lineNum"> 333 </span><span class="lineCov"> 1687 : return crc32c(s-&gt;crc_uncached, s-&gt;buffer, s-&gt;pos - s-&gt;buffer);</span>
<span class="lineNum"> 333 </span><span class="lineCov"> 1688 : return crc32c(s-&gt;crc_uncached, s-&gt;buffer, s-&gt;pos - s-&gt;buffer);</span>
<a name="334"><span class="lineNum"> 334 </span> : }</a>
<span class="lineNum"> 335 </span> :
<span class="lineNum"> 336 </span><span class="lineCov"> 167 : uint32_t scrc_stream(STREAM*s)</span>
@ -400,90 +400,90 @@
<span class="lineNum"> 338 </span><span class="lineCov"> 167 : return s-&gt;crc_stream ^ CRC_IV;</span>
<a name="339"><span class="lineNum"> 339 </span> : }</a>
<span class="lineNum"> 340 </span> :
<span class="lineNum"> 341 </span><span class="lineCov"> 298847 : int sgetc_uncached(STREAM* s)</span>
<span class="lineNum"> 341 </span><span class="lineCov"> 298855 : int sgetc_uncached(STREAM* s)</span>
<span class="lineNum"> 342 </span> : {
<span class="lineNum"> 343 </span> : /* if at the end of the buffer, fill it */
<span class="lineNum"> 344 </span><span class="lineCov"> 298847 : if (s-&gt;pos == s-&gt;end &amp;&amp; sfill(s) != 0)</span>
<span class="lineNum"> 345 </span><span class="lineCov"> 1566 : return EOF;</span>
<span class="lineNum"> 346 </span><span class="lineCov"> 297281 : return *s-&gt;pos++;</span>
<span class="lineNum"> 344 </span><span class="lineCov"> 298855 : if (s-&gt;pos == s-&gt;end &amp;&amp; sfill(s) != 0)</span>
<span class="lineNum"> 345 </span><span class="lineCov"> 1572 : return EOF;</span>
<span class="lineNum"> 346 </span><span class="lineCov"> 297283 : return *s-&gt;pos++;</span>
<a name="347"><span class="lineNum"> 347 </span> : }</a>
<span class="lineNum"> 348 </span> :
<span class="lineNum"> 349 </span><span class="lineCov"> 8138 : int sgettok(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 349 </span><span class="lineCov"> 8162 : int sgettok(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 350 </span> : {
<span class="lineNum"> 351 </span><span class="lineCov"> 8138 : char* i = str;</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 8138 : char* send = str + size;</span>
<span class="lineNum"> 351 </span><span class="lineCov"> 8162 : char* i = str;</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 8162 : char* send = str + size;</span>
<span class="lineNum"> 353 </span> : int c;
<span class="lineNum"> 354 </span> :
<span class="lineNum"> 355 </span> : while (1) {
<span class="lineNum"> 356 </span><span class="lineCov"> 54240 : c = sgetc(f);</span>
<span class="lineNum"> 357 </span><span class="lineCov"> 54240 : if (c == EOF) {</span>
<span class="lineNum"> 358 </span><span class="lineCov"> 263 : break;</span>
<span class="lineNum"> 356 </span><span class="lineCov"> 54379 : c = sgetc(f);</span>
<span class="lineNum"> 357 </span><span class="lineCov"> 54379 : if (c == EOF) {</span>
<span class="lineNum"> 358 </span><span class="lineCov"> 264 : break;</span>
<span class="lineNum"> 359 </span> : }
<span class="lineNum"> 360 </span><span class="lineCov"> 53977 : if (c == ' ' || c == '\t') {</span>
<span class="lineNum"> 361 </span><span class="lineCov"> 7611 : sungetc(c, f);</span>
<span class="lineNum"> 362 </span><span class="lineCov"> 7611 : break;</span>
<span class="lineNum"> 360 </span><span class="lineCov"> 54115 : if (c == ' ' || c == '\t') {</span>
<span class="lineNum"> 361 </span><span class="lineCov"> 7633 : sungetc(c, f);</span>
<span class="lineNum"> 362 </span><span class="lineCov"> 7633 : break;</span>
<span class="lineNum"> 363 </span> : }
<span class="lineNum"> 364 </span><span class="lineCov"> 46366 : if (c == '\n') {</span>
<span class="lineNum"> 364 </span><span class="lineCov"> 46482 : if (c == '\n') {</span>
<span class="lineNum"> 365 </span> : /* remove ending carrige return to support the Windows CR+LF format */
<span class="lineNum"> 366 </span><span class="lineCov"> 264 : if (i != str &amp;&amp; i[-1] == '\r')</span>
<span class="lineNum"> 366 </span><span class="lineCov"> 265 : if (i != str &amp;&amp; i[-1] == '\r')</span>
<span class="lineNum"> 367 </span><span class="lineNoCov"> 0 : --i;</span>
<span class="lineNum"> 368 </span><span class="lineCov"> 264 : sungetc(c, f);</span>
<span class="lineNum"> 369 </span><span class="lineCov"> 264 : break;</span>
<span class="lineNum"> 368 </span><span class="lineCov"> 265 : sungetc(c, f);</span>
<span class="lineNum"> 369 </span><span class="lineCov"> 265 : break;</span>
<span class="lineNum"> 370 </span> : }
<span class="lineNum"> 371 </span> :
<span class="lineNum"> 372 </span><span class="lineCov"> 46102 : *i++ = c;</span>
<span class="lineNum"> 372 </span><span class="lineCov"> 46217 : *i++ = c;</span>
<span class="lineNum"> 373 </span> :
<span class="lineNum"> 374 </span><span class="lineCov"> 46102 : if (i == send) {</span>
<span class="lineNum"> 374 </span><span class="lineCov"> 46217 : if (i == send) {</span>
<span class="lineNum"> 375 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 376 </span> : return -1;
<span class="lineNum"> 377 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 378 </span> : }
<span class="lineNum"> 379 </span><span class="lineCov"> 46102 : }</span>
<span class="lineNum"> 379 </span><span class="lineCov"> 46217 : }</span>
<span class="lineNum"> 380 </span> :
<span class="lineNum"> 381 </span><span class="lineCov"> 8138 : *i = 0;</span>
<span class="lineNum"> 381 </span><span class="lineCov"> 8162 : *i = 0;</span>
<span class="lineNum"> 382 </span> :
<span class="lineNum"> 383 </span><span class="lineCov"> 8138 : return i - str;</span>
<span class="lineNum"> 383 </span><span class="lineCov"> 8162 : return i - str;</span>
<a name="384"><span class="lineNum"> 384 </span> : }</a>
<span class="lineNum"> 385 </span> :
<span class="lineNum"> 386 </span><span class="lineCov"> 12810720 : int sread(STREAM* f, void* void_data, unsigned size)</span>
<span class="lineNum"> 386 </span><span class="lineCov"> 12810372 : int sread(STREAM* f, void* void_data, unsigned size)</span>
<span class="lineNum"> 387 </span> : {
<span class="lineNum"> 388 </span><span class="lineCov"> 12810720 : unsigned char* data = void_data;</span>
<span class="lineNum"> 388 </span><span class="lineCov"> 12810372 : unsigned char* data = void_data;</span>
<span class="lineNum"> 389 </span> :
<span class="lineNum"> 390 </span> : /* if there is enough space in memory */
<span class="lineNum"> 391 </span><span class="lineCov"> 12810720 : if (sptrlookup(f, size)) {</span>
<span class="lineNum"> 391 </span><span class="lineCov"> 12810372 : if (sptrlookup(f, size)) {</span>
<span class="lineNum"> 392 </span> : /* optimized version with all the data in memory */
<span class="lineNum"> 393 </span><span class="lineCov"> 12784282 : unsigned char* pos = sptrget(f);</span>
<span class="lineNum"> 393 </span><span class="lineCov"> 12784238 : unsigned char* pos = sptrget(f);</span>
<span class="lineNum"> 394 </span> :
<span class="lineNum"> 395 </span> : /* copy it */
<span class="lineNum"> 396 </span><span class="lineCov"> 217726263 : while (size--)</span>
<span class="lineNum"> 397 </span><span class="lineCov"> 192157699 : *data++ = *pos++;</span>
<span class="lineNum"> 396 </span><span class="lineCov"> 217725604 : while (size--)</span>
<span class="lineNum"> 397 </span><span class="lineCov"> 192157128 : *data++ = *pos++;</span>
<span class="lineNum"> 398 </span> :
<span class="lineNum"> 399 </span><span class="lineCov"> 12784282 : sptrset(f, pos);</span>
<span class="lineNum"> 399 </span><span class="lineCov"> 12784238 : sptrset(f, pos);</span>
<span class="lineNum"> 400 </span> : } else {
<span class="lineNum"> 401 </span> : /* standard version using sgetc() */
<span class="lineNum"> 402 </span><span class="lineCov"> 1380323 : while (size--) {</span>
<span class="lineNum"> 403 </span><span class="lineCov"> 1327447 : int c = sgetc(f);</span>
<span class="lineNum"> 404 </span><span class="lineCov"> 1327447 : if (c == EOF) {</span>
<span class="lineNum"> 402 </span><span class="lineCov"> 1375577 : while (size--) {</span>
<span class="lineNum"> 403 </span><span class="lineCov"> 1323309 : int c = sgetc(f);</span>
<span class="lineNum"> 404 </span><span class="lineCov"> 1323309 : if (c == EOF) {</span>
<span class="lineNum"> 405 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 406 </span> : return -1;
<span class="lineNum"> 407 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 408 </span> : }
<span class="lineNum"> 409 </span> :
<span class="lineNum"> 410 </span><span class="lineCov"> 1327447 : *data++ = c;</span>
<span class="lineNum"> 410 </span><span class="lineCov"> 1323309 : *data++ = c;</span>
<span class="lineNum"> 411 </span> : }
<span class="lineNum"> 412 </span> : }
<span class="lineNum"> 413 </span> :
<span class="lineNum"> 414 </span><span class="lineCov"> 12810720 : return 0;</span>
<span class="lineNum"> 414 </span><span class="lineCov"> 12810372 : return 0;</span>
<a name="415"><span class="lineNum"> 415 </span> : }</a>
<span class="lineNum"> 416 </span> :
<span class="lineNum"> 417 </span><span class="lineCov"> 5410 : int sgetline(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 417 </span><span class="lineCov"> 5425 : int sgetline(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 418 </span> : {
<span class="lineNum"> 419 </span><span class="lineCov"> 5410 : char* i = str;</span>
<span class="lineNum"> 420 </span><span class="lineCov"> 5410 : char* send = str + size;</span>
<span class="lineNum"> 419 </span><span class="lineCov"> 5425 : char* i = str;</span>
<span class="lineNum"> 420 </span><span class="lineCov"> 5425 : char* send = str + size;</span>
<span class="lineNum"> 421 </span> : int c;
<span class="lineNum"> 422 </span> :
<span class="lineNum"> 423 </span> : /* if there is enough data in memory */
<span class="lineNum"> 424 </span><span class="lineCov"> 5410 : if (sptrlookup(f, size)) {</span>
<span class="lineNum"> 424 </span><span class="lineCov"> 5425 : if (sptrlookup(f, size)) {</span>
<span class="lineNum"> 425 </span> : /* optimized version with all the data in memory */
<span class="lineNum"> 426 </span><span class="lineNoCov"> 0 : unsigned char* pos = sptrget(f);</span>
<span class="lineNum"> 427 </span> :
@ -509,75 +509,75 @@
<span class="lineNum"> 447 </span><span class="lineNoCov"> 0 : sptrset(f, pos);</span>
<span class="lineNum"> 448 </span> : } else {
<span class="lineNum"> 449 </span> : while (1) {
<span class="lineNum"> 450 </span><span class="lineCov"> 139082 : c = sgetc(f);</span>
<span class="lineNum"> 451 </span><span class="lineCov"> 139082 : if (c == EOF) {</span>
<span class="lineNum"> 450 </span><span class="lineCov"> 139326 : c = sgetc(f);</span>
<span class="lineNum"> 451 </span><span class="lineCov"> 139326 : if (c == EOF) {</span>
<span class="lineNum"> 452 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 453 </span> : break;
<span class="lineNum"> 454 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 455 </span> : }
<span class="lineNum"> 456 </span><span class="lineCov"> 139082 : if (c == '\n') {</span>
<span class="lineNum"> 456 </span><span class="lineCov"> 139326 : if (c == '\n') {</span>
<span class="lineNum"> 457 </span> : /* remove ending carrige return to support the Windows CR+LF format */
<span class="lineNum"> 458 </span><span class="lineCov"> 5410 : if (i != str &amp;&amp; i[-1] == '\r')</span>
<span class="lineNum"> 458 </span><span class="lineCov"> 5425 : if (i != str &amp;&amp; i[-1] == '\r')</span>
<span class="lineNum"> 459 </span><span class="lineNoCov"> 0 : --i;</span>
<span class="lineNum"> 460 </span><span class="lineCov"> 5410 : sungetc(c, f);</span>
<span class="lineNum"> 461 </span><span class="lineCov"> 5410 : break;</span>
<span class="lineNum"> 460 </span><span class="lineCov"> 5425 : sungetc(c, f);</span>
<span class="lineNum"> 461 </span><span class="lineCov"> 5425 : break;</span>
<span class="lineNum"> 462 </span> : }
<span class="lineNum"> 463 </span> :
<span class="lineNum"> 464 </span><span class="lineCov"> 133672 : *i++ = c;</span>
<span class="lineNum"> 464 </span><span class="lineCov"> 133901 : *i++ = c;</span>
<span class="lineNum"> 465 </span> :
<span class="lineNum"> 466 </span><span class="lineCov"> 133672 : if (i == send) {</span>
<span class="lineNum"> 466 </span><span class="lineCov"> 133901 : if (i == send) {</span>
<span class="lineNum"> 467 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 468 </span> : return -1;
<span class="lineNum"> 469 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 470 </span> : }
<span class="lineNum"> 471 </span><span class="lineCov"> 133672 : }</span>
<span class="lineNum"> 471 </span><span class="lineCov"> 133901 : }</span>
<span class="lineNum"> 472 </span> : }
<span class="lineNum"> 473 </span> :
<span class="lineNum"> 474 </span><span class="lineCov"> 5410 : *i = 0;</span>
<span class="lineNum"> 474 </span><span class="lineCov"> 5425 : *i = 0;</span>
<span class="lineNum"> 475 </span> :
<span class="lineNum"> 476 </span><span class="lineCov"> 5410 : return i - str;</span>
<span class="lineNum"> 476 </span><span class="lineCov"> 5425 : return i - str;</span>
<a name="477"><span class="lineNum"> 477 </span> : }</a>
<span class="lineNum"> 478 </span> :
<span class="lineNum"> 479 </span><span class="lineCov"> 5370 : int sgetlasttok(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 479 </span><span class="lineCov"> 5384 : int sgetlasttok(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 480 </span> : {
<span class="lineNum"> 481 </span> : int ret;
<span class="lineNum"> 482 </span> :
<span class="lineNum"> 483 </span><span class="lineCov"> 5370 : ret = sgetline(f, str, size);</span>
<span class="lineNum"> 484 </span><span class="lineCov"> 5370 : if (ret &lt; 0) {</span>
<span class="lineNum"> 483 </span><span class="lineCov"> 5384 : ret = sgetline(f, str, size);</span>
<span class="lineNum"> 484 </span><span class="lineCov"> 5384 : if (ret &lt; 0) {</span>
<span class="lineNum"> 485 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 486 </span> : return ret;
<span class="lineNum"> 487 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 488 </span> : }
<span class="lineNum"> 489 </span> :
<span class="lineNum"> 490 </span><span class="lineCov"> 10740 : while (ret &gt; 0 &amp;&amp; (str[ret - 1] == ' ' || str[ret - 1] == '\t'))</span>
<span class="lineNum"> 490 </span><span class="lineCov"> 10768 : while (ret &gt; 0 &amp;&amp; (str[ret - 1] == ' ' || str[ret - 1] == '\t'))</span>
<span class="lineNum"> 491 </span><span class="lineNoCov"> 0 : --ret;</span>
<span class="lineNum"> 492 </span> :
<span class="lineNum"> 493 </span><span class="lineCov"> 5370 : str[ret] = 0;</span>
<span class="lineNum"> 493 </span><span class="lineCov"> 5384 : str[ret] = 0;</span>
<span class="lineNum"> 494 </span> :
<span class="lineNum"> 495 </span><span class="lineCov"> 5370 : return ret;</span>
<span class="lineNum"> 495 </span><span class="lineCov"> 5384 : return ret;</span>
<a name="496"><span class="lineNum"> 496 </span> : }</a>
<span class="lineNum"> 497 </span> :
<span class="lineNum"> 498 </span><span class="lineCov"> 264 : int sgetu32(STREAM* f, uint32_t* value)</span>
<span class="lineNum"> 498 </span><span class="lineCov"> 265 : int sgetu32(STREAM* f, uint32_t* value)</span>
<span class="lineNum"> 499 </span> : {
<span class="lineNum"> 500 </span> : int c;
<span class="lineNum"> 501 </span> :
<span class="lineNum"> 502 </span><span class="lineCov"> 264 : c = sgetc(f);</span>
<span class="lineNum"> 503 </span><span class="lineCov"> 264 : if (c &gt;= '0' &amp;&amp; c &lt;= '9') {</span>
<span class="lineNum"> 502 </span><span class="lineCov"> 265 : c = sgetc(f);</span>
<span class="lineNum"> 503 </span><span class="lineCov"> 265 : if (c &gt;= '0' &amp;&amp; c &lt;= '9') {</span>
<span class="lineNum"> 504 </span> : uint32_t v;
<span class="lineNum"> 505 </span> :
<span class="lineNum"> 506 </span><span class="lineCov"> 264 : v = c - '0';</span>
<span class="lineNum"> 506 </span><span class="lineCov"> 265 : v = c - '0';</span>
<span class="lineNum"> 507 </span> :
<span class="lineNum"> 508 </span><span class="lineCov"> 264 : c = sgetc(f);</span>
<span class="lineNum"> 509 </span><span class="lineCov"> 528 : while (c &gt;= '0' &amp;&amp; c &lt;= '9') {</span>
<span class="lineNum"> 508 </span><span class="lineCov"> 265 : c = sgetc(f);</span>
<span class="lineNum"> 509 </span><span class="lineCov"> 530 : while (c &gt;= '0' &amp;&amp; c &lt;= '9') {</span>
<span class="lineNum"> 510 </span><span class="lineNoCov"> 0 : v *= 10;</span>
<span class="lineNum"> 511 </span><span class="lineNoCov"> 0 : v += c - '0';</span>
<span class="lineNum"> 512 </span><span class="lineNoCov"> 0 : c = sgetc(f);</span>
<span class="lineNum"> 513 </span> : }
<span class="lineNum"> 514 </span> :
<span class="lineNum"> 515 </span><span class="lineCov"> 264 : *value = v;</span>
<span class="lineNum"> 515 </span><span class="lineCov"> 265 : *value = v;</span>
<span class="lineNum"> 516 </span> :
<span class="lineNum"> 517 </span><span class="lineCov"> 264 : sungetc(c, f);</span>
<span class="lineNum"> 518 </span><span class="lineCov"> 264 : return 0;</span>
<span class="lineNum"> 517 </span><span class="lineCov"> 265 : sungetc(c, f);</span>
<span class="lineNum"> 518 </span><span class="lineCov"> 265 : return 0;</span>
<span class="lineNum"> 519 </span> : } else {
<span class="lineNum"> 520 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 521 </span> : /* nothing read */
@ -586,122 +586,122 @@
<span class="lineNum"> 524 </span> : }
<a name="525"><span class="lineNum"> 525 </span> : }</a>
<span class="lineNum"> 526 </span> :
<span class="lineNum"> 527 </span><span class="lineCov"> 18668535 : int sgetb32(STREAM* f, uint32_t* value)</span>
<span class="lineNum"> 527 </span><span class="lineCov"> 18667054 : int sgetb32(STREAM* f, uint32_t* value)</span>
<span class="lineNum"> 528 </span> : {
<span class="lineNum"> 529 </span> : uint32_t v;
<span class="lineNum"> 530 </span> : unsigned char b;
<span class="lineNum"> 531 </span> : unsigned char s;
<span class="lineNum"> 532 </span> : int c;
<span class="lineNum"> 533 </span> :
<span class="lineNum"> 534 </span><span class="lineCov"> 18668535 : v = 0;</span>
<span class="lineNum"> 535 </span><span class="lineCov"> 18668535 : s = 0;</span>
<span class="lineNum"> 534 </span><span class="lineCov"> 18667054 : v = 0;</span>
<span class="lineNum"> 535 </span><span class="lineCov"> 18667054 : s = 0;</span>
<span class="lineNum"> 536 </span> : loop:
<span class="lineNum"> 537 </span><span class="lineCov"> 36576764 : c = sgetc(f);</span>
<span class="lineNum"> 538 </span><span class="lineCov"> 36576764 : if (c == EOF) {</span>
<span class="lineNum"> 537 </span><span class="lineCov"> 35516819 : c = sgetc(f);</span>
<span class="lineNum"> 538 </span><span class="lineCov"> 35516819 : if (c == EOF) {</span>
<span class="lineNum"> 539 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 540 </span> : return -1;
<span class="lineNum"> 541 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 542 </span> : }
<span class="lineNum"> 543 </span> :
<span class="lineNum"> 544 </span><span class="lineCov"> 36576764 : b = (unsigned char)c;</span>
<span class="lineNum"> 545 </span><span class="lineCov"> 36576764 : if ((b &amp; 0x80) == 0) {</span>
<span class="lineNum"> 546 </span><span class="lineCov"> 17908229 : v |= (uint32_t)b &lt;&lt; s;</span>
<span class="lineNum"> 547 </span><span class="lineCov"> 17908229 : s += 7;</span>
<span class="lineNum"> 548 </span><span class="lineCov"> 17908229 : if (s &gt;= 32) {</span>
<span class="lineNum"> 544 </span><span class="lineCov"> 35516819 : b = (unsigned char)c;</span>
<span class="lineNum"> 545 </span><span class="lineCov"> 35516819 : if ((b &amp; 0x80) == 0) {</span>
<span class="lineNum"> 546 </span><span class="lineCov"> 16849766 : v |= (uint32_t)b &lt;&lt; s;</span>
<span class="lineNum"> 547 </span><span class="lineCov"> 16849766 : s += 7;</span>
<span class="lineNum"> 548 </span><span class="lineCov"> 16849766 : if (s &gt;= 32) {</span>
<span class="lineNum"> 549 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 550 </span> : return -1;
<span class="lineNum"> 551 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 552 </span> : }
<span class="lineNum"> 553 </span><span class="lineCov"> 17908229 : goto loop;</span>
<span class="lineNum"> 553 </span><span class="lineCov"> 16849765 : goto loop;</span>
<span class="lineNum"> 554 </span> : }
<span class="lineNum"> 555 </span> :
<span class="lineNum"> 556 </span><span class="lineCov"> 18668535 : v |= (uint32_t)(b &amp; 0x7f) &lt;&lt; s;</span>
<span class="lineNum"> 556 </span><span class="lineCov"> 18667053 : v |= (uint32_t)(b &amp; 0x7f) &lt;&lt; s;</span>
<span class="lineNum"> 557 </span> :
<span class="lineNum"> 558 </span><span class="lineCov"> 18668535 : *value = v;</span>
<span class="lineNum"> 558 </span><span class="lineCov"> 18667053 : *value = v;</span>
<span class="lineNum"> 559 </span> :
<span class="lineNum"> 560 </span><span class="lineCov"> 18668535 : return 0;</span>
<span class="lineNum"> 560 </span><span class="lineCov"> 18667053 : return 0;</span>
<a name="561"><span class="lineNum"> 561 </span> : }</a>
<span class="lineNum"> 562 </span> :
<span class="lineNum"> 563 </span><span class="lineCov"> 10849874 : int sgetb64(STREAM* f, uint64_t* value)</span>
<span class="lineNum"> 563 </span><span class="lineCov"> 10849502 : int sgetb64(STREAM* f, uint64_t* value)</span>
<span class="lineNum"> 564 </span> : {
<span class="lineNum"> 565 </span> : uint64_t v;
<span class="lineNum"> 566 </span> : unsigned char b;
<span class="lineNum"> 567 </span> : unsigned char s;
<span class="lineNum"> 568 </span> : int c;
<span class="lineNum"> 569 </span> :
<span class="lineNum"> 570 </span><span class="lineCov"> 10849874 : v = 0;</span>
<span class="lineNum"> 571 </span><span class="lineCov"> 10849874 : s = 0;</span>
<span class="lineNum"> 570 </span><span class="lineCov"> 10849502 : v = 0;</span>
<span class="lineNum"> 571 </span><span class="lineCov"> 10849502 : s = 0;</span>
<span class="lineNum"> 572 </span> : loop:
<span class="lineNum"> 573 </span><span class="lineCov"> 39668034 : c = sgetc(f);</span>
<span class="lineNum"> 574 </span><span class="lineCov"> 39668034 : if (c == EOF) {</span>
<span class="lineNum"> 573 </span><span class="lineCov"> 39666625 : c = sgetc(f);</span>
<span class="lineNum"> 574 </span><span class="lineCov"> 39666625 : if (c == EOF) {</span>
<span class="lineNum"> 575 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 576 </span> : return -1;
<span class="lineNum"> 577 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 578 </span> : }
<span class="lineNum"> 579 </span> :
<span class="lineNum"> 580 </span><span class="lineCov"> 39668034 : b = (unsigned char)c;</span>
<span class="lineNum"> 581 </span><span class="lineCov"> 39668034 : if ((b &amp; 0x80) == 0) {</span>
<span class="lineNum"> 582 </span><span class="lineCov"> 28818160 : v |= (uint64_t)b &lt;&lt; s;</span>
<span class="lineNum"> 583 </span><span class="lineCov"> 28818160 : s += 7;</span>
<span class="lineNum"> 584 </span><span class="lineCov"> 28818160 : if (s &gt;= 64) {</span>
<span class="lineNum"> 580 </span><span class="lineCov"> 39666625 : b = (unsigned char)c;</span>
<span class="lineNum"> 581 </span><span class="lineCov"> 39666625 : if ((b &amp; 0x80) == 0) {</span>
<span class="lineNum"> 582 </span><span class="lineCov"> 28817123 : v |= (uint64_t)b &lt;&lt; s;</span>
<span class="lineNum"> 583 </span><span class="lineCov"> 28817123 : s += 7;</span>
<span class="lineNum"> 584 </span><span class="lineCov"> 28817123 : if (s &gt;= 64) {</span>
<span class="lineNum"> 585 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 586 </span> : return -1;
<span class="lineNum"> 587 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 588 </span> : }
<span class="lineNum"> 589 </span><span class="lineCov"> 28818160 : goto loop;</span>
<span class="lineNum"> 589 </span><span class="lineCov"> 28817123 : goto loop;</span>
<span class="lineNum"> 590 </span> : }
<span class="lineNum"> 591 </span> :
<span class="lineNum"> 592 </span><span class="lineCov"> 10849874 : v |= (uint64_t)(b &amp; 0x7f) &lt;&lt; s;</span>
<span class="lineNum"> 592 </span><span class="lineCov"> 10849502 : v |= (uint64_t)(b &amp; 0x7f) &lt;&lt; s;</span>
<span class="lineNum"> 593 </span> :
<span class="lineNum"> 594 </span><span class="lineCov"> 10849874 : *value = v;</span>
<span class="lineNum"> 594 </span><span class="lineCov"> 10849502 : *value = v;</span>
<span class="lineNum"> 595 </span> :
<span class="lineNum"> 596 </span><span class="lineCov"> 10849874 : return 0;</span>
<span class="lineNum"> 596 </span><span class="lineCov"> 10849502 : return 0;</span>
<a name="597"><span class="lineNum"> 597 </span> : }</a>
<span class="lineNum"> 598 </span> :
<span class="lineNum"> 599 </span><span class="lineCov"> 379 : int sgetble32(STREAM* f, uint32_t* value)</span>
<span class="lineNum"> 599 </span><span class="lineCov"> 380 : int sgetble32(STREAM* f, uint32_t* value)</span>
<span class="lineNum"> 600 </span> : {
<span class="lineNum"> 601 </span> : unsigned char buf[4];
<span class="lineNum"> 602 </span> :
<span class="lineNum"> 603 </span><span class="lineCov"> 379 : if (sread(f, buf, 4) != 0) {</span>
<span class="lineNum"> 603 </span><span class="lineCov"> 380 : if (sread(f, buf, 4) != 0) {</span>
<span class="lineNum"> 604 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 605 </span> : return -1;
<span class="lineNum"> 606 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 607 </span> : }
<span class="lineNum"> 608 </span> :
<span class="lineNum"> 609 </span><span class="lineCov"> 379 : *value = buf[0] | (uint32_t)buf[1] &lt;&lt; 8 | (uint32_t)buf[2] &lt;&lt; 16 | (uint32_t)buf[3] &lt;&lt; 24;</span>
<span class="lineNum"> 609 </span><span class="lineCov"> 380 : *value = buf[0] | (uint32_t)buf[1] &lt;&lt; 8 | (uint32_t)buf[2] &lt;&lt; 16 | (uint32_t)buf[3] &lt;&lt; 24;</span>
<span class="lineNum"> 610 </span> :
<span class="lineNum"> 611 </span><span class="lineCov"> 379 : return 0;</span>
<span class="lineNum"> 611 </span><span class="lineCov"> 380 : return 0;</span>
<a name="612"><span class="lineNum"> 612 </span> : }</a>
<span class="lineNum"> 613 </span> :
<span class="lineNum"> 614 </span><span class="lineCov"> 3877236 : int sgetbs(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 614 </span><span class="lineCov"> 3877163 : int sgetbs(STREAM* f, char* str, int size)</span>
<span class="lineNum"> 615 </span> : {
<span class="lineNum"> 616 </span> : uint32_t len;
<span class="lineNum"> 617 </span> :
<span class="lineNum"> 618 </span><span class="lineCov"> 3877236 : if (sgetb32(f, &amp;len) &lt; 0) {</span>
<span class="lineNum"> 618 </span><span class="lineCov"> 3877163 : if (sgetb32(f, &amp;len) &lt; 0) {</span>
<span class="lineNum"> 619 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 620 </span> : return -1;
<span class="lineNum"> 621 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 622 </span> : }
<span class="lineNum"> 623 </span> :
<span class="lineNum"> 624 </span><span class="lineCov"> 3877236 : if (len + 1 &gt; (uint32_t)size) {</span>
<span class="lineNum"> 624 </span><span class="lineCov"> 3877162 : if (len + 1 &gt; (uint32_t)size) {</span>
<span class="lineNum"> 625 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 626 </span> : return -1;
<span class="lineNum"> 627 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 628 </span> : }
<span class="lineNum"> 629 </span> :
<span class="lineNum"> 630 </span><span class="lineCov"> 3877236 : str[len] = 0;</span>
<span class="lineNum"> 630 </span><span class="lineCov"> 3877162 : str[len] = 0;</span>
<span class="lineNum"> 631 </span> :
<span class="lineNum"> 632 </span><span class="lineCov"> 3877236 : return sread(f, str, (int)len);</span>
<span class="lineNum"> 632 </span><span class="lineCov"> 3877162 : return sread(f, str, (int)len);</span>
<a name="633"><span class="lineNum"> 633 </span> : }</a>
<span class="lineNum"> 634 </span> :
<span class="lineNum"> 635 </span><span class="lineCov"> 20725275 : int swrite(const void* void_data, unsigned size, STREAM* f)</span>
<span class="lineNum"> 635 </span><span class="lineCov"> 20724964 : int swrite(const void* void_data, unsigned size, STREAM* f)</span>
<span class="lineNum"> 636 </span> : {
<span class="lineNum"> 637 </span><span class="lineCov"> 20725275 : const unsigned char* data = void_data;</span>
<span class="lineNum"> 637 </span><span class="lineCov"> 20724964 : const unsigned char* data = void_data;</span>
<span class="lineNum"> 638 </span> :
<span class="lineNum"> 639 </span> : /* if there is enough space in memory */
<span class="lineNum"> 640 </span><span class="lineCov"> 20725275 : if (sptrlookup(f, size)) {</span>
<span class="lineNum"> 640 </span><span class="lineCov"> 20724964 : if (sptrlookup(f, size)) {</span>
<span class="lineNum"> 641 </span> : /* optimized version with all the data in memory */
<span class="lineNum"> 642 </span><span class="lineCov"> 20719102 : unsigned char* pos = sptrget(f);</span>
<span class="lineNum"> 642 </span><span class="lineCov"> 20718802 : unsigned char* pos = sptrget(f);</span>
<span class="lineNum"> 643 </span> :
<span class="lineNum"> 644 </span> : /**
<span class="lineNum"> 645 </span> : * Update the crc *before* writing the data in the buffer
@ -710,17 +710,17 @@
<span class="lineNum"> 648 </span> : * to be able to detect memory errors on the buffer,
<span class="lineNum"> 649 </span> : * happening before we write it on the file.
<span class="lineNum"> 650 </span> : */
<span class="lineNum"> 651 </span><span class="lineCov"> 20719102 : f-&gt;crc_stream = crc32c_plain(f-&gt;crc_stream, data, size);</span>
<span class="lineNum"> 651 </span><span class="lineCov"> 20718802 : f-&gt;crc_stream = crc32c_plain(f-&gt;crc_stream, data, size);</span>
<span class="lineNum"> 652 </span> :
<span class="lineNum"> 653 </span> : /* copy it */
<span class="lineNum"> 654 </span><span class="lineCov"> 173066513 : while (size--)</span>
<span class="lineNum"> 655 </span><span class="lineCov"> 131628309 : *pos++ = *data++;</span>
<span class="lineNum"> 654 </span><span class="lineCov"> 172634823 : while (size--)</span>
<span class="lineNum"> 655 </span><span class="lineCov"> 131197219 : *pos++ = *data++;</span>
<span class="lineNum"> 656 </span> :
<span class="lineNum"> 657 </span><span class="lineCov"> 20719102 : sptrset(f, pos);</span>
<span class="lineNum"> 657 </span><span class="lineCov"> 20718802 : sptrset(f, pos);</span>
<span class="lineNum"> 658 </span> : } else {
<span class="lineNum"> 659 </span> : /* standard version using sputc() */
<span class="lineNum"> 660 </span><span class="lineCov"> 202070 : while (size--) {</span>
<span class="lineNum"> 661 </span><span class="lineCov"> 189724 : if (sputc(*data++, f) != 0) {</span>
<span class="lineNum"> 660 </span><span class="lineCov"> 201254 : while (size--) {</span>
<span class="lineNum"> 661 </span><span class="lineCov"> 188930 : if (sputc(*data++, f) != 0) {</span>
<span class="lineNum"> 662 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 663 </span> : return -1;
<span class="lineNum"> 664 </span> : /* LCOV_EXCL_STOP */
@ -728,28 +728,28 @@
<span class="lineNum"> 666 </span> : }
<span class="lineNum"> 667 </span> : }
<span class="lineNum"> 668 </span> :
<span class="lineNum"> 669 </span><span class="lineCov"> 20725275 : return 0;</span>
<span class="lineNum"> 669 </span><span class="lineCov"> 20724964 : return 0;</span>
<a name="670"><span class="lineNum"> 670 </span> : }</a>
<span class="lineNum"> 671 </span> :
<span class="lineNum"> 672 </span><span class="lineCov"> 9127648 : int sputb32(uint32_t value, STREAM* s)</span>
<span class="lineNum"> 672 </span><span class="lineCov"> 9127337 : int sputb32(uint32_t value, STREAM* s)</span>
<span class="lineNum"> 673 </span> : {
<span class="lineNum"> 674 </span> : unsigned char b;
<span class="lineNum"> 675 </span> : unsigned char buf[16];
<span class="lineNum"> 676 </span> : unsigned i;
<span class="lineNum"> 677 </span> :
<span class="lineNum"> 678 </span><span class="lineCov"> 9127648 : i = 0;</span>
<span class="lineNum"> 678 </span><span class="lineCov"> 9127337 : i = 0;</span>
<span class="lineNum"> 679 </span> : loop:
<span class="lineNum"> 680 </span><span class="lineCov"> 17909297 : b = value &amp; 0x7f;</span>
<span class="lineNum"> 681 </span><span class="lineCov"> 17909297 : value &gt;&gt;= 7;</span>
<span class="lineNum"> 680 </span><span class="lineCov"> 17477413 : b = value &amp; 0x7f;</span>
<span class="lineNum"> 681 </span><span class="lineCov"> 17477413 : value &gt;&gt;= 7;</span>
<span class="lineNum"> 682 </span> :
<span class="lineNum"> 683 </span><span class="lineCov"> 17909297 : if (value) {</span>
<span class="lineNum"> 684 </span><span class="lineCov"> 8781649 : buf[i++] = b;</span>
<span class="lineNum"> 685 </span><span class="lineCov"> 8781649 : goto loop;</span>
<span class="lineNum"> 683 </span><span class="lineCov"> 17477413 : if (value) {</span>
<span class="lineNum"> 684 </span><span class="lineCov"> 8350076 : buf[i++] = b;</span>
<span class="lineNum"> 685 </span><span class="lineCov"> 8350076 : goto loop;</span>
<span class="lineNum"> 686 </span> : }
<span class="lineNum"> 687 </span> :
<span class="lineNum"> 688 </span><span class="lineCov"> 9127648 : buf[i++] = b | 0x80;</span>
<span class="lineNum"> 688 </span><span class="lineCov"> 9127337 : buf[i++] = b | 0x80;</span>
<span class="lineNum"> 689 </span> :
<span class="lineNum"> 690 </span><span class="lineCov"> 9127648 : return swrite(buf, i, s);</span>
<span class="lineNum"> 690 </span><span class="lineCov"> 9127337 : return swrite(buf, i, s);</span>
<a name="691"><span class="lineNum"> 691 </span> : }</a>
<span class="lineNum"> 692 </span> :
<span class="lineNum"> 693 </span><span class="lineCov"> 5317120 : int sputb64(uint64_t value, STREAM* s)</span>

18
cov/cmdline/stream.h.func-sort-c.html
View file

@ -61,39 +61,39 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#230">sgetc</a></td>
<td class="coverFnHi">85203689</td>
<td class="coverFnHi">84138438</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#160">sptrlookup</a></td>
<td class="coverFnHi">33541405</td>
<td class="coverFnHi">33540761</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#176">sptrset</a></td>
<td class="coverFnHi">33503384</td>
<td class="coverFnHi">33503040</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#168">sptrget</a></td>
<td class="coverFnHi">33503384</td>
<td class="coverFnHi">33503040</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#346">sputc</a></td>
<td class="coverFnHi">3808841</td>
<td class="coverFnHi">3808025</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#184">serror</a></td>
<td class="coverFnHi">3635503</td>
<td class="coverFnHi">3635393</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#241">sungetc</a></td>
<td class="coverFnHi">34340</td>
<td class="coverFnHi">34440</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#271">sgetspace</a></td>
<td class="coverFnHi">20539</td>
<td class="coverFnHi">20599</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#256">sgeteol</a></td>
<td class="coverFnHi">6200</td>
<td class="coverFnHi">6218</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#192">seof</a></td>

18
cov/cmdline/stream.h.func.html
View file

@ -65,7 +65,7 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#184">serror</a></td>
<td class="coverFnHi">3635503</td>
<td class="coverFnHi">3635393</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#208">serrorfile</a></td>
@ -73,35 +73,35 @@
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#230">sgetc</a></td>
<td class="coverFnHi">85203689</td>
<td class="coverFnHi">84138438</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#256">sgeteol</a></td>
<td class="coverFnHi">6200</td>
<td class="coverFnHi">6218</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#271">sgetspace</a></td>
<td class="coverFnHi">20539</td>
<td class="coverFnHi">20599</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#168">sptrget</a></td>
<td class="coverFnHi">33503384</td>
<td class="coverFnHi">33503040</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#160">sptrlookup</a></td>
<td class="coverFnHi">33541405</td>
<td class="coverFnHi">33540761</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#176">sptrset</a></td>
<td class="coverFnHi">33503384</td>
<td class="coverFnHi">33503040</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#346">sputc</a></td>
<td class="coverFnHi">3808841</td>
<td class="coverFnHi">3808025</td>
</tr>
<tr>
<td class="coverFn"><a href="stream.h.gcov.html#241">sungetc</a></td>
<td class="coverFnHi">34340</td>
<td class="coverFnHi">34440</td>
</tr>
</table>
<br>

68
cov/cmdline/stream.h.gcov.html
View file

@ -221,33 +221,33 @@
<span class="lineNum"> 159 </span> : /**
<a name="160"><span class="lineNum"> 160 </span> : * Check if the buffer has enough data loaded.</a>
<span class="lineNum"> 161 </span> : */
<span class="lineNum"> 162 </span><span class="lineCov"> 33541405 : static inline int sptrlookup(STREAM* s, int size)</span>
<span class="lineNum"> 162 </span><span class="lineCov"> 33540761 : static inline int sptrlookup(STREAM* s, int size)</span>
<span class="lineNum"> 163 </span> : {
<span class="lineNum"> 164 </span><span class="lineCov"> 33541405 : return s-&gt;pos + size &lt;= s-&gt;end;</span>
<span class="lineNum"> 164 </span><span class="lineCov"> 33540761 : return s-&gt;pos + size &lt;= s-&gt;end;</span>
<span class="lineNum"> 165 </span> : }
<span class="lineNum"> 166 </span> :
<span class="lineNum"> 167 </span> : /**
<a name="168"><span class="lineNum"> 168 </span> : * Get the current stream ptr.</a>
<span class="lineNum"> 169 </span> : */
<span class="lineNum"> 170 </span><span class="lineCov"> 33503384 : static inline unsigned char* sptrget(STREAM* s)</span>
<span class="lineNum"> 170 </span><span class="lineCov"> 33503040 : static inline unsigned char* sptrget(STREAM* s)</span>
<span class="lineNum"> 171 </span> : {
<span class="lineNum"> 172 </span><span class="lineCov"> 33503384 : return s-&gt;pos;</span>
<span class="lineNum"> 172 </span><span class="lineCov"> 33503040 : return s-&gt;pos;</span>
<span class="lineNum"> 173 </span> : }
<span class="lineNum"> 174 </span> :
<span class="lineNum"> 175 </span> : /**
<a name="176"><span class="lineNum"> 176 </span> : * Set the current stream ptr.</a>
<span class="lineNum"> 177 </span> : */
<span class="lineNum"> 178 </span><span class="lineCov"> 33503384 : static inline void sptrset(STREAM* s, unsigned char* ptr)</span>
<span class="lineNum"> 178 </span><span class="lineCov"> 33503040 : static inline void sptrset(STREAM* s, unsigned char* ptr)</span>
<span class="lineNum"> 179 </span> : {
<span class="lineNum"> 180 </span><span class="lineCov"> 33503384 : s-&gt;pos = ptr;</span>
<span class="lineNum"> 181 </span><span class="lineCov"> 33503384 : }</span>
<span class="lineNum"> 180 </span><span class="lineCov"> 33503040 : s-&gt;pos = ptr;</span>
<span class="lineNum"> 181 </span><span class="lineCov"> 33503040 : }</span>
<span class="lineNum"> 182 </span> :
<span class="lineNum"> 183 </span> : /**
<a name="184"><span class="lineNum"> 184 </span> : * Check the error status. Like ferror().</a>
<span class="lineNum"> 185 </span> : */
<span class="lineNum"> 186 </span><span class="lineCov"> 3635503 : static inline int serror(STREAM* s)</span>
<span class="lineNum"> 186 </span><span class="lineCov"> 3635393 : static inline int serror(STREAM* s)</span>
<span class="lineNum"> 187 </span> : {
<span class="lineNum"> 188 </span><span class="lineCov"> 3635503 : return s-&gt;state == STREAM_STATE_ERROR;</span>
<span class="lineNum"> 188 </span><span class="lineCov"> 3635393 : return s-&gt;state == STREAM_STATE_ERROR;</span>
<span class="lineNum"> 189 </span> : }
<span class="lineNum"> 190 </span> :
<span class="lineNum"> 191 </span> : /**
@ -291,22 +291,22 @@
<span class="lineNum"> 229 </span> : /**
<a name="230"><span class="lineNum"> 230 </span> : * Read a char. Like fgetc().</a>
<span class="lineNum"> 231 </span> : */
<span class="lineNum"> 232 </span><span class="lineCov"> 85203689 : static inline int sgetc(STREAM* s)</span>
<span class="lineNum"> 232 </span><span class="lineCov"> 84138438 : static inline int sgetc(STREAM* s)</span>
<span class="lineNum"> 233 </span> : {
<span class="lineNum"> 234 </span><span class="lineCov"> 85203689 : if (tommy_unlikely(s-&gt;pos == s-&gt;end))</span>
<span class="lineNum"> 235 </span><span class="lineCov"> 298847 : return sgetc_uncached(s);</span>
<span class="lineNum"> 236 </span><span class="lineCov"> 84904842 : return *s-&gt;pos++;</span>
<span class="lineNum"> 234 </span><span class="lineCov"> 84138438 : if (tommy_unlikely(s-&gt;pos == s-&gt;end))</span>
<span class="lineNum"> 235 </span><span class="lineCov"> 298855 : return sgetc_uncached(s);</span>
<span class="lineNum"> 236 </span><span class="lineCov"> 83839583 : return *s-&gt;pos++;</span>
<span class="lineNum"> 237 </span> : }
<span class="lineNum"> 238 </span> :
<span class="lineNum"> 239 </span> : /**
<span class="lineNum"> 240 </span> : * Unread a char.
<a name="241"><span class="lineNum"> 241 </span> : * Like ungetc() but you have to unget the same char read.</a>
<span class="lineNum"> 242 </span> : */
<span class="lineNum"> 243 </span><span class="lineCov"> 34340 : static inline void sungetc(int c, STREAM* s)</span>
<span class="lineNum"> 243 </span><span class="lineCov"> 34440 : static inline void sungetc(int c, STREAM* s)</span>
<span class="lineNum"> 244 </span> : {
<span class="lineNum"> 245 </span><span class="lineCov"> 34340 : if (c != EOF)</span>
<span class="lineNum"> 246 </span><span class="lineCov"> 33551 : --s-&gt;pos;</span>
<span class="lineNum"> 247 </span><span class="lineCov"> 34340 : }</span>
<span class="lineNum"> 245 </span><span class="lineCov"> 34440 : if (c != EOF)</span>
<span class="lineNum"> 246 </span><span class="lineCov"> 33648 : --s-&gt;pos;</span>
<span class="lineNum"> 247 </span><span class="lineCov"> 34440 : }</span>
<span class="lineNum"> 248 </span> :
<span class="lineNum"> 249 </span> : /**
<span class="lineNum"> 250 </span> : * Read a fixed amount of chars.
@ -317,34 +317,34 @@
<span class="lineNum"> 255 </span> : /**
<a name="256"><span class="lineNum"> 256 </span> : * Get a char from a stream, ignoring one '\r'.</a>
<span class="lineNum"> 257 </span> : */
<span class="lineNum"> 258 </span><span class="lineCov"> 6200 : static inline int sgeteol(STREAM* f)</span>
<span class="lineNum"> 258 </span><span class="lineCov"> 6218 : static inline int sgeteol(STREAM* f)</span>
<span class="lineNum"> 259 </span> : {
<span class="lineNum"> 260 </span> : int c;
<span class="lineNum"> 261 </span> :
<span class="lineNum"> 262 </span><span class="lineCov"> 6200 : c = sgetc(f);</span>
<span class="lineNum"> 263 </span><span class="lineCov"> 6200 : if (c == '\r')</span>
<span class="lineNum"> 262 </span><span class="lineCov"> 6218 : c = sgetc(f);</span>
<span class="lineNum"> 263 </span><span class="lineCov"> 6218 : if (c == '\r')</span>
<span class="lineNum"> 264 </span><span class="lineNoCov"> 0 : c = sgetc(f);</span>
<span class="lineNum"> 265 </span> :
<span class="lineNum"> 266 </span><span class="lineCov"> 6200 : return c;</span>
<span class="lineNum"> 266 </span><span class="lineCov"> 6218 : return c;</span>
<span class="lineNum"> 267 </span> : }
<span class="lineNum"> 268 </span> :
<span class="lineNum"> 269 </span> : /**
<span class="lineNum"> 270 </span> : * Read all the spaces and tabs.
<a name="271"><span class="lineNum"> 271 </span> : * Return the number of spaces and tabs read.</a>
<span class="lineNum"> 272 </span> : */
<span class="lineNum"> 273 </span><span class="lineCov"> 20539 : static inline int sgetspace(STREAM* f)</span>
<span class="lineNum"> 273 </span><span class="lineCov"> 20599 : static inline int sgetspace(STREAM* f)</span>
<span class="lineNum"> 274 </span> : {
<span class="lineNum"> 275 </span><span class="lineCov"> 20539 : int count = 0;</span>
<span class="lineNum"> 275 </span><span class="lineCov"> 20599 : int count = 0;</span>
<span class="lineNum"> 276 </span> : int c;
<span class="lineNum"> 277 </span> :
<span class="lineNum"> 278 </span><span class="lineCov"> 20539 : c = sgetc(f);</span>
<span class="lineNum"> 279 </span><span class="lineCov"> 48689 : while (c == ' ' || c == '\t') {</span>
<span class="lineNum"> 280 </span><span class="lineCov"> 7611 : ++count;</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 7611 : c = sgetc(f);</span>
<span class="lineNum"> 278 </span><span class="lineCov"> 20599 : c = sgetc(f);</span>
<span class="lineNum"> 279 </span><span class="lineCov"> 48831 : while (c == ' ' || c == '\t') {</span>
<span class="lineNum"> 280 </span><span class="lineCov"> 7633 : ++count;</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 7633 : c = sgetc(f);</span>
<span class="lineNum"> 282 </span> : }
<span class="lineNum"> 283 </span> :
<span class="lineNum"> 284 </span><span class="lineCov"> 20539 : sungetc(c, f);</span>
<span class="lineNum"> 285 </span><span class="lineCov"> 20539 : return count;</span>
<span class="lineNum"> 284 </span><span class="lineCov"> 20599 : sungetc(c, f);</span>
<span class="lineNum"> 285 </span><span class="lineCov"> 20599 : return count;</span>
<span class="lineNum"> 286 </span> : }
<span class="lineNum"> 287 </span> :
<span class="lineNum"> 288 </span> : /**
@ -407,9 +407,9 @@
<span class="lineNum"> 345 </span> : * Write a char. Like fputc().
<a name="346"><span class="lineNum"> 346 </span> : * Return 0 on success or -1 on error.</a>
<span class="lineNum"> 347 </span> : */
<span class="lineNum"> 348 </span><span class="lineCov"> 3808841 : static inline int sputc(int c, STREAM* s)</span>
<span class="lineNum"> 348 </span><span class="lineCov"> 3808025 : static inline int sputc(int c, STREAM* s)</span>
<span class="lineNum"> 349 </span> : {
<span class="lineNum"> 350 </span><span class="lineCov"> 3808841 : if (s-&gt;pos == s-&gt;end) {</span>
<span class="lineNum"> 350 </span><span class="lineCov"> 3808025 : if (s-&gt;pos == s-&gt;end) {</span>
<span class="lineNum"> 351 </span><span class="lineCov"> 38580 : if (sflush(s) != 0)</span>
<span class="lineNum"> 352 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 353 </span> : }
@ -421,11 +421,11 @@
<span class="lineNum"> 359 </span> : * to be able to detect memory errors on the buffer,
<span class="lineNum"> 360 </span> : * happening before we write it on the file.
<span class="lineNum"> 361 </span> : */
<span class="lineNum"> 362 </span><span class="lineCov"> 3808841 : s-&gt;crc_stream = crc32c_plain_char(s-&gt;crc_stream, c);</span>
<span class="lineNum"> 362 </span><span class="lineCov"> 3808025 : s-&gt;crc_stream = crc32c_plain_char(s-&gt;crc_stream, c);</span>
<span class="lineNum"> 363 </span> :
<span class="lineNum"> 364 </span><span class="lineCov"> 3808841 : *s-&gt;pos++ = c;</span>
<span class="lineNum"> 364 </span><span class="lineCov"> 3808025 : *s-&gt;pos++ = c;</span>
<span class="lineNum"> 365 </span> :
<span class="lineNum"> 366 </span><span class="lineCov"> 3808841 : return 0;</span>
<span class="lineNum"> 366 </span><span class="lineCov"> 3808025 : return 0;</span>
<span class="lineNum"> 367 </span> : }
<span class="lineNum"> 368 </span> :
<span class="lineNum"> 369 </span> : /**

90
cov/cmdline/support.c.func-sort-c.html
View file

@ -61,123 +61,123 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1521">thread_mutex_unlock</a></td>
<td class="coverFnHi">80857847</td>
<td class="coverFnHi">80862235</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1511">thread_mutex_lock</a></td>
<td class="coverFnHi">80853291</td>
<td class="coverFnHi">80858327</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#765">pathcmp</a></td>
<td class="coverFnHi">51888281</td>
<td class="coverFnHi">51889998</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#716">pathprint</a></td>
<td class="coverFnHi">51562554</td>
<td class="coverFnHi">51564205</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#52">unlock_memory</a></td>
<td class="coverFnHi">20174119</td>
<td class="coverFnHi">20174230</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#45">lock_memory</a></td>
<td class="coverFnHi">20174119</td>
<td class="coverFnHi">20174230</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1221">malloc_counter_inc</a></td>
<td class="coverFnHi">20173645</td>
<td class="coverFnHi">20173756</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1280">malloc_nofail</a></td>
<td class="coverFnHi">14364256</td>
<td class="coverFnHi">14364226</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1134">advise_read</a></td>
<td class="coverFnHi">8903012</td>
<td class="coverFnHi">8903872</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#631">pathcpy</a></td>
<td class="coverFnHi">7891437</td>
<td class="coverFnHi">7892425</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1329">strdup_nofail</a></td>
<td class="coverFnHi">5799372</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#38">unlock_msg</a></td>
<td class="coverFnHi">3888570</td>
<td class="coverFnHi">5799477</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#31">lock_msg</a></td>
<td class="coverFnHi">3888569</td>
<td class="coverFnHi">3887429</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#38">unlock_msg</a></td>
<td class="coverFnHi">3887429</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#154">log_tag</a></td>
<td class="coverFnHi">2908990</td>
<td class="coverFnHi">2907978</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#905">advise_flags</a></td>
<td class="coverFnHi">2494931</td>
<td class="coverFnHi">2495042</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#898">advise_init</a></td>
<td class="coverFnHi">2494857</td>
<td class="coverFnHi">2494967</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#390">esc_tag</a></td>
<td class="coverFnHi">2429566</td>
<td class="coverFnHi">2428739</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#925">advise_open</a></td>
<td class="coverFnHi">2416121</td>
<td class="coverFnHi">2416234</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1571">thread_cond_wait</a></td>
<td class="coverFnHi">1095193</td>
<td class="coverFnHi">1095059</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#957">advise_write</a></td>
<td class="coverFnHi">900323</td>
<td class="coverFnHi">900676</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#785">mkancestor</a></td>
<td class="coverFnHi">793097</td>
<td class="coverFnHi">793090</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#115">log_error</a></td>
<td class="coverFnHi">536153</td>
<td class="coverFnHi">536045</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#431">esc_shell_multi</a></td>
<td class="coverFnHi">356012</td>
<td class="coverFnHi">356083</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#207">msg_info</a></td>
<td class="coverFnHi">295787</td>
<td class="coverFnHi">295858</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1561">thread_cond_broadcast</a></td>
<td class="coverFnHi">255449</td>
<td class="coverFnHi">255625</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1627">thread_cond_broadcast_and_unlock</a></td>
<td class="coverFnHi">255259</td>
<td class="coverFnHi">255435</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#269">msg_verbose</a></td>
<td class="coverFnHi">126951</td>
<td class="coverFnHi">126963</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#849">fmtime</a></td>
<td class="coverFnHi">119601</td>
<td class="coverFnHi">119641</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1551">thread_cond_signal</a></td>
<td class="coverFnHi">84548</td>
<td class="coverFnHi">83165</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1610">thread_cond_signal_and_unlock</a></td>
<td class="coverFnHi">84548</td>
<td class="coverFnHi">83165</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#696">pathexport</a></td>
@ -185,7 +185,7 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#675">pathimport</a></td>
<td class="coverFnHi">16494</td>
<td class="coverFnHi">16519</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#137">log_expected</a></td>
@ -193,19 +193,19 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1306">calloc_nofail</a></td>
<td class="coverFnHi">10017</td>
<td class="coverFnHi">10053</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#738">pathslash</a></td>
<td class="coverFnHi">7693</td>
<td class="coverFnHi">7699</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#226">msg_progress</a></td>
<td class="coverFnHi">4445</td>
<td class="coverFnHi">4447</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1491">thread_mutex_init</a></td>
<td class="coverFnHi">2268</td>
<td class="coverFnHi">2276</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1644">thread_create</a></td>
@ -221,15 +221,15 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#250">msg_bar</a></td>
<td class="coverFnHi">1778</td>
<td class="coverFnHi">1678</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#602">strsplit</a></td>
<td class="coverFnHi">1465</td>
<td class="coverFnHi">1466</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#171">log_flush</a></td>
<td class="coverFnHi">1190</td>
<td class="coverFnHi">1196</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#93">log_fatal</a></td>
@ -241,11 +241,11 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#183">msg_status</a></td>
<td class="coverFnHi">616</td>
<td class="coverFnHi">625</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#293">msg_flush</a></td>
<td class="coverFnHi">591</td>
<td class="coverFnHi">571</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1208">malloc_counter_get</a></td>
@ -261,11 +261,11 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#59">lock_init</a></td>
<td class="coverFnHi">297</td>
<td class="coverFnHi">298</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#645">pathcat</a></td>
<td class="coverFnHi">265</td>
<td class="coverFnHi">266</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#68">lock_done</a></td>

84
cov/cmdline/support.c.func.html
View file

@ -61,39 +61,39 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#905">advise_flags</a></td>
<td class="coverFnHi">2494931</td>
<td class="coverFnHi">2495042</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#898">advise_init</a></td>
<td class="coverFnHi">2494857</td>
<td class="coverFnHi">2494967</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#925">advise_open</a></td>
<td class="coverFnHi">2416121</td>
<td class="coverFnHi">2416234</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1134">advise_read</a></td>
<td class="coverFnHi">8903012</td>
<td class="coverFnHi">8903872</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#957">advise_write</a></td>
<td class="coverFnHi">900323</td>
<td class="coverFnHi">900676</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1306">calloc_nofail</a></td>
<td class="coverFnHi">10017</td>
<td class="coverFnHi">10053</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#431">esc_shell_multi</a></td>
<td class="coverFnHi">356012</td>
<td class="coverFnHi">356083</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#390">esc_tag</a></td>
<td class="coverFnHi">2429566</td>
<td class="coverFnHi">2428739</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#849">fmtime</a></td>
<td class="coverFnHi">119601</td>
<td class="coverFnHi">119641</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#68">lock_done</a></td>
@ -101,19 +101,19 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#59">lock_init</a></td>
<td class="coverFnHi">297</td>
<td class="coverFnHi">298</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#45">lock_memory</a></td>
<td class="coverFnHi">20174119</td>
<td class="coverFnHi">20174230</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#31">lock_msg</a></td>
<td class="coverFnHi">3888569</td>
<td class="coverFnHi">3887429</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#115">log_error</a></td>
<td class="coverFnHi">536153</td>
<td class="coverFnHi">536045</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#137">log_expected</a></td>
@ -125,11 +125,11 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#171">log_flush</a></td>
<td class="coverFnHi">1190</td>
<td class="coverFnHi">1196</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#154">log_tag</a></td>
<td class="coverFnHi">2908990</td>
<td class="coverFnHi">2907978</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1208">malloc_counter_get</a></td>
@ -137,43 +137,43 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1221">malloc_counter_inc</a></td>
<td class="coverFnHi">20173645</td>
<td class="coverFnHi">20173756</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1280">malloc_nofail</a></td>
<td class="coverFnHi">14364256</td>
<td class="coverFnHi">14364226</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#785">mkancestor</a></td>
<td class="coverFnHi">793097</td>
<td class="coverFnHi">793090</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#250">msg_bar</a></td>
<td class="coverFnHi">1778</td>
<td class="coverFnHi">1678</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#293">msg_flush</a></td>
<td class="coverFnHi">591</td>
<td class="coverFnHi">571</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#207">msg_info</a></td>
<td class="coverFnHi">295787</td>
<td class="coverFnHi">295858</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#226">msg_progress</a></td>
<td class="coverFnHi">4445</td>
<td class="coverFnHi">4447</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#183">msg_status</a></td>
<td class="coverFnHi">616</td>
<td class="coverFnHi">625</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#269">msg_verbose</a></td>
<td class="coverFnHi">126951</td>
<td class="coverFnHi">126963</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#645">pathcat</a></td>
<td class="coverFnHi">265</td>
<td class="coverFnHi">266</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#660">pathcatc</a></td>
@ -181,11 +181,11 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#765">pathcmp</a></td>
<td class="coverFnHi">51888281</td>
<td class="coverFnHi">51889998</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#631">pathcpy</a></td>
<td class="coverFnHi">7891437</td>
<td class="coverFnHi">7892425</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#755">pathcut</a></td>
@ -197,15 +197,15 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#675">pathimport</a></td>
<td class="coverFnHi">16494</td>
<td class="coverFnHi">16519</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#716">pathprint</a></td>
<td class="coverFnHi">51562554</td>
<td class="coverFnHi">51564205</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#738">pathslash</a></td>
<td class="coverFnHi">7693</td>
<td class="coverFnHi">7699</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#303">printc</a></td>
@ -237,7 +237,7 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1329">strdup_nofail</a></td>
<td class="coverFnHi">5799372</td>
<td class="coverFnHi">5799477</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#589">strpolish</a></td>
@ -245,15 +245,15 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#602">strsplit</a></td>
<td class="coverFnHi">1465</td>
<td class="coverFnHi">1466</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1561">thread_cond_broadcast</a></td>
<td class="coverFnHi">255449</td>
<td class="coverFnHi">255625</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1627">thread_cond_broadcast_and_unlock</a></td>
<td class="coverFnHi">255259</td>
<td class="coverFnHi">255435</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1541">thread_cond_destroy</a></td>
@ -265,15 +265,15 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1551">thread_cond_signal</a></td>
<td class="coverFnHi">84548</td>
<td class="coverFnHi">83165</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1610">thread_cond_signal_and_unlock</a></td>
<td class="coverFnHi">84548</td>
<td class="coverFnHi">83165</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1571">thread_cond_wait</a></td>
<td class="coverFnHi">1095193</td>
<td class="coverFnHi">1095059</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1644">thread_create</a></td>
@ -289,23 +289,23 @@
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1491">thread_mutex_init</a></td>
<td class="coverFnHi">2268</td>
<td class="coverFnHi">2276</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1511">thread_mutex_lock</a></td>
<td class="coverFnHi">80853291</td>
<td class="coverFnHi">80858327</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#1521">thread_mutex_unlock</a></td>
<td class="coverFnHi">80857847</td>
<td class="coverFnHi">80862235</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#52">unlock_memory</a></td>
<td class="coverFnHi">20174119</td>
<td class="coverFnHi">20174230</td>
</tr>
<tr>
<td class="coverFn"><a href="support.c.gcov.html#38">unlock_msg</a></td>
<td class="coverFnHi">3888570</td>
<td class="coverFnHi">3887429</td>
</tr>
</table>
<br>

568
cov/cmdline/support.c.gcov.html
View file

File diff suppressed because it is too large Load diff

2
cov/cmdline/support.h.func-sort-c.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="support.h.gcov.html#230">esc_shell</a></td>
<td class="coverFnHi">331952</td>
<td class="coverFnHi">332023</td>
</tr>
</table>
<br>

2
cov/cmdline/support.h.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="support.h.gcov.html#230">esc_shell</a></td>
<td class="coverFnHi">331952</td>
<td class="coverFnHi">332023</td>
</tr>
</table>
<br>

4
cov/cmdline/support.h.gcov.html
View file

@ -291,9 +291,9 @@
<span class="lineNum"> 229 </span> : * \param buffer Preallocated buffer of ESC_MAX size.
<a name="230"><span class="lineNum"> 230 </span> : */</a>
<span class="lineNum"> 231 </span> : const char* esc_shell_multi(const char** str_map, unsigned str_max, char* buffer);
<span class="lineNum"> 232 </span><span class="lineCov"> 331952 : static inline const char* esc_shell(const char* str, char* buffer)</span>
<span class="lineNum"> 232 </span><span class="lineCov"> 332023 : static inline const char* esc_shell(const char* str, char* buffer)</span>
<span class="lineNum"> 233 </span> : {
<span class="lineNum"> 234 </span><span class="lineCov"> 331952 : return esc_shell_multi(&amp;str, 1, buffer);</span>
<span class="lineNum"> 234 </span><span class="lineCov"> 332023 : return esc_shell_multi(&amp;str, 1, buffer);</span>
<span class="lineNum"> 235 </span> : }
<span class="lineNum"> 236 </span> :
<span class="lineNum"> 237 </span> : /**

10
cov/cmdline/sync.c.func-sort-c.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">502</td>
<td class="headerCovTableEntry">561</td>
<td class="headerCovTableEntryMed">89.5 %</td>
<td class="headerCovTableEntry">546</td>
<td class="headerCovTableEntryHi">91.9 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -65,18 +65,18 @@
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#473">sync_data_reader</a></td>
<td class="coverFnHi">688117</td>
<td class="coverFnHi">688658</td>
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#627">sync_parity_writer</a></td>
<td class="coverFnHi">544283</td>
<td class="coverFnHi">544725</td>
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#416">failed_compare_by_index</a></td>
<td class="coverFnHi">852</td>
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#1409">state_sync</a></td>
<td class="coverFn"><a href="sync.c.gcov.html#1421">state_sync</a></td>
<td class="coverFnHi">87</td>
</tr>
<tr>

10
cov/cmdline/sync.c.func.html
View file

@ -32,8 +32,8 @@
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">502</td>
<td class="headerCovTableEntry">561</td>
<td class="headerCovTableEntryMed">89.5 %</td>
<td class="headerCovTableEntry">546</td>
<td class="headerCovTableEntryHi">91.9 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -72,7 +72,7 @@
<td class="coverFnHi">7</td>
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#1409">state_sync</a></td>
<td class="coverFn"><a href="sync.c.gcov.html#1421">state_sync</a></td>
<td class="coverFnHi">87</td>
</tr>
<tr>
@ -81,11 +81,11 @@
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#473">sync_data_reader</a></td>
<td class="coverFnHi">688117</td>
<td class="coverFnHi">688658</td>
</tr>
<tr>
<td class="coverFn"><a href="sync.c.gcov.html#627">sync_parity_writer</a></td>
<td class="coverFnHi">544283</td>
<td class="coverFnHi">544725</td>
</tr>
</table>
<br>

1576
cov/cmdline/sync.c.gcov.html
View file

File diff suppressed because it is too large Load diff

20
cov/cmdline/unix.c.func-sort-c.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#730">tick</a></td>
<td class="coverFnHi">3816813</td>
<td class="coverFnHi">3819196</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#29">open_noatime</a></td>
<td class="coverFnHi">1719371</td>
<td class="coverFnHi">1719485</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#532">filephy</a></td>
@ -73,23 +73,23 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#494">devuuid</a></td>
<td class="coverFnHi">5624</td>
<td class="coverFnHi">5630</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#395">devuuid_dev</a></td>
<td class="coverFnHi">5620</td>
<td class="coverFnHi">5626</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#626">fsinfo</a></td>
<td class="coverFnHi">5477</td>
<td class="coverFnHi">5483</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#772">randomize</a></td>
<td class="coverFnHi">280</td>
<td class="coverFnHi">281</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#1416">os_init</a></td>
<td class="coverFnHi">269</td>
<td class="coverFnHi">270</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#1431">os_done</a></td>
@ -100,12 +100,12 @@
<td class="coverFnHi">191</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#372">devresolve</a></td>
<td class="coverFn"><a href="unix.c.gcov.html#330">devresolve_sys</a></td>
<td class="coverFnHi">191</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#330">devresolve_sys</a></td>
<td class="coverFnHi">191</td>
<td class="coverFn"><a href="unix.c.gcov.html#372">devresolve</a></td>
<td class="coverFnHi">172</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#798">devread</a></td>

16
cov/cmdline/unix.c.func.html
View file

@ -81,7 +81,7 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#372">devresolve</a></td>
<td class="coverFnHi">191</td>
<td class="coverFnHi">172</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#77">devresolve_proc</a></td>
@ -109,7 +109,7 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#494">devuuid</a></td>
<td class="coverFnHi">5624</td>
<td class="coverFnHi">5630</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#464">devuuid_blkid</a></td>
@ -117,7 +117,7 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#395">devuuid_dev</a></td>
<td class="coverFnHi">5620</td>
<td class="coverFnHi">5626</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#1507">direct_size</a></td>
@ -133,11 +133,11 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#626">fsinfo</a></td>
<td class="coverFnHi">5477</td>
<td class="coverFnHi">5483</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#29">open_noatime</a></td>
<td class="coverFnHi">1719371</td>
<td class="coverFnHi">1719485</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#1500">os_clear</a></td>
@ -149,11 +149,11 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#1416">os_init</a></td>
<td class="coverFnHi">269</td>
<td class="coverFnHi">270</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#772">randomize</a></td>
<td class="coverFnHi">280</td>
<td class="coverFnHi">281</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#48">stat_desc</a></td>
@ -177,7 +177,7 @@
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#730">tick</a></td>
<td class="coverFnHi">3816813</td>
<td class="coverFnHi">3819196</td>
</tr>
<tr>
<td class="coverFn"><a href="unix.c.gcov.html#762">tick_ms</a></td>

136
cov/cmdline/unix.c.gcov.html
View file

@ -90,15 +90,15 @@
<span class="lineNum"> 28 </span> : int exit_failure = 1;
<a name="29"><span class="lineNum"> 29 </span> : int exit_sync_needed = 2;</a>
<span class="lineNum"> 30 </span> :
<span class="lineNum"> 31 </span><span class="lineCov"> 1719371 : int open_noatime(const char* file, int flags)</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 1719485 : int open_noatime(const char* file, int flags)</span>
<span class="lineNum"> 32 </span> : {
<span class="lineNum"> 33 </span> : #ifdef O_NOATIME
<span class="lineNum"> 34 </span><span class="lineCov"> 1719371 : int f = open(file, flags | O_NOATIME);</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 1719485 : int f = open(file, flags | O_NOATIME);</span>
<span class="lineNum"> 35 </span> :
<span class="lineNum"> 36 </span> : /* only root is allowed to use O_NOATIME, in case retry without it */
<span class="lineNum"> 37 </span><span class="lineCov"> 1719426 : if (f == -1 &amp;&amp; errno == EPERM)</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 1719550 : if (f == -1 &amp;&amp; errno == EPERM)</span>
<span class="lineNum"> 38 </span><span class="lineNoCov"> 0 : f = open(file, flags);</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 1719420 : return f;</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 1719558 : return f;</span>
<span class="lineNum"> 40 </span> : #else
<span class="lineNum"> 41 </span> : return open(file, flags);
<span class="lineNum"> 42 </span> : #endif
@ -324,23 +324,23 @@
<span class="lineNum"> 262 </span> : }
<span class="lineNum"> 263 </span> :
<span class="lineNum"> 264 </span><span class="lineCov"> 191 : ret = close(f);</span>
<span class="lineNum"> 265 </span><span class="lineCov"> 190 : if (ret != 0) {</span>
<span class="lineNum"> 265 </span><span class="lineCov"> 191 : if (ret != 0) {</span>
<span class="lineNum"> 266 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 267 </span> : log_fatal(&quot;Failed to close '%s'.\n&quot;, path);
<span class="lineNum"> 268 </span> : return -1;
<span class="lineNum"> 269 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 270 </span> : }
<span class="lineNum"> 271 </span> :
<span class="lineNum"> 272 </span><span class="lineCov"> 190 : buf[len] = 0;</span>
<span class="lineNum"> 273 </span><span class="lineCov"> 190 : tag_len = strlen(tag);</span>
<span class="lineNum"> 272 </span><span class="lineCov"> 191 : buf[len] = 0;</span>
<span class="lineNum"> 273 </span><span class="lineCov"> 191 : tag_len = strlen(tag);</span>
<span class="lineNum"> 274 </span> :
<span class="lineNum"> 275 </span><span class="lineCov"> 3321 : for (i = buf; *i; ++i) {</span>
<span class="lineNum"> 276 </span><span class="lineCov"> 3321 : char* p = i;</span>
<span class="lineNum"> 275 </span><span class="lineCov"> 3324 : for (i = buf; *i; ++i) {</span>
<span class="lineNum"> 276 </span><span class="lineCov"> 3324 : char* p = i;</span>
<span class="lineNum"> 277 </span> :
<span class="lineNum"> 278 </span> : /* start with a space */
<span class="lineNum"> 279 </span><span class="lineCov"> 3321 : if (p != buf) {</span>
<span class="lineNum"> 280 </span><span class="lineCov"> 3130 : if (!isspace(*p))</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 2749 : continue;</span>
<span class="lineNum"> 279 </span><span class="lineCov"> 3324 : if (p != buf) {</span>
<span class="lineNum"> 280 </span><span class="lineCov"> 3133 : if (!isspace(*p))</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 2751 : continue;</span>
<span class="lineNum"> 282 </span><span class="lineCov"> 382 : ++p;</span>
<span class="lineNum"> 283 </span> : }
<span class="lineNum"> 284 </span> :
@ -368,18 +368,18 @@
<span class="lineNum"> 306 </span><span class="lineCov"> 191 : e = i;</span>
<span class="lineNum"> 307 </span><span class="lineCov"> 1020 : while (*e != 0 &amp;&amp; !isspace(*e))</span>
<span class="lineNum"> 308 </span><span class="lineCov"> 638 : ++e;</span>
<span class="lineNum"> 309 </span><span class="lineCov"> 190 : *e = 0;</span>
<span class="lineNum"> 309 </span><span class="lineCov"> 191 : *e = 0;</span>
<span class="lineNum"> 310 </span> :
<span class="lineNum"> 311 </span><span class="lineCov"> 190 : if (!*i) {</span>
<span class="lineNum"> 311 </span><span class="lineCov"> 191 : if (!*i) {</span>
<span class="lineNum"> 312 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 313 </span> : log_fatal(&quot;Empty tag '%s' for '%s'.\n&quot;, tag, path);
<span class="lineNum"> 314 </span> : return -1;
<span class="lineNum"> 315 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 316 </span> : }
<span class="lineNum"> 317 </span> :
<span class="lineNum"> 318 </span><span class="lineCov"> 190 : pathprint(value, value_size, &quot;%s&quot;, i);</span>
<span class="lineNum"> 318 </span><span class="lineCov"> 191 : pathprint(value, value_size, &quot;%s&quot;, i);</span>
<span class="lineNum"> 319 </span> :
<span class="lineNum"> 320 </span><span class="lineCov"> 190 : return 0;</span>
<span class="lineNum"> 320 </span><span class="lineCov"> 191 : return 0;</span>
<span class="lineNum"> 321 </span> : }
<span class="lineNum"> 322 </span> : #endif
<span class="lineNum"> 323 </span> :
@ -407,7 +407,7 @@
<span class="lineNum"> 345 </span> : }
<span class="lineNum"> 346 </span> :
<span class="lineNum"> 347 </span> : /* set the real device path */
<span class="lineNum"> 348 </span><span class="lineCov"> 190 : pathprint(path, path_size, &quot;/dev/%s&quot;, buf);</span>
<span class="lineNum"> 348 </span><span class="lineCov"> 191 : pathprint(path, path_size, &quot;/dev/%s&quot;, buf);</span>
<span class="lineNum"> 349 </span> :
<span class="lineNum"> 350 </span> : /* check the device */
<span class="lineNum"> 351 </span><span class="lineCov"> 191 : if (stat(path, &amp;st) != 0) {</span>
@ -416,14 +416,14 @@
<span class="lineNum"> 354 </span> : return -1;
<span class="lineNum"> 355 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 356 </span> : }
<span class="lineNum"> 357 </span><span class="lineCov"> 190 : if (st.st_rdev != device) {</span>
<span class="lineNum"> 357 </span><span class="lineCov"> 191 : if (st.st_rdev != device) {</span>
<span class="lineNum"> 358 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 359 </span> : log_tag(&quot;resolve:sys:%u:%u: unexpected device '%u:%u' for '%s'.\n&quot;, major(device), minor(device), major(st.st_rdev), minor(st.st_rdev), path);
<span class="lineNum"> 360 </span> : return -1;
<span class="lineNum"> 361 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 362 </span> : }
<span class="lineNum"> 363 </span> :
<span class="lineNum"> 364 </span><span class="lineCov"> 190 : log_tag(&quot;resolve:sys:%u:%u:%s: found\n&quot;, major(device), minor(device), path);</span>
<span class="lineNum"> 364 </span><span class="lineCov"> 191 : log_tag(&quot;resolve:sys:%u:%u:%s: found\n&quot;, major(device), minor(device), path);</span>
<span class="lineNum"> 365 </span> :
<span class="lineNum"> 366 </span><span class="lineCov"> 191 : return 0;</span>
<span class="lineNum"> 367 </span> : }
@ -433,9 +433,9 @@
<span class="lineNum"> 371 </span> : * Get the device file from the device number.
<a name="372"><span class="lineNum"> 372 </span> : */</a>
<span class="lineNum"> 373 </span> : #if HAVE_LINUX_DEVICE
<span class="lineNum"> 374 </span><span class="lineCov"> 191 : static int devresolve(uint64_t device, char* path, size_t path_size)</span>
<span class="lineNum"> 374 </span><span class="lineCov"> 172 : static int devresolve(uint64_t device, char* path, size_t path_size)</span>
<span class="lineNum"> 375 </span> : {
<span class="lineNum"> 376 </span><span class="lineCov"> 191 : if (devresolve_sys(device, path, path_size) == 0)</span>
<span class="lineNum"> 376 </span><span class="lineCov"> 172 : if (devresolve_sys(device, path, path_size) == 0)</span>
<span class="lineNum"> 377 </span><span class="lineCov"> 191 : return 0;</span>
<span class="lineNum"> 378 </span> :
<span class="lineNum"> 379 </span><span class="lineNoCov"> 0 : return -1;</span>
@ -456,7 +456,7 @@
<span class="lineNum"> 394 </span> : * in /dev/disk/by-uuid/.
<a name="395"><span class="lineNum"> 395 </span> : */</a>
<span class="lineNum"> 396 </span> : #if HAVE_LINUX_DEVICE
<span class="lineNum"> 397 </span><span class="lineCov"> 5620 : static int devuuid_dev(uint64_t device, char* uuid, size_t uuid_size)</span>
<span class="lineNum"> 397 </span><span class="lineCov"> 5626 : static int devuuid_dev(uint64_t device, char* uuid, size_t uuid_size)</span>
<span class="lineNum"> 398 </span> : {
<span class="lineNum"> 399 </span> : int ret;
<span class="lineNum"> 400 </span> : DIR* d;
@ -464,47 +464,47 @@
<span class="lineNum"> 402 </span> : struct stat st;
<span class="lineNum"> 403 </span> :
<span class="lineNum"> 404 </span> : /* scan the UUID directory searching for the device */
<span class="lineNum"> 405 </span><span class="lineCov"> 5620 : d = opendir(&quot;/dev/disk/by-uuid&quot;);</span>
<span class="lineNum"> 406 </span><span class="lineCov"> 5620 : if (!d) {</span>
<span class="lineNum"> 405 </span><span class="lineCov"> 5626 : d = opendir(&quot;/dev/disk/by-uuid&quot;);</span>
<span class="lineNum"> 406 </span><span class="lineCov"> 5626 : if (!d) {</span>
<span class="lineNum"> 407 </span><span class="lineNoCov"> 0 : log_tag(&quot;uuid:by-uuidd:%u:%u: opendir(/dev/disk/by-uuid) failed, %s\n&quot;, major(device), minor(device), strerror(errno));</span>
<span class="lineNum"> 408 </span> : /* directory missing?, likely we are not in Linux */
<span class="lineNum"> 409 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 410 </span> : }
<span class="lineNum"> 411 </span> :
<span class="lineNum"> 412 </span><span class="lineCov"> 95540 : while ((dd = readdir(d)) != 0) {</span>
<span class="lineNum"> 412 </span><span class="lineCov"> 95642 : while ((dd = readdir(d)) != 0) {</span>
<span class="lineNum"> 413 </span> : /* skip &quot;.&quot; and &quot;..&quot; files, UUIDs never start with '.' */
<span class="lineNum"> 414 </span><span class="lineCov"> 89920 : if (dd-&gt;d_name[0] == '.')</span>
<span class="lineNum"> 415 </span><span class="lineCov"> 11240 : continue;</span>
<span class="lineNum"> 414 </span><span class="lineCov"> 90016 : if (dd-&gt;d_name[0] == '.')</span>
<span class="lineNum"> 415 </span><span class="lineCov"> 11252 : continue;</span>
<span class="lineNum"> 416 </span> :
<span class="lineNum"> 417 </span><span class="lineCov"> 78680 : ret = fstatat(dirfd(d), dd-&gt;d_name, &amp;st, 0);</span>
<span class="lineNum"> 418 </span><span class="lineCov"> 78680 : if (ret != 0) {</span>
<span class="lineNum"> 417 </span><span class="lineCov"> 78764 : ret = fstatat(dirfd(d), dd-&gt;d_name, &amp;st, 0);</span>
<span class="lineNum"> 418 </span><span class="lineCov"> 78764 : if (ret != 0) {</span>
<span class="lineNum"> 419 </span><span class="lineNoCov"> 0 : log_tag(&quot;uuid:by-uuidd:%u:%u: fstatat(%s) failed, %s\n&quot;, major(device), minor(device), dd-&gt;d_name, strerror(errno));</span>
<span class="lineNum"> 420 </span> : /* generic error, ignore and continue the search */
<span class="lineNum"> 421 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 422 </span> : }
<span class="lineNum"> 423 </span> :
<span class="lineNum"> 424 </span> : /* if it matches, we have the uuid */
<span class="lineNum"> 425 </span><span class="lineCov"> 78680 : if (S_ISBLK(st.st_mode) &amp;&amp; st.st_rdev == (dev_t)device) {</span>
<span class="lineNum"> 425 </span><span class="lineCov"> 78764 : if (S_ISBLK(st.st_mode) &amp;&amp; st.st_rdev == (dev_t)device) {</span>
<span class="lineNum"> 426 </span> : char buf[PATH_MAX];
<span class="lineNum"> 427 </span> : char path[PATH_MAX];
<span class="lineNum"> 428 </span> :
<span class="lineNum"> 429 </span> : /* resolve the link */
<span class="lineNum"> 430 </span><span class="lineCov"> 5620 : pathprint(path, sizeof(path), &quot;/dev/disk/by-uuid/%s&quot;, dd-&gt;d_name);</span>
<span class="lineNum"> 431 </span><span class="lineCov"> 5620 : ret = readlink(path, buf, sizeof(buf));</span>
<span class="lineNum"> 432 </span><span class="lineCov"> 5620 : if (ret &lt; 0 || ret == sizeof(buf)) {</span>
<span class="lineNum"> 430 </span><span class="lineCov"> 5626 : pathprint(path, sizeof(path), &quot;/dev/disk/by-uuid/%s&quot;, dd-&gt;d_name);</span>
<span class="lineNum"> 431 </span><span class="lineCov"> 5626 : ret = readlink(path, buf, sizeof(buf));</span>
<span class="lineNum"> 432 </span><span class="lineCov"> 5626 : if (ret &lt; 0 || ret == sizeof(buf)) {</span>
<span class="lineNum"> 433 </span><span class="lineNoCov"> 0 : log_tag(&quot;uuid:by-uuidd:%u:%u: readlink(/dev/disk/by-uuid/%s) failed, %s\n&quot;, major(device), minor(device), dd-&gt;d_name, strerror(errno));</span>
<span class="lineNum"> 434 </span> : /* generic error, ignore and continue the search */
<span class="lineNum"> 435 </span><span class="lineNoCov"> 0 : continue;</span>
<span class="lineNum"> 436 </span> : }
<span class="lineNum"> 437 </span><span class="lineCov"> 5620 : buf[ret] = 0;</span>
<span class="lineNum"> 437 </span><span class="lineCov"> 5626 : buf[ret] = 0;</span>
<span class="lineNum"> 438 </span> :
<span class="lineNum"> 439 </span> : /* found */
<span class="lineNum"> 440 </span><span class="lineCov"> 5620 : pathcpy(uuid, uuid_size, dd-&gt;d_name);</span>
<span class="lineNum"> 440 </span><span class="lineCov"> 5626 : pathcpy(uuid, uuid_size, dd-&gt;d_name);</span>
<span class="lineNum"> 441 </span> :
<span class="lineNum"> 442 </span><span class="lineCov"> 5620 : log_tag(&quot;uuid:by-uuid:%u:%u:%s: found %s\n&quot;, major(device), minor(device), uuid, buf);</span>
<span class="lineNum"> 442 </span><span class="lineCov"> 5626 : log_tag(&quot;uuid:by-uuid:%u:%u:%s: found %s\n&quot;, major(device), minor(device), uuid, buf);</span>
<span class="lineNum"> 443 </span> :
<span class="lineNum"> 444 </span><span class="lineCov"> 5620 : closedir(d);</span>
<span class="lineNum"> 445 </span><span class="lineCov"> 5620 : return 0;</span>
<span class="lineNum"> 444 </span><span class="lineCov"> 5626 : closedir(d);</span>
<span class="lineNum"> 445 </span><span class="lineCov"> 5626 : return 0;</span>
<span class="lineNum"> 446 </span> : }
<span class="lineNum"> 447 </span> : }
<span class="lineNum"> 448 </span> :
@ -555,11 +555,11 @@
<span class="lineNum"> 493 </span> : }
<a name="494"><span class="lineNum"> 494 </span> : #endif</a>
<span class="lineNum"> 495 </span> :
<span class="lineNum"> 496 </span><span class="lineCov"> 5624 : int devuuid(uint64_t device, char* uuid, size_t uuid_size)</span>
<span class="lineNum"> 496 </span><span class="lineCov"> 5630 : int devuuid(uint64_t device, char* uuid, size_t uuid_size)</span>
<span class="lineNum"> 497 </span> : {
<span class="lineNum"> 498 </span> : #if HAVE_LINUX_DEVICE
<span class="lineNum"> 499 </span> : /* if the major is the null device */
<span class="lineNum"> 500 </span><span class="lineCov"> 5624 : if (major(device) == 0) {</span>
<span class="lineNum"> 500 </span><span class="lineCov"> 5630 : if (major(device) == 0) {</span>
<span class="lineNum"> 501 </span> : /* obtain the real device */
<span class="lineNum"> 502 </span><span class="lineCov"> 4 : if (devdereference(device, &amp;device) != 0) {</span>
<span class="lineNum"> 503 </span> : /* LCOV_EXCL_START */
@ -571,8 +571,8 @@
<span class="lineNum"> 509 </span> :
<span class="lineNum"> 510 </span> : /* first try with the /dev/disk/by-uuid version */
<span class="lineNum"> 511 </span> : #if HAVE_LINUX_DEVICE
<span class="lineNum"> 512 </span><span class="lineCov"> 5620 : if (devuuid_dev(device, uuid, uuid_size) == 0)</span>
<span class="lineNum"> 513 </span><span class="lineCov"> 5620 : return 0;</span>
<span class="lineNum"> 512 </span><span class="lineCov"> 5626 : if (devuuid_dev(device, uuid, uuid_size) == 0)</span>
<span class="lineNum"> 513 </span><span class="lineCov"> 5626 : return 0;</span>
<span class="lineNum"> 514 </span> : #else
<span class="lineNum"> 515 </span> : log_tag(&quot;uuid:by-uuidd:%u:%u: by-uuid not supported\n&quot;, major(device), minor(device));
<span class="lineNum"> 516 </span> : #endif
@ -687,7 +687,7 @@
<span class="lineNum"> 625 </span><span class="lineNoCov"> 0 : return 0;</span>
<a name="626"><span class="lineNum"> 626 </span> : }</a>
<span class="lineNum"> 627 </span> :
<span class="lineNum"> 628 </span><span class="lineCov"> 5477 : int fsinfo(const char* path, int* has_persistent_inode, uint64_t* total_space, uint64_t* free_space)</span>
<span class="lineNum"> 628 </span><span class="lineCov"> 5483 : int fsinfo(const char* path, int* has_persistent_inode, uint64_t* total_space, uint64_t* free_space)</span>
<span class="lineNum"> 629 </span> : {
<span class="lineNum"> 630 </span> : char type[64];
<span class="lineNum"> 631 </span> : const char* ptype;
@ -695,7 +695,7 @@
<span class="lineNum"> 633 </span> : #if HAVE_STATFS
<span class="lineNum"> 634 </span> : struct statfs st;
<span class="lineNum"> 635 </span> :
<span class="lineNum"> 636 </span><span class="lineCov"> 5477 : if (statfs(path, &amp;st) != 0) {</span>
<span class="lineNum"> 636 </span><span class="lineCov"> 5483 : if (statfs(path, &amp;st) != 0) {</span>
<span class="lineNum"> 637 </span> : char dir[PATH_MAX];
<span class="lineNum"> 638 </span> : char* slash;
<span class="lineNum"> 639 </span> :
@ -723,17 +723,17 @@
<span class="lineNum"> 661 </span> : #endif
<span class="lineNum"> 662 </span> :
<span class="lineNum"> 663 </span> : /* to get the fs type check &quot;man stat&quot; or &quot;stat -f -t FILE&quot; */
<span class="lineNum"> 664 </span><span class="lineCov"> 5477 : if (has_persistent_inode) {</span>
<span class="lineNum"> 664 </span><span class="lineCov"> 5483 : if (has_persistent_inode) {</span>
<span class="lineNum"> 665 </span> : #if HAVE_STATFS &amp;&amp; HAVE_STRUCT_STATFS_F_TYPE
<span class="lineNum"> 666 </span><span class="lineCov"> 569 : switch (st.f_type) {</span>
<span class="lineNum"> 666 </span><span class="lineCov"> 575 : switch (st.f_type) {</span>
<span class="lineNum"> 667 </span> : case 0x65735546 : /* FUSE, &quot;fuseblk&quot; in the stat command */
<span class="lineNum"> 668 </span> : case 0x4d44 : /* VFAT, &quot;msdos&quot; in the stat command */
<span class="lineNum"> 669 </span><span class="lineNoCov"> 0 : *has_persistent_inode = 0;</span>
<span class="lineNum"> 670 </span><span class="lineNoCov"> 0 : break;</span>
<span class="lineNum"> 671 </span> : default :
<span class="lineNum"> 672 </span> : /* by default assume yes */
<span class="lineNum"> 673 </span><span class="lineCov"> 569 : *has_persistent_inode = 1;</span>
<span class="lineNum"> 674 </span><span class="lineCov"> 569 : break;</span>
<span class="lineNum"> 673 </span><span class="lineCov"> 575 : *has_persistent_inode = 1;</span>
<span class="lineNum"> 674 </span><span class="lineCov"> 575 : break;</span>
<span class="lineNum"> 675 </span> : }
<span class="lineNum"> 676 </span> : #else
<span class="lineNum"> 677 </span> : /* by default assume yes */
@ -741,7 +741,7 @@
<span class="lineNum"> 679 </span> : #endif
<span class="lineNum"> 680 </span> : }
<span class="lineNum"> 681 </span> :
<span class="lineNum"> 682 </span><span class="lineCov"> 5477 : if (total_space) {</span>
<span class="lineNum"> 682 </span><span class="lineCov"> 5483 : if (total_space) {</span>
<span class="lineNum"> 683 </span> : #if HAVE_STATFS
<span class="lineNum"> 684 </span><span class="lineCov"> 4908 : *total_space = st.f_bsize * (uint64_t)st.f_blocks;</span>
<span class="lineNum"> 685 </span> : #else
@ -749,7 +749,7 @@
<span class="lineNum"> 687 </span> : #endif
<span class="lineNum"> 688 </span> : }
<span class="lineNum"> 689 </span> :
<span class="lineNum"> 690 </span><span class="lineCov"> 5477 : if (free_space) {</span>
<span class="lineNum"> 690 </span><span class="lineCov"> 5483 : if (free_space) {</span>
<span class="lineNum"> 691 </span> : #if HAVE_STATFS
<span class="lineNum"> 692 </span><span class="lineCov"> 4908 : *free_space = st.f_bsize * (uint64_t)st.f_bfree;</span>
<span class="lineNum"> 693 </span> : #else
@ -764,10 +764,10 @@
<span class="lineNum"> 702 </span> : #elif HAVE_STATFS &amp;&amp; HAVE_STRUCT_STATFS_F_TYPE
<span class="lineNum"> 703 </span> : /* get the filesystem type from f_type (Linux) */
<span class="lineNum"> 704 </span> : /* from: https://github.com/influxdata/gopsutil/blob/master/disk/disk_linux.go */
<span class="lineNum"> 705 </span><span class="lineCov"> 5477 : switch (st.f_type) {</span>
<span class="lineNum"> 705 </span><span class="lineCov"> 5483 : switch (st.f_type) {</span>
<span class="lineNum"> 706 </span><span class="lineNoCov"> 0 : case 0x65735546 : ptype = &quot;fuseblk&quot;; break;</span>
<span class="lineNum"> 707 </span><span class="lineNoCov"> 0 : case 0x4D44 : ptype = &quot;vfat/msdos&quot;; break;</span>
<span class="lineNum"> 708 </span><span class="lineCov"> 5477 : case 0xEF53 : ptype = &quot;ext2/3/4&quot;; break;</span>
<span class="lineNum"> 708 </span><span class="lineCov"> 5483 : case 0xEF53 : ptype = &quot;ext2/3/4&quot;; break;</span>
<span class="lineNum"> 709 </span><span class="lineNoCov"> 0 : case 0x6969 : ptype = &quot;nfs&quot;; break; /* remote */</span>
<span class="lineNum"> 710 </span><span class="lineNoCov"> 0 : case 0x6E667364 : ptype = &quot;nfsd&quot;; break; /* remote */</span>
<span class="lineNum"> 711 </span><span class="lineNoCov"> 0 : case 0x517B : ptype = &quot;smb&quot;; break; /* remote */</span>
@ -786,12 +786,12 @@
<span class="lineNum"> 724 </span> : ptype = &quot;unknown&quot;;
<span class="lineNum"> 725 </span> : #endif
<span class="lineNum"> 726 </span> :
<span class="lineNum"> 727 </span><span class="lineCov"> 5477 : log_tag(&quot;statfs:%s: %s \n&quot;, ptype, path);</span>
<span class="lineNum"> 727 </span><span class="lineCov"> 5483 : log_tag(&quot;statfs:%s: %s \n&quot;, ptype, path);</span>
<span class="lineNum"> 728 </span> :
<span class="lineNum"> 729 </span><span class="lineCov"> 5477 : return 0;</span>
<span class="lineNum"> 729 </span><span class="lineCov"> 5483 : return 0;</span>
<a name="730"><span class="lineNum"> 730 </span> : }</a>
<span class="lineNum"> 731 </span> :
<span class="lineNum"> 732 </span><span class="lineCov"> 3816813 : uint64_t tick(void)</span>
<span class="lineNum"> 732 </span><span class="lineCov"> 3819196 : uint64_t tick(void)</span>
<span class="lineNum"> 733 </span> : {
<span class="lineNum"> 734 </span> : #if HAVE_MACH_ABSOLUTE_TIME
<span class="lineNum"> 735 </span> : /* for Mac OS X */
@ -802,14 +802,14 @@
<span class="lineNum"> 740 </span> :
<span class="lineNum"> 741 </span> : /* nanosecond precision with clock_gettime() */
<span class="lineNum"> 742 </span> : #if defined(CLOCK_MONOTONIC_RAW)
<span class="lineNum"> 743 </span><span class="lineCov"> 3816813 : if (clock_gettime(CLOCK_MONOTONIC_RAW, &amp;tv) != 0) {</span>
<span class="lineNum"> 743 </span><span class="lineCov"> 3819196 : if (clock_gettime(CLOCK_MONOTONIC_RAW, &amp;tv) != 0) {</span>
<span class="lineNum"> 744 </span> : #else
<span class="lineNum"> 745 </span> : if (clock_gettime(CLOCK_MONOTONIC, &amp;tv) != 0) {
<span class="lineNum"> 746 </span> : #endif
<span class="lineNum"> 747 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 748 </span> : }
<span class="lineNum"> 749 </span> :
<span class="lineNum"> 750 </span><span class="lineCov"> 3816813 : return tv.tv_sec * 1000000000ULL + tv.tv_nsec;</span>
<span class="lineNum"> 750 </span><span class="lineCov"> 3819196 : return tv.tv_sec * 1000000000ULL + tv.tv_nsec;</span>
<span class="lineNum"> 751 </span> : #else
<span class="lineNum"> 752 </span> : /* other platforms */
<span class="lineNum"> 753 </span> : struct timeval tv;
@ -833,25 +833,25 @@
<span class="lineNum"> 771 </span><span class="lineCov"> 65 : return tv.tv_sec * 1000ULL + tv.tv_usec / 1000;</span>
<a name="772"><span class="lineNum"> 772 </span> : }</a>
<span class="lineNum"> 773 </span> :
<span class="lineNum"> 774 </span><span class="lineCov"> 280 : int randomize(void* ptr, size_t size)</span>
<span class="lineNum"> 774 </span><span class="lineCov"> 281 : int randomize(void* ptr, size_t size)</span>
<span class="lineNum"> 775 </span> : {
<span class="lineNum"> 776 </span> : int f;
<span class="lineNum"> 777 </span> : ssize_t ret;
<span class="lineNum"> 778 </span> :
<span class="lineNum"> 779 </span><span class="lineCov"> 280 : f = open(&quot;/dev/urandom&quot;, O_RDONLY);</span>
<span class="lineNum"> 780 </span><span class="lineCov"> 280 : if (f == -1)</span>
<span class="lineNum"> 779 </span><span class="lineCov"> 281 : f = open(&quot;/dev/urandom&quot;, O_RDONLY);</span>
<span class="lineNum"> 780 </span><span class="lineCov"> 281 : if (f == -1)</span>
<span class="lineNum"> 781 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 782 </span> :
<span class="lineNum"> 783 </span><span class="lineCov"> 280 : ret = read(f, ptr, size);</span>
<span class="lineNum"> 784 </span><span class="lineCov"> 280 : if (ret &lt; 0 || (size_t)ret != size) {</span>
<span class="lineNum"> 783 </span><span class="lineCov"> 281 : ret = read(f, ptr, size);</span>
<span class="lineNum"> 784 </span><span class="lineCov"> 281 : if (ret &lt; 0 || (size_t)ret != size) {</span>
<span class="lineNum"> 785 </span><span class="lineNoCov"> 0 : close(f);</span>
<span class="lineNum"> 786 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 787 </span> : }
<span class="lineNum"> 788 </span> :
<span class="lineNum"> 789 </span><span class="lineCov"> 280 : if (close(f) != 0)</span>
<span class="lineNum"> 789 </span><span class="lineCov"> 281 : if (close(f) != 0)</span>
<span class="lineNum"> 790 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 791 </span> :
<span class="lineNum"> 792 </span><span class="lineCov"> 280 : return 0;</span>
<span class="lineNum"> 792 </span><span class="lineCov"> 281 : return 0;</span>
<span class="lineNum"> 793 </span> : }
<span class="lineNum"> 794 </span> :
<span class="lineNum"> 795 </span> : /**
@ -1477,12 +1477,12 @@
<span class="lineNum"> 1415 </span><span class="lineCov"> 3 : return device_thread(low, func);</span>
<a name="1416"><span class="lineNum"> 1416 </span> : }</a>
<span class="lineNum"> 1417 </span> :
<span class="lineNum"> 1418 </span><span class="lineCov"> 269 : void os_init(int opt)</span>
<span class="lineNum"> 1418 </span><span class="lineCov"> 270 : void os_init(int opt)</span>
<span class="lineNum"> 1419 </span> : {
<span class="lineNum"> 1420 </span> : #if HAVE_BLKID
<span class="lineNum"> 1421 </span> : int ret;
<span class="lineNum"> 1422 </span><span class="lineCov"> 269 : ret = blkid_get_cache(&amp;cache, NULL);</span>
<span class="lineNum"> 1423 </span><span class="lineCov"> 269 : if (ret != 0) {</span>
<span class="lineNum"> 1422 </span><span class="lineCov"> 270 : ret = blkid_get_cache(&amp;cache, NULL);</span>
<span class="lineNum"> 1423 </span><span class="lineCov"> 270 : if (ret != 0) {</span>
<span class="lineNum"> 1424 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 1425 </span> : log_fatal(&quot;WARNING Failed to get blkid cache\n&quot;);
<span class="lineNum"> 1426 </span> : /* LCOV_EXCL_STOP */
@ -1490,7 +1490,7 @@
<span class="lineNum"> 1428 </span> : #endif
<span class="lineNum"> 1429 </span> :
<span class="lineNum"> 1430 </span> : (void)opt;
<a name="1431"><span class="lineNum"> 1431 </span><span class="lineCov"> 269 : }</span></a>
<a name="1431"><span class="lineNum"> 1431 </span><span class="lineCov"> 270 : }</span></a>
<span class="lineNum"> 1432 </span> :
<span class="lineNum"> 1433 </span><span class="lineCov"> 247 : void os_done(void)</span>
<span class="lineNum"> 1434 </span> : {

22
cov/cmdline/util.c.func-sort-c.html
View file

@ -61,23 +61,23 @@
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#461">util_rotl32</a></td>
<td class="coverFnHi">854114224</td>
<td class="coverFnHi">854131328</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#466">util_rotl64</a></td>
<td class="coverFnHi">512217108</td>
<td class="coverFnHi">512341560</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#509">memhash</a></td>
<td class="coverFnHi">5937808</td>
<td class="coverFnHi">5938723</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#429">crc32c_x86</a></td>
<td class="coverFnHi">646614</td>
<td class="coverFnHi">646609</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#540">memdiff</a></td>
<td class="coverFnHi">93184</td>
<td class="coverFnHi">93321</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#58">malloc_nofail_vector_align</a></td>
@ -85,27 +85,27 @@
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#131">mtest_vector</a></td>
<td class="coverFnHi">1951</td>
<td class="coverFnHi">1953</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#90">malloc_nofail_test</a></td>
<td class="coverFnHi">1951</td>
<td class="coverFnHi">1953</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#107">fast_mtest_vector</a></td>
<td class="coverFnHi">1951</td>
<td class="coverFnHi">1953</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#417">crc32c_gen</a></td>
<td class="coverFnHi">361</td>
<td class="coverFnHi">345</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#443">crc32c_init</a></td>
<td class="coverFnHi">285</td>
<td class="coverFnHi">286</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#563">lock_lock</a></td>
<td class="coverFnHi">260</td>
<td class="coverFnHi">261</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#587">lock_unlock</a></td>

22
cov/cmdline/util.c.func.html
View file

@ -61,19 +61,19 @@
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#417">crc32c_gen</a></td>
<td class="coverFnHi">361</td>
<td class="coverFnHi">345</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#443">crc32c_init</a></td>
<td class="coverFnHi">285</td>
<td class="coverFnHi">286</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#429">crc32c_x86</a></td>
<td class="coverFnHi">646614</td>
<td class="coverFnHi">646609</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#107">fast_mtest_vector</a></td>
<td class="coverFnHi">1951</td>
<td class="coverFnHi">1953</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#527">hash_config_name</a></td>
@ -81,7 +81,7 @@
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#563">lock_lock</a></td>
<td class="coverFnHi">260</td>
<td class="coverFnHi">261</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#587">lock_unlock</a></td>
@ -97,7 +97,7 @@
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#90">malloc_nofail_test</a></td>
<td class="coverFnHi">1951</td>
<td class="coverFnHi">1953</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#58">malloc_nofail_vector_align</a></td>
@ -109,23 +109,23 @@
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#540">memdiff</a></td>
<td class="coverFnHi">93184</td>
<td class="coverFnHi">93321</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#509">memhash</a></td>
<td class="coverFnHi">5937808</td>
<td class="coverFnHi">5938723</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#131">mtest_vector</a></td>
<td class="coverFnHi">1951</td>
<td class="coverFnHi">1953</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#461">util_rotl32</a></td>
<td class="coverFnHi">854114224</td>
<td class="coverFnHi">854131328</td>
</tr>
<tr>
<td class="coverFn"><a href="util.c.gcov.html#466">util_rotl64</a></td>
<td class="coverFnHi">512217108</td>
<td class="coverFnHi">512341560</td>
</tr>
</table>
<br>

112
cov/cmdline/util.c.gcov.html
View file

@ -151,15 +151,15 @@
<span class="lineNum"> 89 </span><span class="lineNoCov"> 0 : return ptr;</span>
<a name="90"><span class="lineNum"> 90 </span> : }</a>
<span class="lineNum"> 91 </span> :
<span class="lineNum"> 92 </span><span class="lineCov"> 1951 : void* malloc_nofail_test(size_t size)</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 1953 : void* malloc_nofail_test(size_t size)</span>
<span class="lineNum"> 93 </span> : {
<span class="lineNum"> 94 </span> : void* ptr;
<span class="lineNum"> 95 </span> :
<span class="lineNum"> 96 </span><span class="lineCov"> 1951 : ptr = malloc_nofail(size);</span>
<span class="lineNum"> 96 </span><span class="lineCov"> 1953 : ptr = malloc_nofail(size);</span>
<span class="lineNum"> 97 </span> :
<span class="lineNum"> 98 </span><span class="lineCov"> 1951 : mtest_vector(1, size, &amp;ptr);</span>
<span class="lineNum"> 98 </span><span class="lineCov"> 1953 : mtest_vector(1, size, &amp;ptr);</span>
<span class="lineNum"> 99 </span> :
<span class="lineNum"> 100 </span><span class="lineCov"> 1951 : return ptr;</span>
<span class="lineNum"> 100 </span><span class="lineCov"> 1953 : return ptr;</span>
<span class="lineNum"> 101 </span> : }
<span class="lineNum"> 102 </span> :
<span class="lineNum"> 103 </span> : /**
@ -168,40 +168,40 @@
<span class="lineNum"> 106 </span> : * It's similar at raid_mtest_vector() but faster because
<a name="107"><span class="lineNum"> 107 </span> : * we have a lot of buffers to verify.</a>
<span class="lineNum"> 108 </span> : */
<span class="lineNum"> 109 </span><span class="lineCov"> 1951 : static int fast_mtest_vector(int n, size_t size, void** vv)</span>
<span class="lineNum"> 109 </span><span class="lineCov"> 1953 : static int fast_mtest_vector(int n, size_t size, void** vv)</span>
<span class="lineNum"> 110 </span> : {
<span class="lineNum"> 111 </span> : int i, j;
<span class="lineNum"> 112 </span> :
<span class="lineNum"> 113 </span> : /* test with all the bits */
<span class="lineNum"> 114 </span><span class="lineCov"> 17559 : for (i = 0; i &lt; 8; ++i) {</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 15608 : unsigned char value = 1 &lt;&lt; i;</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 17577 : for (i = 0; i &lt; 8; ++i) {</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 15624 : unsigned char value = 1 &lt;&lt; i;</span>
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span> : /* fill first */
<span class="lineNum"> 118 </span><span class="lineCov"> 15608 : memset(vv[0], value, size);</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 15624 : memset(vv[0], value, size);</span>
<span class="lineNum"> 119 </span> :
<span class="lineNum"> 120 </span> : /* copy to the next */
<span class="lineNum"> 121 </span><span class="lineCov"> 15608 : for (j = 1; j &lt; n; ++j)</span>
<span class="lineNum"> 121 </span><span class="lineCov"> 15624 : for (j = 1; j &lt; n; ++j)</span>
<span class="lineNum"> 122 </span><span class="lineNoCov"> 0 : memcpy(vv[j], vv[j - 1], size);</span>
<span class="lineNum"> 123 </span> :
<span class="lineNum"> 124 </span> : /* compare with the previous */
<span class="lineNum"> 125 </span><span class="lineCov"> 31216 : for (j = 1; j &lt;= n; ++j)</span>
<span class="lineNum"> 126 </span><span class="lineCov"> 15608 : if (memcmp(vv[j % n], vv[j - 1], size) != 0)</span>
<span class="lineNum"> 125 </span><span class="lineCov"> 31248 : for (j = 1; j &lt;= n; ++j)</span>
<span class="lineNum"> 126 </span><span class="lineCov"> 15624 : if (memcmp(vv[j % n], vv[j - 1], size) != 0)</span>
<span class="lineNum"> 127 </span><span class="lineNoCov"> 0 : return -1;</span>
<span class="lineNum"> 128 </span> : }
<span class="lineNum"> 129 </span> :
<span class="lineNum"> 130 </span><span class="lineCov"> 1951 : return 0;</span>
<span class="lineNum"> 130 </span><span class="lineCov"> 1953 : return 0;</span>
<a name="131"><span class="lineNum"> 131 </span> : }</a>
<span class="lineNum"> 132 </span> :
<span class="lineNum"> 133 </span><span class="lineCov"> 1951 : void mtest_vector(int n, size_t size, void** vv)</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 1953 : void mtest_vector(int n, size_t size, void** vv)</span>
<span class="lineNum"> 134 </span> : {
<span class="lineNum"> 135 </span><span class="lineCov"> 1951 : if (fast_mtest_vector(n, size, vv) != 0) {</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 1953 : if (fast_mtest_vector(n, size, vv) != 0) {</span>
<span class="lineNum"> 136 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 137 </span> : log_fatal(&quot;DANGER! Your RAM memory is broken! DO NOT PROCEED UNTIL FIXED!\n&quot;);
<span class="lineNum"> 138 </span> : log_fatal(&quot;Try running a memory test like http://www.memtest86.com/\n&quot;);
<span class="lineNum"> 139 </span> : exit(EXIT_FAILURE);
<span class="lineNum"> 140 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 141 </span> : }
<span class="lineNum"> 142 </span><span class="lineCov"> 1951 : }</span>
<span class="lineNum"> 142 </span><span class="lineCov"> 1953 : }</span>
<span class="lineNum"> 143 </span> :
<span class="lineNum"> 144 </span> : /****************************************************************************/
<span class="lineNum"> 145 </span> : /* crc */
@ -478,42 +478,42 @@
<span class="lineNum"> 416 </span> : int crc_x86;
<a name="417"><span class="lineNum"> 417 </span> : #endif</a>
<span class="lineNum"> 418 </span> :
<span class="lineNum"> 419 </span><span class="lineCov"> 361 : uint32_t crc32c_gen(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 419 </span><span class="lineCov"> 345 : uint32_t crc32c_gen(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 420 </span> : {
<span class="lineNum"> 421 </span><span class="lineCov"> 361 : crc ^= CRC_IV;</span>
<span class="lineNum"> 421 </span><span class="lineCov"> 345 : crc ^= CRC_IV;</span>
<span class="lineNum"> 422 </span> :
<span class="lineNum"> 423 </span><span class="lineCov"> 361 : crc = crc32c_gen_plain(crc, ptr, size);</span>
<span class="lineNum"> 423 </span><span class="lineCov"> 345 : crc = crc32c_gen_plain(crc, ptr, size);</span>
<span class="lineNum"> 424 </span> :
<span class="lineNum"> 425 </span><span class="lineCov"> 361 : crc ^= CRC_IV;</span>
<span class="lineNum"> 425 </span><span class="lineCov"> 345 : crc ^= CRC_IV;</span>
<span class="lineNum"> 426 </span> :
<span class="lineNum"> 427 </span><span class="lineCov"> 361 : return crc;</span>
<span class="lineNum"> 427 </span><span class="lineCov"> 345 : return crc;</span>
<span class="lineNum"> 428 </span> : }
<a name="429"><span class="lineNum"> 429 </span> : </a>
<span class="lineNum"> 430 </span> : #if HAVE_SSE42
<span class="lineNum"> 431 </span><span class="lineCov"> 646614 : uint32_t crc32c_x86(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 431 </span><span class="lineCov"> 646609 : uint32_t crc32c_x86(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 432 </span> : {
<span class="lineNum"> 433 </span><span class="lineCov"> 646614 : crc ^= CRC_IV;</span>
<span class="lineNum"> 433 </span><span class="lineCov"> 646609 : crc ^= CRC_IV;</span>
<span class="lineNum"> 434 </span> :
<span class="lineNum"> 435 </span><span class="lineCov"> 646614 : crc = crc32c_x86_plain(crc, ptr, size);</span>
<span class="lineNum"> 435 </span><span class="lineCov"> 646609 : crc = crc32c_x86_plain(crc, ptr, size);</span>
<span class="lineNum"> 436 </span> :
<span class="lineNum"> 437 </span><span class="lineCov"> 646610 : crc ^= CRC_IV;</span>
<span class="lineNum"> 437 </span><span class="lineCov"> 646607 : crc ^= CRC_IV;</span>
<span class="lineNum"> 438 </span> :
<span class="lineNum"> 439 </span><span class="lineCov"> 646610 : return crc;</span>
<span class="lineNum"> 439 </span><span class="lineCov"> 646607 : return crc;</span>
<span class="lineNum"> 440 </span> : }
<span class="lineNum"> 441 </span> : #endif
<span class="lineNum"> 442 </span> :
<a name="443"><span class="lineNum"> 443 </span> : uint32_t (*crc32c)(uint32_t crc, const unsigned char* ptr, unsigned size);</a>
<span class="lineNum"> 444 </span> :
<span class="lineNum"> 445 </span><span class="lineCov"> 285 : void crc32c_init(void)</span>
<span class="lineNum"> 445 </span><span class="lineCov"> 286 : void crc32c_init(void)</span>
<span class="lineNum"> 446 </span> : {
<span class="lineNum"> 447 </span><span class="lineCov"> 285 : crc32c = crc32c_gen;</span>
<span class="lineNum"> 447 </span><span class="lineCov"> 286 : crc32c = crc32c_gen;</span>
<span class="lineNum"> 448 </span> : #if HAVE_SSE42
<span class="lineNum"> 449 </span><span class="lineCov"> 285 : if (raid_cpu_has_crc32()) {</span>
<span class="lineNum"> 450 </span><span class="lineCov"> 283 : crc_x86 = 1;</span>
<span class="lineNum"> 451 </span><span class="lineCov"> 283 : crc32c = crc32c_x86;</span>
<span class="lineNum"> 449 </span><span class="lineCov"> 286 : if (raid_cpu_has_crc32()) {</span>
<span class="lineNum"> 450 </span><span class="lineCov"> 284 : crc_x86 = 1;</span>
<span class="lineNum"> 451 </span><span class="lineCov"> 284 : crc32c = crc32c_x86;</span>
<span class="lineNum"> 452 </span> : }
<span class="lineNum"> 453 </span> : #endif
<span class="lineNum"> 454 </span><span class="lineCov"> 285 : }</span>
<span class="lineNum"> 454 </span><span class="lineCov"> 286 : }</span>
<span class="lineNum"> 455 </span> :
<span class="lineNum"> 456 </span> : /****************************************************************************/
<span class="lineNum"> 457 </span> : /* byte operations */
@ -522,14 +522,14 @@
<span class="lineNum"> 460 </span> : * Rotate left.
<a name="461"><span class="lineNum"> 461 </span> : * In x86/x64 they are optimized with a single assembler instruction.</a>
<span class="lineNum"> 462 </span> : */
<span class="lineNum"> 463 </span><span class="lineCov"> 854114224 : static inline uint32_t util_rotl32(uint32_t x, int8_t r)</span>
<span class="lineNum"> 463 </span><span class="lineCov"> 854131328 : static inline uint32_t util_rotl32(uint32_t x, int8_t r)</span>
<span class="lineNum"> 464 </span> : {
<span class="lineNum"> 465 </span><span class="lineCov"> 854114224 : return (x &lt;&lt; r) | (x &gt;&gt; (32 - r));</span>
<span class="lineNum"> 465 </span><span class="lineCov"> 854131328 : return (x &lt;&lt; r) | (x &gt;&gt; (32 - r));</span>
<a name="466"><span class="lineNum"> 466 </span> : }</a>
<span class="lineNum"> 467 </span> :
<span class="lineNum"> 468 </span><span class="lineCov"> 512217108 : static inline uint64_t util_rotl64(uint64_t x, int8_t r)</span>
<span class="lineNum"> 468 </span><span class="lineCov"> 512341560 : static inline uint64_t util_rotl64(uint64_t x, int8_t r)</span>
<span class="lineNum"> 469 </span> : {
<span class="lineNum"> 470 </span><span class="lineCov"> 512217108 : return (x &lt;&lt; r) | (x &gt;&gt; (64 - r));</span>
<span class="lineNum"> 470 </span><span class="lineCov"> 512341560 : return (x &lt;&lt; r) | (x &gt;&gt; (64 - r));</span>
<span class="lineNum"> 471 </span> : }
<span class="lineNum"> 472 </span> :
<span class="lineNum"> 473 </span> : /**
@ -570,15 +570,15 @@
<span class="lineNum"> 508 </span> : #include &quot;murmur3.c&quot;
<a name="509"><span class="lineNum"> 509 </span> : #include &quot;spooky2.c&quot;</a>
<span class="lineNum"> 510 </span> :
<span class="lineNum"> 511 </span><span class="lineCov"> 5937808 : void memhash(unsigned kind, const unsigned char* seed, void* digest, const void* src, size_t size)</span>
<span class="lineNum"> 511 </span><span class="lineCov"> 5938723 : void memhash(unsigned kind, const unsigned char* seed, void* digest, const void* src, size_t size)</span>
<span class="lineNum"> 512 </span> : {
<span class="lineNum"> 513 </span><span class="lineCov"> 5937808 : switch (kind) {</span>
<span class="lineNum"> 513 </span><span class="lineCov"> 5938723 : switch (kind) {</span>
<span class="lineNum"> 514 </span> : case HASH_MURMUR3 :
<span class="lineNum"> 515 </span><span class="lineCov"> 2076827 : MurmurHash3_x86_128(src, size, seed, digest);</span>
<span class="lineNum"> 516 </span><span class="lineCov"> 2076827 : break;</span>
<span class="lineNum"> 515 </span><span class="lineCov"> 2076854 : MurmurHash3_x86_128(src, size, seed, digest);</span>
<span class="lineNum"> 516 </span><span class="lineCov"> 2076854 : break;</span>
<span class="lineNum"> 517 </span> : case HASH_SPOOKY2 :
<span class="lineNum"> 518 </span><span class="lineCov"> 3860981 : SpookyHash128(src, size, seed, digest);</span>
<span class="lineNum"> 519 </span><span class="lineCov"> 3860981 : break;</span>
<span class="lineNum"> 518 </span><span class="lineCov"> 3861869 : SpookyHash128(src, size, seed, digest);</span>
<span class="lineNum"> 519 </span><span class="lineCov"> 3861869 : break;</span>
<span class="lineNum"> 520 </span> : default :
<span class="lineNum"> 521 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 522 </span> : log_fatal(&quot;Internal inconsistency in hash function %u\n&quot;, kind);
@ -586,7 +586,7 @@
<span class="lineNum"> 524 </span> : break;
<span class="lineNum"> 525 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 526 </span> : }
<a name="527"><span class="lineNum"> 527 </span><span class="lineCov"> 5937808 : }</span></a>
<a name="527"><span class="lineNum"> 527 </span><span class="lineCov"> 5938723 : }</span></a>
<span class="lineNum"> 528 </span> :
<span class="lineNum"> 529 </span><span class="lineCov"> 42 : const char* hash_config_name(unsigned kind)</span>
<span class="lineNum"> 530 </span> : {
@ -601,49 +601,49 @@
<span class="lineNum"> 539 </span> : }
<a name="540"><span class="lineNum"> 540 </span> : }</a>
<span class="lineNum"> 541 </span> :
<span class="lineNum"> 542 </span><span class="lineCov"> 93184 : unsigned memdiff(const unsigned char* data1, const unsigned char* data2, size_t size)</span>
<span class="lineNum"> 542 </span><span class="lineCov"> 93321 : unsigned memdiff(const unsigned char* data1, const unsigned char* data2, size_t size)</span>
<span class="lineNum"> 543 </span> : {
<span class="lineNum"> 544 </span> : size_t i;
<span class="lineNum"> 545 </span> : unsigned count;
<span class="lineNum"> 546 </span> :
<span class="lineNum"> 547 </span><span class="lineCov"> 93184 : count = 0;</span>
<span class="lineNum"> 548 </span><span class="lineCov"> 80903648 : for (i = 0; i &lt; size; ++i) {</span>
<span class="lineNum"> 547 </span><span class="lineCov"> 93321 : count = 0;</span>
<span class="lineNum"> 548 </span><span class="lineCov"> 80898921 : for (i = 0; i &lt; size; ++i) {</span>
<span class="lineNum"> 549 </span> : unsigned j;
<span class="lineNum"> 550 </span><span class="lineCov"> 80810464 : unsigned char diff = data1[i] ^ data2[i];</span>
<span class="lineNum"> 551 </span><span class="lineCov"> 727294176 : for (j = 0; j &lt; 8; ++j) {</span>
<span class="lineNum"> 552 </span><span class="lineCov"> 646483712 : if ((diff &amp; 1) != 0)</span>
<span class="lineNum"> 553 </span><span class="lineCov"> 311410983 : ++count;</span>
<span class="lineNum"> 554 </span><span class="lineCov"> 646483712 : diff &gt;&gt;= 1;</span>
<span class="lineNum"> 550 </span><span class="lineCov"> 80805600 : unsigned char diff = data1[i] ^ data2[i];</span>
<span class="lineNum"> 551 </span><span class="lineCov"> 727250400 : for (j = 0; j &lt; 8; ++j) {</span>
<span class="lineNum"> 552 </span><span class="lineCov"> 646444800 : if ((diff &amp; 1) != 0)</span>
<span class="lineNum"> 553 </span><span class="lineCov"> 311410136 : ++count;</span>
<span class="lineNum"> 554 </span><span class="lineCov"> 646444800 : diff &gt;&gt;= 1;</span>
<span class="lineNum"> 555 </span> : }
<span class="lineNum"> 556 </span> : }
<span class="lineNum"> 557 </span> :
<span class="lineNum"> 558 </span><span class="lineCov"> 93184 : return count;</span>
<span class="lineNum"> 558 </span><span class="lineCov"> 93321 : return count;</span>
<span class="lineNum"> 559 </span> : }
<span class="lineNum"> 560 </span> :
<span class="lineNum"> 561 </span> : /****************************************************************************/
<span class="lineNum"> 562 </span> : /* lock */
<a name="563"><span class="lineNum"> 563 </span> : </a>
<span class="lineNum"> 564 </span> : #if HAVE_LOCKFILE
<span class="lineNum"> 565 </span><span class="lineCov"> 260 : int lock_lock(const char* file)</span>
<span class="lineNum"> 565 </span><span class="lineCov"> 261 : int lock_lock(const char* file)</span>
<span class="lineNum"> 566 </span> : {
<span class="lineNum"> 567 </span> : int f;
<span class="lineNum"> 568 </span> :
<span class="lineNum"> 569 </span><span class="lineCov"> 260 : f = open(file, O_CREAT | O_TRUNC | O_WRONLY, 0600);</span>
<span class="lineNum"> 570 </span><span class="lineCov"> 260 : if (f == -1) {</span>
<span class="lineNum"> 569 </span><span class="lineCov"> 261 : f = open(file, O_CREAT | O_TRUNC | O_WRONLY, 0600);</span>
<span class="lineNum"> 570 </span><span class="lineCov"> 261 : if (f == -1) {</span>
<span class="lineNum"> 571 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 572 </span> : return -1;
<span class="lineNum"> 573 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 574 </span> : }
<span class="lineNum"> 575 </span> :
<span class="lineNum"> 576 </span> : /* exclusive lock, not blocking */
<span class="lineNum"> 577 </span><span class="lineCov"> 260 : if (flock(f, LOCK_EX | LOCK_NB) == -1) {</span>
<span class="lineNum"> 577 </span><span class="lineCov"> 261 : if (flock(f, LOCK_EX | LOCK_NB) == -1) {</span>
<span class="lineNum"> 578 </span> : /* LCOV_EXCL_START */
<span class="lineNum"> 579 </span> : close(f);
<span class="lineNum"> 580 </span> : return -1;
<span class="lineNum"> 581 </span> : /* LCOV_EXCL_STOP */
<span class="lineNum"> 582 </span> : }
<span class="lineNum"> 583 </span> :
<span class="lineNum"> 584 </span><span class="lineCov"> 260 : return f;</span>
<span class="lineNum"> 584 </span><span class="lineCov"> 261 : return f;</span>
<span class="lineNum"> 585 </span> : }
<span class="lineNum"> 586 </span> : #endif
<a name="587"><span class="lineNum"> 587 </span> : </a>

8
cov/cmdline/util.h.func-sort-c.html
View file

@ -61,19 +61,19 @@
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#119">crc32c_x86_plain</a></td>
<td class="coverFnHi">21365714</td>
<td class="coverFnHi">21365408</td>
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#149">crc32c_plain</a></td>
<td class="coverFnHi">20719102</td>
<td class="coverFnHi">20718802</td>
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#83">crc32c_plain_char</a></td>
<td class="coverFnHi">3808841</td>
<td class="coverFnHi">3808025</td>
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#97">crc32c_gen_plain</a></td>
<td class="coverFnHi">361</td>
<td class="coverFnHi">345</td>
</tr>
</table>
<br>

8
cov/cmdline/util.h.func.html
View file

@ -61,19 +61,19 @@
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#97">crc32c_gen_plain</a></td>
<td class="coverFnHi">361</td>
<td class="coverFnHi">345</td>
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#149">crc32c_plain</a></td>
<td class="coverFnHi">20719102</td>
<td class="coverFnHi">20718802</td>
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#83">crc32c_plain_char</a></td>
<td class="coverFnHi">3808841</td>
<td class="coverFnHi">3808025</td>
</tr>
<tr>
<td class="coverFn"><a href="util.h.gcov.html#119">crc32c_x86_plain</a></td>
<td class="coverFnHi">21365714</td>
<td class="coverFnHi">21365408</td>
</tr>
</table>
<br>

50
cov/cmdline/util.h.gcov.html
View file

@ -144,12 +144,12 @@
<span class="lineNum"> 82 </span> : /**
<a name="83"><span class="lineNum"> 83 </span> : * Compute CRC-32 (Castagnoli) for a single byte without the IV.</a>
<span class="lineNum"> 84 </span> : */
<span class="lineNum"> 85 </span><span class="lineCov"> 3808841 : static inline uint32_t crc32c_plain_char(uint32_t crc, unsigned char c)</span>
<span class="lineNum"> 85 </span><span class="lineCov"> 3808025 : static inline uint32_t crc32c_plain_char(uint32_t crc, unsigned char c)</span>
<span class="lineNum"> 86 </span> : {
<span class="lineNum"> 87 </span> : #if HAVE_SSE42
<span class="lineNum"> 88 </span><span class="lineCov"> 3808841 : if (tommy_likely(crc_x86)) {</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 3808841 : asm(&quot;crc32b %1, %0\n&quot; : &quot;+r&quot; (crc) : &quot;m&quot; (c));</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 3808841 : return crc;</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 3808025 : if (tommy_likely(crc_x86)) {</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 3808025 : asm(&quot;crc32b %1, %0\n&quot; : &quot;+r&quot; (crc) : &quot;m&quot; (c));</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 3808025 : return crc;</span>
<span class="lineNum"> 91 </span> : }
<span class="lineNum"> 92 </span> : #endif
<span class="lineNum"> 93 </span><span class="lineNoCov"> 0 : return CRC32C_0[(crc ^ c) &amp; 0xff] ^ (crc &gt;&gt; 8);</span>
@ -158,29 +158,29 @@
<span class="lineNum"> 96 </span> : /**
<a name="97"><span class="lineNum"> 97 </span> : * Compute the CRC-32 (Castagnoli) without the IV.</a>
<span class="lineNum"> 98 </span> : */
<span class="lineNum"> 99 </span><span class="lineCov"> 361 : static inline uint32_t crc32c_gen_plain(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 99 </span><span class="lineCov"> 345 : static inline uint32_t crc32c_gen_plain(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 100 </span> : {
<span class="lineNum"> 101 </span><span class="lineCov"> 22545273 : while (size &gt;= 4) {</span>
<span class="lineNum"> 102 </span><span class="lineCov"> 22544551 : crc ^= ptr[0] | (uint32_t)ptr[1] &lt;&lt; 8 | (uint32_t)ptr[2] &lt;&lt; 16 | (uint32_t)ptr[3] &lt;&lt; 24;</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 22544551 : crc = CRC32C_3[crc &amp; 0xff] ^ CRC32C_2[(crc &gt;&gt; 8) &amp; 0xff] ^ CRC32C_1[(crc &gt;&gt; 16) &amp; 0xff] ^ CRC32C_0[crc &gt;&gt; 24];</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 22544551 : ptr += 4;</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 22544551 : size -= 4;</span>
<span class="lineNum"> 101 </span><span class="lineCov"> 21496665 : while (size &gt;= 4) {</span>
<span class="lineNum"> 102 </span><span class="lineCov"> 21495975 : crc ^= ptr[0] | (uint32_t)ptr[1] &lt;&lt; 8 | (uint32_t)ptr[2] &lt;&lt; 16 | (uint32_t)ptr[3] &lt;&lt; 24;</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 21495975 : crc = CRC32C_3[crc &amp; 0xff] ^ CRC32C_2[(crc &gt;&gt; 8) &amp; 0xff] ^ CRC32C_1[(crc &gt;&gt; 16) &amp; 0xff] ^ CRC32C_0[crc &gt;&gt; 24];</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 21495975 : ptr += 4;</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 21495975 : size -= 4;</span>
<span class="lineNum"> 106 </span> : }
<span class="lineNum"> 107 </span> :
<span class="lineNum"> 108 </span><span class="lineCov"> 731 : while (size) {</span>
<span class="lineNum"> 108 </span><span class="lineCov"> 699 : while (size) {</span>
<span class="lineNum"> 109 </span><span class="lineCov"> 9 : crc = CRC32C_0[(crc ^ *ptr) &amp; 0xff] ^ (crc &gt;&gt; 8);</span>
<span class="lineNum"> 110 </span><span class="lineCov"> 9 : ++ptr;</span>
<span class="lineNum"> 111 </span><span class="lineCov"> 9 : --size;</span>
<span class="lineNum"> 112 </span> : }
<span class="lineNum"> 113 </span> :
<span class="lineNum"> 114 </span><span class="lineCov"> 361 : return crc;</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 345 : return crc;</span>
<span class="lineNum"> 115 </span> : }
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span> : /**
<span class="lineNum"> 118 </span> : * Compute the CRC-32 (Castagnoli) without the IV.
<a name="119"><span class="lineNum"> 119 </span> : */</a>
<span class="lineNum"> 120 </span> : #if HAVE_SSE42
<span class="lineNum"> 121 </span><span class="lineCov"> 21365714 : static inline uint32_t crc32c_x86_plain(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 121 </span><span class="lineCov"> 21365408 : static inline uint32_t crc32c_x86_plain(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 122 </span> : {
<span class="lineNum"> 123 </span> : #ifdef CONFIG_X86_64
<span class="lineNum"> 124 </span> : uint64_t crc64 = crc;
@ -191,30 +191,30 @@
<span class="lineNum"> 129 </span> : }
<span class="lineNum"> 130 </span> : crc = crc64;
<span class="lineNum"> 131 </span> : #else
<span class="lineNum"> 132 </span><span class="lineCov"> 387175791 : while (size &gt;= 4) {</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 344444363 : asm(&quot;crc32l %1, %0\n&quot; : &quot;+r&quot; (crc) : &quot;m&quot; (*(const uint32_t*)ptr));</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 344444363 : ptr += 4;</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 344444363 : size -= 4;</span>
<span class="lineNum"> 132 </span><span class="lineCov"> 381730335 : while (size &gt;= 4) {</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 338999519 : asm(&quot;crc32l %1, %0\n&quot; : &quot;+r&quot; (crc) : &quot;m&quot; (*(const uint32_t*)ptr));</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 338999519 : ptr += 4;</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 338999519 : size -= 4;</span>
<span class="lineNum"> 136 </span> : }
<span class="lineNum"> 137 </span> : #endif
<span class="lineNum"> 138 </span><span class="lineCov"> 62479703 : while (size) {</span>
<span class="lineNum"> 139 </span><span class="lineCov"> 19748275 : asm(&quot;crc32b %1, %0\n&quot; : &quot;+r&quot; (crc) : &quot;m&quot; (*ptr));</span>
<span class="lineNum"> 140 </span><span class="lineCov"> 19748275 : ++ptr;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 19748275 : --size;</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 62071545 : while (size) {</span>
<span class="lineNum"> 139 </span><span class="lineCov"> 19340729 : asm(&quot;crc32b %1, %0\n&quot; : &quot;+r&quot; (crc) : &quot;m&quot; (*ptr));</span>
<span class="lineNum"> 140 </span><span class="lineCov"> 19340729 : ++ptr;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 19340729 : --size;</span>
<span class="lineNum"> 142 </span> : }
<span class="lineNum"> 143 </span> :
<span class="lineNum"> 144 </span><span class="lineCov"> 21365714 : return crc;</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 21365408 : return crc;</span>
<span class="lineNum"> 145 </span> : }
<span class="lineNum"> 146 </span> : #endif
<span class="lineNum"> 147 </span> :
<span class="lineNum"> 148 </span> : /**
<a name="149"><span class="lineNum"> 149 </span> : * Compute CRC-32 (Castagnoli) without the IV.</a>
<span class="lineNum"> 150 </span> : */
<span class="lineNum"> 151 </span><span class="lineCov"> 20719102 : static inline uint32_t crc32c_plain(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 151 </span><span class="lineCov"> 20718802 : static inline uint32_t crc32c_plain(uint32_t crc, const unsigned char* ptr, unsigned size)</span>
<span class="lineNum"> 152 </span> : {
<span class="lineNum"> 153 </span> : #if HAVE_SSE42
<span class="lineNum"> 154 </span><span class="lineCov"> 20719102 : if (tommy_likely(crc_x86)) {</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 20719102 : return crc32c_x86_plain(crc, ptr, size);</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 20718802 : if (tommy_likely(crc_x86)) {</span>
<span class="lineNum"> 155 </span><span class="lineCov"> 20718802 : return crc32c_x86_plain(crc, ptr, size);</span>
<span class="lineNum"> 156 </span> : }
<span class="lineNum"> 157 </span> : #endif
<span class="lineNum"> 158 </span><span class="lineNoCov"> 0 : return crc32c_gen_plain(crc, ptr, size);</span>

12
cov/index-sort-f.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">10929</td>
<td class="headerCovTableEntry">11932</td>
<td class="headerCovTableEntryHi">91.6 %</td>
<td class="headerCovTableEntry">10944</td>
<td class="headerCovTableEntry">11891</td>
<td class="headerCovTableEntryHi">92.0 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -72,10 +72,10 @@
<tr>
<td class="coverFile"><a href="cmdline/index.html">cmdline</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="amber.png" width=90 height=10 alt="89.7%"><img src="snow.png" width=10 height=10 alt="89.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="emerald.png" width=90 height=10 alt="90.2%"><img src="snow.png" width=10 height=10 alt="90.2%"></td></tr></table>
</td>
<td class="coverPerMed">89.7&nbsp;%</td>
<td class="coverNumMed">8598 / 9589</td>
<td class="coverPerHi">90.2&nbsp;%</td>
<td class="coverNumHi">8613 / 9548</td>
<td class="coverPerHi">96.6&nbsp;%</td>
<td class="coverNumHi">482 / 499</td>
</tr>

12
cov/index-sort-l.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">10929</td>
<td class="headerCovTableEntry">11932</td>
<td class="headerCovTableEntryHi">91.6 %</td>
<td class="headerCovTableEntry">10944</td>
<td class="headerCovTableEntry">11891</td>
<td class="headerCovTableEntryHi">92.0 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -72,10 +72,10 @@
<tr>
<td class="coverFile"><a href="cmdline/index.html">cmdline</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="amber.png" width=90 height=10 alt="89.7%"><img src="snow.png" width=10 height=10 alt="89.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="emerald.png" width=90 height=10 alt="90.2%"><img src="snow.png" width=10 height=10 alt="90.2%"></td></tr></table>
</td>
<td class="coverPerMed">89.7&nbsp;%</td>
<td class="coverNumMed">8598 / 9589</td>
<td class="coverPerHi">90.2&nbsp;%</td>
<td class="coverNumHi">8613 / 9548</td>
<td class="coverPerHi">96.6&nbsp;%</td>
<td class="coverNumHi">482 / 499</td>
</tr>

12
cov/index.html
View file

@ -31,9 +31,9 @@
<td class="headerValue">lcov.info</td>
<td></td>
<td class="headerItem">Lines:</td>
<td class="headerCovTableEntry">10929</td>
<td class="headerCovTableEntry">11932</td>
<td class="headerCovTableEntryHi">91.6 %</td>
<td class="headerCovTableEntry">10944</td>
<td class="headerCovTableEntry">11891</td>
<td class="headerCovTableEntryHi">92.0 %</td>
</tr>
<tr>
<td class="headerItem">Date:</td>
@ -72,10 +72,10 @@
<tr>
<td class="coverFile"><a href="cmdline/index.html">cmdline</a></td>
<td class="coverBar" align="center">
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="amber.png" width=90 height=10 alt="89.7%"><img src="snow.png" width=10 height=10 alt="89.7%"></td></tr></table>
<table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="emerald.png" width=90 height=10 alt="90.2%"><img src="snow.png" width=10 height=10 alt="90.2%"></td></tr></table>
</td>
<td class="coverPerMed">89.7&nbsp;%</td>
<td class="coverNumMed">8598 / 9589</td>
<td class="coverPerHi">90.2&nbsp;%</td>
<td class="coverNumHi">8613 / 9548</td>
<td class="coverPerHi">96.6&nbsp;%</td>
<td class="coverNumHi">482 / 499</td>
</tr>

24
cov/raid/combo.h.gcov.html
View file

@ -170,10 +170,10 @@
<span class="lineNum"> 108 </span> : int i;
<span class="lineNum"> 109 </span> :
<span class="lineNum"> 110 </span> : (void)n; /* unused, but kept for clarity */
<span class="lineNum"> 111 </span><span class="lineCov"> 207805 : assert(0 &lt; r &amp;&amp; r &lt;= n);</span>
<span class="lineNum"> 111 </span><span class="lineCov"> 207990 : assert(0 &lt; r &amp;&amp; r &lt;= n);</span>
<span class="lineNum"> 112 </span> :
<span class="lineNum"> 113 </span><span class="lineCov"> 689192 : for (i = 0; i &lt; r; ++i)</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 481387 : c[i] = i;</span>
<span class="lineNum"> 113 </span><span class="lineCov"> 689341 : for (i = 0; i &lt; r; ++i)</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 481351 : c[i] = i;</span>
<span class="lineNum"> 115 </span> : }
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span> : /**
@ -182,19 +182,19 @@
<span class="lineNum"> 120 </span> : */
<span class="lineNum"> 121 </span> : static __always_inline int combination_next(int r, int n, int *c)
<span class="lineNum"> 122 </span> : {
<span class="lineNum"> 123 </span><span class="lineCov"> 52183 : int i = r - 1; /* present position */</span>
<span class="lineNum"> 124 </span><span class="lineCov"> 52183 : int h = n; /* high limit for this position */</span>
<span class="lineNum"> 123 </span><span class="lineCov"> 52204 : int i = r - 1; /* present position */</span>
<span class="lineNum"> 124 </span><span class="lineCov"> 52204 : int h = n; /* high limit for this position */</span>
<span class="lineNum"> 125 </span> :
<span class="lineNum"> 126 </span> : recurse:
<span class="lineNum"> 127 </span> : /* next element at position i */
<span class="lineNum"> 128 </span><span class="lineCov"> 85056 : ++c[i];</span>
<span class="lineNum"> 128 </span><span class="lineCov"> 85077 : ++c[i];</span>
<span class="lineNum"> 129 </span> :
<span class="lineNum"> 130 </span> : /* if the position has reached the max */
<span class="lineNum"> 131 </span><span class="lineCov"> 85056 : if (c[i] &gt;= h) {</span>
<span class="lineNum"> 131 </span><span class="lineCov"> 85077 : if (c[i] &gt;= h) {</span>
<span class="lineNum"> 132 </span> :
<span class="lineNum"> 133 </span> : /* if we are at the first level, we have finished */
<span class="lineNum"> 134 </span><span class="lineCov"> 45028 : if (i == 0)</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 12155 : return 0;</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 45035 : if (i == 0)</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 12162 : return 0;</span>
<span class="lineNum"> 136 </span> :
<span class="lineNum"> 137 </span> : /* increase the previous position */
<span class="lineNum"> 138 </span><span class="lineCov"> 32873 : --i;</span>
@ -202,16 +202,16 @@
<span class="lineNum"> 140 </span> : goto recurse;
<span class="lineNum"> 141 </span> : }
<span class="lineNum"> 142 </span> :
<span class="lineNum"> 143 </span><span class="lineCov"> 40028 : ++i;</span>
<span class="lineNum"> 143 </span><span class="lineCov"> 40042 : ++i;</span>
<span class="lineNum"> 144 </span> :
<span class="lineNum"> 145 </span> : /* initialize all the next positions, if any */
<span class="lineNum"> 146 </span><span class="lineCov"> 62573 : while (i &lt; r) {</span>
<span class="lineNum"> 146 </span><span class="lineCov"> 62587 : while (i &lt; r) {</span>
<span class="lineNum"> 147 </span> : /* each position start at the next value of the previous one */
<span class="lineNum"> 148 </span><span class="lineCov"> 22545 : c[i] = c[i - 1] + 1;</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 22545 : ++i;</span>
<span class="lineNum"> 150 </span> : }
<span class="lineNum"> 151 </span> :
<span class="lineNum"> 152 </span><span class="lineCov"> 40028 : return 1;</span>
<span class="lineNum"> 152 </span><span class="lineCov"> 40042 : return 1;</span>
<span class="lineNum"> 153 </span> : }
<span class="lineNum"> 154 </span> : #endif
<span class="lineNum"> 155 </span> :

20
cov/raid/cpu.h.func-sort-c.html
View file

@ -61,43 +61,43 @@
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#18">raid_cpuid</a></td>
<td class="coverFnHi">2079</td>
<td class="coverFnHi">2086</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#84">raid_cpu_match_sse</a></td>
<td class="coverFnHi">1185</td>
<td class="coverFnHi">1189</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#135">raid_cpu_has_ssse3</a></td>
<td class="coverFnHi">587</td>
<td class="coverFnHi">589</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#97">raid_cpu_match_avx</a></td>
<td class="coverFnHi">317</td>
<td class="coverFnHi">318</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#168">raid_cpu_has_avx2</a></td>
<td class="coverFnHi">317</td>
<td class="coverFnHi">318</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#116">raid_cpu_has_sse2</a></td>
<td class="coverFnHi">305</td>
<td class="coverFnHi">306</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#152">raid_cpu_has_crc32</a></td>
<td class="coverFnHi">293</td>
<td class="coverFnHi">294</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#51">raid_cpu_info</a></td>
<td class="coverFnHi">277</td>
<td class="coverFnHi">278</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#216">raid_cpu_is_atom</a></td>
<td class="coverFnHi">273</td>
<td class="coverFnHi">274</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#249">raid_cpu_has_slowmult</a></td>
<td class="coverFnHi">269</td>
<td class="coverFnHi">270</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#36">raid_xgetbv</a></td>

20
cov/raid/cpu.h.func.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#168">raid_cpu_has_avx2</a></td>
<td class="coverFnHi">317</td>
<td class="coverFnHi">318</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#152">raid_cpu_has_crc32</a></td>
<td class="coverFnHi">293</td>
<td class="coverFnHi">294</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#280">raid_cpu_has_slowextendedreg</a></td>
@ -73,35 +73,35 @@
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#249">raid_cpu_has_slowmult</a></td>
<td class="coverFnHi">269</td>
<td class="coverFnHi">270</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#116">raid_cpu_has_sse2</a></td>
<td class="coverFnHi">305</td>
<td class="coverFnHi">306</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#135">raid_cpu_has_ssse3</a></td>
<td class="coverFnHi">587</td>
<td class="coverFnHi">589</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#51">raid_cpu_info</a></td>
<td class="coverFnHi">277</td>
<td class="coverFnHi">278</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#216">raid_cpu_is_atom</a></td>
<td class="coverFnHi">273</td>
<td class="coverFnHi">274</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#97">raid_cpu_match_avx</a></td>
<td class="coverFnHi">317</td>
<td class="coverFnHi">318</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#84">raid_cpu_match_sse</a></td>
<td class="coverFnHi">1185</td>
<td class="coverFnHi">1189</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#18">raid_cpuid</a></td>
<td class="coverFnHi">2079</td>
<td class="coverFnHi">2086</td>
</tr>
<tr>
<td class="coverFn"><a href="cpu.h.gcov.html#36">raid_xgetbv</a></td>

94
cov/raid/cpu.h.gcov.html
View file

@ -79,9 +79,9 @@
<span class="lineNum"> 17 </span> :
<a name="18"><span class="lineNum"> 18 </span> : #ifdef CONFIG_X86</a>
<span class="lineNum"> 19 </span> :
<span class="lineNum"> 20 </span><span class="lineCov"> 2079 : static inline void raid_cpuid(uint32_t func_eax, uint32_t sub_ecx, uint32_t *reg)</span>
<span class="lineNum"> 20 </span><span class="lineCov"> 2086 : static inline void raid_cpuid(uint32_t func_eax, uint32_t sub_ecx, uint32_t *reg)</span>
<span class="lineNum"> 21 </span> : {
<span class="lineNum"> 22 </span><span class="lineCov"> 2079 : asm volatile (</span>
<span class="lineNum"> 22 </span><span class="lineCov"> 2086 : asm volatile (</span>
<span class="lineNum"> 23 </span> : #if defined(__i386__) &amp;&amp; defined(__PIC__)
<span class="lineNum"> 24 </span> : /* allow compilation in PIC mode saving ebx */
<span class="lineNum"> 25 </span> : &quot;xchgl %%ebx, %1\n&quot;
@ -91,11 +91,11 @@
<span class="lineNum"> 29 </span> : : &quot;0&quot; (func_eax), &quot;2&quot; (sub_ecx)
<span class="lineNum"> 30 </span> : #else
<span class="lineNum"> 31 </span> : &quot;cpuid\n&quot;
<span class="lineNum"> 32 </span><span class="lineCov"> 2079 : : &quot;=a&quot; (reg[0]), &quot;=b&quot; (reg[1]), &quot;=c&quot; (reg[2]), &quot;=d&quot; (reg[3])</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 2086 : : &quot;=a&quot; (reg[0]), &quot;=b&quot; (reg[1]), &quot;=c&quot; (reg[2]), &quot;=d&quot; (reg[3])</span>
<span class="lineNum"> 33 </span> : : &quot;0&quot; (func_eax), &quot;2&quot; (sub_ecx)
<span class="lineNum"> 34 </span> : #endif
<span class="lineNum"> 35 </span> : );
<a name="36"><span class="lineNum"> 36 </span><span class="lineCov"> 2079 : }</span></a>
<a name="36"><span class="lineNum"> 36 </span><span class="lineCov"> 2086 : }</span></a>
<span class="lineNum"> 37 </span> :
<span class="lineNum"> 38 </span><span class="lineCov"> 23 : static inline void raid_xgetbv(uint32_t* reg)</span>
<span class="lineNum"> 39 </span> : {
@ -112,26 +112,26 @@
<span class="lineNum"> 50 </span> :
<a name="51"><span class="lineNum"> 51 </span> : #define CPU_VENDOR_MAX 13</a>
<span class="lineNum"> 52 </span> :
<span class="lineNum"> 53 </span><span class="lineCov"> 277 : static inline void raid_cpu_info(char *vendor, unsigned *family, unsigned *model)</span>
<span class="lineNum"> 53 </span><span class="lineCov"> 278 : static inline void raid_cpu_info(char *vendor, unsigned *family, unsigned *model)</span>
<span class="lineNum"> 54 </span> : {
<span class="lineNum"> 55 </span> : uint32_t reg[4];
<span class="lineNum"> 56 </span> : unsigned f, ef, m, em;
<span class="lineNum"> 57 </span> :
<span class="lineNum"> 58 </span><span class="lineCov"> 277 : raid_cpuid(0, 0, reg);</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 278 : raid_cpuid(0, 0, reg);</span>
<span class="lineNum"> 59 </span> :
<span class="lineNum"> 60 </span><span class="lineCov"> 277 : ((uint32_t*)vendor)[0] = reg[1];</span>
<span class="lineNum"> 61 </span><span class="lineCov"> 277 : ((uint32_t*)vendor)[1] = reg[3];</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 277 : ((uint32_t*)vendor)[2] = reg[2];</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 277 : vendor[12] = 0;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 278 : ((uint32_t*)vendor)[0] = reg[1];</span>
<span class="lineNum"> 61 </span><span class="lineCov"> 278 : ((uint32_t*)vendor)[1] = reg[3];</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 278 : ((uint32_t*)vendor)[2] = reg[2];</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 278 : vendor[12] = 0;</span>
<span class="lineNum"> 64 </span> :
<span class="lineNum"> 65 </span><span class="lineCov"> 277 : raid_cpuid(1, 0, reg);</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 278 : raid_cpuid(1, 0, reg);</span>
<span class="lineNum"> 66 </span> :
<span class="lineNum"> 67 </span><span class="lineCov"> 277 : f = (reg[0] &gt;&gt; 8) &amp; 0xF;</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 277 : ef = (reg[0] &gt;&gt; 20) &amp; 0xFF;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 277 : m = (reg[0] &gt;&gt; 4) &amp; 0xF;</span>
<span class="lineNum"> 70 </span><span class="lineCov"> 277 : em = (reg[0] &gt;&gt; 16) &amp; 0xF;</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 278 : f = (reg[0] &gt;&gt; 8) &amp; 0xF;</span>
<span class="lineNum"> 68 </span><span class="lineCov"> 278 : ef = (reg[0] &gt;&gt; 20) &amp; 0xFF;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 278 : m = (reg[0] &gt;&gt; 4) &amp; 0xF;</span>
<span class="lineNum"> 70 </span><span class="lineCov"> 278 : em = (reg[0] &gt;&gt; 16) &amp; 0xF;</span>
<span class="lineNum"> 71 </span> :
<span class="lineNum"> 72 </span><span class="lineCov"> 277 : if (strcmp(vendor, &quot;AuthenticAMD&quot;) == 0) {</span>
<span class="lineNum"> 72 </span><span class="lineCov"> 278 : if (strcmp(vendor, &quot;AuthenticAMD&quot;) == 0) {</span>
<span class="lineNum"> 73 </span><span class="lineNoCov"> 0 : if (f &lt; 15) {</span>
<span class="lineNum"> 74 </span><span class="lineNoCov"> 0 : *family = f;</span>
<span class="lineNum"> 75 </span><span class="lineNoCov"> 0 : *model = m;</span>
@ -140,31 +140,31 @@
<span class="lineNum"> 78 </span><span class="lineNoCov"> 0 : *model = m + (em &lt;&lt; 4);</span>
<span class="lineNum"> 79 </span> : }
<span class="lineNum"> 80 </span> : } else {
<span class="lineNum"> 81 </span><span class="lineCov"> 277 : *family = f + ef;</span>
<span class="lineNum"> 82 </span><span class="lineCov"> 277 : *model = m + (em &lt;&lt; 4);</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 278 : *family = f + ef;</span>
<span class="lineNum"> 82 </span><span class="lineCov"> 278 : *model = m + (em &lt;&lt; 4);</span>
<span class="lineNum"> 83 </span> : }
<a name="84"><span class="lineNum"> 84 </span><span class="lineCov"> 277 : }</span></a>
<a name="84"><span class="lineNum"> 84 </span><span class="lineCov"> 278 : }</span></a>
<span class="lineNum"> 85 </span> :
<span class="lineNum"> 86 </span><span class="lineCov"> 1185 : static inline int raid_cpu_match_sse(uint32_t cpuid_1_ecx, uint32_t cpuid_1_edx)</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 1189 : static inline int raid_cpu_match_sse(uint32_t cpuid_1_ecx, uint32_t cpuid_1_edx)</span>
<span class="lineNum"> 87 </span> : {
<span class="lineNum"> 88 </span> : uint32_t reg[4];
<span class="lineNum"> 89 </span> :
<span class="lineNum"> 90 </span><span class="lineCov"> 1185 : raid_cpuid(1, 0, reg);</span>
<span class="lineNum"> 91 </span><span class="lineCov"> 1185 : if ((reg[2] &amp; cpuid_1_ecx) != cpuid_1_ecx)</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 1189 : raid_cpuid(1, 0, reg);</span>
<span class="lineNum"> 91 </span><span class="lineCov"> 1189 : if ((reg[2] &amp; cpuid_1_ecx) != cpuid_1_ecx)</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 18 : return 0;</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 1167 : if ((reg[3] &amp; cpuid_1_edx) != cpuid_1_edx)</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 1171 : if ((reg[3] &amp; cpuid_1_edx) != cpuid_1_edx)</span>
<span class="lineNum"> 94 </span><span class="lineNoCov"> 0 : return 0;</span>
<span class="lineNum"> 95 </span> :
<span class="lineNum"> 96 </span><span class="lineCov"> 1167 : return 1;</span>
<span class="lineNum"> 96 </span><span class="lineCov"> 1171 : return 1;</span>
<a name="97"><span class="lineNum"> 97 </span> : }</a>
<span class="lineNum"> 98 </span> :
<span class="lineNum"> 99 </span><span class="lineCov"> 317 : static inline int raid_cpu_match_avx(uint32_t cpuid_1_ecx, uint32_t cpuid_7_ebx, uint32_t xcr0)</span>
<span class="lineNum"> 99 </span><span class="lineCov"> 318 : static inline int raid_cpu_match_avx(uint32_t cpuid_1_ecx, uint32_t cpuid_7_ebx, uint32_t xcr0)</span>
<span class="lineNum"> 100 </span> : {
<span class="lineNum"> 101 </span> : uint32_t reg[4];
<span class="lineNum"> 102 </span> :
<span class="lineNum"> 103 </span><span class="lineCov"> 317 : raid_cpuid(1, 0, reg);</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 317 : if ((reg[2] &amp; cpuid_1_ecx) != cpuid_1_ecx)</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 294 : return 0;</span>
<span class="lineNum"> 103 </span><span class="lineCov"> 318 : raid_cpuid(1, 0, reg);</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 318 : if ((reg[2] &amp; cpuid_1_ecx) != cpuid_1_ecx)</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 295 : return 0;</span>
<span class="lineNum"> 106 </span> :
<span class="lineNum"> 107 </span><span class="lineCov"> 23 : raid_xgetbv(reg);</span>
<span class="lineNum"> 108 </span><span class="lineCov"> 23 : if ((reg[0] &amp; xcr0) != xcr0)</span>
@ -177,7 +177,7 @@
<span class="lineNum"> 115 </span><span class="lineCov"> 23 : return 1;</span>
<a name="116"><span class="lineNum"> 116 </span> : }</a>
<span class="lineNum"> 117 </span> :
<span class="lineNum"> 118 </span><span class="lineCov"> 305 : static inline int raid_cpu_has_sse2(void)</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 306 : static inline int raid_cpu_has_sse2(void)</span>
<span class="lineNum"> 119 </span> : {
<span class="lineNum"> 120 </span> : /*
<span class="lineNum"> 121 </span> : * Intel® 64 and IA-32 Architectures Software Developer's Manual
@ -191,12 +191,12 @@
<span class="lineNum"> 129 </span> : * 2. Check that the processor supports the SSE and/or SSE2 extensions (true if
<span class="lineNum"> 130 </span> : * CPUID.01H:EDX.SSE[bit 25] = 1 and/or CPUID.01H:EDX.SSE2[bit 26] = 1).
<span class="lineNum"> 131 </span> : */
<span class="lineNum"> 132 </span><span class="lineCov"> 305 : return raid_cpu_match_sse(</span>
<span class="lineNum"> 132 </span><span class="lineCov"> 306 : return raid_cpu_match_sse(</span>
<span class="lineNum"> 133 </span> : 0,
<span class="lineNum"> 134 </span> : 1 &lt;&lt; 26); /* SSE2 */
<a name="135"><span class="lineNum"> 135 </span> : }</a>
<span class="lineNum"> 136 </span> :
<span class="lineNum"> 137 </span><span class="lineCov"> 587 : static inline int raid_cpu_has_ssse3(void)</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 589 : static inline int raid_cpu_has_ssse3(void)</span>
<span class="lineNum"> 138 </span> : {
<span class="lineNum"> 139 </span> : /*
<span class="lineNum"> 140 </span> : * Intel® 64 and IA-32 Architectures Software Developer's Manual
@ -208,12 +208,12 @@
<span class="lineNum"> 146 </span> : * Next, use the additional step provided below:
<span class="lineNum"> 147 </span> : * Check that the processor supports SSSE3 (if CPUID.01H:ECX.SSSE3[bit 9] = 1).
<span class="lineNum"> 148 </span> : */
<span class="lineNum"> 149 </span><span class="lineCov"> 587 : return raid_cpu_match_sse(</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 589 : return raid_cpu_match_sse(</span>
<span class="lineNum"> 150 </span> : 1 &lt;&lt; 9, /* SSSE3 */
<span class="lineNum"> 151 </span> : 1 &lt;&lt; 26); /* SSE2 */
<a name="152"><span class="lineNum"> 152 </span> : }</a>
<span class="lineNum"> 153 </span> :
<span class="lineNum"> 154 </span><span class="lineCov"> 293 : static inline int raid_cpu_has_crc32(void)</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 294 : static inline int raid_cpu_has_crc32(void)</span>
<span class="lineNum"> 155 </span> : {
<span class="lineNum"> 156 </span> : /*
<span class="lineNum"> 157 </span> : * Intel® 64 and IA-32 Architectures Software Developer's Manual
@ -224,12 +224,12 @@
<span class="lineNum"> 162 </span> : * Before an application attempts to use the CRC32 instruction, it must check
<span class="lineNum"> 163 </span> : * that the processor supports SSE4.2 (if CPUID.01H:ECX.SSE4_2[bit 20] = 1).
<span class="lineNum"> 164 </span> : */
<span class="lineNum"> 165 </span><span class="lineCov"> 293 : return raid_cpu_match_sse(</span>
<span class="lineNum"> 165 </span><span class="lineCov"> 294 : return raid_cpu_match_sse(</span>
<span class="lineNum"> 166 </span> : 1 &lt;&lt; 20, /* CRC32 */
<span class="lineNum"> 167 </span> : 0);
<a name="168"><span class="lineNum"> 168 </span> : }</a>
<span class="lineNum"> 169 </span> :
<span class="lineNum"> 170 </span><span class="lineCov"> 317 : static inline int raid_cpu_has_avx2(void)</span>
<span class="lineNum"> 170 </span><span class="lineCov"> 318 : static inline int raid_cpu_has_avx2(void)</span>
<span class="lineNum"> 171 </span> : {
<span class="lineNum"> 172 </span> : /*
<span class="lineNum"> 173 </span> : * Intel Architecture Instruction Set Extensions Programming Reference
@ -246,7 +246,7 @@
<span class="lineNum"> 184 </span> : * Application Software must identify that hardware supports AVX, after that it must
<span class="lineNum"> 185 </span> : * also detect support for AVX2 by checking CPUID.(EAX=07H, ECX=0H):EBX.AVX2[bit 5].
<span class="lineNum"> 186 </span> : */
<span class="lineNum"> 187 </span><span class="lineCov"> 317 : return raid_cpu_match_avx(</span>
<span class="lineNum"> 187 </span><span class="lineCov"> 318 : return raid_cpu_match_avx(</span>
<span class="lineNum"> 188 </span> : (1 &lt;&lt; 27) | (1 &lt;&lt; 28), /* OSXSAVE and AVX */
<span class="lineNum"> 189 </span> : 1 &lt;&lt; 5, /* AVX2 */
<span class="lineNum"> 190 </span> : 3 &lt;&lt; 1); /* OS saves XMM and YMM registers */
@ -277,9 +277,9 @@
<span class="lineNum"> 215 </span> : /**
<a name="216"><span class="lineNum"> 216 </span> : * Check if it's an Intel Atom CPU.</a>
<span class="lineNum"> 217 </span> : */
<span class="lineNum"> 218 </span><span class="lineCov"> 273 : static inline int raid_cpu_is_atom(unsigned family, unsigned model)</span>
<span class="lineNum"> 218 </span><span class="lineCov"> 274 : static inline int raid_cpu_is_atom(unsigned family, unsigned model)</span>
<span class="lineNum"> 219 </span> : {
<span class="lineNum"> 220 </span><span class="lineCov"> 273 : if (family != 6)</span>
<span class="lineNum"> 220 </span><span class="lineCov"> 274 : if (family != 6)</span>
<span class="lineNum"> 221 </span><span class="lineCov"> 3 : return 0;</span>
<span class="lineNum"> 222 </span> :
<span class="lineNum"> 223 </span> : /*
@ -300,17 +300,17 @@
<span class="lineNum"> 238 </span> : * 4D (77) Atom 8C (22 nm) 4 MB L2 (AVN)
<span class="lineNum"> 239 </span> : * ?? Atom ?C (14 nm) ? MB L2 (DVN)
<span class="lineNum"> 240 </span> : */
<span class="lineNum"> 241 </span><span class="lineCov"> 540 : return model == 28 || model == 38 || model == 54</span>
<span class="lineNum"> 242 </span><span class="lineCov"> 270 : || model == 39 || model == 53 || model == 74</span>
<span class="lineNum"> 243 </span><span class="lineCov"> 270 : || model == 90 || model == 55 || model == 76</span>
<span class="lineNum"> 244 </span><span class="lineCov"> 540 : || model == 93 || model == 77;</span>
<span class="lineNum"> 241 </span><span class="lineCov"> 542 : return model == 28 || model == 38 || model == 54</span>
<span class="lineNum"> 242 </span><span class="lineCov"> 271 : || model == 39 || model == 53 || model == 74</span>
<span class="lineNum"> 243 </span><span class="lineCov"> 271 : || model == 90 || model == 55 || model == 76</span>
<span class="lineNum"> 244 </span><span class="lineCov"> 542 : || model == 93 || model == 77;</span>
<span class="lineNum"> 245 </span> : }
<span class="lineNum"> 246 </span> :
<span class="lineNum"> 247 </span> : /**
<span class="lineNum"> 248 </span> : * Check if the processor has a slow MULT implementation.
<a name="249"><span class="lineNum"> 249 </span> : * If yes, it's better to use a hash not based on multiplication.</a>
<span class="lineNum"> 250 </span> : */
<span class="lineNum"> 251 </span><span class="lineCov"> 269 : static inline int raid_cpu_has_slowmult(void)</span>
<span class="lineNum"> 251 </span><span class="lineCov"> 270 : static inline int raid_cpu_has_slowmult(void)</span>
<span class="lineNum"> 252 </span> : {
<span class="lineNum"> 253 </span> : char vendor[CPU_VENDOR_MAX];
<span class="lineNum"> 254 </span> : unsigned family;
@ -320,9 +320,9 @@
<span class="lineNum"> 258 </span> : * In some cases Murmur3 based on MUL instruction,
<span class="lineNum"> 259 </span> : * is a LOT slower than Spooky2 based on SHIFTs.
<span class="lineNum"> 260 </span> : */
<span class="lineNum"> 261 </span><span class="lineCov"> 269 : raid_cpu_info(vendor, &amp;family, &amp;model);</span>
<span class="lineNum"> 261 </span><span class="lineCov"> 270 : raid_cpu_info(vendor, &amp;family, &amp;model);</span>
<span class="lineNum"> 262 </span> :
<span class="lineNum"> 263 </span><span class="lineCov"> 269 : if (strcmp(vendor, &quot;GenuineIntel&quot;) == 0) {</span>
<span class="lineNum"> 263 </span><span class="lineCov"> 270 : if (strcmp(vendor, &quot;GenuineIntel&quot;) == 0) {</span>
<span class="lineNum"> 264 </span> : /*
<span class="lineNum"> 265 </span> : * Intel Atom (Model 28)
<span class="lineNum"> 266 </span> : * murmur3:378 MB/s, spooky2:3413 MB/s (x86)
@ -330,11 +330,11 @@
<span class="lineNum"> 268 </span> : * Intel Atom (Model 77)
<span class="lineNum"> 269 </span> : * murmur3:1311 MB/s, spooky2:4056 MB/s (x64)
<span class="lineNum"> 270 </span> : */
<span class="lineNum"> 271 </span><span class="lineCov"> 269 : if (raid_cpu_is_atom(family, model))</span>
<span class="lineNum"> 271 </span><span class="lineCov"> 270 : if (raid_cpu_is_atom(family, model))</span>
<span class="lineNum"> 272 </span><span class="lineNoCov"> 0 : return 1;</span>
<span class="lineNum"> 273 </span> : }
<span class="lineNum"> 274 </span> :
<span class="lineNum"> 275 </span><span class="lineCov"> 269 : return 0;</span>
<span class="lineNum"> 275 </span><span class="lineCov"> 270 : return 0;</span>
<span class="lineNum"> 276 </span> : }
<span class="lineNum"> 277 </span> :
<span class="lineNum"> 278 </span> : /**

38
cov/raid/gf.h.gcov.html
View file

@ -88,7 +88,7 @@
<span class="lineNum"> 26 </span> : */
<span class="lineNum"> 27 </span> : static __always_inline uint8_t mul(uint8_t a, uint8_t b)
<span class="lineNum"> 28 </span> : {
<span class="lineNum"> 29 </span><span class="lineCov"> 23795594 : return gfmul[a][b];</span>
<span class="lineNum"> 29 </span><span class="lineCov"> 23792058 : return gfmul[a][b];</span>
<span class="lineNum"> 30 </span> : }
<span class="lineNum"> 31 </span> :
<span class="lineNum"> 32 </span> : /*
@ -97,9 +97,9 @@
<span class="lineNum"> 35 </span> : */
<span class="lineNum"> 36 </span> : static __always_inline uint8_t inv(uint8_t v)
<span class="lineNum"> 37 </span> : {
<span class="lineNum"> 38 </span><span class="lineCov"> 635882 : BUG_ON(v == 0); /* division by zero */</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 635454 : BUG_ON(v == 0); /* division by zero */</span>
<span class="lineNum"> 39 </span> :
<span class="lineNum"> 40 </span><span class="lineCov"> 635882 : return gfinv[v];</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 635454 : return gfinv[v];</span>
<span class="lineNum"> 41 </span> : }
<span class="lineNum"> 42 </span> :
<span class="lineNum"> 43 </span> : /*
@ -125,7 +125,7 @@
<span class="lineNum"> 63 </span> : */
<span class="lineNum"> 64 </span> : static __always_inline uint8_t A(int p, int d)
<span class="lineNum"> 65 </span> : {
<span class="lineNum"> 66 </span><span class="lineCov"> 2605358 : return gfgen[p][d];</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 2604488 : return gfgen[p][d];</span>
<span class="lineNum"> 67 </span> : }
<span class="lineNum"> 68 </span> :
<span class="lineNum"> 69 </span> : /*
@ -148,12 +148,12 @@
<span class="lineNum"> 86 </span> : */
<span class="lineNum"> 87 </span> : static __always_inline uint32_t x2_32(uint32_t v)
<span class="lineNum"> 88 </span> : {
<span class="lineNum"> 89 </span><span class="lineCov"> 33036096 : uint32_t mask = v &amp; 0x80808080U;</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 32577344 : uint32_t mask = v &amp; 0x80808080U;</span>
<span class="lineNum"> 90 </span> :
<span class="lineNum"> 91 </span><span class="lineCov"> 33036096 : mask = (mask &lt;&lt; 1) - (mask &gt;&gt; 7);</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 33036096 : v = (v &lt;&lt; 1) &amp; 0xfefefefeU;</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 33036096 : v ^= mask &amp; 0x1d1d1d1dU;</span>
<span class="lineNum"> 94 </span><span class="lineCov"> 33036096 : return v;</span>
<span class="lineNum"> 91 </span><span class="lineCov"> 32577344 : mask = (mask &lt;&lt; 1) - (mask &gt;&gt; 7);</span>
<span class="lineNum"> 92 </span><span class="lineCov"> 32577344 : v = (v &lt;&lt; 1) &amp; 0xfefefefeU;</span>
<span class="lineNum"> 93 </span><span class="lineCov"> 32577344 : v ^= mask &amp; 0x1d1d1d1dU;</span>
<span class="lineNum"> 94 </span><span class="lineCov"> 32577344 : return v;</span>
<span class="lineNum"> 95 </span> : }
<span class="lineNum"> 96 </span> :
<span class="lineNum"> 97 </span> : /*
@ -161,12 +161,12 @@
<span class="lineNum"> 99 </span> : */
<span class="lineNum"> 100 </span> : static __always_inline uint64_t x2_64(uint64_t v)
<span class="lineNum"> 101 </span> : {
<span class="lineNum"> 102 </span><span class="lineCov"> 16518048 : uint64_t mask = v &amp; 0x8080808080808080ULL;</span>
<span class="lineNum"> 102 </span><span class="lineCov"> 16059296 : uint64_t mask = v &amp; 0x8080808080808080ULL;</span>
<span class="lineNum"> 103 </span> :
<span class="lineNum"> 104 </span><span class="lineCov"> 16518048 : mask = (mask &lt;&lt; 1) - (mask &gt;&gt; 7);</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 16518048 : v = (v &lt;&lt; 1) &amp; 0xfefefefefefefefeULL;</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 16518048 : v ^= mask &amp; 0x1d1d1d1d1d1d1d1dULL;</span>
<span class="lineNum"> 107 </span><span class="lineCov"> 16518048 : return v;</span>
<span class="lineNum"> 104 </span><span class="lineCov"> 16059296 : mask = (mask &lt;&lt; 1) - (mask &gt;&gt; 7);</span>
<span class="lineNum"> 105 </span><span class="lineCov"> 16059296 : v = (v &lt;&lt; 1) &amp; 0xfefefefefefefefeULL;</span>
<span class="lineNum"> 106 </span><span class="lineCov"> 16059296 : v ^= mask &amp; 0x1d1d1d1d1d1d1d1dULL;</span>
<span class="lineNum"> 107 </span><span class="lineCov"> 16059296 : return v;</span>
<span class="lineNum"> 108 </span> : }
<span class="lineNum"> 109 </span> :
<span class="lineNum"> 110 </span> : /*
@ -174,12 +174,12 @@
<span class="lineNum"> 112 </span> : */
<span class="lineNum"> 113 </span> : static __always_inline uint32_t d2_32(uint32_t v)
<span class="lineNum"> 114 </span> : {
<span class="lineNum"> 115 </span><span class="lineCov"> 12847040 : uint32_t mask = v &amp; 0x01010101U;</span>
<span class="lineNum"> 115 </span><span class="lineCov"> 12388288 : uint32_t mask = v &amp; 0x01010101U;</span>
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span><span class="lineCov"> 12847040 : mask = (mask &lt;&lt; 8) - mask;</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 12847040 : v = (v &gt;&gt; 1) &amp; 0x7f7f7f7fU;</span>
<span class="lineNum"> 119 </span><span class="lineCov"> 12847040 : v ^= mask &amp; 0x8e8e8e8eU;</span>
<span class="lineNum"> 120 </span><span class="lineCov"> 12847040 : return v;</span>
<span class="lineNum"> 117 </span><span class="lineCov"> 12388288 : mask = (mask &lt;&lt; 8) - mask;</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 12388288 : v = (v &gt;&gt; 1) &amp; 0x7f7f7f7fU;</span>
<span class="lineNum"> 119 </span><span class="lineCov"> 12388288 : v ^= mask &amp; 0x8e8e8e8eU;</span>
<span class="lineNum"> 120 </span><span class="lineCov"> 12388288 : return v;</span>
<span class="lineNum"> 121 </span> : }
<span class="lineNum"> 122 </span> :
<span class="lineNum"> 123 </span> : /*

16
cov/raid/int.c.func-sort-c.html
View file

@ -69,7 +69,7 @@
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#47">raid_gen1_int64</a></td>
<td class="coverFnHi">184</td>
<td class="coverFnHi">182</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#384">raid_rec1_int8</a></td>
@ -77,16 +77,16 @@
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#19">raid_gen1_int32</a></td>
<td class="coverFnHi">112</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#116">raid_gen2_int64</a></td>
<td class="coverFnHi">47</td>
<td class="coverFnHi">117</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#75">raid_gen2_int32</a></td>
<td class="coverFnHi">47</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#116">raid_gen2_int64</a></td>
<td class="coverFnHi">45</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#162">raid_gen3_int8</a></td>
<td class="coverFnHi">26</td>
@ -97,11 +97,11 @@
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#261">raid_gen5_int8</a></td>
<td class="coverFnHi">18</td>
<td class="coverFnHi">17</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#318">raid_gen6_int8</a></td>
<td class="coverFnHi">17</td>
<td class="coverFnHi">15</td>
</tr>
</table>
<br>

10
cov/raid/int.c.func.html
View file

@ -61,11 +61,11 @@
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#19">raid_gen1_int32</a></td>
<td class="coverFnHi">112</td>
<td class="coverFnHi">117</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#47">raid_gen1_int64</a></td>
<td class="coverFnHi">184</td>
<td class="coverFnHi">182</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#75">raid_gen2_int32</a></td>
@ -73,7 +73,7 @@
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#116">raid_gen2_int64</a></td>
<td class="coverFnHi">47</td>
<td class="coverFnHi">45</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#162">raid_gen3_int8</a></td>
@ -85,11 +85,11 @@
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#261">raid_gen5_int8</a></td>
<td class="coverFnHi">18</td>
<td class="coverFnHi">17</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#318">raid_gen6_int8</a></td>
<td class="coverFnHi">17</td>
<td class="coverFnHi">15</td>
</tr>
<tr>
<td class="coverFn"><a href="int.c.gcov.html#384">raid_rec1_int8</a></td>

220
cov/raid/int.c.gcov.html
View file

@ -80,9 +80,9 @@
<span class="lineNum"> 18 </span> : /*
<a name="19"><span class="lineNum"> 19 </span> : * GEN1 (RAID5 with xor) 32bit C implementation</a>
<span class="lineNum"> 20 </span> : */
<span class="lineNum"> 21 </span><span class="lineCov"> 112 : void raid_gen1_int32(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 21 </span><span class="lineCov"> 117 : void raid_gen1_int32(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 22 </span> : {
<span class="lineNum"> 23 </span><span class="lineCov"> 112 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 23 </span><span class="lineCov"> 117 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 24 </span> : uint8_t *p;
<span class="lineNum"> 25 </span> : int d, l;
<span class="lineNum"> 26 </span> : size_t i;
@ -90,27 +90,27 @@
<span class="lineNum"> 28 </span> : uint32_t p0;
<span class="lineNum"> 29 </span> : uint32_t p1;
<span class="lineNum"> 30 </span> :
<span class="lineNum"> 31 </span><span class="lineCov"> 112 : l = nd - 1;</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 112 : p = v[nd];</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 117 : l = nd - 1;</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 117 : p = v[nd];</span>
<span class="lineNum"> 33 </span> :
<span class="lineNum"> 34 </span><span class="lineCov"> 3571920 : for (i = 0; i &lt; size; i += 8) {</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 3571808 : p0 = v_32(v[l][i]);</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 3571808 : p1 = v_32(v[l][i + 4]);</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 28575776 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 25003968 : p0 ^= v_32(v[d][i]);</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 25003968 : p1 ^= v_32(v[d][i + 4]);</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 3735765 : for (i = 0; i &lt; size; i += 8) {</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 3735648 : p0 = v_32(v[l][i]);</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 3735648 : p1 = v_32(v[l][i + 4]);</span>
<span class="lineNum"> 37 </span><span class="lineCov"> 29886496 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 26150848 : p0 ^= v_32(v[d][i]);</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 26150848 : p1 ^= v_32(v[d][i + 4]);</span>
<span class="lineNum"> 40 </span> : }
<span class="lineNum"> 41 </span><span class="lineCov"> 3571808 : v_32(p[i]) = p0;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 3571808 : v_32(p[i + 4]) = p1;</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 3735648 : v_32(p[i]) = p0;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 3735648 : v_32(p[i + 4]) = p1;</span>
<span class="lineNum"> 43 </span> : }
<span class="lineNum"> 44 </span><span class="lineCov"> 112 : }</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 117 : }</span>
<span class="lineNum"> 45 </span> :
<span class="lineNum"> 46 </span> : /*
<a name="47"><span class="lineNum"> 47 </span> : * GEN1 (RAID5 with xor) 64bit C implementation</a>
<span class="lineNum"> 48 </span> : */
<span class="lineNum"> 49 </span><span class="lineCov"> 184 : void raid_gen1_int64(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 182 : void raid_gen1_int64(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 50 </span> : {
<span class="lineNum"> 51 </span><span class="lineCov"> 184 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 51 </span><span class="lineCov"> 182 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 52 </span> : uint8_t *p;
<span class="lineNum"> 53 </span> : int d, l;
<span class="lineNum"> 54 </span> : size_t i;
@ -118,20 +118,20 @@
<span class="lineNum"> 56 </span> : uint64_t p0;
<span class="lineNum"> 57 </span> : uint64_t p1;
<span class="lineNum"> 58 </span> :
<span class="lineNum"> 59 </span><span class="lineCov"> 184 : l = nd - 1;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 184 : p = v[nd];</span>
<span class="lineNum"> 59 </span><span class="lineCov"> 182 : l = nd - 1;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 182 : p = v[nd];</span>
<span class="lineNum"> 61 </span> :
<span class="lineNum"> 62 </span><span class="lineCov"> 2965736 : for (i = 0; i &lt; size; i += 16) {</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 2965552 : p0 = v_64(v[l][i]);</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 2965552 : p1 = v_64(v[l][i + 8]);</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 23725072 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 20759520 : p0 ^= v_64(v[d][i]);</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 20759520 : p1 ^= v_64(v[d][i + 8]);</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 2932966 : for (i = 0; i &lt; size; i += 16) {</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 2932784 : p0 = v_64(v[l][i]);</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 2932784 : p1 = v_64(v[l][i + 8]);</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 23462928 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 20530144 : p0 ^= v_64(v[d][i]);</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 20530144 : p1 ^= v_64(v[d][i + 8]);</span>
<span class="lineNum"> 68 </span> : }
<span class="lineNum"> 69 </span><span class="lineCov"> 2965552 : v_64(p[i]) = p0;</span>
<span class="lineNum"> 70 </span><span class="lineCov"> 2965552 : v_64(p[i + 8]) = p1;</span>
<span class="lineNum"> 69 </span><span class="lineCov"> 2932784 : v_64(p[i]) = p0;</span>
<span class="lineNum"> 70 </span><span class="lineCov"> 2932784 : v_64(p[i + 8]) = p1;</span>
<span class="lineNum"> 71 </span> : }
<span class="lineNum"> 72 </span><span class="lineCov"> 184 : }</span>
<span class="lineNum"> 72 </span><span class="lineCov"> 182 : }</span>
<span class="lineNum"> 73 </span> :
<span class="lineNum"> 74 </span> : /*
<a name="75"><span class="lineNum"> 75 </span> : * GEN2 (RAID6 with powers of 2) 32bit C implementation</a>
@ -177,9 +177,9 @@
<span class="lineNum"> 115 </span> : /*
<a name="116"><span class="lineNum"> 116 </span> : * GEN2 (RAID6 with powers of 2) 64bit C implementation</a>
<span class="lineNum"> 117 </span> : */
<span class="lineNum"> 118 </span><span class="lineCov"> 47 : void raid_gen2_int64(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 118 </span><span class="lineCov"> 45 : void raid_gen2_int64(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 119 </span> : {
<span class="lineNum"> 120 </span><span class="lineCov"> 47 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 120 </span><span class="lineCov"> 45 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 121 </span> : uint8_t *p;
<span class="lineNum"> 122 </span> : uint8_t *q;
<span class="lineNum"> 123 </span> : int d, l;
@ -188,32 +188,32 @@
<span class="lineNum"> 126 </span> : uint64_t d0, q0, p0;
<span class="lineNum"> 127 </span> : uint64_t d1, q1, p1;
<span class="lineNum"> 128 </span> :
<span class="lineNum"> 129 </span><span class="lineCov"> 47 : l = nd - 1;</span>
<span class="lineNum"> 130 </span><span class="lineCov"> 47 : p = v[nd];</span>
<span class="lineNum"> 131 </span><span class="lineCov"> 47 : q = v[nd + 1];</span>
<span class="lineNum"> 129 </span><span class="lineCov"> 45 : l = nd - 1;</span>
<span class="lineNum"> 130 </span><span class="lineCov"> 45 : p = v[nd];</span>
<span class="lineNum"> 131 </span><span class="lineCov"> 45 : q = v[nd + 1];</span>
<span class="lineNum"> 132 </span> :
<span class="lineNum"> 133 </span><span class="lineCov"> 720991 : for (i = 0; i &lt; size; i += 16) {</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 720944 : q0 = p0 = v_64(v[l][i]);</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 720944 : q1 = p1 = v_64(v[l][i + 8]);</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 5768208 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 5047264 : d0 = v_64(v[d][i]);</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 5047264 : d1 = v_64(v[d][i + 8]);</span>
<span class="lineNum"> 133 </span><span class="lineCov"> 688221 : for (i = 0; i &lt; size; i += 16) {</span>
<span class="lineNum"> 134 </span><span class="lineCov"> 688176 : q0 = p0 = v_64(v[l][i]);</span>
<span class="lineNum"> 135 </span><span class="lineCov"> 688176 : q1 = p1 = v_64(v[l][i + 8]);</span>
<span class="lineNum"> 136 </span><span class="lineCov"> 5506064 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 137 </span><span class="lineCov"> 4817888 : d0 = v_64(v[d][i]);</span>
<span class="lineNum"> 138 </span><span class="lineCov"> 4817888 : d1 = v_64(v[d][i + 8]);</span>
<span class="lineNum"> 139 </span> :
<span class="lineNum"> 140 </span><span class="lineCov"> 5047264 : p0 ^= d0;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 5047264 : p1 ^= d1;</span>
<span class="lineNum"> 140 </span><span class="lineCov"> 4817888 : p0 ^= d0;</span>
<span class="lineNum"> 141 </span><span class="lineCov"> 4817888 : p1 ^= d1;</span>
<span class="lineNum"> 142 </span> :
<span class="lineNum"> 143 </span><span class="lineCov"> 5047264 : q0 = x2_64(q0);</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 5047264 : q1 = x2_64(q1);</span>
<span class="lineNum"> 143 </span><span class="lineCov"> 4817888 : q0 = x2_64(q0);</span>
<span class="lineNum"> 144 </span><span class="lineCov"> 4817888 : q1 = x2_64(q1);</span>
<span class="lineNum"> 145 </span> :
<span class="lineNum"> 146 </span><span class="lineCov"> 5047264 : q0 ^= d0;</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 5047264 : q1 ^= d1;</span>
<span class="lineNum"> 146 </span><span class="lineCov"> 4817888 : q0 ^= d0;</span>
<span class="lineNum"> 147 </span><span class="lineCov"> 4817888 : q1 ^= d1;</span>
<span class="lineNum"> 148 </span> : }
<span class="lineNum"> 149 </span><span class="lineCov"> 720944 : v_64(p[i]) = p0;</span>
<span class="lineNum"> 150 </span><span class="lineCov"> 720944 : v_64(p[i + 8]) = p1;</span>
<span class="lineNum"> 151 </span><span class="lineCov"> 720944 : v_64(q[i]) = q0;</span>
<span class="lineNum"> 152 </span><span class="lineCov"> 720944 : v_64(q[i + 8]) = q1;</span>
<span class="lineNum"> 149 </span><span class="lineCov"> 688176 : v_64(p[i]) = p0;</span>
<span class="lineNum"> 150 </span><span class="lineCov"> 688176 : v_64(p[i + 8]) = p1;</span>
<span class="lineNum"> 151 </span><span class="lineCov"> 688176 : v_64(q[i]) = q0;</span>
<span class="lineNum"> 152 </span><span class="lineCov"> 688176 : v_64(q[i + 8]) = q1;</span>
<span class="lineNum"> 153 </span> : }
<span class="lineNum"> 154 </span><span class="lineCov"> 47 : }</span>
<span class="lineNum"> 154 </span><span class="lineCov"> 45 : }</span>
<span class="lineNum"> 155 </span> :
<span class="lineNum"> 156 </span> : /*
<span class="lineNum"> 157 </span> : * GEN3 (triple parity with Cauchy matrix) 8bit C implementation
@ -322,9 +322,9 @@
<span class="lineNum"> 260 </span> : * But this is only a kind of reference function, and we are not really
<a name="261"><span class="lineNum"> 261 </span> : * interested in speed.</a>
<span class="lineNum"> 262 </span> : */
<span class="lineNum"> 263 </span><span class="lineCov"> 18 : void raid_gen5_int8(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 263 </span><span class="lineCov"> 17 : void raid_gen5_int8(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 264 </span> : {
<span class="lineNum"> 265 </span><span class="lineCov"> 18 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 265 </span><span class="lineCov"> 17 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 266 </span> : uint8_t *p;
<span class="lineNum"> 267 </span> : uint8_t *q;
<span class="lineNum"> 268 </span> : uint8_t *r;
@ -335,41 +335,41 @@
<span class="lineNum"> 273 </span> :
<span class="lineNum"> 274 </span> : uint8_t d0, t0, s0, r0, q0, p0;
<span class="lineNum"> 275 </span> :
<span class="lineNum"> 276 </span><span class="lineCov"> 18 : l = nd - 1;</span>
<span class="lineNum"> 277 </span><span class="lineCov"> 18 : p = v[nd];</span>
<span class="lineNum"> 278 </span><span class="lineCov"> 18 : q = v[nd + 1];</span>
<span class="lineNum"> 279 </span><span class="lineCov"> 18 : r = v[nd + 2];</span>
<span class="lineNum"> 280 </span><span class="lineCov"> 18 : s = v[nd + 3];</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 18 : t = v[nd + 4];</span>
<span class="lineNum"> 276 </span><span class="lineCov"> 17 : l = nd - 1;</span>
<span class="lineNum"> 277 </span><span class="lineCov"> 17 : p = v[nd];</span>
<span class="lineNum"> 278 </span><span class="lineCov"> 17 : q = v[nd + 1];</span>
<span class="lineNum"> 279 </span><span class="lineCov"> 17 : r = v[nd + 2];</span>
<span class="lineNum"> 280 </span><span class="lineCov"> 17 : s = v[nd + 3];</span>
<span class="lineNum"> 281 </span><span class="lineCov"> 17 : t = v[nd + 4];</span>
<span class="lineNum"> 282 </span> :
<span class="lineNum"> 283 </span><span class="lineCov"> 4194834 : for (i = 0; i &lt; size; i += 1) {</span>
<span class="lineNum"> 284 </span><span class="lineCov"> 4194816 : p0 = q0 = r0 = s0 = t0 = 0;</span>
<span class="lineNum"> 285 </span><span class="lineCov"> 33562880 : for (d = l; d &gt; 0; --d) {</span>
<span class="lineNum"> 286 </span><span class="lineCov"> 29368064 : d0 = v_8(v[d][i]);</span>
<span class="lineNum"> 283 </span><span class="lineCov"> 3932689 : for (i = 0; i &lt; size; i += 1) {</span>
<span class="lineNum"> 284 </span><span class="lineCov"> 3932672 : p0 = q0 = r0 = s0 = t0 = 0;</span>
<span class="lineNum"> 285 </span><span class="lineCov"> 31465728 : for (d = l; d &gt; 0; --d) {</span>
<span class="lineNum"> 286 </span><span class="lineCov"> 27533056 : d0 = v_8(v[d][i]);</span>
<span class="lineNum"> 287 </span> :
<span class="lineNum"> 288 </span><span class="lineCov"> 29368064 : p0 ^= d0;</span>
<span class="lineNum"> 289 </span><span class="lineCov"> 29368064 : q0 ^= gfmul[d0][gfgen[1][d]];</span>
<span class="lineNum"> 290 </span><span class="lineCov"> 29368064 : r0 ^= gfmul[d0][gfgen[2][d]];</span>
<span class="lineNum"> 291 </span><span class="lineCov"> 29368064 : s0 ^= gfmul[d0][gfgen[3][d]];</span>
<span class="lineNum"> 292 </span><span class="lineCov"> 29368064 : t0 ^= gfmul[d0][gfgen[4][d]];</span>
<span class="lineNum"> 288 </span><span class="lineCov"> 27533056 : p0 ^= d0;</span>
<span class="lineNum"> 289 </span><span class="lineCov"> 27533056 : q0 ^= gfmul[d0][gfgen[1][d]];</span>
<span class="lineNum"> 290 </span><span class="lineCov"> 27533056 : r0 ^= gfmul[d0][gfgen[2][d]];</span>
<span class="lineNum"> 291 </span><span class="lineCov"> 27533056 : s0 ^= gfmul[d0][gfgen[3][d]];</span>
<span class="lineNum"> 292 </span><span class="lineCov"> 27533056 : t0 ^= gfmul[d0][gfgen[4][d]];</span>
<span class="lineNum"> 293 </span> : }
<span class="lineNum"> 294 </span> :
<span class="lineNum"> 295 </span> : /* first disk with all coefficients at 1 */
<span class="lineNum"> 296 </span><span class="lineCov"> 4194816 : d0 = v_8(v[0][i]);</span>
<span class="lineNum"> 296 </span><span class="lineCov"> 3932672 : d0 = v_8(v[0][i]);</span>
<span class="lineNum"> 297 </span> :
<span class="lineNum"> 298 </span><span class="lineCov"> 4194816 : p0 ^= d0;</span>
<span class="lineNum"> 299 </span><span class="lineCov"> 4194816 : q0 ^= d0;</span>
<span class="lineNum"> 300 </span><span class="lineCov"> 4194816 : r0 ^= d0;</span>
<span class="lineNum"> 301 </span><span class="lineCov"> 4194816 : s0 ^= d0;</span>
<span class="lineNum"> 302 </span><span class="lineCov"> 4194816 : t0 ^= d0;</span>
<span class="lineNum"> 298 </span><span class="lineCov"> 3932672 : p0 ^= d0;</span>
<span class="lineNum"> 299 </span><span class="lineCov"> 3932672 : q0 ^= d0;</span>
<span class="lineNum"> 300 </span><span class="lineCov"> 3932672 : r0 ^= d0;</span>
<span class="lineNum"> 301 </span><span class="lineCov"> 3932672 : s0 ^= d0;</span>
<span class="lineNum"> 302 </span><span class="lineCov"> 3932672 : t0 ^= d0;</span>
<span class="lineNum"> 303 </span> :
<span class="lineNum"> 304 </span><span class="lineCov"> 4194816 : v_8(p[i]) = p0;</span>
<span class="lineNum"> 305 </span><span class="lineCov"> 4194816 : v_8(q[i]) = q0;</span>
<span class="lineNum"> 306 </span><span class="lineCov"> 4194816 : v_8(r[i]) = r0;</span>
<span class="lineNum"> 307 </span><span class="lineCov"> 4194816 : v_8(s[i]) = s0;</span>
<span class="lineNum"> 308 </span><span class="lineCov"> 4194816 : v_8(t[i]) = t0;</span>
<span class="lineNum"> 304 </span><span class="lineCov"> 3932672 : v_8(p[i]) = p0;</span>
<span class="lineNum"> 305 </span><span class="lineCov"> 3932672 : v_8(q[i]) = q0;</span>
<span class="lineNum"> 306 </span><span class="lineCov"> 3932672 : v_8(r[i]) = r0;</span>
<span class="lineNum"> 307 </span><span class="lineCov"> 3932672 : v_8(s[i]) = s0;</span>
<span class="lineNum"> 308 </span><span class="lineCov"> 3932672 : v_8(t[i]) = t0;</span>
<span class="lineNum"> 309 </span> : }
<span class="lineNum"> 310 </span><span class="lineCov"> 18 : }</span>
<span class="lineNum"> 310 </span><span class="lineCov"> 17 : }</span>
<span class="lineNum"> 311 </span> :
<span class="lineNum"> 312 </span> : /*
<span class="lineNum"> 313 </span> : * GEN6 (hexa parity with Cauchy matrix) 8bit C implementation
@ -379,9 +379,9 @@
<span class="lineNum"> 317 </span> : * But this is only a kind of reference function, and we are not really
<a name="318"><span class="lineNum"> 318 </span> : * interested in speed.</a>
<span class="lineNum"> 319 </span> : */
<span class="lineNum"> 320 </span><span class="lineCov"> 17 : void raid_gen6_int8(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 320 </span><span class="lineCov"> 15 : void raid_gen6_int8(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 321 </span> : {
<span class="lineNum"> 322 </span><span class="lineCov"> 17 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 322 </span><span class="lineCov"> 15 : uint8_t **v = (uint8_t **)vv;</span>
<span class="lineNum"> 323 </span> : uint8_t *p;
<span class="lineNum"> 324 </span> : uint8_t *q;
<span class="lineNum"> 325 </span> : uint8_t *r;
@ -393,45 +393,45 @@
<span class="lineNum"> 331 </span> :
<span class="lineNum"> 332 </span> : uint8_t d0, u0, t0, s0, r0, q0, p0;
<span class="lineNum"> 333 </span> :
<span class="lineNum"> 334 </span><span class="lineCov"> 17 : l = nd - 1;</span>
<span class="lineNum"> 335 </span><span class="lineCov"> 17 : p = v[nd];</span>
<span class="lineNum"> 336 </span><span class="lineCov"> 17 : q = v[nd + 1];</span>
<span class="lineNum"> 337 </span><span class="lineCov"> 17 : r = v[nd + 2];</span>
<span class="lineNum"> 338 </span><span class="lineCov"> 17 : s = v[nd + 3];</span>
<span class="lineNum"> 339 </span><span class="lineCov"> 17 : t = v[nd + 4];</span>
<span class="lineNum"> 340 </span><span class="lineCov"> 17 : u = v[nd + 5];</span>
<span class="lineNum"> 334 </span><span class="lineCov"> 15 : l = nd - 1;</span>
<span class="lineNum"> 335 </span><span class="lineCov"> 15 : p = v[nd];</span>
<span class="lineNum"> 336 </span><span class="lineCov"> 15 : q = v[nd + 1];</span>
<span class="lineNum"> 337 </span><span class="lineCov"> 15 : r = v[nd + 2];</span>
<span class="lineNum"> 338 </span><span class="lineCov"> 15 : s = v[nd + 3];</span>
<span class="lineNum"> 339 </span><span class="lineCov"> 15 : t = v[nd + 4];</span>
<span class="lineNum"> 340 </span><span class="lineCov"> 15 : u = v[nd + 5];</span>
<span class="lineNum"> 341 </span> :
<span class="lineNum"> 342 </span><span class="lineCov"> 3932689 : for (i = 0; i &lt; size; i += 1) {</span>
<span class="lineNum"> 343 </span><span class="lineCov"> 3932672 : p0 = q0 = r0 = s0 = t0 = u0 = 0;</span>
<span class="lineNum"> 344 </span><span class="lineCov"> 31465728 : for (d = l; d &gt; 0; --d) {</span>
<span class="lineNum"> 345 </span><span class="lineCov"> 27533056 : d0 = v_8(v[d][i]);</span>
<span class="lineNum"> 342 </span><span class="lineCov"> 3408399 : for (i = 0; i &lt; size; i += 1) {</span>
<span class="lineNum"> 343 </span><span class="lineCov"> 3408384 : p0 = q0 = r0 = s0 = t0 = u0 = 0;</span>
<span class="lineNum"> 344 </span><span class="lineCov"> 27271424 : for (d = l; d &gt; 0; --d) {</span>
<span class="lineNum"> 345 </span><span class="lineCov"> 23863040 : d0 = v_8(v[d][i]);</span>
<span class="lineNum"> 346 </span> :
<span class="lineNum"> 347 </span><span class="lineCov"> 27533056 : p0 ^= d0;</span>
<span class="lineNum"> 348 </span><span class="lineCov"> 27533056 : q0 ^= gfmul[d0][gfgen[1][d]];</span>
<span class="lineNum"> 349 </span><span class="lineCov"> 27533056 : r0 ^= gfmul[d0][gfgen[2][d]];</span>
<span class="lineNum"> 350 </span><span class="lineCov"> 27533056 : s0 ^= gfmul[d0][gfgen[3][d]];</span>
<span class="lineNum"> 351 </span><span class="lineCov"> 27533056 : t0 ^= gfmul[d0][gfgen[4][d]];</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 27533056 : u0 ^= gfmul[d0][gfgen[5][d]];</span>
<span class="lineNum"> 347 </span><span class="lineCov"> 23863040 : p0 ^= d0;</span>
<span class="lineNum"> 348 </span><span class="lineCov"> 23863040 : q0 ^= gfmul[d0][gfgen[1][d]];</span>
<span class="lineNum"> 349 </span><span class="lineCov"> 23863040 : r0 ^= gfmul[d0][gfgen[2][d]];</span>
<span class="lineNum"> 350 </span><span class="lineCov"> 23863040 : s0 ^= gfmul[d0][gfgen[3][d]];</span>
<span class="lineNum"> 351 </span><span class="lineCov"> 23863040 : t0 ^= gfmul[d0][gfgen[4][d]];</span>
<span class="lineNum"> 352 </span><span class="lineCov"> 23863040 : u0 ^= gfmul[d0][gfgen[5][d]];</span>
<span class="lineNum"> 353 </span> : }
<span class="lineNum"> 354 </span> :
<span class="lineNum"> 355 </span> : /* first disk with all coefficients at 1 */
<span class="lineNum"> 356 </span><span class="lineCov"> 3932672 : d0 = v_8(v[0][i]);</span>
<span class="lineNum"> 356 </span><span class="lineCov"> 3408384 : d0 = v_8(v[0][i]);</span>
<span class="lineNum"> 357 </span> :
<span class="lineNum"> 358 </span><span class="lineCov"> 3932672 : p0 ^= d0;</span>
<span class="lineNum"> 359 </span><span class="lineCov"> 3932672 : q0 ^= d0;</span>
<span class="lineNum"> 360 </span><span class="lineCov"> 3932672 : r0 ^= d0;</span>
<span class="lineNum"> 361 </span><span class="lineCov"> 3932672 : s0 ^= d0;</span>
<span class="lineNum"> 362 </span><span class="lineCov"> 3932672 : t0 ^= d0;</span>
<span class="lineNum"> 363 </span><span class="lineCov"> 3932672 : u0 ^= d0;</span>
<span class="lineNum"> 358 </span><span class="lineCov"> 3408384 : p0 ^= d0;</span>
<span class="lineNum"> 359 </span><span class="lineCov"> 3408384 : q0 ^= d0;</span>
<span class="lineNum"> 360 </span><span class="lineCov"> 3408384 : r0 ^= d0;</span>
<span class="lineNum"> 361 </span><span class="lineCov"> 3408384 : s0 ^= d0;</span>
<span class="lineNum"> 362 </span><span class="lineCov"> 3408384 : t0 ^= d0;</span>
<span class="lineNum"> 363 </span><span class="lineCov"> 3408384 : u0 ^= d0;</span>
<span class="lineNum"> 364 </span> :
<span class="lineNum"> 365 </span><span class="lineCov"> 3932672 : v_8(p[i]) = p0;</span>
<span class="lineNum"> 366 </span><span class="lineCov"> 3932672 : v_8(q[i]) = q0;</span>
<span class="lineNum"> 367 </span><span class="lineCov"> 3932672 : v_8(r[i]) = r0;</span>
<span class="lineNum"> 368 </span><span class="lineCov"> 3932672 : v_8(s[i]) = s0;</span>
<span class="lineNum"> 369 </span><span class="lineCov"> 3932672 : v_8(t[i]) = t0;</span>
<span class="lineNum"> 370 </span><span class="lineCov"> 3932672 : v_8(u[i]) = u0;</span>
<span class="lineNum"> 365 </span><span class="lineCov"> 3408384 : v_8(p[i]) = p0;</span>
<span class="lineNum"> 366 </span><span class="lineCov"> 3408384 : v_8(q[i]) = q0;</span>
<span class="lineNum"> 367 </span><span class="lineCov"> 3408384 : v_8(r[i]) = r0;</span>
<span class="lineNum"> 368 </span><span class="lineCov"> 3408384 : v_8(s[i]) = s0;</span>
<span class="lineNum"> 369 </span><span class="lineCov"> 3408384 : v_8(t[i]) = t0;</span>
<span class="lineNum"> 370 </span><span class="lineCov"> 3408384 : v_8(u[i]) = u0;</span>
<span class="lineNum"> 371 </span> : }
<span class="lineNum"> 372 </span><span class="lineCov"> 17 : }</span>
<span class="lineNum"> 372 </span><span class="lineCov"> 15 : }</span>
<span class="lineNum"> 373 </span> :
<span class="lineNum"> 374 </span> : /*
<span class="lineNum"> 375 </span> : * Recover failure of one data block at index id[0] using parity at index

8
cov/raid/internal.h.gcov.html
View file

@ -169,11 +169,11 @@
<span class="lineNum"> 107 </span> : */
<span class="lineNum"> 108 </span> : static __always_inline void *__align_ptr(void *ptr, uintptr_t size)
<span class="lineNum"> 109 </span> : {
<span class="lineNum"> 110 </span><span class="lineCov"> 711847 : uintptr_t offset = (uintptr_t)ptr;</span>
<span class="lineNum"> 110 </span><span class="lineCov"> 711919 : uintptr_t offset = (uintptr_t)ptr;</span>
<span class="lineNum"> 111 </span> :
<span class="lineNum"> 112 </span><span class="lineCov"> 711847 : offset = (offset + size - 1U) &amp; ~(size - 1U);</span>
<span class="lineNum"> 112 </span><span class="lineCov"> 711919 : offset = (offset + size - 1U) &amp; ~(size - 1U);</span>
<span class="lineNum"> 113 </span> :
<span class="lineNum"> 114 </span><span class="lineCov"> 711847 : return (void *)offset;</span>
<span class="lineNum"> 114 </span><span class="lineCov"> 711919 : return (void *)offset;</span>
<span class="lineNum"> 115 </span> : }
<span class="lineNum"> 116 </span> :
<span class="lineNum"> 117 </span> : /*
@ -294,7 +294,7 @@
<span class="lineNum"> 232 </span> : /* that use a weak memory model. To ensure that other processors */
<span class="lineNum"> 233 </span> : /* see correctly the data written, we use a store-store memory */
<span class="lineNum"> 234 </span> : /* barrier at the end of the asm code */
<span class="lineNum"> 235 </span><span class="lineCov"> 1388678 : asm volatile (&quot;sfence&quot; : : : &quot;memory&quot;);</span>
<span class="lineNum"> 235 </span><span class="lineCov"> 1388842 : asm volatile (&quot;sfence&quot; : : : &quot;memory&quot;);</span>
<span class="lineNum"> 236 </span> :
<span class="lineNum"> 237 </span> : /* clobbers registers used in the asm code */
<span class="lineNum"> 238 </span> : /* this is required because in the Windows ABI, */

2
cov/raid/intz.c.func-sort-c.html
View file

@ -65,7 +65,7 @@
</tr>
<tr>
<td class="coverFn"><a href="intz.c.gcov.html#19">raid_genz_int32</a></td>
<td class="coverFnHi">29</td>
<td class="coverFnHi">28</td>
</tr>
</table>
<br>

2
cov/raid/intz.c.func.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="intz.c.gcov.html#19">raid_genz_int32</a></td>
<td class="coverFnHi">29</td>
<td class="coverFnHi">28</td>
</tr>
<tr>
<td class="coverFn"><a href="intz.c.gcov.html#70">raid_genz_int64</a></td>

58
cov/raid/intz.c.gcov.html
View file

@ -80,9 +80,9 @@
<span class="lineNum"> 18 </span> : /*
<a name="19"><span class="lineNum"> 19 </span> : * GENz (triple parity with powers of 2^-1) 32bit C implementation</a>
<span class="lineNum"> 20 </span> : */
<span class="lineNum"> 21 </span><span class="lineCov"> 29 : void raid_genz_int32(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 21 </span><span class="lineCov"> 28 : void raid_genz_int32(int nd, size_t size, void **vv)</span>
<span class="lineNum"> 22 </span> : {
<span class="lineNum"> 23 </span><span class="lineCov"> 29 : uint8_t **v = (uint8_t**)vv;</span>
<span class="lineNum"> 23 </span><span class="lineCov"> 28 : uint8_t **v = (uint8_t**)vv;</span>
<span class="lineNum"> 24 </span> : uint8_t *p;
<span class="lineNum"> 25 </span> : uint8_t *q;
<span class="lineNum"> 26 </span> : uint8_t *r;
@ -92,41 +92,41 @@
<span class="lineNum"> 30 </span> : uint32_t d0, r0, q0, p0;
<span class="lineNum"> 31 </span> : uint32_t d1, r1, q1, p1;
<span class="lineNum"> 32 </span> :
<span class="lineNum"> 33 </span><span class="lineCov"> 29 : l = nd - 1;</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 29 : p = v[nd];</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 29 : q = v[nd + 1];</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 29 : r = v[nd + 2];</span>
<span class="lineNum"> 33 </span><span class="lineCov"> 28 : l = nd - 1;</span>
<span class="lineNum"> 34 </span><span class="lineCov"> 28 : p = v[nd];</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 28 : q = v[nd + 1];</span>
<span class="lineNum"> 36 </span><span class="lineCov"> 28 : r = v[nd + 2];</span>
<span class="lineNum"> 37 </span> :
<span class="lineNum"> 38 </span><span class="lineCov"> 917565 : for (i = 0; i &lt; size; i += 8) {</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 917536 : r0 = q0 = p0 = v_32(v[l][i]);</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 917536 : r1 = q1 = p1 = v_32(v[l][i + 4]);</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 7341056 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 6423520 : d0 = v_32(v[d][i]);</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 6423520 : d1 = v_32(v[d][i + 4]);</span>
<span class="lineNum"> 38 </span><span class="lineCov"> 884796 : for (i = 0; i &lt; size; i += 8) {</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 884768 : r0 = q0 = p0 = v_32(v[l][i]);</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 884768 : r1 = q1 = p1 = v_32(v[l][i + 4]);</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 7078912 : for (d = l - 1; d &gt;= 0; --d) {</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 6194144 : d0 = v_32(v[d][i]);</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 6194144 : d1 = v_32(v[d][i + 4]);</span>
<span class="lineNum"> 44 </span> :
<span class="lineNum"> 45 </span><span class="lineCov"> 6423520 : p0 ^= d0;</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 6423520 : p1 ^= d1;</span>
<span class="lineNum"> 45 </span><span class="lineCov"> 6194144 : p0 ^= d0;</span>
<span class="lineNum"> 46 </span><span class="lineCov"> 6194144 : p1 ^= d1;</span>
<span class="lineNum"> 47 </span> :
<span class="lineNum"> 48 </span><span class="lineCov"> 6423520 : q0 = x2_32(q0);</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 6423520 : q1 = x2_32(q1);</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 6194144 : q0 = x2_32(q0);</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 6194144 : q1 = x2_32(q1);</span>
<span class="lineNum"> 50 </span> :
<span class="lineNum"> 51 </span><span class="lineCov"> 6423520 : q0 ^= d0;</span>
<span class="lineNum"> 52 </span><span class="lineCov"> 6423520 : q1 ^= d1;</span>
<span class="lineNum"> 51 </span><span class="lineCov"> 6194144 : q0 ^= d0;</span>
<span class="lineNum"> 52 </span><span class="lineCov"> 6194144 : q1 ^= d1;</span>
<span class="lineNum"> 53 </span> :
<span class="lineNum"> 54 </span><span class="lineCov"> 6423520 : r0 = d2_32(r0);</span>
<span class="lineNum"> 55 </span><span class="lineCov"> 6423520 : r1 = d2_32(r1);</span>
<span class="lineNum"> 54 </span><span class="lineCov"> 6194144 : r0 = d2_32(r0);</span>
<span class="lineNum"> 55 </span><span class="lineCov"> 6194144 : r1 = d2_32(r1);</span>
<span class="lineNum"> 56 </span> :
<span class="lineNum"> 57 </span><span class="lineCov"> 6423520 : r0 ^= d0;</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 6423520 : r1 ^= d1;</span>
<span class="lineNum"> 57 </span><span class="lineCov"> 6194144 : r0 ^= d0;</span>
<span class="lineNum"> 58 </span><span class="lineCov"> 6194144 : r1 ^= d1;</span>
<span class="lineNum"> 59 </span> : }
<span class="lineNum"> 60 </span><span class="lineCov"> 917536 : v_32(p[i]) = p0;</span>
<span class="lineNum"> 61 </span><span class="lineCov"> 917536 : v_32(p[i + 4]) = p1;</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 917536 : v_32(q[i]) = q0;</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 917536 : v_32(q[i + 4]) = q1;</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 917536 : v_32(r[i]) = r0;</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 917536 : v_32(r[i + 4]) = r1;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 884768 : v_32(p[i]) = p0;</span>
<span class="lineNum"> 61 </span><span class="lineCov"> 884768 : v_32(p[i + 4]) = p1;</span>
<span class="lineNum"> 62 </span><span class="lineCov"> 884768 : v_32(q[i]) = q0;</span>
<span class="lineNum"> 63 </span><span class="lineCov"> 884768 : v_32(q[i + 4]) = q1;</span>
<span class="lineNum"> 64 </span><span class="lineCov"> 884768 : v_32(r[i]) = r0;</span>
<span class="lineNum"> 65 </span><span class="lineCov"> 884768 : v_32(r[i + 4]) = r1;</span>
<span class="lineNum"> 66 </span> : }
<span class="lineNum"> 67 </span><span class="lineCov"> 29 : }</span>
<span class="lineNum"> 67 </span><span class="lineCov"> 28 : }</span>
<span class="lineNum"> 68 </span> :
<span class="lineNum"> 69 </span> : /*
<a name="70"><span class="lineNum"> 70 </span> : * GENz (triple parity with powers of 2^-1) 64bit C implementation</a>

2
cov/raid/memory.c.gcov.html
View file

@ -94,7 +94,7 @@
<span class="lineNum"> 32 </span><span class="lineCov"> 12558 : offset = ((uintptr_t)ptr) % align_size;</span>
<span class="lineNum"> 33 </span> :
<span class="lineNum"> 34 </span><span class="lineCov"> 12558 : if (offset != 0)</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 12172 : ptr += align_size - offset;</span>
<span class="lineNum"> 35 </span><span class="lineCov"> 12171 : ptr += align_size - offset;</span>
<span class="lineNum"> 36 </span> :
<span class="lineNum"> 37 </span><span class="lineCov"> 12558 : return ptr;</span>
<a name="38"><span class="lineNum"> 38 </span> : }</a>

2
cov/raid/module.c.func-sort-c.html
View file

@ -61,7 +61,7 @@
</tr>
<tr>
<td class="coverFn"><a href="module.c.gcov.html#20">raid_init</a></td>
<td class="coverFnHi">269</td>
<td class="coverFnHi">270</td>
</tr>
<tr>
<td class="coverFn"><a href="module.c.gcov.html#187">raid_test_rec</a></td>

2
cov/raid/module.c.func.html
View file

@ -65,7 +65,7 @@
</tr>
<tr>
<td class="coverFn"><a href="module.c.gcov.html#20">raid_init</a></td>
<td class="coverFnHi">269</td>
<td class="coverFnHi">270</td>
</tr>
<tr>
<td class="coverFn"><a href="module.c.gcov.html#307">raid_selftest</a></td>

64
cov/raid/module.c.gcov.html
View file

@ -81,34 +81,34 @@
<span class="lineNum"> 19 </span> : /*
<a name="20"><span class="lineNum"> 20 </span> : * Initializes and selects the best algorithm.</a>
<span class="lineNum"> 21 </span> : */
<span class="lineNum"> 22 </span><span class="lineCov"> 269 : void raid_init(void)</span>
<span class="lineNum"> 22 </span><span class="lineCov"> 270 : void raid_init(void)</span>
<span class="lineNum"> 23 </span> : {
<span class="lineNum"> 24 </span><span class="lineCov"> 269 : raid_gen3_ptr = raid_gen3_int8;</span>
<span class="lineNum"> 25 </span><span class="lineCov"> 269 : raid_gen_ptr[3] = raid_gen4_int8;</span>
<span class="lineNum"> 26 </span><span class="lineCov"> 269 : raid_gen_ptr[4] = raid_gen5_int8;</span>
<span class="lineNum"> 27 </span><span class="lineCov"> 269 : raid_gen_ptr[5] = raid_gen6_int8;</span>
<span class="lineNum"> 24 </span><span class="lineCov"> 270 : raid_gen3_ptr = raid_gen3_int8;</span>
<span class="lineNum"> 25 </span><span class="lineCov"> 270 : raid_gen_ptr[3] = raid_gen4_int8;</span>
<span class="lineNum"> 26 </span><span class="lineCov"> 270 : raid_gen_ptr[4] = raid_gen5_int8;</span>
<span class="lineNum"> 27 </span><span class="lineCov"> 270 : raid_gen_ptr[5] = raid_gen6_int8;</span>
<span class="lineNum"> 28 </span> :
<span class="lineNum"> 29 </span> : if (sizeof(void *) == 4) {
<span class="lineNum"> 30 </span><span class="lineCov"> 269 : raid_gen_ptr[0] = raid_gen1_int32;</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 269 : raid_gen_ptr[1] = raid_gen2_int32;</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 269 : raid_genz_ptr = raid_genz_int32;</span>
<span class="lineNum"> 30 </span><span class="lineCov"> 270 : raid_gen_ptr[0] = raid_gen1_int32;</span>
<span class="lineNum"> 31 </span><span class="lineCov"> 270 : raid_gen_ptr[1] = raid_gen2_int32;</span>
<span class="lineNum"> 32 </span><span class="lineCov"> 270 : raid_genz_ptr = raid_genz_int32;</span>
<span class="lineNum"> 33 </span> : } else {
<span class="lineNum"> 34 </span> : raid_gen_ptr[0] = raid_gen1_int64;
<span class="lineNum"> 35 </span> : raid_gen_ptr[1] = raid_gen2_int64;
<span class="lineNum"> 36 </span> : raid_genz_ptr = raid_genz_int64;
<span class="lineNum"> 37 </span> : }
<span class="lineNum"> 38 </span> :
<span class="lineNum"> 39 </span><span class="lineCov"> 269 : raid_rec_ptr[0] = raid_rec1_int8;</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 269 : raid_rec_ptr[1] = raid_rec2_int8;</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 269 : raid_rec_ptr[2] = raid_recX_int8;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 269 : raid_rec_ptr[3] = raid_recX_int8;</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 269 : raid_rec_ptr[4] = raid_recX_int8;</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 269 : raid_rec_ptr[5] = raid_recX_int8;</span>
<span class="lineNum"> 39 </span><span class="lineCov"> 270 : raid_rec_ptr[0] = raid_rec1_int8;</span>
<span class="lineNum"> 40 </span><span class="lineCov"> 270 : raid_rec_ptr[1] = raid_rec2_int8;</span>
<span class="lineNum"> 41 </span><span class="lineCov"> 270 : raid_rec_ptr[2] = raid_recX_int8;</span>
<span class="lineNum"> 42 </span><span class="lineCov"> 270 : raid_rec_ptr[3] = raid_recX_int8;</span>
<span class="lineNum"> 43 </span><span class="lineCov"> 270 : raid_rec_ptr[4] = raid_recX_int8;</span>
<span class="lineNum"> 44 </span><span class="lineCov"> 270 : raid_rec_ptr[5] = raid_recX_int8;</span>
<span class="lineNum"> 45 </span> :
<span class="lineNum"> 46 </span> : #ifdef CONFIG_X86
<span class="lineNum"> 47 </span> : #ifdef CONFIG_SSE2
<span class="lineNum"> 48 </span><span class="lineCov"> 269 : if (raid_cpu_has_sse2()) {</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 269 : raid_gen_ptr[0] = raid_gen1_sse2;</span>
<span class="lineNum"> 48 </span><span class="lineCov"> 270 : if (raid_cpu_has_sse2()) {</span>
<span class="lineNum"> 49 </span><span class="lineCov"> 270 : raid_gen_ptr[0] = raid_gen1_sse2;</span>
<span class="lineNum"> 50 </span> : #ifdef CONFIG_X86_64
<span class="lineNum"> 51 </span> : if (raid_cpu_has_slowextendedreg()) {
<span class="lineNum"> 52 </span> : raid_gen_ptr[1] = raid_gen2_sse2;
@ -118,14 +118,14 @@
<span class="lineNum"> 56 </span> : /* note that raid_cpu_has_slowextendedreg() doesn't affect parz */
<span class="lineNum"> 57 </span> : raid_genz_ptr = raid_genz_sse2ext;
<span class="lineNum"> 58 </span> : #else
<span class="lineNum"> 59 </span><span class="lineCov"> 269 : raid_gen_ptr[1] = raid_gen2_sse2;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 269 : raid_genz_ptr = raid_genz_sse2;</span>
<span class="lineNum"> 59 </span><span class="lineCov"> 270 : raid_gen_ptr[1] = raid_gen2_sse2;</span>
<span class="lineNum"> 60 </span><span class="lineCov"> 270 : raid_genz_ptr = raid_genz_sse2;</span>
<span class="lineNum"> 61 </span> : #endif
<span class="lineNum"> 62 </span> : }
<span class="lineNum"> 63 </span> : #endif
<span class="lineNum"> 64 </span> :
<span class="lineNum"> 65 </span> : #ifdef CONFIG_SSSE3
<span class="lineNum"> 66 </span><span class="lineCov"> 269 : if (raid_cpu_has_ssse3()) {</span>
<span class="lineNum"> 66 </span><span class="lineCov"> 270 : if (raid_cpu_has_ssse3()) {</span>
<span class="lineNum"> 67 </span> : #ifdef CONFIG_X86_64
<span class="lineNum"> 68 </span> : if (raid_cpu_has_slowextendedreg()) {
<span class="lineNum"> 69 </span> : raid_gen3_ptr = raid_gen3_ssse3;
@ -139,22 +139,22 @@
<span class="lineNum"> 77 </span> : raid_gen_ptr[5] = raid_gen6_ssse3ext;
<span class="lineNum"> 78 </span> : }
<span class="lineNum"> 79 </span> : #else
<span class="lineNum"> 80 </span><span class="lineCov"> 268 : raid_gen3_ptr = raid_gen3_ssse3;</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 268 : raid_gen_ptr[3] = raid_gen4_ssse3;</span>
<span class="lineNum"> 82 </span><span class="lineCov"> 268 : raid_gen_ptr[4] = raid_gen5_ssse3;</span>
<span class="lineNum"> 83 </span><span class="lineCov"> 268 : raid_gen_ptr[5] = raid_gen6_ssse3;</span>
<span class="lineNum"> 80 </span><span class="lineCov"> 269 : raid_gen3_ptr = raid_gen3_ssse3;</span>
<span class="lineNum"> 81 </span><span class="lineCov"> 269 : raid_gen_ptr[3] = raid_gen4_ssse3;</span>
<span class="lineNum"> 82 </span><span class="lineCov"> 269 : raid_gen_ptr[4] = raid_gen5_ssse3;</span>
<span class="lineNum"> 83 </span><span class="lineCov"> 269 : raid_gen_ptr[5] = raid_gen6_ssse3;</span>
<span class="lineNum"> 84 </span> : #endif
<span class="lineNum"> 85 </span><span class="lineCov"> 268 : raid_rec_ptr[0] = raid_rec1_ssse3;</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 268 : raid_rec_ptr[1] = raid_rec2_ssse3;</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 268 : raid_rec_ptr[2] = raid_recX_ssse3;</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 268 : raid_rec_ptr[3] = raid_recX_ssse3;</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 268 : raid_rec_ptr[4] = raid_recX_ssse3;</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 268 : raid_rec_ptr[5] = raid_recX_ssse3;</span>
<span class="lineNum"> 85 </span><span class="lineCov"> 269 : raid_rec_ptr[0] = raid_rec1_ssse3;</span>
<span class="lineNum"> 86 </span><span class="lineCov"> 269 : raid_rec_ptr[1] = raid_rec2_ssse3;</span>
<span class="lineNum"> 87 </span><span class="lineCov"> 269 : raid_rec_ptr[2] = raid_recX_ssse3;</span>
<span class="lineNum"> 88 </span><span class="lineCov"> 269 : raid_rec_ptr[3] = raid_recX_ssse3;</span>
<span class="lineNum"> 89 </span><span class="lineCov"> 269 : raid_rec_ptr[4] = raid_recX_ssse3;</span>
<span class="lineNum"> 90 </span><span class="lineCov"> 269 : raid_rec_ptr[5] = raid_recX_ssse3;</span>
<span class="lineNum"> 91 </span> : }
<span class="lineNum"> 92 </span> : #endif
<span class="lineNum"> 93 </span> :
<span class="lineNum"> 94 </span> : #ifdef CONFIG_AVX2
<span class="lineNum"> 95 </span><span class="lineCov"> 269 : if (raid_cpu_has_avx2()) {</span>
<span class="lineNum"> 95 </span><span class="lineCov"> 270 : if (raid_cpu_has_avx2()) {</span>
<span class="lineNum"> 96 </span><span class="lineCov"> 2 : raid_gen_ptr[0] = raid_gen1_avx2;</span>
<span class="lineNum"> 97 </span><span class="lineCov"> 2 : raid_gen_ptr[1] = raid_gen2_avx2;</span>
<span class="lineNum"> 98 </span> : #ifdef CONFIG_X86_64
@ -175,8 +175,8 @@
<span class="lineNum"> 113 </span> : #endif /* CONFIG_X86 */
<span class="lineNum"> 114 </span> :
<span class="lineNum"> 115 </span> : /* set the default mode */
<span class="lineNum"> 116 </span><span class="lineCov"> 269 : raid_mode(RAID_MODE_CAUCHY);</span>
<span class="lineNum"> 117 </span><span class="lineCov"> 269 : }</span>
<span class="lineNum"> 116 </span><span class="lineCov"> 270 : raid_mode(RAID_MODE_CAUCHY);</span>
<span class="lineNum"> 117 </span><span class="lineCov"> 270 : }</span>
<span class="lineNum"> 118 </span> :
<span class="lineNum"> 119 </span> : /*
<a name="120"><span class="lineNum"> 120 </span> : * Reference parity computation.</a>

12
cov/raid/raid.c.func-sort-c.html
View file

@ -61,23 +61,23 @@
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#221">raid_gen</a></td>
<td class="coverFnHi">1235540</td>
<td class="coverFnHi">1235917</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#554">raid_data</a></td>
<td class="coverFnHi">214715</td>
<td class="coverFnHi">214914</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#244">raid_invert</a></td>
<td class="coverFnHi">172728</td>
<td class="coverFnHi">172507</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#289">raid_delta_gen</a></td>
<td class="coverFnHi">171710</td>
<td class="coverFnHi">171503</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#383">raid_rec1of1</a></td>
<td class="coverFnHi">101386</td>
<td class="coverFnHi">101792</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#493">raid_rec</a></td>
@ -85,7 +85,7 @@
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#174">raid_mode</a></td>
<td class="coverFnHi">537</td>
<td class="coverFnHi">539</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#190">raid_zero</a></td>

12
cov/raid/raid.c.func.html
View file

@ -61,23 +61,23 @@
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#554">raid_data</a></td>
<td class="coverFnHi">214715</td>
<td class="coverFnHi">214914</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#289">raid_delta_gen</a></td>
<td class="coverFnHi">171710</td>
<td class="coverFnHi">171503</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#221">raid_gen</a></td>
<td class="coverFnHi">1235540</td>
<td class="coverFnHi">1235917</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#244">raid_invert</a></td>
<td class="coverFnHi">172728</td>
<td class="coverFnHi">172507</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#174">raid_mode</a></td>
<td class="coverFnHi">537</td>
<td class="coverFnHi">539</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#493">raid_rec</a></td>
@ -85,7 +85,7 @@
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#383">raid_rec1of1</a></td>
<td class="coverFnHi">101386</td>
<td class="coverFnHi">101792</td>
</tr>
<tr>
<td class="coverFn"><a href="raid.c.gcov.html#430">raid_rec2of2_int8</a></td>

Some files were not shown because too many files have changed in this diff Show more