1 /* $NetBSD: rf_raid1.c,v 1.39 2021/07/23 22:34:12 oster Exp $ */ 2 /* 3 * Copyright (c) 1995 Carnegie-Mellon University. 4 * All rights reserved. 5 * 6 * Author: William V. Courtright II 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 (at) 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 * rf_raid1.c -- implements RAID Level 1 32 * 33 *****************************************************************************/ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: rf_raid1.c,v 1.39 2021/07/23 22:34:12 oster Exp $"); 37 38 #include "rf_raid.h" 39 #include "rf_raid1.h" 40 #include "rf_dag.h" 41 #include "rf_dagffrd.h" 42 #include "rf_dagffwr.h" 43 #include "rf_dagdegrd.h" 44 #include "rf_dagutils.h" 45 #include "rf_dagfuncs.h" 46 #include "rf_diskqueue.h" 47 #include "rf_general.h" 48 #include "rf_utils.h" 49 #include "rf_parityscan.h" 50 #include "rf_mcpair.h" 51 #include "rf_layout.h" 52 #include "rf_map.h" 53 #include "rf_engine.h" 54 #include "rf_reconbuffer.h" 55 56 typedef struct RF_Raid1ConfigInfo_s { 57 RF_RowCol_t **stripeIdentifier; 58 } RF_Raid1ConfigInfo_t; 59 /* start of day code specific to RAID level 1 */ 60 int 61 rf_ConfigureRAID1(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr, 62 RF_Config_t *cfgPtr) 63 { 64 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 65 RF_Raid1ConfigInfo_t *info; 66 RF_RowCol_t i; 67 68 /* Sanity check the number of columns... */ 69 if (raidPtr->numCol < 2 || raidPtr->numCol % 2 != 0) { 70 return (EINVAL); 71 } 72 73 /* create a RAID level 1 configuration structure */ 74 info = RF_MallocAndAdd(sizeof(*info), raidPtr->cleanupList); 75 if (info == NULL) 76 return (ENOMEM); 77 layoutPtr->layoutSpecificInfo = (void *) info; 78 79 /* ... and fill it in. */ 80 info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2, raidPtr->cleanupList); 81 if (info->stripeIdentifier == NULL) 82 return (ENOMEM); 83 for (i = 0; i < (raidPtr->numCol / 2); i++) { 84 info->stripeIdentifier[i][0] = (2 * i); 85 info->stripeIdentifier[i][1] = (2 * i) + 1; 86 } 87 88 /* this implementation of RAID level 1 uses one row of numCol disks 89 * and allows multiple (numCol / 2) stripes per row. A stripe 90 * consists of a single data unit and a single parity (mirror) unit. 91 * stripe id = raidAddr / stripeUnitSize */ 92 raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit; 93 layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2); 94 layoutPtr->dataSectorsPerStripe = layoutPtr->sectorsPerStripeUnit; 95 layoutPtr->numDataCol = 1; 96 layoutPtr->numParityCol = 1; 97 return (0); 98 } 99 100 101 /* returns the physical disk location of the primary copy in the mirror pair */ 102 void 103 rf_MapSectorRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector, 104 RF_RowCol_t *col, RF_SectorNum_t *diskSector, 105 int remap) 106 { 107 RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit; 108 RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2); 109 110 *col = 2 * mirrorPair; 111 *diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit); 112 } 113 114 115 /* Map Parity 116 * 117 * returns the physical disk location of the secondary copy in the mirror 118 * pair 119 */ 120 void 121 rf_MapParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector, 122 RF_RowCol_t *col, RF_SectorNum_t *diskSector, 123 int remap) 124 { 125 RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit; 126 RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2); 127 128 *col = (2 * mirrorPair) + 1; 129 130 *diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit); 131 } 132 133 134 /* IdentifyStripeRAID1 135 * 136 * returns a list of disks for a given redundancy group 137 */ 138 void 139 rf_IdentifyStripeRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t addr, 140 RF_RowCol_t **diskids) 141 { 142 RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr); 143 RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo; 144 RF_ASSERT(stripeID >= 0); 145 RF_ASSERT(addr >= 0); 146 *diskids = info->stripeIdentifier[stripeID % (raidPtr->numCol / 2)]; 147 RF_ASSERT(*diskids); 148 } 149 150 151 /* MapSIDToPSIDRAID1 152 * 153 * maps a logical stripe to a stripe in the redundant array 154 */ 155 void 156 rf_MapSIDToPSIDRAID1(RF_RaidLayout_t *layoutPtr, 157 RF_StripeNum_t stripeID, 158 RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru) 159 { 160 *which_ru = 0; 161 *psID = stripeID; 162 } 163 164 165 166 /****************************************************************************** 167 * select a graph to perform a single-stripe access 168 * 169 * Parameters: raidPtr - description of the physical array 170 * type - type of operation (read or write) requested 171 * asmap - logical & physical addresses for this access 172 * createFunc - name of function to use to create the graph 173 *****************************************************************************/ 174 175 void 176 rf_RAID1DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type, 177 RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc) 178 { 179 RF_RowCol_t fcol, oc __unused; 180 RF_PhysDiskAddr_t *failedPDA; 181 int prior_recon; 182 RF_RowStatus_t rstat; 183 RF_SectorNum_t oo __unused; 184 185 186 RF_ASSERT(RF_IO_IS_R_OR_W(type)); 187 188 if (asmap->numDataFailed + asmap->numParityFailed > 1) { 189 #if RF_DEBUG_DAG 190 if (rf_dagDebug) 191 RF_ERRORMSG("Multiple disks failed in a single group! Aborting I/O operation.\n"); 192 #endif 193 *createFunc = NULL; 194 return; 195 } 196 if (asmap->numDataFailed + asmap->numParityFailed) { 197 /* 198 * We've got a fault. Re-map to spare space, iff applicable. 199 * Shouldn't the arch-independent code do this for us? 200 * Anyway, it turns out if we don't do this here, then when 201 * we're reconstructing, writes go only to the surviving 202 * original disk, and aren't reflected on the reconstructed 203 * spare. Oops. --jimz 204 */ 205 failedPDA = asmap->failedPDAs[0]; 206 fcol = failedPDA->col; 207 rstat = raidPtr->status; 208 prior_recon = (rstat == rf_rs_reconfigured) || ( 209 (rstat == rf_rs_reconstructing) ? 210 rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, failedPDA->startSector) : 0 211 ); 212 if (prior_recon) { 213 oc = fcol; 214 oo = failedPDA->startSector; 215 /* 216 * If we did distributed sparing, we'd monkey with that here. 217 * But we don't, so we'll 218 */ 219 failedPDA->col = raidPtr->Disks[fcol].spareCol; 220 /* 221 * Redirect other components, iff necessary. This looks 222 * pretty suspicious to me, but it's what the raid5 223 * DAG select does. 224 */ 225 if (asmap->parityInfo->next) { 226 if (failedPDA == asmap->parityInfo) { 227 failedPDA->next->col = failedPDA->col; 228 } else { 229 if (failedPDA == asmap->parityInfo->next) { 230 asmap->parityInfo->col = failedPDA->col; 231 } 232 } 233 } 234 #if RF_DEBUG_DAG > 0 || RF_DEBUG_MAP > 0 235 if (rf_dagDebug || rf_mapDebug) { 236 printf("raid%d: Redirected type '%c' c %d o %ld -> c %d o %ld\n", 237 raidPtr->raidid, type, oc, 238 (long) oo, 239 failedPDA->col, 240 (long) failedPDA->startSector); 241 } 242 #endif 243 asmap->numDataFailed = asmap->numParityFailed = 0; 244 } 245 } 246 if (type == RF_IO_TYPE_READ) { 247 if (asmap->numDataFailed == 0) 248 *createFunc = (RF_VoidFuncPtr) rf_CreateMirrorIdleReadDAG; 249 else 250 *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG; 251 } else { 252 *createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG; 253 } 254 } 255 256 int 257 rf_VerifyParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr, 258 RF_PhysDiskAddr_t *parityPDA, int correct_it, 259 RF_RaidAccessFlags_t flags) 260 { 261 int nbytes, bcount, stripeWidth, ret, i, j, nbad, *bbufs; 262 RF_DagNode_t *blockNode, *wrBlock; 263 RF_DagHeader_t *rd_dag_h, *wr_dag_h; 264 RF_AccessStripeMapHeader_t *asm_h; 265 RF_AllocListElem_t *allocList; 266 #if RF_ACC_TRACE > 0 267 RF_AccTraceEntry_t tracerec; 268 #endif 269 RF_ReconUnitNum_t which_ru; 270 RF_RaidLayout_t *layoutPtr; 271 RF_AccessStripeMap_t *aasm; 272 RF_SectorCount_t nsector; 273 RF_RaidAddr_t startAddr; 274 char *bf, *buf1, *buf2; 275 RF_PhysDiskAddr_t *pda; 276 RF_StripeNum_t psID; 277 RF_MCPair_t *mcpair; 278 279 layoutPtr = &raidPtr->Layout; 280 startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr); 281 nsector = parityPDA->numSector; 282 nbytes = rf_RaidAddressToByte(raidPtr, nsector); 283 psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru); 284 285 asm_h = NULL; 286 rd_dag_h = wr_dag_h = NULL; 287 mcpair = NULL; 288 289 ret = RF_PARITY_COULD_NOT_VERIFY; 290 291 rf_MakeAllocList(allocList); 292 if (allocList == NULL) 293 return (RF_PARITY_COULD_NOT_VERIFY); 294 mcpair = rf_AllocMCPair(raidPtr); 295 if (mcpair == NULL) 296 goto done; 297 RF_ASSERT(layoutPtr->numDataCol == layoutPtr->numParityCol); 298 stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol; 299 bcount = nbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol); 300 bf = RF_MallocAndAdd(bcount, allocList); 301 if (bf == NULL) 302 goto done; 303 #if RF_DEBUG_VERIFYPARITY 304 if (rf_verifyParityDebug) { 305 printf("raid%d: RAID1 parity verify: buf=%lx bcount=%d (%lx - %lx)\n", 306 raidPtr->raidid, (long) bf, bcount, (long) bf, 307 (long) bf + bcount); 308 } 309 #endif 310 /* 311 * Generate a DAG which will read the entire stripe- then we can 312 * just compare data chunks versus "parity" chunks. 313 */ 314 315 rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, nbytes, bf, 316 rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rod", allocList, flags, 317 RF_IO_NORMAL_PRIORITY); 318 if (rd_dag_h == NULL) 319 goto done; 320 blockNode = rd_dag_h->succedents[0]; 321 322 /* 323 * Map the access to physical disk addresses (PDAs)- this will 324 * get us both a list of data addresses, and "parity" addresses 325 * (which are really mirror copies). 326 */ 327 asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe, 328 bf, RF_DONT_REMAP); 329 aasm = asm_h->stripeMap; 330 331 buf1 = bf; 332 /* 333 * Loop through the data blocks, setting up read nodes for each. 334 */ 335 for (pda = aasm->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) { 336 RF_ASSERT(pda); 337 338 rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1); 339 340 RF_ASSERT(pda->numSector != 0); 341 if (rf_TryToRedirectPDA(raidPtr, pda, 0)) { 342 /* cannot verify parity with dead disk */ 343 goto done; 344 } 345 pda->bufPtr = buf1; 346 blockNode->succedents[i]->params[0].p = pda; 347 blockNode->succedents[i]->params[1].p = buf1; 348 blockNode->succedents[i]->params[2].v = psID; 349 blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru); 350 buf1 += nbytes; 351 } 352 RF_ASSERT(pda == NULL); 353 /* 354 * keep i, buf1 running 355 * 356 * Loop through parity blocks, setting up read nodes for each. 357 */ 358 for (pda = aasm->parityInfo; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++, pda = pda->next) { 359 RF_ASSERT(pda); 360 rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1); 361 RF_ASSERT(pda->numSector != 0); 362 if (rf_TryToRedirectPDA(raidPtr, pda, 0)) { 363 /* cannot verify parity with dead disk */ 364 goto done; 365 } 366 pda->bufPtr = buf1; 367 blockNode->succedents[i]->params[0].p = pda; 368 blockNode->succedents[i]->params[1].p = buf1; 369 blockNode->succedents[i]->params[2].v = psID; 370 blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru); 371 buf1 += nbytes; 372 } 373 RF_ASSERT(pda == NULL); 374 375 #if RF_ACC_TRACE > 0 376 memset(&tracerec, 0, sizeof(tracerec)); 377 rd_dag_h->tracerec = &tracerec; 378 #endif 379 #if 0 380 if (rf_verifyParityDebug > 1) { 381 printf("raid%d: RAID1 parity verify read dag:\n", 382 raidPtr->raidid); 383 rf_PrintDAGList(rd_dag_h); 384 } 385 #endif 386 RF_LOCK_MCPAIR(mcpair); 387 mcpair->flag = 0; 388 RF_UNLOCK_MCPAIR(mcpair); 389 390 rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc, 391 (void *) mcpair); 392 393 RF_LOCK_MCPAIR(mcpair); 394 while (mcpair->flag == 0) { 395 RF_WAIT_MCPAIR(mcpair); 396 } 397 RF_UNLOCK_MCPAIR(mcpair); 398 399 if (rd_dag_h->status != rf_enable) { 400 RF_ERRORMSG("Unable to verify raid1 parity: can't read stripe\n"); 401 ret = RF_PARITY_COULD_NOT_VERIFY; 402 goto done; 403 } 404 /* 405 * buf1 is the beginning of the data blocks chunk 406 * buf2 is the beginning of the parity blocks chunk 407 */ 408 buf1 = bf; 409 buf2 = bf + (nbytes * layoutPtr->numDataCol); 410 ret = RF_PARITY_OKAY; 411 /* 412 * bbufs is "bad bufs"- an array whose entries are the data 413 * column numbers where we had miscompares. (That is, column 0 414 * and column 1 of the array are mirror copies, and are considered 415 * "data column 0" for this purpose). 416 */ 417 bbufs = RF_MallocAndAdd(layoutPtr->numParityCol * sizeof(*bbufs), 418 allocList); 419 nbad = 0; 420 /* 421 * Check data vs "parity" (mirror copy). 422 */ 423 for (i = 0; i < layoutPtr->numDataCol; i++) { 424 #if RF_DEBUG_VERIFYPARITY 425 if (rf_verifyParityDebug) { 426 printf("raid%d: RAID1 parity verify %d bytes: i=%d buf1=%lx buf2=%lx buf=%lx\n", 427 raidPtr->raidid, nbytes, i, (long) buf1, 428 (long) buf2, (long) bf); 429 } 430 #endif 431 ret = memcmp(buf1, buf2, nbytes); 432 if (ret) { 433 #if RF_DEBUG_VERIFYPARITY 434 if (rf_verifyParityDebug > 1) { 435 for (j = 0; j < nbytes; j++) { 436 if (buf1[j] != buf2[j]) 437 break; 438 } 439 printf("psid=%ld j=%d\n", (long) psID, j); 440 printf("buf1 %02x %02x %02x %02x %02x\n", buf1[0] & 0xff, 441 buf1[1] & 0xff, buf1[2] & 0xff, buf1[3] & 0xff, buf1[4] & 0xff); 442 printf("buf2 %02x %02x %02x %02x %02x\n", buf2[0] & 0xff, 443 buf2[1] & 0xff, buf2[2] & 0xff, buf2[3] & 0xff, buf2[4] & 0xff); 444 } 445 if (rf_verifyParityDebug) { 446 printf("raid%d: RAID1: found bad parity, i=%d\n", raidPtr->raidid, i); 447 } 448 #endif 449 /* 450 * Parity is bad. Keep track of which columns were bad. 451 */ 452 if (bbufs) 453 bbufs[nbad] = i; 454 nbad++; 455 ret = RF_PARITY_BAD; 456 } 457 buf1 += nbytes; 458 buf2 += nbytes; 459 } 460 461 if ((ret != RF_PARITY_OKAY) && correct_it) { 462 ret = RF_PARITY_COULD_NOT_CORRECT; 463 #if RF_DEBUG_VERIFYPARITY 464 if (rf_verifyParityDebug) { 465 printf("raid%d: RAID1 parity verify: parity not correct\n", raidPtr->raidid); 466 } 467 #endif 468 if (bbufs == NULL) 469 goto done; 470 /* 471 * Make a DAG with one write node for each bad unit. We'll simply 472 * write the contents of the data unit onto the parity unit for 473 * correction. (It's possible that the mirror copy was the correct 474 * copy, and that we're spooging good data by writing bad over it, 475 * but there's no way we can know that. 476 */ 477 wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, bf, 478 rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", allocList, flags, 479 RF_IO_NORMAL_PRIORITY); 480 if (wr_dag_h == NULL) 481 goto done; 482 wrBlock = wr_dag_h->succedents[0]; 483 /* 484 * Fill in a write node for each bad compare. 485 */ 486 for (i = 0; i < nbad; i++) { 487 j = i + layoutPtr->numDataCol; 488 pda = blockNode->succedents[j]->params[0].p; 489 pda->bufPtr = blockNode->succedents[i]->params[1].p; 490 wrBlock->succedents[i]->params[0].p = pda; 491 wrBlock->succedents[i]->params[1].p = pda->bufPtr; 492 wrBlock->succedents[i]->params[2].v = psID; 493 wrBlock->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru); 494 } 495 #if RF_ACC_TRACE > 0 496 memset(&tracerec, 0, sizeof(tracerec)); 497 wr_dag_h->tracerec = &tracerec; 498 #endif 499 #if 0 500 if (rf_verifyParityDebug > 1) { 501 printf("Parity verify write dag:\n"); 502 rf_PrintDAGList(wr_dag_h); 503 } 504 #endif 505 RF_LOCK_MCPAIR(mcpair); 506 mcpair->flag = 0; 507 RF_UNLOCK_MCPAIR(mcpair); 508 509 /* fire off the write DAG */ 510 rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc, 511 (void *) mcpair); 512 513 RF_LOCK_MCPAIR(mcpair); 514 while (!mcpair->flag) { 515 RF_WAIT_MCPAIR(mcpair); 516 } 517 RF_UNLOCK_MCPAIR(mcpair); 518 if (wr_dag_h->status != rf_enable) { 519 RF_ERRORMSG("Unable to correct RAID1 parity in VerifyParity\n"); 520 goto done; 521 } 522 ret = RF_PARITY_CORRECTED; 523 } 524 done: 525 /* 526 * All done. We might've gotten here without doing part of the function, 527 * so cleanup what we have to and return our running status. 528 */ 529 if (asm_h) 530 rf_FreeAccessStripeMap(raidPtr, asm_h); 531 if (rd_dag_h) 532 rf_FreeDAG(rd_dag_h); 533 if (wr_dag_h) 534 rf_FreeDAG(wr_dag_h); 535 if (mcpair) 536 rf_FreeMCPair(raidPtr, mcpair); 537 rf_FreeAllocList(allocList); 538 #if RF_DEBUG_VERIFYPARITY 539 if (rf_verifyParityDebug) { 540 printf("raid%d: RAID1 parity verify, returning %d\n", 541 raidPtr->raidid, ret); 542 } 543 #endif 544 return (ret); 545 } 546 547 /* rbuf - the recon buffer to submit 548 * keep_it - whether we can keep this buffer or we have to return it 549 * use_committed - whether to use a committed or an available recon buffer 550 */ 551 552 int 553 rf_SubmitReconBufferRAID1(RF_ReconBuffer_t *rbuf, int keep_it, 554 int use_committed) 555 { 556 RF_ReconParityStripeStatus_t *pssPtr; 557 RF_ReconCtrl_t *reconCtrlPtr; 558 int retcode; 559 RF_CallbackValueDesc_t *cb, *p; 560 RF_ReconBuffer_t *t; 561 RF_Raid_t *raidPtr; 562 void *ta; 563 564 retcode = 0; 565 566 raidPtr = rbuf->raidPtr; 567 reconCtrlPtr = raidPtr->reconControl; 568 569 RF_ASSERT(rbuf); 570 RF_ASSERT(rbuf->col != reconCtrlPtr->fcol); 571 572 #if RF_DEBUG_RECON 573 if (rf_reconbufferDebug) { 574 printf("raid%d: RAID1 reconbuffer submission c%d psid %ld ru%d (failed offset %ld)\n", 575 raidPtr->raidid, rbuf->col, 576 (long) rbuf->parityStripeID, rbuf->which_ru, 577 (long) rbuf->failedDiskSectorOffset); 578 } 579 #endif 580 if (rf_reconDebug) { 581 unsigned char *b = rbuf->buffer; 582 printf("RAID1 reconbuffer submit psid %ld buf %lx\n", 583 (long) rbuf->parityStripeID, (long) rbuf->buffer); 584 printf("RAID1 psid %ld %02x %02x %02x %02x %02x\n", 585 (long)rbuf->parityStripeID, b[0], b[1], b[2], b[3], b[4]); 586 } 587 RF_LOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID); 588 589 rf_lock_mutex2(reconCtrlPtr->rb_mutex); 590 while(reconCtrlPtr->rb_lock) { 591 rf_wait_cond2(reconCtrlPtr->rb_cv, reconCtrlPtr->rb_mutex); 592 } 593 reconCtrlPtr->rb_lock = 1; 594 rf_unlock_mutex2(reconCtrlPtr->rb_mutex); 595 596 pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable, 597 rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, NULL); 598 RF_ASSERT(pssPtr); /* if it didn't exist, we wouldn't have gotten 599 * an rbuf for it */ 600 601 /* 602 * Since this is simple mirroring, the first submission for a stripe is also 603 * treated as the last. 604 */ 605 606 t = NULL; 607 if (keep_it) { 608 #if RF_DEBUG_RECON 609 if (rf_reconbufferDebug) { 610 printf("raid%d: RAID1 rbuf submission: keeping rbuf\n", 611 raidPtr->raidid); 612 } 613 #endif 614 t = rbuf; 615 } else { 616 if (use_committed) { 617 #if RF_DEBUG_RECON 618 if (rf_reconbufferDebug) { 619 printf("raid%d: RAID1 rbuf submission: using committed rbuf\n", raidPtr->raidid); 620 } 621 #endif 622 t = reconCtrlPtr->committedRbufs; 623 RF_ASSERT(t); 624 reconCtrlPtr->committedRbufs = t->next; 625 t->next = NULL; 626 } else 627 if (reconCtrlPtr->floatingRbufs) { 628 #if RF_DEBUG_RECON 629 if (rf_reconbufferDebug) { 630 printf("raid%d: RAID1 rbuf submission: using floating rbuf\n", raidPtr->raidid); 631 } 632 #endif 633 t = reconCtrlPtr->floatingRbufs; 634 reconCtrlPtr->floatingRbufs = t->next; 635 t->next = NULL; 636 } 637 } 638 if (t == NULL) { 639 #if RF_DEBUG_RECON 640 if (rf_reconbufferDebug) { 641 printf("raid%d: RAID1 rbuf submission: waiting for rbuf\n", raidPtr->raidid); 642 } 643 #endif 644 RF_ASSERT((keep_it == 0) && (use_committed == 0)); 645 raidPtr->procsInBufWait++; 646 if ((raidPtr->procsInBufWait == (raidPtr->numCol - 1)) 647 && (raidPtr->numFullReconBuffers == 0)) { 648 /* ruh-ro */ 649 RF_ERRORMSG("Buffer wait deadlock\n"); 650 rf_PrintPSStatusTable(raidPtr); 651 RF_PANIC(); 652 } 653 pssPtr->flags |= RF_PSS_BUFFERWAIT; 654 cb = rf_AllocCallbackValueDesc(raidPtr); 655 cb->col = rbuf->col; 656 cb->v = rbuf->parityStripeID; 657 cb->next = NULL; 658 if (reconCtrlPtr->bufferWaitList == NULL) { 659 /* we are the wait list- lucky us */ 660 reconCtrlPtr->bufferWaitList = cb; 661 } else { 662 /* append to wait list */ 663 for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next); 664 p->next = cb; 665 } 666 retcode = 1; 667 goto out; 668 } 669 if (t != rbuf) { 670 t->col = reconCtrlPtr->fcol; 671 t->parityStripeID = rbuf->parityStripeID; 672 t->which_ru = rbuf->which_ru; 673 t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset; 674 t->spCol = rbuf->spCol; 675 t->spOffset = rbuf->spOffset; 676 /* Swap buffers. DANCE! */ 677 ta = t->buffer; 678 t->buffer = rbuf->buffer; 679 rbuf->buffer = ta; 680 } 681 /* 682 * Use the rbuf we've been given as the target. 683 */ 684 RF_ASSERT(pssPtr->rbuf == NULL); 685 pssPtr->rbuf = t; 686 687 t->count = 1; 688 /* 689 * Below, we use 1 for numDataCol (which is equal to the count in the 690 * previous line), so we'll always be done. 691 */ 692 rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, 1); 693 694 out: 695 RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->parityStripeID); 696 rf_lock_mutex2(reconCtrlPtr->rb_mutex); 697 reconCtrlPtr->rb_lock = 0; 698 rf_broadcast_cond2(reconCtrlPtr->rb_cv); 699 rf_unlock_mutex2(reconCtrlPtr->rb_mutex); 700 #if RF_DEBUG_RECON 701 if (rf_reconbufferDebug) { 702 printf("raid%d: RAID1 rbuf submission: returning %d\n", 703 raidPtr->raidid, retcode); 704 } 705 #endif 706 return (retcode); 707 } 708 709 RF_HeadSepLimit_t 710 rf_GetDefaultHeadSepLimitRAID1(RF_Raid_t *raidPtr) 711 { 712 return (10); 713 } 714 715
Indexes created Sat Sep 20 22:09:52 GMT 2025