sync with NetBSD

- removed threadid stuff
- removed unused files
- general tidyup
- you can no longer configure the same unit twice (without
de-configuring first of course).

Again, this has only been tested locally on IDE disks. Further testing
and feedback would be appreciated.

1 files changed, 272 insertions, 152 deletions

diff --git a/sys/dev/raidframe/rf_paritylogging.c b/sys/dev/raidframe/rf_paritylogging.c
index 1c9b988d1c7..65877664637 100644
--- a/sys/dev/raidframe/rf_paritylogging.c
+++ b/sys/dev/raidframe/rf_paritylogging.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: rf_paritylogging.c,v 1.3 2000/01/07 14:50:22 peter Exp $	*/
-/*	$NetBSD: rf_paritylogging.c,v 1.4 2000/01/05 02:57:29 oster Exp $	*/
+/*	$OpenBSD: rf_paritylogging.c,v 1.4 2000/01/11 18:02:22 peter Exp $	*/
+/*	$NetBSD: rf_paritylogging.c,v 1.8 2000/01/09 04:35:13 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -45,7 +45,6 @@
 #include "rf_dagffwr.h"
 #include "rf_dagdegrd.h"
 #include "rf_dagdegwr.h"
-#include "rf_threadid.h"
 #include "rf_paritylog.h"
 #include "rf_paritylogDiskMgr.h"
 #include "rf_paritylogging.h"
@@ -82,6 +81,9 @@ rf_ConfigureParityLogging(
 	RF_ParityLog_t *l = NULL, *next;
 	caddr_t lHeapPtr;
 
+	if (rf_numParityRegions <= 0)
+		return(EINVAL);
+
 	/*
          * We create multiple entries on the shutdown list here, since
          * this configuration routine is fairly complicated in and of
@@ -92,7 +94,9 @@ rf_ConfigureParityLogging(
 	raidPtr->numSectorsPerLog = RF_DEFAULT_NUM_SECTORS_PER_LOG;
 
 	/* create a parity logging configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_ParityLoggingConfigInfo_t), (RF_ParityLoggingConfigInfo_t *), raidPtr->cleanupList);
+	RF_MallocAndAdd(info, sizeof(RF_ParityLoggingConfigInfo_t), 
+			(RF_ParityLoggingConfigInfo_t *), 
+			raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
@@ -101,14 +105,17 @@ rf_ConfigureParityLogging(
 
 	/* the stripe identifier must identify the disks in each stripe, IN
 	 * THE ORDER THAT THEY APPEAR IN THE STRIPE. */
