![[BACK]](/icons/back.gif){kind=icon}
Return to rf_aselect.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / raidframe|
Return to rf_aselect.c CVS log | Up to [local] / sys / dev / raidframe |
1.1 ! nbrk 1: /* $OpenBSD: rf_aselect.c,v 1.3 2002/12/16 07:01:03 tdeval Exp $ */
! 2: /* $NetBSD: rf_aselect.c,v 1.3 1999/02/05 00:06:06 oster Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Carnegie-Mellon University.
! 6: * All rights reserved.
! 7: *
! 8: * Author: Mark Holland, 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: * aselect.c -- algorithm selection code
! 34: *
! 35: *****************************************************************************/
! 36:
! 37:
! 38: #include "rf_archs.h"
! 39: #include "rf_types.h"
! 40: #include "rf_raid.h"
! 41: #include "rf_dag.h"
! 42: #include "rf_dagutils.h"
! 43: #include "rf_dagfuncs.h"
! 44: #include "rf_general.h"
! 45: #include "rf_desc.h"
! 46: #include "rf_map.h"
! 47:
! 48: #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
! 49: /* The function below is not used... so don't define it! */
! 50: #else
! 51: void rf_TransferDagMemory(RF_DagHeader_t *, RF_DagHeader_t *);
! 52: #endif
! 53:
! 54: int rf_InitHdrNode(RF_DagHeader_t **, RF_Raid_t *, int);
! 55: void rf_UpdateNodeHdrPtr(RF_DagHeader_t *, RF_DagNode_t *);
! 56: int rf_SelectAlgorithm(RF_RaidAccessDesc_t *, RF_RaidAccessFlags_t);
! 57:
! 58:
! 59: /*****************************************************************************
! 60: *
! 61: * Create and Initialize a dag header and termination node.
! 62: *
! 63: *****************************************************************************/
! 64: int
! 65: rf_InitHdrNode(RF_DagHeader_t **hdr, RF_Raid_t *raidPtr, int memChunkEnable)
! 66: {
! 67: /* Create and initialize dag hdr. */
! 68: *hdr = rf_AllocDAGHeader();
! 69: rf_MakeAllocList((*hdr)->allocList);
! 70: if ((*hdr)->allocList == NULL) {
! 71: rf_FreeDAGHeader(*hdr);
! 72: return (ENOMEM);
! 73: }
! 74: (*hdr)->status = rf_enable;
! 75: (*hdr)->numSuccedents = 0;
! 76: (*hdr)->raidPtr = raidPtr;
! 77: (*hdr)->next = NULL;
! 78: return (0);
! 79: }
! 80:
! 81:
! 82: /*****************************************************************************
! 83: *
! 84: * Transfer allocation list and mem chunks from one dag to another.
! 85: *
! 86: *****************************************************************************/
! 87: #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
! 88: /* The function below is not used... so don't define it! */
! 89: #else
! 90: void
! 91: rf_TransferDagMemory(RF_DagHeader_t *daga, RF_DagHeader_t *dagb)
! 92: {
! 93: RF_AccessStripeMapHeader_t *end;
! 94: RF_AllocListElem_t *p;
! 95: int i, memChunksXfrd = 0, xtraChunksXfrd = 0;
! 96:
! 97: /* Transfer allocList from dagb to daga. */
! 98: for (p = dagb->allocList; p; p = p->next) {
! 99: for (i = 0; i < p->numPointers; i++) {
! 100: rf_AddToAllocList(daga->allocList, p->pointers[i],
! 101: p->sizes[i]);
! 102: p->pointers[i] = NULL;
! 103: p->sizes[i] = 0;
! 104: }
! 105: p->numPointers = 0;
! 106: }
! 107:
! 108: /* Transfer chunks from dagb to daga. */
! 109: while ((memChunksXfrd + xtraChunksXfrd <
! 110: dagb->chunkIndex + dagb->xtraChunkIndex) &&
! 111: (daga->chunkIndex < RF_MAXCHUNKS)) {
! 112: /* Stuff chunks into daga's memChunk array. */
! 113: if (memChunksXfrd < dagb->chunkIndex) {
! 114: daga->memChunk[daga->chunkIndex++] =
! 115: dagb->memChunk[memChunksXfrd];
! 116: dagb->memChunk[memChunksXfrd++] = NULL;
! 117: } else {
! 118: daga->memChunk[daga->xtraChunkIndex++] =
! 119: dagb->xtraMemChunk[xtraChunksXfrd];
! 120: dagb->xtraMemChunk[xtraChunksXfrd++] = NULL;
! 121: }
! 122: }
! 123: /* Use escape hatch to hold excess chunks. */
! 124: while (memChunksXfrd + xtraChunksXfrd <
! 125: dagb->chunkIndex + dagb->xtraChunkIndex) {
! 126: if (memChunksXfrd < dagb->chunkIndex) {
! 127: daga->xtraMemChunk[daga->xtraChunkIndex++] =
! 128: dagb->memChunk[memChunksXfrd];
! 129: dagb->memChunk[memChunksXfrd++] = NULL;
! 130: } else {
! 131: daga->xtraMemChunk[daga->xtraChunkIndex++] =
! 132: dagb->xtraMemChunk[xtraChunksXfrd];
! 133: dagb->xtraMemChunk[xtraChunksXfrd++] = NULL;
! 134: }
! 135: }
! 136: RF_ASSERT((memChunksXfrd == dagb->chunkIndex) &&
! 137: (xtraChunksXfrd == dagb->xtraChunkIndex));
! 138: RF_ASSERT(daga->chunkIndex <= RF_MAXCHUNKS);
! 139: RF_ASSERT(daga->xtraChunkIndex <= daga->xtraChunkCnt);
! 140: dagb->chunkIndex = 0;
! 141: dagb->xtraChunkIndex = 0;
! 142:
! 143: /* Transfer asmList from dagb to daga. */
! 144: if (dagb->asmList) {
! 145: if (daga->asmList) {
! 146: end = daga->asmList;
! 147: while (end->next)
! 148: end = end->next;
! 149: end->next = dagb->asmList;
! 150: } else
! 151: daga->asmList = dagb->asmList;
! 152: dagb->asmList = NULL;
! 153: }
! 154: }
! 155: #endif /* __NetBSD__ || __OpenBSD__ */
! 156:
! 157:
! 158: /*****************************************************************************
! 159: *
! 160: * Ensure that all node->dagHdr fields in a dag are consistent.
! 161: *
! 162: * IMPORTANT: This routine recursively searches all succedents of the node.
! 163: * If a succedent is encountered whose dagHdr ptr does not require adjusting,
! 164: * that node's succedents WILL NOT BE EXAMINED.
! 165: *
! 166: *****************************************************************************/
! 167: void
! 168: rf_UpdateNodeHdrPtr(RF_DagHeader_t *hdr, RF_DagNode_t *node)
! 169: {
! 170: int i;
! 171: RF_ASSERT(hdr != NULL && node != NULL);
! 172: for (i = 0; i < node->numSuccedents; i++)
! 173: if (node->succedents[i]->dagHdr != hdr)
! 174: rf_UpdateNodeHdrPtr(hdr, node->succedents[i]);
! 175: node->dagHdr = hdr;
! 176: }
! 177:
! 178:
! 179: /*****************************************************************************
! 180: *
! 181: * Create a DAG to do a read or write operation.
! 182: *
! 183: * Create an array of dagLists, one list per parity stripe.
! 184: * Return the lists in the array desc->dagArray.
! 185: *
! 186: * Normally, each list contains one dag for the entire stripe. In some
! 187: * tricky cases, we break this into multiple dags, either one per stripe
! 188: * unit or one per block (sector). When this occurs, these dags are returned
! 189: * as a linked list (dagList) which is executed sequentially (to preserve
! 190: * atomic parity updates in the stripe).
! 191: *
! 192: * Dags that operate on independent parity goups (stripes) are returned in
! 193: * independent dagLists (distinct elements in desc->dagArray) and may be
! 194: * executed concurrently.
! 195: *
! 196: * Finally, if the SelectionFunc fails to create a dag for a block, we punt
! 197: * and return 1.
! 198: *
! 199: * The above process is performed in two phases:
! 200: * 1) create an array(s) of creation functions (eg stripeFuncs)
! 201: * 2) create dags and concatenate/merge to form the final dag.
! 202: *
! 203: * Because dag's are basic blocks (single entry, single exit, unconditional
! 204: * control flow), we can add the following optimizations (future work):
! 205: * first-pass optimizer to allow max concurrency (need all data dependencies)
! 206: * second-pass optimizer to eliminate common subexpressions (need true
! 207: * data dependencies)
! 208: * third-pass optimizer to eliminate dead code (need true data dependencies)
! 209: *****************************************************************************/
! 210:
! 211: #define MAXNSTRIPES 50
! 212:
! 213: int
! 214: rf_SelectAlgorithm(RF_RaidAccessDesc_t *desc, RF_RaidAccessFlags_t flags)
! 215: {
! 216: RF_AccessStripeMapHeader_t *asm_h = desc->asmap;
! 217: RF_IoType_t type = desc->type;
! 218: RF_Raid_t *raidPtr = desc->raidPtr;
! 219: void *bp = desc->bp;
! 220:
! 221: RF_AccessStripeMap_t *asmap = asm_h->stripeMap;
! 222: RF_AccessStripeMap_t *asm_p;
! 223: RF_DagHeader_t *dag_h = NULL, *tempdag_h, *lastdag_h;
! 224: int i, j, k;
! 225: RF_VoidFuncPtr *stripeFuncs, normalStripeFuncs[MAXNSTRIPES];
! 226: RF_AccessStripeMap_t *asm_up, *asm_bp;
! 227: RF_AccessStripeMapHeader_t ***asmh_u, *endASMList;
! 228: RF_AccessStripeMapHeader_t ***asmh_b;
! 229: RF_VoidFuncPtr **stripeUnitFuncs, uFunc;
! 230: RF_VoidFuncPtr **blockFuncs, bFunc;
! 231: int numStripesBailed = 0, cantCreateDAGs = RF_FALSE;
! 232: int numStripeUnitsBailed = 0;
! 233: int stripeNum, numUnitDags = 0, stripeUnitNum, numBlockDags = 0;
! 234: RF_StripeNum_t numStripeUnits;
! 235: RF_SectorNum_t numBlocks;
! 236: RF_RaidAddr_t address;
! 237: int length;
! 238: RF_PhysDiskAddr_t *physPtr;
! 239: caddr_t buffer;
! 240:
! 241: lastdag_h = NULL;
! 242: asmh_u = asmh_b = NULL;
! 243: stripeUnitFuncs = NULL;
! 244: blockFuncs = NULL;
! 245:
! 246: /*
! 247: * Get an array of dag-function creation pointers.
! 248: * Try to avoid calling malloc.
! 249: */
! 250: if (asm_h->numStripes <= MAXNSTRIPES)
! 251: stripeFuncs = normalStripeFuncs;
! 252: else
! 253: RF_Calloc(stripeFuncs, asm_h->numStripes,
! 254: sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
! 255:
! 256: /*
! 257: * Walk through the asm list once collecting information.
! 258: * Attempt to find a single creation function for each stripe.
! 259: */
! 260: desc->numStripes = 0;
! 261: for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++) {
! 262: desc->numStripes++;
! 263: (raidPtr->Layout.map->SelectionFunc) (raidPtr, type, asm_p,
! 264: &stripeFuncs[i]);
! 265: /* Check to see if we found a creation func for this stripe. */
! 266: if (stripeFuncs[i] == (RF_VoidFuncPtr) NULL) {
! 267: /*
! 268: * Could not find creation function for entire stripe.
! 269: * So, let's see if we can find one for each stripe
! 270: * unit in the stripe.
! 271: */
! 272:
! 273: if (numStripesBailed == 0) {
! 274: /*
! 275: * One stripe map header for each stripe we
! 276: * bail on.
! 277: */
! 278: RF_Malloc(asmh_u,
! 279: sizeof(RF_AccessStripeMapHeader_t **) *
! 280: asm_h->numStripes,
! 281: (RF_AccessStripeMapHeader_t ***));
! 282: /*
! 283: * Create an array of ptrs to arrays of
! 284: * stripeFuncs.
! 285: */
! 286: RF_Calloc(stripeUnitFuncs, asm_h->numStripes,
! 287: sizeof(RF_VoidFuncPtr),
! 288: (RF_VoidFuncPtr **));
! 289: }
! 290: /*
! 291: * Create an array of creation funcs (called
! 292: * stripeFuncs) for this stripe.
! 293: */
! 294: numStripeUnits = asm_p->numStripeUnitsAccessed;
! 295: RF_Calloc(stripeUnitFuncs[numStripesBailed],
! 296: numStripeUnits, sizeof(RF_VoidFuncPtr),
! 297: (RF_VoidFuncPtr *));
! 298: RF_Malloc(asmh_u[numStripesBailed], numStripeUnits *
! 299: sizeof(RF_AccessStripeMapHeader_t *),
! 300: (RF_AccessStripeMapHeader_t **));
! 301:
! 302: /* Lookup array of stripeUnitFuncs for this stripe. */
! 303: for (j = 0, physPtr = asm_p->physInfo; physPtr;
! 304: physPtr = physPtr->next, j++) {
! 305: /*
! 306: * Remap for series of single stripe-unit
! 307: * accesses.
! 308: */
! 309: address = physPtr->raidAddress;
! 310: length = physPtr->numSector;
! 311: buffer = physPtr->bufPtr;
! 312:
! 313: asmh_u[numStripesBailed][j] =
! 314: rf_MapAccess(raidPtr, address, length,
! 315: buffer, RF_DONT_REMAP);
! 316: asm_up = asmh_u[numStripesBailed][j]->stripeMap;
! 317:
! 318: /*
! 319: * Get the creation func for this
! 320: * stripe unit.
! 321: */
! 322: (raidPtr->Layout.map->SelectionFunc) (raidPtr,
! 323: type, asm_up,
! 324: &(stripeUnitFuncs[numStripesBailed][j]));
! 325:
! 326: /*
! 327: * Check to see if we found a creation func
! 328: * for this stripe unit.
! 329: */
! 330: if (stripeUnitFuncs[numStripesBailed][j] ==
! 331: (RF_VoidFuncPtr) NULL) {
! 332: /*
! 333: * Could not find creation function
! 334: * for stripe unit. So, let's see if
! 335: * we can find one for each block in
! 336: * the stripe unit.
! 337: */
! 338: if (numStripeUnitsBailed == 0) {
! 339: /*
! 340: * one stripe map header for
! 341: * each stripe unit we bail on.
! 342: */
! 343: RF_Malloc(asmh_b,
! 344: sizeof(RF_AccessStripeMapHeader_t **) *
! 345: asm_h->numStripes *
! 346: raidPtr->Layout.numDataCol,
! 347: (RF_AccessStripeMapHeader_t ***));
! 348: /*
! 349: * Create an array of ptrs to
! 350: * arrays of blockFuncs.
! 351: */
! 352: RF_Calloc(blockFuncs,
! 353: asm_h->numStripes *
! 354: raidPtr->Layout.numDataCol,
! 355: sizeof(RF_VoidFuncPtr),
! 356: (RF_VoidFuncPtr **));
! 357: }
! 358: /*
! 359: * Create an array of creation funcs
! 360: * (called blockFuncs) for this stripe
! 361: * unit.
! 362: */
! 363: numBlocks = physPtr->numSector;
! 364: numBlockDags += numBlocks;
! 365: RF_Calloc(
! 366: blockFuncs[numStripeUnitsBailed],
! 367: numBlocks, sizeof(RF_VoidFuncPtr),
! 368: (RF_VoidFuncPtr *));
! 369: RF_Malloc(asmh_b[numStripeUnitsBailed],
! 370: numBlocks *
! 371: sizeof(RF_AccessStripeMapHeader_t *),
! 372: (RF_AccessStripeMapHeader_t **));
! 373:
! 374: /*
! 375: * Lookup array of blockFuncs for this
! 376: * stripe unit.
! 377: */
! 378: for (k = 0; k < numBlocks; k++) {
! 379: /*
! 380: * Remap for series of single
! 381: * stripe-unit accesses.
! 382: */
! 383: address = physPtr->raidAddress
! 384: + k;
! 385: length = 1;
! 386: buffer = physPtr->bufPtr +
! 387: (k * (1 <<
! 388: raidPtr->logBytesPerSector));
! 389:
! 390: asmh_b[numStripeUnitsBailed][k]
! 391: = rf_MapAccess(raidPtr,
! 392: address, length, buffer,
! 393: RF_DONT_REMAP);
! 394: asm_bp =
! 395: asmh_b[numStripeUnitsBailed][k]->stripeMap;
! 396:
! 397: /*
! 398: * Get the creation func for
! 399: * this stripe unit.
! 400: */
! 401: (raidPtr->Layout.map->
! 402: SelectionFunc) (raidPtr,
! 403: type, asm_bp,
! 404: &(blockFuncs[numStripeUnitsBailed][k]));
! 405:
! 406: /*
! 407: * Check to see if we found a
! 408: * creation func for this
! 409: * stripe unit.
! 410: */
! 411: if (blockFuncs
! 412: [numStripeUnitsBailed][k]
! 413: == NULL)
! 414: cantCreateDAGs =
! 415: RF_TRUE;
! 416: }
! 417: numStripeUnitsBailed++;
! 418: } else {
! 419: numUnitDags++;
! 420: }
! 421: }
! 422: RF_ASSERT(j == numStripeUnits);
! 423: numStripesBailed++;
! 424: }
! 425: }
! 426:
! 427: if (cantCreateDAGs) {
! 428: /* Free memory and punt. */
! 429: if (asm_h->numStripes > MAXNSTRIPES)
! 430: RF_Free(stripeFuncs, asm_h->numStripes *
! 431: sizeof(RF_VoidFuncPtr));
! 432: if (numStripesBailed > 0) {
! 433: stripeNum = 0;
! 434: for (i = 0, asm_p = asmap; asm_p;
! 435: asm_p = asm_p->next, i++)
! 436: if (stripeFuncs[i] == NULL) {
! 437: numStripeUnits =
! 438: asm_p->numStripeUnitsAccessed;
! 439: for (j = 0; j < numStripeUnits; j++)
! 440: rf_FreeAccessStripeMap(
! 441: asmh_u[stripeNum][j]);
! 442: RF_Free(asmh_u[stripeNum],
! 443: numStripeUnits *
! 444: sizeof(RF_AccessStripeMapHeader_t *));
! 445: RF_Free(stripeUnitFuncs[stripeNum],
! 446: numStripeUnits *
! 447: sizeof(RF_VoidFuncPtr));
! 448: stripeNum++;
! 449: }
! 450: RF_ASSERT(stripeNum == numStripesBailed);
! 451: RF_Free(stripeUnitFuncs, asm_h->numStripes *
! 452: sizeof(RF_VoidFuncPtr));
! 453: RF_Free(asmh_u, asm_h->numStripes *
! 454: sizeof(RF_AccessStripeMapHeader_t **));
! 455: }
! 456: return (1);
! 457: } else {
! 458: /* Begin dag creation. */
! 459: stripeNum = 0;
! 460: stripeUnitNum = 0;
! 461:
! 462: /* Create an array of dagLists and fill them in. */
! 463: RF_CallocAndAdd(desc->dagArray, desc->numStripes,
! 464: sizeof(RF_DagList_t), (RF_DagList_t *), desc->cleanupList);
! 465:
! 466: for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++) {
! 467: /* Grab dag header for this stripe. */
! 468: dag_h = NULL;
! 469: desc->dagArray[i].desc = desc;
! 470:
! 471: if (stripeFuncs[i] == (RF_VoidFuncPtr) NULL) {
! 472: /* Use bailout functions for this stripe. */
! 473: for (j = 0, physPtr = asm_p->physInfo; physPtr;
! 474: physPtr = physPtr->next, j++) {
! 475: uFunc = stripeUnitFuncs[stripeNum][j];
! 476: if (uFunc == (RF_VoidFuncPtr) NULL) {
! 477: /*
! 478: * Use bailout functions for
! 479: * this stripe unit.
! 480: */
! 481: for (k = 0; k <
! 482: physPtr->numSector; k++) {
! 483: /*
! 484: * Create a dag for
! 485: * this block.
! 486: */
! 487: rf_InitHdrNode(
! 488: &tempdag_h,
! 489: raidPtr,
! 490: rf_useMemChunks);
! 491: desc->dagArray[i].
! 492: numDags++;
! 493: if (dag_h == NULL) {
! 494: dag_h =
! 495: tempdag_h;
! 496: } else {
! 497: lastdag_h->next
! 498: = tempdag_h;
! 499: }
! 500: lastdag_h = tempdag_h;
! 501:
! 502: bFunc = blockFuncs
! 503: [stripeUnitNum][k];
! 504: RF_ASSERT(bFunc);
! 505: asm_bp = asmh_b
! 506: [stripeUnitNum][k]
! 507: ->stripeMap;
! 508: (*bFunc) (raidPtr,
! 509: asm_bp, tempdag_h,
! 510: bp, flags,
! 511: tempdag_h
! 512: ->allocList);
! 513: }
! 514: stripeUnitNum++;
! 515: } else {
! 516: /*
! 517: * Create a dag for this unit.
! 518: */
! 519: rf_InitHdrNode(&tempdag_h,
! 520: raidPtr, rf_useMemChunks);
! 521: desc->dagArray[i].numDags++;
! 522: if (dag_h == NULL) {
! 523: dag_h = tempdag_h;
! 524: } else {
! 525: lastdag_h->next =
! 526: tempdag_h;
! 527: }
! 528: lastdag_h = tempdag_h;
! 529:
! 530: asm_up = asmh_u[stripeNum][j]
! 531: ->stripeMap;
! 532: (*uFunc) (raidPtr, asm_up,
! 533: tempdag_h, bp, flags,
! 534: tempdag_h->allocList);
! 535: }
! 536: }
! 537: RF_ASSERT(j == asm_p->numStripeUnitsAccessed);
! 538: /*
! 539: * Merge linked bailout dag to existing dag
! 540: * collection.
! 541: */
! 542: stripeNum++;
! 543: } else {
! 544: /* Create a dag for this parity stripe. */
! 545: rf_InitHdrNode(&tempdag_h, raidPtr,
! 546: rf_useMemChunks);
! 547: desc->dagArray[i].numDags++;
! 548: if (dag_h == NULL) {
! 549: dag_h = tempdag_h;
! 550: } else {
! 551: lastdag_h->next = tempdag_h;
! 552: }
! 553: lastdag_h = tempdag_h;
! 554:
! 555: (stripeFuncs[i]) (raidPtr, asm_p, tempdag_h,
! 556: bp, flags, tempdag_h->allocList);
! 557: }
! 558: desc->dagArray[i].dags = dag_h;
! 559: }
! 560: RF_ASSERT(i == desc->numStripes);
! 561:
! 562: /* Free memory. */
! 563: if (asm_h->numStripes > MAXNSTRIPES)
! 564: RF_Free(stripeFuncs, asm_h->numStripes *
! 565: sizeof(RF_VoidFuncPtr));
! 566: if ((numStripesBailed > 0) || (numStripeUnitsBailed > 0)) {
! 567: stripeNum = 0;
! 568: stripeUnitNum = 0;
! 569: if (dag_h->asmList) {
! 570: endASMList = dag_h->asmList;
! 571: while (endASMList->next)
! 572: endASMList = endASMList->next;
! 573: } else
! 574: endASMList = NULL;
! 575: /* Walk through io, stripe by stripe. */
! 576: for (i = 0, asm_p = asmap; asm_p;
! 577: asm_p = asm_p->next, i++)
! 578: if (stripeFuncs[i] == NULL) {
! 579: numStripeUnits =
! 580: asm_p->numStripeUnitsAccessed;
! 581: /*
! 582: * Walk through stripe, stripe unit by
! 583: * stripe unit.
! 584: */
! 585: for (j = 0, physPtr = asm_p->physInfo;
! 586: physPtr;
! 587: physPtr = physPtr->next, j++) {
! 588: if (stripeUnitFuncs[stripeNum]
! 589: [j] == NULL) {
! 590: numBlocks =
! 591: physPtr->numSector;
! 592: /*
! 593: * Walk through stripe
! 594: * unit, block by
! 595: * block.
! 596: */
! 597: for (k = 0; k <
! 598: numBlocks; k++)
! 599: if (dag_h
! 600: ->asmList
! 601: == NULL) {
! 602: dag_h->asmList =
! 603: asmh_b[stripeUnitNum][k];
! 604: endASMList = dag_h->asmList;
! 605: } else {
! 606: endASMList->next =
! 607: asmh_b[stripeUnitNum][k];
! 608: endASMList = endASMList->next;
! 609: }
! 610: RF_Free(asmh_b
! 611: [stripeUnitNum], numBlocks *
! 612: sizeof(RF_AccessStripeMapHeader_t *));
! 613: RF_Free(blockFuncs
! 614: [stripeUnitNum], numBlocks *
! 615: sizeof(RF_VoidFuncPtr));
! 616: stripeUnitNum++;
! 617: }
! 618: if (dag_h->asmList == NULL) {
! 619: dag_h->asmList = asmh_u
! 620: [stripeNum][j];
! 621: endASMList = dag_h
! 622: ->asmList;
! 623: } else {
! 624: endASMList->next =
! 625: asmh_u[stripeNum]
! 626: [j];
! 627: endASMList = endASMList
! 628: ->next;
! 629: }
! 630: }
! 631: RF_Free(asmh_u[stripeNum],
! 632: numStripeUnits *
! 633: sizeof(
! 634: RF_AccessStripeMapHeader_t *));
! 635: RF_Free(stripeUnitFuncs[stripeNum],
! 636: numStripeUnits *
! 637: sizeof(RF_VoidFuncPtr));
! 638: stripeNum++;
! 639: }
! 640: RF_ASSERT(stripeNum == numStripesBailed);
! 641: RF_Free(stripeUnitFuncs, asm_h->numStripes *
! 642: sizeof(RF_VoidFuncPtr));
! 643: RF_Free(asmh_u, asm_h->numStripes *
! 644: sizeof(RF_AccessStripeMapHeader_t **));
! 645: if (numStripeUnitsBailed > 0) {
! 646: RF_ASSERT(stripeUnitNum ==
! 647: numStripeUnitsBailed);
! 648: RF_Free(blockFuncs, raidPtr->Layout.numDataCol
! 649: * asm_h->numStripes *
! 650: sizeof(RF_VoidFuncPtr));
! 651: RF_Free(asmh_b, raidPtr->Layout.numDataCol *
! 652: asm_h->numStripes *
! 653: sizeof(RF_AccessStripeMapHeader_t **));
! 654: }
! 655: }
! 656: return (0);
! 657: }
! 658: }