xref: /netbsd-src/sys/dev/raidframe/rf_dagdegrd.c (revision d710132b4b8ce7f7cccaaf660cb16aa16b4077a0)
1 /*	$NetBSD: rf_dagdegrd.c,v 1.13 2003/02/09 10:04:32 jdolecek Exp $	*/
2 /*
3  * Copyright (c) 1995 Carnegie-Mellon University.
4  * All rights reserved.
5  *
6  * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
7  *
8  * Permission to use, copy, modify and distribute this software and
9  * its documentation is hereby granted, provided that both the copyright
10  * notice and this permission notice appear in all copies of the
11  * software, derivative works or modified versions, and any portions
12  * thereof, and that both notices appear in supporting documentation.
13  *
14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
16  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17  *
18  * Carnegie Mellon requests users of this software to return to
19  *
20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
21  *  School of Computer Science
22  *  Carnegie Mellon University
23  *  Pittsburgh PA 15213-3890
24  *
25  * any improvements or extensions that they make and grant Carnegie the
26  * rights to redistribute these changes.
27  */
28 
29 /*
30  * rf_dagdegrd.c
31  *
32  * code for creating degraded read DAGs
33  */
34 
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: rf_dagdegrd.c,v 1.13 2003/02/09 10:04:32 jdolecek Exp $");
37 
38 #include <dev/raidframe/raidframevar.h>
39 
40 #include "rf_archs.h"
41 #include "rf_raid.h"
42 #include "rf_dag.h"
43 #include "rf_dagutils.h"
44 #include "rf_dagfuncs.h"
45 #include "rf_debugMem.h"
46 #include "rf_general.h"
47 #include "rf_dagdegrd.h"
48 
49 
50 /******************************************************************************
51  *
52  * General comments on DAG creation:
53  *
54  * All DAGs in this file use roll-away error recovery.  Each DAG has a single
55  * commit node, usually called "Cmt."  If an error occurs before the Cmt node
56  * is reached, the execution engine will halt forward execution and work
57  * backward through the graph, executing the undo functions.  Assuming that
58  * each node in the graph prior to the Cmt node are undoable and atomic - or -
59  * does not make changes to permanent state, the graph will fail atomically.
60  * If an error occurs after the Cmt node executes, the engine will roll-forward
61  * through the graph, blindly executing nodes until it reaches the end.
62  * If a graph reaches the end, it is assumed to have completed successfully.
63  *
64  * A graph has only 1 Cmt node.
65  *
66  */
67 
68 
69 /******************************************************************************
70  *
71  * The following wrappers map the standard DAG creation interface to the
72  * DAG creation routines.  Additionally, these wrappers enable experimentation
73  * with new DAG structures by providing an extra level of indirection, allowing
74  * the DAG creation routines to be replaced at this single point.
75  */
76 
77 void
78 rf_CreateRaidFiveDegradedReadDAG(
79     RF_Raid_t * raidPtr,
80     RF_AccessStripeMap_t * asmap,
81     RF_DagHeader_t * dag_h,
82     void *bp,
83     RF_RaidAccessFlags_t flags,
84     RF_AllocListElem_t * allocList)
85 {
86 	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
87 	    &rf_xorRecoveryFuncs);
88 }
89 
90 
91 /******************************************************************************
92  *
93  * DAG creation code begins here
94  */
95 
96 
97 /******************************************************************************
98  * Create a degraded read DAG for RAID level 1
99  *
100  * Hdr -> Nil -> R(p/s)d -> Commit -> Trm
101  *
102  * The "Rd" node reads data from the surviving disk in the mirror pair
103  *   Rpd - read of primary copy
104  *   Rsd - read of secondary copy
105  *
106  * Parameters:  raidPtr   - description of the physical array
107  *              asmap     - logical & physical addresses for this access
108  *              bp        - buffer ptr (for holding write data)
109  *              flags     - general flags (e.g. disk locking)
110  *              allocList - list of memory allocated in DAG creation
111  *****************************************************************************/
112 
113 void
114 rf_CreateRaidOneDegradedReadDAG(
115     RF_Raid_t * raidPtr,
116     RF_AccessStripeMap_t * asmap,
117     RF_DagHeader_t * dag_h,
118     void *bp,
119     RF_RaidAccessFlags_t flags,
120     RF_AllocListElem_t * allocList)
121 {
122 	RF_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
123 	RF_StripeNum_t parityStripeID;
124 	RF_ReconUnitNum_t which_ru;
125 	RF_PhysDiskAddr_t *pda;
126 	int     useMirror, i;
127 
128 	useMirror = 0;
129 	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
130 	    asmap->raidAddress, &which_ru);
131 	if (rf_dagDebug) {
132 		printf("[Creating RAID level 1 degraded read DAG]\n");
133 	}
134 	dag_h->creator = "RaidOneDegradedReadDAG";
135 	/* alloc the Wnd nodes and the Wmir node */
136 	if (asmap->numDataFailed == 0)
137 		useMirror = RF_FALSE;
138 	else
139 		useMirror = RF_TRUE;
140 
141 	/* total number of nodes = 1 + (block + commit + terminator) */
142 	RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
143 	i = 0;
144 	rdNode = &nodes[i];
145 	i++;
146 	blockNode = &nodes[i];
147 	i++;
148 	commitNode = &nodes[i];
149 	i++;
150 	termNode = &nodes[i];
151 	i++;
152 
153 	/* this dag can not commit until the commit node is reached.   errors
154 	 * prior to the commit point imply the dag has failed and must be
155 	 * retried */
156 	dag_h->numCommitNodes = 1;
157 	dag_h->numCommits = 0;
158 	dag_h->numSuccedents = 1;
159 
160 	/* initialize the block, commit, and terminator nodes */
161 	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
162 	    NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
163 	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
164 	    NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
165 	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
166 	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
167 
168 	pda = asmap->physInfo;
169 	RF_ASSERT(pda != NULL);
170 	/* parityInfo must describe entire parity unit */
171 	RF_ASSERT(asmap->parityInfo->next == NULL);
172 
173 	/* initialize the data node */
174 	if (!useMirror) {
175 		/* read primary copy of data */
176 		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
177 		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rpd", allocList);
178 		rdNode->params[0].p = pda;
179 		rdNode->params[1].p = pda->bufPtr;
180 		rdNode->params[2].v = parityStripeID;
181 		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
182 	} else {
183 		/* read secondary copy of data */
184 		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
185 		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rsd", allocList);
186 		rdNode->params[0].p = asmap->parityInfo;
187 		rdNode->params[1].p = pda->bufPtr;
188 		rdNode->params[2].v = parityStripeID;
189 		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
190 	}
191 
192 	/* connect header to block node */
193 	RF_ASSERT(dag_h->numSuccedents == 1);
194 	RF_ASSERT(blockNode->numAntecedents == 0);
195 	dag_h->succedents[0] = blockNode;
196 
197 	/* connect block node to rdnode */
198 	RF_ASSERT(blockNode->numSuccedents == 1);
199 	RF_ASSERT(rdNode->numAntecedents == 1);
200 	blockNode->succedents[0] = rdNode;
201 	rdNode->antecedents[0] = blockNode;
202 	rdNode->antType[0] = rf_control;
203 
204 	/* connect rdnode to commit node */
205 	RF_ASSERT(rdNode->numSuccedents == 1);
206 	RF_ASSERT(commitNode->numAntecedents == 1);
207 	rdNode->succedents[0] = commitNode;
208 	commitNode->antecedents[0] = rdNode;
209 	commitNode->antType[0] = rf_control;
210 
211 	/* connect commit node to terminator */
212 	RF_ASSERT(commitNode->numSuccedents == 1);
213 	RF_ASSERT(termNode->numAntecedents == 1);
214 	RF_ASSERT(termNode->numSuccedents == 0);
215 	commitNode->succedents[0] = termNode;
216 	termNode->antecedents[0] = commitNode;
217 	termNode->antType[0] = rf_control;
218 }
219 
220 
221 
222 /******************************************************************************
223  *
224  * creates a DAG to perform a degraded-mode read of data within one stripe.
225  * This DAG is as follows:
226  *
227  * Hdr -> Block -> Rud -> Xor -> Cmt -> T
228  *              -> Rrd ->
229  *              -> Rp -->
230  *
231  * Each R node is a successor of the L node
232  * One successor arc from each R node goes to C, and the other to X
233  * There is one Rud for each chunk of surviving user data requested by the
234  * user, and one Rrd for each chunk of surviving user data _not_ being read by
235  * the user
236  * R = read, ud = user data, rd = recovery (surviving) data, p = parity
237  * X = XOR, C = Commit, T = terminate
238  *
239  * The block node guarantees a single source node.
240  *
241  * Note:  The target buffer for the XOR node is set to the actual user buffer
242  * where the failed data is supposed to end up.  This buffer is zero'd by the
243  * code here.  Thus, if you create a degraded read dag, use it, and then
244  * re-use, you have to be sure to zero the target buffer prior to the re-use.
245  *
246  * The recfunc argument at the end specifies the name and function used for
247  * the redundancy
248  * recovery function.
249  *
250  *****************************************************************************/
251 
252 void
253 rf_CreateDegradedReadDAG(
254     RF_Raid_t * raidPtr,
255     RF_AccessStripeMap_t * asmap,
256     RF_DagHeader_t * dag_h,
257     void *bp,
258     RF_RaidAccessFlags_t flags,
259     RF_AllocListElem_t * allocList,
260     const RF_RedFuncs_t * recFunc)
261 {
262 	RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *xorNode, *blockNode;
263 	RF_DagNode_t *commitNode, *rpNode, *termNode;
264 	int     nNodes, nRrdNodes, nRudNodes, nXorBufs, i;
265 	int     j, paramNum;
266 	RF_SectorCount_t sectorsPerSU;
267 	RF_ReconUnitNum_t which_ru;
268 	char   *overlappingPDAs;/* a temporary array of flags */
269 	RF_AccessStripeMapHeader_t *new_asm_h[2];
270 	RF_PhysDiskAddr_t *pda, *parityPDA;
271 	RF_StripeNum_t parityStripeID;
272 	RF_PhysDiskAddr_t *failedPDA;
273 	RF_RaidLayout_t *layoutPtr;
274 	char   *rpBuf;
275 
276 	layoutPtr = &(raidPtr->Layout);
277 	/* failedPDA points to the pda within the asm that targets the failed
278 	 * disk */
279 	failedPDA = asmap->failedPDAs[0];
280 	parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr,
281 	    asmap->raidAddress, &which_ru);
282 	sectorsPerSU = layoutPtr->sectorsPerStripeUnit;
283 
284 	if (rf_dagDebug) {
285 		printf("[Creating degraded read DAG]\n");
286 	}
287 	RF_ASSERT(asmap->numDataFailed == 1);
288 	dag_h->creator = "DegradedReadDAG";
289 
290 	/*
291          * generate two ASMs identifying the surviving data we need
292          * in order to recover the lost data
293          */
294 
295 	/* overlappingPDAs array must be zero'd */
296 	RF_Calloc(overlappingPDAs, asmap->numStripeUnitsAccessed, sizeof(char), (char *));
297 	rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h, new_asm_h, &nXorBufs,
298 	    &rpBuf, overlappingPDAs, allocList);
299 
300 	/*
301          * create all the nodes at once
302          *
303          * -1 because no access is generated for the failed pda
304          */
305 	nRudNodes = asmap->numStripeUnitsAccessed - 1;
306 	nRrdNodes = ((new_asm_h[0]) ? new_asm_h[0]->stripeMap->numStripeUnitsAccessed : 0) +
307 	    ((new_asm_h[1]) ? new_asm_h[1]->stripeMap->numStripeUnitsAccessed : 0);
308 	nNodes = 5 + nRudNodes + nRrdNodes;	/* lock, unlock, xor, Rp, Rud,
309 						 * Rrd */
310 	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
311 	    allocList);
312 	i = 0;
313 	blockNode = &nodes[i];
314 	i++;
315 	commitNode = &nodes[i];
316 	i++;
317 	xorNode = &nodes[i];
318 	i++;
319 	rpNode = &nodes[i];
320 	i++;
321 	termNode = &nodes[i];
322 	i++;
323 	rudNodes = &nodes[i];
324 	i += nRudNodes;
325 	rrdNodes = &nodes[i];
326 	i += nRrdNodes;
327 	RF_ASSERT(i == nNodes);
328 
329 	/* initialize nodes */
330 	dag_h->numCommitNodes = 1;
331 	dag_h->numCommits = 0;
332 	/* this dag can not commit until the commit node is reached errors
333 	 * prior to the commit point imply the dag has failed */
334 	dag_h->numSuccedents = 1;
335 
336 	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
337 	    NULL, nRudNodes + nRrdNodes + 1, 0, 0, 0, dag_h, "Nil", allocList);
338 	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
339 	    NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
340 	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
341 	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
342 	rf_InitNode(xorNode, rf_wait, RF_FALSE, recFunc->simple, rf_NullNodeUndoFunc,
343 	    NULL, 1, nRudNodes + nRrdNodes + 1, 2 * nXorBufs + 2, 1, dag_h,
344 	    recFunc->SimpleName, allocList);
345 
346 	/* fill in the Rud nodes */
347 	for (pda = asmap->physInfo, i = 0; i < nRudNodes; i++, pda = pda->next) {
348 		if (pda == failedPDA) {
349 			i--;
350 			continue;
351 		}
352 		rf_InitNode(&rudNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc,
353 		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
354 		    "Rud", allocList);
355 		RF_ASSERT(pda);
356 		rudNodes[i].params[0].p = pda;
357 		rudNodes[i].params[1].p = pda->bufPtr;
358 		rudNodes[i].params[2].v = parityStripeID;
359 		rudNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
360 	}
361 
362 	/* fill in the Rrd nodes */
363 	i = 0;
364 	if (new_asm_h[0]) {
365 		for (pda = new_asm_h[0]->stripeMap->physInfo;
366 		    i < new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
367 		    i++, pda = pda->next) {
368 			rf_InitNode(&rrdNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc,
369 			    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
370 			    dag_h, "Rrd", allocList);
371 			RF_ASSERT(pda);
372 			rrdNodes[i].params[0].p = pda;
373 			rrdNodes[i].params[1].p = pda->bufPtr;
374 			rrdNodes[i].params[2].v = parityStripeID;
375 			rrdNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
376 		}
377 	}
378 	if (new_asm_h[1]) {
379 		for (j = 0, pda = new_asm_h[1]->stripeMap->physInfo;
380 		    j < new_asm_h[1]->stripeMap->numStripeUnitsAccessed;
381 		    j++, pda = pda->next) {
382 			rf_InitNode(&rrdNodes[i + j], rf_wait, RF_FALSE, rf_DiskReadFunc,
383 			    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
384 			    dag_h, "Rrd", allocList);
385 			RF_ASSERT(pda);
386 			rrdNodes[i + j].params[0].p = pda;
387 			rrdNodes[i + j].params[1].p = pda->bufPtr;
388 			rrdNodes[i + j].params[2].v = parityStripeID;
389 			rrdNodes[i + j].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
390 		}
391 	}
392 	/* make a PDA for the parity unit */
393 	RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
394 	parityPDA->row = asmap->parityInfo->row;
395 	parityPDA->col = asmap->parityInfo->col;
396 	parityPDA->startSector = ((asmap->parityInfo->startSector / sectorsPerSU)
397 	    * sectorsPerSU) + (failedPDA->startSector % sectorsPerSU);
398 	parityPDA->numSector = failedPDA->numSector;
399 
400 	/* initialize the Rp node */
401 	rf_InitNode(rpNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
402 	    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rp ", allocList);
403 	rpNode->params[0].p = parityPDA;
404 	rpNode->params[1].p = rpBuf;
405 	rpNode->params[2].v = parityStripeID;
406 	rpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
407 
408 	/*
409          * the last and nastiest step is to assign all
410          * the parameters of the Xor node
411          */
412 	paramNum = 0;
413 	for (i = 0; i < nRrdNodes; i++) {
414 		/* all the Rrd nodes need to be xored together */
415 		xorNode->params[paramNum++] = rrdNodes[i].params[0];
416 		xorNode->params[paramNum++] = rrdNodes[i].params[1];
417 	}
418 	for (i = 0; i < nRudNodes; i++) {
419 		/* any Rud nodes that overlap the failed access need to be
420 		 * xored in */
421 		if (overlappingPDAs[i]) {
422 			RF_MallocAndAdd(pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
423 			memcpy((char *) pda, (char *) rudNodes[i].params[0].p, sizeof(RF_PhysDiskAddr_t));
424 			rf_RangeRestrictPDA(raidPtr, failedPDA, pda, RF_RESTRICT_DOBUFFER, 0);
425 			xorNode->params[paramNum++].p = pda;
426 			xorNode->params[paramNum++].p = pda->bufPtr;
427 		}
428 	}
429 	RF_Free(overlappingPDAs, asmap->numStripeUnitsAccessed * sizeof(char));
430 
431 	/* install parity pda as last set of params to be xor'd */
432 	xorNode->params[paramNum++].p = parityPDA;
433 	xorNode->params[paramNum++].p = rpBuf;
434 
435 	/*
436          * the last 2 params to the recovery xor node are
437          * the failed PDA and the raidPtr
438          */
439 	xorNode->params[paramNum++].p = failedPDA;
440 	xorNode->params[paramNum++].p = raidPtr;
441 	RF_ASSERT(paramNum == 2 * nXorBufs + 2);
442 
443 	/*
444          * The xor node uses results[0] as the target buffer.
445          * Set pointer and zero the buffer. In the kernel, this
446          * may be a user buffer in which case we have to remap it.
447          */
448 	xorNode->results[0] = failedPDA->bufPtr;
449 	RF_BZERO(bp, failedPDA->bufPtr, rf_RaidAddressToByte(raidPtr,
450 		failedPDA->numSector));
451 
452 	/* connect nodes to form graph */
453 	/* connect the header to the block node */
454 	RF_ASSERT(dag_h->numSuccedents == 1);
455 	RF_ASSERT(blockNode->numAntecedents == 0);
456 	dag_h->succedents[0] = blockNode;
457 
458 	/* connect the block node to the read nodes */
459 	RF_ASSERT(blockNode->numSuccedents == (1 + nRrdNodes + nRudNodes));
460 	RF_ASSERT(rpNode->numAntecedents == 1);
461 	blockNode->succedents[0] = rpNode;
462 	rpNode->antecedents[0] = blockNode;
463 	rpNode->antType[0] = rf_control;
464 	for (i = 0; i < nRrdNodes; i++) {
465 		RF_ASSERT(rrdNodes[i].numSuccedents == 1);
466 		blockNode->succedents[1 + i] = &rrdNodes[i];
467 		rrdNodes[i].antecedents[0] = blockNode;
468 		rrdNodes[i].antType[0] = rf_control;
469 	}
470 	for (i = 0; i < nRudNodes; i++) {
471 		RF_ASSERT(rudNodes[i].numSuccedents == 1);
472 		blockNode->succedents[1 + nRrdNodes + i] = &rudNodes[i];
473 		rudNodes[i].antecedents[0] = blockNode;
474 		rudNodes[i].antType[0] = rf_control;
475 	}
476 
477 	/* connect the read nodes to the xor node */
478 	RF_ASSERT(xorNode->numAntecedents == (1 + nRrdNodes + nRudNodes));
479 	RF_ASSERT(rpNode->numSuccedents == 1);
480 	rpNode->succedents[0] = xorNode;
481 	xorNode->antecedents[0] = rpNode;
482 	xorNode->antType[0] = rf_trueData;
483 	for (i = 0; i < nRrdNodes; i++) {
484 		RF_ASSERT(rrdNodes[i].numSuccedents == 1);
485 		rrdNodes[i].succedents[0] = xorNode;
486 		xorNode->antecedents[1 + i] = &rrdNodes[i];
487 		xorNode->antType[1 + i] = rf_trueData;
488 	}
489 	for (i = 0; i < nRudNodes; i++) {
490 		RF_ASSERT(rudNodes[i].numSuccedents == 1);
491 		rudNodes[i].succedents[0] = xorNode;
492 		xorNode->antecedents[1 + nRrdNodes + i] = &rudNodes[i];
493 		xorNode->antType[1 + nRrdNodes + i] = rf_trueData;
494 	}
495 
496 	/* connect the xor node to the commit node */
497 	RF_ASSERT(xorNode->numSuccedents == 1);
498 	RF_ASSERT(commitNode->numAntecedents == 1);
499 	xorNode->succedents[0] = commitNode;
500 	commitNode->antecedents[0] = xorNode;
501 	commitNode->antType[0] = rf_control;
502 
503 	/* connect the termNode to the commit node */
504 	RF_ASSERT(commitNode->numSuccedents == 1);
505 	RF_ASSERT(termNode->numAntecedents == 1);
506 	RF_ASSERT(termNode->numSuccedents == 0);
507 	commitNode->succedents[0] = termNode;
508 	termNode->antType[0] = rf_control;
509 	termNode->antecedents[0] = commitNode;
510 }
511 
512 #if (RF_INCLUDE_CHAINDECLUSTER > 0)
513 /******************************************************************************
514  * Create a degraded read DAG for Chained Declustering
515  *
516  * Hdr -> Nil -> R(p/s)d -> Cmt -> Trm
517  *
518  * The "Rd" node reads data from the surviving disk in the mirror pair
519  *   Rpd - read of primary copy
520  *   Rsd - read of secondary copy
521  *
522  * Parameters:  raidPtr   - description of the physical array
523  *              asmap     - logical & physical addresses for this access
524  *              bp        - buffer ptr (for holding write data)
525  *              flags     - general flags (e.g. disk locking)
526  *              allocList - list of memory allocated in DAG creation
527  *****************************************************************************/
528 
529 void
530 rf_CreateRaidCDegradedReadDAG(
531     RF_Raid_t * raidPtr,
532     RF_AccessStripeMap_t * asmap,
533     RF_DagHeader_t * dag_h,
534     void *bp,
535     RF_RaidAccessFlags_t flags,
536     RF_AllocListElem_t * allocList)
537 {
538 	RF_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
539 	RF_StripeNum_t parityStripeID;
540 	int     useMirror, i, shiftable;
541 	RF_ReconUnitNum_t which_ru;
542 	RF_PhysDiskAddr_t *pda;
543 
544 	if ((asmap->numDataFailed + asmap->numParityFailed) == 0) {
545 		shiftable = RF_TRUE;
546 	} else {
547 		shiftable = RF_FALSE;
548 	}
549 	useMirror = 0;
550 	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
551 	    asmap->raidAddress, &which_ru);
552 
553 	if (rf_dagDebug) {
554 		printf("[Creating RAID C degraded read DAG]\n");
555 	}
556 	dag_h->creator = "RaidCDegradedReadDAG";
557 	/* alloc the Wnd nodes and the Wmir node */
558 	if (asmap->numDataFailed == 0)
559 		useMirror = RF_FALSE;
560 	else
561 		useMirror = RF_TRUE;
562 
563 	/* total number of nodes = 1 + (block + commit + terminator) */
564 	RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
565 	i = 0;
566 	rdNode = &nodes[i];
567 	i++;
568 	blockNode = &nodes[i];
569 	i++;
570 	commitNode = &nodes[i];
571 	i++;
572 	termNode = &nodes[i];
573 	i++;
574 
575 	/*
576          * This dag can not commit until the commit node is reached.
577          * Errors prior to the commit point imply the dag has failed
578          * and must be retried.
579          */
580 	dag_h->numCommitNodes = 1;
581 	dag_h->numCommits = 0;
582 	dag_h->numSuccedents = 1;
583 
584 	/* initialize the block, commit, and terminator nodes */
585 	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
586 	    NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
587 	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
588 	    NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
589 	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
590 	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
591 
592 	pda = asmap->physInfo;
593 	RF_ASSERT(pda != NULL);
594 	/* parityInfo must describe entire parity unit */
595 	RF_ASSERT(asmap->parityInfo->next == NULL);
596 
597 	/* initialize the data node */
598 	if (!useMirror) {
599 		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
600 		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rpd", allocList);
601 		if (shiftable && rf_compute_workload_shift(raidPtr, pda)) {
602 			/* shift this read to the next disk in line */
603 			rdNode->params[0].p = asmap->parityInfo;
604 			rdNode->params[1].p = pda->bufPtr;
605 			rdNode->params[2].v = parityStripeID;
606 			rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
607 		} else {
608 			/* read primary copy */
609 			rdNode->params[0].p = pda;
610 			rdNode->params[1].p = pda->bufPtr;
611 			rdNode->params[2].v = parityStripeID;
612 			rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
613 		}
614 	} else {
615 		/* read secondary copy of data */
616 		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
617 		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rsd", allocList);
618 		rdNode->params[0].p = asmap->parityInfo;
619 		rdNode->params[1].p = pda->bufPtr;
620 		rdNode->params[2].v = parityStripeID;
621 		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
622 	}
623 
624 	/* connect header to block node */
625 	RF_ASSERT(dag_h->numSuccedents == 1);
626 	RF_ASSERT(blockNode->numAntecedents == 0);
627 	dag_h->succedents[0] = blockNode;
628 
629 	/* connect block node to rdnode */
630 	RF_ASSERT(blockNode->numSuccedents == 1);
631 	RF_ASSERT(rdNode->numAntecedents == 1);
632 	blockNode->succedents[0] = rdNode;
633 	rdNode->antecedents[0] = blockNode;
634 	rdNode->antType[0] = rf_control;
635 
636 	/* connect rdnode to commit node */
637 	RF_ASSERT(rdNode->numSuccedents == 1);
638 	RF_ASSERT(commitNode->numAntecedents == 1);
639 	rdNode->succedents[0] = commitNode;
640 	commitNode->antecedents[0] = rdNode;
641 	commitNode->antType[0] = rf_control;
642 
643 	/* connect commit node to terminator */
644 	RF_ASSERT(commitNode->numSuccedents == 1);
645 	RF_ASSERT(termNode->numAntecedents == 1);
646 	RF_ASSERT(termNode->numSuccedents == 0);
647 	commitNode->succedents[0] = termNode;
648 	termNode->antecedents[0] = commitNode;
649 	termNode->antType[0] = rf_control;
650 }
651 #endif /* (RF_INCLUDE_CHAINDECLUSTER > 0) */
652 
653 #if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) || (RF_INCLUDE_EVENODD > 0)
654 /*
655  * XXX move this elsewhere?
656  */
657 void
658 rf_DD_GenerateFailedAccessASMs(
659     RF_Raid_t * raidPtr,
660     RF_AccessStripeMap_t * asmap,
661     RF_PhysDiskAddr_t ** pdap,
662     int *nNodep,
663     RF_PhysDiskAddr_t ** pqpdap,
664     int *nPQNodep,
665     RF_AllocListElem_t * allocList)
666 {
667 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
668 	int     PDAPerDisk, i;
669 	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
670 	int     numDataCol = layoutPtr->numDataCol;
671 	int     state;
672 	RF_SectorNum_t suoff, suend;
673 	unsigned firstDataCol, napdas, count;
674 	RF_SectorNum_t fone_start, fone_end, ftwo_start = 0, ftwo_end = 0;
675 	RF_PhysDiskAddr_t *fone = asmap->failedPDAs[0], *ftwo = asmap->failedPDAs[1];
676 	RF_PhysDiskAddr_t *pda_p;
677 	RF_PhysDiskAddr_t *phys_p;
678 	RF_RaidAddr_t sosAddr;
679 
680 	/* determine how many pda's we will have to generate per unaccess
681 	 * stripe. If there is only one failed data unit, it is one; if two,
682 	 * possibly two, depending wether they overlap. */
683 
684 	fone_start = rf_StripeUnitOffset(layoutPtr, fone->startSector);
685 	fone_end = fone_start + fone->numSector;
686 
687 #define CONS_PDA(if,start,num) \
688   pda_p->row = asmap->if->row;    pda_p->col = asmap->if->col; \
689   pda_p->startSector = ((asmap->if->startSector / secPerSU) * secPerSU) + start; \
690   pda_p->numSector = num; \
691   pda_p->next = NULL; \
692   RF_MallocAndAdd(pda_p->bufPtr,rf_RaidAddressToByte(raidPtr,num),(char *), allocList)
693 
694 	if (asmap->numDataFailed == 1) {
695 		PDAPerDisk = 1;
696 		state = 1;
697 		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
698 		pda_p = *pqpdap;
699 		/* build p */
700 		CONS_PDA(parityInfo, fone_start, fone->numSector);
701 		pda_p->type = RF_PDA_TYPE_PARITY;
702 		pda_p++;
703 		/* build q */
704 		CONS_PDA(qInfo, fone_start, fone->numSector);
705 		pda_p->type = RF_PDA_TYPE_Q;
706 	} else {
707 		ftwo_start = rf_StripeUnitOffset(layoutPtr, ftwo->startSector);
708 		ftwo_end = ftwo_start + ftwo->numSector;
709 		if (fone->numSector + ftwo->numSector > secPerSU) {
710 			PDAPerDisk = 1;
711 			state = 2;
712 			RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
713 			pda_p = *pqpdap;
714 			CONS_PDA(parityInfo, 0, secPerSU);
715 			pda_p->type = RF_PDA_TYPE_PARITY;
716 			pda_p++;
717 			CONS_PDA(qInfo, 0, secPerSU);
718 			pda_p->type = RF_PDA_TYPE_Q;
719 		} else {
720 			PDAPerDisk = 2;
721 			state = 3;
722 			/* four of them, fone, then ftwo */
723 			RF_MallocAndAdd(*pqpdap, 4 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
724 			pda_p = *pqpdap;
725 			CONS_PDA(parityInfo, fone_start, fone->numSector);
726 			pda_p->type = RF_PDA_TYPE_PARITY;
727 			pda_p++;
728 			CONS_PDA(qInfo, fone_start, fone->numSector);
729 			pda_p->type = RF_PDA_TYPE_Q;
730 			pda_p++;
731 			CONS_PDA(parityInfo, ftwo_start, ftwo->numSector);
732 			pda_p->type = RF_PDA_TYPE_PARITY;
733 			pda_p++;
734 			CONS_PDA(qInfo, ftwo_start, ftwo->numSector);
735 			pda_p->type = RF_PDA_TYPE_Q;
736 		}
737 	}
738 	/* figure out number of nonaccessed pda */
739 	napdas = PDAPerDisk * (numDataCol - asmap->numStripeUnitsAccessed - (ftwo == NULL ? 1 : 0));
740 	*nPQNodep = PDAPerDisk;
741 
742 	/* sweep over the over accessed pda's, figuring out the number of
743 	 * additional pda's to generate. Of course, skip the failed ones */
744 
745 	count = 0;
746 	for (pda_p = asmap->physInfo; pda_p; pda_p = pda_p->next) {
747 		if ((pda_p == fone) || (pda_p == ftwo))
748 			continue;
749 		suoff = rf_StripeUnitOffset(layoutPtr, pda_p->startSector);
750 		suend = suoff + pda_p->numSector;
751 		switch (state) {
752 		case 1:	/* one failed PDA to overlap */
753 			/* if a PDA doesn't contain the failed unit, it can
754 			 * only miss the start or end, not both */
755 			if ((suoff > fone_start) || (suend < fone_end))
756 				count++;
757 			break;
758 		case 2:	/* whole stripe */
759 			if (suoff)	/* leak at begining */
760 				count++;
761 			if (suend < numDataCol)	/* leak at end */
762 				count++;
763 			break;
764 		case 3:	/* two disjoint units */
765 			if ((suoff > fone_start) || (suend < fone_end))
766 				count++;
767 			if ((suoff > ftwo_start) || (suend < ftwo_end))
768 				count++;
769 			break;
770 		default:
771 			RF_PANIC();
772 		}
773 	}
774 
775 	napdas += count;
776 	*nNodep = napdas;
777 	if (napdas == 0)
778 		return;		/* short circuit */
779 
780 	/* allocate up our list of pda's */
781 
782 	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
783 	*pdap = pda_p;
784 
785 	/* linkem together */
786 	for (i = 0; i < (napdas - 1); i++)
787 		pda_p[i].next = pda_p + (i + 1);
788 
789 	/* march through the one's up to the first accessed disk */
790 	firstDataCol = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), asmap->physInfo->raidAddress) % numDataCol;
791 	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
792 	for (i = 0; i < firstDataCol; i++) {
793 		if ((pda_p - (*pdap)) == napdas)
794 			continue;
795 		pda_p->type = RF_PDA_TYPE_DATA;
796 		pda_p->raidAddress = sosAddr + (i * secPerSU);
797 		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
798 		/* skip over dead disks */
799 		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
800 			continue;
801 		switch (state) {
802 		case 1:	/* fone */
803 			pda_p->numSector = fone->numSector;
804 			pda_p->raidAddress += fone_start;
805 			pda_p->startSector += fone_start;
806 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
807 			break;
808 		case 2:	/* full stripe */
809 			pda_p->numSector = secPerSU;
810 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
811 			break;
812 		case 3:	/* two slabs */
813 			pda_p->numSector = fone->numSector;
814 			pda_p->raidAddress += fone_start;
815 			pda_p->startSector += fone_start;
816 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
817 			pda_p++;
818 			pda_p->type = RF_PDA_TYPE_DATA;
819 			pda_p->raidAddress = sosAddr + (i * secPerSU);
820 			(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
821 			pda_p->numSector = ftwo->numSector;
822 			pda_p->raidAddress += ftwo_start;
823 			pda_p->startSector += ftwo_start;
824 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
825 			break;
826 		default:
827 			RF_PANIC();
828 		}
829 		pda_p++;
830 	}
831 
832 	/* march through the touched stripe units */
833 	for (phys_p = asmap->physInfo; phys_p; phys_p = phys_p->next, i++) {
834 		if ((phys_p == asmap->failedPDAs[0]) || (phys_p == asmap->failedPDAs[1]))
835 			continue;
836 		suoff = rf_StripeUnitOffset(layoutPtr, phys_p->startSector);
837 		suend = suoff + phys_p->numSector;
838 		switch (state) {
839 		case 1:	/* single buffer */
840 			if (suoff > fone_start) {
841 				RF_ASSERT(suend >= fone_end);
842 				/* The data read starts after the mapped
843 				 * access, snip off the begining */
844 				pda_p->numSector = suoff - fone_start;
845 				pda_p->raidAddress = sosAddr + (i * secPerSU) + fone_start;
846 				(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
847 				RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
848 				pda_p++;
849 			}
850 			if (suend < fone_end) {
851 				RF_ASSERT(suoff <= fone_start);
852 				/* The data read stops before the end of the
853 				 * failed access, extend */
854 				pda_p->numSector = fone_end - suend;
855 				pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
856 				(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
857 				RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
858 				pda_p++;
859 			}
860 			break;
861 		case 2:	/* whole stripe unit */
862 			RF_ASSERT((suoff == 0) || (suend == secPerSU));
863 			if (suend < secPerSU) {	/* short read, snip from end
864 						 * on */
865 				pda_p->numSector = secPerSU - suend;
866 				pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
867 				(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
868 				RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
869 				pda_p++;
870 			} else
871 				if (suoff > 0) {	/* short at front */
872 					pda_p->numSector = suoff;
873 					pda_p->raidAddress = sosAddr + (i * secPerSU);
874 					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
875 					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
876 					pda_p++;
877 				}
878 			break;
879 		case 3:	/* two nonoverlapping failures */
880 			if ((suoff > fone_start) || (suend < fone_end)) {
881 				if (suoff > fone_start) {
882 					RF_ASSERT(suend >= fone_end);
883 					/* The data read starts after the
884 					 * mapped access, snip off the
885 					 * begining */
886 					pda_p->numSector = suoff - fone_start;
887 					pda_p->raidAddress = sosAddr + (i * secPerSU) + fone_start;
888 					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
889 					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
890 					pda_p++;
891 				}
892 				if (suend < fone_end) {
893 					RF_ASSERT(suoff <= fone_start);
894 					/* The data read stops before the end
895 					 * of the failed access, extend */
896 					pda_p->numSector = fone_end - suend;
897 					pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
898 					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
899 					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
900 					pda_p++;
901 				}
902 			}
903 			if ((suoff > ftwo_start) || (suend < ftwo_end)) {
904 				if (suoff > ftwo_start) {
905 					RF_ASSERT(suend >= ftwo_end);
906 					/* The data read starts after the
907 					 * mapped access, snip off the
908 					 * begining */
909 					pda_p->numSector = suoff - ftwo_start;
910 					pda_p->raidAddress = sosAddr + (i * secPerSU) + ftwo_start;
911 					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
912 					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
913 					pda_p++;
914 				}
915 				if (suend < ftwo_end) {
916 					RF_ASSERT(suoff <= ftwo_start);
917 					/* The data read stops before the end
918 					 * of the failed access, extend */
919 					pda_p->numSector = ftwo_end - suend;
920 					pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
921 					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
922 					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
923 					pda_p++;
924 				}
925 			}
926 			break;
927 		default:
928 			RF_PANIC();
929 		}
930 	}
931 
932 	/* after the last accessed disk */
933 	for (; i < numDataCol; i++) {
934 		if ((pda_p - (*pdap)) == napdas)
935 			continue;
936 		pda_p->type = RF_PDA_TYPE_DATA;
937 		pda_p->raidAddress = sosAddr + (i * secPerSU);
938 		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
939 		/* skip over dead disks */
940 		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
941 			continue;
942 		switch (state) {
943 		case 1:	/* fone */
944 			pda_p->numSector = fone->numSector;
945 			pda_p->raidAddress += fone_start;
946 			pda_p->startSector += fone_start;
947 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
948 			break;
949 		case 2:	/* full stripe */
950 			pda_p->numSector = secPerSU;
951 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
952 			break;
953 		case 3:	/* two slabs */
954 			pda_p->numSector = fone->numSector;
955 			pda_p->raidAddress += fone_start;
956 			pda_p->startSector += fone_start;
957 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
958 			pda_p++;
959 			pda_p->type = RF_PDA_TYPE_DATA;
960 			pda_p->raidAddress = sosAddr + (i * secPerSU);
961 			(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
962 			pda_p->numSector = ftwo->numSector;
963 			pda_p->raidAddress += ftwo_start;
964 			pda_p->startSector += ftwo_start;
965 			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
966 			break;
967 		default:
968 			RF_PANIC();
969 		}
970 		pda_p++;
971 	}
972 
973 	RF_ASSERT(pda_p - *pdap == napdas);
974 	return;
975 }
976 #define INIT_DISK_NODE(node,name) \
977 rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 2,1,4,0, dag_h, name, allocList); \
978 (node)->succedents[0] = unblockNode; \
979 (node)->succedents[1] = recoveryNode; \
980 (node)->antecedents[0] = blockNode; \
981 (node)->antType[0] = rf_control
982 
983 #define DISK_NODE_PARAMS(_node_,_p_) \
984   (_node_).params[0].p = _p_ ; \
985   (_node_).params[1].p = (_p_)->bufPtr; \
986   (_node_).params[2].v = parityStripeID; \
987   (_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru)
988 
989 void
990 rf_DoubleDegRead(
991     RF_Raid_t * raidPtr,
992     RF_AccessStripeMap_t * asmap,
993     RF_DagHeader_t * dag_h,
994     void *bp,
995     RF_RaidAccessFlags_t flags,
996     RF_AllocListElem_t * allocList,
997     char *redundantReadNodeName,
998     char *recoveryNodeName,
999     int (*recovFunc) (RF_DagNode_t *))
1000 {
1001 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
1002 	RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *recoveryNode, *blockNode,
1003 	       *unblockNode, *rpNodes, *rqNodes, *termNode;
1004 	RF_PhysDiskAddr_t *pda, *pqPDAs;
1005 	RF_PhysDiskAddr_t *npdas;
1006 	int     nNodes, nRrdNodes, nRudNodes, i;
1007 	RF_ReconUnitNum_t which_ru;
1008 	int     nReadNodes, nPQNodes;
1009 	RF_PhysDiskAddr_t *failedPDA = asmap->failedPDAs[0];
1010 	RF_PhysDiskAddr_t *failedPDAtwo = asmap->failedPDAs[1];
1011 	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr, asmap->raidAddress, &which_ru);
1012 
1013 	if (rf_dagDebug)
1014 		printf("[Creating Double Degraded Read DAG]\n");
1015 	rf_DD_GenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes, &pqPDAs, &nPQNodes, allocList);
1016 
1017 	nRudNodes = asmap->numStripeUnitsAccessed - (asmap->numDataFailed);
1018 	nReadNodes = nRrdNodes + nRudNodes + 2 * nPQNodes;
1019 	nNodes = 4 /* block, unblock, recovery, term */ + nReadNodes;
1020 
1021 	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
1022 	i = 0;
1023 	blockNode = &nodes[i];
1024 	i += 1;
1025 	unblockNode = &nodes[i];
1026 	i += 1;
1027 	recoveryNode = &nodes[i];
1028 	i += 1;
1029 	termNode = &nodes[i];
1030 	i += 1;
1031 	rudNodes = &nodes[i];
1032 	i += nRudNodes;
1033 	rrdNodes = &nodes[i];
1034 	i += nRrdNodes;
1035 	rpNodes = &nodes[i];
1036 	i += nPQNodes;
1037 	rqNodes = &nodes[i];
1038 	i += nPQNodes;
1039 	RF_ASSERT(i == nNodes);
1040 
1041 	dag_h->numSuccedents = 1;
1042 	dag_h->succedents[0] = blockNode;
1043 	dag_h->creator = "DoubleDegRead";
1044 	dag_h->numCommits = 0;
1045 	dag_h->numCommitNodes = 1;	/* unblock */
1046 
1047 	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 2, 0, 0, dag_h, "Trm", allocList);
1048 	termNode->antecedents[0] = unblockNode;
1049 	termNode->antType[0] = rf_control;
1050 	termNode->antecedents[1] = recoveryNode;
1051 	termNode->antType[1] = rf_control;
1052 
1053 	/* init the block and unblock nodes */
1054 	/* The block node has all nodes except itself, unblock and recovery as
1055 	 * successors. Similarly for predecessors of the unblock. */
1056 	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nReadNodes, 0, 0, 0, dag_h, "Nil", allocList);
1057 	rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nReadNodes, 0, 0, dag_h, "Nil", allocList);
1058 
1059 	for (i = 0; i < nReadNodes; i++) {
1060 		blockNode->succedents[i] = rudNodes + i;
1061 		unblockNode->antecedents[i] = rudNodes + i;
1062 		unblockNode->antType[i] = rf_control;
1063 	}
1064 	unblockNode->succedents[0] = termNode;
1065 
1066 	/* The recovery node has all the reads as predecessors, and the term
1067 	 * node as successors. It gets a pda as a param from each of the read
1068 	 * nodes plus the raidPtr. For each failed unit is has a result pda. */
1069 	rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc, rf_NullNodeUndoFunc, NULL,
1070 	    1,			/* succesors */
1071 	    nReadNodes,		/* preds */
1072 	    nReadNodes + 2,	/* params */
1073 	    asmap->numDataFailed,	/* results */
1074 	    dag_h, recoveryNodeName, allocList);
1075 
1076 	recoveryNode->succedents[0] = termNode;
1077 	for (i = 0; i < nReadNodes; i++) {
1078 		recoveryNode->antecedents[i] = rudNodes + i;
1079 		recoveryNode->antType[i] = rf_trueData;
1080 	}
1081 
1082 	/* build the read nodes, then come back and fill in recovery params
1083 	 * and results */
1084 	pda = asmap->physInfo;
1085 	for (i = 0; i < nRudNodes; pda = pda->next) {
1086 		if ((pda == failedPDA) || (pda == failedPDAtwo))
1087 			continue;
1088 		INIT_DISK_NODE(rudNodes + i, "Rud");
1089 		RF_ASSERT(pda);
1090 		DISK_NODE_PARAMS(rudNodes[i], pda);
1091 		i++;
1092 	}
1093 
1094 	pda = npdas;
1095 	for (i = 0; i < nRrdNodes; i++, pda = pda->next) {
1096 		INIT_DISK_NODE(rrdNodes + i, "Rrd");
1097 		RF_ASSERT(pda);
1098 		DISK_NODE_PARAMS(rrdNodes[i], pda);
1099 	}
1100 
1101 	/* redundancy pdas */
1102 	pda = pqPDAs;
1103 	INIT_DISK_NODE(rpNodes, "Rp");
1104 	RF_ASSERT(pda);
1105 	DISK_NODE_PARAMS(rpNodes[0], pda);
1106 	pda++;
1107 	INIT_DISK_NODE(rqNodes, redundantReadNodeName);
1108 	RF_ASSERT(pda);
1109 	DISK_NODE_PARAMS(rqNodes[0], pda);
1110 	if (nPQNodes == 2) {
1111 		pda++;
1112 		INIT_DISK_NODE(rpNodes + 1, "Rp");
1113 		RF_ASSERT(pda);
1114 		DISK_NODE_PARAMS(rpNodes[1], pda);
1115 		pda++;
1116 		INIT_DISK_NODE(rqNodes + 1, redundantReadNodeName);
1117 		RF_ASSERT(pda);
1118 		DISK_NODE_PARAMS(rqNodes[1], pda);
1119 	}
1120 	/* fill in recovery node params */
1121 	for (i = 0; i < nReadNodes; i++)
1122 		recoveryNode->params[i] = rudNodes[i].params[0];	/* pda */
1123 	recoveryNode->params[i++].p = (void *) raidPtr;
1124 	recoveryNode->params[i++].p = (void *) asmap;
1125 	recoveryNode->results[0] = failedPDA;
1126 	if (asmap->numDataFailed == 2)
1127 		recoveryNode->results[1] = failedPDAtwo;
1128 
1129 	/* zero fill the target data buffers? */
1130 }
1131 
1132 #endif /* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) || (RF_INCLUDE_EVENODD > 0) */
1133