File: [local] / sys / dev / raidframe / rf_raid1.c (download)
Revision 1.1.1.1 (vendor branch), Tue Mar 4 16:09:50 2008 UTC (16 years, 4 months ago) by nbrk
Branch: OPENBSD_4_2_BASE, MAIN
CVS Tags: jornada-partial-support-wip, HEAD Changes since 1.1: +0 -0 lines
Import of OpenBSD 4.2 release kernel tree with initial code to support
Jornada 720/728, StrongARM 1110-based handheld PC.
At this point kernel roots on NFS and boots into vfs_mountroot() and traps.
What is supported:
- glass console, Jornada framebuffer (jfb) works in 16bpp direct color mode
(needs some palette tweaks for non black/white/blue colors, i think)
- saic, SA11x0 interrupt controller (needs cleanup)
- sacom, SA11x0 UART (supported only as boot console for now)
- SA11x0 GPIO controller fully supported (but can't handle multiple interrupt
handlers on one gpio pin)
- sassp, SSP port on SA11x0 that attaches spibus
- Jornada microcontroller (jmcu) to control kbd, battery, etc throught
the SPI bus (wskbd attaches on jmcu, but not tested)
- tod functions seem work
- initial code for SA-1111 (chip companion) : this is TODO
Next important steps, i think:
- gpio and intc on sa1111
- pcmcia support for sa11x0 (and sa1111 help logic)
- REAL root on nfs when we have PCMCIA support (we may use any of supported pccard NICs)
- root on wd0! (using already supported PCMCIA-ATA)
|
/* $OpenBSD: rf_raid1.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $ */
/* $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 "rf_raid.h"
#include "rf_raid1.h"
#include "rf_dag.h"
#include "rf_dagffrd.h"
#include "rf_dagffwr.h"
#include "rf_dagdegrd.h"
#include "rf_dagutils.h"
#include "rf_dagfuncs.h"
#include "rf_diskqueue.h"
#include "rf_general.h"
#include "rf_utils.h"
#include "rf_parityscan.h"
#include "rf_mcpair.h"
#include "rf_layout.h"
#include "rf_map.h"
#include "rf_engine.h"
#include "rf_reconbuffer.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 that 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(
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);
}