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