-	info->stripeIdentifier = rf_make_2d_array((raidPtr->numCol), (raidPtr->numCol), raidPtr->cleanupList);
+	info->stripeIdentifier = rf_make_2d_array((raidPtr->numCol), 
+						  (raidPtr->numCol), 
+						  raidPtr->cleanupList);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
 
 	startdisk = 0;
 	for (i = 0; i < (raidPtr->numCol); i++) {
 		for (j = 0; j < (raidPtr->numCol); j++) {
-			info->stripeIdentifier[i][j] = (startdisk + j) % (raidPtr->numCol - 1);
+			info->stripeIdentifier[i][j] = (startdisk + j) % 
+				(raidPtr->numCol - 1);
 		}
 		if ((--startdisk) < 0)
 			startdisk = raidPtr->numCol - 1 - 1;
@@ -116,30 +123,40 @@ rf_ConfigureParityLogging(
 
 	/* fill in the remaining layout parameters */
 	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << 
+		raidPtr->logBytesPerSector;
 	layoutPtr->numParityCol = 1;
 	layoutPtr->numParityLogCol = 1;
-	layoutPtr->numDataCol = raidPtr->numCol - layoutPtr->numParityCol - layoutPtr->numParityLogCol;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->numDataCol = raidPtr->numCol - layoutPtr->numParityCol - 
+		layoutPtr->numParityLogCol;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * 
+		layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * 
+		layoutPtr->sectorsPerStripeUnit;
 
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * 
+		layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
 
 	/* configure parity log parameters
 	 * 
-	 * parameter               comment/constraints ----------------
-	 * ------------------- numParityRegions        all regions (except
-	 * possibly last) of equal size totalInCoreLogCapacity  amount of
-	 * memory in bytes available for in-core logs (default 1 MB) #
-	 * numSectorsPerLog        capacity of an in-core log in sectors (1
-	 * disk track) numParityLogs           total number of in-core logs,
-	 * should be at least numParityRegions regionLogCapacity       size of
-	 * a region log (except possibly last one) in sectors totalLogCapacity
-	 * total amount of log space in sectors
+	 * parameter               comment/constraints 
+	 * ------------------------------------------- 
+	 * numParityRegions*       all regions (except possibly last) 
+	 *                         of equal size 
+	 * totalInCoreLogCapacity* amount of memory in bytes available 
+	 *                         for in-core logs (default 1 MB) 
+	 * numSectorsPerLog#       capacity of an in-core log in sectors 
+	 *                         (1 * disk track)
+	 * numParityLogs           total number of in-core logs,
+	 *                         should be at least numParityRegions 
+	 * regionLogCapacity       size of a region log (except possibly 
+	 *                         last one) in sectors 
+	 * totalLogCapacity        total amount of log space in sectors
 	 * 
-	 * denotes a user settable parameter. # logs are fixed to be the size of
-	 * a disk track, value #defined in rf_paritylog.h
+	 * where '*' denotes a user settable parameter. 
+	 * Note that logs are fixed to be the size of a disk track, 
+	 * value #defined in rf_paritylog.h
 	 * 
 	 */
 
@@ -154,37 +171,51 @@ rf_ConfigureParityLogging(
 	fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
 	if (fragmentation > 0)
 		for (i = 1; i < (raidPtr->numSectorsPerLog / 2); i++) {
-			if (((totalLogCapacity / (rf_numParityRegions + i)) % raidPtr->numSectorsPerLog) < fragmentation) {
+			if (((totalLogCapacity / (rf_numParityRegions + i)) % 
+			     raidPtr->numSectorsPerLog) < fragmentation) {
 				rf_numParityRegions++;
-				raidPtr->regionLogCapacity = totalLogCapacity / rf_numParityRegions;
-				fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
+				raidPtr->regionLogCapacity = totalLogCapacity /
+					rf_numParityRegions;
+				fragmentation = raidPtr->regionLogCapacity % 
+					raidPtr->numSectorsPerLog;
 			}
-			if (((totalLogCapacity / (rf_numParityRegions - i)) % raidPtr->numSectorsPerLog) < fragmentation) {
+			if (((totalLogCapacity / (rf_numParityRegions - i)) % 
+			     raidPtr->numSectorsPerLog) < fragmentation) {
 				rf_numParityRegions--;
-				raidPtr->regionLogCapacity = totalLogCapacity / rf_numParityRegions;
-				fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
+				raidPtr->regionLogCapacity = totalLogCapacity /
+					rf_numParityRegions;
+				fragmentation = raidPtr->regionLogCapacity % 
+					raidPtr->numSectorsPerLog;
 			}
 		}
 	/* ensure integral number of regions per log */
-	raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity / raidPtr->numSectorsPerLog) * raidPtr->numSectorsPerLog;
+	raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity / 
+				      raidPtr->numSectorsPerLog) * 
+		raidPtr->numSectorsPerLog;
 
-	raidPtr->numParityLogs = rf_totalInCoreLogCapacity / (raidPtr->bytesPerSector * raidPtr->numSectorsPerLog);
+	raidPtr->numParityLogs = rf_totalInCoreLogCapacity / 
+		(raidPtr->bytesPerSector * raidPtr->numSectorsPerLog);
 	/* to avoid deadlock, must ensure that enough logs exist for each
 	 * region to have one simultaneously */
 	if (raidPtr->numParityLogs < rf_numParityRegions)
 		raidPtr->numParityLogs = rf_numParityRegions;
 
 	/* create region information structs */
-	RF_Malloc(raidPtr->regionInfo, (rf_numParityRegions * sizeof(RF_RegionInfo_t)), (RF_RegionInfo_t *));
+	RF_Malloc(raidPtr->regionInfo, 
+		  (rf_numParityRegions * sizeof(RF_RegionInfo_t)), 
+		  (RF_RegionInfo_t *));
 	if (raidPtr->regionInfo == NULL)
 		return (ENOMEM);
 
 	/* last region may not be full capacity */
 	lastRegionCapacity = raidPtr->regionLogCapacity;
-	while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity + lastRegionCapacity > totalLogCapacity)
-		lastRegionCapacity = lastRegionCapacity - raidPtr->numSectorsPerLog;
+	while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity + 
+	       lastRegionCapacity > totalLogCapacity)
+		lastRegionCapacity = lastRegionCapacity - 
+			raidPtr->numSectorsPerLog;
 
-	raidPtr->regionParityRange = raidPtr->sectorsPerDisk / rf_numParityRegions;
+	raidPtr->regionParityRange = raidPtr->sectorsPerDisk / 
+		rf_numParityRegions;
 	maxRegionParityRange = raidPtr->regionParityRange;
 
 /* i can't remember why this line is in the code -wvcii 6/30/95 */
@@ -192,30 +223,43 @@ rf_ConfigureParityLogging(
     regionParityRange++; */
 
 	/* build pool of unused parity logs */
-	RF_Malloc(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector, (caddr_t));
+	RF_Malloc(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
+		  raidPtr->numSectorsPerLog * raidPtr->bytesPerSector, 
+		  (caddr_t));
 	if (raidPtr->parityLogBufferHeap == NULL)
 		return (ENOMEM);
 	lHeapPtr = raidPtr->parityLogBufferHeap;
 	rc = rf_mutex_init(&raidPtr->parityLogPool.mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
-		RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
+		RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
+			raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
 		return (ENOMEM);
 	}
 	for (i = 0; i < raidPtr->numParityLogs; i++) {
 		if (i == 0) {
-			RF_Calloc(raidPtr->parityLogPool.parityLogs, 1, sizeof(RF_ParityLog_t), (RF_ParityLog_t *));
+			RF_Calloc(raidPtr->parityLogPool.parityLogs, 1, 
+				  sizeof(RF_ParityLog_t), (RF_ParityLog_t *));
 			if (raidPtr->parityLogPool.parityLogs == NULL) {
-				RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
+				RF_Free(raidPtr->parityLogBufferHeap, 
+					raidPtr->numParityLogs * 
+					raidPtr->numSectorsPerLog * 
+					raidPtr->bytesPerSector);
 				return (ENOMEM);
 			}
 			l = raidPtr->parityLogPool.parityLogs;
 		} else {
-			RF_Calloc(l->next, 1, sizeof(RF_ParityLog_t), (RF_ParityLog_t *));
+			RF_Calloc(l->next, 1, sizeof(RF_ParityLog_t), 
+				  (RF_ParityLog_t *));
 			if (l->next == NULL) {
-				RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
-				for (l = raidPtr->parityLogPool.parityLogs; l; l = next) {
+				RF_Free(raidPtr->parityLogBufferHeap, 
+					raidPtr->numParityLogs * 
+					raidPtr->numSectorsPerLog * 
+					raidPtr->bytesPerSector);
+				for (l = raidPtr->parityLogPool.parityLogs; 
+				     l;
+				     l = next) {
 					next = l->next;
 					if (l->records)
 						RF_Free(l->records, (raidPtr->numSectorsPerLog * sizeof(RF_ParityLogRecord_t)));
@@ -226,14 +270,24 @@ rf_ConfigureParityLogging(
 			l = l->next;
 		}
 		l->bufPtr = lHeapPtr;
-		lHeapPtr += raidPtr->numSectorsPerLog * raidPtr->bytesPerSector;
-		RF_Malloc(l->records, (raidPtr->numSectorsPerLog * sizeof(RF_ParityLogRecord_t)), (RF_ParityLogRecord_t *));
+		lHeapPtr += raidPtr->numSectorsPerLog * 
+			raidPtr->bytesPerSector;
+		RF_Malloc(l->records, (raidPtr->numSectorsPerLog * 
+				       sizeof(RF_ParityLogRecord_t)), 
+			  (RF_ParityLogRecord_t *));
 		if (l->records == NULL) {
-			RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
-			for (l = raidPtr->parityLogPool.parityLogs; l; l = next) {
+			RF_Free(raidPtr->parityLogBufferHeap, 
+				raidPtr->numParityLogs * 
+				raidPtr->numSectorsPerLog * 
+				raidPtr->bytesPerSector);
+			for (l = raidPtr->parityLogPool.parityLogs; 
+			     l; 
+			     l = next) {
 				next = l->next;
 				if (l->records)
-					RF_Free(l->records, (raidPtr->numSectorsPerLog * sizeof(RF_ParityLogRecord_t)));
+					RF_Free(l->records, 
+						(raidPtr->numSectorsPerLog * 
+						 sizeof(RF_ParityLogRecord_t)));
 				RF_Free(l, sizeof(RF_ParityLog_t));
 			}
 			return (ENOMEM);
@@ -249,46 +303,60 @@ rf_ConfigureParityLogging(
 	/* build pool of region buffers */
 	rc = rf_mutex_init(&raidPtr->regionBufferPool.mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
 		return (ENOMEM);
 	}
 	rc = rf_cond_init(&raidPtr->regionBufferPool.cond);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
 		rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
 		return (ENOMEM);
 	}
-	raidPtr->regionBufferPool.bufferSize = raidPtr->regionLogCapacity * raidPtr->bytesPerSector;
-	printf("regionBufferPool.bufferSize %d\n", raidPtr->regionBufferPool.bufferSize);
-	raidPtr->regionBufferPool.totalBuffers = 1;	/* for now, only one
-							 * region at a time may
-							 * be reintegrated */
-	raidPtr->regionBufferPool.availableBuffers = raidPtr->regionBufferPool.totalBuffers;
+	raidPtr->regionBufferPool.bufferSize = raidPtr->regionLogCapacity * 
+		raidPtr->bytesPerSector;
+	printf("regionBufferPool.bufferSize %d\n", 
+	       raidPtr->regionBufferPool.bufferSize);
+
+	/* for now, only one region at a time may be reintegrated */
+	raidPtr->regionBufferPool.totalBuffers = 1;	
+
+	raidPtr->regionBufferPool.availableBuffers = 
+		raidPtr->regionBufferPool.totalBuffers;
 	raidPtr->regionBufferPool.availBuffersIndex = 0;
 	raidPtr->regionBufferPool.emptyBuffersIndex = 0;
-	RF_Malloc(raidPtr->regionBufferPool.buffers, raidPtr->regionBufferPool.totalBuffers * sizeof(caddr_t), (caddr_t *));
+	RF_Malloc(raidPtr->regionBufferPool.buffers, 
+		  raidPtr->regionBufferPool.totalBuffers * sizeof(caddr_t), 
+		  (caddr_t *));
 	if (raidPtr->regionBufferPool.buffers == NULL) {
 		rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
 		rf_cond_destroy(&raidPtr->regionBufferPool.cond);
 		return (ENOMEM);
 	}
 	for (i = 0; i < raidPtr->regionBufferPool.totalBuffers; i++) {
-		RF_Malloc(raidPtr->regionBufferPool.buffers[i], raidPtr->regionBufferPool.bufferSize * sizeof(char), (caddr_t));
-		if (raidPtr->regionBufferPool.buffers == NULL) {
+		RF_Malloc(raidPtr->regionBufferPool.buffers[i], 
+			  raidPtr->regionBufferPool.bufferSize * sizeof(char),
+			  (caddr_t));
+		if (raidPtr->regionBufferPool.buffers[i] == NULL) {
 			rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
 			rf_cond_destroy(&raidPtr->regionBufferPool.cond);
 			for (j = 0; j < i; j++) {
-				RF_Free(raidPtr->regionBufferPool.buffers[i], raidPtr->regionBufferPool.bufferSize * sizeof(char));
+				RF_Free(raidPtr->regionBufferPool.buffers[i], 
+					raidPtr->regionBufferPool.bufferSize *
+					sizeof(char));
 			}
-			RF_Free(raidPtr->regionBufferPool.buffers, raidPtr->regionBufferPool.totalBuffers * sizeof(caddr_t));
+			RF_Free(raidPtr->regionBufferPool.buffers, 
+				raidPtr->regionBufferPool.totalBuffers * 
+				sizeof(caddr_t));
 			return (ENOMEM);
 		}
 		printf("raidPtr->regionBufferPool.buffers[%d] = %lx\n", i,
 		    (long) raidPtr->regionBufferPool.buffers[i]);
 	}
-	rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingRegionBufferPool, raidPtr);
+	rc = rf_ShutdownCreate(listp, 
+			       rf_ShutdownParityLoggingRegionBufferPool,
+			       raidPtr);
 	if (rc) {
 		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
 		    __LINE__, rc);
@@ -299,46 +367,60 @@ rf_ConfigureParityLogging(
 	parityBufferCapacity = maxRegionParityRange;
 	rc = rf_mutex_init(&raidPtr->parityBufferPool.mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
 		return (rc);
 	}
 	rc = rf_cond_init(&raidPtr->parityBufferPool.cond);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
 		rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
 		return (ENOMEM);
 	}
-	raidPtr->parityBufferPool.bufferSize = parityBufferCapacity * raidPtr->bytesPerSector;
-	printf("parityBufferPool.bufferSize %d\n", raidPtr->parityBufferPool.bufferSize);
-	raidPtr->parityBufferPool.totalBuffers = 1;	/* for now, only one
-							 * region at a time may
-							 * be reintegrated */
-	raidPtr->parityBufferPool.availableBuffers = raidPtr->parityBufferPool.totalBuffers;
+	raidPtr->parityBufferPool.bufferSize = parityBufferCapacity * 
+		raidPtr->bytesPerSector;
+	printf("parityBufferPool.bufferSize %d\n", 
+	       raidPtr->parityBufferPool.bufferSize);
+
+	/* for now, only one region at a time may be reintegrated */
+	raidPtr->parityBufferPool.totalBuffers = 1;	
+
+	raidPtr->parityBufferPool.availableBuffers = 
+		raidPtr->parityBufferPool.totalBuffers;
 	raidPtr->parityBufferPool.availBuffersIndex = 0;
 	raidPtr->parityBufferPool.emptyBuffersIndex = 0;
-	RF_Malloc(raidPtr->parityBufferPool.buffers, raidPtr->parityBufferPool.totalBuffers * sizeof(caddr_t), (caddr_t *));
+	RF_Malloc(raidPtr->parityBufferPool.buffers, 
+		  raidPtr->parityBufferPool.totalBuffers * sizeof(caddr_t), 
+		  (caddr_t *));
 	if (raidPtr->parityBufferPool.buffers == NULL) {
 		rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
 		rf_cond_destroy(&raidPtr->parityBufferPool.cond);
 		return (ENOMEM);
 	}
 	for (i = 0; i < raidPtr->parityBufferPool.totalBuffers; i++) {
-		RF_Malloc(raidPtr->parityBufferPool.buffers[i], raidPtr->parityBufferPool.bufferSize * sizeof(char), (caddr_t));
+		RF_Malloc(raidPtr->parityBufferPool.buffers[i], 
+			  raidPtr->parityBufferPool.bufferSize * sizeof(char),
+			  (caddr_t));
 		if (raidPtr->parityBufferPool.buffers == NULL) {
 			rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
 			rf_cond_destroy(&raidPtr->parityBufferPool.cond);
 			for (j = 0; j < i; j++) {
-				RF_Free(raidPtr->parityBufferPool.buffers[i], raidPtr->regionBufferPool.bufferSize * sizeof(char));
+				RF_Free(raidPtr->parityBufferPool.buffers[i], 
+					raidPtr->regionBufferPool.bufferSize * 
+					sizeof(char));
 			}
-			RF_Free(raidPtr->parityBufferPool.buffers, raidPtr->regionBufferPool.totalBuffers * sizeof(caddr_t));
+			RF_Free(raidPtr->parityBufferPool.buffers, 
+				raidPtr->regionBufferPool.totalBuffers * 
+				sizeof(caddr_t));
 			return (ENOMEM);
 		}
 		printf("parityBufferPool.buffers[%d] = %lx\n", i,
 		    (long) raidPtr->parityBufferPool.buffers[i]);
 	}
-	rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingParityBufferPool, raidPtr);
+	rc = rf_ShutdownCreate(listp, 
+			       rf_ShutdownParityLoggingParityBufferPool, 
+			       raidPtr);
 	if (rc) {
 		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
 		    __LINE__, rc);
@@ -346,16 +428,17 @@ rf_ConfigureParityLogging(
 		return (rc);
 	}
 	/* initialize parityLogDiskQueue */
-	rc = rf_create_managed_mutex(listp, &raidPtr->parityLogDiskQueue.mutex);
+	rc = rf_create_managed_mutex(listp, 
+				     &raidPtr->parityLogDiskQueue.mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
 		return (rc);
 	}
 	rc = rf_create_managed_cond(listp, &raidPtr->parityLogDiskQueue.cond);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", 
+			     __FILE__, __LINE__, rc);
 		return (rc);
 	}
 	raidPtr->parityLogDiskQueue.flushQueue = NULL;
@@ -371,7 +454,9 @@ rf_ConfigureParityLogging(
 	raidPtr->parityLogDiskQueue.freeDataList = NULL;
 	raidPtr->parityLogDiskQueue.freeCommonList = NULL;
 
-	rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingDiskQueue, raidPtr);
+	rc = rf_ShutdownCreate(listp, 
+			       rf_ShutdownParityLoggingDiskQueue, 
+			       raidPtr);
 	if (rc) {
 		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
 		    __LINE__, rc);
@@ -384,7 +469,9 @@ rf_ConfigureParityLogging(
 			    __LINE__, rc);
 			for (j = 0; j < i; j++)
 				FreeRegionInfo(raidPtr, j);
-			RF_Free(raidPtr->regionInfo, (rf_numParityRegions * sizeof(RF_RegionInfo_t)));
+			RF_Free(raidPtr->regionInfo, 
+				(rf_numParityRegions * 
+				 sizeof(RF_RegionInfo_t)));
 			return (ENOMEM);
 		}
 		rc = rf_mutex_init(&raidPtr->regionInfo[i].reintMutex);
@@ -394,37 +481,59 @@ rf_ConfigureParityLogging(
 			rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
 			for (j = 0; j < i; j++)
 				FreeRegionInfo(raidPtr, j);
-			RF_Free(raidPtr->regionInfo, (rf_numParityRegions * sizeof(RF_RegionInfo_t)));
+			RF_Free(raidPtr->regionInfo, 
+				(rf_numParityRegions * 
+				 sizeof(RF_RegionInfo_t)));
 			return (ENOMEM);
 		}
 		raidPtr->regionInfo[i].reintInProgress = RF_FALSE;
-		raidPtr->regionInfo[i].regionStartAddr = raidPtr->regionLogCapacity * i;
-		raidPtr->regionInfo[i].parityStartAddr = raidPtr->regionParityRange * i;
+		raidPtr->regionInfo[i].regionStartAddr = 
+			raidPtr->regionLogCapacity * i;
+		raidPtr->regionInfo[i].parityStartAddr = 
+			raidPtr->regionParityRange * i;
 		if (i < rf_numParityRegions - 1) {
-			raidPtr->regionInfo[i].capacity = raidPtr->regionLogCapacity;
-			raidPtr->regionInfo[i].numSectorsParity = raidPtr->regionParityRange;
+			raidPtr->regionInfo[i].capacity = 
+				raidPtr->regionLogCapacity;
+			raidPtr->regionInfo[i].numSectorsParity = 
+				raidPtr->regionParityRange;
 		} else {
-			raidPtr->regionInfo[i].capacity = lastRegionCapacity;
-			raidPtr->regionInfo[i].numSectorsParity = raidPtr->sectorsPerDisk - raidPtr->regionParityRange * i;
-			if (raidPtr->regionInfo[i].numSectorsParity > maxRegionParityRange)
-				maxRegionParityRange = raidPtr->regionInfo[i].numSectorsParity;
+			raidPtr->regionInfo[i].capacity = 
+				lastRegionCapacity;
+			raidPtr->regionInfo[i].numSectorsParity = 
+				raidPtr->sectorsPerDisk - 
+				raidPtr->regionParityRange * i;
+			if (raidPtr->regionInfo[i].numSectorsParity > 
+			    maxRegionParityRange)
+				maxRegionParityRange = 
+					raidPtr->regionInfo[i].numSectorsParity;
 		}
 		raidPtr->regionInfo[i].diskCount = 0;
-		RF_ASSERT(raidPtr->regionInfo[i].capacity + raidPtr->regionInfo[i].regionStartAddr <= totalLogCapacity);
-		RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr + raidPtr->regionInfo[i].numSectorsParity <= raidPtr->sectorsPerDisk);
-		RF_Malloc(raidPtr->regionInfo[i].diskMap, (raidPtr->regionInfo[i].capacity * sizeof(RF_DiskMap_t)), (RF_DiskMap_t *));
+		RF_ASSERT(raidPtr->regionInfo[i].capacity + 
+			  raidPtr->regionInfo[i].regionStartAddr <= 
+			  totalLogCapacity);
+		RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr + 
+			  raidPtr->regionInfo[i].numSectorsParity <= 
+			  raidPtr->sectorsPerDisk);
+		RF_Malloc(raidPtr->regionInfo[i].diskMap, 
+			  (raidPtr->regionInfo[i].capacity *
+			   sizeof(RF_DiskMap_t)), 
+			  (RF_DiskMap_t *));
 		if (raidPtr->regionInfo[i].diskMap == NULL) {
 			rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
 			rf_mutex_destroy(&raidPtr->regionInfo[i].reintMutex);
 			for (j = 0; j < i; j++)
 				FreeRegionInfo(raidPtr, j);
-			RF_Free(raidPtr->regionInfo, (rf_numParityRegions * sizeof(RF_RegionInfo_t)));
+			RF_Free(raidPtr->regionInfo, 
+				(rf_numParityRegions * 
+				 sizeof(RF_RegionInfo_t)));
 			return (ENOMEM);
 		}
 		raidPtr->regionInfo[i].loggingEnabled = RF_FALSE;
 		raidPtr->regionInfo[i].coreLog = NULL;
 	}
-	rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingRegionInfo, raidPtr);
+	rc = rf_ShutdownCreate(listp,
+			       rf_ShutdownParityLoggingRegionInfo, 
+			       raidPtr);
 	if (rc) {
 		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
 		    __LINE__, rc);
@@ -433,7 +542,8 @@ rf_ConfigureParityLogging(
 	}
 	RF_ASSERT(raidPtr->parityLogDiskQueue.threadState == 0);
 	raidPtr->parityLogDiskQueue.threadState = RF_PLOG_CREATED;
-	rc = RF_CREATE_THREAD(raidPtr->pLogDiskThreadHandle, rf_ParityLoggingDiskManager, raidPtr,"rf_log");
+	rc = RF_CREATE_THREAD(raidPtr->pLogDiskThreadHandle, 
+			      rf_ParityLoggingDiskManager, raidPtr,"rf_log");
 	if (rc) {
 		raidPtr->parityLogDiskQueue.threadState = 0;
 		RF_ERRORMSG3("Unable to create parity logging disk thread file %s line %d rc=%d\n",
@@ -443,7 +553,8 @@ rf_ConfigureParityLogging(
 	/* wait for thread to start */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
-		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, raidPtr->parityLogDiskQueue.mutex);
+		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, 
+			     raidPtr->parityLogDiskQueue.mutex);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 
@@ -474,9 +585,12 @@ FreeRegionInfo(
     RF_RegionId_t regionID)
 {
 	RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-	RF_Free(raidPtr->regionInfo[regionID].diskMap, (raidPtr->regionInfo[regionID].capacity * sizeof(RF_DiskMap_t)));
+	RF_Free(raidPtr->regionInfo[regionID].diskMap, 
+		(raidPtr->regionInfo[regionID].capacity * 
+		 sizeof(RF_DiskMap_t)));
 	if (!rf_forceParityLogReint && raidPtr->regionInfo[regionID].coreLog) {
-		rf_ReleaseParityLogs(raidPtr, raidPtr->regionInfo[regionID].coreLog);
+		rf_ReleaseParityLogs(raidPtr, 
+				     raidPtr->regionInfo[regionID].coreLog);
 		raidPtr->regionInfo[regionID].coreLog = NULL;
 	} else {
 		RF_ASSERT(raidPtr->regionInfo[regionID].coreLog == NULL);
@@ -500,7 +614,8 @@ FreeParityLogQueue(
 	while (l1) {
 		l2 = l1;
 		l1 = l2->next;
-		RF_Free(l2->records, (raidPtr->numSectorsPerLog * sizeof(RF_ParityLogRecord_t)));
+		RF_Free(l2->records, (raidPtr->numSectorsPerLog * 
+				      sizeof(RF_ParityLogRecord_t)));
 		RF_Free(l2, sizeof(RF_ParityLog_t));
 	}
 	RF_UNLOCK_MUTEX(queue->mutex);
@@ -533,14 +648,14 @@ rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLoggingRegionInfo\n", tid);
+		printf("raid%d: ShutdownParityLoggingRegionInfo\n", 
+		       raidPtr->raidid);
 	}
 	/* free region information structs */
 	for (i = 0; i < rf_numParityRegions; i++)
 		FreeRegionInfo(raidPtr, i);
-	RF_Free(raidPtr->regionInfo, (rf_numParityRegions * sizeof(raidPtr->regionInfo)));
+	RF_Free(raidPtr->regionInfo, (rf_numParityRegions * 
+				      sizeof(raidPtr->regionInfo)));
 	raidPtr->regionInfo = NULL;
 }
 
@@ -551,13 +666,12 @@ rf_ShutdownParityLoggingPool(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLoggingPool\n", tid);
+		printf("raid%d: ShutdownParityLoggingPool\n", raidPtr->raidid);
 	}
 	/* free contents of parityLogPool */
 	FreeParityLogQueue(raidPtr, &raidPtr->parityLogPool);
-	RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
+	RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
+		raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
 }
 
 static void 
@@ -567,9 +681,8 @@ rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLoggingRegionBufferPool\n", tid);
+		printf("raid%d: ShutdownParityLoggingRegionBufferPool\n", 
+		       raidPtr->raidid);
 	}
 	FreeRegionBufferQueue(&raidPtr->regionBufferPool);
 }
@@ -581,9 +694,8 @@ rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLoggingParityBufferPool\n", tid);
+		printf("raid%d: ShutdownParityLoggingParityBufferPool\n",
+		       raidPtr->raidid);
 	}
 	FreeRegionBufferQueue(&raidPtr->parityBufferPool);
 }
@@ -597,9 +709,8 @@ rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLoggingDiskQueue\n", tid);
+		printf("raid%d: ShutdownParityLoggingDiskQueue\n",
+		       raidPtr->raidid);
 	}
 	/* free disk manager stuff */
 	RF_ASSERT(raidPtr->parityLogDiskQueue.bufHead == NULL);
@@ -608,13 +719,15 @@ rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg)
 	RF_ASSERT(raidPtr->parityLogDiskQueue.reintTail == NULL);
 	while (raidPtr->parityLogDiskQueue.freeDataList) {
 		d = raidPtr->parityLogDiskQueue.freeDataList;
-		raidPtr->parityLogDiskQueue.freeDataList = raidPtr->parityLogDiskQueue.freeDataList->next;
+		raidPtr->parityLogDiskQueue.freeDataList = 
+			raidPtr->parityLogDiskQueue.freeDataList->next;
 		RF_Free(d, sizeof(RF_ParityLogData_t));
 	}
 	while (raidPtr->parityLogDiskQueue.freeCommonList) {
 		c = raidPtr->parityLogDiskQueue.freeCommonList;
 		rf_mutex_destroy(&c->mutex);
-		raidPtr->parityLogDiskQueue.freeCommonList = raidPtr->parityLogDiskQueue.freeCommonList->next;
+		raidPtr->parityLogDiskQueue.freeCommonList = 
+			raidPtr->parityLogDiskQueue.freeCommonList->next;
 		RF_Free(c, sizeof(RF_CommonLogData_t));
 	}
 }
