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