root/dev/raidframe/rf_parityscan.c

DEFINITIONS

1. rf_RewriteParity
2. rf_VerifyParity
3. rf_VerifyParityBasic
4. rf_TryToRedirectPDA
5. rf_VerifyDegrModeWrite
6. rf_MakeSimpleDAG

    1 /*      $OpenBSD: rf_parityscan.c,v 1.7 2002/12/16 07:01:04 tdeval Exp $        */
    2 /*      $NetBSD: rf_parityscan.c,v 1.9 2000/05/28 03:00:31 oster Exp $  */
    4 /*
    5  * Copyright (c) 1995 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author: Mark Holland
    9  *
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  *
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  *
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   31 /*****************************************************************************
   32  *
   33  * rf_parityscan.c -- Misc utilities related to parity verification.
   34  *
   35  *****************************************************************************/
   37 #include "rf_types.h"
   38 #include "rf_raid.h"
   39 #include "rf_dag.h"
   40 #include "rf_dagfuncs.h"
   41 #include "rf_dagutils.h"
   42 #include "rf_mcpair.h"
   43 #include "rf_general.h"
   44 #include "rf_engine.h"
   45 #include "rf_parityscan.h"
   46 #include "rf_map.h"
   49 /*****************************************************************************
   50  *
   51  * Walk through the entire arry and write new parity.
   52  * This works by creating two DAGs, one to read a stripe of data and one to
   53  * write new parity. The first is executed, the data is xored together, and
   54  * then the second is executed. To avoid constantly building and tearing down
   55  * the DAGs, we create them a priori and fill them in with the mapping
   56  * information as we go along.
   57  *
   58  * There should never be more than one thread running this.
   59  *
   60  *****************************************************************************/
   61 int
rf_RewriteParity(RF_Raid_t *raidPtr)
   63 {
RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
RF_AccessStripeMapHeader_t *asm_h;
   66         int ret_val;
   67         int rc;
RF_PhysDiskAddr_t pda;
RF_SectorNum_t i;
   71         if (raidPtr->Layout.map->faultsTolerated == 0) {
   72                 /* There isn't any parity. Call it "okay." */
   73                 return (RF_PARITY_OKAY);
   74         }
   75         if (raidPtr->status[0] != rf_rs_optimal) {
   76                 /*
   77                  * We're in degraded mode. Don't try to verify parity now !
   78                  * XXX: This should be a "we don't want to", not a
   79                  * "we can't" error.
   80                  */
   81                 return (RF_PARITY_COULD_NOT_VERIFY);
   82         }
ret_val = 0;
pda.startSector = 0;
pda.numSector = raidPtr->Layout.sectorsPerStripeUnit;
rc = RF_PARITY_OKAY;
   90         for (i = 0; i < raidPtr->totalSectors && rc <= RF_PARITY_CORRECTED;
i += layoutPtr->dataSectorsPerStripe) {
   92                 if (raidPtr->waitShutdown) {
   93                         /*
   94                          * Someone is pulling the plug on this set...
   95                          * Abort the re-write.
   96                          */
   97                         return (1);
   98                 }
asm_h = rf_MapAccess(raidPtr, i,
layoutPtr->dataSectorsPerStripe, NULL, RF_DONT_REMAP);
raidPtr->parity_rewrite_stripes_done =
i / layoutPtr->dataSectorsPerStripe ;
rc = rf_VerifyParity(raidPtr, asm_h->stripeMap, 1, 0);
  104                 switch (rc) {
  105                 case RF_PARITY_OKAY:
  106                 case RF_PARITY_CORRECTED:
  107                         break;
  108                 case RF_PARITY_BAD:
printf("Parity bad during correction.\n");
ret_val = 1;
  111                         break;
  112                 case RF_PARITY_COULD_NOT_CORRECT:
printf("Could not correct bad parity.\n");
ret_val = 1;
  115                         break;
  116                 case RF_PARITY_COULD_NOT_VERIFY:
printf("Could not verify parity.\n");
ret_val = 1;
  119                         break;
  120                 default:
printf("Bad rc=%d from VerifyParity in"
  122                             " RewriteParity.\n", rc);
ret_val = 1;
  124                 }
rf_FreeAccessStripeMap(asm_h);
  126         }
  127         return (ret_val);
  128 }
  131 /*****************************************************************************
  132  *
  133  * Verify that the parity in a particular stripe is correct.
  134  * We validate only the range of parity defined by parityPDA, since
  135  * this is all we have locked. The way we do this is to create an asm
  136  * that maps the whole stripe and then range-restrict it to the parity
  137  * region defined by the parityPDA.
  138  *
  139  *****************************************************************************/
  140 int
