1 /* $NetBSD: rf_raid5.c,v 1.20 2019/02/09 03:34:00 christos Exp $ */
2 /*
3 * Copyright (c) 1995 Carnegie-Mellon University.
4 * All rights reserved.
5 *
6 * Author: Mark Holland
7 *
8 * Permission to use, copy, modify and distribute this software and
9 * its documentation is hereby granted, provided that both the copyright
10 * notice and this permission notice appear in all copies of the
11 * software, derivative works or modified versions, and any portions
12 * thereof, and that both notices appear in supporting documentation.
13 *
14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
16 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17 *
18 * Carnegie Mellon requests users of this software to return to
19 *
20 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
21 * School of Computer Science
22 * Carnegie Mellon University
23 * Pittsburgh PA 15213-3890
24 *
25 * any improvements or extensions that they make and grant Carnegie the
26 * rights to redistribute these changes.
27 */
28
29 /******************************************************************************
30 *
31 * rf_raid5.c -- implements RAID Level 5
32 *
33 *****************************************************************************/
34
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: rf_raid5.c,v 1.20 2019/02/09 03:34:00 christos Exp $");
37
38 #include <dev/raidframe/raidframevar.h>
39
40 #include "rf_raid.h"
41 #include "rf_raid5.h"
42 #include "rf_dag.h"
43 #include "rf_dagffrd.h"
44 #include "rf_dagffwr.h"
45 #include "rf_dagdegrd.h"
46 #include "rf_dagdegwr.h"
47 #include "rf_dagutils.h"
48 #include "rf_general.h"
49 #include "rf_map.h"
50 #include "rf_utils.h"
51
52 typedef struct RF_Raid5ConfigInfo_s {
53 RF_RowCol_t **stripeIdentifier; /* filled in at config time and used
54 * by IdentifyStripe */
55 } RF_Raid5ConfigInfo_t;
56
57 int
rf_ConfigureRAID5(RF_ShutdownList_t ** listp,RF_Raid_t * raidPtr,RF_Config_t * cfgPtr)58 rf_ConfigureRAID5(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
59 RF_Config_t *cfgPtr)
60 {
61 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
62 RF_Raid5ConfigInfo_t *info;
63 RF_RowCol_t i, j, startdisk;
64
65 /* create a RAID level 5 configuration structure */
66 info = RF_MallocAndAdd(sizeof(*info), raidPtr->cleanupList);
67 if (info == NULL)
68 return (ENOMEM);
69 layoutPtr->layoutSpecificInfo = (void *) info;
70
71 /* the stripe identifier must identify the disks in each stripe, IN
72 * THE ORDER THAT THEY APPEAR IN THE STRIPE. */
73 info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, raidPtr->numCol, raidPtr->cleanupList);
74 if (info->stripeIdentifier == NULL)
75 return (ENOMEM);
76 startdisk = 0;
77 for (i = 0; i < raidPtr->numCol; i++) {
78 for (j = 0; j < raidPtr->numCol; j++) {
79 info->stripeIdentifier[i][j] = (startdisk + j) % raidPtr->numCol;
80 }
81 if ((--startdisk) < 0)
82 startdisk = raidPtr->numCol - 1;
83 }
84
85 /* fill in the remaining layout parameters */
86 layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
87 layoutPtr->numDataCol = raidPtr->numCol - 1;
88 layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
89 layoutPtr->numParityCol = 1;
90 layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
91
92 raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
93
94 return (0);
95 }
96
97 int
rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t * raidPtr)98 rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t *raidPtr)
99 {
100 return (20);
101 }
102
103 RF_HeadSepLimit_t
rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t * raidPtr)104 rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t *raidPtr)
105 {
106 return (10);
107 }
108 #if !defined(__NetBSD__) && !defined(_KERNEL)
109 /* not currently used */
110 int
rf_ShutdownRAID5(RF_Raid_t * raidPtr)111 rf_ShutdownRAID5(RF_Raid_t *raidPtr)
112 {
113 return (0);
114 }
115 #endif
116
117 void
rf_MapSectorRAID5(RF_Raid_t * raidPtr,RF_RaidAddr_t raidSector,RF_RowCol_t * col,RF_SectorNum_t * diskSector,int remap)118 rf_MapSectorRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
119 RF_RowCol_t *col, RF_SectorNum_t *diskSector,
120 int remap)
121 {
122 RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
123 *col = (SUID % raidPtr->numCol);
124 *diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
125 (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
126 }
127
128 void
rf_MapParityRAID5(RF_Raid_t * raidPtr,RF_RaidAddr_t raidSector,RF_RowCol_t * col,RF_SectorNum_t * diskSector,int remap)129 rf_MapParityRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
130 RF_RowCol_t *col, RF_SectorNum_t *diskSector,
131 int remap)
132 {
133 RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
134
135 *col = raidPtr->Layout.numDataCol - (SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
136 *diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
137 (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
138 }
139
140 void
rf_IdentifyStripeRAID5(RF_Raid_t * raidPtr,RF_RaidAddr_t addr,RF_RowCol_t ** diskids)141 rf_IdentifyStripeRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
142 RF_RowCol_t **diskids)
143 {
144 RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
145 RF_Raid5ConfigInfo_t *info = (RF_Raid5ConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
146
147 *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
148 }
149
150 void
rf_MapSIDToPSIDRAID5(RF_RaidLayout_t * layoutPtr,RF_StripeNum_t stripeID,RF_StripeNum_t * psID,RF_ReconUnitNum_t * which_ru)151 rf_MapSIDToPSIDRAID5(RF_RaidLayout_t *layoutPtr,
152 RF_StripeNum_t stripeID,
153 RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
154 {
155 *which_ru = 0;
156 *psID = stripeID;
157 }
158 /* select an algorithm for performing an access. Returns two pointers,
159 * one to a function that will return information about the DAG, and
160 * another to a function that will create the dag.
161 */
162 void
rf_RaidFiveDagSelect(RF_Raid_t * raidPtr,RF_IoType_t type,RF_AccessStripeMap_t * asmap,RF_VoidFuncPtr * createFunc)163 rf_RaidFiveDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
164 RF_AccessStripeMap_t *asmap,
165 RF_VoidFuncPtr *createFunc)
166 {
167 RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
168 RF_PhysDiskAddr_t *failedPDA = NULL;
169 RF_RowCol_t fcol;
170 RF_RowStatus_t rstat;
171 int prior_recon;
172
173 RF_ASSERT(RF_IO_IS_R_OR_W(type));
174
175 if ((asmap->numDataFailed + asmap->numParityFailed > 1) ||
176 (raidPtr->numFailures > 1)){
177 #if RF_DEBUG_DAG
178 if (rf_dagDebug)
179 RF_ERRORMSG("Multiple disks failed in a single group! Aborting I/O operation.\n");
180 #endif
181 *createFunc = NULL;
182 return;
183 }
184
185 if (asmap->numDataFailed + asmap->numParityFailed == 1) {
186
187 /* if under recon & already reconstructed, redirect
188 * the access to the spare drive and eliminate the
189 * failure indication */
190 failedPDA = asmap->failedPDAs[0];
191 fcol = failedPDA->col;
192 rstat = raidPtr->status;
193 prior_recon = (rstat == rf_rs_reconfigured) || (
194 (rstat == rf_rs_reconstructing) ?
195 rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, failedPDA->startSector) : 0
196 );
197 if (prior_recon) {
198 #if RF_DEBUG_DAG > 0 || RF_DEBUG_MAP > 0
199 RF_RowCol_t oc = failedPDA->col;
200 RF_SectorNum_t oo = failedPDA->startSector;
201 #endif
202 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
203 if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) { /* redirect to dist
204 * spare space */
205
206 if (failedPDA == asmap->parityInfo) {
207
208 /* parity has failed */
209 (layoutPtr->map->MapParity) (raidPtr, failedPDA->raidAddress,
210 &failedPDA->col, &failedPDA->startSector, RF_REMAP);
211
212 if (asmap->parityInfo->next) { /* redir 2nd component,
213 * if any */
214 RF_PhysDiskAddr_t *p = asmap->parityInfo->next;
215 RF_SectorNum_t SUoffs = p->startSector % layoutPtr->sectorsPerStripeUnit;
216 p->col = failedPDA->col;
217 p->startSector = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, failedPDA->startSector) +
218 SUoffs; /* cheating:
219 * startSector is not
220 * really a RAID address */
221 }
222 } else
223 if (asmap->parityInfo->next && failedPDA == asmap->parityInfo->next) {
224 RF_ASSERT(0); /* should not ever
225 * happen */
226 } else {
227
228 /* data has failed */
229 (layoutPtr->map->MapSector) (raidPtr, failedPDA->raidAddress,
230 &failedPDA->col, &failedPDA->startSector, RF_REMAP);
231
232 }
233
234 } else {
235 #endif
236 /* redirect to dedicated spare space */
237
238 failedPDA->col = raidPtr->Disks[fcol].spareCol;
239
240 /* the parity may have two distinct
241 * components, both of which may need
242 * to be redirected */
243 if (asmap->parityInfo->next) {
244 if (failedPDA == asmap->parityInfo) {
245 failedPDA->next->col = failedPDA->col;
246 } else
247 if (failedPDA == asmap->parityInfo->next) { /* paranoid: should
248 * never occur */
249 asmap->parityInfo->col = failedPDA->col;
250 }
251 }
252 #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
253 }
254 #endif
255 RF_ASSERT(failedPDA->col != -1);
256
257 #if RF_DEBUG_DAG > 0 || RF_DEBUG_MAP > 0
258 if (rf_dagDebug || rf_mapDebug) {
259 printf("raid%d: Redirected type '%c' c %d o %ld -> c %d o %ld\n",
260 raidPtr->raidid, type, oc,
261 (long) oo, failedPDA->col,
262 (long) failedPDA->startSector);
263 }
264 #endif
265 asmap->numDataFailed = asmap->numParityFailed = 0;
266 }
267 }
268 /* all dags begin/end with block/unblock node therefore, hdrSucc &
269 * termAnt counts should always be 1 also, these counts should not be
270 * visible outside dag creation routines - manipulating the counts
271 * here should be removed */
272 if (type == RF_IO_TYPE_READ) {
273 if (asmap->numDataFailed == 0)
274 *createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
275 else
276 *createFunc = (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
277 } else {
278
279
280 /* if mirroring, always use large writes. If the access
281 * requires two distinct parity updates, always do a small
282 * write. If the stripe contains a failure but the access
283 * does not, do a small write. The first conditional
284 * (numStripeUnitsAccessed <= numDataCol/2) uses a
285 * less-than-or-equal rather than just a less-than because
286 * when G is 3 or 4, numDataCol/2 is 1, and I want
287 * single-stripe-unit updates to use just one disk. */
288 if ((asmap->numDataFailed + asmap->numParityFailed) == 0) {
289 if (rf_suppressLocksAndLargeWrites ||
290 (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) && (layoutPtr->numDataCol != 1)) ||
291 (asmap->parityInfo->next != NULL) || rf_CheckStripeForFailures(raidPtr, asmap))) {
292 *createFunc = (RF_VoidFuncPtr) rf_CreateSmallWriteDAG;
293 } else
294 *createFunc = (RF_VoidFuncPtr) rf_CreateLargeWriteDAG;
295 } else {
296 if (asmap->numParityFailed == 1)
297 *createFunc = (RF_VoidFuncPtr) rf_CreateNonRedundantWriteDAG;
298 else
299 if (asmap->numStripeUnitsAccessed != 1 && (failedPDA == NULL || failedPDA->numSector != layoutPtr->sectorsPerStripeUnit))
300 *createFunc = NULL;
301 else
302 *createFunc = (RF_VoidFuncPtr) rf_CreateDegradedWriteDAG;
303 }
304 }
305 }
306