Annotation of sys/dev/raidframe/rf_dagdegrd.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: rf_dagdegrd.c,v 1.6 2006/07/09 22:10:05 mk Exp $ */
! 2: /* $NetBSD: rf_dagdegrd.c,v 1.5 2000/01/07 03:40:57 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: Mark Holland, Daniel Stodolsky, 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: * rf_dagdegrd.c
! 33: *
! 34: * Code for creating degraded read DAGs.
! 35: */
! 36:
! 37: #include "rf_types.h"
! 38: #include "rf_raid.h"
! 39: #include "rf_dag.h"
! 40: #include "rf_dagutils.h"
! 41: #include "rf_dagfuncs.h"
! 42: #include "rf_debugMem.h"
! 43: #include "rf_memchunk.h"
! 44: #include "rf_general.h"
! 45: #include "rf_dagdegrd.h"
! 46:
! 47:
! 48: /*****************************************************************************
! 49: *
! 50: * General comments on DAG creation:
! 51: *
! 52: * All DAGs in this file use roll-away error recovery. Each DAG has a single
! 53: * commit node, usually called "Cmt". If an error occurs before the Cmt node
! 54: * is reached, the execution engine will halt forward execution and work
! 55: * backward through the graph, executing the undo functions. Assuming that
! 56: * each node in the graph prior to the Cmt node are undoable and atomic - or -
! 57: * does not make changes to permanent state, the graph will fail atomically.
! 58: * If an error occurs after the Cmt node executes, the engine will roll-forward
! 59: * through the graph, blindly executing nodes until it reaches the end.
! 60: * If a graph reaches the end, it is assumed to have completed successfully.
! 61: *
! 62: * A graph has only 1 Cmt node.
! 63: *
! 64: *****************************************************************************/
! 65:
! 66:
! 67: /*****************************************************************************
! 68: *
! 69: * The following wrappers map the standard DAG creation interface to the
! 70: * DAG creation routines. Additionally, these wrappers enable experimentation
! 71: * with new DAG structures by providing an extra level of indirection, allowing
! 72: * the DAG creation routines to be replaced at this single point.
! 73: *
! 74: *****************************************************************************/
! 75:
! 76: void
! 77: rf_CreateRaidFiveDegradedReadDAG(
! 78: RF_Raid_t *raidPtr,
! 79: RF_AccessStripeMap_t *asmap,
! 80: RF_DagHeader_t *dag_h,
! 81: void *bp,
! 82: RF_RaidAccessFlags_t flags,
! 83: RF_AllocListElem_t *allocList)
! 84: {
! 85: rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
! 86: &rf_xorRecoveryFuncs);
! 87: }
! 88:
! 89:
! 90: /*****************************************************************************
! 91: *
! 92: * DAG creation code begins here.
! 93: *
! 94: *****************************************************************************/
! 95:
! 96:
! 97: /*****************************************************************************
! 98: * Create a degraded read DAG for RAID level 1.
! 99: *
! 100: * Hdr -> Nil -> R(p/s)d -> Commit -> Trm
! 101: *
! 102: * The "Rd" node reads data from the surviving disk in the mirror pair.
! 103: * Rpd - read of primary copy
! 104: * Rsd - read of secondary copy
! 105: *
! 106: * Parameters: raidPtr - description of the physical array
! 107: * asmap - logical & physical addresses for this access
! 108: * bp - buffer ptr (for holding write data)
! 109: * flags - general flags (e.g. disk locking)
! 110: * allocList - list of memory allocated in DAG creation
! 111: *****************************************************************************/
! 112:
! 113: void
! 114: rf_CreateRaidOneDegradedReadDAG(
! 115: RF_Raid_t *raidPtr,
! 116: RF_AccessStripeMap_t *asmap,
! 117: RF_DagHeader_t *dag_h,
! 118: void *bp,
! 119: RF_RaidAccessFlags_t flags,
! 120: RF_AllocListElem_t *allocList)
! 121: {
! 122: RF_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
! 123: RF_StripeNum_t parityStripeID;
! 124: RF_ReconUnitNum_t which_ru;
! 125: RF_PhysDiskAddr_t *pda;
! 126: int useMirror, i;
! 127:
! 128: useMirror = 0;
! 129: parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
! 130: asmap->raidAddress, &which_ru);
! 131: if (rf_dagDebug) {
! 132: printf("[Creating RAID level 1 degraded read DAG]\n");
! 133: }
! 134: dag_h->creator = "RaidOneDegradedReadDAG";
! 135: /* Alloc the Wnd nodes and the Wmir node. */
! 136: if (asmap->numDataFailed == 0)
! 137: useMirror = RF_FALSE;
! 138: else
! 139: useMirror = RF_TRUE;
! 140:
! 141: /* Total number of nodes = 1 + (block + commit + terminator). */
! 142: RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *),
! 143: allocList);
! 144: i = 0;
! 145: rdNode = &nodes[i];
! 146: i++;
! 147: blockNode = &nodes[i];
! 148: i++;
! 149: commitNode = &nodes[i];
! 150: i++;
! 151: termNode = &nodes[i];
! 152: i++;
! 153:
! 154: /*
! 155: * This dag can not commit until the commit node is reached. Errors
! 156: * prior to the commit point imply the dag has failed and must be
! 157: * retried.
! 158: */
! 159: dag_h->numCommitNodes = 1;
! 160: dag_h->numCommits = 0;
! 161: dag_h->numSuccedents = 1;
! 162:
! 163: /* Initialize the block, commit, and terminator nodes. */
! 164: rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
! 165: rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
! 166: rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
! 167: rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
! 168: rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
! 169: rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
! 170:
! 171: pda = asmap->physInfo;
! 172: RF_ASSERT(pda != NULL);
! 173: /* parityInfo must describe entire parity unit. */
! 174: RF_ASSERT(asmap->parityInfo->next == NULL);
! 175:
! 176: /* Initialize the data node. */
! 177: if (!useMirror) {
! 178: /* Read primary copy of data. */
! 179: rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
! 180: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
! 181: dag_h, "Rpd", allocList);
! 182: rdNode->params[0].p = pda;
! 183: rdNode->params[1].p = pda->bufPtr;
! 184: rdNode->params[2].v = parityStripeID;
! 185: rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
! 186: 0, 0, which_ru);
! 187: } else {
! 188: /* Read secondary copy of data. */
! 189: rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
! 190: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
! 191: dag_h, "Rsd", allocList);
! 192: rdNode->params[0].p = asmap->parityInfo;
! 193: rdNode->params[1].p = pda->bufPtr;
! 194: rdNode->params[2].v = parityStripeID;
! 195: rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
! 196: 0, 0, which_ru);
! 197: }
! 198:
! 199: /* Connect header to block node. */
! 200: RF_ASSERT(dag_h->numSuccedents == 1);
! 201: RF_ASSERT(blockNode->numAntecedents == 0);
! 202: dag_h->succedents[0] = blockNode;
! 203:
! 204: /* Connect block node to rdnode. */
! 205: RF_ASSERT(blockNode->numSuccedents == 1);
! 206: RF_ASSERT(rdNode->numAntecedents == 1);
! 207: blockNode->succedents[0] = rdNode;
! 208: rdNode->antecedents[0] = blockNode;
! 209: rdNode->antType[0] = rf_control;
! 210:
! 211: /* Connect rdnode to commit node. */
! 212: RF_ASSERT(rdNode->numSuccedents == 1);
! 213: RF_ASSERT(commitNode->numAntecedents == 1);
! 214: rdNode->succedents[0] = commitNode;
! 215: commitNode->antecedents[0] = rdNode;
! 216: commitNode->antType[0] = rf_control;
! 217:
! 218: /* Connect commit node to terminator. */
! 219: RF_ASSERT(commitNode->numSuccedents == 1);
! 220: RF_ASSERT(termNode->numAntecedents == 1);
! 221: RF_ASSERT(termNode->numSuccedents == 0);
! 222: commitNode->succedents[0] = termNode;
! 223: termNode->antecedents[0] = commitNode;
! 224: termNode->antType[0] = rf_control;
! 225: }
! 226:
! 227:
! 228: /*****************************************************************************
! 229: *
! 230: * Create a DAG to perform a degraded-mode read of data within one stripe.
! 231: * This DAG is as follows:
! 232: *
! 233: * Hdr -> Block -> Rud -> Xor -> Cmt -> T
! 234: * -> Rrd ->
! 235: * -> Rp -->
! 236: *
! 237: * Each R node is a successor of the L node.
! 238: * One successor arc from each R node goes to C, and the other to X.
! 239: * There is one Rud for each chunk of surviving user data requested by the
! 240: * user, and one Rrd for each chunk of surviving user data _not_ being read by
! 241: * the user.
! 242: * R = read, ud = user data, rd = recovery (surviving) data, p = parity
! 243: * X = XOR, C = Commit, T = terminate
! 244: *
! 245: * The block node guarantees a single source node.
! 246: *
! 247: * Note: The target buffer for the XOR node is set to the actual user buffer
! 248: * where the failed data is supposed to end up. This buffer is zero'd by the
! 249: * code here. Thus, if you create a degraded read dag, use it, and then
! 250: * re-use, you have to be sure to zero the target buffer prior to the re-use.
! 251: *
! 252: * The recfunc argument at the end specifies the name and function used for
! 253: * the redundancy recovery function.
! 254: *
! 255: *****************************************************************************/
! 256:
! 257: void
! 258: rf_CreateDegradedReadDAG(
! 259: RF_Raid_t *raidPtr,
! 260: RF_AccessStripeMap_t *asmap,
! 261: RF_DagHeader_t *dag_h,
! 262: void *bp,
! 263: RF_RaidAccessFlags_t flags,
! 264: RF_AllocListElem_t *allocList,
! 265: RF_RedFuncs_t *recFunc)
! 266: {
! 267: RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *xorNode, *blockNode;
! 268: RF_DagNode_t *commitNode, *rpNode, *termNode;
! 269: int nNodes, nRrdNodes, nRudNodes, nXorBufs, i;
! 270: int j, paramNum;
! 271: RF_SectorCount_t sectorsPerSU;
! 272: RF_ReconUnitNum_t which_ru;
! 273: char *overlappingPDAs; /* A temporary array of flags. */
! 274: RF_AccessStripeMapHeader_t *new_asm_h[2];
! 275: RF_PhysDiskAddr_t *pda, *parityPDA;
! 276: RF_StripeNum_t parityStripeID;
! 277: RF_PhysDiskAddr_t *failedPDA;
! 278: RF_RaidLayout_t *layoutPtr;
! 279: char *rpBuf;
! 280:
! 281: layoutPtr = &(raidPtr->Layout);
! 282: /*
! 283: * failedPDA points to the pda within the asm that targets
! 284: * the failed disk.
! 285: */
! 286: failedPDA = asmap->failedPDAs[0];
! 287: parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr,
! 288: asmap->raidAddress, &which_ru);
! 289: sectorsPerSU = layoutPtr->sectorsPerStripeUnit;
! 290:
! 291: if (rf_dagDebug) {
! 292: printf("[Creating degraded read DAG]\n");
! 293: }
! 294: RF_ASSERT(asmap->numDataFailed == 1);
! 295: dag_h->creator = "DegradedReadDAG";
! 296:
! 297: /*
! 298: * Generate two ASMs identifying the surviving data we need
! 299: * in order to recover the lost data.
! 300: */
! 301:
! 302: /* overlappingPDAs array must be zero'd. */
! 303: RF_Calloc(overlappingPDAs, asmap->numStripeUnitsAccessed,
! 304: sizeof(char), (char *));
! 305: rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h,
! 306: new_asm_h, &nXorBufs, &rpBuf, overlappingPDAs, allocList);
! 307:
! 308: /*
! 309: * Create all the nodes at once.
! 310: *
! 311: * -1 because no access is generated for the failed pda.
! 312: */
! 313: nRudNodes = asmap->numStripeUnitsAccessed - 1;
! 314: nRrdNodes = ((new_asm_h[0]) ?
! 315: new_asm_h[0]->stripeMap->numStripeUnitsAccessed : 0) +
! 316: ((new_asm_h[1]) ?
! 317: new_asm_h[1]->stripeMap->numStripeUnitsAccessed : 0);
! 318: nNodes = 5 + nRudNodes + nRrdNodes; /*
! 319: * lock, unlock, xor, Rp,
! 320: * Rud, Rrd
! 321: */
! 322: RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
! 323: allocList);
! 324: i = 0;
! 325: blockNode = &nodes[i];
! 326: i++;
! 327: commitNode = &nodes[i];
! 328: i++;
! 329: xorNode = &nodes[i];
! 330: i++;
! 331: rpNode = &nodes[i];
! 332: i++;
! 333: termNode = &nodes[i];
! 334: i++;
! 335: rudNodes = &nodes[i];
! 336: i += nRudNodes;
! 337: rrdNodes = &nodes[i];
! 338: i += nRrdNodes;
! 339: RF_ASSERT(i == nNodes);
! 340:
! 341: /* Initialize nodes. */
! 342: dag_h->numCommitNodes = 1;
! 343: dag_h->numCommits = 0;
! 344: /*
! 345: * This dag can not commit until the commit node is reached.
! 346: * Errors prior to the commit point imply the dag has failed.
! 347: */
! 348: dag_h->numSuccedents = 1;
! 349:
! 350: rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
! 351: rf_NullNodeUndoFunc, NULL, nRudNodes + nRrdNodes + 1, 0, 0, 0,
! 352: dag_h, "Nil", allocList);
! 353: rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
! 354: rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
! 355: rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
! 356: rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
! 357: rf_InitNode(xorNode, rf_wait, RF_FALSE, recFunc->simple,
! 358: rf_NullNodeUndoFunc, NULL, 1, nRudNodes + nRrdNodes + 1,
! 359: 2 * nXorBufs + 2, 1, dag_h, recFunc->SimpleName, allocList);
! 360:
! 361: /* Fill in the Rud nodes. */
! 362: for (pda = asmap->physInfo, i = 0; i < nRudNodes;
! 363: i++, pda = pda->next) {
! 364: if (pda == failedPDA) {
! 365: i--;
! 366: continue;
! 367: }
! 368: rf_InitNode(&rudNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc,
! 369: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
! 370: dag_h, "Rud", allocList);
! 371: RF_ASSERT(pda);
! 372: rudNodes[i].params[0].p = pda;
! 373: rudNodes[i].params[1].p = pda->bufPtr;
! 374: rudNodes[i].params[2].v = parityStripeID;
! 375: rudNodes[i].params[3].v =
! 376: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
! 377: }
! 378:
! 379: /* Fill in the Rrd nodes. */
! 380: i = 0;
! 381: if (new_asm_h[0]) {
! 382: for (pda = new_asm_h[0]->stripeMap->physInfo;
! 383: i < new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
! 384: i++, pda = pda->next) {
! 385: rf_InitNode(&rrdNodes[i], rf_wait, RF_FALSE,
! 386: rf_DiskReadFunc, rf_DiskReadUndoFunc,
! 387: rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
! 388: "Rrd", allocList);
! 389: RF_ASSERT(pda);
! 390: rrdNodes[i].params[0].p = pda;
! 391: rrdNodes[i].params[1].p = pda->bufPtr;
! 392: rrdNodes[i].params[2].v = parityStripeID;
! 393: rrdNodes[i].params[3].v =
! 394: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
! 395: which_ru);
! 396: }
! 397: }
! 398: if (new_asm_h[1]) {
! 399: for (j = 0, pda = new_asm_h[1]->stripeMap->physInfo;
! 400: j < new_asm_h[1]->stripeMap->numStripeUnitsAccessed;
! 401: j++, pda = pda->next) {
! 402: rf_InitNode(&rrdNodes[i + j], rf_wait, RF_FALSE,
! 403: rf_DiskReadFunc, rf_DiskReadUndoFunc,
! 404: rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
! 405: "Rrd", allocList);
! 406: RF_ASSERT(pda);
! 407: rrdNodes[i + j].params[0].p = pda;
! 408: rrdNodes[i + j].params[1].p = pda->bufPtr;
! 409: rrdNodes[i + j].params[2].v = parityStripeID;
! 410: rrdNodes[i + j].params[3].v =
! 411: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
! 412: which_ru);
! 413: }
! 414: }
! 415: /* Make a PDA for the parity unit. */
! 416: RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t),
! 417: (RF_PhysDiskAddr_t *), allocList);
! 418: parityPDA->row = asmap->parityInfo->row;
! 419: parityPDA->col = asmap->parityInfo->col;
! 420: parityPDA->startSector = ((asmap->parityInfo->startSector /
! 421: sectorsPerSU) * sectorsPerSU) +
! 422: (failedPDA->startSector % sectorsPerSU);
! 423: parityPDA->numSector = failedPDA->numSector;
! 424:
! 425: /* Initialize the Rp node. */
! 426: rf_InitNode(rpNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
! 427: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
! 428: "Rp ", allocList);
! 429: rpNode->params[0].p = parityPDA;
! 430: rpNode->params[1].p = rpBuf;
! 431: rpNode->params[2].v = parityStripeID;
! 432: rpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
! 433: which_ru);
! 434:
! 435: /*
! 436: * The last and nastiest step is to assign all
! 437: * the parameters of the Xor node.
! 438: */
! 439: paramNum = 0;
! 440: for (i = 0; i < nRrdNodes; i++) {
! 441: /* All the Rrd nodes need to be xored together. */
! 442: xorNode->params[paramNum++] = rrdNodes[i].params[0];
! 443: xorNode->params[paramNum++] = rrdNodes[i].params[1];
! 444: }
! 445: for (i = 0; i < nRudNodes; i++) {
! 446: /* Any Rud nodes that overlap the failed access need to be
! 447: * xored in. */
! 448: if (overlappingPDAs[i]) {
! 449: RF_MallocAndAdd(pda, sizeof(RF_PhysDiskAddr_t),
! 450: (RF_PhysDiskAddr_t *), allocList);
! 451: bcopy((char *) rudNodes[i].params[0].p, (char *) pda,
! 452: sizeof(RF_PhysDiskAddr_t));
! 453: rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
! 454: RF_RESTRICT_DOBUFFER, 0);
! 455: xorNode->params[paramNum++].p = pda;
! 456: xorNode->params[paramNum++].p = pda->bufPtr;
! 457: }
! 458: }
! 459: RF_Free(overlappingPDAs, asmap->numStripeUnitsAccessed * sizeof(char));
! 460:
! 461: /* Install parity pda as last set of params to be xor'd. */
! 462: xorNode->params[paramNum++].p = parityPDA;
! 463: xorNode->params[paramNum++].p = rpBuf;
! 464:
! 465: /*
! 466: * The last 2 params to the recovery xor node are
! 467: * the failed PDA and the raidPtr.
! 468: */
! 469: xorNode->params[paramNum++].p = failedPDA;
! 470: xorNode->params[paramNum++].p = raidPtr;
! 471: RF_ASSERT(paramNum == 2 * nXorBufs + 2);
! 472:
! 473: /*
! 474: * The xor node uses results[0] as the target buffer.
! 475: * Set pointer and zero the buffer. In the kernel, this
! 476: * may be a user buffer in which case we have to remap it.
! 477: */
! 478: xorNode->results[0] = failedPDA->bufPtr;
! 479: RF_BZERO(bp, failedPDA->bufPtr, rf_RaidAddressToByte(raidPtr,
! 480: failedPDA->numSector));
! 481:
! 482: /* Connect nodes to form graph. */
! 483: /* Connect the header to the block node. */
! 484: RF_ASSERT(dag_h->numSuccedents == 1);
! 485: RF_ASSERT(blockNode->numAntecedents == 0);
! 486: dag_h->succedents[0] = blockNode;
! 487:
! 488: /* Connect the block node to the read nodes. */
! 489: RF_ASSERT(blockNode->numSuccedents == (1 + nRrdNodes + nRudNodes));
! 490: RF_ASSERT(rpNode->numAntecedents == 1);
! 491: blockNode->succedents[0] = rpNode;
! 492: rpNode->antecedents[0] = blockNode;
! 493: rpNode->antType[0] = rf_control;
! 494: for (i = 0; i < nRrdNodes; i++) {
! 495: RF_ASSERT(rrdNodes[i].numSuccedents == 1);
! 496: blockNode->succedents[1 + i] = &rrdNodes[i];
! 497: rrdNodes[i].antecedents[0] = blockNode;
! 498: rrdNodes[i].antType[0] = rf_control;
! 499: }
! 500: for (i = 0; i < nRudNodes; i++) {
! 501: RF_ASSERT(rudNodes[i].numSuccedents == 1);
! 502: blockNode->succedents[1 + nRrdNodes + i] = &rudNodes[i];
! 503: rudNodes[i].antecedents[0] = blockNode;
! 504: rudNodes[i].antType[0] = rf_control;
! 505: }
! 506:
! 507: /* Connect the read nodes to the xor node. */
! 508: RF_ASSERT(xorNode->numAntecedents == (1 + nRrdNodes + nRudNodes));
! 509: RF_ASSERT(rpNode->numSuccedents == 1);
! 510: rpNode->succedents[0] = xorNode;
! 511: xorNode->antecedents[0] = rpNode;
! 512: xorNode->antType[0] = rf_trueData;
! 513: for (i = 0; i < nRrdNodes; i++) {
! 514: RF_ASSERT(rrdNodes[i].numSuccedents == 1);
! 515: rrdNodes[i].succedents[0] = xorNode;
! 516: xorNode->antecedents[1 + i] = &rrdNodes[i];
! 517: xorNode->antType[1 + i] = rf_trueData;
! 518: }
! 519: for (i = 0; i < nRudNodes; i++) {
! 520: RF_ASSERT(rudNodes[i].numSuccedents == 1);
! 521: rudNodes[i].succedents[0] = xorNode;
! 522: xorNode->antecedents[1 + nRrdNodes + i] = &rudNodes[i];
! 523: xorNode->antType[1 + nRrdNodes + i] = rf_trueData;
! 524: }
! 525:
! 526: /* Connect the xor node to the commit node. */
! 527: RF_ASSERT(xorNode->numSuccedents == 1);
! 528: RF_ASSERT(commitNode->numAntecedents == 1);
! 529: xorNode->succedents[0] = commitNode;
! 530: commitNode->antecedents[0] = xorNode;
! 531: commitNode->antType[0] = rf_control;
! 532:
! 533: /* Connect the termNode to the commit node. */
! 534: RF_ASSERT(commitNode->numSuccedents == 1);
! 535: RF_ASSERT(termNode->numAntecedents == 1);
! 536: RF_ASSERT(termNode->numSuccedents == 0);
! 537: commitNode->succedents[0] = termNode;
! 538: termNode->antType[0] = rf_control;
! 539: termNode->antecedents[0] = commitNode;
! 540: }
! 541:
! 542:
! 543: /*****************************************************************************
! 544: * Create a degraded read DAG for Chained Declustering.
! 545: *
! 546: * Hdr -> Nil -> R(p/s)d -> Cmt -> Trm
! 547: *
! 548: * The "Rd" node reads data from the surviving disk in the mirror pair
! 549: * Rpd - read of primary copy
! 550: * Rsd - read of secondary copy
! 551: *
! 552: * Parameters: raidPtr - description of the physical array
! 553: * asmap - logical & physical addresses for this access
! 554: * bp - buffer ptr (for holding write data)
! 555: * flags - general flags (e.g. disk locking)
! 556: * allocList - list of memory allocated in DAG creation
! 557: *****************************************************************************/
! 558:
! 559: void
! 560: rf_CreateRaidCDegradedReadDAG(
! 561: RF_Raid_t *raidPtr,
! 562: RF_AccessStripeMap_t *asmap,
! 563: RF_DagHeader_t *dag_h,
! 564: void *bp,
! 565: RF_RaidAccessFlags_t flags,
! 566: RF_AllocListElem_t *allocList
! 567: )
! 568: {
! 569: RF_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
! 570: RF_StripeNum_t parityStripeID;
! 571: int useMirror, i, shiftable;
! 572: RF_ReconUnitNum_t which_ru;
! 573: RF_PhysDiskAddr_t *pda;
! 574:
! 575: if ((asmap->numDataFailed + asmap->numParityFailed) == 0) {
! 576: shiftable = RF_TRUE;
! 577: } else {
! 578: shiftable = RF_FALSE;
! 579: }
! 580: useMirror = 0;
! 581: parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
! 582: asmap->raidAddress, &which_ru);
! 583:
! 584: if (rf_dagDebug) {
! 585: printf("[Creating RAID C degraded read DAG]\n");
! 586: }
! 587: dag_h->creator = "RaidCDegradedReadDAG";
! 588: /* Alloc the Wnd nodes and the Wmir node. */
! 589: if (asmap->numDataFailed == 0)
! 590: useMirror = RF_FALSE;
! 591: else
! 592: useMirror = RF_TRUE;
! 593:
! 594: /* total number of nodes = 1 + (block + commit + terminator) */
! 595: RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *),
! 596: allocList);
! 597: i = 0;
! 598: rdNode = &nodes[i];
! 599: i++;
! 600: blockNode = &nodes[i];
! 601: i++;
! 602: commitNode = &nodes[i];
! 603: i++;
! 604: termNode = &nodes[i];
! 605: i++;
! 606:
! 607: /*
! 608: * This dag can not commit until the commit node is reached.
! 609: * Errors prior to the commit point imply the dag has failed
! 610: * and must be retried.
! 611: */
! 612: dag_h->numCommitNodes = 1;
! 613: dag_h->numCommits = 0;
! 614: dag_h->numSuccedents = 1;
! 615:
! 616: /* initialize the block, commit, and terminator nodes */
! 617: rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
! 618: rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
! 619: rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
! 620: rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
! 621: rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
! 622: rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
! 623:
! 624: pda = asmap->physInfo;
! 625: RF_ASSERT(pda != NULL);
! 626: /* ParityInfo must describe entire parity unit. */
! 627: RF_ASSERT(asmap->parityInfo->next == NULL);
! 628:
! 629: /* Initialize the data node. */
! 630: if (!useMirror) {
! 631: rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
! 632: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
! 633: dag_h, "Rpd", allocList);
! 634: if (shiftable && rf_compute_workload_shift(raidPtr, pda)) {
! 635: /* Shift this read to the next disk in line. */
! 636: rdNode->params[0].p = asmap->parityInfo;
! 637: rdNode->params[1].p = pda->bufPtr;
! 638: rdNode->params[2].v = parityStripeID;
! 639: rdNode->params[3].v = RF_CREATE_PARAM3(
! 640: RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
! 641: } else {
! 642: /* Read primary copy. */
! 643: rdNode->params[0].p = pda;
! 644: rdNode->params[1].p = pda->bufPtr;
! 645: rdNode->params[2].v = parityStripeID;
! 646: rdNode->params[3].v = RF_CREATE_PARAM3(
! 647: RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
! 648: }
! 649: } else {
! 650: /* Read secondary copy of data. */
! 651: rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
! 652: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
! 653: dag_h, "Rsd", allocList);
! 654: rdNode->params[0].p = asmap->parityInfo;
! 655: rdNode->params[1].p = pda->bufPtr;
! 656: rdNode->params[2].v = parityStripeID;
! 657: rdNode->params[3].v =
! 658: RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
! 659: }
! 660:
! 661: /* Connect header to block node. */
! 662: RF_ASSERT(dag_h->numSuccedents == 1);
! 663: RF_ASSERT(blockNode->numAntecedents == 0);
! 664: dag_h->succedents[0] = blockNode;
! 665:
! 666: /* Connect block node to rdnode. */
! 667: RF_ASSERT(blockNode->numSuccedents == 1);
! 668: RF_ASSERT(rdNode->numAntecedents == 1);
! 669: blockNode->succedents[0] = rdNode;
! 670: rdNode->antecedents[0] = blockNode;
! 671: rdNode->antType[0] = rf_control;
! 672:
! 673: /* Connect rdnode to commit node. */
! 674: RF_ASSERT(rdNode->numSuccedents == 1);
! 675: RF_ASSERT(commitNode->numAntecedents == 1);
! 676: rdNode->succedents[0] = commitNode;
! 677: commitNode->antecedents[0] = rdNode;
! 678: commitNode->antType[0] = rf_control;
! 679:
! 680: /* Connect commit node to terminator. */
! 681: RF_ASSERT(commitNode->numSuccedents == 1);
! 682: RF_ASSERT(termNode->numAntecedents == 1);
! 683: RF_ASSERT(termNode->numSuccedents == 0);
! 684: commitNode->succedents[0] = termNode;
! 685: termNode->antecedents[0] = commitNode;
! 686: termNode->antType[0] = rf_control;
! 687: }
! 688:
! 689: /*
! 690: * XXX move this elsewhere ?
! 691: */
! 692: void
! 693: rf_DD_GenerateFailedAccessASMs(
! 694: RF_Raid_t *raidPtr,
! 695: RF_AccessStripeMap_t *asmap,
! 696: RF_PhysDiskAddr_t **pdap,
! 697: int *nNodep,
! 698: RF_PhysDiskAddr_t **pqpdap,
! 699: int *nPQNodep,
! 700: RF_AllocListElem_t *allocList
! 701: )
! 702: {
! 703: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
! 704: int PDAPerDisk, i;
! 705: RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
! 706: int numDataCol = layoutPtr->numDataCol;
! 707: int state;
! 708: RF_SectorNum_t suoff, suend;
! 709: unsigned firstDataCol, napdas, count;
! 710: RF_SectorNum_t fone_start, fone_end, ftwo_start = 0, ftwo_end = 0;
! 711: RF_PhysDiskAddr_t *fone = asmap->failedPDAs[0];
! 712: RF_PhysDiskAddr_t *ftwo = asmap->failedPDAs[1];
! 713: RF_PhysDiskAddr_t *pda_p;
! 714: RF_PhysDiskAddr_t *phys_p;
! 715: RF_RaidAddr_t sosAddr;
! 716:
! 717: /*
! 718: * Determine how many pda's we will have to generate per unaccessed
! 719: * stripe. If there is only one failed data unit, it is one; if two,
! 720: * possibly two, depending whether they overlap.
! 721: */
! 722:
! 723: fone_start = rf_StripeUnitOffset(layoutPtr, fone->startSector);
! 724: fone_end = fone_start + fone->numSector;
! 725:
! 726: #define CONS_PDA(if,start,num) do { \
! 727: pda_p->row = asmap->if->row; \
! 728: pda_p->col = asmap->if->col; \
! 729: pda_p->startSector = ((asmap->if->startSector / secPerSU) * \
! 730: secPerSU) + start; \
! 731: pda_p->numSector = num; \
! 732: pda_p->next = NULL; \
! 733: RF_MallocAndAdd(pda_p->bufPtr, \
! 734: rf_RaidAddressToByte(raidPtr,num),(char *), allocList); \
! 735: } while (0)
! 736:
! 737: if (asmap->numDataFailed == 1) {
! 738: PDAPerDisk = 1;
! 739: state = 1;
! 740: RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t),
! 741: (RF_PhysDiskAddr_t *), allocList);
! 742: pda_p = *pqpdap;
! 743: /* Build p. */
! 744: CONS_PDA(parityInfo, fone_start, fone->numSector);
! 745: pda_p->type = RF_PDA_TYPE_PARITY;
! 746: pda_p++;
! 747: /* Build q. */
! 748: CONS_PDA(qInfo, fone_start, fone->numSector);
! 749: pda_p->type = RF_PDA_TYPE_Q;
! 750: } else {
! 751: ftwo_start = rf_StripeUnitOffset(layoutPtr, ftwo->startSector);
! 752: ftwo_end = ftwo_start + ftwo->numSector;
! 753: if (fone->numSector + ftwo->numSector > secPerSU) {
! 754: PDAPerDisk = 1;
! 755: state = 2;
! 756: RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t),
! 757: (RF_PhysDiskAddr_t *), allocList);
! 758: pda_p = *pqpdap;
! 759: CONS_PDA(parityInfo, 0, secPerSU);
! 760: pda_p->type = RF_PDA_TYPE_PARITY;
! 761: pda_p++;
! 762: CONS_PDA(qInfo, 0, secPerSU);
! 763: pda_p->type = RF_PDA_TYPE_Q;
! 764: } else {
! 765: PDAPerDisk = 2;
! 766: state = 3;
! 767: /* Four of them, fone, then ftwo. */
! 768: RF_MallocAndAdd(*pqpdap, 4 * sizeof(RF_PhysDiskAddr_t),
! 769: (RF_PhysDiskAddr_t *), allocList);
! 770: pda_p = *pqpdap;
! 771: CONS_PDA(parityInfo, fone_start, fone->numSector);
! 772: pda_p->type = RF_PDA_TYPE_PARITY;
! 773: pda_p++;
! 774: CONS_PDA(qInfo, fone_start, fone->numSector);
! 775: pda_p->type = RF_PDA_TYPE_Q;
! 776: pda_p++;
! 777: CONS_PDA(parityInfo, ftwo_start, ftwo->numSector);
! 778: pda_p->type = RF_PDA_TYPE_PARITY;
! 779: pda_p++;
! 780: CONS_PDA(qInfo, ftwo_start, ftwo->numSector);
! 781: pda_p->type = RF_PDA_TYPE_Q;
! 782: }
! 783: }
! 784: /* Figure out number of nonaccessed pda. */
! 785: napdas = PDAPerDisk * (numDataCol - asmap->numStripeUnitsAccessed -
! 786: (ftwo == NULL ? 1 : 0));
! 787: *nPQNodep = PDAPerDisk;
! 788:
! 789: /*
! 790: * Sweep over the over accessed pda's, figuring out the number of
! 791: * additional pda's to generate. Of course, skip the failed ones.
! 792: */
! 793:
! 794: count = 0;
! 795: for (pda_p = asmap->physInfo; pda_p; pda_p = pda_p->next) {
! 796: if ((pda_p == fone) || (pda_p == ftwo))
! 797: continue;
! 798: suoff = rf_StripeUnitOffset(layoutPtr, pda_p->startSector);
! 799: suend = suoff + pda_p->numSector;
! 800: switch (state) {
! 801: case 1: /* One failed PDA to overlap. */
! 802: /*
! 803: * If a PDA doesn't contain the failed unit, it can
! 804: * only miss the start or end, not both.
! 805: */
! 806: if ((suoff > fone_start) || (suend < fone_end))
! 807: count++;
! 808: break;
! 809: case 2: /* Whole stripe. */
! 810: if (suoff) /* Leak at begining. */
! 811: count++;
! 812: if (suend < numDataCol) /* Leak at end. */
! 813: count++;
! 814: break;
! 815: case 3: /* Two disjoint units. */
! 816: if ((suoff > fone_start) || (suend < fone_end))
! 817: count++;
! 818: if ((suoff > ftwo_start) || (suend < ftwo_end))
! 819: count++;
! 820: break;
! 821: default:
! 822: RF_PANIC();
! 823: }
! 824: }
! 825:
! 826: napdas += count;
! 827: *nNodep = napdas;
! 828: if (napdas == 0)
! 829: return; /* short circuit */
! 830:
! 831: /* Allocate up our list of pda's. */
! 832:
! 833: RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t),
! 834: (RF_PhysDiskAddr_t *), allocList);
! 835: *pdap = pda_p;
! 836:
! 837: /* Link them together. */
! 838: for (i = 0; i < (napdas - 1); i++)
! 839: pda_p[i].next = pda_p + (i + 1);
! 840:
! 841: /* March through the one's up to the first accessed disk. */
! 842: firstDataCol = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
! 843: asmap->physInfo->raidAddress) % numDataCol;
! 844: sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
! 845: asmap->raidAddress);
! 846: for (i = 0; i < firstDataCol; i++) {
! 847: if ((pda_p - (*pdap)) == napdas)
! 848: continue;
! 849: pda_p->type = RF_PDA_TYPE_DATA;
! 850: pda_p->raidAddress = sosAddr + (i * secPerSU);
! 851: (raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
! 852: &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
! 853: /* Skip over dead disks. */
! 854: if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
! 855: continue;
! 856: switch (state) {
! 857: case 1: /* Fone. */
! 858: pda_p->numSector = fone->numSector;
! 859: pda_p->raidAddress += fone_start;
! 860: pda_p->startSector += fone_start;
! 861: RF_MallocAndAdd(pda_p->bufPtr,
! 862: rf_RaidAddressToByte(raidPtr, pda_p->numSector),
! 863: (char *), allocList);
! 864: break;
! 865: case 2: /* Full stripe. */
! 866: pda_p->numSector = secPerSU;
! 867: RF_MallocAndAdd(pda_p->bufPtr,
! 868: rf_RaidAddressToByte(raidPtr, secPerSU),
! 869: (char *), allocList);
! 870: break;
! 871: case 3: /* Two slabs. */
! 872: pda_p->numSector = fone->numSector;
! 873: pda_p->raidAddress += fone_start;
! 874: pda_p->startSector += fone_start;
! 875: RF_MallocAndAdd(pda_p->bufPtr,
! 876: rf_RaidAddressToByte(raidPtr, pda_p->numSector),
! 877: (char *), allocList);
! 878: pda_p++;
! 879: pda_p->type = RF_PDA_TYPE_DATA;
! 880: pda_p->raidAddress = sosAddr + (i * secPerSU);
! 881: (raidPtr->Layout.map->MapSector) (raidPtr,
! 882: pda_p->raidAddress, &(pda_p->row), &(pda_p->col),
! 883: &(pda_p->startSector), 0);
! 884: pda_p->numSector = ftwo->numSector;
! 885: pda_p->raidAddress += ftwo_start;
! 886: pda_p->startSector += ftwo_start;
! 887: RF_MallocAndAdd(pda_p->bufPtr,
! 888: rf_RaidAddressToByte(raidPtr, pda_p->numSector),
! 889: (char *), allocList);
! 890: break;
! 891: default:
! 892: RF_PANIC();
! 893: }
! 894: pda_p++;
! 895: }
! 896:
! 897: /* March through the touched stripe units. */
! 898: for (phys_p = asmap->physInfo; phys_p; phys_p = phys_p->next, i++) {
! 899: if ((phys_p == asmap->failedPDAs[0]) ||
! 900: (phys_p == asmap->failedPDAs[1]))
! 901: continue;
! 902: suoff = rf_StripeUnitOffset(layoutPtr, phys_p->startSector);
! 903: suend = suoff + phys_p->numSector;
! 904: switch (state) {
! 905: case 1: /* Single buffer. */
! 906: if (suoff > fone_start) {
! 907: RF_ASSERT(suend >= fone_end);
! 908: /*
! 909: * The data read starts after the mapped
! 910: * access, snip off the begining.
! 911: */
! 912: pda_p->numSector = suoff - fone_start;
! 913: pda_p->raidAddress = sosAddr + (i * secPerSU)
! 914: + fone_start;
! 915: (raidPtr->Layout.map->MapSector) (raidPtr,
! 916: pda_p->raidAddress, &(pda_p->row),
! 917: &(pda_p->col), &(pda_p->startSector), 0);
! 918: RF_MallocAndAdd(pda_p->bufPtr,
! 919: rf_RaidAddressToByte(raidPtr,
! 920: pda_p->numSector), (char *), allocList);
! 921: pda_p++;
! 922: }
! 923: if (suend < fone_end) {
! 924: RF_ASSERT(suoff <= fone_start);
! 925: /*
! 926: * The data read stops before the end of the
! 927: * failed access, extend.
! 928: */
! 929: pda_p->numSector = fone_end - suend;
! 930: pda_p->raidAddress = sosAddr + (i * secPerSU)
! 931: + suend; /* off by one? */
! 932: (raidPtr->Layout.map->MapSector) (raidPtr,
! 933: pda_p->raidAddress, &(pda_p->row),
! 934: &(pda_p->col), &(pda_p->startSector), 0);
! 935: RF_MallocAndAdd(pda_p->bufPtr,
! 936: rf_RaidAddressToByte(raidPtr,
! 937: pda_p->numSector), (char *), allocList);
! 938: pda_p++;
! 939: }
! 940: break;
! 941: case 2: /* Whole stripe unit. */
! 942: RF_ASSERT((suoff == 0) || (suend == secPerSU));
! 943: if (suend < secPerSU) {
! 944: /* Short read, snip from end on. */
! 945: pda_p->numSector = secPerSU - suend;
! 946: pda_p->raidAddress = sosAddr + (i * secPerSU)
! 947: + suend; /* off by one? */
! 948: (raidPtr->Layout.map->MapSector) (raidPtr,
! 949: pda_p->raidAddress, &(pda_p->row),
! 950: &(pda_p->col), &(pda_p->startSector), 0);
! 951: RF_MallocAndAdd(pda_p->bufPtr,
! 952: rf_RaidAddressToByte(raidPtr,
! 953: pda_p->numSector), (char *), allocList);
! 954: pda_p++;
! 955: } else
! 956: if (suoff > 0) {
! 957: /* Short at front. */
! 958: pda_p->numSector = suoff;
! 959: pda_p->raidAddress = sosAddr +
! 960: (i * secPerSU);
! 961: (raidPtr->Layout.map->MapSector)
! 962: (raidPtr, pda_p->raidAddress,
! 963: &(pda_p->row), &(pda_p->col),
! 964: &(pda_p->startSector), 0);
! 965: RF_MallocAndAdd(pda_p->bufPtr,
! 966: rf_RaidAddressToByte(raidPtr,
! 967: pda_p->numSector), (char *),
! 968: allocList);
! 969: pda_p++;
! 970: }
! 971: break;
! 972: case 3: /* Two nonoverlapping failures. */
! 973: if ((suoff > fone_start) || (suend < fone_end)) {
! 974: if (suoff > fone_start) {
! 975: RF_ASSERT(suend >= fone_end);
! 976: /*
! 977: * The data read starts after the
! 978: * mapped access, snip off the
! 979: * begining.
! 980: */
! 981: pda_p->numSector = suoff - fone_start;
! 982: pda_p->raidAddress = sosAddr +
! 983: (i * secPerSU) + fone_start;
! 984: (raidPtr->Layout.map->MapSector)
! 985: (raidPtr, pda_p->raidAddress,
! 986: &(pda_p->row), &(pda_p->col),
! 987: &(pda_p->startSector), 0);
! 988: RF_MallocAndAdd(pda_p->bufPtr,
! 989: rf_RaidAddressToByte(raidPtr,
! 990: pda_p->numSector), (char *),
! 991: allocList);
! 992: pda_p++;
! 993: }
! 994: if (suend < fone_end) {
! 995: RF_ASSERT(suoff <= fone_start);
! 996: /*
! 997: * The data read stops before the end
! 998: * of the failed access, extend.
! 999: */
! 1000: pda_p->numSector = fone_end - suend;
! 1001: pda_p->raidAddress = sosAddr +
! 1002: (i * secPerSU) +
! 1003: suend; /* Off by one ? */
! 1004: (raidPtr->Layout.map->MapSector)
! 1005: (raidPtr, pda_p->raidAddress,
! 1006: &(pda_p->row), &(pda_p->col),
! 1007: &(pda_p->startSector), 0);
! 1008: RF_MallocAndAdd(pda_p->bufPtr,
! 1009: rf_RaidAddressToByte(raidPtr,
! 1010: pda_p->numSector), (char *),
! 1011: allocList);
! 1012: pda_p++;
! 1013: }
! 1014: }
! 1015: if ((suoff > ftwo_start) || (suend < ftwo_end)) {
! 1016: if (suoff > ftwo_start) {
! 1017: RF_ASSERT(suend >= ftwo_end);
! 1018: /*
! 1019: * The data read starts after the
! 1020: * mapped access, snip off the
! 1021: * begining.
! 1022: */
! 1023: pda_p->numSector = suoff - ftwo_start;
! 1024: pda_p->raidAddress = sosAddr +
! 1025: (i * secPerSU) + ftwo_start;
! 1026: (raidPtr->Layout.map->MapSector)
! 1027: (raidPtr, pda_p->raidAddress,
! 1028: &(pda_p->row), &(pda_p->col),
! 1029: &(pda_p->startSector), 0);
! 1030: RF_MallocAndAdd(pda_p->bufPtr,
! 1031: rf_RaidAddressToByte(raidPtr,
! 1032: pda_p->numSector), (char *),
! 1033: allocList);
! 1034: pda_p++;
! 1035: }
! 1036: if (suend < ftwo_end) {
! 1037: RF_ASSERT(suoff <= ftwo_start);
! 1038: /*
! 1039: * The data read stops before the end
! 1040: * of the failed access, extend.
! 1041: */
! 1042: pda_p->numSector = ftwo_end - suend;
! 1043: pda_p->raidAddress = sosAddr +
! 1044: (i * secPerSU) +
! 1045: suend; /* Off by one ? */
! 1046: (raidPtr->Layout.map->MapSector)
! 1047: (raidPtr, pda_p->raidAddress,
! 1048: &(pda_p->row), &(pda_p->col),
! 1049: &(pda_p->startSector), 0);
! 1050: RF_MallocAndAdd(pda_p->bufPtr,
! 1051: rf_RaidAddressToByte(raidPtr,
! 1052: pda_p->numSector), (char *),
! 1053: allocList);
! 1054: pda_p++;
! 1055: }
! 1056: }
! 1057: break;
! 1058: default:
! 1059: RF_PANIC();
! 1060: }
! 1061: }
! 1062:
! 1063: /* After the last accessed disk. */
! 1064: for (; i < numDataCol; i++) {
! 1065: if ((pda_p - (*pdap)) == napdas)
! 1066: continue;
! 1067: pda_p->type = RF_PDA_TYPE_DATA;
! 1068: pda_p->raidAddress = sosAddr + (i * secPerSU);
! 1069: (raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
! 1070: &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
! 1071: /* Skip over dead disks. */
! 1072: if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
! 1073: continue;
! 1074: switch (state) {
! 1075: case 1: /* Fone. */
! 1076: pda_p->numSector = fone->numSector;
! 1077: pda_p->raidAddress += fone_start;
! 1078: pda_p->startSector += fone_start;
! 1079: RF_MallocAndAdd(pda_p->bufPtr,
! 1080: rf_RaidAddressToByte(raidPtr, pda_p->numSector),
! 1081: (char *), allocList);
! 1082: break;
! 1083: case 2: /* Full stripe. */
! 1084: pda_p->numSector = secPerSU;
! 1085: RF_MallocAndAdd(pda_p->bufPtr,
! 1086: rf_RaidAddressToByte(raidPtr, secPerSU),
! 1087: (char *), allocList);
! 1088: break;
! 1089: case 3: /* Two slabs. */
! 1090: pda_p->numSector = fone->numSector;
! 1091: pda_p->raidAddress += fone_start;
! 1092: pda_p->startSector += fone_start;
! 1093: RF_MallocAndAdd(pda_p->bufPtr,
! 1094: rf_RaidAddressToByte(raidPtr, pda_p->numSector),
! 1095: (char *), allocList);
! 1096: pda_p++;
! 1097: pda_p->type = RF_PDA_TYPE_DATA;
! 1098: pda_p->raidAddress = sosAddr + (i * secPerSU);
! 1099: (raidPtr->Layout.map->MapSector) (raidPtr,
! 1100: pda_p->raidAddress, &(pda_p->row), &(pda_p->col),
! 1101: &(pda_p->startSector), 0);
! 1102: pda_p->numSector = ftwo->numSector;
! 1103: pda_p->raidAddress += ftwo_start;
! 1104: pda_p->startSector += ftwo_start;
! 1105: RF_MallocAndAdd(pda_p->bufPtr,
! 1106: rf_RaidAddressToByte(raidPtr, pda_p->numSector),
! 1107: (char *), allocList);
! 1108: break;
! 1109: default:
! 1110: RF_PANIC();
! 1111: }
! 1112: pda_p++;
! 1113: }
! 1114:
! 1115: RF_ASSERT(pda_p - *pdap == napdas);
! 1116: return;
! 1117: }
! 1118:
! 1119: #define INIT_DISK_NODE(node,name) do { \
! 1120: rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc, \
! 1121: rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 2,1,4,0, \
! 1122: dag_h, name, allocList); \
! 1123: (node)->succedents[0] = unblockNode; \
! 1124: (node)->succedents[1] = recoveryNode; \
! 1125: (node)->antecedents[0] = blockNode; \
! 1126: (node)->antType[0] = rf_control; \
! 1127: } while (0)
! 1128:
! 1129: #define DISK_NODE_PARAMS(_node_,_p_) do { \
! 1130: (_node_).params[0].p = _p_ ; \
! 1131: (_node_).params[1].p = (_p_)->bufPtr; \
! 1132: (_node_).params[2].v = parityStripeID; \
! 1133: (_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, \
! 1134: 0, 0, which_ru); \
! 1135: } while (0)
! 1136:
! 1137: void
! 1138: rf_DoubleDegRead(
! 1139: RF_Raid_t *raidPtr,
! 1140: RF_AccessStripeMap_t *asmap,
! 1141: RF_DagHeader_t *dag_h,
! 1142: void *bp,
! 1143: RF_RaidAccessFlags_t flags,
! 1144: RF_AllocListElem_t *allocList,
! 1145: char *redundantReadNodeName,
! 1146: char *recoveryNodeName,
! 1147: int (*recovFunc) (RF_DagNode_t *)
! 1148: )
! 1149: {
! 1150: RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
! 1151: RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *recoveryNode, *blockNode,
! 1152: *unblockNode, *rpNodes, *rqNodes, *termNode;
! 1153: RF_PhysDiskAddr_t *pda, *pqPDAs;
! 1154: RF_PhysDiskAddr_t *npdas;
! 1155: int nNodes, nRrdNodes, nRudNodes, i;
! 1156: RF_ReconUnitNum_t which_ru;
! 1157: int nReadNodes, nPQNodes;
! 1158: RF_PhysDiskAddr_t *failedPDA = asmap->failedPDAs[0];
! 1159: RF_PhysDiskAddr_t *failedPDAtwo = asmap->failedPDAs[1];
! 1160: RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(
! 1161: layoutPtr, asmap->raidAddress, &which_ru);
! 1162:
! 1163: if (rf_dagDebug)
! 1164: printf("[Creating Double Degraded Read DAG]\n");
! 1165: rf_DD_GenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes,
! 1166: &pqPDAs, &nPQNodes, allocList);
! 1167:
! 1168: nRudNodes = asmap->numStripeUnitsAccessed - (asmap->numDataFailed);
! 1169: nReadNodes = nRrdNodes + nRudNodes + 2 * nPQNodes;
! 1170: nNodes = 4 /* Block, unblock, recovery, term. */ + nReadNodes;
! 1171:
! 1172: RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
! 1173: allocList);
! 1174: i = 0;
! 1175: blockNode = &nodes[i];
! 1176: i += 1;
! 1177: unblockNode = &nodes[i];
! 1178: i += 1;
! 1179: recoveryNode = &nodes[i];
! 1180: i += 1;
! 1181: termNode = &nodes[i];
! 1182: i += 1;
! 1183: rudNodes = &nodes[i];
! 1184: i += nRudNodes;
! 1185: rrdNodes = &nodes[i];
! 1186: i += nRrdNodes;
! 1187: rpNodes = &nodes[i];
! 1188: i += nPQNodes;
! 1189: rqNodes = &nodes[i];
! 1190: i += nPQNodes;
! 1191: RF_ASSERT(i == nNodes);
! 1192:
! 1193: dag_h->numSuccedents = 1;
! 1194: dag_h->succedents[0] = blockNode;
! 1195: dag_h->creator = "DoubleDegRead";
! 1196: dag_h->numCommits = 0;
! 1197: dag_h->numCommitNodes = 1; /* Unblock. */
! 1198:
! 1199: rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
! 1200: rf_TerminateUndoFunc, NULL, 0, 2, 0, 0, dag_h, "Trm", allocList);
! 1201: termNode->antecedents[0] = unblockNode;
! 1202: termNode->antType[0] = rf_control;
! 1203: termNode->antecedents[1] = recoveryNode;
! 1204: termNode->antType[1] = rf_control;
! 1205:
! 1206: /*
! 1207: * Init the block and unblock nodes.
! 1208: * The block node has all nodes except itself, unblock and
! 1209: * recovery as successors.
! 1210: * Similarly for predecessors of the unblock.
! 1211: */
! 1212: rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
! 1213: rf_NullNodeUndoFunc, NULL, nReadNodes, 0, 0, 0, dag_h,
! 1214: "Nil", allocList);
! 1215: rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
! 1216: rf_NullNodeUndoFunc, NULL, 1, nReadNodes, 0, 0, dag_h,
! 1217: "Nil", allocList);
! 1218:
! 1219: for (i = 0; i < nReadNodes; i++) {
! 1220: blockNode->succedents[i] = rudNodes + i;
! 1221: unblockNode->antecedents[i] = rudNodes + i;
! 1222: unblockNode->antType[i] = rf_control;
! 1223: }
! 1224: unblockNode->succedents[0] = termNode;
! 1225:
! 1226: /*
! 1227: * The recovery node has all the reads as predecessors, and the term
! 1228: * node as successors. It gets a pda as a param from each of the read
! 1229: * nodes plus the raidPtr. For each failed unit is has a result pda.
! 1230: */
! 1231: rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc,
! 1232: rf_NullNodeUndoFunc, NULL,
! 1233: 1, /* succesors */
! 1234: nReadNodes, /* preds */
! 1235: nReadNodes + 2, /* params */
! 1236: asmap->numDataFailed, /* results */
! 1237: dag_h, recoveryNodeName, allocList);
! 1238:
! 1239: recoveryNode->succedents[0] = termNode;
! 1240: for (i = 0; i < nReadNodes; i++) {
! 1241: recoveryNode->antecedents[i] = rudNodes + i;
! 1242: recoveryNode->antType[i] = rf_trueData;
! 1243: }
! 1244:
! 1245: /*
! 1246: * Build the read nodes, then come back and fill in recovery params
! 1247: * and results.
! 1248: */
! 1249: pda = asmap->physInfo;
! 1250: for (i = 0; i < nRudNodes; pda = pda->next) {
! 1251: if ((pda == failedPDA) || (pda == failedPDAtwo))
! 1252: continue;
! 1253: INIT_DISK_NODE(rudNodes + i, "Rud");
! 1254: RF_ASSERT(pda);
! 1255: DISK_NODE_PARAMS(rudNodes[i], pda);
! 1256: i++;
! 1257: }
! 1258:
! 1259: pda = npdas;
! 1260: for (i = 0; i < nRrdNodes; i++, pda = pda->next) {
! 1261: INIT_DISK_NODE(rrdNodes + i, "Rrd");
! 1262: RF_ASSERT(pda);
! 1263: DISK_NODE_PARAMS(rrdNodes[i], pda);
! 1264: }
! 1265:
! 1266: /* Redundancy pdas. */
! 1267: pda = pqPDAs;
! 1268: INIT_DISK_NODE(rpNodes, "Rp");
! 1269: RF_ASSERT(pda);
! 1270: DISK_NODE_PARAMS(rpNodes[0], pda);
! 1271: pda++;
! 1272: INIT_DISK_NODE(rqNodes, redundantReadNodeName);
! 1273: RF_ASSERT(pda);
! 1274: DISK_NODE_PARAMS(rqNodes[0], pda);
! 1275: if (nPQNodes == 2) {
! 1276: pda++;
! 1277: INIT_DISK_NODE(rpNodes + 1, "Rp");
! 1278: RF_ASSERT(pda);
! 1279: DISK_NODE_PARAMS(rpNodes[1], pda);
! 1280: pda++;
! 1281: INIT_DISK_NODE(rqNodes + 1, redundantReadNodeName);
! 1282: RF_ASSERT(pda);
! 1283: DISK_NODE_PARAMS(rqNodes[1], pda);
! 1284: }
! 1285: /* Fill in recovery node params. */
! 1286: for (i = 0; i < nReadNodes; i++)
! 1287: recoveryNode->params[i] = rudNodes[i].params[0]; /* pda */
! 1288: recoveryNode->params[i++].p = (void *) raidPtr;
! 1289: recoveryNode->params[i++].p = (void *) asmap;
! 1290: recoveryNode->results[0] = failedPDA;
! 1291: if (asmap->numDataFailed == 2)
! 1292: recoveryNode->results[1] = failedPDAtwo;
! 1293:
! 1294: /* Zero fill the target data buffers ? */
! 1295: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rf_dagdegrd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe