Annotation of sys/dev/raidframe/rf_layout.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_layout.c,v 1.7 2007/04/10 17:47:55 miod Exp $ */
2: /* $NetBSD: rf_layout.c,v 1.6 2000/04/17 19:35:12 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: * rf_layout.c -- Driver code dealing with layout and mapping issues.
33: */
34:
35: #include "rf_types.h"
36: #include "rf_archs.h"
37: #include "rf_raid.h"
38: #include "rf_configure.h"
39: #include "rf_dag.h"
40: #include "rf_desc.h"
41: #include "rf_decluster.h"
42: #include "rf_pq.h"
43: #include "rf_declusterPQ.h"
44: #include "rf_raid0.h"
45: #include "rf_raid1.h"
46: #include "rf_raid4.h"
47: #include "rf_raid5.h"
48: #include "rf_states.h"
49: #if RF_INCLUDE_RAID5_RS > 0
50: #include "rf_raid5_rotatedspare.h"
51: #endif /* RF_INCLUDE_RAID5_RS > 0 */
52: #if RF_INCLUDE_CHAINDECLUSTER > 0
53: #include "rf_chaindecluster.h"
54: #endif /* RF_INCLUDE_CHAINDECLUSTER > 0 */
55: #if RF_INCLUDE_INTERDECLUSTER > 0
56: #include "rf_interdecluster.h"
57: #endif /* RF_INCLUDE_INTERDECLUSTER > 0 */
58: #if RF_INCLUDE_PARITYLOGGING > 0
59: #include "rf_paritylogging.h"
60: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
61: #if RF_INCLUDE_EVENODD > 0
62: #include "rf_evenodd.h"
63: #endif /* RF_INCLUDE_EVENODD > 0 */
64: #include "rf_general.h"
65: #include "rf_driver.h"
66: #include "rf_parityscan.h"
67: #include "rf_reconbuffer.h"
68: #include "rf_reconutil.h"
69:
70: /*****************************************************************************
71: *
72: * The layout switch defines all the layouts that are supported.
73: * Fields are: layout ID, init routine, shutdown routine, map sector,
74: * map parity, identify stripe, dag selection, map stripeid
75: * to parity stripe id (optional), num faults tolerated,
76: * special flags.
77: *
78: *****************************************************************************/
79:
80: static RF_AccessState_t DefaultStates[] = {
81: rf_QuiesceState, rf_IncrAccessesCountState, rf_MapState,
82: rf_LockState, rf_CreateDAGState, rf_ExecuteDAGState,
83: rf_ProcessDAGState, rf_DecrAccessesCountState,
84: rf_CleanupState, rf_LastState
85: };
86:
87: #if (defined(__NetBSD__) || defined(__OpenBSD__)) && !defined(_KERNEL)
88: /*
89: * XXX Gross hack to shutup gcc -- It complains that DefaultStates is not
90: * used when compiling this in userland... I hate to burst its bubble, but
91: * DefaultStates is used all over the place here in the initialization of
92: * lots of data structures. GO
93: */
94: RF_AccessState_t *NothingAtAll = DefaultStates;
95: #endif
96:
97: #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
98: /* XXX Remove static so GCC doesn't complain about these being unused ! */
99: int distSpareYes = 1;
100: int distSpareNo = 0;
101: #else
102: static int distSpareYes = 1;
103: static int distSpareNo = 0;
104: #endif
105:
106: #ifdef _KERNEL
107: #define RF_NK2(a,b)
108: #else /* _KERNEL */
109: #define RF_NK2(a,b) a,b,
110: #endif /* !_KERNEL */
111:
112: #if RF_UTILITY > 0
113: #define RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
114: #else /* RF_UTILITY > 0 */
115: #define RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p
116: #endif /* RF_UTILITY > 0 */
117:
118: static RF_LayoutSW_t mapsw[] = {
119: /* Parity declustering. */
120: {'T', "Parity declustering",
121: RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
122: RF_NU(
123: rf_ConfigureDeclustered,
124: rf_MapSectorDeclustered, rf_MapParityDeclustered, NULL,
125: rf_IdentifyStripeDeclustered,
126: rf_RaidFiveDagSelect,
127: rf_MapSIDToPSIDDeclustered,
128: rf_GetDefaultHeadSepLimitDeclustered,
129: rf_GetDefaultNumFloatingReconBuffersDeclustered,
130: NULL, NULL,
131: rf_SubmitReconBufferBasic,
132: rf_VerifyParityBasic,
133: 1,
134: DefaultStates,
135: 0)
136: },
137:
138: /* Parity declustering with distributed sparing. */
139: {'D', "Distributed sparing parity declustering",
140: RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareYes)
141: RF_NU(
142: rf_ConfigureDeclusteredDS,
143: rf_MapSectorDeclustered, rf_MapParityDeclustered, NULL,
144: rf_IdentifyStripeDeclustered,
145: rf_RaidFiveDagSelect,
146: rf_MapSIDToPSIDDeclustered,
147: rf_GetDefaultHeadSepLimitDeclustered,
148: rf_GetDefaultNumFloatingReconBuffersDeclustered,
149: rf_GetNumSpareRUsDeclustered, rf_InstallSpareTable,
150: rf_SubmitReconBufferBasic,
151: rf_VerifyParityBasic,
152: 1,
153: DefaultStates,
154: RF_DISTRIBUTE_SPARE | RF_BD_DECLUSTERED)
155: },
156:
157: #if RF_INCLUDE_DECL_PQ > 0
158: /* Declustered P+Q. */
159: {'Q', "Declustered P+Q",
160: RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
161: RF_NU(
162: rf_ConfigureDeclusteredPQ,
163: rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ,
164: rf_MapQDeclusteredPQ,
165: rf_IdentifyStripeDeclusteredPQ,
166: rf_PQDagSelect,
167: rf_MapSIDToPSIDDeclustered,
168: rf_GetDefaultHeadSepLimitDeclustered,
169: rf_GetDefaultNumFloatingReconBuffersPQ,
170: NULL, NULL,
171: NULL,
172: rf_VerifyParityBasic,
173: 2,
174: DefaultStates,
175: 0)
176: },
177: #endif /* RF_INCLUDE_DECL_PQ > 0 */
178:
179: #if RF_INCLUDE_RAID5_RS > 0
180: /* RAID 5 with rotated sparing. */
181: {'R', "RAID Level 5 rotated sparing",
182: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
183: RF_NU(
184: rf_ConfigureRAID5_RS,
185: rf_MapSectorRAID5_RS, rf_MapParityRAID5_RS, NULL,
186: rf_IdentifyStripeRAID5_RS,
187: rf_RaidFiveDagSelect,
188: rf_MapSIDToPSIDRAID5_RS,
189: rf_GetDefaultHeadSepLimitRAID5,
190: rf_GetDefaultNumFloatingReconBuffersRAID5,
191: rf_GetNumSpareRUsRAID5_RS, NULL,
192: rf_SubmitReconBufferBasic,
193: rf_VerifyParityBasic,
194: 1,
195: DefaultStates,
196: RF_DISTRIBUTE_SPARE)
197: },
198: #endif /* RF_INCLUDE_RAID5_RS > 0 */
199:
200: #if RF_INCLUDE_CHAINDECLUSTER > 0
201: /* Chained Declustering. */
202: {'C', "Chained Declustering",
203: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
204: RF_NU(
205: rf_ConfigureChainDecluster,
206: rf_MapSectorChainDecluster, rf_MapParityChainDecluster,
207: NULL,
208: rf_IdentifyStripeChainDecluster,
209: rf_RAIDCDagSelect,
210: rf_MapSIDToPSIDChainDecluster,
211: NULL,
212: NULL,
213: rf_GetNumSpareRUsChainDecluster, NULL,
214: rf_SubmitReconBufferBasic,
215: rf_VerifyParityBasic,
216: 1,
217: DefaultStates,
218: 0)
219: },
220: #endif /* RF_INCLUDE_CHAINDECLUSTER > 0 */
221:
222: #if RF_INCLUDE_INTERDECLUSTER > 0
223: /* Interleaved Declustering. */
224: {'I', "Interleaved Declustering",
225: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
226: RF_NU(
227: rf_ConfigureInterDecluster,
228: rf_MapSectorInterDecluster, rf_MapParityInterDecluster,
229: NULL,
230: rf_IdentifyStripeInterDecluster,
231: rf_RAIDIDagSelect,
232: rf_MapSIDToPSIDInterDecluster,
233: rf_GetDefaultHeadSepLimitInterDecluster,
234: rf_GetDefaultNumFloatingReconBuffersInterDecluster,
235: rf_GetNumSpareRUsInterDecluster, NULL,
236: rf_SubmitReconBufferBasic,
237: rf_VerifyParityBasic,
238: 1,
239: DefaultStates,
240: RF_DISTRIBUTE_SPARE)
241: },
242: #endif /* RF_INCLUDE_INTERDECLUSTER > 0 */
243:
244: #if RF_INCLUDE_RAID0 > 0
245: /* RAID level 0. */
246: {'0', "RAID Level 0",
247: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
248: RF_NU(
249: rf_ConfigureRAID0,
250: rf_MapSectorRAID0, rf_MapParityRAID0, NULL,
251: rf_IdentifyStripeRAID0,
252: rf_RAID0DagSelect,
253: rf_MapSIDToPSIDRAID0,
254: NULL,
255: NULL,
256: NULL, NULL,
257: NULL,
258: rf_VerifyParityRAID0,
259: 0,
260: DefaultStates,
261: 0)
262: },
263: #endif /* RF_INCLUDE_RAID0 > 0 */
264:
265: #if RF_INCLUDE_RAID1 > 0
266: /* RAID level 1. */
267: {'1', "RAID Level 1",
268: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
269: RF_NU(
270: rf_ConfigureRAID1,
271: rf_MapSectorRAID1, rf_MapParityRAID1, NULL,
272: rf_IdentifyStripeRAID1,
273: rf_RAID1DagSelect,
274: rf_MapSIDToPSIDRAID1,
275: NULL,
276: NULL,
277: NULL, NULL,
278: rf_SubmitReconBufferRAID1,
279: rf_VerifyParityRAID1,
280: 1,
281: DefaultStates,
282: 0)
283: },
284: #endif /* RF_INCLUDE_RAID1 > 0 */
285:
286: #if RF_INCLUDE_RAID4 > 0
287: /* RAID level 4. */
288: {'4', "RAID Level 4",
289: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
290: RF_NU(
291: rf_ConfigureRAID4,
292: rf_MapSectorRAID4, rf_MapParityRAID4, NULL,
293: rf_IdentifyStripeRAID4,
294: rf_RaidFiveDagSelect,
295: rf_MapSIDToPSIDRAID4,
296: rf_GetDefaultHeadSepLimitRAID4,
297: rf_GetDefaultNumFloatingReconBuffersRAID4,
298: NULL, NULL,
299: rf_SubmitReconBufferBasic,
300: rf_VerifyParityBasic,
301: 1,
302: DefaultStates,
303: 0)
304: },
305: #endif /* RF_INCLUDE_RAID4 > 0 */
306:
307: #if RF_INCLUDE_RAID5 > 0
308: /* RAID level 5. */
309: {'5', "RAID Level 5",
310: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
311: RF_NU(
312: rf_ConfigureRAID5,
313: rf_MapSectorRAID5, rf_MapParityRAID5, NULL,
314: rf_IdentifyStripeRAID5,
315: rf_RaidFiveDagSelect,
316: rf_MapSIDToPSIDRAID5,
317: rf_GetDefaultHeadSepLimitRAID5,
318: rf_GetDefaultNumFloatingReconBuffersRAID5,
319: NULL, NULL,
320: rf_SubmitReconBufferBasic,
321: rf_VerifyParityBasic,
322: 1,
323: DefaultStates,
324: 0)
325: },
326: #endif /* RF_INCLUDE_RAID5 > 0 */
327:
328: #if RF_INCLUDE_EVENODD > 0
329: /* Evenodd. */
330: {'E', "EvenOdd",
331: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
332: RF_NU(
333: rf_ConfigureEvenOdd,
334: rf_MapSectorRAID5, rf_MapParityEvenOdd, rf_MapEEvenOdd,
335: rf_IdentifyStripeEvenOdd,
336: rf_EODagSelect,
337: rf_MapSIDToPSIDRAID5,
338: NULL,
339: NULL,
340: NULL, NULL,
341: NULL, /* No reconstruction, yet. */
342: rf_VerifyParityEvenOdd,
343: 2,
344: DefaultStates,
345: 0)
346: },
347: #endif /* RF_INCLUDE_EVENODD > 0 */
348:
349: #if RF_INCLUDE_EVENODD > 0
350: /* Declustered Evenodd. */
351: {'e', "Declustered EvenOdd",
352: RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
353: RF_NU(
354: rf_ConfigureDeclusteredPQ,
355: rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ,
356: rf_MapQDeclusteredPQ,
357: rf_IdentifyStripeDeclusteredPQ,
358: rf_EODagSelect,
359: rf_MapSIDToPSIDRAID5,
360: rf_GetDefaultHeadSepLimitDeclustered,
361: rf_GetDefaultNumFloatingReconBuffersPQ,
362: NULL, NULL,
363: NULL, /* No reconstruction, yet. */
364: rf_VerifyParityEvenOdd,
365: 2,
366: DefaultStates,
367: 0)
368: },
369: #endif /* RF_INCLUDE_EVENODD > 0 */
370:
371: #if RF_INCLUDE_PARITYLOGGING > 0
372: /* Parity logging. */
373: {'L', "Parity logging",
374: RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
375: RF_NU(
376: rf_ConfigureParityLogging,
377: rf_MapSectorParityLogging, rf_MapParityParityLogging, NULL,
378: rf_IdentifyStripeParityLogging,
379: rf_ParityLoggingDagSelect,
380: rf_MapSIDToPSIDParityLogging,
381: rf_GetDefaultHeadSepLimitParityLogging,
382: rf_GetDefaultNumFloatingReconBuffersParityLogging,
383: NULL, NULL,
384: rf_SubmitReconBufferBasic,
385: NULL,
386: 1,
387: DefaultStates,
388: 0)
389: },
390: #endif /* RF_INCLUDE_PARITYLOGGING > 0 */
391:
392: /* End-of-list marker. */
393: {'\0', NULL,
394: RF_NK2(NULL, NULL)
395: RF_NU(
396: NULL,
397: NULL, NULL, NULL,
398: NULL,
399: NULL,
400: NULL,
401: NULL,
402: NULL,
403: NULL, NULL,
404: NULL,
405: NULL,
406: 0,
407: NULL,
408: 0)
409: }
410: };
411:
412: RF_LayoutSW_t *
413: rf_GetLayout(RF_ParityConfig_t parityConfig)
414: {
415: RF_LayoutSW_t *p;
416:
417: /* Look up the specific layout. */
418: for (p = &mapsw[0]; p->parityConfig; p++)
419: if (p->parityConfig == parityConfig)
420: break;
421: if (!p->parityConfig)
422: return (NULL);
423: RF_ASSERT(p->parityConfig == parityConfig);
424: return (p);
425: }
426:
427: #if RF_UTILITY == 0
428: /*****************************************************************************
429: *
430: * ConfigureLayout
431: *
432: * Read the configuration file and set up the RAID layout parameters.
433: * After reading common params, invokes the layout-specific configuration
434: * routine to finish the configuration.
435: *
436: *****************************************************************************/
437: int
438: rf_ConfigureLayout(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
439: RF_Config_t *cfgPtr)
440: {
441: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
442: RF_ParityConfig_t parityConfig;
443: RF_LayoutSW_t *p;
444: int retval;
445:
446: layoutPtr->sectorsPerStripeUnit = cfgPtr->sectPerSU;
447: layoutPtr->SUsPerPU = cfgPtr->SUsPerPU;
448: layoutPtr->SUsPerRU = cfgPtr->SUsPerRU;
449: parityConfig = cfgPtr->parityConfig;
450:
451: if (layoutPtr->sectorsPerStripeUnit <= 0) {
452: RF_ERRORMSG2("raid%d: Invalid sectorsPerStripeUnit: %d.\n",
453: raidPtr->raidid, (int)layoutPtr->sectorsPerStripeUnit);
454: return (EINVAL);
455: }
456:
457: layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
458: layoutPtr->sectorsPerStripeUnit;
459:
460: p = rf_GetLayout(parityConfig);
461: if (p == NULL) {
462: RF_ERRORMSG1("Unknown parity configuration '%c'", parityConfig);
463: return (EINVAL);
464: }
465: RF_ASSERT(p->parityConfig == parityConfig);
466: layoutPtr->map = p;
467:
468: /* Initialize the specific layout. */
469:
470: retval = (p->Configure) (listp, raidPtr, cfgPtr);
471:
472: if (retval)
473: return (retval);
474:
475: layoutPtr->dataBytesPerStripe = layoutPtr->dataSectorsPerStripe <<
476: raidPtr->logBytesPerSector;
477: raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
478: layoutPtr->sectorsPerStripeUnit;
479:
480: if (rf_forceNumFloatingReconBufs >= 0) {
481: raidPtr->numFloatingReconBufs = rf_forceNumFloatingReconBufs;
482: } else {
483: raidPtr->numFloatingReconBufs =
484: rf_GetDefaultNumFloatingReconBuffers(raidPtr);
485: }
486:
487: if (rf_forceHeadSepLimit >= 0) {
488: raidPtr->headSepLimit = rf_forceHeadSepLimit;
489: } else {
490: raidPtr->headSepLimit = rf_GetDefaultHeadSepLimit(raidPtr);
491: }
492:
493: #ifdef RAIDDEBUG
494: if (raidPtr->headSepLimit >= 0) {
495: printf("RAIDFRAME(%s): Using %ld floating recon bufs"
496: " with head sep limit %ld.\n", layoutPtr->map->configName,
497: (long) raidPtr->numFloatingReconBufs,
498: (long) raidPtr->headSepLimit);
499: } else {
500: printf("RAIDFRAME(%s): Using %ld floating recon bufs"
501: " with no head sep limit.\n", layoutPtr->map->configName,
502: (long) raidPtr->numFloatingReconBufs);
503: }
504: #endif /* RAIDDEBUG */
505:
506: return (0);
507: }
508:
509: /*
510: * Typically there is a 1-1 mapping between stripes and parity stripes.
511: * However, the declustering code supports packing multiple stripes into
512: * a single parity stripe, so as to increase the size of the reconstruction
513: * unit without affecting the size of the stripe unit. This routine finds
514: * the parity stripe identifier associated with a stripe ID. There is also
515: * a RaidAddressToParityStripeID macro in layout.h
516: */
517: RF_StripeNum_t
518: rf_MapStripeIDToParityStripeID(RF_RaidLayout_t *layoutPtr,
519: RF_StripeNum_t stripeID, RF_ReconUnitNum_t *which_ru)
520: {
521: RF_StripeNum_t parityStripeID;
522:
523: /* Quick exit in the common case of SUsPerPU == 1. */
524: if ((layoutPtr->SUsPerPU == 1) || !layoutPtr->map->MapSIDToPSID) {
525: *which_ru = 0;
526: return (stripeID);
527: } else {
528: (layoutPtr->map->MapSIDToPSID) (layoutPtr, stripeID,
529: &parityStripeID, which_ru);
530: }
531: return (parityStripeID);
532: }
533: #endif /* RF_UTILITY == 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_layout.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe