/*      $NetBSD: rf_evenodd.c,v 1.24 2025/06/27 21:36:22 andvar Exp $   */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Chang-Ming Wu
*
* 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  [email protected]
*  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_evenodd.c -- implements EVENODD array architecture
*
****************************************************************************************/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rf_evenodd.c,v 1.24 2025/06/27 21:36:22 andvar Exp $");

#include "rf_archs.h"

#if RF_INCLUDE_EVENODD > 0

#include <dev/raidframe/raidframevar.h>

#include "rf_raid.h"
#include "rf_dag.h"
#include "rf_dagffrd.h"
#include "rf_dagffwr.h"
#include "rf_dagdegrd.h"
#include "rf_dagdegwr.h"
#include "rf_dagutils.h"
#include "rf_dagfuncs.h"
#include "rf_etimer.h"
#include "rf_general.h"
#include "rf_evenodd.h"
#include "rf_parityscan.h"
#include "rf_utils.h"
#include "rf_map.h"
#include "rf_pq.h"
#include "rf_mcpair.h"
#include "rf_evenodd_dagfuncs.h"
#include "rf_evenodd_dags.h"
#include "rf_engine.h"

typedef struct RF_EvenOddConfigInfo_s {
       RF_RowCol_t **stripeIdentifier; /* filled in at config time & used by
                                        * IdentifyStripe */
}       RF_EvenOddConfigInfo_t;

int
rf_ConfigureEvenOdd(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
                   RF_Config_t *cfgPtr)
{
       RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
       RF_EvenOddConfigInfo_t *info;
       RF_RowCol_t i, j, startdisk;

       info = RF_MallocAndAdd(sizeof(*info), raidPtr->cleanupList);
       layoutPtr->layoutSpecificInfo = (void *) info;

       info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, raidPtr->numCol, raidPtr->cleanupList);
       startdisk = 0;
       for (i = 0; i < raidPtr->numCol; i++) {
               for (j = 0; j < raidPtr->numCol; j++) {
                       info->stripeIdentifier[i][j] = (startdisk + j) % raidPtr->numCol;
               }
               if ((startdisk -= 2) < 0)
                       startdisk += raidPtr->numCol;
       }

       /* fill in the remaining layout parameters */
       layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
       layoutPtr->numDataCol = raidPtr->numCol - 2;    /* ORIG:
                                                        * layoutPtr->numDataCol
                                                        * = raidPtr->numCol-1;  */
#if RF_EO_MATRIX_DIM > 17
       if (raidPtr->numCol <= 17) {
               printf("Number of stripe units in a parity stripe is smaller than 17. Please\n");
               printf("define the macro RF_EO_MATRIX_DIM in file rf_evenodd_dagfuncs.h to \n");
               printf("be 17 to increase performance. \n");
               return (EINVAL);
       }
#elif RF_EO_MATRIX_DIM == 17
       if (raidPtr->numCol > 17) {
               printf("Number of stripe units in a parity stripe is bigger than 17. Please\n");
               printf("define the macro RF_EO_MATRIX_DIM in file rf_evenodd_dagfuncs.h to \n");
               printf("be 257 for encoding and decoding functions to work. \n");
               return (EINVAL);
       }
#endif
       layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
       layoutPtr->numParityCol = 2;
       layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
       raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;

       raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;

       return (0);
}

int
rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t *raidPtr)
{
       return (20);
}

RF_HeadSepLimit_t
rf_GetDefaultHeadSepLimitEvenOdd(RF_Raid_t *raidPtr)
{
       return (10);
}

void
rf_IdentifyStripeEvenOdd(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
                        RF_RowCol_t **diskids)
{
       RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
       RF_EvenOddConfigInfo_t *info = (RF_EvenOddConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;

       *diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
}
/* The layout of stripe unit on the disks are:      c0 c1 c2 c3 c4

                                                    0  1  2  E  P
                                                    5  E  P  3  4
                                                    P  6  7  8  E
                                                   10 11  E  P  9
                                                    E  P 12 13 14
                                                    ....

 We use the MapSectorRAID5 to map data information because the routine can be shown to map exactly
 the layout of data stripe unit as shown above although we have 2 redundant information now.
 But for E and P, we use rf_MapEEvenOdd and rf_MapParityEvenOdd which are different method from raid-5.
*/


void
rf_MapParityEvenOdd(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
                   RF_RowCol_t *col,
                   RF_SectorNum_t *diskSector, int remap)
{
       RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
       RF_StripeNum_t endSUIDofthisStrip = (SUID / raidPtr->Layout.numDataCol + 1) * raidPtr->Layout.numDataCol - 1;

       *col = (endSUIDofthisStrip + 2) % raidPtr->numCol;
       *diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
           (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
}

void
rf_MapEEvenOdd(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
              RF_RowCol_t *col, RF_SectorNum_t *diskSector,
              int remap)
{
       RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
       RF_StripeNum_t endSUIDofthisStrip = (SUID / raidPtr->Layout.numDataCol + 1) * raidPtr->Layout.numDataCol - 1;

       *col = (endSUIDofthisStrip + 1) % raidPtr->numCol;
       *diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
           (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
}

void
rf_EODagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
              RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
{
       RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
       unsigned ndfail = asmap->numDataFailed;
       unsigned npfail = asmap->numParityFailed + asmap->numQFailed;
       unsigned ntfail = npfail + ndfail;

       RF_ASSERT(RF_IO_IS_R_OR_W(type));
       if (ntfail > 2) {
               RF_ERRORMSG("more than two disks failed in a single group!  Aborting I/O operation.\n");
               *createFunc = NULL;
               return;
       }
       /* ok, we can do this I/O */
       if (type == RF_IO_TYPE_READ) {
               switch (ndfail) {
               case 0:
                       /* fault free read */
                       *createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;       /* same as raid 5 */
                       break;
               case 1:
                       /* lost a single data unit */
                       /* two cases: (1) parity is not lost. do a normal raid
                        * 5 reconstruct read. (2) parity is lost. do a
                        * reconstruct read using "e". */
                       if (ntfail == 2) {      /* also lost redundancy */
                               if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_PARITY)
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_110_CreateReadDAG;
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_101_CreateReadDAG;
                       } else {
                               /* P and E are ok. But is there a failure in
                                * some unaccessed data unit? */
                               if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_200_CreateReadDAG;
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_100_CreateReadDAG;
                       }
                       break;
               case 2:
                       /* *createFunc = rf_EO_200_CreateReadDAG; */
                       *createFunc = NULL;
                       break;
               }
               return;
       }
       /* a write */
       switch (ntfail) {
       case 0:         /* fault free */
               if (rf_suppressLocksAndLargeWrites ||
                   (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) && (layoutPtr->numDataCol != 1)) ||
                       (asmap->parityInfo->next != NULL) || (asmap->qInfo->next != NULL) || rf_CheckStripeForFailures(raidPtr, asmap))) {

                       *createFunc = (RF_VoidFuncPtr) rf_EOCreateSmallWriteDAG;
               } else {
                       *createFunc = (RF_VoidFuncPtr) rf_EOCreateLargeWriteDAG;
               }
               break;

       case 1:         /* single disk fault */
               if (npfail == 1) {
                       RF_ASSERT((asmap->failedPDAs[0]->type == RF_PDA_TYPE_PARITY) || (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q));
                       if (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q) {      /* q died, treat like
                                                                                * normal mode raid5
                                                                                * write. */
                               if (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) || (asmap->numStripeUnitsAccessed == 1))
                                   || (asmap->parityInfo->next != NULL) || rf_NumFailedDataUnitsInStripe(raidPtr, asmap))
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_001_CreateSmallWriteDAG;
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_001_CreateLargeWriteDAG;
                       } else {/* parity died, small write only updating Q */
                               if (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) || (asmap->numStripeUnitsAccessed == 1))
                                   || (asmap->qInfo->next != NULL) || rf_NumFailedDataUnitsInStripe(raidPtr, asmap))
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_010_CreateSmallWriteDAG;
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_010_CreateLargeWriteDAG;
                       }
               } else {        /* data missing. Do a P reconstruct write if
                                * only a single data unit is lost in the
                                * stripe, otherwise a reconstruct write which
                                * employing both P and E units. */
                       if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2) {
                               if (asmap->numStripeUnitsAccessed == 1)
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_200_CreateWriteDAG;
                               else
                                       *createFunc = NULL;     /* No direct support for
                                                                * this case now, like
                                                                * that in Raid-5  */
                       } else {
                               if (asmap->numStripeUnitsAccessed != 1 && asmap->failedPDAs[0]->numSector != layoutPtr->sectorsPerStripeUnit)
                                       *createFunc = NULL;     /* No direct support for
                                                                * this case now, like
                                                                * that in Raid-5  */
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_100_CreateWriteDAG;
                       }
               }
               break;

       case 2:         /* two disk faults */
               switch (npfail) {
               case 2: /* both p and q dead */
                       *createFunc = (RF_VoidFuncPtr) rf_EO_011_CreateWriteDAG;
                       break;
               case 1: /* either p or q and dead data */
                       RF_ASSERT(asmap->failedPDAs[0]->type == RF_PDA_TYPE_DATA);
                       RF_ASSERT((asmap->failedPDAs[1]->type == RF_PDA_TYPE_PARITY) || (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q));
                       if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q) {
                               if (asmap->numStripeUnitsAccessed != 1 && asmap->failedPDAs[0]->numSector != layoutPtr->sectorsPerStripeUnit)
                                       *createFunc = NULL;     /* In both PQ and
                                                                * EvenOdd, no direct
                                                                * support for this case
                                                                * now, like that in
                                                                * Raid-5  */
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_101_CreateWriteDAG;
                       } else {
                               if (asmap->numStripeUnitsAccessed != 1 && asmap->failedPDAs[0]->numSector != layoutPtr->sectorsPerStripeUnit)
                                       *createFunc = NULL;     /* No direct support for
                                                                * this case, like that
                                                                * in Raid-5  */
                               else
                                       *createFunc = (RF_VoidFuncPtr) rf_EO_110_CreateWriteDAG;
                       }
                       break;
               case 0: /* double data loss */
                       /* if(asmap->failedPDAs[0]->numSector +
                        * asmap->failedPDAs[1]->numSector == 2 *
                        * layoutPtr->sectorsPerStripeUnit ) createFunc =
                        * rf_EOCreateLargeWriteDAG; else                                                        */
                       *createFunc = NULL;     /* currently, in Evenodd, No
                                                * support for simultaneous
                                                * access of both failed SUs */
                       break;
               }
               break;

       default:                /* more than 2 disk faults */
               *createFunc = NULL;
               RF_PANIC();
       }
       return;
}


int
rf_VerifyParityEvenOdd(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
                      RF_PhysDiskAddr_t *parityPDA, int correct_it,
                      RF_RaidAccessFlags_t flags)
{
       RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
       RF_RaidAddr_t startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
       RF_SectorCount_t numsector = parityPDA->numSector;
       int     numbytes = rf_RaidAddressToByte(raidPtr, numsector);
       int     bytesPerStripe = numbytes * layoutPtr->numDataCol;
       RF_DagHeader_t *rd_dag_h, *wr_dag_h;    /* read, write dag */
       RF_DagNode_t *blockNode, *wrBlock;
       RF_AccessStripeMapHeader_t *asm_h;
       RF_AccessStripeMap_t *asmap;
       RF_AllocListElem_t *alloclist;
       RF_PhysDiskAddr_t *pda;
       char   *pbuf, *buf, *end_p, *p;
       char   *redundantbuf2;
       int     redundantTwoErr = 0, redundantOneErr = 0;
       int     parity_cant_correct = RF_FALSE, red2_cant_correct = RF_FALSE,
               parity_corrected = RF_FALSE, red2_corrected = RF_FALSE;
       int     i, retcode;
       RF_ReconUnitNum_t which_ru;
       RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
       int     stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
       RF_AccTraceEntry_t tracerec;
       RF_MCPair_t *mcpair;

       retcode = RF_PARITY_OKAY;

       mcpair = rf_AllocMCPair(raidPtr);
       rf_MakeAllocList(alloclist);
       buf = RF_MallocAndAdd(
           numbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol),
           alloclist);
       pbuf = RF_MallocAndAdd(numbytes, alloclist);
       end_p = buf + bytesPerStripe;
       redundantbuf2 = RF_MallocAndAdd(numbytes, alloclist);

       rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf, rf_DiskReadFunc, rf_DiskReadUndoFunc,
           "Rod", alloclist, flags, RF_IO_NORMAL_PRIORITY);
       blockNode = rd_dag_h->succedents[0];

       /* 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;

       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);
               if (rf_TryToRedirectPDA(raidPtr, pda, 0))
                       goto out;       /* no way to verify parity if disk is
                                        * dead.  return w/ good status */
               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, which_ru);
       }

       RF_ASSERT(!asmap->parityInfo->next);
       rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
       RF_ASSERT(asmap->parityInfo->numSector != 0);
       if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
               goto out;
       blockNode->succedents[layoutPtr->numDataCol]->params[0].p = asmap->parityInfo;

       RF_ASSERT(!asmap->qInfo->next);
       rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->qInfo, 0, 1);
       RF_ASSERT(asmap->qInfo->numSector != 0);
       if (rf_TryToRedirectPDA(raidPtr, asmap->qInfo, 1))
               goto out;
       /* if disk is dead, b/c no reconstruction is implemented right now,
        * the function "rf_TryToRedirectPDA" always return one, which cause
        * go to out and return w/ good status   */
       blockNode->succedents[layoutPtr->numDataCol + 1]->params[0].p = asmap->qInfo;

       /* fire off the DAG */
       memset(&tracerec, 0, sizeof(tracerec));
       rd_dag_h->tracerec = &tracerec;

