Annotation of sys/dev/raidframe/rf_parityscan.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: rf_parityscan.c,v 1.7 2002/12/16 07:01:04 tdeval Exp $ */
! 2: /* $NetBSD: rf_parityscan.c,v 1.9 2000/05/28 03:00:31 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: Mark Holland
! 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_parityscan.c -- Misc utilities related to parity verification.
! 34: *
! 35: *****************************************************************************/
! 36:
! 37: #include "rf_types.h"
! 38: #include "rf_raid.h"
! 39: #include "rf_dag.h"
! 40: #include "rf_dagfuncs.h"
! 41: #include "rf_dagutils.h"
! 42: #include "rf_mcpair.h"
! 43: #include "rf_general.h"
! 44: #include "rf_engine.h"
! 45: #include "rf_parityscan.h"
! 46: #include "rf_map.h"
! 47:
! 48:
! 49: /*****************************************************************************
! 50: *
! 51: * Walk through the entire arry and write new parity.
! 52: * This works by creating two DAGs, one to read a stripe of data and one to
! 53: * write new parity. The first is executed, the data is xored together, and
! 54: * then the second is executed. To avoid constantly building and tearing down
! 55: * the DAGs, we create them a priori and fill them in with the mapping
! 56: * information as we go along.
! 57: *
! 58: * There should never be more than one thread running this.
! 59: *
! 60: *****************************************************************************/
! 61: int
! 62: rf_RewriteParity(RF_Raid_t *raidPtr)
! 63: {
! 64: RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
! 65: RF_AccessStripeMapHeader_t *asm_h;
! 66: int ret_val;
! 67: int rc;
! 68: RF_PhysDiskAddr_t pda;
! 69: RF_SectorNum_t i;
! 70:
! 71: if (raidPtr->Layout.map->faultsTolerated == 0) {
! 72: /* There isn't any parity. Call it "okay." */
! 73: return (RF_PARITY_OKAY);
! 74: }
! 75: if (raidPtr->status[0] != rf_rs_optimal) {
! 76: /*
! 77: * We're in degraded mode. Don't try to verify parity now !
! 78: * XXX: This should be a "we don't want to", not a
! 79: * "we can't" error.
! 80: */
! 81: return (RF_PARITY_COULD_NOT_VERIFY);
! 82: }
! 83:
! 84: ret_val = 0;
! 85:
! 86: pda.startSector = 0;
! 87: pda.numSector = raidPtr->Layout.sectorsPerStripeUnit;
! 88: rc = RF_PARITY_OKAY;
! 89:
! 90: for (i = 0; i < raidPtr->totalSectors && rc <= RF_PARITY_CORRECTED;
! 91: i += layoutPtr->dataSectorsPerStripe) {
! 92: if (raidPtr->waitShutdown) {
! 93: /*
! 94: * Someone is pulling the plug on this set...
! 95: * Abort the re-write.
! 96: */
! 97: return (1);
! 98: }
! 99: asm_h = rf_MapAccess(raidPtr, i,
! 100: layoutPtr->dataSectorsPerStripe, NULL, RF_DONT_REMAP);
! 101: raidPtr->parity_rewrite_stripes_done =
! 102: i / layoutPtr->dataSectorsPerStripe ;
! 103: rc = rf_VerifyParity(raidPtr, asm_h->stripeMap, 1, 0);
! 104: switch (rc) {
! 105: case RF_PARITY_OKAY:
! 106: case RF_PARITY_CORRECTED:
! 107: break;
! 108: case RF_PARITY_BAD:
! 109: printf("Parity bad during correction.\n");
! 110: ret_val = 1;
! 111: break;
! 112: case RF_PARITY_COULD_NOT_CORRECT:
! 113: printf("Could not correct bad parity.\n");
! 114: ret_val = 1;
! 115: break;
! 116: case RF_PARITY_COULD_NOT_VERIFY:
! 117: printf("Could not verify parity.\n");
! 118: ret_val = 1;
! 119: break;
! 120: default:
! 121: printf("Bad rc=%d from VerifyParity in"
! 122: " RewriteParity.\n", rc);
! 123: ret_val = 1;
! 124: }
! 125: rf_FreeAccessStripeMap(asm_h);
! 126: }
! 127: return (ret_val);
! 128: }
! 129:
! 130:
! 131: /*****************************************************************************
! 132: *
! 133: * Verify that the parity in a particular stripe is correct.
! 134: * We validate only the range of parity defined by parityPDA, since
! 135: * this is all we have locked. The way we do this is to create an asm
! 136: * that maps the whole stripe and then range-restrict it to the parity
! 137: * region defined by the parityPDA.
! 138: *
! 139: *****************************************************************************/
! 140: int
! 141: rf_VerifyParity(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *aasm, int correct_it,
! 142: RF_RaidAccessFlags_t flags)
! 143: {
! 144: RF_PhysDiskAddr_t *parityPDA;
! 145: RF_AccessStripeMap_t *doasm;
! 146: RF_LayoutSW_t *lp;
! 147: int lrc, rc;
! 148:
! 149: lp = raidPtr->Layout.map;
! 150: if (lp->faultsTolerated == 0) {
! 151: /*
! 152: * There isn't any parity. Call it "okay."
! 153: */
! 154: return (RF_PARITY_OKAY);
! 155: }
! 156: rc = RF_PARITY_OKAY;
! 157: if (lp->VerifyParity) {
! 158: for (doasm = aasm; doasm; doasm = doasm->next) {
! 159: for (parityPDA = doasm->parityInfo; parityPDA;
! 160: parityPDA = parityPDA->next) {
! 161: lrc = lp->VerifyParity(raidPtr,
! 162: doasm->raidAddress, parityPDA, correct_it,
! 163: flags);
! 164: if (lrc > rc) {
! 165: /*
! 166: * see rf_parityscan.h for why this
! 167: * works.
! 168: */
! 169: rc = lrc;
! 170: }
! 171: }
! 172: }
! 173: } else {
! 174: rc = RF_PARITY_COULD_NOT_VERIFY;
! 175: }
! 176: return (rc);
! 177: }
! 178:
! 179: int
! 180: rf_VerifyParityBasic(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
! 181: RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
! 182: {
! 183: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
! 184: RF_RaidAddr_t startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
! 185: raidAddr);
! 186: RF_SectorCount_t numsector = parityPDA->numSector;
! 187: int numbytes = rf_RaidAddressToByte(raidPtr, numsector);
! 188: int bytesPerStripe = numbytes * layoutPtr->numDataCol;
! 189: RF_DagHeader_t *rd_dag_h, *wr_dag_h; /* Read, write dag. */
! 190: RF_DagNode_t *blockNode, *unblockNode, *wrBlock, *wrUnblock;
! 191: RF_AccessStripeMapHeader_t *asm_h;
! 192: RF_AccessStripeMap_t *asmap;
! 193: RF_AllocListElem_t *alloclist;
! 194: RF_PhysDiskAddr_t *pda;
! 195: char *pbuf, *buf, *end_p, *p;
! 196: int i, retcode;
! 197: RF_ReconUnitNum_t which_ru;
! 198: RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr,
! 199: raidAddr, &which_ru);
! 200: int stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
! 201: RF_AccTraceEntry_t tracerec;
! 202: RF_MCPair_t *mcpair;
! 203:
! 204: retcode = RF_PARITY_OKAY;
! 205:
! 206: mcpair = rf_AllocMCPair();
! 207: rf_MakeAllocList(alloclist);
! 208: RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol +
! 209: layoutPtr->numParityCol), (char *), alloclist);
! 210: /* Use calloc to make sure buffer is zeroed. */
! 211: RF_CallocAndAdd(pbuf, 1, numbytes, (char *), alloclist);
! 212: end_p = buf + bytesPerStripe;
! 213:
! 214: rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf,
! 215: rf_DiskReadFunc, rf_DiskReadUndoFunc,
! 216: "Rod", alloclist, flags, RF_IO_NORMAL_PRIORITY);
! 217: blockNode = rd_dag_h->succedents[0];
! 218: unblockNode = blockNode->succedents[0]->succedents[0];
! 219:
! 220: /* Map the stripe and fill in the PDAs in the dag. */
! 221: asm_h = rf_MapAccess(raidPtr, startAddr,
! 222: layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
! 223: asmap = asm_h->stripeMap;
! 224:
! 225: for (pda = asmap->physInfo, i = 0; i < layoutPtr->numDataCol;
! 226: i++, pda = pda->next) {
! 227: RF_ASSERT(pda);
! 228: rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
! 229: RF_ASSERT(pda->numSector != 0);
! 230: if (rf_TryToRedirectPDA(raidPtr, pda, 0))
! 231: goto out; /*
! 232: * No way to verify parity if disk is
! 233: * dead. Return w/ good status.
! 234: */
! 235: blockNode->succedents[i]->params[0].p = pda;
! 236: blockNode->succedents[i]->params[2].v = psID;
! 237: blockNode->succedents[i]->params[3].v =
! 238: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
! 239: }
! 240:
! 241: RF_ASSERT(!asmap->parityInfo->next);
! 242: rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
! 243: RF_ASSERT(asmap->parityInfo->numSector != 0);
! 244: if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
! 245: goto out;
! 246: blockNode->succedents[layoutPtr->numDataCol]->params[0].p =
! 247: asmap->parityInfo;
! 248:
! 249: /* Fire off the DAG. */
! 250: bzero((char *) &tracerec, sizeof(tracerec));
! 251: rd_dag_h->tracerec = &tracerec;
! 252:
! 253: if (rf_verifyParityDebug) {
! 254: printf("Parity verify read dag:\n");
! 255: rf_PrintDAGList(rd_dag_h);
! 256: }
! 257: RF_LOCK_MUTEX(mcpair->mutex);
! 258: mcpair->flag = 0;
! 259: rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
! 260: (void *) mcpair);
! 261: while (!mcpair->flag)
! 262: RF_WAIT_COND(mcpair->cond, mcpair->mutex);
! 263: RF_UNLOCK_MUTEX(mcpair->mutex);
! 264: if (rd_dag_h->status != rf_enable) {
! 265: RF_ERRORMSG("Unable to verify parity: can't read the"
! 266: " stripe.\n");
! 267: retcode = RF_PARITY_COULD_NOT_VERIFY;
! 268: goto out;
! 269: }
! 270: for (p = buf; p < end_p; p += numbytes) {
! 271: rf_bxor(p, pbuf, numbytes, NULL);
! 272: }
! 273: for (i = 0; i < numbytes; i++) {
! 274: #if 0
! 275: if (pbuf[i] != 0 || buf[bytesPerStripe + i] != 0) {
! 276: printf("Bytes: %d %d %d\n", i, pbuf[i],
! 277: buf[bytesPerStripe + i]);
! 278: }
! 279: #endif
! 280: if (pbuf[i] != buf[bytesPerStripe + i]) {
! 281: if (!correct_it)
! 282: RF_ERRORMSG3("Parity verify error: byte %d of"
! 283: " parity is 0x%x should be 0x%x.\n", i,
! 284: (u_char) buf[bytesPerStripe + i],
! 285: (u_char) pbuf[i]);
! 286: retcode = RF_PARITY_BAD;
! 287: break;
! 288: }
! 289: }
! 290:
! 291: if (retcode && correct_it) {
! 292: wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf,
! 293: rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
! 294: "Wnp", alloclist, flags, RF_IO_NORMAL_PRIORITY);
! 295: wrBlock = wr_dag_h->succedents[0];
! 296: wrUnblock = wrBlock->succedents[0]->succedents[0];
! 297: wrBlock->succedents[0]->params[0].p = asmap->parityInfo;
! 298: wrBlock->succedents[0]->params[2].v = psID;
! 299: wrBlock->succedents[0]->params[3].v =
! 300: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
! 301: bzero((char *) &tracerec, sizeof(tracerec));
! 302: wr_dag_h->tracerec = &tracerec;
! 303: if (rf_verifyParityDebug) {
! 304: printf("Parity verify write dag:\n");
! 305: rf_PrintDAGList(wr_dag_h);
! 306: }
! 307: RF_LOCK_MUTEX(mcpair->mutex);
! 308: mcpair->flag = 0;
! 309: rf_DispatchDAG(wr_dag_h, (void (*) (void *))
! 310: rf_MCPairWakeupFunc, (void *) mcpair);
! 311: while (!mcpair->flag)
! 312: RF_WAIT_COND(mcpair->cond, mcpair->mutex);
! 313: RF_UNLOCK_MUTEX(mcpair->mutex);
! 314: if (wr_dag_h->status != rf_enable) {
! 315: RF_ERRORMSG("Unable to correct parity in VerifyParity:"
! 316: " can't write the stripe.\n");
! 317: retcode = RF_PARITY_COULD_NOT_CORRECT;
! 318: }
! 319: rf_FreeDAG(wr_dag_h);
! 320: if (retcode == RF_PARITY_BAD)
! 321: retcode = RF_PARITY_CORRECTED;
! 322: }
! 323: out:
! 324: rf_FreeAccessStripeMap(asm_h);
! 325: rf_FreeAllocList(alloclist);
! 326: rf_FreeDAG(rd_dag_h);
! 327: rf_FreeMCPair(mcpair);
! 328: return (retcode);
! 329: }
! 330:
! 331: int
! 332: rf_TryToRedirectPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, int parity)
! 333: {
! 334: if (raidPtr->Disks[pda->row][pda->col].status == rf_ds_reconstructing) {
! 335: if (rf_CheckRUReconstructed(raidPtr->reconControl[pda->row]
! 336: ->reconMap, pda->startSector)) {
! 337: if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
! 338: RF_RowCol_t or = pda->row, oc = pda->col;
! 339: RF_SectorNum_t os = pda->startSector;
! 340: if (parity) {
! 341: (raidPtr->Layout.map->MapParity)
! 342: (raidPtr, pda->raidAddress,
! 343: &pda->row, &pda->col,
! 344: &pda->startSector, RF_REMAP);
! 345: if (rf_verifyParityDebug)
! 346: printf("VerifyParity: Redir P"
! 347: " r %d c %d sect %ld ->"
! 348: " r %d c %d sect %ld.\n",
! 349: or, oc, (long) os,
! 350: pda->row, pda->col,
! 351: (long) pda->startSector);
! 352: } else {
! 353: (raidPtr->Layout.map->MapSector)
! 354: (raidPtr, pda->raidAddress,
! 355: &pda->row, &pda->col,
! 356: &pda->startSector, RF_REMAP);
! 357: if (rf_verifyParityDebug)
! 358: printf("VerifyParity: Redir D"
! 359: " r %d c %d sect %ld ->"
! 360: " r %d c %d sect %ld.\n",
! 361: or, oc, (long) os,
! 362: pda->row, pda->col,
! 363: (long) pda->startSector);
! 364: }
! 365: } else {
! 366: RF_RowCol_t spRow =
! 367: raidPtr->Disks[pda->row][pda->col].spareRow;
! 368: RF_RowCol_t spCol =
! 369: raidPtr->Disks[pda->row][pda->col].spareCol;
! 370: pda->row = spRow;
! 371: pda->col = spCol;
! 372: }
! 373: }
! 374: }
! 375: if (RF_DEAD_DISK(raidPtr->Disks[pda->row][pda->col].status))
! 376: return (1);
! 377: return (0);
! 378: }
! 379:
! 380:
! 381: /*****************************************************************************
! 382: *
! 383: * Currently a stub.
! 384: *
! 385: * Takes as input an ASM describing a write operation and containing one
! 386: * failure, and verifies that the parity was correctly updated to reflect the
! 387: * write.
! 388: *
! 389: * If it's a data unit that has failed, we read the other data units in the
! 390: * stripe and the parity unit, XOR them together, and verify that we get the
! 391: * data intended for the failed disk. Since it's easy, we also validate that
! 392: * the right data got written to the surviving data disks.
! 393: *
! 394: * If it's the parity that failed, there's really no validation we can do
! 395: * except the above verification that the right data got written to all disks.
! 396: * This is because the new data intended for the failed disk is supplied in
! 397: * the ASM, but this is of course not the case for the new parity.
! 398: *
! 399: *****************************************************************************/
! 400: int
! 401: rf_VerifyDegrModeWrite(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asmh)
! 402: {
! 403: return (0);
! 404: }
! 405:
! 406:
! 407: /*
! 408: * Creates a simple DAG with a header, a block-recon node at level 1,
! 409: * nNodes nodes at level 2, an unblock-recon node at level 3, and
! 410: * a terminator node at level 4. The stripe address field in
! 411: * the block and unblock nodes are not touched, nor are the pda
! 412: * fields in the second-level nodes, so they must be filled in later.
! 413: *
! 414: * Commit point is established at unblock node - this means that any
! 415: * failure during dag execution causes the dag to fail.
! 416: */
! 417: RF_DagHeader_t *
! 418: rf_MakeSimpleDAG(RF_Raid_t *raidPtr, int nNodes, int bytesPerSU, char *databuf,
! 419: int (*doFunc) (RF_DagNode_t * node), int (*undoFunc) (RF_DagNode_t * node),
! 420: char *name /* Node names at the second level. */,
! 421: RF_AllocListElem_t *alloclist, RF_RaidAccessFlags_t flags, int priority)
! 422: {
! 423: RF_DagHeader_t *dag_h;
! 424: RF_DagNode_t *nodes, *termNode, *blockNode, *unblockNode;
! 425: int i;
! 426:
! 427: /*
! 428: * Create the nodes, the block & unblock nodes, and the terminator
! 429: * node.
! 430: */
! 431: RF_CallocAndAdd(nodes, nNodes + 3, sizeof(RF_DagNode_t),
! 432: (RF_DagNode_t *), alloclist);
! 433: blockNode = &nodes[nNodes];
! 434: unblockNode = blockNode + 1;
! 435: termNode = unblockNode + 1;
! 436:
! 437: dag_h = rf_AllocDAGHeader();
! 438: dag_h->raidPtr = (void *) raidPtr;
! 439: dag_h->allocList = NULL; /* We won't use this alloc list. */
! 440: dag_h->status = rf_enable;
! 441: dag_h->numSuccedents = 1;
! 442: dag_h->creator = "SimpleDAG";
! 443:
! 444: /*
! 445: * This dag can not commit until the unblock node is reached.
! 446: * Errors prior to the commit point imply the dag has failed.
! 447: */
! 448: dag_h->numCommitNodes = 1;
! 449: dag_h->numCommits = 0;
! 450:
! 451: dag_h->succedents[0] = blockNode;
! 452: rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
! 453: rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h,
! 454: "Nil", alloclist);
! 455: rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
! 456: rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h,
! 457: "Nil", alloclist);
! 458: unblockNode->succedents[0] = termNode;
! 459: for (i = 0; i < nNodes; i++) {
! 460: blockNode->succedents[i] = unblockNode->antecedents[i]
! 461: = &nodes[i];
! 462: unblockNode->antType[i] = rf_control;
! 463: rf_InitNode(&nodes[i], rf_wait, RF_FALSE, doFunc, undoFunc,
! 464: rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, alloclist);
! 465: nodes[i].succedents[0] = unblockNode;
! 466: nodes[i].antecedents[0] = blockNode;
! 467: nodes[i].antType[0] = rf_control;
! 468: nodes[i].params[1].p = (databuf + (i * bytesPerSU));
! 469: }
! 470: rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
! 471: rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", alloclist);
! 472: termNode->antecedents[0] = unblockNode;
! 473: termNode->antType[0] = rf_control;
! 474: return (dag_h);
! 475: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_parityscan.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe