/* $NetBSD: rf_dagutils.c,v 1.1 1998/11/13 04:20:28 oster Exp $ */ /* * Copyright (c) 1995 Carnegie-Mellon University. * All rights reserved. * * Authors: Mark Holland, William V. Courtright II, Jim Zelenka * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. */ /****************************************************************************** * * rf_dagutils.c -- utility routines for manipulating dags * *****************************************************************************/ /* * : * Log: rf_dagutils.c,v * Revision 1.55 1996/08/22 14:39:47 jimz * reduce v/k fraction (better load balancing) * * Revision 1.54 1996/08/21 04:14:12 jimz * minor workload shift tweaking * * Revision 1.53 1996/08/20 23:41:16 jimz * fix up workload shift computation * * Revision 1.52 1996/08/20 22:34:16 jimz * first cut at fixing workload shift * needs work * * Revision 1.51 1996/08/20 16:51:16 jimz * comment more verbosely compute_workload_shift() * * Revision 1.50 1996/08/11 00:40:50 jimz * fix up broken comment * * Revision 1.49 1996/07/27 23:36:08 jimz * Solaris port of simulator * * Revision 1.48 1996/07/27 18:40:01 jimz * cleanup sweep * * Revision 1.47 1996/07/22 19:52:16 jimz * switched node params to RF_DagParam_t, a union of * a 64-bit int and a void *, for better portability * attempted hpux port, but failed partway through for * lack of a single C compiler capable of compiling all * source files * * Revision 1.46 1996/07/18 22:57:14 jimz * port simulator to AIX * * Revision 1.45 1996/06/17 03:24:59 jimz * include shutdown.h for define of now-macroized ShutdownCreate * * Revision 1.44 1996/06/10 12:50:57 jimz * Add counters to freelists to track number of allocations, frees, * grows, max size, etc. Adjust a couple sets of PRIME params based * on the results. * * Revision 1.43 1996/06/10 11:55:47 jimz * Straightened out some per-array/not-per-array distinctions, fixed * a couple bugs related to confusion. Added shutdown lists. Removed * layout shutdown function (now subsumed by shutdown lists). * * Revision 1.42 1996/06/07 21:33:04 jimz * begin using consistent types for sector numbers, * stripe numbers, row+col numbers, recon unit numbers * * Revision 1.41 1996/06/06 17:28:58 jimz * make PrintNodeInfoString aware of new mirroring funcs * * Revision 1.40 1996/06/05 18:06:02 jimz * Major code cleanup. The Great Renaming is now done. * Better modularity. Better typing. Fixed a bunch of * synchronization bugs. Made a lot of global stuff * per-desc or per-array. Removed dead code. * * Revision 1.39 1996/06/03 23:28:26 jimz * more bugfixes * check in tree to sync for IPDS runs with current bugfixes * there still may be a problem with threads in the script test * getting I/Os stuck- not trivially reproducible (runs ~50 times * in a row without getting stuck) * * Revision 1.38 1996/06/02 17:31:48 jimz * Moved a lot of global stuff into array structure, where it belongs. * Fixed up paritylogging, pss modules in this manner. Some general * code cleanup. Removed lots of dead code, some dead files. * * Revision 1.37 1996/05/31 22:26:54 jimz * fix a lot of mapping problems, memory allocation problems * found some weird lock issues, fixed 'em * more code cleanup * * Revision 1.36 1996/05/30 23:22:16 jimz * bugfixes of serialization, timing problems * more cleanup * * Revision 1.35 1996/05/30 11:29:41 jimz * Numerous bug fixes. Stripe lock release code disagreed with the taking code * about when stripes should be locked (I made it consistent: no parity, no lock) * There was a lot of extra serialization of I/Os which I've removed- a lot of * it was to calculate values for the cache code, which is no longer with us. * More types, function, macro cleanup. Added code to properly quiesce the array * on shutdown. Made a lot of stuff array-specific which was (bogusly) general * before. Fixed memory allocation, freeing bugs. * * Revision 1.34 1996/05/27 18:56:37 jimz * more code cleanup * better typing * compiles in all 3 environments * * Revision 1.33 1996/05/24 22:17:04 jimz * continue code + namespace cleanup * typed a bunch of flags * * Revision 1.32 1996/05/24 04:28:55 jimz * release cleanup ckpt * * Revision 1.31 1996/05/23 21:46:35 jimz * checkpoint in code cleanup (release prep) * lots of types, function names have been fixed * * Revision 1.30 1996/05/23 00:33:23 jimz * code cleanup: move all debug decls to rf_options.c, all extern * debug decls to rf_options.h, all debug vars preceded by rf_ * * Revision 1.29 1996/05/18 19:51:34 jimz * major code cleanup- fix syntax, make some types consistent, * add prototypes, clean out dead code, et cetera * * Revision 1.28 1996/05/16 23:05:52 jimz * changed InitNode() to use dag_ptrs field of node when appropriate * (see rf_dag.h or comments within InitNode() for details) * * Revision 1.27 1996/05/16 15:37:19 jimz * convert to RF_FREELIST stuff for dag headers * * Revision 1.26 1996/05/08 21:01:24 jimz * fixed up enum type names that were conflicting with other * enums and function names (ie, "panic") * future naming trends will be towards RF_ and rf_ for * everything raidframe-related * * Revision 1.25 1996/05/03 19:56:15 wvcii * added misc routines from old dag creation files * * Revision 1.24 1995/12/12 18:10:06 jimz * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT * fix 80-column brain damage in comments * * Revision 1.23 1995/12/01 15:59:50 root * added copyright info * * Revision 1.22 1995/11/17 15:14:12 wvcii * PrintDAG now processes DiskReadMirrorFunc nodes * * Revision 1.21 1995/11/07 16:22:38 wvcii * InitNode and InitNodeFromBuf now initialize commit fields * beefed up ValidateDag * prettied up PrintDAGList * */ #include "rf_archs.h" #include "rf_types.h" #include "rf_threadstuff.h" #include "rf_raid.h" #include "rf_dag.h" #include "rf_dagutils.h" #include "rf_dagfuncs.h" #include "rf_general.h" #include "rf_freelist.h" #include "rf_map.h" #include "rf_shutdown.h" #include "rf_sys.h" #define SNUM_DIFF(_a_,_b_) (((_a_)>(_b_))?((_a_)-(_b_)):((_b_)-(_a_))) RF_RedFuncs_t rf_xorFuncs = { rf_RegularXorFunc, "Reg Xr", rf_SimpleXorFunc, "Simple Xr"}; RF_RedFuncs_t rf_xorRecoveryFuncs = { rf_RecoveryXorFunc, "Recovery Xr", rf_RecoveryXorFunc, "Recovery Xr"}; static void rf_RecurPrintDAG(RF_DagNode_t *, int, int); static void rf_PrintDAG(RF_DagHeader_t *); static int rf_ValidateBranch(RF_DagNode_t *, int *, int *, RF_DagNode_t **, int ); static void rf_ValidateBranchVisitedBits(RF_DagNode_t *, int, int); static void rf_ValidateVisitedBits(RF_DagHeader_t *); /****************************************************************************** * * InitNode - initialize a dag node * * the size of the propList array is always the same as that of the * successors array. * *****************************************************************************/ void rf_InitNode( RF_DagNode_t *node, RF_NodeStatus_t initstatus, int commit, int (*doFunc)(RF_DagNode_t *node), int (*undoFunc)(RF_DagNode_t *node), int (*wakeFunc)(RF_DagNode_t *node,int status), int nSucc, int nAnte, int nParam, int nResult, RF_DagHeader_t *hdr, char *name, RF_AllocListElem_t *alist) { void **ptrs; int nptrs; if (nAnte > RF_MAX_ANTECEDENTS) RF_PANIC(); node->status = initstatus; node->commitNode = commit; node->doFunc = doFunc; node->undoFunc = undoFunc; node->wakeFunc = wakeFunc; node->numParams = nParam; node->numResults = nResult; node->numAntecedents = nAnte; node->numAntDone = 0; node->next = NULL; node->numSuccedents = nSucc; node->name = name; node->dagHdr = hdr; node->visited = 0; /* allocate all the pointers with one call to malloc */ nptrs = nSucc+nAnte+nResult+nSucc; if (nptrs <= RF_DAG_PTRCACHESIZE) { /* * The dag_ptrs field of the node is basically some scribble * space to be used here. We could get rid of it, and always * allocate the range of pointers, but that's expensive. So, * we pick a "common case" size for the pointer cache. Hopefully, * we'll find that: * (1) Generally, nptrs doesn't exceed RF_DAG_PTRCACHESIZE by * only a little bit (least efficient case) * (2) Generally, ntprs isn't a lot less than RF_DAG_PTRCACHESIZE * (wasted memory) */ ptrs = (void **)node->dag_ptrs; } else { RF_CallocAndAdd(ptrs, nptrs, sizeof(void *), (void **), alist); } node->succedents = (nSucc) ? (RF_DagNode_t **) ptrs : NULL; node->antecedents = (nAnte) ? (RF_DagNode_t **) (ptrs+nSucc) : NULL; node->results = (nResult) ? (void **) (ptrs+nSucc+nAnte) : NULL; node->propList = (nSucc) ? (RF_PropHeader_t **) (ptrs+nSucc+nAnte+nResult) : NULL; if (nParam) { if (nParam <= RF_DAG_PARAMCACHESIZE) { node->params = (RF_DagParam_t *)node->dag_params; } else { RF_CallocAndAdd(node->params, nParam, sizeof(RF_DagParam_t), (RF_DagParam_t *), alist); } } else { node->params = NULL; } } /****************************************************************************** * * allocation and deallocation routines * *****************************************************************************/ void rf_FreeDAG(dag_h) RF_DagHeader_t *dag_h; { RF_AccessStripeMapHeader_t *asmap, *t_asmap; RF_DagHeader_t *nextDag; int i; while (dag_h) { nextDag = dag_h->next; for (i=0; dag_h->memChunk[i] && i < RF_MAXCHUNKS; i++) { /* release mem chunks */ rf_ReleaseMemChunk(dag_h->memChunk[i]); dag_h->memChunk[i] = NULL; } RF_ASSERT(i == dag_h->chunkIndex); if (dag_h->xtraChunkCnt > 0) { /* free xtraMemChunks */ for (i=0; dag_h->xtraMemChunk[i] && i < dag_h->xtraChunkIndex; i++) { rf_ReleaseMemChunk(dag_h->xtraMemChunk[i]); dag_h->xtraMemChunk[i] = NULL; } RF_ASSERT(i == dag_h->xtraChunkIndex); /* free ptrs to xtraMemChunks */ RF_Free(dag_h->xtraMemChunk, dag_h->xtraChunkCnt * sizeof(RF_ChunkDesc_t *)); } rf_FreeAllocList(dag_h->allocList); for (asmap = dag_h->asmList; asmap;) { t_asmap = asmap; asmap = asmap->next; rf_FreeAccessStripeMap(t_asmap); } rf_FreeDAGHeader(dag_h); dag_h = nextDag; } } RF_PropHeader_t *rf_MakePropListEntry( RF_DagHeader_t *dag_h, int resultNum, int paramNum, RF_PropHeader_t *next, RF_AllocListElem_t *allocList) { RF_PropHeader_t *p; RF_CallocAndAdd(p, 1, sizeof(RF_PropHeader_t), (RF_PropHeader_t *), allocList); p->resultNum = resultNum; p->paramNum = paramNum; p->next = next; return(p); } static RF_FreeList_t *rf_dagh_freelist; #define RF_MAX_FREE_DAGH 128 #define RF_DAGH_INC 16 #define RF_DAGH_INITIAL 32 static void rf_ShutdownDAGs(void *); static void rf_ShutdownDAGs(ignored) void *ignored; { RF_FREELIST_DESTROY(rf_dagh_freelist,next,(RF_DagHeader_t *)); } int rf_ConfigureDAGs(listp) RF_ShutdownList_t **listp; { int rc; RF_FREELIST_CREATE(rf_dagh_freelist, RF_MAX_FREE_DAGH, RF_DAGH_INC, sizeof(RF_DagHeader_t)); if (rf_dagh_freelist == NULL) return(ENOMEM); rc = rf_ShutdownCreate(listp, rf_ShutdownDAGs, NULL); if (rc) { RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__, __LINE__, rc); rf_ShutdownDAGs(NULL); return(rc); } RF_FREELIST_PRIME(rf_dagh_freelist, RF_DAGH_INITIAL,next, (RF_DagHeader_t *)); return(0); } RF_DagHeader_t *rf_AllocDAGHeader() { RF_DagHeader_t *dh; RF_FREELIST_GET(rf_dagh_freelist,dh,next,(RF_DagHeader_t *)); if (dh) { bzero((char *)dh, sizeof(RF_DagHeader_t)); } return(dh); } void rf_FreeDAGHeader(RF_DagHeader_t *dh) { RF_FREELIST_FREE(rf_dagh_freelist,dh,next); } /* allocates a buffer big enough to hold the data described by pda */ void *rf_AllocBuffer( RF_Raid_t *raidPtr, RF_DagHeader_t *dag_h, RF_PhysDiskAddr_t *pda, RF_AllocListElem_t *allocList) { char *p; RF_MallocAndAdd(p, pda->numSector << raidPtr->logBytesPerSector, (char *), allocList); return((void *)p); } /****************************************************************************** * * debug routines * *****************************************************************************/ char *rf_NodeStatusString(RF_DagNode_t *node) { switch (node->status) { case rf_wait: return("wait"); case rf_fired: return("fired"); case rf_good: return("good"); case rf_bad: return("bad"); default: return("?"); } } void rf_PrintNodeInfoString(RF_DagNode_t *node) { RF_PhysDiskAddr_t *pda; int (*df)(RF_DagNode_t *) = node->doFunc; int i, lk, unlk; void *bufPtr; if ((df==rf_DiskReadFunc) || (df==rf_DiskWriteFunc) || (df==rf_DiskReadMirrorIdleFunc) || (df == rf_DiskReadMirrorPartitionFunc)) { pda = (RF_PhysDiskAddr_t *)node->params[0].p; bufPtr = (void *)node->params[1].p; lk = RF_EXTRACT_LOCK_FLAG(node->params[3].v); unlk = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v); RF_ASSERT( !(lk && unlk) ); printf("r %d c %d offs %ld nsect %d buf 0x%lx %s\n", pda->row, pda->col, (long)pda->startSector, (int) pda->numSector, (long)bufPtr, (lk) ? "LOCK" : ((unlk) ? "UNLK" : " ")); return; } if (df == rf_DiskUnlockFunc) { pda = (RF_PhysDiskAddr_t *)node->params[0].p; lk = RF_EXTRACT_LOCK_FLAG(node->params[3].v); unlk = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v); RF_ASSERT( !(lk && unlk) ); printf("r %d c %d %s\n", pda->row, pda->col, (lk) ? "LOCK" : ((unlk) ? "UNLK" : "nop")); return; } if ((df==rf_SimpleXorFunc) || (df==rf_RegularXorFunc) || (df==rf_RecoveryXorFunc)) { printf("result buf 0x%lx\n",(long) node->results[0]); for (i=0; inumParams-1; i+=2) { pda = (RF_PhysDiskAddr_t *)node->params[i].p; bufPtr = (RF_PhysDiskAddr_t *)node->params[i+1].p; printf(" buf 0x%lx r%d c%d offs %ld nsect %d\n", (long)bufPtr, pda->row, pda->col, (long)pda->startSector, (int)pda->numSector); } return; } #if RF_INCLUDE_PARITYLOGGING > 0 if (df==rf_ParityLogOverwriteFunc || df==rf_ParityLogUpdateFunc) { for (i=0; inumParams-1; i+=2) { pda = (RF_PhysDiskAddr_t *)node->params[i].p; bufPtr = (RF_PhysDiskAddr_t *)node->params[i+1].p; printf(" r%d c%d offs %ld nsect %d buf 0x%lx\n", pda->row, pda->col, (long) pda->startSector, (int) pda->numSector, (long) bufPtr); } return; } #endif /* RF_INCLUDE_PARITYLOGGING > 0 */ if ((df==rf_TerminateFunc) || (df==rf_NullNodeFunc)) { printf("\n"); return; } printf("?\n"); } static void rf_RecurPrintDAG(node, depth, unvisited) RF_DagNode_t *node; int depth; int unvisited; { char *anttype; int i; node->visited = (unvisited) ? 0 : 1; printf("(%d) %d C%d %s: %s,s%d %d/%d,a%d/%d,p%d,r%d S{", depth, node->nodeNum, node->commitNode, node->name, rf_NodeStatusString(node), node->numSuccedents, node->numSuccFired, node->numSuccDone, node->numAntecedents, node->numAntDone, node->numParams,node->numResults); for (i=0; inumSuccedents; i++) { printf("%d%s", node->succedents[i]->nodeNum, ((i==node->numSuccedents-1) ? "\0" : " ")); } printf("} A{"); for (i=0; inumAntecedents; i++) { switch (node->antType[i]) { case rf_trueData : anttype = "T"; break; case rf_antiData : anttype = "A"; break; case rf_outputData : anttype = "O"; break; case rf_control : anttype = "C"; break; default : anttype = "?"; break; } printf("%d(%s)%s", node->antecedents[i]->nodeNum, anttype, (i==node->numAntecedents-1) ? "\0" : " "); } printf("}; "); rf_PrintNodeInfoString(node); for (i=0; inumSuccedents; i++) { if (node->succedents[i]->visited == unvisited) rf_RecurPrintDAG(node->succedents[i], depth+1, unvisited); } } static void rf_PrintDAG(dag_h) RF_DagHeader_t *dag_h; { int unvisited, i; char *status; /* set dag status */ switch (dag_h->status) { case rf_enable : status = "enable"; break; case rf_rollForward : status = "rollForward"; break; case rf_rollBackward : status = "rollBackward"; break; default : status = "illegal!"; break; } /* find out if visited bits are currently set or clear */ unvisited = dag_h->succedents[0]->visited; printf("DAG type: %s\n", dag_h->creator); printf("format is (depth) num commit type: status,nSucc nSuccFired/nSuccDone,nAnte/nAnteDone,nParam,nResult S{x} A{x(type)}; info\n"); printf("(0) %d Hdr: %s, s%d, (commit %d/%d) S{", dag_h->nodeNum, status, dag_h->numSuccedents, dag_h->numCommitNodes, dag_h->numCommits); for (i=0; inumSuccedents; i++) { printf("%d%s", dag_h->succedents[i]->nodeNum, ((i==dag_h->numSuccedents-1) ? "\0" : " ")); } printf("};\n"); for (i=0; inumSuccedents; i++) { if (dag_h->succedents[i]->visited == unvisited) rf_RecurPrintDAG(dag_h->succedents[i], 1, unvisited); } } /* assigns node numbers */ int rf_AssignNodeNums(RF_DagHeader_t *dag_h) { int unvisited, i, nnum; RF_DagNode_t *node; nnum = 0; unvisited = dag_h->succedents[0]->visited; dag_h->nodeNum = nnum++; for (i=0; inumSuccedents; i++) { node = dag_h->succedents[i]; if (node->visited == unvisited) { nnum = rf_RecurAssignNodeNums(dag_h->succedents[i], nnum, unvisited); } } return(nnum); } int rf_RecurAssignNodeNums(node, num, unvisited) RF_DagNode_t *node; int num; int unvisited; { int i; node->visited = (unvisited) ? 0 : 1; node->nodeNum = num++; for (i=0; inumSuccedents; i++) { if (node->succedents[i]->visited == unvisited) { num = rf_RecurAssignNodeNums(node->succedents[i], num, unvisited); } } return(num); } /* set the header pointers in each node to "newptr" */ void rf_ResetDAGHeaderPointers(dag_h, newptr) RF_DagHeader_t *dag_h; RF_DagHeader_t *newptr; { int i; for (i=0; inumSuccedents; i++) if (dag_h->succedents[i]->dagHdr != newptr) rf_RecurResetDAGHeaderPointers(dag_h->succedents[i], newptr); } void rf_RecurResetDAGHeaderPointers(node, newptr) RF_DagNode_t *node; RF_DagHeader_t *newptr; { int i; node->dagHdr = newptr; for (i=0; inumSuccedents; i++) if (node->succedents[i]->dagHdr != newptr) rf_RecurResetDAGHeaderPointers(node->succedents[i], newptr); } void rf_PrintDAGList(RF_DagHeader_t *dag_h) { int i=0; for (; dag_h; dag_h=dag_h->next) { rf_AssignNodeNums(dag_h); printf("\n\nDAG %d IN LIST:\n",i++); rf_PrintDAG(dag_h); } } static int rf_ValidateBranch(node, scount, acount, nodes, unvisited) RF_DagNode_t *node; int *scount; int *acount; RF_DagNode_t **nodes; int unvisited; { int i, retcode = 0; /* construct an array of node pointers indexed by node num */ node->visited = (unvisited) ? 0 : 1; nodes[ node->nodeNum ] = node; if (node->next != NULL) { printf("INVALID DAG: next pointer in node is not NULL\n"); retcode = 1; } if (node->status != rf_wait) { printf("INVALID DAG: Node status is not wait\n"); retcode = 1; } if (node->numAntDone != 0) { printf("INVALID DAG: numAntDone is not zero\n"); retcode = 1; } if (node->doFunc == rf_TerminateFunc) { if (node->numSuccedents != 0) { printf("INVALID DAG: Terminator node has succedents\n"); retcode = 1; } } else { if (node->numSuccedents == 0) { printf("INVALID DAG: Non-terminator node has no succedents\n"); retcode = 1; } } for (i=0; inumSuccedents; i++) { if (!node->succedents[i]) { printf("INVALID DAG: succedent %d of node %s is NULL\n",i,node->name); retcode = 1; } scount[ node->succedents[i]->nodeNum ]++; } for (i=0; inumAntecedents; i++) { if (!node->antecedents[i]) { printf("INVALID DAG: antecedent %d of node %s is NULL\n",i,node->name); retcode = 1; } acount[ node->antecedents[i]->nodeNum ]++; } for (i=0; inumSuccedents; i++) { if (node->succedents[i]->visited == unvisited) { if (rf_ValidateBranch(node->succedents[i], scount, acount, nodes, unvisited)) { retcode = 1; } } } return(retcode); } static void rf_ValidateBranchVisitedBits(node, unvisited, rl) RF_DagNode_t *node; int unvisited; int rl; { int i; RF_ASSERT(node->visited == unvisited); for (i=0; inumSuccedents; i++) { if (node->succedents[i] == NULL) { printf("node=%lx node->succedents[%d] is NULL\n", (long)node, i); RF_ASSERT(0); } rf_ValidateBranchVisitedBits(node->succedents[i],unvisited, rl+1); } } /* NOTE: never call this on a big dag, because it is exponential * in execution time */ static void rf_ValidateVisitedBits(dag) RF_DagHeader_t *dag; { int i, unvisited; unvisited = dag->succedents[0]->visited; for (i=0; inumSuccedents; i++) { if (dag->succedents[i] == NULL) { printf("dag=%lx dag->succedents[%d] is NULL\n", (long) dag, i); RF_ASSERT(0); } rf_ValidateBranchVisitedBits(dag->succedents[i],unvisited,0); } } /* validate a DAG. _at entry_ verify that: * -- numNodesCompleted is zero * -- node queue is null * -- dag status is rf_enable * -- next pointer is null on every node * -- all nodes have status wait * -- numAntDone is zero in all nodes * -- terminator node has zero successors * -- no other node besides terminator has zero successors * -- no successor or antecedent pointer in a node is NULL * -- number of times that each node appears as a successor of another node * is equal to the antecedent count on that node * -- number of times that each node appears as an antecedent of another node * is equal to the succedent count on that node * -- what else? */ int rf_ValidateDAG(dag_h) RF_DagHeader_t *dag_h; { int i, nodecount; int *scount, *acount; /* per-node successor and antecedent counts */ RF_DagNode_t **nodes; /* array of ptrs to nodes in dag */ int retcode = 0; int unvisited; int commitNodeCount = 0; if (rf_validateVisitedDebug) rf_ValidateVisitedBits(dag_h); if (dag_h->numNodesCompleted != 0) { printf("INVALID DAG: num nodes completed is %d, should be 0\n",dag_h->numNodesCompleted); retcode = 1; goto validate_dag_bad; } if (dag_h->status != rf_enable) { printf("INVALID DAG: not enabled\n"); retcode = 1; goto validate_dag_bad; } if (dag_h->numCommits != 0) { printf("INVALID DAG: numCommits != 0 (%d)\n",dag_h->numCommits); retcode = 1; goto validate_dag_bad; } if (dag_h->numSuccedents != 1) { /* currently, all dags must have only one succedent */ printf("INVALID DAG: numSuccedents !1 (%d)\n",dag_h->numSuccedents); retcode = 1; goto validate_dag_bad; } nodecount = rf_AssignNodeNums(dag_h); unvisited = dag_h->succedents[0]->visited; RF_Calloc(scount, nodecount, sizeof(int), (int *)); RF_Calloc(acount, nodecount, sizeof(int), (int *)); RF_Calloc(nodes, nodecount, sizeof(RF_DagNode_t *), (RF_DagNode_t **)); for (i=0; inumSuccedents; i++) { if ((dag_h->succedents[i]->visited == unvisited) && rf_ValidateBranch(dag_h->succedents[i], scount, acount, nodes, unvisited)) { retcode = 1; } } /* start at 1 to skip the header node */ for (i=1; icommitNode ) commitNodeCount++; if ( nodes[i]->doFunc == NULL ) { printf("INVALID DAG: node %s has an undefined doFunc\n", nodes[i]->name); retcode = 1; goto validate_dag_out; } if ( nodes[i]->undoFunc == NULL ) { printf("INVALID DAG: node %s has an undefined doFunc\n", nodes[i]->name); retcode = 1; goto validate_dag_out; } if ( nodes[i]->numAntecedents != scount[ nodes[i]->nodeNum ] ) { printf("INVALID DAG: node %s has %d antecedents but appears as a succedent %d times\n", nodes[i]->name, nodes[i]->numAntecedents, scount[nodes[i]->nodeNum]); retcode = 1; goto validate_dag_out; } if ( nodes[i]->numSuccedents != acount[ nodes[i]->nodeNum ] ) { printf("INVALID DAG: node %s has %d succedents but appears as an antecedent %d times\n", nodes[i]->name, nodes[i]->numSuccedents, acount[nodes[i]->nodeNum]); retcode = 1; goto validate_dag_out; } } if ( dag_h->numCommitNodes != commitNodeCount ) { printf("INVALID DAG: incorrect commit node count. hdr->numCommitNodes (%d) found (%d) commit nodes in graph\n", dag_h->numCommitNodes, commitNodeCount); retcode = 1; goto validate_dag_out; } validate_dag_out: RF_Free(scount, nodecount*sizeof(int)); RF_Free(acount, nodecount*sizeof(int)); RF_Free(nodes, nodecount*sizeof(RF_DagNode_t *)); if (retcode) rf_PrintDAGList(dag_h); if (rf_validateVisitedDebug) rf_ValidateVisitedBits(dag_h); return(retcode); validate_dag_bad: rf_PrintDAGList(dag_h); return(retcode); } /****************************************************************************** * * misc construction routines * *****************************************************************************/ void rf_redirect_asm( RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap) { int ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) ? 1 : 0; int row = asmap->physInfo->row; int fcol = raidPtr->reconControl[row]->fcol; int srow = raidPtr->reconControl[row]->spareRow; int scol = raidPtr->reconControl[row]->spareCol; RF_PhysDiskAddr_t *pda; RF_ASSERT( raidPtr->status[row] == rf_rs_reconstructing ); for (pda = asmap->physInfo; pda; pda=pda->next) { if (pda->col == fcol) { if (rf_dagDebug) { if (!rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, pda->startSector)) { RF_PANIC(); } } /*printf("Remapped data for large write\n");*/ if (ds) { raidPtr->Layout.map->MapSector(raidPtr, pda->raidAddress, &pda->row, &pda->col, &pda->startSector, RF_REMAP); } else { pda->row = srow; pda->col = scol; } } } for (pda = asmap->parityInfo; pda; pda=pda->next) { if (pda->col == fcol) { if (rf_dagDebug) { if (!rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, pda->startSector)) { RF_PANIC(); } } } if (ds) { (raidPtr->Layout.map->MapParity)(raidPtr, pda->raidAddress, &pda->row, &pda->col, &pda->startSector, RF_REMAP); } else { pda->row = srow; pda->col = scol; } } } /* this routine allocates read buffers and generates stripe maps for the * regions of the array from the start of the stripe to the start of the * access, and from the end of the access to the end of the stripe. It also * computes and returns the number of DAG nodes needed to read all this data. * Note that this routine does the wrong thing if the access is fully * contained within one stripe unit, so we RF_ASSERT against this case at the * start. */ void rf_MapUnaccessedPortionOfStripe( RF_Raid_t *raidPtr, RF_RaidLayout_t *layoutPtr, /* in: layout information */ RF_AccessStripeMap_t *asmap, /* in: access stripe map */ RF_DagHeader_t *dag_h, /* in: header of the dag to create */ RF_AccessStripeMapHeader_t **new_asm_h, /* in: ptr to array of 2 headers, to be filled in */ int *nRodNodes, /* out: num nodes to be generated to read unaccessed data */ char **sosBuffer, /* out: pointers to newly allocated buffer */ char **eosBuffer, RF_AllocListElem_t *allocList) { RF_RaidAddr_t sosRaidAddress, eosRaidAddress; RF_SectorNum_t sosNumSector, eosNumSector; RF_ASSERT( asmap->numStripeUnitsAccessed > (layoutPtr->numDataCol/2) ); /* generate an access map for the region of the array from start of stripe * to start of access */ new_asm_h[0] = new_asm_h[1] = NULL; *nRodNodes = 0; if (!rf_RaidAddressStripeAligned(layoutPtr, asmap->raidAddress)) { sosRaidAddress = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress); sosNumSector = asmap->raidAddress - sosRaidAddress; RF_MallocAndAdd(*sosBuffer, rf_RaidAddressToByte(raidPtr, sosNumSector), (char *), allocList); new_asm_h[0] = rf_MapAccess(raidPtr, sosRaidAddress, sosNumSector, *sosBuffer, RF_DONT_REMAP); new_asm_h[0]->next = dag_h->asmList; dag_h->asmList = new_asm_h[0]; *nRodNodes += new_asm_h[0]->stripeMap->numStripeUnitsAccessed; RF_ASSERT(new_asm_h[0]->stripeMap->next == NULL); /* we're totally within one stripe here */ if (asmap->flags & RF_ASM_REDIR_LARGE_WRITE) rf_redirect_asm(raidPtr, new_asm_h[0]->stripeMap); } /* generate an access map for the region of the array from end of access * to end of stripe */ if (!rf_RaidAddressStripeAligned(layoutPtr, asmap->endRaidAddress)) { eosRaidAddress = asmap->endRaidAddress; eosNumSector = rf_RaidAddressOfNextStripeBoundary(layoutPtr, eosRaidAddress) - eosRaidAddress; RF_MallocAndAdd(*eosBuffer, rf_RaidAddressToByte(raidPtr, eosNumSector), (char *), allocList); new_asm_h[1] = rf_MapAccess(raidPtr, eosRaidAddress, eosNumSector, *eosBuffer, RF_DONT_REMAP); new_asm_h[1]->next = dag_h->asmList; dag_h->asmList = new_asm_h[1]; *nRodNodes += new_asm_h[1]->stripeMap->numStripeUnitsAccessed; RF_ASSERT(new_asm_h[1]->stripeMap->next == NULL); /* we're totally within one stripe here */ if (asmap->flags & RF_ASM_REDIR_LARGE_WRITE) rf_redirect_asm(raidPtr, new_asm_h[1]->stripeMap); } } /* returns non-zero if the indicated ranges of stripe unit offsets overlap */ int rf_PDAOverlap( RF_RaidLayout_t *layoutPtr, RF_PhysDiskAddr_t *src, RF_PhysDiskAddr_t *dest) { RF_SectorNum_t soffs = rf_StripeUnitOffset(layoutPtr, src->startSector); RF_SectorNum_t doffs = rf_StripeUnitOffset(layoutPtr, dest->startSector); /* use -1 to be sure we stay within SU */ RF_SectorNum_t send = rf_StripeUnitOffset(layoutPtr, src->startSector + src->numSector-1); RF_SectorNum_t dend = rf_StripeUnitOffset(layoutPtr, dest->startSector + dest->numSector-1); return( (RF_MAX(soffs,doffs) <= RF_MIN(send,dend)) ? 1 : 0 ); } /* GenerateFailedAccessASMs * * this routine figures out what portion of the stripe needs to be read * to effect the degraded read or write operation. It's primary function * is to identify everything required to recover the data, and then * eliminate anything that is already being accessed by the user. * * The main result is two new ASMs, one for the region from the start of the * stripe to the start of the access, and one for the region from the end of * the access to the end of the stripe. These ASMs describe everything that * needs to be read to effect the degraded access. Other results are: * nXorBufs -- the total number of buffers that need to be XORed together to * recover the lost data, * rpBufPtr -- ptr to a newly-allocated buffer to hold the parity. If NULL * at entry, not allocated. * overlappingPDAs -- * describes which of the non-failed PDAs in the user access * overlap data that needs to be read to effect recovery. * overlappingPDAs[i]==1 if and only if, neglecting the failed * PDA, the ith pda in the input asm overlaps data that needs * to be read for recovery. */ /* in: asm - ASM for the actual access, one stripe only */ /* in: faildPDA - which component of the access has failed */ /* in: dag_h - header of the DAG we're going to create */ /* out: new_asm_h - the two new ASMs */ /* out: nXorBufs - the total number of xor bufs required */ /* out: rpBufPtr - a buffer for the parity read */ void rf_GenerateFailedAccessASMs( RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap, RF_PhysDiskAddr_t *failedPDA, RF_DagHeader_t *dag_h, RF_AccessStripeMapHeader_t **new_asm_h, int *nXorBufs, char **rpBufPtr, char *overlappingPDAs, RF_AllocListElem_t *allocList) { RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout); /* s=start, e=end, s=stripe, a=access, f=failed, su=stripe unit */ RF_RaidAddr_t sosAddr, sosEndAddr, eosStartAddr, eosAddr; RF_SectorCount_t numSect[2], numParitySect; RF_PhysDiskAddr_t *pda; char *rdBuf, *bufP; int foundit, i; bufP = NULL; foundit = 0; /* first compute the following raid addresses: start of stripe, (sosAddr) MIN(start of access, start of failed SU), (sosEndAddr) MAX(end of access, end of failed SU), (eosStartAddr) end of stripe (i.e. start of next stripe) (eosAddr) */ sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress); sosEndAddr = RF_MIN(asmap->raidAddress, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,failedPDA->raidAddress)); eosStartAddr = RF_MAX(asmap->endRaidAddress, rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, failedPDA->raidAddress)); eosAddr = rf_RaidAddressOfNextStripeBoundary(layoutPtr, asmap->raidAddress); /* now generate access stripe maps for each of the above regions of the * stripe. Use a dummy (NULL) buf ptr for now */ new_asm_h[0] = (sosAddr != sosEndAddr) ? rf_MapAccess(raidPtr, sosAddr, sosEndAddr-sosAddr, NULL, RF_DONT_REMAP) : NULL; new_asm_h[1] = (eosStartAddr != eosAddr) ? rf_MapAccess(raidPtr, eosStartAddr, eosAddr-eosStartAddr, NULL, RF_DONT_REMAP) : NULL; /* walk through the PDAs and range-restrict each SU to the region of the * SU touched on the failed PDA. also compute total data buffer space * requirements in this step. Ignore the parity for now. */ numSect[0] = numSect[1] = 0; if (new_asm_h[0]) { new_asm_h[0]->next = dag_h->asmList; dag_h->asmList = new_asm_h[0]; for (pda = new_asm_h[0]->stripeMap->physInfo; pda; pda = pda->next) { rf_RangeRestrictPDA(raidPtr,failedPDA, pda, RF_RESTRICT_NOBUFFER, 0); numSect[0] += pda->numSector; } } if (new_asm_h[1]) { new_asm_h[1]->next = dag_h->asmList; dag_h->asmList = new_asm_h[1]; for (pda = new_asm_h[1]->stripeMap->physInfo; pda; pda = pda->next) { rf_RangeRestrictPDA(raidPtr,failedPDA, pda, RF_RESTRICT_NOBUFFER, 0); numSect[1] += pda->numSector; } } numParitySect = failedPDA->numSector; /* allocate buffer space for the data & parity we have to read to recover * from the failure */ if (numSect[0]+numSect[1]+ ((rpBufPtr) ? numParitySect : 0)) { /* don't allocate parity buf if not needed */ RF_MallocAndAdd(rdBuf, rf_RaidAddressToByte(raidPtr,numSect[0]+numSect[1]+numParitySect), (char *), allocList); bufP = rdBuf; if (rf_degDagDebug) printf("Newly allocated buffer (%d bytes) is 0x%lx\n", (int)rf_RaidAddressToByte(raidPtr,numSect[0]+numSect[1]+numParitySect), (unsigned long) bufP); } /* now walk through the pdas one last time and assign buffer pointers * (ugh!). Again, ignore the parity. also, count nodes to find out how * many bufs need to be xored together */ (*nXorBufs) = 1; /* in read case, 1 is for parity. In write case, 1 is for failed data */ if (new_asm_h[0]) { for (pda=new_asm_h[0]->stripeMap->physInfo; pda; pda=pda->next) {pda->bufPtr = bufP; bufP += rf_RaidAddressToByte(raidPtr,pda->numSector);} *nXorBufs += new_asm_h[0]->stripeMap->numStripeUnitsAccessed; } if (new_asm_h[1]) { for (pda=new_asm_h[1]->stripeMap->physInfo; pda; pda=pda->next) {pda->bufPtr = bufP; bufP += rf_RaidAddressToByte(raidPtr,pda->numSector);} (*nXorBufs) += new_asm_h[1]->stripeMap->numStripeUnitsAccessed; } if (rpBufPtr) *rpBufPtr = bufP; /* the rest of the buffer is for parity */ /* the last step is to figure out how many more distinct buffers need to * get xor'd to produce the missing unit. there's one for each user-data * read node that overlaps the portion of the failed unit being accessed */ for (foundit=i=0,pda=asmap->physInfo; pda; i++,pda=pda->next) { if (pda == failedPDA) {i--; foundit=1; continue;} if (rf_PDAOverlap(layoutPtr, pda, failedPDA)) { overlappingPDAs[i] = 1; (*nXorBufs)++; } } if (!foundit) {RF_ERRORMSG("GenerateFailedAccessASMs: did not find failedPDA in asm list\n"); RF_ASSERT(0);} if (rf_degDagDebug) { if (new_asm_h[0]) { printf("First asm:\n"); rf_PrintFullAccessStripeMap(new_asm_h[0], 1); } if (new_asm_h[1]) { printf("Second asm:\n"); rf_PrintFullAccessStripeMap(new_asm_h[1], 1); } } } /* adjusts the offset and number of sectors in the destination pda so that * it covers at most the region of the SU covered by the source PDA. This * is exclusively a restriction: the number of sectors indicated by the * target PDA can only shrink. * * For example: s = sectors within SU indicated by source PDA * d = sectors within SU indicated by dest PDA * r = results, stored in dest PDA * * |--------------- one stripe unit ---------------------| * | sssssssssssssssssssssssssssssssss | * | ddddddddddddddddddddddddddddddddddddddddddddd | * | rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr | * * Another example: * * |--------------- one stripe unit ---------------------| * | sssssssssssssssssssssssssssssssss | * | ddddddddddddddddddddddd | * | rrrrrrrrrrrrrrrr | * */ void rf_RangeRestrictPDA( RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *src, RF_PhysDiskAddr_t *dest, int dobuffer, int doraidaddr) { RF_RaidLayout_t *layoutPtr = &raidPtr->Layout; RF_SectorNum_t soffs = rf_StripeUnitOffset(layoutPtr, src->startSector); RF_SectorNum_t doffs = rf_StripeUnitOffset(layoutPtr, dest->startSector); RF_SectorNum_t send = rf_StripeUnitOffset(layoutPtr, src->startSector + src->numSector-1); /* use -1 to be sure we stay within SU */ RF_SectorNum_t dend = rf_StripeUnitOffset(layoutPtr, dest->startSector + dest->numSector-1); RF_SectorNum_t subAddr = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, dest->startSector); /* stripe unit boundary */ dest->startSector = subAddr + RF_MAX(soffs,doffs); dest->numSector = subAddr + RF_MIN(send,dend) + 1 - dest->startSector; if (dobuffer) dest->bufPtr += (soffs > doffs) ? rf_RaidAddressToByte(raidPtr,soffs-doffs) : 0; if (doraidaddr) { dest->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, dest->raidAddress) + rf_StripeUnitOffset(layoutPtr, dest->startSector); } } /* * Want the highest of these primes to be the largest one * less than the max expected number of columns (won't hurt * to be too small or too large, but won't be optimal, either) * --jimz */ #define NLOWPRIMES 8 static int lowprimes[NLOWPRIMES] = {2,3,5,7,11,13,17,19}; /***************************************************************************** * compute the workload shift factor. (chained declustering) * * return nonzero if access should shift to secondary, otherwise, * access is to primary *****************************************************************************/ int rf_compute_workload_shift( RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda) { /* * variables: * d = column of disk containing primary * f = column of failed disk * n = number of disks in array * sd = "shift distance" (number of columns that d is to the right of f) * row = row of array the access is in * v = numerator of redirection ratio * k = denominator of redirection ratio */ RF_RowCol_t d, f, sd, row, n; int k, v, ret, i; row = pda->row; n = raidPtr->numCol; /* assign column of primary copy to d */ d = pda->col; /* assign column of dead disk to f */ for(f=0;((!RF_DEAD_DISK(raidPtr->Disks[row][f].status))&&(f d) ? (n + d - f) : (d - f); RF_ASSERT(sd < n); /* * v of every k accesses should be redirected * * v/k := (n-1-sd)/(n-1) */ v = (n-1-sd); k = (n-1); #if 1 /* * XXX * Is this worth it? * * Now reduce the fraction, by repeatedly factoring * out primes (just like they teach in elementary school!) */ for(i=0;i v) break; while (((v%lowprimes[i])==0) && ((k%lowprimes[i])==0)) { v /= lowprimes[i]; k /= lowprimes[i]; } } #endif raidPtr->hist_diskreq[row][d]++; if (raidPtr->hist_diskreq[row][d] > v) { ret = 0; /* do not redirect */ } else { ret = 1; /* redirect */ } #if 0 printf("d=%d f=%d sd=%d v=%d k=%d ret=%d h=%d\n", d, f, sd, v, k, ret, raidPtr->hist_diskreq[row][d]); #endif if (raidPtr->hist_diskreq[row][d] >= k) { /* reset counter */ raidPtr->hist_diskreq[row][d] = 0; } return(ret); } /* * Disk selection routines */ /* * Selects the disk with the shortest queue from a mirror pair. * Both the disk I/Os queued in RAIDframe as well as those at the physical * disk are counted as members of the "queue" */ void rf_SelectMirrorDiskIdle(RF_DagNode_t *node) { RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr; RF_RowCol_t rowData, colData, rowMirror, colMirror; int dataQueueLength, mirrorQueueLength, usemirror; RF_PhysDiskAddr_t *data_pda = (RF_PhysDiskAddr_t *)node->params[0].p; RF_PhysDiskAddr_t *mirror_pda = (RF_PhysDiskAddr_t *)node->params[4].p; RF_PhysDiskAddr_t *tmp_pda; RF_RaidDisk_t **disks = raidPtr->Disks; RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue; /* return the [row col] of the disk with the shortest queue */ rowData = data_pda->row; colData = data_pda->col; rowMirror = mirror_pda->row; colMirror = mirror_pda->col; dataQueue = &(dqs[rowData][colData]); mirrorQueue = &(dqs[rowMirror][colMirror]); #ifdef RF_LOCK_QUEUES_TO_READ_LEN RF_LOCK_QUEUE_MUTEX(dataQueue, "SelectMirrorDiskIdle"); #endif /* RF_LOCK_QUEUES_TO_READ_LEN */ dataQueueLength = dataQueue->queueLength + dataQueue->numOutstanding; #ifdef RF_LOCK_QUEUES_TO_READ_LEN RF_UNLOCK_QUEUE_MUTEX(dataQueue, "SelectMirrorDiskIdle"); RF_LOCK_QUEUE_MUTEX(mirrorQueue, "SelectMirrorDiskIdle"); #endif /* RF_LOCK_QUEUES_TO_READ_LEN */ mirrorQueueLength = mirrorQueue->queueLength + mirrorQueue->numOutstanding; #ifdef RF_LOCK_QUEUES_TO_READ_LEN RF_UNLOCK_QUEUE_MUTEX(mirrorQueue, "SelectMirrorDiskIdle"); #endif /* RF_LOCK_QUEUES_TO_READ_LEN */ usemirror = 0; if (RF_DEAD_DISK(disks[rowMirror][colMirror].status)) { usemirror = 0; } else if (RF_DEAD_DISK(disks[rowData][colData].status)) { usemirror = 1; } else if (dataQueueLength < mirrorQueueLength) { usemirror = 0; } else if (mirrorQueueLength < dataQueueLength) { usemirror = 1; } else { /* queues are equal length. attempt cleverness. */ if (SNUM_DIFF(dataQueue->last_deq_sector,data_pda->startSector) <= SNUM_DIFF(mirrorQueue->last_deq_sector,mirror_pda->startSector)) { usemirror = 0; } else { usemirror = 1; } } if (usemirror) { /* use mirror (parity) disk, swap params 0 & 4 */ tmp_pda = data_pda; node->params[0].p = mirror_pda; node->params[4].p = tmp_pda; } else { /* use data disk, leave param 0 unchanged */ } /* printf("dataQueueLength %d, mirrorQueueLength %d\n",dataQueueLength, mirrorQueueLength); */ } /* * Do simple partitioning. This assumes that * the data and parity disks are laid out identically. */ void rf_SelectMirrorDiskPartition(RF_DagNode_t *node) { RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr; RF_RowCol_t rowData, colData, rowMirror, colMirror; RF_PhysDiskAddr_t *data_pda = (RF_PhysDiskAddr_t *)node->params[0].p; RF_PhysDiskAddr_t *mirror_pda = (RF_PhysDiskAddr_t *)node->params[4].p; RF_PhysDiskAddr_t *tmp_pda; RF_RaidDisk_t **disks = raidPtr->Disks; RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue; int usemirror; /* return the [row col] of the disk with the shortest queue */ rowData = data_pda->row; colData = data_pda->col; rowMirror = mirror_pda->row; colMirror = mirror_pda->col; dataQueue = &(dqs[rowData][colData]); mirrorQueue = &(dqs[rowMirror][colMirror]); usemirror = 0; if (RF_DEAD_DISK(disks[rowMirror][colMirror].status)) { usemirror = 0; } else if (RF_DEAD_DISK(disks[rowData][colData].status)) { usemirror = 1; } else if (data_pda->startSector < (disks[rowData][colData].numBlocks / 2)) { usemirror = 0; } else { usemirror = 1; } if (usemirror) { /* use mirror (parity) disk, swap params 0 & 4 */ tmp_pda = data_pda; node->params[0].p = mirror_pda; node->params[4].p = tmp_pda; } else { /* use data disk, leave param 0 unchanged */ } }