| blob | 419c8ac5bb288a951745378f9dac3a477c58436c |
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 {
595 }
597 /*
598 * Deflate the asize to the psize, this includes stripping parity.
599 */
600 uint64_t
602 {
608 }
610 /*
611 * Convert a logical offset to the corresponding group number.
612 */
613 static uint64_t
615 {
621 }
623 /*
624 * Convert a group number to the logical starting offset for that group.
625 */
626 static uint64_t
628 {
634 }
636 /*
637 * Full stripe writes. When writing, all columns (D+P) are required. Parity
638 * is calculated over all the columns, including empty zero filled sectors,
639 * and each is written to disk. While only the data columns are needed for
640 * a normal read, all of the columns are required for reconstruction when
641 * performing a sequential resilver.
642 *
643 * For "big columns" it's sufficient to map the correct range of the zio ABD.
644 * Partial columns require allocating a gang ABD in order to zero fill the
645 * empty sectors. When the column is empty a zero filled sector must be
646 * mapped. In all cases the data ABDs must be the same size as the parity
647 * ABDs (e.g. rc->rc_size == parity_size).
648 */
649 static void
651 {
663 /* empty data column (small write), add a skip sector */
667 /* this is a "big column" */
671 /* short data column, add a skip sector */
677 B_TRUE);
678 }
684 }
687 }
689 /*
690 * Scrub/resilver reads. In order to store the contents of the skip sectors
691 * an additional ABD is allocated. The columns are handled in the same way
692 * as a full stripe write except instead of using the zero ABD the newly
693 * allocated skip ABD is used to back the skip sectors. In all cases the
694 * data ABD must be the same size as the parity ABDs.
695 */
696 static void
698 {
709 B_FALSE);
710 }
716 /* empty data column (small read), add a skip sector */
723 /* this is a "big column" */
727 /* short data column, add a skip sector */
736 }
741 /*
742 * Increase rc_size so the skip ABD is included in subsequent
743 * parity calculations.
744 */
747 }
751 }
753 /*
754 * Normal reads. In this common case only the columns containing data
755 * are read in to the zio ABDs. Neither the parity columns or empty skip
756 * sectors are read unless the checksum fails verification. In which case
757 * vdev_raidz_read_all() will call vdev_draid_map_alloc_empty() to expand
758 * the raid map in order to allow reconstruction using the parity data and
759 * skip sectors.
760 */
761 static void
763 {
775 }
776 }
779 }
781 /*
782 * Converts a normal "read" raidz_row_t to a "scrub" raidz_row_t. The key
783 * difference is that an ABD is allocated to back skip sectors so they may
784 * be read in to memory, verified, and repaired if needed.
785 */
786 void
788 {
798 B_FALSE);
799 }
805 /* empty data column (small read), add a skip sector */
813 /* this is a "big column", nothing to add */
816 /*
817 * short data column, add a skip sector and clear
818 * rc_tried to force the entire column to be re-read
819 * thereby including the missing skip sector data
820 * which is needed for reconstruction.
821 */
833 }
835 /*
836 * Increase rc_size so the empty ABD is included in subsequent
837 * parity calculations.
838 */
840 }
843 }
845 /*
846 * Verify that all empty sectors are zero filled before using them to
847 * calculate parity. Otherwise, silent corruption in an empty sector will
848 * result in bad parity being generated. That bad parity will then be
849 * considered authoritative and overwrite the good parity on disk. This
850 * is possible because the checksum is only calculated over the data,
851 * thus it cannot be used to detect damage in empty sectors.
852 */
853 int
855 {
879 ret++;
880 }
883 }
890 }
892 /*
893 * Given a logical address within a dRAID configuration, return the physical
894 * address on the first drive in the group that this address maps to
895 * (at position 'start' in permutation number 'perm').
896 */
897 static uint64_t
900 {
903 /* b is the dRAID (parent) sector offset. */
907 /*
908 * The height of a row in units of the vdev's minimum sector size.
909 * This is the amount of data written to each disk of each group
910 * in a given permutation.
911 */
914 /*
915 * We cycle through a disk permutation every groupsz * ngroups chunk
916 * of address space. Note that ngroups * groupsz must be a multiple
917 * of the number of data drives (ndisks) in order to guarantee
918 * alignment. So, for example, if our row height is 16MB, our group
919 * size is 10, and there are 13 data drives in the draid, then ngroups
920 * will be 13, we will change permutation every 2.08GB and each
921 * disk will have 160MB of data per chunk.
922 */
927 /*
928 * groupstart is where the group this IO will land in "starts" in
929 * the permutation array.
930 */
936 /* b_offset is the sector offset within a group chunk */
940 /*
941 * Find the starting byte offset on each child vdev:
942 * - within a permutation there are ngroups groups spread over the
943 * rows, where each row covers a slice portion of the disk
944 * - each permutation has (groupwidth * ngroups) / ndisks rows
945 * - so each permutation covers rows * slice portion of the disk
946 * - so we need to find the row where this IO group target begins
947 */
954 }
956 static uint64_t
959 {
968 /*
969 * Limit the io_size to the space remaining in the group. A second
970 * row in the raidz_map_t is created for the remainder.
971 */
975 }
977 /*
978 * At most a block may span the logical end of one group and the start
979 * of the next group. Therefore, at the end of a group the io_size must
980 * span the group width evenly and the remainder must be aligned to the
981 * start of the next group.
982 */
988 /* Lookup starting byte offset on each child vdev */
993 /*
994 * If there is less than groupwidth drives available after the group
995 * start, the group is going to wrap onto the next row. 'wrap' is the
996 * group disk number that starts on the next row.
997 */
1005 /* The io size in units of the vdev's minimum sector size. */
1008 /*
1009 * "Quotient": The number of data sectors for this stripe on all but
1010 * the "big column" child vdevs that also contain "remainder" data.
1011 */
1014 /*
1015 * "Remainder": The number of partial stripe data sectors in this I/O.
1016 * This will add a sector to some, but not all, child vdevs.
1017 */
1020 /* The number of "big columns" - those which contain remainder data. */
1024 /* The total number of data and parity sectors for this I/O. */
1032 #ifdef ZFS_DEBUG
1035 #endif
1045 /* increment the offset if we wrap to the next row */
1056 else
1060 }
1066 /* Allocate buffers for the parity columns */
1070 }
1072 /*
1073 * Map buffers for data columns and allocate/map buffers for skip
1074 * sectors. There are three distinct cases for dRAID which are
1075 * required to support sequential rebuild.
1076 */
1085 }
1088 }
1090 /*
1091 * Allocate the raidz mapping to be applied to the dRAID I/O. The parity
1092 * calculations for dRAID are identical to raidz however there are a few
1093 * differences in the layout.
1094 *
1095 * - dRAID always allocates a full stripe width. Any extra sectors due
1096 * this padding are zero filled and written to disk. They will be read
1097 * back during a scrub or repair operation since they are included in
1098 * the parity calculation. This property enables sequential resilvering.
1099 *
1100 * - When the block at the logical offset spans redundancy groups then two
1101 * rows are allocated in the raidz_map_t. One row resides at the end of
1102 * the first group and the other at the start of the following group.
1103 */
1106 {
1122 nrows++;
1132 }
1142 }
1144 /*
1145 * Given an offset into a dRAID return the next group width aligned offset
1146 * which can be used to start an allocation.
1147 */
1148 static uint64_t
1150 {
1156 }
1158 /*
1159 * Allocatable space for dRAID is (children - nspares) * sizeof(smallest child)
1160 * rounded down to the last full slice. So each child must provide at least
1161 * 1 / (children - nspares) of its asize.
1162 */
1163 static uint64_t
1165 {
1172 }
1174 /*
1175 * When using dRAID the minimum allocation size is determined by the number
1176 * of data disks in the redundancy group. Full stripes are always used.
1177 */
1178 static uint64_t
1180 {
1186 }
1188 /*
1189 * Returns true if the txg range does not exist on any leaf vdev.
1190 *
1191 * A dRAID spare does not fit into the DTL model. While it has child vdevs
1192 * there is no redundancy among them, and the effective child vdev is
1193 * determined by offset. Essentially we do a vdev_dtl_reassess() on the
1194 * fly by replacing a dRAID spare with the child vdev under the offset.
1195 * Note that it is a recursive process because the child vdev can be
1196 * another dRAID spare and so on.
1197 */
1198 boolean_t
1201 {
1204 /*
1205 * Check all of the readable children, if any child
1206 * contains the txg range the data it is not missing.
1207 */
1217 }
1220 }
1223 /*
1224 * When sequentially resilvering we don't have a proper
1225 * txg range so instead we must presume all txgs are
1226 * missing on this vdev until the resilver completes.
1227 */
1231 /*
1232 * DTL_MISSING is set for all prior txgs when a resilver
1233 * is started in spa_vdev_attach().
1234 */
1238 /*
1239 * Consult the DTL on the relevant vdev. Either a vdev
1240 * leaf or spare/replace mirror child may be returned so
1241 * we must recursively call vdev_draid_missing_impl().
1242 */
1249 }
1252 }
1254 /*
1255 * Returns true if the txg is only partially replicated on the leaf vdevs.
1256 */
1257 static boolean_t
1260 {
1263 /*
1264 * Check all of the readable children, if any child is
1265 * missing the txg range then it is partially replicated.
1266 */
1275 }
1278 }
1281 /*
1282 * When sequentially resilvering we don't have a proper
1283 * txg range so instead we must presume all txgs are
1284 * missing on this vdev until the resilver completes.
1285 */
1289 /*
1290 * DTL_MISSING is set for all prior txgs when a resilver
1291 * is started in spa_vdev_attach().
1292 */
1296 /*
1297 * Consult the DTL on the relevant vdev. Either a vdev
1298 * leaf or spare/replace mirror child may be returned so
1299 * we must recursively call vdev_draid_missing_impl().
1300 */
1306 }
1309 }
1311 /*
1312 * Determine if the vdev is readable at the given offset.
1313 */
1314 boolean_t
1316 {
1321 }
1334 }
1337 }
1340 }
1342 /*
1343 * Returns the first distributed spare found under the provided vdev tree.
1344 */
1347 {
1355 }
1358 }
1360 /*
1361 * Returns B_TRUE if the passed in vdev is currently "faulted".
1362 * Faulted, in this context, means that the vdev represents a
1363 * replacing or sparing vdev tree.
1364 */
1365 static boolean_t
1367 {
1373 /*
1374 * After resolving the distributed spare to a leaf vdev
1375 * check the parent to determine if it's "faulted".
1376 */
1378 }
1382 }
1384 /*
1385 * Determine if the dRAID block at the logical offset is degraded.
1386 * Used by sequential resilver.
1387 */
1388 static boolean_t
1390 {
1409 /* Group contains a faulted vdev. */
1413 /*
1414 * Always check groups with active distributed spares
1415 * because any vdev failure in the pool will affect them.
1416 */
1419 }
1422 }
1424 /*
1425 * Determine if the txg is missing. Used by healing resilver.
1426 */
1427 static boolean_t
1430 {
1449 /* Transaction group is known to be partially replicated. */
1453 /*
1454 * Always check groups with active distributed spares
1455 * because any vdev failure in the pool will affect them.
1456 */
1459 }
1462 }
1464 /*
1465 * Find the smallest child asize and largest sector size to calculate the
1466 * available capacity. Distributed spares are ignored since their capacity
1467 * is also based of the minimum child size in the top-level dRAID.
1468 */
1469 static void
1472 {
1487 }
1495 }
1501 }
1503 /*
1504 * Open spare vdevs.
1505 */
1506 static boolean_t
1508 {
1512 }
1514 /*
1515 * Open all children, excluding spares.
1516 */
1517 static boolean_t
1519 {
1521 }
1523 /*
1524 * Open a top-level dRAID vdev.
1525 */
1526 static int
1529 {
1538 }
1540 /*
1541 * First open the normal children then the distributed spares. This
1542 * ordering is important to ensure the distributed spares calculate
1543 * the correct psize in the event that the dRAID vdevs were expanded.
1544 */
1548 /* Verify enough of the children are available to continue. */
1554 }
1555 }
1556 }
1558 /*
1559 * Allocatable capacity is the sum of the space on all children less
1560 * the number of distributed spares rounded down to last full row
1561 * and then to the last full group. An additional 32MB of scratch
1562 * space is reserved at the end of each child for use by the dRAID
1563 * expansion feature.
1564 */
1569 /*
1570 * Should be unreachable since the minimum child size is 64MB, but
1571 * we want to make sure an underflow absolutely cannot occur here.
1572 */
1576 }
1589 }
1591 /*
1592 * Close a top-level dRAID vdev.
1593 */
1594 static void
1596 {
1600 }
1601 }
1603 /*
1604 * Return the maximum asize for a rebuild zio in the provided range
1605 * given the following constraints. A dRAID chunks may not:
1606 *
1607 * - Exceed the maximum allowed block size (SPA_MAXBLOCKSIZE), or
1608 * - Span dRAID redundancy groups.
1609 */
1610 static uint64_t
1613 {
1621 SPA_MAXBLOCKSIZE);
1626 /* Chunks must evenly span all data columns in the group. */
1630 /* Reduce the chunk size to the group space remaining. */
1640 }
1642 /*
1643 * Align the start of the metaslab to the group width and slightly reduce
1644 * its size to a multiple of the group width. Since full stripe writes are
1645 * required by dRAID this space is unallocable. Furthermore, aligning the
1646 * metaslab start is important for vdev initialize and TRIM which both operate
1647 * on metaslab boundaries which vdev_xlate() expects to be aligned.
1648 */
1649 static void
1651 {
1665 }
1667 /*
1668 * Add virtual dRAID spares to the list of valid spares. In order to accomplish
1669 * this the existing array must be freed and reallocated with the additional
1670 * entries.
1671 */
1672 int
1675 {
1686 ndraid++;
1687 }
1688 }
1693 }
1696 uint_t old_nspares;
1702 /* Allocate memory and copy of the existing spares. */
1708 /* Add new distributed spares to ZPOOL_CONFIG_SPARES. */
1732 VDEV_TYPE_DRAID_SPARE);
1736 spare_id);
1744 n++;
1745 }
1746 }
1752 }
1761 }
1763 /*
1764 * Determine if any portion of the provided block resides on a child vdev
1765 * with a dirty DTL and therefore needs to be resilvered.
1766 */
1767 static boolean_t
1770 {
1775 /*
1776 * Sequential resilver. There is no meaningful phys_birth
1777 * for this block, we can only determine if block resides
1778 * in a degraded group in which case it must be resilvered.
1779 */
1785 /*
1786 * Healing resilver. TXGs not in DTL_PARTIAL are intact,
1787 * as are blocks in non-degraded groups.
1788 */
1795 /* The block may span groups in which case check both. */
1801 }
1804 }
1805 }
1807 static boolean_t
1809 {
1816 }
1817 }
1820 }
1822 static void
1824 {
1825 #ifdef ZFS_DEBUG
1839 #endif
1840 }
1842 /*
1843 * For write operations:
1844 * 1. Generate the parity data
1845 * 2. Create child zio write operations to each column's vdev, for both
1846 * data and parity. A gang ABD is allocated by vdev_draid_map_alloc()
1847 * if a skip sector needs to be added to a column.
1848 */
1849 static void
1851 {
1860 /*
1861 * Empty columns are zero filled and included in the parity
1862 * calculation and therefore must be written.
1863 */
1866 /* Verify physical to logical translation */
1873 }
1874 }
1876 /*
1877 * For read operations:
1878 * 1. The vdev_draid_map_alloc() function will create a minimal raidz
1879 * mapping for the read based on the zio->io_flags. There are two
1880 * possible mappings either 1) a normal read, or 2) a scrub/resilver.
1881 * 2. Create the zio read operations. This will include all parity
1882 * columns and skip sectors for a scrub/resilver.
1883 */
1884 static void
1886 {
1889 /* Sequential rebuild must do IO at redundancy group boundary. */
1892 /*
1893 * Iterate over the columns in reverse order so that we hit the parity
1894 * last. Any errors along the way will force us to read the parity.
1895 * For scrub/resilver IOs which verify skip sectors, a gang ABD will
1896 * have been allocated to store them and rc->rc_size is increased.
1897 */
1905 else
1911 }
1916 else
1921 }
1923 /*
1924 * Empty columns may be read during vdev_draid_io_done().
1925 * Only skip them after the readable and missing checks
1926 * verify they are available.
1927 */
1931 }
1936 /*
1937 * Sequential rebuilds need to always consider the data
1938 * on the child being rebuilt to be stale. This is
1939 * important when all columns are available to aid
1940 * known reconstruction in identifing which columns
1941 * contain incorrect data.
1942 *
1943 * Furthermore, all repairs need to be constrained to
1944 * the devices being rebuilt because without a checksum
1945 * we cannot verify the data is actually correct and
1946 * performing an incorrect repair could result in
1947 * locking in damage and making the data unrecoverable.
1948 */
1953 else
1961 }
1964 }
1966 /*
1967 * If this child is a distributed spare then the
1968 * offset might reside on the vdev being replaced.
1969 * In which case this data must be written to the
1970 * new device. Failure to do so would result in
1971 * checksum errors when the old device is detached
1972 * and the pool is scrubbed.
1973 */
1983 }
1984 }
1986 /*
1987 * Always issue a repair IO to this child when its
1988 * a spare or replacing vdev with an active rebuild.
1989 */
1995 }
1996 }
1997 }
1999 /*
2000 * Either a parity or data column is missing this means a repair
2001 * may be attempted by vdev_draid_io_done(). Expand the raid map
2002 * to read in empty columns which are needed along with the parity
2003 * during reconstruction.
2004 */
2008 }
2023 }
2024 }
2025 }
2027 /*
2028 * Start an IO operation to a dRAID vdev.
2029 */
2030 static void
2032 {
2045 }
2051 }
2052 }
2055 }
2057 /*
2058 * Complete an IO operation on a dRAID vdev. The raidz logic can be applied
2059 * to dRAID since the layout is fully described by the raidz_map_t.
2060 */
2061 static void
2063 {
2065 }
2067 static void
2069 {
2075 VDEV_AUX_NO_REPLICAS);
2078 else
2080 }
2082 static void
2085 {
2092 /* Make sure the offsets are block-aligned */
2099 /*
2100 * Unaligned ranges must be skipped. All metaslabs are correctly
2101 * aligned so this should not happen, but this case is handled in
2102 * case it's needed by future callers.
2103 */
2111 }
2113 /*
2114 * Unlike with mirrors and raidz a dRAID logical range can map
2115 * to multiple non-contiguous physical ranges. This is handled by
2116 * limiting the size of the logical range to a single group and
2117 * setting the remain argument such that it describes the remaining
2118 * unmapped logical range. This is stricter than absolutely
2119 * necessary but helps simplify the logic below.
2120 */
2126 /* Find the starting offset for each vdev in the group */
2136 /*
2137 * Check if the passed child falls within the group. If it does
2138 * update the start and end to reflect the physical range.
2139 * Otherwise, leave them unmodified which will result in an empty
2140 * (zero-length) physical range being returned.
2141 */
2146 /* the group wrapped, increment the start */
2149 }
2159 }
2160 }
2164 /*
2165 * Only top-level vdevs are allowed to set remain_rs because
2166 * when .vdev_op_xlate() is called for their children the full
2167 * logical range is not provided by vdev_xlate().
2168 */
2175 }
2177 /*
2178 * Add dRAID specific fields to the config nvlist.
2179 */
2180 static void
2182 {
2190 }
2192 /*
2193 * Initialize private dRAID specific fields from the nvlist.
2194 */
2195 static int
2197 {
2208 }
2210 uint_t children;
2216 }
2221 }
2226 }
2228 /*
2229 * Validate the minimum number of children exist per group for the
2230 * specified parity level (draid1 >= 2, draid2 >= 3, draid3 >= 4).
2231 */
2235 /*
2236 * Create the dRAID configuration using the pool nvlist configuration
2237 * and the fixed mapping for the correct number of children.
2238 */
2258 }
2260 /*
2261 * Derived constants.
2262 */
2280 }
2282 static void
2284 {
2290 }
2292 static uint64_t
2294 {
2298 }
2300 static uint64_t
2302 {
2306 }
2308 vdev_ops_t vdev_draid_ops = {
2331 };
2334 /*
2335 * A dRAID distributed spare is a virtual leaf vdev which is included in the
2336 * parent dRAID configuration. The last N columns of the dRAID permutation
2337 * table are used to determine on which dRAID children a specific offset
2338 * should be written. These spare leaf vdevs can only be used to replace
2339 * faulted children in the same dRAID configuration.
2340 */
2342 /*
2343 * Distributed spare state. All fields are set when the distributed spare is
2344 * first opened and are immutable.
2345 */
2352 /*
2353 * Returns the parent dRAID vdev to which the distributed spare belongs.
2354 * This may be safely called even when the vdev is not open.
2355 */
2356 vdev_t *
2358 {
2368 }
2370 /*
2371 * A dRAID space is active when it's the child of a vdev using the
2372 * vdev_spare_ops, vdev_replacing_ops or vdev_draid_ops.
2373 */
2374 static boolean_t
2376 {
2385 }
2386 }
2388 /*
2389 * Given a dRAID distribute spare vdev, returns the physical child vdev
2390 * on which the provided offset resides. This may involve recursing through
2391 * multiple layers of distributed spares. Note that offset is relative to
2392 * this vdev.
2393 */
2394 vdev_t *
2396 {
2401 /* The vdev is closed */
2425 }
2427 static void
2429 {
2432 }
2434 /*
2435 * Opening a dRAID spare device is done by looking up the associated dRAID
2436 * top-level vdev guid from the spare configuration.
2437 */
2438 static int
2441 {
2448 /*
2449 * When spa_vdev_add() is labeling new spares the
2450 * associated dRAID is not attached to the root vdev
2451 * nor does this spare have a parent. Simulate a valid
2452 * device in order to allow the label to be initialized
2453 * and the distributed spare added to the configuration.
2454 */
2459 }
2462 }
2471 /*
2472 * Neither tvd->vdev_asize or tvd->vdev_max_asize can be used here
2473 * because the caller may be vdev_draid_open() in which case the
2474 * values are stale as they haven't yet been updated by vdev_open().
2475 * To avoid this always recalculate the dRAID asize and max_asize.
2476 */
2486 }
2488 /*
2489 * Completed distributed spare IO. Store the result in the parent zio
2490 * as if it had performed the operation itself. Only the first error is
2491 * preserved if there are multiple errors.
2492 */
2493 static void
2495 {
2498 /*
2499 * IOs are issued to non-writable vdevs in order to keep their
2500 * DTLs accurate. However, we don't want to propagate the
2501 * error in to the distributed spare's DTL. When resilvering
2502 * vdev_draid_need_resilver() will consult the relevant DTL
2503 * to determine if the data is missing and must be repaired.
2504 */
2510 }
2512 /*
2513 * Returns a valid label nvlist for the distributed spare vdev. This is
2514 * used to bypass the IO pipeline to avoid the complexity of constructing
2515 * a complete label with valid checksum to return when read.
2516 */
2517 nvlist_t *
2519 {
2536 /* Set the vdev guid based on the vdev list in sav_count. */
2542 }
2543 }
2548 }
2550 /*
2551 * Handle any flush requested of the distributed spare. All children must be
2552 * flushed.
2553 */
2554 static int
2556 {
2565 }
2568 }
2570 /*
2571 * Initiate an IO to the distributed spare. For normal IOs this entails using
2572 * the zio->io_offset and permutation table to calculate which child dRAID vdev
2573 * is responsible for the data. Then passing along the zio to that child to
2574 * perform the actual IO. The label ranges are not stored on disk and require
2575 * some special handling which is described below.
2576 */
2577 static void
2579 {
2584 /*
2585 * If the vdev is closed, it's likely in the REMOVED or FAULTED state.
2586 * Nothing to be done here but return failure.
2587 */
2592 }
2601 /*
2602 * Accept probe IOs and config writers to simulate the
2603 * existence of an on disk label. vdev_label_sync(),
2604 * vdev_uberblock_sync() and vdev_copy_uberblocks()
2605 * skip the distributed spares. This only leaves
2606 * vdev_label_init() which is allowed to succeed to
2607 * avoid adding special cases the function.
2608 */
2614 }
2625 }
2626 }
2631 /*
2632 * Accept probe IOs to simulate the existence of a
2633 * label. vdev_label_read_config() bypasses the
2634 * pipeline to read the label configuration and
2635 * vdev_uberblock_load() skips distributed spares
2636 * when attempting to locate the best uberblock.
2637 */
2642 }
2653 }
2654 }
2658 /* The vdev label ranges are never trimmed */
2670 }
2676 }
2679 }
2681 static void
2683 {
2685 }
2687 /*
2688 * Lookup the full spare config in spa->spa_spares.sav_config and
2689 * return the top_guid and spare_id for the named spare.
2690 */
2691 static int
2694 {
2696 uint_t nspares;
2703 }
2715 /* Skip non-distributed spares */
2720 /* Skip spares with the wrong name */
2725 /* Found the matching spare */
2731 }
2739 }
2740 }
2743 }
2745 /*
2746 * Initialize private dRAID spare specific fields from the nvlist.
2747 */
2748 static int
2750 {
2755 /*
2756 * In the normal case check the list of spares stored in the spa
2757 * to lookup the top_guid and spare_id for provided spare config.
2758 * When creating a new pool or adding vdevs the spare list is not
2759 * yet populated and the values are provided in the passed config.
2760 */
2769 }
2779 }
2781 static void
2783 {
2785 }
2787 static void
2789 {
2796 }
2798 vdev_ops_t vdev_draid_spare_ops = {
2821 };