1/* $NetBSD: rf_map.c,v 1.44 2009/03/15 17:17:23 cegger Exp $ */ 2/* 3 * Copyright (c) 1995 Carnegie-Mellon University. 4 * All rights reserved. 5 * 6 * Author: Mark Holland 7 * 8 * Permission to use, copy, modify and distribute this software and 9 * its documentation is hereby granted, provided that both the copyright 10 * notice and this permission notice appear in all copies of the 11 * software, derivative works or modified versions, and any portions 12 * thereof, and that both notices appear in supporting documentation. 13 * 14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 16 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 17 * 18 * Carnegie Mellon requests users of this software to return to 19 * 20 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 21 * School of Computer Science 22 * Carnegie Mellon University 23 * Pittsburgh PA 15213-3890 24 * 25 * any improvements or extensions that they make and grant Carnegie the 26 * rights to redistribute these changes. 27 */ 28 29/************************************************************************** 30 * 31 * map.c -- main code for mapping RAID addresses to physical disk addresses 32 * 33 **************************************************************************/ 34 35#include <sys/cdefs.h> 36__KERNEL_RCSID(0, "$NetBSD: rf_map.c,v 1.44 2009/03/15 17:17:23 cegger Exp $"); 37 38#include <dev/raidframe/raidframevar.h> 39 40#include "rf_threadstuff.h" 41#include "rf_raid.h" 42#include "rf_general.h" 43#include "rf_map.h" 44#include "rf_shutdown.h" 45 46static void rf_FreePDAList(RF_PhysDiskAddr_t *pda_list); 47static void rf_FreeASMList(RF_AccessStripeMap_t *asm_list); 48 49/*************************************************************************** 50 * 51 * MapAccess -- main 1st order mapping routine. Maps an access in the 52 * RAID address space to the corresponding set of physical disk 53 * addresses. The result is returned as a list of AccessStripeMap 54 * structures, one per stripe accessed. Each ASM structure contains a 55 * pointer to a list of PhysDiskAddr structures, which describe the 56 * physical locations touched by the user access. Note that this 57 * routine returns only static mapping information, i.e. the list of 58 * physical addresses returned does not necessarily identify the set 59 * of physical locations that will actually be read or written. The 60 * routine also maps the parity. The physical disk location returned 61 * always indicates the entire parity unit, even when only a subset of 62 * it is being accessed. This is because an access that is not stripe 63 * unit aligned but that spans a stripe unit boundary may require 64 * access two distinct portions of the parity unit, and we can't yet 65 * tell which portion(s) we'll actually need. We leave it up to the 66 * algorithm selection code to decide what subset of the parity unit 67 * to access. Note that addresses in the RAID address space must 68 * always be maintained as longs, instead of ints. 69 * 70 * This routine returns NULL if numBlocks is 0 71 * 72 * raidAddress - starting address in RAID address space 73 * numBlocks - number of blocks in RAID address space to access 74 * buffer - buffer to supply/recieve data 75 * remap - 1 => remap address to spare space 76 ***************************************************************************/ 77 78RF_AccessStripeMapHeader_t * 79rf_MapAccess(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddress, 80 RF_SectorCount_t numBlocks, void *buffer, int remap) 81{ 82 RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout); 83 RF_AccessStripeMapHeader_t *asm_hdr = NULL; 84 RF_AccessStripeMap_t *asm_list = NULL, *asm_p = NULL; 85 int faultsTolerated = layoutPtr->map->faultsTolerated; 86 /* we'll change raidAddress along the way */ 87 RF_RaidAddr_t startAddress = raidAddress; 88 RF_RaidAddr_t endAddress = raidAddress + numBlocks; 89 RF_RaidDisk_t *disks = raidPtr->Disks; 90 RF_PhysDiskAddr_t *pda_p; 91#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) 92 RF_PhysDiskAddr_t *pda_q; 93#endif 94 RF_StripeCount_t numStripes = 0; 95 RF_RaidAddr_t stripeRealEndAddress, stripeEndAddress, 96 nextStripeUnitAddress; 97 RF_RaidAddr_t startAddrWithinStripe, lastRaidAddr; 98 RF_StripeCount_t totStripes; 99 RF_StripeNum_t stripeID, lastSID, SUID, lastSUID; 100 RF_AccessStripeMap_t *asmList, *t_asm; 101 RF_PhysDiskAddr_t *pdaList, *t_pda; 102 103 /* allocate all the ASMs and PDAs up front */ 104 lastRaidAddr = raidAddress + numBlocks - 1; 105 stripeID = rf_RaidAddressToStripeID(layoutPtr, raidAddress); 106 lastSID = rf_RaidAddressToStripeID(layoutPtr, lastRaidAddr); 107 totStripes = lastSID - stripeID + 1; 108 SUID = rf_RaidAddressToStripeUnitID(layoutPtr, raidAddress); 109 lastSUID = rf_RaidAddressToStripeUnitID(layoutPtr, lastRaidAddr); 110 111 asmList = rf_AllocASMList(totStripes); 112 113 /* may also need pda(s) per stripe for parity */ 114 pdaList = rf_AllocPDAList(lastSUID - SUID + 1 + 115 faultsTolerated * totStripes); 116 117 118 if (raidAddress + numBlocks > raidPtr->totalSectors) { 119 RF_ERRORMSG1("Unable to map access because offset (%d) was invalid\n", 120 (int) raidAddress); 121 return (NULL); 122 } 123#if RF_DEBUG_MAP 124 if (rf_mapDebug) 125 rf_PrintRaidAddressInfo(raidPtr, raidAddress, numBlocks); 126#endif 127 for (; raidAddress < endAddress;) { 128 /* make the next stripe structure */ 129 RF_ASSERT(asmList); 130 t_asm = asmList; 131 asmList = asmList->next; 132 memset((char *) t_asm, 0, sizeof(RF_AccessStripeMap_t)); 133 if (!asm_p) 134 asm_list = asm_p = t_asm; 135 else { 136 asm_p->next = t_asm; 137 asm_p = asm_p->next; 138 } 139 numStripes++; 140 141 /* map SUs from current location to the end of the stripe */ 142 asm_p->stripeID = /* rf_RaidAddressToStripeID(layoutPtr, 143 raidAddress) */ stripeID++; 144 stripeRealEndAddress = rf_RaidAddressOfNextStripeBoundary(layoutPtr, raidAddress); 145 stripeEndAddress = RF_MIN(endAddress, stripeRealEndAddress); 146 asm_p->raidAddress = raidAddress; 147 asm_p->endRaidAddress = stripeEndAddress; 148 149 /* map each stripe unit in the stripe */ 150 pda_p = NULL; 151 152 /* Raid addr of start of portion of access that is 153 within this stripe */ 154 startAddrWithinStripe = raidAddress; 155 156 for (; raidAddress < stripeEndAddress;) { 157 RF_ASSERT(pdaList); 158 t_pda = pdaList; 159 pdaList = pdaList->next; 160 memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t)); 161 if (!pda_p) 162 asm_p->physInfo = pda_p = t_pda; 163 else { 164 pda_p->next = t_pda; 165 pda_p = pda_p->next; 166 } 167 168 pda_p->type = RF_PDA_TYPE_DATA; 169 (layoutPtr->map->MapSector) (raidPtr, raidAddress, 170 &(pda_p->col), 171 &(pda_p->startSector), 172 remap); 173 174 /* mark any failures we find. failedPDA is 175 * don't-care if there is more than one 176 * failure */ 177 178 /* the RAID address corresponding to this 179 physical diskaddress */ 180 pda_p->raidAddress = raidAddress; 181 nextStripeUnitAddress = rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, raidAddress); 182 pda_p->numSector = RF_MIN(endAddress, nextStripeUnitAddress) - raidAddress; 183 RF_ASSERT(pda_p->numSector != 0); 184 rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 0); 185 pda_p->bufPtr = (char *)buffer + rf_RaidAddressToByte(raidPtr, (raidAddress - startAddress)); 186 asm_p->totalSectorsAccessed += pda_p->numSector; 187 asm_p->numStripeUnitsAccessed++; 188 189 raidAddress = RF_MIN(endAddress, nextStripeUnitAddress); 190 } 191 192 /* Map the parity. At this stage, the startSector and 193 * numSector fields for the parity unit are always set 194 * to indicate the entire parity unit. We may modify 195 * this after mapping the data portion. */ 196 switch (faultsTolerated) { 197 case 0: 198 break; 199 case 1: /* single fault tolerant */ 200 RF_ASSERT(pdaList); 201 t_pda = pdaList; 202 pdaList = pdaList->next; 203 memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t)); 204 pda_p = asm_p->parityInfo = t_pda; 205 pda_p->type = RF_PDA_TYPE_PARITY; 206 (layoutPtr->map->MapParity) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe), 207 &(pda_p->col), &(pda_p->startSector), remap); 208 pda_p->numSector = layoutPtr->sectorsPerStripeUnit; 209 /* raidAddr may be needed to find unit to redirect to */ 210 pda_p->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe); 211 rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1); 212 rf_ASMParityAdjust(asm_p->parityInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p); 213 214 break; 215#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) 216 case 2: /* two fault tolerant */ 217 RF_ASSERT(pdaList && pdaList->next); 218 t_pda = pdaList; 219 pdaList = pdaList->next; 220 memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t)); 221 pda_p = asm_p->parityInfo = t_pda; 222 pda_p->type = RF_PDA_TYPE_PARITY; 223 t_pda = pdaList; 224 pdaList = pdaList->next; 225 memset((char *) t_pda, 0, sizeof(RF_PhysDiskAddr_t)); 226 pda_q = asm_p->qInfo = t_pda; 227 pda_q->type = RF_PDA_TYPE_Q; 228 (layoutPtr->map->MapParity) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe), 229 &(pda_p->col), &(pda_p->startSector), remap); 230 (layoutPtr->map->MapQ) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe), 231 &(pda_q->col), &(pda_q->startSector), remap); 232 pda_q->numSector = pda_p->numSector = layoutPtr->sectorsPerStripeUnit; 233 /* raidAddr may be needed to find unit to redirect to */ 234 pda_p->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe); 235 pda_q->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe); 236 /* failure mode stuff */ 237 rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1); 238 rf_ASMCheckStatus(raidPtr, pda_q, asm_p, disks, 1); 239 rf_ASMParityAdjust(asm_p->parityInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p); 240 rf_ASMParityAdjust(asm_p->qInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p); 241 break; 242#endif 243 } 244 } 245 RF_ASSERT(asmList == NULL && pdaList == NULL); 246 /* make the header structure */ 247 asm_hdr = rf_AllocAccessStripeMapHeader(); 248 RF_ASSERT(numStripes == totStripes); 249 asm_hdr->numStripes = numStripes; 250 asm_hdr->stripeMap = asm_list; 251 252#if RF_DEBUG_MAP 253 if (rf_mapDebug) 254 rf_PrintAccessStripeMap(asm_hdr); 255#endif 256 return (asm_hdr); 257} 258 259/*************************************************************************** 260 * This routine walks through an ASM list and marks the PDAs that have 261 * failed. It's called only when a disk failure causes an in-flight 262 * DAG to fail. The parity may consist of two components, but we want 263 * to use only one failedPDA pointer. Thus we set failedPDA to point 264 * to the first parity component, and rely on the rest of the code to 265 * do the right thing with this. 266 ***************************************************************************/ 267 268void 269rf_MarkFailuresInASMList(RF_Raid_t *raidPtr, 270 RF_AccessStripeMapHeader_t *asm_h) 271{ 272 RF_RaidDisk_t *disks = raidPtr->Disks; 273 RF_AccessStripeMap_t *asmap; 274 RF_PhysDiskAddr_t *pda; 275 276 for (asmap = asm_h->stripeMap; asmap; asmap = asmap->next) { 277 asmap->numDataFailed = 0; 278 asmap->numParityFailed = 0; 279 asmap->numQFailed = 0; 280 asmap->numFailedPDAs = 0; 281 memset((char *) asmap->failedPDAs, 0, 282 RF_MAX_FAILED_PDA * sizeof(RF_PhysDiskAddr_t *)); 283 for (pda = asmap->physInfo; pda; pda = pda->next) { 284 if (RF_DEAD_DISK(disks[pda->col].status)) { 285 asmap->numDataFailed++; 286 asmap->failedPDAs[asmap->numFailedPDAs] = pda; 287 asmap->numFailedPDAs++; 288 } 289 } 290 pda = asmap->parityInfo; 291 if (pda && RF_DEAD_DISK(disks[pda->col].status)) { 292 asmap->numParityFailed++; 293 asmap->failedPDAs[asmap->numFailedPDAs] = pda; 294 asmap->numFailedPDAs++; 295 } 296 pda = asmap->qInfo; 297 if (pda && RF_DEAD_DISK(disks[pda->col].status)) { 298 asmap->numQFailed++; 299 asmap->failedPDAs[asmap->numFailedPDAs] = pda; 300 asmap->numFailedPDAs++; 301 } 302 } 303} 304 305/*************************************************************************** 306 * 307 * routines to allocate and free list elements. All allocation 308 * routines zero the structure before returning it. 309 * 310 * FreePhysDiskAddr is static. It should never be called directly, 311 * because FreeAccessStripeMap takes care of freeing the PhysDiskAddr 312 * list. 313 * 314 ***************************************************************************/ 315 316#define RF_MAX_FREE_ASMHDR 128 317#define RF_MIN_FREE_ASMHDR 32 318 319#define RF_MAX_FREE_ASM 192 320#define RF_MIN_FREE_ASM 64 321 322#define RF_MAX_FREE_PDA 192 323#define RF_MIN_FREE_PDA 64 324 325#define RF_MAX_FREE_ASMHLE 64 326#define RF_MIN_FREE_ASMHLE 16 327 328#define RF_MAX_FREE_FSS 128 329#define RF_MIN_FREE_FSS 32 330 331#define RF_MAX_FREE_VFPLE 128 332#define RF_MIN_FREE_VFPLE 32 333 334#define RF_MAX_FREE_VPLE 128 335#define RF_MIN_FREE_VPLE 32 336 337 338/* called at shutdown time. So far, all that is necessary is to 339 release all the free lists */ 340static void rf_ShutdownMapModule(void *); 341static void 342rf_ShutdownMapModule(void *ignored) 343{ 344 pool_destroy(&rf_pools.asm_hdr); 345 pool_destroy(&rf_pools.asmap); 346 pool_destroy(&rf_pools.asmhle); 347 pool_destroy(&rf_pools.pda); 348 pool_destroy(&rf_pools.fss); 349 pool_destroy(&rf_pools.vfple); 350 pool_destroy(&rf_pools.vple); 351} 352 353int 354rf_ConfigureMapModule(RF_ShutdownList_t **listp) 355{ 356 357 rf_pool_init(&rf_pools.asm_hdr, sizeof(RF_AccessStripeMapHeader_t), 358 "rf_asmhdr_pl", RF_MIN_FREE_ASMHDR, RF_MAX_FREE_ASMHDR); 359 rf_pool_init(&rf_pools.asmap, sizeof(RF_AccessStripeMap_t), 360 "rf_asm_pl", RF_MIN_FREE_ASM, RF_MAX_FREE_ASM); 361 rf_pool_init(&rf_pools.asmhle, sizeof(RF_ASMHeaderListElem_t), 362 "rf_asmhle_pl", RF_MIN_FREE_ASMHLE, RF_MAX_FREE_ASMHLE); 363 rf_pool_init(&rf_pools.pda, sizeof(RF_PhysDiskAddr_t), 364 "rf_pda_pl", RF_MIN_FREE_PDA, RF_MAX_FREE_PDA); 365 rf_pool_init(&rf_pools.fss, sizeof(RF_FailedStripe_t), 366 "rf_fss_pl", RF_MIN_FREE_FSS, RF_MAX_FREE_FSS); 367 rf_pool_init(&rf_pools.vfple, sizeof(RF_VoidFunctionPointerListElem_t), 368 "rf_vfple_pl", RF_MIN_FREE_VFPLE, RF_MAX_FREE_VFPLE); 369 rf_pool_init(&rf_pools.vple, sizeof(RF_VoidPointerListElem_t), 370 "rf_vple_pl", RF_MIN_FREE_VPLE, RF_MAX_FREE_VPLE); 371 rf_ShutdownCreate(listp, rf_ShutdownMapModule, NULL); 372 373 return (0); 374} 375 376RF_AccessStripeMapHeader_t * 377rf_AllocAccessStripeMapHeader(void) 378{ 379 RF_AccessStripeMapHeader_t *p; 380 381 p = pool_get(&rf_pools.asm_hdr, PR_WAITOK); 382 memset((char *) p, 0, sizeof(RF_AccessStripeMapHeader_t)); 383 384 return (p); 385} 386 387void 388rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t *p) 389{ 390 pool_put(&rf_pools.asm_hdr, p); 391} 392 393 394RF_VoidFunctionPointerListElem_t * 395rf_AllocVFPListElem(void) 396{ 397 RF_VoidFunctionPointerListElem_t *p; 398 399 p = pool_get(&rf_pools.vfple, PR_WAITOK); 400 memset((char *) p, 0, sizeof(RF_VoidFunctionPointerListElem_t)); 401 402 return (p); 403} 404 405void 406rf_FreeVFPListElem(RF_VoidFunctionPointerListElem_t *p) 407{ 408 409 pool_put(&rf_pools.vfple, p); 410} 411 412 413RF_VoidPointerListElem_t * 414rf_AllocVPListElem(void) 415{ 416 RF_VoidPointerListElem_t *p; 417 418 p = pool_get(&rf_pools.vple, PR_WAITOK); 419 memset((char *) p, 0, sizeof(RF_VoidPointerListElem_t)); 420 421 return (p); 422} 423 424void 425rf_FreeVPListElem(RF_VoidPointerListElem_t *p) 426{ 427 428 pool_put(&rf_pools.vple, p); 429} 430 431RF_ASMHeaderListElem_t * 432rf_AllocASMHeaderListElem(void) 433{ 434 RF_ASMHeaderListElem_t *p; 435 436 p = pool_get(&rf_pools.asmhle, PR_WAITOK); 437 memset((char *) p, 0, sizeof(RF_ASMHeaderListElem_t)); 438 439 return (p); 440} 441 442void 443rf_FreeASMHeaderListElem(RF_ASMHeaderListElem_t *p) 444{ 445 446 pool_put(&rf_pools.asmhle, p); 447} 448 449RF_FailedStripe_t * 450rf_AllocFailedStripeStruct(void) 451{ 452 RF_FailedStripe_t *p; 453 454 p = pool_get(&rf_pools.fss, PR_WAITOK); 455 memset((char *) p, 0, sizeof(RF_FailedStripe_t)); 456 457 return (p); 458} 459 460void 461rf_FreeFailedStripeStruct(RF_FailedStripe_t *p) 462{ 463 pool_put(&rf_pools.fss, p); 464} 465 466 467 468 469 470RF_PhysDiskAddr_t * 471rf_AllocPhysDiskAddr(void) 472{ 473 RF_PhysDiskAddr_t *p; 474 475 p = pool_get(&rf_pools.pda, PR_WAITOK); 476 memset((char *) p, 0, sizeof(RF_PhysDiskAddr_t)); 477 478 return (p); 479} 480/* allocates a list of PDAs, locking the free list only once when we 481 * have to call calloc, we do it one component at a time to simplify 482 * the process of freeing the list at program shutdown. This should 483 * not be much of a performance hit, because it should be very 484 * infrequently executed. */ 485RF_PhysDiskAddr_t * 486rf_AllocPDAList(int count) 487{ 488 RF_PhysDiskAddr_t *p, *prev; 489 int i; 490 491 p = NULL; 492 prev = NULL; 493 for (i = 0; i < count; i++) { 494 p = pool_get(&rf_pools.pda, PR_WAITOK); 495 p->next = prev; 496 prev = p; 497 } 498 499 return (p); 500} 501 502void 503rf_FreePhysDiskAddr(RF_PhysDiskAddr_t *p) 504{ 505 pool_put(&rf_pools.pda, p); 506} 507 508static void 509rf_FreePDAList(RF_PhysDiskAddr_t *pda_list) 510{ 511 RF_PhysDiskAddr_t *p, *tmp; 512 513 p=pda_list; 514 while (p) { 515 tmp = p->next; 516 pool_put(&rf_pools.pda, p); 517 p = tmp; 518 } 519} 520 521/* this is essentially identical to AllocPDAList. I should combine 522 * the two. when we have to call calloc, we do it one component at a 523 * time to simplify the process of freeing the list at program 524 * shutdown. This should not be much of a performance hit, because it 525 * should be very infrequently executed. */ 526RF_AccessStripeMap_t * 527rf_AllocASMList(int count) 528{ 529 RF_AccessStripeMap_t *p, *prev; 530 int i; 531 532 p = NULL; 533 prev = NULL; 534 for (i = 0; i < count; i++) { 535 p = pool_get(&rf_pools.asmap, PR_WAITOK); 536 p->next = prev; 537 prev = p; 538 } 539 return (p); 540} 541 542static void 543rf_FreeASMList(RF_AccessStripeMap_t *asm_list) 544{ 545 RF_AccessStripeMap_t *p, *tmp; 546 547 p=asm_list; 548 while (p) { 549 tmp = p->next; 550 pool_put(&rf_pools.asmap, p); 551 p = tmp; 552 } 553} 554 555void 556rf_FreeAccessStripeMap(RF_AccessStripeMapHeader_t *hdr) 557{ 558 RF_AccessStripeMap_t *p; 559 RF_PhysDiskAddr_t *pdp, *trailer, *pdaList = NULL, *pdaEnd = NULL; 560 int count = 0, t, asm_count = 0; 561 562 for (p = hdr->stripeMap; p; p = p->next) { 563 564 /* link the 3 pda lists into the accumulating pda list */ 565 566 if (!pdaList) 567 pdaList = p->qInfo; 568 else 569 pdaEnd->next = p->qInfo; 570 for (trailer = NULL, pdp = p->qInfo; pdp;) { 571 trailer = pdp; 572 pdp = pdp->next; 573 count++; 574 } 575 if (trailer) 576 pdaEnd = trailer; 577 578 if (!pdaList) 579 pdaList = p->parityInfo; 580 else 581 pdaEnd->next = p->parityInfo; 582 for (trailer = NULL, pdp = p->parityInfo; pdp;) { 583 trailer = pdp; 584 pdp = pdp->next; 585 count++; 586 } 587 if (trailer) 588 pdaEnd = trailer; 589 590 if (!pdaList) 591 pdaList = p->physInfo; 592 else 593 pdaEnd->next = p->physInfo; 594 for (trailer = NULL, pdp = p->physInfo; pdp;) { 595 trailer = pdp; 596 pdp = pdp->next; 597 count++; 598 } 599 if (trailer) 600 pdaEnd = trailer; 601 602 asm_count++; 603 } 604 605 /* debug only */ 606 for (t = 0, pdp = pdaList; pdp; pdp = pdp->next) 607 t++; 608 RF_ASSERT(t == count); 609 610 if (pdaList) 611 rf_FreePDAList(pdaList); 612 rf_FreeASMList(hdr->stripeMap); 613 rf_FreeAccessStripeMapHeader(hdr); 614} 615/* We can't use the large write optimization if there are any failures 616 * in the stripe. In the declustered layout, there is no way to 617 * immediately determine what disks constitute a stripe, so we 618 * actually have to hunt through the stripe looking for failures. The 619 * reason we map the parity instead of just using asm->parityInfo->col 620 * is because the latter may have been already redirected to a spare 621 * drive, which would mess up the computation of the stripe offset. 622 * 623 * ASSUMES AT MOST ONE FAILURE IN THE STRIPE. */ 624int 625rf_CheckStripeForFailures(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap) 626{ 627 RF_RowCol_t tcol, pcol, *diskids, i; 628 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 629 RF_StripeCount_t stripeOffset; 630 int numFailures; 631 RF_RaidAddr_t sosAddr; 632 RF_SectorNum_t diskOffset, poffset; 633 634 /* quick out in the fault-free case. */ 635 rf_lock_mutex2(raidPtr->mutex); 636 numFailures = raidPtr->numFailures; 637 rf_unlock_mutex2(raidPtr->mutex); 638 if (numFailures == 0) 639 return (0); 640 641 sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, 642 asmap->raidAddress); 643 (layoutPtr->map->IdentifyStripe) (raidPtr, asmap->raidAddress, 644 &diskids); 645 (layoutPtr->map->MapParity) (raidPtr, asmap->raidAddress, 646 &pcol, &poffset, 0); /* get pcol */ 647 648 /* this need not be true if we've redirected the access to a 649 * spare in another row RF_ASSERT(row == testrow); */ 650 stripeOffset = 0; 651 for (i = 0; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++) { 652 if (diskids[i] != pcol) { 653 if (RF_DEAD_DISK(raidPtr->Disks[diskids[i]].status)) { 654 if (raidPtr->status != rf_rs_reconstructing) 655 return (1); 656 RF_ASSERT(raidPtr->reconControl->fcol == diskids[i]); 657 layoutPtr->map->MapSector(raidPtr, 658 sosAddr + stripeOffset * layoutPtr->sectorsPerStripeUnit, 659 &tcol, &diskOffset, 0); 660 RF_ASSERT(tcol == diskids[i]); 661 if (!rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, diskOffset)) 662 return (1); 663 asmap->flags |= RF_ASM_REDIR_LARGE_WRITE; 664 return (0); 665 } 666 stripeOffset++; 667 } 668 } 669 return (0); 670} 671#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) || (RF_INCLUDE_EVENODD >0) 672/* 673 return the number of failed data units in the stripe. 674*/ 675 676int 677rf_NumFailedDataUnitsInStripe(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap) 678{ 679 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 680 RF_RowCol_t tcol, i; 681 RF_SectorNum_t diskOffset; 682 RF_RaidAddr_t sosAddr; 683 int numFailures; 684 685 /* quick out in the fault-free case. */ 686 rf_lock_mutex2(raidPtr->mutex); 687 numFailures = raidPtr->numFailures; 688 rf_unlock_mutex2(raidPtr->mutex); 689 if (numFailures == 0) 690 return (0); 691 numFailures = 0; 692 693 sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, 694 asmap->raidAddress); 695 for (i = 0; i < layoutPtr->numDataCol; i++) { 696 (layoutPtr->map->MapSector) (raidPtr, sosAddr + i * layoutPtr->sectorsPerStripeUnit, 697 &tcol, &diskOffset, 0); 698 if (RF_DEAD_DISK(raidPtr->Disks[tcol].status)) 699 numFailures++; 700 } 701 702 return numFailures; 703} 704#endif 705 706/**************************************************************************** 707 * 708 * debug routines 709 * 710 ***************************************************************************/ 711#if RF_DEBUG_MAP 712void 713rf_PrintAccessStripeMap(RF_AccessStripeMapHeader_t *asm_h) 714{ 715 rf_PrintFullAccessStripeMap(asm_h, 0); 716} 717#endif 718 719/* prbuf - flag to print buffer pointers */ 720void 721rf_PrintFullAccessStripeMap(RF_AccessStripeMapHeader_t *asm_h, int prbuf) 722{ 723 int i; 724 RF_AccessStripeMap_t *asmap = asm_h->stripeMap; 725 RF_PhysDiskAddr_t *p; 726 printf("%d stripes total\n", (int) asm_h->numStripes); 727 for (; asmap; asmap = asmap->next) { 728 /* printf("Num failures: %d\n",asmap->numDataFailed); */ 729 /* printf("Num sectors: 730 * %d\n",(int)asmap->totalSectorsAccessed); */ 731 printf("Stripe %d (%d sectors), failures: %d data, %d parity: ", 732 (int) asmap->stripeID, 733 (int) asmap->totalSectorsAccessed, 734 (int) asmap->numDataFailed, 735 (int) asmap->numParityFailed); 736 if (asmap->parityInfo) { 737 printf("Parity [c%d s%d-%d", asmap->parityInfo->col, 738 (int) asmap->parityInfo->startSector, 739 (int) (asmap->parityInfo->startSector + 740 asmap->parityInfo->numSector - 1)); 741 if (prbuf) 742 printf(" b0x%lx", (unsigned long) asmap->parityInfo->bufPtr); 743 if (asmap->parityInfo->next) { 744 printf(", c%d s%d-%d", asmap->parityInfo->next->col, 745 (int) asmap->parityInfo->next->startSector, 746 (int) (asmap->parityInfo->next->startSector + 747 asmap->parityInfo->next->numSector - 1)); 748 if (prbuf) 749 printf(" b0x%lx", (unsigned long) asmap->parityInfo->next->bufPtr); 750 RF_ASSERT(asmap->parityInfo->next->next == NULL); 751 } 752 printf("]\n\t"); 753 } 754 for (i = 0, p = asmap->physInfo; p; p = p->next, i++) { 755 printf("SU c%d s%d-%d ", p->col, (int) p->startSector, 756 (int) (p->startSector + p->numSector - 1)); 757 if (prbuf) 758 printf("b0x%lx ", (unsigned long) p->bufPtr); 759 if (i && !(i & 1)) 760 printf("\n\t"); 761 } 762 printf("\n"); 763 p = asm_h->stripeMap->failedPDAs[0]; 764 if (asm_h->stripeMap->numDataFailed + asm_h->stripeMap->numParityFailed > 1) 765 printf("[multiple failures]\n"); 766 else 767 if (asm_h->stripeMap->numDataFailed + asm_h->stripeMap->numParityFailed > 0) 768 printf("\t[Failed PDA: c%d s%d-%d]\n", p->col, 769 (int) p->startSector, (int) (p->startSector + p->numSector - 1)); 770 } 771} 772 773#if RF_MAP_DEBUG 774void 775rf_PrintRaidAddressInfo(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr, 776 RF_SectorCount_t numBlocks) 777{ 778 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 779 RF_RaidAddr_t ra, sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr); 780 781 printf("Raid addrs of SU boundaries from start of stripe to end of access:\n\t"); 782 for (ra = sosAddr; ra <= raidAddr + numBlocks; ra += layoutPtr->sectorsPerStripeUnit) { 783 printf("%d (0x%x), ", (int) ra, (int) ra); 784 } 785 printf("\n"); 786 printf("Offset into stripe unit: %d (0x%x)\n", 787 (int) (raidAddr % layoutPtr->sectorsPerStripeUnit), 788 (int) (raidAddr % layoutPtr->sectorsPerStripeUnit)); 789} 790#endif 791/* given a parity descriptor and the starting address within a stripe, 792 * range restrict the parity descriptor to touch only the correct 793 * stuff. */ 794void 795rf_ASMParityAdjust(RF_PhysDiskAddr_t *toAdjust, 796 RF_StripeNum_t startAddrWithinStripe, 797 RF_SectorNum_t endAddress, 798 RF_RaidLayout_t *layoutPtr, 799 RF_AccessStripeMap_t *asm_p) 800{ 801 RF_PhysDiskAddr_t *new_pda; 802 803 /* when we're accessing only a portion of one stripe unit, we 804 * want the parity descriptor to identify only the chunk of 805 * parity associated with the data. When the access spans 806 * exactly one stripe unit boundary and is less than a stripe 807 * unit in size, it uses two disjoint regions of the parity 808 * unit. When an access spans more than one stripe unit 809 * boundary, it uses all of the parity unit. 810 * 811 * To better handle the case where stripe units are small, we 812 * may eventually want to change the 2nd case so that if the 813 * SU size is below some threshold, we just read/write the 814 * whole thing instead of breaking it up into two accesses. */ 815 if (asm_p->numStripeUnitsAccessed == 1) { 816 int x = (startAddrWithinStripe % layoutPtr->sectorsPerStripeUnit); 817 toAdjust->startSector += x; 818 toAdjust->raidAddress += x; 819 toAdjust->numSector = asm_p->physInfo->numSector; 820 RF_ASSERT(toAdjust->numSector != 0); 821 } else 822 if (asm_p->numStripeUnitsAccessed == 2 && asm_p->totalSectorsAccessed < layoutPtr->sectorsPerStripeUnit) { 823 int x = (startAddrWithinStripe % layoutPtr->sectorsPerStripeUnit); 824 825 /* create a second pda and copy the parity map info 826 * into it */ 827 RF_ASSERT(toAdjust->next == NULL); 828 /* the following will get freed in rf_FreeAccessStripeMap() via 829 rf_FreePDAList() */ 830 new_pda = toAdjust->next = rf_AllocPhysDiskAddr(); 831 *new_pda = *toAdjust; /* structure assignment */ 832 new_pda->next = NULL; 833 834 /* adjust the start sector & number of blocks for the 835 * first parity pda */ 836 toAdjust->startSector += x; 837 toAdjust->raidAddress += x; 838 toAdjust->numSector = rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, startAddrWithinStripe) - startAddrWithinStripe; 839 RF_ASSERT(toAdjust->numSector != 0); 840 841 /* adjust the second pda */ 842 new_pda->numSector = endAddress - rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, endAddress); 843 /* new_pda->raidAddress = 844 * rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, 845 * toAdjust->raidAddress); */ 846 RF_ASSERT(new_pda->numSector != 0); 847 } 848} 849 850/* Check if a disk has been spared or failed. If spared, redirect the 851 * I/O. If it has been failed, record it in the asm pointer. Fourth 852 * arg is whether data or parity. */ 853void 854rf_ASMCheckStatus(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda_p, 855 RF_AccessStripeMap_t *asm_p, RF_RaidDisk_t *disks, 856 int parity) 857{ 858 RF_DiskStatus_t dstatus; 859 RF_RowCol_t fcol; 860 861 dstatus = disks[pda_p->col].status; 862 863 if (dstatus == rf_ds_spared) { 864 /* if the disk has been spared, redirect access to the spare */ 865 fcol = pda_p->col; 866 pda_p->col = disks[fcol].spareCol; 867 } else 868 if (dstatus == rf_ds_dist_spared) { 869 /* ditto if disk has been spared to dist spare space */ 870#if RF_DEBUG_MAP 871 RF_RowCol_t oc = pda_p->col; 872 RF_SectorNum_t oo = pda_p->startSector; 873#endif 874 if (pda_p->type == RF_PDA_TYPE_DATA) 875 raidPtr->Layout.map->MapSector(raidPtr, pda_p->raidAddress, &pda_p->col, &pda_p->startSector, RF_REMAP); 876 else 877 raidPtr->Layout.map->MapParity(raidPtr, pda_p->raidAddress, &pda_p->col, &pda_p->startSector, RF_REMAP); 878 879#if RF_DEBUG_MAP 880 if (rf_mapDebug) { 881 printf("Redirected c %d o %d -> c %d o %d\n", oc, (int) oo, 882 pda_p->col, (int) pda_p->startSector); 883 } 884#endif 885 } else 886 if (RF_DEAD_DISK(dstatus)) { 887 /* if the disk is inaccessible, mark the 888 * failure */ 889 if (parity) 890 asm_p->numParityFailed++; 891 else { 892 asm_p->numDataFailed++; 893 } 894 asm_p->failedPDAs[asm_p->numFailedPDAs] = pda_p; 895 asm_p->numFailedPDAs++; 896#if 0 897 switch (asm_p->numParityFailed + asm_p->numDataFailed) { 898 case 1: 899 asm_p->failedPDAs[0] = pda_p; 900 break; 901 case 2: 902 asm_p->failedPDAs[1] = pda_p; 903 default: 904 break; 905 } 906#endif 907 } 908 /* the redirected access should never span a stripe unit boundary */ 909 RF_ASSERT(rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress) == 910 rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress + pda_p->numSector - 1)); 911 RF_ASSERT(pda_p->col != -1); 912} 913