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