rf_VerifyParity(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *aasm, int correct_it,
RF_RaidAccessFlags_t flags)
  143 {
RF_PhysDiskAddr_t *parityPDA;
RF_AccessStripeMap_t *doasm;
RF_LayoutSW_t *lp;
  147         int lrc, rc;
lp = raidPtr->Layout.map;
  150         if (lp->faultsTolerated == 0) {
  151                 /*
  152                  * There isn't any parity. Call it "okay."
  153                  */
  154                 return (RF_PARITY_OKAY);
  155         }
rc = RF_PARITY_OKAY;
  157         if (lp->VerifyParity) {
  158                 for (doasm = aasm; doasm; doasm = doasm->next) {
  159                         for (parityPDA = doasm->parityInfo; parityPDA;
parityPDA = parityPDA->next) {
lrc = lp->VerifyParity(raidPtr,
doasm->raidAddress, parityPDA, correct_it,
flags);
  164                                 if (lrc > rc) {
  165                                         /*
  166                                          * see rf_parityscan.h for why this
  167                                          * works.
  168                                          */
rc = lrc;
  170                                 }
  171                         }
  172                 }
  173         } else {
rc = RF_PARITY_COULD_NOT_VERIFY;
  175         }
  176         return (rc);
  177 }
  179 int
rf_VerifyParityBasic(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
  182 {
RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
RF_RaidAddr_t startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
raidAddr);
RF_SectorCount_t numsector = parityPDA->numSector;
  187         int numbytes = rf_RaidAddressToByte(raidPtr, numsector);
  188         int bytesPerStripe = numbytes * layoutPtr->numDataCol;
RF_DagHeader_t *rd_dag_h, *wr_dag_h;    /* Read, write dag. */
RF_DagNode_t *blockNode, *unblockNode, *wrBlock, *wrUnblock;
RF_AccessStripeMapHeader_t *asm_h;
RF_AccessStripeMap_t *asmap;
RF_AllocListElem_t *alloclist;
RF_PhysDiskAddr_t *pda;
  195         char *pbuf, *buf, *end_p, *p;
  196         int i, retcode;
RF_ReconUnitNum_t which_ru;
RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr,
raidAddr, &which_ru);
  200         int stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
RF_AccTraceEntry_t tracerec;
RF_MCPair_t *mcpair;
retcode = RF_PARITY_OKAY;
mcpair = rf_AllocMCPair();
rf_MakeAllocList(alloclist);
RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol +
layoutPtr->numParityCol), (char *), alloclist);
  210         /* Use calloc to make sure buffer is zeroed. */
RF_CallocAndAdd(pbuf, 1, numbytes, (char *), alloclist);
end_p = buf + bytesPerStripe;
rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf,
rf_DiskReadFunc, rf_DiskReadUndoFunc,
  216             "Rod", alloclist, flags, RF_IO_NORMAL_PRIORITY);
blockNode = rd_dag_h->succedents[0];
unblockNode = blockNode->succedents[0]->succedents[0];
  220         /* Map the stripe and fill in the PDAs in the dag. */
asm_h = rf_MapAccess(raidPtr, startAddr,
layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
asmap = asm_h->stripeMap;
  225         for (pda = asmap->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);
  230                 if (rf_TryToRedirectPDA(raidPtr, pda, 0))
  231                         goto out;       /*
  232                                          * No way to verify parity if disk is
  233                                          * dead. Return w/ good status.
  234                                          */
blockNode->succedents[i]->params[0].p = pda;
blockNode->succedents[i]->params[2].v = psID;
blockNode->succedents[i]->params[3].v =
RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
  239         }
RF_ASSERT(!asmap->parityInfo->next);
rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
RF_ASSERT(asmap->parityInfo->numSector != 0);
  244         if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
  245                 goto out;
blockNode->succedents[layoutPtr->numDataCol]->params[0].p =
asmap->parityInfo;
  249         /* Fire off the DAG. */
bzero((char *) &tracerec, sizeof(tracerec));
rd_dag_h->tracerec = &tracerec;
  253         if (rf_verifyParityDebug) {
printf("Parity verify read dag:\n");
rf_PrintDAGList(rd_dag_h);
  256         }
