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