@@ -626,9 +739,7 @@ rf_ShutdownParityLogging(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLogging\n", tid);
+		printf("raid%d: ShutdownParityLogging\n", raidPtr->raidid);
 	}
 	/* shutdown disk thread */
 	/* This has the desirable side-effect of forcing all regions to be
@@ -645,13 +756,12 @@ rf_ShutdownParityLogging(RF_ThreadArg_t arg)
          */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
-		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, raidPtr->parityLogDiskQueue.mutex);
+		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, 
+			     raidPtr->parityLogDiskQueue.mutex);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	if (rf_parityLogDebug) {
-		int     tid;
-		rf_get_threadid(tid);
-		printf("[%d] ShutdownParityLogging done (thread completed)\n", tid);
+		printf("raid%d: ShutdownParityLogging done (thread completed)\n", raidPtr->raidid);
 	}
 }
 
@@ -681,7 +791,8 @@ rf_MapRegionIDParityLogging(
 		regionID--;
 	}
 	RF_ASSERT(address >= raidPtr->regionInfo[regionID].parityStartAddr);
-	RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr + raidPtr->regionInfo[regionID].numSectorsParity);
+	RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr + 
+		  raidPtr->regionInfo[regionID].numSectorsParity);
 	RF_ASSERT(regionID < rf_numParityRegions);
 	return (regionID);
 }
