710948de69
world. This should be considered highly experimental. Approved-by: re
690 lines
21 KiB
C
690 lines
21 KiB
C
/* $FreeBSD$ */
|
|
/* $NetBSD: rf_raid1.c,v 1.5 2000/01/08 22:57:30 oster Exp $ */
|
|
/*
|
|
* Copyright (c) 1995 Carnegie-Mellon University.
|
|
* All rights reserved.
|
|
*
|
|
* Author: William V. Courtright II
|
|
*
|
|
* Permission to use, copy, modify and distribute this software and
|
|
* its documentation is hereby granted, provided that both the copyright
|
|
* notice and this permission notice appear in all copies of the
|
|
* software, derivative works or modified versions, and any portions
|
|
* thereof, and that both notices appear in supporting documentation.
|
|
*
|
|
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
|
|
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
|
|
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
|
|
*
|
|
* Carnegie Mellon requests users of this software to return to
|
|
*
|
|
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
|
|
* School of Computer Science
|
|
* Carnegie Mellon University
|
|
* Pittsburgh PA 15213-3890
|
|
*
|
|
* any improvements or extensions that they make and grant Carnegie the
|
|
* rights to redistribute these changes.
|
|
*/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* rf_raid1.c -- implements RAID Level 1
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include <dev/raidframe/rf_raid.h>
|
|
#include <dev/raidframe/rf_raid1.h>
|
|
#include <dev/raidframe/rf_dag.h>
|
|
#include <dev/raidframe/rf_dagffrd.h>
|
|
#include <dev/raidframe/rf_dagffwr.h>
|
|
#include <dev/raidframe/rf_dagdegrd.h>
|
|
#include <dev/raidframe/rf_dagutils.h>
|
|
#include <dev/raidframe/rf_dagfuncs.h>
|
|
#include <dev/raidframe/rf_diskqueue.h>
|
|
#include <dev/raidframe/rf_general.h>
|
|
#include <dev/raidframe/rf_utils.h>
|
|
#include <dev/raidframe/rf_parityscan.h>
|
|
#include <dev/raidframe/rf_mcpair.h>
|
|
#include <dev/raidframe/rf_layout.h>
|
|
#include <dev/raidframe/rf_map.h>
|
|
#include <dev/raidframe/rf_engine.h>
|
|
#include <dev/raidframe/rf_reconbuffer.h>
|
|
#include <dev/raidframe/rf_kintf.h>
|
|
|
|
typedef struct RF_Raid1ConfigInfo_s {
|
|
RF_RowCol_t **stripeIdentifier;
|
|
} RF_Raid1ConfigInfo_t;
|
|
/* start of day code specific to RAID level 1 */
|
|
int
|
|
rf_ConfigureRAID1(
|
|
RF_ShutdownList_t ** listp,
|
|
RF_Raid_t * raidPtr,
|
|
RF_Config_t * cfgPtr)
|
|
{
|
|
RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
|
|
RF_Raid1ConfigInfo_t *info;
|
|
RF_RowCol_t i;
|
|
|
|
/* create a RAID level 1 configuration structure */
|
|
RF_MallocAndAdd(info, sizeof(RF_Raid1ConfigInfo_t), (RF_Raid1ConfigInfo_t *), raidPtr->cleanupList);
|
|
if (info == NULL)
|
|
return (ENOMEM);
|
|
layoutPtr->layoutSpecificInfo = (void *) info;
|
|
|
|
/* ... and fill it in. */
|
|
info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2, raidPtr->cleanupList);
|
|
if (info->stripeIdentifier == NULL)
|
|
return (ENOMEM);
|
|
for (i = 0; i < (raidPtr->numCol / 2); i++) {
|
|
info->stripeIdentifier[i][0] = (2 * i);
|
|
info->stripeIdentifier[i][1] = (2 * i) + 1;
|
|
}
|
|
|
|
RF_ASSERT(raidPtr->numRow == 1);
|
|
|
|
/* this implementation of RAID level 1 uses one row of numCol disks
|
|
* and allows multiple (numCol / 2) stripes per row. A stripe
|
|
* consists of a single data unit and a single parity (mirror) unit.
|
|
* stripe id = raidAddr / stripeUnitSize */
|
|
raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit;
|
|
layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2);
|
|
layoutPtr->dataSectorsPerStripe = layoutPtr->sectorsPerStripeUnit;
|
|
layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
|
|
layoutPtr->numDataCol = 1;
|
|
layoutPtr->numParityCol = 1;
|
|
return (0);
|
|
}
|
|
|
|
|
|
/* returns the physical disk location of the primary copy in the mirror pair */
|
|
void
|
|
rf_MapSectorRAID1(
|
|
RF_Raid_t * raidPtr,
|
|
RF_RaidAddr_t raidSector,
|
|
RF_RowCol_t * row,
|
|
RF_RowCol_t * col,
|
|
RF_SectorNum_t * diskSector,
|
|
int remap)
|
|
{
|
|
RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
|
|
RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
|
|
|
|
*row = 0;
|
|
*col = 2 * mirrorPair;
|
|
*diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
|
|
}
|
|
|
|
|
|
/* Map Parity
|
|
*
|
|
* returns the physical disk location of the secondary copy in the mirror
|
|
* pair
|
|
*/
|
|
void
|
|
rf_MapParityRAID1(
|
|
RF_Raid_t * raidPtr,
|
|
RF_RaidAddr_t raidSector,
|
|
RF_RowCol_t * row,
|
|
RF_RowCol_t * col,
|
|
RF_SectorNum_t * diskSector,
|
|
int remap)
|
|
{
|
|
RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
|
|
RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
|
|
|
|
*row = 0;
|
|
*col = (2 * mirrorPair) + 1;
|
|
|
|
*diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
|
|
}
|
|
|
|
|
|
/* IdentifyStripeRAID1
|
|
*
|
|
* returns a list of disks for a given redundancy group
|
|
*/
|
|
void
|
|
rf_IdentifyStripeRAID1(
|
|
RF_Raid_t * raidPtr,
|
|
RF_RaidAddr_t addr,
|
|
RF_RowCol_t ** diskids,
|
|
RF_RowCol_t * outRow)
|
|
{
|
|
RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
|
|
RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
|
|
RF_ASSERT(stripeID >= 0);
|
|
RF_ASSERT(addr >= 0);
|
|
*outRow = 0;
|
|
*diskids = info->stripeIdentifier[stripeID % (raidPtr->numCol / 2)];
|
|
RF_ASSERT(*diskids);
|
|
}
|
|
|
|
|
|
/* MapSIDToPSIDRAID1
|
|
*
|
|
* maps a logical stripe to a stripe in the redundant array
|
|
*/
|
|
void
|
|
rf_MapSIDToPSIDRAID1(
|
|
RF_RaidLayout_t * layoutPtr,
|
|
RF_StripeNum_t stripeID,
|
|
RF_StripeNum_t * psID,
|
|
RF_ReconUnitNum_t * which_ru)
|
|
{
|
|
*which_ru = 0;
|
|
*psID = stripeID;
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
* select a graph to perform a single-stripe access
|
|
*
|
|
* Parameters: raidPtr - description of the physical array
|
|
* type - type of operation (read or write) requested
|
|
* asmap - logical & physical addresses for this access
|
|
* createFunc - name of function to use to create the graph
|
|
*****************************************************************************/
|
|
|
|
void
|
|
rf_RAID1DagSelect(
|
|
RF_Raid_t * raidPtr,
|
|
RF_IoType_t type,
|
|
RF_AccessStripeMap_t * asmap,
|
|
RF_VoidFuncPtr * createFunc)
|
|
{
|
|
RF_RowCol_t frow, fcol, or, oc;
|
|
RF_PhysDiskAddr_t *failedPDA;
|
|
int prior_recon;
|
|
RF_RowStatus_t rstat;
|
|
RF_SectorNum_t oo;
|
|
|
|
|
|
RF_ASSERT(RF_IO_IS_R_OR_W(type));
|
|
|
|
if (asmap->numDataFailed + asmap->numParityFailed > 1) {
|
|
RF_ERRORMSG("Multiple disks failed in a single group! Aborting I/O operation.\n");
|
|
*createFunc = NULL;
|
|
return;
|
|
}
|
|
if (asmap->numDataFailed + asmap->numParityFailed) {
|
|
/*
|
|
* We've got a fault. Re-map to spare space, iff applicable.
|
|
* Shouldn't the arch-independent code do this for us?
|
|
* Anyway, it turns out if we don't do this here, then when
|
|
* we're reconstructing, writes go only to the surviving
|
|
* original disk, and aren't reflected on the reconstructed
|
|
* spare. Oops. --jimz
|
|
*/
|
|
failedPDA = asmap->failedPDAs[0];
|
|
frow = failedPDA->row;
|
|
fcol = failedPDA->col;
|
|
rstat = raidPtr->status[frow];
|
|
prior_recon = (rstat == rf_rs_reconfigured) || (
|
|
(rstat == rf_rs_reconstructing) ?
|
|
rf_CheckRUReconstructed(raidPtr->reconControl[frow]->reconMap, failedPDA->startSector) : 0
|
|
);
|
|
if (prior_recon) {
|
|
or = frow;
|
|
oc = fcol;
|
|
oo = failedPDA->startSector;
|
|
/*
|
|
* If we did distributed sparing, we'd monkey with that here.
|
|
* But we don't, so we'll
|
|
*/
|
|
failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
|
|
failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
|
|
/*
|
|
* Redirect other components, iff necessary. This looks
|
|
* pretty suspicious to me, but it's what the raid5
|
|
* DAG select does.
|
|
*/
|
|
if (asmap->parityInfo->next) {
|
|
if (failedPDA == asmap->parityInfo) {
|
|
failedPDA->next->row = failedPDA->row;
|
|
failedPDA->next->col = failedPDA->col;
|
|
} else {
|
|
if (failedPDA == asmap->parityInfo->next) {
|
|
asmap->parityInfo->row = failedPDA->row;
|
|
asmap->parityInfo->col = failedPDA->col;
|
|
}
|
|
}
|
|
}
|
|
if (rf_dagDebug || rf_mapDebug) {
|
|
printf("raid%d: Redirected type '%c' r %d c %d o %ld -> r %d c %d o %ld\n",
|
|
raidPtr->raidid, type, or, oc,
|
|
(long) oo, failedPDA->row,
|
|
failedPDA->col,
|
|
(long) failedPDA->startSector);
|
|
}
|
|
asmap->numDataFailed = asmap->numParityFailed = 0;
|
|
}
|
|
}
|
|
if (type == RF_IO_TYPE_READ) {
|
|
if (asmap->numDataFailed == 0)
|
|
*createFunc = (RF_VoidFuncPtr) rf_CreateMirrorIdleReadDAG;
|
|
else
|
|
*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG;
|
|
} else {
|
|
*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
|
|
}
|
|
}
|
|
|
|
int
|
|
rf_VerifyParityRAID1(
|
|
RF_Raid_t * raidPtr,
|
|
RF_RaidAddr_t raidAddr,
|
|
RF_PhysDiskAddr_t * parityPDA,
|
|
int correct_it,
|
|
RF_RaidAccessFlags_t flags)
|
|
{
|
|
int nbytes, bcount, stripeWidth, ret, i, j, nbad, *bbufs;
|
|
RF_DagNode_t *blockNode, *unblockNode, *wrBlock;
|
|
RF_DagHeader_t *rd_dag_h, *wr_dag_h;
|
|
RF_AccessStripeMapHeader_t *asm_h;
|
|
RF_AllocListElem_t *allocList;
|
|
RF_AccTraceEntry_t tracerec;
|
|
RF_ReconUnitNum_t which_ru;
|
|
RF_RaidLayout_t *layoutPtr;
|
|
RF_AccessStripeMap_t *aasm;
|
|
RF_SectorCount_t nsector;
|
|
RF_RaidAddr_t startAddr;
|
|
char *buf, *buf1, *buf2;
|
|
RF_PhysDiskAddr_t *pda;
|
|
RF_StripeNum_t psID;
|
|
RF_MCPair_t *mcpair;
|
|
|
|
layoutPtr = &raidPtr->Layout;
|
|
startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
|
|
nsector = parityPDA->numSector;
|
|
nbytes = rf_RaidAddressToByte(raidPtr, nsector);
|
|
psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
|
|
|
|
asm_h = NULL;
|
|
rd_dag_h = wr_dag_h = NULL;
|
|
mcpair = NULL;
|
|
|
|
ret = RF_PARITY_COULD_NOT_VERIFY;
|
|
|
|
rf_MakeAllocList(allocList);
|
|
if (allocList == NULL)
|
|
return (RF_PARITY_COULD_NOT_VERIFY);
|
|
mcpair = rf_AllocMCPair();
|
|
if (mcpair == NULL)
|
|
goto done;
|
|
RF_ASSERT(layoutPtr->numDataCol == layoutPtr->numParityCol);
|
|
stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
|
|
bcount = nbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol);
|
|
RF_MallocAndAdd(buf, bcount, (char *), allocList);
|
|
if (buf == NULL)
|
|
goto done;
|
|
if (rf_verifyParityDebug) {
|
|
printf("raid%d: RAID1 parity verify: buf=%lx bcount=%d (%lx - %lx)\n",
|
|
raidPtr->raidid, (long) buf, bcount, (long) buf,
|
|
(long) buf + bcount);
|
|
}
|
|
/*
|
|
* Generate a DAG which will read the entire stripe- then we can
|
|
* just compare data chunks versus "parity" chunks.
|
|
*/
|
|
|
|
rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, nbytes, buf,
|
|
rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rod", allocList, flags,
|
|
RF_IO_NORMAL_PRIORITY);
|
|
if (rd_dag_h == NULL)
|
|
goto done;
|
|
blockNode = rd_dag_h->succedents[0];
|
|
unblockNode = blockNode->succedents[0]->succedents[0];
|
|
|
|
/*
|
|
* Map the access to physical disk addresses (PDAs)- this will
|
|
* get us both a list of data addresses, and "parity" addresses
|
|
* (which are really mirror copies).
|
|
*/
|
|
asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe,
|
|
buf, RF_DONT_REMAP);
|
|
aasm = asm_h->stripeMap;
|
|
|
|
buf1 = buf;
|
|
/*
|
|
* Loop through the data blocks, setting up read nodes for each.
|
|
*/
|
|
for (pda = aasm->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) {
|
|
RF_ASSERT(pda);
|
|
|
|
rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
|
|
|
|
RF_ASSERT(pda->numSector != 0);
|
|
if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
|
|
/* cannot verify parity with dead disk */
|
|
goto done;
|
|
}
|
|
pda->bufPtr = buf1;
|
|
blockNode->succedents[i]->params[0].p = pda;
|
|
blockNode->succedents[i]->params[1].p = buf1;
|
|
blockNode->succedents[i]->params[2].v = psID;
|
|
blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
|
|
buf1 += nbytes;
|
|
}
|
|
RF_ASSERT(pda == NULL);
|
|
/*
|
|
* keep i, buf1 running
|
|
*
|
|
* Loop through parity blocks, setting up read nodes for each.
|
|
*/
|
|
for (pda = aasm->parityInfo; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++, pda = pda->next) {
|
|
RF_ASSERT(pda);
|
|
rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
|
|
RF_ASSERT(pda->numSector != 0);
|
|
if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
|
|
/* cannot verify parity with dead disk */
|
|
goto done;
|
|
}
|
|
pda->bufPtr = buf1;
|
|
blockNode->succedents[i]->params[0].p = pda;
|
|
blockNode->succedents[i]->params[1].p = buf1;
|
|
blockNode->succedents[i]->params[2].v = psID;
|
|
blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
|
|
buf1 += nbytes;
|
|
}
|
|
RF_ASSERT(pda == NULL);
|
|
|
|
bzero((char *) &tracerec, sizeof(tracerec));
|
|
rd_dag_h->tracerec = &tracerec;
|
|
|
|
if (rf_verifyParityDebug > 1) {
|
|
printf("raid%d: RAID1 parity verify read dag:\n",
|
|
raidPtr->raidid);
|
|
rf_PrintDAGList(rd_dag_h);
|
|
}
|
|
RF_LOCK_MUTEX(mcpair->mutex);
|
|
mcpair->flag = 0;
|
|
rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
|
|
(void *) mcpair);
|
|
while (mcpair->flag == 0) {
|
|
RF_WAIT_MCPAIR(mcpair);
|
|
}
|
|
RF_UNLOCK_MUTEX(mcpair->mutex);
|
|
|
|
if (rd_dag_h->status != rf_enable) {
|
|
RF_ERRORMSG("Unable to verify raid1 parity: can't read stripe\n");
|
|
ret = RF_PARITY_COULD_NOT_VERIFY;
|
|
goto done;
|
|
}
|
|
/*
|
|
* buf1 is the beginning of the data blocks chunk
|
|
* buf2 is the beginning of the parity blocks chunk
|
|
*/
|
|
buf1 = buf;
|
|
buf2 = buf + (nbytes * layoutPtr->numDataCol);
|
|
ret = RF_PARITY_OKAY;
|
|
/*
|
|
* bbufs is "bad bufs"- an array whose entries are the data
|
|
* column numbers where we had miscompares. (That is, column 0
|
|
* and column 1 of the array are mirror copies, and are considered
|
|
* "data column 0" for this purpose).
|
|
*/
|
|
RF_MallocAndAdd(bbufs, layoutPtr->numParityCol * sizeof(int), (int *),
|
|
allocList);
|
|
nbad = 0;
|
|
/*
|
|
* Check data vs "parity" (mirror copy).
|
|
*/
|
|
for (i = 0; i < layoutPtr->numDataCol; i++) {
|
|
if (rf_verifyParityDebug) {
|
|
printf("raid%d: RAID1 parity verify %d bytes: i=%d buf1=%lx buf2=%lx buf=%lx\n",
|
|
raidPtr->raidid, nbytes, i, (long) buf1,
|
|
(long) buf2, (long) buf);
|
|
}
|
|
ret = bcmp(buf1, buf2, nbytes);
|
|
if (ret) {
|
|
if (rf_verifyParityDebug > 1) {
|
|
for (j = 0; j < nbytes; j++) {
|
|
if (buf1[j] != buf2[j])
|
|
break;
|
|
}
|
|
printf("psid=%ld j=%d\n", (long) psID, j);
|
|
printf("buf1 %02x %02x %02x %02x %02x\n", buf1[0] & 0xff,
|
|
buf1[1] & 0xff, buf1[2] & 0xff, buf1[3] & 0xff, buf1[4] & 0xff);
|
|
printf("buf2 %02x %02x %02x %02x %02x\n", buf2[0] & 0xff,
|
|
buf2[1] & 0xff, buf2[2] & 0xff, buf2[3] & 0xff, buf2[4] & 0xff);
|
|
}
|
|
if (rf_verifyParityDebug) {
|
|
printf("raid%d: RAID1: found bad parity, i=%d\n", raidPtr->raidid, i);
|
|
}
|
|
/*
|
|
* Parity is bad. Keep track of which columns were bad.
|
|
*/
|
|
if (bbufs)
|
|
bbufs[nbad] = i;
|
|
nbad++;
|
|
ret = RF_PARITY_BAD;
|
|
}
|
|
buf1 += nbytes;
|
|
buf2 += nbytes;
|
|
}
|
|
|
|
if ((ret != RF_PARITY_OKAY) && correct_it) {
|
|
ret = RF_PARITY_COULD_NOT_CORRECT;
|
|
if (rf_verifyParityDebug) {
|
|
printf("raid%d: RAID1 parity verify: parity not correct\n", raidPtr->raidid);
|
|
}
|
|
if (bbufs == NULL)
|
|
goto done;
|
|
/*
|
|
* Make a DAG with one write node for each bad unit. We'll simply
|
|
* write the contents of the data unit onto the parity unit for
|
|
* correction. (It's possible that the mirror copy was the correct
|
|
* copy, and that we're spooging good data by writing bad over it,
|
|
* but there's no way we can know that.
|
|
*/
|
|
wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, buf,
|
|
rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", allocList, flags,
|
|
RF_IO_NORMAL_PRIORITY);
|
|
if (wr_dag_h == NULL)
|
|
goto done;
|
|
wrBlock = wr_dag_h->succedents[0];
|
|
/*
|
|
* Fill in a write node for each bad compare.
|
|
*/
|
|
for (i = 0; i < nbad; i++) {
|
|
j = i + layoutPtr->numDataCol;
|
|
pda = blockNode->succedents[j]->params[0].p;
|
|
pda->bufPtr = blockNode->succedents[i]->params[1].p;
|
|
wrBlock->succedents[i]->params[0].p = pda;
|
|
wrBlock->succedents[i]->params[1].p = pda->bufPtr;
|
|
wrBlock->succedents[i]->params[2].v = psID;
|
|
wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
|
|
}
|
|
bzero((char *) &tracerec, sizeof(tracerec));
|
|
wr_dag_h->tracerec = &tracerec;
|
|
if (rf_verifyParityDebug > 1) {
|
|
printf("Parity verify write dag:\n");
|
|
rf_PrintDAGList(wr_dag_h);
|
|
}
|
|
RF_LOCK_MUTEX(mcpair->mutex);
|
|
mcpair->flag = 0;
|
|
/* fire off the write DAG */
|
|
rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
|
|
(void *) mcpair);
|
|
while (!mcpair->flag) {
|
|
RF_WAIT_COND(mcpair->cond, mcpair->mutex);
|
|
}
|
|
RF_UNLOCK_MUTEX(mcpair->mutex);
|
|
if (wr_dag_h->status != rf_enable) {
|
|
RF_ERRORMSG("Unable to correct RAID1 parity in VerifyParity\n");
|
|
goto done;
|
|
}
|
|
ret = RF_PARITY_CORRECTED;
|
|
}
|
|
done:
|
|
/*
|
|
* All done. We might've gotten here without doing part of the function,
|
|
* so cleanup what we have to and return our running status.
|
|
*/
|
|
if (asm_h)
|
|
rf_FreeAccessStripeMap(asm_h);
|
|
if (rd_dag_h)
|
|
rf_FreeDAG(rd_dag_h);
|
|
if (wr_dag_h)
|
|
rf_FreeDAG(wr_dag_h);
|
|
if (mcpair)
|
|
rf_FreeMCPair(mcpair);
|
|
rf_FreeAllocList(allocList);
|
|
if (rf_verifyParityDebug) {
|
|
printf("raid%d: RAID1 parity verify, returning %d\n",
|
|
raidPtr->raidid, ret);
|
|
}
|
|
return (ret);
|
|
}
|
|
|
|
int
|
|
rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
|
|
RF_ReconBuffer_t *rbuf; /* the recon buffer to submit */
|
|
int keep_it; /* whether we can keep this buffer or we have
|
|
* to return it */
|
|
int use_committed; /* whether to use a committed or an available
|
|
* recon buffer */
|
|
{
|
|
RF_ReconParityStripeStatus_t *pssPtr;
|
|
RF_ReconCtrl_t *reconCtrlPtr;
|
|
RF_RaidLayout_t *layoutPtr;
|
|
int retcode, created;
|
|
RF_CallbackDesc_t *cb, *p;
|
|
RF_ReconBuffer_t *t;
|
|
RF_Raid_t *raidPtr;
|
|
caddr_t ta;
|
|
|
|
retcode = 0;
|
|
created = 0;
|
|
|
|
raidPtr = rbuf->raidPtr;
|
|
layoutPtr = &raidPtr->Layout;
|
|
reconCtrlPtr = raidPtr->reconControl[rbuf->row];
|
|
|
|
RF_ASSERT(rbuf);
|
|
RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
|
|
|
|
if (rf_reconbufferDebug) {
|
|
printf("raid%d: RAID1 reconbuffer submission r%d c%d psid %ld ru%d (failed offset %ld)\n",
|
|
raidPtr->raidid, rbuf->row, rbuf->col,
|
|
(long) rbuf->parityStripeID, rbuf->which_ru,
|
|
(long) rbuf->failedDiskSectorOffset);
|
|
}
|
|
if (rf_reconDebug) {
|
|
printf("RAID1 reconbuffer submit psid %ld buf %lx\n",
|
|
(long) rbuf->parityStripeID, (long) rbuf->buffer);
|
|
printf("RAID1 psid %ld %02x %02x %02x %02x %02x\n",
|
|
(long) rbuf->parityStripeID,
|
|
rbuf->buffer[0], rbuf->buffer[1], rbuf->buffer[2], rbuf->buffer[3],
|
|
rbuf->buffer[4]);
|
|
}
|
|
RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
|
|
|
|
RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
|
|
|
|
pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
|
|
rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
|
|
RF_ASSERT(pssPtr); /* if it didn't exist, we wouldn't have gotten
|
|
* an rbuf for it */
|
|
|
|
/*
|
|
* Since this is simple mirroring, the first submission for a stripe is also
|
|
* treated as the last.
|
|
*/
|
|
|
|
t = NULL;
|
|
if (keep_it) {
|
|
if (rf_reconbufferDebug) {
|
|
printf("raid%d: RAID1 rbuf submission: keeping rbuf\n",
|
|
raidPtr->raidid);
|
|
}
|
|
t = rbuf;
|
|
} else {
|
|
if (use_committed) {
|
|
if (rf_reconbufferDebug) {
|
|
printf("raid%d: RAID1 rbuf submission: using committed rbuf\n", raidPtr->raidid);
|
|
}
|
|
t = reconCtrlPtr->committedRbufs;
|
|
RF_ASSERT(t);
|
|
reconCtrlPtr->committedRbufs = t->next;
|
|
t->next = NULL;
|
|
} else
|
|
if (reconCtrlPtr->floatingRbufs) {
|
|
if (rf_reconbufferDebug) {
|
|
printf("raid%d: RAID1 rbuf submission: using floating rbuf\n", raidPtr->raidid);
|
|
}
|
|
t = reconCtrlPtr->floatingRbufs;
|
|
reconCtrlPtr->floatingRbufs = t->next;
|
|
t->next = NULL;
|
|
}
|
|
}
|
|
if (t == NULL) {
|
|
if (rf_reconbufferDebug) {
|
|
printf("raid%d: RAID1 rbuf submission: waiting for rbuf\n", raidPtr->raidid);
|
|
}
|
|
RF_ASSERT((keep_it == 0) && (use_committed == 0));
|
|
raidPtr->procsInBufWait++;
|
|
if ((raidPtr->procsInBufWait == (raidPtr->numCol - 1))
|
|
&& (raidPtr->numFullReconBuffers == 0)) {
|
|
/* ruh-ro */
|
|
RF_ERRORMSG("Buffer wait deadlock\n");
|
|
rf_PrintPSStatusTable(raidPtr, rbuf->row);
|
|
RF_PANIC();
|
|
}
|
|
pssPtr->flags |= RF_PSS_BUFFERWAIT;
|
|
cb = rf_AllocCallbackDesc();
|
|
cb->row = rbuf->row;
|
|
cb->col = rbuf->col;
|
|
cb->callbackArg.v = rbuf->parityStripeID;
|
|
cb->callbackArg2.v = rbuf->which_ru;
|
|
cb->next = NULL;
|
|
if (reconCtrlPtr->bufferWaitList == NULL) {
|
|
/* we are the wait list- lucky us */
|
|
reconCtrlPtr->bufferWaitList = cb;
|
|
} else {
|
|
/* append to wait list */
|
|
for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next);
|
|
p->next = cb;
|
|
}
|
|
retcode = 1;
|
|
goto out;
|
|
}
|
|
if (t != rbuf) {
|
|
t->row = rbuf->row;
|
|
t->col = reconCtrlPtr->fcol;
|
|
t->parityStripeID = rbuf->parityStripeID;
|
|
t->which_ru = rbuf->which_ru;
|
|
t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
|
|
t->spRow = rbuf->spRow;
|
|
t->spCol = rbuf->spCol;
|
|
t->spOffset = rbuf->spOffset;
|
|
/* Swap buffers. DANCE! */
|
|
ta = t->buffer;
|
|
t->buffer = rbuf->buffer;
|
|
rbuf->buffer = ta;
|
|
}
|
|
/*
|
|
* Use the rbuf we've been given as the target.
|
|
*/
|
|
RF_ASSERT(pssPtr->rbuf == NULL);
|
|
pssPtr->rbuf = t;
|
|
|
|
t->count = 1;
|
|
/*
|
|
* Below, we use 1 for numDataCol (which is equal to the count in the
|
|
* previous line), so we'll always be done.
|
|
*/
|
|
rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, 1);
|
|
|
|
out:
|
|
RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
|
|
RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
|
|
if (rf_reconbufferDebug) {
|
|
printf("raid%d: RAID1 rbuf submission: returning %d\n",
|
|
raidPtr->raidid, retcode);
|
|
}
|
|
return (retcode);
|
|
}
|