| blob | b8f82d52e8f0c8fe26043fdcbd21ff3869c9ee19 |
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 http://www.opensolaris.org/os/licensing.
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 * Copyright (c) 2018 Intel Corporation.
23 * Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
24 */
26 #include <sys/zfs_context.h>
27 #include <sys/spa.h>
28 #include <sys/spa_impl.h>
29 #include <sys/vdev_impl.h>
30 #include <sys/vdev_draid.h>
31 #include <sys/vdev_raidz.h>
32 #include <sys/vdev_rebuild.h>
33 #include <sys/abd.h>
34 #include <sys/zio.h>
35 #include <sys/nvpair.h>
36 #include <sys/zio_checksum.h>
37 #include <sys/fs/zfs.h>
38 #include <sys/fm/fs/zfs.h>
39 #include <zfs_fletcher.h>
41 #ifdef ZFS_DEBUG
43 #endif
45 /*
46 * dRAID is a distributed spare implementation for ZFS. A dRAID vdev is
47 * comprised of multiple raidz redundancy groups which are spread over the
48 * dRAID children. To ensure an even distribution, and avoid hot spots, a
49 * permutation mapping is applied to the order of the dRAID children.
50 * This mixing effectively distributes the parity columns evenly over all
51 * of the disks in the dRAID.
52 *
53 * This is beneficial because it means when resilvering all of the disks
54 * can participate thereby increasing the available IOPs and bandwidth.
55 * Furthermore, by reserving a small fraction of each child's total capacity
56 * virtual distributed spare disks can be created. These spares similarly
57 * benefit from the performance gains of spanning all of the children. The
58 * consequence of which is that resilvering to a distributed spare can
59 * substantially reduce the time required to restore full parity to pool
60 * with a failed disks.
61 *
62 * === dRAID group layout ===
63 *
64 * First, let's define a "row" in the configuration to be a 16M chunk from
65 * each physical drive at the same offset. This is the minimum allowable
66 * size since it must be possible to store a full 16M block when there is
67 * only a single data column. Next, we define a "group" to be a set of
68 * sequential disks containing both the parity and data columns. We allow
69 * groups to span multiple rows in order to align any group size to any
70 * number of physical drives. Finally, a "slice" is comprised of the rows
71 * which contain the target number of groups. The permutation mappings
72 * are applied in a round robin fashion to each slice.
73 *
74 * Given D+P drives in a group (including parity drives) and C-S physical
75 * drives (not including the spare drives), we can distribute the groups
76 * across R rows without remainder by selecting the least common multiple
77 * of D+P and C-S as the number of groups; i.e. ngroups = LCM(D+P, C-S).
78 *
79 * In the example below, there are C=14 physical drives in the configuration
80 * with S=2 drives worth of spare capacity. Each group has a width of 9
81 * which includes D=8 data and P=1 parity drive. There are 4 groups and
82 * 3 rows per slice. Each group has a size of 144M (16M * 9) and a slice
83 * size is 576M (144M * 4). When allocating from a dRAID each group is
84 * filled before moving on to the next as show in slice0 below.
85 *
86 * data disks (8 data + 1 parity) spares (2)
87 * +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
88 * ^ | 2 | 6 | 1 | 11| 4 | 0 | 7 | 10| 8 | 9 | 13| 5 | 12| 3 | device map 0
89 * | +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
90 * | | group 0 | group 1..| |
91 * | +-----------------------------------+-----------+-------|
92 * | | 0 1 2 3 4 5 6 7 8 | 36 37 38| | r
93 * | | 9 10 11 12 13 14 15 16 17| 45 46 47| | o
94 * | | 18 19 20 21 22 23 24 25 26| 54 55 56| | w
95 * | 27 28 29 30 31 32 33 34 35| 63 64 65| | 0
96 * s +-----------------------+-----------------------+-------+
97 * l | ..group 1 | group 2.. | |
98 * i +-----------------------+-----------------------+-------+
99 * c | 39 40 41 42 43 44| 72 73 74 75 76 77| | r
100 * e | 48 49 50 51 52 53| 81 82 83 84 85 86| | o
101 * 0 | 57 58 59 60 61 62| 90 91 92 93 94 95| | w
102 * | 66 67 68 69 70 71| 99 100 101 102 103 104| | 1
103 * | +-----------+-----------+-----------------------+-------+
104 * | |..group 2 | group 3 | |
105 * | +-----------+-----------+-----------------------+-------+
106 * | | 78 79 80|108 109 110 111 112 113 114 115 116| | r
107 * | | 87 88 89|117 118 119 120 121 122 123 124 125| | o
108 * | | 96 97 98|126 127 128 129 130 131 132 133 134| | w
109 * v |105 106 107|135 136 137 138 139 140 141 142 143| | 2
110 * +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
111 * | 9 | 11| 12| 2 | 4 | 1 | 3 | 0 | 10| 13| 8 | 5 | 6 | 7 | device map 1
112 * s +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
113 * l | group 4 | group 5..| | row 3
114 * i +-----------------------+-----------+-----------+-------|
115 * c | ..group 5 | group 6.. | | row 4
116 * e +-----------+-----------+-----------------------+-------+
117 * 1 |..group 6 | group 7 | | row 5
118 * +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
119 * | 3 | 5 | 10| 8 | 6 | 11| 12| 0 | 2 | 4 | 7 | 1 | 9 | 13| device map 2
120 * s +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
121 * l | group 8 | group 9..| | row 6
122 * i +-----------------------------------------------+-------|
123 * c | ..group 9 | group 10.. | | row 7
124 * e +-----------------------+-----------------------+-------+
125 * 2 |..group 10 | group 11 | | row 8
126 * +-----------+-----------------------------------+-------+
127 *
128 * This layout has several advantages over requiring that each row contain
129 * a whole number of groups.
130 *
131 * 1. The group count is not a relevant parameter when defining a dRAID
132 * layout. Only the group width is needed, and *all* groups will have
133 * the desired size.
134 *
135 * 2. All possible group widths (<= physical disk count) can be supported.
136 *
137 * 3. The logic within vdev_draid.c is simplified when the group width is
138 * the same for all groups (although some of the logic around computing
139 * permutation numbers and drive offsets is more complicated).
140 *
141 * N.B. The following array describes all valid dRAID permutation maps.
142 * Each row is used to generate a permutation map for a different number
143 * of children from a unique seed. The seeds were generated and carefully
144 * evaluated by the 'draid' utility in order to provide balanced mappings.
145 * In addition to the seed a checksum of the in-memory mapping is stored
146 * for verification.
147 *
148 * The imbalance ratio of a given failure (e.g. 5 disks wide, child 3 failed,
149 * with a given permutation map) is the ratio of the amounts of I/O that will
150 * be sent to the least and most busy disks when resilvering. The average
151 * imbalance ratio (of a given number of disks and permutation map) is the
152 * average of the ratios of all possible single and double disk failures.
153 *
154 * In order to achieve a low imbalance ratio the number of permutations in
155 * the mapping must be significantly larger than the number of children.
156 * For dRAID the number of permutations has been limited to 512 to minimize
157 * the map size. This does result in a gradually increasing imbalance ratio
158 * as seen in the table below. Increasing the number of permutations for
159 * larger child counts would reduce the imbalance ratio. However, in practice
160 * when there are a large number of children each child is responsible for
161 * fewer total IOs so it's less of a concern.
162 *
163 * Note these values are hard coded and must never be changed. Existing
164 * pools depend on the same mapping always being generated in order to
165 * read and write from the correct locations. Any change would make
166 * existing pools completely inaccessible.
167 */
423 };
425 /*
426 * Verify the map is valid. Each device index must appear exactly
427 * once in every row, and the permutation array checksum must match.
428 */
429 static int
432 {
443 }
446 }
447 }
451 zio_cksum_t cksum;
458 }
459 }
464 }
466 /*
467 * Generate the permutation array for the draid_map_t. These maps control
468 * the placement of all data in a dRAID. Therefore it's critical that the
469 * seed always generates the same mapping. We provide our own pseudo-random
470 * number generator for this purpose.
471 */
472 int
474 {
481 #ifdef _KERNEL
482 /*
483 * The kernel code always provides both a map_seed and checksum.
484 * Only the tests/zfs-tests/cmd/draid/draid.c utility will provide
485 * a zero checksum when generating new candidate maps.
486 */
488 #endif
495 /* Allocate the permutation array */
498 /* Setup an initial row with a known pattern */
506 /*
507 * Perform a Fisher-Yates shuffle of each row using the previous
508 * row as the starting point. An initial_row with known pattern
509 * is used as the input for the first row.
510 */
520 }
523 }
531 }
536 }
538 /*
539 * Lookup the fixed draid_map_t for the requested number of children.
540 */
541 int
543 {
548 }
549 }
552 }
554 /*
555 * Lookup the permutation array and iteration id for the provided offset.
556 */
557 static void
560 {
566 }
571 {
573 }
575 /*
576 * Return the asize which is the psize rounded up to a full group width.
577 * i.e. vdev_draid_psize_to_asize().
578 */
579 static uint64_t
581 {
594 }
596 /*
597 * Deflate the asize to the psize, this includes stripping parity.
598 */
599 uint64_t
601 {
607 }
609 /*
610 * Convert a logical offset to the corresponding group number.
611 */
612 static uint64_t
614 {
620 }
622 /*
623 * Convert a group number to the logical starting offset for that group.
624 */
625 static uint64_t
627 {
633 }
635 /*
636 * Full stripe writes. When writing, all columns (D+P) are required. Parity
637 * is calculated over all the columns, including empty zero filled sectors,
638 * and each is written to disk. While only the data columns are needed for
639 * a normal read, all of the columns are required for reconstruction when
640 * performing a sequential resilver.
641 *
642 * For "big columns" it's sufficient to map the correct range of the zio ABD.
643 * Partial columns require allocating a gang ABD in order to zero fill the
644 * empty sectors. When the column is empty a zero filled sector must be
645 * mapped. In all cases the data ABDs must be the same size as the parity
646 * ABDs (e.g. rc->rc_size == parity_size).
647 */
648 static void
650 {
662 /* empty data column (small write), add a skip sector */
666 /* this is a "big column" */
670 /* short data column, add a skip sector */
676 B_TRUE);
677 }
683 }
686 }
688 /*
689 * Scrub/resilver reads. In order to store the contents of the skip sectors
690 * an additional ABD is allocated. The columns are handled in the same way
691 * as a full stripe write except instead of using the zero ABD the newly
692 * allocated skip ABD is used to back the skip sectors. In all cases the
693 * data ABD must be the same size as the parity ABDs.
694 */
695 static void
697 {
708 B_FALSE);
709 }
715 /* empty data column (small read), add a skip sector */
722 /* this is a "big column" */
726 /* short data column, add a skip sector */
735 }
740 /*
741 * Increase rc_size so the skip ABD is included in subsequent
742 * parity calculations.
743 */
746 }
750 }
752 /*
753 * Normal reads. In this common case only the columns containing data
754 * are read in to the zio ABDs. Neither the parity columns or empty skip
755 * sectors are read unless the checksum fails verification. In which case
756 * vdev_raidz_read_all() will call vdev_draid_map_alloc_empty() to expand
757 * the raid map in order to allow reconstruction using the parity data and
758 * skip sectors.
759 */
760 static void
762 {
774 }
775 }
778 }
780 /*
781 * Converts a normal "read" raidz_row_t to a "scrub" raidz_row_t. The key
782 * difference is that an ABD is allocated to back skip sectors so they may
783 * be read in to memory, verified, and repaired if needed.
784 */
785 void
787 {
797 B_FALSE);
798 }
804 /* empty data column (small read), add a skip sector */
812 /* this is a "big column", nothing to add */
815 /*
816 * short data column, add a skip sector and clear
817 * rc_tried to force the entire column to be re-read
818 * thereby including the missing skip sector data
819 * which is needed for reconstruction.
820 */
832 }
834 /*
835 * Increase rc_size so the empty ABD is included in subsequent
836 * parity calculations.
837 */
839 }
842 }
844 /*
845 * Given a logical address within a dRAID configuration, return the physical
846 * address on the first drive in the group that this address maps to
847 * (at position 'start' in permutation number 'perm').
848 */
849 static uint64_t
852 {
855 /* b is the dRAID (parent) sector offset. */
859 /*
860 * The height of a row in units of the vdev's minimum sector size.
861 * This is the amount of data written to each disk of each group
862 * in a given permutation.
863 */
866 /*
867 * We cycle through a disk permutation every groupsz * ngroups chunk
868 * of address space. Note that ngroups * groupsz must be a multiple
869 * of the number of data drives (ndisks) in order to guarantee
870 * alignment. So, for example, if our row height is 16MB, our group
871 * size is 10, and there are 13 data drives in the draid, then ngroups
872 * will be 13, we will change permutation every 2.08GB and each
873 * disk will have 160MB of data per chunk.
874 */
879 /*
880 * groupstart is where the group this IO will land in "starts" in
881 * the permutation array.
882 */
888 /* b_offset is the sector offset within a group chunk */
892 /*
893 * Find the starting byte offset on each child vdev:
894 * - within a permutation there are ngroups groups spread over the
895 * rows, where each row covers a slice portion of the disk
896 * - each permutation has (groupwidth * ngroups) / ndisks rows
897 * - so each permutation covers rows * slice portion of the disk
898 * - so we need to find the row where this IO group target begins
899 */
906 }
908 static uint64_t
911 {
920 /*
921 * Limit the io_size to the space remaining in the group. A second
922 * row in the raidz_map_t is created for the remainder.
923 */
927 }
929 /*
930 * At most a block may span the logical end of one group and the start
931 * of the next group. Therefore, at the end of a group the io_size must
932 * span the group width evenly and the remainder must be aligned to the
933 * start of the next group.
934 */
940 /* Lookup starting byte offset on each child vdev */
945 /*
946 * If there is less than groupwidth drives available after the group
947 * start, the group is going to wrap onto the next row. 'wrap' is the
948 * group disk number that starts on the next row.
949 */
957 /* The io size in units of the vdev's minimum sector size. */
960 /*
961 * "Quotient": The number of data sectors for this stripe on all but
962 * the "big column" child vdevs that also contain "remainder" data.
963 */
966 /*
967 * "Remainder": The number of partial stripe data sectors in this I/O.
968 * This will add a sector to some, but not all, child vdevs.
969 */
972 /* The number of "big columns" - those which contain remainder data. */
976 /* The total number of data and parity sectors for this I/O. */
988 #ifdef ZFS_DEBUG
991 #endif
1001 /* increment the offset if we wrap to the next row */
1020 else
1024 }
1030 /* Allocate buffers for the parity columns */
1034 }
1036 /*
1037 * Map buffers for data columns and allocate/map buffers for skip
1038 * sectors. There are three distinct cases for dRAID which are
1039 * required to support sequential rebuild.
1040 */
1049 }
1052 }
1054 /*
1055 * Allocate the raidz mapping to be applied to the dRAID I/O. The parity
1056 * calculations for dRAID are identical to raidz however there are a few
1057 * differences in the layout.
1058 *
1059 * - dRAID always allocates a full stripe width. Any extra sectors due
1060 * this padding are zero filled and written to disk. They will be read
1061 * back during a scrub or repair operation since they are included in
1062 * the parity calculation. This property enables sequential resilvering.
1063 *
1064 * - When the block at the logical offset spans redundancy groups then two
1065 * rows are allocated in the raidz_map_t. One row resides at the end of
1066 * the first group and the other at the start of the following group.
1067 */
1070 {
1086 nrows++;
1096 }
1107 }
1109 /*
1110 * Given an offset into a dRAID return the next group width aligned offset
1111 * which can be used to start an allocation.
1112 */
1113 static uint64_t
1115 {
1121 }
1123 /*
1124 * Allocatable space for dRAID is (children - nspares) * sizeof(smallest child)
1125 * rounded down to the last full slice. So each child must provide at least
1126 * 1 / (children - nspares) of its asize.
1127 */
1128 static uint64_t
1130 {
1137 }
1139 /*
1140 * When using dRAID the minimum allocation size is determined by the number
1141 * of data disks in the redundancy group. Full stripes are always used.
1142 */
1143 static uint64_t
1145 {
1151 }
1153 /*
1154 * Returns true if the txg range does not exist on any leaf vdev.
1155 *
1156 * A dRAID spare does not fit into the DTL model. While it has child vdevs
1157 * there is no redundancy among them, and the effective child vdev is
1158 * determined by offset. Essentially we do a vdev_dtl_reassess() on the
1159 * fly by replacing a dRAID spare with the child vdev under the offset.
1160 * Note that it is a recursive process because the child vdev can be
1161 * another dRAID spare and so on.
1162 */
1163 boolean_t
1166 {
1169 /*
1170 * Check all of the readable children, if any child
1171 * contains the txg range the data it is not missing.
1172 */
1182 }
1185 }
1188 /*
1189 * When sequentially resilvering we don't have a proper
1190 * txg range so instead we must presume all txgs are
1191 * missing on this vdev until the resilver completes.
1192 */
1196 /*
1197 * DTL_MISSING is set for all prior txgs when a resilver
1198 * is started in spa_vdev_attach().
1199 */
1203 /*
1204 * Consult the DTL on the relevant vdev. Either a vdev
1205 * leaf or spare/replace mirror child may be returned so
1206 * we must recursively call vdev_draid_missing_impl().
1207 */
1214 }
1217 }
1219 /*
1220 * Returns true if the txg is only partially replicated on the leaf vdevs.
1221 */
1222 static boolean_t
1225 {
1228 /*
1229 * Check all of the readable children, if any child is
1230 * missing the txg range then it is partially replicated.
1231 */
1240 }
1243 }
1246 /*
1247 * When sequentially resilvering we don't have a proper
1248 * txg range so instead we must presume all txgs are
1249 * missing on this vdev until the resilver completes.
1250 */
1254 /*
1255 * DTL_MISSING is set for all prior txgs when a resilver
1256 * is started in spa_vdev_attach().
1257 */
1261 /*
1262 * Consult the DTL on the relevant vdev. Either a vdev
1263 * leaf or spare/replace mirror child may be returned so
1264 * we must recursively call vdev_draid_missing_impl().
1265 */
1271 }
1274 }
1276 /*
1277 * Determine if the vdev is readable at the given offset.
1278 */
1279 boolean_t
1281 {
1286 }
1299 }
1302 }
1305 }
1307 /*
1308 * Returns the first distributed spare found under the provided vdev tree.
1309 */
1312 {
1320 }
1323 }
1325 /*
1326 * Returns B_TRUE if the passed in vdev is currently "faulted".
1327 * Faulted, in this context, means that the vdev represents a
1328 * replacing or sparing vdev tree.
1329 */
1330 static boolean_t
1332 {
1338 /*
1339 * After resolving the distributed spare to a leaf vdev
1340 * check the parent to determine if it's "faulted".
1341 */
1343 }
1347 }
1349 /*
1350 * Determine if the dRAID block at the logical offset is degraded.
1351 * Used by sequential resilver.
1352 */
1353 static boolean_t
1355 {
1374 /* Group contains a faulted vdev. */
1378 /*
1379 * Always check groups with active distributed spares
1380 * because any vdev failure in the pool will affect them.
1381 */
1384 }
1387 }
1389 /*
1390 * Determine if the txg is missing. Used by healing resilver.
1391 */
1392 static boolean_t
1395 {
1414 /* Transaction group is known to be partially replicated. */
1418 /*
1419 * Always check groups with active distributed spares
1420 * because any vdev failure in the pool will affect them.
1421 */
1424 }
1427 }
1429 /*
1430 * Find the smallest child asize and largest sector size to calculate the
1431 * available capacity. Distributed spares are ignored since their capacity
1432 * is also based of the minimum child size in the top-level dRAID.
1433 */
1434 static void
1437 {
1454 }
1460 }
1462 /*
1463 * Open spare vdevs.
1464 */
1465 static boolean_t
1467 {
1471 }
1473 /*
1474 * Open all children, excluding spares.
1475 */
1476 static boolean_t
1478 {
1480 }
1482 /*
1483 * Open a top-level dRAID vdev.
1484 */
1485 static int
1488 {
1497 }
1499 /*
1500 * First open the normal children then the distributed spares. This
1501 * ordering is important to ensure the distributed spares calculate
1502 * the correct psize in the event that the dRAID vdevs were expanded.
1503 */
1507 /* Verify enough of the children are available to continue. */
1513 }
1514 }
1515 }
1517 /*
1518 * Allocatable capacity is the sum of the space on all children less
1519 * the number of distributed spares rounded down to last full row
1520 * and then to the last full group. An additional 32MB of scratch
1521 * space is reserved at the end of each child for use by the dRAID
1522 * expansion feature.
1523 */
1528 /*
1529 * Should be unreachable since the minimum child size is 64MB, but
1530 * we want to make sure an underflow absolutely cannot occur here.
1531 */
1535 }
1548 }
1550 /*
1551 * Close a top-level dRAID vdev.
1552 */
1553 static void
1555 {
1559 }
1560 }
1562 /*
1563 * Return the maximum asize for a rebuild zio in the provided range
1564 * given the following constraints. A dRAID chunks may not:
1565 *
1566 * - Exceed the maximum allowed block size (SPA_MAXBLOCKSIZE), or
1567 * - Span dRAID redundancy groups.
1568 */
1569 static uint64_t
1572 {
1580 SPA_MAXBLOCKSIZE);
1585 /* Chunks must evenly span all data columns in the group. */
1589 /* Reduce the chunk size to the group space remaining. */
1599 }
1601 /*
1602 * Align the start of the metaslab to the group width and slightly reduce
1603 * its size to a multiple of the group width. Since full stripe writes are
1604 * required by dRAID this space is unallocable. Furthermore, aligning the
1605 * metaslab start is important for vdev initialize and TRIM which both operate
1606 * on metaslab boundaries which vdev_xlate() expects to be aligned.
1607 */
1608 static void
1610 {
1624 }
1626 /*
1627 * Add virtual dRAID spares to the list of valid spares. In order to accomplish
1628 * this the existing array must be freed and reallocated with the additional
1629 * entries.
1630 */
1631 int
1634 {
1645 ndraid++;
1646 }
1647 }
1652 }
1655 uint_t old_nspares;
1661 /* Allocate memory and copy of the existing spares. */
1667 /* Add new distributed spares to ZPOOL_CONFIG_SPARES. */
1691 VDEV_TYPE_DRAID_SPARE);
1695 spare_id);
1703 n++;
1704 }
1705 }
1711 }
1720 }
1722 /*
1723 * Determine if any portion of the provided block resides on a child vdev
1724 * with a dirty DTL and therefore needs to be resilvered.
1725 */
1726 static boolean_t
1729 {
1734 /*
1735 * Sequential resilver. There is no meaningful phys_birth
1736 * for this block, we can only determine if block resides
1737 * in a degraded group in which case it must be resilvered.
1738 */
1744 /*
1745 * Healing resilver. TXGs not in DTL_PARTIAL are intact,
1746 * as are blocks in non-degraded groups.
1747 */
1754 /* The block may span groups in which case check both. */
1760 }
1763 }
1764 }
1766 static boolean_t
1768 {
1775 }
1776 }
1779 }
1781 static void
1783 {
1784 #ifdef ZFS_DEBUG
1798 #endif
1799 }
1801 /*
1802 * For write operations:
1803 * 1. Generate the parity data
1804 * 2. Create child zio write operations to each column's vdev, for both
1805 * data and parity. A gang ABD is allocated by vdev_draid_map_alloc()
1806 * if a skip sector needs to be added to a column.
1807 */
1808 static void
1810 {
1819 /*
1820 * Empty columns are zero filled and included in the parity
1821 * calculation and therefore must be written.
1822 */
1825 /* Verify physical to logical translation */
1832 }
1833 }
1835 /*
1836 * For read operations:
1837 * 1. The vdev_draid_map_alloc() function will create a minimal raidz
1838 * mapping for the read based on the zio->io_flags. There are two
1839 * possible mappings either 1) a normal read, or 2) a scrub/resilver.
1840 * 2. Create the zio read operations. This will include all parity
1841 * columns and skip sectors for a scrub/resilver.
1842 */
1843 static void
1845 {
1848 /* Sequential rebuild must do IO at redundancy group boundary. */
1851 /*
1852 * Iterate over the columns in reverse order so that we hit the parity
1853 * last. Any errors along the way will force us to read the parity.
1854 * For scrub/resilver IOs which verify skip sectors, a gang ABD will
1855 * have been allocated to store them and rc->rc_size is increased.
1856 */
1864 else
1870 }
1875 else
1880 }
1882 /*
1883 * Empty columns may be read during vdev_draid_io_done().
1884 * Only skip them after the readable and missing checks
1885 * verify they are available.
1886 */
1890 }
1895 /*
1896 * Sequential rebuilds need to always consider the data
1897 * on the child being rebuilt to be stale. This is
1898 * important when all columns are available to aid
1899 * known reconstruction in identifing which columns
1900 * contain incorrect data.
1901 *
1902 * Furthermore, all repairs need to be constrained to
1903 * the devices being rebuilt because without a checksum
1904 * we cannot verify the data is actually correct and
1905 * performing an incorrect repair could result in
1906 * locking in damage and making the data unrecoverable.
1907 */
1912 else
1920 }
1923 }
1925 /*
1926 * If this child is a distributed spare then the
1927 * offset might reside on the vdev being replaced.
1928 * In which case this data must be written to the
1929 * new device. Failure to do so would result in
1930 * checksum errors when the old device is detached
1931 * and the pool is scrubbed.
1932 */
1942 }
1943 }
1945 /*
1946 * Always issue a repair IO to this child when its
1947 * a spare or replacing vdev with an active rebuild.
1948 */
1954 }
1955 }
1956 }
1958 /*
1959 * Either a parity or data column is missing this means a repair
1960 * may be attempted by vdev_draid_io_done(). Expand the raid map
1961 * to read in empty columns which are needed along with the parity
1962 * during reconstruction.
1963 */
1967 }
1982 }
1983 }
1984 }
1986 /*
1987 * Start an IO operation to a dRAID vdev.
1988 */
1989 static void
1991 {
2004 }
2010 }
2011 }
2014 }
2016 /*
2017 * Complete an IO operation on a dRAID vdev. The raidz logic can be applied
2018 * to dRAID since the layout is fully described by the raidz_map_t.
2019 */
2020 static void
2022 {
2024 }
2026 static void
2028 {
2034 VDEV_AUX_NO_REPLICAS);
2037 else
2039 }
2041 static void
2044 {
2051 /* Make sure the offsets are block-aligned */
2058 /*
2059 * Unaligned ranges must be skipped. All metaslabs are correctly
2060 * aligned so this should not happen, but this case is handled in
2061 * case it's needed by future callers.
2062 */
2070 }
2072 /*
2073 * Unlike with mirrors and raidz a dRAID logical range can map
2074 * to multiple non-contiguous physical ranges. This is handled by
2075 * limiting the size of the logical range to a single group and
2076 * setting the remain argument such that it describes the remaining
2077 * unmapped logical range. This is stricter than absolutely
2078 * necessary but helps simplify the logic below.
2079 */
2085 /* Find the starting offset for each vdev in the group */
2095 /*
2096 * Check if the passed child falls within the group. If it does
2097 * update the start and end to reflect the physical range.
2098 * Otherwise, leave them unmodified which will result in an empty
2099 * (zero-length) physical range being returned.
2100 */
2105 /* the group wrapped, increment the start */
2108 }
2118 }
2119 }
2123 /*
2124 * Only top-level vdevs are allowed to set remain_rs because
2125 * when .vdev_op_xlate() is called for their children the full
2126 * logical range is not provided by vdev_xlate().
2127 */
2134 }
2136 /*
2137 * Add dRAID specific fields to the config nvlist.
2138 */
2139 static void
2141 {
2149 }
2151 /*
2152 * Initialize private dRAID specific fields from the nvlist.
2153 */
2154 static int
2156 {
2166 }
2168 uint_t children;
2174 }
2179 }
2184 }
2186 /*
2187 * Validate the minimum number of children exist per group for the
2188 * specified parity level (draid1 >= 2, draid2 >= 3, draid3 >= 4).
2189 */
2193 /*
2194 * Create the dRAID configuration using the pool nvlist configuration
2195 * and the fixed mapping for the correct number of children.
2196 */
2216 }
2218 /*
2219 * Derived constants.
2220 */
2238 }
2240 static void
2242 {
2248 }
2250 static uint64_t
2252 {
2256 }
2258 static uint64_t
2260 {
2264 }
2266 vdev_ops_t vdev_draid_ops = {
2289 };
2292 /*
2293 * A dRAID distributed spare is a virtual leaf vdev which is included in the
2294 * parent dRAID configuration. The last N columns of the dRAID permutation
2295 * table are used to determine on which dRAID children a specific offset
2296 * should be written. These spare leaf vdevs can only be used to replace
2297 * faulted children in the same dRAID configuration.
2298 */
2300 /*
2301 * Distributed spare state. All fields are set when the distributed spare is
2302 * first opened and are immutable.
2303 */
2310 /*
2311 * Returns the parent dRAID vdev to which the distributed spare belongs.
2312 * This may be safely called even when the vdev is not open.
2313 */
2314 vdev_t *
2316 {
2326 }
2328 /*
2329 * A dRAID space is active when it's the child of a vdev using the
2330 * vdev_spare_ops, vdev_replacing_ops or vdev_draid_ops.
2331 */
2332 static boolean_t
2334 {
2343 }
2344 }
2346 /*
2347 * Given a dRAID distribute spare vdev, returns the physical child vdev
2348 * on which the provided offset resides. This may involve recursing through
2349 * multiple layers of distributed spares. Note that offset is relative to
2350 * this vdev.
2351 */
2352 vdev_t *
2354 {
2359 /* The vdev is closed */
2383 }
2385 /* ARGSUSED */
2386 static void
2388 {
2391 }
2393 /*
2394 * Opening a dRAID spare device is done by looking up the associated dRAID
2395 * top-level vdev guid from the spare configuration.
2396 */
2397 static int
2400 {
2407 /*
2408 * When spa_vdev_add() is labeling new spares the
2409 * associated dRAID is not attached to the root vdev
2410 * nor does this spare have a parent. Simulate a valid
2411 * device in order to allow the label to be initialized
2412 * and the distributed spare added to the configuration.
2413 */
2418 }
2421 }
2430 /*
2431 * Neither tvd->vdev_asize or tvd->vdev_max_asize can be used here
2432 * because the caller may be vdev_draid_open() in which case the
2433 * values are stale as they haven't yet been updated by vdev_open().
2434 * To avoid this always recalculate the dRAID asize and max_asize.
2435 */
2445 }
2447 /*
2448 * Completed distributed spare IO. Store the result in the parent zio
2449 * as if it had performed the operation itself. Only the first error is
2450 * preserved if there are multiple errors.
2451 */
2452 static void
2454 {
2457 /*
2458 * IOs are issued to non-writable vdevs in order to keep their
2459 * DTLs accurate. However, we don't want to propagate the
2460 * error in to the distributed spare's DTL. When resilvering
2461 * vdev_draid_need_resilver() will consult the relevant DTL
2462 * to determine if the data is missing and must be repaired.
2463 */
2469 }
2471 /*
2472 * Returns a valid label nvlist for the distributed spare vdev. This is
2473 * used to bypass the IO pipeline to avoid the complexity of constructing
2474 * a complete label with valid checksum to return when read.
2475 */
2476 nvlist_t *
2478 {
2495 /* Set the vdev guid based on the vdev list in sav_count. */
2501 }
2502 }
2507 }
2509 /*
2510 * Handle any ioctl requested of the distributed spare. Only flushes
2511 * are supported in which case all children must be flushed.
2512 */
2513 static int
2515 {
2525 }
2528 }
2531 }
2533 /*
2534 * Initiate an IO to the distributed spare. For normal IOs this entails using
2535 * the zio->io_offset and permutation table to calculate which child dRAID vdev
2536 * is responsible for the data. Then passing along the zio to that child to
2537 * perform the actual IO. The label ranges are not stored on disk and require
2538 * some special handling which is described below.
2539 */
2540 static void
2542 {
2547 /*
2548 * If the vdev is closed, it's likely in the REMOVED or FAULTED state.
2549 * Nothing to be done here but return failure.
2550 */
2555 }
2564 /*
2565 * Accept probe IOs and config writers to simulate the
2566 * existence of an on disk label. vdev_label_sync(),
2567 * vdev_uberblock_sync() and vdev_copy_uberblocks()
2568 * skip the distributed spares. This only leaves
2569 * vdev_label_init() which is allowed to succeed to
2570 * avoid adding special cases the function.
2571 */
2577 }
2588 }
2589 }
2594 /*
2595 * Accept probe IOs to simulate the existence of a
2596 * label. vdev_label_read_config() bypasses the
2597 * pipeline to read the label configuration and
2598 * vdev_uberblock_load() skips distributed spares
2599 * when attempting to locate the best uberblock.
2600 */
2605 }
2616 }
2617 }
2621 /* The vdev label ranges are never trimmed */
2633 }
2639 }
2642 }
2644 /* ARGSUSED */
2645 static void
2647 {
2648 }
2650 /*
2651 * Lookup the full spare config in spa->spa_spares.sav_config and
2652 * return the top_guid and spare_id for the named spare.
2653 */
2654 static int
2657 {
2659 uint_t nspares;
2666 }
2678 /* Skip non-distributed spares */
2683 /* Skip spares with the wrong name */
2688 /* Found the matching spare */
2694 }
2702 }
2703 }
2706 }
2708 /*
2709 * Initialize private dRAID spare specific fields from the nvlist.
2710 */
2711 static int
2713 {
2718 /*
2719 * In the normal case check the list of spares stored in the spa
2720 * to lookup the top_guid and spare_id for provided spare config.
2721 * When creating a new pool or adding vdevs the spare list is not
2722 * yet populated and the values are provided in the passed config.
2723 */
2732 }
2742 }
2744 static void
2746 {
2748 }
2750 static void
2752 {
2759 }
2761 vdev_ops_t vdev_draid_spare_ops = {
2784 };