@@ -697,12 +808,14 @@ rf_MapSectorParityLogging(
     RF_SectorNum_t * diskSector,
     int remap)
 {
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
+	RF_StripeNum_t SUID = raidSector / 
+		raidPtr->Layout.sectorsPerStripeUnit;
 	*row = 0;
 	/* *col = (SUID % (raidPtr->numCol -
 	 * raidPtr->Layout.numParityLogCol)); */
 	*col = SUID % raidPtr->Layout.numDataCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * 
+		raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
@@ -717,14 +830,16 @@ rf_MapParityParityLogging(
     RF_SectorNum_t * diskSector,
     int remap)
 {
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
+	RF_StripeNum_t SUID = raidSector / 
+		raidPtr->Layout.sectorsPerStripeUnit;
 
 	*row = 0;
 	/* *col =
 	 * raidPtr->Layout.numDataCol-(SUID/raidPtr->Layout.numDataCol)%(raidPt
 	 * r->numCol - raidPtr->Layout.numParityLogCol); */
 	*col = raidPtr->Layout.numDataCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * 
+		raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
@@ -745,7 +860,8 @@ rf_MapLogParityLogging(
 }
 
 
-/* given a regionID, determine the physical disk address of the logged parity for that region */
+/* given a regionID, determine the physical disk address of the logged
+   parity for that region */
 void 
 rf_MapRegionParity(
     RF_Raid_t * raidPtr,
@@ -762,7 +878,8 @@ rf_MapRegionParity(
 }
 
 
-/* given a logical RAID address, determine the participating disks in the stripe */
+/* given a logical RAID address, determine the participating disks in
+   the stripe */
 void 
 rf_IdentifyStripeParityLogging(
     RF_Raid_t * raidPtr,
@@ -770,8 +887,10 @@ rf_IdentifyStripeParityLogging(
     RF_RowCol_t ** diskids,
     RF_RowCol_t * outRow)
 {
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
-	RF_ParityLoggingConfigInfo_t *info = (RF_ParityLoggingConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, 
+							   addr);
+	RF_ParityLoggingConfigInfo_t *info = (RF_ParityLoggingConfigInfo_t *) 
+		raidPtr->Layout.layoutSpecificInfo;
 	*outRow = 0;
 	*diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
 }
@@ -805,7 +924,6 @@ rf_ParityLoggingDagSelect(
 	RF_RowCol_t frow, fcol;
 	RF_RowStatus_t rstat;
 	int     prior_recon;
-	int     tid;
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 
@@ -830,8 +948,9 @@ rf_ParityLoggingDagSelect(
 			if (prior_recon) {
 				RF_RowCol_t or = failedPDA->row, oc = failedPDA->col;
 				RF_SectorNum_t oo = failedPDA->startSector;
-				if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {	/* redirect to dist
-											 * spare space */
+				if (layoutPtr->map->flags & 
+				    RF_DISTRIBUTE_SPARE) {	
+					/* redirect to dist spare space */
 
 					if (failedPDA == asmp->parityInfo) {
 
@@ -862,8 +981,8 @@ rf_ParityLoggingDagSelect(
 
 						}
 
-				} else {	/* redirect to dedicated spare
-						 * space */
+				} else {	
+					/* redirect to dedicated spare space */
 
 					failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
 					failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
@@ -876,8 +995,7 @@ rf_ParityLoggingDagSelect(
 							failedPDA->next->row = failedPDA->row;
 							failedPDA->next->col = failedPDA->col;
 						} else
-							if (failedPDA == asmp->parityInfo->next) {	/* paranoid:  should
-													 * never occur */
+							if (failedPDA == asmp->parityInfo->next) {	/* paranoid:  should never occur */
 								asmp->parityInfo->row = failedPDA->row;
 								asmp->parityInfo->col = failedPDA->col;
 							}
@@ -887,9 +1005,8 @@ rf_ParityLoggingDagSelect(
 				RF_ASSERT(failedPDA->col != -1);
 
 				if (rf_dagDebug || rf_mapDebug) {
-					rf_get_threadid(tid);
-					printf("[%d] Redirected type '%c' r %d c %d o %ld -> r %d c %d o %ld\n",
-					    tid, type, or, oc, (long) oo, failedPDA->row, failedPDA->col, (long) failedPDA->startSector);
+					printf("raid%d: Redirected type '%c' r %d c %d o %ld -> r %d c %d o %ld\n",
+					    raidPtr->raidid, type, or, oc, (long) oo, failedPDA->row, failedPDA->col, (long) failedPDA->startSector);
 				}
 				asmp->numDataFailed = asmp->numParityFailed = 0;
 			}
@@ -913,8 +1030,11 @@ rf_ParityLoggingDagSelect(
 		 * when G is 3 or 4, numDataCol/2 is 1, and I want
 		 * single-stripe-unit updates to use just one disk. */
 		if ((asmp->numDataFailed + asmp->numParityFailed) == 0) {
-			if (((asmp->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) && (layoutPtr->numDataCol != 1)) ||
-			    (asmp->parityInfo->next != NULL) || rf_CheckStripeForFailures(raidPtr, asmp)) {
+			if (((asmp->numStripeUnitsAccessed <= 
+			      (layoutPtr->numDataCol / 2)) && 
+			     (layoutPtr->numDataCol != 1)) ||
+			    (asmp->parityInfo->next != NULL) || 
+			    rf_CheckStripeForFailures(raidPtr, asmp)) {
 				*createFunc = (RF_VoidFuncPtr) rf_CreateParityLoggingSmallWriteDAG;
 			} else
 				*createFunc = (RF_VoidFuncPtr) rf_CreateParityLoggingLargeWriteDAG;