Annotation of sys/dev/raidframe/rf_interdecluster.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_interdecluster.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $ */
2: /* $NetBSD: rf_interdecluster.c,v 1.4 2000/01/07 03:41:00 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Khalil Amiri
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_interdecluster.c -- Implements interleaved declustering.
34: *
35: *************************************************************/
36:
37:
38: #include "rf_types.h"
39: #include "rf_raid.h"
40: #include "rf_interdecluster.h"
41: #include "rf_dag.h"
42: #include "rf_dagutils.h"
43: #include "rf_dagfuncs.h"
44: #include "rf_general.h"
45: #include "rf_utils.h"
46: #include "rf_dagffrd.h"
47: #include "rf_dagdegrd.h"
48: #include "rf_dagffwr.h"
49: #include "rf_dagdegwr.h"
50:
51: typedef struct RF_InterdeclusterConfigInfo_s {
52: /* Filled in at config time and used by IdentifyStripe. */
53: RF_RowCol_t **stripeIdentifier;
54: RF_StripeCount_t numSparingRegions;
55: RF_StripeCount_t stripeUnitsPerSparingRegion;
56: RF_SectorNum_t mirrorStripeOffset;
57: } RF_InterdeclusterConfigInfo_t;
58:
59: int
60: rf_ConfigureInterDecluster(RF_ShutdownList_t **listp, 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),
70: (RF_InterdeclusterConfigInfo_t *), 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,
78: raidPtr->cleanupList);
79: if (info->stripeIdentifier == NULL)
80: return (ENOMEM);
81: for (i = 0; i < SUs_per_region; i++) {
82: info->stripeIdentifier[i][0] = i / (raidPtr->numCol - 1);
83: tmp = i / raidPtr->numCol;
84: info->stripeIdentifier[i][1] = (i + 1 + tmp) % raidPtr->numCol;
85: }
86:
87: /* No spare tables. */
88: RF_ASSERT(raidPtr->numRow == 1);
89:
90: /* Fill in the remaining layout parameters. */
91:
92: /*
93: * Total number of stripes should a multiple of 2*numCol: Each sparing
94: * region consists of 2*numCol stripes: n-1 primary copy, n-1
95: * secondary copy and 2 for spare...
96: */
97: num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk -
98: (layoutPtr->stripeUnitsPerDisk % (2 * raidPtr->numCol));
99: info->numSparingRegions = num_used_stripeUnitsPerDisk /
100: (2 * raidPtr->numCol);
101: /*
102: * This is in fact the number of stripe units (that are primary data
103: * copies) in the sparing region.
104: */
105: info->stripeUnitsPerSparingRegion = raidPtr->numCol *
106: (raidPtr->numCol - 1);
107: info->mirrorStripeOffset = info->numSparingRegions *
108: (raidPtr->numCol + 1);
109: layoutPtr->numStripe = info->numSparingRegions *
110: info->stripeUnitsPerSparingRegion;
111: layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
112: raidPtr->logBytesPerSector;
113: layoutPtr->numDataCol = 1;
114: layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
115: layoutPtr->sectorsPerStripeUnit;
116: layoutPtr->numParityCol = 1;
117:
118: layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
119:
120: raidPtr->sectorsPerDisk =
121: num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
122:
123: raidPtr->totalSectors =
124: (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
125:
126: layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
127: layoutPtr->sectorsPerStripeUnit;
128:
129: return (0);
130: }
131:
132: int
133: rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *raidPtr)
134: {
135: return (30);
136: }
137:
138: RF_HeadSepLimit_t
139: rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *raidPtr)
140: {
141: return (raidPtr->sectorsPerDisk);
142: }
143:
144: RF_ReconUnitCount_t
145: rf_GetNumSpareRUsInterDecluster(RF_Raid_t *raidPtr)
146: {
147: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
148: raidPtr->Layout.layoutSpecificInfo;
149:
150: return (2 * ((RF_ReconUnitCount_t) info->numSparingRegions));
151: /*
152: * The layout uses two stripe units per disk as spare within each
153: * sparing region.
154: */
155: }
156:
157: /* Maps to the primary copy of the data, i.e. the first mirror pair. */
158: void
159: rf_MapSectorInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
160: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t* diskSector, int remap)
161: {
162: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
163: raidPtr->Layout.layoutSpecificInfo;
164: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
165: RF_StripeNum_t su_offset_into_disk, mirror_su_offset_into_disk;
166: RF_StripeNum_t sparing_region_id, index_within_region;
167: int col_before_remap;
168:
169: *row = 0;
170: sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
171: index_within_region = SUID % info->stripeUnitsPerSparingRegion;
172: su_offset_into_disk = index_within_region % (raidPtr->numCol - 1);
173: mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
174: col_before_remap = index_within_region / (raidPtr->numCol - 1);
175:
176: if (!remap) {
177: *col = col_before_remap;
178: *diskSector = (su_offset_into_disk + ((raidPtr->numCol - 1) *
179: sparing_region_id)) * raidPtr->Layout.sectorsPerStripeUnit;
180: *diskSector +=
181: (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
182: } else {
183: /* Remap sector to spare space... */
184: *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
185: raidPtr->Layout.sectorsPerStripeUnit;
186: *diskSector += (raidPtr->numCol - 1) *
187: raidPtr->Layout.sectorsPerStripeUnit;
188: *diskSector +=
189: (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
190: *col = (index_within_region + 1 + mirror_su_offset_into_disk) %
191: raidPtr->numCol;
192: *col = (*col + 1) % raidPtr->numCol;
193: if (*col == col_before_remap)
194: *col = (*col + 1) % raidPtr->numCol;
195: }
196: }
197:
198: /* Maps to the second copy of the mirror pair. */
199: void
200: rf_MapParityInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
201: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
202: {
203: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
204: raidPtr->Layout.layoutSpecificInfo;
205: RF_StripeNum_t sparing_region_id, index_within_region;
206: RF_StripeNum_t mirror_su_offset_into_disk;
207: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
208: int col_before_remap;
209:
210: sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
211: index_within_region = SUID % info->stripeUnitsPerSparingRegion;
212: mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
213: col_before_remap = (index_within_region + 1 +
214: mirror_su_offset_into_disk) % raidPtr->numCol;
215:
216: *row = 0;
217: if (!remap) {
218: *col = col_before_remap;
219: *diskSector = info->mirrorStripeOffset *
220: raidPtr->Layout.sectorsPerStripeUnit;
221: *diskSector += sparing_region_id * (raidPtr->numCol - 1) *
222: raidPtr->Layout.sectorsPerStripeUnit;
223: *diskSector += mirror_su_offset_into_disk *
224: raidPtr->Layout.sectorsPerStripeUnit;
225: *diskSector +=
226: (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
227: } else {
228: /* Remap parity to spare space... */
229: *diskSector = sparing_region_id * (raidPtr->numCol + 1) *
230: raidPtr->Layout.sectorsPerStripeUnit;
231: *diskSector += (raidPtr->numCol) *
232: raidPtr->Layout.sectorsPerStripeUnit;
233: *diskSector += (raidSector %
234: raidPtr->Layout.sectorsPerStripeUnit);
235: *col = index_within_region / (raidPtr->numCol - 1);
236: *col = (*col + 1) % raidPtr->numCol;
237: if (*col == col_before_remap)
238: *col = (*col + 1) % raidPtr->numCol;
239: }
240: }
241:
242: void
243: rf_IdentifyStripeInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
244: RF_RowCol_t **diskids, RF_RowCol_t *outRow)
245: {
246: RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
247: raidPtr->Layout.layoutSpecificInfo;
248: RF_StripeNum_t SUID;
249:
250: SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
251: SUID = SUID % info->stripeUnitsPerSparingRegion;
252:
253: *outRow = 0;
254: *diskids = info->stripeIdentifier[SUID];
255: }
256:
257: void
258: rf_MapSIDToPSIDInterDecluster( RF_RaidLayout_t *layoutPtr,
259: RF_StripeNum_t stripeID, RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
260: {
261: *which_ru = 0;
262: *psID = stripeID;
263: }
264:
265:
266: /*****************************************************************************
267: * Select a graph to perform a single-stripe access.
268: *
269: * Parameters: raidPtr - Description of the physical array.
270: * type - Type of operation (read or write) requested.
271: * asmap - Logical & physical addresses for this access.
272: * createFunc - Name of function to use to create the graph.
273: *****************************************************************************/
274:
275: void
276: rf_RAIDIDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
277: RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
278: {
279: RF_ASSERT(RF_IO_IS_R_OR_W(type));
280:
281: if (asmap->numDataFailed + asmap->numParityFailed > 1) {
282: RF_ERRORMSG("Multiple disks failed in a single group !"
283: " Aborting I/O operation.\n");
284: *createFunc = NULL;
285: return;
286: }
287: *createFunc = (type == RF_IO_TYPE_READ)
288: ? (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG
289: : (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
290: if (type == RF_IO_TYPE_READ) {
291: if (asmap->numDataFailed == 0)
292: *createFunc = (RF_VoidFuncPtr)
293: rf_CreateMirrorPartitionReadDAG;
294: else
295: *createFunc = (RF_VoidFuncPtr)
296: rf_CreateRaidOneDegradedReadDAG;
297: } else
298: *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
299: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_interdecluster.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe