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