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