| blob | 032e8825a297cb4bf16ef89d67bd0ed45fee44fb |
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 * 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 * Verify that all empty sectors are zero filled before using them to
846 * calculate parity. Otherwise, silent corruption in an empty sector will
847 * result in bad parity being generated. That bad parity will then be
848 * considered authoritative and overwrite the good parity on disk. This
849 * is possible because the checksum is only calculated over the data,
850 * thus it cannot be used to detect damage in empty sectors.
851 */
852 int
854 {
878 ret++;
879 }
882 }
889 }
891 /*
892 * Given a logical address within a dRAID configuration, return the physical
893 * address on the first drive in the group that this address maps to
894 * (at position 'start' in permutation number 'perm').
895 */
896 static uint64_t
899 {
902 /* b is the dRAID (parent) sector offset. */
906 /*
907 * The height of a row in units of the vdev's minimum sector size.
908 * This is the amount of data written to each disk of each group
909 * in a given permutation.
910 */
913 /*
914 * We cycle through a disk permutation every groupsz * ngroups chunk
915 * of address space. Note that ngroups * groupsz must be a multiple
916 * of the number of data drives (ndisks) in order to guarantee
917 * alignment. So, for example, if our row height is 16MB, our group
918 * size is 10, and there are 13 data drives in the draid, then ngroups
919 * will be 13, we will change permutation every 2.08GB and each
920 * disk will have 160MB of data per chunk.
921 */
926 /*
927 * groupstart is where the group this IO will land in "starts" in
928 * the permutation array.
929 */
935 /* b_offset is the sector offset within a group chunk */
939 /*
940 * Find the starting byte offset on each child vdev:
941 * - within a permutation there are ngroups groups spread over the
942 * rows, where each row covers a slice portion of the disk
943 * - each permutation has (groupwidth * ngroups) / ndisks rows
944 * - so each permutation covers rows * slice portion of the disk
945 * - so we need to find the row where this IO group target begins
946 */
953 }
955 static uint64_t
958 {
967 /*
968 * Limit the io_size to the space remaining in the group. A second
969 * row in the raidz_map_t is created for the remainder.
970 */
974 }
976 /*
977 * At most a block may span the logical end of one group and the start
978 * of the next group. Therefore, at the end of a group the io_size must
979 * span the group width evenly and the remainder must be aligned to the
980 * start of the next group.
981 */
987 /* Lookup starting byte offset on each child vdev */
992 /*
993 * If there is less than groupwidth drives available after the group
994 * start, the group is going to wrap onto the next row. 'wrap' is the
995 * group disk number that starts on the next row.
996 */
1004 /* The io size in units of the vdev's minimum sector size. */
1007 /*
1008 * "Quotient": The number of data sectors for this stripe on all but
1009 * the "big column" child vdevs that also contain "remainder" data.
1010 */
1013 /*
1014 * "Remainder": The number of partial stripe data sectors in this I/O.
1015 * This will add a sector to some, but not all, child vdevs.
1016 */
1019 /* The number of "big columns" - those which contain remainder data. */
1023 /* The total number of data and parity sectors for this I/O. */
1035 #ifdef ZFS_DEBUG
1038 #endif
1048 /* increment the offset if we wrap to the next row */
1067 else
1071 }
1077 /* Allocate buffers for the parity columns */
1081 }
1083 /*
1084 * Map buffers for data columns and allocate/map buffers for skip
1085 * sectors. There are three distinct cases for dRAID which are
1086 * required to support sequential rebuild.
1087 */
1096 }
1099 }
1101 /*
1102 * Allocate the raidz mapping to be applied to the dRAID I/O. The parity
1103 * calculations for dRAID are identical to raidz however there are a few
1104 * differences in the layout.
1105 *
1106 * - dRAID always allocates a full stripe width. Any extra sectors due
1107 * this padding are zero filled and written to disk. They will be read
1108 * back during a scrub or repair operation since they are included in
1109 * the parity calculation. This property enables sequential resilvering.
1110 *
1111 * - When the block at the logical offset spans redundancy groups then two
1112 * rows are allocated in the raidz_map_t. One row resides at the end of
1113 * the first group and the other at the start of the following group.
1114 */
1117 {
1133 nrows++;
1143 }
1154 }
1156 /*
1157 * Given an offset into a dRAID return the next group width aligned offset
1158 * which can be used to start an allocation.
1159 */
1160 static uint64_t
1162 {
1168 }
1170 /*
1171 * Allocatable space for dRAID is (children - nspares) * sizeof(smallest child)
1172 * rounded down to the last full slice. So each child must provide at least
1173 * 1 / (children - nspares) of its asize.
1174 */
1175 static uint64_t
1177 {
1184 }
1186 /*
1187 * When using dRAID the minimum allocation size is determined by the number
1188 * of data disks in the redundancy group. Full stripes are always used.
1189 */
1190 static uint64_t
1192 {
1198 }
1200 /*
1201 * Returns true if the txg range does not exist on any leaf vdev.
1202 *
1203 * A dRAID spare does not fit into the DTL model. While it has child vdevs
1204 * there is no redundancy among them, and the effective child vdev is
1205 * determined by offset. Essentially we do a vdev_dtl_reassess() on the
1206 * fly by replacing a dRAID spare with the child vdev under the offset.
1207 * Note that it is a recursive process because the child vdev can be
1208 * another dRAID spare and so on.
1209 */
1210 boolean_t
1213 {
1216 /*
1217 * Check all of the readable children, if any child
1218 * contains the txg range the data it is not missing.
1219 */
1229 }
1232 }
1235 /*
1236 * When sequentially resilvering we don't have a proper
1237 * txg range so instead we must presume all txgs are
1238 * missing on this vdev until the resilver completes.
1239 */
1243 /*
1244 * DTL_MISSING is set for all prior txgs when a resilver
1245 * is started in spa_vdev_attach().
1246 */
1250 /*
1251 * Consult the DTL on the relevant vdev. Either a vdev
1252 * leaf or spare/replace mirror child may be returned so
1253 * we must recursively call vdev_draid_missing_impl().
1254 */
1261 }
1264 }
1266 /*
1267 * Returns true if the txg is only partially replicated on the leaf vdevs.
1268 */
1269 static boolean_t
1272 {
1275 /*
1276 * Check all of the readable children, if any child is
1277 * missing the txg range then it is partially replicated.
1278 */
1287 }
1290 }
1293 /*
1294 * When sequentially resilvering we don't have a proper
1295 * txg range so instead we must presume all txgs are
1296 * missing on this vdev until the resilver completes.
1297 */
1301 /*
1302 * DTL_MISSING is set for all prior txgs when a resilver
1303 * is started in spa_vdev_attach().
1304 */
1308 /*
1309 * Consult the DTL on the relevant vdev. Either a vdev
1310 * leaf or spare/replace mirror child may be returned so
1311 * we must recursively call vdev_draid_missing_impl().
1312 */
1318 }
1321 }
1323 /*
1324 * Determine if the vdev is readable at the given offset.
1325 */
1326 boolean_t
1328 {
1333 }
1346 }
1349 }
1352 }
1354 /*
1355 * Returns the first distributed spare found under the provided vdev tree.
1356 */
1359 {
1367 }
1370 }
1372 /*
1373 * Returns B_TRUE if the passed in vdev is currently "faulted".
1374 * Faulted, in this context, means that the vdev represents a
1375 * replacing or sparing vdev tree.
1376 */
1377 static boolean_t
1379 {
1385 /*
1386 * After resolving the distributed spare to a leaf vdev
1387 * check the parent to determine if it's "faulted".
1388 */
1390 }
1394 }
1396 /*
1397 * Determine if the dRAID block at the logical offset is degraded.
1398 * Used by sequential resilver.
1399 */
1400 static boolean_t
1402 {
1421 /* Group contains a faulted vdev. */
1425 /*
1426 * Always check groups with active distributed spares
1427 * because any vdev failure in the pool will affect them.
1428 */
1431 }
1434 }
1436 /*
1437 * Determine if the txg is missing. Used by healing resilver.
1438 */
1439 static boolean_t
1442 {
1461 /* Transaction group is known to be partially replicated. */
1465 /*
1466 * Always check groups with active distributed spares
1467 * because any vdev failure in the pool will affect them.
1468 */
1471 }
1474 }
1476 /*
1477 * Find the smallest child asize and largest sector size to calculate the
1478 * available capacity. Distributed spares are ignored since their capacity
1479 * is also based of the minimum child size in the top-level dRAID.
1480 */
1481 static void
1484 {
1499 }
1507 }
1513 }
1515 /*
1516 * Open spare vdevs.
1517 */
1518 static boolean_t
1520 {
1524 }
1526 /*
1527 * Open all children, excluding spares.
1528 */
1529 static boolean_t
1531 {
1533 }
1535 /*
1536 * Open a top-level dRAID vdev.
1537 */
1538 static int
1541 {
1550 }
1552 /*
1553 * First open the normal children then the distributed spares. This
1554 * ordering is important to ensure the distributed spares calculate
1555 * the correct psize in the event that the dRAID vdevs were expanded.
1556 */
1560 /* Verify enough of the children are available to continue. */
1566 }
1567 }
1568 }
1570 /*
1571 * Allocatable capacity is the sum of the space on all children less
1572 * the number of distributed spares rounded down to last full row
1573 * and then to the last full group. An additional 32MB of scratch
1574 * space is reserved at the end of each child for use by the dRAID
1575 * expansion feature.
1576 */
1581 /*
1582 * Should be unreachable since the minimum child size is 64MB, but
1583 * we want to make sure an underflow absolutely cannot occur here.
1584 */
1588 }
1601 }
1603 /*
1604 * Close a top-level dRAID vdev.
1605 */
1606 static void
1608 {
1612 }
1613 }
1615 /*
1616 * Return the maximum asize for a rebuild zio in the provided range
1617 * given the following constraints. A dRAID chunks may not:
1618 *
1619 * - Exceed the maximum allowed block size (SPA_MAXBLOCKSIZE), or
1620 * - Span dRAID redundancy groups.
1621 */
1622 static uint64_t
1625 {
1633 SPA_MAXBLOCKSIZE);
1638 /* Chunks must evenly span all data columns in the group. */
1642 /* Reduce the chunk size to the group space remaining. */
1652 }
1654 /*
1655 * Align the start of the metaslab to the group width and slightly reduce
1656 * its size to a multiple of the group width. Since full stripe writes are
1657 * required by dRAID this space is unallocable. Furthermore, aligning the
1658 * metaslab start is important for vdev initialize and TRIM which both operate
1659 * on metaslab boundaries which vdev_xlate() expects to be aligned.
1660 */
1661 static void
1663 {
1677 }
1679 /*
1680 * Add virtual dRAID spares to the list of valid spares. In order to accomplish
1681 * this the existing array must be freed and reallocated with the additional
1682 * entries.
1683 */
1684 int
1687 {
1698 ndraid++;
1699 }
1700 }
1705 }
1708 uint_t old_nspares;
1714 /* Allocate memory and copy of the existing spares. */
1720 /* Add new distributed spares to ZPOOL_CONFIG_SPARES. */
1744 VDEV_TYPE_DRAID_SPARE);
1748 spare_id);
1756 n++;
1757 }
1758 }
1764 }
1773 }
1775 /*
1776 * Determine if any portion of the provided block resides on a child vdev
1777 * with a dirty DTL and therefore needs to be resilvered.
1778 */
1779 static boolean_t
1782 {
1787 /*
1788 * Sequential resilver. There is no meaningful phys_birth
1789 * for this block, we can only determine if block resides
1790 * in a degraded group in which case it must be resilvered.
1791 */
1797 /*
1798 * Healing resilver. TXGs not in DTL_PARTIAL are intact,
1799 * as are blocks in non-degraded groups.
1800 */
1807 /* The block may span groups in which case check both. */
1813 }
1816 }
1817 }
1819 static boolean_t
1821 {
1828 }
1829 }
1832 }
1834 static void
1836 {
1837 #ifdef ZFS_DEBUG
1851 #endif
1852 }
1854 /*
1855 * For write operations:
1856 * 1. Generate the parity data
1857 * 2. Create child zio write operations to each column's vdev, for both
1858 * data and parity. A gang ABD is allocated by vdev_draid_map_alloc()
1859 * if a skip sector needs to be added to a column.
1860 */
1861 static void
1863 {
1872 /*
1873 * Empty columns are zero filled and included in the parity
1874 * calculation and therefore must be written.
1875 */
1878 /* Verify physical to logical translation */
1885 }
1886 }
1888 /*
1889 * For read operations:
1890 * 1. The vdev_draid_map_alloc() function will create a minimal raidz
1891 * mapping for the read based on the zio->io_flags. There are two
1892 * possible mappings either 1) a normal read, or 2) a scrub/resilver.
1893 * 2. Create the zio read operations. This will include all parity
1894 * columns and skip sectors for a scrub/resilver.
1895 */
1896 static void
1898 {
1901 /* Sequential rebuild must do IO at redundancy group boundary. */
1904 /*
1905 * Iterate over the columns in reverse order so that we hit the parity
1906 * last. Any errors along the way will force us to read the parity.
1907 * For scrub/resilver IOs which verify skip sectors, a gang ABD will
1908 * have been allocated to store them and rc->rc_size is increased.
1909 */
1917 else
1923 }
1928 else
1933 }
1935 /*
1936 * Empty columns may be read during vdev_draid_io_done().
1937 * Only skip them after the readable and missing checks
1938 * verify they are available.
1939 */
1943 }
1948 /*
1949 * Sequential rebuilds need to always consider the data
1950 * on the child being rebuilt to be stale. This is
1951 * important when all columns are available to aid
1952 * known reconstruction in identifing which columns
1953 * contain incorrect data.
1954 *
1955 * Furthermore, all repairs need to be constrained to
1956 * the devices being rebuilt because without a checksum
1957 * we cannot verify the data is actually correct and
1958 * performing an incorrect repair could result in
1959 * locking in damage and making the data unrecoverable.
1960 */
1965 else
1973 }
1976 }
1978 /*
1979 * If this child is a distributed spare then the
1980 * offset might reside on the vdev being replaced.
1981 * In which case this data must be written to the
1982 * new device. Failure to do so would result in
1983 * checksum errors when the old device is detached
1984 * and the pool is scrubbed.
1985 */
1995 }
1996 }
1998 /*
1999 * Always issue a repair IO to this child when its
2000 * a spare or replacing vdev with an active rebuild.
2001 */
2007 }
2008 }
2009 }
2011 /*
2012 * Either a parity or data column is missing this means a repair
2013 * may be attempted by vdev_draid_io_done(). Expand the raid map
2014 * to read in empty columns which are needed along with the parity
2015 * during reconstruction.
2016 */
2020 }
2035 }
2036 }
2037 }
2039 /*
2040 * Start an IO operation to a dRAID vdev.
2041 */
2042 static void
2044 {
2057 }
2063 }
2064 }
2067 }
2069 /*
2070 * Complete an IO operation on a dRAID vdev. The raidz logic can be applied
2071 * to dRAID since the layout is fully described by the raidz_map_t.
2072 */
2073 static void
2075 {
2077 }
2079 static void
2081 {
2087 VDEV_AUX_NO_REPLICAS);
2090 else
2092 }
2094 static void
2097 {
2104 /* Make sure the offsets are block-aligned */
2111 /*
2112 * Unaligned ranges must be skipped. All metaslabs are correctly
2113 * aligned so this should not happen, but this case is handled in
2114 * case it's needed by future callers.
2115 */
2123 }
2125 /*
2126 * Unlike with mirrors and raidz a dRAID logical range can map
2127 * to multiple non-contiguous physical ranges. This is handled by
2128 * limiting the size of the logical range to a single group and
2129 * setting the remain argument such that it describes the remaining
2130 * unmapped logical range. This is stricter than absolutely
2131 * necessary but helps simplify the logic below.
2132 */
2138 /* Find the starting offset for each vdev in the group */
2148 /*
2149 * Check if the passed child falls within the group. If it does
2150 * update the start and end to reflect the physical range.
2151 * Otherwise, leave them unmodified which will result in an empty
2152 * (zero-length) physical range being returned.
2153 */
2158 /* the group wrapped, increment the start */
2161 }
2171 }
2172 }
2176 /*
2177 * Only top-level vdevs are allowed to set remain_rs because
2178 * when .vdev_op_xlate() is called for their children the full
2179 * logical range is not provided by vdev_xlate().
2180 */
2187 }
2189 /*
2190 * Add dRAID specific fields to the config nvlist.
2191 */
2192 static void
2194 {
2202 }
2204 /*
2205 * Initialize private dRAID specific fields from the nvlist.
2206 */
2207 static int
2209 {
2220 }
2222 uint_t children;
2228 }
2233 }
2238 }
2240 /*
2241 * Validate the minimum number of children exist per group for the
2242 * specified parity level (draid1 >= 2, draid2 >= 3, draid3 >= 4).
2243 */
2247 /*
2248 * Create the dRAID configuration using the pool nvlist configuration
2249 * and the fixed mapping for the correct number of children.
2250 */
2270 }
2272 /*
2273 * Derived constants.
2274 */
2292 }
2294 static void
2296 {
2302 }
2304 static uint64_t
2306 {
2310 }
2312 static uint64_t
2314 {
2318 }
2320 vdev_ops_t vdev_draid_ops = {
2343 };
2346 /*
2347 * A dRAID distributed spare is a virtual leaf vdev which is included in the
2348 * parent dRAID configuration. The last N columns of the dRAID permutation
2349 * table are used to determine on which dRAID children a specific offset
2350 * should be written. These spare leaf vdevs can only be used to replace
2351 * faulted children in the same dRAID configuration.
2352 */
2354 /*
2355 * Distributed spare state. All fields are set when the distributed spare is
2356 * first opened and are immutable.
2357 */
2364 /*
2365 * Returns the parent dRAID vdev to which the distributed spare belongs.
2366 * This may be safely called even when the vdev is not open.
2367 */
2368 vdev_t *
2370 {
2380 }
2382 /*
2383 * A dRAID space is active when it's the child of a vdev using the
2384 * vdev_spare_ops, vdev_replacing_ops or vdev_draid_ops.
2385 */
2386 static boolean_t
2388 {
2397 }
2398 }
2400 /*
2401 * Given a dRAID distribute spare vdev, returns the physical child vdev
2402 * on which the provided offset resides. This may involve recursing through
2403 * multiple layers of distributed spares. Note that offset is relative to
2404 * this vdev.
2405 */
2406 vdev_t *
2408 {
2413 /* The vdev is closed */
2437 }
2439 static void
2441 {
2444 }
2446 /*
2447 * Opening a dRAID spare device is done by looking up the associated dRAID
2448 * top-level vdev guid from the spare configuration.
2449 */
2450 static int
2453 {
2460 /*
2461 * When spa_vdev_add() is labeling new spares the
2462 * associated dRAID is not attached to the root vdev
2463 * nor does this spare have a parent. Simulate a valid
2464 * device in order to allow the label to be initialized
2465 * and the distributed spare added to the configuration.
2466 */
2471 }
2474 }
2483 /*
2484 * Neither tvd->vdev_asize or tvd->vdev_max_asize can be used here
2485 * because the caller may be vdev_draid_open() in which case the
2486 * values are stale as they haven't yet been updated by vdev_open().
2487 * To avoid this always recalculate the dRAID asize and max_asize.
2488 */
2498 }
2500 /*
2501 * Completed distributed spare IO. Store the result in the parent zio
2502 * as if it had performed the operation itself. Only the first error is
2503 * preserved if there are multiple errors.
2504 */
2505 static void
2507 {
2510 /*
2511 * IOs are issued to non-writable vdevs in order to keep their
2512 * DTLs accurate. However, we don't want to propagate the
2513 * error in to the distributed spare's DTL. When resilvering
2514 * vdev_draid_need_resilver() will consult the relevant DTL
2515 * to determine if the data is missing and must be repaired.
2516 */
2522 }
2524 /*
2525 * Returns a valid label nvlist for the distributed spare vdev. This is
2526 * used to bypass the IO pipeline to avoid the complexity of constructing
2527 * a complete label with valid checksum to return when read.
2528 */
2529 nvlist_t *
2531 {
2548 /* Set the vdev guid based on the vdev list in sav_count. */
2554 }
2555 }
2560 }
2562 /*
2563 * Handle any ioctl requested of the distributed spare. Only flushes
2564 * are supported in which case all children must be flushed.
2565 */
2566 static int
2568 {
2578 }
2581 }
2584 }
2586 /*
2587 * Initiate an IO to the distributed spare. For normal IOs this entails using
2588 * the zio->io_offset and permutation table to calculate which child dRAID vdev
2589 * is responsible for the data. Then passing along the zio to that child to
2590 * perform the actual IO. The label ranges are not stored on disk and require
2591 * some special handling which is described below.
2592 */
2593 static void
2595 {
2600 /*
2601 * If the vdev is closed, it's likely in the REMOVED or FAULTED state.
2602 * Nothing to be done here but return failure.
2603 */
2608 }
2617 /*
2618 * Accept probe IOs and config writers to simulate the
2619 * existence of an on disk label. vdev_label_sync(),
2620 * vdev_uberblock_sync() and vdev_copy_uberblocks()
2621 * skip the distributed spares. This only leaves
2622 * vdev_label_init() which is allowed to succeed to
2623 * avoid adding special cases the function.
2624 */
2630 }
2641 }
2642 }
2647 /*
2648 * Accept probe IOs to simulate the existence of a
2649 * label. vdev_label_read_config() bypasses the
2650 * pipeline to read the label configuration and
2651 * vdev_uberblock_load() skips distributed spares
2652 * when attempting to locate the best uberblock.
2653 */
2658 }
2669 }
2670 }
2674 /* The vdev label ranges are never trimmed */
2686 }
2692 }
2695 }
2697 static void
2699 {
2701 }
2703 /*
2704 * Lookup the full spare config in spa->spa_spares.sav_config and
2705 * return the top_guid and spare_id for the named spare.
2706 */
2707 static int
2710 {
2712 uint_t nspares;
2719 }
2731 /* Skip non-distributed spares */
2736 /* Skip spares with the wrong name */
2741 /* Found the matching spare */
2747 }
2755 }
2756 }
2759 }
2761 /*
2762 * Initialize private dRAID spare specific fields from the nvlist.
2763 */
2764 static int
2766 {
2771 /*
2772 * In the normal case check the list of spares stored in the spa
2773 * to lookup the top_guid and spare_id for provided spare config.
2774 * When creating a new pool or adding vdevs the spare list is not
2775 * yet populated and the values are provided in the passed config.
2776 */
2785 }
2795 }
2797 static void
2799 {
2801 }
2803 static void
2805 {
2812 }
2814 vdev_ops_t vdev_draid_spare_ops = {
2837 };