RF_LOCK_MUTEX(mcpair->mutex);
mcpair->flag = 0;
rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
  260             (void *) mcpair);
  261         while (!mcpair->flag)
RF_WAIT_COND(mcpair->cond, mcpair->mutex);
RF_UNLOCK_MUTEX(mcpair->mutex);
  264         if (rd_dag_h->status != rf_enable) {
RF_ERRORMSG("Unable to verify parity:  can't read the"
  266                             " stripe.\n");
retcode = RF_PARITY_COULD_NOT_VERIFY;
  268                 goto out;
  269         }
  270         for (p = buf; p < end_p; p += numbytes) {
rf_bxor(p, pbuf, numbytes, NULL);
  272         }
  273         for (i = 0; i < numbytes; i++) {
  274 #if 0
  275                 if (pbuf[i] != 0 || buf[bytesPerStripe + i] != 0) {
printf("Bytes: %d %d %d\n", i, pbuf[i],
buf[bytesPerStripe + i]);
  278                 }
  279 #endif
  280                 if (pbuf[i] != buf[bytesPerStripe + i]) {
  281                         if (!correct_it)
RF_ERRORMSG3("Parity verify error: byte %d of"
  283                                     " parity is 0x%x should be 0x%x.\n", i,
  284                                     (u_char) buf[bytesPerStripe + i],
  285                                     (u_char) pbuf[i]);
retcode = RF_PARITY_BAD;
  287                         break;
  288                 }
  289         }
  291         if (retcode && correct_it) {
wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf,
rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
  294                     "Wnp", alloclist, flags, RF_IO_NORMAL_PRIORITY);
wrBlock = wr_dag_h->succedents[0];
wrUnblock = wrBlock->succedents[0]->succedents[0];
wrBlock->succedents[0]->params[0].p = asmap->parityInfo;
wrBlock->succedents[0]->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;
  303                 if (rf_verifyParityDebug) {
printf("Parity verify write dag:\n");
rf_PrintDAGList(wr_dag_h);
  306                 }
RF_LOCK_MUTEX(mcpair->mutex);
mcpair->flag = 0;
rf_DispatchDAG(wr_dag_h, (void (*) (void *))
rf_MCPairWakeupFunc, (void *) mcpair);
  311                 while (!mcpair->flag)
RF_WAIT_COND(mcpair->cond, mcpair->mutex);
RF_UNLOCK_MUTEX(mcpair->mutex);
  314                 if (wr_dag_h->status != rf_enable) {
RF_ERRORMSG("Unable to correct parity in VerifyParity:"
  316                             "  can't write the stripe.\n");
retcode = RF_PARITY_COULD_NOT_CORRECT;
  318                 }
rf_FreeDAG(wr_dag_h);
  320                 if (retcode == RF_PARITY_BAD)
retcode = RF_PARITY_CORRECTED;
  322         }
out:
rf_FreeAccessStripeMap(asm_h);
rf_FreeAllocList(alloclist);
rf_FreeDAG(rd_dag_h);
rf_FreeMCPair(mcpair);
  328         return (retcode);
  329 }
  331 int