#if RF_DEBUG_VALIDATE_DAG
       if (rf_verifyParityDebug) {
               printf("Parity verify read dag:\n");
               rf_PrintDAGList(rd_dag_h);
       }
#endif
       RF_LOCK_MCPAIR(mcpair);
       mcpair->flag = 0;
       rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
           (void *) mcpair);
       while (!mcpair->flag)
               RF_WAIT_MCPAIR(mcpair);
       RF_UNLOCK_MCPAIR(mcpair);
       if (rd_dag_h->status != rf_enable) {
               RF_ERRORMSG("Unable to verify parity:  can't read the stripe\n");
               retcode = RF_PARITY_COULD_NOT_VERIFY;
               goto out;
       }
       for (p = buf, i = 0; p < end_p; p += numbytes, i++) {
               rf_e_encToBuf(raidPtr, i, p, RF_EO_MATRIX_DIM - 2, redundantbuf2, numsector);
               /* the corresponding columes in EvenOdd encoding Matrix for
                * these p pointers which point to the databuffer in a full
                * stripe are sequentially from 0 to layoutPtr->numDataCol-1 */
               rf_bxor(p, pbuf, numbytes);
       }
       RF_ASSERT(i == layoutPtr->numDataCol);

       for (i = 0; i < numbytes; i++) {
               if (pbuf[i] != buf[bytesPerStripe + i]) {
                       if (!correct_it) {
                               RF_ERRORMSG3("Parity verify error: byte %d of parity is 0x%x should be 0x%x\n",
                                   i, (u_char) buf[bytesPerStripe + i], (u_char) pbuf[i]);
                       }
               }
               redundantOneErr = 1;
               break;
       }

       for (i = 0; i < numbytes; i++) {
               if (redundantbuf2[i] != buf[bytesPerStripe + numbytes + i]) {
                       if (!correct_it) {
                               RF_ERRORMSG3("Parity verify error: byte %d of second redundant information is 0x%x should be 0x%x\n",
                                   i, (u_char) buf[bytesPerStripe + numbytes + i], (u_char) redundantbuf2[i]);
                       }
                       redundantTwoErr = 1;
                       break;
               }
       }
       if (redundantOneErr || redundantTwoErr)
               retcode = RF_PARITY_BAD;

       /* correct the first redundant disk, ie parity if it is error    */
       if (redundantOneErr && correct_it) {
               wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
                   "Wnp", alloclist, flags, RF_IO_NORMAL_PRIORITY);
               wrBlock = wr_dag_h->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, which_ru);
               memset(&tracerec, 0, sizeof(tracerec));
               wr_dag_h->tracerec = &tracerec;
