/* $NetBSD: rf_layout.c,v 1.20 2008/05/04 20:57:23 oster Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. * * Author: Mark Holland * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. */ /* rf_layout.c -- driver code dealing with layout and mapping issues */ #include __KERNEL_RCSID(0, "$NetBSD: rf_layout.c,v 1.20 2008/05/04 20:57:23 oster Exp $"); #include #include "rf_archs.h" #include "rf_raid.h" #include "rf_dag.h" #include "rf_desc.h" #include "rf_decluster.h" #include "rf_pq.h" #include "rf_declusterPQ.h" #include "rf_raid0.h" #include "rf_raid1.h" #include "rf_raid4.h" #include "rf_raid5.h" #include "rf_states.h" #if RF_INCLUDE_RAID5_RS > 0 #include "rf_raid5_rotatedspare.h" #endif /* RF_INCLUDE_RAID5_RS > 0 */ #if RF_INCLUDE_CHAINDECLUSTER > 0 #include "rf_chaindecluster.h" #endif /* RF_INCLUDE_CHAINDECLUSTER > 0 */ #if RF_INCLUDE_INTERDECLUSTER > 0 #include "rf_interdecluster.h" #endif /* RF_INCLUDE_INTERDECLUSTER > 0 */ #if RF_INCLUDE_PARITYLOGGING > 0 #include "rf_paritylogging.h" #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ #if RF_INCLUDE_EVENODD > 0 #include "rf_evenodd.h" #endif /* RF_INCLUDE_EVENODD > 0 */ #include "rf_general.h" #include "rf_driver.h" #include "rf_parityscan.h" #include "rf_reconbuffer.h" #include "rf_reconutil.h" /*********************************************************************** * * the layout switch defines all the layouts that are supported. * fields are: layout ID, init routine, shutdown routine, map * sector, map parity, identify stripe, dag selection, map stripeid * to parity stripe id (optional), num faults tolerated, special * flags. * ***********************************************************************/ static const RF_AccessState_t DefaultStates[] = { rf_QuiesceState, rf_IncrAccessesCountState, rf_MapState, rf_LockState, rf_CreateDAGState, rf_ExecuteDAGState, rf_ProcessDAGState, rf_CleanupState, rf_DecrAccessesCountState, rf_LastState}; #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 /* Note that if you add any new RAID types to this list, that you must also update the mapsw[] table in the raidctl sources */ static const RF_LayoutSW_t mapsw[] = { #if RF_INCLUDE_PARITY_DECLUSTERING > 0 /* parity declustering */ {'T', "Parity declustering", RF_NU( rf_ConfigureDeclustered, rf_MapSectorDeclustered, rf_MapParityDeclustered, NULL, rf_IdentifyStripeDeclustered, rf_RaidFiveDagSelect, rf_MapSIDToPSIDDeclustered, rf_GetDefaultHeadSepLimitDeclustered, rf_GetDefaultNumFloatingReconBuffersDeclustered, NULL, NULL, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, 0) }, #endif #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0 /* parity declustering with distributed sparing */ {'D', "Distributed sparing parity declustering", RF_NU( rf_ConfigureDeclusteredDS, rf_MapSectorDeclustered, rf_MapParityDeclustered, NULL, rf_IdentifyStripeDeclustered, rf_RaidFiveDagSelect, rf_MapSIDToPSIDDeclustered, rf_GetDefaultHeadSepLimitDeclustered, rf_GetDefaultNumFloatingReconBuffersDeclustered, rf_GetNumSpareRUsDeclustered, rf_InstallSpareTable, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, RF_DISTRIBUTE_SPARE | RF_BD_DECLUSTERED) }, #endif #if RF_INCLUDE_DECL_PQ > 0 /* declustered P+Q */ {'Q', "Declustered P+Q", RF_NU( rf_ConfigureDeclusteredPQ, rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ, rf_MapQDeclusteredPQ, rf_IdentifyStripeDeclusteredPQ, rf_PQDagSelect, rf_MapSIDToPSIDDeclustered, rf_GetDefaultHeadSepLimitDeclustered, rf_GetDefaultNumFloatingReconBuffersPQ, NULL, NULL, NULL, rf_VerifyParityBasic, 2, DefaultStates, 0) }, #endif /* RF_INCLUDE_DECL_PQ > 0 */ #if RF_INCLUDE_RAID5_RS > 0 /* RAID 5 with rotated sparing */ {'R', "RAID Level 5 rotated sparing", RF_NU( rf_ConfigureRAID5_RS, rf_MapSectorRAID5_RS, rf_MapParityRAID5_RS, NULL, rf_IdentifyStripeRAID5_RS, rf_RaidFiveDagSelect, rf_MapSIDToPSIDRAID5_RS, rf_GetDefaultHeadSepLimitRAID5, rf_GetDefaultNumFloatingReconBuffersRAID5, rf_GetNumSpareRUsRAID5_RS, NULL, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, RF_DISTRIBUTE_SPARE) }, #endif /* RF_INCLUDE_RAID5_RS > 0 */ #if RF_INCLUDE_CHAINDECLUSTER > 0 /* Chained Declustering */ {'C', "Chained Declustering", RF_NU( rf_ConfigureChainDecluster, rf_MapSectorChainDecluster, rf_MapParityChainDecluster, NULL, rf_IdentifyStripeChainDecluster, rf_RAIDCDagSelect, rf_MapSIDToPSIDChainDecluster, NULL, NULL, rf_GetNumSpareRUsChainDecluster, NULL, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, 0) }, #endif /* RF_INCLUDE_CHAINDECLUSTER > 0 */ #if RF_INCLUDE_INTERDECLUSTER > 0 /* Interleaved Declustering */ {'I', "Interleaved Declustering", RF_NU( rf_ConfigureInterDecluster, rf_MapSectorInterDecluster, rf_MapParityInterDecluster, NULL, rf_IdentifyStripeInterDecluster, rf_RAIDIDagSelect, rf_MapSIDToPSIDInterDecluster, rf_GetDefaultHeadSepLimitInterDecluster, rf_GetDefaultNumFloatingReconBuffersInterDecluster, rf_GetNumSpareRUsInterDecluster, NULL, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, RF_DISTRIBUTE_SPARE) }, #endif /* RF_INCLUDE_INTERDECLUSTER > 0 */ #if RF_INCLUDE_RAID0 > 0 /* RAID level 0 */ {'0', "RAID Level 0", RF_NU( rf_ConfigureRAID0, rf_MapSectorRAID0, rf_MapParityRAID0, NULL, rf_IdentifyStripeRAID0, rf_RAID0DagSelect, rf_MapSIDToPSIDRAID0, NULL, NULL, NULL, NULL, NULL, rf_VerifyParityRAID0, 0, DefaultStates, 0) }, #endif /* RF_INCLUDE_RAID0 > 0 */ #if RF_INCLUDE_RAID1 > 0 /* RAID level 1 */ {'1', "RAID Level 1", RF_NU( rf_ConfigureRAID1, rf_MapSectorRAID1, rf_MapParityRAID1, NULL, rf_IdentifyStripeRAID1, rf_RAID1DagSelect, rf_MapSIDToPSIDRAID1, rf_GetDefaultHeadSepLimitRAID1, NULL, NULL, NULL, rf_SubmitReconBufferRAID1, rf_VerifyParityRAID1, 1, DefaultStates, 0) }, #endif /* RF_INCLUDE_RAID1 > 0 */ #if RF_INCLUDE_RAID4 > 0 /* RAID level 4 */ {'4', "RAID Level 4", RF_NU( rf_ConfigureRAID4, rf_MapSectorRAID4, rf_MapParityRAID4, NULL, rf_IdentifyStripeRAID4, rf_RaidFiveDagSelect, rf_MapSIDToPSIDRAID4, rf_GetDefaultHeadSepLimitRAID4, rf_GetDefaultNumFloatingReconBuffersRAID4, NULL, NULL, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, 0) }, #endif /* RF_INCLUDE_RAID4 > 0 */ #if RF_INCLUDE_RAID5 > 0 /* RAID level 5 */ {'5', "RAID Level 5", RF_NU( rf_ConfigureRAID5, rf_MapSectorRAID5, rf_MapParityRAID5, NULL, rf_IdentifyStripeRAID5, rf_RaidFiveDagSelect, rf_MapSIDToPSIDRAID5, rf_GetDefaultHeadSepLimitRAID5, rf_GetDefaultNumFloatingReconBuffersRAID5, NULL, NULL, rf_SubmitReconBufferBasic, rf_VerifyParityBasic, 1, DefaultStates, 0) }, #endif /* RF_INCLUDE_RAID5 > 0 */ #if RF_INCLUDE_EVENODD > 0 /* Evenodd */ {'E', "EvenOdd", RF_NU( rf_ConfigureEvenOdd, rf_MapSectorRAID5, rf_MapParityEvenOdd, rf_MapEEvenOdd, rf_IdentifyStripeEvenOdd, rf_EODagSelect, rf_MapSIDToPSIDRAID5, NULL, NULL, NULL, NULL, NULL, /* no reconstruction, yet */ rf_VerifyParityEvenOdd, 2, DefaultStates, 0) }, #endif /* RF_INCLUDE_EVENODD > 0 */ #if RF_INCLUDE_EVENODD > 0 /* Declustered Evenodd */ {'e', "Declustered EvenOdd", RF_NU( rf_ConfigureDeclusteredPQ, rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ, rf_MapQDeclusteredPQ, rf_IdentifyStripeDeclusteredPQ, rf_EODagSelect, rf_MapSIDToPSIDRAID5, rf_GetDefaultHeadSepLimitDeclustered, rf_GetDefaultNumFloatingReconBuffersPQ, NULL, NULL, NULL, /* no reconstruction, yet */ rf_VerifyParityEvenOdd, 2, DefaultStates, 0) }, #endif /* RF_INCLUDE_EVENODD > 0 */ #if RF_INCLUDE_PARITYLOGGING > 0 /* parity logging */ {'L', "Parity logging", RF_NU( rf_ConfigureParityLogging, rf_MapSectorParityLogging, rf_MapParityParityLogging, NULL, rf_IdentifyStripeParityLogging, rf_ParityLoggingDagSelect, rf_MapSIDToPSIDParityLogging, rf_GetDefaultHeadSepLimitParityLogging, rf_GetDefaultNumFloatingReconBuffersParityLogging, NULL, NULL, rf_SubmitReconBufferBasic, NULL, 1, DefaultStates, 0) }, #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ /* end-of-list marker */ {'\0', NULL, RF_NU( NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0) } }; const RF_LayoutSW_t * rf_GetLayout(RF_ParityConfig_t parityConfig) { const RF_LayoutSW_t *p; /* look up the specific layout */ for (p = &mapsw[0]; p->parityConfig; p++) if (p->parityConfig == parityConfig) break; if (!p->parityConfig) return (NULL); RF_ASSERT(p->parityConfig == parityConfig); return (p); } /***************************************************************************** * * ConfigureLayout -- * * read the configuration file and set up the RAID layout parameters. * After reading common params, invokes the layout-specific * configuration routine to finish the configuration. * ****************************************************************************/ int rf_ConfigureLayout(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr, RF_Config_t *cfgPtr) { RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout); RF_ParityConfig_t parityConfig; const RF_LayoutSW_t *p; int retval; layoutPtr->sectorsPerStripeUnit = cfgPtr->sectPerSU; layoutPtr->SUsPerPU = cfgPtr->SUsPerPU; layoutPtr->SUsPerRU = cfgPtr->SUsPerRU; parityConfig = cfgPtr->parityConfig; if (layoutPtr->sectorsPerStripeUnit <= 0) { RF_ERRORMSG2("raid%d: Invalid sectorsPerStripeUnit: %d\n", raidPtr->raidid, (int)layoutPtr->sectorsPerStripeUnit); return (EINVAL); } if (layoutPtr->SUsPerPU <= 0) { RF_ERRORMSG2("raid%d: Invalid StripeUnitsPerParityUnit: %d\n", raidPtr->raidid, (int)layoutPtr->SUsPerPU); return (EINVAL); } if (layoutPtr->SUsPerRU <= 0) { RF_ERRORMSG2("raid%d: Invalid StripeUnitsPerReconstructUnit: %d\n", raidPtr->raidid, (int)layoutPtr->SUsPerRU); return (EINVAL); } layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit; p = rf_GetLayout(parityConfig); if (p == NULL) { RF_ERRORMSG1("Unknown parity configuration '%c'", parityConfig); return (EINVAL); } RF_ASSERT(p->parityConfig == parityConfig); layoutPtr->map = p; /* initialize the specific layout */ retval = (p->Configure) (listp, raidPtr, cfgPtr); if (retval) return (retval); raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit; if (rf_forceNumFloatingReconBufs >= 0) { raidPtr->numFloatingReconBufs = rf_forceNumFloatingReconBufs; } else { raidPtr->numFloatingReconBufs = rf_GetDefaultNumFloatingReconBuffers(raidPtr); } if (rf_forceHeadSepLimit >= 0) { raidPtr->headSepLimit = rf_forceHeadSepLimit; } else { raidPtr->headSepLimit = rf_GetDefaultHeadSepLimit(raidPtr); } return (0); } /* typically there is a 1-1 mapping between stripes and parity stripes. * however, the declustering code supports packing multiple stripes into * a single parity stripe, so as to increase the size of the reconstruction * unit without affecting the size of the stripe unit. This routine finds * the parity stripe identifier associated with a stripe ID. There is also * a RaidAddressToParityStripeID macro in layout.h */ RF_StripeNum_t rf_MapStripeIDToParityStripeID(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID, RF_ReconUnitNum_t *which_ru) { RF_StripeNum_t parityStripeID; /* quick exit in the common case of SUsPerPU==1 */ if ((layoutPtr->SUsPerPU == 1) || !layoutPtr->map->MapSIDToPSID) { *which_ru = 0; return (stripeID); } else { (layoutPtr->map->MapSIDToPSID) (layoutPtr, stripeID, &parityStripeID, which_ru); } return (parityStripeID); }