rf_reconstruct.c revision 1.20
1/* $NetBSD: rf_reconstruct.c,v 1.20 2000/02/25 17:14:18 oster 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 * rf_reconstruct.c -- code to perform on-line reconstruction 32 * 33 ************************************************************/ 34 35#include "rf_types.h" 36#include <sys/time.h> 37#include <sys/buf.h> 38#include <sys/errno.h> 39 40#include <sys/types.h> 41#include <sys/param.h> 42#include <sys/systm.h> 43#include <sys/proc.h> 44#include <sys/ioctl.h> 45#include <sys/fcntl.h> 46#include <sys/vnode.h> 47 48 49#include "rf_raid.h" 50#include "rf_reconutil.h" 51#include "rf_revent.h" 52#include "rf_reconbuffer.h" 53#include "rf_acctrace.h" 54#include "rf_etimer.h" 55#include "rf_dag.h" 56#include "rf_desc.h" 57#include "rf_general.h" 58#include "rf_freelist.h" 59#include "rf_debugprint.h" 60#include "rf_driver.h" 61#include "rf_utils.h" 62#include "rf_shutdown.h" 63 64#include "rf_kintf.h" 65 66/* setting these to -1 causes them to be set to their default values if not set by debug options */ 67 68#define Dprintf(s) if (rf_reconDebug) rf_debug_printf(s,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL) 69#define Dprintf1(s,a) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL) 70#define Dprintf2(s,a,b) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL) 71#define Dprintf3(s,a,b,c) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL) 72#define Dprintf4(s,a,b,c,d) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),NULL,NULL,NULL,NULL) 73#define Dprintf5(s,a,b,c,d,e) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),NULL,NULL,NULL) 74#define Dprintf6(s,a,b,c,d,e,f) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),NULL,NULL) 75#define Dprintf7(s,a,b,c,d,e,f,g) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),(void *)((unsigned long)g),NULL) 76 77#define DDprintf1(s,a) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL) 78#define DDprintf2(s,a,b) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL) 79 80static RF_FreeList_t *rf_recond_freelist; 81#define RF_MAX_FREE_RECOND 4 82#define RF_RECOND_INC 1 83 84static RF_RaidReconDesc_t * 85AllocRaidReconDesc(RF_Raid_t * raidPtr, 86 RF_RowCol_t row, RF_RowCol_t col, RF_RaidDisk_t * spareDiskPtr, 87 int numDisksDone, RF_RowCol_t srow, RF_RowCol_t scol); 88static void FreeReconDesc(RF_RaidReconDesc_t * reconDesc); 89static int 90ProcessReconEvent(RF_Raid_t * raidPtr, RF_RowCol_t frow, 91 RF_ReconEvent_t * event); 92static int 93IssueNextReadRequest(RF_Raid_t * raidPtr, RF_RowCol_t row, 94 RF_RowCol_t col); 95static int TryToRead(RF_Raid_t * raidPtr, RF_RowCol_t row, RF_RowCol_t col); 96static int 97ComputePSDiskOffsets(RF_Raid_t * raidPtr, RF_StripeNum_t psid, 98 RF_RowCol_t row, RF_RowCol_t col, RF_SectorNum_t * outDiskOffset, 99 RF_SectorNum_t * outFailedDiskSectorOffset, RF_RowCol_t * spRow, 100 RF_RowCol_t * spCol, RF_SectorNum_t * spOffset); 101static int IssueNextWriteRequest(RF_Raid_t * raidPtr, RF_RowCol_t row); 102static int ReconReadDoneProc(void *arg, int status); 103static int ReconWriteDoneProc(void *arg, int status); 104static void 105CheckForNewMinHeadSep(RF_Raid_t * raidPtr, RF_RowCol_t row, 106 RF_HeadSepLimit_t hsCtr); 107static int 108CheckHeadSeparation(RF_Raid_t * raidPtr, RF_PerDiskReconCtrl_t * ctrl, 109 RF_RowCol_t row, RF_RowCol_t col, RF_HeadSepLimit_t hsCtr, 110 RF_ReconUnitNum_t which_ru); 111static int 112CheckForcedOrBlockedReconstruction(RF_Raid_t * raidPtr, 113 RF_ReconParityStripeStatus_t * pssPtr, RF_PerDiskReconCtrl_t * ctrl, 114 RF_RowCol_t row, RF_RowCol_t col, RF_StripeNum_t psid, 115 RF_ReconUnitNum_t which_ru); 116static void ForceReconReadDoneProc(void *arg, int status); 117 118static void rf_ShutdownReconstruction(void *); 119 120struct RF_ReconDoneProc_s { 121 void (*proc) (RF_Raid_t *, void *); 122 void *arg; 123 RF_ReconDoneProc_t *next; 124}; 125 126static RF_FreeList_t *rf_rdp_freelist; 127#define RF_MAX_FREE_RDP 4 128#define RF_RDP_INC 1 129 130static void 131SignalReconDone(RF_Raid_t * raidPtr) 132{ 133 RF_ReconDoneProc_t *p; 134 135 RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex); 136 for (p = raidPtr->recon_done_procs; p; p = p->next) { 137 p->proc(raidPtr, p->arg); 138 } 139 RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex); 140} 141 142int 143rf_RegisterReconDoneProc( 144 RF_Raid_t * raidPtr, 145 void (*proc) (RF_Raid_t *, void *), 146 void *arg, 147 RF_ReconDoneProc_t ** handlep) 148{ 149 RF_ReconDoneProc_t *p; 150 151 RF_FREELIST_GET(rf_rdp_freelist, p, next, (RF_ReconDoneProc_t *)); 152 if (p == NULL) 153 return (ENOMEM); 154 p->proc = proc; 155 p->arg = arg; 156 RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex); 157 p->next = raidPtr->recon_done_procs; 158 raidPtr->recon_done_procs = p; 159 RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex); 160 if (handlep) 161 *handlep = p; 162 return (0); 163} 164/************************************************************************** 165 * 166 * sets up the parameters that will be used by the reconstruction process 167 * currently there are none, except for those that the layout-specific 168 * configuration (e.g. rf_ConfigureDeclustered) routine sets up. 169 * 170 * in the kernel, we fire off the recon thread. 171 * 172 **************************************************************************/ 173static void 174rf_ShutdownReconstruction(ignored) 175 void *ignored; 176{ 177 RF_FREELIST_DESTROY(rf_recond_freelist, next, (RF_RaidReconDesc_t *)); 178 RF_FREELIST_DESTROY(rf_rdp_freelist, next, (RF_ReconDoneProc_t *)); 179} 180 181int 182rf_ConfigureReconstruction(listp) 183 RF_ShutdownList_t **listp; 184{ 185 int rc; 186 187 RF_FREELIST_CREATE(rf_recond_freelist, RF_MAX_FREE_RECOND, 188 RF_RECOND_INC, sizeof(RF_RaidReconDesc_t)); 189 if (rf_recond_freelist == NULL) 190 return (ENOMEM); 191 RF_FREELIST_CREATE(rf_rdp_freelist, RF_MAX_FREE_RDP, 192 RF_RDP_INC, sizeof(RF_ReconDoneProc_t)); 193 if (rf_rdp_freelist == NULL) { 194 RF_FREELIST_DESTROY(rf_recond_freelist, next, (RF_RaidReconDesc_t *)); 195 return (ENOMEM); 196 } 197 rc = rf_ShutdownCreate(listp, rf_ShutdownReconstruction, NULL); 198 if (rc) { 199 RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", 200 __FILE__, __LINE__, rc); 201 rf_ShutdownReconstruction(NULL); 202 return (rc); 203 } 204 return (0); 205} 206 207static RF_RaidReconDesc_t * 208AllocRaidReconDesc(raidPtr, row, col, spareDiskPtr, numDisksDone, srow, scol) 209 RF_Raid_t *raidPtr; 210 RF_RowCol_t row; 211 RF_RowCol_t col; 212 RF_RaidDisk_t *spareDiskPtr; 213 int numDisksDone; 214 RF_RowCol_t srow; 215 RF_RowCol_t scol; 216{ 217 218 RF_RaidReconDesc_t *reconDesc; 219 220 RF_FREELIST_GET(rf_recond_freelist, reconDesc, next, (RF_RaidReconDesc_t *)); 221 222 reconDesc->raidPtr = raidPtr; 223 reconDesc->row = row; 224 reconDesc->col = col; 225 reconDesc->spareDiskPtr = spareDiskPtr; 226 reconDesc->numDisksDone = numDisksDone; 227 reconDesc->srow = srow; 228 reconDesc->scol = scol; 229 reconDesc->state = 0; 230 reconDesc->next = NULL; 231 232 return (reconDesc); 233} 234 235static void 236FreeReconDesc(reconDesc) 237 RF_RaidReconDesc_t *reconDesc; 238{ 239#if RF_RECON_STATS > 0 240 printf("RAIDframe: %lu recon event waits, %lu recon delays\n", 241 (long) reconDesc->numReconEventWaits, (long) reconDesc->numReconExecDelays); 242#endif /* RF_RECON_STATS > 0 */ 243 printf("RAIDframe: %lu max exec ticks\n", 244 (long) reconDesc->maxReconExecTicks); 245#if (RF_RECON_STATS > 0) || defined(KERNEL) 246 printf("\n"); 247#endif /* (RF_RECON_STATS > 0) || KERNEL */ 248 RF_FREELIST_FREE(rf_recond_freelist, reconDesc, next); 249} 250 251 252/***************************************************************************** 253 * 254 * primary routine to reconstruct a failed disk. This should be called from 255 * within its own thread. It won't return until reconstruction completes, 256 * fails, or is aborted. 257 *****************************************************************************/ 258int 259rf_ReconstructFailedDisk(raidPtr, row, col) 260 RF_Raid_t *raidPtr; 261 RF_RowCol_t row; 262 RF_RowCol_t col; 263{ 264 RF_LayoutSW_t *lp; 265 int rc; 266 267 lp = raidPtr->Layout.map; 268 if (lp->SubmitReconBuffer) { 269 /* 270 * The current infrastructure only supports reconstructing one 271 * disk at a time for each array. 272 */ 273 RF_LOCK_MUTEX(raidPtr->mutex); 274 while (raidPtr->reconInProgress) { 275 RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex); 276 } 277 raidPtr->reconInProgress++; 278 RF_UNLOCK_MUTEX(raidPtr->mutex); 279 rc = rf_ReconstructFailedDiskBasic(raidPtr, row, col); 280 RF_LOCK_MUTEX(raidPtr->mutex); 281 raidPtr->reconInProgress--; 282 RF_UNLOCK_MUTEX(raidPtr->mutex); 283 } else { 284 RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n", 285 lp->parityConfig); 286 rc = EIO; 287 } 288 RF_SIGNAL_COND(raidPtr->waitForReconCond); 289 wakeup(&raidPtr->waitForReconCond); /* XXX Methinks this will be 290 * needed at some point... GO */ 291 return (rc); 292} 293 294int 295rf_ReconstructFailedDiskBasic(raidPtr, row, col) 296 RF_Raid_t *raidPtr; 297 RF_RowCol_t row; 298 RF_RowCol_t col; 299{ 300 RF_ComponentLabel_t c_label; 301 RF_RaidDisk_t *spareDiskPtr = NULL; 302 RF_RaidReconDesc_t *reconDesc; 303 RF_RowCol_t srow, scol; 304 int numDisksDone = 0, rc; 305 306 /* first look for a spare drive onto which to reconstruct the data */ 307 /* spare disk descriptors are stored in row 0. This may have to 308 * change eventually */ 309 310 RF_LOCK_MUTEX(raidPtr->mutex); 311 RF_ASSERT(raidPtr->Disks[row][col].status == rf_ds_failed); 312 313 if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) { 314 if (raidPtr->status[row] != rf_rs_degraded) { 315 RF_ERRORMSG2("Unable to reconstruct disk at row %d col %d because status not degraded\n", row, col); 316 RF_UNLOCK_MUTEX(raidPtr->mutex); 317 return (EINVAL); 318 } 319 srow = row; 320 scol = (-1); 321 } else { 322 srow = 0; 323 for (scol = raidPtr->numCol; scol < raidPtr->numCol + raidPtr->numSpare; scol++) { 324 if (raidPtr->Disks[srow][scol].status == rf_ds_spare) { 325 spareDiskPtr = &raidPtr->Disks[srow][scol]; 326 spareDiskPtr->status = rf_ds_used_spare; 327 break; 328 } 329 } 330 if (!spareDiskPtr) { 331 RF_ERRORMSG2("Unable to reconstruct disk at row %d col %d because no spares are available\n", row, col); 332 RF_UNLOCK_MUTEX(raidPtr->mutex); 333 return (ENOSPC); 334 } 335 printf("RECON: initiating reconstruction on row %d col %d -> spare at row %d col %d\n", row, col, srow, scol); 336 } 337 RF_UNLOCK_MUTEX(raidPtr->mutex); 338 339 reconDesc = AllocRaidReconDesc((void *) raidPtr, row, col, spareDiskPtr, numDisksDone, srow, scol); 340 raidPtr->reconDesc = (void *) reconDesc; 341#if RF_RECON_STATS > 0 342 reconDesc->hsStallCount = 0; 343 reconDesc->numReconExecDelays = 0; 344 reconDesc->numReconEventWaits = 0; 345#endif /* RF_RECON_STATS > 0 */ 346 reconDesc->reconExecTimerRunning = 0; 347 reconDesc->reconExecTicks = 0; 348 reconDesc->maxReconExecTicks = 0; 349 rc = rf_ContinueReconstructFailedDisk(reconDesc); 350 351 if (!rc) { 352 /* fix up the component label */ 353 /* Don't actually need the read here.. */ 354 raidread_component_label( 355 raidPtr->raid_cinfo[srow][scol].ci_dev, 356 raidPtr->raid_cinfo[srow][scol].ci_vp, 357 &c_label); 358 359 raid_init_component_label( raidPtr, &c_label); 360 c_label.row = row; 361 c_label.column = col; 362 c_label.clean = RF_RAID_DIRTY; 363 c_label.status = rf_ds_optimal; 364 365 /* XXXX MORE NEEDED HERE */ 366 367 raidwrite_component_label( 368 raidPtr->raid_cinfo[srow][scol].ci_dev, 369 raidPtr->raid_cinfo[srow][scol].ci_vp, 370 &c_label); 371 372 } 373 return (rc); 374} 375 376/* 377 378 Allow reconstructing a disk in-place -- i.e. component /dev/sd2e goes AWOL, 379 and you don't get a spare until the next Monday. With this function 380 (and hot-swappable drives) you can now put your new disk containing 381 /dev/sd2e on the bus, scsictl it alive, and then use raidctl(8) to 382 rebuild the data "on the spot". 383 384*/ 385 386int 387rf_ReconstructInPlace(raidPtr, row, col) 388 RF_Raid_t *raidPtr; 389 RF_RowCol_t row; 390 RF_RowCol_t col; 391{ 392 RF_RaidDisk_t *spareDiskPtr = NULL; 393 RF_RaidReconDesc_t *reconDesc; 394 RF_LayoutSW_t *lp; 395 RF_RaidDisk_t *badDisk; 396 RF_ComponentLabel_t c_label; 397 int numDisksDone = 0, rc; 398 struct partinfo dpart; 399 struct vnode *vp; 400 struct vattr va; 401 struct proc *proc; 402 int retcode; 403 404 lp = raidPtr->Layout.map; 405 if (lp->SubmitReconBuffer) { 406 /* 407 * The current infrastructure only supports reconstructing one 408 * disk at a time for each array. 409 */ 410 RF_LOCK_MUTEX(raidPtr->mutex); 411 if ((raidPtr->Disks[row][col].status == rf_ds_optimal) && 412 (raidPtr->numFailures > 0)) { 413 /* XXX 0 above shouldn't be constant!!! */ 414 /* some component other than this has failed. 415 Let's not make things worse than they already 416 are... */ 417 printf("RAIDFRAME: Unable to reconstruct to disk at:\n"); 418 printf(" Row: %d Col: %d Too many failures.\n", 419 row, col); 420 RF_UNLOCK_MUTEX(raidPtr->mutex); 421 return (EINVAL); 422 } 423 if (raidPtr->Disks[row][col].status == rf_ds_reconstructing) { 424 printf("RAIDFRAME: Unable to reconstruct to disk at:\n"); 425 printf(" Row: %d Col: %d Reconstruction already occuring!\n", row, col); 426 427 RF_UNLOCK_MUTEX(raidPtr->mutex); 428 return (EINVAL); 429 } 430 431 432 if (raidPtr->Disks[row][col].status != rf_ds_failed) { 433 /* "It's gone..." */ 434 raidPtr->numFailures++; 435 raidPtr->Disks[row][col].status = rf_ds_failed; 436 raidPtr->status[row] = rf_rs_degraded; 437 rf_update_component_labels(raidPtr); 438 } 439 440 while (raidPtr->reconInProgress) { 441 RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex); 442 } 443 444 raidPtr->reconInProgress++; 445 446 447 /* first look for a spare drive onto which to reconstruct 448 the data. spare disk descriptors are stored in row 0. 449 This may have to change eventually */ 450 451 /* Actually, we don't care if it's failed or not... 452 On a RAID set with correct parity, this function 453 should be callable on any component without ill affects. */ 454 /* RF_ASSERT(raidPtr->Disks[row][col].status == rf_ds_failed); 455 */ 456 457 if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) { 458 RF_ERRORMSG2("Unable to reconstruct to disk at row %d col %d: operation not supported for RF_DISTRIBUTE_SPARE\n", row, col); 459 460 raidPtr->reconInProgress--; 461 RF_UNLOCK_MUTEX(raidPtr->mutex); 462 return (EINVAL); 463 } 464 465 /* XXX need goop here to see if the disk is alive, 466 and, if not, make it so... */ 467 468 469 470 badDisk = &raidPtr->Disks[row][col]; 471 472 proc = raidPtr->engine_thread; 473 474 /* This device may have been opened successfully the 475 first time. Close it before trying to open it again.. */ 476 477 if (raidPtr->raid_cinfo[row][col].ci_vp != NULL) { 478 printf("Closed the open device: %s\n", 479 raidPtr->Disks[row][col].devname); 480 if (raidPtr->Disks[row][col].auto_configured == 1) { 481 VOP_CLOSE(raidPtr->raid_cinfo[row][col].ci_vp, 482 FREAD, NOCRED, 0); 483 vput(raidPtr->raid_cinfo[row][col].ci_vp); 484 485 } else { 486 VOP_UNLOCK(raidPtr->raid_cinfo[row][col].ci_vp, 0); 487 (void) vn_close(raidPtr->raid_cinfo[row][col].ci_vp, 488 FREAD | FWRITE, proc->p_ucred, proc); 489 } 490 raidPtr->raid_cinfo[row][col].ci_vp = NULL; 491 } 492 /* note that this disk was *not* auto_configured (any longer)*/ 493 raidPtr->Disks[row][col].auto_configured = 0; 494 495 printf("About to (re-)open the device for rebuilding: %s\n", 496 raidPtr->Disks[row][col].devname); 497 498 retcode = raidlookup(raidPtr->Disks[row][col].devname, 499 proc, &vp); 500 501 if (retcode) { 502 printf("raid%d: rebuilding: raidlookup on device: %s failed: %d!\n",raidPtr->raidid, 503 raidPtr->Disks[row][col].devname, retcode); 504 505 /* XXX the component isn't responding properly... 506 must be still dead :-( */ 507 raidPtr->reconInProgress--; 508 RF_UNLOCK_MUTEX(raidPtr->mutex); 509 return(retcode); 510 511 } else { 512 513 /* Ok, so we can at least do a lookup... 514 How about actually getting a vp for it? */ 515 516 if ((retcode = VOP_GETATTR(vp, &va, proc->p_ucred, 517 proc)) != 0) { 518 raidPtr->reconInProgress--; 519 RF_UNLOCK_MUTEX(raidPtr->mutex); 520 return(retcode); 521 } 522 retcode = VOP_IOCTL(vp, DIOCGPART, (caddr_t) & dpart, 523 FREAD, proc->p_ucred, proc); 524 if (retcode) { 525 raidPtr->reconInProgress--; 526 RF_UNLOCK_MUTEX(raidPtr->mutex); 527 return(retcode); 528 } 529 raidPtr->Disks[row][col].blockSize = 530 dpart.disklab->d_secsize; 531 532 raidPtr->Disks[row][col].numBlocks = 533 dpart.part->p_size - rf_protectedSectors; 534 535 raidPtr->raid_cinfo[row][col].ci_vp = vp; 536 raidPtr->raid_cinfo[row][col].ci_dev = va.va_rdev; 537 538 raidPtr->Disks[row][col].dev = va.va_rdev; 539 540 /* we allow the user to specify that only a 541 fraction of the disks should be used this is 542 just for debug: it speeds up 543 * the parity scan */ 544 raidPtr->Disks[row][col].numBlocks = 545 raidPtr->Disks[row][col].numBlocks * 546 rf_sizePercentage / 100; 547 } 548 549 550 551 spareDiskPtr = &raidPtr->Disks[row][col]; 552 spareDiskPtr->status = rf_ds_used_spare; 553 554 printf("RECON: initiating in-place reconstruction on\n"); 555 printf(" row %d col %d -> spare at row %d col %d\n", 556 row, col, row, col); 557 558 RF_UNLOCK_MUTEX(raidPtr->mutex); 559 560 reconDesc = AllocRaidReconDesc((void *) raidPtr, row, col, 561 spareDiskPtr, numDisksDone, 562 row, col); 563 raidPtr->reconDesc = (void *) reconDesc; 564#if RF_RECON_STATS > 0 565 reconDesc->hsStallCount = 0; 566 reconDesc->numReconExecDelays = 0; 567 reconDesc->numReconEventWaits = 0; 568#endif /* RF_RECON_STATS > 0 */ 569 reconDesc->reconExecTimerRunning = 0; 570 reconDesc->reconExecTicks = 0; 571 reconDesc->maxReconExecTicks = 0; 572 rc = rf_ContinueReconstructFailedDisk(reconDesc); 573 574 RF_LOCK_MUTEX(raidPtr->mutex); 575 raidPtr->reconInProgress--; 576 RF_UNLOCK_MUTEX(raidPtr->mutex); 577 578 } else { 579 RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n", 580 lp->parityConfig); 581 rc = EIO; 582 } 583 RF_LOCK_MUTEX(raidPtr->mutex); 584 585 if (!rc) { 586 /* Need to set these here, as at this point it'll be claiming 587 that the disk is in rf_ds_spared! But we know better :-) */ 588 589 raidPtr->Disks[row][col].status = rf_ds_optimal; 590 raidPtr->status[row] = rf_rs_optimal; 591 592 /* fix up the component label */ 593 /* Don't actually need the read here.. */ 594 raidread_component_label(raidPtr->raid_cinfo[row][col].ci_dev, 595 raidPtr->raid_cinfo[row][col].ci_vp, 596 &c_label); 597 598 raid_init_component_label(raidPtr, &c_label); 599 600 c_label.row = row; 601 c_label.column = col; 602 603 raidwrite_component_label(raidPtr->raid_cinfo[row][col].ci_dev, 604 raidPtr->raid_cinfo[row][col].ci_vp, 605 &c_label); 606 607 } 608 RF_UNLOCK_MUTEX(raidPtr->mutex); 609 RF_SIGNAL_COND(raidPtr->waitForReconCond); 610 wakeup(&raidPtr->waitForReconCond); 611 return (rc); 612} 613 614 615int 616rf_ContinueReconstructFailedDisk(reconDesc) 617 RF_RaidReconDesc_t *reconDesc; 618{ 619 RF_Raid_t *raidPtr = reconDesc->raidPtr; 620 RF_RowCol_t row = reconDesc->row; 621 RF_RowCol_t col = reconDesc->col; 622 RF_RowCol_t srow = reconDesc->srow; 623 RF_RowCol_t scol = reconDesc->scol; 624 RF_ReconMap_t *mapPtr; 625 626 RF_ReconEvent_t *event; 627 struct timeval etime, elpsd; 628 unsigned long xor_s, xor_resid_us; 629 int retcode, i, ds; 630 631 switch (reconDesc->state) { 632 633 634 case 0: 635 636 raidPtr->accumXorTimeUs = 0; 637 638 /* create one trace record per physical disk */ 639 RF_Malloc(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *)); 640 641 /* quiesce the array prior to starting recon. this is needed 642 * to assure no nasty interactions with pending user writes. 643 * We need to do this before we change the disk or row status. */ 644 reconDesc->state = 1; 645 646 Dprintf("RECON: begin request suspend\n"); 647 retcode = rf_SuspendNewRequestsAndWait(raidPtr); 648 Dprintf("RECON: end request suspend\n"); 649 rf_StartUserStats(raidPtr); /* zero out the stats kept on 650 * user accs */ 651 652 /* fall through to state 1 */ 653 654 case 1: 655 656 RF_LOCK_MUTEX(raidPtr->mutex); 657 658 /* create the reconstruction control pointer and install it in 659 * the right slot */ 660 raidPtr->reconControl[row] = rf_MakeReconControl(reconDesc, row, col, srow, scol); 661 mapPtr = raidPtr->reconControl[row]->reconMap; 662 raidPtr->status[row] = rf_rs_reconstructing; 663 raidPtr->Disks[row][col].status = rf_ds_reconstructing; 664 raidPtr->Disks[row][col].spareRow = srow; 665 raidPtr->Disks[row][col].spareCol = scol; 666 667 RF_UNLOCK_MUTEX(raidPtr->mutex); 668 669 RF_GETTIME(raidPtr->reconControl[row]->starttime); 670 671 /* now start up the actual reconstruction: issue a read for 672 * each surviving disk */ 673 674 reconDesc->numDisksDone = 0; 675 for (i = 0; i < raidPtr->numCol; i++) { 676 if (i != col) { 677 /* find and issue the next I/O on the 678 * indicated disk */ 679 if (IssueNextReadRequest(raidPtr, row, i)) { 680 Dprintf2("RECON: done issuing for r%d c%d\n", row, i); 681 reconDesc->numDisksDone++; 682 } 683 } 684 } 685 686 case 2: 687 Dprintf("RECON: resume requests\n"); 688 rf_ResumeNewRequests(raidPtr); 689 690 691 reconDesc->state = 3; 692 693 case 3: 694 695 /* process reconstruction events until all disks report that 696 * they've completed all work */ 697 mapPtr = raidPtr->reconControl[row]->reconMap; 698 699 700 701 while (reconDesc->numDisksDone < raidPtr->numCol - 1) { 702 703 event = rf_GetNextReconEvent(reconDesc, row, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc); 704 RF_ASSERT(event); 705 706 if (ProcessReconEvent(raidPtr, row, event)) 707 reconDesc->numDisksDone++; 708 raidPtr->reconControl[row]->percentComplete = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs); 709 if (rf_prReconSched) { 710 rf_PrintReconSchedule(raidPtr->reconControl[row]->reconMap, &(raidPtr->reconControl[row]->starttime)); 711 } 712 } 713 714 715 716 reconDesc->state = 4; 717 718 719 case 4: 720 mapPtr = raidPtr->reconControl[row]->reconMap; 721 if (rf_reconDebug) { 722 printf("RECON: all reads completed\n"); 723 } 724 /* at this point all the reads have completed. We now wait 725 * for any pending writes to complete, and then we're done */ 726 727 while (rf_UnitsLeftToReconstruct(raidPtr->reconControl[row]->reconMap) > 0) { 728 729 event = rf_GetNextReconEvent(reconDesc, row, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc); 730 RF_ASSERT(event); 731 732 (void) ProcessReconEvent(raidPtr, row, event); /* ignore return code */ 733 raidPtr->reconControl[row]->percentComplete = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs); 734 if (rf_prReconSched) { 735 rf_PrintReconSchedule(raidPtr->reconControl[row]->reconMap, &(raidPtr->reconControl[row]->starttime)); 736 } 737 } 738 reconDesc->state = 5; 739 740 case 5: 741 /* Success: mark the dead disk as reconstructed. We quiesce 742 * the array here to assure no nasty interactions with pending 743 * user accesses when we free up the psstatus structure as 744 * part of FreeReconControl() */ 745 746 reconDesc->state = 6; 747 748 retcode = rf_SuspendNewRequestsAndWait(raidPtr); 749 rf_StopUserStats(raidPtr); 750 rf_PrintUserStats(raidPtr); /* print out the stats on user 751 * accs accumulated during 752 * recon */ 753 754 /* fall through to state 6 */ 755 case 6: 756 757 758 759 RF_LOCK_MUTEX(raidPtr->mutex); 760 raidPtr->numFailures--; 761 ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE); 762 raidPtr->Disks[row][col].status = (ds) ? rf_ds_dist_spared : rf_ds_spared; 763 raidPtr->status[row] = (ds) ? rf_rs_reconfigured : rf_rs_optimal; 764 RF_UNLOCK_MUTEX(raidPtr->mutex); 765 RF_GETTIME(etime); 766 RF_TIMEVAL_DIFF(&(raidPtr->reconControl[row]->starttime), &etime, &elpsd); 767 768 /* XXX -- why is state 7 different from state 6 if there is no 769 * return() here? -- XXX Note that I set elpsd above & use it 770 * below, so if you put a return here you'll have to fix this. 771 * (also, FreeReconControl is called below) */ 772 773 case 7: 774 775 rf_ResumeNewRequests(raidPtr); 776 777 printf("Reconstruction of disk at row %d col %d completed\n", 778 row, col); 779 xor_s = raidPtr->accumXorTimeUs / 1000000; 780 xor_resid_us = raidPtr->accumXorTimeUs % 1000000; 781 printf("Recon time was %d.%06d seconds, accumulated XOR time was %ld us (%ld.%06ld)\n", 782 (int) elpsd.tv_sec, (int) elpsd.tv_usec, raidPtr->accumXorTimeUs, xor_s, xor_resid_us); 783 printf(" (start time %d sec %d usec, end time %d sec %d usec)\n", 784 (int) raidPtr->reconControl[row]->starttime.tv_sec, 785 (int) raidPtr->reconControl[row]->starttime.tv_usec, 786 (int) etime.tv_sec, (int) etime.tv_usec); 787 788#if RF_RECON_STATS > 0 789 printf("Total head-sep stall count was %d\n", 790 (int) reconDesc->hsStallCount); 791#endif /* RF_RECON_STATS > 0 */ 792 rf_FreeReconControl(raidPtr, row); 793 RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t)); 794 FreeReconDesc(reconDesc); 795 796 } 797 798 SignalReconDone(raidPtr); 799 return (0); 800} 801/***************************************************************************** 802 * do the right thing upon each reconstruction event. 803 * returns nonzero if and only if there is nothing left unread on the 804 * indicated disk 805 *****************************************************************************/ 806static int 807ProcessReconEvent(raidPtr, frow, event) 808 RF_Raid_t *raidPtr; 809 RF_RowCol_t frow; 810 RF_ReconEvent_t *event; 811{ 812 int retcode = 0, submitblocked; 813 RF_ReconBuffer_t *rbuf; 814 RF_SectorCount_t sectorsPerRU; 815 816 Dprintf1("RECON: ProcessReconEvent type %d\n", event->type); 817 switch (event->type) { 818 819 /* a read I/O has completed */ 820 case RF_REVENT_READDONE: 821 rbuf = raidPtr->reconControl[frow]->perDiskInfo[event->col].rbuf; 822 Dprintf3("RECON: READDONE EVENT: row %d col %d psid %ld\n", 823 frow, event->col, rbuf->parityStripeID); 824 Dprintf7("RECON: done read psid %ld buf %lx %02x %02x %02x %02x %02x\n", 825 rbuf->parityStripeID, rbuf->buffer, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff, 826 rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff); 827 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg); 828 submitblocked = rf_SubmitReconBuffer(rbuf, 0, 0); 829 Dprintf1("RECON: submitblocked=%d\n", submitblocked); 830 if (!submitblocked) 831 retcode = IssueNextReadRequest(raidPtr, frow, event->col); 832 break; 833 834 /* a write I/O has completed */ 835 case RF_REVENT_WRITEDONE: 836 if (rf_floatingRbufDebug) { 837 rf_CheckFloatingRbufCount(raidPtr, 1); 838 } 839 sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU; 840 rbuf = (RF_ReconBuffer_t *) event->arg; 841 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg); 842 Dprintf3("RECON: WRITEDONE EVENT: psid %d ru %d (%d %% complete)\n", 843 rbuf->parityStripeID, rbuf->which_ru, raidPtr->reconControl[frow]->percentComplete); 844 rf_ReconMapUpdate(raidPtr, raidPtr->reconControl[frow]->reconMap, 845 rbuf->failedDiskSectorOffset, rbuf->failedDiskSectorOffset + sectorsPerRU - 1); 846 rf_RemoveFromActiveReconTable(raidPtr, frow, rbuf->parityStripeID, rbuf->which_ru); 847 848 if (rbuf->type == RF_RBUF_TYPE_FLOATING) { 849 RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex); 850 raidPtr->numFullReconBuffers--; 851 rf_ReleaseFloatingReconBuffer(raidPtr, frow, rbuf); 852 RF_UNLOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex); 853 } else 854 if (rbuf->type == RF_RBUF_TYPE_FORCED) 855 rf_FreeReconBuffer(rbuf); 856 else 857 RF_ASSERT(0); 858 break; 859 860 case RF_REVENT_BUFCLEAR: /* A buffer-stall condition has been 861 * cleared */ 862 Dprintf2("RECON: BUFCLEAR EVENT: row %d col %d\n", frow, event->col); 863 submitblocked = rf_SubmitReconBuffer(raidPtr->reconControl[frow]->perDiskInfo[event->col].rbuf, 0, (int) (long) event->arg); 864 RF_ASSERT(!submitblocked); /* we wouldn't have gotten the 865 * BUFCLEAR event if we 866 * couldn't submit */ 867 retcode = IssueNextReadRequest(raidPtr, frow, event->col); 868 break; 869 870 case RF_REVENT_BLOCKCLEAR: /* A user-write reconstruction 871 * blockage has been cleared */ 872 DDprintf2("RECON: BLOCKCLEAR EVENT: row %d col %d\n", frow, event->col); 873 retcode = TryToRead(raidPtr, frow, event->col); 874 break; 875 876 case RF_REVENT_HEADSEPCLEAR: /* A max-head-separation 877 * reconstruction blockage has been 878 * cleared */ 879 Dprintf2("RECON: HEADSEPCLEAR EVENT: row %d col %d\n", frow, event->col); 880 retcode = TryToRead(raidPtr, frow, event->col); 881 break; 882 883 /* a buffer has become ready to write */ 884 case RF_REVENT_BUFREADY: 885 Dprintf2("RECON: BUFREADY EVENT: row %d col %d\n", frow, event->col); 886 retcode = IssueNextWriteRequest(raidPtr, frow); 887 if (rf_floatingRbufDebug) { 888 rf_CheckFloatingRbufCount(raidPtr, 1); 889 } 890 break; 891 892 /* we need to skip the current RU entirely because it got 893 * recon'd while we were waiting for something else to happen */ 894 case RF_REVENT_SKIP: 895 DDprintf2("RECON: SKIP EVENT: row %d col %d\n", frow, event->col); 896 retcode = IssueNextReadRequest(raidPtr, frow, event->col); 897 break; 898 899 /* a forced-reconstruction read access has completed. Just 900 * submit the buffer */ 901 case RF_REVENT_FORCEDREADDONE: 902 rbuf = (RF_ReconBuffer_t *) event->arg; 903 rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg); 904 DDprintf2("RECON: FORCEDREADDONE EVENT: row %d col %d\n", frow, event->col); 905 submitblocked = rf_SubmitReconBuffer(rbuf, 1, 0); 906 RF_ASSERT(!submitblocked); 907 break; 908 909 default: 910 RF_PANIC(); 911 } 912 rf_FreeReconEventDesc(event); 913 return (retcode); 914} 915/***************************************************************************** 916 * 917 * find the next thing that's needed on the indicated disk, and issue 918 * a read request for it. We assume that the reconstruction buffer 919 * associated with this process is free to receive the data. If 920 * reconstruction is blocked on the indicated RU, we issue a 921 * blockage-release request instead of a physical disk read request. 922 * If the current disk gets too far ahead of the others, we issue a 923 * head-separation wait request and return. 924 * 925 * ctrl->{ru_count, curPSID, diskOffset} and 926 * rbuf->failedDiskSectorOffset are maintained to point the the unit 927 * we're currently accessing. Note that this deviates from the 928 * standard C idiom of having counters point to the next thing to be 929 * accessed. This allows us to easily retry when we're blocked by 930 * head separation or reconstruction-blockage events. 931 * 932 * returns nonzero if and only if there is nothing left unread on the 933 * indicated disk 934 * 935 *****************************************************************************/ 936static int 937IssueNextReadRequest(raidPtr, row, col) 938 RF_Raid_t *raidPtr; 939 RF_RowCol_t row; 940 RF_RowCol_t col; 941{ 942 RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl[row]->perDiskInfo[col]; 943 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 944 RF_ReconBuffer_t *rbuf = ctrl->rbuf; 945 RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU / layoutPtr->SUsPerRU; 946 RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU; 947 int do_new_check = 0, retcode = 0, status; 948 949 /* if we are currently the slowest disk, mark that we have to do a new 950 * check */ 951 if (ctrl->headSepCounter <= raidPtr->reconControl[row]->minHeadSepCounter) 952 do_new_check = 1; 953 954 while (1) { 955 956 ctrl->ru_count++; 957 if (ctrl->ru_count < RUsPerPU) { 958 ctrl->diskOffset += sectorsPerRU; 959 rbuf->failedDiskSectorOffset += sectorsPerRU; 960 } else { 961 ctrl->curPSID++; 962 ctrl->ru_count = 0; 963 /* code left over from when head-sep was based on 964 * parity stripe id */ 965 if (ctrl->curPSID >= raidPtr->reconControl[row]->lastPSID) { 966 CheckForNewMinHeadSep(raidPtr, row, ++(ctrl->headSepCounter)); 967 return (1); /* finito! */ 968 } 969 /* find the disk offsets of the start of the parity 970 * stripe on both the current disk and the failed 971 * disk. skip this entire parity stripe if either disk 972 * does not appear in the indicated PS */ 973 status = ComputePSDiskOffsets(raidPtr, ctrl->curPSID, row, col, &ctrl->diskOffset, &rbuf->failedDiskSectorOffset, 974 &rbuf->spRow, &rbuf->spCol, &rbuf->spOffset); 975 if (status) { 976 ctrl->ru_count = RUsPerPU - 1; 977 continue; 978 } 979 } 980 rbuf->which_ru = ctrl->ru_count; 981 982 /* skip this RU if it's already been reconstructed */ 983 if (rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, rbuf->failedDiskSectorOffset)) { 984 Dprintf2("Skipping psid %ld ru %d: already reconstructed\n", ctrl->curPSID, ctrl->ru_count); 985 continue; 986 } 987 break; 988 } 989 ctrl->headSepCounter++; 990 if (do_new_check) 991 CheckForNewMinHeadSep(raidPtr, row, ctrl->headSepCounter); /* update min if needed */ 992 993 994 /* at this point, we have definitely decided what to do, and we have 995 * only to see if we can actually do it now */ 996 rbuf->parityStripeID = ctrl->curPSID; 997 rbuf->which_ru = ctrl->ru_count; 998 bzero((char *) &raidPtr->recon_tracerecs[col], sizeof(raidPtr->recon_tracerecs[col])); 999 raidPtr->recon_tracerecs[col].reconacc = 1; 1000 RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer); 1001 retcode = TryToRead(raidPtr, row, col); 1002 return (retcode); 1003} 1004 1005/* 1006 * tries to issue the next read on the indicated disk. We may be 1007 * blocked by (a) the heads being too far apart, or (b) recon on the 1008 * indicated RU being blocked due to a write by a user thread. In 1009 * this case, we issue a head-sep or blockage wait request, which will 1010 * cause this same routine to be invoked again later when the blockage 1011 * has cleared. 1012 */ 1013 1014static int 1015TryToRead(raidPtr, row, col) 1016 RF_Raid_t *raidPtr; 1017 RF_RowCol_t row; 1018 RF_RowCol_t col; 1019{ 1020 RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl[row]->perDiskInfo[col]; 1021 RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU; 1022 RF_StripeNum_t psid = ctrl->curPSID; 1023 RF_ReconUnitNum_t which_ru = ctrl->ru_count; 1024 RF_DiskQueueData_t *req; 1025 int status, created = 0; 1026 RF_ReconParityStripeStatus_t *pssPtr; 1027 1028 /* if the current disk is too far ahead of the others, issue a 1029 * head-separation wait and return */ 1030 if (CheckHeadSeparation(raidPtr, ctrl, row, col, ctrl->headSepCounter, which_ru)) 1031 return (0); 1032 RF_LOCK_PSS_MUTEX(raidPtr, row, psid); 1033 pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]->pssTable, psid, which_ru, RF_PSS_CREATE, &created); 1034 1035 /* if recon is blocked on the indicated parity stripe, issue a 1036 * block-wait request and return. this also must mark the indicated RU 1037 * in the stripe as under reconstruction if not blocked. */ 1038 status = CheckForcedOrBlockedReconstruction(raidPtr, pssPtr, ctrl, row, col, psid, which_ru); 1039 if (status == RF_PSS_RECON_BLOCKED) { 1040 Dprintf2("RECON: Stalling psid %ld ru %d: recon blocked\n", psid, which_ru); 1041 goto out; 1042 } else 1043 if (status == RF_PSS_FORCED_ON_WRITE) { 1044 rf_CauseReconEvent(raidPtr, row, col, NULL, RF_REVENT_SKIP); 1045 goto out; 1046 } 1047 /* make one last check to be sure that the indicated RU didn't get 1048 * reconstructed while we were waiting for something else to happen. 1049 * This is unfortunate in that it causes us to make this check twice 1050 * in the normal case. Might want to make some attempt to re-work 1051 * this so that we only do this check if we've definitely blocked on 1052 * one of the above checks. When this condition is detected, we may 1053 * have just created a bogus status entry, which we need to delete. */ 1054 if (rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, ctrl->rbuf->failedDiskSectorOffset)) { 1055 Dprintf2("RECON: Skipping psid %ld ru %d: prior recon after stall\n", psid, which_ru); 1056 if (created) 1057 rf_PSStatusDelete(raidPtr, raidPtr->reconControl[row]->pssTable, pssPtr); 1058 rf_CauseReconEvent(raidPtr, row, col, NULL, RF_REVENT_SKIP); 1059 goto out; 1060 } 1061 /* found something to read. issue the I/O */ 1062 Dprintf5("RECON: Read for psid %ld on row %d col %d offset %ld buf %lx\n", 1063 psid, row, col, ctrl->diskOffset, ctrl->rbuf->buffer); 1064 RF_ETIMER_STOP(raidPtr->recon_tracerecs[col].recon_timer); 1065 RF_ETIMER_EVAL(raidPtr->recon_tracerecs[col].recon_timer); 1066 raidPtr->recon_tracerecs[col].specific.recon.recon_start_to_fetch_us = 1067 RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[col].recon_timer); 1068 RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer); 1069 1070 /* should be ok to use a NULL proc pointer here, all the bufs we use 1071 * should be in kernel space */ 1072 req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, ctrl->diskOffset, sectorsPerRU, ctrl->rbuf->buffer, psid, which_ru, 1073 ReconReadDoneProc, (void *) ctrl, NULL, &raidPtr->recon_tracerecs[col], (void *) raidPtr, 0, NULL); 1074 1075 RF_ASSERT(req); /* XXX -- fix this -- XXX */ 1076 1077 ctrl->rbuf->arg = (void *) req; 1078 rf_DiskIOEnqueue(&raidPtr->Queues[row][col], req, RF_IO_RECON_PRIORITY); 1079 pssPtr->issued[col] = 1; 1080 1081out: 1082 RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid); 1083 return (0); 1084} 1085 1086 1087/* 1088 * given a parity stripe ID, we want to find out whether both the 1089 * current disk and the failed disk exist in that parity stripe. If 1090 * not, we want to skip this whole PS. If so, we want to find the 1091 * disk offset of the start of the PS on both the current disk and the 1092 * failed disk. 1093 * 1094 * this works by getting a list of disks comprising the indicated 1095 * parity stripe, and searching the list for the current and failed 1096 * disks. Once we've decided they both exist in the parity stripe, we 1097 * need to decide whether each is data or parity, so that we'll know 1098 * which mapping function to call to get the corresponding disk 1099 * offsets. 1100 * 1101 * this is kind of unpleasant, but doing it this way allows the 1102 * reconstruction code to use parity stripe IDs rather than physical 1103 * disks address to march through the failed disk, which greatly 1104 * simplifies a lot of code, as well as eliminating the need for a 1105 * reverse-mapping function. I also think it will execute faster, 1106 * since the calls to the mapping module are kept to a minimum. 1107 * 1108 * ASSUMES THAT THE STRIPE IDENTIFIER IDENTIFIES THE DISKS COMPRISING 1109 * THE STRIPE IN THE CORRECT ORDER */ 1110 1111 1112static int 1113ComputePSDiskOffsets( 1114 RF_Raid_t * raidPtr, /* raid descriptor */ 1115 RF_StripeNum_t psid, /* parity stripe identifier */ 1116 RF_RowCol_t row, /* row and column of disk to find the offsets 1117 * for */ 1118 RF_RowCol_t col, 1119 RF_SectorNum_t * outDiskOffset, 1120 RF_SectorNum_t * outFailedDiskSectorOffset, 1121 RF_RowCol_t * spRow, /* OUT: row,col of spare unit for failed unit */ 1122 RF_RowCol_t * spCol, 1123 RF_SectorNum_t * spOffset) 1124{ /* OUT: offset into disk containing spare unit */ 1125 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 1126 RF_RowCol_t fcol = raidPtr->reconControl[row]->fcol; 1127 RF_RaidAddr_t sosRaidAddress; /* start-of-stripe */ 1128 RF_RowCol_t *diskids; 1129 u_int i, j, k, i_offset, j_offset; 1130 RF_RowCol_t prow, pcol; 1131 int testcol, testrow; 1132 RF_RowCol_t stripe; 1133 RF_SectorNum_t poffset; 1134 char i_is_parity = 0, j_is_parity = 0; 1135 RF_RowCol_t stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol; 1136 1137 /* get a listing of the disks comprising that stripe */ 1138 sosRaidAddress = rf_ParityStripeIDToRaidAddress(layoutPtr, psid); 1139 (layoutPtr->map->IdentifyStripe) (raidPtr, sosRaidAddress, &diskids, &stripe); 1140 RF_ASSERT(diskids); 1141 1142 /* reject this entire parity stripe if it does not contain the 1143 * indicated disk or it does not contain the failed disk */ 1144 if (row != stripe) 1145 goto skipit; 1146 for (i = 0; i < stripeWidth; i++) { 1147 if (col == diskids[i]) 1148 break; 1149 } 1150 if (i == stripeWidth) 1151 goto skipit; 1152 for (j = 0; j < stripeWidth; j++) { 1153 if (fcol == diskids[j]) 1154 break; 1155 } 1156 if (j == stripeWidth) { 1157 goto skipit; 1158 } 1159 /* find out which disk the parity is on */ 1160 (layoutPtr->map->MapParity) (raidPtr, sosRaidAddress, &prow, &pcol, &poffset, RF_DONT_REMAP); 1161 1162 /* find out if either the current RU or the failed RU is parity */ 1163 /* also, if the parity occurs in this stripe prior to the data and/or 1164 * failed col, we need to decrement i and/or j */ 1165 for (k = 0; k < stripeWidth; k++) 1166 if (diskids[k] == pcol) 1167 break; 1168 RF_ASSERT(k < stripeWidth); 1169 i_offset = i; 1170 j_offset = j; 1171 if (k < i) 1172 i_offset--; 1173 else 1174 if (k == i) { 1175 i_is_parity = 1; 1176 i_offset = 0; 1177 } /* set offsets to zero to disable multiply 1178 * below */ 1179 if (k < j) 1180 j_offset--; 1181 else 1182 if (k == j) { 1183 j_is_parity = 1; 1184 j_offset = 0; 1185 } 1186 /* at this point, [ij]_is_parity tells us whether the [current,failed] 1187 * disk is parity at the start of this RU, and, if data, "[ij]_offset" 1188 * tells us how far into the stripe the [current,failed] disk is. */ 1189 1190 /* call the mapping routine to get the offset into the current disk, 1191 * repeat for failed disk. */ 1192 if (i_is_parity) 1193 layoutPtr->map->MapParity(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outDiskOffset, RF_DONT_REMAP); 1194 else 1195 layoutPtr->map->MapSector(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outDiskOffset, RF_DONT_REMAP); 1196 1197 RF_ASSERT(row == testrow && col == testcol); 1198 1199 if (j_is_parity) 1200 layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP); 1201 else 1202 layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP); 1203 RF_ASSERT(row == testrow && fcol == testcol); 1204 1205 /* now locate the spare unit for the failed unit */ 1206 if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) { 1207 if (j_is_parity) 1208 layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spRow, spCol, spOffset, RF_REMAP); 1209 else 1210 layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spRow, spCol, spOffset, RF_REMAP); 1211 } else { 1212 *spRow = raidPtr->reconControl[row]->spareRow; 1213 *spCol = raidPtr->reconControl[row]->spareCol; 1214 *spOffset = *outFailedDiskSectorOffset; 1215 } 1216 1217 return (0); 1218 1219skipit: 1220 Dprintf3("RECON: Skipping psid %ld: nothing needed from r%d c%d\n", 1221 psid, row, col); 1222 return (1); 1223} 1224/* this is called when a buffer has become ready to write to the replacement disk */ 1225static int 1226IssueNextWriteRequest(raidPtr, row) 1227 RF_Raid_t *raidPtr; 1228 RF_RowCol_t row; 1229{ 1230 RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; 1231 RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU; 1232 RF_RowCol_t fcol = raidPtr->reconControl[row]->fcol; 1233 RF_ReconBuffer_t *rbuf; 1234 RF_DiskQueueData_t *req; 1235 1236 rbuf = rf_GetFullReconBuffer(raidPtr->reconControl[row]); 1237 RF_ASSERT(rbuf); /* there must be one available, or we wouldn't 1238 * have gotten the event that sent us here */ 1239 RF_ASSERT(rbuf->pssPtr); 1240 1241 rbuf->pssPtr->writeRbuf = rbuf; 1242 rbuf->pssPtr = NULL; 1243 1244 Dprintf7("RECON: New write (r %d c %d offs %d) for psid %ld ru %d (failed disk offset %ld) buf %lx\n", 1245 rbuf->spRow, rbuf->spCol, rbuf->spOffset, rbuf->parityStripeID, 1246 rbuf->which_ru, rbuf->failedDiskSectorOffset, rbuf->buffer); 1247 Dprintf6("RECON: new write psid %ld %02x %02x %02x %02x %02x\n", 1248 rbuf->parityStripeID, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff, 1249 rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff); 1250 1251 /* should be ok to use a NULL b_proc here b/c all addrs should be in 1252 * kernel space */ 1253 req = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, rbuf->spOffset, 1254 sectorsPerRU, rbuf->buffer, 1255 rbuf->parityStripeID, rbuf->which_ru, 1256 ReconWriteDoneProc, (void *) rbuf, NULL, 1257 &raidPtr->recon_tracerecs[fcol], 1258 (void *) raidPtr, 0, NULL); 1259 1260 RF_ASSERT(req); /* XXX -- fix this -- XXX */ 1261 1262 rbuf->arg = (void *) req; 1263 rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spRow][rbuf->spCol], req, RF_IO_RECON_PRIORITY); 1264 1265 return (0); 1266} 1267 1268/* 1269 * this gets called upon the completion of a reconstruction read 1270 * operation the arg is a pointer to the per-disk reconstruction 1271 * control structure for the process that just finished a read. 1272 * 1273 * called at interrupt context in the kernel, so don't do anything 1274 * illegal here. 1275 */ 1276static int 1277ReconReadDoneProc(arg, status) 1278 void *arg; 1279 int status; 1280{ 1281 RF_PerDiskReconCtrl_t *ctrl = (RF_PerDiskReconCtrl_t *) arg; 1282 RF_Raid_t *raidPtr = ctrl->reconCtrl->reconDesc->raidPtr; 1283 1284 if (status) { 1285 /* 1286 * XXX 1287 */ 1288 printf("Recon read failed!\n"); 1289 RF_PANIC(); 1290 } 1291 RF_ETIMER_STOP(raidPtr->recon_tracerecs[ctrl->col].recon_timer); 1292 RF_ETIMER_EVAL(raidPtr->recon_tracerecs[ctrl->col].recon_timer); 1293 raidPtr->recon_tracerecs[ctrl->col].specific.recon.recon_fetch_to_return_us = 1294 RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[ctrl->col].recon_timer); 1295 RF_ETIMER_START(raidPtr->recon_tracerecs[ctrl->col].recon_timer); 1296 1297 rf_CauseReconEvent(raidPtr, ctrl->row, ctrl->col, NULL, RF_REVENT_READDONE); 1298 return (0); 1299} 1300/* this gets called upon the completion of a reconstruction write operation. 1301 * the arg is a pointer to the rbuf that was just written 1302 * 1303 * called at interrupt context in the kernel, so don't do anything illegal here. 1304 */ 1305static int 1306ReconWriteDoneProc(arg, status) 1307 void *arg; 1308 int status; 1309{ 1310 RF_ReconBuffer_t *rbuf = (RF_ReconBuffer_t *) arg; 1311 1312 Dprintf2("Reconstruction completed on psid %ld ru %d\n", rbuf->parityStripeID, rbuf->which_ru); 1313 if (status) { 1314 printf("Recon write failed!\n"); /* fprintf(stderr,"Recon 1315 * write failed!\n"); */ 1316 RF_PANIC(); 1317 } 1318 rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col, arg, RF_REVENT_WRITEDONE); 1319 return (0); 1320} 1321 1322 1323/* 1324 * computes a new minimum head sep, and wakes up anyone who needs to 1325 * be woken as a result 1326 */ 1327static void 1328CheckForNewMinHeadSep(raidPtr, row, hsCtr) 1329 RF_Raid_t *raidPtr; 1330 RF_RowCol_t row; 1331 RF_HeadSepLimit_t hsCtr; 1332{ 1333 RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row]; 1334 RF_HeadSepLimit_t new_min; 1335 RF_RowCol_t i; 1336 RF_CallbackDesc_t *p; 1337 RF_ASSERT(hsCtr >= reconCtrlPtr->minHeadSepCounter); /* from the definition 1338 * of a minimum */ 1339 1340 1341 RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex); 1342 1343 new_min = ~(1L << (8 * sizeof(long) - 1)); /* 0x7FFF....FFF */ 1344 for (i = 0; i < raidPtr->numCol; i++) 1345 if (i != reconCtrlPtr->fcol) { 1346 if (reconCtrlPtr->perDiskInfo[i].headSepCounter < new_min) 1347 new_min = reconCtrlPtr->perDiskInfo[i].headSepCounter; 1348 } 1349 /* set the new minimum and wake up anyone who can now run again */ 1350 if (new_min != reconCtrlPtr->minHeadSepCounter) { 1351 reconCtrlPtr->minHeadSepCounter = new_min; 1352 Dprintf1("RECON: new min head pos counter val is %ld\n", new_min); 1353 while (reconCtrlPtr->headSepCBList) { 1354 if (reconCtrlPtr->headSepCBList->callbackArg.v > new_min) 1355 break; 1356 p = reconCtrlPtr->headSepCBList; 1357 reconCtrlPtr->headSepCBList = p->next; 1358 p->next = NULL; 1359 rf_CauseReconEvent(raidPtr, p->row, p->col, NULL, RF_REVENT_HEADSEPCLEAR); 1360 rf_FreeCallbackDesc(p); 1361 } 1362 1363 } 1364 RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex); 1365} 1366 1367/* 1368 * checks to see that the maximum head separation will not be violated 1369 * if we initiate a reconstruction I/O on the indicated disk. 1370 * Limiting the maximum head separation between two disks eliminates 1371 * the nasty buffer-stall conditions that occur when one disk races 1372 * ahead of the others and consumes all of the floating recon buffers. 1373 * This code is complex and unpleasant but it's necessary to avoid 1374 * some very nasty, albeit fairly rare, reconstruction behavior. 1375 * 1376 * returns non-zero if and only if we have to stop working on the 1377 * indicated disk due to a head-separation delay. 1378 */ 1379static int 1380CheckHeadSeparation( 1381 RF_Raid_t * raidPtr, 1382 RF_PerDiskReconCtrl_t * ctrl, 1383 RF_RowCol_t row, 1384 RF_RowCol_t col, 1385 RF_HeadSepLimit_t hsCtr, 1386 RF_ReconUnitNum_t which_ru) 1387{ 1388 RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row]; 1389 RF_CallbackDesc_t *cb, *p, *pt; 1390 int retval = 0; 1391 1392 /* if we're too far ahead of the slowest disk, stop working on this 1393 * disk until the slower ones catch up. We do this by scheduling a 1394 * wakeup callback for the time when the slowest disk has caught up. 1395 * We define "caught up" with 20% hysteresis, i.e. the head separation 1396 * must have fallen to at most 80% of the max allowable head 1397 * separation before we'll wake up. 1398 * 1399 */ 1400 RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex); 1401 if ((raidPtr->headSepLimit >= 0) && 1402 ((ctrl->headSepCounter - reconCtrlPtr->minHeadSepCounter) > raidPtr->headSepLimit)) { 1403 Dprintf6("raid%d: RECON: head sep stall: row %d col %d hsCtr %ld minHSCtr %ld limit %ld\n", 1404 raidPtr->raidid, row, col, ctrl->headSepCounter, 1405 reconCtrlPtr->minHeadSepCounter, 1406 raidPtr->headSepLimit); 1407 cb = rf_AllocCallbackDesc(); 1408 /* the minHeadSepCounter value we have to get to before we'll 1409 * wake up. build in 20% hysteresis. */ 1410 cb->callbackArg.v = (ctrl->headSepCounter - raidPtr->headSepLimit + raidPtr->headSepLimit / 5); 1411 cb->row = row; 1412 cb->col = col; 1413 cb->next = NULL; 1414 1415 /* insert this callback descriptor into the sorted list of 1416 * pending head-sep callbacks */ 1417 p = reconCtrlPtr->headSepCBList; 1418 if (!p) 1419 reconCtrlPtr->headSepCBList = cb; 1420 else 1421 if (cb->callbackArg.v < p->callbackArg.v) { 1422 cb->next = reconCtrlPtr->headSepCBList; 1423 reconCtrlPtr->headSepCBList = cb; 1424 } else { 1425 for (pt = p, p = p->next; p && (p->callbackArg.v < cb->callbackArg.v); pt = p, p = p->next); 1426 cb->next = p; 1427 pt->next = cb; 1428 } 1429 retval = 1; 1430#if RF_RECON_STATS > 0 1431 ctrl->reconCtrl->reconDesc->hsStallCount++; 1432#endif /* RF_RECON_STATS > 0 */ 1433 } 1434 RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex); 1435 1436 return (retval); 1437} 1438/* 1439 * checks to see if reconstruction has been either forced or blocked 1440 * by a user operation. if forced, we skip this RU entirely. else if 1441 * blocked, put ourselves on the wait list. else return 0. 1442 * 1443 * ASSUMES THE PSS MUTEX IS LOCKED UPON ENTRY 1444 */ 1445static int 1446CheckForcedOrBlockedReconstruction( 1447 RF_Raid_t * raidPtr, 1448 RF_ReconParityStripeStatus_t * pssPtr, 1449 RF_PerDiskReconCtrl_t * ctrl, 1450 RF_RowCol_t row, 1451 RF_RowCol_t col, 1452 RF_StripeNum_t psid, 1453 RF_ReconUnitNum_t which_ru) 1454{ 1455 RF_CallbackDesc_t *cb; 1456 int retcode = 0; 1457 1458 if ((pssPtr->flags & RF_PSS_FORCED_ON_READ) || (pssPtr->flags & RF_PSS_FORCED_ON_WRITE)) 1459 retcode = RF_PSS_FORCED_ON_WRITE; 1460 else 1461 if (pssPtr->flags & RF_PSS_RECON_BLOCKED) { 1462 Dprintf4("RECON: row %d col %d blocked at psid %ld ru %d\n", row, col, psid, which_ru); 1463 cb = rf_AllocCallbackDesc(); /* append ourselves to 1464 * the blockage-wait 1465 * list */ 1466 cb->row = row; 1467 cb->col = col; 1468 cb->next = pssPtr->blockWaitList; 1469 pssPtr->blockWaitList = cb; 1470 retcode = RF_PSS_RECON_BLOCKED; 1471 } 1472 if (!retcode) 1473 pssPtr->flags |= RF_PSS_UNDER_RECON; /* mark this RU as under 1474 * reconstruction */ 1475 1476 return (retcode); 1477} 1478/* 1479 * if reconstruction is currently ongoing for the indicated stripeID, 1480 * reconstruction is forced to completion and we return non-zero to 1481 * indicate that the caller must wait. If not, then reconstruction is 1482 * blocked on the indicated stripe and the routine returns zero. If 1483 * and only if we return non-zero, we'll cause the cbFunc to get 1484 * invoked with the cbArg when the reconstruction has completed. 1485 */ 1486int 1487rf_ForceOrBlockRecon(raidPtr, asmap, cbFunc, cbArg) 1488 RF_Raid_t *raidPtr; 1489 RF_AccessStripeMap_t *asmap; 1490 void (*cbFunc) (RF_Raid_t *, void *); 1491 void *cbArg; 1492{ 1493 RF_RowCol_t row = asmap->physInfo->row; /* which row of the array 1494 * we're working on */ 1495 RF_StripeNum_t stripeID = asmap->stripeID; /* the stripe ID we're 1496 * forcing recon on */ 1497 RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU; /* num sects in one RU */ 1498 RF_ReconParityStripeStatus_t *pssPtr; /* a pointer to the parity 1499 * stripe status structure */ 1500 RF_StripeNum_t psid; /* parity stripe id */ 1501 RF_SectorNum_t offset, fd_offset; /* disk offset, failed-disk 1502 * offset */ 1503 RF_RowCol_t *diskids; 1504 RF_RowCol_t stripe; 1505 RF_ReconUnitNum_t which_ru; /* RU within parity stripe */ 1506 RF_RowCol_t fcol, diskno, i; 1507 RF_ReconBuffer_t *new_rbuf; /* ptr to newly allocated rbufs */ 1508 RF_DiskQueueData_t *req;/* disk I/O req to be enqueued */ 1509 RF_CallbackDesc_t *cb; 1510 int created = 0, nPromoted; 1511 1512 psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru); 1513 1514 RF_LOCK_PSS_MUTEX(raidPtr, row, psid); 1515 1516 pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]->pssTable, psid, which_ru, RF_PSS_CREATE | RF_PSS_RECON_BLOCKED, &created); 1517 1518 /* if recon is not ongoing on this PS, just return */ 1519 if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) { 1520 RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid); 1521 return (0); 1522 } 1523 /* otherwise, we have to wait for reconstruction to complete on this 1524 * RU. */ 1525 /* In order to avoid waiting for a potentially large number of 1526 * low-priority accesses to complete, we force a normal-priority (i.e. 1527 * not low-priority) reconstruction on this RU. */ 1528 if (!(pssPtr->flags & RF_PSS_FORCED_ON_WRITE) && !(pssPtr->flags & RF_PSS_FORCED_ON_READ)) { 1529 DDprintf1("Forcing recon on psid %ld\n", psid); 1530 pssPtr->flags |= RF_PSS_FORCED_ON_WRITE; /* mark this RU as under 1531 * forced recon */ 1532 pssPtr->flags &= ~RF_PSS_RECON_BLOCKED; /* clear the blockage 1533 * that we just set */ 1534 fcol = raidPtr->reconControl[row]->fcol; 1535 1536 /* get a listing of the disks comprising the indicated stripe */ 1537 (raidPtr->Layout.map->IdentifyStripe) (raidPtr, asmap->raidAddress, &diskids, &stripe); 1538 RF_ASSERT(row == stripe); 1539 1540 /* For previously issued reads, elevate them to normal 1541 * priority. If the I/O has already completed, it won't be 1542 * found in the queue, and hence this will be a no-op. For 1543 * unissued reads, allocate buffers and issue new reads. The 1544 * fact that we've set the FORCED bit means that the regular 1545 * recon procs will not re-issue these reqs */ 1546 for (i = 0; i < raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol; i++) 1547 if ((diskno = diskids[i]) != fcol) { 1548 if (pssPtr->issued[diskno]) { 1549 nPromoted = rf_DiskIOPromote(&raidPtr->Queues[row][diskno], psid, which_ru); 1550 if (rf_reconDebug && nPromoted) 1551 printf("raid%d: promoted read from row %d col %d\n", raidPtr->raidid, row, diskno); 1552 } else { 1553 new_rbuf = rf_MakeReconBuffer(raidPtr, row, diskno, RF_RBUF_TYPE_FORCED); /* create new buf */ 1554 ComputePSDiskOffsets(raidPtr, psid, row, diskno, &offset, &fd_offset, 1555 &new_rbuf->spRow, &new_rbuf->spCol, &new_rbuf->spOffset); /* find offsets & spare 1556 * location */ 1557 new_rbuf->parityStripeID = psid; /* fill in the buffer */ 1558 new_rbuf->which_ru = which_ru; 1559 new_rbuf->failedDiskSectorOffset = fd_offset; 1560 new_rbuf->priority = RF_IO_NORMAL_PRIORITY; 1561 1562 /* use NULL b_proc b/c all addrs 1563 * should be in kernel space */ 1564 req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, offset + which_ru * sectorsPerRU, sectorsPerRU, new_rbuf->buffer, 1565 psid, which_ru, (int (*) (void *, int)) ForceReconReadDoneProc, (void *) new_rbuf, NULL, 1566 NULL, (void *) raidPtr, 0, NULL); 1567 1568 RF_ASSERT(req); /* XXX -- fix this -- 1569 * XXX */ 1570 1571 new_rbuf->arg = req; 1572 rf_DiskIOEnqueue(&raidPtr->Queues[row][diskno], req, RF_IO_NORMAL_PRIORITY); /* enqueue the I/O */ 1573 Dprintf3("raid%d: Issued new read req on row %d col %d\n", raidPtr->raidid, row, diskno); 1574 } 1575 } 1576 /* if the write is sitting in the disk queue, elevate its 1577 * priority */ 1578 if (rf_DiskIOPromote(&raidPtr->Queues[row][fcol], psid, which_ru)) 1579 printf("raid%d: promoted write to row %d col %d\n", 1580 raidPtr->raidid, row, fcol); 1581 } 1582 /* install a callback descriptor to be invoked when recon completes on 1583 * this parity stripe. */ 1584 cb = rf_AllocCallbackDesc(); 1585 /* XXX the following is bogus.. These functions don't really match!! 1586 * GO */ 1587 cb->callbackFunc = (void (*) (RF_CBParam_t)) cbFunc; 1588 cb->callbackArg.p = (void *) cbArg; 1589 cb->next = pssPtr->procWaitList; 1590 pssPtr->procWaitList = cb; 1591 DDprintf2("raid%d: Waiting for forced recon on psid %ld\n", 1592 raidPtr->raidid, psid); 1593 1594 RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid); 1595 return (1); 1596} 1597/* called upon the completion of a forced reconstruction read. 1598 * all we do is schedule the FORCEDREADONE event. 1599 * called at interrupt context in the kernel, so don't do anything illegal here. 1600 */ 1601static void 1602ForceReconReadDoneProc(arg, status) 1603 void *arg; 1604 int status; 1605{ 1606 RF_ReconBuffer_t *rbuf = arg; 1607 1608 if (status) { 1609 printf("Forced recon read failed!\n"); /* fprintf(stderr,"Forced 1610 * recon read 1611 * failed!\n"); */ 1612 RF_PANIC(); 1613 } 1614 rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col, (void *) rbuf, RF_REVENT_FORCEDREADDONE); 1615} 1616/* releases a block on the reconstruction of the indicated stripe */ 1617int 1618rf_UnblockRecon(raidPtr, asmap) 1619 RF_Raid_t *raidPtr; 1620 RF_AccessStripeMap_t *asmap; 1621{ 1622 RF_RowCol_t row = asmap->origRow; 1623 RF_StripeNum_t stripeID = asmap->stripeID; 1624 RF_ReconParityStripeStatus_t *pssPtr; 1625 RF_ReconUnitNum_t which_ru; 1626 RF_StripeNum_t psid; 1627 int created = 0; 1628 RF_CallbackDesc_t *cb; 1629 1630 psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru); 1631 RF_LOCK_PSS_MUTEX(raidPtr, row, psid); 1632 pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]->pssTable, psid, which_ru, RF_PSS_NONE, &created); 1633 1634 /* When recon is forced, the pss desc can get deleted before we get 1635 * back to unblock recon. But, this can _only_ happen when recon is 1636 * forced. It would be good to put some kind of sanity check here, but 1637 * how to decide if recon was just forced or not? */ 1638 if (!pssPtr) { 1639 /* printf("Warning: no pss descriptor upon unblock on psid %ld 1640 * RU %d\n",psid,which_ru); */ 1641 if (rf_reconDebug || rf_pssDebug) 1642 printf("Warning: no pss descriptor upon unblock on psid %ld RU %d\n", (long) psid, which_ru); 1643 goto out; 1644 } 1645 pssPtr->blockCount--; 1646 Dprintf3("raid%d: unblocking recon on psid %ld: blockcount is %d\n", 1647 raidPtr->raidid, psid, pssPtr->blockCount); 1648 if (pssPtr->blockCount == 0) { /* if recon blockage has been released */ 1649 1650 /* unblock recon before calling CauseReconEvent in case 1651 * CauseReconEvent causes us to try to issue a new read before 1652 * returning here. */ 1653 pssPtr->flags &= ~RF_PSS_RECON_BLOCKED; 1654 1655 1656 while (pssPtr->blockWaitList) { 1657 /* spin through the block-wait list and 1658 release all the waiters */ 1659 cb = pssPtr->blockWaitList; 1660 pssPtr->blockWaitList = cb->next; 1661 cb->next = NULL; 1662 rf_CauseReconEvent(raidPtr, cb->row, cb->col, NULL, RF_REVENT_BLOCKCLEAR); 1663 rf_FreeCallbackDesc(cb); 1664 } 1665 if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) { 1666 /* if no recon was requested while recon was blocked */ 1667 rf_PSStatusDelete(raidPtr, raidPtr->reconControl[row]->pssTable, pssPtr); 1668 } 1669 } 1670out: 1671 RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid); 1672 return (0); 1673} 1674