?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tag 2.2.0-rc4
[zfs.git] / cmd / raidz_test / raidz_test.c
blob195026d3a7ab916c49967932386ba32dceb24473
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or https://opensource.org/licenses/CDDL-1.0.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (C) 2016 Gvozden Nešković. All rights reserved.
24 */
25
26 #include <sys/zfs_context.h>
27 #include <sys/time.h>
28 #include <sys/wait.h>
29 #include <sys/zio.h>
30 #include <umem.h>
31 #include <sys/vdev_raidz.h>
32 #include <sys/vdev_raidz_impl.h>
33 #include <assert.h>
34 #include <stdio.h>
35 #include "raidz_test.h"
36
37 static int *rand_data;
38 raidz_test_opts_t rto_opts;
39
40 static char pid_s[16];
41
42 static void sig_handler(int signo)
43 {
44 int old_errno = errno;
45 struct sigaction action;
46 /*
47 * Restore default action and re-raise signal so SIGSEGV and
48 * SIGABRT can trigger a core dump.
49 */
50 action.sa_handler = SIG_DFL;
51 sigemptyset(&action.sa_mask);
52 action.sa_flags = 0;
53 (void) sigaction(signo, &action, NULL);
54
55 if (rto_opts.rto_gdb) {
56 pid_t pid = fork();
57 if (pid == 0) {
58 execlp("gdb", "gdb", "-ex", "set pagination 0",
59 "-p", pid_s, NULL);
60 _exit(-1);
61 } else if (pid > 0)
62 while (waitpid(pid, NULL, 0) == -1 && errno == EINTR)
63 ;
64 }
65
66 raise(signo);
67 errno = old_errno;
68 }
69
70 static void print_opts(raidz_test_opts_t *opts, boolean_t force)
71 {
72 const char *verbose;
73 switch (opts->rto_v) {
74 case D_ALL:
75 verbose = "no";
76 break;
77 case D_INFO:
78 verbose = "info";
79 break;
80 case D_DEBUG:
81 default:
82 verbose = "debug";
83 break;
84 }
85
86 if (force || opts->rto_v >= D_INFO) {
87 (void) fprintf(stdout, DBLSEP "Running with options:\n"
88 " (-a) zio ashift : %zu\n"
89 " (-o) zio offset : 1 << %zu\n"
90 " (-e) expanded map : %s\n"
91 " (-r) reflow offset : %llx\n"
92 " (-d) number of raidz data columns : %zu\n"
93 " (-s) size of DATA : 1 << %zu\n"
94 " (-S) sweep parameters : %s \n"
95 " (-v) verbose : %s \n\n",
96 opts->rto_ashift, /* -a */
97 ilog2(opts->rto_offset), /* -o */
98 opts->rto_expand ? "yes" : "no", /* -e */
99 (u_longlong_t)opts->rto_expand_offset, /* -r */
100 opts->rto_dcols, /* -d */
101 ilog2(opts->rto_dsize), /* -s */
102 opts->rto_sweep ? "yes" : "no", /* -S */
103 verbose); /* -v */
104 }
105 }
106
107 static void usage(boolean_t requested)
108 {
109 const raidz_test_opts_t *o = &rto_opts_defaults;
110
111 FILE *fp = requested ? stdout : stderr;
112
113 (void) fprintf(fp, "Usage:\n"
114 "\t[-a zio ashift (default: %zu)]\n"
115 "\t[-o zio offset, exponent radix 2 (default: %zu)]\n"
116 "\t[-d number of raidz data columns (default: %zu)]\n"
117 "\t[-s zio size, exponent radix 2 (default: %zu)]\n"
118 "\t[-S parameter sweep (default: %s)]\n"
119 "\t[-t timeout for parameter sweep test]\n"
120 "\t[-B benchmark all raidz implementations]\n"
121 "\t[-e use expanded raidz map (default: %s)]\n"
122 "\t[-r expanded raidz map reflow offset (default: %llx)]\n"
123 "\t[-v increase verbosity (default: %d)]\n"
124 "\t[-h (print help)]\n"
125 "\t[-T test the test, see if failure would be detected]\n"
126 "\t[-D debug (attach gdb on SIGSEGV)]\n"
127 "",
128 o->rto_ashift, /* -a */
129 ilog2(o->rto_offset), /* -o */
130 o->rto_dcols, /* -d */
131 ilog2(o->rto_dsize), /* -s */
132 rto_opts.rto_sweep ? "yes" : "no", /* -S */
133 rto_opts.rto_expand ? "yes" : "no", /* -e */
134 (u_longlong_t)o->rto_expand_offset, /* -r */
135 o->rto_v); /* -v */
136
137 exit(requested ? 0 : 1);
138 }
139
140 static void process_options(int argc, char **argv)
141 {
142 size_t value;
143 int opt;
144 raidz_test_opts_t *o = &rto_opts;
145
146 memcpy(o, &rto_opts_defaults, sizeof (*o));
147
148 while ((opt = getopt(argc, argv, "TDBSvha:er:o:d:s:t:")) != -1) {
149 switch (opt) {
150 case 'a':
151 value = strtoull(optarg, NULL, 0);
152 o->rto_ashift = MIN(13, MAX(9, value));
153 break;
154 case 'e':
155 o->rto_expand = 1;
156 break;
157 case 'r':
158 o->rto_expand_offset = strtoull(optarg, NULL, 0);
159 break;
160 case 'o':
161 value = strtoull(optarg, NULL, 0);
162 o->rto_offset = ((1ULL << MIN(12, value)) >> 9) << 9;
163 break;
164 case 'd':
165 value = strtoull(optarg, NULL, 0);
166 o->rto_dcols = MIN(255, MAX(1, value));
167 break;
168 case 's':
169 value = strtoull(optarg, NULL, 0);
170 o->rto_dsize = 1ULL << MIN(SPA_MAXBLOCKSHIFT,
171 MAX(SPA_MINBLOCKSHIFT, value));
172 break;
173 case 't':
174 value = strtoull(optarg, NULL, 0);
175 o->rto_sweep_timeout = value;
176 break;
177 case 'v':
178 o->rto_v++;
179 break;
180 case 'S':
181 o->rto_sweep = 1;
182 break;
183 case 'B':
184 o->rto_benchmark = 1;
185 break;
186 case 'D':
187 o->rto_gdb = 1;
188 break;
189 case 'T':
190 o->rto_sanity = 1;
191 break;
192 case 'h':
193 usage(B_TRUE);
194 break;
195 case '?':
196 default:
197 usage(B_FALSE);
198 break;
199 }
200 }
201 }
202
203 #define DATA_COL(rr, i) ((rr)->rr_col[rr->rr_firstdatacol + (i)].rc_abd)
204 #define DATA_COL_SIZE(rr, i) ((rr)->rr_col[rr->rr_firstdatacol + (i)].rc_size)
205
206 #define CODE_COL(rr, i) ((rr)->rr_col[(i)].rc_abd)
207 #define CODE_COL_SIZE(rr, i) ((rr)->rr_col[(i)].rc_size)
208
209 static int
210 cmp_code(raidz_test_opts_t *opts, const raidz_map_t *rm, const int parity)
211 {
212 int r, i, ret = 0;
213
214 VERIFY(parity >= 1 && parity <= 3);
215
216 for (r = 0; r < rm->rm_nrows; r++) {
217 raidz_row_t * const rr = rm->rm_row[r];
218 raidz_row_t * const rrg = opts->rm_golden->rm_row[r];
219 for (i = 0; i < parity; i++) {
220 if (CODE_COL_SIZE(rrg, i) == 0) {
221 VERIFY0(CODE_COL_SIZE(rr, i));
222 continue;
223 }
224
225 if (abd_cmp(CODE_COL(rr, i),
226 CODE_COL(rrg, i)) != 0) {
227 ret++;
228 LOG_OPT(D_DEBUG, opts,
229 "\nParity block [%d] different!\n", i);
230 }
231 }
232 }
233 return (ret);
234 }
235
236 static int
237 cmp_data(raidz_test_opts_t *opts, raidz_map_t *rm)
238 {
239 int r, i, dcols, ret = 0;
240
241 for (r = 0; r < rm->rm_nrows; r++) {
242 raidz_row_t *rr = rm->rm_row[r];
243 raidz_row_t *rrg = opts->rm_golden->rm_row[r];
244 dcols = opts->rm_golden->rm_row[0]->rr_cols -
245 raidz_parity(opts->rm_golden);
246 for (i = 0; i < dcols; i++) {
247 if (DATA_COL_SIZE(rrg, i) == 0) {
248 VERIFY0(DATA_COL_SIZE(rr, i));
249 continue;
250 }
251
252 if (abd_cmp(DATA_COL(rrg, i),
253 DATA_COL(rr, i)) != 0) {
254 ret++;
255
256 LOG_OPT(D_DEBUG, opts,
257 "\nData block [%d] different!\n", i);
258 }
259 }
260 }
261 return (ret);
262 }
263
264 static int
265 init_rand(void *data, size_t size, void *private)
266 {
267 (void) private;
268 memcpy(data, rand_data, size);
269 return (0);
270 }
271
272 static void
273 corrupt_colums(raidz_map_t *rm, const int *tgts, const int cnt)
274 {
275 for (int r = 0; r < rm->rm_nrows; r++) {
276 raidz_row_t *rr = rm->rm_row[r];
277 for (int i = 0; i < cnt; i++) {
278 raidz_col_t *col = &rr->rr_col[tgts[i]];
279 abd_iterate_func(col->rc_abd, 0, col->rc_size,
280 init_rand, NULL);
281 }
282 }
283 }
284
285 void
286 init_zio_abd(zio_t *zio)
287 {
288 abd_iterate_func(zio->io_abd, 0, zio->io_size, init_rand, NULL);
289 }
290
291 static void
292 fini_raidz_map(zio_t **zio, raidz_map_t **rm)
293 {
294 vdev_raidz_map_free(*rm);
295 raidz_free((*zio)->io_abd, (*zio)->io_size);
296 umem_free(*zio, sizeof (zio_t));
297
298 *zio = NULL;
299 *rm = NULL;
300 }
301
302 static int
303 init_raidz_golden_map(raidz_test_opts_t *opts, const int parity)
304 {
305 int err = 0;
306 zio_t *zio_test;
307 raidz_map_t *rm_test;
308 const size_t total_ncols = opts->rto_dcols + parity;
309
310 if (opts->rm_golden) {
311 fini_raidz_map(&opts->zio_golden, &opts->rm_golden);
312 }
313
314 opts->zio_golden = umem_zalloc(sizeof (zio_t), UMEM_NOFAIL);
315 zio_test = umem_zalloc(sizeof (zio_t), UMEM_NOFAIL);
316
317 opts->zio_golden->io_offset = zio_test->io_offset = opts->rto_offset;
318 opts->zio_golden->io_size = zio_test->io_size = opts->rto_dsize;
319
320 opts->zio_golden->io_abd = raidz_alloc(opts->rto_dsize);
321 zio_test->io_abd = raidz_alloc(opts->rto_dsize);
322
323 init_zio_abd(opts->zio_golden);
324 init_zio_abd(zio_test);
325
326 VERIFY0(vdev_raidz_impl_set("original"));
327
328 if (opts->rto_expand) {
329 opts->rm_golden =
330 vdev_raidz_map_alloc_expanded(opts->zio_golden->io_abd,
331 opts->zio_golden->io_size, opts->zio_golden->io_offset,
332 opts->rto_ashift, total_ncols+1, total_ncols,
333 parity, opts->rto_expand_offset);
334 rm_test = vdev_raidz_map_alloc_expanded(zio_test->io_abd,
335 zio_test->io_size, zio_test->io_offset,
336 opts->rto_ashift, total_ncols+1, total_ncols,
337 parity, opts->rto_expand_offset);
338 } else {
339 opts->rm_golden = vdev_raidz_map_alloc(opts->zio_golden,
340 opts->rto_ashift, total_ncols, parity);
341 rm_test = vdev_raidz_map_alloc(zio_test,
342 opts->rto_ashift, total_ncols, parity);
343 }
344
345 VERIFY(opts->zio_golden);
346 VERIFY(opts->rm_golden);
347
348 vdev_raidz_generate_parity(opts->rm_golden);
349 vdev_raidz_generate_parity(rm_test);
350
351 /* sanity check */
352 err |= cmp_data(opts, rm_test);
353 err |= cmp_code(opts, rm_test, parity);
354
355 if (err)
356 ERR("initializing the golden copy ... [FAIL]!\n");
357
358 /* tear down raidz_map of test zio */
359 fini_raidz_map(&zio_test, &rm_test);
360
361 return (err);
362 }
363
364 /*
365 * If reflow is not in progress, reflow_offset should be UINT64_MAX.
366 * For each row, if the row is entirely before reflow_offset, it will
367 * come from the new location. Otherwise this row will come from the
368 * old location. Therefore, rows that straddle the reflow_offset will
369 * come from the old location.
370 *
371 * NOTE: Until raidz expansion is implemented this function is only
372 * needed by raidz_test.c to the multi-row raid_map_t functionality.
373 */
374 raidz_map_t *
375 vdev_raidz_map_alloc_expanded(abd_t *abd, uint64_t size, uint64_t offset,
376 uint64_t ashift, uint64_t physical_cols, uint64_t logical_cols,
377 uint64_t nparity, uint64_t reflow_offset)
378 {
379 /* The zio's size in units of the vdev's minimum sector size. */
380 uint64_t s = size >> ashift;
381 uint64_t q, r, bc, devidx, asize = 0, tot;
382
383 /*
384 * "Quotient": The number of data sectors for this stripe on all but
385 * the "big column" child vdevs that also contain "remainder" data.
386 * AKA "full rows"
387 */
388 q = s / (logical_cols - nparity);
389
390 /*
391 * "Remainder": The number of partial stripe data sectors in this I/O.
392 * This will add a sector to some, but not all, child vdevs.
393 */
394 r = s - q * (logical_cols - nparity);
395
396 /* The number of "big columns" - those which contain remainder data. */
397 bc = (r == 0 ? 0 : r + nparity);
398
399 /*
400 * The total number of data and parity sectors associated with
401 * this I/O.
402 */
403 tot = s + nparity * (q + (r == 0 ? 0 : 1));
404
405 /* How many rows contain data (not skip) */
406 uint64_t rows = howmany(tot, logical_cols);
407 int cols = MIN(tot, logical_cols);
408
409 raidz_map_t *rm = kmem_zalloc(offsetof(raidz_map_t, rm_row[rows]),
410 KM_SLEEP);
411 rm->rm_nrows = rows;
412
413 for (uint64_t row = 0; row < rows; row++) {
414 raidz_row_t *rr = kmem_alloc(offsetof(raidz_row_t,
415 rr_col[cols]), KM_SLEEP);
416 rm->rm_row[row] = rr;
417
418 /* The starting RAIDZ (parent) vdev sector of the row. */
419 uint64_t b = (offset >> ashift) + row * logical_cols;
420
421 /*
422 * If we are in the middle of a reflow, and any part of this
423 * row has not been copied, then use the old location of
424 * this row.
425 */
426 int row_phys_cols = physical_cols;
427 if (b + (logical_cols - nparity) > reflow_offset >> ashift)
428 row_phys_cols--;
429
430 /* starting child of this row */
431 uint64_t child_id = b % row_phys_cols;
432 /* The starting byte offset on each child vdev. */
433 uint64_t child_offset = (b / row_phys_cols) << ashift;
434
435 /*
436 * We set cols to the entire width of the block, even
437 * if this row is shorter. This is needed because parity
438 * generation (for Q and R) needs to know the entire width,
439 * because it treats the short row as though it was
440 * full-width (and the "phantom" sectors were zero-filled).
441 *
442 * Another approach to this would be to set cols shorter
443 * (to just the number of columns that we might do i/o to)
444 * and have another mechanism to tell the parity generation
445 * about the "entire width". Reconstruction (at least
446 * vdev_raidz_reconstruct_general()) would also need to
447 * know about the "entire width".
448 */
449 rr->rr_cols = cols;
450 rr->rr_bigcols = bc;
451 rr->rr_missingdata = 0;
452 rr->rr_missingparity = 0;
453 rr->rr_firstdatacol = nparity;
454 rr->rr_abd_empty = NULL;
455 rr->rr_nempty = 0;
456
457 for (int c = 0; c < rr->rr_cols; c++, child_id++) {
458 if (child_id >= row_phys_cols) {
459 child_id -= row_phys_cols;
460 child_offset += 1ULL << ashift;
461 }
462 rr->rr_col[c].rc_devidx = child_id;
463 rr->rr_col[c].rc_offset = child_offset;
464 rr->rr_col[c].rc_orig_data = NULL;
465 rr->rr_col[c].rc_error = 0;
466 rr->rr_col[c].rc_tried = 0;
467 rr->rr_col[c].rc_skipped = 0;
468 rr->rr_col[c].rc_need_orig_restore = B_FALSE;
469
470 uint64_t dc = c - rr->rr_firstdatacol;
471 if (c < rr->rr_firstdatacol) {
472 rr->rr_col[c].rc_size = 1ULL << ashift;
473 rr->rr_col[c].rc_abd =
474 abd_alloc_linear(rr->rr_col[c].rc_size,
475 B_TRUE);
476 } else if (row == rows - 1 && bc != 0 && c >= bc) {
477 /*
478 * Past the end, this for parity generation.
479 */
480 rr->rr_col[c].rc_size = 0;
481 rr->rr_col[c].rc_abd = NULL;
482 } else {
483 /*
484 * "data column" (col excluding parity)
485 * Add an ASCII art diagram here
486 */
487 uint64_t off;
488
489 if (c < bc || r == 0) {
490 off = dc * rows + row;
491 } else {
492 off = r * rows +
493 (dc - r) * (rows - 1) + row;
494 }
495 rr->rr_col[c].rc_size = 1ULL << ashift;
496 rr->rr_col[c].rc_abd = abd_get_offset_struct(
497 &rr->rr_col[c].rc_abdstruct,
498 abd, off << ashift, 1 << ashift);
499 }
500
501 asize += rr->rr_col[c].rc_size;
502 }
503 /*
504 * If all data stored spans all columns, there's a danger that
505 * parity will always be on the same device and, since parity
506 * isn't read during normal operation, that that device's I/O
507 * bandwidth won't be used effectively. We therefore switch
508 * the parity every 1MB.
509 *
510 * ...at least that was, ostensibly, the theory. As a practical
511 * matter unless we juggle the parity between all devices
512 * evenly, we won't see any benefit. Further, occasional writes
513 * that aren't a multiple of the LCM of the number of children
514 * and the minimum stripe width are sufficient to avoid pessimal
515 * behavior. Unfortunately, this decision created an implicit
516 * on-disk format requirement that we need to support for all
517 * eternity, but only for single-parity RAID-Z.
518 *
519 * If we intend to skip a sector in the zeroth column for
520 * padding we must make sure to note this swap. We will never
521 * intend to skip the first column since at least one data and
522 * one parity column must appear in each row.
523 */
524 if (rr->rr_firstdatacol == 1 && rr->rr_cols > 1 &&
525 (offset & (1ULL << 20))) {
526 ASSERT(rr->rr_cols >= 2);
527 ASSERT(rr->rr_col[0].rc_size == rr->rr_col[1].rc_size);
528 devidx = rr->rr_col[0].rc_devidx;
529 uint64_t o = rr->rr_col[0].rc_offset;
530 rr->rr_col[0].rc_devidx = rr->rr_col[1].rc_devidx;
531 rr->rr_col[0].rc_offset = rr->rr_col[1].rc_offset;
532 rr->rr_col[1].rc_devidx = devidx;
533 rr->rr_col[1].rc_offset = o;
534 }
535
536 }
537 ASSERT3U(asize, ==, tot << ashift);
538
539 /* init RAIDZ parity ops */
540 rm->rm_ops = vdev_raidz_math_get_ops();
541
542 return (rm);
543 }
544
545 static raidz_map_t *
546 init_raidz_map(raidz_test_opts_t *opts, zio_t **zio, const int parity)
547 {
548 raidz_map_t *rm = NULL;
549 const size_t alloc_dsize = opts->rto_dsize;
550 const size_t total_ncols = opts->rto_dcols + parity;
551 const int ccols[] = { 0, 1, 2 };
552
553 VERIFY(zio);
554 VERIFY(parity <= 3 && parity >= 1);
555
556 *zio = umem_zalloc(sizeof (zio_t), UMEM_NOFAIL);
557
558 (*zio)->io_offset = 0;
559 (*zio)->io_size = alloc_dsize;
560 (*zio)->io_abd = raidz_alloc(alloc_dsize);
561 init_zio_abd(*zio);
562
563 if (opts->rto_expand) {
564 rm = vdev_raidz_map_alloc_expanded((*zio)->io_abd,
565 (*zio)->io_size, (*zio)->io_offset,
566 opts->rto_ashift, total_ncols+1, total_ncols,
567 parity, opts->rto_expand_offset);
568 } else {
569 rm = vdev_raidz_map_alloc(*zio, opts->rto_ashift,
570 total_ncols, parity);
571 }
572 VERIFY(rm);
573
574 /* Make sure code columns are destroyed */
575 corrupt_colums(rm, ccols, parity);
576
577 return (rm);
578 }
579
580 static int
581 run_gen_check(raidz_test_opts_t *opts)
582 {
583 char **impl_name;
584 int fn, err = 0;
585 zio_t *zio_test;
586 raidz_map_t *rm_test;
587
588 err = init_raidz_golden_map(opts, PARITY_PQR);
589 if (0 != err)
590 return (err);
591
592 LOG(D_INFO, DBLSEP);
593 LOG(D_INFO, "Testing parity generation...\n");
594
595 for (impl_name = (char **)raidz_impl_names+1; *impl_name != NULL;
596 impl_name++) {
597
598 LOG(D_INFO, SEP);
599 LOG(D_INFO, "\tTesting [%s] implementation...", *impl_name);
600
601 if (0 != vdev_raidz_impl_set(*impl_name)) {
602 LOG(D_INFO, "[SKIP]\n");
603 continue;
604 } else {
605 LOG(D_INFO, "[SUPPORTED]\n");
606 }
607
608 for (fn = 0; fn < RAIDZ_GEN_NUM; fn++) {
609
610 /* Check if should stop */
611 if (rto_opts.rto_should_stop)
612 return (err);
613
614 /* create suitable raidz_map */
615 rm_test = init_raidz_map(opts, &zio_test, fn+1);
616 VERIFY(rm_test);
617
618 LOG(D_INFO, "\t\tTesting method [%s] ...",
619 raidz_gen_name[fn]);
620
621 if (!opts->rto_sanity)
622 vdev_raidz_generate_parity(rm_test);
623
624 if (cmp_code(opts, rm_test, fn+1) != 0) {
625 LOG(D_INFO, "[FAIL]\n");
626 err++;
627 } else
628 LOG(D_INFO, "[PASS]\n");
629
630 fini_raidz_map(&zio_test, &rm_test);
631 }
632 }
633
634 fini_raidz_map(&opts->zio_golden, &opts->rm_golden);
635
636 return (err);
637 }
638
639 static int
640 run_rec_check_impl(raidz_test_opts_t *opts, raidz_map_t *rm, const int fn)
641 {
642 int x0, x1, x2;
643 int tgtidx[3];
644 int err = 0;
645 static const int rec_tgts[7][3] = {
646 {1, 2, 3}, /* rec_p: bad QR & D[0] */
647 {0, 2, 3}, /* rec_q: bad PR & D[0] */
648 {0, 1, 3}, /* rec_r: bad PQ & D[0] */
649 {2, 3, 4}, /* rec_pq: bad R & D[0][1] */
650 {1, 3, 4}, /* rec_pr: bad Q & D[0][1] */
651 {0, 3, 4}, /* rec_qr: bad P & D[0][1] */
652 {3, 4, 5} /* rec_pqr: bad & D[0][1][2] */
653 };
654
655 memcpy(tgtidx, rec_tgts[fn], sizeof (tgtidx));
656
657 if (fn < RAIDZ_REC_PQ) {
658 /* can reconstruct 1 failed data disk */
659 for (x0 = 0; x0 < opts->rto_dcols; x0++) {
660 if (x0 >= rm->rm_row[0]->rr_cols - raidz_parity(rm))
661 continue;
662
663 /* Check if should stop */
664 if (rto_opts.rto_should_stop)
665 return (err);
666
667 LOG(D_DEBUG, "[%d] ", x0);
668
669 tgtidx[2] = x0 + raidz_parity(rm);
670
671 corrupt_colums(rm, tgtidx+2, 1);
672
673 if (!opts->rto_sanity)
674 vdev_raidz_reconstruct(rm, tgtidx, 3);
675
676 if (cmp_data(opts, rm) != 0) {
677 err++;
678 LOG(D_DEBUG, "\nREC D[%d]... [FAIL]\n", x0);
679 }
680 }
681
682 } else if (fn < RAIDZ_REC_PQR) {
683 /* can reconstruct 2 failed data disk */
684 for (x0 = 0; x0 < opts->rto_dcols; x0++) {
685 if (x0 >= rm->rm_row[0]->rr_cols - raidz_parity(rm))
686 continue;
687 for (x1 = x0 + 1; x1 < opts->rto_dcols; x1++) {
688 if (x1 >= rm->rm_row[0]->rr_cols -
689 raidz_parity(rm))
690 continue;
691
692 /* Check if should stop */
693 if (rto_opts.rto_should_stop)
694 return (err);
695
696 LOG(D_DEBUG, "[%d %d] ", x0, x1);
697
698 tgtidx[1] = x0 + raidz_parity(rm);
699 tgtidx[2] = x1 + raidz_parity(rm);
700
701 corrupt_colums(rm, tgtidx+1, 2);
702
703 if (!opts->rto_sanity)
704 vdev_raidz_reconstruct(rm, tgtidx, 3);
705
706 if (cmp_data(opts, rm) != 0) {
707 err++;
708 LOG(D_DEBUG, "\nREC D[%d %d]... "
709 "[FAIL]\n", x0, x1);
710 }
711 }
712 }
713 } else {
714 /* can reconstruct 3 failed data disk */
715 for (x0 = 0; x0 < opts->rto_dcols; x0++) {
716 if (x0 >= rm->rm_row[0]->rr_cols - raidz_parity(rm))
717 continue;
718 for (x1 = x0 + 1; x1 < opts->rto_dcols; x1++) {
719 if (x1 >= rm->rm_row[0]->rr_cols -
720 raidz_parity(rm))
721 continue;
722 for (x2 = x1 + 1; x2 < opts->rto_dcols; x2++) {
723 if (x2 >= rm->rm_row[0]->rr_cols -
724 raidz_parity(rm))
725 continue;
726
727 /* Check if should stop */
728 if (rto_opts.rto_should_stop)
729 return (err);
730
731 LOG(D_DEBUG, "[%d %d %d]", x0, x1, x2);
732
733 tgtidx[0] = x0 + raidz_parity(rm);
734 tgtidx[1] = x1 + raidz_parity(rm);
735 tgtidx[2] = x2 + raidz_parity(rm);
736
737 corrupt_colums(rm, tgtidx, 3);
738
739 if (!opts->rto_sanity)
740 vdev_raidz_reconstruct(rm,
741 tgtidx, 3);
742
743 if (cmp_data(opts, rm) != 0) {
744 err++;
745 LOG(D_DEBUG,
746 "\nREC D[%d %d %d]... "
747 "[FAIL]\n", x0, x1, x2);
748 }
749 }
750 }
751 }
752 }
753 return (err);
754 }
755
756 static int
757 run_rec_check(raidz_test_opts_t *opts)
758 {
759 char **impl_name;
760 unsigned fn, err = 0;
761 zio_t *zio_test;
762 raidz_map_t *rm_test;
763
764 err = init_raidz_golden_map(opts, PARITY_PQR);
765 if (0 != err)
766 return (err);
767
768 LOG(D_INFO, DBLSEP);
769 LOG(D_INFO, "Testing data reconstruction...\n");
770
771 for (impl_name = (char **)raidz_impl_names+1; *impl_name != NULL;
772 impl_name++) {
773
774 LOG(D_INFO, SEP);
775 LOG(D_INFO, "\tTesting [%s] implementation...", *impl_name);
776
777 if (vdev_raidz_impl_set(*impl_name) != 0) {
778 LOG(D_INFO, "[SKIP]\n");
779 continue;
780 } else
781 LOG(D_INFO, "[SUPPORTED]\n");
782
783
784 /* create suitable raidz_map */
785 rm_test = init_raidz_map(opts, &zio_test, PARITY_PQR);
786 /* generate parity */
787 vdev_raidz_generate_parity(rm_test);
788
789 for (fn = 0; fn < RAIDZ_REC_NUM; fn++) {
790
791 LOG(D_INFO, "\t\tTesting method [%s] ...",
792 raidz_rec_name[fn]);
793
794 if (run_rec_check_impl(opts, rm_test, fn) != 0) {
795 LOG(D_INFO, "[FAIL]\n");
796 err++;
797
798 } else
799 LOG(D_INFO, "[PASS]\n");
800
801 }
802 /* tear down test raidz_map */
803 fini_raidz_map(&zio_test, &rm_test);
804 }
805
806 fini_raidz_map(&opts->zio_golden, &opts->rm_golden);
807
808 return (err);
809 }
810
811 static int
812 run_test(raidz_test_opts_t *opts)
813 {
814 int err = 0;
815
816 if (opts == NULL)
817 opts = &rto_opts;
818
819 print_opts(opts, B_FALSE);
820
821 err |= run_gen_check(opts);
822 err |= run_rec_check(opts);
823
824 return (err);
825 }
826
827 #define SWEEP_RUNNING 0
828 #define SWEEP_FINISHED 1
829 #define SWEEP_ERROR 2
830 #define SWEEP_TIMEOUT 3
831
832 static int sweep_state = 0;
833 static raidz_test_opts_t failed_opts;
834
835 static kmutex_t sem_mtx;
836 static kcondvar_t sem_cv;
837 static int max_free_slots;
838 static int free_slots;
839
840 static __attribute__((noreturn)) void
841 sweep_thread(void *arg)
842 {
843 int err = 0;
844 raidz_test_opts_t *opts = (raidz_test_opts_t *)arg;
845 VERIFY(opts != NULL);
846
847 err = run_test(opts);
848
849 if (rto_opts.rto_sanity) {
850 /* 25% chance that a sweep test fails */
851 if (rand() < (RAND_MAX/4))
852 err = 1;
853 }
854
855 if (0 != err) {
856 mutex_enter(&sem_mtx);
857 memcpy(&failed_opts, opts, sizeof (raidz_test_opts_t));
858 sweep_state = SWEEP_ERROR;
859 mutex_exit(&sem_mtx);
860 }
861
862 umem_free(opts, sizeof (raidz_test_opts_t));
863
864 /* signal the next thread */
865 mutex_enter(&sem_mtx);
866 free_slots++;
867 cv_signal(&sem_cv);
868 mutex_exit(&sem_mtx);
869
870 thread_exit();
871 }
872
873 static int
874 run_sweep(void)
875 {
876 static const size_t dcols_v[] = { 1, 2, 3, 4, 5, 6, 7, 8, 12, 15, 16 };
877 static const size_t ashift_v[] = { 9, 12, 14 };
878 static const size_t size_v[] = { 1 << 9, 21 * (1 << 9), 13 * (1 << 12),
879 1 << 17, (1 << 20) - (1 << 12), SPA_MAXBLOCKSIZE };
880
881 (void) setvbuf(stdout, NULL, _IONBF, 0);
882
883 ulong_t total_comb = ARRAY_SIZE(size_v) * ARRAY_SIZE(ashift_v) *
884 ARRAY_SIZE(dcols_v);
885 ulong_t tried_comb = 0;
886 hrtime_t time_diff, start_time = gethrtime();
887 raidz_test_opts_t *opts;
888 int a, d, s;
889
890 max_free_slots = free_slots = MAX(2, boot_ncpus);
891
892 mutex_init(&sem_mtx, NULL, MUTEX_DEFAULT, NULL);
893 cv_init(&sem_cv, NULL, CV_DEFAULT, NULL);
894
895 for (s = 0; s < ARRAY_SIZE(size_v); s++)
896 for (a = 0; a < ARRAY_SIZE(ashift_v); a++)
897 for (d = 0; d < ARRAY_SIZE(dcols_v); d++) {
898
899 if (size_v[s] < (1 << ashift_v[a])) {
900 total_comb--;
901 continue;
902 }
903
904 if (++tried_comb % 20 == 0)
905 LOG(D_ALL, "%lu/%lu... ", tried_comb, total_comb);
906
907 /* wait for signal to start new thread */
908 mutex_enter(&sem_mtx);
909 while (cv_timedwait_sig(&sem_cv, &sem_mtx,
910 ddi_get_lbolt() + hz)) {
911
912 /* check if should stop the test (timeout) */
913 time_diff = (gethrtime() - start_time) / NANOSEC;
914 if (rto_opts.rto_sweep_timeout > 0 &&
915 time_diff >= rto_opts.rto_sweep_timeout) {
916 sweep_state = SWEEP_TIMEOUT;
917 rto_opts.rto_should_stop = B_TRUE;
918 mutex_exit(&sem_mtx);
919 goto exit;
920 }
921
922 /* check if should stop the test (error) */
923 if (sweep_state != SWEEP_RUNNING) {
924 mutex_exit(&sem_mtx);
925 goto exit;
926 }
927
928 /* exit loop if a slot is available */
929 if (free_slots > 0) {
930 break;
931 }
932 }
933
934 free_slots--;
935 mutex_exit(&sem_mtx);
936
937 opts = umem_zalloc(sizeof (raidz_test_opts_t), UMEM_NOFAIL);
938 opts->rto_ashift = ashift_v[a];
939 opts->rto_dcols = dcols_v[d];
940 opts->rto_offset = (1ULL << ashift_v[a]) * rand();
941 opts->rto_dsize = size_v[s];
942 opts->rto_expand = rto_opts.rto_expand;
943 opts->rto_expand_offset = rto_opts.rto_expand_offset;
944 opts->rto_v = 0; /* be quiet */
945
946 VERIFY3P(thread_create(NULL, 0, sweep_thread, (void *) opts,
947 0, NULL, TS_RUN, defclsyspri), !=, NULL);
948 }
949
950 exit:
951 LOG(D_ALL, "\nWaiting for test threads to finish...\n");
952 mutex_enter(&sem_mtx);
953 VERIFY(free_slots <= max_free_slots);
954 while (free_slots < max_free_slots) {
955 (void) cv_wait(&sem_cv, &sem_mtx);
956 }
957 mutex_exit(&sem_mtx);
958
959 if (sweep_state == SWEEP_ERROR) {
960 ERR("Sweep test failed! Failed option: \n");
961 print_opts(&failed_opts, B_TRUE);
962 } else {
963 if (sweep_state == SWEEP_TIMEOUT)
964 LOG(D_ALL, "Test timeout (%lus). Stopping...\n",
965 (ulong_t)rto_opts.rto_sweep_timeout);
966
967 LOG(D_ALL, "Sweep test succeeded on %lu raidz maps!\n",
968 (ulong_t)tried_comb);
969 }
970
971 mutex_destroy(&sem_mtx);
972
973 return (sweep_state == SWEEP_ERROR ? SWEEP_ERROR : 0);
974 }
975
976
977 int
978 main(int argc, char **argv)
979 {
980 size_t i;
981 struct sigaction action;
982 int err = 0;
983
984 /* init gdb pid string early */
985 (void) sprintf(pid_s, "%d", getpid());
986
987 action.sa_handler = sig_handler;
988 sigemptyset(&action.sa_mask);
989 action.sa_flags = 0;
990
991 if (sigaction(SIGSEGV, &action, NULL) < 0) {
992 ERR("raidz_test: cannot catch SIGSEGV: %s.\n", strerror(errno));
993 exit(EXIT_FAILURE);
994 }
995
996 (void) setvbuf(stdout, NULL, _IOLBF, 0);
997
998 dprintf_setup(&argc, argv);
999
1000 process_options(argc, argv);
1001
1002 kernel_init(SPA_MODE_READ);
1003
1004 /* setup random data because rand() is not reentrant */
1005 rand_data = (int *)umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
1006 srand((unsigned)time(NULL) * getpid());
1007 for (i = 0; i < SPA_MAXBLOCKSIZE / sizeof (int); i++)
1008 rand_data[i] = rand();
1009
1010 mprotect(rand_data, SPA_MAXBLOCKSIZE, PROT_READ);
1011
1012 if (rto_opts.rto_benchmark) {
1013 run_raidz_benchmark();
1014 } else if (rto_opts.rto_sweep) {
1015 err = run_sweep();
1016 } else {
1017 err = run_test(NULL);
1018 }
1019
1020 umem_free(rand_data, SPA_MAXBLOCKSIZE);
1021 kernel_fini();
1022
1023 return (err);
1024 }
OpenZFS on Linux and FreeBSD