#if RF_DEBUG_VALIDATE_DAG
               if (rf_verifyParityDebug) {
                       printf("Parity verify write dag:\n");
                       rf_PrintDAGList(wr_dag_h);
               }
#endif
               RF_LOCK_MCPAIR(mcpair);
               mcpair->flag = 0;
               rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
                   (void *) mcpair);
               while (!mcpair->flag)
                       RF_WAIT_MCPAIR(mcpair);
               RF_UNLOCK_MCPAIR(mcpair);
               if (wr_dag_h->status != rf_enable) {
                       RF_ERRORMSG("Unable to correct parity in VerifyParity:  can't write the stripe\n");
                       parity_cant_correct = RF_TRUE;
               } else {
                       parity_corrected = RF_TRUE;
               }
               rf_FreeDAG(wr_dag_h);
       }
       if (redundantTwoErr && correct_it) {
               wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, redundantbuf2, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
                   "Wnred2", alloclist, flags, RF_IO_NORMAL_PRIORITY);
               wrBlock = wr_dag_h->succedents[0];
               wrBlock->succedents[0]->params[0].p = asmap->qInfo;
               wrBlock->succedents[0]->params[2].v = psID;
               wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru);
               memset(&tracerec, 0, sizeof(tracerec));
               wr_dag_h->tracerec = &tracerec;
#if RF_DEBUG_VALIDATE_DAG
               if (rf_verifyParityDebug) {
                       printf("Dag of write new second redundant information in parity verify :\n");
                       rf_PrintDAGList(wr_dag_h);
               }
#endif
               RF_LOCK_MCPAIR(mcpair);
               mcpair->flag = 0;
               rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
                   (void *) mcpair);
               while (!mcpair->flag)
                       RF_WAIT_MCPAIR(mcpair);
               RF_UNLOCK_MCPAIR(mcpair);
               if (wr_dag_h->status != rf_enable) {
                       RF_ERRORMSG("Unable to correct second redundant information in VerifyParity:  can't write the stripe\n");
                       red2_cant_correct = RF_TRUE;
               } else {
                       red2_corrected = RF_TRUE;
               }
               rf_FreeDAG(wr_dag_h);
       }
       if ((redundantOneErr && parity_cant_correct) ||
           (redundantTwoErr && red2_cant_correct))
               retcode = RF_PARITY_COULD_NOT_CORRECT;
       if ((retcode = RF_PARITY_BAD) && parity_corrected && red2_corrected)
               retcode = RF_PARITY_CORRECTED;


out:
       rf_FreeAccessStripeMap(raidPtr, asm_h);
       rf_FreeAllocList(alloclist);
       rf_FreeDAG(rd_dag_h);
       rf_FreeMCPair(raidPtr, mcpair);
       return (retcode);
}
#endif                          /* RF_INCLUDE_EVENODD > 0 */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.