Annotation of sys/dev/raidframe/rf_raid1.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rf_raid1.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $ */
2: /* $NetBSD: rf_raid1.c,v 1.5 2000/01/08 22:57:30 oster Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: William V. Courtright II
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_raid1.c -- Implements RAID Level 1.
34: *
35: *****************************************************************************/
36:
37: #include "rf_raid.h"
38: #include "rf_raid1.h"
39: #include "rf_dag.h"
40: #include "rf_dagffrd.h"
41: #include "rf_dagffwr.h"
42: #include "rf_dagdegrd.h"
43: #include "rf_dagutils.h"
44: #include "rf_dagfuncs.h"
45: #include "rf_diskqueue.h"
46: #include "rf_general.h"
47: #include "rf_utils.h"
48: #include "rf_parityscan.h"
49: #include "rf_mcpair.h"
50: #include "rf_layout.h"
51: #include "rf_map.h"
52: #include "rf_engine.h"
53: #include "rf_reconbuffer.h"
54:
55: typedef struct RF_Raid1ConfigInfo_s {
56: RF_RowCol_t **stripeIdentifier;
57: } RF_Raid1ConfigInfo_t;
58:
59:
60: /* Start of day code specific to RAID level 1. */
61: int
62: rf_ConfigureRAID1(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
63: RF_Config_t *cfgPtr)
64: {
65: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
66: RF_Raid1ConfigInfo_t *info;
67: RF_RowCol_t i;
68:
69: /* Create a RAID level 1 configuration structure. */
70: RF_MallocAndAdd(info, sizeof(RF_Raid1ConfigInfo_t),
71: (RF_Raid1ConfigInfo_t *), raidPtr->cleanupList);
72: if (info == NULL)
73: return (ENOMEM);
74: layoutPtr->layoutSpecificInfo = (void *) info;
75:
76: /* ... and fill it in. */
77: info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2,
78: raidPtr->cleanupList);
79: if (info->stripeIdentifier == NULL)
80: return (ENOMEM);
81: for (i = 0; i < (raidPtr->numCol / 2); i++) {
82: info->stripeIdentifier[i][0] = (2 * i);
83: info->stripeIdentifier[i][1] = (2 * i) + 1;
84: }
85:
86: RF_ASSERT(raidPtr->numRow == 1);
87:
88: /*
89: * This implementation of RAID level 1 uses one row of numCol disks
90: * and allows multiple (numCol / 2) stripes per row. A stripe
91: * consists of a single data unit and a single parity (mirror) unit.
92: * Stripe id = raidAddr / stripeUnitSize.
93: */
94: raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
95: (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit;
96: layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk *
97: (raidPtr->numCol / 2);
98: layoutPtr->dataSectorsPerStripe = layoutPtr->sectorsPerStripeUnit;
99: layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
100: raidPtr->logBytesPerSector;
101: layoutPtr->numDataCol = 1;
102: layoutPtr->numParityCol = 1;
103: return (0);
104: }
105:
106:
107: /*
108: * Returns the physical disk location of the primary copy in the mirror pair.
109: */
110: void
111: rf_MapSectorRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
112: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
113: {
114: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
115: RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
116:
117: *row = 0;
118: *col = 2 * mirrorPair;
119: *diskSector = ((SUID / (raidPtr->numCol / 2)) *
120: raidPtr->Layout.sectorsPerStripeUnit) +
121: (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
122: }
123:
124:
125: /*
126: * Map Parity.
127: *
128: * Returns the physical disk location of the secondary copy in the mirror
129: * pair.
130: */
131: void
132: rf_MapParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
133: RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
134: {
135: RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
136: RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
137:
138: *row = 0;
139: *col = (2 * mirrorPair) + 1;
140:
141: *diskSector = ((SUID / (raidPtr->numCol / 2)) *
142: raidPtr->Layout.sectorsPerStripeUnit) +
143: (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
144: }
145:
146:
147: /*
148: * IdentifyStripeRAID1
149: *
150: * Returns a list of disks for a given redundancy group.
151: */
152: void
153: rf_IdentifyStripeRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
154: RF_RowCol_t **diskids, RF_RowCol_t *outRow)
155: {
156: RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
157: addr);
158: RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
159: RF_ASSERT(stripeID >= 0);
160: RF_ASSERT(addr >= 0);
161: *outRow = 0;
162: *diskids = info->stripeIdentifier[stripeID % (raidPtr->numCol / 2)];
163: RF_ASSERT(*diskids);
164: }
165:
166:
167: /*
168: * MapSIDToPSIDRAID1
169: *
170: * Maps a logical stripe to a stripe in the redundant array.
171: */
172: void
173: rf_MapSIDToPSIDRAID1(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
174: RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
175: {
176: *which_ru = 0;
177: *psID = stripeID;
178: }
179:
180:
181:
182: /*****************************************************************************
183: * Select a graph to perform a single-stripe access.
184: *
185: * Parameters: raidPtr - Description of the physical array.
186: * type - Type of operation (read or write) requested.
187: * asmap - Logical & physical addresses for this access.
188: * createFunc - Name of function to use to create the graph.
189: *****************************************************************************/
190:
191: void
192: rf_RAID1DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
193: RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
194: {
195: RF_RowCol_t frow, fcol, or, oc;
196: RF_PhysDiskAddr_t *failedPDA;
197: int prior_recon;
198: RF_RowStatus_t rstat;
199: RF_SectorNum_t oo;
200:
201:
202: RF_ASSERT(RF_IO_IS_R_OR_W(type));
203:
204: if (asmap->numDataFailed + asmap->numParityFailed > 1) {
205: RF_ERRORMSG("Multiple disks failed in a single group !"
206: " Aborting I/O operation.\n");
207: *createFunc = NULL;
208: return;
209: }
210: if (asmap->numDataFailed + asmap->numParityFailed) {
211: /*
212: * We've got a fault. Re-map to spare space, iff applicable.
213: * Shouldn't the arch-independent code do this for us ?
214: * Anyway, it turns out if we don't do this here, then when
215: * we're reconstructing, writes go only to the surviving
216: * original disk, and aren't reflected on the reconstructed
217: * spare. Oops. --jimz
218: */
219: failedPDA = asmap->failedPDAs[0];
220: frow = failedPDA->row;
221: fcol = failedPDA->col;
222: rstat = raidPtr->status[frow];
223: prior_recon = (rstat == rf_rs_reconfigured) || (
224: (rstat == rf_rs_reconstructing) ?
225: rf_CheckRUReconstructed(raidPtr->reconControl[frow]
226: ->reconMap, failedPDA->startSector) : 0);
227: if (prior_recon) {
228: or = frow;
229: oc = fcol;
230: oo = failedPDA->startSector;
231: /*
232: * If we did distributed sparing, we'd monkey with
233: * that here.
234: * But we don't, so we'll.
235: */
236: failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
237: failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
238: /*
239: * Redirect other components, iff necessary. This looks
240: * pretty suspicious to me, but it's what the raid5
241: * DAG select does.
242: */
243: if (asmap->parityInfo->next) {
244: if (failedPDA == asmap->parityInfo) {
245: failedPDA->next->row = failedPDA->row;
246: failedPDA->next->col = failedPDA->col;
247: } else {
248: if (failedPDA ==
249: asmap->parityInfo->next) {
250: asmap->parityInfo->row =
251: failedPDA->row;
252: asmap->parityInfo->col =
253: failedPDA->col;
254: }
255: }
256: }
257: if (rf_dagDebug || rf_mapDebug) {
258: printf("raid%d: Redirected type '%c' r %d c %d"
259: " o %ld -> r %d c %d o %ld.\n",
260: raidPtr->raidid, type, or, oc, (long) oo,
261: failedPDA->row, failedPDA->col,
262: (long) failedPDA->startSector);
263: }
264: asmap->numDataFailed = asmap->numParityFailed = 0;
265: }
266: }
267: if (type == RF_IO_TYPE_READ) {
268: if (asmap->numDataFailed == 0)
269: *createFunc = (RF_VoidFuncPtr)
270: rf_CreateMirrorIdleReadDAG;
271: else
272: *createFunc = (RF_VoidFuncPtr)
273: rf_CreateRaidOneDegradedReadDAG;
274: } else {
275: *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
276: }
277: }
278:
279: int
280: rf_VerifyParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
281: RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
282: {
283: int nbytes, bcount, stripeWidth, ret, i, j, nbad, *bbufs;
284: RF_DagNode_t *blockNode, *unblockNode, *wrBlock;
285: RF_DagHeader_t *rd_dag_h, *wr_dag_h;
286: RF_AccessStripeMapHeader_t *asm_h;
287: RF_AllocListElem_t *allocList;
288: RF_AccTraceEntry_t tracerec;
289: RF_ReconUnitNum_t which_ru;
290: RF_RaidLayout_t *layoutPtr;
291: RF_AccessStripeMap_t *aasm;
292: RF_SectorCount_t nsector;
293: RF_RaidAddr_t startAddr;
294: char *buf, *buf1, *buf2;
295: RF_PhysDiskAddr_t *pda;
296: RF_StripeNum_t psID;
297: RF_MCPair_t *mcpair;
298:
299: layoutPtr = &raidPtr->Layout;
300: startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
301: nsector = parityPDA->numSector;
302: nbytes = rf_RaidAddressToByte(raidPtr, nsector);
303: psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
304:
305: asm_h = NULL;
306: rd_dag_h = wr_dag_h = NULL;
307: mcpair = NULL;
308:
309: ret = RF_PARITY_COULD_NOT_VERIFY;
310:
311: rf_MakeAllocList(allocList);
312: if (allocList == NULL)
313: return (RF_PARITY_COULD_NOT_VERIFY);
314: mcpair = rf_AllocMCPair();
315: if (mcpair == NULL)
316: goto done;
317: RF_ASSERT(layoutPtr->numDataCol == layoutPtr->numParityCol);
318: stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
319: bcount = nbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol);
320: RF_MallocAndAdd(buf, bcount, (char *), allocList);
321: if (buf == NULL)
322: goto done;
323: if (rf_verifyParityDebug) {
324: printf("raid%d: RAID1 parity verify: buf=%lx bcount=%d"
325: " (%lx - %lx).\n", raidPtr->raidid, (long) buf, bcount,
326: (long) buf, (long) buf + bcount);
327: }
328: /*
329: * Generate a DAG that will read the entire stripe- then we can
330: * just compare data chunks versus "parity" chunks.
331: */
332:
333: rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, nbytes, buf,
334: rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rod", allocList, flags,
335: RF_IO_NORMAL_PRIORITY);
336: if (rd_dag_h == NULL)
337: goto done;
338: blockNode = rd_dag_h->succedents[0];
339: unblockNode = blockNode->succedents[0]->succedents[0];
340:
341: /*
342: * Map the access to physical disk addresses (PDAs)- this will
343: * get us both a list of data addresses, and "parity" addresses
344: * (which are really mirror copies).
345: */
346: asm_h = rf_MapAccess(raidPtr, startAddr,
347: layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
348: aasm = asm_h->stripeMap;
349:
350: buf1 = buf;
351: /*
352: * Loop through the data blocks, setting up read nodes for each.
353: */
354: for (pda = aasm->physInfo, i = 0; i < layoutPtr->numDataCol;
355: i++, pda = pda->next) {
356: RF_ASSERT(pda);
357:
358: rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
359:
360: RF_ASSERT(pda->numSector != 0);
361: if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
362: /* cannot verify parity with dead disk */
363: goto done;
364: }
365: pda->bufPtr = buf1;
366: blockNode->succedents[i]->params[0].p = pda;
367: blockNode->succedents[i]->params[1].p = buf1;
368: blockNode->succedents[i]->params[2].v = psID;
369: blockNode->succedents[i]->params[3].v =
370: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
371: buf1 += nbytes;
372: }
373: RF_ASSERT(pda == NULL);
374: /*
375: * Keep i, buf1 running.
376: *
377: * Loop through parity blocks, setting up read nodes for each.
378: */
379: for (pda = aasm->parityInfo; i < layoutPtr->numDataCol +
380: layoutPtr->numParityCol; i++, pda = pda->next) {
381: RF_ASSERT(pda);
382: rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
383: RF_ASSERT(pda->numSector != 0);
384: if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
385: /* Cannot verify parity with dead disk. */
386: goto done;
387: }
388: pda->bufPtr = buf1;
389: blockNode->succedents[i]->params[0].p = pda;
390: blockNode->succedents[i]->params[1].p = buf1;
391: blockNode->succedents[i]->params[2].v = psID;
392: blockNode->succedents[i]->params[3].v =
393: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
394: buf1 += nbytes;
395: }
396: RF_ASSERT(pda == NULL);
397:
398: bzero((char *) &tracerec, sizeof(tracerec));
399: rd_dag_h->tracerec = &tracerec;
400:
401: if (rf_verifyParityDebug > 1) {
402: printf("raid%d: RAID1 parity verify read dag:\n",
403: raidPtr->raidid);
404: rf_PrintDAGList(rd_dag_h);
405: }
406: RF_LOCK_MUTEX(mcpair->mutex);
407: mcpair->flag = 0;
408: rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
409: (void *) mcpair);
410: while (mcpair->flag == 0) {
411: RF_WAIT_MCPAIR(mcpair);
412: }
413: RF_UNLOCK_MUTEX(mcpair->mutex);
414:
415: if (rd_dag_h->status != rf_enable) {
416: RF_ERRORMSG("Unable to verify raid1 parity:"
417: " can't read stripe.\n");
418: ret = RF_PARITY_COULD_NOT_VERIFY;
419: goto done;
420: }
421: /*
422: * buf1 is the beginning of the data blocks chunk.
423: * buf2 is the beginning of the parity blocks chunk.
424: */
425: buf1 = buf;
426: buf2 = buf + (nbytes * layoutPtr->numDataCol);
427: ret = RF_PARITY_OKAY;
428: /*
429: * bbufs is "bad bufs"- an array whose entries are the data
430: * column numbers where we had miscompares. (That is, column 0
431: * and column 1 of the array are mirror copies, and are considered
432: * "data column 0" for this purpose).
433: */
434: RF_MallocAndAdd(bbufs, layoutPtr->numParityCol * sizeof(int), (int *),
435: allocList);
436: nbad = 0;
437: /*
438: * Check data vs "parity" (mirror copy).
439: */
440: for (i = 0; i < layoutPtr->numDataCol; i++) {
441: if (rf_verifyParityDebug) {
442: printf("raid%d: RAID1 parity verify %d bytes: i=%d"
443: " buf1=%lx buf2=%lx buf=%lx.\n", raidPtr->raidid,
444: nbytes, i, (long) buf1, (long) buf2, (long) buf);
445: }
446: ret = bcmp(buf1, buf2, nbytes);
447: if (ret) {
448: if (rf_verifyParityDebug > 1) {
449: for (j = 0; j < nbytes; j++) {
450: if (buf1[j] != buf2[j])
451: break;
452: }
453: printf("psid=%ld j=%d\n", (long) psID, j);
454: printf("buf1 %02x %02x %02x %02x %02x\n",
455: buf1[0] & 0xff, buf1[1] & 0xff,
456: buf1[2] & 0xff, buf1[3] & 0xff,
457: buf1[4] & 0xff);
458: printf("buf2 %02x %02x %02x %02x %02x\n",
459: buf2[0] & 0xff, buf2[1] & 0xff,
460: buf2[2] & 0xff, buf2[3] & 0xff,
461: buf2[4] & 0xff);
462: }
463: if (rf_verifyParityDebug) {
464: printf("raid%d: RAID1: found bad parity,"
465: " i=%d.\n", raidPtr->raidid, i);
466: }
467: /*
468: * Parity is bad. Keep track of which columns were bad.
469: */
470: if (bbufs)
471: bbufs[nbad] = i;
472: nbad++;
473: ret = RF_PARITY_BAD;
474: }
475: buf1 += nbytes;
476: buf2 += nbytes;
477: }
478:
479: if ((ret != RF_PARITY_OKAY) && correct_it) {
480: ret = RF_PARITY_COULD_NOT_CORRECT;
481: if (rf_verifyParityDebug) {
482: printf("raid%d: RAID1 parity verify:"
483: " parity not correct.\n", raidPtr->raidid);
484: }
485: if (bbufs == NULL)
486: goto done;
487: /*
488: * Make a DAG with one write node for each bad unit. We'll
489: * simply write the contents of the data unit onto the parity
490: * unit for correction. (It's possible that the mirror copy
491: * was the correct copy, and that we're spooging good data by
492: * writing bad over it, but there's no way we can know that.
493: */
494: wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, buf,
495: rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", allocList,
496: flags, RF_IO_NORMAL_PRIORITY);
497: if (wr_dag_h == NULL)
498: goto done;
499: wrBlock = wr_dag_h->succedents[0];
500: /*
501: * Fill in a write node for each bad compare.
502: */
503: for (i = 0; i < nbad; i++) {
504: j = i + layoutPtr->numDataCol;
505: pda = blockNode->succedents[j]->params[0].p;
506: pda->bufPtr = blockNode->succedents[i]->params[1].p;
507: wrBlock->succedents[i]->params[0].p = pda;
508: wrBlock->succedents[i]->params[1].p = pda->bufPtr;
509: wrBlock->succedents[i]->params[2].v = psID;
510: wrBlock->succedents[0]->params[3].v =
511: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
512: which_ru);
513: }
514: bzero((char *) &tracerec, sizeof(tracerec));
515: wr_dag_h->tracerec = &tracerec;
516: if (rf_verifyParityDebug > 1) {
517: printf("Parity verify write dag:\n");
518: rf_PrintDAGList(wr_dag_h);
519: }
520: RF_LOCK_MUTEX(mcpair->mutex);
521: mcpair->flag = 0;
522: /* Fire off the write DAG. */
523: rf_DispatchDAG(wr_dag_h, (void (*) (void *))
524: rf_MCPairWakeupFunc, (void *) mcpair);
525: while (!mcpair->flag) {
526: RF_WAIT_COND(mcpair->cond, mcpair->mutex);
527: }
528: RF_UNLOCK_MUTEX(mcpair->mutex);
529: if (wr_dag_h->status != rf_enable) {
530: RF_ERRORMSG("Unable to correct RAID1 parity in"
531: " VerifyParity.\n");
532: goto done;
533: }
534: ret = RF_PARITY_CORRECTED;
535: }
536: done:
537: /*
538: * All done. We might've gotten here without doing part of the function,
539: * so cleanup what we have to and return our running status.
540: */
541: if (asm_h)
542: rf_FreeAccessStripeMap(asm_h);
543: if (rd_dag_h)
544: rf_FreeDAG(rd_dag_h);
545: if (wr_dag_h)
546: rf_FreeDAG(wr_dag_h);
547: if (mcpair)
548: rf_FreeMCPair(mcpair);
549: rf_FreeAllocList(allocList);
550: if (rf_verifyParityDebug) {
551: printf("raid%d: RAID1 parity verify, returning %d.\n",
552: raidPtr->raidid, ret);
553: }
554: return (ret);
555: }
556:
557: int
558: rf_SubmitReconBufferRAID1(
559: RF_ReconBuffer_t *rbuf, /* The recon buffer to submit. */
560: int keep_it, /*
561: * Whether we can keep this buffer
562: * or we have to return it ?
563: */
564: int use_committed /*
565: * Whether to use a committed or
566: * an available recon buffer ?
567: */
568: )
569: {
570: RF_ReconParityStripeStatus_t *pssPtr;
571: RF_ReconCtrl_t *reconCtrlPtr;
572: RF_RaidLayout_t *layoutPtr;
573: int retcode, created;
574: RF_CallbackDesc_t *cb, *p;
575: RF_ReconBuffer_t *t;
576: RF_Raid_t *raidPtr;
577: caddr_t ta;
578:
579: retcode = 0;
580: created = 0;
581:
582: raidPtr = rbuf->raidPtr;
583: layoutPtr = &raidPtr->Layout;
584: reconCtrlPtr = raidPtr->reconControl[rbuf->row];
585:
586: RF_ASSERT(rbuf);
587: RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
588:
589: if (rf_reconbufferDebug) {
590: printf("raid%d: RAID1 reconbuffer submission r%d c%d psid %ld"
591: " ru%d (failed offset %ld).\n", raidPtr->raidid, rbuf->row,
592: rbuf->col, (long) rbuf->parityStripeID, rbuf->which_ru,
593: (long) rbuf->failedDiskSectorOffset);
594: }
595: if (rf_reconDebug) {
596: printf("RAID1 reconbuffer submit psid %ld buf %lx\n",
597: (long) rbuf->parityStripeID, (long) rbuf->buffer);
598: printf("RAID1 psid %ld %02x %02x %02x %02x %02x\n",
599: (long) rbuf->parityStripeID,
600: rbuf->buffer[0], rbuf->buffer[1], rbuf->buffer[2],
601: rbuf->buffer[3], rbuf->buffer[4]);
602: }
603: RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
604:
605: RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
606:
607: pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
608: rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
609: RF_ASSERT(pssPtr); /*
610: * If it didn't exist, we wouldn't have gotten
611: * an rbuf for it.
612: */
613:
614: /*
615: * Since this is simple mirroring, the first submission for a stripe
616: * is also treated as the last.
617: */
618:
619: t = NULL;
620: if (keep_it) {
621: if (rf_reconbufferDebug) {
622: printf("raid%d: RAID1 rbuf submission: keeping rbuf.\n",
623: raidPtr->raidid);
624: }
625: t = rbuf;
626: } else {
627: if (use_committed) {
628: if (rf_reconbufferDebug) {
629: printf("raid%d: RAID1 rbuf submission:"
630: " using committed rbuf.\n",
631: raidPtr->raidid);
632: }
633: t = reconCtrlPtr->committedRbufs;
634: RF_ASSERT(t);
635: reconCtrlPtr->committedRbufs = t->next;
636: t->next = NULL;
637: } else
638: if (reconCtrlPtr->floatingRbufs) {
639: if (rf_reconbufferDebug) {
640: printf("raid%d: RAID1 rbuf submission:"
641: " using floating rbuf.\n",
642: raidPtr->raidid);
643: }
644: t = reconCtrlPtr->floatingRbufs;
645: reconCtrlPtr->floatingRbufs = t->next;
646: t->next = NULL;
647: }
648: }
649: if (t == NULL) {
650: if (rf_reconbufferDebug) {
651: printf("raid%d: RAID1 rbuf submission:"
652: " waiting for rbuf.\n", raidPtr->raidid);
653: }
654: RF_ASSERT((keep_it == 0) && (use_committed == 0));
655: raidPtr->procsInBufWait++;
656: if ((raidPtr->procsInBufWait == (raidPtr->numCol - 1))
657: && (raidPtr->numFullReconBuffers == 0)) {
658: /* ruh-ro */
659: RF_ERRORMSG("Buffer wait deadlock.\n");
660: rf_PrintPSStatusTable(raidPtr, rbuf->row);
661: RF_PANIC();
662: }
663: pssPtr->flags |= RF_PSS_BUFFERWAIT;
664: cb = rf_AllocCallbackDesc();
665: cb->row = rbuf->row;
666: cb->col = rbuf->col;
667: cb->callbackArg.v = rbuf->parityStripeID;
668: cb->callbackArg2.v = rbuf->which_ru;
669: cb->next = NULL;
670: if (reconCtrlPtr->bufferWaitList == NULL) {
671: /* We are the wait list- lucky us. */
672: reconCtrlPtr->bufferWaitList = cb;
673: } else {
674: /* Append to wait list. */
675: for (p = reconCtrlPtr->bufferWaitList; p->next;
676: p = p->next);
677: p->next = cb;
678: }
679: retcode = 1;
680: goto out;
681: }
682: if (t != rbuf) {
683: t->row = rbuf->row;
684: t->col = reconCtrlPtr->fcol;
685: t->parityStripeID = rbuf->parityStripeID;
686: t->which_ru = rbuf->which_ru;
687: t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
688: t->spRow = rbuf->spRow;
689: t->spCol = rbuf->spCol;
690: t->spOffset = rbuf->spOffset;
691: /* Swap buffers. DANCE ! */
692: ta = t->buffer;
693: t->buffer = rbuf->buffer;
694: rbuf->buffer = ta;
695: }
696: /*
697: * Use the rbuf we've been given as the target.
698: */
699: RF_ASSERT(pssPtr->rbuf == NULL);
700: pssPtr->rbuf = t;
701:
702: t->count = 1;
703: /*
704: * Below, we use 1 for numDataCol (which is equal to the count in the
705: * previous line), so we'll always be done.
706: */
707: rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, 1);
708:
709: out:
710: RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
711: RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
712: if (rf_reconbufferDebug) {
713: printf("raid%d: RAID1 rbuf submission: returning %d.\n",
714: raidPtr->raidid, retcode);
715: }
716: return (retcode);
717: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_raid1.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe