rf_map.c revision 1.9 1 1.9 lukem /* $NetBSD: rf_map.c,v 1.9 2001/11/13 07:11:14 lukem Exp $ */
2 1.1 oster /*
3 1.1 oster * Copyright (c) 1995 Carnegie-Mellon University.
4 1.1 oster * All rights reserved.
5 1.1 oster *
6 1.1 oster * Author: Mark Holland
7 1.1 oster *
8 1.1 oster * Permission to use, copy, modify and distribute this software and
9 1.1 oster * its documentation is hereby granted, provided that both the copyright
10 1.1 oster * notice and this permission notice appear in all copies of the
11 1.1 oster * software, derivative works or modified versions, and any portions
12 1.1 oster * thereof, and that both notices appear in supporting documentation.
13 1.1 oster *
14 1.1 oster * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15 1.1 oster * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
16 1.1 oster * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17 1.1 oster *
18 1.1 oster * Carnegie Mellon requests users of this software to return to
19 1.1 oster *
20 1.1 oster * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU
21 1.1 oster * School of Computer Science
22 1.1 oster * Carnegie Mellon University
23 1.1 oster * Pittsburgh PA 15213-3890
24 1.1 oster *
25 1.1 oster * any improvements or extensions that they make and grant Carnegie the
26 1.1 oster * rights to redistribute these changes.
27 1.1 oster */
28 1.1 oster
29 1.1 oster /**************************************************************************
30 1.1 oster *
31 1.1 oster * map.c -- main code for mapping RAID addresses to physical disk addresses
32 1.1 oster *
33 1.1 oster **************************************************************************/
34 1.9 lukem
35 1.9 lukem #include <sys/cdefs.h>
36 1.9 lukem __KERNEL_RCSID(0, "$NetBSD: rf_map.c,v 1.9 2001/11/13 07:11:14 lukem Exp $");
37 1.1 oster
38 1.7 oster #include <dev/raidframe/raidframevar.h>
39 1.7 oster
40 1.1 oster #include "rf_threadstuff.h"
41 1.1 oster #include "rf_raid.h"
42 1.1 oster #include "rf_general.h"
43 1.1 oster #include "rf_map.h"
44 1.1 oster #include "rf_freelist.h"
45 1.1 oster #include "rf_shutdown.h"
46 1.1 oster
47 1.3 oster static void rf_FreePDAList(RF_PhysDiskAddr_t * start, RF_PhysDiskAddr_t * end, int count);
48 1.3 oster static void
49 1.3 oster rf_FreeASMList(RF_AccessStripeMap_t * start, RF_AccessStripeMap_t * end,
50 1.3 oster int count);
51 1.1 oster
52 1.1 oster /*****************************************************************************************
53 1.1 oster *
54 1.1 oster * MapAccess -- main 1st order mapping routine.
55 1.1 oster *
56 1.1 oster * Maps an access in the RAID address space to the corresponding set of physical disk
57 1.1 oster * addresses. The result is returned as a list of AccessStripeMap structures, one per
58 1.1 oster * stripe accessed. Each ASM structure contains a pointer to a list of PhysDiskAddr
59 1.1 oster * structures, which describe the physical locations touched by the user access. Note
60 1.1 oster * that this routine returns only static mapping information, i.e. the list of physical
61 1.1 oster * addresses returned does not necessarily identify the set of physical locations that
62 1.1 oster * will actually be read or written.
63 1.1 oster *
64 1.1 oster * The routine also maps the parity. The physical disk location returned always
65 1.1 oster * indicates the entire parity unit, even when only a subset of it is being accessed.
66 1.1 oster * This is because an access that is not stripe unit aligned but that spans a stripe
67 1.1 oster * unit boundary may require access two distinct portions of the parity unit, and we
68 1.1 oster * can't yet tell which portion(s) we'll actually need. We leave it up to the algorithm
69 1.1 oster * selection code to decide what subset of the parity unit to access.
70 1.1 oster *
71 1.1 oster * Note that addresses in the RAID address space must always be maintained as
72 1.1 oster * longs, instead of ints.
73 1.1 oster *
74 1.1 oster * This routine returns NULL if numBlocks is 0
75 1.1 oster *
76 1.1 oster ****************************************************************************************/
77 1.1 oster
78 1.3 oster RF_AccessStripeMapHeader_t *
79 1.3 oster rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
80 1.3 oster RF_Raid_t *raidPtr;
81 1.3 oster RF_RaidAddr_t raidAddress; /* starting address in RAID address
82 1.3 oster * space */
83 1.3 oster RF_SectorCount_t numBlocks; /* number of blocks in RAID address
84 1.3 oster * space to access */
85 1.3 oster caddr_t buffer; /* buffer to supply/receive data */
86 1.3 oster int remap; /* 1 => remap addresses to spare space */
87 1.3 oster {
88 1.3 oster RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
89 1.3 oster RF_AccessStripeMapHeader_t *asm_hdr = NULL;
90 1.3 oster RF_AccessStripeMap_t *asm_list = NULL, *asm_p = NULL;
91 1.3 oster int faultsTolerated = layoutPtr->map->faultsTolerated;
92 1.3 oster RF_RaidAddr_t startAddress = raidAddress; /* we'll change
93 1.3 oster * raidAddress along the
94 1.3 oster * way */
95 1.3 oster RF_RaidAddr_t endAddress = raidAddress + numBlocks;
96 1.3 oster RF_RaidDisk_t **disks = raidPtr->Disks;
97 1.3 oster
98 1.3 oster RF_PhysDiskAddr_t *pda_p, *pda_q;
99 1.3 oster RF_StripeCount_t numStripes = 0;
100 1.3 oster RF_RaidAddr_t stripeRealEndAddress, stripeEndAddress, nextStripeUnitAddress;
101 1.3 oster RF_RaidAddr_t startAddrWithinStripe, lastRaidAddr;
102 1.3 oster RF_StripeCount_t totStripes;
103 1.3 oster RF_StripeNum_t stripeID, lastSID, SUID, lastSUID;
104 1.3 oster RF_AccessStripeMap_t *asmList, *t_asm;
105 1.3 oster RF_PhysDiskAddr_t *pdaList, *t_pda;
106 1.3 oster
107 1.3 oster /* allocate all the ASMs and PDAs up front */
108 1.3 oster lastRaidAddr = raidAddress + numBlocks - 1;
109 1.3 oster stripeID = rf_RaidAddressToStripeID(layoutPtr, raidAddress);
110 1.3 oster lastSID = rf_RaidAddressToStripeID(layoutPtr, lastRaidAddr);
111 1.3 oster totStripes = lastSID - stripeID + 1;
112 1.3 oster SUID = rf_RaidAddressToStripeUnitID(layoutPtr, raidAddress);
113 1.3 oster lastSUID = rf_RaidAddressToStripeUnitID(layoutPtr, lastRaidAddr);
114 1.3 oster
115 1.3 oster asmList = rf_AllocASMList(totStripes);
116 1.3 oster pdaList = rf_AllocPDAList(lastSUID - SUID + 1 + faultsTolerated * totStripes); /* may also need pda(s)
117 1.3 oster * per stripe for parity */
118 1.3 oster
119 1.3 oster if (raidAddress + numBlocks > raidPtr->totalSectors) {
120 1.3 oster RF_ERRORMSG1("Unable to map access because offset (%d) was invalid\n",
121 1.3 oster (int) raidAddress);
122 1.3 oster return (NULL);
123 1.3 oster }
124 1.3 oster if (rf_mapDebug)
125 1.3 oster rf_PrintRaidAddressInfo(raidPtr, raidAddress, numBlocks);
126 1.3 oster for (; raidAddress < endAddress;) {
127 1.3 oster /* make the next stripe structure */
128 1.3 oster RF_ASSERT(asmList);
129 1.3 oster t_asm = asmList;
130 1.3 oster asmList = asmList->next;
131 1.6 thorpej memset((char *) t_asm, 0, sizeof(RF_AccessStripeMap_t));
132 1.3 oster if (!asm_p)
133 1.3 oster asm_list = asm_p = t_asm;
134 1.3 oster else {
135 1.3 oster asm_p->next = t_asm;
136 1.3 oster asm_p = asm_p->next;
137 1.3 oster }
138 1.3 oster numStripes++;
139 1.3 oster
140 1.3 oster /* map SUs from current location to the end of the stripe */
141 1.3 oster asm_p->stripeID = /* rf_RaidAddressToStripeID(layoutPtr,
142 1.3 oster raidAddress) */ stripeID++;
143 1.3 oster stripeRealEndAddress = rf_RaidAddressOfNextStripeBoundary(layoutPtr, raidAddress);
144 1.3 oster stripeEndAddress = RF_MIN(endAddress, stripeRealEndAddress);
145 1.3 oster asm_p->raidAddress = raidAddress;
146 1.3 oster asm_p->endRaidAddress = stripeEndAddress;
147 1.3 oster
148 1.3 oster /* map each stripe unit in the stripe */
149 1.3 oster pda_p = NULL;
150 1.3 oster startAddrWithinStripe = raidAddress; /* Raid addr of start of
151 1.3 oster * portion of access
152 1.3 oster * that is within this
153 1.3 oster * stripe */
154 1.3 oster for (; raidAddress < stripeEndAddress;) {
155 1.3 oster RF_ASSERT(pdaList);
156 1.3 oster t_pda = pdaList;
157 1.3 oster pdaList = pdaList->next;
158 1.6 thorpej memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t));
159 1.3 oster if (!pda_p)
160 1.3 oster asm_p->physInfo = pda_p = t_pda;
161 1.3 oster else {
162 1.3 oster pda_p->next = t_pda;
163 1.3 oster pda_p = pda_p->next;
164 1.3 oster }
165 1.3 oster
166 1.3 oster pda_p->type = RF_PDA_TYPE_DATA;
167 1.3 oster (layoutPtr->map->MapSector) (raidPtr, raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), remap);
168 1.3 oster
169 1.3 oster /* mark any failures we find. failedPDA is don't-care
170 1.3 oster * if there is more than one failure */
171 1.3 oster pda_p->raidAddress = raidAddress; /* the RAID address
172 1.3 oster * corresponding to this
173 1.3 oster * physical disk address */
174 1.3 oster nextStripeUnitAddress = rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, raidAddress);
175 1.3 oster pda_p->numSector = RF_MIN(endAddress, nextStripeUnitAddress) - raidAddress;
176 1.3 oster RF_ASSERT(pda_p->numSector != 0);
177 1.3 oster rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 0);
178 1.3 oster pda_p->bufPtr = buffer + rf_RaidAddressToByte(raidPtr, (raidAddress - startAddress));
179 1.3 oster asm_p->totalSectorsAccessed += pda_p->numSector;
180 1.3 oster asm_p->numStripeUnitsAccessed++;
181 1.3 oster asm_p->origRow = pda_p->row; /* redundant but
182 1.3 oster * harmless to do this
183 1.3 oster * in every loop
184 1.3 oster * iteration */
185 1.3 oster
186 1.3 oster raidAddress = RF_MIN(endAddress, nextStripeUnitAddress);
187 1.3 oster }
188 1.3 oster
189 1.3 oster /* Map the parity. At this stage, the startSector and
190 1.3 oster * numSector fields for the parity unit are always set to
191 1.3 oster * indicate the entire parity unit. We may modify this after
192 1.3 oster * mapping the data portion. */
193 1.3 oster switch (faultsTolerated) {
194 1.3 oster case 0:
195 1.3 oster break;
196 1.3 oster case 1: /* single fault tolerant */
197 1.3 oster RF_ASSERT(pdaList);
198 1.3 oster t_pda = pdaList;
199 1.3 oster pdaList = pdaList->next;
200 1.6 thorpej memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t));
201 1.3 oster pda_p = asm_p->parityInfo = t_pda;
202 1.3 oster pda_p->type = RF_PDA_TYPE_PARITY;
203 1.3 oster (layoutPtr->map->MapParity) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe),
204 1.3 oster &(pda_p->row), &(pda_p->col), &(pda_p->startSector), remap);
205 1.3 oster pda_p->numSector = layoutPtr->sectorsPerStripeUnit;
206 1.3 oster /* raidAddr may be needed to find unit to redirect to */
207 1.3 oster pda_p->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe);
208 1.3 oster rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1);
209 1.3 oster rf_ASMParityAdjust(asm_p->parityInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p);
210 1.3 oster
211 1.3 oster break;
212 1.3 oster case 2: /* two fault tolerant */
213 1.3 oster RF_ASSERT(pdaList && pdaList->next);
214 1.3 oster t_pda = pdaList;
215 1.3 oster pdaList = pdaList->next;
216 1.6 thorpej memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t));
217 1.3 oster pda_p = asm_p->parityInfo = t_pda;
218 1.3 oster pda_p->type = RF_PDA_TYPE_PARITY;
219 1.3 oster t_pda = pdaList;
220 1.3 oster pdaList = pdaList->next;
221 1.6 thorpej memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t));
222 1.3 oster pda_q = asm_p->qInfo = t_pda;
223 1.3 oster pda_q->type = RF_PDA_TYPE_Q;
224 1.3 oster (layoutPtr->map->MapParity) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe),
225 1.3 oster &(pda_p->row), &(pda_p->col), &(pda_p->startSector), remap);
226 1.3 oster (layoutPtr->map->MapQ) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe),
227 1.3 oster &(pda_q->row), &(pda_q->col), &(pda_q->startSector), remap);
228 1.3 oster pda_q->numSector = pda_p->numSector = layoutPtr->sectorsPerStripeUnit;
229 1.3 oster /* raidAddr may be needed to find unit to redirect to */
230 1.3 oster pda_p->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe);
231 1.3 oster pda_q->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe);
232 1.3 oster /* failure mode stuff */
233 1.3 oster rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1);
234 1.3 oster rf_ASMCheckStatus(raidPtr, pda_q, asm_p, disks, 1);
235 1.3 oster rf_ASMParityAdjust(asm_p->parityInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p);
236 1.3 oster rf_ASMParityAdjust(asm_p->qInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p);
237 1.3 oster break;
238 1.3 oster }
239 1.3 oster }
240 1.3 oster RF_ASSERT(asmList == NULL && pdaList == NULL);
241 1.3 oster /* make the header structure */
242 1.3 oster asm_hdr = rf_AllocAccessStripeMapHeader();
243 1.3 oster RF_ASSERT(numStripes == totStripes);
244 1.3 oster asm_hdr->numStripes = numStripes;
245 1.3 oster asm_hdr->stripeMap = asm_list;
246 1.3 oster
247 1.3 oster if (rf_mapDebug)
248 1.3 oster rf_PrintAccessStripeMap(asm_hdr);
249 1.3 oster return (asm_hdr);
250 1.1 oster }
251 1.1 oster /*****************************************************************************************
252 1.1 oster * This routine walks through an ASM list and marks the PDAs that have failed.
253 1.1 oster * It's called only when a disk failure causes an in-flight DAG to fail.
254 1.1 oster * The parity may consist of two components, but we want to use only one failedPDA
255 1.1 oster * pointer. Thus we set failedPDA to point to the first parity component, and rely
256 1.1 oster * on the rest of the code to do the right thing with this.
257 1.1 oster ****************************************************************************************/
258 1.1 oster
259 1.3 oster void
260 1.3 oster rf_MarkFailuresInASMList(raidPtr, asm_h)
261 1.3 oster RF_Raid_t *raidPtr;
262 1.3 oster RF_AccessStripeMapHeader_t *asm_h;
263 1.3 oster {
264 1.3 oster RF_RaidDisk_t **disks = raidPtr->Disks;
265 1.3 oster RF_AccessStripeMap_t *asmap;
266 1.3 oster RF_PhysDiskAddr_t *pda;
267 1.3 oster
268 1.3 oster for (asmap = asm_h->stripeMap; asmap; asmap = asmap->next) {
269 1.3 oster asmap->numDataFailed = asmap->numParityFailed = asmap->numQFailed = 0;
270 1.3 oster asmap->numFailedPDAs = 0;
271 1.6 thorpej memset((char *) asmap->failedPDAs, 0,
272 1.3 oster RF_MAX_FAILED_PDA * sizeof(RF_PhysDiskAddr_t *));
273 1.3 oster for (pda = asmap->physInfo; pda; pda = pda->next) {
274 1.3 oster if (RF_DEAD_DISK(disks[pda->row][pda->col].status)) {
275 1.3 oster asmap->numDataFailed++;
276 1.3 oster asmap->failedPDAs[asmap->numFailedPDAs] = pda;
277 1.3 oster asmap->numFailedPDAs++;
278 1.3 oster }
279 1.3 oster }
280 1.3 oster pda = asmap->parityInfo;
281 1.3 oster if (pda && RF_DEAD_DISK(disks[pda->row][pda->col].status)) {
282 1.3 oster asmap->numParityFailed++;
283 1.3 oster asmap->failedPDAs[asmap->numFailedPDAs] = pda;
284 1.3 oster asmap->numFailedPDAs++;
285 1.3 oster }
286 1.3 oster pda = asmap->qInfo;
287 1.3 oster if (pda && RF_DEAD_DISK(disks[pda->row][pda->col].status)) {
288 1.3 oster asmap->numQFailed++;
289 1.3 oster asmap->failedPDAs[asmap->numFailedPDAs] = pda;
290 1.3 oster asmap->numFailedPDAs++;
291 1.3 oster }
292 1.3 oster }
293 1.1 oster }
294 1.1 oster /*****************************************************************************************
295 1.1 oster *
296 1.1 oster * DuplicateASM -- duplicates an ASM and returns the new one
297 1.1 oster *
298 1.1 oster ****************************************************************************************/
299 1.3 oster RF_AccessStripeMap_t *
300 1.3 oster rf_DuplicateASM(asmap)
301 1.3 oster RF_AccessStripeMap_t *asmap;
302 1.3 oster {
303 1.3 oster RF_AccessStripeMap_t *new_asm;
304 1.3 oster RF_PhysDiskAddr_t *pda, *new_pda, *t_pda;
305 1.3 oster
306 1.3 oster new_pda = NULL;
307 1.3 oster new_asm = rf_AllocAccessStripeMapComponent();
308 1.3 oster bcopy((char *) asmap, (char *) new_asm, sizeof(RF_AccessStripeMap_t));
309 1.3 oster new_asm->numFailedPDAs = 0; /* ??? */
310 1.3 oster new_asm->failedPDAs[0] = NULL;
311 1.3 oster new_asm->physInfo = NULL;
312 1.3 oster new_asm->parityInfo = NULL;
313 1.3 oster new_asm->next = NULL;
314 1.3 oster
315 1.3 oster for (pda = asmap->physInfo; pda; pda = pda->next) { /* copy the physInfo
316 1.3 oster * list */
317 1.3 oster t_pda = rf_AllocPhysDiskAddr();
318 1.3 oster bcopy((char *) pda, (char *) t_pda, sizeof(RF_PhysDiskAddr_t));
319 1.3 oster t_pda->next = NULL;
320 1.3 oster if (!new_asm->physInfo) {
321 1.3 oster new_asm->physInfo = t_pda;
322 1.3 oster new_pda = t_pda;
323 1.3 oster } else {
324 1.3 oster new_pda->next = t_pda;
325 1.3 oster new_pda = new_pda->next;
326 1.3 oster }
327 1.3 oster if (pda == asmap->failedPDAs[0])
328 1.3 oster new_asm->failedPDAs[0] = t_pda;
329 1.3 oster }
330 1.3 oster for (pda = asmap->parityInfo; pda; pda = pda->next) { /* copy the parityInfo
331 1.3 oster * list */
332 1.3 oster t_pda = rf_AllocPhysDiskAddr();
333 1.3 oster bcopy((char *) pda, (char *) t_pda, sizeof(RF_PhysDiskAddr_t));
334 1.3 oster t_pda->next = NULL;
335 1.3 oster if (!new_asm->parityInfo) {
336 1.3 oster new_asm->parityInfo = t_pda;
337 1.3 oster new_pda = t_pda;
338 1.3 oster } else {
339 1.3 oster new_pda->next = t_pda;
340 1.3 oster new_pda = new_pda->next;
341 1.3 oster }
342 1.3 oster if (pda == asmap->failedPDAs[0])
343 1.3 oster new_asm->failedPDAs[0] = t_pda;
344 1.3 oster }
345 1.3 oster return (new_asm);
346 1.1 oster }
347 1.1 oster /*****************************************************************************************
348 1.1 oster *
349 1.1 oster * DuplicatePDA -- duplicates a PDA and returns the new one
350 1.1 oster *
351 1.1 oster ****************************************************************************************/
352 1.3 oster RF_PhysDiskAddr_t *
353 1.3 oster rf_DuplicatePDA(pda)
354 1.3 oster RF_PhysDiskAddr_t *pda;
355 1.3 oster {
356 1.3 oster RF_PhysDiskAddr_t *new;
357 1.3 oster
358 1.3 oster new = rf_AllocPhysDiskAddr();
359 1.3 oster bcopy((char *) pda, (char *) new, sizeof(RF_PhysDiskAddr_t));
360 1.3 oster return (new);
361 1.1 oster }
362 1.1 oster /*****************************************************************************************
363 1.1 oster *
364 1.1 oster * routines to allocate and free list elements. All allocation routines zero the
365 1.1 oster * structure before returning it.
366 1.1 oster *
367 1.1 oster * FreePhysDiskAddr is static. It should never be called directly, because
368 1.1 oster * FreeAccessStripeMap takes care of freeing the PhysDiskAddr list.
369 1.1 oster *
370 1.1 oster ****************************************************************************************/
371 1.1 oster
372 1.1 oster static RF_FreeList_t *rf_asmhdr_freelist;
373 1.1 oster #define RF_MAX_FREE_ASMHDR 128
374 1.1 oster #define RF_ASMHDR_INC 16
375 1.1 oster #define RF_ASMHDR_INITIAL 32
376 1.1 oster
377 1.1 oster static RF_FreeList_t *rf_asm_freelist;
378 1.1 oster #define RF_MAX_FREE_ASM 192
379 1.1 oster #define RF_ASM_INC 24
380 1.1 oster #define RF_ASM_INITIAL 64
381 1.1 oster
382 1.1 oster static RF_FreeList_t *rf_pda_freelist;
383 1.1 oster #define RF_MAX_FREE_PDA 192
384 1.1 oster #define RF_PDA_INC 24
385 1.1 oster #define RF_PDA_INITIAL 64
386 1.1 oster
387 1.1 oster /* called at shutdown time. So far, all that is necessary is to release all the free lists */
388 1.1 oster static void rf_ShutdownMapModule(void *);
389 1.3 oster static void
390 1.3 oster rf_ShutdownMapModule(ignored)
391 1.3 oster void *ignored;
392 1.1 oster {
393 1.3 oster RF_FREELIST_DESTROY(rf_asmhdr_freelist, next, (RF_AccessStripeMapHeader_t *));
394 1.3 oster RF_FREELIST_DESTROY(rf_pda_freelist, next, (RF_PhysDiskAddr_t *));
395 1.3 oster RF_FREELIST_DESTROY(rf_asm_freelist, next, (RF_AccessStripeMap_t *));
396 1.1 oster }
397 1.1 oster
398 1.3 oster int
399 1.3 oster rf_ConfigureMapModule(listp)
400 1.3 oster RF_ShutdownList_t **listp;
401 1.1 oster {
402 1.3 oster int rc;
403 1.1 oster
404 1.1 oster RF_FREELIST_CREATE(rf_asmhdr_freelist, RF_MAX_FREE_ASMHDR,
405 1.3 oster RF_ASMHDR_INC, sizeof(RF_AccessStripeMapHeader_t));
406 1.1 oster if (rf_asmhdr_freelist == NULL) {
407 1.3 oster return (ENOMEM);
408 1.1 oster }
409 1.1 oster RF_FREELIST_CREATE(rf_asm_freelist, RF_MAX_FREE_ASM,
410 1.3 oster RF_ASM_INC, sizeof(RF_AccessStripeMap_t));
411 1.1 oster if (rf_asm_freelist == NULL) {
412 1.3 oster RF_FREELIST_DESTROY(rf_asmhdr_freelist, next, (RF_AccessStripeMapHeader_t *));
413 1.3 oster return (ENOMEM);
414 1.1 oster }
415 1.1 oster RF_FREELIST_CREATE(rf_pda_freelist, RF_MAX_FREE_PDA,
416 1.3 oster RF_PDA_INC, sizeof(RF_PhysDiskAddr_t));
417 1.1 oster if (rf_pda_freelist == NULL) {
418 1.3 oster RF_FREELIST_DESTROY(rf_asmhdr_freelist, next, (RF_AccessStripeMapHeader_t *));
419 1.3 oster RF_FREELIST_DESTROY(rf_pda_freelist, next, (RF_PhysDiskAddr_t *));
420 1.3 oster return (ENOMEM);
421 1.1 oster }
422 1.1 oster rc = rf_ShutdownCreate(listp, rf_ShutdownMapModule, NULL);
423 1.1 oster if (rc) {
424 1.1 oster RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
425 1.3 oster __LINE__, rc);
426 1.1 oster rf_ShutdownMapModule(NULL);
427 1.3 oster return (rc);
428 1.1 oster }
429 1.3 oster RF_FREELIST_PRIME(rf_asmhdr_freelist, RF_ASMHDR_INITIAL, next,
430 1.3 oster (RF_AccessStripeMapHeader_t *));
431 1.3 oster RF_FREELIST_PRIME(rf_asm_freelist, RF_ASM_INITIAL, next,
432 1.3 oster (RF_AccessStripeMap_t *));
433 1.3 oster RF_FREELIST_PRIME(rf_pda_freelist, RF_PDA_INITIAL, next,
434 1.3 oster (RF_PhysDiskAddr_t *));
435 1.1 oster
436 1.3 oster return (0);
437 1.1 oster }
438 1.1 oster
439 1.3 oster RF_AccessStripeMapHeader_t *
440 1.3 oster rf_AllocAccessStripeMapHeader()
441 1.1 oster {
442 1.1 oster RF_AccessStripeMapHeader_t *p;
443 1.1 oster
444 1.3 oster RF_FREELIST_GET(rf_asmhdr_freelist, p, next, (RF_AccessStripeMapHeader_t *));
445 1.6 thorpej memset((char *) p, 0, sizeof(RF_AccessStripeMapHeader_t));
446 1.1 oster
447 1.3 oster return (p);
448 1.1 oster }
449 1.1 oster
450 1.1 oster
451 1.3 oster void
452 1.3 oster rf_FreeAccessStripeMapHeader(p)
453 1.3 oster RF_AccessStripeMapHeader_t *p;
454 1.1 oster {
455 1.3 oster RF_FREELIST_FREE(rf_asmhdr_freelist, p, next);
456 1.1 oster }
457 1.1 oster
458 1.3 oster RF_PhysDiskAddr_t *
459 1.3 oster rf_AllocPhysDiskAddr()
460 1.1 oster {
461 1.1 oster RF_PhysDiskAddr_t *p;
462 1.1 oster
463 1.3 oster RF_FREELIST_GET(rf_pda_freelist, p, next, (RF_PhysDiskAddr_t *));
464 1.6 thorpej memset((char *) p, 0, sizeof(RF_PhysDiskAddr_t));
465 1.1 oster
466 1.3 oster return (p);
467 1.1 oster }
468 1.1 oster /* allocates a list of PDAs, locking the free list only once
469 1.1 oster * when we have to call calloc, we do it one component at a time to simplify
470 1.1 oster * the process of freeing the list at program shutdown. This should not be
471 1.1 oster * much of a performance hit, because it should be very infrequently executed.
472 1.1 oster */
473 1.3 oster RF_PhysDiskAddr_t *
474 1.3 oster rf_AllocPDAList(count)
475 1.3 oster int count;
476 1.1 oster {
477 1.1 oster RF_PhysDiskAddr_t *p = NULL;
478 1.1 oster
479 1.3 oster RF_FREELIST_GET_N(rf_pda_freelist, p, next, (RF_PhysDiskAddr_t *), count);
480 1.3 oster return (p);
481 1.1 oster }
482 1.1 oster
483 1.3 oster void
484 1.3 oster rf_FreePhysDiskAddr(p)
485 1.3 oster RF_PhysDiskAddr_t *p;
486 1.1 oster {
487 1.3 oster RF_FREELIST_FREE(rf_pda_freelist, p, next);
488 1.1 oster }
489 1.1 oster
490 1.3 oster static void
491 1.3 oster rf_FreePDAList(l_start, l_end, count)
492 1.3 oster RF_PhysDiskAddr_t *l_start, *l_end; /* pointers to start and end
493 1.3 oster * of list */
494 1.3 oster int count; /* number of elements in list */
495 1.1 oster {
496 1.3 oster RF_FREELIST_FREE_N(rf_pda_freelist, l_start, next, (RF_PhysDiskAddr_t *), count);
497 1.1 oster }
498 1.1 oster
499 1.3 oster RF_AccessStripeMap_t *
500 1.3 oster rf_AllocAccessStripeMapComponent()
501 1.1 oster {
502 1.1 oster RF_AccessStripeMap_t *p;
503 1.1 oster
504 1.3 oster RF_FREELIST_GET(rf_asm_freelist, p, next, (RF_AccessStripeMap_t *));
505 1.6 thorpej memset((char *) p, 0, sizeof(RF_AccessStripeMap_t));
506 1.1 oster
507 1.3 oster return (p);
508 1.1 oster }
509 1.1 oster /* this is essentially identical to AllocPDAList. I should combine the two.
510 1.1 oster * when we have to call calloc, we do it one component at a time to simplify
511 1.1 oster * the process of freeing the list at program shutdown. This should not be
512 1.1 oster * much of a performance hit, because it should be very infrequently executed.
513 1.1 oster */
514 1.3 oster RF_AccessStripeMap_t *
515 1.3 oster rf_AllocASMList(count)
516 1.3 oster int count;
517 1.1 oster {
518 1.1 oster RF_AccessStripeMap_t *p = NULL;
519 1.1 oster
520 1.3 oster RF_FREELIST_GET_N(rf_asm_freelist, p, next, (RF_AccessStripeMap_t *), count);
521 1.3 oster return (p);
522 1.1 oster }
523 1.1 oster
524 1.3 oster void
525 1.3 oster rf_FreeAccessStripeMapComponent(p)
526 1.3 oster RF_AccessStripeMap_t *p;
527 1.1 oster {
528 1.3 oster RF_FREELIST_FREE(rf_asm_freelist, p, next);
529 1.1 oster }
530 1.1 oster
531 1.3 oster static void
532 1.3 oster rf_FreeASMList(l_start, l_end, count)
533 1.3 oster RF_AccessStripeMap_t *l_start, *l_end;
534 1.3 oster int count;
535 1.3 oster {
536 1.3 oster RF_FREELIST_FREE_N(rf_asm_freelist, l_start, next, (RF_AccessStripeMap_t *), count);
537 1.3 oster }
538 1.3 oster
539 1.3 oster void
540 1.3 oster rf_FreeAccessStripeMap(hdr)
541 1.3 oster RF_AccessStripeMapHeader_t *hdr;
542 1.3 oster {
543 1.3 oster RF_AccessStripeMap_t *p, *pt = NULL;
544 1.3 oster RF_PhysDiskAddr_t *pdp, *trailer, *pdaList = NULL, *pdaEnd = NULL;
545 1.3 oster int count = 0, t, asm_count = 0;
546 1.3 oster
547 1.3 oster for (p = hdr->stripeMap; p; p = p->next) {
548 1.3 oster
549 1.3 oster /* link the 3 pda lists into the accumulating pda list */
550 1.3 oster
551 1.3 oster if (!pdaList)
552 1.3 oster pdaList = p->qInfo;
553 1.3 oster else
554 1.3 oster pdaEnd->next = p->qInfo;
555 1.3 oster for (trailer = NULL, pdp = p->qInfo; pdp;) {
556 1.3 oster trailer = pdp;
557 1.3 oster pdp = pdp->next;
558 1.3 oster count++;
559 1.3 oster }
560 1.3 oster if (trailer)
561 1.3 oster pdaEnd = trailer;
562 1.3 oster
563 1.3 oster if (!pdaList)
564 1.3 oster pdaList = p->parityInfo;
565 1.3 oster else
566 1.3 oster pdaEnd->next = p->parityInfo;
567 1.3 oster for (trailer = NULL, pdp = p->parityInfo; pdp;) {
568 1.3 oster trailer = pdp;
569 1.3 oster pdp = pdp->next;
570 1.3 oster count++;
571 1.3 oster }
572 1.3 oster if (trailer)
573 1.3 oster pdaEnd = trailer;
574 1.3 oster
575 1.3 oster if (!pdaList)
576 1.3 oster pdaList = p->physInfo;
577 1.3 oster else
578 1.3 oster pdaEnd->next = p->physInfo;
579 1.3 oster for (trailer = NULL, pdp = p->physInfo; pdp;) {
580 1.3 oster trailer = pdp;
581 1.3 oster pdp = pdp->next;
582 1.3 oster count++;
583 1.3 oster }
584 1.3 oster if (trailer)
585 1.3 oster pdaEnd = trailer;
586 1.3 oster
587 1.3 oster pt = p;
588 1.3 oster asm_count++;
589 1.3 oster }
590 1.3 oster
591 1.3 oster /* debug only */
592 1.3 oster for (t = 0, pdp = pdaList; pdp; pdp = pdp->next)
593 1.3 oster t++;
594 1.3 oster RF_ASSERT(t == count);
595 1.3 oster
596 1.3 oster if (pdaList)
597 1.3 oster rf_FreePDAList(pdaList, pdaEnd, count);
598 1.3 oster rf_FreeASMList(hdr->stripeMap, pt, asm_count);
599 1.3 oster rf_FreeAccessStripeMapHeader(hdr);
600 1.1 oster }
601 1.1 oster /* We can't use the large write optimization if there are any failures in the stripe.
602 1.1 oster * In the declustered layout, there is no way to immediately determine what disks
603 1.1 oster * constitute a stripe, so we actually have to hunt through the stripe looking for failures.
604 1.1 oster * The reason we map the parity instead of just using asm->parityInfo->col is because
605 1.1 oster * the latter may have been already redirected to a spare drive, which would
606 1.1 oster * mess up the computation of the stripe offset.
607 1.1 oster *
608 1.1 oster * ASSUMES AT MOST ONE FAILURE IN THE STRIPE.
609 1.1 oster */
610 1.3 oster int
611 1.3 oster rf_CheckStripeForFailures(raidPtr, asmap)
612 1.3 oster RF_Raid_t *raidPtr;
613 1.3 oster RF_AccessStripeMap_t *asmap;
614 1.3 oster {
615 1.3 oster RF_RowCol_t trow, tcol, prow, pcol, *diskids, row, i;
616 1.3 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
617 1.3 oster RF_StripeCount_t stripeOffset;
618 1.3 oster int numFailures;
619 1.3 oster RF_RaidAddr_t sosAddr;
620 1.3 oster RF_SectorNum_t diskOffset, poffset;
621 1.3 oster RF_RowCol_t testrow;
622 1.3 oster
623 1.3 oster /* quick out in the fault-free case. */
624 1.3 oster RF_LOCK_MUTEX(raidPtr->mutex);
625 1.3 oster numFailures = raidPtr->numFailures;
626 1.3 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
627 1.3 oster if (numFailures == 0)
628 1.3 oster return (0);
629 1.3 oster
630 1.3 oster sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
631 1.3 oster row = asmap->physInfo->row;
632 1.3 oster (layoutPtr->map->IdentifyStripe) (raidPtr, asmap->raidAddress, &diskids, &testrow);
633 1.3 oster (layoutPtr->map->MapParity) (raidPtr, asmap->raidAddress, &prow, &pcol, &poffset, 0); /* get pcol */
634 1.3 oster
635 1.3 oster /* this need not be true if we've redirected the access to a spare in
636 1.3 oster * another row RF_ASSERT(row == testrow); */
637 1.3 oster stripeOffset = 0;
638 1.3 oster for (i = 0; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++) {
639 1.3 oster if (diskids[i] != pcol) {
640 1.3 oster if (RF_DEAD_DISK(raidPtr->Disks[testrow][diskids[i]].status)) {
641 1.3 oster if (raidPtr->status[testrow] != rf_rs_reconstructing)
642 1.3 oster return (1);
643 1.3 oster RF_ASSERT(raidPtr->reconControl[testrow]->fcol == diskids[i]);
644 1.3 oster layoutPtr->map->MapSector(raidPtr,
645 1.3 oster sosAddr + stripeOffset * layoutPtr->sectorsPerStripeUnit,
646 1.3 oster &trow, &tcol, &diskOffset, 0);
647 1.3 oster RF_ASSERT((trow == testrow) && (tcol == diskids[i]));
648 1.3 oster if (!rf_CheckRUReconstructed(raidPtr->reconControl[testrow]->reconMap, diskOffset))
649 1.3 oster return (1);
650 1.3 oster asmap->flags |= RF_ASM_REDIR_LARGE_WRITE;
651 1.3 oster return (0);
652 1.3 oster }
653 1.3 oster stripeOffset++;
654 1.3 oster }
655 1.3 oster }
656 1.3 oster return (0);
657 1.1 oster }
658 1.1 oster /*
659 1.1 oster return the number of failed data units in the stripe.
660 1.1 oster */
661 1.1 oster
662 1.3 oster int
663 1.3 oster rf_NumFailedDataUnitsInStripe(raidPtr, asmap)
664 1.3 oster RF_Raid_t *raidPtr;
665 1.3 oster RF_AccessStripeMap_t *asmap;
666 1.3 oster {
667 1.3 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
668 1.3 oster RF_RowCol_t trow, tcol, row, i;
669 1.3 oster RF_SectorNum_t diskOffset;
670 1.3 oster RF_RaidAddr_t sosAddr;
671 1.3 oster int numFailures;
672 1.3 oster
673 1.3 oster /* quick out in the fault-free case. */
674 1.3 oster RF_LOCK_MUTEX(raidPtr->mutex);
675 1.3 oster numFailures = raidPtr->numFailures;
676 1.3 oster RF_UNLOCK_MUTEX(raidPtr->mutex);
677 1.3 oster if (numFailures == 0)
678 1.3 oster return (0);
679 1.3 oster numFailures = 0;
680 1.3 oster
681 1.3 oster sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
682 1.3 oster row = asmap->physInfo->row;
683 1.3 oster for (i = 0; i < layoutPtr->numDataCol; i++) {
684 1.3 oster (layoutPtr->map->MapSector) (raidPtr, sosAddr + i * layoutPtr->sectorsPerStripeUnit,
685 1.3 oster &trow, &tcol, &diskOffset, 0);
686 1.3 oster if (RF_DEAD_DISK(raidPtr->Disks[trow][tcol].status))
687 1.3 oster numFailures++;
688 1.3 oster }
689 1.1 oster
690 1.3 oster return numFailures;
691 1.1 oster }
692 1.1 oster
693 1.1 oster
694 1.1 oster /*****************************************************************************************
695 1.1 oster *
696 1.1 oster * debug routines
697 1.1 oster *
698 1.1 oster ****************************************************************************************/
699 1.1 oster
700 1.3 oster void
701 1.3 oster rf_PrintAccessStripeMap(asm_h)
702 1.3 oster RF_AccessStripeMapHeader_t *asm_h;
703 1.1 oster {
704 1.3 oster rf_PrintFullAccessStripeMap(asm_h, 0);
705 1.1 oster }
706 1.1 oster
707 1.3 oster void
708 1.3 oster rf_PrintFullAccessStripeMap(asm_h, prbuf)
709 1.3 oster RF_AccessStripeMapHeader_t *asm_h;
710 1.3 oster int prbuf; /* flag to print buffer pointers */
711 1.3 oster {
712 1.3 oster int i;
713 1.3 oster RF_AccessStripeMap_t *asmap = asm_h->stripeMap;
714 1.3 oster RF_PhysDiskAddr_t *p;
715 1.3 oster printf("%d stripes total\n", (int) asm_h->numStripes);
716 1.3 oster for (; asmap; asmap = asmap->next) {
717 1.3 oster /* printf("Num failures: %d\n",asmap->numDataFailed); */
718 1.3 oster /* printf("Num sectors:
719 1.3 oster * %d\n",(int)asmap->totalSectorsAccessed); */
720 1.3 oster printf("Stripe %d (%d sectors), failures: %d data, %d parity: ",
721 1.3 oster (int) asmap->stripeID,
722 1.3 oster (int) asmap->totalSectorsAccessed,
723 1.3 oster (int) asmap->numDataFailed,
724 1.3 oster (int) asmap->numParityFailed);
725 1.3 oster if (asmap->parityInfo) {
726 1.3 oster printf("Parity [r%d c%d s%d-%d", asmap->parityInfo->row, asmap->parityInfo->col,
727 1.3 oster (int) asmap->parityInfo->startSector,
728 1.3 oster (int) (asmap->parityInfo->startSector +
729 1.3 oster asmap->parityInfo->numSector - 1));
730 1.3 oster if (prbuf)
731 1.3 oster printf(" b0x%lx", (unsigned long) asmap->parityInfo->bufPtr);
732 1.3 oster if (asmap->parityInfo->next) {
733 1.3 oster printf(", r%d c%d s%d-%d", asmap->parityInfo->next->row,
734 1.3 oster asmap->parityInfo->next->col,
735 1.3 oster (int) asmap->parityInfo->next->startSector,
736 1.3 oster (int) (asmap->parityInfo->next->startSector +
737 1.3 oster asmap->parityInfo->next->numSector - 1));
738 1.3 oster if (prbuf)
739 1.3 oster printf(" b0x%lx", (unsigned long) asmap->parityInfo->next->bufPtr);
740 1.3 oster RF_ASSERT(asmap->parityInfo->next->next == NULL);
741 1.3 oster }
742 1.3 oster printf("]\n\t");
743 1.3 oster }
744 1.3 oster for (i = 0, p = asmap->physInfo; p; p = p->next, i++) {
745 1.3 oster printf("SU r%d c%d s%d-%d ", p->row, p->col, (int) p->startSector,
746 1.3 oster (int) (p->startSector + p->numSector - 1));
747 1.3 oster if (prbuf)
748 1.3 oster printf("b0x%lx ", (unsigned long) p->bufPtr);
749 1.3 oster if (i && !(i & 1))
750 1.3 oster printf("\n\t");
751 1.3 oster }
752 1.3 oster printf("\n");
753 1.3 oster p = asm_h->stripeMap->failedPDAs[0];
754 1.3 oster if (asm_h->stripeMap->numDataFailed + asm_h->stripeMap->numParityFailed > 1)
755 1.3 oster printf("[multiple failures]\n");
756 1.3 oster else
757 1.3 oster if (asm_h->stripeMap->numDataFailed + asm_h->stripeMap->numParityFailed > 0)
758 1.3 oster printf("\t[Failed PDA: r%d c%d s%d-%d]\n", p->row, p->col,
759 1.3 oster (int) p->startSector, (int) (p->startSector + p->numSector - 1));
760 1.3 oster }
761 1.1 oster }
762 1.1 oster
763 1.3 oster void
764 1.3 oster rf_PrintRaidAddressInfo(raidPtr, raidAddr, numBlocks)
765 1.3 oster RF_Raid_t *raidPtr;
766 1.3 oster RF_RaidAddr_t raidAddr;
767 1.3 oster RF_SectorCount_t numBlocks;
768 1.3 oster {
769 1.3 oster RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
770 1.3 oster RF_RaidAddr_t ra, sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
771 1.3 oster
772 1.3 oster printf("Raid addrs of SU boundaries from start of stripe to end of access:\n\t");
773 1.3 oster for (ra = sosAddr; ra <= raidAddr + numBlocks; ra += layoutPtr->sectorsPerStripeUnit) {
774 1.3 oster printf("%d (0x%x), ", (int) ra, (int) ra);
775 1.3 oster }
776 1.3 oster printf("\n");
777 1.3 oster printf("Offset into stripe unit: %d (0x%x)\n",
778 1.3 oster (int) (raidAddr % layoutPtr->sectorsPerStripeUnit),
779 1.3 oster (int) (raidAddr % layoutPtr->sectorsPerStripeUnit));
780 1.3 oster }
781 1.1 oster /*
782 1.1 oster given a parity descriptor and the starting address within a stripe,
783 1.1 oster range restrict the parity descriptor to touch only the correct stuff.
784 1.1 oster */
785 1.3 oster void
786 1.3 oster rf_ASMParityAdjust(
787 1.3 oster RF_PhysDiskAddr_t * toAdjust,
788 1.3 oster RF_StripeNum_t startAddrWithinStripe,
789 1.3 oster RF_SectorNum_t endAddress,
790 1.3 oster RF_RaidLayout_t * layoutPtr,
791 1.3 oster RF_AccessStripeMap_t * asm_p)
792 1.3 oster {
793 1.3 oster RF_PhysDiskAddr_t *new_pda;
794 1.3 oster
795 1.3 oster /* when we're accessing only a portion of one stripe unit, we want the
796 1.3 oster * parity descriptor to identify only the chunk of parity associated
797 1.3 oster * with the data. When the access spans exactly one stripe unit
798 1.3 oster * boundary and is less than a stripe unit in size, it uses two
799 1.3 oster * disjoint regions of the parity unit. When an access spans more
800 1.3 oster * than one stripe unit boundary, it uses all of the parity unit.
801 1.3 oster *
802 1.3 oster * To better handle the case where stripe units are small, we may
803 1.3 oster * eventually want to change the 2nd case so that if the SU size is
804 1.3 oster * below some threshold, we just read/write the whole thing instead of
805 1.3 oster * breaking it up into two accesses. */
806 1.3 oster if (asm_p->numStripeUnitsAccessed == 1) {
807 1.3 oster int x = (startAddrWithinStripe % layoutPtr->sectorsPerStripeUnit);
808 1.3 oster toAdjust->startSector += x;
809 1.3 oster toAdjust->raidAddress += x;
810 1.3 oster toAdjust->numSector = asm_p->physInfo->numSector;
811 1.3 oster RF_ASSERT(toAdjust->numSector != 0);
812 1.3 oster } else
813 1.3 oster if (asm_p->numStripeUnitsAccessed == 2 && asm_p->totalSectorsAccessed < layoutPtr->sectorsPerStripeUnit) {
814 1.3 oster int x = (startAddrWithinStripe % layoutPtr->sectorsPerStripeUnit);
815 1.3 oster
816 1.3 oster /* create a second pda and copy the parity map info
817 1.3 oster * into it */
818 1.3 oster RF_ASSERT(toAdjust->next == NULL);
819 1.3 oster new_pda = toAdjust->next = rf_AllocPhysDiskAddr();
820 1.3 oster *new_pda = *toAdjust; /* structure assignment */
821 1.3 oster new_pda->next = NULL;
822 1.3 oster
823 1.3 oster /* adjust the start sector & number of blocks for the
824 1.3 oster * first parity pda */
825 1.3 oster toAdjust->startSector += x;
826 1.3 oster toAdjust->raidAddress += x;
827 1.3 oster toAdjust->numSector = rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, startAddrWithinStripe) - startAddrWithinStripe;
828 1.3 oster RF_ASSERT(toAdjust->numSector != 0);
829 1.3 oster
830 1.3 oster /* adjust the second pda */
831 1.3 oster new_pda->numSector = endAddress - rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, endAddress);
832 1.3 oster /* new_pda->raidAddress =
833 1.3 oster * rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr,
834 1.3 oster * toAdjust->raidAddress); */
835 1.3 oster RF_ASSERT(new_pda->numSector != 0);
836 1.3 oster }
837 1.1 oster }
838 1.1 oster /*
839 1.1 oster Check if a disk has been spared or failed. If spared,
840 1.3 oster redirect the I/O.
841 1.1 oster If it has been failed, record it in the asm pointer.
842 1.1 oster Fourth arg is whether data or parity.
843 1.1 oster */
844 1.3 oster void
845 1.3 oster rf_ASMCheckStatus(
846 1.3 oster RF_Raid_t * raidPtr,
847 1.3 oster RF_PhysDiskAddr_t * pda_p,
848 1.3 oster RF_AccessStripeMap_t * asm_p,
849 1.3 oster RF_RaidDisk_t ** disks,
850 1.3 oster int parity)
851 1.3 oster {
852 1.3 oster RF_DiskStatus_t dstatus;
853 1.3 oster RF_RowCol_t frow, fcol;
854 1.3 oster
855 1.3 oster dstatus = disks[pda_p->row][pda_p->col].status;
856 1.3 oster
857 1.3 oster if (dstatus == rf_ds_spared) {
858 1.3 oster /* if the disk has been spared, redirect access to the spare */
859 1.3 oster frow = pda_p->row;
860 1.3 oster fcol = pda_p->col;
861 1.3 oster pda_p->row = disks[frow][fcol].spareRow;
862 1.3 oster pda_p->col = disks[frow][fcol].spareCol;
863 1.3 oster } else
864 1.3 oster if (dstatus == rf_ds_dist_spared) {
865 1.3 oster /* ditto if disk has been spared to dist spare space */
866 1.3 oster RF_RowCol_t or = pda_p->row, oc = pda_p->col;
867 1.3 oster RF_SectorNum_t oo = pda_p->startSector;
868 1.3 oster
869 1.3 oster if (pda_p->type == RF_PDA_TYPE_DATA)
870 1.3 oster raidPtr->Layout.map->MapSector(raidPtr, pda_p->raidAddress, &pda_p->row, &pda_p->col, &pda_p->startSector, RF_REMAP);
871 1.3 oster else
872 1.3 oster raidPtr->Layout.map->MapParity(raidPtr, pda_p->raidAddress, &pda_p->row, &pda_p->col, &pda_p->startSector, RF_REMAP);
873 1.3 oster
874 1.3 oster if (rf_mapDebug) {
875 1.3 oster printf("Redirected r %d c %d o %d -> r%d c %d o %d\n", or, oc, (int) oo,
876 1.3 oster pda_p->row, pda_p->col, (int) pda_p->startSector);
877 1.3 oster }
878 1.3 oster } else
879 1.3 oster if (RF_DEAD_DISK(dstatus)) {
880 1.3 oster /* if the disk is inaccessible, mark the
881 1.3 oster * failure */
882 1.3 oster if (parity)
883 1.3 oster asm_p->numParityFailed++;
884 1.3 oster else {
885 1.3 oster asm_p->numDataFailed++;
886 1.3 oster }
887 1.3 oster asm_p->failedPDAs[asm_p->numFailedPDAs] = pda_p;
888 1.3 oster asm_p->numFailedPDAs++;
889 1.1 oster #if 0
890 1.3 oster switch (asm_p->numParityFailed + asm_p->numDataFailed) {
891 1.3 oster case 1:
892 1.3 oster asm_p->failedPDAs[0] = pda_p;
893 1.3 oster break;
894 1.3 oster case 2:
895 1.3 oster asm_p->failedPDAs[1] = pda_p;
896 1.3 oster default:
897 1.3 oster break;
898 1.3 oster }
899 1.1 oster #endif
900 1.3 oster }
901 1.3 oster /* the redirected access should never span a stripe unit boundary */
902 1.3 oster RF_ASSERT(rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress) ==
903 1.3 oster rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress + pda_p->numSector - 1));
904 1.3 oster RF_ASSERT(pda_p->col != -1);
905 1.1 oster }
906