Home | History | Annotate | Line # | Download | only in raidframe
rf_parityscan.c revision 1.27
      1  1.27     oster /*	$NetBSD: rf_parityscan.c,v 1.27 2004/03/18 17:26:36 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_parityscan.c -- misc utilities related to parity verification
     32   1.1     oster  *
     33  1.22     oster  ****************************************************************************/
     34  1.12     lukem 
     35  1.12     lukem #include <sys/cdefs.h>
     36  1.27     oster __KERNEL_RCSID(0, "$NetBSD: rf_parityscan.c,v 1.27 2004/03/18 17:26:36 oster Exp $");
     37   1.1     oster 
     38  1.11     oster #include <dev/raidframe/raidframevar.h>
     39  1.11     oster 
     40   1.1     oster #include "rf_raid.h"
     41   1.1     oster #include "rf_dag.h"
     42   1.1     oster #include "rf_dagfuncs.h"
     43   1.1     oster #include "rf_dagutils.h"
     44   1.1     oster #include "rf_mcpair.h"
     45   1.1     oster #include "rf_general.h"
     46   1.1     oster #include "rf_engine.h"
     47   1.1     oster #include "rf_parityscan.h"
     48   1.1     oster #include "rf_map.h"
     49   1.1     oster 
     50  1.22     oster /*****************************************************************************
     51   1.1     oster  *
     52  1.22     oster  * walk through the entire arry and write new parity.  This works by
     53  1.22     oster  * creating two DAGs, one to read a stripe of data and one to write
     54  1.22     oster  * new parity.  The first is executed, the data is xored together, and
     55  1.22     oster  * then the second is executed.  To avoid constantly building and
     56  1.22     oster  * tearing down the DAGs, we create them a priori and fill them in
     57  1.22     oster  * with the mapping information as we go along.
     58   1.1     oster  *
     59   1.1     oster  * there should never be more than one thread running this.
     60   1.1     oster  *
     61  1.22     oster  ****************************************************************************/
     62   1.1     oster 
     63   1.3     oster int
     64  1.22     oster rf_RewriteParity(RF_Raid_t *raidPtr)
     65   1.1     oster {
     66   1.3     oster 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
     67   1.3     oster 	RF_AccessStripeMapHeader_t *asm_h;
     68   1.6     oster 	int ret_val;
     69   1.4     oster 	int rc;
     70   1.3     oster 	RF_SectorNum_t i;
     71   1.5     oster 
     72   1.5     oster 	if (raidPtr->Layout.map->faultsTolerated == 0) {
     73   1.5     oster 		/* There isn't any parity. Call it "okay." */
     74   1.5     oster 		return (RF_PARITY_OKAY);
     75   1.5     oster 	}
     76  1.19     oster 	if (raidPtr->status != rf_rs_optimal) {
     77   1.5     oster 		/*
     78   1.5     oster 		 * We're in degraded mode.  Don't try to verify parity now!
     79   1.5     oster 		 * XXX: this should be a "we don't want to", not a
     80   1.5     oster 		 * "we can't" error.
     81   1.5     oster 		 */
     82   1.5     oster 		return (RF_PARITY_COULD_NOT_VERIFY);
     83   1.5     oster 	}
     84   1.3     oster 
     85   1.6     oster 	ret_val = 0;
     86   1.6     oster 
     87   1.6     oster 	rc = RF_PARITY_OKAY;
     88   1.1     oster 
     89   1.6     oster 	for (i = 0; i < raidPtr->totalSectors &&
     90   1.6     oster 		     rc <= RF_PARITY_CORRECTED;
     91   1.4     oster 	     i += layoutPtr->dataSectorsPerStripe) {
     92   1.9     oster 		if (raidPtr->waitShutdown) {
     93   1.9     oster 			/* Someone is pulling the plug on this set...
     94   1.9     oster 			   abort the re-write */
     95   1.9     oster 			return (1);
     96   1.9     oster 		}
     97   1.4     oster 		asm_h = rf_MapAccess(raidPtr, i,
     98   1.4     oster 				     layoutPtr->dataSectorsPerStripe,
     99   1.4     oster 				     NULL, RF_DONT_REMAP);
    100   1.8     oster 		raidPtr->parity_rewrite_stripes_done =
    101   1.8     oster 			i / layoutPtr->dataSectorsPerStripe ;
    102   1.3     oster 		rc = rf_VerifyParity(raidPtr, asm_h->stripeMap, 1, 0);
    103   1.4     oster 
    104   1.3     oster 		switch (rc) {
    105   1.3     oster 		case RF_PARITY_OKAY:
    106   1.3     oster 		case RF_PARITY_CORRECTED:
    107   1.3     oster 			break;
    108   1.3     oster 		case RF_PARITY_BAD:
    109   1.3     oster 			printf("Parity bad during correction\n");
    110   1.6     oster 			ret_val = 1;
    111   1.3     oster 			break;
    112   1.3     oster 		case RF_PARITY_COULD_NOT_CORRECT:
    113   1.3     oster 			printf("Could not correct bad parity\n");
    114   1.6     oster 			ret_val = 1;
    115   1.3     oster 			break;
    116   1.3     oster 		case RF_PARITY_COULD_NOT_VERIFY:
    117   1.3     oster 			printf("Could not verify parity\n");
    118   1.6     oster 			ret_val = 1;
    119   1.3     oster 			break;
    120   1.3     oster 		default:
    121   1.3     oster 			printf("Bad rc=%d from VerifyParity in RewriteParity\n", rc);
    122   1.6     oster 			ret_val = 1;
    123   1.3     oster 		}
    124   1.3     oster 		rf_FreeAccessStripeMap(asm_h);
    125   1.3     oster 	}
    126   1.6     oster 	return (ret_val);
    127   1.1     oster }
    128  1.22     oster /*****************************************************************************
    129   1.1     oster  *
    130  1.22     oster  * verify that the parity in a particular stripe is correct.  we
    131  1.22     oster  * validate only the range of parity defined by parityPDA, since this
    132  1.22     oster  * is all we have locked.  The way we do this is to create an asm that
    133  1.22     oster  * maps the whole stripe and then range-restrict it to the parity
    134   1.1     oster  * region defined by the parityPDA.
    135   1.1     oster  *
    136  1.22     oster  ****************************************************************************/
    137   1.3     oster int
    138  1.22     oster rf_VerifyParity(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *aasm,
    139  1.22     oster 		int correct_it, RF_RaidAccessFlags_t flags)
    140   1.1     oster {
    141   1.3     oster 	RF_PhysDiskAddr_t *parityPDA;
    142   1.3     oster 	RF_AccessStripeMap_t *doasm;
    143  1.18  jdolecek 	const RF_LayoutSW_t *lp;
    144   1.3     oster 	int     lrc, rc;
    145   1.3     oster 
    146   1.3     oster 	lp = raidPtr->Layout.map;
    147   1.3     oster 	if (lp->faultsTolerated == 0) {
    148   1.3     oster 		/*
    149   1.3     oster 	         * There isn't any parity. Call it "okay."
    150   1.3     oster 	         */
    151   1.3     oster 		return (RF_PARITY_OKAY);
    152   1.3     oster 	}
    153   1.3     oster 	rc = RF_PARITY_OKAY;
    154   1.3     oster 	if (lp->VerifyParity) {
    155   1.3     oster 		for (doasm = aasm; doasm; doasm = doasm->next) {
    156   1.4     oster 			for (parityPDA = doasm->parityInfo; parityPDA;
    157   1.4     oster 			     parityPDA = parityPDA->next) {
    158   1.4     oster 				lrc = lp->VerifyParity(raidPtr,
    159   1.4     oster 						       doasm->raidAddress,
    160   1.4     oster 						       parityPDA,
    161   1.4     oster 						       correct_it, flags);
    162   1.3     oster 				if (lrc > rc) {
    163   1.3     oster 					/* see rf_parityscan.h for why this
    164   1.3     oster 					 * works */
    165   1.3     oster 					rc = lrc;
    166   1.3     oster 				}
    167   1.3     oster 			}
    168   1.3     oster 		}
    169   1.3     oster 	} else {
    170   1.3     oster 		rc = RF_PARITY_COULD_NOT_VERIFY;
    171   1.3     oster 	}
    172   1.3     oster 	return (rc);
    173   1.1     oster }
    174   1.1     oster 
    175   1.3     oster int
    176  1.22     oster rf_VerifyParityBasic(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
    177  1.22     oster 		     RF_PhysDiskAddr_t *parityPDA, int correct_it,
    178  1.22     oster 		     RF_RaidAccessFlags_t flags)
    179   1.1     oster {
    180   1.3     oster 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
    181   1.4     oster 	RF_RaidAddr_t startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
    182   1.4     oster 								     raidAddr);
    183   1.3     oster 	RF_SectorCount_t numsector = parityPDA->numSector;
    184   1.3     oster 	int     numbytes = rf_RaidAddressToByte(raidPtr, numsector);
    185   1.3     oster 	int     bytesPerStripe = numbytes * layoutPtr->numDataCol;
    186   1.3     oster 	RF_DagHeader_t *rd_dag_h, *wr_dag_h;	/* read, write dag */
    187  1.16     oster 	RF_DagNode_t *blockNode, *wrBlock;
    188   1.3     oster 	RF_AccessStripeMapHeader_t *asm_h;
    189   1.3     oster 	RF_AccessStripeMap_t *asmap;
    190   1.3     oster 	RF_AllocListElem_t *alloclist;
    191   1.3     oster 	RF_PhysDiskAddr_t *pda;
    192   1.3     oster 	char   *pbuf, *buf, *end_p, *p;
    193   1.3     oster 	int     i, retcode;
    194   1.3     oster 	RF_ReconUnitNum_t which_ru;
    195   1.4     oster 	RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr,
    196   1.4     oster 							     raidAddr,
    197   1.4     oster 							     &which_ru);
    198   1.3     oster 	int     stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
    199  1.24     oster #if RF_ACC_TRACE > 0
    200   1.3     oster 	RF_AccTraceEntry_t tracerec;
    201  1.24     oster #endif
    202   1.3     oster 	RF_MCPair_t *mcpair;
    203   1.3     oster 
    204   1.3     oster 	retcode = RF_PARITY_OKAY;
    205   1.3     oster 
    206   1.3     oster 	mcpair = rf_AllocMCPair();
    207   1.3     oster 	rf_MakeAllocList(alloclist);
    208   1.3     oster 	RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol), (char *), alloclist);
    209  1.20     oster 	RF_MallocAndAdd(pbuf, numbytes, (char *), alloclist);
    210   1.3     oster 	end_p = buf + bytesPerStripe;
    211   1.3     oster 
    212   1.3     oster 	rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf, rf_DiskReadFunc, rf_DiskReadUndoFunc,
    213   1.3     oster 	    "Rod", alloclist, flags, RF_IO_NORMAL_PRIORITY);
    214   1.3     oster 	blockNode = rd_dag_h->succedents[0];
    215   1.3     oster 
    216   1.3     oster 	/* map the stripe and fill in the PDAs in the dag */
    217   1.3     oster 	asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
    218   1.3     oster 	asmap = asm_h->stripeMap;
    219   1.3     oster 
    220   1.3     oster 	for (pda = asmap->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) {
    221   1.3     oster 		RF_ASSERT(pda);
    222   1.3     oster 		rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
    223   1.3     oster 		RF_ASSERT(pda->numSector != 0);
    224   1.3     oster 		if (rf_TryToRedirectPDA(raidPtr, pda, 0))
    225   1.3     oster 			goto out;	/* no way to verify parity if disk is
    226   1.3     oster 					 * dead.  return w/ good status */
    227   1.3     oster 		blockNode->succedents[i]->params[0].p = pda;
    228   1.3     oster 		blockNode->succedents[i]->params[2].v = psID;
    229  1.23     oster 		blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru);
    230   1.3     oster 	}
    231   1.3     oster 
    232   1.3     oster 	RF_ASSERT(!asmap->parityInfo->next);
    233   1.3     oster 	rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
    234   1.3     oster 	RF_ASSERT(asmap->parityInfo->numSector != 0);
    235   1.3     oster 	if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
    236   1.3     oster 		goto out;
    237   1.3     oster 	blockNode->succedents[layoutPtr->numDataCol]->params[0].p = asmap->parityInfo;
    238   1.3     oster 
    239   1.3     oster 	/* fire off the DAG */
    240  1.24     oster #if RF_ACC_TRACE > 0
    241  1.10   thorpej 	memset((char *) &tracerec, 0, sizeof(tracerec));
    242   1.3     oster 	rd_dag_h->tracerec = &tracerec;
    243  1.24     oster #endif
    244  1.13     oster #if 0
    245   1.3     oster 	if (rf_verifyParityDebug) {
    246   1.3     oster 		printf("Parity verify read dag:\n");
    247   1.3     oster 		rf_PrintDAGList(rd_dag_h);
    248   1.3     oster 	}
    249  1.13     oster #endif
    250   1.3     oster 	RF_LOCK_MUTEX(mcpair->mutex);
    251   1.3     oster 	mcpair->flag = 0;
    252  1.25     oster 	RF_UNLOCK_MUTEX(mcpair->mutex);
    253  1.25     oster 
    254   1.3     oster 	rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
    255   1.3     oster 	    (void *) mcpair);
    256  1.25     oster 
    257  1.25     oster 	RF_LOCK_MUTEX(mcpair->mutex);
    258   1.3     oster 	while (!mcpair->flag)
    259   1.3     oster 		RF_WAIT_COND(mcpair->cond, mcpair->mutex);
    260   1.3     oster 	RF_UNLOCK_MUTEX(mcpair->mutex);
    261   1.3     oster 	if (rd_dag_h->status != rf_enable) {
    262   1.3     oster 		RF_ERRORMSG("Unable to verify parity:  can't read the stripe\n");
    263   1.3     oster 		retcode = RF_PARITY_COULD_NOT_VERIFY;
    264   1.3     oster 		goto out;
    265   1.3     oster 	}
    266   1.3     oster 	for (p = buf; p < end_p; p += numbytes) {
    267  1.21     oster 		rf_bxor(p, pbuf, numbytes);
    268   1.3     oster 	}
    269   1.3     oster 	for (i = 0; i < numbytes; i++) {
    270   1.3     oster 		if (pbuf[i] != buf[bytesPerStripe + i]) {
    271   1.3     oster 			if (!correct_it)
    272   1.3     oster 				RF_ERRORMSG3("Parity verify error: byte %d of parity is 0x%x should be 0x%x\n",
    273   1.3     oster 				    i, (u_char) buf[bytesPerStripe + i], (u_char) pbuf[i]);
    274   1.3     oster 			retcode = RF_PARITY_BAD;
    275   1.3     oster 			break;
    276   1.3     oster 		}
    277   1.3     oster 	}
    278   1.1     oster 
    279   1.3     oster 	if (retcode && correct_it) {
    280   1.3     oster 		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
    281   1.3     oster 		    "Wnp", alloclist, flags, RF_IO_NORMAL_PRIORITY);
    282   1.3     oster 		wrBlock = wr_dag_h->succedents[0];
    283   1.3     oster 		wrBlock->succedents[0]->params[0].p = asmap->parityInfo;
    284   1.3     oster 		wrBlock->succedents[0]->params[2].v = psID;
    285  1.23     oster 		wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, which_ru);
    286  1.24     oster #if RF_ACC_TRACE > 0
    287  1.10   thorpej 		memset((char *) &tracerec, 0, sizeof(tracerec));
    288   1.3     oster 		wr_dag_h->tracerec = &tracerec;
    289  1.24     oster #endif
    290  1.13     oster #if 0
    291   1.3     oster 		if (rf_verifyParityDebug) {
    292   1.3     oster 			printf("Parity verify write dag:\n");
    293   1.3     oster 			rf_PrintDAGList(wr_dag_h);
    294   1.3     oster 		}
    295  1.13     oster #endif
    296   1.3     oster 		RF_LOCK_MUTEX(mcpair->mutex);
    297   1.3     oster 		mcpair->flag = 0;
    298  1.25     oster 		RF_UNLOCK_MUTEX(mcpair->mutex);
    299  1.25     oster 
    300   1.3     oster 		rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
    301   1.3     oster 		    (void *) mcpair);
    302  1.25     oster 
    303  1.25     oster 		RF_LOCK_MUTEX(mcpair->mutex);
    304   1.3     oster 		while (!mcpair->flag)
    305   1.3     oster 			RF_WAIT_COND(mcpair->cond, mcpair->mutex);
    306   1.3     oster 		RF_UNLOCK_MUTEX(mcpair->mutex);
    307   1.3     oster 		if (wr_dag_h->status != rf_enable) {
    308   1.3     oster 			RF_ERRORMSG("Unable to correct parity in VerifyParity:  can't write the stripe\n");
    309   1.3     oster 			retcode = RF_PARITY_COULD_NOT_CORRECT;
    310   1.3     oster 		}
    311   1.3     oster 		rf_FreeDAG(wr_dag_h);
    312   1.3     oster 		if (retcode == RF_PARITY_BAD)
    313   1.3     oster 			retcode = RF_PARITY_CORRECTED;
    314   1.3     oster 	}
    315   1.1     oster out:
    316   1.3     oster 	rf_FreeAccessStripeMap(asm_h);
    317   1.3     oster 	rf_FreeAllocList(alloclist);
    318   1.3     oster 	rf_FreeDAG(rd_dag_h);
    319   1.3     oster 	rf_FreeMCPair(mcpair);
    320   1.3     oster 	return (retcode);
    321   1.1     oster }
    322   1.1     oster 
    323   1.3     oster int
    324  1.22     oster rf_TryToRedirectPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, int parity)
    325   1.1     oster {
    326  1.19     oster 	if (raidPtr->Disks[pda->col].status == rf_ds_reconstructing) {
    327  1.19     oster 		if (rf_CheckRUReconstructed(raidPtr->reconControl->reconMap, pda->startSector)) {
    328  1.26     oster #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
    329   1.3     oster 			if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
    330  1.14     oster #if RF_DEBUG_VERIFYPARITY
    331  1.19     oster 				RF_RowCol_t oc = pda->col;
    332   1.3     oster 				RF_SectorNum_t os = pda->startSector;
    333  1.14     oster #endif
    334   1.3     oster 				if (parity) {
    335  1.19     oster 					(raidPtr->Layout.map->MapParity) (raidPtr, pda->raidAddress, &pda->col, &pda->startSector, RF_REMAP);
    336  1.14     oster #if RF_DEBUG_VERIFYPARITY
    337   1.3     oster 					if (rf_verifyParityDebug)
    338  1.19     oster 						printf("VerifyParity: Redir P c %d sect %ld -> c %d sect %ld\n",
    339  1.19     oster 						    oc, (long) os, pda->col, (long) pda->startSector);
    340  1.14     oster #endif
    341   1.3     oster 				} else {
    342  1.19     oster 					(raidPtr->Layout.map->MapSector) (raidPtr, pda->raidAddress, &pda->col, &pda->startSector, RF_REMAP);
    343  1.14     oster #if RF_DEBUG_VERIFYPARITY
    344   1.3     oster 					if (rf_verifyParityDebug)
    345  1.19     oster 						printf("VerifyParity: Redir D c %d sect %ld -> c %d sect %ld\n",
    346  1.19     oster 						   oc, (long) os, pda->col, (long) pda->startSector);
    347  1.14     oster #endif
    348   1.3     oster 				}
    349   1.3     oster 			} else {
    350  1.26     oster #endif
    351  1.19     oster 				RF_RowCol_t spCol = raidPtr->Disks[pda->col].spareCol;
    352   1.3     oster 				pda->col = spCol;
    353  1.26     oster #if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
    354   1.3     oster 			}
    355  1.26     oster #endif
    356   1.3     oster 		}
    357   1.3     oster 	}
    358  1.19     oster 	if (RF_DEAD_DISK(raidPtr->Disks[pda->col].status))
    359   1.3     oster 		return (1);
    360   1.3     oster 	return (0);
    361   1.1     oster }
    362  1.22     oster /*****************************************************************************
    363   1.1     oster  *
    364   1.1     oster  * currently a stub.
    365   1.1     oster  *
    366  1.22     oster  * takes as input an ASM describing a write operation and containing
    367  1.22     oster  * one failure, and verifies that the parity was correctly updated to
    368  1.22     oster  * reflect the write.
    369  1.22     oster  *
    370  1.22     oster  * if it's a data unit that's failed, we read the other data units in
    371  1.22     oster  * the stripe and the parity unit, XOR them together, and verify that
    372  1.22     oster  * we get the data intended for the failed disk.  Since it's easy, we
    373  1.22     oster  * also validate that the right data got written to the surviving data
    374  1.22     oster  * disks.
    375  1.22     oster  *
    376  1.22     oster  * If it's the parity that failed, there's really no validation we can
    377  1.22     oster  * do except the above verification that the right data got written to
    378  1.22     oster  * all disks.  This is because the new data intended for the failed
    379  1.22     oster  * disk is supplied in the ASM, but this is of course not the case for
    380  1.22     oster  * the new parity.
    381   1.1     oster  *
    382  1.22     oster  ****************************************************************************/
    383  1.15     oster #if 0
    384   1.3     oster int
    385  1.22     oster rf_VerifyDegrModeWrite(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asmh)
    386   1.1     oster {
    387   1.3     oster 	return (0);
    388   1.1     oster }
    389  1.15     oster #endif
    390   1.1     oster /* creates a simple DAG with a header, a block-recon node at level 1,
    391  1.22     oster  * nNodes nodes at level 2, an unblock-recon node at level 3, and a
    392  1.22     oster  * terminator node at level 4.  The stripe address field in the block
    393  1.22     oster  * and unblock nodes are not touched, nor are the pda fields in the
    394  1.22     oster  * second-level nodes, so they must be filled in later.
    395   1.1     oster  *
    396   1.1     oster  * commit point is established at unblock node - this means that any
    397  1.22     oster  * failure during dag execution causes the dag to fail
    398  1.22     oster  *
    399  1.22     oster  * name - node names at the second level
    400   1.1     oster  */
    401   1.3     oster RF_DagHeader_t *
    402  1.22     oster rf_MakeSimpleDAG(RF_Raid_t *raidPtr, int nNodes, int bytesPerSU, char *databuf,
    403  1.22     oster 		 int (*doFunc) (RF_DagNode_t * node),
    404  1.22     oster 		 int (*undoFunc) (RF_DagNode_t * node),
    405  1.22     oster 		 char *name, RF_AllocListElem_t *alloclist,
    406  1.22     oster 		 RF_RaidAccessFlags_t flags, int priority)
    407   1.1     oster {
    408   1.3     oster 	RF_DagHeader_t *dag_h;
    409  1.27     oster 	RF_DagNode_t *nodes, *termNode, *blockNode, *unblockNode, *tmpNode;
    410   1.3     oster 	int     i;
    411   1.3     oster 
    412  1.27     oster 	/* grab a DAG header... */
    413   1.3     oster 
    414   1.3     oster 	dag_h = rf_AllocDAGHeader();
    415   1.3     oster 	dag_h->raidPtr = (void *) raidPtr;
    416   1.3     oster 	dag_h->allocList = NULL;/* we won't use this alloc list */
    417   1.3     oster 	dag_h->status = rf_enable;
    418   1.3     oster 	dag_h->numSuccedents = 1;
    419   1.3     oster 	dag_h->creator = "SimpleDAG";
    420   1.3     oster 
    421   1.3     oster 	/* this dag can not commit until the unblock node is reached errors
    422   1.3     oster 	 * prior to the commit point imply the dag has failed */
    423   1.3     oster 	dag_h->numCommitNodes = 1;
    424   1.3     oster 	dag_h->numCommits = 0;
    425   1.3     oster 
    426  1.27     oster 	/* create the nodes, the block & unblock nodes, and the terminator
    427  1.27     oster 	 * node */
    428  1.27     oster 
    429  1.27     oster 	for (i = 0; i < nNodes; i++) {
    430  1.27     oster 		tmpNode = rf_AllocDAGNode();
    431  1.27     oster 		tmpNode->list_next = dag_h->nodes;
    432  1.27     oster 		dag_h->nodes = tmpNode;
    433  1.27     oster 	}
    434  1.27     oster 	nodes = dag_h->nodes;
    435  1.27     oster 
    436  1.27     oster 	blockNode = rf_AllocDAGNode();
    437  1.27     oster 	blockNode->list_next = dag_h->nodes;
    438  1.27     oster 	dag_h->nodes = blockNode;
    439  1.27     oster 
    440  1.27     oster 	unblockNode = rf_AllocDAGNode();
    441  1.27     oster 	unblockNode->list_next = dag_h->nodes;
    442  1.27     oster 	dag_h->nodes = unblockNode;
    443  1.27     oster 
    444  1.27     oster 	termNode = rf_AllocDAGNode();
    445  1.27     oster 	termNode->list_next = dag_h->nodes;
    446  1.27     oster 	dag_h->nodes = termNode;
    447  1.27     oster 
    448   1.3     oster 	dag_h->succedents[0] = blockNode;
    449   1.3     oster 	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h, "Nil", alloclist);
    450   1.3     oster 	rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h, "Nil", alloclist);
    451   1.3     oster 	unblockNode->succedents[0] = termNode;
    452  1.27     oster 	tmpNode = nodes;
    453   1.3     oster 	for (i = 0; i < nNodes; i++) {
    454  1.27     oster 		blockNode->succedents[i] = unblockNode->antecedents[i] = tmpNode;
    455   1.3     oster 		unblockNode->antType[i] = rf_control;
    456  1.27     oster 		rf_InitNode(tmpNode, rf_wait, RF_FALSE, doFunc, undoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, alloclist);
    457  1.27     oster 		tmpNode->succedents[0] = unblockNode;
    458  1.27     oster 		tmpNode->antecedents[0] = blockNode;
    459  1.27     oster 		tmpNode->antType[0] = rf_control;
    460  1.27     oster 		tmpNode->params[1].p = (databuf + (i * bytesPerSU));
    461  1.27     oster 		tmpNode = tmpNode->list_next;
    462   1.3     oster 	}
    463   1.3     oster 	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", alloclist);
    464   1.3     oster 	termNode->antecedents[0] = unblockNode;
    465   1.3     oster 	termNode->antType[0] = rf_control;
    466   1.3     oster 	return (dag_h);
    467   1.1     oster }
    468