720 lines
21 KiB
C
720 lines
21 KiB
C
/* $NetBSD: rf_layout.c,v 1.1 1998/11/13 04:20:30 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
|
|
*/
|
|
|
|
/*
|
|
* :
|
|
* Log: rf_layout.c,v
|
|
* Revision 1.71 1996/08/20 22:41:30 jimz
|
|
* add declustered evenodd
|
|
*
|
|
* Revision 1.70 1996/07/31 16:56:18 jimz
|
|
* dataBytesPerStripe, sectorsPerDisk init arch-indep.
|
|
*
|
|
* Revision 1.69 1996/07/31 15:34:46 jimz
|
|
* add EvenOdd
|
|
*
|
|
* Revision 1.68 1996/07/29 14:05:12 jimz
|
|
* fix numPUs/numRUs confusion (everything is now numRUs)
|
|
* clean up some commenting, return values
|
|
*
|
|
* Revision 1.67 1996/07/27 23:36:08 jimz
|
|
* Solaris port of simulator
|
|
*
|
|
* Revision 1.66 1996/07/27 18:40:24 jimz
|
|
* cleanup sweep
|
|
*
|
|
* Revision 1.65 1996/07/18 22:57:14 jimz
|
|
* port simulator to AIX
|
|
*
|
|
* Revision 1.64 1996/07/15 17:22:18 jimz
|
|
* nit-pick code cleanup
|
|
* resolve stdlib problems on DEC OSF
|
|
*
|
|
* Revision 1.63 1996/07/13 00:00:59 jimz
|
|
* sanitized generalized reconstruction architecture
|
|
* cleaned up head sep, rbuf problems
|
|
*
|
|
* Revision 1.62 1996/07/11 19:08:00 jimz
|
|
* generalize reconstruction mechanism
|
|
* allow raid1 reconstructs via copyback (done with array
|
|
* quiesced, not online, therefore not disk-directed)
|
|
*
|
|
* Revision 1.61 1996/06/19 22:23:01 jimz
|
|
* parity verification is now a layout-configurable thing
|
|
* not all layouts currently support it (correctly, anyway)
|
|
*
|
|
* Revision 1.60 1996/06/19 17:53:48 jimz
|
|
* move GetNumSparePUs, InstallSpareTable ops into layout switch
|
|
*
|
|
* Revision 1.59 1996/06/19 14:57:58 jimz
|
|
* move layout-specific config parsing hooks into RF_LayoutSW_t
|
|
* table in rf_layout.c
|
|
*
|
|
* Revision 1.58 1996/06/10 11:55:47 jimz
|
|
* Straightened out some per-array/not-per-array distinctions, fixed
|
|
* a couple bugs related to confusion. Added shutdown lists. Removed
|
|
* layout shutdown function (now subsumed by shutdown lists).
|
|
*
|
|
* Revision 1.57 1996/06/07 22:26:27 jimz
|
|
* type-ify which_ru (RF_ReconUnitNum_t)
|
|
*
|
|
* Revision 1.56 1996/06/07 21:33:04 jimz
|
|
* begin using consistent types for sector numbers,
|
|
* stripe numbers, row+col numbers, recon unit numbers
|
|
*
|
|
* Revision 1.55 1996/06/06 18:41:35 jimz
|
|
* change interleaved declustering dag selection to an
|
|
* interleaved-declustering-specific routine (so we can
|
|
* use the partitioned mirror node)
|
|
*
|
|
* Revision 1.54 1996/06/05 18:06:02 jimz
|
|
* Major code cleanup. The Great Renaming is now done.
|
|
* Better modularity. Better typing. Fixed a bunch of
|
|
* synchronization bugs. Made a lot of global stuff
|
|
* per-desc or per-array. Removed dead code.
|
|
*
|
|
* Revision 1.53 1996/06/03 23:28:26 jimz
|
|
* more bugfixes
|
|
* check in tree to sync for IPDS runs with current bugfixes
|
|
* there still may be a problem with threads in the script test
|
|
* getting I/Os stuck- not trivially reproducible (runs ~50 times
|
|
* in a row without getting stuck)
|
|
*
|
|
* Revision 1.52 1996/06/02 17:31:48 jimz
|
|
* Moved a lot of global stuff into array structure, where it belongs.
|
|
* Fixed up paritylogging, pss modules in this manner. Some general
|
|
* code cleanup. Removed lots of dead code, some dead files.
|
|
*
|
|
* Revision 1.51 1996/05/31 22:26:54 jimz
|
|
* fix a lot of mapping problems, memory allocation problems
|
|
* found some weird lock issues, fixed 'em
|
|
* more code cleanup
|
|
*
|
|
* Revision 1.50 1996/05/30 23:22:16 jimz
|
|
* bugfixes of serialization, timing problems
|
|
* more cleanup
|
|
*
|
|
* Revision 1.49 1996/05/30 11:29:41 jimz
|
|
* Numerous bug fixes. Stripe lock release code disagreed with the taking code
|
|
* about when stripes should be locked (I made it consistent: no parity, no lock)
|
|
* There was a lot of extra serialization of I/Os which I've removed- a lot of
|
|
* it was to calculate values for the cache code, which is no longer with us.
|
|
* More types, function, macro cleanup. Added code to properly quiesce the array
|
|
* on shutdown. Made a lot of stuff array-specific which was (bogusly) general
|
|
* before. Fixed memory allocation, freeing bugs.
|
|
*
|
|
* Revision 1.48 1996/05/27 18:56:37 jimz
|
|
* more code cleanup
|
|
* better typing
|
|
* compiles in all 3 environments
|
|
*
|
|
* Revision 1.47 1996/05/24 22:17:04 jimz
|
|
* continue code + namespace cleanup
|
|
* typed a bunch of flags
|
|
*
|
|
* Revision 1.46 1996/05/24 01:59:45 jimz
|
|
* another checkpoint in code cleanup for release
|
|
* time to sync kernel tree
|
|
*
|
|
* Revision 1.45 1996/05/23 21:46:35 jimz
|
|
* checkpoint in code cleanup (release prep)
|
|
* lots of types, function names have been fixed
|
|
*
|
|
* Revision 1.44 1996/05/18 19:51:34 jimz
|
|
* major code cleanup- fix syntax, make some types consistent,
|
|
* add prototypes, clean out dead code, et cetera
|
|
*
|
|
* Revision 1.43 1996/02/22 16:46:35 amiri
|
|
* modified chained declustering to use a seperate DAG selection routine
|
|
*
|
|
* Revision 1.42 1995/12/01 19:16:11 root
|
|
* added copyright info
|
|
*
|
|
* Revision 1.41 1995/11/28 21:31:02 amiri
|
|
* added Interleaved Declustering to switch table
|
|
*
|
|
* Revision 1.40 1995/11/20 14:35:17 arw
|
|
* moved rf_StartThroughputStats in DefaultWrite and DefaultRead
|
|
*
|
|
* Revision 1.39 1995/11/19 16:28:46 wvcii
|
|
* replaced LaunchDAGState with CreateDAGState, ExecuteDAGState
|
|
*
|
|
* Revision 1.38 1995/11/17 19:00:41 wvcii
|
|
* added MapQ entries to switch table
|
|
*
|
|
* Revision 1.37 1995/11/17 16:58:13 amiri
|
|
* Added the Chained Declustering architecture ('C'),
|
|
* essentially a variant of mirroring.
|
|
*
|
|
* Revision 1.36 1995/11/16 16:16:10 amiri
|
|
* Added RAID5 with rotated sparing ('R' configuration)
|
|
*
|
|
* Revision 1.35 1995/11/07 15:41:17 wvcii
|
|
* modified state lists: DefaultStates, VSReadStates
|
|
* necessary to support new states (LaunchDAGState, ProcessDAGState)
|
|
*
|
|
* Revision 1.34 1995/10/18 01:23:20 amiri
|
|
* added ifndef SIMULATE wrapper around rf_StartThroughputStats()
|
|
*
|
|
* Revision 1.33 1995/10/13 15:05:46 arw
|
|
* added rf_StartThroughputStats to DefaultRead and DefaultWrite
|
|
*
|
|
* Revision 1.32 1995/10/12 16:04:23 jimz
|
|
* added config names to mapsw entires
|
|
*
|
|
* Revision 1.31 1995/10/04 03:57:48 wvcii
|
|
* added raid level 1 to mapsw
|
|
*
|
|
* Revision 1.30 1995/09/07 01:26:55 jimz
|
|
* Achive basic compilation in kernel. Kernel functionality
|
|
* is not guaranteed at all, but it'll compile. Mostly. I hope.
|
|
*
|
|
* Revision 1.29 1995/07/28 21:43:42 robby
|
|
* checkin after leaving for Rice. Bye
|
|
*
|
|
* Revision 1.28 1995/07/26 03:26:14 robby
|
|
* *** empty log message ***
|
|
*
|
|
* Revision 1.27 1995/07/21 19:47:52 rachad
|
|
* Added raid 0 /5 with caching architectures
|
|
*
|
|
* Revision 1.26 1995/07/21 19:29:27 robby
|
|
* added virtual striping states
|
|
*
|
|
* Revision 1.25 1995/07/10 21:41:47 robby
|
|
* switched to have my own virtual stripng write function from the cache
|
|
*
|
|
* Revision 1.24 1995/07/10 20:51:59 robby
|
|
* added virtual striping states
|
|
*
|
|
* Revision 1.23 1995/07/10 16:57:42 robby
|
|
* updated alloclistelem struct to the correct struct name
|
|
*
|
|
* Revision 1.22 1995/07/08 20:06:11 rachad
|
|
* *** empty log message ***
|
|
*
|
|
* Revision 1.21 1995/07/08 19:43:16 cfb
|
|
* *** empty log message ***
|
|
*
|
|
* Revision 1.20 1995/07/08 18:05:39 rachad
|
|
* Linked up Claudsons code with the real cache
|
|
*
|
|
* Revision 1.19 1995/07/06 14:29:36 robby
|
|
* added defaults states list to the layout switch
|
|
*
|
|
* Revision 1.18 1995/06/23 13:40:34 robby
|
|
* updeated to prototypes in rf_layout.h
|
|
*
|
|
*/
|
|
|
|
#include "rf_types.h"
|
|
#include "rf_archs.h"
|
|
#include "rf_raid.h"
|
|
#include "rf_configure.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 RF_AccessState_t DefaultStates[] = {rf_QuiesceState,
|
|
rf_IncrAccessesCountState, rf_MapState, rf_LockState, rf_CreateDAGState,
|
|
rf_ExecuteDAGState, rf_ProcessDAGState, rf_DecrAccessesCountState,
|
|
rf_CleanupState, rf_LastState};
|
|
|
|
#if defined(__NetBSD__) && !defined(_KERNEL)
|
|
/* XXX Gross hack to shutup gcc -- it complains that DefaultStates is not
|
|
used when compiling this in userland.. I hate to burst it's bubble, but
|
|
DefaultStates is used all over the place here in the initialization of
|
|
lots of data structures. GO */
|
|
RF_AccessState_t *NothingAtAll = DefaultStates;
|
|
#endif
|
|
|
|
#if defined(__NetBSD__) && defined(_KERNEL)
|
|
/* XXX Remove static so GCC doesn't complain about these being unused! */
|
|
int distSpareYes = 1;
|
|
int distSpareNo = 0;
|
|
#else
|
|
static int distSpareYes = 1;
|
|
static int distSpareNo = 0;
|
|
#endif
|
|
#ifdef KERNEL
|
|
#define RF_NK2(a,b)
|
|
#else /* KERNEL */
|
|
#define RF_NK2(a,b) a,b,
|
|
#endif /* KERNEL */
|
|
|
|
#if RF_UTILITY > 0
|
|
#define RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
|
|
#else /* RF_UTILITY > 0 */
|
|
#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
|
|
#endif /* RF_UTILITY > 0 */
|
|
|
|
static RF_LayoutSW_t mapsw[] = {
|
|
/* parity declustering */
|
|
{'T', "Parity declustering",
|
|
RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
|
|
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)
|
|
},
|
|
|
|
/* parity declustering with distributed sparing */
|
|
{'D', "Distributed sparing parity declustering",
|
|
RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareYes)
|
|
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)
|
|
},
|
|
|
|
#if RF_INCLUDE_DECL_PQ > 0
|
|
/* declustered P+Q */
|
|
{'Q', "Declustered P+Q",
|
|
RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
RF_NU(
|
|
rf_ConfigureRAID1,
|
|
rf_MapSectorRAID1, rf_MapParityRAID1, NULL,
|
|
rf_IdentifyStripeRAID1,
|
|
rf_RAID1DagSelect,
|
|
rf_MapSIDToPSIDRAID1,
|
|
NULL,
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
|
|
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_NK2(rf_MakeLayoutSpecificNULL, NULL)
|
|
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_NK2(NULL, NULL)
|
|
RF_NU(
|
|
NULL,
|
|
NULL, NULL, NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, NULL,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0)
|
|
}
|
|
};
|
|
|
|
RF_LayoutSW_t *rf_GetLayout(RF_ParityConfig_t parityConfig)
|
|
{
|
|
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);
|
|
}
|
|
|
|
#if RF_UTILITY == 0
|
|
/*****************************************************************************************
|
|
*
|
|
* 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;
|
|
RF_LayoutSW_t *p;
|
|
int retval;
|
|
|
|
layoutPtr->sectorsPerStripeUnit = cfgPtr->sectPerSU;
|
|
layoutPtr->SUsPerPU = cfgPtr->SUsPerPU;
|
|
layoutPtr->SUsPerRU = cfgPtr->SUsPerRU;
|
|
parityConfig = cfgPtr->parityConfig;
|
|
|
|
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);
|
|
|
|
layoutPtr->dataBytesPerStripe = layoutPtr->dataSectorsPerStripe << raidPtr->logBytesPerSector;
|
|
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);
|
|
}
|
|
|
|
printf("RAIDFRAME: Configure (%s): total number of sectors is %lu (%lu MB)\n",
|
|
layoutPtr->map->configName,
|
|
(unsigned long)raidPtr->totalSectors,
|
|
(unsigned long)(raidPtr->totalSectors / 1024 * (1<<raidPtr->logBytesPerSector) / 1024));
|
|
if (raidPtr->headSepLimit >= 0) {
|
|
printf("RAIDFRAME(%s): Using %ld floating recon bufs with head sep limit %ld\n",
|
|
layoutPtr->map->configName, (long)raidPtr->numFloatingReconBufs, (long)raidPtr->headSepLimit);
|
|
}
|
|
else {
|
|
printf("RAIDFRAME(%s): Using %ld floating recon bufs with no head sep limit\n",
|
|
layoutPtr->map->configName, (long)raidPtr->numFloatingReconBufs);
|
|
}
|
|
|
|
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(layoutPtr, stripeID, which_ru)
|
|
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);
|
|
}
|
|
#endif /* RF_UTILITY == 0 */
|