rf_TryToRedirectPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, int parity)
  333 {
  334         if (raidPtr->Disks[pda->row][pda->col].status == rf_ds_reconstructing) {
  335                 if (rf_CheckRUReconstructed(raidPtr->reconControl[pda->row]
  336                      ->reconMap, pda->startSector)) {
  337                         if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
RF_RowCol_t or = pda->row, oc = pda->col;
RF_SectorNum_t os = pda->startSector;
  340                                 if (parity) {
  341                                         (raidPtr->Layout.map->MapParity)
  342                                             (raidPtr, pda->raidAddress,
  343                                              &pda->row, &pda->col,
  344                                              &pda->startSector, RF_REMAP);
  345                                         if (rf_verifyParityDebug)
printf("VerifyParity: Redir P"
  347                                                     " r %d c %d sect %ld ->"
  348                                                     " r %d c %d sect %ld.\n",
or, oc, (long) os,
pda->row, pda->col,
  351                                                     (long) pda->startSector);
  352                                 } else {
  353                                         (raidPtr->Layout.map->MapSector)
  354                                             (raidPtr, pda->raidAddress,
  355                                              &pda->row, &pda->col,
  356                                              &pda->startSector, RF_REMAP);
  357                                         if (rf_verifyParityDebug)
printf("VerifyParity: Redir D"
  359                                                     " r %d c %d sect %ld ->"
  360                                                     " r %d c %d sect %ld.\n",
or, oc, (long) os,
pda->row, pda->col,
  363                                                     (long) pda->startSector);
  364                                 }
  365                         } else {
RF_RowCol_t spRow =
raidPtr->Disks[pda->row][pda->col].spareRow;
RF_RowCol_t spCol =
raidPtr->Disks[pda->row][pda->col].spareCol;
pda->row = spRow;
pda->col = spCol;
  372                         }
  373                 }
  374         }
  375         if (RF_DEAD_DISK(raidPtr->Disks[pda->row][pda->col].status))
  376                 return (1);
  377         return (0);
  378 }
  381 /*****************************************************************************
  382  *
  383  * Currently a stub.
  384  *
  385  * Takes as input an ASM describing a write operation and containing one
  386  * failure, and verifies that the parity was correctly updated to reflect the
  387  * write.
  388  *
  389  * If it's a data unit that has failed, we read the other data units in the
  390  * stripe and the parity unit, XOR them together, and verify that we get the
  391  * data intended for the failed disk. Since it's easy, we also validate that
  392  * the right data got written to the surviving data disks.
  393  *
  394  * If it's the parity that failed, there's really no validation we can do
  395  * except the above verification that the right data got written to all disks.
  396  * This is because the new data intended for the failed disk is supplied in
  397  * the ASM, but this is of course not the case for the new parity.
  398  *
  399  *****************************************************************************/
  400 int
rf_VerifyDegrModeWrite(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asmh)
  402 {
  403         return (0);
  404 }
  407 /*
  408  * Creates a simple DAG with a header, a block-recon node at level 1,
  409  * nNodes nodes at level 2, an unblock-recon node at level 3, and
  410  * a terminator node at level 4. The stripe address field in
  411  * the block and unblock nodes are not touched, nor are the pda
  412  * fields in the second-level nodes, so they must be filled in later.
  413  *
  414  * Commit point is established at unblock node - this means that any
  415  * failure during dag execution causes the dag to fail.
  416  */
RF_DagHeader_t *
rf_MakeSimpleDAG(RF_Raid_t *raidPtr, int nNodes, int bytesPerSU, char *databuf,
  419     int (*doFunc) (RF_DagNode_t * node), int (*undoFunc) (RF_DagNode_t * node),
  420     char *name  /* Node names at the second level. */,
RF_AllocListElem_t *alloclist, RF_RaidAccessFlags_t flags, int priority)
  422 {
RF_DagHeader_t *dag_h;
RF_DagNode_t *nodes, *termNode, *blockNode, *unblockNode;
  425         int i;
  427         /*
  428          * Create the nodes, the block & unblock nodes, and the terminator
  429          * node.
  430          */
RF_CallocAndAdd(nodes, nNodes + 3, sizeof(RF_DagNode_t),
  432             (RF_DagNode_t *), alloclist);
blockNode = &nodes[nNodes];
unblockNode = blockNode + 1;
termNode = unblockNode + 1;
dag_h = rf_AllocDAGHeader();
dag_h->raidPtr = (void *) raidPtr;
dag_h->allocList = NULL;        /* We won't use this alloc list. */
dag_h->status = rf_enable;
dag_h->numSuccedents = 1;
dag_h->creator = "SimpleDAG";
  444         /*
  445          * This dag can not commit until the unblock node is reached.
  446          * Errors prior to the commit point imply the dag has failed.
  447          */
dag_h->numCommitNodes = 1;
dag_h->numCommits = 0;
dag_h->succedents[0] = blockNode;
rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h,
  454             "Nil", alloclist);
rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h,
  457             "Nil", alloclist);
unblockNode->succedents[0] = termNode;
  459         for (i = 0; i < nNodes; i++) {
blockNode->succedents[i] = unblockNode->antecedents[i]
  461                                          = &nodes[i];
unblockNode->antType[i] = rf_control;
rf_InitNode(&nodes[i], rf_wait, RF_FALSE, doFunc, undoFunc,
rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, alloclist);
nodes[i].succedents[0] = unblockNode;
nodes[i].antecedents[0] = blockNode;
nodes[i].antType[0] = rf_control;
nodes[i].params[1].p = (databuf + (i * bytesPerSU));
  469         }
rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", alloclist);
termNode->antecedents[0] = unblockNode;
termNode->antType[0] = rf_control;
  474         return (dag_h);
  475 }