Annotation of src/sys/dev/raidframe/rf_interdecluster.c, revision 1.2
1.2 ! oster 1: /* $NetBSD: rf_interdecluster.c,v 1.1 1998/11/13 04:20:30 oster Exp $ */
1.1 oster 2: /*
3: * Copyright (c) 1995 Carnegie-Mellon University.
4: * All rights reserved.
5: *
6: * Author: Khalil Amiri
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_interdecluster.c -- implements interleaved declustering
32: *
33: ************************************************************/
34:
35:
36: #include "rf_types.h"
37: #include "rf_raid.h"
38: #include "rf_interdecluster.h"
39: #include "rf_dag.h"
40: #include "rf_dagutils.h"
41: #include "rf_dagfuncs.h"
42: #include "rf_threadid.h"
43: #include "rf_general.h"
44: #include "rf_utils.h"
45: #include "rf_dagffrd.h"
46: #include "rf_dagdegrd.h"
47: #include "rf_dagffwr.h"
48: #include "rf_dagdegwr.h"
49:
50: typedef struct RF_InterdeclusterConfigInfo_s {
51: RF_RowCol_t **stripeIdentifier; /* filled in at config time
52: * and used by IdentifyStripe */
53: RF_StripeCount_t numSparingRegions;
54: RF_StripeCount_t stripeUnitsPerSparingRegion;
55: RF_SectorNum_t mirrorStripeOffset;
56: } RF_InterdeclusterConfigInfo_t;
57:
58: int rf_ConfigureInterDecluster(
59: RF_ShutdownList_t **listp,
60: RF_Raid_t *raidPtr,
61: RF_Config_t *cfgPtr)
62: {
63: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
64: RF_StripeCount_t num_used_stripeUnitsPerDisk;
65: RF_InterdeclusterConfigInfo_t *info;
66: RF_RowCol_t i, tmp, SUs_per_region;
67:
68: /* create an Interleaved Declustering configuration structure */
69: RF_MallocAndAdd(info, sizeof(RF_InterdeclusterConfigInfo_t), (RF_InterdeclusterConfigInfo_t *),
70: raidPtr->cleanupList);
71: if (info == NULL)
72: return(ENOMEM);
73: layoutPtr->layoutSpecificInfo = (void *) info;
74:
75: /* fill in the config structure. */
76: SUs_per_region = raidPtr->numCol * (raidPtr->numCol - 1);
77: info->stripeIdentifier = rf_make_2d_array(SUs_per_region, 2 , raidPtr->cleanupList);
78: if (info->stripeIdentifier == NULL)
79: return(ENOMEM);
80: for (i=0; i< SUs_per_region; i++) {
81: info->stripeIdentifier[i][0] = i / (raidPtr->numCol-1);
82: tmp = i / raidPtr->numCol;
83: info->stripeIdentifier[i][1] = (i+1+tmp) % raidPtr->numCol;
84: }
85:
86: /* no spare tables */
87: RF_ASSERT(raidPtr->numRow == 1);
88:
89: /* fill in the remaining layout parameters */
90:
91: /* total number of stripes should a multiple of 2*numCol: Each sparing region consists of
92: 2*numCol stripes: n-1 primary copy, n-1 secondary copy and 2 for spare .. */
93: num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk - (layoutPtr->stripeUnitsPerDisk %
94: (2*raidPtr->numCol) );
95: info->numSparingRegions = num_used_stripeUnitsPerDisk / (2*raidPtr->numCol);
96: /* this is in fact the number of stripe units (that are primary data copies) in the sparing region */
97: info->stripeUnitsPerSparingRegion = raidPtr->numCol * (raidPtr->numCol - 1);
98: info->mirrorStripeOffset = info->numSparingRegions * (raidPtr->numCol+1);
99: layoutPtr->numStripe = info->numSparingRegions * info->stripeUnitsPerSparingRegion;
100: layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
101: layoutPtr->numDataCol = 1;
102: layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
103: layoutPtr->numParityCol = 1;
104:
105: layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
106:
107: raidPtr->sectorsPerDisk =
108: num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
109:
110: raidPtr->totalSectors =
111: (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
112:
113: layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
114:
115: return(0);
116: }
117:
118: int rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *raidPtr)
119: {
120: return(30);
121: }
122:
123: RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *raidPtr)
124: {
125: return(raidPtr->sectorsPerDisk);
126: }
127:
128: RF_ReconUnitCount_t rf_GetNumSpareRUsInterDecluster(
129: RF_Raid_t *raidPtr)
130: {
131: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
132:
133: return ( 2 * ((RF_ReconUnitCount_t) info->numSparingRegions) );
134: /* the layout uses two stripe units per disk as spare within each sparing region */
135: }
136:
137: /* Maps to the primary copy of the data, i.e. the first mirror pair */
138: void rf_MapSectorInterDecluster(
139: RF_Raid_t *raidPtr,
140: RF_RaidAddr_t raidSector,
141: RF_RowCol_t *row,
142: RF_RowCol_t *col,
143: RF_SectorNum_t *diskSector,
144: int remap)
145: {
146: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
147: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
148: RF_StripeNum_t su_offset_into_disk, mirror_su_offset_into_disk;
149: RF_StripeNum_t sparing_region_id, index_within_region;
150: int col_before_remap;
151:
152: *row = 0;
153: sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
154: index_within_region = SUID % info->stripeUnitsPerSparingRegion;
155: su_offset_into_disk = index_within_region % (raidPtr->numCol-1);
156: mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
157: col_before_remap = index_within_region / (raidPtr->numCol-1);
158:
159: if (!remap) {
160: *col = col_before_remap;;
161: *diskSector = ( su_offset_into_disk + ( (raidPtr->numCol-1) * sparing_region_id) ) *
162: raidPtr->Layout.sectorsPerStripeUnit;
163: *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
164: }
165: else {
166: /* remap sector to spare space...*/
167: *diskSector = sparing_region_id * (raidPtr->numCol+1) * raidPtr->Layout.sectorsPerStripeUnit;
168: *diskSector += (raidPtr->numCol-1) * raidPtr->Layout.sectorsPerStripeUnit;
169: *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
170: *col = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
171: *col = (*col + 1) % raidPtr->numCol;
172: if (*col == col_before_remap) *col = (*col + 1) % raidPtr->numCol;
173: }
174: }
175:
176: /* Maps to the second copy of the mirror pair. */
177: void rf_MapParityInterDecluster(
178: RF_Raid_t *raidPtr,
179: RF_RaidAddr_t raidSector,
180: RF_RowCol_t *row,
181: RF_RowCol_t *col,
182: RF_SectorNum_t *diskSector,
183: int remap)
184: {
185: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
186: RF_StripeNum_t sparing_region_id, index_within_region, mirror_su_offset_into_disk;
187: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
188: int col_before_remap;
189:
190: sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
191: index_within_region = SUID % info->stripeUnitsPerSparingRegion;
192: mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
193: col_before_remap = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
194:
195: *row = 0;
196: if (!remap) {
197: *col = col_before_remap;
198: *diskSector = info->mirrorStripeOffset * raidPtr->Layout.sectorsPerStripeUnit;
199: *diskSector += sparing_region_id * (raidPtr->numCol-1) * raidPtr->Layout.sectorsPerStripeUnit;
200: *diskSector += mirror_su_offset_into_disk * raidPtr->Layout.sectorsPerStripeUnit;
201: *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
202: }
203: else {
204: /* remap parity to spare space ... */
205: *diskSector = sparing_region_id * (raidPtr->numCol+1) * raidPtr->Layout.sectorsPerStripeUnit;
206: *diskSector += (raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit;
207: *diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
208: *col = index_within_region / (raidPtr->numCol-1);
209: *col = (*col + 1) % raidPtr->numCol;
210: if (*col == col_before_remap) *col = (*col + 1) % raidPtr->numCol;
211: }
212: }
213:
214: void rf_IdentifyStripeInterDecluster(
215: RF_Raid_t *raidPtr,
216: RF_RaidAddr_t addr,
217: RF_RowCol_t **diskids,
218: RF_RowCol_t *outRow)
219: {
220: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
221: RF_StripeNum_t SUID;
222:
223: SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
224: SUID = SUID % info->stripeUnitsPerSparingRegion;
225:
226: *outRow = 0;
227: *diskids = info->stripeIdentifier[ SUID ];
228: }
229:
230: void rf_MapSIDToPSIDInterDecluster(
231: RF_RaidLayout_t *layoutPtr,
232: RF_StripeNum_t stripeID,
233: RF_StripeNum_t *psID,
234: RF_ReconUnitNum_t *which_ru)
235: {
236: *which_ru = 0;
237: *psID = stripeID;
238: }
239:
240: /******************************************************************************
241: * select a graph to perform a single-stripe access
242: *
243: * Parameters: raidPtr - description of the physical array
244: * type - type of operation (read or write) requested
245: * asmap - logical & physical addresses for this access
246: * createFunc - name of function to use to create the graph
247: *****************************************************************************/
248:
249: void rf_RAIDIDagSelect(
250: RF_Raid_t *raidPtr,
251: RF_IoType_t type,
252: RF_AccessStripeMap_t *asmap,
253: RF_VoidFuncPtr *createFunc)
254: {
255: RF_ASSERT(RF_IO_IS_R_OR_W(type));
256:
257: if (asmap->numDataFailed + asmap->numParityFailed > 1) {
258: RF_ERRORMSG("Multiple disks failed in a single group! Aborting I/O operation.\n");
259: *createFunc = NULL;
260: return;
261: }
262:
263: *createFunc = (type == RF_IO_TYPE_READ) ? (RF_VoidFuncPtr)rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr)rf_CreateRaidOneWriteDAG;
264: if (type == RF_IO_TYPE_READ) {
265: if (asmap->numDataFailed == 0)
266: *createFunc = (RF_VoidFuncPtr)rf_CreateMirrorPartitionReadDAG;
267: else
268: *createFunc = (RF_VoidFuncPtr)rf_CreateRaidOneDegradedReadDAG;
269: }
270: else
271: *createFunc = (RF_VoidFuncPtr)rf_CreateRaidOneWriteDAG;
272: }
CVSweb <webmaster@jp.NetBSD.org>