Major KNF. Incentive from Tedu

137 files changed, 19383 insertions, 15494 deletions

diff --git a/sys/dev/raidframe/TODO b/sys/dev/raidframe/TODO
new file mode 100644
index 00000000000..234a9aca17d
--- /dev/null
+++ b/sys/dev/raidframe/TODO
@@ -0,0 +1,11 @@
+rf_debugprint.c -- redesign to use real circular queue
+Dprintf -- use the 'DPRINTF((...));' form like in FW stuff
+rf_freelist.h -- get rid of those macro usage !!!
+
+rf_driver.c
+rf_memchunk.c
+rf_openbsdkintf.c
+rf_revent.c
+rf_states.c
+rf_threadstuff.c
+
diff --git a/sys/dev/raidframe/rf_acctrace.c b/sys/dev/raidframe/rf_acctrace.c
index c570fce74e8..d95b47c5e61 100644
--- a/sys/dev/raidframe/rf_acctrace.c
+++ b/sys/dev/raidframe/rf_acctrace.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_acctrace.c,v 1.3 2000/01/07 14:50:19 peter Exp $	*/
+/*	$OpenBSD: rf_acctrace.c,v 1.4 2002/12/16 07:01:02 tdeval Exp $	*/
 /*	$NetBSD: rf_acctrace.c,v 1.4 1999/08/13 03:41:52 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,7 +30,7 @@
 
 /*****************************************************************************
  *
- * acctrace.c -- code to support collecting information about each access
+ * acctrace.c -- Code to support collecting information about each access.
  *
  *****************************************************************************/
 
@@ -52,77 +53,84 @@ static int accessTraceBufCount = 0;
 static RF_AccTraceEntry_t *access_tracebuf;
 static long traceCount;
 
-int     rf_stopCollectingTraces;
-RF_DECLARE_MUTEX(rf_tracing_mutex)
-	int     rf_trace_fd;
+int	rf_stopCollectingTraces;
+RF_DECLARE_MUTEX(rf_tracing_mutex);
+int	rf_trace_fd;
 
-	static void rf_ShutdownAccessTrace(void *);
+void rf_ShutdownAccessTrace(void *);
 
-	static void rf_ShutdownAccessTrace(ignored)
-	void   *ignored;
+void
+rf_ShutdownAccessTrace(void *ignored)
 {
 	if (rf_accessTraceBufSize) {
 		if (accessTraceBufCount)
 			rf_FlushAccessTraceBuf();
-		RF_Free(access_tracebuf, rf_accessTraceBufSize * sizeof(RF_AccTraceEntry_t));
+		RF_Free(access_tracebuf, rf_accessTraceBufSize *
+		    sizeof(RF_AccTraceEntry_t));
 	}
 	rf_mutex_destroy(&rf_tracing_mutex);
 }
 
-int 
-rf_ConfigureAccessTrace(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureAccessTrace(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	numTracesSoFar = accessTraceBufCount = rf_stopCollectingTraces = 0;
 	if (rf_accessTraceBufSize) {
-		RF_Malloc(access_tracebuf, rf_accessTraceBufSize * sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
+		RF_Malloc(access_tracebuf, rf_accessTraceBufSize *
+		    sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
 		accessTraceBufCount = 0;
 	}
 	traceCount = 0;
 	numTracesSoFar = 0;
 	rc = rf_mutex_init(&rf_tracing_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);
 	}
 	rc = rf_ShutdownCreate(listp, rf_ShutdownAccessTrace, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		if (rf_accessTraceBufSize) {
-			RF_Free(access_tracebuf, rf_accessTraceBufSize * sizeof(RF_AccTraceEntry_t));
+			RF_Free(access_tracebuf, rf_accessTraceBufSize *
+			    sizeof(RF_AccTraceEntry_t));
 			rf_mutex_destroy(&rf_tracing_mutex);
 		}
 	}
 	return (rc);
 }
-/* install a trace record.  cause a flush to disk or to the trace collector daemon
- * if the trace buffer is at least 1/2 full.
+
+/*
+ * Install a trace record. Cause a flush to disk or to the trace collector
+ * daemon if the trace buffer is at least 1/2 full.
  */
-void 
-rf_LogTraceRec(raid, rec)
-	RF_Raid_t *raid;
-	RF_AccTraceEntry_t *rec;
+void
+rf_LogTraceRec(RF_Raid_t *raid, RF_AccTraceEntry_t *rec)
 {
 	RF_AccTotals_t *acc = &raid->acc_totals;
 #if 0
 	RF_Etimer_t timer;
-	int     i, n;
+	int	i, n;
 #endif
 
-	if (rf_stopCollectingTraces || ((rf_maxNumTraces >= 0) && (numTracesSoFar >= rf_maxNumTraces)))
+	if (rf_stopCollectingTraces || ((rf_maxNumTraces >= 0) &&
+	    (numTracesSoFar >= rf_maxNumTraces)))
 		return;
 
-	/* update AccTotals for this device */
+	/* Update AccTotals for this device. */
 	if (!raid->keep_acc_totals)
 		return;
+
 	acc->num_log_ents++;
 	if (rec->reconacc) {
-		acc->recon_start_to_fetch_us += rec->specific.recon.recon_start_to_fetch_us;
-		acc->recon_fetch_to_return_us += rec->specific.recon.recon_fetch_to_return_us;
-		acc->recon_return_to_submit_us += rec->specific.recon.recon_return_to_submit_us;
+		acc->recon_start_to_fetch_us +=
+		    rec->specific.recon.recon_start_to_fetch_us;
+		acc->recon_fetch_to_return_us +=
+		    rec->specific.recon.recon_fetch_to_return_us;
+		acc->recon_return_to_submit_us +=
+		    rec->specific.recon.recon_return_to_submit_us;
 		acc->recon_num_phys_ios += rec->num_phys_ios;
 		acc->recon_phys_io_us += rec->phys_io_us;
 		acc->recon_diskwait_us += rec->diskwait_us;
@@ -130,11 +138,15 @@ rf_LogTraceRec(raid, rec)
 	} else {
 		RF_HIST_ADD(acc->tot_hist, rec->total_us);
 		RF_HIST_ADD(acc->dw_hist, rec->diskwait_us);
-		/* count of physical ios which are too big.  often due to
-		 * thermal recalibration */
-		/* if bigvals > 0, you should probably ignore this data set */
+		/*
+		 * Count of physical IOs that are too big. (often due to
+		 * thermal recalibration)
+		 *
+		 * If bigvals > 0, you should probably ignore this data set.
+		 */
 		if (rec->diskwait_us > 100000)
 			acc->bigvals++;
+
 		acc->total_us += rec->total_us;
 		acc->suspend_ovhd_us += rec->specific.user.suspend_ovhd_us;
 		acc->map_us += rec->specific.user.map_us;
@@ -156,12 +168,13 @@ rf_LogTraceRec(raid, rec)
 }
 
 
-/* assumes the tracing mutex is locked at entry.  In order to allow this to be called
- * from interrupt context, we don't do any copyouts here, but rather just wake trace
- * buffer collector thread.
+/*
+ * Assumes the tracing mutex is locked at entry. In order to allow this to
+ * be called from interrupt context, we don't do any copyouts here, but rather
+ * just wake the trace buffer collector thread.
  */
-void 
-rf_FlushAccessTraceBuf()
+void
+rf_FlushAccessTraceBuf(void)
 {
 	accessTraceBufCount = 0;
 }
diff --git a/sys/dev/raidframe/rf_acctrace.h b/sys/dev/raidframe/rf_acctrace.h
index f7ca09eb173..4c31bd17d32 100644
--- a/sys/dev/raidframe/rf_acctrace.h
+++ b/sys/dev/raidframe/rf_acctrace.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_acctrace.h,v 1.2 1999/02/16 00:02:22 niklas Exp $	*/
+/*	$OpenBSD: rf_acctrace.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_acctrace.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,106 +30,133 @@
 
 /*****************************************************************************
  *
- * acctrace.h -- header file for acctrace.c
+ * acctrace.h -- Header file for acctrace.c
  *
  *****************************************************************************/
 
 
-#ifndef _RF__RF_ACCTRACE_H_
-#define _RF__RF_ACCTRACE_H_
+#ifndef	_RF__RF_ACCTRACE_H_
+#define	_RF__RF_ACCTRACE_H_
 
 #include "rf_types.h"
 #include "rf_hist.h"
 #include "rf_etimer.h"
 
 typedef struct RF_user_acc_stats_s {
-	RF_uint64 suspend_ovhd_us;	/* us spent mucking in the
-					 * access-suspension code */
-	RF_uint64 map_us;	/* us spent mapping the access */
-	RF_uint64 lock_us;	/* us spent locking & unlocking stripes,
-				 * including time spent blocked */
-	RF_uint64 dag_create_us;/* us spent creating the DAGs */
-	RF_uint64 dag_retry_us;	/* _total_ us spent retrying the op -- not
-				 * broken down into components */
-	RF_uint64 exec_us;	/* us spent in DispatchDAG */
-	RF_uint64 exec_engine_us;	/* us spent in engine, not including
-					 * blocking time */
-	RF_uint64 cleanup_us;	/* us spent tearing down the dag & maps, and
-				 * generally cleaning up */
-}       RF_user_acc_stats_t;
+	RF_uint64	suspend_ovhd_us;/*
+					 * usec spent mucking in the
+					 * access-suspension code.
+					 */
+	RF_uint64	map_us;		/* usec spent mapping the access. */
+	RF_uint64	lock_us;	/*
+					 * usec spent locking & unlocking
+					 * stripes, including time spent
+					 * blocked.
+					 */
+	RF_uint64	dag_create_us;	/* usec spent creating the DAGs. */
+	RF_uint64	dag_retry_us;	/*
+					 * _total_ usec spent retrying the op
+					 * -- not broken down into components.
+					 */
+	RF_uint64	exec_us;	/* usec spent in DispatchDAG. */
+	RF_uint64	exec_engine_us;	/*
+					 * usec spent in engine, not including
+					 * blocking time.
+					 */
+	RF_uint64	cleanup_us;	/*
+					 * usec spent tearing down the dag &
+					 * maps, and generally cleaning up.
+					 */
+} RF_user_acc_stats_t;
 
 typedef struct RF_recon_acc_stats_s {
-	RF_uint32 recon_start_to_fetch_us;
-	RF_uint32 recon_fetch_to_return_us;
-	RF_uint32 recon_return_to_submit_us;
-}       RF_recon_acc_stats_t;
+	RF_uint32	recon_start_to_fetch_us;
+	RF_uint32	recon_fetch_to_return_us;
+	RF_uint32	recon_return_to_submit_us;
+} RF_recon_acc_stats_t;
 
 typedef struct RF_acctrace_entry_s {
 	union {
-		RF_user_acc_stats_t user;
-		RF_recon_acc_stats_t recon;
-	}       specific;
-	RF_uint8 reconacc;	/* whether  this is a tracerec for a user acc
-				 * or a recon acc */
-	RF_uint64 xor_us;	/* us spent doing XORs */
-	RF_uint64 q_us;		/* us spent doing XORs */
-	RF_uint64 plog_us;	/* us spent waiting to stuff parity into log */
-	RF_uint64 diskqueue_us;	/* _total_ us spent in disk queue(s), incl
-				 * concurrent ops */
-	RF_uint64 diskwait_us;	/* _total_ us spent waiting actually waiting
-				 * on the disk, incl concurrent ops */
-	RF_uint64 total_us;	/* total us spent on this access */
-	RF_uint64 num_phys_ios;	/* number of physical I/Os invoked */
-	RF_uint64 phys_io_us;	/* time of physical I/O */
-	RF_Etimer_t tot_timer;	/* a timer used to compute total access time */
-	RF_Etimer_t timer;	/* a generic timer val for timing events that
-				 * live across procedure boundaries */
-	RF_Etimer_t recon_timer;/* generic timer for recon stuff */
-	RF_uint64 index;
-}       RF_AccTraceEntry_t;
+		RF_user_acc_stats_t	user;
+		RF_recon_acc_stats_t	recon;
+	}		specific;
+	RF_uint8	reconacc;	/*
+					 * Whether this is a tracerec for a
+					 * user acc or a recon acc.
+					 */
+	RF_uint64	xor_us;		/* usec spent doing XORs. */
+	RF_uint64	q_us;		/* usec spent doing XORs. */
+	RF_uint64	plog_us;	/*
+					 * usec spent waiting to stuff parity
+					 * into log.
+					 */
+	RF_uint64	diskqueue_us;	/*
+					 * _total_ usec spent in disk queue(s),
+					 * incl concurrent ops.
+					 */
+	RF_uint64	diskwait_us;	/*
+					 * _total_ usec spent actually waiting
+					 * on the disk, incl concurrent ops.
+					 */
+	RF_uint64	total_us;	/* Total usec spent on this access. */
+	RF_uint64	num_phys_ios;	/* Number of physical I/Os invoked. */
+	RF_uint64	phys_io_us;	/* Time of physical I/O. */
+	RF_Etimer_t	tot_timer;	/*
+					 * A timer used to compute total
+					 * access time.
+					 */
+	RF_Etimer_t	timer;		/*
+					 * A generic timer val for timing
+					 * events that live across procedure
+					 * boundaries.
+					 */
+	RF_Etimer_t	recon_timer;	/* Generic timer for recon stuff. */
+	RF_uint64	index;
+} RF_AccTraceEntry_t;
 
 typedef struct RF_AccTotals_s {
-	/* user acc stats */
-	RF_uint64 suspend_ovhd_us;
-	RF_uint64 map_us;
-	RF_uint64 lock_us;
-	RF_uint64 dag_create_us;
-	RF_uint64 dag_retry_us;
-	RF_uint64 exec_us;
-	RF_uint64 exec_engine_us;
-	RF_uint64 cleanup_us;
-	RF_uint64 user_reccount;
-	/* recon acc stats */
-	RF_uint64 recon_start_to_fetch_us;
-	RF_uint64 recon_fetch_to_return_us;
-	RF_uint64 recon_return_to_submit_us;
-	RF_uint64 recon_io_overflow_count;
-	RF_uint64 recon_phys_io_us;
-	RF_uint64 recon_num_phys_ios;
-	RF_uint64 recon_diskwait_us;
-	RF_uint64 recon_reccount;
-	/* trace entry stats */
-	RF_uint64 xor_us;
-	RF_uint64 q_us;
-	RF_uint64 plog_us;
-	RF_uint64 diskqueue_us;
-	RF_uint64 diskwait_us;
-	RF_uint64 total_us;
-	RF_uint64 num_log_ents;
-	RF_uint64 phys_io_overflow_count;
-	RF_uint64 num_phys_ios;
-	RF_uint64 phys_io_us;
-	RF_uint64 bigvals;
-	/* histograms */
-	RF_Hist_t dw_hist[RF_HIST_NUM_BUCKETS];
-	RF_Hist_t tot_hist[RF_HIST_NUM_BUCKETS];
-}       RF_AccTotals_t;
-#if RF_UTILITY == 0
-RF_DECLARE_EXTERN_MUTEX(rf_tracing_mutex)
-#endif				/* RF_UTILITY == 0 */
+	/* User acc stats. */
+	RF_uint64	suspend_ovhd_us;
+	RF_uint64	map_us;
+	RF_uint64	lock_us;
+	RF_uint64	dag_create_us;
+	RF_uint64	dag_retry_us;
+	RF_uint64	exec_us;
+	RF_uint64	exec_engine_us;
+	RF_uint64	cleanup_us;
+	RF_uint64	user_reccount;
+	/* Recon acc stats. */
+	RF_uint64	recon_start_to_fetch_us;
+	RF_uint64	recon_fetch_to_return_us;
+	RF_uint64	recon_return_to_submit_us;
+	RF_uint64	recon_io_overflow_count;
+	RF_uint64	recon_phys_io_us;
+	RF_uint64	recon_num_phys_ios;
+	RF_uint64	recon_diskwait_us;
+	RF_uint64	recon_reccount;
+	/* Trace entry stats. */
+	RF_uint64	xor_us;
+	RF_uint64	q_us;
+	RF_uint64	plog_us;
+	RF_uint64	diskqueue_us;
+	RF_uint64	diskwait_us;
+	RF_uint64	total_us;
+	RF_uint64	num_log_ents;
+	RF_uint64	phys_io_overflow_count;
+	RF_uint64	num_phys_ios;
+	RF_uint64	phys_io_us;
+	RF_uint64	bigvals;
+	/* Histograms. */
+	RF_Hist_t	dw_hist[RF_HIST_NUM_BUCKETS];
+	RF_Hist_t	tot_hist[RF_HIST_NUM_BUCKETS];
+} RF_AccTotals_t;
+
+#if	RF_UTILITY == 0
+RF_DECLARE_EXTERN_MUTEX(rf_tracing_mutex);
+#endif	/* RF_UTILITY == 0 */
 
-	int     rf_ConfigureAccessTrace(RF_ShutdownList_t ** listp);
-	void    rf_LogTraceRec(RF_Raid_t * raid, RF_AccTraceEntry_t * rec);
-	void    rf_FlushAccessTraceBuf(void);
+int  rf_ConfigureAccessTrace(RF_ShutdownList_t **);
+void rf_LogTraceRec(RF_Raid_t * raid, RF_AccTraceEntry_t *);
+void rf_FlushAccessTraceBuf(void);
 
-#endif				/* !_RF__RF_ACCTRACE_H_ */
+#endif	/* !_RF__RF_ACCTRACE_H_ */
diff --git a/sys/dev/raidframe/rf_alloclist.c b/sys/dev/raidframe/rf_alloclist.c
index f0ddd462625..9da2da7feaa 100644
--- a/sys/dev/raidframe/rf_alloclist.c
+++ b/sys/dev/raidframe/rf_alloclist.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_alloclist.c,v 1.3 2000/01/07 14:50:19 peter Exp $	*/
+/*	$OpenBSD: rf_alloclist.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_alloclist.c,v 1.4 1999/08/13 03:41:53 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,10 +30,10 @@
 
 /****************************************************************************
  *
- * Alloclist.c -- code to manipulate allocation lists
+ * Alloclist.c -- Code to manipulate allocation lists.
  *
- * an allocation list is just a list of AllocListElem structures.  Each
- * such structure contains a fixed-size array of pointers.  Calling
+ * An allocation list is just a list of AllocListElem structures. Each
+ * such structure contains a fixed-size array of pointers. Calling
  * FreeAList() causes each pointer to be freed.
  *
  ***************************************************************************/
@@ -45,20 +46,20 @@
 #include "rf_general.h"
 #include "rf_shutdown.h"
 
-RF_DECLARE_STATIC_MUTEX(alist_mutex)
-	static unsigned int fl_hit_count, fl_miss_count;
+RF_DECLARE_STATIC_MUTEX(alist_mutex);
+static unsigned int fl_hit_count, fl_miss_count;
 
-	static RF_AllocListElem_t *al_free_list = NULL;
-	static int al_free_list_count;
+static RF_AllocListElem_t *al_free_list = NULL;
+static int al_free_list_count;
 
-#define RF_AL_FREELIST_MAX 256
+#define	RF_AL_FREELIST_MAX	256
 
-#define DO_FREE(_p,_sz) RF_Free((_p),(_sz))
+#define	DO_FREE(_p,_sz)		RF_Free((_p), (_sz))
 
-	static void rf_ShutdownAllocList(void *);
+void rf_ShutdownAllocList(void *);
 
-	static void rf_ShutdownAllocList(ignored)
-	void   *ignored;
+void
+rf_ShutdownAllocList(void *ignored)
 {
 	RF_AllocListElem_t *p, *pt;
 
@@ -69,30 +70,30 @@ RF_DECLARE_STATIC_MUTEX(alist_mutex)
 	}
 	rf_mutex_destroy(&alist_mutex);
 	/*
-        printf("Alloclist: Free list hit count %lu (%lu %%) miss count %lu (%lu %%)\n",
-	       fl_hit_count, (100*fl_hit_count)/(fl_hit_count+fl_miss_count),
-	       fl_miss_count, (100*fl_miss_count)/(fl_hit_count+fl_miss_count));
-        */
+	 * printf("Alloclist: Free list hit count %lu (%lu %%) miss count %lu"
+	 *     " (%lu %%).\n", fl_hit_count,
+	 *     (100*fl_hit_count)/(fl_hit_count+fl_miss_count),
+	 *     fl_miss_count, (100*fl_miss_count)/(fl_hit_count+fl_miss_count));
+	 */
 }
 
-int 
-rf_ConfigureAllocList(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureAllocList(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_mutex_init(&alist_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);
 	}
 	al_free_list = NULL;
 	fl_hit_count = fl_miss_count = al_free_list_count = 0;
 	rc = rf_ShutdownCreate(listp, rf_ShutdownAllocList, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		rf_mutex_destroy(&alist_mutex);
 		return (rc);
 	}
@@ -100,23 +101,21 @@ rf_ConfigureAllocList(listp)
 }
 
 
-/* we expect the lists to have at most one or two elements, so we're willing
- * to search for the end.  If you ever observe the lists growing longer,
+/*
+ * We expect the lists to have at most one or two elements, so we're willing
+ * to search for the end. If you ever observe the lists growing longer,
  * increase POINTERS_PER_ALLOC_LIST_ELEMENT.
  */
-void 
-rf_real_AddToAllocList(l, p, size, lockflag)
-	RF_AllocListElem_t *l;
-	void   *p;
-	int     size;
-	int     lockflag;
+void
+rf_real_AddToAllocList(RF_AllocListElem_t *l, void *p, int size, int lockflag)
 {
 	RF_AllocListElem_t *newelem;
 
 	for (; l->next; l = l->next)
-		RF_ASSERT(l->numPointers == RF_POINTERS_PER_ALLOC_LIST_ELEMENT);	/* find end of list */
+		RF_ASSERT(l->numPointers == RF_POINTERS_PER_ALLOC_LIST_ELEMENT);	/* Find end of list. */
 
-	RF_ASSERT(l->numPointers >= 0 && l->numPointers <= RF_POINTERS_PER_ALLOC_LIST_ELEMENT);
+	RF_ASSERT(l->numPointers >= 0 &&
+	    l->numPointers <= RF_POINTERS_PER_ALLOC_LIST_ELEMENT);
 	if (l->numPointers == RF_POINTERS_PER_ALLOC_LIST_ELEMENT) {
 		newelem = rf_real_MakeAllocList(lockflag);
 		l->next = newelem;
@@ -129,22 +128,23 @@ rf_real_AddToAllocList(l, p, size, lockflag)
 }
 
 
-/* we use the debug_mem_mutex here because we need to lock it anyway to call free.
- * this is probably a bug somewhere else in the code, but when I call malloc/free
- * outside of any lock I have endless trouble with malloc appearing to return the
- * same pointer twice.  Since we have to lock it anyway, we might as well use it
- * as the lock around the al_free_list.  Note that we can't call Free with the
- * debug_mem_mutex locked.
+/*
+ * We use the debug_mem_mutex here because we need to lock it anyway to call
+ * free. This is probably a bug somewhere else in the code, but when I call
+ * malloc/free outside of any lock, I have endless trouble with malloc
+ * appearing to return the same pointer twice. Since we have to lock it
+ * anyway, we might as well use it as the lock around the al_free_list.
+ * Note that we can't call Free with the debug_mem_mutex locked.
  */
-void 
-rf_FreeAllocList(l)
-	RF_AllocListElem_t *l;
+void
+rf_FreeAllocList(RF_AllocListElem_t *l)
 {
-	int     i;
+	int i;
 	RF_AllocListElem_t *temp, *p;
 
 	for (p = l; p; p = p->next) {
-		RF_ASSERT(p->numPointers >= 0 && p->numPointers <= RF_POINTERS_PER_ALLOC_LIST_ELEMENT);
+		RF_ASSERT(p->numPointers >= 0 &&
+		    p->numPointers <= RF_POINTERS_PER_ALLOC_LIST_ELEMENT);
 		for (i = 0; i < p->numPointers; i++) {
 			RF_ASSERT(p->pointers[i]);
 			RF_Free(p->pointers[i], p->sizes[i]);
@@ -164,8 +164,7 @@ rf_FreeAllocList(l)
 }
 
 RF_AllocListElem_t *
-rf_real_MakeAllocList(lockflag)
-	int     lockflag;
+rf_real_MakeAllocList(int lockflag)
 {
 	RF_AllocListElem_t *p;
 
@@ -176,9 +175,12 @@ rf_real_MakeAllocList(lockflag)
 		al_free_list_count--;
 	} else {
 		fl_miss_count++;
-		RF_Malloc(p, sizeof(RF_AllocListElem_t), (RF_AllocListElem_t *));	/* no allocation locking
-											 * in kernel, so this is
-											 * fine */
+		RF_Malloc(p, sizeof(RF_AllocListElem_t),
+		    (RF_AllocListElem_t *));	/*
+						 * No allocation locking
+						 * in kernel, so this is
+						 * fine.
+						 */
 	}
 	if (p == NULL) {
 		return (NULL);
diff --git a/sys/dev/raidframe/rf_alloclist.h b/sys/dev/raidframe/rf_alloclist.h
index 8426b1cd7fd..3f7874e5a25 100644
--- a/sys/dev/raidframe/rf_alloclist.h
+++ b/sys/dev/raidframe/rf_alloclist.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_alloclist.h,v 1.2 1999/02/16 00:02:23 niklas Exp $	*/
+/*	$OpenBSD: rf_alloclist.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_alloclist.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,32 +30,33 @@
 
 /****************************************************************************
  *
- * alloclist.h -- header file for alloclist.c
+ * alloclist.h -- Header file for alloclist.c
  *
  ***************************************************************************/
 
-#ifndef _RF__RF_ALLOCLIST_H_
-#define _RF__RF_ALLOCLIST_H_
+#ifndef	_RF__RF_ALLOCLIST_H_
+#define	_RF__RF_ALLOCLIST_H_
 
 #include "rf_types.h"
 
-#define RF_POINTERS_PER_ALLOC_LIST_ELEMENT 20
+#define	RF_POINTERS_PER_ALLOC_LIST_ELEMENT	20
 
 struct RF_AllocListElem_s {
-	void   *pointers[RF_POINTERS_PER_ALLOC_LIST_ELEMENT];
-	int     sizes[RF_POINTERS_PER_ALLOC_LIST_ELEMENT];
-	int     numPointers;
-	RF_AllocListElem_t *next;
+	void			*pointers[RF_POINTERS_PER_ALLOC_LIST_ELEMENT];
+	int			 sizes[RF_POINTERS_PER_ALLOC_LIST_ELEMENT];
+	int			 numPointers;
+	RF_AllocListElem_t	*next;
 };
-#define rf_MakeAllocList(_ptr_) _ptr_ = rf_real_MakeAllocList(1);
-#define rf_AddToAllocList(_l_,_ptr_,_sz_) rf_real_AddToAllocList((_l_), (_ptr_), (_sz_), 1)
+#define	rf_MakeAllocList(_ptr_)		_ptr_ = rf_real_MakeAllocList(1);
+#define	rf_AddToAllocList(_l_,_ptr_,_sz_)				\
+	rf_real_AddToAllocList((_l_), (_ptr_), (_sz_), 1)
 
-int     rf_ConfigureAllocList(RF_ShutdownList_t ** listp);
+int  rf_ConfigureAllocList(RF_ShutdownList_t **);
 
-#if RF_UTILITY == 0
-void    rf_real_AddToAllocList(RF_AllocListElem_t * l, void *p, int size, int lockflag);
-void    rf_FreeAllocList(RF_AllocListElem_t * l);
-RF_AllocListElem_t *rf_real_MakeAllocList(int lockflag);
-#endif				/* RF_UTILITY == 0 */
+#if	RF_UTILITY == 0
+void rf_real_AddToAllocList(RF_AllocListElem_t *, void *, int, int);
+void rf_FreeAllocList(RF_AllocListElem_t *);
+RF_AllocListElem_t *rf_real_MakeAllocList(int);
+#endif	/* RF_UTILITY == 0 */
 
-#endif				/* !_RF__RF_ALLOCLIST_H_ */
+#endif	/* !_RF__RF_ALLOCLIST_H_ */
diff --git a/sys/dev/raidframe/rf_archs.h b/sys/dev/raidframe/rf_archs.h
index 700746d15f0..72fb7891dda 100644
--- a/sys/dev/raidframe/rf_archs.h
+++ b/sys/dev/raidframe/rf_archs.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_archs.h,v 1.5 2000/08/08 16:07:38 peter Exp $	*/
+/*	$OpenBSD: rf_archs.h,v 1.6 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_archs.h,v 1.9 2000/03/04 03:27:13 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,46 +28,46 @@
  * rights to redistribute these changes.
  */
 
-/* rf_archs.h -- defines for which architectures you want to
- * include is some particular build of raidframe.  Unfortunately,
+/*
+ * rf_archs.h -- Defines for which architectures you want to
+ * include in some particular build of RAIDframe.  Unfortunately,
  * it's difficult to exclude declustering, P+Q, and distributed
  * sparing because the code is intermixed with RAID5 code.  This
  * should be fixed.
  *
- * this is really intended only for use in the kernel, where I
+ * This is really intended only for use in the kernel, where I
  * am worried about the size of the object module.  At user level and
  * in the simulator, I don't really care that much, so all the
  * architectures can be compiled together.  Note that by itself, turning
  * off these defines does not affect the size of the executable; you
  * have to edit the makefile for that.
  *
- * comment out any line below to eliminate that architecture.
- * the list below includes all the modules that can be compiled
+ * Comment out any line below to eliminate that architecture.
+ * The list below includes all the modules that can be compiled
  * out.
- *
  */
 
-#ifndef _RF__RF_ARCHS_H_
-#define _RF__RF_ARCHS_H_
+#ifndef	_RF__RF_ARCHS_H_
+#define	_RF__RF_ARCHS_H_
 
-#define RF_INCLUDE_EVENODD       1
+#define	RF_INCLUDE_EVENODD			1
 
-#define RF_INCLUDE_RAID5_RS      1
-#define RF_INCLUDE_PARITYLOGGING 1
+#define	RF_INCLUDE_RAID5_RS			1
+#define	RF_INCLUDE_PARITYLOGGING		1
 
-#define RF_INCLUDE_CHAINDECLUSTER 1
-#define RF_INCLUDE_INTERDECLUSTER 1
+#define	RF_INCLUDE_CHAINDECLUSTER		1
+#define	RF_INCLUDE_INTERDECLUSTER		1
 
-#define RF_INCLUDE_RAID0   1
-#define RF_INCLUDE_RAID1   1
-#define RF_INCLUDE_RAID4   1
-#define RF_INCLUDE_RAID5   1
-#define RF_INCLUDE_RAID6   0
-#define RF_INCLUDE_DECL_PQ 0
+#define	RF_INCLUDE_RAID0			1
+#define	RF_INCLUDE_RAID1			1
+#define	RF_INCLUDE_RAID4			1
+#define	RF_INCLUDE_RAID5			1
+#define	RF_INCLUDE_RAID6			1
+#define	RF_INCLUDE_DECL_PQ			1
 
-#define RF_MEMORY_REDZONES 0
-#define RF_RECON_STATS     1
+#define	RF_MEMORY_REDZONES			0
+#define	RF_RECON_STATS				1
 
 #include "rf_options.h"
 
-#endif				/* !_RF__RF_ARCHS_H_ */
+#endif	/* !_RF__RF_ARCHS_H_ */
diff --git a/sys/dev/raidframe/rf_aselect.c b/sys/dev/raidframe/rf_aselect.c
index b50be26171b..e376909ec8b 100644
--- a/sys/dev/raidframe/rf_aselect.c
+++ b/sys/dev/raidframe/rf_aselect.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_aselect.c,v 1.2 1999/02/16 00:02:23 niklas Exp $	*/
+/*	$OpenBSD: rf_aselect.c,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_aselect.c,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,7 +28,7 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************
+/****************************************************************************
  *
  * aselect.c -- algorithm selection code
  *
@@ -45,28 +46,25 @@
 #include "rf_map.h"
 
 #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
-/* the function below is not used... so don't define it! */
+/* The function below is not used... so don't define it! */
 #else
-static void TransferDagMemory(RF_DagHeader_t *, RF_DagHeader_t *);
+void rf_TransferDagMemory(RF_DagHeader_t *, RF_DagHeader_t *);
 #endif
 
-static int InitHdrNode(RF_DagHeader_t **, RF_Raid_t *, int);
-static void UpdateNodeHdrPtr(RF_DagHeader_t *, RF_DagNode_t *);
-int     rf_SelectAlgorithm(RF_RaidAccessDesc_t *, RF_RaidAccessFlags_t);
+int  rf_InitHdrNode(RF_DagHeader_t **, RF_Raid_t *, int);
+void rf_UpdateNodeHdrPtr(RF_DagHeader_t *, RF_DagNode_t *);
+int  rf_SelectAlgorithm(RF_RaidAccessDesc_t *, RF_RaidAccessFlags_t);
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * Create and Initialiaze a dag header and termination node
+ * Create and Initialize a dag header and termination node.
  *
  *****************************************************************************/
-static int 
-InitHdrNode(hdr, raidPtr, memChunkEnable)
-	RF_DagHeader_t **hdr;
-	RF_Raid_t *raidPtr;
-	int     memChunkEnable;
+int
+rf_InitHdrNode(RF_DagHeader_t **hdr, RF_Raid_t *raidPtr, int memChunkEnable)
 {
-	/* create and initialize dag hdr */
+	/* Create and initialize dag hdr. */
 	*hdr = rf_AllocDAGHeader();
 	rf_MakeAllocList((*hdr)->allocList);
 	if ((*hdr)->allocList == NULL) {
@@ -79,61 +77,70 @@ InitHdrNode(hdr, raidPtr, memChunkEnable)
 	(*hdr)->next = NULL;
 	return (0);
 }
-/******************************************************************************
+
+
+/*****************************************************************************
  *
- * Transfer allocation list and mem chunks from one dag to another
+ * Transfer allocation list and mem chunks from one dag to another.
  *
  *****************************************************************************/
 #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
-/* the function below is not used... so don't define it! */
+/* The function below is not used... so don't define it! */
 #else
-static void 
-TransferDagMemory(daga, dagb)
-	RF_DagHeader_t *daga;
-	RF_DagHeader_t *dagb;
+void
+rf_TransferDagMemory(RF_DagHeader_t *daga, RF_DagHeader_t *dagb)
 {
 	RF_AccessStripeMapHeader_t *end;
 	RF_AllocListElem_t *p;
-	int     i, memChunksXfrd = 0, xtraChunksXfrd = 0;
+	int i, memChunksXfrd = 0, xtraChunksXfrd = 0;
 
-	/* transfer allocList from dagb to daga */
+	/* Transfer allocList from dagb to daga. */
 	for (p = dagb->allocList; p; p = p->next) {
 		for (i = 0; i < p->numPointers; i++) {
-			rf_AddToAllocList(daga->allocList, p->pointers[i], p->sizes[i]);
+			rf_AddToAllocList(daga->allocList, p->pointers[i],
+			    p->sizes[i]);
 			p->pointers[i] = NULL;
 			p->sizes[i] = 0;
 		}
 		p->numPointers = 0;
 	}
 
-	/* transfer chunks from dagb to daga */
-	while ((memChunksXfrd + xtraChunksXfrd < dagb->chunkIndex + dagb->xtraChunkIndex) && (daga->chunkIndex < RF_MAXCHUNKS)) {
-		/* stuff chunks into daga's memChunk array */
+	/* Transfer chunks from dagb to daga. */
+	while ((memChunksXfrd + xtraChunksXfrd <
+	    dagb->chunkIndex + dagb->xtraChunkIndex) &&
+	    (daga->chunkIndex < RF_MAXCHUNKS)) {
+		/* Stuff chunks into daga's memChunk array. */
 		if (memChunksXfrd < dagb->chunkIndex) {
-			daga->memChunk[daga->chunkIndex++] = dagb->memChunk[memChunksXfrd];
+			daga->memChunk[daga->chunkIndex++] =
+			    dagb->memChunk[memChunksXfrd];
 			dagb->memChunk[memChunksXfrd++] = NULL;
 		} else {
-			daga->memChunk[daga->xtraChunkIndex++] = dagb->xtraMemChunk[xtraChunksXfrd];
+			daga->memChunk[daga->xtraChunkIndex++] =
+			    dagb->xtraMemChunk[xtraChunksXfrd];
 			dagb->xtraMemChunk[xtraChunksXfrd++] = NULL;
 		}
 	}
-	/* use escape hatch to hold excess chunks */
-	while (memChunksXfrd + xtraChunksXfrd < dagb->chunkIndex + dagb->xtraChunkIndex) {
+	/* Use escape hatch to hold excess chunks. */
+	while (memChunksXfrd + xtraChunksXfrd <
+	    dagb->chunkIndex + dagb->xtraChunkIndex) {
 		if (memChunksXfrd < dagb->chunkIndex) {
-			daga->xtraMemChunk[daga->xtraChunkIndex++] = dagb->memChunk[memChunksXfrd];
+			daga->xtraMemChunk[daga->xtraChunkIndex++] =
+			    dagb->memChunk[memChunksXfrd];
 			dagb->memChunk[memChunksXfrd++] = NULL;
 		} else {
-			daga->xtraMemChunk[daga->xtraChunkIndex++] = dagb->xtraMemChunk[xtraChunksXfrd];
+			daga->xtraMemChunk[daga->xtraChunkIndex++] =
+			    dagb->xtraMemChunk[xtraChunksXfrd];
 			dagb->xtraMemChunk[xtraChunksXfrd++] = NULL;
 		}
 	}
-	RF_ASSERT((memChunksXfrd == dagb->chunkIndex) && (xtraChunksXfrd == dagb->xtraChunkIndex));
+	RF_ASSERT((memChunksXfrd == dagb->chunkIndex) &&
+	    (xtraChunksXfrd == dagb->xtraChunkIndex));
 	RF_ASSERT(daga->chunkIndex <= RF_MAXCHUNKS);
 	RF_ASSERT(daga->xtraChunkIndex <= daga->xtraChunkCnt);
 	dagb->chunkIndex = 0;
 	dagb->xtraChunkIndex = 0;
 
-	/* transfer asmList from dagb to daga */
+	/* Transfer asmList from dagb to daga. */
 	if (dagb->asmList) {
 		if (daga->asmList) {
 			end = daga->asmList;
@@ -145,35 +152,36 @@ TransferDagMemory(daga, dagb)
 		dagb->asmList = NULL;
 	}
 }
-#endif				/* __NetBSD__ || __OpenBSD__ */
+#endif	/* __NetBSD__ || __OpenBSD__ */
+
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * Ensure that all node->dagHdr fields in a dag are consistent
+ * Ensure that all node->dagHdr fields in a dag are consistent.
  *
- * IMPORTANT: This routine recursively searches all succedents of the node.  If a
- * succedent is encountered whose dagHdr ptr does not require adjusting, that node's
- * succedents WILL NOT BE EXAMINED.
+ * IMPORTANT: This routine recursively searches all succedents of the node.
+ * If a succedent is encountered whose dagHdr ptr does not require adjusting,
+ * that node's succedents WILL NOT BE EXAMINED.
  *
- ****************************************************************************************/
-static void 
-UpdateNodeHdrPtr(hdr, node)
-	RF_DagHeader_t *hdr;
-	RF_DagNode_t *node;
+ *****************************************************************************/
+void
+rf_UpdateNodeHdrPtr(RF_DagHeader_t *hdr, RF_DagNode_t *node)
 {
-	int     i;
+	int i;
 	RF_ASSERT(hdr != NULL && node != NULL);
 	for (i = 0; i < node->numSuccedents; i++)
 		if (node->succedents[i]->dagHdr != hdr)
-			UpdateNodeHdrPtr(hdr, node->succedents[i]);
+			rf_UpdateNodeHdrPtr(hdr, node->succedents[i]);
 	node->dagHdr = hdr;
 }
-/******************************************************************************
+
+
+/*****************************************************************************
  *
  * Create a DAG to do a read or write operation.
  *
- * create an array of dagLists, one list per parity stripe.
- * return the lists in the array desc->dagArray.
+ * Create an array of dagLists, one list per parity stripe.
+ * Return the lists in the array desc->dagArray.
  *
  * Normally, each list contains one dag for the entire stripe.  In some
  * tricky cases, we break this into multiple dags, either one per stripe
@@ -181,7 +189,7 @@ UpdateNodeHdrPtr(hdr, node)
  * as a linked list (dagList) which is executed sequentially (to preserve
  * atomic parity updates in the stripe).
  *
- * dags which operate on independent parity goups (stripes) are returned in
+ * Dags that operate on independent parity goups (stripes) are returned in
  * independent dagLists (distinct elements in desc->dagArray) and may be
  * executed concurrently.
  *
@@ -193,42 +201,40 @@ UpdateNodeHdrPtr(hdr, node)
  *   2) create dags and concatenate/merge to form the final dag.
  *
  * Because dag's are basic blocks (single entry, single exit, unconditional
- * control flow, we can add the following optimizations (future work):
+ * control flow), we can add the following optimizations (future work):
  *   first-pass optimizer to allow max concurrency (need all data dependencies)
  *   second-pass optimizer to eliminate common subexpressions (need true
- *                         data dependencies)
+ *       data dependencies)
  *   third-pass optimizer to eliminate dead code (need true data dependencies)
  *****************************************************************************/
 
-#define MAXNSTRIPES 50
+#define	MAXNSTRIPES	50
 
-int 
-rf_SelectAlgorithm(desc, flags)
-	RF_RaidAccessDesc_t *desc;
-	RF_RaidAccessFlags_t flags;
+int
+rf_SelectAlgorithm(RF_RaidAccessDesc_t *desc, RF_RaidAccessFlags_t flags)
 {
 	RF_AccessStripeMapHeader_t *asm_h = desc->asmap;
 	RF_IoType_t type = desc->type;
 	RF_Raid_t *raidPtr = desc->raidPtr;
-	void   *bp = desc->bp;
+	void *bp = desc->bp;
 
 	RF_AccessStripeMap_t *asmap = asm_h->stripeMap;
 	RF_AccessStripeMap_t *asm_p;
 	RF_DagHeader_t *dag_h = NULL, *tempdag_h, *lastdag_h;
-	int     i, j, k;
+	int i, j, k;
 	RF_VoidFuncPtr *stripeFuncs, normalStripeFuncs[MAXNSTRIPES];
 	RF_AccessStripeMap_t *asm_up, *asm_bp;
 	RF_AccessStripeMapHeader_t ***asmh_u, *endASMList;
 	RF_AccessStripeMapHeader_t ***asmh_b;
 	RF_VoidFuncPtr **stripeUnitFuncs, uFunc;
 	RF_VoidFuncPtr **blockFuncs, bFunc;
-	int     numStripesBailed = 0, cantCreateDAGs = RF_FALSE;
-	int     numStripeUnitsBailed = 0;
-	int     stripeNum, numUnitDags = 0, stripeUnitNum, numBlockDags = 0;
+	int numStripesBailed = 0, cantCreateDAGs = RF_FALSE;
+	int numStripeUnitsBailed = 0;
+	int stripeNum, numUnitDags = 0, stripeUnitNum, numBlockDags = 0;
 	RF_StripeNum_t numStripeUnits;
 	RF_SectorNum_t numBlocks;
 	RF_RaidAddr_t address;
-	int     length;
+	int length;
 	RF_PhysDiskAddr_t *physPtr;
 	caddr_t buffer;
 
@@ -237,97 +243,176 @@ rf_SelectAlgorithm(desc, flags)
 	stripeUnitFuncs = NULL;
 	blockFuncs = NULL;
 
-	/* get an array of dag-function creation pointers, try to avoid
-	 * calling malloc */
+	/*
+	 * Get an array of dag-function creation pointers.
+	 * Try to avoid calling malloc.
+	 */
 	if (asm_h->numStripes <= MAXNSTRIPES)
 		stripeFuncs = normalStripeFuncs;
 	else
-		RF_Calloc(stripeFuncs, asm_h->numStripes, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
+		RF_Calloc(stripeFuncs, asm_h->numStripes,
+		    sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
 
-	/* walk through the asm list once collecting information */
-	/* attempt to find a single creation function for each stripe */
+	/*
+	 * Walk through the asm list once collecting information.
+	 * Attempt to find a single creation function for each stripe.
+	 */
 	desc->numStripes = 0;
 	for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++) {
 		desc->numStripes++;
-		(raidPtr->Layout.map->SelectionFunc) (raidPtr, type, asm_p, &stripeFuncs[i]);
-		/* check to see if we found a creation func for this stripe */
+		(raidPtr->Layout.map->SelectionFunc) (raidPtr, type, asm_p,
+		    &stripeFuncs[i]);
+		/* Check to see if we found a creation func for this stripe. */
 		if (stripeFuncs[i] == (RF_VoidFuncPtr) NULL) {
-			/* could not find creation function for entire stripe
-			 * so, let's see if we can find one for each stripe
-			 * unit in the stripe */
+			/*
+			 * Could not find creation function for entire stripe.
+			 * So, let's see if we can find one for each stripe
+			 * unit in the stripe.
+			 */
 
 			if (numStripesBailed == 0) {
-				/* one stripe map header for each stripe we
-				 * bail on */
-				RF_Malloc(asmh_u, sizeof(RF_AccessStripeMapHeader_t **) * asm_h->numStripes, (RF_AccessStripeMapHeader_t ***));
-				/* create an array of ptrs to arrays of
-				 * stripeFuncs */
-				RF_Calloc(stripeUnitFuncs, asm_h->numStripes, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr **));
+				/*
+				 * One stripe map header for each stripe we
+				 * bail on.
+				 */
+				RF_Malloc(asmh_u,
+				    sizeof(RF_AccessStripeMapHeader_t **) *
+				    asm_h->numStripes,
+				    (RF_AccessStripeMapHeader_t ***));
+				/*
+				 * Create an array of ptrs to arrays of
+				 * stripeFuncs.
+				 */
+				RF_Calloc(stripeUnitFuncs, asm_h->numStripes,
+				    sizeof(RF_VoidFuncPtr),
+				    (RF_VoidFuncPtr **));
 			}
-			/* create an array of creation funcs (called
-			 * stripeFuncs) for this stripe */
+			/*
+			 * Create an array of creation funcs (called
+			 * stripeFuncs) for this stripe.
+			 */
 			numStripeUnits = asm_p->numStripeUnitsAccessed;
-			RF_Calloc(stripeUnitFuncs[numStripesBailed], numStripeUnits, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
-			RF_Malloc(asmh_u[numStripesBailed], numStripeUnits * sizeof(RF_AccessStripeMapHeader_t *), (RF_AccessStripeMapHeader_t **));
-
-			/* lookup array of stripeUnitFuncs for this stripe */
-			for (j = 0, physPtr = asm_p->physInfo; physPtr; physPtr = physPtr->next, j++) {
-				/* remap for series of single stripe-unit
-				 * accesses */
+			RF_Calloc(stripeUnitFuncs[numStripesBailed],
+			    numStripeUnits, sizeof(RF_VoidFuncPtr),
+			    (RF_VoidFuncPtr *));
+			RF_Malloc(asmh_u[numStripesBailed], numStripeUnits *
+			    sizeof(RF_AccessStripeMapHeader_t *),
+			    (RF_AccessStripeMapHeader_t **));
+
+			/* Lookup array of stripeUnitFuncs for this stripe. */
+			for (j = 0, physPtr = asm_p->physInfo; physPtr;
+			    physPtr = physPtr->next, j++) {
+				/*
+				 * Remap for series of single stripe-unit
+				 * accesses.
+				 */
 				address = physPtr->raidAddress;
 				length = physPtr->numSector;
 				buffer = physPtr->bufPtr;
 
-				asmh_u[numStripesBailed][j] = rf_MapAccess(raidPtr, address, length, buffer, RF_DONT_REMAP);
+				asmh_u[numStripesBailed][j] =
+				    rf_MapAccess(raidPtr, address, length,
+				        buffer, RF_DONT_REMAP);
 				asm_up = asmh_u[numStripesBailed][j]->stripeMap;
 
-				/* get the creation func for this stripe unit */
-				(raidPtr->Layout.map->SelectionFunc) (raidPtr, type, asm_up, &(stripeUnitFuncs[numStripesBailed][j]));
-
-				/* check to see if we found a creation func
-				 * for this stripe unit */
-				if (stripeUnitFuncs[numStripesBailed][j] == (RF_VoidFuncPtr) NULL) {
-					/* could not find creation function
-					 * for stripe unit so, let's see if we
-					 * can find one for each block in the
-					 * stripe unit */
+				/*
+				 * Get the creation func for this
+				 * stripe unit.
+				 */
+				(raidPtr->Layout.map->SelectionFunc) (raidPtr,
+				    type, asm_up,
+				    &(stripeUnitFuncs[numStripesBailed][j]));
+
+				/*
+				 * Check to see if we found a creation func
+				 * for this stripe unit.
+				 */
+				if (stripeUnitFuncs[numStripesBailed][j] ==
+				    (RF_VoidFuncPtr) NULL) {
+					/*
+					 * Could not find creation function
+					 * for stripe unit.  So, let's see if
+					 * we can find one for each block in
+					 * the stripe unit.
+					 */
 					if (numStripeUnitsBailed == 0) {
-						/* one stripe map header for
-						 * each stripe unit we bail on */
-						RF_Malloc(asmh_b, sizeof(RF_AccessStripeMapHeader_t **) * asm_h->numStripes * raidPtr->Layout.numDataCol, (RF_AccessStripeMapHeader_t ***));
-						/* create an array of ptrs to
-						 * arrays of blockFuncs */
-						RF_Calloc(blockFuncs, asm_h->numStripes * raidPtr->Layout.numDataCol, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr **));
+						/*
+						 * one stripe map header for
+						 * each stripe unit we bail on.
+						 */
+						RF_Malloc(asmh_b,
+				    sizeof(RF_AccessStripeMapHeader_t **) *
+				    asm_h->numStripes *
+				    raidPtr->Layout.numDataCol,
+				    (RF_AccessStripeMapHeader_t ***));
+						/*
+						 * Create an array of ptrs to
+						 * arrays of blockFuncs.
+						 */
+						RF_Calloc(blockFuncs,
+						    asm_h->numStripes *
+						    raidPtr->Layout.numDataCol,
+						    sizeof(RF_VoidFuncPtr),
+						    (RF_VoidFuncPtr **));
 					}
-					/* create an array of creation funcs
+					/*
+					 * Create an array of creation funcs
 					 * (called blockFuncs) for this stripe
-					 * unit */
+					 * unit.
+					 */
 					numBlocks = physPtr->numSector;
 					numBlockDags += numBlocks;
-					RF_Calloc(blockFuncs[numStripeUnitsBailed], numBlocks, sizeof(RF_VoidFuncPtr), (RF_VoidFuncPtr *));
-					RF_Malloc(asmh_b[numStripeUnitsBailed], numBlocks * sizeof(RF_AccessStripeMapHeader_t *), (RF_AccessStripeMapHeader_t **));
-
-					/* lookup array of blockFuncs for this
-					 * stripe unit */
+					RF_Calloc(
+					    blockFuncs[numStripeUnitsBailed], 
+					    numBlocks, sizeof(RF_VoidFuncPtr), 
+					    (RF_VoidFuncPtr *));
+					RF_Malloc(asmh_b[numStripeUnitsBailed], 
+				    numBlocks * 
+				    sizeof(RF_AccessStripeMapHeader_t *), 
+				    (RF_AccessStripeMapHeader_t **));
+
+					/*
+					 * Lookup array of blockFuncs for this
+					 * stripe unit.
+					 */
 					for (k = 0; k < numBlocks; k++) {
-						/* remap for series of single
-						 * stripe-unit accesses */
-						address = physPtr->raidAddress + k;
+						/*
+						 * Remap for series of single
+						 * stripe-unit accesses.
+						 */
+						address = physPtr->raidAddress
+						    + k;
 						length = 1;
-						buffer = physPtr->bufPtr + (k * (1 << raidPtr->logBytesPerSector));
-
-						asmh_b[numStripeUnitsBailed][k] = rf_MapAccess(raidPtr, address, length, buffer, RF_DONT_REMAP);
-						asm_bp = asmh_b[numStripeUnitsBailed][k]->stripeMap;
-
-						/* get the creation func for
-						 * this stripe unit */
-						(raidPtr->Layout.map->SelectionFunc) (raidPtr, type, asm_bp, &(blockFuncs[numStripeUnitsBailed][k]));
-
-						/* check to see if we found a
+						buffer = physPtr->bufPtr +
+					    (k * (1 <<
+					    raidPtr->logBytesPerSector));
+
+						asmh_b[numStripeUnitsBailed][k]
+						    = rf_MapAccess(raidPtr,
+						    address, length, buffer,
+						    RF_DONT_REMAP);
+						asm_bp =
+				    asmh_b[numStripeUnitsBailed][k]->stripeMap;
+
+						/*
+						 * Get the creation func for
+						 * this stripe unit.
+						 */
+						(raidPtr->Layout.map->
+				    SelectionFunc) (raidPtr,
+				        type, asm_bp,
+				        &(blockFuncs[numStripeUnitsBailed][k]));
+
+						/*
+						 * Check to see if we found a
 						 * creation func for this
-						 * stripe unit */
-						if (blockFuncs[numStripeUnitsBailed][k] == NULL)
-							cantCreateDAGs = RF_TRUE;
+						 * stripe unit.
+						 */
+						if (blockFuncs
+						    [numStripeUnitsBailed][k]
+						    == NULL)
+							cantCreateDAGs =
+							    RF_TRUE;
 					}
 					numStripeUnitsBailed++;
 				} else {
@@ -340,85 +425,125 @@ rf_SelectAlgorithm(desc, flags)
 	}
 
 	if (cantCreateDAGs) {
-		/* free memory and punt */
+		/* Free memory and punt. */
 		if (asm_h->numStripes > MAXNSTRIPES)
-			RF_Free(stripeFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
+			RF_Free(stripeFuncs, asm_h->numStripes *
+			    sizeof(RF_VoidFuncPtr));
 		if (numStripesBailed > 0) {
 			stripeNum = 0;
-			for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++)
+			for (i = 0, asm_p = asmap; asm_p;
+			    asm_p = asm_p->next, i++)
 				if (stripeFuncs[i] == NULL) {
-					numStripeUnits = asm_p->numStripeUnitsAccessed;
+					numStripeUnits =
+					    asm_p->numStripeUnitsAccessed;
 					for (j = 0; j < numStripeUnits; j++)
-						rf_FreeAccessStripeMap(asmh_u[stripeNum][j]);
-					RF_Free(asmh_u[stripeNum], numStripeUnits * sizeof(RF_AccessStripeMapHeader_t *));
-					RF_Free(stripeUnitFuncs[stripeNum], numStripeUnits * sizeof(RF_VoidFuncPtr));
+						rf_FreeAccessStripeMap(
+						    asmh_u[stripeNum][j]);
+					RF_Free(asmh_u[stripeNum],
+				    numStripeUnits *
+				    sizeof(RF_AccessStripeMapHeader_t *));
+					RF_Free(stripeUnitFuncs[stripeNum],
+					    numStripeUnits *
+					    sizeof(RF_VoidFuncPtr));
 					stripeNum++;
 				}
 			RF_ASSERT(stripeNum == numStripesBailed);
-			RF_Free(stripeUnitFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
-			RF_Free(asmh_u, asm_h->numStripes * sizeof(RF_AccessStripeMapHeader_t **));
+			RF_Free(stripeUnitFuncs, asm_h->numStripes *
+			    sizeof(RF_VoidFuncPtr));
+			RF_Free(asmh_u, asm_h->numStripes *
+			    sizeof(RF_AccessStripeMapHeader_t **));
 		}
 		return (1);
 	} else {
-		/* begin dag creation */
+		/* Begin dag creation. */
 		stripeNum = 0;
 		stripeUnitNum = 0;
 
-		/* create an array of dagLists and fill them in */
-		RF_CallocAndAdd(desc->dagArray, desc->numStripes, sizeof(RF_DagList_t), (RF_DagList_t *), desc->cleanupList);
+		/* Create an array of dagLists and fill them in. */
+		RF_CallocAndAdd(desc->dagArray, desc->numStripes,
+		    sizeof(RF_DagList_t), (RF_DagList_t *), desc->cleanupList);
 
 		for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++) {
-			/* grab dag header for this stripe */
+			/* Grab dag header for this stripe. */
 			dag_h = NULL;
 			desc->dagArray[i].desc = desc;
 
 			if (stripeFuncs[i] == (RF_VoidFuncPtr) NULL) {
-				/* use bailout functions for this stripe */
-				for (j = 0, physPtr = asm_p->physInfo; physPtr; physPtr = physPtr->next, j++) {
+				/* Use bailout functions for this stripe. */
+				for (j = 0, physPtr = asm_p->physInfo; physPtr;
+				    physPtr = physPtr->next, j++) {
 					uFunc = stripeUnitFuncs[stripeNum][j];
 					if (uFunc == (RF_VoidFuncPtr) NULL) {
-						/* use bailout functions for
-						 * this stripe unit */
-						for (k = 0; k < physPtr->numSector; k++) {
-							/* create a dag for
-							 * this block */
-							InitHdrNode(&tempdag_h, raidPtr, rf_useMemChunks);
-							desc->dagArray[i].numDags++;
+						/*
+						 * Use bailout functions for
+						 * this stripe unit.
+						 */
+						for (k = 0; k <
+						    physPtr->numSector; k++) {
+							/*
+							 * Create a dag for
+							 * this block.
+							 */
+							rf_InitHdrNode(
+							    &tempdag_h,
+							    raidPtr,
+							    rf_useMemChunks);
+							desc->dagArray[i].
+							    numDags++;
 							if (dag_h == NULL) {
-								dag_h = tempdag_h;
+								dag_h =
+								    tempdag_h;
 							} else {
-								lastdag_h->next = tempdag_h;
+								lastdag_h->next
+								    = tempdag_h;
 							}
 							lastdag_h = tempdag_h;
 
-							bFunc = blockFuncs[stripeUnitNum][k];
+							bFunc = blockFuncs
+							    [stripeUnitNum][k];
 							RF_ASSERT(bFunc);
-							asm_bp = asmh_b[stripeUnitNum][k]->stripeMap;
-							(*bFunc) (raidPtr, asm_bp, tempdag_h, bp, flags, tempdag_h->allocList);
+							asm_bp = asmh_b
+							    [stripeUnitNum][k]
+							    ->stripeMap;
+							(*bFunc) (raidPtr,
+							    asm_bp, tempdag_h,
+							    bp, flags,
+							    tempdag_h
+							    ->allocList);
 						}
 						stripeUnitNum++;
 					} else {
-						/* create a dag for this unit */
-						InitHdrNode(&tempdag_h, raidPtr, rf_useMemChunks);
+						/*
+						 * Create a dag for this unit.
+						 */
+						rf_InitHdrNode(&tempdag_h,
+						    raidPtr, rf_useMemChunks);
 						desc->dagArray[i].numDags++;
 						if (dag_h == NULL) {
 							dag_h = tempdag_h;
 						} else {
-							lastdag_h->next = tempdag_h;
+							lastdag_h->next =
+							    tempdag_h;
 						}
 						lastdag_h = tempdag_h;
 
-						asm_up = asmh_u[stripeNum][j]->stripeMap;
-						(*uFunc) (raidPtr, asm_up, tempdag_h, bp, flags, tempdag_h->allocList);
+						asm_up = asmh_u[stripeNum][j]
+						    ->stripeMap;
+						(*uFunc) (raidPtr, asm_up,
+						    tempdag_h, bp, flags,
+						    tempdag_h->allocList);
 					}
 				}
 				RF_ASSERT(j == asm_p->numStripeUnitsAccessed);
-				/* merge linked bailout dag to existing dag
-				 * collection */
+				/*
+				 * Merge linked bailout dag to existing dag
+				 * collection.
+				 */
 				stripeNum++;
 			} else {
-				/* Create a dag for this parity stripe */
-				InitHdrNode(&tempdag_h, raidPtr, rf_useMemChunks);
+				/* Create a dag for this parity stripe. */
+				rf_InitHdrNode(&tempdag_h, raidPtr,
+				    rf_useMemChunks);
 				desc->dagArray[i].numDags++;
 				if (dag_h == NULL) {
 					dag_h = tempdag_h;
@@ -427,15 +552,17 @@ rf_SelectAlgorithm(desc, flags)
 				}
 				lastdag_h = tempdag_h;
 
-				(stripeFuncs[i]) (raidPtr, asm_p, tempdag_h, bp, flags, tempdag_h->allocList);
+				(stripeFuncs[i]) (raidPtr, asm_p, tempdag_h,
+				    bp, flags, tempdag_h->allocList);
 			}
 			desc->dagArray[i].dags = dag_h;
 		}
 		RF_ASSERT(i == desc->numStripes);
 
-		/* free memory */
+		/* Free memory. */
 		if (asm_h->numStripes > MAXNSTRIPES)
-			RF_Free(stripeFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
+			RF_Free(stripeFuncs, asm_h->numStripes *
+			    sizeof(RF_VoidFuncPtr));
 		if ((numStripesBailed > 0) || (numStripeUnitsBailed > 0)) {
 			stripeNum = 0;
 			stripeUnitNum = 0;
@@ -445,49 +572,85 @@ rf_SelectAlgorithm(desc, flags)
 					endASMList = endASMList->next;
 			} else
 				endASMList = NULL;
-			/* walk through io, stripe by stripe */
-			for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++)
+			/* Walk through io, stripe by stripe. */
+			for (i = 0, asm_p = asmap; asm_p;
+			    asm_p = asm_p->next, i++)
 				if (stripeFuncs[i] == NULL) {
-					numStripeUnits = asm_p->numStripeUnitsAccessed;
-					/* walk through stripe, stripe unit by
-					 * stripe unit */
-					for (j = 0, physPtr = asm_p->physInfo; physPtr; physPtr = physPtr->next, j++) {
-						if (stripeUnitFuncs[stripeNum][j] == NULL) {
-							numBlocks = physPtr->numSector;
-							/* walk through stripe
+					numStripeUnits =
+					    asm_p->numStripeUnitsAccessed;
+					/*
+					 * Walk through stripe, stripe unit by
+					 * stripe unit.
+					 */
+					for (j = 0, physPtr = asm_p->physInfo;
+					    physPtr;
+					    physPtr = physPtr->next, j++) {
+						if (stripeUnitFuncs[stripeNum]
+						    [j] == NULL) {
+							numBlocks =
+							    physPtr->numSector;
+							/*
+							 * Walk through stripe
 							 * unit, block by
-							 * block */
-							for (k = 0; k < numBlocks; k++)
-								if (dag_h->asmList == NULL) {
-									dag_h->asmList = asmh_b[stripeUnitNum][k];
-									endASMList = dag_h->asmList;
+							 * block.
+							 */
+							for (k = 0; k <
+							    numBlocks; k++)
+								if (dag_h
+								    ->asmList 
+								    == NULL) {
+						dag_h->asmList = 
+						    asmh_b[stripeUnitNum][k];
+						endASMList = dag_h->asmList;
 								} else {
-									endASMList->next = asmh_b[stripeUnitNum][k];
-									endASMList = endASMList->next;
+						endASMList->next =
+						    asmh_b[stripeUnitNum][k];
+						endASMList = endASMList->next;
 								}
-							RF_Free(asmh_b[stripeUnitNum], numBlocks * sizeof(RF_AccessStripeMapHeader_t *));
-							RF_Free(blockFuncs[stripeUnitNum], numBlocks * sizeof(RF_VoidFuncPtr));
+							RF_Free(asmh_b
+				    [stripeUnitNum], numBlocks *
+				    sizeof(RF_AccessStripeMapHeader_t *));
+							RF_Free(blockFuncs
+						    [stripeUnitNum], numBlocks *
+						    sizeof(RF_VoidFuncPtr));
 							stripeUnitNum++;
 						}
 						if (dag_h->asmList == NULL) {
-							dag_h->asmList = asmh_u[stripeNum][j];
-							endASMList = dag_h->asmList;
+							dag_h->asmList = asmh_u
+							    [stripeNum][j];
+							endASMList = dag_h
+							    ->asmList;
 						} else {
-							endASMList->next = asmh_u[stripeNum][j];
-							endASMList = endASMList->next;
+							endASMList->next =
+							    asmh_u[stripeNum]
+							    [j];
+							endASMList = endASMList
+							    ->next;
 						}
 					}
-					RF_Free(asmh_u[stripeNum], numStripeUnits * sizeof(RF_AccessStripeMapHeader_t *));
-					RF_Free(stripeUnitFuncs[stripeNum], numStripeUnits * sizeof(RF_VoidFuncPtr));
+					RF_Free(asmh_u[stripeNum],
+					    numStripeUnits *
+					    sizeof(
+					        RF_AccessStripeMapHeader_t *));
+					RF_Free(stripeUnitFuncs[stripeNum],
+					    numStripeUnits *
+					    sizeof(RF_VoidFuncPtr));
 					stripeNum++;
 				}
 			RF_ASSERT(stripeNum == numStripesBailed);
-			RF_Free(stripeUnitFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
-			RF_Free(asmh_u, asm_h->numStripes * sizeof(RF_AccessStripeMapHeader_t **));
+			RF_Free(stripeUnitFuncs, asm_h->numStripes *
+			    sizeof(RF_VoidFuncPtr));
+			RF_Free(asmh_u, asm_h->numStripes *
+			    sizeof(RF_AccessStripeMapHeader_t **));
 			if (numStripeUnitsBailed > 0) {
-				RF_ASSERT(stripeUnitNum == numStripeUnitsBailed);
-				RF_Free(blockFuncs, raidPtr->Layout.numDataCol * asm_h->numStripes * sizeof(RF_VoidFuncPtr));
-				RF_Free(asmh_b, raidPtr->Layout.numDataCol * asm_h->numStripes * sizeof(RF_AccessStripeMapHeader_t **));
+				RF_ASSERT(stripeUnitNum ==
+				    numStripeUnitsBailed);
+				RF_Free(blockFuncs, raidPtr->Layout.numDataCol
+				    * asm_h->numStripes *
+				    sizeof(RF_VoidFuncPtr));
+				RF_Free(asmh_b, raidPtr->Layout.numDataCol *
+				    asm_h->numStripes *
+				    sizeof(RF_AccessStripeMapHeader_t **));
 			}
 		}
 		return (0);
diff --git a/sys/dev/raidframe/rf_aselect.h b/sys/dev/raidframe/rf_aselect.h
index 565f042ab53..87a893f487b 100644
--- a/sys/dev/raidframe/rf_aselect.h
+++ b/sys/dev/raidframe/rf_aselect.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_aselect.h,v 1.2 1999/02/16 00:02:24 niklas Exp $	*/
+/*	$OpenBSD: rf_aselect.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_aselect.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,15 +30,15 @@
 
 /*****************************************************************************
  *
- * aselect.h -- header file for algorithm selection code
+ * rf_aselect.h -- Header file for algorithm selection code.
  *
  *****************************************************************************/
 
-#ifndef _RF__RF_ASELECT_H_
-#define _RF__RF_ASELECT_H_
+#ifndef	_RF__RF_ASELECT_H_
+#define	_RF__RF_ASELECT_H_
 
 #include "rf_desc.h"
 
-int     rf_SelectAlgorithm(RF_RaidAccessDesc_t * desc, RF_RaidAccessFlags_t flags);
+int  rf_SelectAlgorithm(RF_RaidAccessDesc_t *, RF_RaidAccessFlags_t);
 
-#endif				/* !_RF__RF_ASELECT_H_ */
+#endif	/* !_RF__RF_ASELECT_H_ */
diff --git a/sys/dev/raidframe/rf_callback.c b/sys/dev/raidframe/rf_callback.c
index ba7e3869c10..5c973bb2252 100644
--- a/sys/dev/raidframe/rf_callback.c
+++ b/sys/dev/raidframe/rf_callback.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_callback.c,v 1.2 1999/02/16 00:02:24 niklas Exp $	*/
+/*	$OpenBSD: rf_callback.c,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_callback.c,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * callback.c -- code to manipulate callback descriptor
+ * rf_callback.c -- Code to manipulate callback descriptor.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 
 #include "rf_types.h"
@@ -43,23 +44,22 @@
 
 static RF_FreeList_t *rf_callback_freelist;
 
-#define RF_MAX_FREE_CALLBACK 64
-#define RF_CALLBACK_INC       4
-#define RF_CALLBACK_INITIAL   4
+void rf_ShutdownCallback(void *);
+
+#define	RF_MAX_FREE_CALLBACK	64
+#define	RF_CALLBACK_INC		 4
+#define	RF_CALLBACK_INITIAL	 4
 
-static void rf_ShutdownCallback(void *);
-static void 
-rf_ShutdownCallback(ignored)
-	void   *ignored;
+void
+rf_ShutdownCallback(void *ignored)
 {
 	RF_FREELIST_DESTROY(rf_callback_freelist, next, (RF_CallbackDesc_t *));
 }
 
-int 
-rf_ConfigureCallback(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureCallback(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_callback_freelist, RF_MAX_FREE_CALLBACK,
 	    RF_CALLBACK_INC, sizeof(RF_CallbackDesc_t));
@@ -67,8 +67,8 @@ rf_ConfigureCallback(listp)
 		return (ENOMEM);
 	rc = rf_ShutdownCreate(listp, rf_ShutdownCallback, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		rf_ShutdownCallback(NULL);
 		return (rc);
 	}
@@ -78,7 +78,7 @@ rf_ConfigureCallback(listp)
 }
 
 RF_CallbackDesc_t *
-rf_AllocCallbackDesc()
+rf_AllocCallbackDesc(void)
 {
 	RF_CallbackDesc_t *p;
 
@@ -86,9 +86,8 @@ rf_AllocCallbackDesc()
 	return (p);
 }
 
-void 
-rf_FreeCallbackDesc(p)
-	RF_CallbackDesc_t *p;
+void
+rf_FreeCallbackDesc(RF_CallbackDesc_t *p)
 {
 	RF_FREELIST_FREE(rf_callback_freelist, p, next);
 }
diff --git a/sys/dev/raidframe/rf_callback.h b/sys/dev/raidframe/rf_callback.h
index 528eed625b9..b0ac8830ce1 100644
--- a/sys/dev/raidframe/rf_callback.h
+++ b/sys/dev/raidframe/rf_callback.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_callback.h,v 1.2 1999/02/16 00:02:24 niklas Exp $	*/
+/*	$OpenBSD: rf_callback.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_callback.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,39 +28,37 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * callback.h -- header file for callback.c
+ * rf_callback.h -- Header file for callback.c
  *
- * the reconstruction code must manage concurrent I/Os on multiple drives.
- * it sometimes needs to suspend operation on a particular drive until some
- * condition occurs.  we can't block the thread, of course, or we wouldn't
- * be able to manage our other outstanding I/Os.  Instead we just suspend
+ * The reconstruction code must manage concurrent I/Os on multiple drives.
+ * It sometimes needs to suspend operation on a particular drive until some
+ * condition occurs. We can't block the thread, of course, or we wouldn't
+ * be able to manage our other outstanding I/Os. Instead we just suspend
  * new activity on the indicated disk, and create a callback descriptor and
  * put it someplace where it will get invoked when the condition that's
- * stalling us has cleared.  When the descriptor is invoked, it will call
+ * stalling us has cleared. When the descriptor is invoked, it will call
  * a function that will restart operation on the indicated disk.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-#ifndef _RF__RF_CALLBACK_H_
-#define _RF__RF_CALLBACK_H_
+#ifndef	_RF__RF_CALLBACK_H_
+#define	_RF__RF_CALLBACK_H_
 
 #include "rf_types.h"
 
 struct RF_CallbackDesc_s {
-	void    (*callbackFunc) (RF_CBParam_t);	/* function to call */
-	RF_CBParam_t callbackArg;	/* args to give to function, or just
-					 * info about this callback  */
-	RF_CBParam_t callbackArg2;
-	RF_RowCol_t row;	/* disk row and column IDs to give to the
-				 * callback func */
-	RF_RowCol_t col;
-	RF_CallbackDesc_t *next;/* next entry in list */
+	void		(*callbackFunc) (RF_CBParam_t);	/* Function to call. */
+	RF_CBParam_t	  callbackArg;	/* Args to give to function, or */
+	RF_CBParam_t	  callbackArg2;	/* just info about this callback. */
+	RF_RowCol_t	  row;		/* Disk row and column IDs to */
+	RF_RowCol_t	  col;		/* give to the callback func. */
+	RF_CallbackDesc_t *next;	/* Next entry in list. */
 };
 
-int     rf_ConfigureCallback(RF_ShutdownList_t ** listp);
+int  rf_ConfigureCallback(RF_ShutdownList_t **);
 RF_CallbackDesc_t *rf_AllocCallbackDesc(void);
-void    rf_FreeCallbackDesc(RF_CallbackDesc_t * p);
+void rf_FreeCallbackDesc(RF_CallbackDesc_t *);
 
-#endif				/* !_RF__RF_CALLBACK_H_ */
+#endif	/* !_RF__RF_CALLBACK_H_ */
diff --git a/sys/dev/raidframe/rf_chaindecluster.c b/sys/dev/raidframe/rf_chaindecluster.c
index 6eab8c5f937..b761cb4100d 100644
--- a/sys/dev/raidframe/rf_chaindecluster.c
+++ b/sys/dev/raidframe/rf_chaindecluster.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_chaindecluster.c,v 1.3 2000/01/11 18:02:20 peter Exp $	*/
+/*	$OpenBSD: rf_chaindecluster.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_chaindecluster.c,v 1.4 2000/01/07 03:40:56 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,7 +28,7 @@
  * rights to redistribute these changes.
  */
 
-/******************************************************************************
+/*****************************************************************************
  *
  * rf_chaindecluster.c -- implements chained declustering
  *
@@ -47,32 +48,35 @@
 #include "rf_utils.h"
 
 typedef struct RF_ChaindeclusterConfigInfo_s {
-	RF_RowCol_t **stripeIdentifier;	/* filled in at config time and used
-					 * by IdentifyStripe */
-	RF_StripeCount_t numSparingRegions;
-	RF_StripeCount_t stripeUnitsPerSparingRegion;
-	RF_SectorNum_t mirrorStripeOffset;
-}       RF_ChaindeclusterConfigInfo_t;
-
-int 
-rf_ConfigureChainDecluster(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+	RF_RowCol_t	**stripeIdentifier;	/*
+						 * Filled in at config time and
+						 * used by IdentifyStripe.
+						 */
+	RF_StripeCount_t  numSparingRegions;
+	RF_StripeCount_t  stripeUnitsPerSparingRegion;
+	RF_SectorNum_t	  mirrorStripeOffset;
+}	RF_ChaindeclusterConfigInfo_t;
+
+
+int
+rf_ConfigureChainDecluster(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_StripeCount_t num_used_stripeUnitsPerDisk;
 	RF_ChaindeclusterConfigInfo_t *info;
 	RF_RowCol_t i;
 
-	/* create a Chained Declustering configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_ChaindeclusterConfigInfo_t), (RF_ChaindeclusterConfigInfo_t *), raidPtr->cleanupList);
+	/* Create a Chained Declustering configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_ChaindeclusterConfigInfo_t),
+	    (RF_ChaindeclusterConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
-	/* fill in the config structure.  */
-	info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, 2, raidPtr->cleanupList);
+	/* Fill in the config structure. */
+	info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, 2,
+	    raidPtr->cleanupList);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
 	for (i = 0; i < raidPtr->numCol; i++) {
@@ -82,60 +86,63 @@ rf_ConfigureChainDecluster(
 
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	/* fill in the remaining layout parameters */
-	num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk - (layoutPtr->stripeUnitsPerDisk %
-	    (2 * raidPtr->numCol - 2));
-	info->numSparingRegions = num_used_stripeUnitsPerDisk / (2 * raidPtr->numCol - 2);
-	info->stripeUnitsPerSparingRegion = raidPtr->numCol * (raidPtr->numCol - 1);
-	info->mirrorStripeOffset = info->numSparingRegions * (raidPtr->numCol - 1);
-	layoutPtr->numStripe = info->numSparingRegions * info->stripeUnitsPerSparingRegion;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	/* Fill in the remaining layout parameters. */
+	num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk -
+	    (layoutPtr->stripeUnitsPerDisk % (2 * raidPtr->numCol - 2));
+	info->numSparingRegions = num_used_stripeUnitsPerDisk /
+	    (2 * raidPtr->numCol - 2);
+	info->stripeUnitsPerSparingRegion = raidPtr->numCol *
+	    (raidPtr->numCol - 1);
+	info->mirrorStripeOffset = info->numSparingRegions *
+	    (raidPtr->numCol - 1);
+	layoutPtr->numStripe = info->numSparingRegions *
+	    info->stripeUnitsPerSparingRegion;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
+	    layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numParityCol = 1;
 
 	layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
 
-	raidPtr->sectorsPerDisk =
-	    num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->sectorsPerDisk = num_used_stripeUnitsPerDisk *
+	    layoutPtr->sectorsPerStripeUnit;
 
-	raidPtr->totalSectors =
-	    (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->totalSectors = (layoutPtr->numStripe) *
+	    layoutPtr->sectorsPerStripeUnit;
 
-	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
+	    layoutPtr->sectorsPerStripeUnit;
 
 	return (0);
 }
 
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsChainDecluster(raidPtr)
-	RF_Raid_t *raidPtr;
+RF_ReconUnitCount_t
+rf_GetNumSpareRUsChainDecluster(RF_Raid_t *raidPtr)
 {
-	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 
 	/*
-         * The layout uses two stripe units per disk as spare within each
-         * sparing region.
-         */
+	 * The layout uses two stripe units per disk as spare within each
+	 * sparing region.
+	 */
 	return (2 * info->numSparingRegions);
 }
 
 
-/* Maps to the primary copy of the data, i.e. the first mirror pair */
-void 
-rf_MapSectorChainDecluster(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+/* Maps to the primary copy of the data, i.e. the first mirror pair. */
+void
+rf_MapSectorChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
-	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	RF_SectorNum_t index_within_region, index_within_disk;
 	RF_StripeNum_t sparing_region_id;
-	int     col_before_remap;
+	int col_before_remap;
 
 	*row = 0;
 	sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
@@ -145,83 +152,93 @@ rf_MapSectorChainDecluster(
 
 	if (!remap) {
 		*col = col_before_remap;
-		*diskSector = (index_within_disk + ((raidPtr->numCol - 1) * sparing_region_id)) *
-		    raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		*diskSector = (index_within_disk + ((raidPtr->numCol - 1) *
+		    sparing_region_id)) * raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidSector %
+		    raidPtr->Layout.sectorsPerStripeUnit);
 	} else {
-		/* remap sector to spare space... */
-		*diskSector = sparing_region_id * (raidPtr->numCol + 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidPtr->numCol - 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		/* Remap sector to spare space... */
+		*diskSector = sparing_region_id * (raidPtr->numCol + 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidPtr->numCol - 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidSector %
+		    raidPtr->Layout.sectorsPerStripeUnit);
 		index_within_disk = index_within_region / raidPtr->numCol;
 		if (index_within_disk < col_before_remap)
 			*col = index_within_disk;
 		else
 			if (index_within_disk == raidPtr->numCol - 2) {
-				*col = (col_before_remap + raidPtr->numCol - 1) % raidPtr->numCol;
-				*diskSector += raidPtr->Layout.sectorsPerStripeUnit;
+				*col = (col_before_remap + raidPtr->numCol - 1)
+				    % raidPtr->numCol;
+				*diskSector +=
+				    raidPtr->Layout.sectorsPerStripeUnit;
 			} else
-				*col = (index_within_disk + 2) % raidPtr->numCol;
+				*col = (index_within_disk + 2) %
+				    raidPtr->numCol;
 	}
 
 }
 
 
-
-/* Maps to the second copy of the mirror pair, which is chain declustered. The second copy is contained
-   in the next disk (mod numCol) after the disk containing the primary copy.
-   The offset into the disk is one-half disk down */
-void 
-rf_MapParityChainDecluster(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+/*
+ * Maps to the second copy of the mirror pair, which is chain declustered.
+ * The second copy is contained in the next disk (mod numCol) after the disk
+ * containing the primary copy.
+ * The offset into the disk is one-half disk down.
+ */
+void
+rf_MapParityChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
-	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	RF_SectorNum_t index_within_region, index_within_disk;
 	RF_StripeNum_t sparing_region_id;
-	int     col_before_remap;
+	int col_before_remap;
 
 	*row = 0;
 	if (!remap) {
 		*col = SUID % raidPtr->numCol;
 		*col = (*col + 1) % raidPtr->numCol;
-		*diskSector = info->mirrorStripeOffset * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (SUID / raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		*diskSector = info->mirrorStripeOffset *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (SUID / raidPtr->numCol) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidSector %
+		    raidPtr->Layout.sectorsPerStripeUnit);
 	} else {
-		/* remap parity to spare space ... */
+		/* Remap parity to spare space... */
 		sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
 		index_within_region = SUID % info->stripeUnitsPerSparingRegion;
 		index_within_disk = index_within_region / raidPtr->numCol;
-		*diskSector = sparing_region_id * (raidPtr->numCol + 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		*diskSector = sparing_region_id * (raidPtr->numCol + 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidPtr->numCol) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidSector %
+		    raidPtr->Layout.sectorsPerStripeUnit);
 		col_before_remap = SUID % raidPtr->numCol;
 		if (index_within_disk < col_before_remap)
 			*col = index_within_disk;
 		else
 			if (index_within_disk == raidPtr->numCol - 2) {
 				*col = (col_before_remap + 2) % raidPtr->numCol;
-				*diskSector -= raidPtr->Layout.sectorsPerStripeUnit;
+				*diskSector -=
+				    raidPtr->Layout.sectorsPerStripeUnit;
 			} else
-				*col = (index_within_disk + 2) % raidPtr->numCol;
+				*col = (index_within_disk + 2) %
+				    raidPtr->numCol;
 	}
-
 }
 
-void 
-rf_IdentifyStripeChainDecluster(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeChainDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 	RF_StripeNum_t SUID;
 	RF_RowCol_t col;
 
@@ -231,57 +248,57 @@ rf_IdentifyStripeChainDecluster(
 	*diskids = info->stripeIdentifier[col];
 }
 
-void 
-rf_MapSIDToPSIDChainDecluster(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDChainDecluster(RF_RaidLayout_t *layoutPtr,
+    RF_StripeNum_t stripeID, RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
 }
-/******************************************************************************
- * select a graph to perform a single-stripe access
+
+
+/****************************************************************************
+ * Select a graph to perform a single-stripe access.
  *
- * Parameters:  raidPtr    - description of the physical array
- *              type       - type of operation (read or write) requested
- *              asmap      - logical & physical addresses for this access
- *              createFunc - function to use to create the graph (return value)
+ * Parameters:	raidPtr	   - description of the physical array
+ *		type	   - type of operation (read or write) requested
+ *		asmap	   - logical & physical addresses for this access
+ *		createFunc - function to use to create the graph (return value)
  *****************************************************************************/
 
-void 
-rf_RAIDCDagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
-#if 0
-	void    (**createFunc) (RF_Raid_t *, RF_AccessStripeMap_t *,
-            RF_DagHeader_t *, void *, RF_RaidAccessFlags_t,
-/**INDENT** Warning@258: Extra ) */
-            RF_AllocListElem_t *))
-#endif
+void
+rf_RAIDCDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 {
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 	RF_ASSERT(raidPtr->numRow == 1);
 
 	if (asmap->numDataFailed + asmap->numParityFailed > 1) {
-		RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("Multiple disks failed in a single group !"
+		    "  Aborting I/O operation.\n");
 		*createFunc = NULL;
 		return;
 	}
-	*createFunc = (type == RF_IO_TYPE_READ) ? (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
+	*createFunc = (type == RF_IO_TYPE_READ) ?
+	    (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG :
+	    (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
 
 	if (type == RF_IO_TYPE_READ) {
-		if ((raidPtr->status[0] == rf_rs_degraded) || (raidPtr->status[0] == rf_rs_reconstructing))
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidCDegradedReadDAG;	/* array status is
-											 * degraded, implement
-											 * workload shifting */
+		if ((raidPtr->status[0] == rf_rs_degraded) ||
+		    (raidPtr->status[0] == rf_rs_reconstructing))
+			/*
+			 * Array status is degraded,
+			 * implement workload shifting.
+			 */
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateRaidCDegradedReadDAG;
 		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateMirrorPartitionReadDAG;	/* array status not
-											 * degraded, so use
-											 * mirror partition dag */
+			/*
+			 * Array status not degraded,
+			 * so use mirror partition dag.
+			 */
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateMirrorPartitionReadDAG;
 	} else
 		*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
 }
diff --git a/sys/dev/raidframe/rf_chaindecluster.h b/sys/dev/raidframe/rf_chaindecluster.h
index f8105d177d8..9a8005467ab 100644
--- a/sys/dev/raidframe/rf_chaindecluster.h
+++ b/sys/dev/raidframe/rf_chaindecluster.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_chaindecluster.h,v 1.2 1999/02/16 00:02:26 niklas Exp $	*/
+/*	$OpenBSD: rf_chaindecluster.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_chaindecluster.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,44 +28,27 @@
  * rights to redistribute these changes.
  */
 
-/* rf_chaindecluster.h
- * header file for Chained Declustering
+/*
+ * rf_chaindecluster.h
+ * Header file for Chained Declustering.
  */
 
 
-#ifndef _RF__RF_CHAINDECLUSTER_H_
-#define _RF__RF_CHAINDECLUSTER_H_
+#ifndef	_RF__RF_CHAINDECLUSTER_H_
+#define	_RF__RF_CHAINDECLUSTER_H_
 
-int 
-rf_ConfigureChainDecluster(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-RF_ReconUnitCount_t rf_GetNumSpareRUsChainDecluster(RF_Raid_t * raidPtr);
-void 
-rf_MapSectorChainDecluster(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityChainDecluster(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeChainDecluster(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDChainDecluster(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_RAIDCDagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr *);
-#if 0
-void    (**createFunc) (RF_Raid_t *,
-            RF_AccessStripeMap_t *,
-            RF_DagHeader_t *,
-            void *,
-            RF_RaidAccessFlags_t,
-            RF_AllocListElem_t *)
-/**INDENT** Warning@59: Extra ) */
-);
-#endif
+int  rf_ConfigureChainDecluster(RF_ShutdownList_t **, RF_Raid_t *,
+	RF_Config_t *);
+RF_ReconUnitCount_t rf_GetNumSpareRUsChainDecluster(RF_Raid_t *);
+void rf_MapSectorChainDecluster(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityChainDecluster(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeChainDecluster(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDChainDecluster(RF_RaidLayout_t *,
+	RF_StripeNum_t, RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_RAIDCDagSelect(RF_Raid_t *, RF_IoType_t,
+	RF_AccessStripeMap_t *, RF_VoidFuncPtr *);
 
-#endif				/* !_RF__RF_CHAINDECLUSTER_H_ */
+#endif	/* !_RF__RF_CHAINDECLUSTER_H_ */
diff --git a/sys/dev/raidframe/rf_configure.h b/sys/dev/raidframe/rf_configure.h
index fd436a53903..5fdad68294b 100644
--- a/sys/dev/raidframe/rf_configure.h
+++ b/sys/dev/raidframe/rf_configure.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_configure.h,v 1.4 2002/05/22 21:22:32 tdeval Exp $	*/
+/*	$OpenBSD: rf_configure.h,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_configure.h,v 1.4 1999/03/02 03:18:49 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,18 +28,18 @@
  * rights to redistribute these changes.
  */
 
-/********************************
+/*****************************************************************************
  *
  * rf_configure.h
  *
- * header file for raidframe configuration in the kernel version only.
- * configuration is invoked via ioctl rather than at boot time
+ * Header file for RAIDframe configuration in the kernel version only.
+ * Configuration is invoked via ioctl rather than at boot time.
  *
- *******************************/
+ *****************************************************************************/
 
 
-#ifndef _RF__RF_CONFIGURE_H_
-#define _RF__RF_CONFIGURE_H_
+#ifndef	_RF__RF_CONFIGURE_H_
+#define	_RF__RF_CONFIGURE_H_
 
 #include "rf_archs.h"
 #include "rf_types.h"
@@ -48,48 +49,68 @@
 
 #include <sys/ioctl.h>
 
-/* the raidframe configuration, passed down through an ioctl.
- * the driver can be reconfigured (with total loss of data) at any time,
+/*
+ * The RAIDframe configuration, passed down through an ioctl.
+ * The driver can be reconfigured (with total loss of data) at any time,
  * but it must be shut down first.
  */
 struct RF_Config_s {
-	RF_RowCol_t numRow, numCol, numSpare;	/* number of rows, columns,
-						 * and spare disks */
-	dev_t   devs[RF_MAXROW][RF_MAXCOL];	/* device numbers for disks
-						 * comprising array */
-	char    devnames[RF_MAXROW][RF_MAXCOL][50];	/* device names */
-	dev_t   spare_devs[RF_MAXSPARE];	/* device numbers for spare
-						 * disks */
-	char    spare_names[RF_MAXSPARE][50];	/* device names */
-	RF_SectorNum_t sectPerSU;	/* sectors per stripe unit */
-	RF_StripeNum_t SUsPerPU;/* stripe units per parity unit */
-	RF_StripeNum_t SUsPerRU;/* stripe units per reconstruction unit */
-	RF_ParityConfig_t parityConfig;	/* identifies the RAID architecture to
-					 * be used */
-	RF_DiskQueueType_t diskQueueType;	/* 'f' = fifo, 'c' = cvscan,
-						 * not used in kernel */
-	char    maxOutstandingDiskReqs;	/* # concurrent reqs to be sent to a
-					 * disk.  not used in kernel. */
-	char    debugVars[RF_MAXDBGV][RF_MAXDBGVLEN];	/* space for specifying
-							 * debug variables &
-							 * their values */
-	unsigned int layoutSpecificSize;	/* size in bytes of
-						 * layout-specific info */
-	void   *layoutSpecific;	/* a pointer to a layout-specific structure to
-				 * be copied in */
-	int     force;                          /* if !0, ignore many fatal
-						   configuration conditions */
-	/* 
-	  "force" is used to override cases where the component labels would 
-	  indicate that configuration should not proceed without user 
-	  intervention
+	/* Number of rows, columns, and spare disks. */
+	RF_RowCol_t		 numRow, numCol, numSpare;
+
+	/* Device numbers for disks comprising array. */
+	dev_t			 devs[RF_MAXROW][RF_MAXCOL];
+
+	/* Device names. */
+	char			 devnames[RF_MAXROW][RF_MAXCOL][50];
+
+	/* Device numbers for spare disks. */
+	dev_t			 spare_devs[RF_MAXSPARE];
+
+	/* Device names. */
+	char			 spare_names[RF_MAXSPARE][50];
+
+	/* Sectors per stripe unit. */
+	RF_SectorNum_t		 sectPerSU;
+
+	/* Stripe units per parity unit. */
+	RF_StripeNum_t		 SUsPerPU;
+
+	/* Stripe units per reconstruction unit. */
+	RF_StripeNum_t		 SUsPerRU;
+
+	/* Identifies the RAID architecture to be used. */
+	RF_ParityConfig_t	 parityConfig;
+
+	/* 'f' = fifo, 'c' = cvscan, not used in kernel. */
+	RF_DiskQueueType_t	 diskQueueType;
+
+	/* # concurrent reqs to be sent to a disk.  Not used in kernel. */
+	char			 maxOutstandingDiskReqs;
+
+	/* Space for specifying debug variables & their values. */
+	char			 debugVars[RF_MAXDBGV][RF_MAXDBGVLEN];
+
+	/* Size in bytes of layout-specific info. */
+	unsigned int		 layoutSpecificSize;
+
+	/* A pointer to a layout-specific structure to be copied in. */
+	void			*layoutSpecific;
+
+	/* If !0, ignore many fatal configuration conditions. */
+	int			 force;
+	/*
+	 * "force" is used to override cases where the component labels
+	 * would indicate that configuration should not proceed without
+	 * user intervention.
 	*/
 };
-#ifndef _KERNEL
-int     rf_MakeConfig(char *configname, RF_Config_t * cfgPtr);
-int     rf_MakeLayoutSpecificNULL(FILE * fp, RF_Config_t * cfgPtr, void *arg);
-int     rf_MakeLayoutSpecificDeclustered(FILE * configfp, RF_Config_t * cfgPtr, void *arg);
-void   *rf_ReadSpareTable(RF_SparetWait_t * req, char *fname);
-#endif				/* !_KERNEL */
-
-#endif				/* !_RF__RF_CONFIGURE_H_ */
+
+#ifndef	_KERNEL
+int   rf_MakeConfig(char *, RF_Config_t *);
+int   rf_MakeLayoutSpecificNULL(FILE *, RF_Config_t *, void *);
+int   rf_MakeLayoutSpecificDeclustered(FILE *, RF_Config_t *, void *);
+void *rf_ReadSpareTable(RF_SparetWait_t *, char *);
+#endif	/* !_KERNEL */
+
+#endif	/* !_RF__RF_CONFIGURE_H_ */
diff --git a/sys/dev/raidframe/rf_copyback.c b/sys/dev/raidframe/rf_copyback.c
index 025aaaca293..9b573cd9234 100644
--- a/sys/dev/raidframe/rf_copyback.c
+++ b/sys/dev/raidframe/rf_copyback.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_copyback.c,v 1.6 2000/08/08 16:07:39 peter Exp $	*/
+/*	$OpenBSD: rf_copyback.c,v 1.7 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_copyback.c,v 1.14 2000/03/07 02:59:50 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,16 +28,17 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************************
+
+/*****************************************************************************
  *
- * copyback.c -- code to copy reconstructed data back from spare space to
- *               the replaced disk.
+ * copyback.c -- Code to copy reconstructed data back from spare space to
+ *		 the replaced disk.
  *
- * the code operates using callbacks on the I/Os to continue with the next
- * unit to be copied back.  We do this because a simple loop containing blocking I/Os
- * will not work in the simulator.
+ * The code operates using callbacks on the I/Os to continue with the next
+ * unit to be copied back. We do this because a simple loop containing
+ * blocking I/Os will not work in the simulator.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 #include "rf_types.h"
 
@@ -54,47 +56,45 @@
 #include "rf_shutdown.h"
 #include "rf_kintf.h"
 
-#define RF_COPYBACK_DATA   0
-#define RF_COPYBACK_PARITY 1
+#define	RF_COPYBACK_DATA	0
+#define	RF_COPYBACK_PARITY	1
 
-int     rf_copyback_in_progress;
+int	rf_copyback_in_progress;
 
-static int rf_CopybackReadDoneProc(RF_CopybackDesc_t * desc, int status);
-static int rf_CopybackWriteDoneProc(RF_CopybackDesc_t * desc, int status);
-static void rf_CopybackOne(RF_CopybackDesc_t * desc, int typ,
-			   RF_RaidAddr_t addr, RF_RowCol_t testRow, 
-			   RF_RowCol_t testCol,
-    RF_SectorNum_t testOffs);
-static void rf_CopybackComplete(RF_CopybackDesc_t * desc, int status);
+int  rf_CopybackReadDoneProc(RF_CopybackDesc_t *, int);
+int  rf_CopybackWriteDoneProc(RF_CopybackDesc_t *, int);
+void rf_CopybackOne(RF_CopybackDesc_t *, int, RF_RaidAddr_t,
+	RF_RowCol_t, RF_RowCol_t, RF_SectorNum_t);
+void rf_CopybackComplete(RF_CopybackDesc_t *, int);
 
-int 
-rf_ConfigureCopyback(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureCopyback(RF_ShutdownList_t **listp)
 {
 	rf_copyback_in_progress = 0;
 	return (0);
 }
+
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
-#ifdef __NETBSD__
+#ifdef	__NETBSD__
 #include <sys/vnode.h>
 #endif
 
-/* do a complete copyback */
-void 
-rf_CopybackReconstructedData(raidPtr)
-	RF_Raid_t *raidPtr;
+
+/* Do a complete copyback. */
+void
+rf_CopybackReconstructedData(RF_Raid_t *raidPtr)
 {
 	RF_ComponentLabel_t c_label;
-	int     done, retcode;
+	int done, retcode;
 	RF_CopybackDesc_t *desc;
 	RF_RowCol_t frow, fcol;
 	RF_RaidDisk_t *badDisk;
-	char   *databuf;
+	char *databuf;
 
 	struct partinfo dpart;
 	struct vnode *vp;
@@ -107,8 +107,10 @@ rf_CopybackReconstructedData(raidPtr)
 	fcol = 0;
 	for (frow = 0; frow < raidPtr->numRow; frow++) {
 		for (fcol = 0; fcol < raidPtr->numCol; fcol++) {
-			if (raidPtr->Disks[frow][fcol].status == rf_ds_dist_spared
-			    || raidPtr->Disks[frow][fcol].status == rf_ds_spared) {
+			if (raidPtr->Disks[frow][fcol].status ==
+			     rf_ds_dist_spared ||
+			    raidPtr->Disks[frow][fcol].status ==
+			     rf_ds_spared) {
 				done = 1;
 				break;
 			}
@@ -118,18 +120,20 @@ rf_CopybackReconstructedData(raidPtr)
 	}
 
 	if (frow == raidPtr->numRow) {
-		printf("COPYBACK:  no disks need copyback\n");
+		printf("COPYBACK: No disks need copyback.\n");
 		return;
 	}
 	badDisk = &raidPtr->Disks[frow][fcol];
 
 	proc = raidPtr->engine_thread;
 
-	/* This device may have been opened successfully the first time. Close
-	 * it before trying to open it again.. */
+	/*
+	 * This device may have been opened successfully the first time.
+	 * Close it before trying to open it again.
+	 */
 
 	if (raidPtr->raid_cinfo[frow][fcol].ci_vp != NULL) {
-		printf("Closed the open device: %s\n",
+		printf("Close the opened device: %s.\n",
 		    raidPtr->Disks[frow][fcol].devname);
  		vp = raidPtr->raid_cinfo[frow][fcol].ci_vp;
  		ac = raidPtr->Disks[frow][fcol].auto_configured;
@@ -137,32 +141,37 @@ rf_CopybackReconstructedData(raidPtr)
 		raidPtr->raid_cinfo[frow][fcol].ci_vp = NULL;
 
 	}
- 	/* note that this disk was *not* auto_configured (any longer) */
+ 	/* Note that this disk was *not* auto_configured (any longer). */
  	raidPtr->Disks[frow][fcol].auto_configured = 0;
- 
-	printf("About to (re-)open the device: %s\n",
+
+	printf("About to (re-)open the device: %s.\n",
 	    raidPtr->Disks[frow][fcol].devname);
 
 	retcode = raidlookup(raidPtr->Disks[frow][fcol].devname, proc, &vp);
 
 	if (retcode) {
-		printf("COPYBACK: raidlookup on device: %s failed: %d!\n",
+		printf("COPYBACK: raidlookup on device: %s failed: %d !\n",
 		    raidPtr->Disks[frow][fcol].devname, retcode);
 
-		/* XXX the component isn't responding properly... must be
-		 * still dead :-( */
+		/*
+		 * XXX The component isn't responding properly... Must be
+		 * still dead :-(
+		 */
 		return;
 
 	} else {
 
-		/* Ok, so we can at least do a lookup... How about actually
-		 * getting a vp for it? */
+		/*
+		 * Ok, so we can at least do a lookup...
+		 * How about actually getting a vp for it ?
+		 */
 
-		if ((retcode = VOP_GETATTR(vp, &va, proc->p_ucred, proc)) != 0) {
+		if ((retcode = VOP_GETATTR(vp, &va, proc->p_ucred, proc)) != 0)
+		{
 			return;
 		}
-		retcode = VOP_IOCTL(vp, DIOCGPART, (caddr_t) & dpart,
-		    FREAD, proc->p_ucred, proc);
+		retcode = VOP_IOCTL(vp, DIOCGPART, (caddr_t) &dpart, FREAD,
+		    proc->p_ucred, proc);
 		if (retcode) {
 			return;
 		}
@@ -174,38 +183,44 @@ rf_CopybackReconstructedData(raidPtr)
 		raidPtr->raid_cinfo[frow][fcol].ci_vp = vp;
 		raidPtr->raid_cinfo[frow][fcol].ci_dev = va.va_rdev;
 
-		raidPtr->Disks[frow][fcol].dev = va.va_rdev;	/* XXX or the above? */
+		/* XXX Or the above ? */
+		raidPtr->Disks[frow][fcol].dev = va.va_rdev;
 
-		/* we allow the user to specify that only a fraction of the
-		 * disks should be used this is just for debug:  it speeds up
-		 * the parity scan */
+		/*
+		 * We allow the user to specify that only a fraction of the
+		 * disks should be used this is just for debug: it speeds up
+		 * the parity scan.
+		 */
 		raidPtr->Disks[frow][fcol].numBlocks =
 		    raidPtr->Disks[frow][fcol].numBlocks *
 		    rf_sizePercentage / 100;
 	}
 #if 0
-	/* This is the way it was done before the CAM stuff was removed */
+	/* This is the way it was done before the CAM stuff was removed. */
 
 	if (rf_extract_ids(badDisk->devname, &bus, &targ, &lun)) {
-		printf("COPYBACK: unable to extract bus, target, lun from devname %s\n",
-		    badDisk->devname);
+		printf("COPYBACK: unable to extract bus, target, lun from"
+		    " devname %s.\n", badDisk->devname);
 		return;
 	}
-	/* TUR the disk that's marked as bad to be sure that it's actually
-	 * alive */
+	/*
+	 * TUR the disk that's marked as bad to be sure that it's actually
+	 * alive.
+	 */
 	rf_SCSI_AllocTUR(&tur_op);
 	retcode = rf_SCSI_DoTUR(tur_op, bus, targ, lun, badDisk->dev);
 	rf_SCSI_FreeDiskOp(tur_op, 0);
 #endif
 
 	if (retcode) {
-		printf("COPYBACK: target disk failed TUR\n");
+		printf("COPYBACK: target disk failed TUR.\n");
 		return;
 	}
-	/* get a buffer to hold one SU  */
-	RF_Malloc(databuf, rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit), (char *));
+	/* Get a buffer to hold one SU. */
+	RF_Malloc(databuf, rf_RaidAddressToByte(raidPtr,
+	    raidPtr->Layout.sectorsPerStripeUnit), (char *));
 
-	/* create a descriptor */
+	/* Create a descriptor. */
 	RF_Malloc(desc, sizeof(*desc), (RF_CopybackDesc_t *));
 	desc->raidPtr = raidPtr;
 	desc->status = 0;
@@ -215,124 +230,139 @@ rf_CopybackReconstructedData(raidPtr)
 	desc->spCol = badDisk->spareCol;
 	desc->stripeAddr = 0;
 	desc->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	desc->sectPerStripe = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.numDataCol;
+	desc->sectPerStripe = raidPtr->Layout.sectorsPerStripeUnit *
+	    raidPtr->Layout.numDataCol;
 	desc->databuf = databuf;
 	desc->mcpair = rf_AllocMCPair();
 
-	printf("COPYBACK: Quiescing the array\n");
-	/* quiesce the array, since we don't want to code support for user
-	 * accs here */
+	printf("COPYBACK: Quiescing the array.\n");
+	/*
+	 * Quiesce the array, since we don't want to code support for user
+	 * accs here.
+	 */
 	rf_SuspendNewRequestsAndWait(raidPtr);
 
-	/* adjust state of the array and of the disks */
+	/* Adjust state of the array and of the disks. */
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	raidPtr->Disks[desc->frow][desc->fcol].status = rf_ds_optimal;
 	raidPtr->status[desc->frow] = rf_rs_optimal;
-	rf_copyback_in_progress = 1;	/* debug only */
+	rf_copyback_in_progress = 1;	/* Debug only. */
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
 
 	printf("COPYBACK: Beginning\n");
 	RF_GETTIME(desc->starttime);
 	rf_ContinueCopyback(desc);
 
-	/* Data has been restored.  Fix up the component label. */
-	/* Don't actually need the read here.. */
-	raidread_component_label( raidPtr->raid_cinfo[frow][fcol].ci_dev,
-				  raidPtr->raid_cinfo[frow][fcol].ci_vp,
-				  &c_label);
-	
-	raid_init_component_label( raidPtr, &c_label );
+	/*
+	 * Data has been restored.
+	 * Fix up the component label.
+	 * Don't actually need the read here.
+	 */
+	raidread_component_label(raidPtr->raid_cinfo[frow][fcol].ci_dev,
+				 raidPtr->raid_cinfo[frow][fcol].ci_vp,
+				 &c_label);
+
+	raid_init_component_label(raidPtr, &c_label);
 
 	c_label.row = frow;
 	c_label.column = fcol;
 
-	raidwrite_component_label( raidPtr->raid_cinfo[frow][fcol].ci_dev,
-				   raidPtr->raid_cinfo[frow][fcol].ci_vp,
-				   &c_label);
+	raidwrite_component_label(raidPtr->raid_cinfo[frow][fcol].ci_dev,
+				  raidPtr->raid_cinfo[frow][fcol].ci_vp,
+				  &c_label);
 }
 
 
 /*
- * invoked via callback after a copyback I/O has completed to
- * continue on with the next one
+ * Invoked via callback after a copyback I/O has completed to
+ * continue on with the next one.
  */
-void 
-rf_ContinueCopyback(desc)
-	RF_CopybackDesc_t *desc;
+void
+rf_ContinueCopyback(RF_CopybackDesc_t *desc)
 {
 	RF_SectorNum_t testOffs, stripeAddr;
 	RF_Raid_t *raidPtr = desc->raidPtr;
 	RF_RaidAddr_t addr;
 	RF_RowCol_t testRow, testCol;
-	int     old_pctg, new_pctg, done;
+	int old_pctg, new_pctg, done;
 	struct timeval t, diff;
 
 	old_pctg = (-1);
 	while (1) {
 		stripeAddr = desc->stripeAddr;
-		desc->raidPtr->copyback_stripes_done = stripeAddr
-			/ desc->sectPerStripe;
+		desc->raidPtr->copyback_stripes_done = stripeAddr /
+		    desc->sectPerStripe;
 		if (rf_prReconSched) {
-			old_pctg = 100 * desc->stripeAddr / raidPtr->totalSectors;
+			old_pctg = 100 * desc->stripeAddr /
+			    raidPtr->totalSectors;
 		}
 		desc->stripeAddr += desc->sectPerStripe;
 		if (rf_prReconSched) {
-			new_pctg = 100 * desc->stripeAddr / raidPtr->totalSectors;
+			new_pctg = 100 * desc->stripeAddr /
+			    raidPtr->totalSectors;
 			if (new_pctg != old_pctg) {
 				RF_GETTIME(t);
 				RF_TIMEVAL_DIFF(&desc->starttime, &t, &diff);
-				printf("%d %d.%06d\n", new_pctg, (int) diff.tv_sec, (int) diff.tv_usec);
+				printf("%d %d.%06d\n", new_pctg,
+				    (int) diff.tv_sec, (int) diff.tv_usec);
 			}
 		}
 		if (stripeAddr >= raidPtr->totalSectors) {
 			rf_CopybackComplete(desc, 0);
 			return;
 		}
-		/* walk through the current stripe, su-by-su */
-		for (done = 0, addr = stripeAddr; addr < stripeAddr + desc->sectPerStripe; addr += desc->sectPerSU) {
+		/* Walk through the current stripe, su-by-su. */
+		for (done = 0, addr = stripeAddr;
+		     addr < stripeAddr + desc->sectPerStripe;
+		     addr += desc->sectPerSU) {
 
-			/* map the SU, disallowing remap to spare space */
-			(raidPtr->Layout.map->MapSector) (raidPtr, addr, &testRow, &testCol, &testOffs, RF_DONT_REMAP);
+			/* Map the SU, disallowing remap to spare space. */
+			(raidPtr->Layout.map->MapSector) (raidPtr, addr,
+			    &testRow, &testCol, &testOffs, RF_DONT_REMAP);
 
 			if (testRow == desc->frow && testCol == desc->fcol) {
-				rf_CopybackOne(desc, RF_COPYBACK_DATA, addr, testRow, testCol, testOffs);
+				rf_CopybackOne(desc, RF_COPYBACK_DATA, addr,
+				    testRow, testCol, testOffs);
 				done = 1;
 				break;
 			}
 		}
 
 		if (!done) {
-			/* we didn't find the failed disk in the data part.
-			 * check parity. */
-
-			/* map the parity for this stripe, disallowing remap
-			 * to spare space */
-			(raidPtr->Layout.map->MapParity) (raidPtr, stripeAddr, &testRow, &testCol, &testOffs, RF_DONT_REMAP);
+			/*
+			 * We didn't find the failed disk in the data part,
+			 * check parity.
+			 */
+
+			/*
+			 * Map the parity for this stripe, disallowing remap
+			 * to spare space.
+			 */
+			(raidPtr->Layout.map->MapParity) (raidPtr, stripeAddr,
+			    &testRow, &testCol, &testOffs, RF_DONT_REMAP);
 
 			if (testRow == desc->frow && testCol == desc->fcol) {
-				rf_CopybackOne(desc, RF_COPYBACK_PARITY, stripeAddr, testRow, testCol, testOffs);
+				rf_CopybackOne(desc, RF_COPYBACK_PARITY,
+				    stripeAddr, testRow, testCol, testOffs);
 			}
 		}
-		/* check to see if the last read/write pair failed */
+		/* Check to see if the last read/write pair failed. */
 		if (desc->status) {
 			rf_CopybackComplete(desc, 1);
 			return;
 		}
-		/* we didn't find any units to copy back in this stripe.
-		 * Continue with the next one */
+		/*
+		 * We didn't find any units to copy back in this stripe.
+		 * Continue with the next one.
+		 */
 	}
 }
 
 
-/* copyback one unit */
-static void 
-rf_CopybackOne(desc, typ, addr, testRow, testCol, testOffs)
-	RF_CopybackDesc_t *desc;
-	int     typ;
-	RF_RaidAddr_t addr;
-	RF_RowCol_t testRow;
-	RF_RowCol_t testCol;
-	RF_SectorNum_t testOffs;
+/* Copyback one unit. */
+void
+rf_CopybackOne(RF_CopybackDesc_t *desc, int typ, RF_RaidAddr_t addr,
+    RF_RowCol_t testRow, RF_RowCol_t testCol, RF_SectorNum_t testOffs)
 {
 	RF_SectorCount_t sectPerSU = desc->sectPerSU;
 	RF_Raid_t *raidPtr = desc->raidPtr;
@@ -340,37 +370,42 @@ rf_CopybackOne(desc, typ, addr, testRow, testCol, testOffs)
 	RF_RowCol_t spCol = desc->spCol;
 	RF_SectorNum_t spOffs;
 
-	/* find the spare spare location for this SU */
+	/* Find the spare location for this SU. */
 	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
 		if (typ == RF_COPYBACK_DATA)
-			raidPtr->Layout.map->MapSector(raidPtr, addr, &spRow, &spCol, &spOffs, RF_REMAP);
+			raidPtr->Layout.map->MapSector(raidPtr, addr, &spRow,
+			    &spCol, &spOffs, RF_REMAP);
 		else
-			raidPtr->Layout.map->MapParity(raidPtr, addr, &spRow, &spCol, &spOffs, RF_REMAP);
+			raidPtr->Layout.map->MapParity(raidPtr, addr, &spRow,
+			    &spCol, &spOffs, RF_REMAP);
 	} else {
 		spOffs = testOffs;
 	}
 
-	/* create reqs to read the old location & write the new */
+	/* Create reqs to read the old location & write the new. */
 	desc->readreq = rf_CreateDiskQueueData(RF_IO_TYPE_READ, spOffs,
-	    sectPerSU, desc->databuf, 0L, 0,
-	    (int (*) (void *, int)) rf_CopybackReadDoneProc, desc,
-	    NULL, NULL, (void *) raidPtr, RF_DISKQUEUE_DATA_FLAGS_NONE, NULL);
+	    sectPerSU, desc->databuf, 0L, 0, (int (*) (void *, int))
+	    rf_CopybackReadDoneProc, desc, NULL, NULL, (void *) raidPtr,
+	    RF_DISKQUEUE_DATA_FLAGS_NONE, NULL);
 	desc->writereq = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, testOffs,
-	    sectPerSU, desc->databuf, 0L, 0,
-	    (int (*) (void *, int)) rf_CopybackWriteDoneProc, desc,
-	    NULL, NULL, (void *) raidPtr, RF_DISKQUEUE_DATA_FLAGS_NONE, NULL);
+	    sectPerSU, desc->databuf, 0L, 0, (int (*) (void *, int))
+	    rf_CopybackWriteDoneProc, desc, NULL, NULL, (void *) raidPtr,
+	    RF_DISKQUEUE_DATA_FLAGS_NONE, NULL);
 	desc->frow = testRow;
 	desc->fcol = testCol;
 
-	/* enqueue the read.  the write will go out as part of the callback on
-	 * the read. at user-level & in the kernel, wait for the read-write
-	 * pair to complete. in the simulator, just return, since everything
-	 * will happen as callbacks */
+	/*
+	 * Enqueue the read. The write will go out as part of the callback on
+	 * the read. At user-level & in the kernel, wait for the read-write
+	 * pair to complete. In the simulator, just return, since everything
+	 * will happen as callbacks.
+	 */
 
 	RF_LOCK_MUTEX(desc->mcpair->mutex);
 	desc->mcpair->flag = 0;
 
-	rf_DiskIOEnqueue(&raidPtr->Queues[spRow][spCol], desc->readreq, RF_IO_NORMAL_PRIORITY);
+	rf_DiskIOEnqueue(&raidPtr->Queues[spRow][spCol], desc->readreq,
+	    RF_IO_NORMAL_PRIORITY);
 
 	while (!desc->mcpair->flag) {
 		RF_WAIT_MCPAIR(desc->mcpair);
@@ -382,42 +417,47 @@ rf_CopybackOne(desc, typ, addr, testRow, testCol, testOffs)
 }
 
 
-/* called at interrupt context when the read has completed.  just send out the write */
-static int 
-rf_CopybackReadDoneProc(desc, status)
-	RF_CopybackDesc_t *desc;
-	int     status;
+/*
+ * Called at interrupt context when the read has completed.
+ * Just send out the write.
+ */
+int
+rf_CopybackReadDoneProc(RF_CopybackDesc_t *desc, int status)
 {
-	if (status) {		/* invoke the callback with bad status */
-		printf("COPYBACK: copyback read failed.  Aborting.\n");
+	if (status) {		/* Invoke the callback with bad status. */
+		printf("COPYBACK: copyback read failed. Aborting.\n");
 		(desc->writereq->CompleteFunc) (desc, -100);
 	} else {
-		rf_DiskIOEnqueue(&(desc->raidPtr->Queues[desc->frow][desc->fcol]), desc->writereq, RF_IO_NORMAL_PRIORITY);
+		rf_DiskIOEnqueue(&(desc->raidPtr
+		    ->Queues[desc->frow][desc->fcol]),
+		    desc->writereq, RF_IO_NORMAL_PRIORITY);
 	}
 	return (0);
 }
-/* called at interrupt context when the write has completed.
- * at user level & in the kernel, wake up the copyback thread.
- * in the simulator, invoke the next copyback directly.
- * can't free diskqueuedata structs in the kernel b/c we're at interrupt context.
+
+
+/*
+ * Called at interrupt context when the write has completed.
+ * At user level & in the kernel, wake up the copyback thread.
+ * In the simulator, invoke the next copyback directly.
+ * Can't free diskqueuedata structs in the kernel because we're at
+ * interrupt context.
  */
-static int 
-rf_CopybackWriteDoneProc(desc, status)
-	RF_CopybackDesc_t *desc;
-	int     status;
+int
+rf_CopybackWriteDoneProc(RF_CopybackDesc_t *desc, int status)
 {
 	if (status && status != -100) {
-		printf("COPYBACK: copyback write failed.  Aborting.\n");
+		printf("COPYBACK: copyback write failed. Aborting.\n");
 	}
 	desc->status = status;
 	rf_MCPairWakeupFunc(desc->mcpair);
 	return (0);
 }
-/* invoked when the copyback has completed */
-static void 
-rf_CopybackComplete(desc, status)
-	RF_CopybackDesc_t *desc;
-	int     status;
+
+
+/* Invoked when the copyback has completed. */
+void
+rf_CopybackComplete(RF_CopybackDesc_t *desc, int status)
 {
 	RF_Raid_t *raidPtr = desc->raidPtr;
 	struct timeval t, diff;
@@ -428,13 +468,14 @@ rf_CopybackComplete(desc, status)
 			RF_ASSERT(raidPtr->Layout.map->parityConfig == 'D');
 			rf_FreeSpareTable(raidPtr);
 		} else {
-			raidPtr->Disks[desc->spRow][desc->spCol].status = rf_ds_spare;
+			raidPtr->Disks[desc->spRow][desc->spCol].status =
+			    rf_ds_spare;
 		}
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
 
 		RF_GETTIME(t);
 		RF_TIMEVAL_DIFF(&desc->starttime, &t, &diff);
-		printf("Copyback time was %d.%06d seconds\n",
+		printf("Copyback time was %d.%06d seconds.\n",
 		    (int) diff.tv_sec, (int) diff.tv_usec);
 	} else
 		printf("COPYBACK: Failure.\n");
diff --git a/sys/dev/raidframe/rf_copyback.h b/sys/dev/raidframe/rf_copyback.h
index d04066e291f..6ac073017dd 100644
--- a/sys/dev/raidframe/rf_copyback.h
+++ b/sys/dev/raidframe/rf_copyback.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_copyback.h,v 1.2 1999/02/16 00:02:27 niklas Exp $	*/
+/*	$OpenBSD: rf_copyback.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_copyback.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
+
 /*
  * rf_copyback.h
  */
@@ -30,32 +31,32 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_COPYBACK_H_
-#define _RF__RF_COPYBACK_H_
+#ifndef	_RF__RF_COPYBACK_H_
+#define	_RF__RF_COPYBACK_H_
 
 #include "rf_types.h"
 
 typedef struct RF_CopybackDesc_s {
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t frow;
-	RF_RowCol_t fcol;
-	RF_RowCol_t spRow;
-	RF_RowCol_t spCol;
-	int     status;
-	RF_StripeNum_t stripeAddr;
-	RF_SectorCount_t sectPerSU;
-	RF_SectorCount_t sectPerStripe;
-	char   *databuf;
-	RF_DiskQueueData_t *readreq;
-	RF_DiskQueueData_t *writereq;
-	struct timeval starttime;
-	RF_MCPair_t *mcpair;
-}       RF_CopybackDesc_t;
+	RF_Raid_t		*raidPtr;
+	RF_RowCol_t		 frow;
+	RF_RowCol_t		 fcol;
+	RF_RowCol_t		 spRow;
+	RF_RowCol_t		 spCol;
+	int			 status;
+	RF_StripeNum_t		 stripeAddr;
+	RF_SectorCount_t	 sectPerSU;
+	RF_SectorCount_t	 sectPerStripe;
+	char			*databuf;
+	RF_DiskQueueData_t	*readreq;
+	RF_DiskQueueData_t	*writereq;
+	struct timeval		 starttime;
+	RF_MCPair_t		*mcpair;
+} RF_CopybackDesc_t;
 
 extern int rf_copyback_in_progress;
 
-int     rf_ConfigureCopyback(RF_ShutdownList_t ** listp);
-void    rf_CopybackReconstructedData(RF_Raid_t * raidPtr);
-void    rf_ContinueCopyback(RF_CopybackDesc_t * desc);
+int  rf_ConfigureCopyback(RF_ShutdownList_t **);
+void rf_CopybackReconstructedData(RF_Raid_t *);
+void rf_ContinueCopyback(RF_CopybackDesc_t *);
 
-#endif				/* !_RF__RF_COPYBACK_H_ */
+#endif	/* !_RF__RF_COPYBACK_H_ */
diff --git a/sys/dev/raidframe/rf_cvscan.c b/sys/dev/raidframe/rf_cvscan.c
index 488e0501bcb..cf55ef631c9 100644
--- a/sys/dev/raidframe/rf_cvscan.c
+++ b/sys/dev/raidframe/rf_cvscan.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_cvscan.c,v 1.4 2000/01/07 14:50:20 peter Exp $	*/
+/*	$OpenBSD: rf_cvscan.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_cvscan.c,v 1.5 1999/08/13 03:41:53 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,13 +28,13 @@
  * rights to redistribute these changes.
  */
 
-/*******************************************************************************
+/*****************************************************************************
  *
  * cvscan.c --  prioritized cvscan disk queueing code.
  *
  * Nov 9, 1994, adapted from raidSim version (MCH)
  *
- ******************************************************************************/
+ *****************************************************************************/
 
 #include "rf_types.h"
 #include "rf_alloclist.h"
@@ -44,28 +45,40 @@
 #include "rf_debugMem.h"
 #include "rf_general.h"
 
-#define DO_CHECK_STATE(_hdr_) CheckCvscanState((_hdr_), __FILE__, __LINE__)
+void rf_CheckCvscanState(RF_CvscanHeader_t *, char *, int);
+void rf_PriorityInsert(RF_DiskQueueData_t **, RF_DiskQueueData_t *);
+void rf_ReqInsert(RF_DiskQueueData_t **, RF_DiskQueueData_t *,
+	RF_CvscanArmDir_t);
+RF_DiskQueueData_t *rf_ReqDequeue(RF_DiskQueueData_t **);
+void rf_ReBalance(RF_CvscanHeader_t *);
+void rf_Transfer(RF_DiskQueueData_t **, RF_DiskQueueData_t **);
+void rf_RealEnqueue(RF_CvscanHeader_t *, RF_DiskQueueData_t *);
+
+#define	DO_CHECK_STATE(_hdr_)	rf_CheckCvscanState((_hdr_), __FILE__, __LINE__)
+
+#define	pri_ok(p)	(((p) == RF_IO_NORMAL_PRIORITY) ||		\
+			 ((p) == RF_IO_LOW_PRIORITY))
 
-#define pri_ok(p)  ( ((p) == RF_IO_NORMAL_PRIORITY) || ((p) == RF_IO_LOW_PRIORITY))
 
-static void 
-CheckCvscanState(RF_CvscanHeader_t * hdr, char *file, int line)
+void
+rf_CheckCvscanState(RF_CvscanHeader_t *hdr, char *file, int line)
 {
-	long    i, key;
+	long i, key;
 	RF_DiskQueueData_t *tmp;
 
 	if (hdr->left != (RF_DiskQueueData_t *) NULL)
 		RF_ASSERT(hdr->left->sectorOffset < hdr->cur_block);
 	for (key = hdr->cur_block, i = 0, tmp = hdr->left;
-	    tmp != (RF_DiskQueueData_t *) NULL;
-	    key = tmp->sectorOffset, i++, tmp = tmp->next)
+	     tmp != (RF_DiskQueueData_t *) NULL;
+	     key = tmp->sectorOffset, i++, tmp = tmp->next)
 		RF_ASSERT(tmp->sectorOffset <= key
-		    && tmp->priority == hdr->nxt_priority && pri_ok(tmp->priority));
+		    && tmp->priority == hdr->nxt_priority && 
+		    pri_ok(tmp->priority));
 	RF_ASSERT(i == hdr->left_cnt);
 
 	for (key = hdr->cur_block, i = 0, tmp = hdr->right;
-	    tmp != (RF_DiskQueueData_t *) NULL;
-	    key = tmp->sectorOffset, i++, tmp = tmp->next) {
+	     tmp != (RF_DiskQueueData_t *) NULL;
+	     key = tmp->sectorOffset, i++, tmp = tmp->next) {
 		RF_ASSERT(key <= tmp->sectorOffset);
 		RF_ASSERT(tmp->priority == hdr->nxt_priority);
 		RF_ASSERT(pri_ok(tmp->priority));
@@ -73,8 +86,8 @@ CheckCvscanState(RF_CvscanHeader_t * hdr, char *file, int line)
 	RF_ASSERT(i == hdr->right_cnt);
 
 	for (key = hdr->nxt_priority - 1, tmp = hdr->burner;
-	    tmp != (RF_DiskQueueData_t *) NULL;
-	    key = tmp->priority, tmp = tmp->next) {
+	     tmp != (RF_DiskQueueData_t *) NULL;
+	     key = tmp->priority, tmp = tmp->next) {
 		RF_ASSERT(tmp);
 		RF_ASSERT(hdr);
 		RF_ASSERT(pri_ok(tmp->priority));
@@ -84,45 +97,47 @@ CheckCvscanState(RF_CvscanHeader_t * hdr, char *file, int line)
 }
 
 
-
-static void 
-PriorityInsert(RF_DiskQueueData_t ** list_ptr, RF_DiskQueueData_t * req)
+void
+rf_PriorityInsert(RF_DiskQueueData_t **list_ptr, RF_DiskQueueData_t *req)
 {
-	/* * insert block pointed to by req in to list whose first * entry is
-	 * pointed to by the pointer that list_ptr points to * ie., list_ptr
-	 * is a grandparent of the first entry */
+	/*
+	 * Insert block pointed to by req into list whose first entry is
+	 * pointed to by the pointer that list_ptr points to.
+	 * i.e. list_ptr is a grandparent of the first entry.
+	 */
 
 	for (; (*list_ptr) != (RF_DiskQueueData_t *) NULL &&
-	    (*list_ptr)->priority > req->priority;
-	    list_ptr = &((*list_ptr)->next)) {
+	       (*list_ptr)->priority > req->priority;
+	     list_ptr = &((*list_ptr)->next)) {
 	}
 	req->next = (*list_ptr);
 	(*list_ptr) = req;
 }
 
 
-
-static void 
-ReqInsert(RF_DiskQueueData_t ** list_ptr, RF_DiskQueueData_t * req, RF_CvscanArmDir_t order)
+void
+rf_ReqInsert(RF_DiskQueueData_t **list_ptr, RF_DiskQueueData_t *req,
+    RF_CvscanArmDir_t order)
 {
-	/* * insert block pointed to by req in to list whose first * entry is
-	 * pointed to by the pointer that list_ptr points to * ie., list_ptr
-	 * is a grandparent of the first entry */
+	/*
+	 * Insert block pointed to by req into list whose first entry is
+	 * pointed to by the pointer that list_ptr points to.
+	 * i.e. list_ptr is a grandparent of the first entry.
+	 */
 
 	for (; (*list_ptr) != (RF_DiskQueueData_t *) NULL &&
-
-	    ((order == rf_cvscan_RIGHT && (*list_ptr)->sectorOffset <= req->sectorOffset)
-		|| (order == rf_cvscan_LEFT && (*list_ptr)->sectorOffset > req->sectorOffset));
-	    list_ptr = &((*list_ptr)->next)) {
+	       ((order == rf_cvscan_RIGHT && (*list_ptr)->sectorOffset <=
+	       req->sectorOffset) || (order == rf_cvscan_LEFT &&
+	       (*list_ptr)->sectorOffset > req->sectorOffset));
+	     list_ptr = &((*list_ptr)->next)) {
 	}
 	req->next = (*list_ptr);
 	(*list_ptr) = req;
 }
 
 
-
-static RF_DiskQueueData_t *
-ReqDequeue(RF_DiskQueueData_t ** list_ptr)
+RF_DiskQueueData_t *
+rf_ReqDequeue(RF_DiskQueueData_t **list_ptr)
 {
 	RF_DiskQueueData_t *ret = (*list_ptr);
 	if ((*list_ptr) != (RF_DiskQueueData_t *) NULL) {
@@ -132,40 +147,39 @@ ReqDequeue(RF_DiskQueueData_t ** list_ptr)
 }
 
 
-
-static void 
-ReBalance(RF_CvscanHeader_t * hdr)
+void
+rf_ReBalance(RF_CvscanHeader_t *hdr)
 {
 	/* DO_CHECK_STATE(hdr); */
 	while (hdr->right != (RF_DiskQueueData_t *) NULL
 	    && hdr->right->sectorOffset < hdr->cur_block) {
 		hdr->right_cnt--;
 		hdr->left_cnt++;
-		ReqInsert(&hdr->left, ReqDequeue(&hdr->right), rf_cvscan_LEFT);
+		rf_ReqInsert(&hdr->left, rf_ReqDequeue(&hdr->right),
+		    rf_cvscan_LEFT);
 	}
 	/* DO_CHECK_STATE(hdr); */
 }
 
 
-
-static void 
-Transfer(RF_DiskQueueData_t ** to_list_ptr, RF_DiskQueueData_t ** from_list_ptr)
+void
+rf_Transfer(RF_DiskQueueData_t **to_list_ptr, RF_DiskQueueData_t **from_list_ptr)
 {
 	RF_DiskQueueData_t *gp;
 	for (gp = (*from_list_ptr); gp != (RF_DiskQueueData_t *) NULL;) {
 		RF_DiskQueueData_t *p = gp->next;
-		PriorityInsert(to_list_ptr, gp);
+		rf_PriorityInsert(to_list_ptr, gp);
 		gp = p;
 	}
 	(*from_list_ptr) = (RF_DiskQueueData_t *) NULL;
 }
 
 
-
-static void 
-RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
+void
+rf_RealEnqueue(RF_CvscanHeader_t *hdr, RF_DiskQueueData_t *req)
 {
-	RF_ASSERT(req->priority == RF_IO_NORMAL_PRIORITY || req->priority == RF_IO_LOW_PRIORITY);
+	RF_ASSERT(req->priority == RF_IO_NORMAL_PRIORITY ||
+	    req->priority == RF_IO_LOW_PRIORITY);
 
 	DO_CHECK_STATE(hdr);
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0) {
@@ -173,27 +187,27 @@ RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
 	}
 	if (req->priority > hdr->nxt_priority) {
 		/*
-		** dump all other outstanding requests on the back burner
-		*/
-		Transfer(&hdr->burner, &hdr->left);
-		Transfer(&hdr->burner, &hdr->right);
+		 * Dump all other outstanding requests on the back burner.
+		 */
+		rf_Transfer(&hdr->burner, &hdr->left);
+		rf_Transfer(&hdr->burner, &hdr->right);
 		hdr->left_cnt = 0;
 		hdr->right_cnt = 0;
 		hdr->nxt_priority = req->priority;
 	}
 	if (req->priority < hdr->nxt_priority) {
 		/*
-		** yet another low priority task!
-		*/
-		PriorityInsert(&hdr->burner, req);
+		 * Yet another low priority task !
+		 */
+		rf_PriorityInsert(&hdr->burner, req);
 	} else {
 		if (req->sectorOffset < hdr->cur_block) {
-			/* this request is to the left of the current arms */
-			ReqInsert(&hdr->left, req, rf_cvscan_LEFT);
+			/* This request is to the left of the current arms. */
+			rf_ReqInsert(&hdr->left, req, rf_cvscan_LEFT);
 			hdr->left_cnt++;
 		} else {
-			/* this request is to the right of the current arms */
-			ReqInsert(&hdr->right, req, rf_cvscan_RIGHT);
+			/* This request is to the right of the current arms. */
+			rf_ReqInsert(&hdr->right, req, rf_cvscan_RIGHT);
 			hdr->right_cnt++;
 		}
 	}
@@ -201,16 +215,14 @@ RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
 }
 
 
-
-void 
-rf_CvscanEnqueue(void *q_in, RF_DiskQueueData_t * elem, int priority)
+void
+rf_CvscanEnqueue(void *q_in, RF_DiskQueueData_t *elem, int priority)
 {
 	RF_CvscanHeader_t *hdr = (RF_CvscanHeader_t *) q_in;
-	RealEnqueue(hdr, elem /* req */ );
+	rf_RealEnqueue(hdr, elem /* req */ );
 }
 
 
-
 RF_DiskQueueData_t *
 rf_CvscanDequeue(void *q_in)
 {
@@ -224,17 +236,20 @@ rf_CvscanDequeue(void *q_in)
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0)
 		return ((RF_DiskQueueData_t *) NULL);
 
-	range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt, hdr->right_cnt));
+	range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt,
+	    hdr->right_cnt));
 	for (i = 0, tmp = hdr->left, sum_dist_left =
-	    ((hdr->direction == rf_cvscan_RIGHT) ? range * hdr->change_penalty : 0);
-	    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-	    tmp = tmp->next, i++) {
+	     ((hdr->direction == rf_cvscan_RIGHT) ?
+	      range * hdr->change_penalty : 0);
+	     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+	     tmp = tmp->next, i++) {
 		sum_dist_left += hdr->cur_block - tmp->sectorOffset;
 	}
 	for (i = 0, tmp = hdr->right, sum_dist_right =
-	    ((hdr->direction == rf_cvscan_LEFT) ? range * hdr->change_penalty : 0);
-	    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-	    tmp = tmp->next, i++) {
+	     ((hdr->direction == rf_cvscan_LEFT) ?
+	      range * hdr->change_penalty : 0);
+	     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+	     tmp = tmp->next, i++) {
 		sum_dist_right += tmp->sectorOffset - hdr->cur_block;
 	}
 
@@ -243,27 +258,28 @@ rf_CvscanDequeue(void *q_in)
 		hdr->cur_block = hdr->left->sectorOffset + hdr->left->numSector;
 		hdr->left_cnt = RF_MAX(hdr->left_cnt - 1, 0);
 		tmp = hdr->left;
-		ret = (ReqDequeue(&hdr->left)) /*->parent*/ ;
+		ret = (rf_ReqDequeue(&hdr->left)) /*->parent*/ ;
 	} else {
 		hdr->direction = rf_cvscan_RIGHT;
-		hdr->cur_block = hdr->right->sectorOffset + hdr->right->numSector;
+		hdr->cur_block = hdr->right->sectorOffset +
+		    hdr->right->numSector;
 		hdr->right_cnt = RF_MAX(hdr->right_cnt - 1, 0);
 		tmp = hdr->right;
-		ret = (ReqDequeue(&hdr->right)) /*->parent*/ ;
+		ret = (rf_ReqDequeue(&hdr->right)) /*->parent*/ ;
 	}
-	ReBalance(hdr);
+	rf_ReBalance(hdr);
 
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0
 	    && hdr->burner != (RF_DiskQueueData_t *) NULL) {
 		/*
-		** restore low priority requests for next dequeue
-		*/
+		 * Restore low priority requests for next dequeue.
+		 */
 		RF_DiskQueueData_t *burner = hdr->burner;
 		hdr->nxt_priority = burner->priority;
-		while (burner != (RF_DiskQueueData_t *) NULL
-		    && burner->priority == hdr->nxt_priority) {
+		while (burner != (RF_DiskQueueData_t *) NULL &&
+		    burner->priority == hdr->nxt_priority) {
 			RF_DiskQueueData_t *next = burner->next;
-			RealEnqueue(hdr, burner);
+			rf_RealEnqueue(hdr, burner);
 			burner = next;
 		}
 		hdr->burner = burner;
@@ -273,7 +289,6 @@ rf_CvscanDequeue(void *q_in)
 }
 
 
-
 RF_DiskQueueData_t *
 rf_CvscanPeek(void *q_in)
 {
@@ -286,17 +301,20 @@ rf_CvscanPeek(void *q_in)
 	if (hdr->left_cnt == 0 && hdr->right_cnt == 0)
 		headElement = NULL;
 	else {
-		range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt, hdr->right_cnt));
+		range = RF_MIN(hdr->range_for_avg, RF_MIN(hdr->left_cnt,
+		    hdr->right_cnt));
 		for (i = 0, tmp = hdr->left, sum_dist_left =
-		    ((hdr->direction == rf_cvscan_RIGHT) ? range * hdr->change_penalty : 0);
-		    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-		    tmp = tmp->next, i++) {
+		     ((hdr->direction == rf_cvscan_RIGHT) ?
+		      range * hdr->change_penalty : 0);
+		     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+		     tmp = tmp->next, i++) {
 			sum_dist_left += hdr->cur_block - tmp->sectorOffset;
 		}
 		for (i = 0, tmp = hdr->right, sum_dist_right =
-		    ((hdr->direction == rf_cvscan_LEFT) ? range * hdr->change_penalty : 0);
-		    tmp != (RF_DiskQueueData_t *) NULL && i < range;
-		    tmp = tmp->next, i++) {
+		     ((hdr->direction == rf_cvscan_LEFT) ?
+		      range * hdr->change_penalty : 0);
+		     tmp != (RF_DiskQueueData_t *) NULL && i < range;
+		     tmp = tmp->next, i++) {
 			sum_dist_right += tmp->sectorOffset - hdr->cur_block;
 		}
 
@@ -309,33 +327,31 @@ rf_CvscanPeek(void *q_in)
 }
 
 
-
 /*
-** CVSCAN( 1, 0 ) is Shortest Seek Time First (SSTF)
-**				lowest average response time
-** CVSCAN( 1, infinity ) is SCAN
-**				lowest response time standard deviation
-*/
+ * CVSCAN( 1, 0 ) is Shortest Seek Time First (SSTF)
+ *				lowest average response time
+ * CVSCAN( 1, infinity ) is SCAN
+ *				lowest response time standard deviation
+ */
 
 
-int 
-rf_CvscanConfigure()
+int
+rf_CvscanConfigure(void)
 {
 	return (0);
 }
 
 
-
 void   *
-rf_CvscanCreate(RF_SectorCount_t sectPerDisk,
-    RF_AllocListElem_t * clList,
-    RF_ShutdownList_t ** listp)
+rf_CvscanCreate(RF_SectorCount_t sectPerDisk, RF_AllocListElem_t *clList,
+    RF_ShutdownList_t **listp)
 {
 	RF_CvscanHeader_t *hdr;
-	long    range = 2;	/* Currently no mechanism to change these */
-	long    penalty = sectPerDisk / 5;
+	long range = 2;		/* Currently no mechanism to change these. */
+	long penalty = sectPerDisk / 5;
 
-	RF_MallocAndAdd(hdr, sizeof(RF_CvscanHeader_t), (RF_CvscanHeader_t *), clList);
+	RF_MallocAndAdd(hdr, sizeof(RF_CvscanHeader_t), (RF_CvscanHeader_t *),
+	    clList);
 	bzero((char *) hdr, sizeof(RF_CvscanHeader_t));
 	hdr->range_for_avg = RF_MAX(range, 1);
 	hdr->change_penalty = RF_MAX(penalty, 0);
@@ -351,10 +367,10 @@ rf_CvscanCreate(RF_SectorCount_t sectPerDisk,
 
 
 #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
-/* PrintCvscanQueue is not used, so we ignore it... */
+/* rf_PrintCvscanQueue is not used, so we ignore it... */
 #else
-static void 
-PrintCvscanQueue(RF_CvscanHeader_t * hdr)
+void
+rf_PrintCvscanQueue(RF_CvscanHeader_t *hdr)
 {
 	RF_DiskQueueData_t *tmp;
 
@@ -364,21 +380,24 @@ PrintCvscanQueue(RF_CvscanHeader_t * hdr)
 	    (int) hdr->cur_block,
 	    (hdr->direction == rf_cvscan_LEFT) ? "LEFT" : "RIGHT");
 	printf("\tLeft(%d): ", hdr->left_cnt);
-	for (tmp = hdr->left; tmp != (RF_DiskQueueData_t *) NULL; tmp = tmp->next)
+	for (tmp = hdr->left; tmp != (RF_DiskQueueData_t *) NULL;
+	     tmp = tmp->next)
 		printf("(%d,%ld,%d) ",
 		    (int) tmp->sectorOffset,
 		    (long) (tmp->sectorOffset + tmp->numSector),
 		    tmp->priority);
 	printf("\n");
 	printf("\tRight(%d): ", hdr->right_cnt);
-	for (tmp = hdr->right; tmp != (RF_DiskQueueData_t *) NULL; tmp = tmp->next)
+	for (tmp = hdr->right; tmp != (RF_DiskQueueData_t *) NULL;
+	     tmp = tmp->next)
 		printf("(%d,%ld,%d) ",
 		    (int) tmp->sectorOffset,
 		    (long) (tmp->sectorOffset + tmp->numSector),
 		    tmp->priority);
 	printf("\n");
 	printf("\tBurner: ");
-	for (tmp = hdr->burner; tmp != (RF_DiskQueueData_t *) NULL; tmp = tmp->next)
+	for (tmp = hdr->burner; tmp != (RF_DiskQueueData_t *) NULL;
+	     tmp = tmp->next)
 		printf("(%d,%ld,%d) ",
 		    (int) tmp->sectorOffset,
 		    (long) (tmp->sectorOffset + tmp->numSector),
@@ -388,21 +407,24 @@ PrintCvscanQueue(RF_CvscanHeader_t * hdr)
 #endif
 
 
-/* promotes reconstruction accesses for the given stripeID to normal priority.
- * returns 1 if an access was found and zero otherwise.  Normally, we should
- * only have one or zero entries in the burner queue, so execution time should
- * be short.
+/*
+ * Promote reconstruction accesses for the given stripeID to normal priority.
+ * Return 1 if an access was found and zero otherwise.
+ * Normally, we should only have one or zero entries in the burner queue,
+ * so execution time should be short.
  */
-int 
-rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID, RF_ReconUnitNum_t which_ru)
+int
+rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID,
+    RF_ReconUnitNum_t which_ru)
 {
 	RF_CvscanHeader_t *hdr = (RF_CvscanHeader_t *) q_in;
 	RF_DiskQueueData_t *trailer = NULL, *tmp = hdr->burner, *tlist = NULL;
-	int     retval = 0;
+	int retval = 0;
 
 	DO_CHECK_STATE(hdr);
-	while (tmp) {		/* handle entries at the front of the list */
-		if (tmp->parityStripeID == parityStripeID && tmp->which_ru == which_ru) {
+	while (tmp) {		/* Handle entries at the front of the list. */
+		if (tmp->parityStripeID == parityStripeID &&
+		    tmp->which_ru == which_ru) {
 			hdr->burner = tmp->next;
 			tmp->priority = RF_IO_NORMAL_PRIORITY;
 			tmp->next = tlist;
@@ -415,12 +437,13 @@ rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID, RF_ReconUnitNum_t wh
 		trailer = tmp;
 		tmp = tmp->next;
 	}
-	while (tmp) {		/* handle entries on the rest of the list */
-		if (tmp->parityStripeID == parityStripeID && tmp->which_ru == which_ru) {
+	while (tmp) {		/* Handle entries on the rest of the list. */
+		if (tmp->parityStripeID == parityStripeID &&
+		    tmp->which_ru == which_ru) {
 			trailer->next = tmp->next;
 			tmp->priority = RF_IO_NORMAL_PRIORITY;
 			tmp->next = tlist;
-			tlist = tmp;	/* insert on a temp queue */
+			tlist = tmp;	/* Insert on a temp queue. */
 			tmp = trailer->next;
 		} else {
 			trailer = tmp;
@@ -430,7 +453,7 @@ rf_CvscanPromote(void *q_in, RF_StripeNum_t parityStripeID, RF_ReconUnitNum_t wh
 	while (tlist) {
 		retval++;
 		tmp = tlist->next;
-		RealEnqueue(hdr, tlist);
+		rf_RealEnqueue(hdr, tlist);
 		tlist = tmp;
 	}
 	RF_ASSERT(retval == 0 || retval == 1);
diff --git a/sys/dev/raidframe/rf_cvscan.h b/sys/dev/raidframe/rf_cvscan.h
index 4175865e6d6..42b61d42df2 100644
--- a/sys/dev/raidframe/rf_cvscan.h
+++ b/sys/dev/raidframe/rf_cvscan.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_cvscan.h,v 1.2 1999/02/16 00:02:28 niklas Exp $	*/
+/*	$OpenBSD: rf_cvscan.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_cvscan.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,58 +29,55 @@
  */
 
 /*
-**	Disk scheduling by CVSCAN( N, r )
-**
-**	Given a set of requests, partition them into one set on each
-**	side of the current arm position.  The trick is to pick which
-**	side you are going to service next; once a side is picked you will
-**	service the closest request.
-**	Let there be n1 requests on one side and n2 requests on the other
-**	side.  If one of n1 or n2 is zero, select the other side.
-**	If both n1 and n2 are nonzero, select a "range" for examination
-**	that is N' = min( n1, n2, N ).  Average the distance from the
-**	current position to the nearest N' requests on each side giving
-**	d1 and d2.
-**	Suppose the last decision was to move toward set 2, then the
-**	current direction is toward set 2, and you will only switch to set
-**	1 if d1+R < d2 where R is r*(total number of cylinders), r in [0,1].
-**
-**	I extend this by applying only to the set of requests that all
-**	share the same, highest priority level.
-*/
+ *	Disk scheduling by CVSCAN( N, r )
+ *
+ *	Given a set of requests, partition them into one set on each
+ *	side of the current arm position.  The trick is to pick which
+ *	side you are going to service next; once a side is picked you will
+ *	service the closest request.
+ *	Let there be n1 requests on one side and n2 requests on the other
+ *	side.  If one of n1 or n2 is zero, select the other side.
+ *	If both n1 and n2 are nonzero, select a "range" for examination
+ *	that is N' = min( n1, n2, N ).  Average the distance from the
+ *	current position to the nearest N' requests on each side giving
+ *	d1 and d2.
+ *	Suppose the last decision was to move toward set 2, then the
+ *	current direction is toward set 2, and you will only switch to set
+ *	1 if d1+R < d2 where R is r*(total number of cylinders), r in [0,1].
+ *
+ *	I extend this by applying only to the set of requests that all
+ *	share the same, highest priority level.
+ */
 
-#ifndef _RF__RF_CVSCAN_H_
-#define _RF__RF_CVSCAN_H_
+#ifndef	_RF__RF_CVSCAN_H_
+#define	_RF__RF_CVSCAN_H_
 
 #include "rf_diskqueue.h"
 
 typedef enum RF_CvscanArmDir_e {
 	rf_cvscan_LEFT,
 	rf_cvscan_RIGHT
-}       RF_CvscanArmDir_t;
+} RF_CvscanArmDir_t;
 
 typedef struct RF_CvscanHeader_s {
-	long    range_for_avg;	/* CVSCAN param N */
-	long    change_penalty;	/* CVSCAN param R */
-	RF_CvscanArmDir_t direction;
-	RF_SectorNum_t cur_block;
-	int     nxt_priority;
-	RF_DiskQueueData_t *left;
-	int     left_cnt;
-	RF_DiskQueueData_t *right;
-	int     right_cnt;
-	RF_DiskQueueData_t *burner;
-}       RF_CvscanHeader_t;
+	long			 range_for_avg;		/* CVSCAN param N */
+	long			 change_penalty;	/* CVSCAN param R */
+	RF_CvscanArmDir_t	 direction;
+	RF_SectorNum_t		 cur_block;
+	int			 nxt_priority;
+	RF_DiskQueueData_t	*left;
+	int			 left_cnt;
+	RF_DiskQueueData_t	*right;
+	int			 right_cnt;
+	RF_DiskQueueData_t	*burner;
+} RF_CvscanHeader_t;
 
-int     rf_CvscanConfigure(void);
-void   *
-rf_CvscanCreate(RF_SectorCount_t sect_per_disk,
-    RF_AllocListElem_t * cl_list, RF_ShutdownList_t ** listp);
-void    rf_CvscanEnqueue(void *qptr, RF_DiskQueueData_t * req, int priority);
-RF_DiskQueueData_t *rf_CvscanDequeue(void *qptr);
-RF_DiskQueueData_t *rf_CvscanPeek(void *qptr);
-int 
-rf_CvscanPromote(void *qptr, RF_StripeNum_t parityStripeID,
-    RF_ReconUnitNum_t which_ru);
+int   rf_CvscanConfigure(void);
+void *rf_CvscanCreate(RF_SectorCount_t, RF_AllocListElem_t *,
+	RF_ShutdownList_t **);
+void  rf_CvscanEnqueue(void *, RF_DiskQueueData_t *, int);
+RF_DiskQueueData_t *rf_CvscanDequeue(void *);
+RF_DiskQueueData_t *rf_CvscanPeek(void *);
+int   rf_CvscanPromote(void *, RF_StripeNum_t, RF_ReconUnitNum_t);
 
-#endif				/* !_RF__RF_CVSCAN_H_ */
+#endif	/* !_RF__RF_CVSCAN_H_ */
diff --git a/sys/dev/raidframe/rf_dag.h b/sys/dev/raidframe/rf_dag.h
index 6221d88fbd4..f75153f7716 100644
--- a/sys/dev/raidframe/rf_dag.h
+++ b/sys/dev/raidframe/rf_dag.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dag.h,v 1.3 2002/06/14 21:34:59 todd Exp $	*/
+/*	$OpenBSD: rf_dag.h,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dag.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -33,8 +34,8 @@
  *                                                                          *
  ****************************************************************************/
 
-#ifndef _RF__RF_DAG_H_
-#define _RF__RF_DAG_H_
+#ifndef	_RF__RF_DAG_H_
+#define	_RF__RF_DAG_H_
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
@@ -45,38 +46,50 @@
 #include "rf_acctrace.h"
 #include "rf_memchunk.h"
 
-#define RF_THREAD_CONTEXT   0	/* we were invoked from thread context */
-#define RF_INTR_CONTEXT     1	/* we were invoked from interrupt context */
-#define RF_MAX_ANTECEDENTS 20	/* max num of antecedents a node may posses */
+#define	RF_THREAD_CONTEXT   0	/* We were invoked from thread context. */
+#define	RF_INTR_CONTEXT     1	/* We were invoked from interrupt context. */
+#define	RF_MAX_ANTECEDENTS 20	/* Max num of antecedents a node may possess. */
 
 #include <sys/buf.h>
 
-struct RF_PropHeader_s {	/* structure for propagation of results */
-	int     resultNum;	/* bind result # resultNum */
-	int     paramNum;	/* to parameter # paramNum */
-	RF_PropHeader_t *next;	/* linked list for multiple results/params */
+struct RF_PropHeader_s {	/* Structure for propagation of results. */
+	int		 resultNum;	/* Bind result # resultNum. */
+	int		 paramNum;	/* To parameter # paramNum. */
+	RF_PropHeader_t	*next;		/* Linked list for multiple
+					 * results/params. */
 };
 
 typedef enum RF_NodeStatus_e {
-	rf_bwd1,		/* node is ready for undo logging (backward
-				 * error recovery only) */
-	rf_bwd2,		/* node has completed undo logging (backward
-				 * error recovery only) */
-	rf_wait,		/* node is waiting to be executed */
-	rf_fired,		/* node is currently executing its do function */
-	rf_good,		/* node successfully completed execution of
-				 * its do function */
-	rf_bad,			/* node failed to successfully execute its do
-				 * function */
-	rf_skipped,		/* not used anymore, used to imply a node was
-				 * not executed */
-	rf_recover,		/* node is currently executing its undo
-				 * function */
-	rf_panic,		/* node failed to successfully execute its
-				 * undo function */
-	rf_undone		/* node successfully executed its undo
-				 * function */
-}       RF_NodeStatus_t;
+	rf_bwd1,	/*
+			 * Node is ready for undo logging
+			 * (backward error recovery only).
+			 */
+	rf_bwd2,	/*
+			 * Node has completed undo logging
+			 * (backward error recovery only).
+			 */
+	rf_wait,	/* Node is waiting to be executed. */
+	rf_fired,	/* Node is currently executing its do function. */
+	rf_good,	/*
+			 * Node successfully completed execution
+			 * of its do function.
+			 */
+	rf_bad,		/*
+			 * Node failed to successfully execute
+			 * its do function.
+			 */
+	rf_skipped,	/*
+			 * Not used anymore, used to imply a node
+			 * was not executed.
+			 */
+	rf_recover,	/* Node is currently executing its undo function. */
+	rf_panic,	/*
+			 * Node failed to successfully execute
+			 * its undo function.
+			 */
+	rf_undone	/* Node successfully executed its undo function. */
+} RF_NodeStatus_t;
+
 /*
  * These were used to control skipping a node.
  * Now, these are only used as comments.
@@ -86,151 +99,253 @@ typedef enum RF_AntecedentType_e {
 	rf_antiData,
 	rf_outputData,
 	rf_control
-}       RF_AntecedentType_t;
-#define RF_DAG_PTRCACHESIZE   40
-#define RF_DAG_PARAMCACHESIZE 12
+} RF_AntecedentType_t;
+#define	RF_DAG_PTRCACHESIZE	40
+#define	RF_DAG_PARAMCACHESIZE	12
 
 typedef RF_uint8 RF_DagNodeFlags_t;
 
 struct RF_DagNode_s {
-	RF_NodeStatus_t status;	/* current status of this node */
-	int     (*doFunc) (RF_DagNode_t *);	/* normal function */
-	int     (*undoFunc) (RF_DagNode_t *);	/* func to remove effect of
-						 * doFunc */
-	int     (*wakeFunc) (RF_DagNode_t *, int status);	/* func called when the
-								 * node completes an I/O */
-	int     numParams;	/* number of parameters required by *funcPtr */
-	int     numResults;	/* number of results produced by *funcPtr */
-	int     numAntecedents;	/* number of antecedents */
-	int     numAntDone;	/* number of antecedents which have finished */
-	int     numSuccedents;	/* number of succedents */
-	int     numSuccFired;	/* incremented when a succedent is fired
-				 * during forward execution */
-	int     numSuccDone;	/* incremented when a succedent finishes
-				 * during rollBackward */
-	int     commitNode;	/* boolean flag - if true, this is a commit
-				 * node */
-	RF_DagNode_t **succedents;	/* succedents, array size
-					 * numSuccedents */
-	RF_DagNode_t **antecedents;	/* antecedents, array size
-					 * numAntecedents */
-	RF_AntecedentType_t antType[RF_MAX_ANTECEDENTS];	/* type of each
-								 * antecedent */
-	void  **results;	/* array of results produced by *funcPtr */
-	RF_DagParam_t *params;	/* array of parameters required by *funcPtr */
-	RF_PropHeader_t **propList;	/* propagation list, size
-					 * numSuccedents */
-	RF_DagHeader_t *dagHdr;	/* ptr to head of dag containing this node */
-	void   *dagFuncData;	/* dag execution func uses this for whatever
-				 * it wants */
-	RF_DagNode_t *next;
-	int     nodeNum;	/* used by PrintDAG for debug only */
-	int     visited;	/* used to avoid re-visiting nodes on DAG
-				 * walks */
-	/* ANY CODE THAT USES THIS FIELD MUST MAINTAIN THE PROPERTY THAT AFTER
-	 * IT FINISHES, ALL VISITED FLAGS IN THE DAG ARE IDENTICAL */
-	char   *name;		/* debug only */
-	RF_DagNodeFlags_t flags;/* see below */
-	RF_DagNode_t *dag_ptrs[RF_DAG_PTRCACHESIZE];	/* cache for performance */
-	RF_DagParam_t dag_params[RF_DAG_PARAMCACHESIZE];	/* cache for performance */
+	RF_NodeStatus_t	  status;	/* Current status of this node. */
+	int		(*doFunc) (RF_DagNode_t *);
+					/* Normal function. */
+	int		(*undoFunc) (RF_DagNode_t *);
+					/* Func to remove effect of doFunc. */
+	int		(*wakeFunc) (RF_DagNode_t *, int status);
+					/*
+					 * Func called when the node completes
+					 * an I/O.
+					 */
+	int		  numParams;	/*
+					 * Number of parameters required
+					 * by *funcPtr.
+					 */
+	int		  numResults;	/*
+					 * Number of results produced
+					 * by *funcPtr.
+					 */
+	int		  numAntecedents; /* Number of antecedents. */
+	int		  numAntDone;	/*
+					 * Number of antecedents that
+					 * have finished.
+					 */
+	int		  numSuccedents; /* Number of succedents. */
+	int		  numSuccFired;	/*
+					 * Incremented when a succedent
+					 * is fired during forward execution.
+					 */
+	int		  numSuccDone;	/*
+					 * Incremented when a succedent
+					 * finishes during rollBackward.
+					 */
+	int		  commitNode;	/*
+					 * Boolean flag - if true, this is
+					 * a commit node.
+					 */
+	RF_DagNode_t	**succedents;	/*
+					 * Succedents, array size
+					 * numSuccedents.
+					 */
+	RF_DagNode_t	**antecedents;	/*
+					 * Antecedents, array size
+					 * numAntecedents.
+					 */
+	RF_AntecedentType_t antType[RF_MAX_ANTECEDENTS];
+					/* Type of each antecedent. */
+	void		**results;	/*
+					 * Array of results produced
+					 * by *funcPtr.
+					 */
+	RF_DagParam_t	 *params;	/*
+					 * Array of parameters required
+					 * by *funcPtr.
+					 */
+	RF_PropHeader_t	**propList;	/*
+					 * Propagation list,
+					 * size numSuccedents.
+					 */
+	RF_DagHeader_t	 *dagHdr;	/*
+					 * Ptr to head of dag containing
+					 * this node.
+					 */
+	void		 *dagFuncData;	/*
+					 * Dag execution func uses this
+					 * for whatever it wants.
+					 */
+	RF_DagNode_t	 *next;
+	int		  nodeNum;	/* Used by PrintDAG for debug only. */
+	int		  visited;	/*
+					 * Used to avoid re-visiting
+					 * nodes on DAG walks.
+					 */
+	/*
+	 * ANY CODE THAT USES THIS FIELD MUST MAINTAIN THE PROPERTY THAT
+	 * AFTER IT FINISHES, ALL VISITED FLAGS IN THE DAG ARE IDENTICAL.
+	 */
+
+	char		 *name;		/* Debug only. */
+	RF_DagNodeFlags_t flags;	/* See below. */
+	RF_DagNode_t	 *dag_ptrs[RF_DAG_PTRCACHESIZE];
+					/* Cache for performance. */
+	RF_DagParam_t	  dag_params[RF_DAG_PARAMCACHESIZE];
+					/* Cache for performance. */
 };
+
 /*
- * Bit values for flags field of RF_DagNode_t
+ * Bit values for flags field of RF_DagNode_t.
  */
-#define RF_DAGNODE_FLAG_NONE  0x00
-#define RF_DAGNODE_FLAG_YIELD 0x01	/* in the kernel, yield the processor
-					 * before firing this node */
+#define	RF_DAGNODE_FLAG_NONE	0x00
+#define	RF_DAGNODE_FLAG_YIELD	0x01	/*
+					 * In the kernel, yield the processor
+					 * before firing this node.
+					 */
 
-/* enable - DAG ready for normal execution, no errors encountered
- * rollForward - DAG encountered an error after commit point, rolling forward
- * rollBackward - DAG encountered an error prior to commit point, rolling backward
+/*
+ * rf_enable	   - DAG ready for normal execution, no errors encountered.
+ * rf_rollForward  - DAG encountered an error after commit point, rolling
+ *		     forward.
+ * rf_rollBackward - DAG encountered an error prior to commit point, rolling
+ *		     backward.
  */
 typedef enum RF_DagStatus_e {
 	rf_enable,
 	rf_rollForward,
 	rf_rollBackward
-}       RF_DagStatus_t;
-#define RF_MAX_HDR_SUCC 1
+} RF_DagStatus_t;
+
+#define	RF_MAX_HDR_SUCC		 1
 
-#define RF_MAXCHUNKS 10
+#define	RF_MAXCHUNKS		10
 
 struct RF_DagHeader_s {
-	RF_DagStatus_t status;	/* status of this DAG */
-	int     numSuccedents;	/* DAG may be a tree, i.e. may have > 1 root */
-	int     numCommitNodes;	/* number of commit nodes in graph */
-	int     numCommits;	/* number of commit nodes which have been
-				 * fired  */
-	RF_DagNode_t *succedents[RF_MAX_HDR_SUCC];	/* array of succedents,
-							 * size numSuccedents */
-	RF_DagHeader_t *next;	/* ptr to allow a list of dags */
-	RF_AllocListElem_t *allocList;	/* ptr to list of ptrs to be freed
-					 * prior to freeing DAG */
-	RF_AccessStripeMapHeader_t *asmList;	/* list of access stripe maps
-						 * to be freed */
-	int     nodeNum;	/* used by PrintDAG for debug only */
-	int     numNodesCompleted;
-	RF_AccTraceEntry_t *tracerec;	/* perf mon only */
-
-	void    (*cbFunc) (void *);	/* function to call when the dag
-					 * completes */
-	void   *cbArg;		/* argument for cbFunc */
-	char   *creator;	/* name of function used to create this dag */
-
-	RF_Raid_t *raidPtr;	/* the descriptor for the RAID device this DAG
-				 * is for */
-	void   *bp;		/* the bp for this I/O passed down from the
-				 * file system. ignored outside kernel */
-
-	RF_ChunkDesc_t *memChunk[RF_MAXCHUNKS];	/* experimental- Chunks of
-						 * memory to be retained upon
-						 * DAG free for re-use */
-	int     chunkIndex;	/* the idea is to avoid calls to alloc and
-				 * free */
+	RF_DagStatus_t	  status;		/* Status of this DAG. */
+	int		  numSuccedents;	/*
+						 * DAG may be a tree,
+						 * i.e. may have > 1 root.
+						 */
+	int		  numCommitNodes;	/*
+						 * Number of commit nodes
+						 * in graph.
+						 */
+	int		  numCommits;		/*
+						 * Number of commit nodes
+						 * that have been fired.
+						 */
+	RF_DagNode_t	 *succedents[RF_MAX_HDR_SUCC];	/*
+							 * Array of succedents,
+							 * size numSuccedents.
+							 */
+	RF_DagHeader_t	 *next;			/*
+						 * Ptr to allow a list
+						 * of dags.
+						 */
+	RF_AllocListElem_t *allocList;		/*
+						 * Ptr to list of ptrs
+						 * to be freed prior to
+						 * freeing DAG.
+						 */
+	RF_AccessStripeMapHeader_t *asmList;	/*
+						 * List of access stripe maps
+						 * to be freed.
+						 */
+	int		  nodeNum;		/*
+						 * Used by PrintDAG for
+						 * debug only.
+						 */
+	int		  numNodesCompleted;
+	RF_AccTraceEntry_t *tracerec;		/* Perf mon only. */
 
-	RF_ChunkDesc_t **xtraMemChunk;	/* escape hatch which allows
-					 * SelectAlgorithm to merge memChunks
-					 * from several dags */
-	int     xtraChunkIndex;	/* number of ptrs to valid chunks */
-	int     xtraChunkCnt;	/* number of ptrs to chunks allocated */
+	void		(*cbFunc) (void *);	/*
+						 * Function to call when
+						 * the dag completes.
+						 */
+	void		 *cbArg;		/* Argument for cbFunc. */
+	char		 *creator;		/*
+						 * Name of function used
+						 * to create this dag.
+						 */
 
+	RF_Raid_t	 *raidPtr;		/*
+						 * The descriptor for the
+						 * RAID device this DAG
+						 * is for.
+						 */
+	void		 *bp;			/*
+						 * The bp for this I/O passed
+						 * down from the file system.
+						 * ignored outside kernel.
+						 */
+
+	RF_ChunkDesc_t	 *memChunk[RF_MAXCHUNKS]; /*
+						 * Experimental- Chunks of
+						 * memory to be retained upon
+						 * DAG free for re-use.
+						 */
+	int		  chunkIndex;		/*
+						 * The idea is to avoid calls
+						 * to alloc and free.
+						 */
+
+	RF_ChunkDesc_t	**xtraMemChunk;		/*
+						 * Escape hatch that allows
+						 * SelectAlgorithm to merge
+						 * memChunks from several dags.
+						 */
+	int		  xtraChunkIndex;	/*
+						 * Number of ptrs to valid
+						 * chunks.
+						 */
+	int		  xtraChunkCnt;		/*
+						 * Number of ptrs to chunks
+						 * allocated.
+						 */
 };
 
 struct RF_DagList_s {
-	/* common info for a list of dags which will be fired sequentially */
-	int     numDags;	/* number of dags in the list */
-	int     numDagsFired;	/* number of dags in list which have initiated
-				 * execution */
-	int     numDagsDone;	/* number of dags in list which have completed
-				 * execution */
-	RF_DagHeader_t *dags;	/* list of dags */
-	RF_RaidAccessDesc_t *desc;	/* ptr to descriptor for this access */
-	RF_AccTraceEntry_t tracerec;	/* perf mon info for dags (not user
-					 * info) */
+	/* Common info for a list of dags that will be fired sequentially. */
+	int		 numDags;	/* Number of dags in the list. */
+	int		 numDagsFired;	/*
+					 * Number of dags in list that
+					 * have initiated execution.
+					 */
+	int		 numDagsDone;	/*
+					 * Number of dags in list that
+					 * have completed execution.
+					 */
+	RF_DagHeader_t	*dags;		/* List of dags. */
+	RF_RaidAccessDesc_t *desc;	/* Ptr to descriptor for this access. */
+	RF_AccTraceEntry_t tracerec;	/*
+					 * Perf mon info for dags (not user
+					 * info).
+					 */
 };
-/* resets a node so that it can be fired again */
-#define RF_ResetNode(_n_)  { \
-  (_n_)->status = rf_wait;   \
-  (_n_)->numAntDone = 0;     \
-  (_n_)->numSuccFired = 0;   \
-  (_n_)->numSuccDone = 0;    \
-  (_n_)->next = NULL;        \
-}
-
-#define RF_ResetDagHeader(_h_) { \
-  (_h_)->numNodesCompleted = 0;  \
-  (_h_)->numCommits = 0;         \
-  (_h_)->status = rf_enable;     \
-}
-
-/* convenience macro for declaring a create dag function */
-
-#define RF_CREATE_DAG_FUNC_DECL(_name_) \
-void _name_ ( \
-	RF_Raid_t             *raidPtr, \
-	RF_AccessStripeMap_t  *asmap, \
-	RF_DagHeader_t        *dag_h, \
-	void                  *bp, \
-	RF_RaidAccessFlags_t   flags, \
-	RF_AllocListElem_t    *allocList)
-
-#endif				/* !_RF__RF_DAG_H_ */
+
+/* Reset a node so that it can be fired again. */
+#define	RF_ResetNode(_n_)	do {					\
+	(_n_)->status = rf_wait;					\
+	(_n_)->numAntDone = 0;						\
+	(_n_)->numSuccFired = 0;					\
+	(_n_)->numSuccDone = 0;						\
+	(_n_)->next = NULL;						\
+} while (0)
+
+#define	RF_ResetDagHeader(_h_)	do {					\
+	(_h_)->numNodesCompleted = 0;					\
+	(_h_)->numCommits = 0;						\
+	(_h_)->status = rf_enable;					\
+} while (0)
+
+/* Convenience macro for declaring a create dag function. */
+#define	RF_CREATE_DAG_FUNC_DECL(_name_)					\
+void _name_ (RF_Raid_t *, RF_AccessStripeMap_t *, RF_DagHeader_t *,	\
+    void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);		\
+void _name_ (								\
+	RF_Raid_t		*raidPtr,				\
+	RF_AccessStripeMap_t	*asmap,					\
+	RF_DagHeader_t		*dag_h,					\
+	void			*bp,					\
+	RF_RaidAccessFlags_t	 flags,					\
+	RF_AllocListElem_t	*allocList				\
+)
+
+#endif	/* !_RF__RF_DAG_H_ */
diff --git a/sys/dev/raidframe/rf_dagdegrd.c b/sys/dev/raidframe/rf_dagdegrd.c
index 306fa952d48..be1d06ad1ee 100644
--- a/sys/dev/raidframe/rf_dagdegrd.c
+++ b/sys/dev/raidframe/rf_dagdegrd.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagdegrd.c,v 1.4 2000/01/11 18:02:20 peter Exp $	*/
+/*	$OpenBSD: rf_dagdegrd.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagdegrd.c,v 1.5 2000/01/07 03:40:57 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -30,7 +31,7 @@
 /*
  * rf_dagdegrd.c
  *
- * code for creating degraded read DAGs
+ * Code for creating degraded read DAGs.
  */
 
 #include "rf_types.h"
@@ -44,14 +45,14 @@
 #include "rf_dagdegrd.h"
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * General comments on DAG creation:
  *
- * All DAGs in this file use roll-away error recovery.  Each DAG has a single
- * commit node, usually called "Cmt."  If an error occurs before the Cmt node
+ * All DAGs in this file use roll-away error recovery. Each DAG has a single
+ * commit node, usually called "Cmt". If an error occurs before the Cmt node
  * is reached, the execution engine will halt forward execution and work
- * backward through the graph, executing the undo functions.  Assuming that
+ * backward through the graph, executing the undo functions. Assuming that
  * each node in the graph prior to the Cmt node are undoable and atomic - or -
  * does not make changes to permanent state, the graph will fail atomically.
  * If an error occurs after the Cmt node executes, the engine will roll-forward
@@ -60,67 +61,69 @@
  *
  * A graph has only 1 Cmt node.
  *
- */
+ *****************************************************************************/
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * The following wrappers map the standard DAG creation interface to the
- * DAG creation routines.  Additionally, these wrappers enable experimentation
+ * DAG creation routines. Additionally, these wrappers enable experimentation
  * with new DAG structures by providing an extra level of indirection, allowing
  * the DAG creation routines to be replaced at this single point.
- */
+ *
+ *****************************************************************************/
 
-void 
+void
 rf_CreateRaidFiveDegradedReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+    RF_Raid_t			*raidPtr,
+    RF_AccessStripeMap_t	*asmap,
+    RF_DagHeader_t		*dag_h,
+    void			*bp,
+    RF_RaidAccessFlags_t	 flags,
+    RF_AllocListElem_t		*allocList)
 {
 	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    &rf_xorRecoveryFuncs);
 }
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * DAG creation code begins here
- */
+ * DAG creation code begins here.
+ *
+ *****************************************************************************/
 
 
-/******************************************************************************
- * Create a degraded read DAG for RAID level 1
+/*****************************************************************************
+ * Create a degraded read DAG for RAID level 1.
  *
  * Hdr -> Nil -> R(p/s)d -> Commit -> Trm
  *
- * The "Rd" node reads data from the surviving disk in the mirror pair
+ * The "Rd" node reads data from the surviving disk in the mirror pair.
  *   Rpd - read of primary copy
  *   Rsd - read of secondary copy
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (for holding write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
+ * Parameters:	raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (for holding write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
  *****************************************************************************/
 
-void 
+void
 rf_CreateRaidOneDegradedReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+    RF_Raid_t			*raidPtr,
+    RF_AccessStripeMap_t	*asmap,
+    RF_DagHeader_t		*dag_h,
+    void			*bp,
+    RF_RaidAccessFlags_t	 flags,
+    RF_AllocListElem_t		*allocList)
 {
 	RF_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
 	RF_StripeNum_t parityStripeID;
 	RF_ReconUnitNum_t which_ru;
 	RF_PhysDiskAddr_t *pda;
-	int     useMirror, i;
+	int useMirror, i;
 
 	useMirror = 0;
 	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
@@ -129,14 +132,15 @@ rf_CreateRaidOneDegradedReadDAG(
 		printf("[Creating RAID level 1 degraded read DAG]\n");
 	}
 	dag_h->creator = "RaidOneDegradedReadDAG";
-	/* alloc the Wnd nodes and the Wmir node */
+	/* Alloc the Wnd nodes and the Wmir node. */
 	if (asmap->numDataFailed == 0)
 		useMirror = RF_FALSE;
 	else
 		useMirror = RF_TRUE;
 
-	/* total number of nodes = 1 + (block + commit + terminator) */
-	RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	/* Total number of nodes = 1 + (block + commit + terminator). */
+	RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *),
+	    allocList);
 	i = 0;
 	rdNode = &nodes[i];
 	i++;
@@ -147,65 +151,71 @@ rf_CreateRaidOneDegradedReadDAG(
 	termNode = &nodes[i];
 	i++;
 
-	/* this dag can not commit until the commit node is reached.   errors
+	/*
+	 * This dag can not commit until the commit node is reached. Errors
 	 * prior to the commit point imply the dag has failed and must be
-	 * retried */
+	 * retried.
+	 */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	/* initialize the block, commit, and terminator nodes */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+	/* Initialize the block, commit, and terminator nodes. */
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
 
 	pda = asmap->physInfo;
 	RF_ASSERT(pda != NULL);
-	/* parityInfo must describe entire parity unit */
+	/* parityInfo must describe entire parity unit. */
 	RF_ASSERT(asmap->parityInfo->next == NULL);
 
-	/* initialize the data node */
+	/* Initialize the data node. */
 	if (!useMirror) {
-		/* read primary copy of data */
-		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rpd", allocList);
+		/* Read primary copy of data. */
+		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
+		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Rpd", allocList);
 		rdNode->params[0].p = pda;
 		rdNode->params[1].p = pda->bufPtr;
 		rdNode->params[2].v = parityStripeID;
-		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+		    0, 0, which_ru);
 	} else {
-		/* read secondary copy of data */
-		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rsd", allocList);
+		/* Read secondary copy of data. */
+		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
+		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Rsd", allocList);
 		rdNode->params[0].p = asmap->parityInfo;
 		rdNode->params[1].p = pda->bufPtr;
 		rdNode->params[2].v = parityStripeID;
-		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+		    0, 0, which_ru);
 	}
 
-	/* connect header to block node */
+	/* Connect header to block node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* connect block node to rdnode */
+	/* Connect block node to rdnode. */
 	RF_ASSERT(blockNode->numSuccedents == 1);
 	RF_ASSERT(rdNode->numAntecedents == 1);
 	blockNode->succedents[0] = rdNode;
 	rdNode->antecedents[0] = blockNode;
 	rdNode->antType[0] = rf_control;
 
-	/* connect rdnode to commit node */
+	/* Connect rdnode to commit node. */
 	RF_ASSERT(rdNode->numSuccedents == 1);
 	RF_ASSERT(commitNode->numAntecedents == 1);
 	rdNode->succedents[0] = commitNode;
 	commitNode->antecedents[0] = rdNode;
 	commitNode->antType[0] = rf_control;
 
-	/* connect commit node to terminator */
+	/* Connect commit node to terminator. */
 	RF_ASSERT(commitNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -215,64 +225,64 @@ rf_CreateRaidOneDegradedReadDAG(
 }
 
 
-
-/******************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a degraded-mode read of data within one stripe.
+ * Create a DAG to perform a degraded-mode read of data within one stripe.
  * This DAG is as follows:
  *
  * Hdr -> Block -> Rud -> Xor -> Cmt -> T
- *              -> Rrd ->
- *              -> Rp -->
+ *		-> Rrd ->
+ *		-> Rp -->
  *
- * Each R node is a successor of the L node
- * One successor arc from each R node goes to C, and the other to X
+ * Each R node is a successor of the L node.
+ * One successor arc from each R node goes to C, and the other to X.
  * There is one Rud for each chunk of surviving user data requested by the
  * user, and one Rrd for each chunk of surviving user data _not_ being read by
- * the user
+ * the user.
  * R = read, ud = user data, rd = recovery (surviving) data, p = parity
  * X = XOR, C = Commit, T = terminate
  *
  * The block node guarantees a single source node.
  *
  * Note:  The target buffer for the XOR node is set to the actual user buffer
- * where the failed data is supposed to end up.  This buffer is zero'd by the
- * code here.  Thus, if you create a degraded read dag, use it, and then
+ * where the failed data is supposed to end up. This buffer is zero'd by the
+ * code here. Thus, if you create a degraded read dag, use it, and then
  * re-use, you have to be sure to zero the target buffer prior to the re-use.
  *
  * The recfunc argument at the end specifies the name and function used for
- * the redundancy
- * recovery function.
+ * the redundancy recovery function.
  *
  *****************************************************************************/
 
-void 
+void
 rf_CreateDegradedReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_RedFuncs_t * recFunc)
+    RF_Raid_t			*raidPtr,
+    RF_AccessStripeMap_t	*asmap,
+    RF_DagHeader_t		*dag_h,
+    void			*bp,
+    RF_RaidAccessFlags_t	 flags,
+    RF_AllocListElem_t		*allocList,
+    RF_RedFuncs_t		*recFunc)
 {
 	RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *xorNode, *blockNode;
 	RF_DagNode_t *commitNode, *rpNode, *termNode;
-	int     nNodes, nRrdNodes, nRudNodes, nXorBufs, i;
-	int     j, paramNum;
+	int nNodes, nRrdNodes, nRudNodes, nXorBufs, i;
+	int j, paramNum;
 	RF_SectorCount_t sectorsPerSU;
 	RF_ReconUnitNum_t which_ru;
-	char   *overlappingPDAs;/* a temporary array of flags */
+	char *overlappingPDAs;		/* A temporary array of flags. */
 	RF_AccessStripeMapHeader_t *new_asm_h[2];
 	RF_PhysDiskAddr_t *pda, *parityPDA;
 	RF_StripeNum_t parityStripeID;
 	RF_PhysDiskAddr_t *failedPDA;
 	RF_RaidLayout_t *layoutPtr;
-	char   *rpBuf;
+	char *rpBuf;
 
 	layoutPtr = &(raidPtr->Layout);
-	/* failedPDA points to the pda within the asm that targets the failed
-	 * disk */
+	/*
+	 * failedPDA points to the pda within the asm that targets
+	 * the failed disk.
+	 */
 	failedPDA = asmap->failedPDAs[0];
 	parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr,
 	    asmap->raidAddress, &which_ru);
@@ -285,25 +295,30 @@ rf_CreateDegradedReadDAG(
 	dag_h->creator = "DegradedReadDAG";
 
 	/*
-         * generate two ASMs identifying the surviving data we need
-         * in order to recover the lost data
-         */
+	 * Generate two ASMs identifying the surviving data we need
+	 * in order to recover the lost data.
+	 */
 
-	/* overlappingPDAs array must be zero'd */
-	RF_Calloc(overlappingPDAs, asmap->numStripeUnitsAccessed, sizeof(char), (char *));
-	rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h, new_asm_h, &nXorBufs,
-	    &rpBuf, overlappingPDAs, allocList);
+	/* overlappingPDAs array must be zero'd. */
+	RF_Calloc(overlappingPDAs, asmap->numStripeUnitsAccessed,
+	    sizeof(char), (char *));
+	rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h,
+	    new_asm_h, &nXorBufs, &rpBuf, overlappingPDAs, allocList);
 
 	/*
-         * create all the nodes at once
-         *
-         * -1 because no access is generated for the failed pda
-         */
+	 * Create all the nodes at once.
+	 *
+	 * -1 because no access is generated for the failed pda.
+	 */
 	nRudNodes = asmap->numStripeUnitsAccessed - 1;
-	nRrdNodes = ((new_asm_h[0]) ? new_asm_h[0]->stripeMap->numStripeUnitsAccessed : 0) +
-	    ((new_asm_h[1]) ? new_asm_h[1]->stripeMap->numStripeUnitsAccessed : 0);
-	nNodes = 5 + nRudNodes + nRrdNodes;	/* lock, unlock, xor, Rp, Rud,
-						 * Rrd */
+	nRrdNodes = ((new_asm_h[0]) ?
+	    new_asm_h[0]->stripeMap->numStripeUnitsAccessed : 0) +
+	    ((new_asm_h[1]) ?
+	    new_asm_h[1]->stripeMap->numStripeUnitsAccessed : 0);
+	nNodes = 5 + nRudNodes + nRrdNodes;	/*
+						 * lock, unlock, xor, Rp,
+						 * Rud, Rrd
+						 */
 	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
 	    allocList);
 	i = 0;
@@ -323,136 +338,154 @@ rf_CreateDegradedReadDAG(
 	i += nRrdNodes;
 	RF_ASSERT(i == nNodes);
 
-	/* initialize nodes */
+	/* Initialize nodes. */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
-	/* this dag can not commit until the commit node is reached errors
-	 * prior to the commit point imply the dag has failed */
+	/*
+	 * This dag can not commit until the commit node is reached.
+	 * Errors prior to the commit point imply the dag has failed.
+	 */
 	dag_h->numSuccedents = 1;
 
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, nRudNodes + nRrdNodes + 1, 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
-	rf_InitNode(xorNode, rf_wait, RF_FALSE, recFunc->simple, rf_NullNodeUndoFunc,
-	    NULL, 1, nRudNodes + nRrdNodes + 1, 2 * nXorBufs + 2, 1, dag_h,
-	    recFunc->SimpleName, allocList);
-
-	/* fill in the Rud nodes */
-	for (pda = asmap->physInfo, i = 0; i < nRudNodes; i++, pda = pda->next) {
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nRudNodes + nRrdNodes + 1, 0, 0, 0,
+	    dag_h, "Nil", allocList);
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(xorNode, rf_wait, RF_FALSE, recFunc->simple,
+	    rf_NullNodeUndoFunc, NULL, 1, nRudNodes + nRrdNodes + 1,
+	    2 * nXorBufs + 2, 1, dag_h, recFunc->SimpleName, allocList);
+
+	/* Fill in the Rud nodes. */
+	for (pda = asmap->physInfo, i = 0; i < nRudNodes;
+	     i++, pda = pda->next) {
 		if (pda == failedPDA) {
 			i--;
 			continue;
 		}
 		rf_InitNode(&rudNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc,
-		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
-		    "Rud", allocList);
+		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Rud", allocList);
 		RF_ASSERT(pda);
 		rudNodes[i].params[0].p = pda;
 		rudNodes[i].params[1].p = pda->bufPtr;
 		rudNodes[i].params[2].v = parityStripeID;
-		rudNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		rudNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 	}
 
-	/* fill in the Rrd nodes */
+	/* Fill in the Rrd nodes. */
 	i = 0;
 	if (new_asm_h[0]) {
 		for (pda = new_asm_h[0]->stripeMap->physInfo;
-		    i < new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
-		    i++, pda = pda->next) {
-			rf_InitNode(&rrdNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc,
-			    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
-			    dag_h, "Rrd", allocList);
+		     i < new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
+		     i++, pda = pda->next) {
+			rf_InitNode(&rrdNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskReadFunc, rf_DiskReadUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Rrd", allocList);
 			RF_ASSERT(pda);
 			rrdNodes[i].params[0].p = pda;
 			rrdNodes[i].params[1].p = pda->bufPtr;
 			rrdNodes[i].params[2].v = parityStripeID;
-			rrdNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			rrdNodes[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
+			    which_ru);
 		}
 	}
 	if (new_asm_h[1]) {
 		for (j = 0, pda = new_asm_h[1]->stripeMap->physInfo;
 		    j < new_asm_h[1]->stripeMap->numStripeUnitsAccessed;
 		    j++, pda = pda->next) {
-			rf_InitNode(&rrdNodes[i + j], rf_wait, RF_FALSE, rf_DiskReadFunc,
-			    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
-			    dag_h, "Rrd", allocList);
+			rf_InitNode(&rrdNodes[i + j], rf_wait, RF_FALSE,
+			    rf_DiskReadFunc, rf_DiskReadUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Rrd", allocList);
 			RF_ASSERT(pda);
 			rrdNodes[i + j].params[0].p = pda;
 			rrdNodes[i + j].params[1].p = pda->bufPtr;
 			rrdNodes[i + j].params[2].v = parityStripeID;
-			rrdNodes[i + j].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			rrdNodes[i + j].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
+			    which_ru);
 		}
 	}
-	/* make a PDA for the parity unit */
-	RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+	/* Make a PDA for the parity unit. */
+	RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t),
+	    (RF_PhysDiskAddr_t *), allocList);
 	parityPDA->row = asmap->parityInfo->row;
 	parityPDA->col = asmap->parityInfo->col;
-	parityPDA->startSector = ((asmap->parityInfo->startSector / sectorsPerSU)
-	    * sectorsPerSU) + (failedPDA->startSector % sectorsPerSU);
+	parityPDA->startSector = ((asmap->parityInfo->startSector /
+	    sectorsPerSU) * sectorsPerSU) +
+	    (failedPDA->startSector % sectorsPerSU);
 	parityPDA->numSector = failedPDA->numSector;
 
-	/* initialize the Rp node */
-	rf_InitNode(rpNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-	    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rp ", allocList);
+	/* Initialize the Rp node. */
+	rf_InitNode(rpNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
+	    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+	    "Rp ", allocList);
 	rpNode->params[0].p = parityPDA;
 	rpNode->params[1].p = rpBuf;
 	rpNode->params[2].v = parityStripeID;
-	rpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+	rpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
+	    which_ru);
 
 	/*
-         * the last and nastiest step is to assign all
-         * the parameters of the Xor node
-         */
+	 * The last and nastiest step is to assign all
+	 * the parameters of the Xor node.
+	 */
 	paramNum = 0;
 	for (i = 0; i < nRrdNodes; i++) {
-		/* all the Rrd nodes need to be xored together */
+		/* All the Rrd nodes need to be xored together. */
 		xorNode->params[paramNum++] = rrdNodes[i].params[0];
 		xorNode->params[paramNum++] = rrdNodes[i].params[1];
 	}
 	for (i = 0; i < nRudNodes; i++) {
-		/* any Rud nodes that overlap the failed access need to be
-		 * xored in */
+		/* Any Rud nodes that overlap the failed access need to be
+		 * xored in. */
 		if (overlappingPDAs[i]) {
-			RF_MallocAndAdd(pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
-			bcopy((char *) rudNodes[i].params[0].p, (char *) pda, sizeof(RF_PhysDiskAddr_t));
-			rf_RangeRestrictPDA(raidPtr, failedPDA, pda, RF_RESTRICT_DOBUFFER, 0);
+			RF_MallocAndAdd(pda, sizeof(RF_PhysDiskAddr_t),
+			    (RF_PhysDiskAddr_t *), allocList);
+			bcopy((char *) rudNodes[i].params[0].p, (char *) pda,
+			    sizeof(RF_PhysDiskAddr_t));
+			rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
+			    RF_RESTRICT_DOBUFFER, 0);
 			xorNode->params[paramNum++].p = pda;
 			xorNode->params[paramNum++].p = pda->bufPtr;
 		}
 	}
 	RF_Free(overlappingPDAs, asmap->numStripeUnitsAccessed * sizeof(char));
 
-	/* install parity pda as last set of params to be xor'd */
+	/* Install parity pda as last set of params to be xor'd. */
 	xorNode->params[paramNum++].p = parityPDA;
 	xorNode->params[paramNum++].p = rpBuf;
 
 	/*
-         * the last 2 params to the recovery xor node are
-         * the failed PDA and the raidPtr
-         */
+	 * The last 2 params to the recovery xor node are
+	 * the failed PDA and the raidPtr.
+	 */
 	xorNode->params[paramNum++].p = failedPDA;
 	xorNode->params[paramNum++].p = raidPtr;
 	RF_ASSERT(paramNum == 2 * nXorBufs + 2);
 
 	/*
-         * The xor node uses results[0] as the target buffer.
-         * Set pointer and zero the buffer. In the kernel, this
-         * may be a user buffer in which case we have to remap it.
-         */
+	 * The xor node uses results[0] as the target buffer.
+	 * Set pointer and zero the buffer. In the kernel, this
+	 * may be a user buffer in which case we have to remap it.
+	 */
 	xorNode->results[0] = failedPDA->bufPtr;
 	RF_BZERO(bp, failedPDA->bufPtr, rf_RaidAddressToByte(raidPtr,
-		failedPDA->numSector));
+	    failedPDA->numSector));
 
-	/* connect nodes to form graph */
-	/* connect the header to the block node */
+	/* Connect nodes to form graph. */
+	/* Connect the header to the block node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* connect the block node to the read nodes */
+	/* Connect the block node to the read nodes. */
 	RF_ASSERT(blockNode->numSuccedents == (1 + nRrdNodes + nRudNodes));
 	RF_ASSERT(rpNode->numAntecedents == 1);
 	blockNode->succedents[0] = rpNode;
@@ -471,7 +504,7 @@ rf_CreateDegradedReadDAG(
 		rudNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect the read nodes to the xor node */
+	/* Connect the read nodes to the xor node. */
 	RF_ASSERT(xorNode->numAntecedents == (1 + nRrdNodes + nRudNodes));
 	RF_ASSERT(rpNode->numSuccedents == 1);
 	rpNode->succedents[0] = xorNode;
@@ -490,14 +523,14 @@ rf_CreateDegradedReadDAG(
 		xorNode->antType[1 + nRrdNodes + i] = rf_trueData;
 	}
 
-	/* connect the xor node to the commit node */
+	/* Connect the xor node to the commit node. */
 	RF_ASSERT(xorNode->numSuccedents == 1);
 	RF_ASSERT(commitNode->numAntecedents == 1);
 	xorNode->succedents[0] = commitNode;
 	commitNode->antecedents[0] = xorNode;
 	commitNode->antType[0] = rf_control;
 
-	/* connect the termNode to the commit node */
+	/* Connect the termNode to the commit node. */
 	RF_ASSERT(commitNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -507,8 +540,8 @@ rf_CreateDegradedReadDAG(
 }
 
 
-/******************************************************************************
- * Create a degraded read DAG for Chained Declustering
+/*****************************************************************************
+ * Create a degraded read DAG for Chained Declustering.
  *
  * Hdr -> Nil -> R(p/s)d -> Cmt -> Trm
  *
@@ -516,25 +549,26 @@ rf_CreateDegradedReadDAG(
  *   Rpd - read of primary copy
  *   Rsd - read of secondary copy
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (for holding write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
+ * Parameters:  raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (for holding write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
  *****************************************************************************/
 
-void 
+void
 rf_CreateRaidCDegradedReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+    RF_Raid_t			*raidPtr,
+    RF_AccessStripeMap_t	*asmap,
+    RF_DagHeader_t		*dag_h,
+    void			*bp,
+    RF_RaidAccessFlags_t	 flags,
+    RF_AllocListElem_t		*allocList
+)
 {
 	RF_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
 	RF_StripeNum_t parityStripeID;
-	int     useMirror, i, shiftable;
+	int useMirror, i, shiftable;
 	RF_ReconUnitNum_t which_ru;
 	RF_PhysDiskAddr_t *pda;
 
@@ -551,14 +585,15 @@ rf_CreateRaidCDegradedReadDAG(
 		printf("[Creating RAID C degraded read DAG]\n");
 	}
 	dag_h->creator = "RaidCDegradedReadDAG";
-	/* alloc the Wnd nodes and the Wmir node */
+	/* Alloc the Wnd nodes and the Wmir node. */
 	if (asmap->numDataFailed == 0)
 		useMirror = RF_FALSE;
 	else
 		useMirror = RF_TRUE;
 
 	/* total number of nodes = 1 + (block + commit + terminator) */
-	RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	RF_CallocAndAdd(nodes, 4, sizeof(RF_DagNode_t), (RF_DagNode_t *),
+	    allocList);
 	i = 0;
 	rdNode = &nodes[i];
 	i++;
@@ -570,74 +605,79 @@ rf_CreateRaidCDegradedReadDAG(
 	i++;
 
 	/*
-         * This dag can not commit until the commit node is reached.
-         * Errors prior to the commit point imply the dag has failed
-         * and must be retried.
-         */
+	 * This dag can not commit until the commit node is reached.
+	 * Errors prior to the commit point imply the dag has failed
+	 * and must be retried.
+	 */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
 	/* initialize the block, commit, and terminator nodes */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "Cmt", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
 
 	pda = asmap->physInfo;
 	RF_ASSERT(pda != NULL);
-	/* parityInfo must describe entire parity unit */
+	/* ParityInfo must describe entire parity unit. */
 	RF_ASSERT(asmap->parityInfo->next == NULL);
 
-	/* initialize the data node */
+	/* Initialize the data node. */
 	if (!useMirror) {
-		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rpd", allocList);
+		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
+		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Rpd", allocList);
 		if (shiftable && rf_compute_workload_shift(raidPtr, pda)) {
-			/* shift this read to the next disk in line */
+			/* Shift this read to the next disk in line. */
 			rdNode->params[0].p = asmap->parityInfo;
 			rdNode->params[1].p = pda->bufPtr;
 			rdNode->params[2].v = parityStripeID;
-			rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			rdNode->params[3].v = RF_CREATE_PARAM3(
+			    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		} else {
-			/* read primary copy */
+			/* Read primary copy. */
 			rdNode->params[0].p = pda;
 			rdNode->params[1].p = pda->bufPtr;
 			rdNode->params[2].v = parityStripeID;
-			rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			rdNode->params[3].v = RF_CREATE_PARAM3(
+			    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		}
 	} else {
-		/* read secondary copy of data */
-		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rsd", allocList);
+		/* Read secondary copy of data. */
+		rf_InitNode(rdNode, rf_wait, RF_FALSE, rf_DiskReadFunc,
+		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Rsd", allocList);
 		rdNode->params[0].p = asmap->parityInfo;
 		rdNode->params[1].p = pda->bufPtr;
 		rdNode->params[2].v = parityStripeID;
-		rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		rdNode->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 	}
 
-	/* connect header to block node */
+	/* Connect header to block node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* connect block node to rdnode */
+	/* Connect block node to rdnode. */
 	RF_ASSERT(blockNode->numSuccedents == 1);
 	RF_ASSERT(rdNode->numAntecedents == 1);
 	blockNode->succedents[0] = rdNode;
 	rdNode->antecedents[0] = blockNode;
 	rdNode->antType[0] = rf_control;
 
-	/* connect rdnode to commit node */
+	/* Connect rdnode to commit node. */
 	RF_ASSERT(rdNode->numSuccedents == 1);
 	RF_ASSERT(commitNode->numAntecedents == 1);
 	rdNode->succedents[0] = commitNode;
 	commitNode->antecedents[0] = rdNode;
 	commitNode->antType[0] = rf_control;
 
-	/* connect commit node to terminator */
+	/* Connect commit node to terminator. */
 	RF_ASSERT(commitNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -645,56 +685,66 @@ rf_CreateRaidCDegradedReadDAG(
 	termNode->antecedents[0] = commitNode;
 	termNode->antType[0] = rf_control;
 }
+
 /*
- * XXX move this elsewhere?
+ * XXX move this elsewhere ?
  */
-void 
+void
 rf_DD_GenerateFailedAccessASMs(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_PhysDiskAddr_t ** pdap,
-    int *nNodep,
-    RF_PhysDiskAddr_t ** pqpdap,
-    int *nPQNodep,
-    RF_AllocListElem_t * allocList)
+    RF_Raid_t			 *raidPtr,
+    RF_AccessStripeMap_t	 *asmap,
+    RF_PhysDiskAddr_t		**pdap,
+    int				 *nNodep,
+    RF_PhysDiskAddr_t		**pqpdap,
+    int				 *nPQNodep,
+    RF_AllocListElem_t		 *allocList
+)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	int     PDAPerDisk, i;
+	int PDAPerDisk, i;
 	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
-	int     numDataCol = layoutPtr->numDataCol;
-	int     state;
+	int numDataCol = layoutPtr->numDataCol;
+	int state;
 	RF_SectorNum_t suoff, suend;
 	unsigned firstDataCol, napdas, count;
 	RF_SectorNum_t fone_start, fone_end, ftwo_start = 0, ftwo_end = 0;
-	RF_PhysDiskAddr_t *fone = asmap->failedPDAs[0], *ftwo = asmap->failedPDAs[1];
+	RF_PhysDiskAddr_t *fone = asmap->failedPDAs[0];
+	RF_PhysDiskAddr_t *ftwo = asmap->failedPDAs[1];
 	RF_PhysDiskAddr_t *pda_p;
 	RF_PhysDiskAddr_t *phys_p;
 	RF_RaidAddr_t sosAddr;
 
-	/* determine how many pda's we will have to generate per unaccess
+	/*
+	 * Determine how many pda's we will have to generate per unaccessed
 	 * stripe. If there is only one failed data unit, it is one; if two,
-	 * possibly two, depending wether they overlap. */
+	 * possibly two, depending wether they overlap.
+	 */
 
 	fone_start = rf_StripeUnitOffset(layoutPtr, fone->startSector);
 	fone_end = fone_start + fone->numSector;
 
-#define CONS_PDA(if,start,num) \
-  pda_p->row = asmap->if->row;    pda_p->col = asmap->if->col; \
-  pda_p->startSector = ((asmap->if->startSector / secPerSU) * secPerSU) + start; \
-  pda_p->numSector = num; \
-  pda_p->next = NULL; \
-  RF_MallocAndAdd(pda_p->bufPtr,rf_RaidAddressToByte(raidPtr,num),(char *), allocList)
+#define	CONS_PDA(if,start,num)		do {				\
+	pda_p->row = asmap->if->row;					\
+	pda_p->col = asmap->if->col;					\
+	pda_p->startSector = ((asmap->if->startSector / secPerSU) *	\
+	    secPerSU) + start;						\
+	pda_p->numSector = num;						\
+	pda_p->next = NULL;						\
+	RF_MallocAndAdd(pda_p->bufPtr,					\
+	    rf_RaidAddressToByte(raidPtr,num),(char *), allocList);	\
+} while (0)
 
 	if (asmap->numDataFailed == 1) {
 		PDAPerDisk = 1;
 		state = 1;
-		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t),
+		    (RF_PhysDiskAddr_t *), allocList);
 		pda_p = *pqpdap;
-		/* build p */
+		/* Build p. */
 		CONS_PDA(parityInfo, fone_start, fone->numSector);
 		pda_p->type = RF_PDA_TYPE_PARITY;
 		pda_p++;
-		/* build q */
+		/* Build q. */
 		CONS_PDA(qInfo, fone_start, fone->numSector);
 		pda_p->type = RF_PDA_TYPE_Q;
 	} else {
@@ -703,7 +753,8 @@ rf_DD_GenerateFailedAccessASMs(
 		if (fone->numSector + ftwo->numSector > secPerSU) {
 			PDAPerDisk = 1;
 			state = 2;
-			RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+			RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t),
+			    (RF_PhysDiskAddr_t *), allocList);
 			pda_p = *pqpdap;
 			CONS_PDA(parityInfo, 0, secPerSU);
 			pda_p->type = RF_PDA_TYPE_PARITY;
@@ -713,8 +764,9 @@ rf_DD_GenerateFailedAccessASMs(
 		} else {
 			PDAPerDisk = 2;
 			state = 3;
-			/* four of them, fone, then ftwo */
-			RF_MallocAndAdd(*pqpdap, 4 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+			/* Four of them, fone, then ftwo. */
+			RF_MallocAndAdd(*pqpdap, 4 * sizeof(RF_PhysDiskAddr_t),
+			    (RF_PhysDiskAddr_t *), allocList);
 			pda_p = *pqpdap;
 			CONS_PDA(parityInfo, fone_start, fone->numSector);
 			pda_p->type = RF_PDA_TYPE_PARITY;
@@ -729,12 +781,15 @@ rf_DD_GenerateFailedAccessASMs(
 			pda_p->type = RF_PDA_TYPE_Q;
 		}
 	}
-	/* figure out number of nonaccessed pda */
-	napdas = PDAPerDisk * (numDataCol - asmap->numStripeUnitsAccessed - (ftwo == NULL ? 1 : 0));
+	/* Figure out number of nonaccessed pda. */
+	napdas = PDAPerDisk * (numDataCol - asmap->numStripeUnitsAccessed -
+	    (ftwo == NULL ? 1 : 0));
 	*nPQNodep = PDAPerDisk;
 
-	/* sweep over the over accessed pda's, figuring out the number of
-	 * additional pda's to generate. Of course, skip the failed ones */
+	/*
+	 * Sweep over the over accessed pda's, figuring out the number of
+	 * additional pda's to generate. Of course, skip the failed ones.
+	 */
 
 	count = 0;
 	for (pda_p = asmap->physInfo; pda_p; pda_p = pda_p->next) {
@@ -743,19 +798,21 @@ rf_DD_GenerateFailedAccessASMs(
 		suoff = rf_StripeUnitOffset(layoutPtr, pda_p->startSector);
 		suend = suoff + pda_p->numSector;
 		switch (state) {
-		case 1:	/* one failed PDA to overlap */
-			/* if a PDA doesn't contain the failed unit, it can
-			 * only miss the start or end, not both */
+		case 1:	/* One failed PDA to overlap. */
+			/*
+			 * If a PDA doesn't contain the failed unit, it can
+			 * only miss the start or end, not both.
+			 */
 			if ((suoff > fone_start) || (suend < fone_end))
 				count++;
 			break;
-		case 2:	/* whole stripe */
-			if (suoff)	/* leak at begining */
+		case 2:	/* Whole stripe. */
+			if (suoff)			/* Leak at begining. */
 				count++;
-			if (suend < numDataCol)	/* leak at end */
+			if (suend < numDataCol)		/* Leak at end. */
 				count++;
 			break;
-		case 3:	/* two disjoint units */
+		case 3:	/* Two disjoint units. */
 			if ((suoff > fone_start) || (suend < fone_end))
 				count++;
 			if ((suoff > ftwo_start) || (suend < ftwo_end))
@@ -771,51 +828,65 @@ rf_DD_GenerateFailedAccessASMs(
 	if (napdas == 0)
 		return;		/* short circuit */
 
-	/* allocate up our list of pda's */
+	/* Allocate up our list of pda's. */
 
-	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t),
+	    (RF_PhysDiskAddr_t *), allocList);
 	*pdap = pda_p;
 
-	/* linkem together */
+	/* Link them together. */
 	for (i = 0; i < (napdas - 1); i++)
 		pda_p[i].next = pda_p + (i + 1);
 
-	/* march through the one's up to the first accessed disk */
-	firstDataCol = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), asmap->physInfo->raidAddress) % numDataCol;
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
+	/* March through the one's up to the first accessed disk. */
+	firstDataCol = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+	    asmap->physInfo->raidAddress) % numDataCol;
+	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+	    asmap->raidAddress);
 	for (i = 0; i < firstDataCol; i++) {
 		if ((pda_p - (*pdap)) == napdas)
 			continue;
 		pda_p->type = RF_PDA_TYPE_DATA;
 		pda_p->raidAddress = sosAddr + (i * secPerSU);
-		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-		/* skip over dead disks */
+		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
+		    &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
+		/* Skip over dead disks. */
 		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
 			continue;
 		switch (state) {
-		case 1:	/* fone */
+		case 1:	/* Fone. */
 			pda_p->numSector = fone->numSector;
 			pda_p->raidAddress += fone_start;
 			pda_p->startSector += fone_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda_p->numSector),
+			    (char *), allocList);
 			break;
-		case 2:	/* full stripe */
+		case 2:	/* Full stripe. */
 			pda_p->numSector = secPerSU;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, secPerSU),
+			    (char *), allocList);
 			break;
-		case 3:	/* two slabs */
+		case 3:	/* Two slabs. */
 			pda_p->numSector = fone->numSector;
 			pda_p->raidAddress += fone_start;
 			pda_p->startSector += fone_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda_p->numSector),
+			    (char *), allocList);
 			pda_p++;
 			pda_p->type = RF_PDA_TYPE_DATA;
 			pda_p->raidAddress = sosAddr + (i * secPerSU);
-			(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
+			(raidPtr->Layout.map->MapSector) (raidPtr,
+			    pda_p->raidAddress, &(pda_p->row), &(pda_p->col),
+			    &(pda_p->startSector), 0);
 			pda_p->numSector = ftwo->numSector;
 			pda_p->raidAddress += ftwo_start;
 			pda_p->startSector += ftwo_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda_p->numSector),
+			    (char *), allocList);
 			break;
 		default:
 			RF_PANIC();
@@ -823,97 +894,163 @@ rf_DD_GenerateFailedAccessASMs(
 		pda_p++;
 	}
 
-	/* march through the touched stripe units */
+	/* March through the touched stripe units. */
 	for (phys_p = asmap->physInfo; phys_p; phys_p = phys_p->next, i++) {
-		if ((phys_p == asmap->failedPDAs[0]) || (phys_p == asmap->failedPDAs[1]))
+		if ((phys_p == asmap->failedPDAs[0]) ||
+		    (phys_p == asmap->failedPDAs[1]))
 			continue;
 		suoff = rf_StripeUnitOffset(layoutPtr, phys_p->startSector);
 		suend = suoff + phys_p->numSector;
 		switch (state) {
-		case 1:	/* single buffer */
+		case 1:	/* Single buffer. */
 			if (suoff > fone_start) {
 				RF_ASSERT(suend >= fone_end);
-				/* The data read starts after the mapped
-				 * access, snip off the begining */
+				/*
+				 * The data read starts after the mapped
+				 * access, snip off the begining.
+				 */
 				pda_p->numSector = suoff - fone_start;
-				pda_p->raidAddress = sosAddr + (i * secPerSU) + fone_start;
-				(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-				RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+				pda_p->raidAddress = sosAddr + (i * secPerSU)
+				    + fone_start;
+				(raidPtr->Layout.map->MapSector) (raidPtr,
+				    pda_p->raidAddress, &(pda_p->row),
+				    &(pda_p->col), &(pda_p->startSector), 0);
+				RF_MallocAndAdd(pda_p->bufPtr,
+				    rf_RaidAddressToByte(raidPtr,
+				    pda_p->numSector), (char *), allocList);
 				pda_p++;
 			}
 			if (suend < fone_end) {
 				RF_ASSERT(suoff <= fone_start);
-				/* The data read stops before the end of the
-				 * failed access, extend */
+				/*
+				 * The data read stops before the end of the
+				 * failed access, extend.
+				 */
 				pda_p->numSector = fone_end - suend;
-				pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
-				(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-				RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+				pda_p->raidAddress = sosAddr + (i * secPerSU)
+				    + suend;	/* off by one? */
+				(raidPtr->Layout.map->MapSector) (raidPtr,
+				    pda_p->raidAddress, &(pda_p->row),
+				    &(pda_p->col), &(pda_p->startSector), 0);
+				RF_MallocAndAdd(pda_p->bufPtr,
+				    rf_RaidAddressToByte(raidPtr,
+				    pda_p->numSector), (char *), allocList);
 				pda_p++;
 			}
 			break;
-		case 2:	/* whole stripe unit */
+		case 2:	/* Whole stripe unit. */
 			RF_ASSERT((suoff == 0) || (suend == secPerSU));
-			if (suend < secPerSU) {	/* short read, snip from end
-						 * on */
+			if (suend < secPerSU) {
+				/* Short read, snip from end on. */
 				pda_p->numSector = secPerSU - suend;
-				pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
-				(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-				RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+				pda_p->raidAddress = sosAddr + (i * secPerSU)
+				    + suend;	/* off by one? */
+				(raidPtr->Layout.map->MapSector) (raidPtr,
+				    pda_p->raidAddress, &(pda_p->row),
+				    &(pda_p->col), &(pda_p->startSector), 0);
+				RF_MallocAndAdd(pda_p->bufPtr,
+				    rf_RaidAddressToByte(raidPtr,
+				    pda_p->numSector), (char *), allocList);
 				pda_p++;
 			} else
-				if (suoff > 0) {	/* short at front */
+				if (suoff > 0) {
+					/* Short at front. */
 					pda_p->numSector = suoff;
-					pda_p->raidAddress = sosAddr + (i * secPerSU);
-					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+					pda_p->raidAddress = sosAddr +
+					    (i * secPerSU);
+					(raidPtr->Layout.map->MapSector)
+					    (raidPtr, pda_p->raidAddress,
+					    &(pda_p->row), &(pda_p->col),
+					    &(pda_p->startSector), 0);
+					RF_MallocAndAdd(pda_p->bufPtr,
+					    rf_RaidAddressToByte(raidPtr,
+					    pda_p->numSector), (char *),
+					    allocList);
 					pda_p++;
 				}
 			break;
-		case 3:	/* two nonoverlapping failures */
+		case 3:	/* Two nonoverlapping failures. */
 			if ((suoff > fone_start) || (suend < fone_end)) {
 				if (suoff > fone_start) {
 					RF_ASSERT(suend >= fone_end);
-					/* The data read starts after the
+					/*
+					 * The data read starts after the
 					 * mapped access, snip off the
-					 * begining */
+					 * begining.
+					 */
 					pda_p->numSector = suoff - fone_start;
-					pda_p->raidAddress = sosAddr + (i * secPerSU) + fone_start;
-					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+					pda_p->raidAddress = sosAddr +
+					    (i * secPerSU) + fone_start;
+					(raidPtr->Layout.map->MapSector)
+					    (raidPtr, pda_p->raidAddress,
+					    &(pda_p->row), &(pda_p->col),
+					    &(pda_p->startSector), 0);
+					RF_MallocAndAdd(pda_p->bufPtr,
+					    rf_RaidAddressToByte(raidPtr,
+					    pda_p->numSector), (char *),
+					    allocList);
 					pda_p++;
 				}
 				if (suend < fone_end) {
 					RF_ASSERT(suoff <= fone_start);
-					/* The data read stops before the end
-					 * of the failed access, extend */
+					/*
+					 * The data read stops before the end
+					 * of the failed access, extend.
+					 */
 					pda_p->numSector = fone_end - suend;
-					pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
-					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+					pda_p->raidAddress = sosAddr +
+					    (i * secPerSU) +
+					    suend;	/* Off by one ? */
+					(raidPtr->Layout.map->MapSector)
+					    (raidPtr, pda_p->raidAddress,
+					    &(pda_p->row), &(pda_p->col),
+					    &(pda_p->startSector), 0);
+					RF_MallocAndAdd(pda_p->bufPtr,
+					    rf_RaidAddressToByte(raidPtr,
+					    pda_p->numSector), (char *),
+					    allocList);
 					pda_p++;
 				}
 			}
 			if ((suoff > ftwo_start) || (suend < ftwo_end)) {
 				if (suoff > ftwo_start) {
 					RF_ASSERT(suend >= ftwo_end);
-					/* The data read starts after the
+					/*
+					 * The data read starts after the
 					 * mapped access, snip off the
-					 * begining */
+					 * begining.
+					 */
 					pda_p->numSector = suoff - ftwo_start;
-					pda_p->raidAddress = sosAddr + (i * secPerSU) + ftwo_start;
-					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+					pda_p->raidAddress = sosAddr +
+					    (i * secPerSU) + ftwo_start;
+					(raidPtr->Layout.map->MapSector)
+					    (raidPtr, pda_p->raidAddress,
+					    &(pda_p->row), &(pda_p->col),
+					    &(pda_p->startSector), 0);
+					RF_MallocAndAdd(pda_p->bufPtr,
+					    rf_RaidAddressToByte(raidPtr,
+					    pda_p->numSector), (char *),
+					    allocList);
 					pda_p++;
 				}
 				if (suend < ftwo_end) {
 					RF_ASSERT(suoff <= ftwo_start);
-					/* The data read stops before the end
-					 * of the failed access, extend */
+					/*
+					 * The data read stops before the end
+					 * of the failed access, extend.
+					 */
 					pda_p->numSector = ftwo_end - suend;
-					pda_p->raidAddress = sosAddr + (i * secPerSU) + suend;	/* off by one? */
-					(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-					RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+					pda_p->raidAddress = sosAddr +
+					    (i * secPerSU) +
+					    suend;	/* Off by one ? */
+					(raidPtr->Layout.map->MapSector)
+					    (raidPtr, pda_p->raidAddress,
+					    &(pda_p->row), &(pda_p->col),
+					    &(pda_p->startSector), 0);
+					RF_MallocAndAdd(pda_p->bufPtr,
+					    rf_RaidAddressToByte(raidPtr,
+					    pda_p->numSector), (char *),
+					    allocList);
 					pda_p++;
 				}
 			}
@@ -923,40 +1060,51 @@ rf_DD_GenerateFailedAccessASMs(
 		}
 	}
 
-	/* after the last accessed disk */
+	/* After the last accessed disk. */
 	for (; i < numDataCol; i++) {
 		if ((pda_p - (*pdap)) == napdas)
 			continue;
 		pda_p->type = RF_PDA_TYPE_DATA;
 		pda_p->raidAddress = sosAddr + (i * secPerSU);
-		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-		/* skip over dead disks */
+		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
+		    &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
+		/* Skip over dead disks. */
 		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
 			continue;
 		switch (state) {
-		case 1:	/* fone */
+		case 1:	/* Fone. */
 			pda_p->numSector = fone->numSector;
 			pda_p->raidAddress += fone_start;
 			pda_p->startSector += fone_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda_p->numSector),
+			    (char *), allocList);
 			break;
-		case 2:	/* full stripe */
+		case 2:	/* Full stripe. */
 			pda_p->numSector = secPerSU;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, secPerSU),
+			    (char *), allocList);
 			break;
-		case 3:	/* two slabs */
+		case 3:	/* Two slabs. */
 			pda_p->numSector = fone->numSector;
 			pda_p->raidAddress += fone_start;
 			pda_p->startSector += fone_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda_p->numSector),
+			    (char *), allocList);
 			pda_p++;
 			pda_p->type = RF_PDA_TYPE_DATA;
 			pda_p->raidAddress = sosAddr + (i * secPerSU);
-			(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
+			(raidPtr->Layout.map->MapSector) (raidPtr,
+			    pda_p->raidAddress, &(pda_p->row), &(pda_p->col),
+			    &(pda_p->startSector), 0);
 			pda_p->numSector = ftwo->numSector;
 			pda_p->raidAddress += ftwo_start;
 			pda_p->startSector += ftwo_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda_p->numSector),
+			    (char *), allocList);
 			break;
 		default:
 			RF_PANIC();
@@ -967,52 +1115,62 @@ rf_DD_GenerateFailedAccessASMs(
 	RF_ASSERT(pda_p - *pdap == napdas);
 	return;
 }
-#define INIT_DISK_NODE(node,name) \
-rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 2,1,4,0, dag_h, name, allocList); \
-(node)->succedents[0] = unblockNode; \
-(node)->succedents[1] = recoveryNode; \
-(node)->antecedents[0] = blockNode; \
-(node)->antType[0] = rf_control
-
-#define DISK_NODE_PARAMS(_node_,_p_) \
-  (_node_).params[0].p = _p_ ; \
-  (_node_).params[1].p = (_p_)->bufPtr; \
-  (_node_).params[2].v = parityStripeID; \
-  (_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru)
-
-void 
+
+#define	INIT_DISK_NODE(node,name)	do {				\
+	rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc,		\
+	    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 2,1,4,0,		\
+	    dag_h, name, allocList);					\
+	(node)->succedents[0] = unblockNode;				\
+	(node)->succedents[1] = recoveryNode;				\
+	(node)->antecedents[0] = blockNode;				\
+	(node)->antType[0] = rf_control;				\
+} while (0)
+
+#define	DISK_NODE_PARAMS(_node_,_p_)	do {				\
+	(_node_).params[0].p = _p_ ;					\
+	(_node_).params[1].p = (_p_)->bufPtr;				\
+	(_node_).params[2].v = parityStripeID;				\
+	(_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,	\
+	    0, 0, which_ru);						\
+} while (0)
+
+void
 rf_DoubleDegRead(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    char *redundantReadNodeName,
-    char *recoveryNodeName,
-    int (*recovFunc) (RF_DagNode_t *))
+    RF_Raid_t			 *raidPtr,
+    RF_AccessStripeMap_t	 *asmap,
+    RF_DagHeader_t		 *dag_h,
+    void			 *bp,
+    RF_RaidAccessFlags_t	  flags,
+    RF_AllocListElem_t		 *allocList,
+    char			 *redundantReadNodeName,
+    char			 *recoveryNodeName,
+    int				(*recovFunc) (RF_DagNode_t *)
+)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *recoveryNode, *blockNode,
-	       *unblockNode, *rpNodes, *rqNodes, *termNode;
+	    *unblockNode, *rpNodes, *rqNodes, *termNode;
 	RF_PhysDiskAddr_t *pda, *pqPDAs;
 	RF_PhysDiskAddr_t *npdas;
-	int     nNodes, nRrdNodes, nRudNodes, i;
+	int nNodes, nRrdNodes, nRudNodes, i;
 	RF_ReconUnitNum_t which_ru;
-	int     nReadNodes, nPQNodes;
+	int nReadNodes, nPQNodes;
 	RF_PhysDiskAddr_t *failedPDA = asmap->failedPDAs[0];
 	RF_PhysDiskAddr_t *failedPDAtwo = asmap->failedPDAs[1];
-	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr, asmap->raidAddress, &which_ru);
+	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(
+	    layoutPtr, asmap->raidAddress, &which_ru);
 
 	if (rf_dagDebug)
 		printf("[Creating Double Degraded Read DAG]\n");
-	rf_DD_GenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes, &pqPDAs, &nPQNodes, allocList);
+	rf_DD_GenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes,
+	    &pqPDAs, &nPQNodes, allocList);
 
 	nRudNodes = asmap->numStripeUnitsAccessed - (asmap->numDataFailed);
 	nReadNodes = nRrdNodes + nRudNodes + 2 * nPQNodes;
-	nNodes = 4 /* block, unblock, recovery, term */ + nReadNodes;
+	nNodes = 4 /* Block, unblock, recovery, term. */ + nReadNodes;
 
-	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
+	    allocList);
 	i = 0;
 	blockNode = &nodes[i];
 	i += 1;
@@ -1036,19 +1194,27 @@ rf_DoubleDegRead(
 	dag_h->succedents[0] = blockNode;
 	dag_h->creator = "DoubleDegRead";
 	dag_h->numCommits = 0;
-	dag_h->numCommitNodes = 1;	/* unblock */
+	dag_h->numCommitNodes = 1;	/* Unblock. */
 
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 2, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 2, 0, 0, dag_h, "Trm", allocList);
 	termNode->antecedents[0] = unblockNode;
 	termNode->antType[0] = rf_control;
 	termNode->antecedents[1] = recoveryNode;
 	termNode->antType[1] = rf_control;
 
-	/* init the block and unblock nodes */
-	/* The block node has all nodes except itself, unblock and recovery as
-	 * successors. Similarly for predecessors of the unblock. */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nReadNodes, 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nReadNodes, 0, 0, dag_h, "Nil", allocList);
+	/*
+	 * Init the block and unblock nodes.
+	 * The block node has all nodes except itself, unblock and
+	 * recovery as successors.
+	 * Similarly for predecessors of the unblock.
+	 */
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nReadNodes, 0, 0, 0, dag_h,
+	    "Nil", allocList);
+	rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, nReadNodes, 0, 0, dag_h,
+	    "Nil", allocList);
 
 	for (i = 0; i < nReadNodes; i++) {
 		blockNode->succedents[i] = rudNodes + i;
@@ -1057,13 +1223,16 @@ rf_DoubleDegRead(
 	}
 	unblockNode->succedents[0] = termNode;
 
-	/* The recovery node has all the reads as predecessors, and the term
+	/*
+	 * The recovery node has all the reads as predecessors, and the term
 	 * node as successors. It gets a pda as a param from each of the read
-	 * nodes plus the raidPtr. For each failed unit is has a result pda. */
-	rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc, rf_NullNodeUndoFunc, NULL,
-	    1,			/* succesors */
-	    nReadNodes,		/* preds */
-	    nReadNodes + 2,	/* params */
+	 * nodes plus the raidPtr. For each failed unit is has a result pda.
+	 */
+	rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc,
+	    rf_NullNodeUndoFunc, NULL,
+	    1,				/* succesors */
+	    nReadNodes,			/* preds */
+	    nReadNodes + 2,		/* params */
 	    asmap->numDataFailed,	/* results */
 	    dag_h, recoveryNodeName, allocList);
 
@@ -1073,8 +1242,10 @@ rf_DoubleDegRead(
 		recoveryNode->antType[i] = rf_trueData;
 	}
 
-	/* build the read nodes, then come back and fill in recovery params
-	 * and results */
+	/*
+	 * Build the read nodes, then come back and fill in recovery params
+	 * and results.
+	 */
 	pda = asmap->physInfo;
 	for (i = 0; i < nRudNodes; pda = pda->next) {
 		if ((pda == failedPDA) || (pda == failedPDAtwo))
@@ -1092,7 +1263,7 @@ rf_DoubleDegRead(
 		DISK_NODE_PARAMS(rrdNodes[i], pda);
 	}
 
-	/* redundancy pdas */
+	/* Redundancy pdas. */
 	pda = pqPDAs;
 	INIT_DISK_NODE(rpNodes, "Rp");
 	RF_ASSERT(pda);
@@ -1111,14 +1282,14 @@ rf_DoubleDegRead(
 		RF_ASSERT(pda);
 		DISK_NODE_PARAMS(rqNodes[1], pda);
 	}
-	/* fill in recovery node params */
+	/* Fill in recovery node params. */
 	for (i = 0; i < nReadNodes; i++)
-		recoveryNode->params[i] = rudNodes[i].params[0];	/* pda */
+		recoveryNode->params[i] = rudNodes[i].params[0]; /* pda */
 	recoveryNode->params[i++].p = (void *) raidPtr;
 	recoveryNode->params[i++].p = (void *) asmap;
 	recoveryNode->results[0] = failedPDA;
 	if (asmap->numDataFailed == 2)
 		recoveryNode->results[1] = failedPDAtwo;
 
-	/* zero fill the target data buffers? */
+	/* Zero fill the target data buffers ? */
 }
diff --git a/sys/dev/raidframe/rf_dagdegrd.h b/sys/dev/raidframe/rf_dagdegrd.h
index 8071bbb6bf5..a794004980d 100644
--- a/sys/dev/raidframe/rf_dagdegrd.h
+++ b/sys/dev/raidframe/rf_dagdegrd.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagdegrd.h,v 1.2 1999/02/16 00:02:29 niklas Exp $	*/
+/*	$OpenBSD: rf_dagdegrd.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagdegrd.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -32,33 +33,21 @@
 
 #include "rf_types.h"
 
-/* degraded read DAG creation routines */
-void 
-rf_CreateRaidFiveDegradedReadDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
-void 
-rf_CreateRaidOneDegradedReadDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
-void 
-rf_CreateDegradedReadDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-    RF_RedFuncs_t * recFunc);
-void 
-rf_CreateRaidCDegradedReadDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
-void 
-rf_DD_GenerateFailedAccessASMs(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_PhysDiskAddr_t ** pdap,
-    int *nNodep, RF_PhysDiskAddr_t ** pqpdap, int *nPQNodep,
-    RF_AllocListElem_t * allocList);
-void 
-rf_DoubleDegRead(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList, char *redundantReadNodeName,
-    char *recoveryNodeName, int (*recovFunc) (RF_DagNode_t *));
+/* Degraded read DAG creation routines. */
+void rf_CreateRaidFiveDegradedReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CreateRaidOneDegradedReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CreateDegradedReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_RedFuncs_t *);
+void rf_CreateRaidCDegradedReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_DD_GenerateFailedAccessASMs(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_PhysDiskAddr_t **, int *, RF_PhysDiskAddr_t **, int *,
+	RF_AllocListElem_t *);
+void rf_DoubleDegRead(RF_Raid_t *, RF_AccessStripeMap_t *, RF_DagHeader_t *,
+	void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *, char *, char *,
+	int (*) (RF_DagNode_t *));
 
-#endif				/* !_RF__RF_DAGDEGRD_H_ */
+#endif	/* !_RF__RF_DAGDEGRD_H_ */
diff --git a/sys/dev/raidframe/rf_dagdegwr.c b/sys/dev/raidframe/rf_dagdegwr.c
index c5df4e9cac7..c9305a4de36 100644
--- a/sys/dev/raidframe/rf_dagdegwr.c
+++ b/sys/dev/raidframe/rf_dagdegwr.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagdegwr.c,v 1.4 2000/01/11 18:02:20 peter Exp $	*/
+/*	$OpenBSD: rf_dagdegwr.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagdegwr.c,v 1.5 2000/01/07 03:40:57 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -30,7 +31,7 @@
 /*
  * rf_dagdegwr.c
  *
- * code for creating degraded write DAGs
+ * Code for creating degraded write DAGs.
  *
  */
 
@@ -45,14 +46,14 @@
 #include "rf_dagdegwr.h"
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * General comments on DAG creation:
  *
- * All DAGs in this file use roll-away error recovery.  Each DAG has a single
- * commit node, usually called "Cmt."  If an error occurs before the Cmt node
+ * All DAGs in this file use roll-away error recovery. Each DAG has a single
+ * commit node, usually called "Cmt". If an error occurs before the Cmt node
  * is reached, the execution engine will halt forward execution and work
- * backward through the graph, executing the undo functions.  Assuming that
+ * backward through the graph, executing the undo functions. Assuming that
  * each node in the graph prior to the Cmt node are undoable and atomic - or -
  * does not make changes to permanent state, the graph will fail atomically.
  * If an error occurs after the Cmt node executes, the engine will roll-forward
@@ -61,32 +62,28 @@
  *
  * A graph has only 1 Cmt node.
  *
- */
+ *****************************************************************************/
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * The following wrappers map the standard DAG creation interface to the
- * DAG creation routines.  Additionally, these wrappers enable experimentation
+ * DAG creation routines. Additionally, these wrappers enable experimentation
  * with new DAG structures by providing an extra level of indirection, allowing
  * the DAG creation routines to be replaced at this single point.
- */
+ *
+ *****************************************************************************/
 
-static 
 RF_CREATE_DAG_FUNC_DECL(rf_CreateSimpleDegradedWriteDAG)
 {
 	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
 	    flags, allocList, 1, rf_RecoveryXorFunc, RF_TRUE);
 }
 
-void 
-rf_CreateDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *asmap;
-	RF_DagHeader_t *dag_h;
-	void   *bp;
-	RF_RaidAccessFlags_t flags;
-	RF_AllocListElem_t *allocList;
+void
+rf_CreateDegradedWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_PhysDiskAddr_t *failedPDA = asmap->failedPDAs[0];
@@ -94,82 +91,82 @@ rf_CreateDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList)
 	RF_ASSERT(asmap->numDataFailed == 1);
 	dag_h->creator = "DegradedWriteDAG";
 
-	/* if the access writes only a portion of the failed unit, and also
+	/*
+	 * If the access writes only a portion of the failed unit, and also
 	 * writes some portion of at least one surviving unit, we create two
 	 * DAGs, one for the failed component and one for the non-failed
-	 * component, and do them sequentially.  Note that the fact that we're
+	 * component, and do them sequentially. Note that the fact that we're
 	 * accessing only a portion of the failed unit indicates that the
 	 * access either starts or ends in the failed unit, and hence we need
-	 * create only two dags.  This is inefficient in that the same data or
-	 * parity can get read and written twice using this structure.  I need
-	 * to fix this to do the access all at once. */
-	RF_ASSERT(!(asmap->numStripeUnitsAccessed != 1 && failedPDA->numSector != layoutPtr->sectorsPerStripeUnit));
-	rf_CreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList);
+	 * create only two dags. This is inefficient in that the same data or
+	 * parity can get read and written twice using this structure. I need
+	 * to fix this to do the access all at once.
+	 */
+	RF_ASSERT(!(asmap->numStripeUnitsAccessed != 1 &&
+	    failedPDA->numSector != layoutPtr->sectorsPerStripeUnit));
+	rf_CreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList);
 }
 
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * DAG creation code begins here
- */
-
+ * DAG creation code begins here.
+ *
+ *****************************************************************************/
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * CommonCreateSimpleDegradedWriteDAG -- creates a DAG to do a degraded-mode
  * write, which is as follows
  *
  *                                        / {Wnq} --\
  * hdr -> blockNode ->  Rod -> Xor -> Cmt -> Wnp ----> unblock -> term
- *                  \  {Rod} /            \  Wnd ---/
+ *                  \  {Rod} /            |  Wnd ---/
  *                                        \ {Wnd} -/
  *
- * commit nodes: Xor, Wnd
+ * Commit nodes: Xor, Wnd
  *
  * IMPORTANT:
  * This DAG generator does not work for double-degraded archs since it does not
- * generate Q
+ * generate Q.
  *
  * This dag is essentially identical to the large-write dag, except that the
  * write to the failed data unit is suppressed.
  *
  * IMPORTANT:  this dag does not work in the case where the access writes only
  * a portion of the failed unit, and also writes some portion of at least one
- * surviving SU.  this case is handled in CreateDegradedWriteDAG above.
+ * surviving SU. this case is handled in CreateDegradedWriteDAG above.
  *
- * The block & unblock nodes are leftovers from a previous version.  They
+ * The block & unblock nodes are leftovers from a previous version. They
  * do nothing, but I haven't deleted them because it would be a tremendous
  * effort to put them back in.
  *
- * This dag is used whenever a one of the data units in a write has failed.
+ * This dag is used whenever one of the data units in a write has failed.
  * If it is the parity unit that failed, the nonredundant write dag (below)
  * is used.
+ *
  *****************************************************************************/
 
-void 
-rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
-    allocList, nfaults, redFunc, allowBufferRecycle)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *asmap;
-	RF_DagHeader_t *dag_h;
-	void   *bp;
-	RF_RaidAccessFlags_t flags;
-	RF_AllocListElem_t *allocList;
-	int     nfaults;
-	int     (*redFunc) (RF_DagNode_t *);
-	int     allowBufferRecycle;
+void
+rf_CommonCreateSimpleDegradedWriteDAG(RF_Raid_t *raidPtr,
+    RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
+    RF_RaidAccessFlags_t flags, RF_AllocListElem_t *allocList, int nfaults,
+    int (*redFunc) (RF_DagNode_t *), int allowBufferRecycle)
 {
-	int     nNodes, nRrdNodes, nWndNodes, nXorBufs, i, j, paramNum,
-	        rdnodesFaked;
+	int nNodes, nRrdNodes, nWndNodes, nXorBufs, i, j, paramNum,
+	    rdnodesFaked;
 	RF_DagNode_t *blockNode, *unblockNode, *wnpNode, *wnqNode, *termNode;
 	RF_DagNode_t *nodes, *wndNodes, *rrdNodes, *xorNode, *commitNode;
 	RF_SectorCount_t sectorsPerSU;
 	RF_ReconUnitNum_t which_ru;
-	char   *xorTargetBuf = NULL;	/* the target buffer for the XOR
-					 * operation */
-	char   *overlappingPDAs;/* a temporary array of flags */
+	char *xorTargetBuf = NULL;	/*
+					 * The target buffer for the XOR
+					 * operation.
+					 */
+	char *overlappingPDAs;		/* A temporary array of flags. */
 	RF_AccessStripeMapHeader_t *new_asm_h[2];
 	RF_PhysDiskAddr_t *pda, *parityPDA;
 	RF_StripeNum_t parityStripeID;
@@ -177,11 +174,13 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 	RF_RaidLayout_t *layoutPtr;
 
 	layoutPtr = &(raidPtr->Layout);
-	parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr, asmap->raidAddress,
-	    &which_ru);
+	parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr,
+	    asmap->raidAddress, &which_ru);
 	sectorsPerSU = layoutPtr->sectorsPerStripeUnit;
-	/* failedPDA points to the pda within the asm that targets the failed
-	 * disk */
+	/*
+	 * failedPDA points to the pda within the asm that targets
+	 * the failed disk.
+	 */
 	failedPDA = asmap->failedPDAs[0];
 
 	if (rf_dagDebug)
@@ -191,39 +190,45 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 	dag_h->creator = "SimpleDegradedWriteDAG";
 
 	/*
-         * Generate two ASMs identifying the surviving data
-         * we need in order to recover the lost data.
-         */
+	 * Generate two ASMs identifying the surviving data
+	 * we need in order to recover the lost data.
+	 */
 	/* overlappingPDAs array must be zero'd */
-	RF_Calloc(overlappingPDAs, asmap->numStripeUnitsAccessed, sizeof(char), (char *));
-	rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h, new_asm_h,
-	    &nXorBufs, NULL, overlappingPDAs, allocList);
-
-	/* create all the nodes at once */
-	nWndNodes = asmap->numStripeUnitsAccessed - 1;	/* no access is
+	RF_Calloc(overlappingPDAs, asmap->numStripeUnitsAccessed,
+	    sizeof(char), (char *));
+	rf_GenerateFailedAccessASMs(raidPtr, asmap, failedPDA, dag_h,
+	    new_asm_h, &nXorBufs, NULL, overlappingPDAs, allocList);
+
+	/* Create all the nodes at once. */
+	nWndNodes = asmap->numStripeUnitsAccessed - 1;	/*
+							 * No access is
 							 * generated for the
-							 * failed pda */
+							 * failed pda.
+							 */
 
-	nRrdNodes = ((new_asm_h[0]) ? new_asm_h[0]->stripeMap->numStripeUnitsAccessed : 0) +
-	    ((new_asm_h[1]) ? new_asm_h[1]->stripeMap->numStripeUnitsAccessed : 0);
+	nRrdNodes = ((new_asm_h[0]) ?
+	    new_asm_h[0]->stripeMap->numStripeUnitsAccessed : 0) +
+	    ((new_asm_h[1]) ? new_asm_h[1]->stripeMap->numStripeUnitsAccessed
+			    : 0);
 	/*
-         * XXX
-         *
-         * There's a bug with a complete stripe overwrite- that means 0 reads
-         * of old data, and the rest of the DAG generation code doesn't like
-         * that. A release is coming, and I don't wanna risk breaking a critical
-         * DAG generator, so here's what I'm gonna do- if there's no read nodes,
-         * I'm gonna fake there being a read node, and I'm gonna swap in a
-         * no-op node in its place (to make all the link-up code happy).
-         * This should be fixed at some point.  --jimz
-         */
+	 * XXX
+	 *
+	 * There's a bug with a complete stripe overwrite- that means 0 reads
+	 * of old data, and the rest of the DAG generation code doesn't like
+	 * that. A release is coming, and I don't wanna risk breaking a
+	 * critical DAG generator, so here's what I'm gonna do- if there's
+	 * no read nodes, I'm gonna fake there being a read node, and I'm
+	 * gonna swap in a no-op node in its place (to make all the link-up
+	 * code happy).
+	 * This should be fixed at some point. --jimz
+	 */
 	if (nRrdNodes == 0) {
 		nRrdNodes = 1;
 		rdnodesFaked = 1;
 	} else {
 		rdnodesFaked = 0;
 	}
-	/* lock, unlock, xor, Wnd, Rrd, W(nfaults) */
+	/* Lock, unlock, xor, Wnd, Rrd, W(nfaults). */
 	nNodes = 5 + nfaults + nWndNodes + nRrdNodes;
 	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t),
 	    (RF_DagNode_t *), allocList);
@@ -252,154 +257,189 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 	}
 	RF_ASSERT(i == nNodes);
 
-	/* this dag can not commit until all rrd and xor Nodes have completed */
+	/*
+	 * This dag can not commit until all rrd and xor Nodes have
+	 * completed.
+	 */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
 	RF_ASSERT(nRrdNodes > 0);
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, nRrdNodes, 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, nWndNodes + nfaults, 1, 0, 0, dag_h, "Cmt", allocList);
-	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, nWndNodes + nfaults, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
-	rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc, rf_NullNodeUndoFunc, NULL, 1,
-	    nRrdNodes, 2 * nXorBufs + 2, nfaults, dag_h, "Xrc", allocList);
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nRrdNodes, 0, 0, 0, dag_h,
+	    "Nil", allocList);
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nWndNodes + nfaults, 1, 0, 0,
+	    dag_h, "Cmt", allocList);
+	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, nWndNodes + nfaults, 0, 0,
+	    dag_h, "Nil", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc, rf_NullNodeUndoFunc,
+	    NULL, 1, nRrdNodes, 2 * nXorBufs + 2, nfaults, dag_h, "Xrc",
+	    allocList);
 
 	/*
-         * Fill in the Rrd nodes. If any of the rrd buffers are the same size as
-         * the failed buffer, save a pointer to it so we can use it as the target
-         * of the XOR. The pdas in the rrd nodes have been range-restricted, so if
-         * a buffer is the same size as the failed buffer, it must also be at the
-         * same alignment within the SU.
-         */
+	 * Fill in the Rrd nodes. If any of the rrd buffers are the same size
+	 * as the failed buffer, save a pointer to it so we can use it as the
+	 * target of the XOR. The pdas in the rrd nodes have been range-
+	 * restricted, so if a buffer is the same size as the failed buffer,
+	 * it must also be at the same alignment within the SU.
+	 */
 	i = 0;
 	if (new_asm_h[0]) {
 		for (i = 0, pda = new_asm_h[0]->stripeMap->physInfo;
 		    i < new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
 		    i++, pda = pda->next) {
-			rf_InitNode(&rrdNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rrd", allocList);
+			rf_InitNode(&rrdNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskReadFunc, rf_DiskReadUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Rrd", allocList);
 			RF_ASSERT(pda);
 			rrdNodes[i].params[0].p = pda;
 			rrdNodes[i].params[1].p = pda->bufPtr;
 			rrdNodes[i].params[2].v = parityStripeID;
-			rrdNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			rrdNodes[i].params[3].v = RF_CREATE_PARAM3(
+			    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		}
 	}
-	/* i now equals the number of stripe units accessed in new_asm_h[0] */
+	/* i now equals the number of stripe units accessed in new_asm_h[0]. */
 	if (new_asm_h[1]) {
 		for (j = 0, pda = new_asm_h[1]->stripeMap->physInfo;
 		    j < new_asm_h[1]->stripeMap->numStripeUnitsAccessed;
 		    j++, pda = pda->next) {
-			rf_InitNode(&rrdNodes[i + j], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rrd", allocList);
+			rf_InitNode(&rrdNodes[i + j], rf_wait, RF_FALSE,
+			    rf_DiskReadFunc, rf_DiskReadUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Rrd", allocList);
 			RF_ASSERT(pda);
 			rrdNodes[i + j].params[0].p = pda;
 			rrdNodes[i + j].params[1].p = pda->bufPtr;
 			rrdNodes[i + j].params[2].v = parityStripeID;
-			rrdNodes[i + j].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
-			if (allowBufferRecycle && (pda->numSector == failedPDA->numSector))
+			rrdNodes[i + j].params[3].v = RF_CREATE_PARAM3(
+			    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			if (allowBufferRecycle &&
+			    (pda->numSector == failedPDA->numSector))
 				xorTargetBuf = pda->bufPtr;
 		}
 	}
 	if (rdnodesFaked) {
 		/*
-	         * This is where we'll init that fake noop read node
-	         * (XXX should the wakeup func be different?)
-	         */
-		rf_InitNode(&rrdNodes[0], rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, 1, 1, 0, 0, dag_h, "RrN", allocList);
+		 * This is where we'll init that fake noop read node.
+		 * (XXX should the wakeup func be different ?)
+		 */
+		rf_InitNode(&rrdNodes[0], rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, 1, 0, 0, dag_h, "RrN",
+		    allocList);
 	}
 	/*
-         * Make a PDA for the parity unit.  The parity PDA should start at
-         * the same offset into the SU as the failed PDA.
-         */
-	/* Danner comment: I don't think this copy is really necessary. We are
-	 * in one of two cases here. (1) The entire failed unit is written.
-	 * Then asmap->parityInfo will describe the entire parity. (2) We are
-	 * only writing a subset of the failed unit and nothing else. Then the
-	 * asmap->parityInfo describes the failed unit and the copy can also
-	 * be avoided. */
-
-	RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+	 * Make a PDA for the parity unit. The parity PDA should start at
+	 * the same offset into the SU as the failed PDA.
+	 */
+	/*
+	 * Danner comment: I don't think this copy is really necessary. We are
+	 * in one of two cases here.
+	 * (1) The entire failed unit is written. Then asmap->parityInfo will
+	 *     describe the entire parity.
+	 * (2) We are only writing a subset of the failed unit and nothing else.
+	 *     Then the asmap->parityInfo describes the failed unit and the copy
+	 *     can also be avoided.
+	 */
+
+	RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t),
+	    (RF_PhysDiskAddr_t *), allocList);
 	parityPDA->row = asmap->parityInfo->row;
 	parityPDA->col = asmap->parityInfo->col;
-	parityPDA->startSector = ((asmap->parityInfo->startSector / sectorsPerSU)
-	    * sectorsPerSU) + (failedPDA->startSector % sectorsPerSU);
+	parityPDA->startSector = ((asmap->parityInfo->startSector /
+	    sectorsPerSU) * sectorsPerSU) + (failedPDA->startSector %
+	    sectorsPerSU);
 	parityPDA->numSector = failedPDA->numSector;
 
 	if (!xorTargetBuf) {
-		RF_CallocAndAdd(xorTargetBuf, 1,
-		    rf_RaidAddressToByte(raidPtr, failedPDA->numSector), (char *), allocList);
+		RF_CallocAndAdd(xorTargetBuf, 1, rf_RaidAddressToByte(raidPtr,
+		    failedPDA->numSector), (char *), allocList);
 	}
-	/* init the Wnp node */
-	rf_InitNode(wnpNode, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-	    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnp", allocList);
+	/* Init the Wnp node. */
+	rf_InitNode(wnpNode, rf_wait, RF_FALSE, rf_DiskWriteFunc,
+	    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+	    dag_h, "Wnp", allocList);
 	wnpNode->params[0].p = parityPDA;
 	wnpNode->params[1].p = xorTargetBuf;
 	wnpNode->params[2].v = parityStripeID;
-	wnpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+	wnpNode->params[3].v = RF_CREATE_PARAM3(
+	    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 
-	/* fill in the Wnq Node */
+	/* Fill in the Wnq Node. */
 	if (nfaults == 2) {
 		{
 			RF_MallocAndAdd(parityPDA, sizeof(RF_PhysDiskAddr_t),
 			    (RF_PhysDiskAddr_t *), allocList);
 			parityPDA->row = asmap->qInfo->row;
 			parityPDA->col = asmap->qInfo->col;
-			parityPDA->startSector = ((asmap->qInfo->startSector / sectorsPerSU)
-			    * sectorsPerSU) + (failedPDA->startSector % sectorsPerSU);
+			parityPDA->startSector = ((asmap->qInfo->startSector /
+			    sectorsPerSU) * sectorsPerSU) +
+			    (failedPDA->startSector % sectorsPerSU);
 			parityPDA->numSector = failedPDA->numSector;
 
-			rf_InitNode(wnqNode, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnq", allocList);
+			rf_InitNode(wnqNode, rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Wnq", allocList);
 			wnqNode->params[0].p = parityPDA;
 			RF_CallocAndAdd(xorNode->results[1], 1,
-			    rf_RaidAddressToByte(raidPtr, failedPDA->numSector), (char *), allocList);
+			    rf_RaidAddressToByte(raidPtr, failedPDA->numSector),
+			    (char *), allocList);
 			wnqNode->params[1].p = xorNode->results[1];
 			wnqNode->params[2].v = parityStripeID;
-			wnqNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			wnqNode->params[3].v = RF_CREATE_PARAM3(
+			    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		}
 	}
-	/* fill in the Wnd nodes */
-	for (pda = asmap->physInfo, i = 0; i < nWndNodes; i++, pda = pda->next) {
+	/* Fill in the Wnd nodes. */
+	for (pda = asmap->physInfo, i = 0; i < nWndNodes;
+	     i++, pda = pda->next) {
 		if (pda == failedPDA) {
 			i--;
 			continue;
 		}
-		rf_InitNode(&wndNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnd", allocList);
+		rf_InitNode(&wndNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc,
+		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnd", allocList);
 		RF_ASSERT(pda);
 		wndNodes[i].params[0].p = pda;
 		wndNodes[i].params[1].p = pda->bufPtr;
 		wndNodes[i].params[2].v = parityStripeID;
-		wndNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wndNodes[i].params[3].v = RF_CREATE_PARAM3(
+		    RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 	}
 
-	/* fill in the results of the xor node */
+	/* Fill in the results of the xor node. */
 	xorNode->results[0] = xorTargetBuf;
 
-	/* fill in the params of the xor node */
+	/* Fill in the params of the xor node. */
 
 	paramNum = 0;
 	if (rdnodesFaked == 0) {
 		for (i = 0; i < nRrdNodes; i++) {
-			/* all the Rrd nodes need to be xored together */
+			/* All the Rrd nodes need to be xored together. */
 			xorNode->params[paramNum++] = rrdNodes[i].params[0];
 			xorNode->params[paramNum++] = rrdNodes[i].params[1];
 		}
 	}
 	for (i = 0; i < nWndNodes; i++) {
-		/* any Wnd nodes that overlap the failed access need to be
-		 * xored in */
+		/*
+		 * Any Wnd nodes that overlap the failed access need to be
+		 * xored in.
+		 */
 		if (overlappingPDAs[i]) {
-			RF_MallocAndAdd(pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
-			bcopy((char *) wndNodes[i].params[0].p, (char *) pda, sizeof(RF_PhysDiskAddr_t));
-			rf_RangeRestrictPDA(raidPtr, failedPDA, pda, RF_RESTRICT_DOBUFFER, 0);
+			RF_MallocAndAdd(pda, sizeof(RF_PhysDiskAddr_t),
+			    (RF_PhysDiskAddr_t *), allocList);
+			bcopy((char *) wndNodes[i].params[0].p, (char *) pda,
+			    sizeof(RF_PhysDiskAddr_t));
+			rf_RangeRestrictPDA(raidPtr, failedPDA, pda,
+			    RF_RESTRICT_DOBUFFER, 0);
 			xorNode->params[paramNum++].p = pda;
 			xorNode->params[paramNum++].p = pda->bufPtr;
 		}
@@ -407,31 +447,31 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 	RF_Free(overlappingPDAs, asmap->numStripeUnitsAccessed * sizeof(char));
 
 	/*
-         * Install the failed PDA into the xor param list so that the
-         * new data gets xor'd in.
-         */
+	 * Install the failed PDA into the xor param list so that the
+	 * new data gets xor'd in.
+	 */
 	xorNode->params[paramNum++].p = failedPDA;
 	xorNode->params[paramNum++].p = failedPDA->bufPtr;
 
 	/*
-         * The last 2 params to the recovery xor node are always the failed
-         * PDA and the raidPtr. install the failedPDA even though we have just
-         * done so above. This allows us to use the same XOR function for both
-         * degraded reads and degraded writes.
-         */
+	 * The last 2 params to the recovery xor node are always the failed
+	 * PDA and the raidPtr. Install the failedPDA even though we have just
+	 * done so above. This allows us to use the same XOR function for both
+	 * degraded reads and degraded writes.
+	 */
 	xorNode->params[paramNum++].p = failedPDA;
 	xorNode->params[paramNum++].p = raidPtr;
 	RF_ASSERT(paramNum == 2 * nXorBufs + 2);
 
 	/*
-         * Code to link nodes begins here
-         */
+	 * Code to link nodes begins here.
+	 */
 
-	/* link header to block node */
+	/* Link header to block node. */
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* link block node to rd nodes */
+	/* Link block node to rd nodes. */
 	RF_ASSERT(blockNode->numSuccedents == nRrdNodes);
 	for (i = 0; i < nRrdNodes; i++) {
 		RF_ASSERT(rrdNodes[i].numAntecedents == 1);
@@ -440,7 +480,7 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 		rrdNodes[i].antType[0] = rf_control;
 	}
 
-	/* link read nodes to xor node */
+	/* Link read nodes to xor node. */
 	RF_ASSERT(xorNode->numAntecedents == nRrdNodes);
 	for (i = 0; i < nRrdNodes; i++) {
 		RF_ASSERT(rrdNodes[i].numSuccedents == 1);
@@ -449,14 +489,14 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 		xorNode->antType[i] = rf_trueData;
 	}
 
-	/* link xor node to commit node */
+	/* Link xor node to commit node. */
 	RF_ASSERT(xorNode->numSuccedents == 1);
 	RF_ASSERT(commitNode->numAntecedents == 1);
 	xorNode->succedents[0] = commitNode;
 	commitNode->antecedents[0] = xorNode;
 	commitNode->antType[0] = rf_control;
 
-	/* link commit node to wnd nodes */
+	/* Link commit node to wnd nodes. */
 	RF_ASSERT(commitNode->numSuccedents == nfaults + nWndNodes);
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNodes[i].numAntecedents == 1);
@@ -465,7 +505,7 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 		wndNodes[i].antType[0] = rf_control;
 	}
 
-	/* link the commit node to wnp, wnq nodes */
+	/* Link the commit node to wnp, wnq nodes. */
 	RF_ASSERT(wnpNode->numAntecedents == 1);
 	commitNode->succedents[nWndNodes] = wnpNode;
 	wnpNode->antecedents[0] = commitNode;
@@ -476,7 +516,7 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 		wnqNode->antecedents[0] = commitNode;
 		wnqNode->antType[0] = rf_control;
 	}
-	/* link write new data nodes to unblock node */
+	/* Link write new data nodes to unblock node. */
 	RF_ASSERT(unblockNode->numAntecedents == (nWndNodes + nfaults));
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNodes[i].numSuccedents == 1);
@@ -485,20 +525,20 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 		unblockNode->antType[i] = rf_control;
 	}
 
-	/* link write new parity node to unblock node */
+	/* Link write new parity node to unblock node. */
 	RF_ASSERT(wnpNode->numSuccedents == 1);
 	wnpNode->succedents[0] = unblockNode;
 	unblockNode->antecedents[nWndNodes] = wnpNode;
 	unblockNode->antType[nWndNodes] = rf_control;
 
-	/* link write new q node to unblock node */
+	/* Link write new q node to unblock node. */
 	if (nfaults == 2) {
 		RF_ASSERT(wnqNode->numSuccedents == 1);
 		wnqNode->succedents[0] = unblockNode;
 		unblockNode->antecedents[nWndNodes + 1] = wnqNode;
 		unblockNode->antType[nWndNodes + 1] = rf_control;
 	}
-	/* link unblock node to term node */
+	/* Link unblock node to term node. */
 	RF_ASSERT(unblockNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -506,37 +546,40 @@ rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 	termNode->antecedents[0] = unblockNode;
 	termNode->antType[0] = rf_control;
 }
-#define CONS_PDA(if,start,num) \
-  pda_p->row = asmap->if->row;    pda_p->col = asmap->if->col; \
-  pda_p->startSector = ((asmap->if->startSector / secPerSU) * secPerSU) + start; \
-  pda_p->numSector = num; \
-  pda_p->next = NULL; \
-  RF_MallocAndAdd(pda_p->bufPtr,rf_RaidAddressToByte(raidPtr,num),(char *), allocList)
-
-void 
-rf_WriteGenerateFailedAccessASMs(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_PhysDiskAddr_t ** pdap,
-    int *nNodep,
-    RF_PhysDiskAddr_t ** pqpdap,
-    int *nPQNodep,
-    RF_AllocListElem_t * allocList)
+
+#define	CONS_PDA(if,start,num)	do {					\
+	pda_p->row = asmap->if->row;					\
+	pda_p->col = asmap->if->col;					\
+	pda_p->startSector = ((asmap->if->startSector / secPerSU) *	\
+	    secPerSU) + start;						\
+	pda_p->numSector = num;						\
+	pda_p->next = NULL;						\
+	RF_MallocAndAdd(pda_p->bufPtr,					\
+	    rf_RaidAddressToByte(raidPtr,num),(char *), allocList);	\
+} while (0)
+
+void
+rf_WriteGenerateFailedAccessASMs(RF_Raid_t *raidPtr,
+    RF_AccessStripeMap_t *asmap, RF_PhysDiskAddr_t **pdap, int *nNodep,
+    RF_PhysDiskAddr_t **pqpdap, int *nPQNodep, RF_AllocListElem_t *allocList)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	int     PDAPerDisk, i;
+	int PDAPerDisk, i;
 	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
-	int     numDataCol = layoutPtr->numDataCol;
-	int     state;
+	int numDataCol = layoutPtr->numDataCol;
+	int state;
 	unsigned napdas;
 	RF_SectorNum_t fone_start, fone_end, ftwo_start = 0, ftwo_end;
-	RF_PhysDiskAddr_t *fone = asmap->failedPDAs[0], *ftwo = asmap->failedPDAs[1];
+	RF_PhysDiskAddr_t *fone = asmap->failedPDAs[0];
+	RF_PhysDiskAddr_t *ftwo = asmap->failedPDAs[1];
 	RF_PhysDiskAddr_t *pda_p;
 	RF_RaidAddr_t sosAddr;
 
-	/* determine how many pda's we will have to generate per unaccess
+	/*
+	 * Determine how many pda's we will have to generate per unaccessed
 	 * stripe. If there is only one failed data unit, it is one; if two,
-	 * possibly two, depending wether they overlap. */
+	 * possibly two, depending wether they overlap.
+	 */
 
 	fone_start = rf_StripeUnitOffset(layoutPtr, fone->startSector);
 	fone_end = fone_start + fone->numSector;
@@ -544,13 +587,14 @@ rf_WriteGenerateFailedAccessASMs(
 	if (asmap->numDataFailed == 1) {
 		PDAPerDisk = 1;
 		state = 1;
-		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t),
+		    (RF_PhysDiskAddr_t *), allocList);
 		pda_p = *pqpdap;
-		/* build p */
+		/* Build p. */
 		CONS_PDA(parityInfo, fone_start, fone->numSector);
 		pda_p->type = RF_PDA_TYPE_PARITY;
 		pda_p++;
-		/* build q */
+		/* Build q. */
 		CONS_PDA(qInfo, fone_start, fone->numSector);
 		pda_p->type = RF_PDA_TYPE_Q;
 	} else {
@@ -559,7 +603,8 @@ rf_WriteGenerateFailedAccessASMs(
 		if (fone->numSector + ftwo->numSector > secPerSU) {
 			PDAPerDisk = 1;
 			state = 2;
-			RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+			RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t),
+			    (RF_PhysDiskAddr_t *), allocList);
 			pda_p = *pqpdap;
 			CONS_PDA(parityInfo, 0, secPerSU);
 			pda_p->type = RF_PDA_TYPE_PARITY;
@@ -569,8 +614,9 @@ rf_WriteGenerateFailedAccessASMs(
 		} else {
 			PDAPerDisk = 2;
 			state = 3;
-			/* four of them, fone, then ftwo */
-			RF_MallocAndAdd(*pqpdap, 4 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+			/* Four of them, fone, then ftwo. */
+			RF_MallocAndAdd(*pqpdap, 4 * sizeof(RF_PhysDiskAddr_t),
+			    (RF_PhysDiskAddr_t *), allocList);
 			pda_p = *pqpdap;
 			CONS_PDA(parityInfo, fone_start, fone->numSector);
 			pda_p->type = RF_PDA_TYPE_PARITY;
@@ -585,57 +631,66 @@ rf_WriteGenerateFailedAccessASMs(
 			pda_p->type = RF_PDA_TYPE_Q;
 		}
 	}
-	/* figure out number of nonaccessed pda */
+	/* Figure out number of nonaccessed pda. */
 	napdas = PDAPerDisk * (numDataCol - 2);
 	*nPQNodep = PDAPerDisk;
 
 	*nNodep = napdas;
 	if (napdas == 0)
-		return;		/* short circuit */
+		return;		/* Short circuit. */
 
-	/* allocate up our list of pda's */
+	/* Allocate up our list of pda's. */
 
-	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
+	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t),
+	    (RF_PhysDiskAddr_t *), allocList);
 	*pdap = pda_p;
 
-	/* linkem together */
+	/* Link them together. */
 	for (i = 0; i < (napdas - 1); i++)
 		pda_p[i].next = pda_p + (i + 1);
 
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
+	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+	    asmap->raidAddress);
 	for (i = 0; i < numDataCol; i++) {
 		if ((pda_p - (*pdap)) == napdas)
 			continue;
 		pda_p->type = RF_PDA_TYPE_DATA;
 		pda_p->raidAddress = sosAddr + (i * secPerSU);
-		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
-		/* skip over dead disks */
+		(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress,
+		    &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
+		/* Skip over dead disks. */
 		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
 			continue;
 		switch (state) {
-		case 1:	/* fone */
+		case 1:	/* Fone. */
 			pda_p->numSector = fone->numSector;
 			pda_p->raidAddress += fone_start;
 			pda_p->startSector += fone_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(
+			    raidPtr, pda_p->numSector), (char *), allocList);
 			break;
-		case 2:	/* full stripe */
+		case 2:	/* Full stripe. */
 			pda_p->numSector = secPerSU;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(
+			    raidPtr, secPerSU), (char *), allocList);
 			break;
-		case 3:	/* two slabs */
+		case 3:	/* Two slabs. */
 			pda_p->numSector = fone->numSector;
 			pda_p->raidAddress += fone_start;
 			pda_p->startSector += fone_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(
+			    raidPtr, pda_p->numSector), (char *), allocList);
 			pda_p++;
 			pda_p->type = RF_PDA_TYPE_DATA;
 			pda_p->raidAddress = sosAddr + (i * secPerSU);
-			(raidPtr->Layout.map->MapSector) (raidPtr, pda_p->raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), 0);
+			(raidPtr->Layout.map->MapSector) (raidPtr,
+			    pda_p->raidAddress, &(pda_p->row), &(pda_p->col),
+			    &(pda_p->startSector), 0);
 			pda_p->numSector = ftwo->numSector;
 			pda_p->raidAddress += ftwo_start;
 			pda_p->startSector += ftwo_start;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, pda_p->numSector), (char *), allocList);
+			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(
+			    raidPtr, pda_p->numSector), (char *), allocList);
 			break;
 		default:
 			RF_PANIC();
@@ -646,53 +701,56 @@ rf_WriteGenerateFailedAccessASMs(
 	RF_ASSERT(pda_p - *pdap == napdas);
 	return;
 }
-#define DISK_NODE_PDA(node)  ((node)->params[0].p)
-
-#define DISK_NODE_PARAMS(_node_,_p_) \
-  (_node_).params[0].p = _p_ ; \
-  (_node_).params[1].p = (_p_)->bufPtr; \
-  (_node_).params[2].v = parityStripeID; \
-  (_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru)
-
-void 
-rf_DoubleDegSmallWrite(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    char *redundantReadNodeName,
-    char *redundantWriteNodeName,
-    char *recoveryNodeName,
+
+#define	DISK_NODE_PDA(node)	((node)->params[0].p)
+
+#define	DISK_NODE_PARAMS(_node_,_p_)	do {				\
+	(_node_).params[0].p = _p_ ;					\
+	(_node_).params[1].p = (_p_)->bufPtr;				\
+	(_node_).params[2].v = parityStripeID;				\
+	(_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,	\
+	    0, 0, which_ru);						\
+} while (0)
+
+void
+rf_DoubleDegSmallWrite(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, char *redundantReadNodeName,
+    char *redundantWriteNodeName, char *recoveryNodeName,
     int (*recovFunc) (RF_DagNode_t *))
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_DagNode_t *nodes, *wudNodes, *rrdNodes, *recoveryNode, *blockNode,
-	       *unblockNode, *rpNodes, *rqNodes, *wpNodes, *wqNodes, *termNode;
+	    *unblockNode, *rpNodes, *rqNodes, *wpNodes, *wqNodes, *termNode;
 	RF_PhysDiskAddr_t *pda, *pqPDAs;
 	RF_PhysDiskAddr_t *npdas;
-	int     nWriteNodes, nNodes, nReadNodes, nRrdNodes, nWudNodes, i;
+	int nWriteNodes, nNodes, nReadNodes, nRrdNodes, nWudNodes, i;
 	RF_ReconUnitNum_t which_ru;
-	int     nPQNodes;
-	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr, asmap->raidAddress, &which_ru);
+	int nPQNodes;
+	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(
+	    layoutPtr, asmap->raidAddress, &which_ru);
 
-	/* simple small write case - First part looks like a reconstruct-read
+	/*
+	 * Simple small write case - First part looks like a reconstruct-read
 	 * of the failed data units. Then a write of all data units not
-	 * failed. */
+	 * failed.
+	 */
 
 
-	/* Hdr | ------Block- /  /         \   Rrd  Rrd ...  Rrd  Rp Rq \  \
+	/*
+	 * Hdr | ------Block- /  /         \   Rrd  Rrd ...  Rrd  Rp Rq \  \
 	 * /  -------PQ----- /   \   \ Wud   Wp  WQ	     \    |   /
 	 * --Unblock- | T
-	 * 
-	 * Rrd = read recovery data  (potentially none) Wud = write user data
-	 * (not incl. failed disks) Wp = Write P (could be two) Wq = Write Q
-	 * (could be two)
-	 * 
+	 *
+	 * Rrd = read recovery data (potentially none)
+	 * Wud = write user data (not incl. failed disks)
+	 * Wp = Write P (could be two)
+	 * Wq = Write Q (could be two)
+	 *
 	 */
 
-	rf_WriteGenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes, &pqPDAs, &nPQNodes, allocList);
+	rf_WriteGenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes,
+	    &pqPDAs, &nPQNodes, allocList);
 
 	RF_ASSERT(asmap->numDataFailed == 1);
 
@@ -701,7 +759,8 @@ rf_DoubleDegSmallWrite(
 	nWriteNodes = nWudNodes + 2 * nPQNodes;
 	nNodes = 4 + nReadNodes + nWriteNodes;
 
-	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
+	    allocList);
 	blockNode = nodes;
 	unblockNode = blockNode + 1;
 	termNode = unblockNode + 1;
@@ -716,38 +775,46 @@ rf_DoubleDegSmallWrite(
 	dag_h->creator = "PQ_DDSimpleSmallWrite";
 	dag_h->numSuccedents = 1;
 	dag_h->succedents[0] = blockNode;
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
 	termNode->antecedents[0] = unblockNode;
 	termNode->antType[0] = rf_control;
 
-	/* init the block and unblock nodes */
-	/* The block node has all the read nodes as successors */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nReadNodes, 0, 0, 0, dag_h, "Nil", allocList);
+	/* Init the block and unblock nodes. */
+	/* The block node has all the read nodes as successors. */
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nReadNodes, 0, 0, 0, dag_h,
+	    "Nil", allocList);
 	for (i = 0; i < nReadNodes; i++)
 		blockNode->succedents[i] = rrdNodes + i;
 
-	/* The unblock node has all the writes as successors */
-	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nWriteNodes, 0, 0, dag_h, "Nil", allocList);
+	/* The unblock node has all the writes as successors. */
+	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, nWriteNodes, 0, 0, dag_h,
+	    "Nil", allocList);
 	for (i = 0; i < nWriteNodes; i++) {
 		unblockNode->antecedents[i] = wudNodes + i;
 		unblockNode->antType[i] = rf_control;
 	}
 	unblockNode->succedents[0] = termNode;
 
-#define INIT_READ_NODE(node,name) \
-  rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, allocList); \
-  (node)->succedents[0] = recoveryNode; \
-  (node)->antecedents[0] = blockNode; \
-  (node)->antType[0] = rf_control;
+#define	INIT_READ_NODE(node,name)	do {				\
+	rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc,		\
+	    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,	\
+	    dag_h, name, allocList);					\
+	(node)->succedents[0] = recoveryNode;				\
+	(node)->antecedents[0] = blockNode;				\
+	(node)->antType[0] = rf_control;				\
+} while (0)
 
-	/* build the read nodes */
+	/* Build the read nodes. */
 	pda = npdas;
 	for (i = 0; i < nRrdNodes; i++, pda = pda->next) {
 		INIT_READ_NODE(rrdNodes + i, "rrd");
 		DISK_NODE_PARAMS(rrdNodes[i], pda);
 	}
 
-	/* read redundancy pdas */
+	/* Read redundancy pdas. */
 	pda = pqPDAs;
 	INIT_READ_NODE(rpNodes, "Rp");
 	RF_ASSERT(pda);
@@ -766,18 +833,20 @@ rf_DoubleDegSmallWrite(
 		RF_ASSERT(pda);
 		DISK_NODE_PARAMS(rqNodes[1], pda);
 	}
-	/* the recovery node has all reads as precedessors and all writes as
+	/*
+	 * The recovery node has all reads as precedessors and all writes as
 	 * successors. It generates a result for every write P or write Q
 	 * node. As parameters, it takes a pda per read and a pda per stripe
 	 * of user data written. It also takes as the last params the raidPtr
-	 * and asm. For results, it takes PDA for P & Q. */
-
+	 * and asm. For results, it takes PDA for P & Q.
+	 */
 
-	rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc, rf_NullNodeUndoFunc, NULL,
-	    nWriteNodes,	/* succesors */
-	    nReadNodes,		/* preds */
+	rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc,
+	    rf_NullNodeUndoFunc, NULL,
+	    nWriteNodes,		/* succesors */
+	    nReadNodes,			/* preds */
 	    nReadNodes + nWudNodes + 3,	/* params */
-	    2 * nPQNodes,	/* results */
+	    2 * nPQNodes,		/* results */
 	    dag_h, recoveryNodeName, allocList);
 
 
@@ -807,21 +876,25 @@ rf_DoubleDegSmallWrite(
 		pda++;
 		recoveryNode->results[3] = pda;
 	}
-	/* fill writes */
-#define INIT_WRITE_NODE(node,name) \
-  rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, allocList); \
-    (node)->succedents[0] = unblockNode; \
-    (node)->antecedents[0] = recoveryNode; \
-    (node)->antType[0] = rf_control;
+	/* Fill writes. */
+#define	INIT_WRITE_NODE(node,name)	do {				\
+	rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskWriteFunc,		\
+	    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,	\
+	    dag_h, name, allocList);					\
+	(node)->succedents[0] = unblockNode;				\
+	(node)->antecedents[0] = recoveryNode;				\
+	(node)->antType[0] = rf_control;				\
+} while (0)
 
 	pda = asmap->physInfo;
 	for (i = 0; i < nWudNodes; i++) {
 		INIT_WRITE_NODE(wudNodes + i, "Wd");
 		DISK_NODE_PARAMS(wudNodes[i], pda);
-		recoveryNode->params[nReadNodes + i].p = DISK_NODE_PDA(wudNodes + i);
+		recoveryNode->params[nReadNodes + i].p =
+		    DISK_NODE_PDA(wudNodes + i);
 		pda = pda->next;
 	}
-	/* write redundancy pdas */
+	/* Write redundancy pdas. */
 	pda = pqPDAs;
 	INIT_WRITE_NODE(wpNodes, "Wp");
 	RF_ASSERT(pda);
diff --git a/sys/dev/raidframe/rf_dagdegwr.h b/sys/dev/raidframe/rf_dagdegwr.h
index 7d24706f264..ad4cc439bb2 100644
--- a/sys/dev/raidframe/rf_dagdegwr.h
+++ b/sys/dev/raidframe/rf_dagdegwr.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagdegwr.h,v 1.3 2000/01/07 14:50:20 peter Exp $	*/
+/*	$OpenBSD: rf_dagdegwr.h,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagdegwr.h,v 1.4 1999/08/15 02:36:03 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,28 +29,24 @@
  */
 
 
-#ifndef _RF__RF_DAGDEGWR_H_
-#define _RF__RF_DAGDEGWR_H_
+#ifndef	_RF__RF_DAGDEGWR_H_
+#define	_RF__RF_DAGDEGWR_H_
+
+/* Degraded write DAG creation routines. */
 
-/* degraded write DAG creation routines */
-void rf_CreateDegradedWriteDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
+void rf_CreateDegradedWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
 
-void rf_CommonCreateSimpleDegradedWriteDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-    int nfaults, int (*redFunc) (RF_DagNode_t *), int allowBufferRecycle);
+void rf_CommonCreateSimpleDegradedWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	int, int (*) (RF_DagNode_t *), int);
 
-	void    rf_WriteGenerateFailedAccessASMs(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_PhysDiskAddr_t ** pdap,
-            int *nNodep, RF_PhysDiskAddr_t ** pqpdap,
-            int *nPQNodep, RF_AllocListElem_t * allocList);
+void rf_WriteGenerateFailedAccessASMs(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_PhysDiskAddr_t **, int *, RF_PhysDiskAddr_t **, int *,
+	RF_AllocListElem_t *);
 
-	void    rf_DoubleDegSmallWrite(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-            RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-            RF_AllocListElem_t * allocList, char *redundantReadNodeName,
-            char *redundantWriteNodeName, char *recoveryNodeName,
-            int (*recovFunc) (RF_DagNode_t *));
+void rf_DoubleDegSmallWrite(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	char *, char *, char *, int (*) (RF_DagNode_t *));
 
-#endif				/* !_RF__RF_DAGDEGWR_H_ */
+#endif	/* !_RF__RF_DAGDEGWR_H_ */
diff --git a/sys/dev/raidframe/rf_dagffrd.c b/sys/dev/raidframe/rf_dagffrd.c
index 8e6ed1e5af8..89a485b8ca5 100644
--- a/sys/dev/raidframe/rf_dagffrd.c
+++ b/sys/dev/raidframe/rf_dagffrd.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagffrd.c,v 1.3 2000/01/11 18:02:21 peter Exp $	*/
+/*	$OpenBSD: rf_dagffrd.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagffrd.c,v 1.4 2000/01/07 03:40:58 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -30,7 +31,7 @@
 /*
  * rf_dagffrd.c
  *
- * code for creating fault-free read DAGs
+ * Code for creating fault-free read DAGs.
  *
  */
 
@@ -44,7 +45,11 @@
 #include "rf_general.h"
 #include "rf_dagffrd.h"
 
-/******************************************************************************
+void rf_CreateMirrorReadDAG( RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	int (*) (RF_DagNode_t *));
+
+/*****************************************************************************
  *
  * General comments on DAG creation:
  *
@@ -60,39 +65,42 @@
  *
  * A graph has only 1 Cmt node.
  *
- */
+ *****************************************************************************/
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * The following wrappers map the standard DAG creation interface to the
  * DAG creation routines.  Additionally, these wrappers enable experimentation
  * with new DAG structures by providing an extra level of indirection, allowing
  * the DAG creation routines to be replaced at this single point.
- */
+ *
+ *****************************************************************************/
 
-void 
+void
 rf_CreateFaultFreeReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+	RF_Raid_t		*raidPtr,
+	RF_AccessStripeMap_t	*asmap,
+	RF_DagHeader_t		*dag_h,
+	void			*bp,
+	RF_RaidAccessFlags_t	 flags,
+	RF_AllocListElem_t	*allocList
+)
 {
 	rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    RF_IO_TYPE_READ);
 }
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * DAG creation code begins here
- */
+ * DAG creation code begins here.
+ *
+ *****************************************************************************/
 
-/******************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a nonredundant read or write of data within one
+ * Creates a DAG to perform a nonredundant read or write of data within one
  * stripe.
  * For reads, this DAG is as follows:
  *
@@ -124,21 +132,22 @@ rf_CreateFaultFreeReadDAG(
  *
  *****************************************************************************/
 
-void 
+void
 rf_CreateNonredundantDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_IoType_t type)
+	RF_Raid_t		*raidPtr,
+	RF_AccessStripeMap_t	*asmap,
+	RF_DagHeader_t		*dag_h,
+	void			*bp,
+	RF_RaidAccessFlags_t	 flags,
+	RF_AllocListElem_t	*allocList,
+	RF_IoType_t		 type
+)
 {
 	RF_DagNode_t *nodes, *diskNodes, *blockNode, *commitNode, *termNode;
 	RF_PhysDiskAddr_t *pda = asmap->physInfo;
-	int     (*doFunc) (RF_DagNode_t *), (*undoFunc) (RF_DagNode_t *);
-	int     i, n, totalNumNodes;
-	char   *name;
+	int (*doFunc) (RF_DagNode_t *), (*undoFunc) (RF_DagNode_t *);
+	int i, n, totalNumNodes;
+	char *name;
 
 	n = asmap->numStripeUnitsAccessed;
 	dag_h->creator = "NonredundantDAG";
@@ -164,20 +173,20 @@ rf_CreateNonredundantDAG(
 	}
 
 	/*
-         * For reads, the dag can not commit until the block node is reached.
-         * for writes, the dag commits immediately.
-         */
+	 * For reads, the dag can not commit until the block node is reached.
+	 * For writes, the dag commits immediately.
+	 */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
 	/*
-         * Node count:
-         * 1 block node
-         * n data reads (or writes)
-         * 1 commit node
-         * 1 terminator node
-         */
+	 * Node count:
+	 * 1 block node
+	 * n data reads (or writes)
+	 * 1 commit node
+	 * 1 terminator node
+	 */
 	RF_ASSERT(n > 0);
 	totalNumNodes = n + 3;
 	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
@@ -193,23 +202,29 @@ rf_CreateNonredundantDAG(
 	i += 1;
 	RF_ASSERT(i == totalNumNodes);
 
-	/* initialize nodes */
+	/* Initialize nodes. */
 	switch (type) {
 	case RF_IO_TYPE_READ:
-		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, n, 0, 0, 0, dag_h, "Nil", allocList);
-		rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, 1, n, 0, 0, dag_h, "Cmt", allocList);
-		rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-		    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, n, 0, 0, 0, dag_h, "Nil",
+		    allocList);
+		rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, n, 0, 0, dag_h, "Cmt",
+		    allocList);
+		rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+		    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm",
+		    allocList);
 		break;
 	case RF_IO_TYPE_WRITE:
-		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
-		rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, n, 1, 0, 0, dag_h, "Cmt", allocList);
-		rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-		    NULL, 0, n, 0, 0, dag_h, "Trm", allocList);
+		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil",
+		    allocList);
+		rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, n, 1, 0, 0, dag_h, "Cmt",
+		    allocList);
+		rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+		    rf_TerminateUndoFunc, NULL, 0, n, 0, 0, dag_h, "Trm",
+		    allocList);
 		break;
 	default:
 		RF_PANIC();
@@ -217,42 +232,43 @@ rf_CreateNonredundantDAG(
 
 	for (i = 0; i < n; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&diskNodes[i], rf_wait, RF_FALSE, doFunc, undoFunc, rf_GenericWakeupFunc,
-		    1, 1, 4, 0, dag_h, name, allocList);
+		rf_InitNode(&diskNodes[i], rf_wait, RF_FALSE, doFunc, undoFunc,
+		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, allocList);
 		diskNodes[i].params[0].p = pda;
 		diskNodes[i].params[1].p = pda->bufPtr;
-		/* parity stripe id is not necessary */
+		/* Parity stripe id is not necessary. */
 		diskNodes[i].params[2].v = 0;
-		diskNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
+		diskNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
 		pda = pda->next;
 	}
 
 	/*
-         * Connect nodes.
-         */
+	 * Connect nodes.
+	 */
 
-	/* connect hdr to block node */
+	/* Connect hdr to block node. */
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
 	if (type == RF_IO_TYPE_READ) {
-		/* connecting a nonredundant read DAG */
+		/* Connecting a nonredundant read DAG. */
 		RF_ASSERT(blockNode->numSuccedents == n);
 		RF_ASSERT(commitNode->numAntecedents == n);
 		for (i = 0; i < n; i++) {
-			/* connect block node to each read node */
+			/* Connect block node to each read node. */
 			RF_ASSERT(diskNodes[i].numAntecedents == 1);
 			blockNode->succedents[i] = &diskNodes[i];
 			diskNodes[i].antecedents[0] = blockNode;
 			diskNodes[i].antType[0] = rf_control;
 
-			/* connect each read node to the commit node */
+			/* Connect each read node to the commit node. */
 			RF_ASSERT(diskNodes[i].numSuccedents == 1);
 			diskNodes[i].succedents[0] = commitNode;
 			commitNode->antecedents[i] = &diskNodes[i];
 			commitNode->antType[i] = rf_control;
 		}
-		/* connect the commit node to the term node */
+		/* Connect the commit node to the term node. */
 		RF_ASSERT(commitNode->numSuccedents == 1);
 		RF_ASSERT(termNode->numAntecedents == 1);
 		RF_ASSERT(termNode->numSuccedents == 0);
@@ -260,8 +276,8 @@ rf_CreateNonredundantDAG(
 		termNode->antecedents[0] = commitNode;
 		termNode->antType[0] = rf_control;
 	} else {
-		/* connecting a nonredundant write DAG */
-		/* connect the block node to the commit node */
+		/* Connecting a nonredundant write DAG. */
+		/* Connect the block node to the commit node. */
 		RF_ASSERT(blockNode->numSuccedents == 1);
 		RF_ASSERT(commitNode->numAntecedents == 1);
 		blockNode->succedents[0] = commitNode;
@@ -272,13 +288,13 @@ rf_CreateNonredundantDAG(
 		RF_ASSERT(termNode->numAntecedents == n);
 		RF_ASSERT(termNode->numSuccedents == 0);
 		for (i = 0; i < n; i++) {
-			/* connect the commit node to each write node */
+			/* Connect the commit node to each write node. */
 			RF_ASSERT(diskNodes[i].numAntecedents == 1);
 			commitNode->succedents[i] = &diskNodes[i];
 			diskNodes[i].antecedents[0] = commitNode;
 			diskNodes[i].antType[0] = rf_control;
 
-			/* connect each write node to the term node */
+			/* Connect each write node to the term node. */
 			RF_ASSERT(diskNodes[i].numSuccedents == 1);
 			diskNodes[i].succedents[0] = termNode;
 			termNode->antecedents[i] = &diskNodes[i];
@@ -286,37 +302,38 @@ rf_CreateNonredundantDAG(
 		}
 	}
 }
-/******************************************************************************
- * Create a fault-free read DAG for RAID level 1
+/*****************************************************************************
+ * Create a fault-free read DAG for RAID level 1.
  *
  * Hdr -> Nil -> Rmir -> Cmt -> Trm
  *
  * The "Rmir" node schedules a read from the disk in the mirror pair with the
- * shortest disk queue.  the proper queue is selected at Rmir execution.  this
+ * shortest disk queue.  The proper queue is selected at Rmir execution.  This
  * deferred mapping is unlike other archs in RAIDframe which generally fix
  * mapping at DAG creation time.
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (for holding read data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
+ * Parameters:  raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (for holding read data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
  *****************************************************************************/
 
-static void 
-CreateMirrorReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    int (*readfunc) (RF_DagNode_t * node))
+void
+rf_CreateMirrorReadDAG(
+	RF_Raid_t		 *raidPtr,
+	RF_AccessStripeMap_t	 *asmap,
+	RF_DagHeader_t		 *dag_h,
+	void			 *bp,
+	RF_RaidAccessFlags_t	  flags,
+	RF_AllocListElem_t	 *allocList,
+	int			(*readfunc) (RF_DagNode_t *)
+)
 {
 	RF_DagNode_t *readNodes, *nodes, *blockNode, *commitNode, *termNode;
 	RF_PhysDiskAddr_t *data_pda = asmap->physInfo;
 	RF_PhysDiskAddr_t *parity_pda = asmap->parityInfo;
-	int     i, n, totalNumNodes;
+	int i, n, totalNumNodes;
 
 	n = asmap->numStripeUnitsAccessed;
 	dag_h->creator = "RaidOneReadDAG";
@@ -324,20 +341,20 @@ CreateMirrorReadDAG(
 		printf("[Creating RAID level 1 read DAG]\n");
 	}
 	/*
-         * This dag can not commit until the commit node is reached
-         * errors prior to the commit point imply the dag has failed.
-         */
+	 * This dag can not commit until the commit node is reached.
+	 * Errors prior to the commit point imply the dag has failed.
+	 */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
 	/*
-         * Node count:
-         * n data reads
-         * 1 block node
-         * 1 commit node
-         * 1 terminator node
-         */
+	 * Node count:
+	 * n data reads
+	 * 1 block node
+	 * 1 commit node
+	 * 1 terminator node
+	 */
 	RF_ASSERT(n > 0);
 	totalNumNodes = n + 3;
 	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
@@ -353,7 +370,7 @@ CreateMirrorReadDAG(
 	i += 1;
 	RF_ASSERT(i == totalNumNodes);
 
-	/* initialize nodes */
+	/* Initialize nodes. */
 	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
 	    rf_NullNodeUndoFunc, NULL, n, 0, 0, 0, dag_h, "Nil", allocList);
 	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
@@ -365,27 +382,28 @@ CreateMirrorReadDAG(
 		RF_ASSERT(data_pda != NULL);
 		RF_ASSERT(parity_pda != NULL);
 		rf_InitNode(&readNodes[i], rf_wait, RF_FALSE, readfunc,
-		    rf_DiskReadMirrorUndoFunc, rf_GenericWakeupFunc, 1, 1, 5, 0, dag_h,
-		    "Rmir", allocList);
+		    rf_DiskReadMirrorUndoFunc, rf_GenericWakeupFunc, 1, 1, 5,
+		    0, dag_h, "Rmir", allocList);
 		readNodes[i].params[0].p = data_pda;
 		readNodes[i].params[1].p = data_pda->bufPtr;
-		/* parity stripe id is not necessary */
+		/* Parity stripe id is not necessary. */
 		readNodes[i].params[2].p = 0;
-		readNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
+		readNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
 		readNodes[i].params[4].p = parity_pda;
 		data_pda = data_pda->next;
 		parity_pda = parity_pda->next;
 	}
 
 	/*
-         * Connect nodes
-         */
+	 * Connect nodes.
+	 */
 
-	/* connect hdr to block node */
+	/* Connect hdr to block node. */
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* connect block node to read nodes */
+	/* Connect block node to read nodes. */
 	RF_ASSERT(blockNode->numSuccedents == n);
 	for (i = 0; i < n; i++) {
 		RF_ASSERT(readNodes[i].numAntecedents == 1);
@@ -394,7 +412,7 @@ CreateMirrorReadDAG(
 		readNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect read nodes to commit node */
+	/* Connect read nodes to commit node. */
 	RF_ASSERT(commitNode->numAntecedents == n);
 	for (i = 0; i < n; i++) {
 		RF_ASSERT(readNodes[i].numSuccedents == 1);
@@ -403,7 +421,7 @@ CreateMirrorReadDAG(
 		commitNode->antType[i] = rf_control;
 	}
 
-	/* connect commit node to term node */
+	/* Connect commit node to term node. */
 	RF_ASSERT(commitNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -412,28 +430,30 @@ CreateMirrorReadDAG(
 	termNode->antType[0] = rf_control;
 }
 
-void 
+void
 rf_CreateMirrorIdleReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+	RF_Raid_t		*raidPtr,
+	RF_AccessStripeMap_t	*asmap,
+	RF_DagHeader_t		*dag_h,
+	void			*bp,
+	RF_RaidAccessFlags_t	 flags,
+	RF_AllocListElem_t	*allocList
+)
 {
-	CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	rf_CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    rf_DiskReadMirrorIdleFunc);
 }
 
-void 
+void
 rf_CreateMirrorPartitionReadDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+	RF_Raid_t		*raidPtr,
+	RF_AccessStripeMap_t	*asmap,
+	RF_DagHeader_t		*dag_h,
+	void			*bp,
+	RF_RaidAccessFlags_t	 flags,
+	RF_AllocListElem_t	*allocList
+)
 {
-	CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	rf_CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    rf_DiskReadMirrorPartitionFunc);
 }
diff --git a/sys/dev/raidframe/rf_dagffrd.h b/sys/dev/raidframe/rf_dagffrd.h
index ae068900493..4912f0c46b2 100644
--- a/sys/dev/raidframe/rf_dagffrd.h
+++ b/sys/dev/raidframe/rf_dagffrd.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagffrd.h,v 1.2 1999/02/16 00:02:30 niklas Exp $	*/
+/*	$OpenBSD: rf_dagffrd.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagffrd.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,27 +28,21 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_DAGFFRD_H_
-#define _RF__RF_DAGFFRD_H_
+#ifndef	_RF__RF_DAGFFRD_H_
+#define	_RF__RF_DAGFFRD_H_
 
 #include "rf_types.h"
 
-/* fault-free read DAG creation routines */
-void 
-rf_CreateFaultFreeReadDAG(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList);
-void 
-rf_CreateNonredundantDAG(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList, RF_IoType_t type);
-void 
-rf_CreateMirrorIdleReadDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
-void 
-rf_CreateMirrorPartitionReadDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
+/* Fault-free read DAG creation routines. */
+
+void rf_CreateFaultFreeReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CreateNonredundantDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_IoType_t);
+void rf_CreateMirrorIdleReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CreateMirrorPartitionReadDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
 
-#endif				/* !_RF__RF_DAGFFRD_H_ */
+#endif	/* !_RF__RF_DAGFFRD_H_ */
diff --git a/sys/dev/raidframe/rf_dagffwr.c b/sys/dev/raidframe/rf_dagffwr.c
index 38e42e43134..0dcbd898d28 100644
--- a/sys/dev/raidframe/rf_dagffwr.c
+++ b/sys/dev/raidframe/rf_dagffwr.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagffwr.c,v 1.4 2000/01/11 18:02:21 peter Exp $	*/
+/*	$OpenBSD: rf_dagffwr.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagffwr.c,v 1.5 2000/01/07 03:40:58 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -30,7 +31,7 @@
 /*
  * rf_dagff.c
  *
- * code for creating fault-free DAGs
+ * Code for creating fault-free DAGs.
  *
  */
 
@@ -45,14 +46,14 @@
 #include "rf_general.h"
 #include "rf_dagffwr.h"
 
-/******************************************************************************
+/*****************************************************************************
  *
  * General comments on DAG creation:
  *
- * All DAGs in this file use roll-away error recovery.  Each DAG has a single
+ * All DAGs in this file use roll-away error recovery. Each DAG has a single
  * commit node, usually called "Cmt."  If an error occurs before the Cmt node
  * is reached, the execution engine will halt forward execution and work
- * backward through the graph, executing the undo functions.  Assuming that
+ * backward through the graph, executing the undo functions. Assuming that
  * each node in the graph prior to the Cmt node are undoable and atomic - or -
  * does not make changes to permanent state, the graph will fail atomically.
  * If an error occurs after the Cmt node executes, the engine will roll-forward
@@ -61,82 +62,66 @@
  *
  * A graph has only 1 Cmt node.
  *
- */
+ *****************************************************************************/
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * The following wrappers map the standard DAG creation interface to the
- * DAG creation routines.  Additionally, these wrappers enable experimentation
+ * DAG creation routines. Additionally, these wrappers enable experimentation
  * with new DAG structures by providing an extra level of indirection, allowing
  * the DAG creation routines to be replaced at this single point.
- */
+ *
+ *****************************************************************************/
 
 
-void 
-rf_CreateNonRedundantWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_IoType_t type)
+void
+rf_CreateNonRedundantWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, RF_IoType_t type)
 {
 	rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    RF_IO_TYPE_WRITE);
 }
 
-void 
-rf_CreateRAID0WriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_IoType_t type)
+void
+rf_CreateRAID0WriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, RF_IoType_t type)
 {
 	rf_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    RF_IO_TYPE_WRITE);
 }
 
-void 
-rf_CreateSmallWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+void
+rf_CreateSmallWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList)
 {
-	/* "normal" rollaway */
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    &rf_xorFuncs, NULL);
+	/* "normal" rollaway. */
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_xorFuncs, NULL);
 }
 
-void 
-rf_CreateLargeWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+void
+rf_CreateLargeWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList)
 {
-	/* "normal" rollaway */
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    1, rf_RegularXorFunc, RF_TRUE);
+	/* "normal" rollaway. */
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 1, rf_RegularXorFunc, RF_TRUE);
 }
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * DAG creation code begins here
- */
+ * DAG creation code begins here.
+ *
+ *****************************************************************************/
 
 
-/******************************************************************************
+/*****************************************************************************
  *
  * creates a DAG to perform a large-write operation:
  *
@@ -146,52 +131,46 @@ rf_CreateLargeWriteDAG(
  *                             \[Wnq]/
  *
  * The XOR node also does the Q calculation in the P+Q architecture.
- * All nodes are before the commit node (Cmt) are assumed to be atomic and
- * undoable - or - they make no changes to permanent state.
+ * All nodes that are before the commit node (Cmt) are assumed to be atomic
+ * and undoable - or - they make no changes to permanent state.
  *
  * Rod = read old data
  * Cmt = commit node
  * Wnp = write new parity
  * Wnd = write new data
  * Wnq = write new "q"
- * [] denotes optional segments in the graph
+ * [] denotes optional segments in the graph.
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (holds write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
- *              nfaults   - number of faults array can tolerate
- *                          (equal to # redundancy units in stripe)
- *              redfuncs  - list of redundancy generating functions
+ * Parameters:  raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (holds write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
+ *		nfaults	  - number of faults array can tolerate
+ *			    (equal to # redundancy units in stripe)
+ *		redfuncs  - list of redundancy generating functions
  *
  *****************************************************************************/
 
-void 
-rf_CommonCreateLargeWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    int nfaults,
-    int (*redFunc) (RF_DagNode_t *),
+void
+rf_CommonCreateLargeWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, int nfaults, int (*redFunc) (RF_DagNode_t *),
     int allowBufferRecycle)
 {
 	RF_DagNode_t *nodes, *wndNodes, *rodNodes, *xorNode, *wnpNode;
 	RF_DagNode_t *wnqNode, *blockNode, *commitNode, *termNode;
-	int     nWndNodes, nRodNodes, i, nodeNum, asmNum;
+	int nWndNodes, nRodNodes, i, nodeNum, asmNum;
 	RF_AccessStripeMapHeader_t *new_asm_h[2];
 	RF_StripeNum_t parityStripeID;
-	char   *sosBuffer, *eosBuffer;
+	char *sosBuffer, *eosBuffer;
 	RF_ReconUnitNum_t which_ru;
 	RF_RaidLayout_t *layoutPtr;
 	RF_PhysDiskAddr_t *pda;
 
 	layoutPtr = &(raidPtr->Layout);
-	parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr, asmap->raidAddress,
-	    &which_ru);
+	parityStripeID = rf_RaidAddressToParityStripeID(layoutPtr,
+	    asmap->raidAddress, &which_ru);
 
 	if (rf_dagDebug) {
 		printf("[Creating large-write DAG]\n");
@@ -202,7 +181,7 @@ rf_CommonCreateLargeWriteDAG(
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	/* alloc the nodes: Wnd, xor, commit, block, term, and  Wnp */
+	/* Alloc the nodes: Wnd, xor, commit, block, term, and  Wnp. */
 	nWndNodes = asmap->numStripeUnitsAccessed;
 	RF_CallocAndAdd(nodes, nWndNodes + 4 + nfaults, sizeof(RF_DagNode_t),
 	    (RF_DagNode_t *), allocList);
@@ -225,8 +204,8 @@ rf_CommonCreateLargeWriteDAG(
 	} else {
 		wnqNode = NULL;
 	}
-	rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h, new_asm_h,
-	    &nRodNodes, &sosBuffer, &eosBuffer, allocList);
+	rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h,
+	    new_asm_h, &nRodNodes, &sosBuffer, &eosBuffer, allocList);
 	if (nRodNodes > 0) {
 		RF_CallocAndAdd(rodNodes, nRodNodes, sizeof(RF_DagNode_t),
 		    (RF_DagNode_t *), allocList);
@@ -234,32 +213,38 @@ rf_CommonCreateLargeWriteDAG(
 		rodNodes = NULL;
 	}
 
-	/* begin node initialization */
+	/* Begin node initialization. */
 	if (nRodNodes > 0) {
-		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, nRodNodes, 0, 0, 0, dag_h, "Nil", allocList);
+		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, nRodNodes, 0, 0, 0, dag_h,
+		    "Nil", allocList);
 	} else {
-		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-		    NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
+		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil",
+		    allocList);
 	}
 
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL,
-	    nWndNodes + nfaults, 1, 0, 0, dag_h, "Cmt", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL,
-	    0, nWndNodes + nfaults, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nWndNodes + nfaults, 1, 0, 0,
+	    dag_h, "Cmt", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, nWndNodes + nfaults, 0, 0,
+	    dag_h, "Trm", allocList);
 
-	/* initialize the Rod nodes */
+	/* Initialize the Rod nodes. */
 	for (nodeNum = asmNum = 0; asmNum < 2; asmNum++) {
 		if (new_asm_h[asmNum]) {
 			pda = new_asm_h[asmNum]->stripeMap->physInfo;
 			while (pda) {
-				rf_InitNode(&rodNodes[nodeNum], rf_wait, RF_FALSE, rf_DiskReadFunc,
-				    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
-				    "Rod", allocList);
+				rf_InitNode(&rodNodes[nodeNum], rf_wait,
+				    RF_FALSE, rf_DiskReadFunc,
+				    rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+				    1, 1, 4, 0, dag_h, "Rod", allocList);
 				rodNodes[nodeNum].params[0].p = pda;
 				rodNodes[nodeNum].params[1].p = pda->bufPtr;
 				rodNodes[nodeNum].params[2].v = parityStripeID;
-				rodNodes[nodeNum].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+				rodNodes[nodeNum].params[3].v =
+				    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 				    0, 0, which_ru);
 				nodeNum++;
 				pda = pda->next;
@@ -268,98 +253,115 @@ rf_CommonCreateLargeWriteDAG(
 	}
 	RF_ASSERT(nodeNum == nRodNodes);
 
-	/* initialize the wnd nodes */
+	/* Initialize the wnd nodes. */
 	pda = asmap->physInfo;
 	for (i = 0; i < nWndNodes; i++) {
-		rf_InitNode(&wndNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnd", allocList);
+		rf_InitNode(&wndNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc,
+		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnd", allocList);
 		RF_ASSERT(pda != NULL);
 		wndNodes[i].params[0].p = pda;
 		wndNodes[i].params[1].p = pda->bufPtr;
 		wndNodes[i].params[2].v = parityStripeID;
-		wndNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wndNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		pda = pda->next;
 	}
 
-	/* initialize the redundancy node */
+	/* Initialize the redundancy node. */
 	if (nRodNodes > 0) {
-		rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc, rf_NullNodeUndoFunc, NULL, 1,
-		    nRodNodes, 2 * (nWndNodes + nRodNodes) + 1, nfaults, dag_h,
+		rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, nRodNodes,
+		    2 * (nWndNodes + nRodNodes) + 1, nfaults, dag_h,
 		    "Xr ", allocList);
 	} else {
-		rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc, rf_NullNodeUndoFunc, NULL, 1,
-		    1, 2 * (nWndNodes + nRodNodes) + 1, nfaults, dag_h, "Xr ", allocList);
+		rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, 1,
+		    2 * (nWndNodes + nRodNodes) + 1, nfaults, dag_h,
+		    "Xr ", allocList);
 	}
 	xorNode->flags |= RF_DAGNODE_FLAG_YIELD;
 	for (i = 0; i < nWndNodes; i++) {
-		xorNode->params[2 * i + 0] = wndNodes[i].params[0];	/* pda */
-		xorNode->params[2 * i + 1] = wndNodes[i].params[1];	/* buf ptr */
+		xorNode->params[2 * i + 0] =
+		    wndNodes[i].params[0];	/* pda */
+		xorNode->params[2 * i + 1] =
+		    wndNodes[i].params[1];	/* buf ptr */
 	}
 	for (i = 0; i < nRodNodes; i++) {
-		xorNode->params[2 * (nWndNodes + i) + 0] = rodNodes[i].params[0];	/* pda */
-		xorNode->params[2 * (nWndNodes + i) + 1] = rodNodes[i].params[1];	/* buf ptr */
+		xorNode->params[2 * (nWndNodes + i) + 0] =
+		    rodNodes[i].params[0];	/* pda */
+		xorNode->params[2 * (nWndNodes + i) + 1] =
+		    rodNodes[i].params[1];	/* buf ptr */
 	}
-	/* xor node needs to get at RAID information */
+	/* Xor node needs to get at RAID information. */
 	xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;
 
 	/*
-         * Look for an Rod node that reads a complete SU. If none, alloc a buffer
-         * to receive the parity info. Note that we can't use a new data buffer
-         * because it will not have gotten written when the xor occurs.
-         */
+	 * Look for an Rod node that reads a complete SU. If none, alloc
+	 * a buffer to receive the parity info. Note that we can't use a
+	 * new data buffer because it will not have gotten written when
+	 * the xor occurs.
+	 */
 	if (allowBufferRecycle) {
 		for (i = 0; i < nRodNodes; i++) {
-			if (((RF_PhysDiskAddr_t *) rodNodes[i].params[0].p)->numSector == raidPtr->Layout.sectorsPerStripeUnit)
+			if (((RF_PhysDiskAddr_t *) rodNodes[i].params[0].p)
+			    ->numSector == raidPtr->Layout.sectorsPerStripeUnit)
 				break;
 		}
 	}
 	if ((!allowBufferRecycle) || (i == nRodNodes)) {
 		RF_CallocAndAdd(xorNode->results[0], 1,
-		    rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit),
+		    rf_RaidAddressToByte(raidPtr,
+		    raidPtr->Layout.sectorsPerStripeUnit),
 		    (void *), allocList);
 	} else {
 		xorNode->results[0] = rodNodes[i].params[1].p;
 	}
 
-	/* initialize the Wnp node */
-	rf_InitNode(wnpNode, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-	    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnp", allocList);
+	/* Initialize the Wnp node. */
+	rf_InitNode(wnpNode, rf_wait, RF_FALSE, rf_DiskWriteFunc,
+	    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+	    dag_h, "Wnp", allocList);
 	wnpNode->params[0].p = asmap->parityInfo;
 	wnpNode->params[1].p = xorNode->results[0];
 	wnpNode->params[2].v = parityStripeID;
-	wnpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
-	/* parityInfo must describe entire parity unit */
+	wnpNode->params[3].v =
+	    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+	/* parityInfo must describe entire parity unit. */
 	RF_ASSERT(asmap->parityInfo->next == NULL);
 
 	if (nfaults == 2) {
 		/*
-	         * We never try to recycle a buffer for the Q calcuation
-	         * in addition to the parity. This would cause two buffers
-	         * to get smashed during the P and Q calculation, guaranteeing
-	         * one would be wrong.
-	         */
+		 * We never try to recycle a buffer for the Q calculation
+		 * in addition to the parity. This would cause two buffers
+		 * to get smashed during the P and Q calculation, guaranteeing
+		 * one would be wrong.
+		 */
 		RF_CallocAndAdd(xorNode->results[1], 1,
-		    rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit),
+		    rf_RaidAddressToByte(raidPtr,
+		     raidPtr->Layout.sectorsPerStripeUnit),
 		    (void *), allocList);
-		rf_InitNode(wnqNode, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnq", allocList);
+		rf_InitNode(wnqNode, rf_wait, RF_FALSE, rf_DiskWriteFunc,
+		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnq", allocList);
 		wnqNode->params[0].p = asmap->qInfo;
 		wnqNode->params[1].p = xorNode->results[1];
 		wnqNode->params[2].v = parityStripeID;
-		wnqNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
-		/* parityInfo must describe entire parity unit */
+		wnqNode->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		/* parityInfo must describe entire parity unit. */
 		RF_ASSERT(asmap->parityInfo->next == NULL);
 	}
 	/*
-         * Connect nodes to form graph.
-         */
+	 * Connect nodes to form graph.
+	 */
 
-	/* connect dag header to block node */
+	/* Connect dag header to block node. */
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
 	if (nRodNodes > 0) {
-		/* connect the block node to the Rod nodes */
+		/* Connect the block node to the Rod nodes. */
 		RF_ASSERT(blockNode->numSuccedents == nRodNodes);
 		RF_ASSERT(xorNode->numAntecedents == nRodNodes);
 		for (i = 0; i < nRodNodes; i++) {
@@ -368,14 +370,14 @@ rf_CommonCreateLargeWriteDAG(
 			rodNodes[i].antecedents[0] = blockNode;
 			rodNodes[i].antType[0] = rf_control;
 
-			/* connect the Rod nodes to the Xor node */
+			/* Connect the Rod nodes to the Xor node. */
 			RF_ASSERT(rodNodes[i].numSuccedents == 1);
 			rodNodes[i].succedents[0] = xorNode;
 			xorNode->antecedents[i] = &rodNodes[i];
 			xorNode->antType[i] = rf_trueData;
 		}
 	} else {
-		/* connect the block node to the Xor node */
+		/* Connect the block node to the Xor node. */
 		RF_ASSERT(blockNode->numSuccedents == 1);
 		RF_ASSERT(xorNode->numAntecedents == 1);
 		blockNode->succedents[0] = xorNode;
@@ -383,14 +385,14 @@ rf_CommonCreateLargeWriteDAG(
 		xorNode->antType[0] = rf_control;
 	}
 
-	/* connect the xor node to the commit node */
+	/* Connect the xor node to the commit node. */
 	RF_ASSERT(xorNode->numSuccedents == 1);
 	RF_ASSERT(commitNode->numAntecedents == 1);
 	xorNode->succedents[0] = commitNode;
 	commitNode->antecedents[0] = xorNode;
 	commitNode->antType[0] = rf_control;
 
-	/* connect the commit node to the write nodes */
+	/* Connect the commit node to the write nodes. */
 	RF_ASSERT(commitNode->numSuccedents == nWndNodes + nfaults);
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNodes->numAntecedents == 1);
@@ -408,7 +410,7 @@ rf_CommonCreateLargeWriteDAG(
 		wnqNode->antecedents[0] = commitNode;
 		wnqNode->antType[0] = rf_trueData;
 	}
-	/* connect the write nodes to the term node */
+	/* Connect the write nodes to the term node. */
 	RF_ASSERT(termNode->numAntecedents == nWndNodes + nfaults);
 	RF_ASSERT(termNode->numSuccedents == 0);
 	for (i = 0; i < nWndNodes; i++) {
@@ -428,9 +430,9 @@ rf_CommonCreateLargeWriteDAG(
 		termNode->antType[nWndNodes + 1] = rf_control;
 	}
 }
-/******************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a small-write operation (either raid 5 or pq),
+ * Create a DAG to perform a small-write operation (either raid 5 or pq),
  * which is as follows:
  *
  * Hdr -> Nil -> Rop -> Xor -> Cmt ----> Wnp [Unp] --> Trm
@@ -448,46 +450,41 @@ rf_CommonCreateLargeWriteDAG(
  * Wnp = write new parity
  * Wnd = write new data
  * Wnq = write new "q"
- * [ ] denotes optional segments in the graph
+ * [ ] denotes optional segments in the graph.
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (holds write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
- *              pfuncs    - list of parity generating functions
- *              qfuncs    - list of q generating functions
+ * Parameters:	raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (holds write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
+ *		pfuncs	  - list of parity generating functions
+ *		qfuncs	  - list of q generating functions
  *
- * A null qfuncs indicates single fault tolerant
+ * A null qfuncs indicates single fault tolerant.
  *****************************************************************************/
 
-void 
-rf_CommonCreateSmallWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_RedFuncs_t * pfuncs,
-    RF_RedFuncs_t * qfuncs)
+void
+rf_CommonCreateSmallWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, RF_RedFuncs_t *pfuncs, RF_RedFuncs_t *qfuncs)
 {
 	RF_DagNode_t *readDataNodes, *readParityNodes, *readQNodes, *termNode;
 	RF_DagNode_t *unlockDataNodes, *unlockParityNodes, *unlockQNodes;
 	RF_DagNode_t *xorNodes, *qNodes, *blockNode, *commitNode, *nodes;
 	RF_DagNode_t *writeDataNodes, *writeParityNodes, *writeQNodes;
-	int     i, j, nNodes, totalNumNodes, lu_flag;
+	int i, j, nNodes, totalNumNodes, lu_flag;
 	RF_ReconUnitNum_t which_ru;
-	int     (*func) (RF_DagNode_t *), (*undoFunc) (RF_DagNode_t *);
-	int     (*qfunc) (RF_DagNode_t *);
-	int     numDataNodes, numParityNodes;
+	int (*func) (RF_DagNode_t *);
+	int (*undoFunc) (RF_DagNode_t *);
+	int (*qfunc) (RF_DagNode_t *);
+	int numDataNodes, numParityNodes;
 	RF_StripeNum_t parityStripeID;
 	RF_PhysDiskAddr_t *pda;
-	char   *name, *qname;
-	long    nfaults;
+	char *name, *qname;
+	long nfaults;
 
 	nfaults = qfuncs ? 2 : 1;
-	lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* lock/unlock flag */
+	lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* Lock/unlock flag. */
 
 	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
 	    asmap->raidAddress, &which_ru);
@@ -506,30 +503,32 @@ rf_CommonCreateSmallWriteDAG(
 	dag_h->numSuccedents = 1;
 
 	/*
-         * DAG creation occurs in four steps:
-         * 1. count the number of nodes in the DAG
-         * 2. create the nodes
-         * 3. initialize the nodes
-         * 4. connect the nodes
-         */
+	 * DAG creation occurs in four steps:
+	 * 1. Count the number of nodes in the DAG.
+	 * 2. Create the nodes.
+	 * 3. Initialize the nodes.
+	 * 4. Connect the nodes.
+	 */
+
+	/*
+	 * Step 1. Compute number of nodes in the graph.
+	 */
 
 	/*
-         * Step 1. compute number of nodes in the graph
-         */
-
-	/* number of nodes: a read and write for each data unit a redundancy
-	 * computation node for each parity node (nfaults * nparity) a read
-	 * and write for each parity unit a block and commit node (2) a
-	 * terminate node if atomic RMW an unlock node for each data unit,
-	 * redundancy unit */
+	 * Number of nodes: a read and write for each data unit, a redundancy
+	 * computation node for each parity node (nfaults * nparity), a read
+	 * and write for each parity unit, a block and commit node (2), a
+	 * terminate node if atomic RMW, an unlock node for each
+	 * data/redundancy unit.
+	 */
 	totalNumNodes = (2 * numDataNodes) + (nfaults * numParityNodes)
 	    + (nfaults * 2 * numParityNodes) + 3;
 	if (lu_flag) {
 		totalNumNodes += (numDataNodes + (nfaults * numParityNodes));
 	}
 	/*
-         * Step 2. create the nodes
-         */
+	 * Step 2. Create the nodes.
+	 */
 	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
 	    (RF_DagNode_t *), allocList);
 	i = 0;
@@ -576,34 +575,39 @@ rf_CommonCreateSmallWriteDAG(
 	RF_ASSERT(i == totalNumNodes);
 
 	/*
-         * Step 3. initialize the nodes
-         */
-	/* initialize block node (Nil) */
+	 * Step 3. Initialize the nodes.
+	 */
+	/* Initialize block node (Nil). */
 	nNodes = numDataNodes + (nfaults * numParityNodes);
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, nNodes, 0, 0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h,
+	    "Nil", allocList);
 
-	/* initialize commit node (Cmt) */
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, nNodes, (nfaults * numParityNodes), 0, 0, dag_h, "Cmt", allocList);
+	/* Initialize commit node (Cmt). */
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nNodes, (nfaults * numParityNodes),
+	    0, 0, dag_h, "Cmt", allocList);
 
-	/* initialize terminate node (Trm) */
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-	    NULL, 0, nNodes, 0, 0, dag_h, "Trm", allocList);
+	/* Initialize terminate node (Trm). */
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, nNodes, 0, 0, dag_h,
+	    "Trm", allocList);
 
-	/* initialize nodes which read old data (Rod) */
+	/* Initialize nodes which read old data (Rod). */
 	for (i = 0; i < numDataNodes; i++) {
-		rf_InitNode(&readDataNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-		    rf_GenericWakeupFunc, (nfaults * numParityNodes), 1, 4, 0, dag_h,
-		    "Rod", allocList);
+		rf_InitNode(&readDataNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+		    (nfaults * numParityNodes), 1, 4, 0, dag_h, "Rod",
+		    allocList);
 		RF_ASSERT(pda != NULL);
-		/* physical disk addr desc */
+		/* Physical disk addr desc. */
 		readDataNodes[i].params[0].p = pda;
-		/* buffer to hold old data */
+		/* Buffer to hold old data. */
 		readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
 		    dag_h, pda, allocList);
 		readDataNodes[i].params[2].v = parityStripeID;
-		readDataNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+		readDataNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 		    lu_flag, 0, which_ru);
 		pda = pda->next;
 		for (j = 0; j < readDataNodes[i].numSuccedents; j++) {
@@ -611,20 +615,21 @@ rf_CommonCreateSmallWriteDAG(
 		}
 	}
 
-	/* initialize nodes which read old parity (Rop) */
+	/* Initialize nodes which read old parity (Rop). */
 	pda = asmap->parityInfo;
 	i = 0;
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&readParityNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc,
-		    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, numParityNodes, 1, 4,
-		    0, dag_h, "Rop", allocList);
+		rf_InitNode(&readParityNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+		    numParityNodes, 1, 4, 0, dag_h, "Rop", allocList);
 		readParityNodes[i].params[0].p = pda;
-		/* buffer to hold old parity */
+		/* Buffer to hold old parity. */
 		readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
 		    dag_h, pda, allocList);
 		readParityNodes[i].params[2].v = parityStripeID;
-		readParityNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+		readParityNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 		    lu_flag, 0, which_ru);
 		pda = pda->next;
 		for (j = 0; j < readParityNodes[i].numSuccedents; j++) {
@@ -632,19 +637,22 @@ rf_CommonCreateSmallWriteDAG(
 		}
 	}
 
-	/* initialize nodes which read old Q (Roq) */
+	/* Initialize nodes which read old Q (Roq). */
 	if (nfaults == 2) {
 		pda = asmap->qInfo;
 		for (i = 0; i < numParityNodes; i++) {
 			RF_ASSERT(pda != NULL);
-			rf_InitNode(&readQNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-			    rf_GenericWakeupFunc, numParityNodes, 1, 4, 0, dag_h, "Roq", allocList);
+			rf_InitNode(&readQNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskReadFunc, rf_DiskReadUndoFunc,
+			    rf_GenericWakeupFunc, numParityNodes,
+			    1, 4, 0, dag_h, "Roq", allocList);
 			readQNodes[i].params[0].p = pda;
-			/* buffer to hold old Q */
-			readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda,
-			    allocList);
+			/* Buffer to hold old Q. */
+			readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
+			    dag_h, pda, allocList);
 			readQNodes[i].params[2].v = parityStripeID;
-			readQNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			readQNodes[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 			    lu_flag, 0, which_ru);
 			pda = pda->next;
 			for (j = 0; j < readQNodes[i].numSuccedents; j++) {
@@ -652,46 +660,51 @@ rf_CommonCreateSmallWriteDAG(
 			}
 		}
 	}
-	/* initialize nodes which write new data (Wnd) */
+	/* Initialize nodes which write new data (Wnd). */
 	pda = asmap->physInfo;
 	for (i = 0; i < numDataNodes; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&writeDataNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc,
-		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+		rf_InitNode(&writeDataNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
 		    "Wnd", allocList);
-		/* physical disk addr desc */
+		/* Physical disk addr desc. */
 		writeDataNodes[i].params[0].p = pda;
-		/* buffer holding new data to be written */
+		/* Buffer holding new data to be written. */
 		writeDataNodes[i].params[1].p = pda->bufPtr;
 		writeDataNodes[i].params[2].v = parityStripeID;
-		writeDataNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
-		    0, 0, which_ru);
+		writeDataNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		if (lu_flag) {
-			/* initialize node to unlock the disk queue */
-			rf_InitNode(&unlockDataNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc,
-			    rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
+			/* Initialize node to unlock the disk queue. */
+			rf_InitNode(&unlockDataNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
 			    "Und", allocList);
-			/* physical disk addr desc */
+			/* Physical disk addr desc. */
 			unlockDataNodes[i].params[0].p = pda;
-			unlockDataNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			unlockDataNodes[i].params[1].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 			    0, lu_flag, which_ru);
 		}
 		pda = pda->next;
 	}
 
 	/*
-         * Initialize nodes which compute new parity and Q.
-         */
+	 * Initialize nodes which compute new parity and Q.
+	 */
 	/*
-         * We use the simple XOR func in the double-XOR case, and when
-         * we're accessing only a portion of one stripe unit. The distinction
-         * between the two is that the regular XOR func assumes that the targbuf
-         * is a full SU in size, and examines the pda associated with the buffer
-         * to decide where within the buffer to XOR the data, whereas
-         * the simple XOR func just XORs the data into the start of the buffer.
-         */
-	if ((numParityNodes == 2) || ((numDataNodes == 1)
-		&& (asmap->totalSectorsAccessed < raidPtr->Layout.sectorsPerStripeUnit))) {
+	 * We use the simple XOR func in the double-XOR case, and when
+	 * we're accessing only a portion of one stripe unit.
+	 * The distinction between the two is that the regular XOR func
+	 * assumes that the targbuf is a full SU in size, and examines
+	 * the pda associated with the buffer to decide where within
+	 * the buffer to XOR the data, whereas the simple XOR func just
+	 * XORs the data into the start of the buffer.
+	 */
+	if ((numParityNodes == 2) || ((numDataNodes == 1) &&
+	    (asmap->totalSectorsAccessed <
+	     raidPtr->Layout.sectorsPerStripeUnit))) {
 		func = pfuncs->simple;
 		undoFunc = rf_NullNodeUndoFunc;
 		name = pfuncs->SimpleName;
@@ -715,15 +728,16 @@ rf_CommonCreateSmallWriteDAG(
 		}
 	}
 	/*
-         * Initialize the xor nodes: params are {pda,buf}
-         * from {Rod,Wnd,Rop} nodes, and raidPtr
-         */
+	 * Initialize the xor nodes: params are {pda,buf}.
+	 * From {Rod,Wnd,Rop} nodes, and raidPtr.
+	 */
 	if (numParityNodes == 2) {
-		/* double-xor case */
+		/* Double-xor case. */
 		for (i = 0; i < numParityNodes; i++) {
-			/* note: no wakeup func for xor */
-			rf_InitNode(&xorNodes[i], rf_wait, RF_FALSE, func, undoFunc, NULL,
-			    1, (numDataNodes + numParityNodes), 7, 1, dag_h, name, allocList);
+			/* Note: no wakeup func for xor. */
+			rf_InitNode(&xorNodes[i], rf_wait, RF_FALSE, func,
+			    undoFunc, NULL, 1, (numDataNodes + numParityNodes),
+			    7, 1, dag_h, name, allocList);
 			xorNodes[i].flags |= RF_DAGNODE_FLAG_YIELD;
 			xorNodes[i].params[0] = readDataNodes[i].params[0];
 			xorNodes[i].params[1] = readDataNodes[i].params[1];
@@ -732,138 +746,163 @@ rf_CommonCreateSmallWriteDAG(
 			xorNodes[i].params[4] = writeDataNodes[i].params[0];
 			xorNodes[i].params[5] = writeDataNodes[i].params[1];
 			xorNodes[i].params[6].p = raidPtr;
-			/* use old parity buf as target buf */
+			/* Use old parity buf as target buf. */
 			xorNodes[i].results[0] = readParityNodes[i].params[1].p;
 			if (nfaults == 2) {
-				/* note: no wakeup func for qor */
-				rf_InitNode(&qNodes[i], rf_wait, RF_FALSE, qfunc, undoFunc, NULL, 1,
-				    (numDataNodes + numParityNodes), 7, 1, dag_h, qname, allocList);
-				qNodes[i].params[0] = readDataNodes[i].params[0];
-				qNodes[i].params[1] = readDataNodes[i].params[1];
+				/* Note: no wakeup func for qor. */
+				rf_InitNode(&qNodes[i], rf_wait, RF_FALSE,
+				    qfunc, undoFunc, NULL, 1,
+				    (numDataNodes + numParityNodes), 7, 1,
+				    dag_h, qname, allocList);
+				qNodes[i].params[0] =
+				    readDataNodes[i].params[0];
+				qNodes[i].params[1] =
+				    readDataNodes[i].params[1];
 				qNodes[i].params[2] = readQNodes[i].params[0];
 				qNodes[i].params[3] = readQNodes[i].params[1];
-				qNodes[i].params[4] = writeDataNodes[i].params[0];
-				qNodes[i].params[5] = writeDataNodes[i].params[1];
+				qNodes[i].params[4] =
+				    writeDataNodes[i].params[0];
+				qNodes[i].params[5] =
+				    writeDataNodes[i].params[1];
 				qNodes[i].params[6].p = raidPtr;
-				/* use old Q buf as target buf */
-				qNodes[i].results[0] = readQNodes[i].params[1].p;
+				/* Use old Q buf as target buf. */
+				qNodes[i].results[0] =
+				    readQNodes[i].params[1].p;
 			}
 		}
 	} else {
-		/* there is only one xor node in this case */
-		rf_InitNode(&xorNodes[0], rf_wait, RF_FALSE, func, undoFunc, NULL, 1,
-		    (numDataNodes + numParityNodes),
-		    (2 * (numDataNodes + numDataNodes + 1) + 1), 1, dag_h, name, allocList);
+		/* There is only one xor node in this case. */
+		rf_InitNode(&xorNodes[0], rf_wait, RF_FALSE, func, undoFunc,
+		    NULL, 1, (numDataNodes + numParityNodes),
+		    (2 * (numDataNodes + numDataNodes + 1) + 1), 1,
+		    dag_h, name, allocList);
 		xorNodes[0].flags |= RF_DAGNODE_FLAG_YIELD;
 		for (i = 0; i < numDataNodes + 1; i++) {
-			/* set up params related to Rod and Rop nodes */
-			xorNodes[0].params[2 * i + 0] = readDataNodes[i].params[0];	/* pda */
-			xorNodes[0].params[2 * i + 1] = readDataNodes[i].params[1];	/* buffer ptr */
+			/* Set up params related to Rod and Rop nodes. */
+			xorNodes[0].params[2 * i + 0] =
+			    readDataNodes[i].params[0];	/* pda */
+			xorNodes[0].params[2 * i + 1] =
+			    readDataNodes[i].params[1];	/* buffer ptr */
 		}
 		for (i = 0; i < numDataNodes; i++) {
-			/* set up params related to Wnd and Wnp nodes */
-			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 0] =	/* pda */
-			    writeDataNodes[i].params[0];
-			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 1] =	/* buffer ptr */
-			    writeDataNodes[i].params[1];
+			/* Set up params related to Wnd and Wnp nodes. */
+			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 0] =
+			    writeDataNodes[i].params[0];	/* pda */
+			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 1] =
+			    writeDataNodes[i].params[1];	/* buffer ptr */
 		}
-		/* xor node needs to get at RAID information */
-		xorNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;
+		/* Xor node needs to get at RAID information. */
+		xorNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p =
+		    raidPtr;
 		xorNodes[0].results[0] = readParityNodes[0].params[1].p;
 		if (nfaults == 2) {
-			rf_InitNode(&qNodes[0], rf_wait, RF_FALSE, qfunc, undoFunc, NULL, 1,
-			    (numDataNodes + numParityNodes),
-			    (2 * (numDataNodes + numDataNodes + 1) + 1), 1, dag_h,
-			    qname, allocList);
+			rf_InitNode(&qNodes[0], rf_wait, RF_FALSE, qfunc,
+			    undoFunc, NULL, 1, (numDataNodes + numParityNodes),
+			    (2 * (numDataNodes + numDataNodes + 1) + 1), 1,
+			    dag_h, qname, allocList);
 			for (i = 0; i < numDataNodes; i++) {
-				/* set up params related to Rod */
-				qNodes[0].params[2 * i + 0] = readDataNodes[i].params[0];	/* pda */
-				qNodes[0].params[2 * i + 1] = readDataNodes[i].params[1];	/* buffer ptr */
+				/* Set up params related to Rod. */
+				qNodes[0].params[2 * i + 0] =
+				    readDataNodes[i].params[0];	/* pda */
+				qNodes[0].params[2 * i + 1] =
+				    readDataNodes[i].params[1];	/* buffer ptr */
 			}
-			/* and read old q */
-			qNodes[0].params[2 * numDataNodes + 0] =	/* pda */
-			    readQNodes[0].params[0];
-			qNodes[0].params[2 * numDataNodes + 1] =	/* buffer ptr */
-			    readQNodes[0].params[1];
+			/* And read old q. */
+			qNodes[0].params[2 * numDataNodes + 0] =
+			    readQNodes[0].params[0];	/* pda */
+			qNodes[0].params[2 * numDataNodes + 1] =
+			    readQNodes[0].params[1];	/* buffer ptr */
 			for (i = 0; i < numDataNodes; i++) {
-				/* set up params related to Wnd nodes */
-				qNodes[0].params[2 * (numDataNodes + 1 + i) + 0] =	/* pda */
+				/* Set up params related to Wnd nodes. */
+				qNodes[0].params
+				    [2 * (numDataNodes + 1 + i) + 0] =
+				    /* pda */
 				    writeDataNodes[i].params[0];
-				qNodes[0].params[2 * (numDataNodes + 1 + i) + 1] =	/* buffer ptr */
+				qNodes[0].params
+				    [2 * (numDataNodes + 1 + i) + 1] =
+				    /* buffer ptr */
 				    writeDataNodes[i].params[1];
 			}
-			/* xor node needs to get at RAID information */
-			qNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;
+			/* Xor node needs to get at RAID information. */
+			qNodes[0].params
+			    [2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;
 			qNodes[0].results[0] = readQNodes[0].params[1].p;
 		}
 	}
 
-	/* initialize nodes which write new parity (Wnp) */
+	/* Initialize nodes which write new parity (Wnp). */
 	pda = asmap->parityInfo;
 	for (i = 0; i < numParityNodes; i++) {
-		rf_InitNode(&writeParityNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc,
-		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+		rf_InitNode(&writeParityNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
 		    "Wnp", allocList);
 		RF_ASSERT(pda != NULL);
-		writeParityNodes[i].params[0].p = pda;	/* param 1 (bufPtr)
-							 * filled in by xor node */
-		writeParityNodes[i].params[1].p = xorNodes[i].results[0];	/* buffer pointer for
-										 * parity write
-										 * operation */
+		/* Param 1 (bufPtr) filled in by xor node. */
+		writeParityNodes[i].params[0].p = pda;
+		/* Buffer pointer for parity write operation. */
+		writeParityNodes[i].params[1].p = xorNodes[i].results[0];
 		writeParityNodes[i].params[2].v = parityStripeID;
-		writeParityNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
-		    0, 0, which_ru);
+		writeParityNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		if (lu_flag) {
-			/* initialize node to unlock the disk queue */
-			rf_InitNode(&unlockParityNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc,
-			    rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
+			/* Initialize node to unlock the disk queue. */
+			rf_InitNode(&unlockParityNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
 			    "Unp", allocList);
-			unlockParityNodes[i].params[0].p = pda;	/* physical disk addr
-								 * desc */
-			unlockParityNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			/* Physical disk addr desc. */
+			unlockParityNodes[i].params[0].p = pda;
+			unlockParityNodes[i].params[1].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 			    0, lu_flag, which_ru);
 		}
 		pda = pda->next;
 	}
 
-	/* initialize nodes which write new Q (Wnq) */
+	/* Initialize nodes which write new Q (Wnq). */
 	if (nfaults == 2) {
 		pda = asmap->qInfo;
 		for (i = 0; i < numParityNodes; i++) {
-			rf_InitNode(&writeQNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc,
-			    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			rf_InitNode(&writeQNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
 			    "Wnq", allocList);
 			RF_ASSERT(pda != NULL);
-			writeQNodes[i].params[0].p = pda;	/* param 1 (bufPtr)
-								 * filled in by xor node */
-			writeQNodes[i].params[1].p = qNodes[i].results[0];	/* buffer pointer for
-										 * parity write
-										 * operation */
+			/* Param 1 (bufPtr) filled in by xor node. */
+			writeQNodes[i].params[0].p = pda;
+			writeQNodes[i].params[1].p = qNodes[i].results[0];
+			/* Buffer pointer for parity write operation. */
 			writeQNodes[i].params[2].v = parityStripeID;
-			writeQNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			writeQNodes[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 			    0, 0, which_ru);
 			if (lu_flag) {
-				/* initialize node to unlock the disk queue */
-				rf_InitNode(&unlockQNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc,
-				    rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
-				    "Unq", allocList);
-				unlockQNodes[i].params[0].p = pda;	/* physical disk addr
-									 * desc */
-				unlockQNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+				/* Initialize node to unlock the disk queue. */
+				rf_InitNode(&unlockQNodes[i], rf_wait,
+				    RF_FALSE, rf_DiskUnlockFunc,
+				    rf_DiskUnlockUndoFunc,
+				    rf_GenericWakeupFunc, 1, 1, 2, 0,
+				    dag_h, "Unq", allocList);
+				/* Physical disk addr desc. */
+				unlockQNodes[i].params[0].p = pda;
+				unlockQNodes[i].params[1].v =
+				    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 				    0, lu_flag, which_ru);
 			}
 			pda = pda->next;
 		}
 	}
 	/*
-         * Step 4. connect the nodes.
-         */
+	 * Step 4. Connect the nodes.
+	 */
 
-	/* connect header to block node */
+	/* Connect header to block node. */
 	dag_h->succedents[0] = blockNode;
 
-	/* connect block node to read old data nodes */
-	RF_ASSERT(blockNode->numSuccedents == (numDataNodes + (numParityNodes * nfaults)));
+	/* Connect block node to read old data nodes. */
+	RF_ASSERT(blockNode->numSuccedents ==
+	    (numDataNodes + (numParityNodes * nfaults)));
 	for (i = 0; i < numDataNodes; i++) {
 		blockNode->succedents[i] = &readDataNodes[i];
 		RF_ASSERT(readDataNodes[i].numAntecedents == 1);
@@ -871,7 +910,7 @@ rf_CommonCreateSmallWriteDAG(
 		readDataNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect block node to read old parity nodes */
+	/* Connect block node to read old parity nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		blockNode->succedents[numDataNodes + i] = &readParityNodes[i];
 		RF_ASSERT(readParityNodes[i].numAntecedents == 1);
@@ -879,59 +918,68 @@ rf_CommonCreateSmallWriteDAG(
 		readParityNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect block node to read old Q nodes */
+	/* Connect block node to read old Q nodes. */
 	if (nfaults == 2) {
 		for (i = 0; i < numParityNodes; i++) {
-			blockNode->succedents[numDataNodes + numParityNodes + i] = &readQNodes[i];
+			blockNode->succedents[numDataNodes + numParityNodes + i]
+			    = &readQNodes[i];
 			RF_ASSERT(readQNodes[i].numAntecedents == 1);
 			readQNodes[i].antecedents[0] = blockNode;
 			readQNodes[i].antType[0] = rf_control;
 		}
 	}
-	/* connect read old data nodes to xor nodes */
+	/* Connect read old data nodes to xor nodes. */
 	for (i = 0; i < numDataNodes; i++) {
-		RF_ASSERT(readDataNodes[i].numSuccedents == (nfaults * numParityNodes));
+		RF_ASSERT(readDataNodes[i].numSuccedents ==
+		    (nfaults * numParityNodes));
 		for (j = 0; j < numParityNodes; j++) {
-			RF_ASSERT(xorNodes[j].numAntecedents == numDataNodes + numParityNodes);
+			RF_ASSERT(xorNodes[j].numAntecedents ==
+			    numDataNodes + numParityNodes);
 			readDataNodes[i].succedents[j] = &xorNodes[j];
 			xorNodes[j].antecedents[i] = &readDataNodes[i];
 			xorNodes[j].antType[i] = rf_trueData;
 		}
 	}
 
-	/* connect read old data nodes to q nodes */
+	/* Connect read old data nodes to q nodes. */
 	if (nfaults == 2) {
 		for (i = 0; i < numDataNodes; i++) {
 			for (j = 0; j < numParityNodes; j++) {
-				RF_ASSERT(qNodes[j].numAntecedents == numDataNodes + numParityNodes);
-				readDataNodes[i].succedents[numParityNodes + j] = &qNodes[j];
+				RF_ASSERT(qNodes[j].numAntecedents ==
+				    numDataNodes + numParityNodes);
+				readDataNodes[i].succedents[numParityNodes + j]
+				    = &qNodes[j];
 				qNodes[j].antecedents[i] = &readDataNodes[i];
 				qNodes[j].antType[i] = rf_trueData;
 			}
 		}
 	}
-	/* connect read old parity nodes to xor nodes */
+	/* Connect read old parity nodes to xor nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(readParityNodes[i].numSuccedents == numParityNodes);
 		for (j = 0; j < numParityNodes; j++) {
 			readParityNodes[i].succedents[j] = &xorNodes[j];
-			xorNodes[j].antecedents[numDataNodes + i] = &readParityNodes[i];
+			xorNodes[j].antecedents[numDataNodes + i] =
+			    &readParityNodes[i];
 			xorNodes[j].antType[numDataNodes + i] = rf_trueData;
 		}
 	}
 
-	/* connect read old q nodes to q nodes */
+	/* Connect read old q nodes to q nodes. */
 	if (nfaults == 2) {
 		for (i = 0; i < numParityNodes; i++) {
-			RF_ASSERT(readParityNodes[i].numSuccedents == numParityNodes);
+			RF_ASSERT(readParityNodes[i].numSuccedents ==
+			    numParityNodes);
 			for (j = 0; j < numParityNodes; j++) {
 				readQNodes[i].succedents[j] = &qNodes[j];
-				qNodes[j].antecedents[numDataNodes + i] = &readQNodes[i];
-				qNodes[j].antType[numDataNodes + i] = rf_trueData;
+				qNodes[j].antecedents[numDataNodes + i] =
+				    &readQNodes[i];
+				qNodes[j].antType[numDataNodes + i] =
+				    rf_trueData;
 			}
 		}
 	}
-	/* connect xor nodes to commit node */
+	/* Connect xor nodes to commit node. */
 	RF_ASSERT(commitNode->numAntecedents == (nfaults * numParityNodes));
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(xorNodes[i].numSuccedents == 1);
@@ -940,17 +988,19 @@ rf_CommonCreateSmallWriteDAG(
 		commitNode->antType[i] = rf_control;
 	}
 
-	/* connect q nodes to commit node */
+	/* Connect q nodes to commit node. */
 	if (nfaults == 2) {
 		for (i = 0; i < numParityNodes; i++) {
 			RF_ASSERT(qNodes[i].numSuccedents == 1);
 			qNodes[i].succedents[0] = commitNode;
-			commitNode->antecedents[i + numParityNodes] = &qNodes[i];
+			commitNode->antecedents[i + numParityNodes] =
+			    &qNodes[i];
 			commitNode->antType[i + numParityNodes] = rf_control;
 		}
 	}
-	/* connect commit node to write nodes */
-	RF_ASSERT(commitNode->numSuccedents == (numDataNodes + (nfaults * numParityNodes)));
+	/* Connect commit node to write nodes. */
+	RF_ASSERT(commitNode->numSuccedents ==
+	    (numDataNodes + (nfaults * numParityNodes)));
 	for (i = 0; i < numDataNodes; i++) {
 		RF_ASSERT(writeDataNodes[i].numAntecedents == 1);
 		commitNode->succedents[i] = &writeDataNodes[i];
@@ -966,31 +1016,35 @@ rf_CommonCreateSmallWriteDAG(
 	if (nfaults == 2) {
 		for (i = 0; i < numParityNodes; i++) {
 			RF_ASSERT(writeQNodes[i].numAntecedents == 1);
-			commitNode->succedents[i + numDataNodes + numParityNodes] = &writeQNodes[i];
+			commitNode->succedents
+			    [i + numDataNodes + numParityNodes] =
+			    &writeQNodes[i];
 			writeQNodes[i].antecedents[0] = commitNode;
 			writeQNodes[i].antType[0] = rf_trueData;
 		}
 	}
-	RF_ASSERT(termNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
+	RF_ASSERT(termNode->numAntecedents ==
+	    (numDataNodes + (nfaults * numParityNodes)));
 	RF_ASSERT(termNode->numSuccedents == 0);
 	for (i = 0; i < numDataNodes; i++) {
 		if (lu_flag) {
-			/* connect write new data nodes to unlock nodes */
+			/* Connect write new data nodes to unlock nodes. */
 			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
 			RF_ASSERT(unlockDataNodes[i].numAntecedents == 1);
 			writeDataNodes[i].succedents[0] = &unlockDataNodes[i];
 			unlockDataNodes[i].antecedents[0] = &writeDataNodes[i];
 			unlockDataNodes[i].antType[0] = rf_control;
 
-			/* connect unlock nodes to term node */
+			/* Connect unlock nodes to term node. */
 			RF_ASSERT(unlockDataNodes[i].numSuccedents == 1);
 			unlockDataNodes[i].succedents[0] = termNode;
 			termNode->antecedents[i] = &unlockDataNodes[i];
 			termNode->antType[i] = rf_control;
 		} else {
-			/* connect write new data nodes to term node */
+			/* Connect write new data nodes to term node. */
 			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
-			RF_ASSERT(termNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
+			RF_ASSERT(termNode->numAntecedents ==
+			    (numDataNodes + (nfaults * numParityNodes)));
 			writeDataNodes[i].succedents[0] = termNode;
 			termNode->antecedents[i] = &writeDataNodes[i];
 			termNode->antType[i] = rf_control;
@@ -999,22 +1053,26 @@ rf_CommonCreateSmallWriteDAG(
 
 	for (i = 0; i < numParityNodes; i++) {
 		if (lu_flag) {
-			/* connect write new parity nodes to unlock nodes */
+			/* Connect write new parity nodes to unlock nodes. */
 			RF_ASSERT(writeParityNodes[i].numSuccedents == 1);
 			RF_ASSERT(unlockParityNodes[i].numAntecedents == 1);
-			writeParityNodes[i].succedents[0] = &unlockParityNodes[i];
-			unlockParityNodes[i].antecedents[0] = &writeParityNodes[i];
+			writeParityNodes[i].succedents[0] =
+			    &unlockParityNodes[i];
+			unlockParityNodes[i].antecedents[0] =
+			    &writeParityNodes[i];
 			unlockParityNodes[i].antType[0] = rf_control;
 
-			/* connect unlock nodes to term node */
+			/* Connect unlock nodes to term node. */
 			RF_ASSERT(unlockParityNodes[i].numSuccedents == 1);
 			unlockParityNodes[i].succedents[0] = termNode;
-			termNode->antecedents[numDataNodes + i] = &unlockParityNodes[i];
+			termNode->antecedents[numDataNodes + i] =
+			    &unlockParityNodes[i];
 			termNode->antType[numDataNodes + i] = rf_control;
 		} else {
 			RF_ASSERT(writeParityNodes[i].numSuccedents == 1);
 			writeParityNodes[i].succedents[0] = termNode;
-			termNode->antecedents[numDataNodes + i] = &writeParityNodes[i];
+			termNode->antecedents[numDataNodes + i] =
+			    &writeParityNodes[i];
 			termNode->antType[numDataNodes + i] = rf_control;
 		}
 	}
@@ -1022,57 +1080,62 @@ rf_CommonCreateSmallWriteDAG(
 	if (nfaults == 2) {
 		for (i = 0; i < numParityNodes; i++) {
 			if (lu_flag) {
-				/* connect write new Q nodes to unlock nodes */
+				/* Connect write new Q nodes to unlock nodes. */
 				RF_ASSERT(writeQNodes[i].numSuccedents == 1);
 				RF_ASSERT(unlockQNodes[i].numAntecedents == 1);
 				writeQNodes[i].succedents[0] = &unlockQNodes[i];
-				unlockQNodes[i].antecedents[0] = &writeQNodes[i];
+				unlockQNodes[i].antecedents[0] =
+				    &writeQNodes[i];
 				unlockQNodes[i].antType[0] = rf_control;
 
-				/* connect unlock nodes to unblock node */
+				/* Connect unlock nodes to unblock node. */
 				RF_ASSERT(unlockQNodes[i].numSuccedents == 1);
 				unlockQNodes[i].succedents[0] = termNode;
-				termNode->antecedents[numDataNodes + numParityNodes + i] = &unlockQNodes[i];
-				termNode->antType[numDataNodes + numParityNodes + i] = rf_control;
+				termNode->antecedents
+				    [numDataNodes + numParityNodes + i] =
+				    &unlockQNodes[i];
+				termNode->antType
+				    [numDataNodes + numParityNodes + i] =
+				    rf_control;
 			} else {
 				RF_ASSERT(writeQNodes[i].numSuccedents == 1);
 				writeQNodes[i].succedents[0] = termNode;
-				termNode->antecedents[numDataNodes + numParityNodes + i] = &writeQNodes[i];
-				termNode->antType[numDataNodes + numParityNodes + i] = rf_control;
+				termNode->antecedents
+				    [numDataNodes + numParityNodes + i] =
+				    &writeQNodes[i];
+				termNode->antType
+				    [numDataNodes + numParityNodes + i] =
+				    rf_control;
 			}
 		}
 	}
 }
 
 
-/******************************************************************************
- * create a write graph (fault-free or degraded) for RAID level 1
+/*****************************************************************************
+ * Create a write graph (fault-free or degraded) for RAID level 1.
  *
  * Hdr -> Commit -> Wpd -> Nil -> Trm
- *               -> Wsd ->
+ *		 -> Wsd ->
  *
- * The "Wpd" node writes data to the primary copy in the mirror pair
- * The "Wsd" node writes data to the secondary copy in the mirror pair
+ * The "Wpd" node writes data to the primary copy in the mirror pair.
+ * The "Wsd" node writes data to the secondary copy in the mirror pair.
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (holds write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
+ * Parameters:	raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (holds write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
  *****************************************************************************/
 
-void 
-rf_CreateRaidOneWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+void
+rf_CreateRaidOneWriteDAG(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList)
 {
 	RF_DagNode_t *unblockNode, *termNode, *commitNode;
 	RF_DagNode_t *nodes, *wndNode, *wmirNode;
-	int     nWndNodes, nWmirNodes, i;
+	int nWndNodes, nWmirNodes, i;
 	RF_ReconUnitNum_t which_ru;
 	RF_PhysDiskAddr_t *pda, *pdaP;
 	RF_StripeNum_t parityStripeID;
@@ -1084,18 +1147,20 @@ rf_CreateRaidOneWriteDAG(
 	}
 	dag_h->creator = "RaidOneWriteDAG";
 
-	/* 2 implies access not SU aligned */
+	/* 2 implies access not SU aligned. */
 	nWmirNodes = (asmap->parityInfo->next) ? 2 : 1;
 	nWndNodes = (asmap->physInfo->next) ? 2 : 1;
 
-	/* alloc the Wnd nodes and the Wmir node */
+	/* Alloc the Wnd nodes and the Wmir node. */
 	if (asmap->numDataFailed == 1)
 		nWndNodes--;
 	if (asmap->numParityFailed == 1)
 		nWmirNodes--;
 
-	/* total number of nodes = nWndNodes + nWmirNodes + (commit + unblock
-	 * + terminator) */
+	/*
+	 * Total number of nodes = nWndNodes + nWmirNodes
+	 * + (commit + unblock + terminator)
+	 */
 	RF_CallocAndAdd(nodes, nWndNodes + nWmirNodes + 3, sizeof(RF_DagNode_t),
 	    (RF_DagNode_t *), allocList);
 	i = 0;
@@ -1111,58 +1176,68 @@ rf_CreateRaidOneWriteDAG(
 	i += 1;
 	RF_ASSERT(i == (nWndNodes + nWmirNodes + 3));
 
-	/* this dag can commit immediately */
+	/* This dag can commit immediately. */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	/* initialize the commit, unblock, and term nodes */
-	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, (nWndNodes + nWmirNodes), 0, 0, 0, dag_h, "Cmt", allocList);
-	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc,
-	    NULL, 1, (nWndNodes + nWmirNodes), 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc,
-	    NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
-
-	/* initialize the wnd nodes */
+	/* Initialize the commit, unblock, and term nodes. */
+	rf_InitNode(commitNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, (nWndNodes + nWmirNodes), 0, 0, 0,
+	    dag_h, "Cmt", allocList);
+	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, (nWndNodes + nWmirNodes), 0, 0,
+	    dag_h, "Nil", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+
+	/* Initialize the wnd nodes. */
 	if (nWndNodes > 0) {
 		pda = asmap->physInfo;
 		for (i = 0; i < nWndNodes; i++) {
-			rf_InitNode(&wndNode[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wpd", allocList);
+			rf_InitNode(&wndNode[i], rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Wpd", allocList);
 			RF_ASSERT(pda != NULL);
 			wndNode[i].params[0].p = pda;
 			wndNode[i].params[1].p = pda->bufPtr;
 			wndNode[i].params[2].v = parityStripeID;
-			wndNode[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			wndNode[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, 0, which_ru);
 			pda = pda->next;
 		}
 		RF_ASSERT(pda == NULL);
 	}
-	/* initialize the mirror nodes */
+	/* Initialize the mirror nodes. */
 	if (nWmirNodes > 0) {
 		pda = asmap->physInfo;
 		pdaP = asmap->parityInfo;
 		for (i = 0; i < nWmirNodes; i++) {
-			rf_InitNode(&wmirNode[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wsd", allocList);
+			rf_InitNode(&wmirNode[i], rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Wsd", allocList);
 			RF_ASSERT(pda != NULL);
 			wmirNode[i].params[0].p = pdaP;
 			wmirNode[i].params[1].p = pda->bufPtr;
 			wmirNode[i].params[2].v = parityStripeID;
-			wmirNode[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			wmirNode[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, 0, which_ru);
 			pda = pda->next;
 			pdaP = pdaP->next;
 		}
 		RF_ASSERT(pda == NULL);
 		RF_ASSERT(pdaP == NULL);
 	}
-	/* link the header node to the commit node */
+	/* Link the header node to the commit node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(commitNode->numAntecedents == 0);
 	dag_h->succedents[0] = commitNode;
 
-	/* link the commit node to the write nodes */
+	/* Link the commit node to the write nodes. */
 	RF_ASSERT(commitNode->numSuccedents == (nWndNodes + nWmirNodes));
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNode[i].numAntecedents == 1);
@@ -1177,7 +1252,7 @@ rf_CreateRaidOneWriteDAG(
 		wmirNode[i].antType[0] = rf_control;
 	}
 
-	/* link the write nodes to the unblock node */
+	/* Link the write nodes to the unblock node. */
 	RF_ASSERT(unblockNode->numAntecedents == (nWndNodes + nWmirNodes));
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNode[i].numSuccedents == 1);
@@ -1192,7 +1267,7 @@ rf_CreateRaidOneWriteDAG(
 		unblockNode->antType[i + nWndNodes] = rf_control;
 	}
 
-	/* link the unblock node to the term node */
+	/* Link the unblock node to the term node. */
 	RF_ASSERT(unblockNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -1203,39 +1278,35 @@ rf_CreateRaidOneWriteDAG(
 
 
 
-/* DAGs which have no commit points.
+/*
+ * DAGs that have no commit points.
  *
- * The following DAGs are used in forward and backward error recovery experiments.
- * They are identical to the DAGs above this comment with the exception that the
+ * The following DAGs are used in forward and backward error recovery
+ * experiments.
+ * They are identical to the DAGs above this comment with the exception that
  * the commit points have been removed.
  */
 
 
-
-void 
-rf_CommonCreateLargeWriteDAGFwd(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    int nfaults,
-    int (*redFunc) (RF_DagNode_t *),
+void
+rf_CommonCreateLargeWriteDAGFwd(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, int nfaults, int (*redFunc) (RF_DagNode_t *),
     int allowBufferRecycle)
 {
 	RF_DagNode_t *nodes, *wndNodes, *rodNodes, *xorNode, *wnpNode;
 	RF_DagNode_t *wnqNode, *blockNode, *syncNode, *termNode;
-	int     nWndNodes, nRodNodes, i, nodeNum, asmNum;
+	int nWndNodes, nRodNodes, i, nodeNum, asmNum;
 	RF_AccessStripeMapHeader_t *new_asm_h[2];
 	RF_StripeNum_t parityStripeID;
-	char   *sosBuffer, *eosBuffer;
+	char *sosBuffer, *eosBuffer;
 	RF_ReconUnitNum_t which_ru;
 	RF_RaidLayout_t *layoutPtr;
 	RF_PhysDiskAddr_t *pda;
 
 	layoutPtr = &(raidPtr->Layout);
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout), asmap->raidAddress, &which_ru);
+	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
+	    asmap->raidAddress, &which_ru);
 
 	if (rf_dagDebug)
 		printf("[Creating large-write DAG]\n");
@@ -1245,9 +1316,10 @@ rf_CommonCreateLargeWriteDAGFwd(
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	/* alloc the nodes: Wnd, xor, commit, block, term, and  Wnp */
+	/* Alloc the nodes: Wnd, xor, commit, block, term, and  Wnp. */
 	nWndNodes = asmap->numStripeUnitsAccessed;
-	RF_CallocAndAdd(nodes, nWndNodes + 4 + nfaults, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	RF_CallocAndAdd(nodes, nWndNodes + 4 + nfaults, sizeof(RF_DagNode_t),
+	    (RF_DagNode_t *), allocList);
 	i = 0;
 	wndNodes = &nodes[i];
 	i += nWndNodes;
@@ -1267,34 +1339,51 @@ rf_CommonCreateLargeWriteDAGFwd(
 	} else {
 		wnqNode = NULL;
 	}
-	rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h, new_asm_h, &nRodNodes, &sosBuffer, &eosBuffer, allocList);
+	rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h,
+	    new_asm_h, &nRodNodes, &sosBuffer, &eosBuffer, allocList);
 	if (nRodNodes > 0) {
-		RF_CallocAndAdd(rodNodes, nRodNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+		RF_CallocAndAdd(rodNodes, nRodNodes, sizeof(RF_DagNode_t),
+		    (RF_DagNode_t *), allocList);
 	} else {
 		rodNodes = NULL;
 	}
 
-	/* begin node initialization */
+	/* Begin node initialization. */
 	if (nRodNodes > 0) {
-		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nRodNodes, 0, 0, 0, dag_h, "Nil", allocList);
-		rf_InitNode(syncNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nWndNodes + 1, nRodNodes, 0, 0, dag_h, "Nil", allocList);
+		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, nRodNodes, 0, 0, 0, dag_h,
+		    "Nil", allocList);
+		rf_InitNode(syncNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, nWndNodes + 1, nRodNodes, 0, 0,
+		    dag_h, "Nil", allocList);
 	} else {
-		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil", allocList);
-		rf_InitNode(syncNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nWndNodes + 1, 1, 0, 0, dag_h, "Nil", allocList);
+		rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, 1, 0, 0, 0, dag_h, "Nil",
+		    allocList);
+		rf_InitNode(syncNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+		    rf_NullNodeUndoFunc, NULL, nWndNodes + 1, 1, 0, 0, dag_h,
+		    "Nil", allocList);
 	}
 
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, nWndNodes + nfaults, 0, 0, dag_h, "Trm", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, nWndNodes + nfaults, 0, 0,
+	    dag_h, "Trm", allocList);
 
-	/* initialize the Rod nodes */
+	/* Initialize the Rod nodes. */
 	for (nodeNum = asmNum = 0; asmNum < 2; asmNum++) {
 		if (new_asm_h[asmNum]) {
 			pda = new_asm_h[asmNum]->stripeMap->physInfo;
 			while (pda) {
-				rf_InitNode(&rodNodes[nodeNum], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rod", allocList);
+				rf_InitNode(&rodNodes[nodeNum], rf_wait,
+				    RF_FALSE, rf_DiskReadFunc,
+				    rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+				    1, 1, 4, 0, dag_h, "Rod", allocList);
 				rodNodes[nodeNum].params[0].p = pda;
 				rodNodes[nodeNum].params[1].p = pda->bufPtr;
 				rodNodes[nodeNum].params[2].v = parityStripeID;
-				rodNodes[nodeNum].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+				rodNodes[nodeNum].params[3].v =
+				    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+				    0, 0, which_ru);
 				nodeNum++;
 				pda = pda->next;
 			}
@@ -1302,79 +1391,104 @@ rf_CommonCreateLargeWriteDAGFwd(
 	}
 	RF_ASSERT(nodeNum == nRodNodes);
 
-	/* initialize the wnd nodes */
+	/* Initialize the wnd nodes. */
 	pda = asmap->physInfo;
 	for (i = 0; i < nWndNodes; i++) {
-		rf_InitNode(&wndNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnd", allocList);
+		rf_InitNode(&wndNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc,
+		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnd", allocList);
 		RF_ASSERT(pda != NULL);
 		wndNodes[i].params[0].p = pda;
 		wndNodes[i].params[1].p = pda->bufPtr;
 		wndNodes[i].params[2].v = parityStripeID;
-		wndNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wndNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		pda = pda->next;
 	}
 
-	/* initialize the redundancy node */
-	rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc, rf_NullNodeUndoFunc, NULL, 1, nfaults, 2 * (nWndNodes + nRodNodes) + 1, nfaults, dag_h, "Xr ", allocList);
+	/* Initialize the redundancy node. */
+	rf_InitNode(xorNode, rf_wait, RF_FALSE, redFunc, rf_NullNodeUndoFunc,
+	    NULL, 1, nfaults, 2 * (nWndNodes + nRodNodes) + 1, nfaults, dag_h,
+	    "Xr ", allocList);
 	xorNode->flags |= RF_DAGNODE_FLAG_YIELD;
 	for (i = 0; i < nWndNodes; i++) {
-		xorNode->params[2 * i + 0] = wndNodes[i].params[0];	/* pda */
-		xorNode->params[2 * i + 1] = wndNodes[i].params[1];	/* buf ptr */
+		xorNode->params[2 * i + 0] =
+		    wndNodes[i].params[0];	/* pda */
+		xorNode->params[2 * i + 1] =
+		    wndNodes[i].params[1];	/* buf ptr */
 	}
 	for (i = 0; i < nRodNodes; i++) {
-		xorNode->params[2 * (nWndNodes + i) + 0] = rodNodes[i].params[0];	/* pda */
-		xorNode->params[2 * (nWndNodes + i) + 1] = rodNodes[i].params[1];	/* buf ptr */
+		xorNode->params[2 * (nWndNodes + i) + 0] =
+		    rodNodes[i].params[0];	/* pda */
+		xorNode->params[2 * (nWndNodes + i) + 1] =
+		    rodNodes[i].params[1];	/* buf ptr */
 	}
-	xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;	/* xor node needs to get
-									 * at RAID information */
+	/* Xor node needs to get at RAID information. */
+	xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;
 
-	/* look for an Rod node that reads a complete SU.  If none, alloc a
+	/*
+	 * Look for an Rod node that reads a complete SU. If none, alloc a
 	 * buffer to receive the parity info. Note that we can't use a new
 	 * data buffer because it will not have gotten written when the xor
-	 * occurs. */
+	 * occurs.
+	 */
 	if (allowBufferRecycle) {
 		for (i = 0; i < nRodNodes; i++)
-			if (((RF_PhysDiskAddr_t *) rodNodes[i].params[0].p)->numSector == raidPtr->Layout.sectorsPerStripeUnit)
+			if (((RF_PhysDiskAddr_t *) rodNodes[i].params[0].p)
+			    ->numSector == raidPtr->Layout.sectorsPerStripeUnit)
 				break;
 	}
 	if ((!allowBufferRecycle) || (i == nRodNodes)) {
-		RF_CallocAndAdd(xorNode->results[0], 1, rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit), (void *), allocList);
+		RF_CallocAndAdd(xorNode->results[0], 1,
+		    rf_RaidAddressToByte(raidPtr,
+		    raidPtr->Layout.sectorsPerStripeUnit),
+		    (void *), allocList);
 	} else
 		xorNode->results[0] = rodNodes[i].params[1].p;
 
-	/* initialize the Wnp node */
-	rf_InitNode(wnpNode, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnp", allocList);
+	/* Initialize the Wnp node. */
+	rf_InitNode(wnpNode, rf_wait, RF_FALSE, rf_DiskWriteFunc,
+	    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+	    dag_h, "Wnp", allocList);
 	wnpNode->params[0].p = asmap->parityInfo;
 	wnpNode->params[1].p = xorNode->results[0];
 	wnpNode->params[2].v = parityStripeID;
-	wnpNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
-	RF_ASSERT(asmap->parityInfo->next == NULL);	/* parityInfo must
-							 * describe entire
-							 * parity unit */
+	wnpNode->params[3].v =
+	    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+	/* parityInfo must describe entire parity unit. */
+	RF_ASSERT(asmap->parityInfo->next == NULL);
 
 	if (nfaults == 2) {
-		/* we never try to recycle a buffer for the Q calcuation in
-		 * addition to the parity. This would cause two buffers to get
-		 * smashed during the P and Q calculation, guaranteeing one
-		 * would be wrong. */
-		RF_CallocAndAdd(xorNode->results[1], 1, rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit), (void *), allocList);
-		rf_InitNode(wnqNode, rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnq", allocList);
+		/*
+		 * Never try to recycle a buffer for the Q calcuation in
+		 * addition to the parity. This would cause two buffers to
+		 * get smashed during the P and Q calculation, guaranteeing
+		 * one would be wrong.
+		 */
+		RF_CallocAndAdd(xorNode->results[1], 1,
+		    rf_RaidAddressToByte(raidPtr,
+		    raidPtr->Layout.sectorsPerStripeUnit),
+		    (void *), allocList);
+		rf_InitNode(wnqNode, rf_wait, RF_FALSE, rf_DiskWriteFunc,
+		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnq", allocList);
 		wnqNode->params[0].p = asmap->qInfo;
 		wnqNode->params[1].p = xorNode->results[1];
 		wnqNode->params[2].v = parityStripeID;
-		wnqNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
-		RF_ASSERT(asmap->parityInfo->next == NULL);	/* parityInfo must
-								 * describe entire
-								 * parity unit */
+		wnqNode->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		/* parityInfo must describe entire parity unit. */
+		RF_ASSERT(asmap->parityInfo->next == NULL);
 	}
-	/* connect nodes to form graph */
 
-	/* connect dag header to block node */
+	/* Connect nodes to form graph. */
+
+	/* Connect dag header to block node. */
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
 	if (nRodNodes > 0) {
-		/* connect the block node to the Rod nodes */
+		/* Connect the block node to the Rod nodes. */
 		RF_ASSERT(blockNode->numSuccedents == nRodNodes);
 		RF_ASSERT(syncNode->numAntecedents == nRodNodes);
 		for (i = 0; i < nRodNodes; i++) {
@@ -1383,14 +1497,14 @@ rf_CommonCreateLargeWriteDAGFwd(
 			rodNodes[i].antecedents[0] = blockNode;
 			rodNodes[i].antType[0] = rf_control;
 
-			/* connect the Rod nodes to the Nil node */
+			/* Connect the Rod nodes to the Nil node. */
 			RF_ASSERT(rodNodes[i].numSuccedents == 1);
 			rodNodes[i].succedents[0] = syncNode;
 			syncNode->antecedents[i] = &rodNodes[i];
 			syncNode->antType[i] = rf_trueData;
 		}
 	} else {
-		/* connect the block node to the Nil node */
+		/* Connect the block node to the Nil node. */
 		RF_ASSERT(blockNode->numSuccedents == 1);
 		RF_ASSERT(syncNode->numAntecedents == 1);
 		blockNode->succedents[0] = syncNode;
@@ -1398,7 +1512,7 @@ rf_CommonCreateLargeWriteDAGFwd(
 		syncNode->antType[0] = rf_control;
 	}
 
-	/* connect the sync node to the Wnd nodes */
+	/* Connect the sync node to the Wnd nodes. */
 	RF_ASSERT(syncNode->numSuccedents == (1 + nWndNodes));
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNodes->numAntecedents == 1);
@@ -1407,13 +1521,13 @@ rf_CommonCreateLargeWriteDAGFwd(
 		wndNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect the sync node to the Xor node */
+	/* Connect the sync node to the Xor node. */
 	RF_ASSERT(xorNode->numAntecedents == 1);
 	syncNode->succedents[nWndNodes] = xorNode;
 	xorNode->antecedents[0] = syncNode;
 	xorNode->antType[0] = rf_control;
 
-	/* connect the xor node to the write parity node */
+	/* Connect the xor node to the write parity node. */
 	RF_ASSERT(xorNode->numSuccedents == nfaults);
 	RF_ASSERT(wnpNode->numAntecedents == 1);
 	xorNode->succedents[0] = wnpNode;
@@ -1425,7 +1539,7 @@ rf_CommonCreateLargeWriteDAGFwd(
 		wnqNode->antecedents[0] = xorNode;
 		wnqNode->antType[0] = rf_trueData;
 	}
-	/* connect the write nodes to the term node */
+	/* Connect the write nodes to the term node. */
 	RF_ASSERT(termNode->numAntecedents == nWndNodes + nfaults);
 	RF_ASSERT(termNode->numSuccedents == 0);
 	for (i = 0; i < nWndNodes; i++) {
@@ -1447,9 +1561,9 @@ rf_CommonCreateLargeWriteDAGFwd(
 }
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a small-write operation (either raid 5 or pq),
+ * Create a DAG to perform a small-write operation (either raid 5 or pq),
  * which is as follows:
  *
  * Hdr -> Nil -> Rop - Xor - Wnp [Unp] -- Trm
@@ -1467,48 +1581,44 @@ rf_CommonCreateLargeWriteDAGFwd(
  * Wnp = write new parity
  * Wnd = write new data
  * Wnq = write new "q"
- * [ ] denotes optional segments in the graph
+ * [ ] denotes optional segments in the graph.
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (holds write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
- *              pfuncs    - list of parity generating functions
- *              qfuncs    - list of q generating functions
+ * Parameters:	raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (holds write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
+ *		pfuncs	  - list of parity generating functions
+ *		qfuncs	  - list of q generating functions
  *
- * A null qfuncs indicates single fault tolerant
+ * A null qfuncs indicates single fault tolerant.
  *****************************************************************************/
 
-void 
-rf_CommonCreateSmallWriteDAGFwd(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_RedFuncs_t * pfuncs,
-    RF_RedFuncs_t * qfuncs)
+void
+rf_CommonCreateSmallWriteDAGFwd(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList, RF_RedFuncs_t *pfuncs, RF_RedFuncs_t *qfuncs)
 {
 	RF_DagNode_t *readDataNodes, *readParityNodes, *readQNodes, *termNode;
 	RF_DagNode_t *unlockDataNodes, *unlockParityNodes, *unlockQNodes;
 	RF_DagNode_t *xorNodes, *qNodes, *blockNode, *nodes;
 	RF_DagNode_t *writeDataNodes, *writeParityNodes, *writeQNodes;
-	int     i, j, nNodes, totalNumNodes, lu_flag;
+	int i, j, nNodes, totalNumNodes, lu_flag;
 	RF_ReconUnitNum_t which_ru;
-	int     (*func) (RF_DagNode_t *), (*undoFunc) (RF_DagNode_t *);
-	int     (*qfunc) (RF_DagNode_t *);
-	int     numDataNodes, numParityNodes;
+	int (*func) (RF_DagNode_t *);
+	int (*undoFunc) (RF_DagNode_t *);
+	int (*qfunc) (RF_DagNode_t *);
+	int numDataNodes, numParityNodes;
 	RF_StripeNum_t parityStripeID;
 	RF_PhysDiskAddr_t *pda;
-	char   *name, *qname;
-	long    nfaults;
+	char *name, *qname;
+	long nfaults;
 
 	nfaults = qfuncs ? 2 : 1;
-	lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* lock/unlock flag */
+	lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* Lock/unlock flag. */
 
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout), asmap->raidAddress, &which_ru);
+	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
+	    asmap->raidAddress, &which_ru);
 	pda = asmap->physInfo;
 	numDataNodes = asmap->numStripeUnitsAccessed;
 	numParityNodes = (asmap->parityInfo->next) ? 2 : 1;
@@ -1525,23 +1635,31 @@ rf_CommonCreateSmallWriteDAGFwd(
 	qfunc = NULL;
 	qname = NULL;
 
-	/* DAG creation occurs in four steps: 1. count the number of nodes in
-	 * the DAG 2. create the nodes 3. initialize the nodes 4. connect the
-	 * nodes */
+	/*
+	 * DAG creation occurs in four steps:
+	 * 1. Count the number of nodes in the DAG.
+	 * 2. Create the nodes.
+	 * 3. Initialize the nodes.
+	 * 4. Connect the nodes.
+	 */
 
-	/* Step 1. compute number of nodes in the graph */
+	/* Step 1. Compute number of nodes in the graph. */
 
-	/* number of nodes: a read and write for each data unit a redundancy
-	 * computation node for each parity node (nfaults * nparity) a read
-	 * and write for each parity unit a block node a terminate node if
-	 * atomic RMW an unlock node for each data unit, redundancy unit */
-	totalNumNodes = (2 * numDataNodes) + (nfaults * numParityNodes) + (nfaults * 2 * numParityNodes) + 2;
+	/*
+	 * Number of nodes: a read and write for each data unit, a redundancy
+	 * computation node for each parity node (nfaults * nparity), a read
+	 * and write for each parity unit, a block node, a terminate node if
+	 * atomic RMW, an unlock node for each data/redundancy unit.
+	 */
+	totalNumNodes = (2 * numDataNodes) + (nfaults * numParityNodes)
+	    + (nfaults * 2 * numParityNodes) + 2;
 	if (lu_flag)
 		totalNumNodes += (numDataNodes + (nfaults * numParityNodes));
 
 
-	/* Step 2. create the nodes */
-	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	/* Step 2. Create the nodes. */
+	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
+	    (RF_DagNode_t *), allocList);
 	i = 0;
 	blockNode = &nodes[i];
 	i += 1;
@@ -1583,92 +1701,127 @@ rf_CommonCreateSmallWriteDAGFwd(
 	}
 	RF_ASSERT(i == totalNumNodes);
 
-	/* Step 3. initialize the nodes */
-	/* initialize block node (Nil) */
+	/* Step 3. Initialize the nodes. */
+	/* Initialize block node (Nil). */
 	nNodes = numDataNodes + (nfaults * numParityNodes);
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h,
+	    "Nil", allocList);
 
-	/* initialize terminate node (Trm) */
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, nNodes, 0, 0, dag_h, "Trm", allocList);
+	/* Initialize terminate node (Trm). */
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, nNodes, 0, 0, dag_h,
+	    "Trm", allocList);
 
-	/* initialize nodes which read old data (Rod) */
+	/* Initialize nodes which read old data (Rod). */
 	for (i = 0; i < numDataNodes; i++) {
-		rf_InitNode(&readDataNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, (numParityNodes * nfaults) + 1, 1, 4, 0, dag_h, "Rod", allocList);
+		rf_InitNode(&readDataNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+		    (numParityNodes * nfaults) + 1, 1, 4, 0, dag_h,
+		    "Rod", allocList);
 		RF_ASSERT(pda != NULL);
-		readDataNodes[i].params[0].p = pda;	/* physical disk addr
-							 * desc */
-		readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda, allocList);	/* buffer to hold old
-												 * data */
+		/* Physical disk addr desc. */
+		readDataNodes[i].params[0].p = pda;
+		/* Buffer to hold old data. */
+		readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h,
+		    pda, allocList);
 		readDataNodes[i].params[2].v = parityStripeID;
-		readDataNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, lu_flag, 0, which_ru);
+		readDataNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+		    lu_flag, 0, which_ru);
 		pda = pda->next;
 		for (j = 0; j < readDataNodes[i].numSuccedents; j++)
 			readDataNodes[i].propList[j] = NULL;
 	}
 
-	/* initialize nodes which read old parity (Rop) */
+	/* Initialize nodes which read old parity (Rop). */
 	pda = asmap->parityInfo;
 	i = 0;
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&readParityNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, numParityNodes, 1, 4, 0, dag_h, "Rop", allocList);
+		rf_InitNode(&readParityNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+		    numParityNodes, 1, 4, 0, dag_h, "Rop", allocList);
 		readParityNodes[i].params[0].p = pda;
-		readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda, allocList);	/* buffer to hold old
-													 * parity */
+		/* Buffer to hold old parity. */
+		readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
+		    dag_h, pda, allocList);
 		readParityNodes[i].params[2].v = parityStripeID;
-		readParityNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, lu_flag, 0, which_ru);
+		readParityNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+		    lu_flag, 0, which_ru);
 		for (j = 0; j < readParityNodes[i].numSuccedents; j++)
 			readParityNodes[i].propList[0] = NULL;
 		pda = pda->next;
 	}
 
-	/* initialize nodes which read old Q (Roq) */
+	/* Initialize nodes which read old Q (Roq). */
 	if (nfaults == 2) {
 		pda = asmap->qInfo;
 		for (i = 0; i < numParityNodes; i++) {
 			RF_ASSERT(pda != NULL);
-			rf_InitNode(&readQNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, numParityNodes, 1, 4, 0, dag_h, "Roq", allocList);
+			rf_InitNode(&readQNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskReadFunc, rf_DiskReadUndoFunc,
+			    rf_GenericWakeupFunc, numParityNodes, 1, 4, 0,
+			    dag_h, "Roq", allocList);
 			readQNodes[i].params[0].p = pda;
-			readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda, allocList);	/* buffer to hold old Q */
+			/* Buffer to hold old Q. */
+			readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr,
+			    dag_h, pda, allocList);
 			readQNodes[i].params[2].v = parityStripeID;
-			readQNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, lu_flag, 0, which_ru);
+			readQNodes[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    lu_flag, 0, which_ru);
 			for (j = 0; j < readQNodes[i].numSuccedents; j++)
 				readQNodes[i].propList[0] = NULL;
 			pda = pda->next;
 		}
 	}
-	/* initialize nodes which write new data (Wnd) */
+	/* Initialize nodes which write new data (Wnd). */
 	pda = asmap->physInfo;
 	for (i = 0; i < numDataNodes; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&writeDataNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnd", allocList);
-		writeDataNodes[i].params[0].p = pda;	/* physical disk addr
-							 * desc */
-		writeDataNodes[i].params[1].p = pda->bufPtr;	/* buffer holding new
-								 * data to be written */
+		rf_InitNode(&writeDataNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		    rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnd", allocList);
+		/* Physical disk addr desc. */
+		writeDataNodes[i].params[0].p = pda;
+		/* Buffer holding new data to be written. */
+		writeDataNodes[i].params[1].p = pda->bufPtr;
 		writeDataNodes[i].params[2].v = parityStripeID;
-		writeDataNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		writeDataNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 
 		if (lu_flag) {
-			/* initialize node to unlock the disk queue */
-			rf_InitNode(&unlockDataNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Und", allocList);
-			unlockDataNodes[i].params[0].p = pda;	/* physical disk addr
-								 * desc */
-			unlockDataNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, lu_flag, which_ru);
+			/* Initialize node to unlock the disk queue. */
+			rf_InitNode(&unlockDataNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
+			    "Und", allocList);
+			/* Physical disk addr desc. */
+			unlockDataNodes[i].params[0].p = pda;
+			unlockDataNodes[i].params[1].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, lu_flag, which_ru);
 		}
 		pda = pda->next;
 	}
 
 
-	/* initialize nodes which compute new parity and Q */
-	/* we use the simple XOR func in the double-XOR case, and when we're
-	 * accessing only a portion of one stripe unit. the distinction
+	/* Initialize nodes which compute new parity and Q. */
+	/*
+	 * Use the simple XOR func in the double-XOR case, and when
+	 * accessing only a portion of one stripe unit. The distinction
 	 * between the two is that the regular XOR func assumes that the
 	 * targbuf is a full SU in size, and examines the pda associated with
 	 * the buffer to decide where within the buffer to XOR the data,
 	 * whereas the simple XOR func just XORs the data into the start of
-	 * the buffer. */
-	if ((numParityNodes == 2) || ((numDataNodes == 1) && (asmap->totalSectorsAccessed < raidPtr->Layout.sectorsPerStripeUnit))) {
+	 * the buffer.
+	 */
+	if ((numParityNodes == 2) || ((numDataNodes == 1) &&
+	    (asmap->totalSectorsAccessed <
+	     raidPtr->Layout.sectorsPerStripeUnit))) {
 		func = pfuncs->simple;
 		undoFunc = rf_NullNodeUndoFunc;
 		name = pfuncs->SimpleName;
@@ -1685,12 +1838,16 @@ rf_CommonCreateSmallWriteDAGFwd(
 			qname = qfuncs->RegularName;
 		}
 	}
-	/* initialize the xor nodes: params are {pda,buf} from {Rod,Wnd,Rop}
-	 * nodes, and raidPtr  */
-	if (numParityNodes == 2) {	/* double-xor case */
+	/*
+	 * Initialize the xor nodes: params are {pda,buf} from {Rod,Wnd,Rop}
+	 * nodes, and raidPtr.
+	 */
+	if (numParityNodes == 2) {	/* Double-xor case. */
 		for (i = 0; i < numParityNodes; i++) {
-			rf_InitNode(&xorNodes[i], rf_wait, RF_FALSE, func, undoFunc, NULL, numParityNodes, numParityNodes + numDataNodes, 7, 1, dag_h, name, allocList);	/* no wakeup func for
-																						 * xor */
+			/* No wakeup func for xor. */
+			rf_InitNode(&xorNodes[i], rf_wait, RF_FALSE, func,
+			    undoFunc, NULL, numParityNodes, numParityNodes +
+			    numDataNodes, 7, 1, dag_h, name, allocList);
 			xorNodes[i].flags |= RF_DAGNODE_FLAG_YIELD;
 			xorNodes[i].params[0] = readDataNodes[i].params[0];
 			xorNodes[i].params[1] = readDataNodes[i].params[1];
@@ -1699,114 +1856,166 @@ rf_CommonCreateSmallWriteDAGFwd(
 			xorNodes[i].params[4] = writeDataNodes[i].params[0];
 			xorNodes[i].params[5] = writeDataNodes[i].params[1];
 			xorNodes[i].params[6].p = raidPtr;
-			xorNodes[i].results[0] = readParityNodes[i].params[1].p;	/* use old parity buf as
-											 * target buf */
+			/* Use old parity buf as target buf. */
+			xorNodes[i].results[0] = readParityNodes[i].params[1].p;
 			if (nfaults == 2) {
-				rf_InitNode(&qNodes[i], rf_wait, RF_FALSE, qfunc, undoFunc, NULL, numParityNodes, numParityNodes + numDataNodes, 7, 1, dag_h, qname, allocList);	/* no wakeup func for
-																							 * xor */
-				qNodes[i].params[0] = readDataNodes[i].params[0];
-				qNodes[i].params[1] = readDataNodes[i].params[1];
+				/* No wakeup func for xor. */
+				rf_InitNode(&qNodes[i], rf_wait, RF_FALSE,
+				    qfunc, undoFunc, NULL, numParityNodes,
+				    numParityNodes + numDataNodes, 7, 1,
+				    dag_h, qname, allocList);
+				qNodes[i].params[0] =
+				    readDataNodes[i].params[0];
+				qNodes[i].params[1] =
+				    readDataNodes[i].params[1];
 				qNodes[i].params[2] = readQNodes[i].params[0];
 				qNodes[i].params[3] = readQNodes[i].params[1];
-				qNodes[i].params[4] = writeDataNodes[i].params[0];
-				qNodes[i].params[5] = writeDataNodes[i].params[1];
+				qNodes[i].params[4] =
+				    writeDataNodes[i].params[0];
+				qNodes[i].params[5] =
+				    writeDataNodes[i].params[1];
 				qNodes[i].params[6].p = raidPtr;
-				qNodes[i].results[0] = readQNodes[i].params[1].p;	/* use old Q buf as
-											 * target buf */
+				/* Use old Q buf as target buf. */
+				qNodes[i].results[0] =
+				    readQNodes[i].params[1].p;
 			}
 		}
 	} else {
-		/* there is only one xor node in this case */
-		rf_InitNode(&xorNodes[0], rf_wait, RF_FALSE, func, undoFunc, NULL, numParityNodes, numParityNodes + numDataNodes, (2 * (numDataNodes + numDataNodes + 1) + 1), 1, dag_h, name, allocList);
+		/* There is only one xor node in this case. */
+		rf_InitNode(&xorNodes[0], rf_wait, RF_FALSE, func, undoFunc,
+		    NULL, numParityNodes, numParityNodes + numDataNodes,
+		    (2 * (numDataNodes + numDataNodes + 1) + 1), 1, dag_h,
+		    name, allocList);
 		xorNodes[0].flags |= RF_DAGNODE_FLAG_YIELD;
 		for (i = 0; i < numDataNodes + 1; i++) {
-			/* set up params related to Rod and Rop nodes */
-			xorNodes[0].params[2 * i + 0] = readDataNodes[i].params[0];	/* pda */
-			xorNodes[0].params[2 * i + 1] = readDataNodes[i].params[1];	/* buffer pointer */
+			/* Set up params related to Rod and Rop nodes. */
+			xorNodes[0].params[2 * i + 0] =
+			    readDataNodes[i].params[0];	/* pda */
+			xorNodes[0].params[2 * i + 1] =
+			    readDataNodes[i].params[1];	/* buffer pointer */
 		}
 		for (i = 0; i < numDataNodes; i++) {
-			/* set up params related to Wnd and Wnp nodes */
-			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 0] = writeDataNodes[i].params[0];	/* pda */
-			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 1] = writeDataNodes[i].params[1];	/* buffer pointer */
+			/* Set up params related to Wnd and Wnp nodes. */
+			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 0] =
+			    writeDataNodes[i].params[0]; /* pda */
+			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 1] =
+			    writeDataNodes[i].params[1]; /* buffer pointer */
 		}
-		xorNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;	/* xor node needs to get
-											 * at RAID information */
+		xorNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p =
+		    raidPtr;	/* xor node needs to get at RAID information */
 		xorNodes[0].results[0] = readParityNodes[0].params[1].p;
 		if (nfaults == 2) {
-			rf_InitNode(&qNodes[0], rf_wait, RF_FALSE, qfunc, undoFunc, NULL, numParityNodes, numParityNodes + numDataNodes, (2 * (numDataNodes + numDataNodes + 1) + 1), 1, dag_h, qname, allocList);
+			rf_InitNode(&qNodes[0], rf_wait, RF_FALSE, qfunc,
+			    undoFunc, NULL, numParityNodes,
+			    numParityNodes + numDataNodes,
+			    (2 * (numDataNodes + numDataNodes + 1) + 1),
+			    1, dag_h, qname, allocList);
 			for (i = 0; i < numDataNodes; i++) {
-				/* set up params related to Rod */
-				qNodes[0].params[2 * i + 0] = readDataNodes[i].params[0];	/* pda */
-				qNodes[0].params[2 * i + 1] = readDataNodes[i].params[1];	/* buffer pointer */
+				/* Set up params related to Rod. */
+				/* pda */
+				qNodes[0].params[2 * i + 0] =
+				    readDataNodes[i].params[0];
+				/* buffer pointer */
+				qNodes[0].params[2 * i + 1] =
+				    readDataNodes[i].params[1];
 			}
-			/* and read old q */
-			qNodes[0].params[2 * numDataNodes + 0] = readQNodes[0].params[0];	/* pda */
-			qNodes[0].params[2 * numDataNodes + 1] = readQNodes[0].params[1];	/* buffer pointer */
+			/* And read old q. */
+			qNodes[0].params[2 * numDataNodes + 0] =
+			    readQNodes[0].params[0];	/* pda */
+			qNodes[0].params[2 * numDataNodes + 1] =
+			    readQNodes[0].params[1];	/* buffer pointer */
 			for (i = 0; i < numDataNodes; i++) {
-				/* set up params related to Wnd nodes */
-				qNodes[0].params[2 * (numDataNodes + 1 + i) + 0] = writeDataNodes[i].params[0];	/* pda */
-				qNodes[0].params[2 * (numDataNodes + 1 + i) + 1] = writeDataNodes[i].params[1];	/* buffer pointer */
+				/* Set up params related to Wnd nodes. */
+				/* pda */
+				qNodes[0].params
+				    [2 * (numDataNodes + 1 + i) + 0] =
+				    writeDataNodes[i].params[0];
+				/* buffer pointer */
+				qNodes[0].params
+				    [2 * (numDataNodes + 1 + i) + 1] =
+				    writeDataNodes[i].params[1];
 			}
-			qNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;	/* xor node needs to get
-												 * at RAID information */
+			/* Xor node needs to get at RAID information. */
+			qNodes[0].params
+			    [2 * (numDataNodes + numDataNodes + 1)].p =
+			    raidPtr;
 			qNodes[0].results[0] = readQNodes[0].params[1].p;
 		}
 	}
 
-	/* initialize nodes which write new parity (Wnp) */
+	/* Initialize nodes which write new parity (Wnp). */
 	pda = asmap->parityInfo;
 	for (i = 0; i < numParityNodes; i++) {
-		rf_InitNode(&writeParityNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, numParityNodes, 4, 0, dag_h, "Wnp", allocList);
+		rf_InitNode(&writeParityNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		    rf_GenericWakeupFunc, 1, numParityNodes,
+		    4, 0, dag_h, "Wnp", allocList);
 		RF_ASSERT(pda != NULL);
-		writeParityNodes[i].params[0].p = pda;	/* param 1 (bufPtr)
-							 * filled in by xor node */
-		writeParityNodes[i].params[1].p = xorNodes[i].results[0];	/* buffer pointer for
-										 * parity write
-										 * operation */
+		/* Param 1 (bufPtr) filled in by xor node. */
+		writeParityNodes[i].params[0].p = pda;
+		/* Buffer pointer for parity write operation. */
+		writeParityNodes[i].params[1].p = xorNodes[i].results[0];
 		writeParityNodes[i].params[2].v = parityStripeID;
-		writeParityNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		writeParityNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 
 		if (lu_flag) {
-			/* initialize node to unlock the disk queue */
-			rf_InitNode(&unlockParityNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Unp", allocList);
-			unlockParityNodes[i].params[0].p = pda;	/* physical disk addr
-								 * desc */
-			unlockParityNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, lu_flag, which_ru);
+			/* Initialize node to unlock the disk queue. */
+			rf_InitNode(&unlockParityNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
+			    "Unp", allocList);
+			unlockParityNodes[i].params[0].p =
+			    pda;	/* Physical disk addr desc. */
+			unlockParityNodes[i].params[1].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, lu_flag, which_ru);
 		}
 		pda = pda->next;
 	}
 
-	/* initialize nodes which write new Q (Wnq) */
+	/* Initialize nodes which write new Q (Wnq). */
 	if (nfaults == 2) {
 		pda = asmap->qInfo;
 		for (i = 0; i < numParityNodes; i++) {
-			rf_InitNode(&writeQNodes[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, numParityNodes, 4, 0, dag_h, "Wnq", allocList);
+			rf_InitNode(&writeQNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, numParityNodes,
+			    4, 0, dag_h, "Wnq", allocList);
 			RF_ASSERT(pda != NULL);
-			writeQNodes[i].params[0].p = pda;	/* param 1 (bufPtr)
-								 * filled in by xor node */
-			writeQNodes[i].params[1].p = qNodes[i].results[0];	/* buffer pointer for
-										 * parity write
-										 * operation */
+			/* Param 1 (bufPtr) filled in by xor node. */
+			writeQNodes[i].params[0].p = pda;
+			/* Buffer pointer for parity write operation. */
+			writeQNodes[i].params[1].p = qNodes[i].results[0];
 			writeQNodes[i].params[2].v = parityStripeID;
-			writeQNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			writeQNodes[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, 0, which_ru);
 
 			if (lu_flag) {
-				/* initialize node to unlock the disk queue */
-				rf_InitNode(&unlockQNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Unq", allocList);
-				unlockQNodes[i].params[0].p = pda;	/* physical disk addr
-									 * desc */
-				unlockQNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, lu_flag, which_ru);
+				/* Initialize node to unlock the disk queue. */
+				rf_InitNode(&unlockQNodes[i], rf_wait,
+				    RF_FALSE, rf_DiskUnlockFunc,
+				    rf_DiskUnlockUndoFunc,
+				    rf_GenericWakeupFunc, 1, 1, 2, 0,
+				    dag_h, "Unq", allocList);
+				/* Physical disk addr desc. */
+				unlockQNodes[i].params[0].p = pda;
+				unlockQNodes[i].params[1].v =
+				    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+				    0, lu_flag, which_ru);
 			}
 			pda = pda->next;
 		}
 	}
-	/* Step 4. connect the nodes */
+	/* Step 4. Connect the nodes. */
 
-	/* connect header to block node */
+	/* Connect header to block node. */
 	dag_h->succedents[0] = blockNode;
 
-	/* connect block node to read old data nodes */
-	RF_ASSERT(blockNode->numSuccedents == (numDataNodes + (numParityNodes * nfaults)));
+	/* Connect block node to read old data nodes. */
+	RF_ASSERT(blockNode->numSuccedents ==
+	    (numDataNodes + (numParityNodes * nfaults)));
 	for (i = 0; i < numDataNodes; i++) {
 		blockNode->succedents[i] = &readDataNodes[i];
 		RF_ASSERT(readDataNodes[i].numAntecedents == 1);
@@ -1814,7 +2023,7 @@ rf_CommonCreateSmallWriteDAGFwd(
 		readDataNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect block node to read old parity nodes */
+	/* Connect block node to read old parity nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		blockNode->succedents[numDataNodes + i] = &readParityNodes[i];
 		RF_ASSERT(readParityNodes[i].numAntecedents == 1);
@@ -1822,66 +2031,76 @@ rf_CommonCreateSmallWriteDAGFwd(
 		readParityNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect block node to read old Q nodes */
+	/* Connect block node to read old Q nodes. */
 	if (nfaults == 2)
 		for (i = 0; i < numParityNodes; i++) {
-			blockNode->succedents[numDataNodes + numParityNodes + i] = &readQNodes[i];
+			blockNode->succedents[numDataNodes +
+			    numParityNodes + i] = &readQNodes[i];
 			RF_ASSERT(readQNodes[i].numAntecedents == 1);
 			readQNodes[i].antecedents[0] = blockNode;
 			readQNodes[i].antType[0] = rf_control;
 		}
 
-	/* connect read old data nodes to write new data nodes */
+	/* Connect read old data nodes to write new data nodes. */
 	for (i = 0; i < numDataNodes; i++) {
-		RF_ASSERT(readDataNodes[i].numSuccedents == ((nfaults * numParityNodes) + 1));
+		RF_ASSERT(readDataNodes[i].numSuccedents ==
+		    ((nfaults * numParityNodes) + 1));
 		RF_ASSERT(writeDataNodes[i].numAntecedents == 1);
 		readDataNodes[i].succedents[0] = &writeDataNodes[i];
 		writeDataNodes[i].antecedents[0] = &readDataNodes[i];
 		writeDataNodes[i].antType[0] = rf_antiData;
 	}
 
-	/* connect read old data nodes to xor nodes */
+	/* Connect read old data nodes to xor nodes. */
 	for (i = 0; i < numDataNodes; i++) {
 		for (j = 0; j < numParityNodes; j++) {
-			RF_ASSERT(xorNodes[j].numAntecedents == numDataNodes + numParityNodes);
+			RF_ASSERT(xorNodes[j].numAntecedents ==
+			    numDataNodes + numParityNodes);
 			readDataNodes[i].succedents[1 + j] = &xorNodes[j];
 			xorNodes[j].antecedents[i] = &readDataNodes[i];
 			xorNodes[j].antType[i] = rf_trueData;
 		}
 	}
 
-	/* connect read old data nodes to q nodes */
+	/* Connect read old data nodes to q nodes. */
 	if (nfaults == 2)
 		for (i = 0; i < numDataNodes; i++)
 			for (j = 0; j < numParityNodes; j++) {
-				RF_ASSERT(qNodes[j].numAntecedents == numDataNodes + numParityNodes);
-				readDataNodes[i].succedents[1 + numParityNodes + j] = &qNodes[j];
+				RF_ASSERT(qNodes[j].numAntecedents ==
+				    numDataNodes + numParityNodes);
+				readDataNodes[i].succedents
+				    [1 + numParityNodes + j] = &qNodes[j];
 				qNodes[j].antecedents[i] = &readDataNodes[i];
 				qNodes[j].antType[i] = rf_trueData;
 			}
 
-	/* connect read old parity nodes to xor nodes */
+	/* Connect read old parity nodes to xor nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		for (j = 0; j < numParityNodes; j++) {
-			RF_ASSERT(readParityNodes[i].numSuccedents == numParityNodes);
+			RF_ASSERT(readParityNodes[i].numSuccedents ==
+			    numParityNodes);
 			readParityNodes[i].succedents[j] = &xorNodes[j];
-			xorNodes[j].antecedents[numDataNodes + i] = &readParityNodes[i];
+			xorNodes[j].antecedents[numDataNodes + i] =
+			    &readParityNodes[i];
 			xorNodes[j].antType[numDataNodes + i] = rf_trueData;
 		}
 	}
 
-	/* connect read old q nodes to q nodes */
+	/* Connect read old q nodes to q nodes. */
 	if (nfaults == 2)
 		for (i = 0; i < numParityNodes; i++) {
 			for (j = 0; j < numParityNodes; j++) {
-				RF_ASSERT(readQNodes[i].numSuccedents == numParityNodes);
+				RF_ASSERT(readQNodes[i].numSuccedents ==
+				    numParityNodes);
 				readQNodes[i].succedents[j] = &qNodes[j];
-				qNodes[j].antecedents[numDataNodes + i] = &readQNodes[i];
-				qNodes[j].antType[numDataNodes + i] = rf_trueData;
+				qNodes[j].antecedents[numDataNodes + i] =
+				    &readQNodes[i];
+				qNodes[j].antType[numDataNodes + i] =
+				    rf_trueData;
 			}
 		}
 
-	/* connect xor nodes to the write new parity nodes */
+	/* Connect xor nodes to the write new parity nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(writeParityNodes[i].numAntecedents == numParityNodes);
 		for (j = 0; j < numParityNodes; j++) {
@@ -1892,10 +2111,11 @@ rf_CommonCreateSmallWriteDAGFwd(
 		}
 	}
 
-	/* connect q nodes to the write new q nodes */
+	/* Connect q nodes to the write new q nodes. */
 	if (nfaults == 2)
 		for (i = 0; i < numParityNodes; i++) {
-			RF_ASSERT(writeQNodes[i].numAntecedents == numParityNodes);
+			RF_ASSERT(writeQNodes[i].numAntecedents ==
+			    numParityNodes);
 			for (j = 0; j < numParityNodes; j++) {
 				RF_ASSERT(qNodes[j].numSuccedents == 1);
 				qNodes[i].succedents[j] = &writeQNodes[j];
@@ -1904,26 +2124,28 @@ rf_CommonCreateSmallWriteDAGFwd(
 			}
 		}
 
-	RF_ASSERT(termNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
+	RF_ASSERT(termNode->numAntecedents ==
+	    (numDataNodes + (nfaults * numParityNodes)));
 	RF_ASSERT(termNode->numSuccedents == 0);
 	for (i = 0; i < numDataNodes; i++) {
 		if (lu_flag) {
-			/* connect write new data nodes to unlock nodes */
+			/* Connect write new data nodes to unlock nodes. */
 			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
 			RF_ASSERT(unlockDataNodes[i].numAntecedents == 1);
 			writeDataNodes[i].succedents[0] = &unlockDataNodes[i];
 			unlockDataNodes[i].antecedents[0] = &writeDataNodes[i];
 			unlockDataNodes[i].antType[0] = rf_control;
 
-			/* connect unlock nodes to term node */
+			/* Connect unlock nodes to term nodes. */
 			RF_ASSERT(unlockDataNodes[i].numSuccedents == 1);
 			unlockDataNodes[i].succedents[0] = termNode;
 			termNode->antecedents[i] = &unlockDataNodes[i];
 			termNode->antType[i] = rf_control;
 		} else {
-			/* connect write new data nodes to term node */
+			/* Connect write new data nodes to term node. */
 			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
-			RF_ASSERT(termNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
+			RF_ASSERT(termNode->numAntecedents ==
+			    (numDataNodes + (nfaults * numParityNodes)));
 			writeDataNodes[i].succedents[0] = termNode;
 			termNode->antecedents[i] = &writeDataNodes[i];
 			termNode->antType[i] = rf_control;
@@ -1932,22 +2154,26 @@ rf_CommonCreateSmallWriteDAGFwd(
 
 	for (i = 0; i < numParityNodes; i++) {
 		if (lu_flag) {
-			/* connect write new parity nodes to unlock nodes */
+			/* Connect write new parity nodes to unlock nodes. */
 			RF_ASSERT(writeParityNodes[i].numSuccedents == 1);
 			RF_ASSERT(unlockParityNodes[i].numAntecedents == 1);
-			writeParityNodes[i].succedents[0] = &unlockParityNodes[i];
-			unlockParityNodes[i].antecedents[0] = &writeParityNodes[i];
+			writeParityNodes[i].succedents[0] =
+			    &unlockParityNodes[i];
+			unlockParityNodes[i].antecedents[0] =
+			    &writeParityNodes[i];
 			unlockParityNodes[i].antType[0] = rf_control;
 
-			/* connect unlock nodes to term node */
+			/* Connect unlock nodes to term node. */
 			RF_ASSERT(unlockParityNodes[i].numSuccedents == 1);
 			unlockParityNodes[i].succedents[0] = termNode;
-			termNode->antecedents[numDataNodes + i] = &unlockParityNodes[i];
+			termNode->antecedents[numDataNodes + i] =
+			    &unlockParityNodes[i];
 			termNode->antType[numDataNodes + i] = rf_control;
 		} else {
 			RF_ASSERT(writeParityNodes[i].numSuccedents == 1);
 			writeParityNodes[i].succedents[0] = termNode;
-			termNode->antecedents[numDataNodes + i] = &writeParityNodes[i];
+			termNode->antecedents[numDataNodes + i] =
+			    &writeParityNodes[i];
 			termNode->antType[numDataNodes + i] = rf_control;
 		}
 	}
@@ -1955,57 +2181,58 @@ rf_CommonCreateSmallWriteDAGFwd(
 	if (nfaults == 2)
 		for (i = 0; i < numParityNodes; i++) {
 			if (lu_flag) {
-				/* connect write new Q nodes to unlock nodes */
+				/* Connect write new Q nodes to unlock nodes. */
 				RF_ASSERT(writeQNodes[i].numSuccedents == 1);
 				RF_ASSERT(unlockQNodes[i].numAntecedents == 1);
 				writeQNodes[i].succedents[0] = &unlockQNodes[i];
-				unlockQNodes[i].antecedents[0] = &writeQNodes[i];
+				unlockQNodes[i].antecedents[0] =
+				    &writeQNodes[i];
 				unlockQNodes[i].antType[0] = rf_control;
 
-				/* connect unlock nodes to unblock node */
+				/* Connect unlock nodes to unblock node. */
 				RF_ASSERT(unlockQNodes[i].numSuccedents == 1);
 				unlockQNodes[i].succedents[0] = termNode;
-				termNode->antecedents[numDataNodes + numParityNodes + i] = &unlockQNodes[i];
-				termNode->antType[numDataNodes + numParityNodes + i] = rf_control;
+				termNode->antecedents[numDataNodes +
+				    numParityNodes + i] = &unlockQNodes[i];
+				termNode->antType[numDataNodes +
+				    numParityNodes + i] = rf_control;
 			} else {
 				RF_ASSERT(writeQNodes[i].numSuccedents == 1);
 				writeQNodes[i].succedents[0] = termNode;
-				termNode->antecedents[numDataNodes + numParityNodes + i] = &writeQNodes[i];
-				termNode->antType[numDataNodes + numParityNodes + i] = rf_control;
+				termNode->antecedents[numDataNodes +
+				    numParityNodes + i] = &writeQNodes[i];
+				termNode->antType[numDataNodes +
+				    numParityNodes + i] = rf_control;
 			}
 		}
 }
 
 
 
-/******************************************************************************
- * create a write graph (fault-free or degraded) for RAID level 1
+/*****************************************************************************
+ * Create a write graph (fault-free or degraded) for RAID level 1.
  *
  * Hdr  Nil -> Wpd -> Nil -> Trm
- *      Nil -> Wsd ->
+ *	Nil -> Wsd ->
  *
- * The "Wpd" node writes data to the primary copy in the mirror pair
- * The "Wsd" node writes data to the secondary copy in the mirror pair
+ * The "Wpd" node writes data to the primary copy in the mirror pair.
+ * The "Wsd" node writes data to the secondary copy in the mirror pair.
  *
- * Parameters:  raidPtr   - description of the physical array
- *              asmap     - logical & physical addresses for this access
- *              bp        - buffer ptr (holds write data)
- *              flags     - general flags (e.g. disk locking)
- *              allocList - list of memory allocated in DAG creation
+ * Parameters:	raidPtr	  - description of the physical array
+ *		asmap	  - logical & physical addresses for this access
+ *		bp	  - buffer ptr (holds write data)
+ *		flags	  - general flags (e.g. disk locking)
+ *		allocList - list of memory allocated in DAG creation
  *****************************************************************************/
 
-void 
-rf_CreateRaidOneWriteDAGFwd(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList)
+void
+rf_CreateRaidOneWriteDAGFwd(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+    RF_DagHeader_t *dag_h, void *bp, RF_RaidAccessFlags_t flags,
+    RF_AllocListElem_t *allocList)
 {
 	RF_DagNode_t *blockNode, *unblockNode, *termNode;
 	RF_DagNode_t *nodes, *wndNode, *wmirNode;
-	int     nWndNodes, nWmirNodes, i;
+	int nWndNodes, nWmirNodes, i;
 	RF_ReconUnitNum_t which_ru;
 	RF_PhysDiskAddr_t *pda, *pdaP;
 	RF_StripeNum_t parityStripeID;
@@ -2015,19 +2242,22 @@ rf_CreateRaidOneWriteDAGFwd(
 	if (rf_dagDebug) {
 		printf("[Creating RAID level 1 write DAG]\n");
 	}
-	nWmirNodes = (asmap->parityInfo->next) ? 2 : 1;	/* 2 implies access not
-							 * SU aligned */
+	/* 2 implies access not SU aligned. */
+	nWmirNodes = (asmap->parityInfo->next) ? 2 : 1;
 	nWndNodes = (asmap->physInfo->next) ? 2 : 1;
 
-	/* alloc the Wnd nodes and the Wmir node */
+	/* Alloc the Wnd nodes and the Wmir node. */
 	if (asmap->numDataFailed == 1)
 		nWndNodes--;
 	if (asmap->numParityFailed == 1)
 		nWmirNodes--;
 
-	/* total number of nodes = nWndNodes + nWmirNodes + (block + unblock +
-	 * terminator) */
-	RF_CallocAndAdd(nodes, nWndNodes + nWmirNodes + 3, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	/*
+	 * Total number of nodes = nWndNodes + nWmirNodes +
+	 *			   (block + unblock + terminator)
+	 */
+	RF_CallocAndAdd(nodes, nWndNodes + nWmirNodes + 3,
+	    sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
 	i = 0;
 	wndNode = &nodes[i];
 	i += nWndNodes;
@@ -2041,53 +2271,68 @@ rf_CreateRaidOneWriteDAGFwd(
 	i += 1;
 	RF_ASSERT(i == (nWndNodes + nWmirNodes + 3));
 
-	/* this dag can commit immediately */
+	/* This dag can commit immediately. */
 	dag_h->numCommitNodes = 0;
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	/* initialize the unblock and term nodes */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, (nWndNodes + nWmirNodes), 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, (nWndNodes + nWmirNodes), 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
-
-	/* initialize the wnd nodes */
+	/* Initialize the unblock and term nodes. */
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, (nWndNodes + nWmirNodes),
+	    0, 0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, (nWndNodes + nWmirNodes),
+	    0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+
+	/* Initialize the wnd nodes. */
 	if (nWndNodes > 0) {
 		pda = asmap->physInfo;
 		for (i = 0; i < nWndNodes; i++) {
-			rf_InitNode(&wndNode[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wpd", allocList);
+			rf_InitNode(&wndNode[i], rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Wpd", allocList);
 			RF_ASSERT(pda != NULL);
 			wndNode[i].params[0].p = pda;
 			wndNode[i].params[1].p = pda->bufPtr;
 			wndNode[i].params[2].v = parityStripeID;
-			wndNode[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			wndNode[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, 0, which_ru);
 			pda = pda->next;
 		}
 		RF_ASSERT(pda == NULL);
 	}
-	/* initialize the mirror nodes */
+	/* Initialize the mirror nodes. */
 	if (nWmirNodes > 0) {
 		pda = asmap->physInfo;
 		pdaP = asmap->parityInfo;
 		for (i = 0; i < nWmirNodes; i++) {
-			rf_InitNode(&wmirNode[i], rf_wait, RF_FALSE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wsd", allocList);
+			rf_InitNode(&wmirNode[i], rf_wait, RF_FALSE,
+			    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h,
+			    "Wsd", allocList);
 			RF_ASSERT(pda != NULL);
 			wmirNode[i].params[0].p = pdaP;
 			wmirNode[i].params[1].p = pda->bufPtr;
 			wmirNode[i].params[2].v = parityStripeID;
-			wmirNode[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			wmirNode[i].params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+			    0, 0, which_ru);
 			pda = pda->next;
 			pdaP = pdaP->next;
 		}
 		RF_ASSERT(pda == NULL);
 		RF_ASSERT(pdaP == NULL);
 	}
-	/* link the header node to the block node */
+	/* Link the header node to the block node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* link the block node to the write nodes */
+	/* Link the block node to the write nodes. */
 	RF_ASSERT(blockNode->numSuccedents == (nWndNodes + nWmirNodes));
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNode[i].numAntecedents == 1);
@@ -2102,7 +2347,7 @@ rf_CreateRaidOneWriteDAGFwd(
 		wmirNode[i].antType[0] = rf_control;
 	}
 
-	/* link the write nodes to the unblock node */
+	/* Link the write nodes to the unblock node. */
 	RF_ASSERT(unblockNode->numAntecedents == (nWndNodes + nWmirNodes));
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNode[i].numSuccedents == 1);
@@ -2117,7 +2362,7 @@ rf_CreateRaidOneWriteDAGFwd(
 		unblockNode->antType[i + nWndNodes] = rf_control;
 	}
 
-	/* link the unblock node to the term node */
+	/* Link the unblock node to the term node. */
 	RF_ASSERT(unblockNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
diff --git a/sys/dev/raidframe/rf_dagffwr.h b/sys/dev/raidframe/rf_dagffwr.h
index b7b50da1e70..7e3ed9ac897 100644
--- a/sys/dev/raidframe/rf_dagffwr.h
+++ b/sys/dev/raidframe/rf_dagffwr.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagffwr.h,v 1.2 1999/02/16 00:02:31 niklas Exp $	*/
+/*	$OpenBSD: rf_dagffwr.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagffwr.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,51 +28,38 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_DAGFFWR_H_
-#define _RF__RF_DAGFFWR_H_
+#ifndef	_RF__RF_DAGFFWR_H_
+#define	_RF__RF_DAGFFWR_H_
 
 #include "rf_types.h"
 
-/* fault-free write DAG creation routines */
-void 
-rf_CreateNonRedundantWriteDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-    RF_IoType_t type);
-void 
-rf_CreateRAID0WriteDAG(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList, RF_IoType_t type);
-void 
-rf_CreateSmallWriteDAG(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList);
-void 
-rf_CreateLargeWriteDAG(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList);
-void 
-rf_CommonCreateLargeWriteDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-    RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList, int nfaults,
-    int (*redFunc) (RF_DagNode_t *), int allowBufferRecycle);
-	void    rf_CommonCreateLargeWriteDAGFwd(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-            RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList, int nfaults,
-            int (*redFunc) (RF_DagNode_t *), int allowBufferRecycle);
-	void    rf_CommonCreateSmallWriteDAG(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-            RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-            RF_RedFuncs_t * pfuncs, RF_RedFuncs_t * qfuncs);
-	void    rf_CommonCreateSmallWriteDAGFwd(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-            RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-            RF_RedFuncs_t * pfuncs, RF_RedFuncs_t * qfuncs);
-	void    rf_CreateRaidOneWriteDAG(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-            RF_DagHeader_t * dag_h, void *bp, RF_RaidAccessFlags_t flags,
-            RF_AllocListElem_t * allocList);
-	void    rf_CreateRaidOneWriteDAGFwd(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h, void *bp,
-            RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList);
+/* Fault-free write DAG creation routines. */
+
+void rf_CreateNonRedundantWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_IoType_t);
+void rf_CreateRAID0WriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_IoType_t);
+void rf_CreateSmallWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CreateLargeWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CommonCreateLargeWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	int, int (*) (RF_DagNode_t *), int);
+void rf_CommonCreateLargeWriteDAGFwd(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	int, int (*) (RF_DagNode_t *), int);
+void rf_CommonCreateSmallWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_RedFuncs_t *, RF_RedFuncs_t *);
+void rf_CommonCreateSmallWriteDAGFwd(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_RedFuncs_t *, RF_RedFuncs_t *);
+void rf_CreateRaidOneWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
+void rf_CreateRaidOneWriteDAGFwd(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *);
 
-#endif				/* !_RF__RF_DAGFFWR_H_ */
+#endif	/* !_RF__RF_DAGFFWR_H_ */
diff --git a/sys/dev/raidframe/rf_dagflags.h b/sys/dev/raidframe/rf_dagflags.h
index a978088ce9f..29e2acb0141 100644
--- a/sys/dev/raidframe/rf_dagflags.h
+++ b/sys/dev/raidframe/rf_dagflags.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagflags.h,v 1.2 1999/02/16 00:02:31 niklas Exp $	*/
+/*	$OpenBSD: rf_dagflags.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagflags.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,17 +28,18 @@
  * rights to redistribute these changes.
  */
 
-/**************************************************************************************
+/*****************************************************************************
  *
- * dagflags.h -- flags that can be given to DoAccess
- * I pulled these out of dag.h because routines that call DoAccess may need these flags,
- * but certainly do not need the declarations related to the DAG data structures.
+ * dagflags.h -- Flags that can be given to DoAccess.
+ * I pulled these out of dag.h because routines that call DoAccess may need
+ * these flags, but certainly do not need the declarations related to the DAG
+ * data structures.
  *
- **************************************************************************************/
+ *****************************************************************************/
 
 
-#ifndef _RF__RF_DAGFLAGS_H_
-#define _RF__RF_DAGFLAGS_H_
+#ifndef	_RF__RF_DAGFLAGS_H_
+#define	_RF__RF_DAGFLAGS_H_
 
 /*
  * Bitmasks for the "flags" parameter (RF_RaidAccessFlags_t) used
@@ -48,21 +50,35 @@
  * specify USE_DAG.
  */
 
-#define RF_DAG_FLAGS_NONE             0	/* no flags */
-#define RF_DAG_SUPPRESS_LOCKS     (1<<0)	/* supress all stripe locks in
-						 * the DAG */
-#define RF_DAG_RETURN_ASM         (1<<1)	/* create an ASM and return it
-						 * instead of freeing it */
-#define RF_DAG_RETURN_DAG         (1<<2)	/* create a DAG and return it
-						 * instead of freeing it */
-#define RF_DAG_NONBLOCKING_IO     (1<<3)	/* cause DoAccess to be
-						 * non-blocking */
-#define RF_DAG_ACCESS_COMPLETE    (1<<4)	/* the access is complete */
-#define RF_DAG_DISPATCH_RETURNED  (1<<5)	/* used to handle the case
+#define	RF_DAG_FLAGS_NONE		    0	/* No flags */
+#define	RF_DAG_SUPPRESS_LOCKS		(1<<0)	/*
+						 * Supress all stripe locks in
+						 * the DAG.
+						 */
+#define	RF_DAG_RETURN_ASM		(1<<1)	/*
+						 * Create an ASM and return it
+						 * instead of freeing it.
+						 */
+#define	RF_DAG_RETURN_DAG		(1<<2)	/*
+						 * Create a DAG and return it
+						 * instead of freeing it.
+						 */
+#define	RF_DAG_NONBLOCKING_IO		(1<<3)	/*
+						 * Cause DoAccess to be
+						 * non-blocking.
+						 */
+#define	RF_DAG_ACCESS_COMPLETE		(1<<4)	/*
+						 * The access is complete.
+						 */
+#define	RF_DAG_DISPATCH_RETURNED	(1<<5)	/*
+						 * Used to handle the case
 						 * where the dag invokes no
-						 * I/O */
-#define RF_DAG_TEST_ACCESS        (1<<6)	/* this access came through
+						 * I/O.
+						 */
+#define	RF_DAG_TEST_ACCESS		(1<<6)	/*
+						 * This access came through
 						 * rf_ioctl instead of
-						 * rf_strategy */
+						 * rf_strategy.
+						 */
 
-#endif				/* !_RF__RF_DAGFLAGS_H_ */
+#endif	/* !_RF__RF_DAGFLAGS_H_ */
diff --git a/sys/dev/raidframe/rf_dagfuncs.c b/sys/dev/raidframe/rf_dagfuncs.c
index d3e35553d0a..7a2317034e6 100644
--- a/sys/dev/raidframe/rf_dagfuncs.c
+++ b/sys/dev/raidframe/rf_dagfuncs.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagfuncs.c,v 1.5 2000/08/08 16:07:39 peter Exp $	*/
+/*	$OpenBSD: rf_dagfuncs.c,v 1.6 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagfuncs.c,v 1.6 2000/03/30 12:45:40 augustss Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,7 +29,7 @@
  */
 
 /*
- * dagfuncs.c -- DAG node execution routines
+ * dagfuncs.c -- DAG node execution routines.
  *
  * Rules:
  * 1. Every DAG execution function must eventually cause node->status to
@@ -65,28 +66,28 @@
 
 #include "rf_kintf.h"
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 #include "rf_paritylog.h"
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-int     (*rf_DiskReadFunc) (RF_DagNode_t *);
-int     (*rf_DiskWriteFunc) (RF_DagNode_t *);
-int     (*rf_DiskReadUndoFunc) (RF_DagNode_t *);
-int     (*rf_DiskWriteUndoFunc) (RF_DagNode_t *);
-int     (*rf_DiskUnlockFunc) (RF_DagNode_t *);
-int     (*rf_DiskUnlockUndoFunc) (RF_DagNode_t *);
-int     (*rf_RegularXorUndoFunc) (RF_DagNode_t *);
-int     (*rf_SimpleXorUndoFunc) (RF_DagNode_t *);
-int     (*rf_RecoveryXorUndoFunc) (RF_DagNode_t *);
-
-/*****************************************************************************************
- * main (only) configuration routine for this module
- ****************************************************************************************/
-int 
-rf_ConfigureDAGFuncs(listp)
-	RF_ShutdownList_t **listp;
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
+
+int	(*rf_DiskReadFunc) (RF_DagNode_t *);
+int	(*rf_DiskWriteFunc) (RF_DagNode_t *);
+int	(*rf_DiskReadUndoFunc) (RF_DagNode_t *);
+int	(*rf_DiskWriteUndoFunc) (RF_DagNode_t *);
+int	(*rf_DiskUnlockFunc) (RF_DagNode_t *);
+int	(*rf_DiskUnlockUndoFunc) (RF_DagNode_t *);
+int	(*rf_RegularXorUndoFunc) (RF_DagNode_t *);
+int	(*rf_SimpleXorUndoFunc) (RF_DagNode_t *);
+int	(*rf_RecoveryXorUndoFunc) (RF_DagNode_t *);
+
+/*****************************************************************************
+ * Main (only) configuration routine for this module.
+ *****************************************************************************/
+int
+rf_ConfigureDAGFuncs(RF_ShutdownList_t **listp)
 {
-	RF_ASSERT(((sizeof(long) == 8) && RF_LONGSHIFT == 3) || ((sizeof(long) == 4) && RF_LONGSHIFT == 2));
+	RF_ASSERT(((sizeof(long) == 8) && RF_LONGSHIFT == 3) ||
+	    ((sizeof(long) == 4) && RF_LONGSHIFT == 2));
 	rf_DiskReadFunc = rf_DiskReadFuncForThreads;
 	rf_DiskReadUndoFunc = rf_DiskUndoFunc;
 	rf_DiskWriteFunc = rf_DiskWriteFuncForThreads;
@@ -100,78 +101,75 @@ rf_ConfigureDAGFuncs(listp)
 }
 
 
-
-/*****************************************************************************************
- * the execution function associated with a terminate node
- ****************************************************************************************/
-int 
-rf_TerminateFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ * The execution function associated with a terminate node.
+ *****************************************************************************/
+int
+rf_TerminateFunc(RF_DagNode_t *node)
 {
 	RF_ASSERT(node->dagHdr->numCommits == node->dagHdr->numCommitNodes);
 	node->status = rf_good;
 	return (rf_FinishNode(node, RF_THREAD_CONTEXT));
 }
 
-int 
-rf_TerminateUndoFunc(node)
-	RF_DagNode_t *node;
+int
+rf_TerminateUndoFunc(RF_DagNode_t *node)
 {
 	return (0);
 }
 
 
-/*****************************************************************************************
- * execution functions associated with a mirror node
+/*****************************************************************************
+ * Execution functions associated with a mirror node.
  *
  * parameters:
  *
- * 0 - physical disk addres of data
- * 1 - buffer for holding read data
- * 2 - parity stripe ID
- * 3 - flags
- * 4 - physical disk address of mirror (parity)
+ * 0 - Physical disk addres of data.
+ * 1 - Buffer for holding read data.
+ * 2 - Parity stripe ID.
+ * 3 - Flags.
+ * 4 - Physical disk address of mirror (parity).
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-int 
-rf_DiskReadMirrorIdleFunc(node)
-	RF_DagNode_t *node;
+int
+rf_DiskReadMirrorIdleFunc(RF_DagNode_t *node)
 {
-	/* select the mirror copy with the shortest queue and fill in node
-	 * parameters with physical disk address */
+	/*
+	 * Select the mirror copy with the shortest queue and fill in node
+	 * parameters with physical disk address.
+	 */
 
 	rf_SelectMirrorDiskIdle(node);
 	return (rf_DiskReadFunc(node));
 }
 
-int 
-rf_DiskReadMirrorPartitionFunc(node)
-	RF_DagNode_t *node;
+int
+rf_DiskReadMirrorPartitionFunc(RF_DagNode_t *node)
 {
-	/* select the mirror copy with the shortest queue and fill in node
-	 * parameters with physical disk address */
+	/*
+	 * Select the mirror copy with the shortest queue and fill in node
+	 * parameters with physical disk address.
+	 */
 
 	rf_SelectMirrorDiskPartition(node);
 	return (rf_DiskReadFunc(node));
 }
 
-int 
-rf_DiskReadMirrorUndoFunc(node)
-	RF_DagNode_t *node;
+int
+rf_DiskReadMirrorUndoFunc(RF_DagNode_t *node)
 {
 	return (0);
 }
 
 
 
-#if RF_INCLUDE_PARITYLOGGING > 0
-/*****************************************************************************************
- * the execution function associated with a parity log update node
- ****************************************************************************************/
-int 
-rf_ParityLogUpdateFunc(node)
-	RF_DagNode_t *node;
+#if	RF_INCLUDE_PARITYLOGGING > 0
+/*****************************************************************************
+ * The execution function associated with a parity log update node.
+ *****************************************************************************/
+int
+rf_ParityLogUpdateFunc(RF_DagNode_t *node)
 {
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
 	caddr_t buf = (caddr_t) node->params[1].p;
@@ -198,12 +196,11 @@ rf_ParityLogUpdateFunc(node)
 }
 
 
-/*****************************************************************************************
- * the execution function associated with a parity log overwrite node
- ****************************************************************************************/
-int 
-rf_ParityLogOverwriteFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ * The execution function associated with a parity log overwrite node.
+ *****************************************************************************/
+int
+rf_ParityLogOverwriteFunc(RF_DagNode_t *node)
 {
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
 	caddr_t buf = (caddr_t) node->params[1].p;
@@ -213,8 +210,9 @@ rf_ParityLogOverwriteFunc(node)
 
 	if (node->dagHdr->status == rf_enable) {
 		RF_ETIMER_START(timer);
-		logData = rf_CreateParityLogData(RF_OVERWRITE, pda, buf, (RF_Raid_t *) (node->dagHdr->raidPtr),
-		    node->wakeFunc, (void *) node, node->dagHdr->tracerec, timer);
+		logData = rf_CreateParityLogData(RF_OVERWRITE, pda, buf,
+		    (RF_Raid_t *) (node->dagHdr->raidPtr), node->wakeFunc,
+		    (void *) node, node->dagHdr->tracerec, timer);
 		if (logData)
 			rf_ParityLogAppend(logData, RF_FALSE, NULL, RF_FALSE);
 		else {
@@ -226,61 +224,56 @@ rf_ParityLogOverwriteFunc(node)
 	}
 	return (0);
 }
-#else				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#else	/* RF_INCLUDE_PARITYLOGGING > 0 */
 
-int 
-rf_ParityLogUpdateFunc(node)
-	RF_DagNode_t *node;
+int
+rf_ParityLogUpdateFunc(RF_DagNode_t *node)
 {
 	return (0);
 }
-int 
-rf_ParityLogOverwriteFunc(node)
-	RF_DagNode_t *node;
+
+int
+rf_ParityLogOverwriteFunc(RF_DagNode_t *node)
 {
 	return (0);
 }
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
 
-int 
-rf_ParityLogUpdateUndoFunc(node)
-	RF_DagNode_t *node;
+int
+rf_ParityLogUpdateUndoFunc(RF_DagNode_t *node)
 {
 	return (0);
 }
 
-int 
-rf_ParityLogOverwriteUndoFunc(node)
-	RF_DagNode_t *node;
+int
+rf_ParityLogOverwriteUndoFunc(RF_DagNode_t *node)
 {
 	return (0);
 }
-/*****************************************************************************************
- * the execution function associated with a NOP node
- ****************************************************************************************/
-int 
-rf_NullNodeFunc(node)
-	RF_DagNode_t *node;
+
+/*****************************************************************************
+ * The execution function associated with a NOP node.
+ *****************************************************************************/
+int
+rf_NullNodeFunc(RF_DagNode_t *node)
 {
 	node->status = rf_good;
 	return (rf_FinishNode(node, RF_THREAD_CONTEXT));
 }
 
-int 
-rf_NullNodeUndoFunc(node)
-	RF_DagNode_t *node;
+int
+rf_NullNodeUndoFunc(RF_DagNode_t *node)
 {
 	node->status = rf_undone;
 	return (rf_FinishNode(node, RF_THREAD_CONTEXT));
 }
 
 
-/*****************************************************************************************
- * the execution function associated with a disk-read node
- ****************************************************************************************/
-int 
-rf_DiskReadFuncForThreads(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ * The execution function associated with a disk-read node.
+ *****************************************************************************/
+int
+rf_DiskReadFuncForThreads(RF_DagNode_t *node)
 {
 	RF_DiskQueueData_t *req;
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
@@ -291,9 +284,10 @@ rf_DiskReadFuncForThreads(node)
 	unsigned unlock = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v);
 	unsigned which_ru = RF_EXTRACT_RU(node->params[3].v);
 	RF_DiskQueueDataFlags_t flags = 0;
-	RF_IoType_t iotype = (node->dagHdr->status == rf_enable) ? RF_IO_TYPE_READ : RF_IO_TYPE_NOP;
+	RF_IoType_t iotype = (node->dagHdr->status == rf_enable) ?
+	    RF_IO_TYPE_READ : RF_IO_TYPE_NOP;
 	RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
-	void   *b_proc = NULL;
+	void *b_proc = NULL;
 
 	if (node->dagHdr->bp)
 		b_proc = (void *) ((struct buf *) node->dagHdr->bp)->b_proc;
@@ -317,12 +311,11 @@ rf_DiskReadFuncForThreads(node)
 }
 
 
-/*****************************************************************************************
+/*****************************************************************************
  * the execution function associated with a disk-write node
- ****************************************************************************************/
-int 
-rf_DiskWriteFuncForThreads(node)
-	RF_DagNode_t *node;
+ *****************************************************************************/
+int
+rf_DiskWriteFuncForThreads(RF_DagNode_t *node)
 {
 	RF_DiskQueueData_t *req;
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
@@ -333,23 +326,22 @@ rf_DiskWriteFuncForThreads(node)
 	unsigned unlock = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v);
 	unsigned which_ru = RF_EXTRACT_RU(node->params[3].v);
 	RF_DiskQueueDataFlags_t flags = 0;
-	RF_IoType_t iotype = (node->dagHdr->status == rf_enable) ? RF_IO_TYPE_WRITE : RF_IO_TYPE_NOP;
+	RF_IoType_t iotype = (node->dagHdr->status == rf_enable) ?
+	    RF_IO_TYPE_WRITE : RF_IO_TYPE_NOP;
 	RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
-	void   *b_proc = NULL;
+	void *b_proc = NULL;
 
 	if (node->dagHdr->bp)
 		b_proc = (void *) ((struct buf *) node->dagHdr->bp)->b_proc;
 
-	/* normal processing (rollaway or forward recovery) begins here */
+	/* Normal processing (rollaway or forward recovery) begins here. */
 	RF_ASSERT(!(lock && unlock));
 	flags |= (lock) ? RF_LOCK_DISK_QUEUE : 0;
 	flags |= (unlock) ? RF_UNLOCK_DISK_QUEUE : 0;
 	req = rf_CreateDiskQueueData(iotype, pda->startSector, pda->numSector,
 	    buf, parityStripeID, which_ru,
-	    (int (*) (void *, int)) node->wakeFunc,
-	    (void *) node, NULL,
-	    node->dagHdr->tracerec,
-	    (void *) (node->dagHdr->raidPtr),
+	    (int (*) (void *, int)) node->wakeFunc, (void *) node, NULL,
+	    node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
 	    flags, b_proc);
 
 	if (!req) {
@@ -361,77 +353,72 @@ rf_DiskWriteFuncForThreads(node)
 
 	return (0);
 }
-/*****************************************************************************************
- * the undo function for disk nodes
- * Note:  this is not a proper undo of a write node, only locks are released.
- *        old data is not restored to disk!
- ****************************************************************************************/
-int 
-rf_DiskUndoFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ * The undo function for disk nodes.
+ * Note:  This is not a proper undo of a write node, only locks are released.
+ *	  old data is not restored to disk !
+ *****************************************************************************/
+int
+rf_DiskUndoFunc(RF_DagNode_t *node)
 {
 	RF_DiskQueueData_t *req;
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
 	RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
 
-	req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP,
-	    0L, 0, NULL, 0L, 0,
-	    (int (*) (void *, int)) node->wakeFunc,
-	    (void *) node,
-	    NULL, node->dagHdr->tracerec,
-	    (void *) (node->dagHdr->raidPtr),
+	req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP, 0L, 0, NULL, 0L, 0,
+	    (int (*) (void *, int)) node->wakeFunc, (void *) node,
+	    NULL, node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
 	    RF_UNLOCK_DISK_QUEUE, NULL);
 	if (!req)
 		(node->wakeFunc) (node, ENOMEM);
 	else {
 		node->dagFuncData = (void *) req;
-		rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, RF_IO_NORMAL_PRIORITY);
+		rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req,
+		    RF_IO_NORMAL_PRIORITY);
 	}
 
 	return (0);
 }
-/*****************************************************************************************
- * the execution function associated with an "unlock disk queue" node
- ****************************************************************************************/
-int 
-rf_DiskUnlockFuncForThreads(node)
-	RF_DagNode_t *node;
+
+/*****************************************************************************
+ * The execution function associated with an "unlock disk queue" node.
+ *****************************************************************************/
+int
+rf_DiskUnlockFuncForThreads(RF_DagNode_t *node)
 {
 	RF_DiskQueueData_t *req;
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
 	RF_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
 
-	req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP,
-	    0L, 0, NULL, 0L, 0,
-	    (int (*) (void *, int)) node->wakeFunc,
-	    (void *) node,
-	    NULL, node->dagHdr->tracerec,
-	    (void *) (node->dagHdr->raidPtr),
+	req = rf_CreateDiskQueueData(RF_IO_TYPE_NOP, 0L, 0, NULL, 0L, 0,
+	    (int (*) (void *, int)) node->wakeFunc, (void *) node,
+	    NULL, node->dagHdr->tracerec, (void *) (node->dagHdr->raidPtr),
 	    RF_UNLOCK_DISK_QUEUE, NULL);
 	if (!req)
 		(node->wakeFunc) (node, ENOMEM);
 	else {
 		node->dagFuncData = (void *) req;
-		rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, RF_IO_NORMAL_PRIORITY);
+		rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req,
+		    RF_IO_NORMAL_PRIORITY);
 	}
 
 	return (0);
 }
-/*****************************************************************************************
- * Callback routine for DiskRead and DiskWrite nodes.  When the disk op completes,
- * the routine is called to set the node status and inform the execution engine that
- * the node has fired.
- ****************************************************************************************/
-int 
-rf_GenericWakeupFunc(node, status)
-	RF_DagNode_t *node;
-	int     status;
+
+/*****************************************************************************
+ * Callback routine for DiskRead and DiskWrite nodes. When the disk op
+ * completes, the routine is called to set the node status and inform
+ * the execution engine that the node has fired.
+ *****************************************************************************/
+int
+rf_GenericWakeupFunc(RF_DagNode_t *node, int status)
 {
 	switch (node->status) {
 	case rf_bwd1:
 		node->status = rf_bwd2;
 		if (node->dagFuncData)
-			rf_FreeDiskQueueData((RF_DiskQueueData_t *) node->dagFuncData);
+			rf_FreeDiskQueueData((RF_DiskQueueData_t *)
+			    node->dagFuncData);
 		return (rf_DiskWriteFuncForThreads(node));
 		break;
 	case rf_fired:
@@ -441,7 +428,7 @@ rf_GenericWakeupFunc(node, status)
 			node->status = rf_good;
 		break;
 	case rf_recover:
-		/* probably should never reach this case */
+		/* Probably should never reach this case. */
 		if (status)
 			node->status = rf_panic;
 		else
@@ -460,99 +447,111 @@ rf_GenericWakeupFunc(node, status)
 }
 
 
-/*****************************************************************************************
- * there are three distinct types of xor nodes
- * A "regular xor" is used in the fault-free case where the access spans a complete
- * stripe unit.  It assumes that the result buffer is one full stripe unit in size,
- * and uses the stripe-unit-offset values that it computes from the PDAs to determine
- * where within the stripe unit to XOR each argument buffer.
+/*****************************************************************************
+ * There are three distinct types of xor nodes.
+ *
+ * A "regular xor" is used in the fault-free case where the access spans
+ * a complete stripe unit. It assumes that the result buffer is one full
+ * stripe unit in size, and uses the stripe-unit-offset values that it
+ * computes from the PDAs to determine where within the stripe unit to
+ * XOR each argument buffer.
  *
- * A "simple xor" is used in the fault-free case where the access touches only a portion
- * of one (or two, in some cases) stripe unit(s).  It assumes that all the argument
- * buffers are of the same size and have the same stripe unit offset.
+ * A "simple xor" is used in the fault-free case where the access touches
+ * only a portion of one (or two, in some cases) stripe unit(s). It assumes
+ * that all the argument buffers are of the same size and have the same
+ * stripe unit offset.
  *
- * A "recovery xor" is used in the degraded-mode case.  It's similar to the regular
- * xor function except that it takes the failed PDA as an additional parameter, and
- * uses it to determine what portions of the argument buffers need to be xor'd into
- * the result buffer, and where in the result buffer they should go.
- ****************************************************************************************/
-
-/* xor the params together and store the result in the result field.
- * assume the result field points to a buffer that is the size of one SU,
+ * A "recovery xor" is used in the degraded-mode case. It's similar to
+ * the regular xor function except that it takes the failed PDA as an
+ * additional parameter, and uses it to determine what portions of the
+ * argument buffers need to be xor'd into the result buffer, and where
+ * in the result buffer they should go.
+ *****************************************************************************/
+
+/*
+ * Xor the params together and store the result in the result field.
+ * Assume the result field points to a buffer that is the size of one SU,
  * and use the pda params to determine where within the buffer to XOR
  * the input buffers.
  */
-int 
-rf_RegularXorFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RegularXorFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	int     i, retcode;
+	int i, retcode;
 
 	retcode = 0;
 	if (node->dagHdr->status == rf_enable) {
-		/* don't do the XOR if the input is the same as the output */
+		/* Don't do the XOR if the input is the same as the output. */
 		RF_ETIMER_START(timer);
 		for (i = 0; i < node->numParams - 1; i += 2)
 			if (node->params[i + 1].p != node->results[0]) {
-				retcode = rf_XorIntoBuffer(raidPtr, (RF_PhysDiskAddr_t *) node->params[i].p,
-				    (char *) node->params[i + 1].p, (char *) node->results[0], node->dagHdr->bp);
+				retcode = rf_XorIntoBuffer(raidPtr,
+				    (RF_PhysDiskAddr_t *) node->params[i].p,
+				    (char *) node->params[i + 1].p,
+				    (char *) node->results[0],
+				    node->dagHdr->bp);
 			}
 		RF_ETIMER_STOP(timer);
 		RF_ETIMER_EVAL(timer);
 		tracerec->xor_us += RF_ETIMER_VAL_US(timer);
 	}
-	return (rf_GenericWakeupFunc(node, retcode));	/* call wake func
-							 * explicitly since no
-							 * I/O in this node */
+	/* Call wake func explicitly since no I/O in this node. */
+	return (rf_GenericWakeupFunc(node, retcode));
 }
-/* xor the inputs into the result buffer, ignoring placement issues */
-int 
-rf_SimpleXorFunc(node)
-	RF_DagNode_t *node;
+
+/* Xor the inputs into the result buffer, ignoring placement issues. */
+int
+rf_SimpleXorFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
-	int     i, retcode = 0;
+	int i, retcode = 0;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
 
 	if (node->dagHdr->status == rf_enable) {
 		RF_ETIMER_START(timer);
-		/* don't do the XOR if the input is the same as the output */
+		/* Don't do the XOR if the input is the same as the output. */
 		for (i = 0; i < node->numParams - 1; i += 2)
 			if (node->params[i + 1].p != node->results[0]) {
-				retcode = rf_bxor((char *) node->params[i + 1].p, (char *) node->results[0],
-				    rf_RaidAddressToByte(raidPtr, ((RF_PhysDiskAddr_t *) node->params[i].p)->numSector),
+				retcode = rf_bxor((char *)
+				    node->params[i + 1].p,
+				    (char *) node->results[0],
+				    rf_RaidAddressToByte(raidPtr,
+				    ((RF_PhysDiskAddr_t *)
+				    node->params[i].p)->numSector),
 				    (struct buf *) node->dagHdr->bp);
 			}
 		RF_ETIMER_STOP(timer);
 		RF_ETIMER_EVAL(timer);
 		tracerec->xor_us += RF_ETIMER_VAL_US(timer);
 	}
-	return (rf_GenericWakeupFunc(node, retcode));	/* call wake func
-							 * explicitly since no
-							 * I/O in this node */
+	/* Call wake func explicitly since no I/O in this node. */
+	return (rf_GenericWakeupFunc(node, retcode));
 }
-/* this xor is used by the degraded-mode dag functions to recover lost data.
- * the second-to-last parameter is the PDA for the failed portion of the access.
- * the code here looks at this PDA and assumes that the xor target buffer is
- * equal in size to the number of sectors in the failed PDA.  It then uses
+
+/*
+ * This xor is used by the degraded-mode dag functions to recover lost data.
+ * The second-to-last parameter is the PDA for the failed portion of the access.
+ * The code here looks at this PDA and assumes that the xor target buffer is
+ * equal in size to the number of sectors in the failed PDA. It then uses
  * the other PDAs in the parameter list to determine where within the target
  * buffer the corresponding data should be xored.
  */
-int 
-rf_RecoveryXorFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RecoveryXorFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
-	RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
-	int     i, retcode = 0;
+	RF_PhysDiskAddr_t *failedPDA =
+	    (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
+	int i, retcode = 0;
 	RF_PhysDiskAddr_t *pda;
-	int     suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
-	char   *srcbuf, *destbuf;
+	int suoffset, failedSUOffset =
+	    rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
 
@@ -562,9 +561,14 @@ rf_RecoveryXorFunc(node)
 			if (node->params[i + 1].p != node->results[0]) {
 				pda = (RF_PhysDiskAddr_t *) node->params[i].p;
 				srcbuf = (char *) node->params[i + 1].p;
-				suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-				destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
-				retcode = rf_bxor(srcbuf, destbuf, rf_RaidAddressToByte(raidPtr, pda->numSector), node->dagHdr->bp);
+				suoffset = rf_StripeUnitOffset(layoutPtr,
+				    pda->startSector);
+				destbuf = ((char *) node->results[0]) +
+				    rf_RaidAddressToByte(raidPtr,
+				    suoffset - failedSUOffset);
+				retcode = rf_bxor(srcbuf, destbuf,
+				    rf_RaidAddressToByte(raidPtr,
+				    pda->numSector), node->dagHdr->bp);
 			}
 		RF_ETIMER_STOP(timer);
 		RF_ETIMER_EVAL(timer);
@@ -572,31 +576,30 @@ rf_RecoveryXorFunc(node)
 	}
 	return (rf_GenericWakeupFunc(node, retcode));
 }
-/*****************************************************************************************
- * The next three functions are utilities used by the above xor-execution functions.
- ****************************************************************************************/
 
 
+/*****************************************************************************
+ * The next three functions are utilities used by the above xor-execution
+ * functions.
+ *****************************************************************************/
+
 /*
- * this is just a glorified buffer xor.  targbuf points to a buffer that is one full stripe unit
- * in size.  srcbuf points to a buffer that may be less than 1 SU, but never more.  When the
- * access described by pda is one SU in size (which by implication means it's SU-aligned),
- * all that happens is (targbuf) <- (srcbuf ^ targbuf).  When the access is less than one
- * SU in size the XOR occurs on only the portion of targbuf identified in the pda.
+ * This is just a glorified buffer xor. Targbuf points to a buffer that is
+ * one full stripe unit in size. srcbuf points to a buffer that may be less
+ * than 1 SU, but never more. When the access described by pda is one SU in
+ * size (which by implication means it's SU-aligned), all that happens is
+ * (targbuf) <- (srcbuf ^ targbuf). When the access is less than one SU in
+ * size the XOR occurs on only the portion of targbuf identified in the pda.
  */
 
-int 
-rf_XorIntoBuffer(raidPtr, pda, srcbuf, targbuf, bp)
-	RF_Raid_t *raidPtr;
-	RF_PhysDiskAddr_t *pda;
-	char   *srcbuf;
-	char   *targbuf;
-	void   *bp;
+int
+rf_XorIntoBuffer(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, char *srcbuf,
+    char *targbuf, void *bp)
 {
-	char   *targptr;
-	int     sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	int     SUOffset = pda->startSector % sectPerSU;
-	int     length, retcode = 0;
+	char *targptr;
+	int sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
+	int SUOffset = pda->startSector % sectPerSU;
+	int length, retcode = 0;
 
 	RF_ASSERT(pda->numSector <= sectPerSU);
 
@@ -605,48 +608,46 @@ rf_XorIntoBuffer(raidPtr, pda, srcbuf, targbuf, bp)
 	retcode = rf_bxor(srcbuf, targptr, length, bp);
 	return (retcode);
 }
-/* it really should be the case that the buffer pointers (returned by malloc)
+
+/*
+ * It really should be the case that the buffer pointers (returned by malloc)
  * are aligned to the natural word size of the machine, so this is the only
- * case we optimize for.  The length should always be a multiple of the sector
+ * case we optimize for. The length should always be a multiple of the sector
  * size, so there should be no problem with leftover bytes at the end.
  */
-int 
-rf_bxor(src, dest, len, bp)
-	char   *src;
-	char   *dest;
-	int     len;
-	void   *bp;
+int
+rf_bxor(char *src, char *dest, int len, void *bp)
 {
 	unsigned mask = sizeof(long) - 1, retcode = 0;
 
-	if (!(((unsigned long) src) & mask) && !(((unsigned long) dest) & mask) && !(len & mask)) {
-		retcode = rf_longword_bxor((unsigned long *) src, (unsigned long *) dest, len >> RF_LONGSHIFT, bp);
+	if (!(((unsigned long) src) & mask) &&
+	    !(((unsigned long) dest) & mask) && !(len & mask)) {
+		retcode = rf_longword_bxor((unsigned long *) src,
+		    (unsigned long *) dest, len >> RF_LONGSHIFT, bp);
 	} else {
 		RF_ASSERT(0);
 	}
 	return (retcode);
 }
-/* map a user buffer into kernel space, if necessary */
-#define REMAP_VA(_bp,x,y) (y) = (x)
-
-/* When XORing in kernel mode, we need to map each user page to kernel space before we can access it.
- * We don't want to assume anything about which input buffers are in kernel/user
- * space, nor about their alignment, so in each loop we compute the maximum number
- * of bytes that we can xor without crossing any page boundaries, and do only this many
- * bytes before the next remap.
+
+/* Map a user buffer into kernel space, if necessary. */
+#define	REMAP_VA(_bp,x,y)	(y) = (x)
+
+/*
+ * When XORing in kernel mode, we need to map each user page to kernel
+ * space before we can access it.
+ * We don't want to assume anything about which input buffers are in
+ * kernel/user space, nor about their alignment, so in each loop we
+ * compute the maximum number of bytes that we can xor without crossing
+ * any page boundaries, and do only this many bytes before the next remap.
  */
-int 
-rf_longword_bxor(src, dest, len, bp)
-	unsigned long *src;
-	unsigned long *dest;
-	int     len;		/* longwords */
-	void   *bp;
+int
+rf_longword_bxor(unsigned long *src, unsigned long *dest, int len, void *bp)
 {
-	unsigned long *end = src + len;
-	unsigned long d0, d1, d2, d3, s0, s1, s2, s3;	/* temps */
-	unsigned long *pg_src, *pg_dest;	/* per-page source/dest
-							 * pointers */
-	int     longs_this_time;/* # longwords to xor in the current iteration */
+	unsigned long *end = src + len; /* len in longwords. */
+	unsigned long d0, d1, d2, d3, s0, s1, s2, s3; /* temps */
+	unsigned long *pg_src, *pg_dest; /* Per-page source/dest pointers. */
+	int longs_this_time; /* # longwords to xor in the current iteration. */
 
 	REMAP_VA(bp, src, pg_src);
 	REMAP_VA(bp, dest, pg_dest);
@@ -654,7 +655,8 @@ rf_longword_bxor(src, dest, len, bp)
 		return (EFAULT);
 
 	while (len >= 4) {
-		longs_this_time = RF_MIN(len, RF_MIN(RF_BLIP(pg_src), RF_BLIP(pg_dest)) >> RF_LONGSHIFT);	/* note len in longwords */
+		longs_this_time = RF_MIN(len, RF_MIN(RF_BLIP(pg_src),
+		    RF_BLIP(pg_dest)) >> RF_LONGSHIFT);
 		src += longs_this_time;
 		dest += longs_this_time;
 		len -= longs_this_time;
@@ -675,14 +677,16 @@ rf_longword_bxor(src, dest, len, bp)
 			pg_dest += 4;
 			longs_this_time -= 4;
 		}
-		while (longs_this_time > 0) {	/* cannot cross any page
-						 * boundaries here */
+		while (longs_this_time > 0) {
+			/* Cannot cross any page boundaries here. */
 			*pg_dest++ ^= *pg_src++;
 			longs_this_time--;
 		}
 
-		/* either we're done, or we've reached a page boundary on one
-		 * (or possibly both) of the pointers */
+		/*
+		 * Either we're done, or we've reached a page boundary on one
+		 * (or possibly both) of the pointers.
+		 */
 		if (len) {
 			if (RF_PAGE_ALIGNED(src))
 				REMAP_VA(bp, src, pg_src);
@@ -708,24 +712,21 @@ rf_longword_bxor(src, dest, len, bp)
 
 
 /*
-   dst = a ^ b ^ c;
-   a may equal dst
-   see comment above longword_bxor
-*/
-int 
-rf_longword_bxor3(dst, a, b, c, len, bp)
-	unsigned long *dst;
-	unsigned long *a;
-	unsigned long *b;
-	unsigned long *c;
-	int     len;		/* length in longwords */
-	void   *bp;
+ * dst = a ^ b ^ c;
+ * a may equal dst
+ * see comment above longword_bxor
+ */
+int
+rf_longword_bxor3(unsigned long *dst, unsigned long *a, unsigned long *b,
+    unsigned long *c, int len, void *bp)
 {
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-	unsigned long *pg_a, *pg_b, *pg_c, *pg_dst;	/* per-page source/dest
-								 * pointers */
-	int     longs_this_time;/* # longs to xor in the current iteration */
-	char    dst_is_a = 0;
+	/* Per-page source/dest pointers. */
+	unsigned long *pg_a, *pg_b, *pg_c, *pg_dst;
+	int longs_this_time;	/* # longs to xor in the current iteration */
+	char dst_is_a = 0;
+
+	/* Note: The length (len) is in longwords. */
 
 	REMAP_VA(bp, a, pg_a);
 	REMAP_VA(bp, b, pg_b);
@@ -737,7 +738,7 @@ rf_longword_bxor3(dst, a, b, c, len, bp)
 		REMAP_VA(bp, dst, pg_dst);
 	}
 
-	/* align dest to cache line.  Can't cross a pg boundary on dst here. */
+	/* Align dest to cache line. Can't cross a pg boundary on dst here. */
 	while ((((unsigned long) pg_dst) & 0x1f)) {
 		*pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
 		dst++;
@@ -763,7 +764,9 @@ rf_longword_bxor3(dst, a, b, c, len, bp)
 	}
 
 	while (len > 4) {
-		longs_this_time = RF_MIN(len, RF_MIN(RF_BLIP(a), RF_MIN(RF_BLIP(b), RF_MIN(RF_BLIP(c), RF_BLIP(dst)))) >> RF_LONGSHIFT);
+		longs_this_time = RF_MIN(len, RF_MIN(RF_BLIP(a),
+		    RF_MIN(RF_BLIP(b), RF_MIN(RF_BLIP(c), RF_BLIP(dst)))) >>
+		    RF_LONGSHIFT);
 		a += longs_this_time;
 		b += longs_this_time;
 		c += longs_this_time;
@@ -784,7 +787,7 @@ rf_longword_bxor3(dst, a, b, c, len, bp)
 
 			b2 = pg_b[2];
 			b3 = pg_b[3];
-			/* start dual issue */
+			/* Start dual issue. */
 			a0 ^= b0;
 			b0 = pg_c[0];
 
@@ -811,8 +814,8 @@ rf_longword_bxor3(dst, a, b, c, len, bp)
 			pg_dst[3] = a3;
 			pg_dst += 4;
 		}
-		while (longs_this_time > 0) {	/* cannot cross any page
-						 * boundaries here */
+		while (longs_this_time > 0) {
+			/* Cannot cross any page boundaries here. */
 			*pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
 			longs_this_time--;
 		}
@@ -877,17 +880,14 @@ rf_longword_bxor3(dst, a, b, c, len, bp)
 	return (0);
 }
 
-int 
-rf_bxor3(dst, a, b, c, len, bp)
-	unsigned char *dst;
-	unsigned char *a;
-	unsigned char *b;
-	unsigned char *c;
-	unsigned long len;
-	void   *bp;
+int
+rf_bxor3(unsigned char *dst, unsigned char *a, unsigned char *b,
+    unsigned char *c, unsigned long len, void *bp)
 {
-	RF_ASSERT(((RF_UL(dst) | RF_UL(a) | RF_UL(b) | RF_UL(c) | len) & 0x7) == 0);
+	RF_ASSERT(((RF_UL(dst) | RF_UL(a) | RF_UL(b) | RF_UL(c) | len) & 0x7)
+	    == 0);
 
 	return (rf_longword_bxor3((unsigned long *) dst, (unsigned long *) a,
-		(unsigned long *) b, (unsigned long *) c, len >> RF_LONGSHIFT, bp));
+		(unsigned long *) b, (unsigned long *) c, len >> RF_LONGSHIFT,
+		 bp));
 }
diff --git a/sys/dev/raidframe/rf_dagfuncs.h b/sys/dev/raidframe/rf_dagfuncs.h
index 7114fd5f164..681d0fb5f4e 100644
--- a/sys/dev/raidframe/rf_dagfuncs.h
+++ b/sys/dev/raidframe/rf_dagfuncs.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagfuncs.h,v 1.3 2000/08/08 16:07:39 peter Exp $	*/
+/*	$OpenBSD: rf_dagfuncs.h,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagfuncs.h,v 1.4 2000/03/30 13:39:07 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,49 +28,44 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * dagfuncs.h -- header file for DAG node execution routines
+ * dagfuncs.h -- Header file for DAG node execution routines.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-#ifndef _RF__RF_DAGFUNCS_H_
-#define _RF__RF_DAGFUNCS_H_
+#ifndef	_RF__RF_DAGFUNCS_H_
+#define	_RF__RF_DAGFUNCS_H_
 
-int     rf_ConfigureDAGFuncs(RF_ShutdownList_t ** listp);
-int     rf_TerminateFunc(RF_DagNode_t * node);
-int     rf_TerminateUndoFunc(RF_DagNode_t * node);
-int     rf_DiskReadMirrorIdleFunc(RF_DagNode_t * node);
-int     rf_DiskReadMirrorPartitionFunc(RF_DagNode_t * node);
-int     rf_DiskReadMirrorUndoFunc(RF_DagNode_t * node);
-int     rf_ParityLogUpdateFunc(RF_DagNode_t * node);
-int     rf_ParityLogOverwriteFunc(RF_DagNode_t * node);
-int     rf_ParityLogUpdateUndoFunc(RF_DagNode_t * node);
-int     rf_ParityLogOverwriteUndoFunc(RF_DagNode_t * node);
-int     rf_NullNodeFunc(RF_DagNode_t * node);
-int     rf_NullNodeUndoFunc(RF_DagNode_t * node);
-int     rf_DiskReadFuncForThreads(RF_DagNode_t * node);
-int     rf_DiskWriteFuncForThreads(RF_DagNode_t * node);
-int     rf_DiskUndoFunc(RF_DagNode_t * node);
-int     rf_DiskUnlockFuncForThreads(RF_DagNode_t * node);
-int     rf_GenericWakeupFunc(RF_DagNode_t * node, int status);
-int     rf_RegularXorFunc(RF_DagNode_t * node);
-int     rf_SimpleXorFunc(RF_DagNode_t * node);
-int     rf_RecoveryXorFunc(RF_DagNode_t * node);
-int 
-rf_XorIntoBuffer(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda, char *srcbuf,
-    char *targbuf, void *bp);
-int     rf_bxor(char *src, char *dest, int len, void *bp);
-int 
-rf_longword_bxor(unsigned long *src, unsigned long *dest, int len, void *bp);
-int 
-rf_longword_bxor3(unsigned long *dest, unsigned long *a, unsigned long *b, 
-		  unsigned long *c, int len, void *bp);
-int 
-rf_bxor3(unsigned char *dst, unsigned char *a, unsigned char *b,
-    unsigned char *c, unsigned long len, void *bp);
+int rf_ConfigureDAGFuncs(RF_ShutdownList_t **);
+int rf_TerminateFunc(RF_DagNode_t *);
+int rf_TerminateUndoFunc(RF_DagNode_t *);
+int rf_DiskReadMirrorIdleFunc(RF_DagNode_t *);
+int rf_DiskReadMirrorPartitionFunc(RF_DagNode_t *);
+int rf_DiskReadMirrorUndoFunc(RF_DagNode_t *);
+int rf_ParityLogUpdateFunc(RF_DagNode_t *);
+int rf_ParityLogOverwriteFunc(RF_DagNode_t *);
+int rf_ParityLogUpdateUndoFunc(RF_DagNode_t *);
+int rf_ParityLogOverwriteUndoFunc(RF_DagNode_t *);
+int rf_NullNodeFunc(RF_DagNode_t *);
+int rf_NullNodeUndoFunc(RF_DagNode_t *);
+int rf_DiskReadFuncForThreads(RF_DagNode_t *);
+int rf_DiskWriteFuncForThreads(RF_DagNode_t *);
+int rf_DiskUndoFunc(RF_DagNode_t *);
+int rf_DiskUnlockFuncForThreads(RF_DagNode_t *);
+int rf_GenericWakeupFunc(RF_DagNode_t *, int);
+int rf_RegularXorFunc(RF_DagNode_t *);
+int rf_SimpleXorFunc(RF_DagNode_t *);
+int rf_RecoveryXorFunc(RF_DagNode_t *);
+int rf_XorIntoBuffer(RF_Raid_t *, RF_PhysDiskAddr_t *, char *, char *, void *);
+int rf_bxor(char *, char *, int, void *);
+int rf_longword_bxor(unsigned long *, unsigned long *, int, void *);
+int rf_longword_bxor3(unsigned long *, unsigned long *, unsigned long *,
+	unsigned long *, int, void *);
+int rf_bxor3(unsigned char *, unsigned char *, unsigned char *,
+	unsigned char *, unsigned long, void *);
 
-/* function ptrs defined in ConfigureDAGFuncs() */
+/* Function ptrs defined in ConfigureDAGFuncs(). */
 extern int (*rf_DiskReadFunc) (RF_DagNode_t *);
 extern int (*rf_DiskWriteFunc) (RF_DagNode_t *);
 extern int (*rf_DiskReadUndoFunc) (RF_DagNode_t *);
@@ -80,11 +76,17 @@ extern int (*rf_SimpleXorUndoFunc) (RF_DagNode_t *);
 extern int (*rf_RegularXorUndoFunc) (RF_DagNode_t *);
 extern int (*rf_RecoveryXorUndoFunc) (RF_DagNode_t *);
 
-/* macros for manipulating the param[3] in a read or write node */
-#define RF_CREATE_PARAM3(pri, lk, unlk, wru) (((RF_uint64)(((wru&0xFFFFFF)<<8)|((lk)?0x10:0)|((unlk)?0x20:0)|((pri)&0xF)) ))
-#define RF_EXTRACT_PRIORITY(_x_)     ((((unsigned) ((unsigned long)(_x_))) >> 0) & 0x0F)
-#define RF_EXTRACT_LOCK_FLAG(_x_)    ((((unsigned) ((unsigned long)(_x_))) >> 4) & 0x1)
-#define RF_EXTRACT_UNLOCK_FLAG(_x_)  ((((unsigned) ((unsigned long)(_x_))) >> 5) & 0x1)
-#define RF_EXTRACT_RU(_x_)           ((((unsigned) ((unsigned long)(_x_))) >> 8) & 0xFFFFFF)
+/* Macros for manipulating the param[3] in a read or write node. */
+#define	RF_CREATE_PARAM3(pri,lk,unlk,wru)				\
+	(((RF_uint64) (((wru & 0xFFFFFF) << 8) | ((lk) ? 0x10 : 0) |	\
+		       ((unlk) ? 0x20 : 0) | ((pri) & 0xF))))
+#define	RF_EXTRACT_PRIORITY(_x_)					\
+	((((unsigned) ((unsigned long)(_x_))) >> 0) & 0x0F)
+#define	RF_EXTRACT_LOCK_FLAG(_x_)					\
+	((((unsigned) ((unsigned long)(_x_))) >> 4) & 0x1)
+#define	RF_EXTRACT_UNLOCK_FLAG(_x_)					\
+	((((unsigned) ((unsigned long)(_x_))) >> 5) & 0x1)
+#define	RF_EXTRACT_RU(_x_)						\
+	((((unsigned) ((unsigned long)(_x_))) >> 8) & 0xFFFFFF)
 
-#endif				/* !_RF__RF_DAGFUNCS_H_ */
+#endif	/* !_RF__RF_DAGFUNCS_H_ */
diff --git a/sys/dev/raidframe/rf_dagutils.c b/sys/dev/raidframe/rf_dagutils.c
index d2b0930be1d..78f04e8e1f0 100644
--- a/sys/dev/raidframe/rf_dagutils.c
+++ b/sys/dev/raidframe/rf_dagutils.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagutils.c,v 1.3 2000/01/07 14:50:20 peter Exp $	*/
+/*	$OpenBSD: rf_dagutils.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagutils.c,v 1.6 1999/12/09 02:26:09 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,9 +28,9 @@
  * rights to redistribute these changes.
  */
 
-/******************************************************************************
+/*****************************************************************************
  *
- * rf_dagutils.c -- utility routines for manipulating dags
+ * rf_dagutils.c -- Utility routines for manipulating dags.
  *
  *****************************************************************************/
 
@@ -45,50 +46,49 @@
 #include "rf_map.h"
 #include "rf_shutdown.h"
 
-#define SNUM_DIFF(_a_,_b_) (((_a_)>(_b_))?((_a_)-(_b_)):((_b_)-(_a_)))
+#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_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 *);
-
-/******************************************************************************
+	rf_RecoveryXorFunc, "Recovery Xr", rf_RecoveryXorFunc, "Recovery Xr"
+};
+
+void rf_RecurPrintDAG(RF_DagNode_t *, int, int);
+void rf_PrintDAG(RF_DagHeader_t *);
+int  rf_ValidateBranch(RF_DagNode_t *, int *, int *, RF_DagNode_t **, int);
+void rf_ValidateBranchVisitedBits(RF_DagNode_t *, int, int);
+void rf_ValidateVisitedBits(RF_DagHeader_t *);
+
+/*****************************************************************************
  *
- * InitNode - initialize a dag node
+ * InitNode - Initialize a dag node.
  *
- * the size of the propList array is always the same as that of the
+ * The size of the propList array is always the same as that of the
  * successors array.
  *
  *****************************************************************************/
-void 
+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)
+	RF_DagNode_t	 *node,
+	RF_NodeStatus_t	  initstatus,
+	int		  commit,
+	int		(*doFunc) (RF_DagNode_t *),
+	int		(*undoFunc) (RF_DagNode_t *node),
+	int		(*wakeFunc) (RF_DagNode_t *node, int),
+	int		  nSucc,
+	int		  nAnte,
+	int		  nParam,
+	int		  nResult,
+	RF_DagHeader_t	 *hdr,
+	char		 *name,
+	RF_AllocListElem_t *alist
+)
 {
-	void  **ptrs;
-	int     nptrs;
+	void **ptrs;
+	int nptrs;
 
 	if (nAnte > RF_MAX_ANTECEDENTS)
 		RF_PANIC();
@@ -107,7 +107,7 @@ rf_InitNode(
 	node->dagHdr = hdr;
 	node->visited = 0;
 
-	/* allocate all the pointers with one call to malloc */
+	/* Allocate all the pointers with one call to malloc. */
 	nptrs = nSucc + nAnte + nResult + nSucc;
 
 	if (nptrs <= RF_DAG_PTRCACHESIZE) {
@@ -115,12 +115,12 @@ rf_InitNode(
 	         * 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:
+	         * 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)
+	         *     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 {
@@ -129,13 +129,15 @@ rf_InitNode(
 	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;
+	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);
+			RF_CallocAndAdd(node->params, nParam,
+			    sizeof(RF_DagParam_t), (RF_DagParam_t *), alist);
 		}
 	} else {
 		node->params = NULL;
@@ -144,38 +146,39 @@ rf_InitNode(
 
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * allocation and deallocation routines
+ * Allocation and deallocation routines.
  *
  *****************************************************************************/
 
-void 
-rf_FreeDAG(dag_h)
-	RF_DagHeader_t *dag_h;
+void
+rf_FreeDAG(RF_DagHeader_t *dag_h)
 {
 	RF_AccessStripeMapHeader_t *asmap, *t_asmap;
 	RF_DagHeader_t *nextDag;
-	int     i;
+	int i;
 
 	while (dag_h) {
 		nextDag = dag_h->next;
 		for (i = 0; dag_h->memChunk[i] && i < RF_MAXCHUNKS; i++) {
-			/* release mem chunks */
+			/* 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++) {
+			/* 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 *));
+			/* 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;) {
@@ -189,17 +192,13 @@ rf_FreeDAG(dag_h)
 }
 
 RF_PropHeader_t *
-rf_MakePropListEntry(
-    RF_DagHeader_t * dag_h,
-    int resultNum,
-    int paramNum,
-    RF_PropHeader_t * next,
-    RF_AllocListElem_t * allocList)
+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);
+	RF_CallocAndAdd(p, 1, sizeof(RF_PropHeader_t), (RF_PropHeader_t *),
+	    allocList);
 	p->resultNum = resultNum;
 	p->paramNum = paramNum;
 	p->next = next;
@@ -208,32 +207,30 @@ rf_MakePropListEntry(
 
 static RF_FreeList_t *rf_dagh_freelist;
 
-#define RF_MAX_FREE_DAGH 128
-#define RF_DAGH_INC       16
-#define RF_DAGH_INITIAL   32
+#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;
+void rf_ShutdownDAGs(void *);
+void
+rf_ShutdownDAGs(void *ignored)
 {
 	RF_FREELIST_DESTROY(rf_dagh_freelist, next, (RF_DagHeader_t *));
 }
 
-int 
-rf_ConfigureDAGs(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureDAGs(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
-	RF_FREELIST_CREATE(rf_dagh_freelist, RF_MAX_FREE_DAGH,
-	    RF_DAGH_INC, sizeof(RF_DagHeader_t));
+	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_ERRORMSG3("Unable to add to shutdown list file %s line"
+		    " %d rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownDAGs(NULL);
 		return (rc);
 	}
@@ -243,7 +240,7 @@ rf_ConfigureDAGs(listp)
 }
 
 RF_DagHeader_t *
-rf_AllocDAGHeader()
+rf_AllocDAGHeader(void)
 {
 	RF_DagHeader_t *dh;
 
@@ -254,36 +251,37 @@ rf_AllocDAGHeader()
 	return (dh);
 }
 
-void 
-rf_FreeDAGHeader(RF_DagHeader_t * 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)
+
+/* Allocate 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;
+	char *p;
 
 	RF_MallocAndAdd(p, pda->numSector << raidPtr->logBytesPerSector,
 	    (char *), allocList);
 	return ((void *) p);
 }
-/******************************************************************************
+
+
+/*****************************************************************************
  *
- * debug routines
+ * Debug routines.
  *
  *****************************************************************************/
 
-char   *
-rf_NodeStatusString(RF_DagNode_t * node)
+char *
+rf_NodeStatusString(RF_DagNode_t *node)
 {
 	switch (node->status) {
-		case rf_wait:return ("wait");
+	case rf_wait:
+		return ("wait");
 	case rf_fired:
 		return ("fired");
 	case rf_good:
@@ -295,25 +293,25 @@ rf_NodeStatusString(RF_DagNode_t * node)
 	}
 }
 
-void 
-rf_PrintNodeInfoString(RF_DagNode_t * node)
+void
+rf_PrintNodeInfoString(RF_DagNode_t *node)
 {
 	RF_PhysDiskAddr_t *pda;
-	int     (*df) (RF_DagNode_t *) = node->doFunc;
-	int     i, lk, unlk;
-	void   *bufPtr;
+	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)) {
+	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" : " "));
+		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) {
@@ -337,7 +335,7 @@ rf_PrintNodeInfoString(RF_DagNode_t * node)
 		}
 		return;
 	}
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 	if (df == rf_ParityLogOverwriteFunc || df == rf_ParityLogUpdateFunc) {
 		for (i = 0; i < node->numParams - 1; i += 2) {
 			pda = (RF_PhysDiskAddr_t *) node->params[i].p;
@@ -348,7 +346,7 @@ rf_PrintNodeInfoString(RF_DagNode_t * node)
 		}
 		return;
 	}
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
 
 	if ((df == rf_TerminateFunc) || (df == rf_NullNodeFunc)) {
 		printf("\n");
@@ -357,20 +355,19 @@ rf_PrintNodeInfoString(RF_DagNode_t * node)
 	printf("?\n");
 }
 
-static void 
-rf_RecurPrintDAG(node, depth, unvisited)
-	RF_DagNode_t *node;
-	int     depth;
-	int     unvisited;
+void
+rf_RecurPrintDAG(RF_DagNode_t *node, int depth, int unvisited)
 {
-	char   *anttype;
-	int     i;
+	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);
+	    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; i < node->numSuccedents; i++) {
 		printf("%d%s", node->succedents[i]->nodeNum,
 		    ((i == node->numSuccedents - 1) ? "\0" : " "));
@@ -394,24 +391,25 @@ rf_RecurPrintDAG(node, depth, unvisited)
 			anttype = "?";
 			break;
 		}
-		printf("%d(%s)%s", node->antecedents[i]->nodeNum, anttype, (i == node->numAntecedents - 1) ? "\0" : " ");
+		printf("%d(%s)%s", node->antecedents[i]->nodeNum, anttype,
+		    (i == node->numAntecedents - 1) ? "\0" : " ");
 	}
 	printf("}; ");
 	rf_PrintNodeInfoString(node);
 	for (i = 0; i < node->numSuccedents; i++) {
 		if (node->succedents[i]->visited == unvisited)
-			rf_RecurPrintDAG(node->succedents[i], depth + 1, unvisited);
+			rf_RecurPrintDAG(node->succedents[i], depth + 1,
+			    unvisited);
 	}
 }
 
-static void 
-rf_PrintDAG(dag_h)
-	RF_DagHeader_t *dag_h;
+void
+rf_PrintDAG(RF_DagHeader_t *dag_h)
 {
-	int     unvisited, i;
-	char   *status;
+	int unvisited, i;
+	char *status;
 
-	/* set dag status */
+	/* Set dag status. */
 	switch (dag_h->status) {
 	case rf_enable:
 		status = "enable";
@@ -423,16 +421,18 @@ rf_PrintDAG(dag_h)
 		status = "rollBackward";
 		break;
 	default:
-		status = "illegal!";
+		status = "illegal !";
 		break;
 	}
-	/* find out if visited bits are currently set or clear */
+	/* Find out if visited bits are currently set or cleared. */
 	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("format is (depth) num commit type: status,nSucc nSuccFired/n"
+	    "SuccDone,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);
+	    status, dag_h->numSuccedents, dag_h->numCommitNodes,
+	    dag_h->numCommits);
 	for (i = 0; i < dag_h->numSuccedents; i++) {
 		printf("%d%s", dag_h->succedents[i]->nodeNum,
 		    ((i == dag_h->numSuccedents - 1) ? "\0" : " "));
@@ -443,11 +443,12 @@ rf_PrintDAG(dag_h)
 			rf_RecurPrintDAG(dag_h->succedents[i], 1, unvisited);
 	}
 }
-/* assigns node numbers */
-int 
-rf_AssignNodeNums(RF_DagHeader_t * dag_h)
+
+/* Assign node numbers. */
+int
+rf_AssignNodeNums(RF_DagHeader_t *dag_h)
 {
-	int     unvisited, i, nnum;
+	int unvisited, i, nnum;
 	RF_DagNode_t *node;
 
 	nnum = 0;
@@ -457,59 +458,58 @@ rf_AssignNodeNums(RF_DagHeader_t * dag_h)
 	for (i = 0; i < dag_h->numSuccedents; i++) {
 		node = dag_h->succedents[i];
 		if (node->visited == unvisited) {
-			nnum = rf_RecurAssignNodeNums(dag_h->succedents[i], nnum, 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
+rf_RecurAssignNodeNums(RF_DagNode_t *node, int num, int unvisited)
 {
-	int     i;
+	int i;
 
 	node->visited = (unvisited) ? 0 : 1;
 
 	node->nodeNum = num++;
 	for (i = 0; i < node->numSuccedents; i++) {
 		if (node->succedents[i]->visited == unvisited) {
-			num = rf_RecurAssignNodeNums(node->succedents[i], num, 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;
+
+/* Set the header pointers in each node to "newptr". */
+void
+rf_ResetDAGHeaderPointers(RF_DagHeader_t *dag_h, RF_DagHeader_t *newptr)
 {
-	int     i;
+	int i;
+
 	for (i = 0; i < dag_h->numSuccedents; i++)
 		if (dag_h->succedents[i]->dagHdr != newptr)
-			rf_RecurResetDAGHeaderPointers(dag_h->succedents[i], newptr);
+			rf_RecurResetDAGHeaderPointers(dag_h->succedents[i],
+			    newptr);
 }
 
-void 
-rf_RecurResetDAGHeaderPointers(node, newptr)
-	RF_DagNode_t *node;
-	RF_DagHeader_t *newptr;
+void
+rf_RecurResetDAGHeaderPointers(RF_DagNode_t *node, RF_DagHeader_t *newptr)
 {
-	int     i;
+	int i;
+
 	node->dagHdr = newptr;
 	for (i = 0; i < node->numSuccedents; i++)
 		if (node->succedents[i]->dagHdr != newptr)
-			rf_RecurResetDAGHeaderPointers(node->succedents[i], newptr);
+			rf_RecurResetDAGHeaderPointers(node->succedents[i],
+			    newptr);
 }
 
-
-void 
-rf_PrintDAGList(RF_DagHeader_t * dag_h)
+void
+rf_PrintDAGList(RF_DagHeader_t *dag_h)
 {
-	int     i = 0;
+	int i = 0;
 
 	for (; dag_h; dag_h = dag_h->next) {
 		rf_AssignNodeNums(dag_h);
@@ -518,53 +518,53 @@ rf_PrintDAGList(RF_DagHeader_t * 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
+rf_ValidateBranch(RF_DagNode_t *node, int *scount, int *acount,
+    RF_DagNode_t **nodes, int unvisited)
 {
-	int     i, retcode = 0;
+	int i, retcode = 0;
 
-	/* construct an array of node pointers indexed by node num */
+	/* 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");
+		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");
+		printf("INVALID DAG: Node status is not wait.\n");
 		retcode = 1;
 	}
 	if (node->numAntDone != 0) {
-		printf("INVALID DAG: numAntDone is not zero\n");
+		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");
+			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");
+			printf("INVALID DAG: Non-terminator node has no"
+			    " succedents\n");
 			retcode = 1;
 		}
 	}
 	for (i = 0; i < node->numSuccedents; i++) {
 		if (!node->succedents[i]) {
-			printf("INVALID DAG: succedent %d of node %s is NULL\n", i, node->name);
+			printf("INVALID DAG: succedent %d of node %s"
+			    " is NULL.\n", i, node->name);
 			retcode = 1;
 		}
 		scount[node->succedents[i]->nodeNum]++;
 	}
 	for (i = 0; i < node->numAntecedents; i++) {
 		if (!node->antecedents[i]) {
-			printf("INVALID DAG: antecedent %d of node %s is NULL\n", i, node->name);
+			printf("INVALID DAG: antecedent %d of node %s is"
+			    " NULL.\n", i, node->name);
 			retcode = 1;
 		}
 		acount[node->antecedents[i]->nodeNum]++;
@@ -580,43 +580,46 @@ rf_ValidateBranch(node, scount, acount, nodes, unvisited)
 	return (retcode);
 }
 
-static void 
-rf_ValidateBranchVisitedBits(node, unvisited, rl)
-	RF_DagNode_t *node;
-	int     unvisited;
-	int     rl;
+void
+rf_ValidateBranchVisitedBits(RF_DagNode_t *node, int unvisited, int rl)
 {
-	int     i;
+	int i;
 
 	RF_ASSERT(node->visited == unvisited);
 	for (i = 0; i < node->numSuccedents; i++) {
 		if (node->succedents[i] == NULL) {
-			printf("node=%lx node->succedents[%d] is NULL\n", (long) node, i);
+			printf("node=%lx node->succedents[%d] is NULL.\n",
+			    (long) node, i);
 			RF_ASSERT(0);
 		}
-		rf_ValidateBranchVisitedBits(node->succedents[i], unvisited, rl + 1);
+		rf_ValidateBranchVisitedBits(node->succedents[i],
+		    unvisited, rl + 1);
 	}
 }
-/* NOTE:  never call this on a big dag, because it is exponential
- * in execution time
+
+/*
+ * NOTE:  Never call this on a big dag, because it is exponential
+ * in execution time.
  */
-static void 
-rf_ValidateVisitedBits(dag)
-	RF_DagHeader_t *dag;
+void
+rf_ValidateVisitedBits(RF_DagHeader_t *dag)
 {
-	int     i, unvisited;
+	int i, unvisited;
 
 	unvisited = dag->succedents[0]->visited;
 
 	for (i = 0; i < dag->numSuccedents; i++) {
 		if (dag->succedents[i] == NULL) {
-			printf("dag=%lx dag->succedents[%d] is NULL\n", (long) dag, i);
+			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:
+
+/*
+ * Validate a DAG. _at entry_ verify that:
  *   -- numNodesCompleted is zero
  *   -- node queue is null
  *   -- dag status is rf_enable
@@ -630,40 +633,42 @@ rf_ValidateVisitedBits(dag)
  *      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?
+ *   -- what else ?
  */
-int 
-rf_ValidateDAG(dag_h)
-	RF_DagHeader_t *dag_h;
+int
+rf_ValidateDAG(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;
+	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);
+		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");
+		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);
+		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);
+		/* Currently, all dags must have only one succedent. */
+		printf("INVALID DAG: numSuccedents != 1 (%d).\n",
+		    dag_h->numSuccedents);
 		retcode = 1;
 		goto validate_dag_bad;
 	}
@@ -681,40 +686,49 @@ rf_ValidateDAG(dag_h)
 			retcode = 1;
 		}
 	}
-	/* start at 1 to skip the header node */
+	/* Start at 1 to skip the header node. */
 	for (i = 1; i < nodecount; i++) {
 		if (nodes[i]->commitNode)
 			commitNodeCount++;
 		if (nodes[i]->doFunc == NULL) {
-			printf("INVALID DAG: node %s has an undefined doFunc\n", nodes[i]->name);
+			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);
+			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]);
+			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]);
+			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",
+		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));
@@ -733,37 +747,37 @@ validate_dag_bad:
 }
 
 
-/******************************************************************************
+/*****************************************************************************
  *
- * misc construction routines
+ * Misc construction routines.
  *
  *****************************************************************************/
 
-void 
-rf_redirect_asm(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap)
+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;
+	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)) {
+				if (!rf_CheckRUReconstructed(
+				    raidPtr->reconControl[row]->reconMap,
+				    pda->startSector)) {
 					RF_PANIC();
 				}
 			}
-			/* printf("Remapped data for large write\n"); */
+			/*printf("Remapped data for large write\n");*/
 			if (ds) {
-				raidPtr->Layout.map->MapSector(raidPtr, pda->raidAddress,
-				    &pda->row, &pda->col, &pda->startSector, RF_REMAP);
+				raidPtr->Layout.map->MapSector(raidPtr,
+				    pda->raidAddress, &pda->row, &pda->col,
+				    &pda->startSector, RF_REMAP);
 			} else {
 				pda->row = srow;
 				pda->col = scol;
@@ -773,13 +787,17 @@ rf_redirect_asm(
 	for (pda = asmap->parityInfo; pda; pda = pda->next) {
 		if (pda->col == fcol) {
 			if (rf_dagDebug) {
-				if (!rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, pda->startSector)) {
+				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);
+			(raidPtr->Layout.map->MapParity) (raidPtr,
+			    pda->raidAddress, &pda->row, &pda->col,
+			    &pda->startSector, RF_REMAP);
 		} else {
 			pda->row = srow;
 			pda->col = scol;
@@ -788,125 +806,147 @@ rf_redirect_asm(
 }
 
 
-/* this routine allocates read buffers and generates stripe maps for the
+/*
+ * 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
+ * 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 
+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_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 */
+	/*
+	 * 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);
+		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);
+		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 */
+		/* 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 */
+	/*
+	 * 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);
+		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 */
+		/* 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)
+/* 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);
+	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
+/*
+ * 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
+ * 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
+ * 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
+ *                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
+ *                PDA, the i'th 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 
+ /* in: asmap - 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_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);
 
@@ -915,89 +955,124 @@ rf_GenerateFailedAccessASMs(
 
 	RF_SectorCount_t numSect[2], numParitySect;
 	RF_PhysDiskAddr_t *pda;
-	char   *rdBuf, *bufP;
-	int     foundit, i;
+	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);
+	/*
+	 * 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 */
+	/*
+	 * 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;
+	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. */
+	/*
+	 * 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);
+		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);
+		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);
+	/*
+	 * 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);
+			    (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 */
+	/*
+	 * 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) {
+		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) {
+		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 rest of the buffer is for parity. */
+		*rpBufPtr = bufP;
 
-	/* 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
+	/*
+	 * 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 */
+	 * being accessed.
+	 */
 
-	for (foundit = i = 0, pda = asmap->physInfo; pda; i++, pda = pda->next) {
+	for (foundit = i = 0, pda = asmap->physInfo;
+	     pda; i++, pda = pda->next) {
 		if (pda == failedPDA) {
 			i--;
 			foundit = 1;
@@ -1009,7 +1084,8 @@ rf_GenerateFailedAccessASMs(
 		}
 	}
 	if (!foundit) {
-		RF_ERRORMSG("GenerateFailedAccessASMs: did not find failedPDA in asm list\n");
+		RF_ERRORMSG("GenerateFailedAccessASMs: did not find failedPDA"
+		    " in asm list.\n");
 		RF_ASSERT(0);
 	}
 	if (rf_degDagDebug) {
@@ -1025,8 +1101,9 @@ rf_GenerateFailedAccessASMs(
 }
 
 
-/* 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
+/*
+ * Adjust 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.
  *
@@ -1047,72 +1124,80 @@ rf_GenerateFailedAccessASMs(
  * |           rrrrrrrrrrrrrrrr                          |
  *
  */
-void 
-rf_RangeRestrictPDA(
-    RF_Raid_t * raidPtr,
-    RF_PhysDiskAddr_t * src,
-    RF_PhysDiskAddr_t * dest,
-    int dobuffer,
-    int doraidaddr)
+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 */
+	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;
+		dest->bufPtr += (soffs > doffs) ?
+		    rf_RaidAddressToByte(raidPtr, soffs - doffs) : 0;
 	if (doraidaddr) {
-		dest->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, dest->raidAddress) +
+		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
+#define	NLOWPRIMES	8
 static int lowprimes[NLOWPRIMES] = {2, 3, 5, 7, 11, 13, 17, 19};
+
 /*****************************************************************************
- * compute the workload shift factor.  (chained declustering)
+ * Compute the workload shift factor. (chained declustering)
  *
- * return nonzero if access should shift to secondary, otherwise,
- * access is to primary
+ * 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)
+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
+         * 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;
+	int k, v, ret, i;
 
 	row = pda->row;
 	n = raidPtr->numCol;
 
-	/* assign column of primary copy to d */
+	/* 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 < n)); f++);
+	/* Assign column of dead disk to f. */
+	for (f = 0; ((!RF_DEAD_DISK(raidPtr->Disks[row][f].status)) &&
+	     (f < n)); f++);
 
 	RF_ASSERT(f < n);
 	RF_ASSERT(f != d);
@@ -1121,7 +1206,7 @@ rf_compute_workload_shift(
 	RF_ASSERT(sd < n);
 
 	/*
-         * v of every k accesses should be redirected
+         * v of every k accesses should be redirected.
          *
          * v/k := (n-1-sd)/(n-1)
          */
@@ -1131,10 +1216,10 @@ rf_compute_workload_shift(
 #if 1
 	/*
          * XXX
-         * Is this worth it?
+         * Is this worth it ?
          *
          * Now reduce the fraction, by repeatedly factoring
-         * out primes (just like they teach in elementary school!)
+         * out primes (just like they teach in elementary school !).
          */
 	for (i = 0; i < NLOWPRIMES; i++) {
 		if (lowprimes[i] > v)
@@ -1148,9 +1233,9 @@ rf_compute_workload_shift(
 
 	raidPtr->hist_diskreq[row][d]++;
 	if (raidPtr->hist_diskreq[row][d] > v) {
-		ret = 0;	/* do not redirect */
+		ret = 0;	/* Do not redirect. */
 	} else {
-		ret = 1;	/* redirect */
+		ret = 1;	/* Redirect. */
 	}
 
 #if 0
@@ -1159,33 +1244,34 @@ rf_compute_workload_shift(
 #endif
 
 	if (raidPtr->hist_diskreq[row][d] >= k) {
-		/* reset counter */
+		/* Reset counter. */
 		raidPtr->hist_diskreq[row][d] = 0;
 	}
 	return (ret);
 }
+
 /*
- * Disk selection routines
+ * Disk selection routines.
  */
 
 /*
- * Selects the disk with the shortest queue from a mirror pair.
+ * Select 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"
+ * disk are counted as members of the "queue".
  */
-void 
-rf_SelectMirrorDiskIdle(RF_DagNode_t * node)
+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;
+	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 */
+	/* Return the [row col] of the disk with the shortest queue. */
 	rowData = data_pda->row;
 	colData = data_pda->col;
 	rowMirror = mirror_pda->row;
@@ -1193,18 +1279,19 @@ rf_SelectMirrorDiskIdle(RF_DagNode_t * node)
 	dataQueue = &(dqs[rowData][colData]);
 	mirrorQueue = &(dqs[rowMirror][colMirror]);
 
-#ifdef RF_LOCK_QUEUES_TO_READ_LEN
+#ifdef	RF_LOCK_QUEUES_TO_READ_LEN
 	RF_LOCK_QUEUE_MUTEX(dataQueue, "SelectMirrorDiskIdle");
-#endif				/* RF_LOCK_QUEUES_TO_READ_LEN */
+#endif	/* RF_LOCK_QUEUES_TO_READ_LEN */
 	dataQueueLength = dataQueue->queueLength + dataQueue->numOutstanding;
-#ifdef RF_LOCK_QUEUES_TO_READ_LEN
+#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
+#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 */
+#endif	/* RF_LOCK_QUEUES_TO_READ_LEN */
 
 	usemirror = 0;
 	if (RF_DEAD_DISK(disks[rowMirror][colMirror].status)) {
@@ -1214,7 +1301,7 @@ rf_SelectMirrorDiskIdle(RF_DagNode_t * node)
 			usemirror = 1;
 		} else
 			if (raidPtr->parity_good == RF_RAID_DIRTY) {
-				/* Trust only the main disk */
+				/* Trust only the main disk. */
 				usemirror = 0;
 			} else
 			if (dataQueueLength < mirrorQueueLength) {
@@ -1223,10 +1310,14 @@ rf_SelectMirrorDiskIdle(RF_DagNode_t * node)
 				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)) {
+					/* 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;
@@ -1234,22 +1325,23 @@ rf_SelectMirrorDiskIdle(RF_DagNode_t * node)
 				}
 
 	if (usemirror) {
-		/* use mirror (parity) disk, swap params 0 & 4 */
+		/* 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 */
+		/* Use data disk, leave param 0 unchanged. */
 	}
-	/* printf("dataQueueLength %d, mirrorQueueLength
-	 * %d\n",dataQueueLength, mirrorQueueLength); */
+	/*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)
+void
+rf_SelectMirrorDiskPartition(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr;
 	RF_RowCol_t rowData, colData, rowMirror, colMirror;
@@ -1258,9 +1350,9 @@ rf_SelectMirrorDiskPartition(RF_DagNode_t * node)
 	RF_PhysDiskAddr_t *tmp_pda;
 	RF_RaidDisk_t **disks = raidPtr->Disks;
 	RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue;
-	int     usemirror;
+	int usemirror;
 
-	/* return the [row col] of the disk with the shortest queue */
+	/* Return the [row col] of the disk with the shortest queue. */
 	rowData = data_pda->row;
 	colData = data_pda->col;
 	rowMirror = mirror_pda->row;
@@ -1274,12 +1366,12 @@ rf_SelectMirrorDiskPartition(RF_DagNode_t * node)
 	} else
 		if (RF_DEAD_DISK(disks[rowData][colData].status)) {
 			usemirror = 1;
-		} else 
+		} else
 			if (raidPtr->parity_good == RF_RAID_DIRTY) {
-				/* Trust only the main disk */
+				/* Trust only the main disk. */
 				usemirror = 0;
 		} else
-				if (data_pda->startSector < 
+				if (data_pda->startSector <
 				    (disks[rowData][colData].numBlocks / 2)) {
 				usemirror = 0;
 			} else {
@@ -1287,11 +1379,11 @@ rf_SelectMirrorDiskPartition(RF_DagNode_t * node)
 			}
 
 	if (usemirror) {
-		/* use mirror (parity) disk, swap params 0 & 4 */
+		/* 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 */
+		/* Use data disk, leave param 0 unchanged. */
 	}
 }
diff --git a/sys/dev/raidframe/rf_dagutils.h b/sys/dev/raidframe/rf_dagutils.h
index abd3fa8f520..2541363c2e6 100644
--- a/sys/dev/raidframe/rf_dagutils.h
+++ b/sys/dev/raidframe/rf_dagutils.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_dagutils.h,v 1.2 1999/02/16 00:02:33 niklas Exp $	*/
+/*	$OpenBSD: rf_dagutils.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_dagutils.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,95 +28,85 @@
  * rights to redistribute these changes.
  */
 
-/*************************************************************************
+/*****************************************************************************
  *
- * rf_dagutils.h -- header file for utility routines for manipulating DAGs
+ * rf_dagutils.h -- Header file for utility routines for manipulating DAGs.
  *
- *************************************************************************/
+ *****************************************************************************/
 
 
 #include "rf_types.h"
 #include "rf_dagfuncs.h"
 #include "rf_general.h"
 
-#ifndef _RF__RF_DAGUTILS_H_
-#define _RF__RF_DAGUTILS_H_
+#ifndef	_RF__RF_DAGUTILS_H_
+#define	_RF__RF_DAGUTILS_H_
 
 struct RF_RedFuncs_s {
-	int     (*regular) (RF_DagNode_t *);
-	char   *RegularName;
-	int     (*simple) (RF_DagNode_t *);
-	char   *SimpleName;
+	int	(*regular) (RF_DagNode_t *);
+	char	 *RegularName;
+	int	(*simple) (RF_DagNode_t *);
+	char	 *SimpleName;
 };
 
 extern RF_RedFuncs_t rf_xorFuncs;
 extern RF_RedFuncs_t rf_xorRecoveryFuncs;
 
-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 rf_InitNode(RF_DagNode_t *, RF_NodeStatus_t, int, int (*) (RF_DagNode_t *),
+	int (*) (RF_DagNode_t *), int (*) (RF_DagNode_t *, int), int, int, int,
+	int, RF_DagHeader_t *, char *, RF_AllocListElem_t *);
 
-	void    rf_FreeDAG(RF_DagHeader_t * dag_h);
+void rf_FreeDAG(RF_DagHeader_t *);
 
-	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 *rf_MakePropListEntry(RF_DagHeader_t *, int, int,
+RF_PropHeader_t *, RF_AllocListElem_t *);
 
-	int     rf_ConfigureDAGs(RF_ShutdownList_t ** listp);
+int  rf_ConfigureDAGs(RF_ShutdownList_t **);
 
-	RF_DagHeader_t *rf_AllocDAGHeader(void);
+RF_DagHeader_t *rf_AllocDAGHeader(void);
 
-	void    rf_FreeDAGHeader(RF_DagHeader_t * dh);
+void rf_FreeDAGHeader(RF_DagHeader_t *);
 
-	void   *rf_AllocBuffer(RF_Raid_t * raidPtr, RF_DagHeader_t * dag_h,
-            RF_PhysDiskAddr_t * pda, RF_AllocListElem_t * allocList);
+void *rf_AllocBuffer(RF_Raid_t *, RF_DagHeader_t *, RF_PhysDiskAddr_t *,
+	RF_AllocListElem_t *);
 
-	char   *rf_NodeStatusString(RF_DagNode_t * node);
+char *rf_NodeStatusString(RF_DagNode_t *);
 
-	void    rf_PrintNodeInfoString(RF_DagNode_t * node);
+void rf_PrintNodeInfoString(RF_DagNode_t *);
 
-	int     rf_AssignNodeNums(RF_DagHeader_t * dag_h);
+int  rf_AssignNodeNums(RF_DagHeader_t *);
 
-	int     rf_RecurAssignNodeNums(RF_DagNode_t * node, int num, int unvisited);
+int  rf_RecurAssignNodeNums(RF_DagNode_t *, int, int);
 
-	void    rf_ResetDAGHeaderPointers(RF_DagHeader_t * dag_h, RF_DagHeader_t * newptr);
+void rf_ResetDAGHeaderPointers(RF_DagHeader_t *, RF_DagHeader_t *);
 
-	void    rf_RecurResetDAGHeaderPointers(RF_DagNode_t * node, RF_DagHeader_t * newptr);
+void rf_RecurResetDAGHeaderPointers(RF_DagNode_t *, RF_DagHeader_t *);
 
-	void    rf_PrintDAGList(RF_DagHeader_t * dag_h);
+void rf_PrintDAGList(RF_DagHeader_t *);
 
-	int     rf_ValidateDAG(RF_DagHeader_t * dag_h);
+int  rf_ValidateDAG(RF_DagHeader_t *);
 
-	void    rf_redirect_asm(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
+void rf_redirect_asm(RF_Raid_t *, RF_AccessStripeMap_t *);
 
-	void    rf_MapUnaccessedPortionOfStripe(RF_Raid_t * raidPtr,
-            RF_RaidLayout_t * layoutPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h,
-            RF_AccessStripeMapHeader_t ** new_asm_h, int *nRodNodes, char **sosBuffer,
-            char **eosBuffer, RF_AllocListElem_t * allocList);
+void rf_MapUnaccessedPortionOfStripe(RF_Raid_t *, RF_RaidLayout_t *,
+	RF_AccessStripeMap_t *, RF_DagHeader_t *, RF_AccessStripeMapHeader_t **,
+	int *, char **, char **, RF_AllocListElem_t *);
 
-	int     rf_PDAOverlap(RF_RaidLayout_t * layoutPtr, RF_PhysDiskAddr_t * src,
-            RF_PhysDiskAddr_t * dest);
+int  rf_PDAOverlap(RF_RaidLayout_t *, RF_PhysDiskAddr_t *, RF_PhysDiskAddr_t *);
 
-	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);
+void rf_GenerateFailedAccessASMs(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_PhysDiskAddr_t *, RF_DagHeader_t *, RF_AccessStripeMapHeader_t **,
+	int *, char **, char *, RF_AllocListElem_t *);
 
-/* flags used by RangeRestrictPDA */
-#define RF_RESTRICT_NOBUFFER 0
-#define RF_RESTRICT_DOBUFFER 1
+/* Flags used by RangeRestrictPDA. */
+#define	RF_RESTRICT_NOBUFFER	0
+#define	RF_RESTRICT_DOBUFFER	1
 
-	void    rf_RangeRestrictPDA(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * src,
-            RF_PhysDiskAddr_t * dest, int dobuffer, int doraidaddr);
+void rf_RangeRestrictPDA(RF_Raid_t *, RF_PhysDiskAddr_t *, RF_PhysDiskAddr_t *,
+	int, int);
 
-	int     rf_compute_workload_shift(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda);
-	void    rf_SelectMirrorDiskIdle(RF_DagNode_t * node);
-	void    rf_SelectMirrorDiskPartition(RF_DagNode_t * node);
+int  rf_compute_workload_shift(RF_Raid_t *, RF_PhysDiskAddr_t *);
+void rf_SelectMirrorDiskIdle(RF_DagNode_t *);
+void rf_SelectMirrorDiskPartition(RF_DagNode_t *);
 
-#endif				/* !_RF__RF_DAGUTILS_H_ */
+#endif	/* ! _RF__RF_DAGUTILS_H_ */
diff --git a/sys/dev/raidframe/rf_debugMem.c b/sys/dev/raidframe/rf_debugMem.c
index 731986fee9e..c533aba562b 100644
--- a/sys/dev/raidframe/rf_debugMem.c
+++ b/sys/dev/raidframe/rf_debugMem.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_debugMem.c,v 1.4 2000/01/11 18:02:21 peter Exp $	*/
+/*	$OpenBSD: rf_debugMem.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_debugMem.c,v 1.7 2000/01/07 03:40:59 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,18 +28,19 @@
  * rights to redistribute these changes.
  */
 
-/* debugMem.c:  memory usage debugging stuff.
+/*
+ * debugMem.c:  Memory usage debugging stuff.
+ *
  * Malloc, Calloc, and Free are #defined everywhere
  * to do_malloc, do_calloc, and do_free.
  *
- * if RF_UTILITY is nonzero, it means were compiling one of the
- * raidframe utility programs, such as rfctrl or smd.  In this
+ * If RF_UTILITY is nonzero, it means we are compiling one of the
+ * RAIDframe utility programs, such as rfctrl or smd. In this
  * case, we eliminate all references to the threads package
  * and to the allocation list stuff.
  */
 
 #include "rf_types.h"
-
 #include "rf_threadstuff.h"
 #include "rf_options.h"
 #include "rf_debugMem.h"
@@ -46,72 +48,74 @@
 
 static long tot_mem_in_use = 0;
 
-/* Hash table of information about memory allocations */
-#define RF_MH_TABLESIZE 1000
+/* Hash table of information about memory allocations. */
+#define	RF_MH_TABLESIZE		1000
 
 struct mh_struct {
-	void   *address;
-	int     size;
-	int     line;
-	char   *filen;
-	char    allocated;
+	void		*address;
+	int		 size;
+	int		 line;
+	char		*filen;
+	char		 allocated;
 	struct mh_struct *next;
 };
+
 static struct mh_struct *mh_table[RF_MH_TABLESIZE];
-RF_DECLARE_MUTEX(rf_debug_mem_mutex)
-	static int mh_table_initialized = 0;
 
-	static void memory_hash_insert(void *addr, int size, int line, char *filen);
-	static int memory_hash_remove(void *addr, int sz);
+RF_DECLARE_MUTEX(rf_debug_mem_mutex);
+static int mh_table_initialized = 0;
+
+void rf_memory_hash_insert(void *, int, int, char *);
+int  rf_memory_hash_remove(void *, int);
 
-void 
-rf_record_malloc(p, size, line, filen)
-	void   *p;
-	int     size, line;
-	char   *filen;
+void
+rf_record_malloc(void *p, int size, int line, char *filen)
 {
 	RF_ASSERT(size != 0);
 
-	/* RF_LOCK_MUTEX(rf_debug_mem_mutex); */
-	memory_hash_insert(p, size, line, filen);
+	/*RF_LOCK_MUTEX(rf_debug_mem_mutex);*/
+	rf_memory_hash_insert(p, size, line, filen);
 	tot_mem_in_use += size;
-	/* RF_UNLOCK_MUTEX(rf_debug_mem_mutex); */
+	/*RF_UNLOCK_MUTEX(rf_debug_mem_mutex);*/
+
 	if ((long) p == rf_memDebugAddress) {
-		printf("Allocate: debug address allocated from line %d file %s\n", line, filen);
+		printf("Allocate: debug address allocated from line %d file"
+		    " %s\n", line, filen);
 	}
 }
 
-void 
-rf_unrecord_malloc(p, sz)
-	void   *p;
-	int     sz;
+void
+rf_unrecord_malloc(void *p, int sz)
 {
-	int     size;
+	int size;
 
-	/* RF_LOCK_MUTEX(rf_debug_mem_mutex); */
-	size = memory_hash_remove(p, sz);
+	/*RF_LOCK_MUTEX(rf_debug_mem_mutex);*/
+	size = rf_memory_hash_remove(p, sz);
 	tot_mem_in_use -= size;
-	/* RF_UNLOCK_MUTEX(rf_debug_mem_mutex); */
+	/*RF_UNLOCK_MUTEX(rf_debug_mem_mutex);*/
 	if ((long) p == rf_memDebugAddress) {
-		printf("Free: Found debug address\n");	/* this is really only a
-							 * flag line for gdb */
+		/* This is really only a flag line for gdb. */
+		printf("Free: Found debug address\n");
 	}
 }
 
-void 
-rf_print_unfreed()
+void
+rf_print_unfreed(void)
 {
-	int     i, foundone = 0;
+	int i, foundone = 0;
 	struct mh_struct *p;
 
 	for (i = 0; i < RF_MH_TABLESIZE; i++) {
 		for (p = mh_table[i]; p; p = p->next)
 			if (p->allocated) {
 				if (!foundone)
-					printf("\n\nThere are unfreed memory locations at program shutdown:\n");
+					printf("\n\nThere are unfreed"
+					    " memory locations at"
+					    " program shutdown:\n");
 				foundone = 1;
 				printf("Addr 0x%lx Size %d line %d file %s\n",
-				    (long) p->address, p->size, p->line, p->filen);
+				    (long) p->address, p->size, p->line,
+				    p->filen);
 			}
 	}
 	if (tot_mem_in_use) {
@@ -119,16 +123,15 @@ rf_print_unfreed()
 	}
 }
 
-int 
-rf_ConfigureDebugMem(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureDebugMem(RF_ShutdownList_t **listp)
 {
-	int     i, rc;
+	int i, rc;
 
 	rc = rf_create_managed_mutex(listp, &rf_debug_mem_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);
 	}
 	if (rf_memDebug) {
@@ -138,20 +141,18 @@ rf_ConfigureDebugMem(listp)
 	}
 	return (0);
 }
-#define HASHADDR(_a_)      ( (((unsigned long) _a_)>>3) % RF_MH_TABLESIZE )
 
-static void 
-memory_hash_insert(addr, size, line, filen)
-	void   *addr;
-	int     size, line;
-	char   *filen;
+#define	HASHADDR(_a_)	( (((unsigned long) _a_)>>3) % RF_MH_TABLESIZE )
+
+void
+rf_memory_hash_insert(void *addr, int size, int line, char *filen)
 {
 	unsigned long bucket = HASHADDR(addr);
 	struct mh_struct *p;
 
 	RF_ASSERT(mh_table_initialized);
 
-	/* search for this address in the hash table */
+	/* Search for this address in the hash table. */
 	for (p = mh_table[bucket]; p && (p->address != addr); p = p->next);
 	if (!p) {
 		RF_Malloc(p, sizeof(struct mh_struct), (struct mh_struct *));
@@ -162,8 +163,11 @@ memory_hash_insert(addr, size, line, filen)
 		p->allocated = 0;
 	}
 	if (p->allocated) {
-		printf("ERROR:  reallocated address 0x%lx from line %d, file %s without intervening free\n", (long) addr, line, filen);
-		printf("        last allocated from line %d file %s\n", p->line, p->filen);
+		printf("ERROR:  Reallocated address 0x%lx from line %d,"
+		    " file %s without intervening free\n", (long) addr,
+		    line, filen);
+		printf("        Last allocated from line %d file %s\n",
+		    p->line, p->filen);
 		RF_ASSERT(0);
 	}
 	p->size = size;
@@ -172,10 +176,8 @@ memory_hash_insert(addr, size, line, filen)
 	p->allocated = 1;
 }
 
-static int 
-memory_hash_remove(addr, sz)
-	void   *addr;
-	int     sz;
+int
+rf_memory_hash_remove(void *addr, int sz)
 {
 	unsigned long bucket = HASHADDR(addr);
 	struct mh_struct *p;
@@ -183,17 +185,24 @@ memory_hash_remove(addr, sz)
 	RF_ASSERT(mh_table_initialized);
 	for (p = mh_table[bucket]; p && (p->address != addr); p = p->next);
 	if (!p) {
-		printf("ERROR:  freeing never-allocated address 0x%lx\n", (long) addr);
+		printf("ERROR:  Freeing never-allocated address 0x%lx\n",
+		    (long) addr);
 		RF_PANIC();
 	}
 	if (!p->allocated) {
-		printf("ERROR:  freeing unallocated address 0x%lx.  Last allocation line %d file %s\n", (long) addr, p->line, p->filen);
+		printf("ERROR:  Freeing unallocated address 0x%lx."
+		    "  Last allocation line %d file %s\n", (long) addr,
+		    p->line, p->filen);
 		RF_PANIC();
 	}
-	if (sz > 0 && p->size != sz) {	/* you can suppress this error by
-					 * using a negative value as the size
-					 * to free */
-		printf("ERROR:  incorrect size at free for address 0x%lx: is %d should be %d.  Alloc at line %d of file %s\n", (unsigned long) addr, sz, p->size, p->line, p->filen);
+	if (sz > 0 && p->size != sz) {
+		/*
+		 * This error can be suppressed by using a negative value
+		 * as the size to free.
+		 */
+		printf("ERROR:  Incorrect size at free for address 0x%lx:"
+		    " is %d should be %d.  Alloc at line %d of file %s\n",
+		    (unsigned long) addr, sz, p->size, p->line, p->filen);
 		RF_PANIC();
 	}
 	p->allocated = 0;
diff --git a/sys/dev/raidframe/rf_debugMem.h b/sys/dev/raidframe/rf_debugMem.h
index d189fb46224..a22b9dc5917 100644
--- a/sys/dev/raidframe/rf_debugMem.h
+++ b/sys/dev/raidframe/rf_debugMem.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_debugMem.h,v 1.4 2000/01/07 14:50:20 peter Exp $	*/
+/*	$OpenBSD: rf_debugMem.h,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_debugMem.h,v 1.7 1999/09/05 01:58:11 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,57 +29,53 @@
  */
 
 /*
- * rf_debugMem.h -- memory leak debugging module
+ * rf_debugMem.h -- Memory leak debugging module.
  *
- * IMPORTANT:  if you put the lock/unlock mutex stuff back in here, you
- *             need to take it out of the routines in debugMem.c
+ * IMPORTANT:	If you put the lock/unlock mutex stuff back in here, you
+ *		need to take it out of the routines in debugMem.c
  *
  */
 
-#ifndef _RF__RF_DEBUGMEM_H_
-#define _RF__RF_DEBUGMEM_H_
+#ifndef	_RF__RF_DEBUGMEM_H_
+#define	_RF__RF_DEBUGMEM_H_
 
 #include "rf_alloclist.h"
 
-#ifdef _KERNEL
+#ifdef	_KERNEL
 #include <sys/types.h>
 #include <sys/malloc.h>
 
-#define RF_Malloc(_p_, _size_, _cast_)                                      \
-  {                                                                      \
-     _p_ = _cast_ malloc((u_long)_size_, M_RAIDFRAME, M_WAITOK); \
-     bzero((char *)_p_, _size_); \
-     if (rf_memDebug) rf_record_malloc(_p_, _size_, __LINE__, __FILE__);       \
-  }
+#define	RF_Malloc(_p_,_size_,_cast_)	do {				\
+	_p_ = _cast_ malloc((u_long)_size_, M_RAIDFRAME, M_WAITOK);	\
+	bzero((char *)_p_, _size_);					\
+	if (rf_memDebug)						\
+	    rf_record_malloc(_p_, _size_, __LINE__, __FILE__);		\
+} while (0)
 
-#define RF_MallocAndAdd(__p_, __size_, __cast_, __alist_)                   \
-  {                                                                      \
-     RF_Malloc(__p_, __size_, __cast_);                                     \
-     if (__alist_) rf_AddToAllocList(__alist_, __p_, __size_);              \
-  }
+#define	RF_MallocAndAdd(__p_,__size_,__cast_,__alist_)	do {	\
+	RF_Malloc(__p_, __size_, __cast_);				\
+	if (__alist_) rf_AddToAllocList(__alist_, __p_, __size_);	\
+} while (0)
 
-#define RF_Calloc(_p_, _nel_, _elsz_, _cast_)                               \
-  {                                                                      \
-     RF_Malloc( _p_, (_nel_) * (_elsz_), _cast_);                           \
-   }
+#define	RF_Calloc(_p_,_nel_,_elsz_,_cast_)				\
+	RF_Malloc( _p_, (_nel_) * (_elsz_), _cast_);
 
-#define RF_CallocAndAdd(__p,__nel,__elsz,__cast,__alist)                     \
-  {                                                                       \
-     RF_Calloc(__p, __nel, __elsz, __cast);                                  \
-     if (__alist) rf_AddToAllocList(__alist, __p, (__nel)*(__elsz));         \
-  }
+#define	RF_CallocAndAdd(__p,__nel,__elsz,__cast,__alist)	do {	\
+	RF_Calloc(__p, __nel, __elsz, __cast);				\
+	if (__alist)							\
+	    rf_AddToAllocList(__alist, __p, (__nel)*(__elsz));		\
+} while (0)
 
-#define RF_Free(_p_, _sz_)                                                   \
-  {                                                                       \
-	free((void *)(_p_), M_RAIDFRAME);                                      \
-     if (rf_memDebug) rf_unrecord_malloc(_p_, (u_int32_t) (_sz_));          \
-  }
+#define	RF_Free(_p_,_sz_)	do {					\
+	free((void *)(_p_), M_RAIDFRAME);				\
+	if (rf_memDebug) rf_unrecord_malloc(_p_, (u_int32_t) (_sz_));	\
+} while (0)
 
-#endif				/* _KERNEL */
+#endif	/* _KERNEL */
 
-void    rf_record_malloc(void *p, int size, int line, char *filen);
-void    rf_unrecord_malloc(void *p, int sz);
-void    rf_print_unfreed(void);
-int     rf_ConfigureDebugMem(RF_ShutdownList_t ** listp);
+void rf_record_malloc(void *, int, int, char *);
+void rf_unrecord_malloc(void *, int);
+void rf_print_unfreed(void);
+int  rf_ConfigureDebugMem(RF_ShutdownList_t **);
 
-#endif				/* !_RF__RF_DEBUGMEM_H_ */
+#endif	/* ! _RF__RF_DEBUGMEM_H_ */
diff --git a/sys/dev/raidframe/rf_debugprint.c b/sys/dev/raidframe/rf_debugprint.c
index f6546c135f8..93b0f7b1694 100644
--- a/sys/dev/raidframe/rf_debugprint.c
+++ b/sys/dev/raidframe/rf_debugprint.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_debugprint.c,v 1.2 1999/02/16 00:02:34 niklas Exp $	*/
+/*	$OpenBSD: rf_debugprint.c,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_debugprint.c,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -43,48 +44,50 @@
 #include <sys/param.h>
 
 struct RF_Entry_s {
-	char   *cstring;
-	void   *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
+	char	*cstring;
+	void	*a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
 };
+
 /* space for 1k lines */
-#define BUFSHIFT 10
-#define BUFSIZE  (1<<BUFSHIFT)
-#define BUFMASK  (BUFSIZE-1)
+#define	BUFSHIFT		   10
+#define	BUFSIZE		(1<<BUFSHIFT)
+#define	BUFMASK		  (BUFSIZE-1)
 
 static struct RF_Entry_s rf_debugprint_buf[BUFSIZE];
 static int rf_debugprint_index = 0;
-RF_DECLARE_STATIC_MUTEX(rf_debug_print_mutex)
-	int     rf_ConfigureDebugPrint(listp)
-	RF_ShutdownList_t **listp;
+RF_DECLARE_STATIC_MUTEX(rf_debug_print_mutex);
+
+int
+rf_ConfigureDebugPrint(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_create_managed_mutex(listp, &rf_debug_print_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);
 	}
+
 	rf_clear_debug_print_buffer();
 	return (0);
 }
 
-void 
-rf_clear_debug_print_buffer()
+void
+rf_clear_debug_print_buffer(void)
 {
-	int     i;
+	int i;
 
 	for (i = 0; i < BUFSIZE; i++)
 		rf_debugprint_buf[i].cstring = NULL;
 	rf_debugprint_index = 0;
 }
 
-void 
-rf_debug_printf(s, a1, a2, a3, a4, a5, a6, a7, a8)
-	char   *s;
-	void   *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
+void
+rf_debug_printf(char *s, void *a1, void *a2, void *a3, void *a4, void *a5,
+    void *a6, void *a7, void *a8)
 {
-	int     idx;
+	int idx;
 
 	if (rf_debugPrintUseBuffer) {
 
@@ -107,28 +110,36 @@ rf_debug_printf(s, a1, a2, a3, a4, a5, a6, a7, a8)
 	}
 }
 
-void 
-rf_print_debug_buffer()
+void
+rf_print_debug_buffer(void)
 {
 	rf_spill_debug_buffer(NULL);
 }
 
-void 
-rf_spill_debug_buffer(fname)
-	char   *fname;
+void
+rf_spill_debug_buffer(char *fname)
 {
-	int     i;
+	int i;
 
 	if (!rf_debugPrintUseBuffer)
 		return;
 
 	RF_LOCK_MUTEX(rf_debug_print_mutex);
 
-	for (i = rf_debugprint_index + 1; i != rf_debugprint_index; i = (i + 1) & BUFMASK)
+	for (i = rf_debugprint_index + 1; i != rf_debugprint_index;
+	     i = (i + 1) & BUFMASK)
 		if (rf_debugprint_buf[i].cstring)
-			printf(rf_debugprint_buf[i].cstring, rf_debugprint_buf[i].a1, rf_debugprint_buf[i].a2, rf_debugprint_buf[i].a3,
-			    rf_debugprint_buf[i].a4, rf_debugprint_buf[i].a5, rf_debugprint_buf[i].a6, rf_debugprint_buf[i].a7, rf_debugprint_buf[i].a8);
-	printf(rf_debugprint_buf[i].cstring, rf_debugprint_buf[i].a1, rf_debugprint_buf[i].a2, rf_debugprint_buf[i].a3,
-	    rf_debugprint_buf[i].a4, rf_debugprint_buf[i].a5, rf_debugprint_buf[i].a6, rf_debugprint_buf[i].a7, rf_debugprint_buf[i].a8);
+			printf(rf_debugprint_buf[i].cstring,
+			    rf_debugprint_buf[i].a1, rf_debugprint_buf[i].a2,
+			    rf_debugprint_buf[i].a3, rf_debugprint_buf[i].a4,
+			    rf_debugprint_buf[i].a5, rf_debugprint_buf[i].a6,
+			    rf_debugprint_buf[i].a7, rf_debugprint_buf[i].a8);
+
+	printf(rf_debugprint_buf[i].cstring,
+	    rf_debugprint_buf[i].a1, rf_debugprint_buf[i].a2,
+	    rf_debugprint_buf[i].a3, rf_debugprint_buf[i].a4,
+	    rf_debugprint_buf[i].a5, rf_debugprint_buf[i].a6,
+	    rf_debugprint_buf[i].a7, rf_debugprint_buf[i].a8);
+
 	RF_UNLOCK_MUTEX(rf_debug_print_mutex);
 }
diff --git a/sys/dev/raidframe/rf_debugprint.h b/sys/dev/raidframe/rf_debugprint.h
index a0d1168f863..e03d1716ba3 100644
--- a/sys/dev/raidframe/rf_debugprint.h
+++ b/sys/dev/raidframe/rf_debugprint.h
@@ -1,8 +1,10 @@
-/*	$OpenBSD: rf_debugprint.h,v 1.2 1999/02/16 00:02:34 niklas Exp $	*/
+/*	$OpenBSD: rf_debugprint.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_debugprint.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
+
 /*
  * rf_debugprint.h
  */
+
 /*
  * Copyright (c) 1996 Carnegie-Mellon University.
  * All rights reserved.
@@ -30,15 +32,14 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_DEBUGPRINT_H_
-#define _RF__RF_DEBUGPRINT_H_
+#ifndef	_RF__RF_DEBUGPRINT_H_
+#define	_RF__RF_DEBUGPRINT_H_
 
-int     rf_ConfigureDebugPrint(RF_ShutdownList_t ** listp);
-void    rf_clear_debug_print_buffer(void);
-void 
-rf_debug_printf(char *s, void *a1, void *a2, void *a3, void *a4,
-    void *a5, void *a6, void *a7, void *a8);
-void    rf_print_debug_buffer(void);
-void    rf_spill_debug_buffer(char *fname);
+int  rf_ConfigureDebugPrint(RF_ShutdownList_t **);
+void rf_clear_debug_print_buffer(void);
+void rf_debug_printf(char *, void *, void *, void *, void *, void *, void *,
+	void *, void *);
+void rf_print_debug_buffer(void);
+void rf_spill_debug_buffer(char *);
 
-#endif				/* !_RF__RF_DEBUGPRINT_H_ */
+#endif	/* ! _RF__RF_DEBUGPRINT_H_ */
diff --git a/sys/dev/raidframe/rf_decluster.c b/sys/dev/raidframe/rf_decluster.c
index 3cae0d27f59..3568a03f4a7 100644
--- a/sys/dev/raidframe/rf_decluster.c
+++ b/sys/dev/raidframe/rf_decluster.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_decluster.c,v 1.4 2000/08/08 16:07:40 peter Exp $	*/
+/*	$OpenBSD: rf_decluster.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_decluster.c,v 1.5 2000/03/07 01:54:29 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,26 +28,26 @@
  * rights to redistribute these changes.
  */
 
-/*----------------------------------------------------------------------
+/*****************************************************************************
  *
- * rf_decluster.c -- code related to the declustered layout
+ * rf_decluster.c -- Code related to the declustered layout.
  *
  * Created 10-21-92 (MCH)
  *
- * Nov 93:  adding support for distributed sparing.  This code is a little
- *          complex:  the basic layout used is as follows:
- *          let F = (v-1)/GCD(r,v-1).  The spare space for each set of
- *          F consecutive fulltables is grouped together and placed after
- *          that set of tables.
- *                   +------------------------------+
- *                   |        F fulltables          |
- *                   |        Spare Space           |
- *                   |        F fulltables          |
- *                   |        Spare Space           |
- *                   |            ...               |
- *                   +------------------------------+
+ * Nov 93:	Adding support for distributed sparing. This code is a little
+ *		complex; the basic layout used is as follows:
+ *		Let F = (v-1)/GCD(r,v-1). The spare space for each set of
+ *		F consecutive fulltables is grouped together and placed after
+ *		that set of tables.
+ *			+-------------------------------+
+ *			|	  F fulltables		|
+ *			|	  Spare Space		|
+ *			|	  F fulltables		|
+ *			|	  Spare Space		|
+ *			|	      ...		|
+ *			+-------------------------------+
  *
- *--------------------------------------------------------------------*/
+ *****************************************************************************/
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -59,46 +60,45 @@
 #include "rf_general.h"
 #include "rf_shutdown.h"
 
-extern int rf_copyback_in_progress;	/* debug only */
+extern int rf_copyback_in_progress;	/* Debug only. */
 
-/* found in rf_kintf.c */
-int     rf_GetSpareTableFromDaemon(RF_SparetWait_t * req);
+/* Found in rf_kintf.c */
+int  rf_GetSpareTableFromDaemon(RF_SparetWait_t *);
 
-/* configuration code */
+/* Configuration code. */
 
-int 
-rf_ConfigureDeclustered(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureDeclustered(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	int     b, v, k, r, lambda;	/* block design params */
-	int     i, j;
+	int b, v, k, r, lambda;	/* block design params */
+	int i, j;
 	RF_RowCol_t *first_avail_slot;
 	RF_StripeCount_t complete_FT_count, numCompleteFullTablesPerDisk;
 	RF_DeclusteredConfigInfo_t *info;
-	RF_StripeCount_t PUsPerDisk, spareRegionDepthInPUs, numCompleteSpareRegionsPerDisk,
-	        extraPUsPerDisk;
+	RF_StripeCount_t PUsPerDisk, spareRegionDepthInPUs,
+	    numCompleteSpareRegionsPerDisk, extraPUsPerDisk;
 	RF_StripeCount_t totSparePUsPerDisk;
 	RF_SectorNum_t diskOffsetOfLastFullTableInSUs;
 	RF_SectorCount_t SpareSpaceInSUs;
-	char   *cfgBuf = (char *) (cfgPtr->layoutSpecific);
+	char *cfgBuf = (char *) (cfgPtr->layoutSpecific);
 	RF_StripeNum_t l, SUID;
 
 	SUID = l = 0;
 	numCompleteSpareRegionsPerDisk = 0;
 
-	/* 1. create layout specific structure */
-	RF_MallocAndAdd(info, sizeof(RF_DeclusteredConfigInfo_t), (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
+	/* 1. Create layout specific structure. */
+	RF_MallocAndAdd(info, sizeof(RF_DeclusteredConfigInfo_t),
+	    (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 	info->SpareTable = NULL;
 
-	/* 2. extract parameters from the config structure */
+	/* 2. Extract parameters from the config structure. */
 	if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {
-		(void) bcopy(cfgBuf, info->sparemap_fname, RF_SPAREMAP_NAME_LEN);
+		bcopy(cfgBuf, info->sparemap_fname, RF_SPAREMAP_NAME_LEN);
 	}
 	cfgBuf += RF_SPAREMAP_NAME_LEN;
 
@@ -115,132 +115,181 @@ rf_ConfigureDeclustered(
 	raidPtr->noRotate = *((int *) cfgBuf);
 	cfgBuf += sizeof(int);
 
-	/* the sparemaps are generated assuming that parity is rotated, so we
+	/*
+	 * The sparemaps are generated assuming that parity is rotated, so we
 	 * issue a warning if both distributed sparing and no-rotate are on at
-	 * the same time */
-	if ((layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) && raidPtr->noRotate) {
-		RF_ERRORMSG("Warning:  distributed sparing specified without parity rotation.\n");
+	 * the same time.
+	 */
+	if ((layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) &&
+	    raidPtr->noRotate) {
+		RF_ERRORMSG("Warning:  distributed sparing specified without"
+		    " parity rotation.\n");
 	}
 	if (raidPtr->numCol != v) {
-		RF_ERRORMSG2("RAID: config error: table element count (%d) not equal to no. of cols (%d)\n", v, raidPtr->numCol);
+		RF_ERRORMSG2("RAID: config error: table element count (%d)"
+		    " not equal to no. of cols (%d).\n", v, raidPtr->numCol);
 		return (EINVAL);
 	}
-	/* 3.  set up the values used in the mapping code */
+	/* 3. Set up the values used in the mapping code. */
 	info->BlocksPerTable = b;
 	info->Lambda = lambda;
 	info->NumParityReps = info->groupSize = k;
-	info->SUsPerTable = b * (k - 1) * layoutPtr->SUsPerPU;	/* b blks, k-1 SUs each */
+	/* b blks, k-1 SUs each. */
+	info->SUsPerTable = b * (k - 1) * layoutPtr->SUsPerPU;
 	info->SUsPerFullTable = k * info->SUsPerTable;	/* rot k times */
 	info->PUsPerBlock = k - 1;
 	info->SUsPerBlock = info->PUsPerBlock * layoutPtr->SUsPerPU;
 	info->TableDepthInPUs = (b * k) / v;
-	info->FullTableDepthInPUs = info->TableDepthInPUs * k;	/* k repetitions */
+	/* k repetitions. */
+	info->FullTableDepthInPUs = info->TableDepthInPUs * k;
 
-	/* used only in distributed sparing case */
-	info->FullTablesPerSpareRegion = (v - 1) / rf_gcd(r, v - 1);	/* (v-1)/gcd fulltables */
+	/* Used only in distributed sparing case. */
+	/* (v-1)/gcd fulltables. */
+	info->FullTablesPerSpareRegion = (v - 1) / rf_gcd(r, v - 1);
 	info->TablesPerSpareRegion = k * info->FullTablesPerSpareRegion;
-	info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion / (v - 1)) * layoutPtr->SUsPerPU;
+	info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion /
+	    (v - 1)) * layoutPtr->SUsPerPU;
 
-	/* check to make sure the block design is sufficiently small */
+	/* Check to make sure the block design is sufficiently small. */
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		if (info->FullTableDepthInPUs * layoutPtr->SUsPerPU + info->SpareSpaceDepthPerRegionInSUs > layoutPtr->stripeUnitsPerDisk) {
-			RF_ERRORMSG3("RAID: config error: Full Table depth (%d) + Spare Space (%d) larger than disk size (%d) (BD too big)\n",
+		if (info->FullTableDepthInPUs * layoutPtr->SUsPerPU +
+		    info->SpareSpaceDepthPerRegionInSUs >
+		    layoutPtr->stripeUnitsPerDisk) {
+			RF_ERRORMSG3("RAID: config error: Full Table depth"
+			    " (%d) + Spare Space (%d) larger than disk size"
+			    " (%d) (BD too big).\n",
 			    (int) info->FullTableDepthInPUs,
 			    (int) info->SpareSpaceDepthPerRegionInSUs,
 			    (int) layoutPtr->stripeUnitsPerDisk);
 			return (EINVAL);
 		}
 	} else {
-		if (info->TableDepthInPUs * layoutPtr->SUsPerPU > layoutPtr->stripeUnitsPerDisk) {
-			RF_ERRORMSG2("RAID: config error: Table depth (%d) larger than disk size (%d) (BD too big)\n",
-			    (int) (info->TableDepthInPUs * layoutPtr->SUsPerPU), \
+		if (info->TableDepthInPUs * layoutPtr->SUsPerPU >
+		    layoutPtr->stripeUnitsPerDisk) {
+			RF_ERRORMSG2("RAID: config error: Table depth (%d)"
+			    " larger than disk size (%d) (BD too big).\n",
+			    (int) (info->TableDepthInPUs * layoutPtr->SUsPerPU),
 			    (int) layoutPtr->stripeUnitsPerDisk);
 			return (EINVAL);
 		}
 	}
 
 
-	/* compute the size of each disk, and the number of tables in the last
-	 * fulltable (which need not be complete) */
+	/*
+	 * Compute the size of each disk, and the number of tables in the last
+	 * fulltable (which need not be complete).
+	 */
 	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
 
-		PUsPerDisk = layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU;
-		spareRegionDepthInPUs = (info->TablesPerSpareRegion * info->TableDepthInPUs +
-		    (info->TablesPerSpareRegion * info->TableDepthInPUs) / (v - 1));
-		info->SpareRegionDepthInSUs = spareRegionDepthInPUs * layoutPtr->SUsPerPU;
-
-		numCompleteSpareRegionsPerDisk = PUsPerDisk / spareRegionDepthInPUs;
+		PUsPerDisk = layoutPtr->stripeUnitsPerDisk /
+		    layoutPtr->SUsPerPU;
+		spareRegionDepthInPUs =
+		    (info->TablesPerSpareRegion * info->TableDepthInPUs +
+		    (info->TablesPerSpareRegion * info->TableDepthInPUs) /
+		    (v - 1));
+		info->SpareRegionDepthInSUs =
+		    spareRegionDepthInPUs * layoutPtr->SUsPerPU;
+
+		numCompleteSpareRegionsPerDisk =
+		    PUsPerDisk / spareRegionDepthInPUs;
 		info->NumCompleteSRs = numCompleteSpareRegionsPerDisk;
 		extraPUsPerDisk = PUsPerDisk % spareRegionDepthInPUs;
 
-		/* assume conservatively that we need the full amount of spare
+		/*
+		 * Assume conservatively that we need the full amount of spare
 		 * space in one region in order to provide spares for the
-		 * partial spare region at the end of the array.  We set "i"
-		 * to the number of tables in the partial spare region.  This
-		 * may actually include some fulltables. */
-		extraPUsPerDisk -= (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
+		 * partial spare region at the end of the array. We set "i"
+		 * to the number of tables in the partial spare region. This
+		 * may actually include some fulltables.
+		 */
+		extraPUsPerDisk -= (info->SpareSpaceDepthPerRegionInSUs /
+		    layoutPtr->SUsPerPU);
 		if (extraPUsPerDisk <= 0)
 			i = 0;
 		else
 			i = extraPUsPerDisk / info->TableDepthInPUs;
 
-		complete_FT_count = raidPtr->numRow * (numCompleteSpareRegionsPerDisk * (info->TablesPerSpareRegion / k) + i / k);
-		info->FullTableLimitSUID = complete_FT_count * info->SUsPerFullTable;
+		complete_FT_count = raidPtr->numRow *
+		    (numCompleteSpareRegionsPerDisk *
+		    (info->TablesPerSpareRegion / k) + i / k);
+		info->FullTableLimitSUID =
+		    complete_FT_count * info->SUsPerFullTable;
 		info->ExtraTablesPerDisk = i % k;
 
-		/* note that in the last spare region, the spare space is
-		 * complete even though data/parity space is not */
-		totSparePUsPerDisk = (numCompleteSpareRegionsPerDisk + 1) * (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
+		/*
+		 * Note that in the last spare region, the spare space is
+		 * complete even though data/parity space is not.
+		 */
+		totSparePUsPerDisk = (numCompleteSpareRegionsPerDisk + 1) *
+		    (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
 		info->TotSparePUsPerDisk = totSparePUsPerDisk;
 
 		layoutPtr->stripeUnitsPerDisk =
-		    ((complete_FT_count / raidPtr->numRow) * info->FullTableDepthInPUs +	/* data & parity space */
+		    ((complete_FT_count / raidPtr->numRow) *
+		    info->FullTableDepthInPUs +	/* data & parity space */
 		    info->ExtraTablesPerDisk * info->TableDepthInPUs +
-		    totSparePUsPerDisk	/* spare space */
+		    totSparePUsPerDisk		/* spare space */
 		    ) * layoutPtr->SUsPerPU;
 		layoutPtr->dataStripeUnitsPerDisk =
-		    (complete_FT_count * info->FullTableDepthInPUs + info->ExtraTablesPerDisk * info->TableDepthInPUs)
-		    * layoutPtr->SUsPerPU * (k - 1) / k;
+		    (complete_FT_count * info->FullTableDepthInPUs +
+		    info->ExtraTablesPerDisk * info->TableDepthInPUs) *
+		    layoutPtr->SUsPerPU * (k - 1) / k;
 
 	} else {
-		/* non-dist spare case:  force each disk to contain an
-		 * integral number of tables */
-		layoutPtr->stripeUnitsPerDisk /= (info->TableDepthInPUs * layoutPtr->SUsPerPU);
-		layoutPtr->stripeUnitsPerDisk *= (info->TableDepthInPUs * layoutPtr->SUsPerPU);
+		/*
+		 * Non-dist spare case:  force each disk to contain an
+		 * integral number of tables.
+		 */
+		layoutPtr->stripeUnitsPerDisk /=
+		    (info->TableDepthInPUs * layoutPtr->SUsPerPU);
+		layoutPtr->stripeUnitsPerDisk *=
+		    (info->TableDepthInPUs * layoutPtr->SUsPerPU);
 
-		/* compute the number of tables in the last fulltable, which
-		 * need not be complete */
+		/*
+		 * Compute the number of tables in the last fulltable, which
+		 * need not be complete.
+		 */
 		complete_FT_count =
-		    ((layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU) / info->FullTableDepthInPUs) * raidPtr->numRow;
+		    ((layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU) /
+		    info->FullTableDepthInPUs) * raidPtr->numRow;
 
-		info->FullTableLimitSUID = complete_FT_count * info->SUsPerFullTable;
+		info->FullTableLimitSUID =
+		    complete_FT_count * info->SUsPerFullTable;
 		info->ExtraTablesPerDisk =
-		    ((layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU) / info->TableDepthInPUs) % k;
+		    ((layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU) /
+		    info->TableDepthInPUs) % k;
 	}
 
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
+		    layoutPtr->sectorsPerStripeUnit;
 
-	/* find the disk offset of the stripe unit where the last fulltable
-	 * starts */
+	/*
+	 * Find the disk offset of the stripe unit where the last fulltable
+	 * starts.
+	 */
 	numCompleteFullTablesPerDisk = complete_FT_count / raidPtr->numRow;
-	diskOffsetOfLastFullTableInSUs = numCompleteFullTablesPerDisk * info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	diskOffsetOfLastFullTableInSUs = numCompleteFullTablesPerDisk *
+	    info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
 	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
-		SpareSpaceInSUs = numCompleteSpareRegionsPerDisk * info->SpareSpaceDepthPerRegionInSUs;
+		SpareSpaceInSUs = numCompleteSpareRegionsPerDisk *
+		    info->SpareSpaceDepthPerRegionInSUs;
 		diskOffsetOfLastFullTableInSUs += SpareSpaceInSUs;
 		info->DiskOffsetOfLastSpareSpaceChunkInSUs =
-		    diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU;
+		    diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk *
+		    info->TableDepthInPUs * layoutPtr->SUsPerPU;
 	}
 	info->DiskOffsetOfLastFullTableInSUs = diskOffsetOfLastFullTableInSUs;
 	info->numCompleteFullTablesPerDisk = numCompleteFullTablesPerDisk;
 
-	/* 4.  create and initialize the lookup tables */
+	/* 4. Create and initialize the lookup tables. */
 	info->LayoutTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
 	if (info->LayoutTable == NULL)
 		return (ENOMEM);
 	info->OffsetTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
 	if (info->OffsetTable == NULL)
 		return (ENOMEM);
-	info->BlockTable = rf_make_2d_array(info->TableDepthInPUs * layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
+	info->BlockTable = rf_make_2d_array(info->TableDepthInPUs *
+	    layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
 	if (info->BlockTable == NULL)
 		return (ENOMEM);
 
@@ -252,18 +301,20 @@ rf_ConfigureDeclustered(
 		for (j = 0; j < k; j++)
 			info->LayoutTable[i][j] = *cfgBuf++;
 
-	/* initialize offset table */
+	/* Initialize the offset table. */
 	for (i = 0; i < b; i++)
 		for (j = 0; j < k; j++) {
-			info->OffsetTable[i][j] = first_avail_slot[info->LayoutTable[i][j]];
+			info->OffsetTable[i][j] =
+			    first_avail_slot[info->LayoutTable[i][j]];
 			first_avail_slot[info->LayoutTable[i][j]]++;
 		}
 
-	/* initialize block table */
+	/* Initialize the block table. */
 	for (SUID = l = 0; l < layoutPtr->SUsPerPU; l++) {
 		for (i = 0; i < b; i++) {
 			for (j = 0; j < k; j++) {
-				info->BlockTable[(info->OffsetTable[i][j] * layoutPtr->SUsPerPU) + l]
+				info->BlockTable[(info->OffsetTable[i][j] *
+				    layoutPtr->SUsPerPU) + l]
 				    [info->LayoutTable[i][j]] = SUID;
 			}
 			SUID++;
@@ -272,85 +323,91 @@ rf_ConfigureDeclustered(
 
 	rf_free_1d_array(first_avail_slot, v);
 
-	/* 5.  set up the remaining redundant-but-useful parameters */
+	/* 5. Set up the remaining redundant-but-useful parameters. */
 
-	raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow * info->ExtraTablesPerDisk) *
-	    info->SUsPerTable * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numStripe = (raidPtr->totalSectors / layoutPtr->sectorsPerStripeUnit) / (k - 1);
+	raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow *
+	    info->ExtraTablesPerDisk) * info->SUsPerTable *
+	    layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->numStripe = (raidPtr->totalSectors /
+	    layoutPtr->sectorsPerStripeUnit) / (k - 1);
 
-	/* strange evaluation order below to try and minimize overflow
-	 * problems */
-
-	layoutPtr->dataSectorsPerStripe = (k - 1) * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	/*
+	 * Strange evaluation order below to try and minimize overflow
+	 * problems.
+	 */
+
+	layoutPtr->dataSectorsPerStripe =
+	    (k - 1) * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = k - 1;
 	layoutPtr->numParityCol = 1;
 
 	return (0);
 }
-/* declustering with distributed sparing */
-static void rf_ShutdownDeclusteredDS(RF_ThreadArg_t);
-static void 
-rf_ShutdownDeclusteredDS(arg)
-	RF_ThreadArg_t arg;
+
+/* Declustering with distributed sparing. */
+void rf_ShutdownDeclusteredDS(RF_ThreadArg_t);
+void
+rf_ShutdownDeclusteredDS(RF_ThreadArg_t arg)
 {
 	RF_DeclusteredConfigInfo_t *info;
 	RF_Raid_t *raidPtr;
 
 	raidPtr = (RF_Raid_t *) arg;
-	info = (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	info =
+	    (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 	if (info->SpareTable)
 		rf_FreeSpareTable(raidPtr);
 }
 
-int 
-rf_ConfigureDeclusteredDS(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureDeclusteredDS(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_ConfigureDeclustered(listp, raidPtr, cfgPtr);
 	if (rc)
 		return (rc);
+
 	rc = rf_ShutdownCreate(listp, rf_ShutdownDeclusteredDS, raidPtr);
 	if (rc) {
-		RF_ERRORMSG1("Got %d adding shutdown event for DeclusteredDS\n", rc);
+		RF_ERRORMSG1("Got %d adding shutdown event for"
+		    " DeclusteredDS.\n", rc);
 		rf_ShutdownDeclusteredDS(raidPtr);
 		return (rc);
 	}
+
 	return (0);
 }
 
-void 
-rf_MapSectorDeclustered(raidPtr, raidSector, row, col, diskSector, remap)
-	RF_Raid_t *raidPtr;
-	RF_RaidAddr_t raidSector;
-	RF_RowCol_t *row;
-	RF_RowCol_t *col;
-	RF_SectorNum_t *diskSector;
-	int     remap;
+void
+rf_MapSectorDeclustered(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
 	RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
 	RF_StripeNum_t BlockID, BlockOffset, RepIndex;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth =
+	    info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
 
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
+	/* Fulltable ID within array (across rows). */
+	FullTableID = SUID / sus_per_fulltable;
 	if (raidPtr->numRow == 1)
-		*row = 0;	/* avoid a mod and a div in the common case */
+		*row = 0;	/* Avoid a mod and a div in the common case. */
 	else {
 		*row = FullTableID % raidPtr->numRow;
-		FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on
-						 * this disk */
+		/* Convert to fulltable ID on this disk. */
+		FullTableID /= raidPtr->numRow;
 	}
 	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
 		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
@@ -367,294 +424,331 @@ rf_MapSectorDeclustered(raidPtr, raidSector, row, col, diskSector, remap)
 		BlockOffset += ((BlockOffset >= RepIndex) ? 1 : 0);
 	*col = info->LayoutTable[BlockID][BlockOffset];
 
-	/* remap to distributed spare space if indicated */
+	/* Remap to distributed spare space if indicated. */
 	if (remap) {
-		RF_ASSERT(raidPtr->Disks[*row][*col].status == rf_ds_reconstructing || raidPtr->Disks[*row][*col].status == rf_ds_dist_spared ||
-		    (rf_copyback_in_progress && raidPtr->Disks[*row][*col].status == rf_ds_optimal));
-		rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID, TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col, &outSU);
+		RF_ASSERT(raidPtr->Disks[*row][*col].status ==
+		    rf_ds_reconstructing ||
+		    raidPtr->Disks[*row][*col].status == rf_ds_dist_spared ||
+		    (rf_copyback_in_progress &&
+		    raidPtr->Disks[*row][*col].status == rf_ds_optimal));
+		rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID,
+		    TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col,
+		    &outSU);
 	} else {
 
 		outSU = base_suid;
-		outSU += FullTableID * fulltable_depth;	/* offs to strt of FT */
-		outSU += SpareSpace;	/* skip rsvd spare space */
-		outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;	/* offs to strt of tble */
-		outSU += info->OffsetTable[BlockID][BlockOffset] * layoutPtr->SUsPerPU;	/* offs to the PU */
+		outSU += FullTableID * fulltable_depth;
+			/* Offset to start of FT. */
+		outSU += SpareSpace;
+			/* Skip rsvd spare space. */
+		outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
+			/* Offset to start of table. */
+		outSU += info->OffsetTable[BlockID][BlockOffset] *
+		    layoutPtr->SUsPerPU;
+			/* Offset to the PU. */
 	}
-	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);	/* offs to the SU within
-										 * a PU */
+	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
+		/* offs to the SU within a PU */
 
-	/* convert SUs to sectors, and, if not aligned to SU boundary, add in
-	 * offset to sector.  */
-	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit + (raidSector % layoutPtr->sectorsPerStripeUnit);
+	/*
+	 * Convert SUs to sectors, and, if not aligned to SU boundary, add in
+	 * offset to sector.
+	 */
+	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
+	    (raidSector % layoutPtr->sectorsPerStripeUnit);
 
 	RF_ASSERT(*col != -1);
 }
 
-
-/* prototyping this inexplicably causes the compile of the layout table (rf_layout.c) to fail */
-void 
-rf_MapParityDeclustered(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+/*
+ * Prototyping this inexplicably causes the compile of the layout table
+ * (rf_layout.c) to fail.
+ */
+void
+rf_MapParityDeclustered(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
 	RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
 	RF_StripeNum_t BlockID, BlockOffset, RepIndex;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth =
+	    info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
 
-	/* compute row & (possibly) spare space exactly as before */
+	/* Compute row & (possibly) spare space exactly as before. */
 	FullTableID = SUID / sus_per_fulltable;
 	if (raidPtr->numRow == 1)
-		*row = 0;	/* avoid a mod and a div in the common case */
+		*row = 0;	/* Avoid a mod and a div in the common case. */
 	else {
 		*row = FullTableID % raidPtr->numRow;
-		FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on
-						 * this disk */
+		/* Convert to fulltable ID on this disk. */
+		FullTableID /= raidPtr->numRow;
 	}
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
 		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
 		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
 	}
-	/* compute BlockID and RepIndex exactly as before */
+	/* Compute BlockID and RepIndex exactly as before. */
 	FullTableOffset = SUID % sus_per_fulltable;
 	TableID = FullTableOffset / info->SUsPerTable;
 	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
-	/* TableOffset     = FullTableOffset % info->SUsPerTable; */
-	/* BlockID         = (TableOffset / info->PUsPerBlock) %
-	 * info->BlocksPerTable; */
+	/*TableOffset	= FullTableOffset % info->SUsPerTable;*/
+	/*BlockID	= (TableOffset / info->PUsPerBlock) %
+	 *info->BlocksPerTable;*/
 	BlockID = TableOffset / info->PUsPerBlock;
-	/* BlockOffset     = TableOffset % info->PUsPerBlock; */
+	/*BlockOffset	= TableOffset % info->PUsPerBlock;*/
 	BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
 	BlockID %= info->BlocksPerTable;
 
-	/* the parity block is in the position indicated by RepIndex */
-	RepIndex = (raidPtr->noRotate) ? info->PUsPerBlock : info->PUsPerBlock - TableID;
+	/* The parity block is in the position indicated by RepIndex. */
+	RepIndex = (raidPtr->noRotate) ?
+	    info->PUsPerBlock : info->PUsPerBlock - TableID;
 	*col = info->LayoutTable[BlockID][RepIndex];
 
 	if (remap) {
-		RF_ASSERT(raidPtr->Disks[*row][*col].status == rf_ds_reconstructing || raidPtr->Disks[*row][*col].status == rf_ds_dist_spared ||
-		    (rf_copyback_in_progress && raidPtr->Disks[*row][*col].status == rf_ds_optimal));
-		rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID, TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col, &outSU);
+		RF_ASSERT(raidPtr->Disks[*row][*col].status ==
+		    rf_ds_reconstructing ||
+		    raidPtr->Disks[*row][*col].status == rf_ds_dist_spared ||
+		    (rf_copyback_in_progress &&
+		    raidPtr->Disks[*row][*col].status == rf_ds_optimal));
+		rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID,
+		    TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col,
+		    &outSU);
 	} else {
 
-		/* compute sector as before, except use RepIndex instead of
-		 * BlockOffset */
+		/*
+		 * Compute sector as before, except use RepIndex instead of
+		 * BlockOffset.
+		 */
 		outSU = base_suid;
 		outSU += FullTableID * fulltable_depth;
 		outSU += SpareSpace;	/* skip rsvd spare space */
 		outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
-		outSU += info->OffsetTable[BlockID][RepIndex] * layoutPtr->SUsPerPU;
+		outSU += info->OffsetTable[BlockID][RepIndex] *
+		    layoutPtr->SUsPerPU;
 	}
 
 	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
-	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit + (raidSector % layoutPtr->sectorsPerStripeUnit);
+	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
+	    (raidSector % layoutPtr->sectorsPerStripeUnit);
 
 	RF_ASSERT(*col != -1);
 }
-/* returns an array of ints identifying the disks that comprise the stripe containing the indicated address.
- * the caller must _never_ attempt to modify this array.
+
+/*
+ * Return an array of ints identifying the disks that comprise the stripe
+ * containing the indicated address.
+ * The caller must _never_ attempt to modify this array.
  */
-void 
-rf_IdentifyStripeDeclustered(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeDeclustered(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth =
+	    info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0;
 	RF_StripeNum_t SUID = rf_RaidAddressToStripeUnitID(layoutPtr, addr);
 	RF_StripeNum_t stripeID, FullTableID;
-	int     tableOffset;
+	int tableOffset;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
+	/* Fulltable ID within array (across rows). */
+	FullTableID = SUID / sus_per_fulltable;
 	*outRow = FullTableID % raidPtr->numRow;
-	stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);	/* find stripe offset
-								 * into array */
-	tableOffset = (stripeID % info->BlocksPerTable);	/* find offset into
-								 * block design table */
+	/* Find stripe offset into array. */
+	stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);
+	/* Find offset into block design table. */
+	tableOffset = (stripeID % info->BlocksPerTable);
 	*diskids = info->LayoutTable[tableOffset];
 }
-/* This returns the default head-separation limit, which is measured
- * in "required units for reconstruction".  Each time a disk fetches
- * a unit, it bumps a counter.  The head-sep code prohibits any disk
+
+/*
+ * This returns the default head-separation limit, measured in
+ * "required units for reconstruction". Each time a disk fetches
+ * a unit, it bumps a counter. The head-sep code prohibits any disk
  * from getting more than headSepLimit counter values ahead of any
  * other.
  *
  * We assume here that the number of floating recon buffers is already
- * set.  There are r stripes to be reconstructed in each table, and so
+ * set. There are r stripes to be reconstructed in each table, and so
  * if we have a total of B buffers, we can have at most B/r tables
- * under recon at any one time.  In each table, lambda units are required
+ * under recon at any one time. In each table, lambda units are required
  * from each disk, so given B buffers, the head sep limit has to be
- * (lambda*B)/r units.  We subtract one to avoid weird boundary cases.
+ * (lambda*B)/r units. We subtract one to avoid weird boundary cases.
  *
- * for example, suppose were given 50 buffers, r=19, and lambda=4 as in
- * the 20.5 design.  There are 19 stripes/table to be reconstructed, so
+ * For example, suppose we are given 50 buffers, r=19, and lambda=4 as in
+ * the 20.5 design. There are 19 stripes/table to be reconstructed, so
  * we can have 50/19 tables concurrently under reconstruction, which means
  * we can allow the fastest disk to get 50/19 tables ahead of the slower
- * disk.  There are lambda "required units" for each disk, so the fastest
+ * disk. There are lambda "required units" for each disk, so the fastest
  * disk can get 4*50/19 = 10 counter values ahead of the slowest.
  *
  * If numBufsToAccumulate is not 1, we need to limit the head sep further
  * because multiple bufs will be required for each stripe under recon.
  */
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitDeclustered(
-    RF_Raid_t * raidPtr)
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimitDeclustered(RF_Raid_t *raidPtr)
 {
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 
-	return (info->Lambda * raidPtr->numFloatingReconBufs / info->TableDepthInPUs / rf_numBufsToAccumulate);
+	return (info->Lambda * raidPtr->numFloatingReconBufs /
+	    info->TableDepthInPUs / rf_numBufsToAccumulate);
 }
-/* returns the default number of recon buffers to use.  The value
- * is somewhat arbitrary...it's intended to be large enough to allow
- * for a reasonably large head-sep limit, but small enough that you
- * don't use up all your system memory with buffers.
+
+/*
+ * Return the default number of recon buffers to use. The value
+ * is somewhat arbitrary...  It's intended to be large enough to
+ * allow for a reasonably large head-sep limit, but small enough
+ * that you don't use up all your system memory with buffers.
  */
-int 
-rf_GetDefaultNumFloatingReconBuffersDeclustered(RF_Raid_t * raidPtr)
+int
+rf_GetDefaultNumFloatingReconBuffersDeclustered(RF_Raid_t *raidPtr)
 {
 	return (100 * rf_numBufsToAccumulate);
 }
-/* sectors in the last fulltable of the array need to be handled
- * specially since this fulltable can be incomplete.  this function
+
+/*
+ * Sectors in the last fulltable of the array need to be handled
+ * specially since this fulltable can be incomplete. This function
  * changes the values of certain params to handle this.
  *
- * the idea here is that MapSector et. al. figure out which disk the
+ * The idea here is that MapSector et. al. figure out which disk the
  * addressed unit lives on by computing the modulos of the unit number
  * with the number of units per fulltable, table, etc.  In the last
  * fulltable, there are fewer units per fulltable, so we need to adjust
  * the number of user data units per fulltable to reflect this.
  *
- * so, we (1) convert the fulltable size and depth parameters to
+ * So, we (1) convert the fulltable size and depth parameters to
  * the size of the partial fulltable at the end, (2) compute the
  * disk sector offset where this fulltable starts, and (3) convert
  * the users stripe unit number from an offset into the array to
  * an offset into the last fulltable.
  */
-void 
-rf_decluster_adjust_params(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t * SUID,
-    RF_StripeCount_t * sus_per_fulltable,
-    RF_StripeCount_t * fulltable_depth,
-    RF_StripeNum_t * base_suid)
+void
+rf_decluster_adjust_params(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t *SUID,
+    RF_StripeCount_t *sus_per_fulltable, RF_StripeCount_t *fulltable_depth,
+    RF_StripeNum_t *base_suid)
 {
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 
 	if (*SUID >= info->FullTableLimitSUID) {
-		/* new full table size is size of last full table on disk */
-		*sus_per_fulltable = info->ExtraTablesPerDisk * info->SUsPerTable;
+		/* New full table size is size of last full table on disk. */
+		*sus_per_fulltable =
+		    info->ExtraTablesPerDisk * info->SUsPerTable;
 
-		/* new full table depth is corresponding depth */
-		*fulltable_depth = info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU;
+		/* New full table depth is corresponding depth. */
+		*fulltable_depth =
+		    info->ExtraTablesPerDisk * info->TableDepthInPUs *
+		    layoutPtr->SUsPerPU;
 
-		/* set up the new base offset */
+		/* Set up the new base offset. */
 		*base_suid = info->DiskOffsetOfLastFullTableInSUs;
 
-		/* convert users array address to an offset into the last
-		 * fulltable */
+		/*
+		 * Convert user's array address to an offset into the last
+		 * fulltable.
+		 */
 		*SUID -= info->FullTableLimitSUID;
 	}
 }
+
 /*
- * map a stripe ID to a parity stripe ID.
+ * Map a stripe ID to a parity stripe ID.
  * See comment above RaidAddressToParityStripeID in layout.c.
  */
-void 
-rf_MapSIDToPSIDDeclustered(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDDeclustered(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
+    RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	RF_DeclusteredConfigInfo_t *info;
 
 	info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 
-	*psID = (stripeID / (layoutPtr->SUsPerPU * info->BlocksPerTable))
-	    * info->BlocksPerTable + (stripeID % info->BlocksPerTable);
-	*which_ru = (stripeID % (info->BlocksPerTable * layoutPtr->SUsPerPU))
-	    / info->BlocksPerTable;
+	*psID = (stripeID / (layoutPtr->SUsPerPU * info->BlocksPerTable)) *
+	    info->BlocksPerTable + (stripeID % info->BlocksPerTable);
+	*which_ru = (stripeID % (info->BlocksPerTable * layoutPtr->SUsPerPU)) /
+	    info->BlocksPerTable;
 	RF_ASSERT((*which_ru) < layoutPtr->SUsPerPU / layoutPtr->SUsPerRU);
 }
+
 /*
  * Called from MapSector and MapParity to retarget an access at the spare unit.
  * Modifies the "col" and "outSU" parameters only.
  */
-void 
-rf_remap_to_spare_space(
-    RF_RaidLayout_t * layoutPtr,
-    RF_DeclusteredConfigInfo_t * info,
-    RF_RowCol_t row,
-    RF_StripeNum_t FullTableID,
-    RF_StripeNum_t TableID,
-    RF_SectorNum_t BlockID,
-    RF_StripeNum_t base_suid,
-    RF_StripeNum_t SpareRegion,
-    RF_RowCol_t * outCol,
-    RF_StripeNum_t * outSU)
+void
+rf_remap_to_spare_space(RF_RaidLayout_t *layoutPtr,
+    RF_DeclusteredConfigInfo_t *info, RF_RowCol_t row,
+    RF_StripeNum_t FullTableID, RF_StripeNum_t TableID, RF_SectorNum_t BlockID,
+    RF_StripeNum_t base_suid, RF_StripeNum_t SpareRegion, RF_RowCol_t *outCol,
+    RF_StripeNum_t *outSU)
 {
-	RF_StripeNum_t ftID, spareTableStartSU, TableInSpareRegion, lastSROffset,
-	        which_ft;
+	RF_StripeNum_t ftID, spareTableStartSU, TableInSpareRegion,
+	    lastSROffset, which_ft;
 
 	/*
-         * note that FullTableID and hence SpareRegion may have gotten
-         * tweaked by rf_decluster_adjust_params. We detect this by
-         * noticing that base_suid is not 0.
-         */
+	 * Note that FullTableID and hence SpareRegion may have gotten
+	 * tweaked by rf_decluster_adjust_params. We detect this by
+	 * noticing that base_suid is not 0.
+	 */
 	if (base_suid == 0) {
 		ftID = FullTableID;
 	} else {
 		/*
-	         * There may be > 1.0 full tables in the last (i.e. partial)
-	         * spare region.  find out which of these we're in.
-	         */
-		lastSROffset = info->NumCompleteSRs * info->SpareRegionDepthInSUs;
-		which_ft = (info->DiskOffsetOfLastFullTableInSUs - lastSROffset) / (info->FullTableDepthInPUs * layoutPtr->SUsPerPU);
-
-		/* compute the actual full table ID */
-		ftID = info->DiskOffsetOfLastFullTableInSUs / (info->FullTableDepthInPUs * layoutPtr->SUsPerPU) + which_ft;
+		 * There may be > 1.0 full tables in the last (i.e. partial)
+		 * spare region. Find out which of these we are in.
+		 */
+		lastSROffset = info->NumCompleteSRs *
+		    info->SpareRegionDepthInSUs;
+		which_ft =
+		    (info->DiskOffsetOfLastFullTableInSUs - lastSROffset) /
+		    (info->FullTableDepthInPUs * layoutPtr->SUsPerPU);
+
+		/* Compute the actual full table ID. */
+		ftID = info->DiskOffsetOfLastFullTableInSUs /
+		    (info->FullTableDepthInPUs * layoutPtr->SUsPerPU) +
+		    which_ft;
 		SpareRegion = info->NumCompleteSRs;
 	}
-	TableInSpareRegion = (ftID * info->NumParityReps + TableID) % info->TablesPerSpareRegion;
+	TableInSpareRegion = (ftID * info->NumParityReps + TableID) %
+	    info->TablesPerSpareRegion;
 
 	*outCol = info->SpareTable[TableInSpareRegion][BlockID].spareDisk;
 	RF_ASSERT(*outCol != -1);
 
 	spareTableStartSU = (SpareRegion == info->NumCompleteSRs) ?
-	    info->DiskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU :
-	    (SpareRegion + 1) * info->SpareRegionDepthInSUs - info->SpareSpaceDepthPerRegionInSUs;
-	*outSU = spareTableStartSU + info->SpareTable[TableInSpareRegion][BlockID].spareBlockOffsetInSUs;
+	    info->DiskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk *
+	    info->TableDepthInPUs * layoutPtr->SUsPerPU :
+	    (SpareRegion + 1) * info->SpareRegionDepthInSUs -
+	    info->SpareSpaceDepthPerRegionInSUs;
+	*outSU = spareTableStartSU +
+	    info->SpareTable[TableInSpareRegion][BlockID].spareBlockOffsetInSUs;
 	if (*outSU >= layoutPtr->stripeUnitsPerDisk) {
-		printf("rf_remap_to_spare_space: invalid remapped disk SU offset %ld\n", (long) *outSU);
+		printf("rf_remap_to_spare_space: invalid remapped disk SU"
+		    " offset %ld.\n", (long) *outSU);
 	}
 }
 
-int 
-rf_InstallSpareTable(
-    RF_Raid_t * raidPtr,
-    RF_RowCol_t frow,
-    RF_RowCol_t fcol)
+int
+rf_InstallSpareTable(RF_Raid_t *raidPtr, RF_RowCol_t frow, RF_RowCol_t fcol)
 {
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 	RF_SparetWait_t *req;
-	int     retcode;
+	int retcode;
 
 	RF_Malloc(req, sizeof(*req), (RF_SparetWait_t *));
 	req->C = raidPtr->numCol;
@@ -664,76 +758,89 @@ rf_InstallSpareTable(
 	req->TablesPerSpareRegion = info->TablesPerSpareRegion;
 	req->BlocksPerTable = info->BlocksPerTable;
 	req->TableDepthInPUs = info->TableDepthInPUs;
-	req->SpareSpaceDepthPerRegionInSUs = info->SpareSpaceDepthPerRegionInSUs;
+	req->SpareSpaceDepthPerRegionInSUs =
+	    info->SpareSpaceDepthPerRegionInSUs;
 
 	retcode = rf_GetSpareTableFromDaemon(req);
-	RF_ASSERT(!retcode);	/* XXX -- fix this to recover gracefully --
-				 * XXX */
+	RF_ASSERT(!retcode);
+	/* XXX -- Fix this to recover gracefully. -- XXX */
+
 	return (retcode);
 }
+
 /*
  * Invoked via ioctl to install a spare table in the kernel.
  */
-int 
-rf_SetSpareTable(raidPtr, data)
-	RF_Raid_t *raidPtr;
-	void   *data;
+int
+rf_SetSpareTable(RF_Raid_t *raidPtr, void *data)
 {
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 	RF_SpareTableEntry_t **ptrs;
-	int     i, retcode;
+	int i, retcode;
 
-	/* what we need to copyin is a 2-d array, so first copyin the user
-	 * pointers to the rows in the table */
-	RF_Malloc(ptrs, info->TablesPerSpareRegion * sizeof(RF_SpareTableEntry_t *), (RF_SpareTableEntry_t **));
-	retcode = copyin((caddr_t) data, (caddr_t) ptrs, info->TablesPerSpareRegion * sizeof(RF_SpareTableEntry_t *));
+	/*
+	 * What we need to copyin is a 2-d array, so first copyin the user
+	 * pointers to the rows in the table.
+	 */
+	RF_Malloc(ptrs, info->TablesPerSpareRegion *
+	    sizeof(RF_SpareTableEntry_t *), (RF_SpareTableEntry_t **));
+	retcode = copyin((caddr_t) data, (caddr_t) ptrs,
+	    info->TablesPerSpareRegion * sizeof(RF_SpareTableEntry_t *));
 
 	if (retcode)
 		return (retcode);
 
-	/* now allocate kernel space for the row pointers */
-	RF_Malloc(info->SpareTable, info->TablesPerSpareRegion * sizeof(RF_SpareTableEntry_t *), (RF_SpareTableEntry_t **));
+	/* Now allocate kernel space for the row pointers. */
+	RF_Malloc(info->SpareTable, info->TablesPerSpareRegion *
+	    sizeof(RF_SpareTableEntry_t *), (RF_SpareTableEntry_t **));
 
-	/* now allocate kernel space for each row in the table, and copy it in
-	 * from user space */
+	/*
+	 * Now allocate kernel space for each row in the table, and copy it in
+	 * from user space. */
 	for (i = 0; i < info->TablesPerSpareRegion; i++) {
-		RF_Malloc(info->SpareTable[i], info->BlocksPerTable * sizeof(RF_SpareTableEntry_t), (RF_SpareTableEntry_t *));
-		retcode = copyin(ptrs[i], info->SpareTable[i], info->BlocksPerTable * sizeof(RF_SpareTableEntry_t));
+		RF_Malloc(info->SpareTable[i], info->BlocksPerTable *
+		    sizeof(RF_SpareTableEntry_t), (RF_SpareTableEntry_t *));
+		retcode = copyin(ptrs[i], info->SpareTable[i],
+		    info->BlocksPerTable * sizeof(RF_SpareTableEntry_t));
 		if (retcode) {
-			info->SpareTable = NULL;	/* blow off the memory
-							 * we've allocated */
+			/* Blow off the memory we have allocated. */
+			info->SpareTable = NULL;
 			return (retcode);
 		}
 	}
 
-	/* free up the temporary array we used */
-	RF_Free(ptrs, info->TablesPerSpareRegion * sizeof(RF_SpareTableEntry_t *));
+	/* Free up the temporary array we used. */
+	RF_Free(ptrs, info->TablesPerSpareRegion *
+	    sizeof(RF_SpareTableEntry_t *));
 
 	return (0);
 }
 
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsDeclustered(raidPtr)
-	RF_Raid_t *raidPtr;
+RF_ReconUnitCount_t
+rf_GetNumSpareRUsDeclustered(RF_Raid_t *raidPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 
-	return (((RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo)->TotSparePUsPerDisk);
+	return (((RF_DeclusteredConfigInfo_t *)
+	    layoutPtr->layoutSpecificInfo)->TotSparePUsPerDisk);
 }
 
 
-void 
-rf_FreeSpareTable(raidPtr)
-	RF_Raid_t *raidPtr;
+void
+rf_FreeSpareTable(RF_Raid_t *raidPtr)
 {
-	long    i;
+	long i;
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_SpareTableEntry_t **table = info->SpareTable;
 
 	for (i = 0; i < info->TablesPerSpareRegion; i++) {
-		RF_Free(table[i], info->BlocksPerTable * sizeof(RF_SpareTableEntry_t));
+		RF_Free(table[i], info->BlocksPerTable *
+		    sizeof(RF_SpareTableEntry_t));
 	}
-	RF_Free(table, info->TablesPerSpareRegion * sizeof(RF_SpareTableEntry_t *));
+	RF_Free(table, info->TablesPerSpareRegion *
+	    sizeof(RF_SpareTableEntry_t *));
 	info->SpareTable = (RF_SpareTableEntry_t **) NULL;
 }
diff --git a/sys/dev/raidframe/rf_decluster.h b/sys/dev/raidframe/rf_decluster.h
index e4e3ac40c7d..b1b3cc9a3c9 100644
--- a/sys/dev/raidframe/rf_decluster.h
+++ b/sys/dev/raidframe/rf_decluster.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_decluster.h,v 1.2 1999/02/16 00:02:35 niklas Exp $	*/
+/*	$OpenBSD: rf_decluster.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_decluster.h,v 1.3 1999/02/05 00:06:09 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,17 +28,17 @@
  * rights to redistribute these changes.
  */
 
-/*----------------------------------------------------------------------
+/*****************************************************************************
  *
- * decluster.h -- header file for declustered layout code
+ * decluster.h -- Header file for declustered layout code.
  *
  * Adapted from raidSim version July 1994
  * Created 10-21-92 (MCH)
  *
- *--------------------------------------------------------------------*/
+ *****************************************************************************/
 
-#ifndef _RF__RF_DECLUSTER_H_
-#define _RF__RF_DECLUSTER_H_
+#ifndef	_RF__RF_DECLUSTER_H_
+#define	_RF__RF_DECLUSTER_H_
 
 #include "rf_types.h"
 
@@ -47,95 +48,98 @@
  * the associated inverse mapping.
  */
 struct RF_SpareTableEntry_s {
-	u_int   spareDisk;	/* disk to which this block is spared */
-	u_int   spareBlockOffsetInSUs;	/* offset into spare table for that
-					 * disk */
+	u_int	spareDisk;		/* Disk where this block is spared. */
+	u_int	spareBlockOffsetInSUs;	/*
+					 * Offset into spare table for that
+					 * disk.
+					 */
 };
-#define RF_SPAREMAP_NAME_LEN 128
 
-/* this is the layout-specific info structure for the declustered layout.
+#define	RF_SPAREMAP_NAME_LEN	128
+
+/*
+ * This is the layout-specific info structure for the declustered layout.
  */
 struct RF_DeclusteredConfigInfo_s {
-	RF_StripeCount_t groupSize;	/* no. of stripe units per parity
-					 * stripe */
-	RF_RowCol_t **LayoutTable;	/* the block design table */
-	RF_RowCol_t **OffsetTable;	/* the sector offset table */
-	RF_RowCol_t **BlockTable;	/* the block membership table */
-	RF_StripeCount_t SUsPerFullTable;	/* stripe units per full table */
-	RF_StripeCount_t SUsPerTable;	/* stripe units per table */
-	RF_StripeCount_t PUsPerBlock;	/* parity units per block */
-	RF_StripeCount_t SUsPerBlock;	/* stripe units per block */
-	RF_StripeCount_t BlocksPerTable;	/* block design tuples per
-						 * table */
-	RF_StripeCount_t NumParityReps;	/* tables per full table */
-	RF_StripeCount_t TableDepthInPUs;	/* PUs on one disk in 1 table */
-	RF_StripeCount_t FullTableDepthInPUs;	/* PUs on one disk in 1
-						 * fulltable */
-	RF_StripeCount_t FullTableLimitSUID;	/* SU where partial fulltables
-						 * start */
-	RF_StripeCount_t ExtraTablesPerDisk;	/* # of tables in last
-						 * fulltable */
-	RF_SectorNum_t DiskOffsetOfLastFullTableInSUs;	/* disk offs of partial
-							 * ft, if any */
-	RF_StripeCount_t numCompleteFullTablesPerDisk;	/* ft identifier of
-							 * partial ft, if any */
-	u_int   Lambda;		/* the pair count in the block design */
+		/* Number of stripe units per parity stripe. */
+	RF_StripeCount_t	  groupSize;
+		/* The block design table. */
+	RF_RowCol_t		**LayoutTable;
+	RF_RowCol_t		**OffsetTable;
+		/* The sector offset table. */
+	RF_RowCol_t		**BlockTable;
+		/* The block membership table. */
+	RF_StripeCount_t	  SUsPerFullTable;
+		/* Stripe units per full table. */
+	RF_StripeCount_t	  SUsPerTable;
+		/* Stripe units per table. */
+	RF_StripeCount_t	  PUsPerBlock;
+		/* Parity units per block. */
+	RF_StripeCount_t	  SUsPerBlock;
+		/* Stripe units per block. */
+	RF_StripeCount_t	  BlocksPerTable;
+		/* Block design tuples per table. */
+	RF_StripeCount_t	  NumParityReps;
+		/* Tables per full table. */
+	RF_StripeCount_t	  TableDepthInPUs;
+		/* PUs on one disk in 1 table. */
+	RF_StripeCount_t	  FullTableDepthInPUs;
+		/* PUs on one disk in 1 fulltable. */
+	RF_StripeCount_t	  FullTableLimitSUID;
+		/* SU where partial fulltables start. */
+	RF_StripeCount_t	  ExtraTablesPerDisk;
+		/* Number of tables in last fulltable. */
+	RF_SectorNum_t		  DiskOffsetOfLastFullTableInSUs;
+		/* Disk offsets of partial fulltable, if any. */
+	RF_StripeCount_t	  numCompleteFullTablesPerDisk;
+		/* Fulltable identifier of partial fulltable, if any. */
+	u_int			  Lambda;
+		/* The pair count in the block design. */
 
-	/* these are used only in the distributed-sparing case */
-	RF_StripeCount_t FullTablesPerSpareRegion;	/* # of ft's comprising
-							 * 1 spare region */
-	RF_StripeCount_t TablesPerSpareRegion;	/* # of tables */
-	RF_SectorCount_t SpareSpaceDepthPerRegionInSUs;	/* spare
-							 * space/disk/region */
-	RF_SectorCount_t SpareRegionDepthInSUs;	/* # of units/disk/region */
-	RF_SectorNum_t DiskOffsetOfLastSpareSpaceChunkInSUs;	/* locates sp space
-								 * after partial ft */
-	RF_StripeCount_t TotSparePUsPerDisk;	/* total number of spare PUs
-						 * per disk */
-	RF_StripeCount_t NumCompleteSRs;
-	RF_SpareTableEntry_t **SpareTable;	/* remap table for spare space */
-	char    sparemap_fname[RF_SPAREMAP_NAME_LEN];	/* where to find
-							 * sparemap. not used in
-							 * kernel */
+	/* These are used only in the distributed-sparing case. */
+	RF_StripeCount_t	  FullTablesPerSpareRegion;
+		/* Number of fulltables comprising 1 spare region. */
+	RF_StripeCount_t	  TablesPerSpareRegion;
+		/* Number of tables. */
+	RF_SectorCount_t	  SpareSpaceDepthPerRegionInSUs;
+		/* Spare space/disk/region. */
+	RF_SectorCount_t	  SpareRegionDepthInSUs;
+		/* Number of units/disk/region. */
+	RF_SectorNum_t		  DiskOffsetOfLastSpareSpaceChunkInSUs;
+		/* Locates spare space after partial fulltable. */
+	RF_StripeCount_t	  TotSparePUsPerDisk;
+		/* Total number of spare PUs per disk. */
+	RF_StripeCount_t	  NumCompleteSRs;
+	RF_SpareTableEntry_t	**SpareTable;
+		/* Remap table for spare space. */
+	char			  sparemap_fname[RF_SPAREMAP_NAME_LEN];
+		/* Where to find sparemap. Not used in kernel. */
 };
 
-int 
-rf_ConfigureDeclustered(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int 
-rf_ConfigureDeclusteredDS(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
+int  rf_ConfigureDeclustered(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int  rf_ConfigureDeclusteredDS(RF_ShutdownList_t **, RF_Raid_t *,
+	RF_Config_t *);
 
-void 
-rf_MapSectorDeclustered(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityDeclustered(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeDeclustered(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDDeclustered(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-int     rf_InstallSpareTable(RF_Raid_t * raidPtr, RF_RowCol_t frow, RF_RowCol_t fcol);
-void    rf_FreeSpareTable(RF_Raid_t * raidPtr);
+void rf_MapSectorDeclustered(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityDeclustered(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeDeclustered(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t **,
+	RF_RowCol_t *);
+void rf_MapSIDToPSIDDeclustered(RF_RaidLayout_t *, RF_StripeNum_t,
+	RF_StripeNum_t *, RF_ReconUnitNum_t *);
+int  rf_InstallSpareTable(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+void rf_FreeSpareTable(RF_Raid_t *);
 
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitDeclustered(RF_Raid_t * raidPtr);
-int     rf_GetDefaultNumFloatingReconBuffersDeclustered(RF_Raid_t * raidPtr);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitDeclustered(RF_Raid_t *);
+int  rf_GetDefaultNumFloatingReconBuffersDeclustered(RF_Raid_t *);
 
-void 
-rf_decluster_adjust_params(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t * SUID, RF_StripeCount_t * sus_per_fulltable,
-    RF_StripeCount_t * fulltable_depth, RF_StripeNum_t * base_suid);
-void 
-rf_remap_to_spare_space(
-    RF_RaidLayout_t * layoutPtr,
-    RF_DeclusteredConfigInfo_t * info, RF_RowCol_t row, RF_StripeNum_t FullTableID,
-    RF_StripeNum_t TableID, RF_SectorNum_t BlockID, RF_StripeNum_t base_suid,
-    RF_StripeNum_t SpareRegion, RF_RowCol_t * outCol, RF_StripeNum_t * outSU);
-int     rf_SetSpareTable(RF_Raid_t * raidPtr, void *data);
-RF_ReconUnitCount_t rf_GetNumSpareRUsDeclustered(RF_Raid_t * raidPtr);
+void rf_decluster_adjust_params(RF_RaidLayout_t *, RF_StripeNum_t *,
+	RF_StripeCount_t *, RF_StripeCount_t *, RF_StripeNum_t *);
+void rf_remap_to_spare_space(RF_RaidLayout_t *, RF_DeclusteredConfigInfo_t *,
+	RF_RowCol_t, RF_StripeNum_t, RF_StripeNum_t, RF_SectorNum_t,
+	RF_StripeNum_t, RF_StripeNum_t, RF_RowCol_t *, RF_StripeNum_t *);
+int  rf_SetSpareTable(RF_Raid_t *, void *);
+RF_ReconUnitCount_t rf_GetNumSpareRUsDeclustered(RF_Raid_t *);
 
-#endif				/* !_RF__RF_DECLUSTER_H_ */
+#endif	/* ! _RF__RF_DECLUSTER_H_ */
diff --git a/sys/dev/raidframe/rf_declusterPQ.c b/sys/dev/raidframe/rf_declusterPQ.c
index 1fa4692a96b..605071fbe97 100644
--- a/sys/dev/raidframe/rf_declusterPQ.c
+++ b/sys/dev/raidframe/rf_declusterPQ.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_declusterPQ.c,v 1.3 2002/08/09 15:10:20 tdeval Exp $	*/
+/*	$OpenBSD: rf_declusterPQ.c,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_declusterPQ.c,v 1.3 1999/02/05 00:06:09 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,13 +28,13 @@
  * rights to redistribute these changes.
  */
 
-/*--------------------------------------------------
+/*****************************************************************************
  * rf_declusterPQ.c
  *
- * mapping code for declustered P & Q or declustered EvenOdd
- * much code borrowed from rf_decluster.c
+ * Mapping code for declustered P & Q or declustered EvenOdd.
+ * Much code borrowed from rf_decluster.c
  *
- *--------------------------------------------------*/
+ *****************************************************************************/
 
 
 #include "rf_types.h"
@@ -46,26 +47,24 @@
 #include "rf_alloclist.h"
 #include "rf_general.h"
 
-/* configuration code */
+/* Configuration code. */
 
-int 
-rf_ConfigureDeclusteredPQ(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureDeclusteredPQ(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	int     b, v, k, r, lambda;	/* block design params */
-	int     i, j, l;
-	int    *first_avail_slot;
-	int     complete_FT_count, SUID;
+	int b, v, k, r, lambda;	/* block design params */
+	int i, j, l;
+	int *first_avail_slot;
+	int complete_FT_count, SUID;
 	RF_DeclusteredConfigInfo_t *info;
-	int     numCompleteFullTablesPerDisk;
-	int     PUsPerDisk, spareRegionDepthInPUs, numCompleteSpareRegionsPerDisk = 0,
-	        extraPUsPerDisk;
-	int     totSparePUsPerDisk;
-	int     diskOffsetOfLastFullTableInSUs, SpareSpaceInSUs;
-	char   *cfgBuf = (char *) (cfgPtr->layoutSpecific);
+	int numCompleteFullTablesPerDisk;
+	int PUsPerDisk, spareRegionDepthInPUs, extraPUsPerDisk;
+	int numCompleteSpareRegionsPerDisk = 0;
+	int totSparePUsPerDisk;
+	int diskOffsetOfLastFullTableInSUs, SpareSpaceInSUs;
+	char *cfgBuf = (char *)(cfgPtr->layoutSpecific);
 
 	cfgBuf += RF_SPAREMAP_NAME_LEN;
 
@@ -88,137 +87,186 @@ rf_ConfigureDeclusteredPQ(
 #endif	/* RAIDDEBUG */
 		return (EINVAL);
 	}
-	/* 1. create layout specific structure */
-	RF_MallocAndAdd(info, sizeof(RF_DeclusteredConfigInfo_t), (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
+	/* 1. Create layout specific structure. */
+	RF_MallocAndAdd(info, sizeof(RF_DeclusteredConfigInfo_t),
+	    (RF_DeclusteredConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
-	/* the sparemaps are generated assuming that parity is rotated, so we
-	 * issue a warning if both distributed sparing and no-rotate are on at
-	 * the same time */
-	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) && raidPtr->noRotate) {
-		RF_ERRORMSG("Warning:  distributed sparing specified without parity rotation.\n");
+	/*
+	 * 2. The sparemaps are generated assuming that parity is rotated, so
+	 * we issue a warning if both distributed sparing and no-rotate are on
+	 * at the same time.
+	 */
+	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) &&
+	    raidPtr->noRotate) {
+		RF_ERRORMSG("Warning:  distributed sparing specified without"
+		    " parity rotation.\n");
 	}
 	if (raidPtr->numCol != v) {
-		RF_ERRORMSG2("RAID: config error: table element count (%d) not equal to no. of cols (%d)\n", v, raidPtr->numCol);
+		RF_ERRORMSG2("RAID: config error: table element count (%d)"
+		    " not equal to no. of cols (%d).\n", v, raidPtr->numCol);
 		return (EINVAL);
 	}
-	/* 3.  set up the values used in devRaidMap */
+	/* 3. Set up the values used in devRaidMap. */
 	info->BlocksPerTable = b;
 	info->NumParityReps = info->groupSize = k;
 	info->PUsPerBlock = k - 2;	/* PQ */
-	info->SUsPerTable = b * info->PUsPerBlock * layoutPtr->SUsPerPU;	/* b blks, k-1 SUs each */
-	info->SUsPerFullTable = k * info->SUsPerTable;	/* rot k times */
+	info->SUsPerTable = b * info->PUsPerBlock * layoutPtr->SUsPerPU;
+		/* b blks, k-1 SUs each. */
+	info->SUsPerFullTable = k * info->SUsPerTable;	/* Rot k times. */
 	info->SUsPerBlock = info->PUsPerBlock * layoutPtr->SUsPerPU;
 	info->TableDepthInPUs = (b * k) / v;
-	info->FullTableDepthInPUs = info->TableDepthInPUs * k;	/* k repetitions */
+	info->FullTableDepthInPUs = info->TableDepthInPUs * k;
+		/* k repetitions. */
 
-	/* used only in distributed sparing case */
-	info->FullTablesPerSpareRegion = (v - 1) / rf_gcd(r, v - 1);	/* (v-1)/gcd fulltables */
+	/* Used only in distributed sparing case. */
+	info->FullTablesPerSpareRegion = (v - 1) / rf_gcd(r, v - 1);
+		/* (v-1)/gcd fulltables. */
 	info->TablesPerSpareRegion = k * info->FullTablesPerSpareRegion;
-	info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion / (v - 1)) * layoutPtr->SUsPerPU;
+	info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion
+	    / (v - 1)) * layoutPtr->SUsPerPU;
 
-	/* check to make sure the block design is sufficiently small */
+	/* Check to make sure the block design is sufficiently small. */
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		if (info->FullTableDepthInPUs * layoutPtr->SUsPerPU + info->SpareSpaceDepthPerRegionInSUs > layoutPtr->stripeUnitsPerDisk) {
-			RF_ERRORMSG3("RAID: config error: Full Table depth (%d) + Spare Space (%d) larger than disk size (%d) (BD too big)\n",
-			    (int) info->FullTableDepthInPUs,
-			    (int) info->SpareSpaceDepthPerRegionInSUs,
-			    (int) layoutPtr->stripeUnitsPerDisk);
+		if (info->FullTableDepthInPUs * layoutPtr->SUsPerPU +
+		    info->SpareSpaceDepthPerRegionInSUs >
+		    layoutPtr->stripeUnitsPerDisk) {
+			RF_ERRORMSG3("RAID: config error: Full Table depth"
+			    " (%d) + Spare Space (%d) larger than disk size"
+			    " (%d) (BD too big).\n",
+			    (int)info->FullTableDepthInPUs,
+			    (int)info->SpareSpaceDepthPerRegionInSUs,
+			    (int)layoutPtr->stripeUnitsPerDisk);
 			return (EINVAL);
 		}
 	} else {
-		if (info->TableDepthInPUs * layoutPtr->SUsPerPU > layoutPtr->stripeUnitsPerDisk) {
-			RF_ERRORMSG2("RAID: config error: Table depth (%d) larger than disk size (%d) (BD too big)\n",
+		if (info->TableDepthInPUs * layoutPtr->SUsPerPU >
+		    layoutPtr->stripeUnitsPerDisk) {
+			RF_ERRORMSG2("RAID: config error: Table depth (%d)"
+			    " larger than disk size (%d) (BD too big).\n",
 			    (int) (info->TableDepthInPUs * layoutPtr->SUsPerPU),
 			    (int) layoutPtr->stripeUnitsPerDisk);
 			return (EINVAL);
 		}
 	}
 
-
-	/* compute the size of each disk, and the number of tables in the last
-	 * fulltable (which need not be complete) */
+	/*
+	 * Compute the size of each disk, and the number of tables in the last
+	 * fulltable (which need not be complete).
+	 */
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
 
-		PUsPerDisk = layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU;
-		spareRegionDepthInPUs = (info->TablesPerSpareRegion * info->TableDepthInPUs +
-		    (info->TablesPerSpareRegion * info->TableDepthInPUs) / (v - 1));
-		info->SpareRegionDepthInSUs = spareRegionDepthInPUs * layoutPtr->SUsPerPU;
+		PUsPerDisk = layoutPtr->stripeUnitsPerDisk /
+		    layoutPtr->SUsPerPU;
+		spareRegionDepthInPUs = (info->TablesPerSpareRegion *
+		    info->TableDepthInPUs + (info->TablesPerSpareRegion *
+		    info->TableDepthInPUs) / (v - 1));
+		info->SpareRegionDepthInSUs = spareRegionDepthInPUs *
+		    layoutPtr->SUsPerPU;
 
-		numCompleteSpareRegionsPerDisk = PUsPerDisk / spareRegionDepthInPUs;
+		numCompleteSpareRegionsPerDisk = PUsPerDisk /
+		    spareRegionDepthInPUs;
 		info->NumCompleteSRs = numCompleteSpareRegionsPerDisk;
 		extraPUsPerDisk = PUsPerDisk % spareRegionDepthInPUs;
 
-		/* assume conservatively that we need the full amount of spare
+		/*
+		 * Assume conservatively that we need the full amount of spare
 		 * space in one region in order to provide spares for the
 		 * partial spare region at the end of the array.  We set "i"
 		 * to the number of tables in the partial spare region.  This
-		 * may actually include some fulltables. */
-		extraPUsPerDisk -= (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
+		 * may actually include some fulltables.
+		 */
+		extraPUsPerDisk -= (info->SpareSpaceDepthPerRegionInSUs /
+		    layoutPtr->SUsPerPU);
 		if (extraPUsPerDisk <= 0)
 			i = 0;
 		else
 			i = extraPUsPerDisk / info->TableDepthInPUs;
 
-		complete_FT_count = raidPtr->numRow * (numCompleteSpareRegionsPerDisk * (info->TablesPerSpareRegion / k) + i / k);
-		info->FullTableLimitSUID = complete_FT_count * info->SUsPerFullTable;
+		complete_FT_count = raidPtr->numRow *
+		    (numCompleteSpareRegionsPerDisk *
+		    (info->TablesPerSpareRegion / k) + i / k);
+		info->FullTableLimitSUID = complete_FT_count *
+		    info->SUsPerFullTable;
 		info->ExtraTablesPerDisk = i % k;
 
-		/* note that in the last spare region, the spare space is
-		 * complete even though data/parity space is not */
-		totSparePUsPerDisk = (numCompleteSpareRegionsPerDisk + 1) * (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
+		/*
+		 * Note that in the last spare region, the spare space is
+		 * complete even though data/parity space is not.
+		 */
+		totSparePUsPerDisk = (numCompleteSpareRegionsPerDisk + 1) *
+		    (info->SpareSpaceDepthPerRegionInSUs / layoutPtr->SUsPerPU);
 		info->TotSparePUsPerDisk = totSparePUsPerDisk;
 
 		layoutPtr->stripeUnitsPerDisk =
-		    ((complete_FT_count / raidPtr->numRow) * info->FullTableDepthInPUs +	/* data & parity space */
+		    ((complete_FT_count / raidPtr->numRow) *
+		    info->FullTableDepthInPUs +	/* data & parity space */
 		    info->ExtraTablesPerDisk * info->TableDepthInPUs +
 		    totSparePUsPerDisk	/* spare space */
 		    ) * layoutPtr->SUsPerPU;
 		layoutPtr->dataStripeUnitsPerDisk =
-		    (complete_FT_count * info->FullTableDepthInPUs + info->ExtraTablesPerDisk * info->TableDepthInPUs)
+		    (complete_FT_count * info->FullTableDepthInPUs +
+		    info->ExtraTablesPerDisk * info->TableDepthInPUs)
 		    * layoutPtr->SUsPerPU * (k - 1) / k;
 
 	} else {
-		/* non-dist spare case:  force each disk to contain an
-		 * integral number of tables */
-		layoutPtr->stripeUnitsPerDisk /= (info->TableDepthInPUs * layoutPtr->SUsPerPU);
-		layoutPtr->stripeUnitsPerDisk *= (info->TableDepthInPUs * layoutPtr->SUsPerPU);
-
-		/* compute the number of tables in the last fulltable, which
-		 * need not be complete */
-		complete_FT_count =
-		    ((layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU) / info->FullTableDepthInPUs) * raidPtr->numRow;
-
-		info->FullTableLimitSUID = complete_FT_count * info->SUsPerFullTable;
-		info->ExtraTablesPerDisk =
-		    ((layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerPU) / info->TableDepthInPUs) % k;
+		/*
+		 * Non-dist spare case:  force each disk to contain an
+		 * integral number of tables.
+		 */
+		layoutPtr->stripeUnitsPerDisk /=
+		    (info->TableDepthInPUs * layoutPtr->SUsPerPU);
+		layoutPtr->stripeUnitsPerDisk *=
+		    (info->TableDepthInPUs * layoutPtr->SUsPerPU);
+
+		/*
+		 * Compute the number of tables in the last fulltable, which
+		 * need not be complete.
+		 */
+		complete_FT_count = ((layoutPtr->stripeUnitsPerDisk /
+		    layoutPtr->SUsPerPU) / info->FullTableDepthInPUs) *
+		    raidPtr->numRow;
+
+		info->FullTableLimitSUID = complete_FT_count *
+		    info->SUsPerFullTable;
+		info->ExtraTablesPerDisk = ((layoutPtr->stripeUnitsPerDisk /
+		    layoutPtr->SUsPerPU) / info->TableDepthInPUs) % k;
 	}
 
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
+	    layoutPtr->sectorsPerStripeUnit;
 
-	/* find the disk offset of the stripe unit where the last fulltable
-	 * starts */
+	/*
+	 * Find the disk offset of the stripe unit where the last
+	 * fulltable starts.
+	 */
 	numCompleteFullTablesPerDisk = complete_FT_count / raidPtr->numRow;
-	diskOffsetOfLastFullTableInSUs = numCompleteFullTablesPerDisk * info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	diskOffsetOfLastFullTableInSUs = numCompleteFullTablesPerDisk *
+	    info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		SpareSpaceInSUs = numCompleteSpareRegionsPerDisk * info->SpareSpaceDepthPerRegionInSUs;
+		SpareSpaceInSUs = numCompleteSpareRegionsPerDisk *
+		    info->SpareSpaceDepthPerRegionInSUs;
 		diskOffsetOfLastFullTableInSUs += SpareSpaceInSUs;
 		info->DiskOffsetOfLastSpareSpaceChunkInSUs =
-		    diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU;
+		    diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk *
+		    info->TableDepthInPUs * layoutPtr->SUsPerPU;
 	}
 	info->DiskOffsetOfLastFullTableInSUs = diskOffsetOfLastFullTableInSUs;
 	info->numCompleteFullTablesPerDisk = numCompleteFullTablesPerDisk;
 
-	/* 4.  create and initialize the lookup tables */
+	/* 4. Create and initialize the lookup tables. */
 	info->LayoutTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
 	if (info->LayoutTable == NULL)
 		return (ENOMEM);
+
 	info->OffsetTable = rf_make_2d_array(b, k, raidPtr->cleanupList);
 	if (info->OffsetTable == NULL)
 		return (ENOMEM);
-	info->BlockTable = rf_make_2d_array(info->TableDepthInPUs * layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
+
+	info->BlockTable = rf_make_2d_array(info->TableDepthInPUs *
+	    layoutPtr->SUsPerPU, raidPtr->numCol, raidPtr->cleanupList);
 	if (info->BlockTable == NULL)
 		return (ENOMEM);
 
@@ -230,18 +278,20 @@ rf_ConfigureDeclusteredPQ(
 		for (j = 0; j < k; j++)
 			info->LayoutTable[i][j] = *cfgBuf++;
 
-	/* initialize offset table */
+	/* Initialize offset table. */
 	for (i = 0; i < b; i++)
 		for (j = 0; j < k; j++) {
-			info->OffsetTable[i][j] = first_avail_slot[info->LayoutTable[i][j]];
+			info->OffsetTable[i][j] =
+			    first_avail_slot[info->LayoutTable[i][j]];
 			first_avail_slot[info->LayoutTable[i][j]]++;
 		}
 
-	/* initialize block table */
+	/* Initialize block table. */
 	for (SUID = l = 0; l < layoutPtr->SUsPerPU; l++) {
 		for (i = 0; i < b; i++) {
 			for (j = 0; j < k; j++) {
-				info->BlockTable[(info->OffsetTable[i][j] * layoutPtr->SUsPerPU) + l]
+				info->BlockTable[(info->OffsetTable[i][j] *
+				     layoutPtr->SUsPerPU) + l]
 				    [info->LayoutTable[i][j]] = SUID;
 			}
 			SUID++;
@@ -250,57 +300,63 @@ rf_ConfigureDeclusteredPQ(
 
 	rf_free_1d_array(first_avail_slot, v);
 
-	/* 5.  set up the remaining redundant-but-useful parameters */
-
-	raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow * info->ExtraTablesPerDisk) *
-	    info->SUsPerTable * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numStripe = (raidPtr->totalSectors / layoutPtr->sectorsPerStripeUnit) / (k - 2);
+	/* 5. Set up the remaining redundant-but-useful parameters. */
 
-	/* strange evaluation order below to try and minimize overflow
-	 * problems */
+	raidPtr->totalSectors = (k * complete_FT_count + raidPtr->numRow *
+	    info->ExtraTablesPerDisk) * info->SUsPerTable *
+	    layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->numStripe = (raidPtr->totalSectors /
+	    layoutPtr->sectorsPerStripeUnit) / (k - 2);
 
-	layoutPtr->dataSectorsPerStripe = (k - 2) * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	/*
+	 * Strange evaluation order below to try and minimize overflow
+	 * problems.
+	 */
+
+	layoutPtr->dataSectorsPerStripe = (k - 2) *
+	    layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = k - 2;
 	layoutPtr->numParityCol = 2;
 
 	return (0);
 }
 
-int 
-rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t * raidPtr)
+int
+rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t *raidPtr)
 {
-	int     def_decl;
+	int def_decl;
 
 	def_decl = rf_GetDefaultNumFloatingReconBuffersDeclustered(raidPtr);
 	return (RF_MAX(3 * raidPtr->numCol, def_decl));
 }
 
-void 
-rf_MapSectorDeclusteredPQ(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapSectorDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
 	RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
 	RF_StripeNum_t BlockID, BlockOffset, RepIndex;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
+	    layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
 
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
+	/* Fulltable ID within array (across rows). */
+	FullTableID = SUID / sus_per_fulltable;
 	*row = FullTableID % raidPtr->numRow;
-	FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on this
-					 * disk */
+
+	/* Convert to fulltable ID on this disk. */
+	FullTableID /= raidPtr->numRow;
+
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
 		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
 		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
@@ -313,71 +369,82 @@ rf_MapSectorDeclusteredPQ(
 	BlockID %= info->BlocksPerTable;
 	RF_ASSERT(BlockOffset < info->groupSize - 2);
 	/*
-           TableIDs go from 0 .. GroupSize-1 inclusive.
-           PUsPerBlock is k-2.
-           We want the tableIDs to rotate from the
-           right, so use GroupSize
-           */
+	 * TableIDs go from 0 .. GroupSize-1 inclusive.
+	 * PUsPerBlock is k-2.
+	 * We want the tableIDs to rotate from the
+	 * right, so use GroupSize.
+	 */
 	RepIndex = info->groupSize - 1 - TableID;
 	RF_ASSERT(RepIndex >= 0);
 	if (!raidPtr->noRotate) {
 		if (TableID == 0)
-			BlockOffset++;	/* P on last drive, Q on first */
+			/* P on last drive, Q on first. */
+			BlockOffset++;
 		else
-			BlockOffset += ((BlockOffset >= RepIndex) ? 2 : 0);	/* skip over PQ */
+			/* Skip over PQ. */
+			BlockOffset += ((BlockOffset >= RepIndex) ? 2 : 0);
+
 		RF_ASSERT(BlockOffset < info->groupSize);
 		*col = info->LayoutTable[BlockID][BlockOffset];
 	}
-	/* remap to distributed spare space if indicated */
+	/* Remap to distributed spare space if indicated. */
 	if (remap) {
-		rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID, TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col, &outSU);
+		rf_remap_to_spare_space(layoutPtr, info, *row, FullTableID,
+		    TableID, BlockID, (base_suid) ? 1 : 0, SpareRegion, col,
+		    &outSU);
 	} else {
 
 		outSU = base_suid;
-		outSU += FullTableID * fulltable_depth;	/* offs to strt of FT */
-		outSU += SpareSpace;	/* skip rsvd spare space */
-		outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;	/* offs to strt of tble */
-		outSU += info->OffsetTable[BlockID][BlockOffset] * layoutPtr->SUsPerPU;	/* offs to the PU */
+		outSU += FullTableID * fulltable_depth;
+			/* Offset to strt of FT. */
+		outSU += SpareSpace;
+			/* Skip reserved spare space. */
+		outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
+			/* Offset to start of table. */
+		outSU += info->OffsetTable[BlockID][BlockOffset] *
+		    layoutPtr->SUsPerPU;
+			/* Offset to the PU. */
 	}
-	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);	/* offs to the SU within
-										 * a PU */
+	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
+		/* Offset to the SU within a PU. */
 
-	/* convert SUs to sectors, and, if not aligned to SU boundary, add in
-	 * offset to sector */
-	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit + (raidSector % layoutPtr->sectorsPerStripeUnit);
+	/*
+	 * Convert SUs to sectors, and, if not aligned to SU boundary, add in
+	 * offset to sector.
+	 */
+	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
+	    (raidSector % layoutPtr->sectorsPerStripeUnit);
 }
 
 
-void 
-rf_MapParityDeclusteredPQ(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
 	RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
 	RF_StripeNum_t BlockID, BlockOffset, RepIndex;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
+	    layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
 
-	/* compute row & (possibly) spare space exactly as before */
+	/* Compute row & (possibly) spare space exactly as before. */
 	FullTableID = SUID / sus_per_fulltable;
 	*row = FullTableID % raidPtr->numRow;
-	FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on this
-					 * disk */
+	/* Convert to fulltable ID on this disk. */
+	FullTableID /= raidPtr->numRow;
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
 		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
 		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
 	}
-	/* compute BlockID and RepIndex exactly as before */
+	/* Compute BlockID and RepIndex exactly as before. */
 	FullTableOffset = SUID % sus_per_fulltable;
 	TableID = FullTableOffset / info->SUsPerTable;
 	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
@@ -385,15 +452,18 @@ rf_MapParityDeclusteredPQ(
 	BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
 	BlockID %= info->BlocksPerTable;
 
-	/* the parity block is in the position indicated by RepIndex */
-	RepIndex = (raidPtr->noRotate) ? info->PUsPerBlock : info->groupSize - 1 - TableID;
+	/* The parity block is in the position indicated by RepIndex. */
+	RepIndex = (raidPtr->noRotate) ?
+	    info->PUsPerBlock : info->groupSize - 1 - TableID;
 	*col = info->LayoutTable[BlockID][RepIndex];
 
 	if (remap)
 		RF_PANIC();
 
-	/* compute sector as before, except use RepIndex instead of
-	 * BlockOffset */
+	/*
+	 * Compute sector as before, except use RepIndex instead of
+	 * BlockOffset.
+	 */
 	outSU = base_suid;
 	outSU += FullTableID * fulltable_depth;
 	outSU += SpareSpace;	/* skip rsvd spare space */
@@ -401,39 +471,38 @@ rf_MapParityDeclusteredPQ(
 	outSU += info->OffsetTable[BlockID][RepIndex] * layoutPtr->SUsPerPU;
 	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
 
-	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit + (raidSector % layoutPtr->sectorsPerStripeUnit);
+	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
+	    (raidSector % layoutPtr->sectorsPerStripeUnit);
 }
 
-void 
-rf_MapQDeclusteredPQ(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapQDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / layoutPtr->sectorsPerStripeUnit;
 	RF_StripeNum_t FullTableID, FullTableOffset, TableID, TableOffset;
 	RF_StripeNum_t BlockID, BlockOffset, RepIndex, RepIndexQ;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
+	    layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
 
-	/* compute row & (possibly) spare space exactly as before */
+	/* Compute row & (possibly) spare space exactly as before. */
 	FullTableID = SUID / sus_per_fulltable;
 	*row = FullTableID % raidPtr->numRow;
-	FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on this
-					 * disk */
+	/* Convert to fulltable ID on this disk. */
+	FullTableID /= raidPtr->numRow;
 	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
 		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
 		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
 	}
-	/* compute BlockID and RepIndex exactly as before */
+	/* Compute BlockID and RepIndex exactly as before. */
 	FullTableOffset = SUID % sus_per_fulltable;
 	TableID = FullTableOffset / info->SUsPerTable;
 	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
@@ -441,16 +510,19 @@ rf_MapQDeclusteredPQ(
 	BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
 	BlockID %= info->BlocksPerTable;
 
-	/* the q block is in the position indicated by RepIndex */
-	RepIndex = (raidPtr->noRotate) ? info->PUsPerBlock : info->groupSize - 1 - TableID;
+	/* The q block is in the position indicated by RepIndex. */
+	RepIndex = (raidPtr->noRotate) ?
+	    info->PUsPerBlock : info->groupSize - 1 - TableID;
 	RepIndexQ = ((RepIndex == (info->groupSize - 1)) ? 0 : RepIndex + 1);
 	*col = info->LayoutTable[BlockID][RepIndexQ];
 
 	if (remap)
 		RF_PANIC();
 
-	/* compute sector as before, except use RepIndex instead of
-	 * BlockOffset */
+	/*
+	 * Compute sector as before, except use RepIndex instead of
+	 * BlockOffset.
+	 */
 	outSU = base_suid;
 	outSU += FullTableID * fulltable_depth;
 	outSU += SpareSpace;	/* skip rsvd spare space */
@@ -458,34 +530,38 @@ rf_MapQDeclusteredPQ(
 	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
 
 	outSU += info->OffsetTable[BlockID][RepIndexQ] * layoutPtr->SUsPerPU;
-	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit + (raidSector % layoutPtr->sectorsPerStripeUnit);
+	*diskSector = outSU * layoutPtr->sectorsPerStripeUnit +
+	    (raidSector % layoutPtr->sectorsPerStripeUnit);
 }
-/* returns an array of ints identifying the disks that comprise the stripe containing the indicated address.
- * the caller must _never_ attempt to modify this array.
+
+/*
+ * Returns an array of ints identifying the disks that comprise the stripe
+ * containing the indicated address.
+ * The caller must _never_ attempt to modify this array.
  */
-void 
-rf_IdentifyStripeDeclusteredPQ(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeDeclusteredPQ(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
+	RF_DeclusteredConfigInfo_t *info =
+	    (RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo;
 	RF_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs * layoutPtr->SUsPerPU;
+	RF_StripeCount_t fulltable_depth = info->FullTableDepthInPUs *
+	    layoutPtr->SUsPerPU;
 	RF_StripeNum_t base_suid = 0;
 	RF_StripeNum_t SUID = rf_RaidAddressToStripeUnitID(layoutPtr, addr);
 	RF_StripeNum_t stripeID, FullTableID;
-	int     tableOffset;
+	int tableOffset;
 
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
+	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable,
+	    &fulltable_depth, &base_suid);
+	/* Fulltable ID within array (across rows). */
+	FullTableID = SUID / sus_per_fulltable;
 	*outRow = FullTableID % raidPtr->numRow;
-	stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);	/* find stripe offset
-								 * into array */
-	tableOffset = (stripeID % info->BlocksPerTable);	/* find offset into
-								 * block design table */
+	/* Find stripe offset into array. */
+	stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);
+	/* Find offset into block design table. */
+	tableOffset = (stripeID % info->BlocksPerTable);
 	*diskids = info->LayoutTable[tableOffset];
 }
diff --git a/sys/dev/raidframe/rf_declusterPQ.h b/sys/dev/raidframe/rf_declusterPQ.h
index f83ec3d7d5d..9d9d6c421c3 100644
--- a/sys/dev/raidframe/rf_declusterPQ.h
+++ b/sys/dev/raidframe/rf_declusterPQ.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_declusterPQ.h,v 1.2 1999/02/16 00:02:35 niklas Exp $	*/
+/*	$OpenBSD: rf_declusterPQ.h,v 1.3 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_declusterPQ.h,v 1.3 1999/02/05 00:06:09 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,26 +28,21 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_DECLUSTERPQ_H_
-#define _RF__RF_DECLUSTERPQ_H_
+#ifndef	_RF__RF_DECLUSTERPQ_H_
+#define	_RF__RF_DECLUSTERPQ_H_
 
 #include "rf_types.h"
 
-int 
-rf_ConfigureDeclusteredPQ(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int     rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t * raidPtr);
-void 
-rf_MapSectorDeclusteredPQ(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityDeclusteredPQ(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapQDeclusteredPQ(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeDeclusteredPQ(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
+int  rf_ConfigureDeclusteredPQ(RF_ShutdownList_t **, RF_Raid_t *,
+	RF_Config_t *);
+int  rf_GetDefaultNumFloatingReconBuffersPQ(RF_Raid_t *);
+void rf_MapSectorDeclusteredPQ(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityDeclusteredPQ(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapQDeclusteredPQ(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeDeclusteredPQ(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t **,
+	RF_RowCol_t *);
 
-#endif				/* !_RF__RF_DECLUSTERPQ_H_ */
+#endif	/* ! _RF__RF_DECLUSTERPQ_H_ */
diff --git a/sys/dev/raidframe/rf_desc.h b/sys/dev/raidframe/rf_desc.h
index 84b4cb109a8..1b673a9d8d3 100644
--- a/sys/dev/raidframe/rf_desc.h
+++ b/sys/dev/raidframe/rf_desc.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_desc.h,v 1.5 2000/01/11 18:02:21 peter Exp $	*/
+/*	$OpenBSD: rf_desc.h,v 1.6 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_desc.h,v 1.5 2000/01/09 00:00:18 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,8 +28,8 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_DESC_H_
-#define _RF__RF_DESC_H_
+#ifndef	_RF__RF_DESC_H_
+#define	_RF__RF_DESC_H_
 
 #include "rf_archs.h"
 #include "rf_types.h"
@@ -36,78 +37,115 @@
 #include "rf_dag.h"
 
 struct RF_RaidReconDesc_s {
-	RF_Raid_t *raidPtr;	/* raid device descriptor */
-	RF_RowCol_t row;	/* row of failed disk */
-	RF_RowCol_t col;	/* col of failed disk */
-	int     state;		/* how far along the reconstruction operation
-				 * has gotten */
-	RF_RaidDisk_t *spareDiskPtr;	/* describes target disk for recon
-					 * (not used in dist sparing) */
-	int     numDisksDone;	/* the number of surviving disks that have
-				 * completed their work */
-	RF_RowCol_t srow;	/* row ID of the spare disk (not used in dist
-				 * sparing) */
-	RF_RowCol_t scol;	/* col ID of the spare disk (not used in dist
-				 * sparing) */
+	RF_Raid_t	*raidPtr;	/* Raid device descriptor. */
+	RF_RowCol_t	 row;		/* Row of failed disk. */
+	RF_RowCol_t	 col;		/* Col of failed disk. */
+	int		 state;		/*
+					 * How far along the reconstruction
+					 * operation has gotten.
+					 */
+	RF_RaidDisk_t	*spareDiskPtr;	/*
+					 * Describes target disk for recon.
+					 * (not used in dist sparing)
+					 */
+	int		 numDisksDone;	/*
+					 * The number of surviving disks that
+					 * have completed their work.
+					 */
+	RF_RowCol_t	 srow;		/*
+					 * Row ID of the spare disk.
+					 * (not used in dist sparing)
+					 */
+	RF_RowCol_t	 scol;		/*
+					 * Col ID of the spare disk.
+					 * (not used in dist sparing)
+					 */
 	/*
          * Prevent recon from hogging CPU
          */
-	RF_Etimer_t recon_exec_timer;
-	RF_uint64 reconExecTimerRunning;
-	RF_uint64 reconExecTicks;
-	RF_uint64 maxReconExecTicks;
+	RF_Etimer_t	 recon_exec_timer;
+	RF_uint64	 reconExecTimerRunning;
+	RF_uint64	 reconExecTicks;
+	RF_uint64	 maxReconExecTicks;
 
-#if RF_RECON_STATS > 0
-	RF_uint64 hsStallCount;	/* head sep stall count */
-	RF_uint64 numReconExecDelays;
-	RF_uint64 numReconEventWaits;
-#endif				/* RF_RECON_STATS > 0 */
+#if	RF_RECON_STATS > 0
+	RF_uint64	 hsStallCount;	/* Head sep stall count. */
+	RF_uint64	 numReconExecDelays;
+	RF_uint64	 numReconEventWaits;
+#endif	/* RF_RECON_STATS > 0 */
 	RF_RaidReconDesc_t *next;
 };
 
 struct RF_RaidAccessDesc_s {
-	RF_Raid_t *raidPtr;	/* raid device descriptor */
-	RF_IoType_t type;	/* read or write */
-	RF_RaidAddr_t raidAddress;	/* starting address in raid address
-					 * space */
-	RF_SectorCount_t numBlocks;	/* number of blocks (sectors) to
-					 * transfer */
-	RF_StripeCount_t numStripes;	/* number of stripes involved in
-					 * access */
-	caddr_t bufPtr;		/* pointer to data buffer */
-	RF_RaidAccessFlags_t flags;	/* flags controlling operation */
-	int     state;		/* index into states telling how far along the
-				 * RAID operation has gotten */
-	RF_AccessState_t *states;	/* array of states to be run */
-	int     status;		/* pass/fail status of the last operation */
-	RF_DagList_t *dagArray;	/* array of dag lists, one list per stripe */
-	RF_AccessStripeMapHeader_t *asmap;	/* the asm for this I/O */
-	void   *bp;		/* buf pointer for this RAID acc.  ignored
-				 * outside the kernel */
-	RF_DagHeader_t **paramDAG;	/* allows the DAG to be returned to
-					 * the caller after I/O completion */
-	RF_AccessStripeMapHeader_t **paramASM;	/* allows the ASM to be
+	RF_Raid_t	 *raidPtr;	/* Raid device descriptor. */
+	RF_IoType_t	  type;		/* Read or write. */
+	RF_RaidAddr_t	  raidAddress;	/*
+					 * Starting address in raid address
+					 * space.
+					 */
+	RF_SectorCount_t  numBlocks;	/*
+					 * Number of blocks (sectors)
+					 * to transfer.
+					 */
+	RF_StripeCount_t  numStripes;	/*
+					 * Number of stripes involved in
+					 * access.
+					 */
+	caddr_t		  bufPtr;	/* Pointer to data buffer. */
+	RF_RaidAccessFlags_t flags;	/* Flags controlling operation. */
+	int		  state;	/*
+					 * Index into states telling how far
+					 * along the RAID operation has gotten.
+					 */
+	RF_AccessState_t *states;	/* Array of states to be run. */
+	int		  status;	/*
+					 * Pass/fail status of the last
+					 * operation.
+					 */
+	RF_DagList_t	 *dagArray;	/*
+					 * Array of DAG lists, one list
+					 * per stripe.
+					 */
+	RF_AccessStripeMapHeader_t *asmap; /* The asm for this I/O. */
+	void		 *bp;		/*
+					 * Buffer pointer for this RAID acc.
+					 * Ignored outside the kernel.
+					 */
+	RF_DagHeader_t	**paramDAG;	/*
+					 * Allows the DAG to be returned to
+					 * the caller after I/O completion.
+					 */
+	RF_AccessStripeMapHeader_t **paramASM;	/*
+						 * Allows the ASM to be
 						 * returned to the caller
-						 * after I/O completion */
-	RF_AccTraceEntry_t tracerec;	/* perf monitoring information for a
-					 * user access (not for dag stats) */
-	void    (*callbackFunc) (RF_CBParam_t);	/* callback function for this
-						 * I/O */
-	void   *callbackArg;	/* arg to give to callback func */
+						 * after I/O completion.
+						 */
+	RF_AccTraceEntry_t tracerec;	/*
+					 * Perf monitoring information for a
+					 * user access (not for dag stats).
+					 */
+	void		(*callbackFunc) (RF_CBParam_t);
+					/* Callback function for this I/O. */
+	void		 *callbackArg;	/* Arg to give to callback func. */
 
-	RF_AllocListElem_t *cleanupList;	/* memory to be freed at the
-						 * end of the access */
+	RF_AllocListElem_t *cleanupList; /*
+					  * Memory to be freed at the
+					  * end of the access.
+					  */
 
 	RF_RaidAccessDesc_t *next;
 	RF_RaidAccessDesc_t *head;
 
-	int     numPending;
+	int		  numPending;
 
-	        RF_DECLARE_MUTEX(mutex)	/* these are used to implement
-					 * blocking I/O */
-	        RF_DECLARE_COND(cond)
-	int     async_flag;
+	RF_DECLARE_MUTEX( mutex );	/*
+					 * These are used to implement
+					 * blocking I/O.
+					 */
+	RF_DECLARE_COND(  cond );
+	int		  async_flag;
 
-	RF_Etimer_t timer;	/* used for timing this access */
+	RF_Etimer_t	  timer;	/* Used for timing this access. */
 };
-#endif				/* !_RF__RF_DESC_H_ */
+
+#endif	/* ! _RF__RF_DESC_H_ */
diff --git a/sys/dev/raidframe/rf_diskqueue.c b/sys/dev/raidframe/rf_diskqueue.c
index d324f43fadc..e29d25b81a2 100644
--- a/sys/dev/raidframe/rf_diskqueue.c
+++ b/sys/dev/raidframe/rf_diskqueue.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_diskqueue.c,v 1.6 2000/08/08 16:07:40 peter Exp $	*/
+/*	$OpenBSD: rf_diskqueue.c,v 1.7 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_diskqueue.c,v 1.13 2000/03/04 04:22:34 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,44 +28,44 @@
  * rights to redistribute these changes.
  */
 
-/****************************************************************************
+/*****************************************************************************
  *
- * rf_diskqueue.c -- higher-level disk queue code
+ * rf_diskqueue.c -- Higher-level disk queue code.
  *
- * the routines here are a generic wrapper around the actual queueing
- * routines.  The code here implements thread scheduling, synchronization,
+ * The routines here are a generic wrapper around the actual queueing
+ * routines. The code here implements thread scheduling, synchronization,
  * and locking ops (see below) on top of the lower-level queueing code.
  *
- * to support atomic RMW, we implement "locking operations".  When a
+ * To support atomic RMW, we implement "locking operations". When a
  * locking op is dispatched to the lower levels of the driver, the
  * queue is locked, and no further I/Os are dispatched until the queue
- * receives & completes a corresponding "unlocking operation".  This
+ * receives & completes a corresponding "unlocking operation". This
  * code relies on the higher layers to guarantee that a locking op
- * will always be eventually followed by an unlocking op.  The model
+ * will always be eventually followed by an unlocking op. The model
  * is that the higher layers are structured so locking and unlocking
  * ops occur in pairs, i.e.  an unlocking op cannot be generated until
- * after a locking op reports completion.  There is no good way to
+ * after a locking op reports completion. There is no good way to
  * check to see that an unlocking op "corresponds" to the op that
- * currently has the queue locked, so we make no such attempt.  Since
+ * currently has the queue locked, so we make no such attempt. Since
  * by definition there can be only one locking op outstanding on a
  * disk, this should not be a problem.
  *
  * In the kernel, we allow multiple I/Os to be concurrently dispatched
- * to the disk driver.  In order to support locking ops in this
+ * to the disk driver. In order to support locking ops in this
  * environment, when we decide to do a locking op, we stop dispatching
  * new I/Os and wait until all dispatched I/Os have completed before
  * dispatching the locking op.
  *
  * Unfortunately, the code is different in the 3 different operating
- * states (user level, kernel, simulator).  In the kernel, I/O is
+ * states (user level, kernel, simulator). In the kernel, I/O is
  * non-blocking, and we have no disk threads to dispatch for us.
  * Therefore, we have to dispatch new I/Os to the scsi driver at the
- * time of enqueue, and also at the time of completion.  At user
+ * time of enqueue, and also at the time of completion. At user
  * level, I/O is blocking, and so only the disk threads may dispatch
- * I/Os.  Thus at user level, all we can do at enqueue time is enqueue
+ * I/Os. Thus at user level, all we can do at enqueue time is enqueue
  * and wake up the disk thread to do the dispatch.
  *
- ****************************************************************************/
+ *****************************************************************************/
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
@@ -83,21 +84,33 @@
 #include "rf_fifo.h"
 #include "rf_kintf.h"
 
-static int init_dqd(RF_DiskQueueData_t *);
-static void clean_dqd(RF_DiskQueueData_t *);
-static void rf_ShutdownDiskQueueSystem(void *);
-
-#define Dprintf1(s,a)         if (rf_queueDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf2(s,a,b)       if (rf_queueDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf3(s,a,b,c)     if (rf_queueDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
+int  rf_init_dqd(RF_DiskQueueData_t *);
+void rf_clean_dqd(RF_DiskQueueData_t *);
+void rf_ShutdownDiskQueueSystem(void *);
+
+#define	Dprintf1(s,a)							\
+	if (rf_queueDebug)						\
+		rf_debug_printf(s,(void *)((unsigned long)a),		\
+		    NULL,NULL,NULL,NULL,NULL,NULL,NULL)
+#define	Dprintf2(s,a,b)							\
+	if (rf_queueDebug)						\
+		rf_debug_printf(s,(void *)((unsigned long)a),		\
+		    (void *)((unsigned long)b),				\
+		    NULL,NULL,NULL,NULL,NULL,NULL)
+#define	Dprintf3(s,a,b,c)						\
+	if (rf_queueDebug)						\
+		rf_debug_printf(s,(void *)((unsigned long)a),		\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    NULL,NULL,NULL,NULL,NULL)
 
 /*****************************************************************************
  *
- * the disk queue switch defines all the functions used in the
+ * The disk queue switch defines all the functions used in the
  * different queueing disciplines queue ID, init routine, enqueue
- * routine, dequeue routine
+ * routine, dequeue routine.
  *
- ****************************************************************************/
+ *****************************************************************************/
 
 static RF_DiskQueueSW_t diskqueuesw[] = {
 	{"fifo",		/* FIFO */
@@ -105,85 +118,85 @@ static RF_DiskQueueSW_t diskqueuesw[] = {
 		rf_FifoEnqueue,
 		rf_FifoDequeue,
 		rf_FifoPeek,
-	rf_FifoPromote},
+		rf_FifoPromote},
 
 	{"cvscan",		/* cvscan */
 		rf_CvscanCreate,
 		rf_CvscanEnqueue,
 		rf_CvscanDequeue,
 		rf_CvscanPeek,
-	rf_CvscanPromote},
+		rf_CvscanPromote},
 
 	{"sstf",		/* shortest seek time first */
 		rf_SstfCreate,
 		rf_SstfEnqueue,
 		rf_SstfDequeue,
 		rf_SstfPeek,
-	rf_SstfPromote},
+		rf_SstfPromote},
 
 	{"scan",		/* SCAN (two-way elevator) */
 		rf_ScanCreate,
 		rf_SstfEnqueue,
 		rf_ScanDequeue,
 		rf_ScanPeek,
-	rf_SstfPromote},
+		rf_SstfPromote},
 
 	{"cscan",		/* CSCAN (one-way elevator) */
 		rf_CscanCreate,
 		rf_SstfEnqueue,
 		rf_CscanDequeue,
 		rf_CscanPeek,
-	rf_SstfPromote},
+		rf_SstfPromote},
 
 };
-#define NUM_DISK_QUEUE_TYPES (sizeof(diskqueuesw)/sizeof(RF_DiskQueueSW_t))
+#define	NUM_DISK_QUEUE_TYPES	(sizeof(diskqueuesw)/sizeof(RF_DiskQueueSW_t))
 
 static RF_FreeList_t *rf_dqd_freelist;
 
-#define RF_MAX_FREE_DQD 256
-#define RF_DQD_INC       16
-#define RF_DQD_INITIAL   64
+#define	RF_MAX_FREE_DQD		256
+#define	RF_DQD_INC		 16
+#define	RF_DQD_INITIAL		 64
 
 #include <sys/buf.h>
 
-static int 
-init_dqd(dqd)
-	RF_DiskQueueData_t *dqd;
+int
+rf_init_dqd(RF_DiskQueueData_t *dqd)
 {
 
-	dqd->bp = (struct buf *) malloc(sizeof(struct buf), 
-					M_RAIDFRAME, M_NOWAIT);
+	dqd->bp = (struct buf *) malloc(sizeof(struct buf), M_RAIDFRAME,
+	    M_NOWAIT);
 	if (dqd->bp == NULL) {
 		return (ENOMEM);
 	}
-	memset(dqd->bp, 0, sizeof(struct buf));	/* if you don't do it, nobody
-						 * else will.. */
+	/* If you don't do it, nobody else will... */
+	memset(dqd->bp, 0, sizeof(struct buf));
+
 	return (0);
 }
 
-static void 
-clean_dqd(dqd)
-	RF_DiskQueueData_t *dqd;
+void
+rf_clean_dqd(RF_DiskQueueData_t *dqd)
 {
 	free(dqd->bp, M_RAIDFRAME);
 }
-/* configures a single disk queue */
 
-int 
+/* Configure a single disk queue. */
+int
 rf_ConfigureDiskQueue(
-      RF_Raid_t * raidPtr,
-      RF_DiskQueue_t * diskqueue,
-      RF_RowCol_t r,		/* row & col -- debug only.  BZZT not any
-				 * more... */
-      RF_RowCol_t c,
-      RF_DiskQueueSW_t * p,
-      RF_SectorCount_t sectPerDisk,
-      dev_t dev,
-      int maxOutstanding,
-      RF_ShutdownList_t ** listp,
-      RF_AllocListElem_t * clList)
+	RF_Raid_t		 *raidPtr,
+	RF_DiskQueue_t		 *diskqueue,
+	/* row & col -- Debug only.  BZZT not any more... */
+	RF_RowCol_t		  r,
+	RF_RowCol_t		  c,
+	RF_DiskQueueSW_t	 *p,
+	RF_SectorCount_t	  sectPerDisk,
+	dev_t			  dev,
+	int			  maxOutstanding,
+	RF_ShutdownList_t	**listp,
+	RF_AllocListElem_t	 *clList
+)
 {
-	int     rc;
+	int rc;
 
 	diskqueue->row = r;
 	diskqueue->col = c;
@@ -202,58 +215,55 @@ rf_ConfigureDiskQueue(
 	diskqueue->rf_cinfo = &raidPtr->raid_cinfo[r][c];
 	rc = rf_create_managed_mutex(listp, &diskqueue->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, &diskqueue->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);
 	}
 	return (0);
 }
 
-static void 
-rf_ShutdownDiskQueueSystem(ignored)
-	void   *ignored;
+void
+rf_ShutdownDiskQueueSystem(void *ignored)
 {
-	RF_FREELIST_DESTROY_CLEAN(rf_dqd_freelist, next, (RF_DiskQueueData_t *), clean_dqd);
+	RF_FREELIST_DESTROY_CLEAN(rf_dqd_freelist, next,
+	    (RF_DiskQueueData_t *), rf_clean_dqd);
 }
 
-int 
-rf_ConfigureDiskQueueSystem(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureDiskQueueSystem(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
-	RF_FREELIST_CREATE(rf_dqd_freelist, RF_MAX_FREE_DQD,
-	    RF_DQD_INC, sizeof(RF_DiskQueueData_t));
+	RF_FREELIST_CREATE(rf_dqd_freelist, RF_MAX_FREE_DQD, RF_DQD_INC,
+	    sizeof(RF_DiskQueueData_t));
 	if (rf_dqd_freelist == NULL)
 		return (ENOMEM);
 	rc = rf_ShutdownCreate(listp, rf_ShutdownDiskQueueSystem, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownDiskQueueSystem(NULL);
 		return (rc);
 	}
 	RF_FREELIST_PRIME_INIT(rf_dqd_freelist, RF_DQD_INITIAL, next,
-	    (RF_DiskQueueData_t *), init_dqd);
+	    (RF_DiskQueueData_t *), rf_init_dqd);
 	return (0);
 }
 
-int 
-rf_ConfigureDiskQueues(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureDiskQueues(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_DiskQueue_t **diskQueues, *spareQueues;
 	RF_DiskQueueSW_t *p;
 	RF_RowCol_t r, c;
-	int     rc, i;
+	int rc, i;
 
 	raidPtr->maxQueueDepth = cfgPtr->maxOutstandingDiskReqs;
 
@@ -264,29 +274,30 @@ rf_ConfigureDiskQueues(
 		}
 	}
 	if (p == NULL) {
-		RF_ERRORMSG2("Unknown queue type \"%s\".  Using %s\n", cfgPtr->diskQueueType, diskqueuesw[0].queueType);
+		RF_ERRORMSG2("Unknown queue type \"%s\".  Using %s\n",
+		    cfgPtr->diskQueueType, diskqueuesw[0].queueType);
 		p = &diskqueuesw[0];
 	}
 	raidPtr->qType = p;
-	RF_CallocAndAdd(diskQueues, raidPtr->numRow, sizeof(RF_DiskQueue_t *), (RF_DiskQueue_t **), raidPtr->cleanupList);
+	RF_CallocAndAdd(diskQueues, raidPtr->numRow, sizeof(RF_DiskQueue_t *),
+	    (RF_DiskQueue_t **), raidPtr->cleanupList);
 	if (diskQueues == NULL) {
 		return (ENOMEM);
 	}
 	raidPtr->Queues = diskQueues;
 	for (r = 0; r < raidPtr->numRow; r++) {
-		RF_CallocAndAdd(diskQueues[r], raidPtr->numCol + 
-				 ((r == 0) ? RF_MAXSPARE : 0), 
-				sizeof(RF_DiskQueue_t), (RF_DiskQueue_t *), 
+		RF_CallocAndAdd(diskQueues[r], raidPtr->numCol +
+				 ((r == 0) ? RF_MAXSPARE : 0),
+				sizeof(RF_DiskQueue_t), (RF_DiskQueue_t *),
 				raidPtr->cleanupList);
 		if (diskQueues[r] == NULL)
 			return (ENOMEM);
 		for (c = 0; c < raidPtr->numCol; c++) {
 			rc = rf_ConfigureDiskQueue(raidPtr, &diskQueues[r][c],
-						   r, c, p,
-						   raidPtr->sectorsPerDisk, 
-						   raidPtr->Disks[r][c].dev,
-						   cfgPtr->maxOutstandingDiskReqs, 
-						   listp, raidPtr->cleanupList);
+			    r, c, p, raidPtr->sectorsPerDisk,
+			    raidPtr->Disks[r][c].dev,
+			    cfgPtr->maxOutstandingDiskReqs, listp,
+			    raidPtr->cleanupList);
 			if (rc)
 				return (rc);
 		}
@@ -294,9 +305,8 @@ rf_ConfigureDiskQueues(
 
 	spareQueues = &raidPtr->Queues[0][raidPtr->numCol];
 	for (r = 0; r < raidPtr->numSpare; r++) {
-		rc = rf_ConfigureDiskQueue(raidPtr, &spareQueues[r],
-		    0, raidPtr->numCol + r, p,
-		    raidPtr->sectorsPerDisk,
+		rc = rf_ConfigureDiskQueue(raidPtr, &spareQueues[r], 0,
+		    raidPtr->numCol + r, p, raidPtr->sectorsPerDisk,
 		    raidPtr->Disks[0][raidPtr->numCol + r].dev,
 		    cfgPtr->maxOutstandingDiskReqs, listp,
 		    raidPtr->cleanupList);
@@ -305,7 +315,9 @@ rf_ConfigureDiskQueues(
 	}
 	return (0);
 }
-/* Enqueue a disk I/O
+
+/*
+ * Enqueue a disk I/O
  *
  * Unfortunately, we have to do things differently in the different
  * environments (simulator, user-level, kernel).
@@ -314,31 +326,28 @@ rf_ConfigureDiskQueues(
  * In the kernel, I/O is non-blocking and so we'd like to have multiple
  * I/Os outstanding on the physical disks when possible.
  *
- * when any request arrives at a queue, we have two choices:
+ * When any request arrives at a queue, we have two choices:
  *    dispatch it to the lower levels
  *    queue it up
  *
- * kernel rules for when to do what:
- *    locking request:  queue empty => dispatch and lock queue,
- *                      else queue it
- *    unlocking req  :  always dispatch it
- *    normal req     :  queue empty => dispatch it & set priority
- *                      queue not full & priority is ok => dispatch it
- *                      else queue it
+ * Kernel rules for when to do what:
+ *    locking request:	Queue empty => dispatch and lock queue,
+ *			else queue it.
+ *    unlocking req  :	Always dispatch it.
+ *    normal req     :	Queue empty => dispatch it & set priority.
+ *			Queue not full & priority is ok => dispatch it
+ *			else queue it.
  *
- * user-level rules:
- *    always enqueue.  In the special case of an unlocking op, enqueue
+ * User-level rules:
+ *    Always enqueue. In the special case of an unlocking op, enqueue
  *    in a special way that will cause the unlocking op to be the next
  *    thing dequeued.
  *
- * simulator rules:
+ * Simulator rules:
  *    Do the same as at user level, with the sleeps and wakeups suppressed.
  */
-void 
-rf_DiskIOEnqueue(queue, req, pri)
-	RF_DiskQueue_t *queue;
-	RF_DiskQueueData_t *req;
-	int     pri;
+void
+rf_DiskIOEnqueue(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req, int pri)
 {
 	RF_ETIMER_START(req->qtime);
 	RF_ASSERT(req->type == RF_IO_TYPE_NOP || req->numSector);
@@ -348,148 +357,208 @@ rf_DiskIOEnqueue(queue, req, pri)
 		printf("Warning: Enqueueing zero-sector access\n");
 	}
 	/*
-         * kernel
+         * Kernel.
          */
 	RF_LOCK_QUEUE_MUTEX(queue, "DiskIOEnqueue");
-	/* locking request */
+	/* Locking request. */
 	if (RF_LOCKING_REQ(req)) {
 		if (RF_QUEUE_EMPTY(queue)) {
-			Dprintf3("Dispatching pri %d locking op to r %d c %d (queue empty)\n", pri, queue->row, queue->col);
+			Dprintf3("Dispatching pri %d locking op to r %d c %d"
+			    " (queue empty)\n", pri, queue->row, queue->col);
 			RF_LOCK_QUEUE(queue);
 			rf_DispatchKernelIO(queue, req);
 		} else {
-			queue->queueLength++;	/* increment count of number
-						 * of requests waiting in this
-						 * queue */
-			Dprintf3("Enqueueing pri %d locking op to r %d c %d (queue not empty)\n", pri, queue->row, queue->col);
+			/*
+			 * Increment count of number of requests waiting
+			 * in this queue.
+			 */
+			queue->queueLength++;
+			Dprintf3("Enqueueing pri %d locking op to r %d c %d"
+			    " (queue not empty)\n", pri, queue->row,
+			    queue->col);
 			req->queue = (void *) queue;
 			(queue->qPtr->Enqueue) (queue->qHdr, req, pri);
 		}
-	}
-	/* unlocking request */
-	else
-		if (RF_UNLOCKING_REQ(req)) {	/* we'll do the actual unlock
-						 * when this I/O completes */
-			Dprintf3("Dispatching pri %d unlocking op to r %d c %d\n", pri, queue->row, queue->col);
+	} else {
+	/* Unlocking request. */
+		if (RF_UNLOCKING_REQ(req)) {
+			/*
+			 * We'll do the actual unlock when this
+			 * I/O completes.
+			 */
+			Dprintf3("Dispatching pri %d unlocking op to r %d"
+			    " c %d\n", pri, queue->row, queue->col);
 			RF_ASSERT(RF_QUEUE_LOCKED(queue));
 			rf_DispatchKernelIO(queue, req);
-		}
-	/* normal request */
-		else
+		} else {
+	/* Normal request. */
 			if (RF_OK_TO_DISPATCH(queue, req)) {
-				Dprintf3("Dispatching pri %d regular op to r %d c %d (ok to dispatch)\n", pri, queue->row, queue->col);
+				Dprintf3("Dispatching pri %d regular op to"
+				    " r %d c %d (ok to dispatch)\n", pri,
+				    queue->row, queue->col);
 				rf_DispatchKernelIO(queue, req);
 			} else {
-				queue->queueLength++;	/* increment count of
-							 * number of requests
-							 * waiting in this queue */
-				Dprintf3("Enqueueing pri %d regular op to r %d c %d (not ok to dispatch)\n", pri, queue->row, queue->col);
+				/*
+				 * Increment count of number of requests
+				 * waiting in this queue.
+				 */
+				queue->queueLength++;
+				Dprintf3("Enqueueing pri %d regular op to"
+				    " r %d c %d (not ok to dispatch)\n", pri,
+				    queue->row, queue->col);
 				req->queue = (void *) queue;
 				(queue->qPtr->Enqueue) (queue->qHdr, req, pri);
 			}
+		}
+	}
 	RF_UNLOCK_QUEUE_MUTEX(queue, "DiskIOEnqueue");
 }
 
 
-/* get the next set of I/Os started, kernel version only */
-void 
-rf_DiskIOComplete(queue, req, status)
-	RF_DiskQueue_t *queue;
-	RF_DiskQueueData_t *req;
-	int     status;
+/* Get the next set of I/Os started, kernel version only. */
+void
+rf_DiskIOComplete(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req, int status)
 {
-	int     done = 0;
+	int done = 0;
 
 	RF_LOCK_QUEUE_MUTEX(queue, "DiskIOComplete");
 
-	/* unlock the queue: (1) after an unlocking req completes (2) after a
-	 * locking req fails */
+	/*
+	 * Unlock the queue:
+	 * (1) after an unlocking req completes.
+	 * (2) after a locking req fails.
+	 */
 	if (RF_UNLOCKING_REQ(req) || (RF_LOCKING_REQ(req) && status)) {
-		Dprintf2("DiskIOComplete: unlocking queue at r %d c %d\n", queue->row, queue->col);
-		RF_ASSERT(RF_QUEUE_LOCKED(queue) && (queue->unlockingOp == NULL));
+		Dprintf2("DiskIOComplete: unlocking queue at r %d c %d\n",
+		    queue->row, queue->col);
+		RF_ASSERT(RF_QUEUE_LOCKED(queue) &&
+		    (queue->unlockingOp == NULL));
 		RF_UNLOCK_QUEUE(queue);
 	}
 	queue->numOutstanding--;
 	RF_ASSERT(queue->numOutstanding >= 0);
 
-	/* dispatch requests to the disk until we find one that we can't. */
-	/* no reason to continue once we've filled up the queue */
-	/* no reason to even start if the queue is locked */
+	/*
+	 * Dispatch requests to the disk until we find one that we can't.
+	 * No reason to continue once we've filled up the queue.
+	 * No reason to even start if the queue is locked.
+	 */
 
 	while (!done && !RF_QUEUE_FULL(queue) && !RF_QUEUE_LOCKED(queue)) {
 		if (queue->nextLockingOp) {
 			req = queue->nextLockingOp;
 			queue->nextLockingOp = NULL;
-			Dprintf3("DiskIOComplete: a pri %d locking req was pending at r %d c %d\n", req->priority, queue->row, queue->col);
+			Dprintf3("DiskIOComplete: a pri %d locking req was"
+			    " pending at r %d c %d\n", req->priority,
+			    queue->row, queue->col);
 		} else {
 			req = (queue->qPtr->Dequeue) (queue->qHdr);
 			if (req != NULL) {
-				Dprintf3("DiskIOComplete: extracting pri %d req from queue at r %d c %d\n", req->priority, queue->row, queue->col);
+				Dprintf3("DiskIOComplete: extracting pri %d"
+				    " req from queue at r %d c %d\n",
+				    req->priority, queue->row, queue->col);
 			} else {
-				Dprintf1("DiskIOComplete: no more requests to extract.\n", "");
+				Dprintf1("DiskIOComplete: no more requests"
+				    " to extract.\n", "");
 			}
 		}
 		if (req) {
-			queue->queueLength--;	/* decrement count of number
-						 * of requests waiting in this
-						 * queue */
+			/*
+			 * Decrement count of number of requests waiting
+			 * in this queue.
+			 */
+			queue->queueLength--;
 			RF_ASSERT(queue->queueLength >= 0);
 		}
 		if (!req)
 			done = 1;
-		else
+		else {
 			if (RF_LOCKING_REQ(req)) {
-				if (RF_QUEUE_EMPTY(queue)) {	/* dispatch it */
-					Dprintf3("DiskIOComplete: dispatching pri %d locking req to r %d c %d (queue empty)\n", req->priority, queue->row, queue->col);
+				if (RF_QUEUE_EMPTY(queue)) {
+					/* Dispatch it. */
+					Dprintf3("DiskIOComplete: dispatching"
+					    " pri %d locking req to r %d c %d"
+					    " (queue empty)\n", req->priority,
+					    queue->row, queue->col);
 					RF_LOCK_QUEUE(queue);
 					rf_DispatchKernelIO(queue, req);
 					done = 1;
-				} else {	/* put it aside to wait for
-						 * the queue to drain */
-					Dprintf3("DiskIOComplete: postponing pri %d locking req to r %d c %d\n", req->priority, queue->row, queue->col);
+				} else {
+					/*
+					 * Put it aside to wait for
+					 * the queue to drain.
+					 */
+					Dprintf3("DiskIOComplete: postponing"
+					    " pri %d locking req to r %d"
+					    " c %d\n", req->priority,
+					    queue->row, queue->col);
 					RF_ASSERT(queue->nextLockingOp == NULL);
 					queue->nextLockingOp = req;
 					done = 1;
 				}
-			} else
-				if (RF_UNLOCKING_REQ(req)) {	/* should not happen:
-								 * unlocking ops should
-								 * not get queued */
-					RF_ASSERT(RF_QUEUE_LOCKED(queue));	/* support it anyway for
-										 * the future */
-					Dprintf3("DiskIOComplete: dispatching pri %d unl req to r %d c %d (SHOULD NOT SEE THIS)\n", req->priority, queue->row, queue->col);
+			} else {
+				if (RF_UNLOCKING_REQ(req)) {
+					/*
+					 * Should not happen:
+					 * Unlocking ops should not get queued.
+					 */
+					/* Support it anyway for the future. */
+					RF_ASSERT(RF_QUEUE_LOCKED(queue));
+					Dprintf3("DiskIOComplete: dispatching"
+					    " pri %d unl req to r %d c %d"
+					    " (SHOULD NOT SEE THIS)\n",
+					    req->priority, queue->row,
+					    queue->col);
 					rf_DispatchKernelIO(queue, req);
 					done = 1;
-				} else
+				} else {
 					if (RF_OK_TO_DISPATCH(queue, req)) {
-						Dprintf3("DiskIOComplete: dispatching pri %d regular req to r %d c %d (ok to dispatch)\n", req->priority, queue->row, queue->col);
+						Dprintf3("DiskIOComplete:"
+						    " dispatching pri %d"
+						    " regular req to r %d"
+						    " c %d (ok to dispatch)\n",
+						    req->priority, queue->row,
+						    queue->col);
 						rf_DispatchKernelIO(queue, req);
-					} else {	/* we can't dispatch it,
-							 * so just re-enqueue
-							 * it.  */
-						/* potential trouble here if
-						 * disk queues batch reqs */
-						Dprintf3("DiskIOComplete: re-enqueueing pri %d regular req to r %d c %d\n", req->priority, queue->row, queue->col);
+					} else {
+						/*
+						 * We can't dispatch it,
+						 * so just re-enqueue
+						 * it.
+						 */
+						/*
+						 * Potential trouble here if
+						 * disk queues batch reqs.
+						 */
+						Dprintf3("DiskIOComplete:"
+						    " re-enqueueing pri %d"
+						    " regular req to r %d"
+						    " c %d\n", req->priority,
+						    queue->row, queue->col);
 						queue->queueLength++;
-						(queue->qPtr->Enqueue) (queue->qHdr, req, req->priority);
+						(queue->qPtr->Enqueue)
+						    (queue->qHdr, req,
+						    req->priority);
 						done = 1;
 					}
+				}
+			}
+		}
 	}
 
 	RF_UNLOCK_QUEUE_MUTEX(queue, "DiskIOComplete");
 }
-/* promotes accesses tagged with the given parityStripeID from low priority
- * to normal priority.  This promotion is optional, meaning that a queue
- * need not implement it.  If there is no promotion routine associated with
+
+/* Promote accesses tagged with the given parityStripeID from low priority
+ * to normal priority. This promotion is optional, meaning that a queue
+ * need not implement it. If there is no promotion routine associated with
  * a queue, this routine does nothing and returns -1.
  */
-int 
-rf_DiskIOPromote(queue, parityStripeID, which_ru)
-	RF_DiskQueue_t *queue;
-	RF_StripeNum_t parityStripeID;
-	RF_ReconUnitNum_t which_ru;
+int
+rf_DiskIOPromote(RF_DiskQueue_t *queue, RF_StripeNum_t parityStripeID,
+    RF_ReconUnitNum_t which_ru)
 {
-	int     retval;
+	int retval;
 
 	if (!queue->qPtr->Promote)
 		return (-1);
@@ -501,23 +570,25 @@ rf_DiskIOPromote(queue, parityStripeID, which_ru)
 
 RF_DiskQueueData_t *
 rf_CreateDiskQueueData(
-    RF_IoType_t typ,
-    RF_SectorNum_t ssect,
-    RF_SectorCount_t nsect,
-    caddr_t buf,
-    RF_StripeNum_t parityStripeID,
-    RF_ReconUnitNum_t which_ru,
-    int (*wakeF) (void *, int),
-    void *arg,
-    RF_DiskQueueData_t * next,
-    RF_AccTraceEntry_t * tracerec,
-    void *raidPtr,
-    RF_DiskQueueDataFlags_t flags,
-    void *kb_proc)
+	RF_IoType_t		  typ,
+	RF_SectorNum_t		  ssect,
+	RF_SectorCount_t	  nsect,
+	caddr_t			  buf,
+	RF_StripeNum_t		  parityStripeID,
+	RF_ReconUnitNum_t	  which_ru,
+	int			(*wakeF) (void *, int),
+	void			 *arg,
+	RF_DiskQueueData_t	 *next,
+	RF_AccTraceEntry_t	 *tracerec,
+	void			 *raidPtr,
+	RF_DiskQueueDataFlags_t	  flags,
+	void			 *kb_proc
+)
 {
 	RF_DiskQueueData_t *p;
 
-	RF_FREELIST_GET_INIT(rf_dqd_freelist, p, next, (RF_DiskQueueData_t *), init_dqd);
+	RF_FREELIST_GET_INIT(rf_dqd_freelist, p, next, (RF_DiskQueueData_t *),
+	    rf_init_dqd);
 
 	p->sectorOffset = ssect + rf_protectedSectors;
 	p->numSector = nsect;
@@ -540,26 +611,28 @@ rf_CreateDiskQueueData(
 
 RF_DiskQueueData_t *
 rf_CreateDiskQueueDataFull(
-    RF_IoType_t typ,
-    RF_SectorNum_t ssect,
-    RF_SectorCount_t nsect,
-    caddr_t buf,
-    RF_StripeNum_t parityStripeID,
-    RF_ReconUnitNum_t which_ru,
-    int (*wakeF) (void *, int),
-    void *arg,
-    RF_DiskQueueData_t * next,
-    RF_AccTraceEntry_t * tracerec,
-    int priority,
-    int (*AuxFunc) (void *,...),
-    caddr_t buf2,
-    void *raidPtr,
-    RF_DiskQueueDataFlags_t flags,
-    void *kb_proc)
+	RF_IoType_t		  typ,
+	RF_SectorNum_t		  ssect,
+	RF_SectorCount_t	  nsect,
+	caddr_t			  buf,
+	RF_StripeNum_t		  parityStripeID,
+	RF_ReconUnitNum_t	  which_ru,
+	int			(*wakeF) (void *, int),
+	void			 *arg,
+	RF_DiskQueueData_t	 *next,
+	RF_AccTraceEntry_t	 *tracerec,
+	int			  priority,
+	int			(*AuxFunc) (void *,...),
+	caddr_t			  buf2,
+	void			 *raidPtr,
+	RF_DiskQueueDataFlags_t	  flags,
+	void			 *kb_proc
+)
 {
 	RF_DiskQueueData_t *p;
 
-	RF_FREELIST_GET_INIT(rf_dqd_freelist, p, next, (RF_DiskQueueData_t *), init_dqd);
+	RF_FREELIST_GET_INIT(rf_dqd_freelist, p, next, (RF_DiskQueueData_t *),
+	    rf_init_dqd);
 
 	p->sectorOffset = ssect + rf_protectedSectors;
 	p->numSector = nsect;
@@ -580,9 +653,8 @@ rf_CreateDiskQueueDataFull(
 	return (p);
 }
 
-void 
-rf_FreeDiskQueueData(p)
-	RF_DiskQueueData_t *p;
+void
+rf_FreeDiskQueueData(RF_DiskQueueData_t *p)
 {
-	RF_FREELIST_FREE_CLEAN(rf_dqd_freelist, p, next, clean_dqd);
+	RF_FREELIST_FREE_CLEAN(rf_dqd_freelist, p, next, rf_clean_dqd);
 }
diff --git a/sys/dev/raidframe/rf_diskqueue.h b/sys/dev/raidframe/rf_diskqueue.h
index fb8e09927bd..d22e791b4f6 100644
--- a/sys/dev/raidframe/rf_diskqueue.h
+++ b/sys/dev/raidframe/rf_diskqueue.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_diskqueue.h,v 1.4 2000/08/08 16:07:40 peter Exp $	*/
+/*	$OpenBSD: rf_diskqueue.h,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_diskqueue.h,v 1.5 2000/02/13 04:53:57 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,17 +28,17 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * rf_diskqueue.h -- header file for disk queues
+ * rf_diskqueue.h -- Header file for disk queues.
  *
- * see comments in rf_diskqueue.c
+ * See comments in rf_diskqueue.c
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 
-#ifndef _RF__RF_DISKQUEUE_H_
-#define _RF__RF_DISKQUEUE_H_
+#ifndef	_RF__RF_DISKQUEUE_H_
+#define	_RF__RF_DISKQUEUE_H_
 
 #include "rf_threadstuff.h"
 #include "rf_acctrace.h"
@@ -46,168 +47,206 @@
 #include "rf_etimer.h"
 
 
-#if defined(__NetBSD__)
+#if	defined(__NetBSD__)
 #include "rf_netbsd.h"
-#elif defined(__OpenBSD__)
+#elif	defined(__OpenBSD__)
 #include "rf_openbsd.h"
 #endif
 
 
-#define RF_IO_NORMAL_PRIORITY 1
-#define RF_IO_LOW_PRIORITY    0
+#define	RF_IO_NORMAL_PRIORITY	1
+#define	RF_IO_LOW_PRIORITY	0
 
-/* the data held by a disk queue entry */
+/* The data held by a disk queue entry. */
 struct RF_DiskQueueData_s {
-	RF_SectorNum_t sectorOffset;	/* sector offset into the disk */
-	RF_SectorCount_t numSector;	/* number of sectors to read/write */
-	RF_IoType_t type;	/* read/write/nop */
-	caddr_t buf;		/* buffer pointer */
-	RF_StripeNum_t parityStripeID;	/* the RAID parity stripe ID this
-					 * access is for */
-	RF_ReconUnitNum_t which_ru;	/* which RU within this parity stripe */
-	int     priority;	/* the priority of this request */
-	int     (*CompleteFunc) (void *, int);	/* function to be called upon
-						 * completion */
-	int     (*AuxFunc) (void *,...);	/* function called upon
-						 * completion of the first I/O
-						 * of a Read_Op_Write pair */
-	void   *argument;	/* argument to be passed to CompleteFunc */
-	RF_Raid_t *raidPtr;	/* needed for simulation */
-	RF_AccTraceEntry_t *tracerec;	/* perf mon only */
-	RF_Etimer_t qtime;	/* perf mon only - time request is in queue */
-	long    entryTime;
+	RF_SectorNum_t	  sectorOffset;	/* Sector offset into the disk. */
+	RF_SectorCount_t  numSector;	/* Number of sectors to read/write. */
+	RF_IoType_t	  type;		/* Read/write/nop. */
+	caddr_t		  buf;		/* Buffer pointer. */
+	RF_StripeNum_t	  parityStripeID;
+					/*
+					 * The RAID parity stripe ID this
+					 * access is for.
+					 */
+	RF_ReconUnitNum_t which_ru;	/* Which RU within this parity stripe */
+	int		  priority;	/* The priority of this request. */
+	int		(*CompleteFunc) (void *, int);
+					/*
+					 * Function to be called upon
+					 * completion.
+					 */
+	int		(*AuxFunc) (void *,...);
+					/*
+					 * Function called upon completion
+					 * of the first I/O of a Read_Op_Write
+					 * pair.
+					 */
+	void		 *argument;	/*
+					 * Argument to be passed to
+					 * CompleteFunc.
+					 */
+	RF_Raid_t	 *raidPtr;	/* Needed for simulation. */
+	RF_AccTraceEntry_t *tracerec;	/* Perf mon only. */
+	RF_Etimer_t	  qtime;	/*
+					 * Perf mon only - time request is
+					 * in queue.
+					 */
+	long		  entryTime;
 	RF_DiskQueueData_t *next;
 	RF_DiskQueueData_t *prev;
-	caddr_t buf2;		/* for read-op-write */
-	dev_t   dev;		/* the device number for in-kernel version */
-	RF_DiskQueue_t *queue;	/* the disk queue to which this req is
-				 * targeted */
-	RF_DiskQueueDataFlags_t flags;	/* flags controlling operation */
-
-	struct proc *b_proc;	/* the b_proc from the original bp passed into
-				 * the driver for this I/O */
-	struct buf *bp;		/* a bp to use to get this I/O done */
+	caddr_t		  buf2;		/* For read-op-write. */
+	dev_t		  dev;		/*
+					 * The device number for in-kernel
+					 * version.
+					 */
+	RF_DiskQueue_t	 *queue;	/*
+					 * The disk queue to which this req
+					 * is targeted.
+					 */
+	RF_DiskQueueDataFlags_t flags;	/* Flags controlling operation. */
+
+	struct proc	 *b_proc;	/*
+					 * The b_proc from the original bp
+					 * passed into the driver for this I/O.
+					 */
+	struct buf	 *bp;		/* A bp to use to get this I/O done. */
 };
-#define RF_LOCK_DISK_QUEUE   0x01
-#define RF_UNLOCK_DISK_QUEUE 0x02
+#define	RF_LOCK_DISK_QUEUE	0x01
+#define	RF_UNLOCK_DISK_QUEUE	0x02
 
-/* note: "Create" returns type-specific queue header pointer cast to (void *) */
+/*
+ * Note: "Create" returns type-specific queue header pointer cast to (void *).
+ */
 struct RF_DiskQueueSW_s {
 	RF_DiskQueueType_t queueType;
-	void   *(*Create) (RF_SectorCount_t, RF_AllocListElem_t *, RF_ShutdownList_t **);	/* creation routine --
-												 * one call per queue in
-												 * system */
-	void    (*Enqueue) (void *, RF_DiskQueueData_t *, int);	/* enqueue routine */
-	RF_DiskQueueData_t *(*Dequeue) (void *);	/* dequeue routine */
-	RF_DiskQueueData_t *(*Peek) (void *);	/* peek at head of queue */
-
-	/* the rest are optional:  they improve performance, but the driver
-	 * will deal with it if they don't exist */
-	int     (*Promote) (void *, RF_StripeNum_t, RF_ReconUnitNum_t);	/* promotes priority of
-									 * tagged accesses */
+	void		*(*Create) (RF_SectorCount_t, RF_AllocListElem_t *,
+			    RF_ShutdownList_t **);
+					/*
+					 * Creation routine -- one call per
+					 * queue in system.
+					 */
+	void		 (*Enqueue) (void *, RF_DiskQueueData_t *, int);
+					/* Enqueue routine. */
+	RF_DiskQueueData_t *(*Dequeue) (void *);
+					/* Dequeue routine. */
+	RF_DiskQueueData_t *(*Peek) (void *);
+					/* Peek at head of queue. */
+
+	/*
+	 * The rest are optional:  they improve performance, but the driver
+	 * will deal with it if they don't exist.
+	 */
+	int		 (*Promote) (void *, RF_StripeNum_t, RF_ReconUnitNum_t);
+					/*
+					 * Promotes priority of tagged
+					 * accesses.
+					 */
 };
 
 struct RF_DiskQueue_s {
-	RF_DiskQueueSW_t *qPtr;	/* access point to queue functions */
-	void   *qHdr;		/* queue header, of whatever type */
-	        RF_DECLARE_MUTEX(mutex)	/* mutex locking data structures */
-	        RF_DECLARE_COND(cond)	/* condition variable for
-					 * synchronization */
-	long    numOutstanding;	/* number of I/Os currently outstanding on
-				 * disk */
-	long    maxOutstanding;	/* max # of I/Os that can be outstanding on a
-				 * disk (in-kernel only) */
-	int     curPriority;	/* the priority of accs all that are currently
-				 * outstanding */
-	long    queueLength;	/* number of requests in queue */
-	RF_DiskQueueData_t *nextLockingOp;	/* a locking op that has
-						 * arrived at the head of the
-						 * queue & is waiting for
-						 * drainage */
-	RF_DiskQueueData_t *unlockingOp;	/* used at user level to
-						 * communicate unlocking op
-						 * b/w user (or dag exec) &
-						 * disk threads */
-	int     numWaiting;	/* number of threads waiting on this variable.
-				 * user-level only */
-	RF_DiskQueueFlags_t flags;	/* terminate, locked */
-	RF_Raid_t *raidPtr;	/* associated array */
-	dev_t   dev;		/* device number for kernel version */
-	RF_SectorNum_t last_deq_sector;	/* last sector number dequeued or
-					 * dispatched */
-	int     row, col;	/* debug only */
-	struct raidcinfo *rf_cinfo;	/* disks component info.. */
+	RF_DiskQueueSW_t  *qPtr;	/* Access point to queue functions. */
+	void		  *qHdr;	/* Queue header, of whatever type. */
+	RF_DECLARE_MUTEX(mutex);	/* Mutex locking data structures. */
+	RF_DECLARE_COND(cond);		/*
+					 * Condition variable for
+					 * synchronization.
+					 */
+	long		   numOutstanding;
+					/*
+					 * Number of I/Os currently
+					 * outstanding on disk.
+					 */
+	long		   maxOutstanding;
+					/*
+					 * Max number of I/Os that can be
+					 * outstanding on a disk.
+					 * (in-kernel only)
+					 */
+	int		   curPriority;	/*
+					 * The priority of accs all that are
+					 * currently outstanding.
+					 */
+	long		   queueLength;	/* Number of requests in queue. */
+	RF_DiskQueueData_t *nextLockingOp;
+					/*
+					 * A locking op that has arrived at
+					 * the head of the queue & is waiting
+					 * for drainage.
+					 */
+	RF_DiskQueueData_t *unlockingOp;/*
+					 * Used at user level to communicate
+					 * unlocking op b/w user (or dag exec)
+					 * & disk threads.
+					 */
+	int		   numWaiting;	/*
+					 * Number of threads waiting on
+					 * this variable.
+					 * (user-level only)
+					 */
+	RF_DiskQueueFlags_t flags;	/* Terminate, locked. */
+	RF_Raid_t	  *raidPtr;	/* Associated array. */
+	dev_t		   dev;		/* Device number for kernel version. */
+	RF_SectorNum_t	   last_deq_sector;
+					/*
+					 * Last sector number dequeued or
+					 * dispatched.
+					 */
+	int		   row, col;	/* Debug only. */
+	struct raidcinfo  *rf_cinfo;	/* Disks component info... */
 };
-#define RF_DQ_LOCKED  0x02	/* no new accs allowed until queue is
-				 * explicitly unlocked */
-
-/* macros setting & returning information about queues and requests */
-#define RF_QUEUE_LOCKED(_q)                 ((_q)->flags & RF_DQ_LOCKED)
-#define RF_QUEUE_EMPTY(_q)                  (((_q)->numOutstanding == 0) && ((_q)->nextLockingOp == NULL) && !RF_QUEUE_LOCKED(_q))
-#define RF_QUEUE_FULL(_q)                   ((_q)->numOutstanding == (_q)->maxOutstanding)
-
-#define RF_LOCK_QUEUE(_q)                   (_q)->flags |= RF_DQ_LOCKED
-#define RF_UNLOCK_QUEUE(_q)                 (_q)->flags &= ~RF_DQ_LOCKED
-
-#define RF_LOCK_QUEUE_MUTEX(_q_,_wh_)   RF_LOCK_MUTEX((_q_)->mutex)
-#define RF_UNLOCK_QUEUE_MUTEX(_q_,_wh_) RF_UNLOCK_MUTEX((_q_)->mutex)
-
-#define RF_LOCKING_REQ(_r)                  ((_r)->flags & RF_LOCK_DISK_QUEUE)
-#define RF_UNLOCKING_REQ(_r)                ((_r)->flags & RF_UNLOCK_DISK_QUEUE)
-
-/* whether it is ok to dispatch a regular request */
-#define RF_OK_TO_DISPATCH(_q_,_r_) \
-  (RF_QUEUE_EMPTY(_q_) || \
-    (!RF_QUEUE_FULL(_q_) && ((_r_)->priority >= (_q_)->curPriority)))
-
-int     rf_ConfigureDiskQueueSystem(RF_ShutdownList_t ** listp);
-
-void    rf_TerminateDiskQueues(RF_Raid_t * raidPtr);
-
-int 
-rf_ConfigureDiskQueues(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-
-void    rf_DiskIOEnqueue(RF_DiskQueue_t * queue, RF_DiskQueueData_t * req, int pri);
-
-
-void    rf_DiskIOComplete(RF_DiskQueue_t * queue, RF_DiskQueueData_t * req, int status);
-
-int 
-rf_DiskIOPromote(RF_DiskQueue_t * queue, RF_StripeNum_t parityStripeID,
-    RF_ReconUnitNum_t which_ru);
-
-RF_DiskQueueData_t *
-rf_CreateDiskQueueData(RF_IoType_t typ, RF_SectorNum_t ssect, 
-		       RF_SectorCount_t nsect, caddr_t buf,
-		       RF_StripeNum_t parityStripeID, 
-		       RF_ReconUnitNum_t which_ru,
-		       int (*wakeF) (void *, int),
-		       void *arg, RF_DiskQueueData_t * next, 
-		       RF_AccTraceEntry_t * tracerec,
-		       void *raidPtr, RF_DiskQueueDataFlags_t flags, 
-		       void *kb_proc);
-
-RF_DiskQueueData_t *
-rf_CreateDiskQueueDataFull(RF_IoType_t typ, RF_SectorNum_t ssect, 
-			   RF_SectorCount_t nsect, caddr_t buf,
-			   RF_StripeNum_t parityStripeID, 
-			   RF_ReconUnitNum_t which_ru,
-			   int (*wakeF) (void *, int),
-			   void *arg, RF_DiskQueueData_t * next, 
-			   RF_AccTraceEntry_t * tracerec,
-			   int priority, int (*AuxFunc) (void *,...), 
-			   caddr_t buf2, void *raidPtr, 
-			   RF_DiskQueueDataFlags_t flags, void *kb_proc);
-
-void    
-rf_FreeDiskQueueData(RF_DiskQueueData_t * p);
-
-int 
-rf_ConfigureDiskQueue(RF_Raid_t *, RF_DiskQueue_t *, RF_RowCol_t, 
-		      RF_RowCol_t, RF_DiskQueueSW_t *,
-		      RF_SectorCount_t, dev_t, int, 
-		      RF_ShutdownList_t **,
-		      RF_AllocListElem_t *);
-
-#endif				/* !_RF__RF_DISKQUEUE_H_ */
+
+/* No new accs allowed until queue is explicitly unlocked. */
+#define	RF_DQ_LOCKED	0x02
+
+/* Macros setting & returning information about queues and requests. */
+#define	RF_QUEUE_LOCKED(_q)		((_q)->flags & RF_DQ_LOCKED)
+#define	RF_QUEUE_EMPTY(_q)		(((_q)->numOutstanding == 0) &&	\
+					 ((_q)->nextLockingOp == NULL) && \
+					 !RF_QUEUE_LOCKED(_q))
+#define	RF_QUEUE_FULL(_q)		((_q)->numOutstanding ==	\
+					 (_q)->maxOutstanding)
+
+#define	RF_LOCK_QUEUE(_q)		(_q)->flags |= RF_DQ_LOCKED
+#define	RF_UNLOCK_QUEUE(_q)		(_q)->flags &= ~RF_DQ_LOCKED
+
+#define	RF_LOCK_QUEUE_MUTEX(_q_,_wh_)	RF_LOCK_MUTEX((_q_)->mutex)
+#define	RF_UNLOCK_QUEUE_MUTEX(_q_,_wh_)	RF_UNLOCK_MUTEX((_q_)->mutex)
+
+#define	RF_LOCKING_REQ(_r)		((_r)->flags & RF_LOCK_DISK_QUEUE)
+#define	RF_UNLOCKING_REQ(_r)		((_r)->flags & RF_UNLOCK_DISK_QUEUE)
+
+/* Whether it is ok to dispatch a regular request. */
+#define	RF_OK_TO_DISPATCH(_q_,_r_)					\
+	(RF_QUEUE_EMPTY(_q_) ||						\
+	( !RF_QUEUE_FULL(_q_) && ((_r_)->priority >= (_q_)->curPriority)))
+
+int  rf_ConfigureDiskQueueSystem(RF_ShutdownList_t **);
+
+void rf_TerminateDiskQueues(RF_Raid_t *);
+
+int  rf_ConfigureDiskQueues(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+
+void rf_DiskIOEnqueue(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
+
+void rf_DiskIOComplete(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
+
+int  rf_DiskIOPromote(RF_DiskQueue_t *, RF_StripeNum_t, RF_ReconUnitNum_t);
+
+RF_DiskQueueData_t *rf_CreateDiskQueueData(RF_IoType_t, RF_SectorNum_t,
+	RF_SectorCount_t, caddr_t, RF_StripeNum_t, RF_ReconUnitNum_t,
+	int (*) (void *, int), void *, RF_DiskQueueData_t *,
+	RF_AccTraceEntry_t *, void *, RF_DiskQueueDataFlags_t, void *);
+
+RF_DiskQueueData_t *rf_CreateDiskQueueDataFull(RF_IoType_t, RF_SectorNum_t,
+	RF_SectorCount_t, caddr_t, RF_StripeNum_t, RF_ReconUnitNum_t,
+	int (*) (void *, int), void *, RF_DiskQueueData_t *,
+	RF_AccTraceEntry_t *, int, int (*) (void *,...), caddr_t, void *,
+	RF_DiskQueueDataFlags_t, void *);
+
+void rf_FreeDiskQueueData(RF_DiskQueueData_t *);
+
+int  rf_ConfigureDiskQueue(RF_Raid_t *, RF_DiskQueue_t *, RF_RowCol_t,
+	RF_RowCol_t, RF_DiskQueueSW_t *, RF_SectorCount_t, dev_t, int,
+	RF_ShutdownList_t **, RF_AllocListElem_t *);
+
+#endif	/* ! _RF__RF_DISKQUEUE_H_ */
diff --git a/sys/dev/raidframe/rf_disks.c b/sys/dev/raidframe/rf_disks.c
index 80aaffd87d8..f9ba8433298 100644
--- a/sys/dev/raidframe/rf_disks.c
+++ b/sys/dev/raidframe/rf_disks.c
@@ -1,6 +1,7 @@
-/*	$OpenBSD: rf_disks.c,v 1.6 2000/08/08 16:07:40 peter Exp $	*/
+/*	$OpenBSD: rf_disks.c,v 1.7 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_disks.c,v 1.31 2000/06/02 01:17:14 oster Exp $	*/
-/*-
+
+/*
  * Copyright (c) 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
@@ -17,8 +18,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *        This product includes software developed by the NetBSD
- *        Foundation, Inc. and its contributors.
+ *	This product includes software developed by the NetBSD
+ *	Foundation, Inc. and its contributors.
  * 4. Neither the name of The NetBSD Foundation nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
@@ -63,7 +64,7 @@
  */
 
 /***************************************************************
- * rf_disks.c -- code to perform operations on the actual disks
+ * rf_disks.c -- Code to perform operations on the actual disks.
  ***************************************************************/
 
 #include "rf_types.h"
@@ -87,59 +88,56 @@
 #include <sys/proc.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
-#ifdef __NETBSD__
+#ifdef	__NETBSD__
 #include <sys/vnode.h>
-#endif
+#endif	/* __NETBSD__ */
 
-static int rf_AllocDiskStructures(RF_Raid_t *, RF_Config_t *);
-static void rf_print_label_status( RF_Raid_t *, int, int, char *, 
-				  RF_ComponentLabel_t *);
-static int rf_check_label_vitals( RF_Raid_t *, int, int, char *, 
-				  RF_ComponentLabel_t *, int, int );
+int  rf_AllocDiskStructures(RF_Raid_t *, RF_Config_t *);
+void rf_print_label_status(RF_Raid_t *, int, int, char *,
+	RF_ComponentLabel_t *);
+int  rf_check_label_vitals(RF_Raid_t *, int, int, char *,
+	RF_ComponentLabel_t *, int, int);
 
-#define DPRINTF6(a,b,c,d,e,f) if (rf_diskDebug) printf(a,b,c,d,e,f)
-#define DPRINTF7(a,b,c,d,e,f,g) if (rf_diskDebug) printf(a,b,c,d,e,f,g)
+#define	DPRINTF6(a,b,c,d,e,f)	if (rf_diskDebug) printf(a,b,c,d,e,f)
+#define	DPRINTF7(a,b,c,d,e,f,g)	if (rf_diskDebug) printf(a,b,c,d,e,f,g)
 
 /****************************************************************************
  *
- * initialize the disks comprising the array
+ * Initialize the disks comprising the array.
  *
- * We want the spare disks to have regular row,col numbers so that we can 
- * easily substitue a spare for a failed disk.  But, the driver code assumes 
- * throughout that the array contains numRow by numCol _non-spare_ disks, so 
- * it's not clear how to fit in the spares.  This is an unfortunate holdover
- * from raidSim.  The quick and dirty fix is to make row zero bigger than the 
- * rest, and put all the spares in it.  This probably needs to get changed 
+ * We want the spare disks to have regular row,col numbers so that we can
+ * easily substitue a spare for a failed disk. But, the driver code assumes
+ * throughout that the array contains numRow by numCol _non-spare_ disks, so
+ * it's not clear how to fit in the spares. This is an unfortunate holdover
+ * from raidSim. The quick and dirty fix is to make row zero bigger than the
+ * rest, and put all the spares in it. This probably needs to get changed
  * eventually.
  *
  ****************************************************************************/
-int 
-rf_ConfigureDisks( listp, raidPtr, cfgPtr )
-	RF_ShutdownList_t **listp;
-	RF_Raid_t *raidPtr;
-	RF_Config_t *cfgPtr;
+int
+rf_ConfigureDisks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidDisk_t **disks;
 	RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL;
 	RF_RowCol_t r, c;
-	int     bs, ret;
+	int bs, ret;
 	unsigned i, count, foundone = 0, numFailuresThisRow;
-	int	force;
+	int force;
 
 	force = cfgPtr->force;
- 
+
  	ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
  	if (ret)
 		goto fail;
 
  	disks = raidPtr->Disks;
- 
+
 	for (r = 0; r < raidPtr->numRow; r++) {
 		numFailuresThisRow = 0;
 		for (c = 0; c < raidPtr->numCol; c++) {
-			ret = rf_ConfigureDisk(raidPtr, 
-					       &cfgPtr->devnames[r][c][0],
-					       &disks[r][c], r, c);
+			ret = rf_ConfigureDisk(raidPtr,
+			    &cfgPtr->devnames[r][c][0], &disks[r][c], r, c);
 
 			if (ret)
 				goto fail;
@@ -156,22 +154,27 @@ rf_ConfigureDisks( listp, raidPtr, cfgPtr )
 			} else {
 				if (disks[r][c].numBlocks < min_numblks)
 					min_numblks = disks[r][c].numBlocks;
-				DPRINTF7("Disk at row %d col %d: dev %s numBlocks %ld blockSize %d (%ld MB)\n",
+				DPRINTF7("Disk at row %d col %d: dev %s"
+				    " numBlocks %ld blockSize %d (%ld MB)\n",
 				    r, c, disks[r][c].devname,
 				    (long int) disks[r][c].numBlocks,
 				    disks[r][c].blockSize,
 				    (long int) disks[r][c].numBlocks *
-					 disks[r][c].blockSize / 1024 / 1024);
+				     disks[r][c].blockSize / 1024 / 1024);
 			}
 		}
-		/* XXX fix for n-fault tolerant */
-		/* XXX this should probably check to see how many failures
-		   we can handle for this configuration! */
+		/* XXX Fix for n-fault tolerant. */
+		/*
+		 * XXX This should probably check to see how many failures
+		 * we can handle for this configuration !
+		 */
 		if (numFailuresThisRow > 0)
 			raidPtr->status[r] = rf_rs_degraded;
 	}
-	/* all disks must be the same size & have the same block size, bs must
-	 * be a power of 2 */
+	/*
+	 * All disks must be the same size & have the same block size, bs must
+	 * be a power of 2.
+	 */
 	bs = 0;
 	for (foundone = r = 0; !foundone && r < raidPtr->numRow; r++) {
 		for (c = 0; !foundone && c < raidPtr->numCol; c++) {
@@ -182,7 +185,8 @@ rf_ConfigureDisks( listp, raidPtr, cfgPtr )
 		}
 	}
 	if (!foundone) {
-		RF_ERRORMSG("RAIDFRAME: Did not find any live disks in the array.\n");
+		RF_ERRORMSG("RAIDFRAME: Did not find any live disks in"
+		    " the array.\n");
 		ret = EINVAL;
 		goto fail;
 	}
@@ -190,32 +194,36 @@ rf_ConfigureDisks( listp, raidPtr, cfgPtr )
 		if (bs & i)
 			count++;
 	if (count != 1) {
-		RF_ERRORMSG1("Error: block size on disks (%d) must be a power of 2\n", bs);
+		RF_ERRORMSG1("Error: block size on disks (%d) must be a"
+		    " power of 2.\n", bs);
 		ret = EINVAL;
 		goto fail;
 	}
 
-	if (rf_CheckLabels( raidPtr, cfgPtr )) {
+	if (rf_CheckLabels(raidPtr, cfgPtr)) {
 		printf("raid%d: There were fatal errors\n", raidPtr->raidid);
 		if (force != 0) {
 			printf("raid%d: Fatal errors being ignored.\n",
-			       raidPtr->raidid);
+			    raidPtr->raidid);
 		} else {
 			ret = EINVAL;
 			goto fail;
-		} 
+		}
 	}
 
 	for (r = 0; r < raidPtr->numRow; r++) {
 		for (c = 0; c < raidPtr->numCol; c++) {
 			if (disks[r][c].status == rf_ds_optimal) {
 				if (disks[r][c].blockSize != bs) {
-					RF_ERRORMSG2("Error: block size of disk at r %d c %d different from disk at r 0 c 0\n", r, c);
+					RF_ERRORMSG2("Error: block size of"
+					    " disk at r %d c %d different from"
+					    " disk at r 0 c 0.\n", r, c);
 					ret = EINVAL;
 					goto fail;
 				}
 				if (disks[r][c].numBlocks != min_numblks) {
-					RF_ERRORMSG3("WARNING: truncating disk at r %d c %d to %d blocks\n",
+					RF_ERRORMSG3("WARNING: truncating disk"
+					    " at r %d c %d to %d blocks.\n",
 					    r, c, (int) min_numblks);
 					disks[r][c].numBlocks = min_numblks;
 				}
@@ -230,71 +238,76 @@ rf_ConfigureDisks( listp, raidPtr, cfgPtr )
 	return (0);
 
 fail:
-	rf_UnconfigureVnodes( raidPtr );
+	rf_UnconfigureVnodes(raidPtr);
 
 	return (ret);
 }
 
 
 /****************************************************************************
- * set up the data structures describing the spare disks in the array
- * recall from the above comment that the spare disk descriptors are stored
+ * Set up the data structures describing the spare disks in the array.
+ * Recall from the above comment that the spare disk descriptors are stored
  * in row zero, which is specially expanded to hold them.
  ****************************************************************************/
-int 
-rf_ConfigureSpareDisks( listp, raidPtr, cfgPtr )
-	RF_ShutdownList_t ** listp;
-	RF_Raid_t * raidPtr;
-	RF_Config_t * cfgPtr;
+int
+rf_ConfigureSpareDisks(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
+    RF_Config_t * cfgPtr)
 {
-	int     i, ret;
+	int i, ret;
 	unsigned int bs;
 	RF_RaidDisk_t *disks;
-	int     num_spares_done;
+	int num_spares_done;
 
 	num_spares_done = 0;
 
-	/* The space for the spares should have already been allocated by
-	 * ConfigureDisks() */
+	/*
+	 * The space for the spares should have already been allocated by
+	 * ConfigureDisks().
+	 */
 
 	disks = &raidPtr->Disks[0][raidPtr->numCol];
 	for (i = 0; i < raidPtr->numSpare; i++) {
 		ret = rf_ConfigureDisk(raidPtr, &cfgPtr->spare_names[i][0],
-				       &disks[i], 0, raidPtr->numCol + i);
+		    &disks[i], 0, raidPtr->numCol + i);
 		if (ret)
 			goto fail;
 		if (disks[i].status != rf_ds_optimal) {
-			RF_ERRORMSG1("Warning: spare disk %s failed TUR\n", 
-				     &cfgPtr->spare_names[i][0]);
+			RF_ERRORMSG1("Warning: spare disk %s failed TUR\n",
+			    &cfgPtr->spare_names[i][0]);
 		} else {
-			disks[i].status = rf_ds_spare;	/* change status to
-							 * spare */
-			DPRINTF6("Spare Disk %d: dev %s numBlocks %ld blockSize %d (%ld MB)\n", i,
-			    disks[i].devname,
+			/* Change status to spare. */
+			disks[i].status = rf_ds_spare;
+			DPRINTF6("Spare Disk %d: dev %s numBlocks %ld"
+			    " blockSize %d (%ld MB).\n", i, disks[i].devname,
 			    (long int) disks[i].numBlocks, disks[i].blockSize,
-			    (long int) disks[i].numBlocks * 
-				 disks[i].blockSize / 1024 / 1024);
+			    (long int) disks[i].numBlocks *
+			    disks[i].blockSize / 1024 / 1024);
 		}
 		num_spares_done++;
 	}
 
-	/* check sizes and block sizes on spare disks */
+	/* Check sizes and block sizes on spare disks. */
 	bs = 1 << raidPtr->logBytesPerSector;
 	for (i = 0; i < raidPtr->numSpare; i++) {
 		if (disks[i].blockSize != bs) {
-			RF_ERRORMSG3("Block size of %d on spare disk %s is not the same as on other disks (%d)\n", disks[i].blockSize, disks[i].devname, bs);
+			RF_ERRORMSG3("Block size of %d on spare disk %s is"
+			    " not the same as on other disks (%d).\n",
+			    disks[i].blockSize, disks[i].devname, bs);
 			ret = EINVAL;
 			goto fail;
 		}
 		if (disks[i].numBlocks < raidPtr->sectorsPerDisk) {
-			RF_ERRORMSG3("Spare disk %s (%d blocks) is too small to serve as a spare (need %ld blocks)\n",
-				     disks[i].devname, disks[i].blockSize, 
-				     (long int) raidPtr->sectorsPerDisk);
+			RF_ERRORMSG3("Spare disk %s (%d blocks) is too small"
+			    " to serve as a spare (need %ld blocks).\n",
+			    disks[i].devname, disks[i].blockSize,
+			    (long int) raidPtr->sectorsPerDisk);
 			ret = EINVAL;
 			goto fail;
 		} else
 			if (disks[i].numBlocks > raidPtr->sectorsPerDisk) {
-				RF_ERRORMSG2("Warning: truncating spare disk %s to %ld blocks\n", disks[i].devname, (long int) raidPtr->sectorsPerDisk);
+				RF_ERRORMSG2("Warning: truncating spare disk"
+				    " %s to %ld blocks.\n", disks[i].devname,
+				    (long int) raidPtr->sectorsPerDisk);
 
 				disks[i].numBlocks = raidPtr->sectorsPerDisk;
 			}
@@ -304,38 +317,37 @@ rf_ConfigureSpareDisks( listp, raidPtr, cfgPtr )
 
 fail:
 
-	/* Release the hold on the main components.  We've failed to allocate
-	 * a spare, and since we're failing, we need to free things.. 
-
-	 XXX failing to allocate a spare is *not* that big of a deal... 
-	 We *can* survive without it, if need be, esp. if we get hot
-	 adding working.  
-	 If we don't fail out here, then we need a way to remove this spare... 
-	 that should be easier to do here than if we are "live"... 
+	/*
+	 * Release the hold on the main components. We've failed to allocate
+	 * a spare, and since we're failing, we need to free things...
+	 *
+	 * XXX Failing to allocate a spare is *not* that big of a deal...
+	 * We *can* survive without it, if need be, esp. if we get hot
+	 * adding working.
+	 * If we don't fail out here, then we need a way to remove this spare...
+	 * That should be easier to do here than if we are "live"...
 	 */
 
-	rf_UnconfigureVnodes( raidPtr );
-	
+	rf_UnconfigureVnodes(raidPtr);
+
 	return (ret);
 }
 
-static int
-rf_AllocDiskStructures(raidPtr, cfgPtr)
-	RF_Raid_t *raidPtr;
- 	RF_Config_t *cfgPtr;
+int
+rf_AllocDiskStructures(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
 {
 	RF_RaidDisk_t **disks;
 	int ret;
 	int r;
 
-	RF_CallocAndAdd(disks, raidPtr->numRow, sizeof(RF_RaidDisk_t *), 
-			(RF_RaidDisk_t **), raidPtr->cleanupList);
+	RF_CallocAndAdd(disks, raidPtr->numRow, sizeof(RF_RaidDisk_t *),
+	    (RF_RaidDisk_t **), raidPtr->cleanupList);
 	if (disks == NULL) {
 		ret = ENOMEM;
 		goto fail;
 	}
 	raidPtr->Disks = disks;
-	/* get space for the device-specific stuff... */
+	/* Get space for the device-specific stuff... */
 	RF_CallocAndAdd(raidPtr->raid_cinfo, raidPtr->numRow,
 	    sizeof(struct raidcinfo *), (struct raidcinfo **),
 	    raidPtr->cleanupList);
@@ -345,19 +357,20 @@ rf_AllocDiskStructures(raidPtr, cfgPtr)
 	}
 
 	for (r = 0; r < raidPtr->numRow; r++) {
-		/* We allocate RF_MAXSPARE on the first row so that we
-		   have room to do hot-swapping of spares */
-		RF_CallocAndAdd(disks[r], raidPtr->numCol 
-				+ ((r == 0) ? RF_MAXSPARE : 0), 
-				sizeof(RF_RaidDisk_t), (RF_RaidDisk_t *), 
-				raidPtr->cleanupList);
+		/*
+		 * We allocate RF_MAXSPARE on the first row so that we
+		 * have room to do hot-swapping of spares.
+		 */
+		RF_CallocAndAdd(disks[r], raidPtr->numCol +
+		    ((r == 0) ? RF_MAXSPARE : 0), sizeof(RF_RaidDisk_t),
+		    (RF_RaidDisk_t *), raidPtr->cleanupList);
 		if (disks[r] == NULL) {
 			ret = ENOMEM;
 			goto fail;
 		}
-		/* get more space for device specific stuff.. */
-		RF_CallocAndAdd(raidPtr->raid_cinfo[r],
-		    raidPtr->numCol + ((r == 0) ? raidPtr->numSpare : 0),
+		/* Get more space for device specific stuff... */
+		RF_CallocAndAdd(raidPtr->raid_cinfo[r], raidPtr->numCol +
+		    ((r == 0) ? raidPtr->numSpare : 0),
 		    sizeof(struct raidcinfo), (struct raidcinfo *),
 		    raidPtr->cleanupList);
 		if (raidPtr->raid_cinfo[r] == NULL) {
@@ -366,23 +379,21 @@ rf_AllocDiskStructures(raidPtr, cfgPtr)
 		}
 	}
 	return(0);
-fail:	
-	rf_UnconfigureVnodes( raidPtr );
+fail:
+	rf_UnconfigureVnodes(raidPtr);
 
 	return(ret);
 }
 
 
-/* configure a single disk during auto-configuration at boot */
+/* Configure a single disk during auto-configuration at boot. */
 int
-rf_AutoConfigureDisks(raidPtr, cfgPtr, auto_config)
-	RF_Raid_t *raidPtr;
-	RF_Config_t *cfgPtr;
-	RF_AutoConfig_t *auto_config;
+rf_AutoConfigureDisks(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr,
+    RF_AutoConfig_t *auto_config)
 {
 	RF_RaidDisk_t **disks;
 	RF_RaidDisk_t *diskPtr;
-	RF_RowCol_t r, c;	
+	RF_RowCol_t r, c;
 	RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL;
 	int bs, ret;
 	int numFailuresThisRow;
@@ -392,9 +403,9 @@ rf_AutoConfigureDisks(raidPtr, cfgPtr, auto_config)
 	int mod_counter;
 	int mod_counter_found;
 
-#if DEBUG
+#if	DEBUG
 	printf("Starting autoconfiguration of RAID set...\n");
-#endif
+#endif	/* DEBUG */
 	force = cfgPtr->force;
 
 	ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
@@ -403,14 +414,14 @@ rf_AutoConfigureDisks(raidPtr, cfgPtr, auto_config)
 
 	disks = raidPtr->Disks;
 
-	/* assume the parity will be fine.. */
+	/* Assume the parity will be fine... */
 	parity_good = RF_RAID_CLEAN;
 
-	/* Check for mod_counters that are too low */
+	/* Check for mod_counters that are too low. */
 	mod_counter_found = 0;
 	ac = auto_config;
 	while(ac!=NULL) {
-		if (mod_counter_found==0) {
+		if (mod_counter_found == 0) {
 			mod_counter = ac->clabel->mod_counter;
 			mod_counter_found = 1;
 		} else {
@@ -418,7 +429,7 @@ rf_AutoConfigureDisks(raidPtr, cfgPtr, auto_config)
 				mod_counter = ac->clabel->mod_counter;
 			}
 		}
-		ac->flag = 0; /* clear the general purpose flag */
+		ac->flag = 0; /* Clear the general purpose flag. */
 		ac = ac->next;
 	}
 
@@ -427,163 +438,184 @@ rf_AutoConfigureDisks(raidPtr, cfgPtr, auto_config)
 		for (c = 0; c < raidPtr->numCol; c++) {
 			diskPtr = &disks[r][c];
 
-			/* find this row/col in the autoconfig */
-#if DEBUG
-			printf("Looking for %d,%d in autoconfig\n",r,c);
-#endif
+			/* Find this row/col in the autoconfig. */
+#if	DEBUG
+			printf("Looking for %d,%d in autoconfig.\n", r, c);
+#endif	/* DEBUG */
 			ac = auto_config;
 			while(ac!=NULL) {
-				if (ac->clabel==NULL) {
-					/* big-time bad news. */
+				if (ac->clabel == NULL) {
+					/* Big-time bad news. */
 					goto fail;
 				}
 				if ((ac->clabel->row == r) &&
 				    (ac->clabel->column == c) &&
 				    (ac->clabel->mod_counter == mod_counter)) {
-					/* it's this one... */
-					/* flag it as 'used', so we don't
-					   free it later. */
+					/* It's this one... */
+					/*
+					 * Flag it as 'used', so we don't
+					 * free it later.
+					 */
 					ac->flag = 1;
-#if DEBUG
-					printf("Found: %s at %d,%d\n",
-					       ac->devname,r,c);
-#endif
-					
+#if	DEBUG
+					printf("Found: %s at %d,%d.\n",
+					    ac->devname, r, c);
+#endif	/* DEBUG */
+
 					break;
 				}
-				ac=ac->next;
+				ac = ac->next;
 			}
 
-			if (ac==NULL) {
-				/* we didn't find an exact match with a 
-				   correct mod_counter above... can we
-				   find one with an incorrect mod_counter
-				   to use instead?  (this one, if we find
-				   it, will be marked as failed once the 
-				   set configures) 
-				*/
+			if (ac == NULL) {
+				/*
+				 * We didn't find an exact match with a
+				 * correct mod_counter above...  Can we
+				 * find one with an incorrect mod_counter
+				 * to use instead ?  (This one, if we find
+				 * it, will be marked as failed once the
+				 * set configures)
+				 */
 
 				ac = auto_config;
 				while(ac!=NULL) {
-					if (ac->clabel==NULL) {
-						/* big-time bad news. */
+					if (ac->clabel == NULL) {
+						/* Big-time bad news. */
 						goto fail;
 					}
 					if ((ac->clabel->row == r) &&
 					    (ac->clabel->column == c)) {
-						/* it's this one... 
-						   flag it as 'used', so we 
-						   don't free it later. */
+						/*
+						 * It's this one...
+						 * Flag it as 'used', so we
+						 * don't free it later.
+						 */
 						ac->flag = 1;
-#if DEBUG
-						printf("Found(low mod_counter): %s at %d,%d\n",
-						       ac->devname,r,c);
-#endif
-						
+#if	DEBUG
+						printf("Found(low mod_counter)"
+						    ": %s at %d,%d.\n",
+						    ac->devname, r, c);
+#endif	/* DEBUG */
+
 						break;
 					}
-					ac=ac->next;
+					ac = ac->next;
 				}
 			}
 
 
 
 			if (ac!=NULL) {
-				/* Found it.  Configure it.. */
+				/* Found it. Configure it... */
 				diskPtr->blockSize = ac->clabel->blockSize;
 				diskPtr->numBlocks = ac->clabel->numBlocks;
-				/* Note: rf_protectedSectors is already 
-				   factored into numBlocks here */
+				/*
+				 * Note: rf_protectedSectors is already
+				 * factored into numBlocks here.
+				 */
 				raidPtr->raid_cinfo[r][c].ci_vp = ac->vp;
 				raidPtr->raid_cinfo[r][c].ci_dev = ac->dev;
 
 				memcpy(&raidPtr->raid_cinfo[r][c].ci_label,
-				       ac->clabel, sizeof(*ac->clabel));
-				sprintf(diskPtr->devname, "/dev/%s", 
-					ac->devname);
-				
-				/* note the fact that this component was
-				   autoconfigured.  You'll need this info
-				   later.  Trust me :) */
+				    ac->clabel, sizeof(*ac->clabel));
+				sprintf(diskPtr->devname, "/dev/%s",
+				    ac->devname);
+
+				/*
+				 * Note the fact that this component was
+				 * autoconfigured. You'll need this info
+				 * later. Trust me :)
+				 */
 				diskPtr->auto_configured = 1;
 				diskPtr->dev = ac->dev;
-			
-				/* 
-				 * we allow the user to specify that
+
+				/*
+				 * We allow the user to specify that
 				 * only a fraction of the disks should
-				 * be used this is just for debug: it
-				 * speeds up the parity scan 
+				 * be used. This is just for debug: it
+				 * speeds up the parity scan.
 				 */
 
-				diskPtr->numBlocks = diskPtr->numBlocks * 
+				diskPtr->numBlocks = diskPtr->numBlocks *
 					rf_sizePercentage / 100;
 
-				/* XXX these will get set multiple times, 
-				   but since we're autoconfiguring, they'd
-				   better be always the same each time!
-				   If not, this is the least of your worries */
+				/*
+				 * XXX These will get set multiple times,
+				 * but since we're autoconfiguring, they'd
+				 * better be always the same each time !
+				 * If not, this is the least of your worries.
+				 */
 
 				bs = diskPtr->blockSize;
 				min_numblks = diskPtr->numBlocks;
 
-				/* this gets done multiple times, but that's
-				   fine -- the serial number will be the same
-				   for all components, guaranteed */
-				raidPtr->serial_number = 
-					ac->clabel->serial_number;
-				/* check the last time the label
-				   was modified */
-				if (ac->clabel->mod_counter !=
-				    mod_counter) {
-					/* Even though we've filled in all
-					   of the above, we don't trust
-					   this component since it's 
-					   modification counter is not
-					   in sync with the rest, and we really
-					   consider it to be failed.  */
+				/*
+				 * This gets done multiple times, but that's
+				 * fine -- the serial number will be the same
+				 * for all components, guaranteed.
+				 */
+				raidPtr->serial_number =
+				    ac->clabel->serial_number;
+				/*
+				 * Check the last time the label
+				 * was modified.
+				 */
+				if (ac->clabel->mod_counter != mod_counter) {
+					/*
+					 * Even though we've filled in all
+					 * of the above, we don't trust
+					 * this component since it's
+					 * modification counter is not
+					 * in sync with the rest, and we really
+					 * consider it to be failed.
+					 */
 					disks[r][c].status = rf_ds_failed;
 					numFailuresThisRow++;
 				} else {
-					if (ac->clabel->clean != 
-					    RF_RAID_CLEAN) {
+					if (ac->clabel->clean != RF_RAID_CLEAN)
+					{
 						parity_good = RF_RAID_DIRTY;
 					}
 				}
 			} else {
-				/* Didn't find it at all!! 
-				   Component must really be dead */
+				/*
+				 * Didn't find it at all !!!
+				 * Component must really be dead.
+				 */
 				disks[r][c].status = rf_ds_failed;
-				sprintf(disks[r][c].devname,"component%d",
-					r * raidPtr->numCol + c);
+				sprintf(disks[r][c].devname, "component%d",
+				    r * raidPtr->numCol + c);
 				numFailuresThisRow++;
 			}
 		}
-		/* XXX fix for n-fault tolerant */
-		/* XXX this should probably check to see how many failures
-		   we can handle for this configuration! */
+		/* XXX Fix for n-fault tolerant. */
+		/*
+		 * XXX This should probably check to see how many failures
+		 * we can handle for this configuration !
+		 */
 		if (numFailuresThisRow > 0)
 			raidPtr->status[r] = rf_rs_degraded;
 	}
 
-	/* close the device for the ones that didn't get used */
+	/* Close the device for the ones that didn't get used. */
 
 	ac = auto_config;
-	while(ac!=NULL) {
+	while(ac != NULL) {
 		if (ac->flag == 0) {
 			VOP_CLOSE(ac->vp, FREAD, NOCRED, 0);
 			vput(ac->vp);
 			ac->vp = NULL;
-#if DEBUG 
+#if	DEBUG
 			printf("Released %s from auto-config set.\n",
-			       ac->devname);
-#endif
+			    ac->devname);
+#endif  /* DEBUG */
 		}
 		ac = ac->next;
 	}
 
 	raidPtr->mod_counter = mod_counter;
 
-	/* note the state of the parity, if any */
+	/* Note the state of the parity, if any. */
 	raidPtr->parity_good = parity_good;
 	raidPtr->sectorsPerDisk = min_numblks;
 	raidPtr->logBytesPerSector = ffs(bs) - 1;
@@ -592,35 +624,31 @@ rf_AutoConfigureDisks(raidPtr, cfgPtr, auto_config)
 	return (0);
 
 fail:
-	
-	rf_UnconfigureVnodes( raidPtr );
+
+	rf_UnconfigureVnodes(raidPtr);
 
 	return (ret);
 
 }
 
-/* configure a single disk in the array */
-int 
-rf_ConfigureDisk(raidPtr, buf, diskPtr, row, col)
-	RF_Raid_t *raidPtr;
-	char   *buf;
-	RF_RaidDisk_t *diskPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
+/* Configure a single disk in the array. */
+int
+rf_ConfigureDisk(RF_Raid_t *raidPtr, char *buf, RF_RaidDisk_t *diskPtr,
+    RF_RowCol_t row, RF_RowCol_t col)
 {
-	char   *p;
-	int     retcode;
+	char *p;
+	int retcode;
 
 	struct partinfo dpart;
 	struct vnode *vp;
 	struct vattr va;
 	struct proc *proc;
-	int     error;
+	int error;
 
 	retcode = 0;
 	p = rf_find_non_white(buf);
 	if (p[strlen(p) - 1] == '\n') {
-		/* strip off the newline */
+		/* Strip off the newline. */
 		p[strlen(p) - 1] = '\0';
 	}
 	(void) strcpy(diskPtr->devname, p);
@@ -639,9 +667,9 @@ rf_ConfigureDisk(raidPtr, buf, diskPtr, row, col)
 
 	error = raidlookup(diskPtr->devname, proc, &vp);
 	if (error) {
-		printf("raidlookup on device: %s failed!\n", diskPtr->devname);
+		printf("raidlookup on device: %s failed !\n", diskPtr->devname);
 		if (error == ENXIO) {
-			/* the component isn't there... must be dead :-( */
+			/* The component isn't there...  Must be dead :-( */
 			diskPtr->status = rf_ds_failed;
 		} else {
 			return (error);
@@ -652,8 +680,8 @@ rf_ConfigureDisk(raidPtr, buf, diskPtr, row, col)
 		if ((error = VOP_GETATTR(vp, &va, proc->p_ucred, proc)) != 0) {
 			return (error);
 		}
-		error = VOP_IOCTL(vp, DIOCGPART, (caddr_t) & dpart,
-		    FREAD, proc->p_ucred, proc);
+		error = VOP_IOCTL(vp, DIOCGPART, (caddr_t) & dpart, FREAD,
+		    proc->p_ucred, proc);
 		if (error) {
 			return (error);
 		}
@@ -661,103 +689,92 @@ rf_ConfigureDisk(raidPtr, buf, diskPtr, row, col)
 
 		diskPtr->numBlocks = dpart.part->p_size - rf_protectedSectors;
  		diskPtr->partitionSize = dpart.part->p_size;
- 
+
 		raidPtr->raid_cinfo[row][col].ci_vp = vp;
 		raidPtr->raid_cinfo[row][col].ci_dev = va.va_rdev;
 
- 		/* This component was not automatically configured */
+ 		/* This component was not automatically configured. */
  		diskPtr->auto_configured = 0;
 		diskPtr->dev = va.va_rdev;
 
-		/* we allow the user to specify that only a fraction of the
-		 * disks should be used this is just for debug:  it speeds up
-		 * the parity scan */
-		diskPtr->numBlocks = diskPtr->numBlocks * 
-			rf_sizePercentage / 100;
+		/*
+		 * We allow the user to specify that only a fraction of the
+		 * disks should be used. This is just for debug: it speeds up
+		 * the parity scan.
+		 */
+		diskPtr->numBlocks = diskPtr->numBlocks * rf_sizePercentage
+		    / 100;
 	}
 	return (0);
 }
 
-static void
-rf_print_label_status( raidPtr, row, column, dev_name, ci_label )
-	RF_Raid_t *raidPtr;
-	int row;
-	int column;
-	char *dev_name;
-	RF_ComponentLabel_t *ci_label;
+void
+rf_print_label_status(RF_Raid_t *raidPtr, int row, int column, char *dev_name,
+    RF_ComponentLabel_t *ci_label)
 {
 
-	printf("raid%d: Component %s being configured at row: %d col: %d\n", 
-	       raidPtr->raidid, dev_name, row, column );
+	printf("raid%d: Component %s being configured at row: %d col: %d\n",
+	    raidPtr->raidid, dev_name, row, column);
 	printf("         Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
-	       ci_label->row, ci_label->column, 
-	       ci_label->num_rows, ci_label->num_columns);
+	    ci_label->row, ci_label->column, ci_label->num_rows,
+	    ci_label->num_columns);
 	printf("         Version: %d Serial Number: %d Mod Counter: %d\n",
-	       ci_label->version, ci_label->serial_number,
-	       ci_label->mod_counter);
+	    ci_label->version, ci_label->serial_number, ci_label->mod_counter);
 	printf("         Clean: %s Status: %d\n",
-	       ci_label->clean ? "Yes" : "No", ci_label->status );
+	    ci_label->clean ? "Yes" : "No", ci_label->status);
 }
 
-static int rf_check_label_vitals( raidPtr, row, column, dev_name, ci_label,
-				  serial_number, mod_counter )
-	RF_Raid_t *raidPtr;
-	int row;
-	int column;
-	char *dev_name;
-	RF_ComponentLabel_t *ci_label;
-	int serial_number;
-	int mod_counter;
+int
+rf_check_label_vitals(RF_Raid_t *raidPtr, int row, int column, char *dev_name,
+    RF_ComponentLabel_t *ci_label, int serial_number, int mod_counter)
 {
 	int fatal_error = 0;
 
 	if (serial_number != ci_label->serial_number) {
-		printf("%s has a different serial number: %d %d\n", 
-		       dev_name, serial_number, ci_label->serial_number);
+		printf("%s has a different serial number: %d %d.\n",
+		    dev_name, serial_number, ci_label->serial_number);
 		fatal_error = 1;
 	}
 	if (mod_counter != ci_label->mod_counter) {
-		printf("%s has a different modfication count: %d %d\n",
-		       dev_name, mod_counter, ci_label->mod_counter);
+		printf("%s has a different modfication count: %d %d.\n",
+		    dev_name, mod_counter, ci_label->mod_counter);
 	}
-	
+
 	if (row != ci_label->row) {
-		printf("Row out of alignment for: %s\n", dev_name); 
+		printf("Row out of alignment for: %s.\n", dev_name);
 		fatal_error = 1;
 	}
 	if (column != ci_label->column) {
-		printf("Column out of alignment for: %s\n", dev_name);
+		printf("Column out of alignment for: %s.\n", dev_name);
 		fatal_error = 1;
 	}
 	if (raidPtr->numRow != ci_label->num_rows) {
-		printf("Number of rows do not match for: %s\n", dev_name);
+		printf("Number of rows do not match for: %s.\n", dev_name);
 		fatal_error = 1;
 	}
 	if (raidPtr->numCol != ci_label->num_columns) {
-		printf("Number of columns do not match for: %s\n", dev_name);
+		printf("Number of columns do not match for: %s.\n", dev_name);
 		fatal_error = 1;
 	}
 	if (ci_label->clean == 0) {
-		/* it's not clean, but that's not fatal */
-		printf("%s is not clean!\n", dev_name);
+		/* It's not clean, but that's not fatal. */
+		printf("%s is not clean !\n", dev_name);
 	}
 	return(fatal_error);
 }
 
 
-/* 
-
-   rf_CheckLabels() - check all the component labels for consistency.
-   Return an error if there is anything major amiss.
-
+/*
+ *
+ * rf_CheckLabels() - Check all the component labels for consistency.
+ * Return an error if there is anything major amiss.
+ *
  */
 
-int 
-rf_CheckLabels( raidPtr, cfgPtr )
-	RF_Raid_t *raidPtr;
-	RF_Config_t *cfgPtr;
+int
+rf_CheckLabels(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr)
 {
-	int r,c;
+	int r, c;
 	char *dev_name;
 	RF_ComponentLabel_t *ci_label;
 	int serial_number = 0;
@@ -782,32 +799,32 @@ rf_CheckLabels( raidPtr, cfgPtr )
 	too_fatal = 0;
 	force = cfgPtr->force;
 
-	/* 
-	   We're going to try to be a little intelligent here.  If one 
-	   component's label is bogus, and we can identify that it's the
-	   *only* one that's gone, we'll mark it as "failed" and allow
-	   the configuration to proceed.  This will be the *only* case
-	   that we'll proceed if there would be (otherwise) fatal errors.
-	   
-	   Basically we simply keep a count of how many components had
-	   what serial number.  If all but one agree, we simply mark
-	   the disagreeing component as being failed, and allow 
-	   things to come up "normally".
-	   
-	   We do this first for serial numbers, and then for "mod_counter".
-
+	/*
+	 * We're going to try to be a little intelligent here. If one
+	 * component's label is bogus, and we can identify that it's the
+	 * *only* one that's gone, we'll mark it as "failed" and allow
+	 * the configuration to proceed. This will be the *only* case
+	 * that we'll proceed if there would be (otherwise) fatal errors.
+	 *
+	 * Basically we simply keep a count of how many components had
+	 * what serial number. If all but one agree, we simply mark
+	 * the disagreeing component as being failed, and allow
+	 * things to come up "normally".
+	 *
+	 * We do this first for serial numbers, and then for "mod_counter".
+	 *
 	 */
 
 	num_ser = 0;
 	num_mod = 0;
-	for (r = 0; r < raidPtr->numRow && !fatal_error ; r++) {
+	for (r = 0; r < raidPtr->numRow && !fatal_error; r++) {
 		for (c = 0; c < raidPtr->numCol; c++) {
 			ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
-			found=0;
-			for(i=0;i<num_ser;i++) {
+			found = 0;
+			for(i = 0; i < num_ser; i++) {
 				if (ser_values[i] == ci_label->serial_number) {
 					ser_count[i]++;
-					found=1;
+					found = 1;
 					break;
 				}
 			}
@@ -815,51 +832,52 @@ rf_CheckLabels( raidPtr, cfgPtr )
 				ser_values[num_ser] = ci_label->serial_number;
 				ser_count[num_ser] = 1;
 				num_ser++;
-				if (num_ser>2) {
+				if (num_ser > 2) {
 					fatal_error = 1;
 					break;
 				}
 			}
-			found=0;
-			for(i=0;i<num_mod;i++) {
+			found = 0;
+			for(i = 0; i < num_mod; i++) {
 				if (mod_values[i] == ci_label->mod_counter) {
 					mod_count[i]++;
-					found=1;
+					found = 1;
 					break;
 				}
 			}
 			if (!found) {
-			        mod_values[num_mod] = ci_label->mod_counter;
+				mod_values[num_mod] = ci_label->mod_counter;
 				mod_count[num_mod] = 1;
 				num_mod++;
-				if (num_mod>2) {
+				if (num_mod > 2) {
 					fatal_error = 1;
 					break;
 				}
 			}
 		}
 	}
-#if DEBUG
+#if	DEBUG
 	printf("raid%d: Summary of serial numbers:\n", raidPtr->raidid);
-	for(i=0;i<num_ser;i++) {
+	for(i = 0; i < num_ser; i++) {
 		printf("%d %d\n", ser_values[i], ser_count[i]);
 	}
 	printf("raid%d: Summary of mod counters:\n", raidPtr->raidid);
-	for(i=0;i<num_mod;i++) {
+	for(i = 0; i < num_mod; i++) {
 		printf("%d %d\n", mod_values[i], mod_count[i]);
 	}
-#endif
+#endif  /* DEBUG */
 	serial_number = ser_values[0];
 	if (num_ser == 2) {
 		if ((ser_count[0] == 1) || (ser_count[1] == 1)) {
-			/* Locate the maverick component */
+			/* Locate the maverick component. */
 			if (ser_count[1] > ser_count[0]) {
 				serial_number = ser_values[1];
-			} 
+			}
 			for (r = 0; r < raidPtr->numRow; r++) {
 				for (c = 0; c < raidPtr->numCol; c++) {
-				ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
-					if (serial_number != 
+					ci_label =
+					    &raidPtr->raid_cinfo[r][c].ci_label;
+					if (serial_number !=
 					    ci_label->serial_number) {
 						hosed_row = r;
 						hosed_column = c;
@@ -867,14 +885,16 @@ rf_CheckLabels( raidPtr, cfgPtr )
 					}
 				}
 			}
-			printf("Hosed component: %s\n",
-			       &cfgPtr->devnames[hosed_row][hosed_column][0]);
+			printf("Hosed component: %s.\n",
+			    &cfgPtr->devnames[hosed_row][hosed_column][0]);
 			if (!force) {
-				/* we'll fail this component, as if there are
-				   other major errors, we arn't forcing things
-				   and we'll abort the config anyways */
+				/*
+				 * We'll fail this component, as if there are
+				 * other major errors, we aren't forcing things
+				 * and we'll abort the config anyways.
+				 */
 				raidPtr->Disks[hosed_row][hosed_column].status
-					= rf_ds_failed;
+				    = rf_ds_failed;
 				raidPtr->numFailures++;
 				raidPtr->status[hosed_row] = rf_rs_degraded;
 			}
@@ -882,47 +902,56 @@ rf_CheckLabels( raidPtr, cfgPtr )
 			too_fatal = 1;
 		}
 		if (cfgPtr->parityConfig == '0') {
-			/* We've identified two different serial numbers. 
-			   RAID 0 can't cope with that, so we'll punt */
+			/*
+			 * We've identified two different serial numbers.
+			 * RAID 0 can't cope with that, so we'll punt.
+			 */
 			too_fatal = 1;
 		}
 
-	} 
+	}
 
-	/* record the serial number for later.  If we bail later, setting
-	   this doesn't matter, otherwise we've got the best guess at the 
-	   correct serial number */
+	/*
+	 * Record the serial number for later. If we bail later, setting
+	 * this doesn't matter, otherwise we've got the best guess at the
+	 * correct serial number.
+	 */
 	raidPtr->serial_number = serial_number;
 
 	mod_number = mod_values[0];
 	if (num_mod == 2) {
 		if ((mod_count[0] == 1) || (mod_count[1] == 1)) {
-			/* Locate the maverick component */
+			/* Locate the maverick component. */
 			if (mod_count[1] > mod_count[0]) {
 				mod_number = mod_values[1];
 			} else if (mod_count[1] < mod_count[0]) {
 				mod_number = mod_values[0];
 			} else {
-				/* counts of different modification values
-				   are the same.   Assume greater value is 
-				   the correct one, all other things 
-				   considered */
+				/*
+				 * Counts of different modification values
+				 * are the same. Assume greater value is
+				 * the correct one, all other things
+				 * considered.
+				 */
 				if (mod_values[0] > mod_values[1]) {
 					mod_number = mod_values[0];
 				} else {
 					mod_number = mod_values[1];
 				}
-				
+
 			}
-			for (r = 0; r < raidPtr->numRow && !too_fatal ; r++) {
+			for (r = 0; r < raidPtr->numRow && !too_fatal; r++) {
 				for (c = 0; c < raidPtr->numCol; c++) {
-					ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
-					if (mod_number != 
+					ci_label =
+					    &raidPtr->raid_cinfo[r][c].ci_label;
+					if (mod_number !=
 					    ci_label->mod_counter) {
-						if ( ( hosed_row == r ) &&
-						     ( hosed_column == c )) {
-							/* same one.  Can
-							   deal with it.  */
+						if ((hosed_row == r) &&
+						    (hosed_column == c)) {
+							/*
+							 * Same one. Can
+							 * deal with it.
+							 */
 						} else {
 							hosed_row = r;
 							hosed_column = c;
@@ -934,52 +963,64 @@ rf_CheckLabels( raidPtr, cfgPtr )
 					}
 				}
 			}
-			printf("Hosed component: %s\n",
-			       &cfgPtr->devnames[hosed_row][hosed_column][0]);
+			printf("Hosed component: %s.\n",
+			    &cfgPtr->devnames[hosed_row][hosed_column][0]);
 			if (!force) {
-				/* we'll fail this component, as if there are
-				   other major errors, we arn't forcing things
-				   and we'll abort the config anyways */
-				if (raidPtr->Disks[hosed_row][hosed_column].status != rf_ds_failed) {
-					raidPtr->Disks[hosed_row][hosed_column].status
-						= rf_ds_failed;
+				/*
+				 * We'll fail this component, as if there are
+				 * other major errors, we aren't forcing things
+				 * and we'll abort the config anyways.
+				 */
+				if (raidPtr
+				    ->Disks[hosed_row][hosed_column].status !=
+				    rf_ds_failed) {
+					raidPtr->Disks[hosed_row]
+					    [hosed_column].status =
+					    rf_ds_failed;
 					raidPtr->numFailures++;
-					raidPtr->status[hosed_row] = rf_rs_degraded;
+					raidPtr->status[hosed_row] =
+					    rf_rs_degraded;
 				}
 			}
 		} else {
 			too_fatal = 1;
 		}
 		if (cfgPtr->parityConfig == '0') {
-			/* We've identified two different mod counters.
-			   RAID 0 can't cope with that, so we'll punt */
+			/*
+			 * We've identified two different mod counters.
+			 * RAID 0 can't cope with that, so we'll punt.
+			 */
 			too_fatal = 1;
 		}
-	} 
+	}
 
 	raidPtr->mod_counter = mod_number;
 
 	if (too_fatal) {
-		/* we've had both a serial number mismatch, and a mod_counter
-		   mismatch -- and they involved two different components!!
-		   Bail -- make things fail so that the user must force
-		   the issue... */
+		/*
+		 * We've had both a serial number mismatch, and a mod_counter
+		 * mismatch -- and they involved two different components !!!
+		 * Bail -- make things fail so that the user must force
+		 * the issue...
+		 */
 		hosed_row = -1;
 		hosed_column = -1;
 	}
 
 	if (num_ser > 2) {
-		printf("raid%d: Too many different serial numbers!\n", 
-		       raidPtr->raidid);
+		printf("raid%d: Too many different serial numbers !\n",
+		    raidPtr->raidid);
 	}
 
 	if (num_mod > 2) {
-		printf("raid%d: Too many different mod counters!\n", 
-		       raidPtr->raidid);
+		printf("raid%d: Too many different mod counters !\n",
+		    raidPtr->raidid);
 	}
 
-	/* we start by assuming the parity will be good, and flee from
-	   that notion at the slightest sign of trouble */
+	/*
+	 * We start by assuming the parity will be good, and flee from
+	 * that notion at the slightest sign of trouble.
+	 */
 
 	parity_good = RF_RAID_CLEAN;
 	for (r = 0; r < raidPtr->numRow; r++) {
@@ -988,15 +1029,14 @@ rf_CheckLabels( raidPtr, cfgPtr )
 			ci_label = &raidPtr->raid_cinfo[r][c].ci_label;
 
 			if ((r == hosed_row) && (c == hosed_column)) {
-				printf("raid%d: Ignoring %s\n",
-				       raidPtr->raidid, dev_name);
-			} else {			
-				rf_print_label_status( raidPtr, r, c, 
-						       dev_name, ci_label );
-				if (rf_check_label_vitals( raidPtr, r, c, 
-							   dev_name, ci_label,
-							   serial_number, 
-							   mod_number )) {
+				printf("raid%d: Ignoring %s.\n",
+				    raidPtr->raidid, dev_name);
+			} else {
+				rf_print_label_status(raidPtr, r, c, dev_name,
+				    ci_label);
+				if (rf_check_label_vitals(raidPtr, r, c,
+				     dev_name, ci_label, serial_number,
+				     mod_number)) {
 					fatal_error = 1;
 				}
 				if (ci_label->clean != RF_RAID_CLEAN) {
@@ -1009,16 +1049,14 @@ rf_CheckLabels( raidPtr, cfgPtr )
 		parity_good = RF_RAID_DIRTY;
 	}
 
-	/* we note the state of the parity */
+	/* We note the state of the parity. */
 	raidPtr->parity_good = parity_good;
 
-	return(fatal_error);	
+	return(fatal_error);
 }
 
 int
-rf_add_hot_spare(raidPtr, sparePtr)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *sparePtr;
+rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
 {
 	RF_RaidDisk_t *disks;
 	RF_DiskQueue_t *spareQueues;
@@ -1027,78 +1065,77 @@ rf_add_hot_spare(raidPtr, sparePtr)
 	int spare_number;
 
 #if 0
-	printf("Just in rf_add_hot_spare: %d\n",raidPtr->numSpare);
-	printf("Num col: %d\n",raidPtr->numCol);
+	printf("Just in rf_add_hot_spare: %d.\n", raidPtr->numSpare);
+	printf("Num col: %d.\n", raidPtr->numCol);
 #endif
 	if (raidPtr->numSpare >= RF_MAXSPARE) {
-		RF_ERRORMSG1("Too many spares: %d\n", raidPtr->numSpare);
+		RF_ERRORMSG1("Too many spares: %d.\n", raidPtr->numSpare);
 		return(EINVAL);
  	}
 
 	RF_LOCK_MUTEX(raidPtr->mutex);
 
-	/* the beginning of the spares... */
+	/* The beginning of the spares... */
 	disks = &raidPtr->Disks[0][raidPtr->numCol];
 
 	spare_number = raidPtr->numSpare;
 
 	ret = rf_ConfigureDisk(raidPtr, sparePtr->component_name,
-			       &disks[spare_number], 0,
-			       raidPtr->numCol + spare_number);
+	    &disks[spare_number], 0, raidPtr->numCol + spare_number);
 
 	if (ret)
 		goto fail;
 	if (disks[spare_number].status != rf_ds_optimal) {
-		RF_ERRORMSG1("Warning: spare disk %s failed TUR\n", 
-			     sparePtr->component_name);
-		ret=EINVAL;
+		RF_ERRORMSG1("Warning: spare disk %s failed TUR.\n",
+		    sparePtr->component_name);
+		ret = EINVAL;
 		goto fail;
 	} else {
 		disks[spare_number].status = rf_ds_spare;
-		DPRINTF6("Spare Disk %d: dev %s numBlocks %ld blockSize %d (%ld MB)\n", spare_number,
-			 disks[spare_number].devname,
-			 (long int) disks[spare_number].numBlocks, 
-			 disks[spare_number].blockSize,
-			 (long int) disks[spare_number].numBlocks * 
-			 disks[spare_number].blockSize / 1024 / 1024);
+		DPRINTF6("Spare Disk %d: dev %s numBlocks %ld blockSize %d"
+		    " (%ld MB).\n", spare_number, disks[spare_number].devname,
+		    (long int) disks[spare_number].numBlocks,
+		    disks[spare_number].blockSize,
+		    (long int) disks[spare_number].numBlocks *
+		     disks[spare_number].blockSize / 1024 / 1024);
 	}
-	
 
-	/* check sizes and block sizes on the spare disk */
+
+	/* Check sizes and block sizes on the spare disk. */
 	bs = 1 << raidPtr->logBytesPerSector;
 	if (disks[spare_number].blockSize != bs) {
-		RF_ERRORMSG3("Block size of %d on spare disk %s is not the same as on other disks (%d)\n", disks[spare_number].blockSize, disks[spare_number].devname, bs);
+		RF_ERRORMSG3("Block size of %d on spare disk %s is not"
+		    " the same as on other disks (%d).\n",
+		    disks[spare_number].blockSize,
+		    disks[spare_number].devname, bs);
 		ret = EINVAL;
 		goto fail;
 	}
 	if (disks[spare_number].numBlocks < raidPtr->sectorsPerDisk) {
-		RF_ERRORMSG3("Spare disk %s (%d blocks) is too small to serve as a spare (need %ld blocks)\n",
-			     disks[spare_number].devname, 
-			     disks[spare_number].blockSize, 
-			     (long int) raidPtr->sectorsPerDisk);
+		RF_ERRORMSG3("Spare disk %s (%d blocks) is too small to serve"
+		    " as a spare (need %ld blocks).\n",
+		    disks[spare_number].devname, disks[spare_number].blockSize,
+		    (long int) raidPtr->sectorsPerDisk);
 		ret = EINVAL;
 		goto fail;
 	} else {
-		if (disks[spare_number].numBlocks > 
+		if (disks[spare_number].numBlocks >
 		    raidPtr->sectorsPerDisk) {
-			RF_ERRORMSG2("Warning: truncating spare disk %s to %ld blocks\n", disks[spare_number].devname, 
-				     (long int) raidPtr->sectorsPerDisk);
-			
+			RF_ERRORMSG2("Warning: truncating spare disk %s to %ld"
+			    " blocks.\n", disks[spare_number].devname,
+			    (long int) raidPtr->sectorsPerDisk);
+
 			disks[spare_number].numBlocks = raidPtr->sectorsPerDisk;
 		}
 	}
 
 	spareQueues = &raidPtr->Queues[0][raidPtr->numCol];
-	ret = rf_ConfigureDiskQueue( raidPtr, &spareQueues[spare_number],
-				 0, raidPtr->numCol + spare_number, 
-				 raidPtr->qType,
-				 raidPtr->sectorsPerDisk,
-				 raidPtr->Disks[0][raidPtr->numCol + 
-						  spare_number].dev,
-				 raidPtr->maxOutstanding,
-				 &raidPtr->shutdownList,
-				 raidPtr->cleanupList);
-				 
+	ret = rf_ConfigureDiskQueue(raidPtr, &spareQueues[spare_number],
+	    0, raidPtr->numCol + spare_number, raidPtr->qType,
+	    raidPtr->sectorsPerDisk, raidPtr->Disks[0][raidPtr->numCol +
+	     spare_number].dev, raidPtr->maxOutstanding,
+	    &raidPtr->shutdownList, raidPtr->cleanupList);
+
 
 	raidPtr->numSpare++;
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
@@ -1110,29 +1147,26 @@ fail:
 }
 
 int
-rf_remove_hot_spare(raidPtr,sparePtr)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *sparePtr;
+rf_remove_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr)
 {
 	int spare_number;
 
-
-	if (raidPtr->numSpare==0) {
-		printf("No spares to remove!\n");
+	if (raidPtr->numSpare == 0) {
+		printf("No spares to remove !\n");
 		return(EINVAL);
 	}
 
 	spare_number = sparePtr->column;
 
-	return(EINVAL); /* XXX not implemented yet */
+	return(EINVAL);	/* XXX Not implemented yet. */
 #if 0
 	if (spare_number < 0 || spare_number > raidPtr->numSpare) {
 		return(EINVAL);
 	}
 
-	/* verify that this spare isn't in use... */
+	/* Verify that this spare isn't in use... */
 
-	/* it's gone.. */
+	/* It's gone... */
 
 	raidPtr->numSpare--;
 
@@ -1141,34 +1175,32 @@ rf_remove_hot_spare(raidPtr,sparePtr)
 }
 
 int
-rf_delete_component(raidPtr,component)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *component;
+rf_delete_component(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
 {
 	RF_RaidDisk_t *disks;
 
-	if ((component->row < 0) || 
+	if ((component->row < 0) ||
 	    (component->row >= raidPtr->numRow) ||
-	    (component->column < 0) || 
+	    (component->column < 0) ||
 	    (component->column >= raidPtr->numCol)) {
 		return(EINVAL);
 	}
 
 	disks = &raidPtr->Disks[component->row][component->column];
 
-	/* 1. This component must be marked as 'failed' */
+	/* 1. This component must be marked as 'failed'. */
 
 	return(EINVAL); /* Not implemented yet. */
 }
 
 int
-rf_incorporate_hot_spare(raidPtr,component)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *component;
+rf_incorporate_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *component)
 {
 
-	/* Issues here include how to 'move' this in if there is IO 
-	   taking place (e.g. component queues and such) */
+	/*
+	 * Issues here include how to 'move' this in if there is IO
+	 * taking place (e.g. component queues and such).
+	 */
 
 	return(EINVAL); /* Not implemented yet. */
 }
diff --git a/sys/dev/raidframe/rf_disks.h b/sys/dev/raidframe/rf_disks.h
index bb15d365b5e..f6ea2e666d2 100644
--- a/sys/dev/raidframe/rf_disks.h
+++ b/sys/dev/raidframe/rf_disks.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_disks.h,v 1.4 2000/08/08 16:07:40 peter Exp $	*/
+/*	$OpenBSD: rf_disks.h,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_disks.h,v 1.8 2000/03/27 03:25:17 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,20 +29,20 @@
  */
 
 /*
- * rf_disks.h -- header file for code related to physical disks
+ * rf_disks.h -- Header file for code related to physical disks.
  */
 
-#ifndef _RF__RF_DISKS_H_
-#define _RF__RF_DISKS_H_
+#ifndef	_RF__RF_DISKS_H_
+#define	_RF__RF_DISKS_H_
 
 #include <sys/types.h>
 
 #include "rf_archs.h"
 #include "rf_types.h"
 
-#if defined(__NetBSD__)
+#if	defined(__NetBSD__)
 #include "rf_netbsd.h"
-#elif defined(__OpenBSD__)
+#elif	defined(__OpenBSD__)
 #include "rf_openbsd.h"
 #endif
 
@@ -50,69 +51,86 @@
  * IF YOU ADD A STATE, CHECK TO SEE IF YOU NEED TO MODIFY RF_DEAD_DISK() BELOW.
  */
 enum RF_DiskStatus_e {
-	rf_ds_optimal,		/* no problems */
-	rf_ds_failed,		/* reconstruction ongoing */
-	rf_ds_reconstructing,	/* reconstruction complete to spare, dead disk
-				 * not yet replaced */
-	rf_ds_dist_spared,	/* reconstruction complete to distributed
-				 * spare space, dead disk not yet replaced */
-	rf_ds_spared,		/* reconstruction complete to distributed
-				 * spare space, dead disk not yet replaced */
-	rf_ds_spare,		/* an available spare disk */
-	rf_ds_used_spare	/* a spare which has been used, and hence is
-				 * not available */
+	rf_ds_optimal,		/* No problems. */
+	rf_ds_failed,		/* Reconstruction ongoing. */
+	rf_ds_reconstructing,	/*
+				 * Reconstruction complete to spare, dead disk
+				 * not yet replaced.
+				 */
+	rf_ds_dist_spared,	/*
+				 * Reconstruction complete to distributed
+				 * spare space, dead disk not yet replaced.
+				 */
+	rf_ds_spared,		/*
+				 * Reconstruction complete to distributed
+				 * spare space, dead disk not yet replaced.
+				 */
+	rf_ds_spare,		/* An available spare disk. */
+	rf_ds_used_spare	/*
+				 * A spare which has been used, and hence is
+				 * not available.
+				 */
 };
 typedef enum RF_DiskStatus_e RF_DiskStatus_t;
 
 struct RF_RaidDisk_s {
-	char    devname[56];	/* name of device file */
-	RF_DiskStatus_t status;	/* whether it is up or down */
-	RF_RowCol_t spareRow;	/* if in status "spared", this identifies the
-				 * spare disk */
-	RF_RowCol_t spareCol;	/* if in status "spared", this identifies the
-				 * spare disk */
-	RF_SectorCount_t numBlocks;	/* number of blocks, obtained via READ
-					 * CAPACITY */
-	int     blockSize;
-	RF_SectorCount_t partitionSize; /* The *actual* and *full* size of 
-					   the partition, from the disklabel */
-	int     auto_configured;/* 1 if this component was autoconfigured.
-				   0 otherwise. */
-	dev_t   dev;
+	char devname[56];		/* Name of device file. */
+	RF_DiskStatus_t status;		/* Whether it is up or down. */
+	RF_RowCol_t spareRow;		/*
+					 * If in status "spared", this
+					 * identifies the spare disk.
+					 */
+	RF_RowCol_t spareCol;		/*
+					 * If in status "spared", this
+					 * identifies the spare disk.
+					 */
+	RF_SectorCount_t numBlocks;	/*
+					 * Number of blocks, obtained via
+					 * READ CAPACITY.
+					 */
+	int blockSize;
+	RF_SectorCount_t partitionSize; /*
+					 * The *actual* and *full* size of
+					 * the partition, from the disklabel.
+					 */
+	int auto_configured;		/*
+					 * 1 if this component was
+					 * autoconfigured. 0 otherwise.
+					 */
+	dev_t dev;
 };
+
 /*
  * An RF_DiskOp_t ptr is really a pointer to a UAGT_CCB, but I want
- * to isolate the cam layer from all other layers, so I typecast to/from
+ * to isolate the CAM layer from all other layers, so I typecast to/from
  * RF_DiskOp_t * (i.e. void *) at the interfaces.
  */
 typedef void RF_DiskOp_t;
 
-/* if a disk is in any of these states, it is inaccessible */
-#define RF_DEAD_DISK(_dstat_) (((_dstat_) == rf_ds_spared) || \
-	((_dstat_) == rf_ds_reconstructing) || ((_dstat_) == rf_ds_failed) || \
-	((_dstat_) == rf_ds_dist_spared))
+/* If a disk is in any of these states, it is inaccessible. */
+#define	RF_DEAD_DISK(_dstat_)						\
+	(((_dstat_) == rf_ds_spared) ||					\
+	 ((_dstat_) == rf_ds_reconstructing) ||				\
+	 ((_dstat_) == rf_ds_failed) ||					\
+	 ((_dstat_) == rf_ds_dist_spared))
 
-#ifdef _KERNEL
-#if defined(__NetBSD__)
+#ifdef	_KERNEL
+#if	defined(__NetBSD__)
 #include "rf_netbsd.h"
-#elif defined(__OpenBSD__)
+#elif	defined(__OpenBSD__)
 #include "rf_openbsd.h"
 #endif
 
-int rf_ConfigureDisks(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-		      RF_Config_t * cfgPtr);
-int rf_ConfigureSpareDisks(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-			   RF_Config_t * cfgPtr);
-int rf_ConfigureDisk(RF_Raid_t * raidPtr, char *buf, RF_RaidDisk_t * diskPtr,
-		     RF_RowCol_t row, RF_RowCol_t col);
-int rf_AutoConfigureDisks(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr,
-			  RF_AutoConfig_t *auto_config);
-int rf_CheckLabels( RF_Raid_t *, RF_Config_t *);
-int rf_add_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr);
-int rf_remove_hot_spare(RF_Raid_t *raidPtr, RF_SingleComponent_t *sparePtr);
-int rf_delete_component(RF_Raid_t *raidPtr, RF_SingleComponent_t *component);
-int rf_incorporate_hot_spare(RF_Raid_t *raidPtr, 
-			     RF_SingleComponent_t *component);
-#endif /* _KERNEL */
+int rf_ConfigureDisks(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int rf_ConfigureSpareDisks(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int rf_ConfigureDisk(RF_Raid_t *, char *, RF_RaidDisk_t *,
+	RF_RowCol_t, RF_RowCol_t);
+int rf_AutoConfigureDisks(RF_Raid_t *, RF_Config_t *, RF_AutoConfig_t *);
+int rf_CheckLabels(RF_Raid_t *, RF_Config_t *);
+int rf_add_hot_spare(RF_Raid_t *, RF_SingleComponent_t *);
+int rf_remove_hot_spare(RF_Raid_t *, RF_SingleComponent_t *);
+int rf_delete_component(RF_Raid_t *, RF_SingleComponent_t *);
+int rf_incorporate_hot_spare(RF_Raid_t *, RF_SingleComponent_t *);
+#endif	/* _KERNEL */
 
-#endif				/* !_RF__RF_DISKS_H_ */
+#endif	/* !_RF__RF_DISKS_H_ */
diff --git a/sys/dev/raidframe/rf_driver.c b/sys/dev/raidframe/rf_driver.c
index 57580f7b390..3a5e00f74b3 100644
--- a/sys/dev/raidframe/rf_driver.c
+++ b/sys/dev/raidframe/rf_driver.c
@@ -1,6 +1,7 @@
-/*	$OpenBSD: rf_driver.c,v 1.10 2002/08/09 15:10:20 tdeval Exp $	*/
+/*	$OpenBSD: rf_driver.c,v 1.11 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_driver.c,v 1.37 2000/06/04 02:05:13 oster Exp $	*/
-/*-
+
+/*
  * Copyright (c) 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
@@ -17,8 +18,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *        This product includes software developed by the NetBSD
- *        Foundation, Inc. and its contributors.
+ *	This product includes software developed by the NetBSD
+ *	Foundation, Inc. and its contributors.
  * 4. Neither the name of The NetBSD Foundation nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
@@ -40,8 +41,9 @@
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
  *
- * Author: Mark Holland, Khalil Amiri, Claudson Bornstein, William V. Courtright II,
- *         Robby Findler, Daniel Stodolsky, Rachad Youssef, Jim Zelenka
+ * Author:	Mark Holland, Khalil Amiri, Claudson Bornstein,
+ *		William V. Courtright II, Robby Findler, Daniel Stodolsky,
+ *		Rachad Youssef, Jim Zelenka
  *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
@@ -64,20 +66,21 @@
  * rights to redistribute these changes.
  */
 
-/******************************************************************************
+/*****************************************************************************
  *
- * rf_driver.c -- main setup, teardown, and access routines for the RAID driver
+ * rf_driver.c -- Main setup, teardown, and access routines for the RAID
+ *		  driver
  *
- * all routines are prefixed with rf_ (raidframe), to avoid conficts.
+ * All routines are prefixed with rf_ (RAIDframe), to avoid conficts.
  *
- ******************************************************************************/
+ *****************************************************************************/
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
-#ifdef __NetBSD__
+#ifdef	__NetBSD__
 #include <sys/vnode.h>
 #endif
 
@@ -122,51 +125,61 @@
 
 /* rad == RF_RaidAccessDesc_t */
 static RF_FreeList_t *rf_rad_freelist;
-#define RF_MAX_FREE_RAD 128
-#define RF_RAD_INC       16
-#define RF_RAD_INITIAL   32
+#define	RF_MAX_FREE_RAD		128
+#define	RF_RAD_INC		 16
+#define	RF_RAD_INITIAL		 32
 
-/* debug variables */
-char    rf_panicbuf[2048];	/* a buffer to hold an error msg when we panic */
+/* Debug variables. */
+char	rf_panicbuf[2048];	/*
+				 * A buffer to hold an error msg when we panic.
+				 */
 
-/* main configuration routines */
+/* Main configuration routines. */
 static int raidframe_booted = 0;
 
-static void rf_ConfigureDebug(RF_Config_t * cfgPtr);
-static void set_debug_option(char *name, long val);
-static void rf_UnconfigureArray(void);
-static int init_rad(RF_RaidAccessDesc_t *);
-static void clean_rad(RF_RaidAccessDesc_t *);
-static void rf_ShutdownRDFreeList(void *);
-static int rf_ConfigureRDFreeList(RF_ShutdownList_t **);
-
-RF_DECLARE_MUTEX(rf_printf_mutex)	/* debug only:  avoids interleaved
-					 * printfs by different stripes */
-
-#define SIGNAL_QUIESCENT_COND(_raid_)  wakeup(&((_raid_)->accesses_suspended))
-#define WAIT_FOR_QUIESCENCE(_raid_) \
-	tsleep(&((_raid_)->accesses_suspended),PRIBIO,"raidframe quiesce", 0);
-
-#define IO_BUF_ERR(bp, err) { \
-	bp->b_flags |= B_ERROR; \
-	bp->b_resid = bp->b_bcount; \
-	bp->b_error = err; \
-	biodone(bp); \
-}
-
-static int configureCount = 0;	/* number of active configurations */
-static int isconfigged = 0;	/* is basic raidframe (non per-array)
-					 * stuff configged */
-RF_DECLARE_STATIC_MUTEX(configureMutex)	/* used to lock the configuration
-					 * stuff */
-static RF_ShutdownList_t *globalShutdown;	/* non array-specific stuff */
-static int rf_ConfigureRDFreeList(RF_ShutdownList_t ** listp);
-
-/* called at system boot time */
+void rf_ConfigureDebug(RF_Config_t *);
+void rf_set_debug_option(char *, long);
+void rf_UnconfigureArray(void);
+int  rf_init_rad(RF_RaidAccessDesc_t *);
+void rf_clean_rad(RF_RaidAccessDesc_t *);
+void rf_ShutdownRDFreeList(void *);
+int  rf_ConfigureRDFreeList(RF_ShutdownList_t **);
+
+RF_DECLARE_MUTEX(rf_printf_mutex);	/*
+					 * Debug only: Avoids interleaved
+					 * printfs by different stripes.
+					 */
+
+#define	SIGNAL_QUIESCENT_COND(_raid_)	wakeup(&((_raid_)->accesses_suspended))
+#define	WAIT_FOR_QUIESCENCE(_raid_)					\
+	tsleep(&((_raid_)->accesses_suspended), PRIBIO, "RAIDframe quiesce", 0);
+
+#define	IO_BUF_ERR(bp, err)						\
+do {									\
+	bp->b_flags |= B_ERROR;						\
+	bp->b_resid = bp->b_bcount;					\
+	bp->b_error = err;						\
+	biodone(bp);							\
+} while (0)
+
+static int configureCount = 0;	/* Number of active configurations. */
+static int isconfigged = 0;	/*
+				 * Is basic RAIDframe (non per-array)
+				 * stuff configured ?
+				 */
+RF_DECLARE_STATIC_MUTEX(configureMutex);	/*
+						 * Used to lock the
+						 * configuration stuff.
+						 */
+static RF_ShutdownList_t *globalShutdown;	/* Non array-specific stuff. */
+int  rf_ConfigureRDFreeList(RF_ShutdownList_t **);
+
+
+/* Called at system boot time. */
 int
-rf_BootRaidframe()
+rf_BootRaidframe(void)
 {
-	int     rc;
+	int rc;
 
 	if (raidframe_booted)
 		return (EBUSY);
@@ -174,8 +187,8 @@ rf_BootRaidframe()
 
 	rc = rf_mutex_init(&configureMutex);
 	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);
 		RF_PANIC();
 	}
 	configureCount = 0;
@@ -183,16 +196,18 @@ rf_BootRaidframe()
 	globalShutdown = NULL;
 	return (0);
 }
+
+
 /*
- * This function is really just for debugging user-level stuff: it
- * frees up all memory, other RAIDframe resources which might otherwise
+ * This function is really just for debugging user-level stuff: It
+ * frees up all memory, other RAIDframe resources that might otherwise
  * be kept around. This is used with systems like "sentinel" to detect
  * memory leaks.
  */
-int 
-rf_UnbootRaidframe()
+int
+rf_UnbootRaidframe(void)
 {
-	int     rc;
+	int rc;
 
 	RF_LOCK_MUTEX(configureMutex);
 	if (configureCount) {
@@ -203,58 +218,65 @@ rf_UnbootRaidframe()
 	RF_UNLOCK_MUTEX(configureMutex);
 	rc = rf_mutex_destroy(&configureMutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to destroy mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to destroy mutex file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		RF_PANIC();
 	}
 	return (0);
 }
+
+
 /*
- * Called whenever an array is shutdown
+ * Called whenever an array is shutdown.
  */
-static void 
-rf_UnconfigureArray()
+void
+rf_UnconfigureArray(void)
 {
-	int     rc;
+	int rc;
 
 	RF_LOCK_MUTEX(configureMutex);
-	if (--configureCount == 0) {	/* if no active configurations, shut
-					 * everything down */
+	if (--configureCount == 0) {	/*
+					 * If no active configurations, shut
+					 * everything down.
+					 */
 		isconfigged = 0;
 
 		rc = rf_ShutdownList(&globalShutdown);
 		if (rc) {
-			RF_ERRORMSG1("RAIDFRAME: unable to do global shutdown, rc=%d\n", rc);
+			RF_ERRORMSG1("RAIDFRAME: unable to do global shutdown,"
+			    " rc=%d.\n", rc);
 		}
 
 		/*
-	         * We must wait until now, because the AllocList module
-	         * uses the DebugMem module.
-	         */
+		 * We must wait until now, because the AllocList module
+		 * uses the DebugMem module.
+		 */
 		if (rf_memDebug)
 			rf_print_unfreed();
 	}
 	RF_UNLOCK_MUTEX(configureMutex);
 }
+
+
 /*
  * Called to shut down an array.
  */
-int 
-rf_Shutdown(raidPtr)
-	RF_Raid_t *raidPtr;
+int
+rf_Shutdown(RF_Raid_t *raidPtr)
 {
 	if (!raidPtr->valid) {
-		RF_ERRORMSG("Attempt to shut down unconfigured RAIDframe driver.  Aborting shutdown\n");
+		RF_ERRORMSG("Attempt to shut down unconfigured RAIDframe"
+		    " driver. Aborting shutdown.\n");
 		return (EINVAL);
 	}
 	/*
-         * wait for outstanding IOs to land
-         * As described in rf_raid.h, we use the rad_freelist lock
-         * to protect the per-array info about outstanding descs
-         * since we need to do freelist locking anyway, and this
-         * cuts down on the amount of serialization we've got going
-         * on.
-         */
+	 * Wait for outstanding IOs to land.
+	 * As described in rf_raid.h, we use the rad_freelist lock
+	 * to protect the per-array info about outstanding descs,
+	 * since we need to do freelist locking anyway, and this
+	 * cuts down on the amount of serialization we've got going
+	 * on.
+	 */
 	RF_FREELIST_DO_LOCK(rf_rad_freelist);
 	if (raidPtr->waitShutdown) {
 		RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
@@ -286,67 +308,73 @@ rf_Shutdown(raidPtr)
 	return (0);
 }
 
-#define DO_INIT_CONFIGURE(f) { \
-	rc = f (&globalShutdown); \
-	if (rc) { \
-		RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \
-		rf_ShutdownList(&globalShutdown); \
-		configureCount--; \
-		RF_UNLOCK_MUTEX(configureMutex); \
-		return(rc); \
-	} \
-}
-
-#define DO_RAID_FAIL() { \
-	rf_UnconfigureVnodes(raidPtr); \
-	rf_ShutdownList(&raidPtr->shutdownList); \
-	rf_UnconfigureArray(); \
-}
-
-#define DO_RAID_INIT_CONFIGURE(f) { \
-	rc = f (&raidPtr->shutdownList, raidPtr, cfgPtr); \
-	if (rc) { \
-		RF_ERRORMSG2("RAIDFRAME: failed %s with %d\n", RF_STRING(f), rc); \
-		DO_RAID_FAIL(); \
-		return(rc); \
-	} \
-}
-
-#define DO_RAID_MUTEX(_m_) { \
-	rc = rf_create_managed_mutex(&raidPtr->shutdownList, (_m_)); \
-	if (rc) { \
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", \
-			__FILE__, __LINE__, rc); \
-		DO_RAID_FAIL(); \
-		return(rc); \
-	} \
-}
-
-#define DO_RAID_COND(_c_) { \
-	rc = rf_create_managed_cond(&raidPtr->shutdownList, (_c_)); \
-	if (rc) { \
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", \
-			__FILE__, __LINE__, rc); \
-		DO_RAID_FAIL(); \
-		return(rc); \
-	} \
-}
+#define	DO_INIT_CONFIGURE(f)						\
+do {									\
+	rc = f (&globalShutdown);					\
+	if (rc) {							\
+		RF_ERRORMSG2("RAIDFRAME: failed %s with %d.\n",		\
+		    RF_STRING(f), rc);					\
+		rf_ShutdownList(&globalShutdown);			\
+		configureCount--;					\
+		RF_UNLOCK_MUTEX(configureMutex);			\
+		return(rc);						\
+	}								\
+} while (0)
+
+#define	DO_RAID_FAIL()							\
+do {									\
+	rf_UnconfigureVnodes(raidPtr);					\
+	rf_ShutdownList(&raidPtr->shutdownList);			\
+	rf_UnconfigureArray();						\
+} while (0)
+
+#define	DO_RAID_INIT_CONFIGURE(f)					\
+do {									\
+	rc = (f)(&raidPtr->shutdownList, raidPtr, cfgPtr);		\
+	if (rc) {							\
+		RF_ERRORMSG2("RAIDFRAME: failed %s with %d.\n",		\
+		    RF_STRING(f), rc);					\
+		DO_RAID_FAIL();						\
+		return(rc);						\
+	}								\
+} while (0)
+
+#define	DO_RAID_MUTEX(_m_)						\
+do {									\
+	rc = rf_create_managed_mutex(&raidPtr->shutdownList, (_m_));	\
+	if (rc) {							\
+		RF_ERRORMSG3("Unable to init mutex file %s line %d"	\
+		    " rc=%d.\n", __FILE__, __LINE__, rc);		\
+		DO_RAID_FAIL();						\
+		return(rc);						\
+	}								\
+} while (0)
+
+#define	DO_RAID_COND(_c_)						\
+do {									\
+	rc = rf_create_managed_cond(&raidPtr->shutdownList, (_c_));	\
+	if (rc) {							\
+		RF_ERRORMSG3("Unable to init cond file %s line %d"	\
+		    " rc=%d.\n", __FILE__, __LINE__, rc);		\
+		DO_RAID_FAIL();						\
+		return(rc);						\
+	}								\
+} while (0)
 
-int 
-rf_Configure(raidPtr, cfgPtr, ac)
-	RF_Raid_t *raidPtr;
-	RF_Config_t *cfgPtr;
-	RF_AutoConfig_t *ac;
+int
+rf_Configure(RF_Raid_t *raidPtr, RF_Config_t *cfgPtr, RF_AutoConfig_t *ac)
 {
 	RF_RowCol_t row, col;
-	int     i, rc;
+	int i, rc;
 
-	/* XXX This check can probably be removed now, since 
-	   RAIDFRAME_CONFIGURRE now checks to make sure that the
-	   RAID set is not already valid
-	*/
+	/*
+	 * XXX This check can probably be removed now, since
+	 * RAIDFRAME_CONFIGURE now checks to make sure that the
+	 * RAID set is not already valid.
+	 */
 	if (raidPtr->valid) {
-		RF_ERRORMSG("RAIDframe configuration not shut down.  Aborting configure.\n");
+		RF_ERRORMSG("RAIDframe configuration not shut down."
+		    " Aborting configure.\n");
 		return (EINVAL);
 	}
 	RF_LOCK_MUTEX(configureMutex);
@@ -354,14 +382,14 @@ rf_Configure(raidPtr, cfgPtr, ac)
 	if (isconfigged == 0) {
 		rc = rf_create_managed_mutex(&globalShutdown, &rf_printf_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);
 			rf_ShutdownList(&globalShutdown);
 			return (rc);
 		}
-		/* initialize globals */
+		/* Initialize globals. */
 #ifdef	RAIDDEBUG
-		printf("RAIDFRAME: protectedSectors is %ld\n", 
+		printf("RAIDFRAME: protectedSectors is %ld.\n",
 		       rf_protectedSectors);
 #endif	/* RAIDDEBUG */
 
@@ -370,8 +398,8 @@ rf_Configure(raidPtr, cfgPtr, ac)
 		DO_INIT_CONFIGURE(rf_ConfigureAllocList);
 
 		/*
-	         * Yes, this does make debugging general to the whole
-	         * system instead of being array specific. Bummer, drag.  
+		 * Yes, this does make debugging general to the whole
+		 * system instead of being array specific. Bummer, drag.
 		 */
 		rf_ConfigureDebug(cfgPtr);
 		DO_INIT_CONFIGURE(rf_ConfigureDebugMem);
@@ -395,8 +423,10 @@ rf_Configure(raidPtr, cfgPtr, ac)
 	RF_UNLOCK_MUTEX(configureMutex);
 
 	DO_RAID_MUTEX(&raidPtr->mutex);
-	/* set up the cleanup list.  Do this after ConfigureDebug so that
-	 * value of memDebug will be set */
+	/*
+	 * Set up the cleanup list. Do this after ConfigureDebug so that
+	 * value of memDebug will be set.
+	 */
 
 	rf_MakeAllocList(raidPtr->cleanupList);
 	if (raidPtr->cleanupList == NULL) {
@@ -404,11 +434,10 @@ rf_Configure(raidPtr, cfgPtr, ac)
 		return (ENOMEM);
 	}
 	rc = rf_ShutdownCreate(&raidPtr->shutdownList,
-	    (void (*) (void *)) rf_FreeAllocList,
-	    raidPtr->cleanupList);
+	    (void (*) (void *)) rf_FreeAllocList, raidPtr->cleanupList);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		DO_RAID_FAIL();
 		return (rc);
 	}
@@ -416,15 +445,17 @@ rf_Configure(raidPtr, cfgPtr, ac)
 	raidPtr->numCol = cfgPtr->numCol;
 	raidPtr->numSpare = cfgPtr->numSpare;
 
-	/* XXX we don't even pretend to support more than one row in the
-	 * kernel... */
+	/*
+	 * XXX We don't even pretend to support more than one row in the
+	 * kernel...
+	 */
 	if (raidPtr->numRow != 1) {
 		RF_ERRORMSG("Only one row supported in kernel.\n");
 		DO_RAID_FAIL();
 		return (EINVAL);
 	}
-	RF_CallocAndAdd(raidPtr->status, raidPtr->numRow, sizeof(RF_RowStatus_t),
-	    (RF_RowStatus_t *), raidPtr->cleanupList);
+	RF_CallocAndAdd(raidPtr->status, raidPtr->numRow,
+	    sizeof(RF_RowStatus_t), (RF_RowStatus_t *), raidPtr->cleanupList);
 	if (raidPtr->status == NULL) {
 		DO_RAID_FAIL();
 		return (ENOMEM);
@@ -455,17 +486,21 @@ rf_Configure(raidPtr, cfgPtr, ac)
 
 	DO_RAID_MUTEX(&raidPtr->recon_done_proc_mutex);
 
-	if (ac!=NULL) {
-		/* We have an AutoConfig structure..  Don't do the
-		   normal disk configuration... call the auto config
-		   stuff */
+	if (ac != NULL) {
+		/*
+		 * We have an AutoConfig structure... Don't do the
+		 * normal disk configuration... call the auto config
+		 * stuff.
+		 */
 		rf_AutoConfigureDisks(raidPtr, cfgPtr, ac);
 	} else {
 		DO_RAID_INIT_CONFIGURE(rf_ConfigureDisks);
 		DO_RAID_INIT_CONFIGURE(rf_ConfigureSpareDisks);
 	}
-	/* do this after ConfigureDisks & ConfigureSpareDisks to be sure dev
-	 * no. is set */
+	/*
+	 * Do this after ConfigureDisks & ConfigureSpareDisks to be sure
+	 * devno is set.
+	 */
 	DO_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues);
 
 	DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout);
@@ -475,8 +510,8 @@ rf_Configure(raidPtr, cfgPtr, ac)
 	for (row = 0; row < raidPtr->numRow; row++) {
 		for (col = 0; col < raidPtr->numCol; col++) {
 			/*
-		         * XXX better distribution
-		         */
+			 * XXX Better distribution.
+			 */
 			raidPtr->hist_diskreq[row][col] = 0;
 		}
 	}
@@ -487,8 +522,10 @@ rf_Configure(raidPtr, cfgPtr, ac)
 	raidPtr->recon_in_progress = 0;
 	raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs;
 
-	/* autoconfigure and root_partition will actually get filled in 
-	   after the config is done */
+	/*
+	 * Autoconfigure and root_partition will actually get filled in
+	 * after the config is done.
+	 */
 	raidPtr->autoconfigure = 0;
 	raidPtr->root_partition = 0;
 	raidPtr->last_unit = raidPtr->raidid;
@@ -503,21 +540,20 @@ rf_Configure(raidPtr, cfgPtr, ac)
 	return (0);
 }
 
-static int 
-init_rad(desc)
-	RF_RaidAccessDesc_t *desc;
+int
+rf_init_rad(RF_RaidAccessDesc_t *desc)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_mutex_init(&desc->mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n", __FILE__,
 		    __LINE__, rc);
 		return (rc);
 	}
 	rc = rf_cond_init(&desc->cond);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", __FILE__,
+		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d.\n", __FILE__,
 		    __LINE__, rc);
 		rf_mutex_destroy(&desc->mutex);
 		return (rc);
@@ -525,26 +561,24 @@ init_rad(desc)
 	return (0);
 }
 
-static void 
-clean_rad(desc)
-	RF_RaidAccessDesc_t *desc;
+void
+rf_clean_rad(RF_RaidAccessDesc_t *desc)
 {
 	rf_mutex_destroy(&desc->mutex);
 	rf_cond_destroy(&desc->cond);
 }
 
-static void 
-rf_ShutdownRDFreeList(ignored)
-	void   *ignored;
+void
+rf_ShutdownRDFreeList(void *ignored)
 {
-	RF_FREELIST_DESTROY_CLEAN(rf_rad_freelist, next, (RF_RaidAccessDesc_t *), clean_rad);
+	RF_FREELIST_DESTROY_CLEAN(rf_rad_freelist, next,
+	    (RF_RaidAccessDesc_t *), rf_clean_rad);
 }
 
-static int 
-rf_ConfigureRDFreeList(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureRDFreeList(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_rad_freelist, RF_MAX_FREE_RAD,
 	    RF_RAD_INC, sizeof(RF_RaidAccessDesc_t));
@@ -553,41 +587,44 @@ rf_ConfigureRDFreeList(listp)
 	}
 	rc = rf_ShutdownCreate(listp, rf_ShutdownRDFreeList, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d.\n", __FILE__,
 		    __LINE__, rc);
 		rf_ShutdownRDFreeList(NULL);
 		return (rc);
 	}
 	RF_FREELIST_PRIME_INIT(rf_rad_freelist, RF_RAD_INITIAL, next,
-	    (RF_RaidAccessDesc_t *), init_rad);
+	    (RF_RaidAccessDesc_t *), rf_init_rad);
 	return (0);
 }
 
 RF_RaidAccessDesc_t *
 rf_AllocRaidAccDesc(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_RaidAddr_t raidAddress,
-    RF_SectorCount_t numBlocks,
-    caddr_t bufPtr,
-    void *bp,
-    RF_DagHeader_t ** paramDAG,
-    RF_AccessStripeMapHeader_t ** paramASM,
-    RF_RaidAccessFlags_t flags,
-    void (*cbF) (struct buf *),
-    void *cbA,
-    RF_AccessState_t * states)
+    RF_Raid_t			 *raidPtr,
+    RF_IoType_t			  type,
+    RF_RaidAddr_t		  raidAddress,
+    RF_SectorCount_t		  numBlocks,
+    caddr_t			  bufPtr,
+    void			 *bp,
+    RF_DagHeader_t		**paramDAG,
+    RF_AccessStripeMapHeader_t	**paramASM,
+    RF_RaidAccessFlags_t	  flags,
+    void			(*cbF) (struct buf *),
+    void			 *cbA,
+    RF_AccessState_t		 *states
+)
 {
 	RF_RaidAccessDesc_t *desc;
 
-	RF_FREELIST_GET_INIT_NOUNLOCK(rf_rad_freelist, desc, next, (RF_RaidAccessDesc_t *), init_rad);
+	RF_FREELIST_GET_INIT_NOUNLOCK(rf_rad_freelist, desc, next,
+	    (RF_RaidAccessDesc_t *), rf_init_rad);
 	if (raidPtr->waitShutdown) {
 		/*
-	         * Actually, we're shutting the array down. Free the desc
-	         * and return NULL.
-	         */
+		 * Actually, we're shutting the array down. Free the desc
+		 * and return NULL.
+		 */
 		RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
-		RF_FREELIST_FREE_CLEAN(rf_rad_freelist, desc, next, clean_rad);
+		RF_FREELIST_FREE_CLEAN(rf_rad_freelist, desc, next,
+		    rf_clean_rad);
 		return (NULL);
 	}
 	raidPtr->nAccOutstanding++;
@@ -617,7 +654,7 @@ rf_AllocRaidAccDesc(
 	return (desc);
 }
 
-void 
+void
 rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc)
 {
 	RF_Raid_t *raidPtr = desc->raidPtr;
@@ -625,39 +662,45 @@ rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc)
 	RF_ASSERT(desc);
 
 	rf_FreeAllocList(desc->cleanupList);
-	RF_FREELIST_FREE_CLEAN_NOUNLOCK(rf_rad_freelist, desc, next, clean_rad);
+	RF_FREELIST_FREE_CLEAN_NOUNLOCK(rf_rad_freelist, desc, next, rf_clean_rad);
 	raidPtr->nAccOutstanding--;
 	if (raidPtr->waitShutdown) {
 		RF_SIGNAL_COND(raidPtr->outstandingCond);
 	}
 	RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
 }
-/*********************************************************************
+
+
+/********************************************************************
  * Main routine for performing an access.
- * Accesses are retried until a DAG can not be selected.  This occurs
+ * Accesses are retried until a DAG can not be selected. This occurs
  * when either the DAG library is incomplete or there are too many
  * failures in a parity group.
  ********************************************************************/
-int 
+int
 rf_DoAccess(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    int async_flag,
-    RF_RaidAddr_t raidAddress,
-    RF_SectorCount_t numBlocks,
-    caddr_t bufPtr,
-    void *bp_in,
-    RF_DagHeader_t ** paramDAG,
-    RF_AccessStripeMapHeader_t ** paramASM,
-    RF_RaidAccessFlags_t flags,
-    RF_RaidAccessDesc_t ** paramDesc,
-    void (*cbF) (struct buf *),
-    void *cbA)
-/*
-type should be read or write
-async_flag should be RF_TRUE or RF_FALSE
-bp_in is a buf pointer.  void * to facilitate ignoring it outside the kernel
-*/
+    RF_Raid_t			 *raidPtr,
+    RF_IoType_t			  type,		/* Should be read or write. */
+    int				  async_flag,	/*
+						 * Should be RF_TRUE
+						 * or RF_FALSE.
+						 */
+    RF_RaidAddr_t		  raidAddress,
+    RF_SectorCount_t		  numBlocks,
+    caddr_t			  bufPtr,
+    void			 *bp_in,	/*
+						 * It's a buf pointer.
+						 * void * to facilitate
+						 * ignoring it outside
+						 * the kernel.
+						 */
+    RF_DagHeader_t		**paramDAG,
+    RF_AccessStripeMapHeader_t	**paramASM,
+    RF_RaidAccessFlags_t	  flags,
+    RF_RaidAccessDesc_t		**paramDesc,
+    void			(*cbF) (struct buf *),
+    void			 *cbA
+)
 {
 	RF_RaidAccessDesc_t *desc;
 	caddr_t lbufPtr = bufPtr;
@@ -666,17 +709,18 @@ bp_in is a buf pointer.  void * to facilitate ignoring it outside the kernel
 	raidAddress += rf_raidSectorOffset;
 
 	if (!raidPtr->valid) {
-		RF_ERRORMSG("RAIDframe driver not successfully configured.  Rejecting access.\n");
+		RF_ERRORMSG("RAIDframe driver not successfully configured."
+		    " Rejecting access.\n");
 		IO_BUF_ERR(bp, EINVAL);
 		return (EINVAL);
 	}
 
 	if (rf_accessDebug) {
 
-		printf("logBytes is: %d %d %d\n", raidPtr->raidid,
+		printf("logBytes is: %d %d %d.\n", raidPtr->raidid,
 		    raidPtr->logBytesPerSector,
 		    (int) rf_RaidAddressToByte(raidPtr, numBlocks));
-		printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx\n", raidPtr->raidid,
+		printf("raid%d: %s raidAddr %d (stripeid %d-%d) numBlocks %d (%d bytes) buf 0x%lx.\n", raidPtr->raidid,
 		    (type == RF_IO_TYPE_READ) ? "READ" : "WRITE", (int) raidAddress,
 		    (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress),
 		    (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1),
@@ -686,7 +730,7 @@ bp_in is a buf pointer.  void * to facilitate ignoring it outside the kernel
 	}
 	if (raidAddress + numBlocks > raidPtr->totalSectors) {
 
-		printf("DoAccess: raid addr %lu too large to access %lu sectors.  Max legal addr is %lu\n",
+		printf("DoAccess: raid addr %lu too large to access %lu sectors. Max legal addr is %lu.\n",
 		    (u_long) raidAddress, (u_long) numBlocks, (u_long) raidPtr->totalSectors);
 
 			IO_BUF_ERR(bp, ENOSPC);
@@ -707,15 +751,15 @@ bp_in is a buf pointer.  void * to facilitate ignoring it outside the kernel
 
 	return (0);
 }
-/* force the array into reconfigured mode without doing reconstruction */
-int 
-rf_SetReconfiguredMode(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	int     row;
-	int     col;
+
+
+/* Force the array into reconfigured mode without doing reconstruction. */
+int
+rf_SetReconfiguredMode(RF_Raid_t *raidPtr, int row, int col)
 {
 	if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		printf("Can't set reconfigured mode in dedicated-spare array\n");
+		printf("Can't set reconfigured mode in dedicated-spare"
+		    " array.\n");
 		RF_PANIC();
 	}
 	RF_LOCK_MUTEX(raidPtr->mutex);
@@ -723,8 +767,10 @@ rf_SetReconfiguredMode(raidPtr, row, col)
 	raidPtr->Disks[row][col].status = rf_ds_dist_spared;
 	raidPtr->status[row] = rf_rs_reconfigured;
 	rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
-	/* install spare table only if declustering + distributed sparing
-	 * architecture. */
+	/*
+	 * Install spare table only if declustering + distributed sparing
+	 * architecture.
+	 */
 	if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED)
 		rf_InstallSpareTable(raidPtr, row, col);
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
@@ -734,14 +780,10 @@ rf_SetReconfiguredMode(raidPtr, row, col)
 extern int fail_row, fail_col, fail_time;
 extern int delayed_recon;
 
-int 
-rf_FailDisk(
-    RF_Raid_t * raidPtr,
-    int frow,
-    int fcol,
-    int initRecon)
+int
+rf_FailDisk(RF_Raid_t *raidPtr, int frow, int fcol, int initRecon)
 {
-	printf("raid%d: Failing disk r%d c%d\n", raidPtr->raidid, frow, fcol);
+	printf("raid%d: Failing disk r%d c%d.\n", raidPtr->raidid, frow, fcol);
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	raidPtr->numFailures++;
 	raidPtr->Disks[frow][fcol].status = rf_ds_failed;
@@ -752,16 +794,17 @@ rf_FailDisk(
 		rf_ReconstructFailedDisk(raidPtr, frow, fcol);
 	return (0);
 }
-/* releases a thread that is waiting for the array to become quiesced.
- * access_suspend_mutex should be locked upon calling this
+
+
+/*
+ * Releases a thread that is waiting for the array to become quiesced.
+ * access_suspend_mutex should be locked upon calling this.
  */
-void 
-rf_SignalQuiescenceLock(raidPtr, reconDesc)
-	RF_Raid_t *raidPtr;
-	RF_RaidReconDesc_t *reconDesc;
+void
+rf_SignalQuiescenceLock(RF_Raid_t *raidPtr, RF_RaidReconDesc_t *reconDesc)
 {
 	if (rf_quiesceDebug) {
-		printf("raid%d: Signalling quiescence lock\n", 
+		printf("raid%d: Signalling quiescence lock.\n",
 		       raidPtr->raidid);
 	}
 	raidPtr->access_suspend_release = 1;
@@ -770,13 +813,17 @@ rf_SignalQuiescenceLock(raidPtr, reconDesc)
 		SIGNAL_QUIESCENT_COND(raidPtr);
 	}
 }
-/* suspends all new requests to the array.  No effect on accesses that are in flight.  */
-int 
-rf_SuspendNewRequestsAndWait(raidPtr)
-	RF_Raid_t *raidPtr;
+
+
+/*
+ * Suspends all new requests to the array. No effect on accesses that are
+ * in flight.
+ */
+int
+rf_SuspendNewRequestsAndWait(RF_Raid_t *raidPtr)
 {
 	if (rf_quiesceDebug)
-		printf("Suspending new reqs\n");
+		printf("Suspending new reqs.\n");
 
 	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
 	raidPtr->accesses_suspended++;
@@ -785,25 +832,26 @@ rf_SuspendNewRequestsAndWait(raidPtr)
 	if (raidPtr->waiting_for_quiescence) {
 		raidPtr->access_suspend_release = 0;
 		while (!raidPtr->access_suspend_release) {
-			printf("Suspending: Waiting for Quiescence\n");
+			printf("Suspending: Waiting for Quiescence.\n");
 			WAIT_FOR_QUIESCENCE(raidPtr);
 			raidPtr->waiting_for_quiescence = 0;
 		}
 	}
-	printf("Quiescence reached..\n");
+	printf("Quiescence reached...\n");
 
 	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
 	return (raidPtr->waiting_for_quiescence);
 }
-/* wake up everyone waiting for quiescence to be released */
-void 
-rf_ResumeNewRequests(raidPtr)
-	RF_Raid_t *raidPtr;
+
+
+/* Wake up everyone waiting for quiescence to be released. */
+void
+rf_ResumeNewRequests(RF_Raid_t *raidPtr)
 {
 	RF_CallbackDesc_t *t, *cb;
 
 	if (rf_quiesceDebug)
-		printf("Resuming new reqs\n");
+		printf("Resuming new reqs.\n");
 
 	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
 	raidPtr->accesses_suspended--;
@@ -821,16 +869,16 @@ rf_ResumeNewRequests(raidPtr)
 		rf_FreeCallbackDesc(t);
 	}
 }
-/*****************************************************************************************
+
+
+/*****************************************************************************
  *
- * debug routines
+ * Debug routines.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-static void 
-set_debug_option(name, val)
-	char   *name;
-	long    val;
+void
+rf_set_debug_option(char *name, long val)
 {
 	RF_DebugName_t *p;
 
@@ -845,51 +893,52 @@ set_debug_option(name, val)
 }
 
 
-/* would like to use sscanf here, but apparently not available in kernel */
+/* Would like to use sscanf here, but apparently not available in kernel. */
 /*ARGSUSED*/
-static void 
-rf_ConfigureDebug(cfgPtr)
-	RF_Config_t *cfgPtr;
+void
+rf_ConfigureDebug(RF_Config_t *cfgPtr)
 {
-	char   *val_p, *name_p, *white_p;
-	long    val;
-	int     i;
+	char *val_p, *name_p, *white_p;
+	long val;
+	int i;
 
 	rf_ResetDebugOptions();
 	for (i = 0; cfgPtr->debugVars[i][0] && i < RF_MAXDBGV; i++) {
 		name_p = rf_find_non_white(&cfgPtr->debugVars[i][0]);
-		white_p = rf_find_white(name_p);	/* skip to start of 2nd
-							 * word */
+		white_p = rf_find_white(name_p);	/*
+							 * Skip to start of 2nd
+							 * word.
+							 */
 		val_p = rf_find_non_white(white_p);
 		if (*val_p == '0' && *(val_p + 1) == 'x')
 			val = rf_htoi(val_p + 2);
 		else
 			val = rf_atoi(val_p);
 		*white_p = '\0';
-		set_debug_option(name_p, val);
+		rf_set_debug_option(name_p, val);
 	}
 }
-/* performance monitoring stuff */
 
-#if !defined(_KERNEL) && !defined(SIMULATE)
+
+/* Performance monitoring stuff. */
+
+#if	!defined(_KERNEL) && !defined(SIMULATE)
 
 /*
- * Throughput stats currently only used in user-level RAIDframe
+ * Throughput stats currently only used in user-level RAIDframe.
  */
 
-static int 
-rf_InitThroughputStats(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_InitThroughputStats(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
-	int     rc;
+	int rc;
 
-	/* these used by user-level raidframe only */
+	/* These used by user-level RAIDframe only. */
 	rc = rf_create_managed_mutex(listp, &raidPtr->throughputstats.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);
 	}
 	raidPtr->throughputstats.sum_io_us = 0;
@@ -898,8 +947,8 @@ rf_InitThroughputStats(
 	return (0);
 }
 
-void 
-rf_StartThroughputStats(RF_Raid_t * raidPtr)
+void
+rf_StartThroughputStats(RF_Raid_t *raidPtr)
 {
 	RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
 	raidPtr->throughputstats.num_ios++;
@@ -909,8 +958,8 @@ rf_StartThroughputStats(RF_Raid_t * raidPtr)
 	RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
 }
 
-static void 
-rf_StopThroughputStats(RF_Raid_t * raidPtr)
+void
+rf_StopThroughputStats(RF_Raid_t *raidPtr)
 {
 	struct timeval diff;
 
@@ -918,25 +967,28 @@ rf_StopThroughputStats(RF_Raid_t * raidPtr)
 	raidPtr->throughputstats.num_out_ios--;
 	if (raidPtr->throughputstats.num_out_ios == 0) {
 		RF_GETTIME(raidPtr->throughputstats.stop);
-		RF_TIMEVAL_DIFF(&raidPtr->throughputstats.start, &raidPtr->throughputstats.stop, &diff);
+		RF_TIMEVAL_DIFF(&raidPtr->throughputstats.start,
+		    &raidPtr->throughputstats.stop, &diff);
 		raidPtr->throughputstats.sum_io_us += RF_TIMEVAL_TO_US(diff);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
 }
 
-static void 
-rf_PrintThroughputStats(RF_Raid_t * raidPtr)
+void
+rf_PrintThroughputStats(RF_Raid_t *raidPtr)
 {
 	RF_ASSERT(raidPtr->throughputstats.num_out_ios == 0);
 	if (raidPtr->throughputstats.sum_io_us != 0) {
-		printf("[Througphut: %8.2f IOs/second]\n", raidPtr->throughputstats.num_ios
-		    / (raidPtr->throughputstats.sum_io_us / 1000000.0));
+		printf("[Througphut: %8.2f IOs/second]\n",
+		    raidPtr->throughputstats.num_ios /
+		    (raidPtr->throughputstats.sum_io_us / 1000000.0));
 	}
 }
-#endif				/* !_KERNEL && !SIMULATE */
 
-void 
-rf_StartUserStats(RF_Raid_t * raidPtr)
+#endif	/* !_KERNEL && !SIMULATE */
+
+void
+rf_StartUserStats(RF_Raid_t *raidPtr)
 {
 	RF_GETTIME(raidPtr->userstats.start);
 	raidPtr->userstats.sum_io_us = 0;
@@ -944,51 +996,63 @@ rf_StartUserStats(RF_Raid_t * raidPtr)
 	raidPtr->userstats.num_sect_moved = 0;
 }
 
-void 
-rf_StopUserStats(RF_Raid_t * raidPtr)
+void
+rf_StopUserStats(RF_Raid_t *raidPtr)
 {
 	RF_GETTIME(raidPtr->userstats.stop);
 }
 
-void 
-rf_UpdateUserStats(raidPtr, rt, numsect)
-	RF_Raid_t *raidPtr;
-	int     rt;		/* resp time in us */
-	int     numsect;	/* number of sectors for this access */
+void
+rf_UpdateUserStats(
+    RF_Raid_t	*raidPtr,
+    int		 rt,		/* Response time in us. */
+    int		 numsect	/* Number of sectors for this access. */
+)
 {
 	raidPtr->userstats.sum_io_us += rt;
 	raidPtr->userstats.num_ios++;
 	raidPtr->userstats.num_sect_moved += numsect;
 }
 
-void 
-rf_PrintUserStats(RF_Raid_t * raidPtr)
+void
+rf_PrintUserStats(RF_Raid_t *raidPtr)
 {
 	long    elapsed_us, mbs, mbs_frac;
 	struct timeval diff;
 
-	RF_TIMEVAL_DIFF(&raidPtr->userstats.start, &raidPtr->userstats.stop, &diff);
+	RF_TIMEVAL_DIFF(&raidPtr->userstats.start, &raidPtr->userstats.stop,
+	    &diff);
 	elapsed_us = RF_TIMEVAL_TO_US(diff);
 
-	/* 2000 sectors per megabyte, 10000000 microseconds per second */
+	/* 2000 sectors per megabyte, 10000000 microseconds per second. */
 	if (elapsed_us)
-		mbs = (raidPtr->userstats.num_sect_moved / 2000) / (elapsed_us / 1000000);
+		mbs = (raidPtr->userstats.num_sect_moved / 2000) /
+		    (elapsed_us / 1000000);
 	else
 		mbs = 0;
 
-	/* this computes only the first digit of the fractional mb/s moved */
+	/* This computes only the first digit of the fractional mb/s moved. */
 	if (elapsed_us) {
-		mbs_frac = ((raidPtr->userstats.num_sect_moved / 200) / (elapsed_us / 1000000))
-		    - (mbs * 10);
+		mbs_frac = ((raidPtr->userstats.num_sect_moved / 200) /
+		    (elapsed_us / 1000000)) - (mbs * 10);
 	} else {
 		mbs_frac = 0;
 	}
 
-	printf("Number of I/Os:             %ld\n", raidPtr->userstats.num_ios);
-	printf("Elapsed time (us):          %ld\n", elapsed_us);
-	printf("User I/Os per second:       %ld\n", RF_DB0_CHECK(raidPtr->userstats.num_ios, (elapsed_us / 1000000)));
-	printf("Average user response time: %ld us\n", RF_DB0_CHECK(raidPtr->userstats.sum_io_us, raidPtr->userstats.num_ios));
-	printf("Total sectors moved:        %ld\n", raidPtr->userstats.num_sect_moved);
-	printf("Average access size (sect): %ld\n", RF_DB0_CHECK(raidPtr->userstats.num_sect_moved, raidPtr->userstats.num_ios));
-	printf("Achieved data rate:         %ld.%ld MB/sec\n", mbs, mbs_frac);
+	printf("Number of I/Os:             %ld\n",
+	    raidPtr->userstats.num_ios);
+	printf("Elapsed time (us):          %ld\n",
+	    elapsed_us);
+	printf("User I/Os per second:       %ld\n",
+	    RF_DB0_CHECK(raidPtr->userstats.num_ios, (elapsed_us / 1000000)));
+	printf("Average user response time: %ld us\n",
+	    RF_DB0_CHECK(raidPtr->userstats.sum_io_us,
+	     raidPtr->userstats.num_ios));
+	printf("Total sectors moved:        %ld\n",
+	    raidPtr->userstats.num_sect_moved);
+	printf("Average access size (sect): %ld\n",
+	    RF_DB0_CHECK(raidPtr->userstats.num_sect_moved,
+	    raidPtr->userstats.num_ios));
+	printf("Achieved data rate:         %ld.%ld MB/sec\n",
+	    mbs, mbs_frac);
 }
diff --git a/sys/dev/raidframe/rf_driver.h b/sys/dev/raidframe/rf_driver.h
index 6e29c3c6d6c..9df7c907f2d 100644
--- a/sys/dev/raidframe/rf_driver.h
+++ b/sys/dev/raidframe/rf_driver.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_driver.h,v 1.3 2000/08/08 16:07:41 peter Exp $	*/
+/*	$OpenBSD: rf_driver.h,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_driver.h,v 1.4 2000/02/13 04:53:57 oster Exp $	*/
+
 /*
  * rf_driver.h
  */
@@ -30,55 +31,43 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_DRIVER_H_
-#define _RF__RF_DRIVER_H_
+#ifndef	_RF__RF_DRIVER_H_
+#define	_RF__RF_DRIVER_H_
 
 #include "rf_threadstuff.h"
 #include "rf_types.h"
 
-#if defined(__NetBSD__)
+#if	defined(__NetBSD__)
 #include "rf_netbsd.h"
-#elif defined(__OpenBSD__)
+#elif	defined(__OpenBSD__)
 #include "rf_openbsd.h"
 #endif
 
-#if _KERNEL
-RF_DECLARE_EXTERN_MUTEX(rf_printf_mutex)
-int     rf_BootRaidframe(void);
-int     rf_UnbootRaidframe(void);
-int     rf_Shutdown(RF_Raid_t * raidPtr);
-int     rf_Configure(RF_Raid_t * raidPtr, RF_Config_t * cfgPtr,
-		     RF_AutoConfig_t *ac);
-RF_RaidAccessDesc_t *rf_AllocRaidAccDesc(RF_Raid_t * raidPtr, RF_IoType_t type,
-					 RF_RaidAddr_t raidAddress, 
-					 RF_SectorCount_t numBlocks, 
-					 caddr_t bufPtr,
-					 void *bp, RF_DagHeader_t ** paramDAG,
-					 RF_AccessStripeMapHeader_t ** paramASM,
-					 RF_RaidAccessFlags_t flags, 
-					 void (*cbF) (struct buf *), 
-					 void *cbA,
-					 RF_AccessState_t * states);
-void    rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc);
-int     rf_DoAccess(RF_Raid_t * raidPtr, RF_IoType_t type, int async_flag,
-		    RF_RaidAddr_t raidAddress, RF_SectorCount_t numBlocks, 
-		    caddr_t bufPtr, void *bp_in, RF_DagHeader_t ** paramDAG,
-		    RF_AccessStripeMapHeader_t ** paramASM, 
-		    RF_RaidAccessFlags_t flags, 
-		    RF_RaidAccessDesc_t ** paramDesc, 
-		    void (*cbF) (struct buf *), void *cbA);
-int     rf_SetReconfiguredMode(RF_Raid_t * raidPtr, RF_RowCol_t row,
-			       RF_RowCol_t col);
-int     rf_FailDisk(RF_Raid_t * raidPtr, RF_RowCol_t frow, RF_RowCol_t fcol,
-		    int initRecon);
-void    rf_SignalQuiescenceLock(RF_Raid_t * raidPtr, 
-				RF_RaidReconDesc_t * reconDesc);
-int     rf_SuspendNewRequestsAndWait(RF_Raid_t * raidPtr);
-void    rf_ResumeNewRequests(RF_Raid_t * raidPtr);
-void    rf_StartThroughputStats(RF_Raid_t * raidPtr);
-void    rf_StartUserStats(RF_Raid_t * raidPtr);
-void    rf_StopUserStats(RF_Raid_t * raidPtr);
-void    rf_UpdateUserStats(RF_Raid_t * raidPtr, int rt, int numsect);
-void    rf_PrintUserStats(RF_Raid_t * raidPtr);
-#endif /* _KERNEL */
-#endif				/* !_RF__RF_DRIVER_H_ */
+#if	_KERNEL
+RF_DECLARE_EXTERN_MUTEX(rf_printf_mutex);
+int  rf_BootRaidframe(void);
+int  rf_UnbootRaidframe(void);
+int  rf_Shutdown(RF_Raid_t *);
+int  rf_Configure(RF_Raid_t *, RF_Config_t *, RF_AutoConfig_t *);
+RF_RaidAccessDesc_t *rf_AllocRaidAccDesc(RF_Raid_t *, RF_IoType_t,
+	RF_RaidAddr_t, RF_SectorCount_t, caddr_t, void *, RF_DagHeader_t **,
+	RF_AccessStripeMapHeader_t **, RF_RaidAccessFlags_t,
+	void (*) (struct buf *), void *, RF_AccessState_t *);
+void rf_FreeRaidAccDesc(RF_RaidAccessDesc_t *);
+int  rf_DoAccess(RF_Raid_t *, RF_IoType_t, int, RF_RaidAddr_t,
+	RF_SectorCount_t, caddr_t, void *, RF_DagHeader_t **,
+	RF_AccessStripeMapHeader_t **, RF_RaidAccessFlags_t,
+	RF_RaidAccessDesc_t **, void (*) (struct buf *), void *);
+int  rf_SetReconfiguredMode(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+int  rf_FailDisk(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t, int);
+void rf_SignalQuiescenceLock(RF_Raid_t *, RF_RaidReconDesc_t *);
+int  rf_SuspendNewRequestsAndWait(RF_Raid_t *);
+void rf_ResumeNewRequests(RF_Raid_t *);
+void rf_StartThroughputStats(RF_Raid_t *);
+void rf_StartUserStats(RF_Raid_t *);
+void rf_StopUserStats(RF_Raid_t *);
+void rf_UpdateUserStats(RF_Raid_t *, int, int);
+void rf_PrintUserStats(RF_Raid_t *);
+#endif	/* _KERNEL */
+
+#endif	/* !_RF__RF_DRIVER_H_ */
diff --git a/sys/dev/raidframe/rf_engine.c b/sys/dev/raidframe/rf_engine.c
index f988f0de05a..458ab8c00b3 100644
--- a/sys/dev/raidframe/rf_engine.c
+++ b/sys/dev/raidframe/rf_engine.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_engine.c,v 1.12 2002/07/15 18:42:06 art Exp $	*/
+/*	$OpenBSD: rf_engine.c,v 1.13 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_engine.c,v 1.10 2000/08/20 16:51:03 thorpej Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,16 +30,16 @@
 
 /****************************************************************************
  *                                                                          *
- * engine.c -- code for DAG execution engine                                *
+ * engine.c -- Code for DAG execution engine.                               *
  *                                                                          *
  * Modified to work as follows (holland):                                   *
  *   A user-thread calls into DispatchDAG, which fires off the nodes that   *
- *   are direct successors to the header node.  DispatchDAG then returns,   *
- *   and the rest of the I/O continues asynchronously.  As each node        *
- *   completes, the node execution function calls FinishNode().  FinishNode *
+ *   are direct successors to the header node. DispatchDAG then returns,    *
+ *   and the rest of the I/O continues asynchronously. As each node         *
+ *   completes, the node execution function calls FinishNode(). FinishNode  *
  *   scans the list of successors to the node and increments the antecedent *
- *   counts.  Each node that becomes enabled is placed on a central node    *
- *   queue.  A dedicated dag-execution thread grabs nodes off of this       *
+ *   counts. Each node that becomes enabled is placed on a central node     *
+ *   queue. A dedicated dag-execution thread grabs nodes off of this        *
  *   queue and fires them.                                                  *
  *                                                                          *
  *   NULL nodes are never fired.                                            *
@@ -49,8 +50,8 @@
  *   If a node fails, the dag either rolls forward to the completion or     *
  *   rolls back, undoing previously-completed nodes and fails atomically.   *
  *   The direction of recovery is determined by the location of the failed  *
- *   node in the graph.  If the failure occurred before the commit node in   *
- *   the graph, backward recovery is used.  Otherwise, forward recovery is  *
+ *   node in the graph. If the failure occurred before the commit node in   *
+ *   the graph, backward recovery is used. Otherwise, forward recovery is   *
  *   used.                                                                  *
  *                                                                          *
  ****************************************************************************/
@@ -67,56 +68,67 @@
 #include "rf_shutdown.h"
 #include "rf_raid.h"
 
-void	DAGExecutionThread(RF_ThreadArg_t arg);
-#ifdef RAID_AUTOCONFIG
-void	DAGExecutionThread_pre(RF_ThreadArg_t arg);
+int  rf_BranchDone(RF_DagNode_t *);
+int  rf_NodeReady(RF_DagNode_t *);
+void rf_FireNode(RF_DagNode_t *);
+void rf_FireNodeArray(int, RF_DagNode_t **);
+void rf_FireNodeList(RF_DagNode_t *);
+void rf_PropagateResults(RF_DagNode_t *, int);
+void rf_ProcessNode(RF_DagNode_t *, int);
+
+void rf_DAGExecutionThread(RF_ThreadArg_t);
+#ifdef	RAID_AUTOCONFIG
 #define	RF_ENGINE_PID	10
+void rf_DAGExecutionThread_pre(RF_ThreadArg_t);
 extern pid_t	  lastpid;
 #endif	/* RAID_AUTOCONFIG */
 void		**rf_hook_cookies;
 extern int	  numraid;
 
-#define DO_INIT(_l_,_r_) { \
-  int _rc; \
-  _rc = rf_create_managed_mutex(_l_,&(_r_)->node_queue_mutex); \
-  if (_rc) { \
-    return(_rc); \
-  } \
-  _rc = rf_create_managed_cond(_l_,&(_r_)->node_queue_cond); \
-  if (_rc) { \
-    return(_rc); \
-  } \
-}
+#define	DO_INIT(_l_,_r_)						\
+do {									\
+	int _rc;							\
+	_rc = rf_create_managed_mutex(_l_, &(_r_)->node_queue_mutex);	\
+	if (_rc) {							\
+		return(_rc);						\
+	}								\
+	_rc = rf_create_managed_cond(_l_, &(_r_)->node_queue_cond);	\
+	if (_rc) {							\
+		return(_rc);						\
+	}								\
+} while (0)
 
-/* synchronization primitives for this file.  DO_WAIT should be enclosed in a while loop. */
+/*
+ * Synchronization primitives for this file. DO_WAIT should be enclosed
+ * in a while loop.
+ */
 
 /*
- * XXX Is this spl-ing really necessary?
+ * XXX Is this spl-ing really necessary ?
  */
-#define DO_LOCK(_r_) \
-do { \
-	ks = splbio(); \
-	RF_LOCK_MUTEX((_r_)->node_queue_mutex); \
+#define	DO_LOCK(_r_)							\
+do {									\
+	ks = splbio();							\
+	RF_LOCK_MUTEX((_r_)->node_queue_mutex);				\
 } while (0)
 
-#define DO_UNLOCK(_r_) \
-do { \
-	RF_UNLOCK_MUTEX((_r_)->node_queue_mutex); \
-	splx(ks); \
+#define	DO_UNLOCK(_r_)							\
+do {									\
+	RF_UNLOCK_MUTEX((_r_)->node_queue_mutex);			\
+	splx(ks);							\
 } while (0)
 
-#define DO_WAIT(_r_) \
+#define	DO_WAIT(_r_)							\
 	RF_WAIT_COND((_r_)->node_queue, (_r_)->node_queue_mutex)
 
 /* XXX RF_SIGNAL_COND? */
-#define DO_SIGNAL(_r_) \
+#define	DO_SIGNAL(_r_)							\
 	RF_BROADCAST_COND((_r_)->node_queue)
 
 void rf_ShutdownEngine(void *);
 
-void 
-rf_ShutdownEngine(arg)
-	void   *arg;
+void
+rf_ShutdownEngine(void *arg)
 {
 	RF_Raid_t *raidPtr;
 
@@ -125,14 +137,12 @@ rf_ShutdownEngine(arg)
 	DO_SIGNAL(raidPtr);
 }
 
-int 
-rf_ConfigureEngine(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureEngine(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
-	int     rc;
-	char	raidname[16];
+	int rc;
+	char raidname[16];
 
 	DO_INIT(listp, raidPtr);
 
@@ -143,9 +153,11 @@ rf_ConfigureEngine(
 	if (rc)
 		return (rc);
 
-	/* we create the execution thread only once per system boot. no need
+	/*
+	 * We create the execution thread only once per system boot. No need
 	 * to check return code b/c the kernel panics if it can't create the
-	 * thread. */
+	 * thread.
+	 */
 	if (rf_engineDebug) {
 		printf("raid%d: Creating engine thread\n", raidPtr->raidid);
 	}
@@ -157,94 +169,105 @@ rf_ConfigureEngine(
 			return (ENOMEM);
 		bzero(rf_hook_cookies, numraid * sizeof(void *));
 	}
-#ifdef RAID_AUTOCONFIG
+#ifdef	RAID_AUTOCONFIG
 	if (initproc == NULL) {
 		rf_hook_cookies[raidPtr->raidid] =
-			startuphook_establish(DAGExecutionThread_pre, raidPtr);
+			startuphook_establish(rf_DAGExecutionThread_pre,
+			    raidPtr);
 	} else {
 #endif	/* RAID_AUTOCONFIG */
 		snprintf(&raidname[0], 16, "raid%d", raidPtr->raidid);
 		if (RF_CREATE_THREAD(raidPtr->engine_thread,
-		    DAGExecutionThread, raidPtr, &raidname[0])) {
-			RF_ERRORMSG("RAIDFRAME: Unable to create engine thread\n");
+		    rf_DAGExecutionThread, raidPtr, &raidname[0])) {
+			RF_ERRORMSG("RAIDFRAME: Unable to create engine"
+			    " thread\n");
 			return (ENOMEM);
 		}
 		if (rf_engineDebug) {
-			printf("raid%d: Created engine thread\n", raidPtr->raidid);
+			printf("raid%d: Created engine thread\n",
+			    raidPtr->raidid);
 		}
 		RF_THREADGROUP_STARTED(&raidPtr->engine_tg);
-#ifdef RAID_AUTOCONFIG
+#ifdef	RAID_AUTOCONFIG
 	}
 #endif
-	/* XXX something is missing here... */
-#ifdef debug
-	printf("Skipping the WAIT_START!!\n");
+	/* XXX Something is missing here... */
+#ifdef	debug
+	printf("Skipping the WAIT_START !!!\n");
 #endif
-	/* engine thread is now running and waiting for work */
+	/* Engine thread is now running and waiting for work. */
 	if (rf_engineDebug) {
-		printf("raid%d: Engine thread running and waiting for events\n", raidPtr->raidid);
+		printf("raid%d: Engine thread running and waiting for events\n",
+		    raidPtr->raidid);
 	}
 	rc = rf_ShutdownCreate(listp, rf_ShutdownEngine, raidPtr);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownEngine(NULL);
 	}
 	return (rc);
 }
 
-static int 
-BranchDone(RF_DagNode_t * node)
+int
+rf_BranchDone(RF_DagNode_t *node)
 {
-	int     i;
+	int i;
 
-	/* return true if forward execution is completed for a node and it's
-	 * succedents */
+	/*
+	 * Return true if forward execution is completed for a node and it's
+	 * succedents.
+	 */
 	switch (node->status) {
 	case rf_wait:
-		/* should never be called in this state */
+		/* Should never be called in this state. */
 		RF_PANIC();
 		break;
 	case rf_fired:
-		/* node is currently executing, so we're not done */
+		/* Node is currently executing, so we're not done. */
 		return (RF_FALSE);
 	case rf_good:
-		for (i = 0; i < node->numSuccedents; i++)	/* for each succedent */
-			if (!BranchDone(node->succedents[i]))	/* recursively check
-								 * branch */
+		/* For each succedent. */
+		for (i = 0; i < node->numSuccedents; i++)
+			/* Recursively check branch. */
+			if (!rf_BranchDone(node->succedents[i]))
 				return RF_FALSE;
-		return RF_TRUE;	/* node and all succedent branches aren't in
-				 * fired state */
+
+		return RF_TRUE;	/*
+				 * Node and all succedent branches aren't in
+				 * fired state.
+				 */
 		break;
 	case rf_bad:
-		/* succedents can't fire */
+		/* Succedents can't fire. */
 		return (RF_TRUE);
 	case rf_recover:
-		/* should never be called in this state */
+		/* Should never be called in this state. */
 		RF_PANIC();
 		break;
 	case rf_undone:
 	case rf_panic:
-		/* XXX need to fix this case */
-		/* for now, assume that we're done */
+		/* XXX Need to fix this case. */
+		/* For now, assume that we're done. */
 		return (RF_TRUE);
 		break;
 	default:
-		/* illegal node status */
+		/* Illegal node status. */
 		RF_PANIC();
 		break;
 	}
 }
 
-static int 
-NodeReady(RF_DagNode_t * node)
+int
+rf_NodeReady(RF_DagNode_t *node)
 {
-	int     ready;
+	int ready;
 
 	switch (node->dagHdr->status) {
 	case rf_enable:
 	case rf_rollForward:
-		if ((node->status == rf_wait) && (node->numAntecedents == node->numAntDone))
+		if ((node->status == rf_wait) &&
+		    (node->numAntecedents == node->numAntDone))
 			ready = RF_TRUE;
 		else
 			ready = RF_FALSE;
@@ -253,13 +276,15 @@ NodeReady(RF_DagNode_t * node)
 		RF_ASSERT(node->numSuccDone <= node->numSuccedents);
 		RF_ASSERT(node->numSuccFired <= node->numSuccedents);
 		RF_ASSERT(node->numSuccFired <= node->numSuccDone);
-		if ((node->status == rf_good) && (node->numSuccDone == node->numSuccedents))
+		if ((node->status == rf_good) &&
+		    (node->numSuccDone == node->numSuccedents))
 			ready = RF_TRUE;
 		else
 			ready = RF_FALSE;
 		break;
 	default:
-		printf("Execution engine found illegal DAG status in NodeReady\n");
+		printf("Execution engine found illegal DAG status"
+		    " in rf_NodeReady\n");
 		RF_PANIC();
 		break;
 	}
@@ -268,30 +293,32 @@ NodeReady(RF_DagNode_t * node)
 }
 
 
-
-/* user context and dag-exec-thread context:
- * Fire a node.  The node's status field determines which function, do or undo,
+/*
+ * User context and dag-exec-thread context:
+ * Fire a node. The node's status field determines which function, do or undo,
  * to be fired.
  * This routine assumes that the node's status field has alread been set to
  * "fired" or "recover" to indicate the direction of execution.
  */
-static void 
-FireNode(RF_DagNode_t * node)
+void
+rf_FireNode(RF_DagNode_t *node)
 {
 	switch (node->status) {
 	case rf_fired:
-		/* fire the do function of a node */
+		/* Fire the do function of a node. */
 		if (rf_engineDebug) {
-			printf("raid%d: Firing node 0x%lx (%s)\n", 
-			       node->dagHdr->raidPtr->raidid, 
-			       (unsigned long) node, node->name);
+			printf("raid%d: Firing node 0x%lx (%s)\n",
+			    node->dagHdr->raidPtr->raidid,
+			    (unsigned long) node, node->name);
 		}
 		if (node->flags & RF_DAGNODE_FLAG_YIELD) {
 #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
 			/* thread_block(); */
 			/* printf("Need to block the thread here...\n");  */
-			/* XXX thread_block is actually mentioned in
-			 * /usr/include/vm/vm_extern.h */
+			/*
+			 * XXX thread_block is actually mentioned in
+			 * /usr/include/vm/vm_extern.h
+			 */
 #else
 			thread_block();
 #endif
@@ -299,22 +326,24 @@ FireNode(RF_DagNode_t * node)
 		(*(node->doFunc)) (node);
 		break;
 	case rf_recover:
-		/* fire the undo function of a node */
+		/* Fire the undo function of a node. */
 		if (rf_engineDebug) {
-			printf("raid%d: Firing (undo) node 0x%lx (%s)\n", 
-			       node->dagHdr->raidPtr->raidid,
-			       (unsigned long) node, node->name);
+			printf("raid%d: Firing (undo) node 0x%lx (%s)\n",
+			    node->dagHdr->raidPtr->raidid,
+			    (unsigned long) node, node->name);
 		}
 		if (node->flags & RF_DAGNODE_FLAG_YIELD) {
 #if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
 			/* thread_block(); */
 			/* printf("Need to block the thread here...\n"); */
-			/* XXX thread_block is actually mentioned in
-			 * /usr/include/vm/vm_extern.h */
+			/*
+			 * XXX thread_block is actually mentioned in
+			 * /usr/include/vm/vm_extern.h
+			 */
 #else
 			thread_block();
 #endif
-                }
+		}
 		(*(node->undoFunc)) (node);
 		break;
 	default:
@@ -324,26 +353,25 @@ FireNode(RF_DagNode_t * node)
 }
 
 
-
-/* user context:
+/*
+ * User context:
  * Attempt to fire each node in a linear array.
  * The entire list is fired atomically.
  */
-static void 
-FireNodeArray(
-    int numNodes,
-    RF_DagNode_t ** nodeList)
+void
+rf_FireNodeArray(int numNodes, RF_DagNode_t **nodeList)
 {
 	RF_DagStatus_t dstat;
 	RF_DagNode_t *node;
-	int     i, j;
+	int i, j;
 
-	/* first, mark all nodes which are ready to be fired */
+	/* First, mark all nodes which are ready to be fired. */
 	for (i = 0; i < numNodes; i++) {
 		node = nodeList[i];
 		dstat = node->dagHdr->status;
-		RF_ASSERT((node->status == rf_wait) || (node->status == rf_good));
-		if (NodeReady(node)) {
+		RF_ASSERT((node->status == rf_wait) ||
+		    (node->status == rf_good));
+		if (rf_NodeReady(node)) {
 			if ((dstat == rf_enable) || (dstat == rf_rollForward)) {
 				RF_ASSERT(node->status == rf_wait);
 				if (node->commitNode)
@@ -354,99 +382,107 @@ FireNodeArray(
 			} else {
 				RF_ASSERT(dstat == rf_rollBackward);
 				RF_ASSERT(node->status == rf_good);
-				RF_ASSERT(node->commitNode == RF_FALSE);	/* only one commit node
-										 * per graph */
+				/* Only one commit node per graph. */
+				RF_ASSERT(node->commitNode == RF_FALSE);
 				node->status = rf_recover;
 			}
 		}
 	}
-	/* now, fire the nodes */
+	/* Now, fire the nodes. */
 	for (i = 0; i < numNodes; i++) {
-		if ((nodeList[i]->status == rf_fired) || (nodeList[i]->status == rf_recover))
-			FireNode(nodeList[i]);
+		if ((nodeList[i]->status == rf_fired) ||
+		    (nodeList[i]->status == rf_recover))
+			rf_FireNode(nodeList[i]);
 	}
 }
 
 
-/* user context:
+/*
+ * User context:
  * Attempt to fire each node in a linked list.
  * The entire list is fired atomically.
  */
-static void 
-FireNodeList(RF_DagNode_t * nodeList)
+void
+rf_FireNodeList(RF_DagNode_t *nodeList)
 {
 	RF_DagNode_t *node, *next;
 	RF_DagStatus_t dstat;
-	int     j;
+	int j;
 
 	if (nodeList) {
-		/* first, mark all nodes which are ready to be fired */
+		/* First, mark all nodes which are ready to be fired. */
 		for (node = nodeList; node; node = next) {
 			next = node->next;
 			dstat = node->dagHdr->status;
-			RF_ASSERT((node->status == rf_wait) || (node->status == rf_good));
-			if (NodeReady(node)) {
-				if ((dstat == rf_enable) || (dstat == rf_rollForward)) {
+			RF_ASSERT((node->status == rf_wait) ||
+			    (node->status == rf_good));
+			if (rf_NodeReady(node)) {
+				if ((dstat == rf_enable) ||
+				    (dstat == rf_rollForward)) {
 					RF_ASSERT(node->status == rf_wait);
 					if (node->commitNode)
 						node->dagHdr->numCommits++;
 					node->status = rf_fired;
-					for (j = 0; j < node->numAntecedents; j++)
-						node->antecedents[j]->numSuccFired++;
+					for (j = 0; j < node->numAntecedents;
+					     j++)
+						node->antecedents[j]
+						    ->numSuccFired++;
 				} else {
 					RF_ASSERT(dstat == rf_rollBackward);
 					RF_ASSERT(node->status == rf_good);
-					RF_ASSERT(node->commitNode == RF_FALSE);	/* only one commit node
-											 * per graph */
+					/* Only one commit node per graph. */
+					RF_ASSERT(node->commitNode == RF_FALSE);
 					node->status = rf_recover;
 				}
 			}
 		}
-		/* now, fire the nodes */
+		/* Now, fire the nodes. */
 		for (node = nodeList; node; node = next) {
 			next = node->next;
-			if ((node->status == rf_fired) || (node->status == rf_recover))
-				FireNode(node);
+			if ((node->status == rf_fired) ||
+			    (node->status == rf_recover))
+				rf_FireNode(node);
 		}
 	}
 }
-/* interrupt context:
- * for each succedent
- *    propagate required results from node to succedent
- *    increment succedent's numAntDone
- *    place newly-enable nodes on node queue for firing
+
+
+/*
+ * Interrupt context:
+ * For each succedent,
+ *    propagate required results from node to succedent.
+ *    increment succedent's numAntDone.
+ *    place newly-enable nodes on node queue for firing.
  *
  * To save context switches, we don't place NIL nodes on the node queue,
- * but rather just process them as if they had fired.  Note that NIL nodes
+ * but rather just process them as if they had fired. Note that NIL nodes
  * that are the direct successors of the header will actually get fired by
  * DispatchDAG, which is fine because no context switches are involved.
  *
  * Important:  when running at user level, this can be called by any
  * disk thread, and so the increment and check of the antecedent count
- * must be locked.  I used the node queue mutex and locked down the
+ * must be locked. I used the node queue mutex and locked down the
  * entire function, but this is certainly overkill.
  */
-static void 
-PropagateResults(
-    RF_DagNode_t * node,
-    int context)
+void
+rf_PropagateResults(RF_DagNode_t *node, int context)
 {
 	RF_DagNode_t *s, *a;
 	RF_Raid_t *raidPtr;
-	int     i, ks;
-	RF_DagNode_t *finishlist = NULL;	/* a list of NIL nodes to be
-						 * finished */
-	RF_DagNode_t *skiplist = NULL;	/* list of nodes with failed truedata
-					 * antecedents */
-	RF_DagNode_t *firelist = NULL;	/* a list of nodes to be fired */
+	int i, ks;
+	/* A list of NIL nodes to be finished. */
+	RF_DagNode_t *finishlist = NULL;
+	/* List of nodes with failed truedata antecedents. */
+	RF_DagNode_t *skiplist = NULL;
+	RF_DagNode_t *firelist = NULL;	/* A list of nodes to be fired. */
 	RF_DagNode_t *q = NULL, *qh = NULL, *next;
-	int     j, skipNode;
+	int j, skipNode;
 
 	raidPtr = node->dagHdr->raidPtr;
 
 	DO_LOCK(raidPtr);
 
-	/* debug - validate fire counts */
+	/* Debug - validate fire counts. */
 	for (i = 0; i < node->numAntecedents; i++) {
 		a = *(node->antecedents + i);
 		RF_ASSERT(a->numSuccFired >= a->numSuccDone);
@@ -462,40 +498,60 @@ PropagateResults(
 			RF_ASSERT(s->status == rf_wait);
 			(s->numAntDone)++;
 			if (s->numAntDone == s->numAntecedents) {
-				/* look for NIL nodes */
+				/* Look for NIL nodes. */
 				if (s->doFunc == rf_NullNodeFunc) {
-					/* don't fire NIL nodes, just process
-					 * them */
+					/*
+					 * Don't fire NIL nodes, just process
+					 * them.
+					 */
 					s->next = finishlist;
 					finishlist = s;
 				} else {
-					/* look to see if the node is to be
-					 * skipped */
+					/*
+					 * Look to see if the node is to be
+					 * skipped.
+					 */
 					skipNode = RF_FALSE;
 					for (j = 0; j < s->numAntecedents; j++)
-						if ((s->antType[j] == rf_trueData) && (s->antecedents[j]->status == rf_bad))
+						if ((s->antType[j] ==
+						     rf_trueData) &&
+						    (s->antecedents[j]->status
+						     == rf_bad))
 							skipNode = RF_TRUE;
 					if (skipNode) {
-						/* this node has one or more
+						/*
+						 * This node has one or more
 						 * failed true data
-						 * dependencies, so skip it */
+						 * dependencies, so skip it.
+						 */
 						s->next = skiplist;
 						skiplist = s;
-					} else
-						/* add s to list of nodes (q)
-						 * to execute */
-						if (context != RF_INTR_CONTEXT) {
-							/* we only have to
+					} else {
+						/*
+						 * Add s to list of nodes (q)
+						 * to execute.
+						 */
+						if (context != RF_INTR_CONTEXT)
+						{
+							/*
+							 * We only have to
 							 * enqueue if we're at
-							 * intr context */
-							s->next = firelist;	/* put node on a list to
-										 * be fired after we
-										 * unlock */
+							 * intr context.
+							 */
+							/*
+							 * Put node on a list to
+							 * be fired after we
+							 * unlock.
+							 */
+							s->next = firelist;
 							firelist = s;
-						} else {	/* enqueue the node for
-								 * the dag exec thread
-								 * to fire */
-							RF_ASSERT(NodeReady(s));
+						} else {
+							/*
+							 * Enqueue the node for
+							 * the dag exec thread
+							 * to fire.
+							 */
+						     RF_ASSERT(rf_NodeReady(s));
 							if (q) {
 								q->next = s;
 								q = s;
@@ -504,12 +560,16 @@ PropagateResults(
 								qh->next = NULL;
 							}
 						}
+					}
 				}
 			}
 		}
 
 		if (q) {
-			/* xfer our local list of nodes to the node queue */
+			/*
+			 * Transfer our local list of nodes to the node
+			 * queue.
+			 */
 			q->next = raidPtr->node_queue;
 			raidPtr->node_queue = qh;
 			DO_SIGNAL(raidPtr);
@@ -528,7 +588,7 @@ PropagateResults(
 			rf_FinishNode(skiplist, context);
 		}
 		for (; finishlist; finishlist = next) {
-			/* NIL nodes: no need to fire them */
+			/* NIL nodes: no need to fire them. */
 			next = finishlist->next;
 			finishlist->status = rf_good;
 			for (i = 0; i < finishlist->numAntecedents; i++) {
@@ -537,18 +597,20 @@ PropagateResults(
 			if (finishlist->commitNode)
 				finishlist->dagHdr->numCommits++;
 			/*
-		         * Okay, here we're calling rf_FinishNode() on nodes that
-		         * have the null function as their work proc. Such a node
-		         * could be the terminal node in a DAG. If so, it will
-		         * cause the DAG to complete, which will in turn free
-		         * memory used by the DAG, which includes the node in
-		         * question. Thus, we must avoid referencing the node
-		         * at all after calling rf_FinishNode() on it.
-		         */
-			rf_FinishNode(finishlist, context);	/* recursive call */
+			 * Okay, here we're calling rf_FinishNode() on nodes
+			 * that have the null function as their work proc.
+			 * Such a node could be the terminal node in a DAG.
+			 * If so, it will cause the DAG to complete, which will
+			 * in turn free memory used by the DAG, which includes
+			 * the node in question.
+			 * Thus, we must avoid referencing the node at all
+			 * after calling rf_FinishNode() on it.
+			 */
+			/* Recursive call. */
+			rf_FinishNode(finishlist, context);
 		}
-		/* fire all nodes in firelist */
-		FireNodeList(firelist);
+		/* Fire all nodes in firelist. */
+		rf_FireNodeList(firelist);
 		break;
 
 	case rf_rollBackward:
@@ -560,22 +622,32 @@ PropagateResults(
 
 			if (a->numSuccDone == a->numSuccFired) {
 				if (a->undoFunc == rf_NullNodeFunc) {
-					/* don't fire NIL nodes, just process
-					 * them */
+					/*
+					 * Don't fire NIL nodes, just process
+					 * them.
+					 */
 					a->next = finishlist;
 					finishlist = a;
 				} else {
 					if (context != RF_INTR_CONTEXT) {
-						/* we only have to enqueue if
-						 * we're at intr context */
-						a->next = firelist;	/* put node on a list to
-									 * be fired after we
-									 * unlock */
+						/*
+						 * We only have to enqueue if
+						 * we're at intr context.
+						 */
+						/*
+						 * Put node on a list to
+						 * be fired after we
+						 * unlock.
+						 */
+						a->next = firelist;
 						firelist = a;
-					} else {	/* enqueue the node for
-							 * the dag exec thread
-							 * to fire */
-						RF_ASSERT(NodeReady(a));
+					} else {
+						/*
+						 * Enqueue the node for
+						 * the dag exec thread
+						 * to fire.
+						 */
+						RF_ASSERT(rf_NodeReady(a));
 						if (q) {
 							q->next = a;
 							q = a;
@@ -588,47 +660,50 @@ PropagateResults(
 			}
 		}
 		if (q) {
-			/* xfer our local list of nodes to the node queue */
+			/*
+			 * Transfer our local list of nodes to the node
+			 * queue.
+			 */
 			q->next = raidPtr->node_queue;
 			raidPtr->node_queue = qh;
 			DO_SIGNAL(raidPtr);
 		}
 		DO_UNLOCK(raidPtr);
-		for (; finishlist; finishlist = next) {	/* NIL nodes: no need to
-							 * fire them */
+		for (; finishlist; finishlist = next) {
+			/* NIL nodes: no need to fire them. */
 			next = finishlist->next;
 			finishlist->status = rf_good;
 			/*
-		         * Okay, here we're calling rf_FinishNode() on nodes that
-		         * have the null function as their work proc. Such a node
-		         * could be the first node in a DAG. If so, it will
-		         * cause the DAG to complete, which will in turn free
-		         * memory used by the DAG, which includes the node in
-		         * question. Thus, we must avoid referencing the node
-		         * at all after calling rf_FinishNode() on it.
-		         */
-			rf_FinishNode(finishlist, context);	/* recursive call */
+			 * Okay, here we're calling rf_FinishNode() on nodes
+			 * that have the null function as their work proc.
+			 * Such a node could be the first node in a DAG.
+			 * If so, it will cause the DAG to complete, which will
+			 * in turn free memory used by the DAG, which includes
+			 * the node in question.
+			 * Thus, we must avoid referencing the node at all
+			 * after calling rf_FinishNode() on it.
+			 */
+			rf_FinishNode(finishlist, context);
+			/* Recursive call. */
 		}
-		/* fire all nodes in firelist */
-		FireNodeList(firelist);
+		/* Fire all nodes in firelist. */
+		rf_FireNodeList(firelist);
 
 		break;
 	default:
-		printf("Engine found illegal DAG status in PropagateResults()\n");
+		printf("Engine found illegal DAG status in"
+		    " rf_PropagateResults()\n");
 		RF_PANIC();
 		break;
 	}
 }
 
 
-
 /*
- * Process a fired node which has completed
+ * Process a fired node which has completed.
  */
-static void 
-ProcessNode(
-    RF_DagNode_t * node,
-    int context)
+void
+rf_ProcessNode(RF_DagNode_t *node, int context)
 {
 	RF_Raid_t *raidPtr;
 
@@ -636,79 +711,82 @@ ProcessNode(
 
 	switch (node->status) {
 	case rf_good:
-		/* normal case, don't need to do anything */
+		/* Normal case, don't need to do anything. */
 		break;
 	case rf_bad:
-		if ((node->dagHdr->numCommits > 0) || (node->dagHdr->numCommitNodes == 0)) {
-			node->dagHdr->status = rf_rollForward;	/* crossed commit
-								 * barrier */
+		if ((node->dagHdr->numCommits > 0) ||
+		    (node->dagHdr->numCommitNodes == 0)) {
+			/* Crossed commit barrier. */
+			node->dagHdr->status = rf_rollForward;
 			if (rf_engineDebug || 1) {
-				printf("raid%d: node (%s) returned fail, rolling forward\n", raidPtr->raidid, node->name);
+				printf("raid%d: node (%s) returned fail,"
+				    " rolling forward\n", raidPtr->raidid,
+				    node->name);
 			}
 		} else {
-			node->dagHdr->status = rf_rollBackward;	/* never reached commit
-								 * barrier */
+			/* Never reached commit barrier. */
+			node->dagHdr->status = rf_rollBackward;
 			if (rf_engineDebug || 1) {
-				printf("raid%d: node (%s) returned fail, rolling backward\n", raidPtr->raidid, node->name);
+				printf("raid%d: node (%s) returned fail,"
+				    " rolling backward\n", raidPtr->raidid,
+				    node->name);
 			}
 		}
 		break;
 	case rf_undone:
-		/* normal rollBackward case, don't need to do anything */
+		/* Normal rollBackward case, don't need to do anything. */
 		break;
 	case rf_panic:
-		/* an undo node failed!!! */
-		printf("UNDO of a node failed!!!/n");
+		/* An undo node failed !!! */
+		printf("UNDO of a node failed !!!/n");
 		break;
 	default:
-		printf("node finished execution with an illegal status!!!\n");
+		printf("node finished execution with an illegal status !!!\n");
 		RF_PANIC();
 		break;
 	}
 
-	/* enqueue node's succedents (antecedents if rollBackward) for
-	 * execution */
-	PropagateResults(node, context);
+	/*
+	 * Enqueue node's succedents (antecedents if rollBackward) for
+	 * execution.
+	 */
+	rf_PropagateResults(node, context);
 }
 
 
-
-/* user context or dag-exec-thread context:
+/*
+ * User context or dag-exec-thread context:
  * This is the first step in post-processing a newly-completed node.
  * This routine is called by each node execution function to mark the node
  * as complete and fire off any successors that have been enabled.
  */
-int 
-rf_FinishNode(
-    RF_DagNode_t * node,
-    int context)
+int
+rf_FinishNode(RF_DagNode_t *node, int context)
 {
-	/* as far as I can tell, retcode is not used -wvcii */
-	int     retcode = RF_FALSE;
+	/* As far as I can tell, retcode is not used -wvcii. */
+	int retcode = RF_FALSE;
 	node->dagHdr->numNodesCompleted++;
-	ProcessNode(node, context);
+	rf_ProcessNode(node, context);
 
 	return (retcode);
 }
 
 
-/* user context:
- * submit dag for execution, return non-zero if we have to wait for completion.
- * if and only if we return non-zero, we'll cause cbFunc to get invoked with
+/*
+ * User context:
+ * Submit dag for execution, return non-zero if we have to wait for completion.
+ * If and only if we return non-zero, we'll cause cbFunc to get invoked with
  * cbArg when the DAG has completed.
  *
- * for now we always return 1.  If the DAG does not cause any I/O, then the callback
- * may get invoked before DispatchDAG returns.  There's code in state 5 of ContinueRaidAccess
- * to handle this.
+ * For now we always return 1. If the DAG does not cause any I/O, then the
+ * callback may get invoked before DispatchDAG returns. There's code in state
+ * 5 of ContinueRaidAccess to handle this.
  *
- * All we do here is fire the direct successors of the header node.  The
- * DAG execution thread does the rest of the dag processing.
+ * All we do here is fire the direct successors of the header node. The DAG
+ * execution thread does the rest of the dag processing.
  */
-int 
-rf_DispatchDAG(
-    RF_DagHeader_t * dag,
-    void (*cbFunc) (void *),
-    void *cbArg)
+int
+rf_DispatchDAG(RF_DagHeader_t *dag, void (*cbFunc) (void *), void *cbArg)
 {
 	RF_Raid_t *raidPtr;
 
@@ -723,29 +801,35 @@ rf_DispatchDAG(
 	if (rf_engineDebug) {
 		printf("raid%d: Entering DispatchDAG\n", raidPtr->raidid);
 	}
-	raidPtr->dags_in_flight++;	/* debug only:  blow off proper
-					 * locking */
+	raidPtr->dags_in_flight++;	/*
+					 * Debug only:  blow off proper
+					 * locking.
+					 */
 	dag->cbFunc = cbFunc;
 	dag->cbArg = cbArg;
 	dag->numNodesCompleted = 0;
 	dag->status = rf_enable;
-	FireNodeArray(dag->numSuccedents, dag->succedents);
+	rf_FireNodeArray(dag->numSuccedents, dag->succedents);
 	return (1);
 }
-/* dedicated kernel thread:
- * the thread that handles all DAG node firing.
- * To minimize locking and unlocking, we grab a copy of the entire node queue and then set the
- * node queue to NULL before doing any firing of nodes.  This way we only have to release the
- * lock once.  Of course, it's probably rare that there's more than one node in the queue at
- * any one time, but it sometimes happens.
+
+
+/*
+ * Dedicated kernel thread:
+ * The thread that handles all DAG node firing.
+ * To minimize locking and unlocking, we grab a copy of the entire node queue
+ * and then set the node queue to NULL before doing any firing of nodes.
+ * This way we only have to release the lock once. Of course, it's probably
+ * rare that there's more than one node in the queue at any one time, but it
+ * sometimes happens.
  *
- * In the kernel, this thread runs at spl0 and is not swappable.  I copied these
+ * In the kernel, this thread runs at spl0 and is not swappable. I copied these
  * characteristics from the aio_completion_thread.
  */
 
-#ifdef RAID_AUTOCONFIG
-void 
-DAGExecutionThread_pre(RF_ThreadArg_t arg)
+#ifdef	RAID_AUTOCONFIG
+void
+rf_DAGExecutionThread_pre(RF_ThreadArg_t arg)
 {
 	RF_Raid_t *raidPtr;
 	char raidname[16];
@@ -760,12 +844,12 @@ DAGExecutionThread_pre(RF_ThreadArg_t arg)
 
 	lastpid = RF_ENGINE_PID + raidPtr->raidid - 1;
 	len = sprintf(&raidname[0], "raid%d", raidPtr->raidid);
-#ifdef DIAGNOSTIC
+#ifdef	DIAGNOSTIC
 	if (len >= sizeof(raidname))
 		panic("raidname expansion too long.");
-#endif /* DIAGNOSTIC */
+#endif	/* DIAGNOSTIC */
 
-	if (RF_CREATE_THREAD(raidPtr->engine_thread, DAGExecutionThread,
+	if (RF_CREATE_THREAD(raidPtr->engine_thread, rf_DAGExecutionThread,
 	    raidPtr, &raidname[0])) {
 		RF_ERRORMSG("RAIDFRAME: Unable to create engine thread\n");
 		return;
@@ -779,13 +863,13 @@ DAGExecutionThread_pre(RF_ThreadArg_t arg)
 }
 #endif	/* RAID_AUTOCONFIG */
 
-void 
-DAGExecutionThread(RF_ThreadArg_t arg)
+void
+rf_DAGExecutionThread(RF_ThreadArg_t arg)
 {
 	RF_DagNode_t *nd, *local_nq, *term_nq, *fire_nq;
 	RF_Raid_t *raidPtr;
-	int     ks;
-	int     s;
+	int ks;
+	int s;
 
 	raidPtr = (RF_Raid_t *) arg;
 
@@ -796,7 +880,7 @@ DAGExecutionThread(RF_ThreadArg_t arg)
 	if (rf_engineDebug) {
 		printf("raid%d: Engine thread is running\n", raidPtr->raidid);
 	}
-	/* XXX what to put here XXX */
+	/* XXX What to put here ? XXX */
 
 	s = splbio();
 
@@ -815,7 +899,7 @@ DAGExecutionThread(RF_ThreadArg_t arg)
 			raidPtr->node_queue = NULL;
 			DO_UNLOCK(raidPtr);
 
-			/* first, strip out the terminal nodes */
+			/* First, strip out the terminal nodes. */
 			while (local_nq) {
 				nd = local_nq;
 				local_nq = local_nq->next;
@@ -823,26 +907,34 @@ DAGExecutionThread(RF_ThreadArg_t arg)
 				case rf_enable:
 				case rf_rollForward:
 					if (nd->numSuccedents == 0) {
-						/* end of the dag, add to
-						 * callback list */
+						/*
+						 * End of the dag, add to
+						 * callback list.
+						 */
 						nd->next = term_nq;
 						term_nq = nd;
 					} else {
-						/* not the end, add to the
-						 * fire queue */
+						/*
+						 * Not the end, add to the
+						 * fire queue.
+						 */
 						nd->next = fire_nq;
 						fire_nq = nd;
 					}
 					break;
 				case rf_rollBackward:
 					if (nd->numAntecedents == 0) {
-						/* end of the dag, add to the
-						 * callback list */
+						/*
+						 * End of the dag, add to the
+						 * callback list.
+						 */
 						nd->next = term_nq;
 						term_nq = nd;
 					} else {
-						/* not the end, add to the
-						 * fire queue */
+						/*
+						 * Not the end, add to the
+						 * fire queue.
+						 */
 						nd->next = fire_nq;
 						fire_nq = nd;
 					}
@@ -853,18 +945,20 @@ DAGExecutionThread(RF_ThreadArg_t arg)
 				}
 			}
 
-			/* execute callback of dags which have reached the
-			 * terminal node */
+			/*
+			 * Execute callback of dags which have reached the
+			 * terminal node.
+			 */
 			while (term_nq) {
 				nd = term_nq;
 				term_nq = term_nq->next;
 				nd->next = NULL;
 				(nd->dagHdr->cbFunc) (nd->dagHdr->cbArg);
-				raidPtr->dags_in_flight--;	/* debug only */
+				raidPtr->dags_in_flight--; /* Debug only. */
 			}
 
-			/* fire remaining nodes */
-			FireNodeList(fire_nq);
+			/* Fire remaining nodes. */
+			rf_FireNodeList(fire_nq);
 
 			DO_LOCK(raidPtr);
 		}
diff --git a/sys/dev/raidframe/rf_engine.h b/sys/dev/raidframe/rf_engine.h
index dd21e705369..ae3ae2dd293 100644
--- a/sys/dev/raidframe/rf_engine.h
+++ b/sys/dev/raidframe/rf_engine.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_engine.h,v 1.3 2002/08/05 22:11:27 tdeval Exp $	*/
+/*	$OpenBSD: rf_engine.h,v 1.4 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_engine.h,v 1.3 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,24 +28,23 @@
  * rights to redistribute these changes.
  */
 
-/**********************************************************
- *                                                        *
- * engine.h -- header file for execution engine functions *
- *                                                        *
- **********************************************************/
+/***********************************************************
+ *                                                         *
+ * engine.h -- Header file for execution engine functions. *
+ *                                                         *
+ ***********************************************************/
 
-#ifndef _RF__RF_ENGINE_H_
-#define _RF__RF_ENGINE_H_
+#ifndef	_RF__RF_ENGINE_H_
+#define	_RF__RF_ENGINE_H_
 
 extern void **rf_hook_cookies;
 
-int 
-rf_ConfigureEngine(RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr, RF_Config_t * cfgPtr);
+int  rf_ConfigureEngine(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
 
-int     rf_FinishNode(RF_DagNode_t * node, int context);	/* return finished node
-								 * to engine */
+	/* Return finished node to engine. */
+int  rf_FinishNode(RF_DagNode_t *, int);
 
-int     rf_DispatchDAG(RF_DagHeader_t * dag, void (*cbFunc) (void *), void *cbArg);	/* execute dag */
+	/* Execute dag. */
+int  rf_DispatchDAG(RF_DagHeader_t *, void (*) (void *), void *);
 
-#endif				/* !_RF__RF_ENGINE_H_ */
+#endif	/* !_RF__RF_ENGINE_H_ */
diff --git a/sys/dev/raidframe/rf_etimer.h b/sys/dev/raidframe/rf_etimer.h
index 7531ade1471..197433740a1 100644
--- a/sys/dev/raidframe/rf_etimer.h
+++ b/sys/dev/raidframe/rf_etimer.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_etimer.h,v 1.5 2000/01/07 14:50:21 peter Exp $	*/
+/*	$OpenBSD: rf_etimer.h,v 1.6 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_etimer.h,v 1.4 1999/08/13 03:26:55 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,8 +28,8 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_TIMER_H_
-#define _RF__RF_TIMER_H_
+#ifndef	_RF__RF_TIMER_H_
+#define	_RF__RF_TIMER_H_
 
 
 #include "rf_options.h"
@@ -42,34 +43,34 @@ struct RF_Etimer_s {
 	struct timeval diff;
 };
 
-#if defined(_KERNEL)
+#if	defined(_KERNEL)
 #include <sys/kernel.h>
 
-#define RF_ETIMER_START(_t_) 					\
-		{						\
-			int s;					\
-			bzero(&(_t_), sizeof (_t_));		\
-			s = splclock();				\
-			(_t_).st = mono_time;			\
-			splx(s);				\
-		}
+#define	RF_ETIMER_START(_t_) 						\
+	do {								\
+		int s;							\
+		bzero(&(_t_), sizeof (_t_));				\
+		s = splclock();						\
+		(_t_).st = mono_time;					\
+		splx(s);						\
+	} while (0)
 
-#define RF_ETIMER_STOP(_t_) 					\
-		{						\
-			int s;					\
-			s = splclock();				\
-			(_t_).et = mono_time;			\
-			splx(s);				\
-		}
+#define	RF_ETIMER_STOP(_t_) 						\
+	do {								\
+		int s;							\
+		s = splclock();						\
+		(_t_).et = mono_time;					\
+		splx(s);						\
+	} while (0)
 
-#define RF_ETIMER_EVAL(_t_)					\
-	{							\
-		RF_TIMEVAL_DIFF(&(_t_).st, &(_t_).et, &(_t_).diff) \
-	}
+#define	RF_ETIMER_EVAL(_t_)						\
+	do {								\
+		RF_TIMEVAL_DIFF(&(_t_).st, &(_t_).et, &(_t_).diff);	\
+	} while (0)
 
-#define RF_ETIMER_VAL_US(_t_)      (RF_TIMEVAL_TO_US((_t_).diff))
-#define RF_ETIMER_VAL_MS(_t_)      (RF_TIMEVAL_TO_US((_t_).diff)/1000)
+#define	RF_ETIMER_VAL_US(_t_)		(RF_TIMEVAL_TO_US((_t_).diff))
+#define	RF_ETIMER_VAL_MS(_t_)		(RF_TIMEVAL_TO_US((_t_).diff)/1000)
 
-#endif /* _KERNEL */
+#endif	/* _KERNEL */
 
-#endif				/* !_RF__RF_TIMER_H_ */
+#endif	/* !_RF__RF_TIMER_H_ */
diff --git a/sys/dev/raidframe/rf_evenodd.c b/sys/dev/raidframe/rf_evenodd.c
index 52118285fc8..da372aca9ed 100644
--- a/sys/dev/raidframe/rf_evenodd.c
+++ b/sys/dev/raidframe/rf_evenodd.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_evenodd.c,v 1.4 2000/01/11 18:02:22 peter Exp $	*/
+/*	$OpenBSD: rf_evenodd.c,v 1.5 2002/12/16 07:01:03 tdeval Exp $	*/
 /*	$NetBSD: rf_evenodd.c,v 1.4 2000/01/07 03:40:59 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,15 +28,15 @@
  * rights to redistribute these changes.
  */
 
-/*****************************************************************************************
+/*****************************************************************************
  *
  * rf_evenodd.c -- implements EVENODD array architecture
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 #include "rf_archs.h"
 
-#if RF_INCLUDE_EVENODD > 0
+#if	RF_INCLUDE_EVENODD > 0
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -61,148 +62,172 @@
 #include "rf_engine.h"
 
 typedef struct RF_EvenOddConfigInfo_s {
-	RF_RowCol_t **stripeIdentifier;	/* filled in at config time & used by
-					 * IdentifyStripe */
-}       RF_EvenOddConfigInfo_t;
-
-int 
-rf_ConfigureEvenOdd(listp, raidPtr, cfgPtr)
-	RF_ShutdownList_t **listp;
-	RF_Raid_t *raidPtr;
-	RF_Config_t *cfgPtr;
+	RF_RowCol_t **stripeIdentifier;	/*
+					 * Filled in at config time & used by
+					 * IdentifyStripe.
+					 */
+}	RF_EvenOddConfigInfo_t;
+
+int
+rf_ConfigureEvenOdd(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_EvenOddConfigInfo_t *info;
 	RF_RowCol_t i, j, startdisk;
 
-	RF_MallocAndAdd(info, sizeof(RF_EvenOddConfigInfo_t), (RF_EvenOddConfigInfo_t *), raidPtr->cleanupList);
+	RF_MallocAndAdd(info, sizeof(RF_EvenOddConfigInfo_t),
+	    (RF_EvenOddConfigInfo_t *), raidPtr->cleanupList);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol, raidPtr->numCol, raidPtr->cleanupList);
+	info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol,
+	    raidPtr->numCol, raidPtr->cleanupList);
 	startdisk = 0;
 	for (i = 0; i < raidPtr->numCol; i++) {
 		for (j = 0; j < raidPtr->numCol; j++) {
-			info->stripeIdentifier[i][j] = (startdisk + j) % raidPtr->numCol;
+			info->stripeIdentifier[i][j] = (startdisk + j) %
+			    raidPtr->numCol;
 		}
 		if ((startdisk -= 2) < 0)
 			startdisk += raidPtr->numCol;
 	}
 
-	/* fill in the remaining layout parameters */
+	/* Fill in the remaining layout parameters. */
 	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
-	layoutPtr->numDataCol = raidPtr->numCol - 2;	/* ORIG:
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
+	layoutPtr->numDataCol = raidPtr->numCol - 2;	/*
+							 * ORIG:
 							 * layoutPtr->numDataCol
-							 * = raidPtr->numCol-1;  */
-#if RF_EO_MATRIX_DIM > 17
+							 * = raidPtr->numCol-1;
+							 */
+#if	RF_EO_MATRIX_DIM > 17
 	if (raidPtr->numCol <= 17) {
-		printf("Number of stripe units in a parity stripe is smaller than 17. Please\n");
-		printf("define the macro RF_EO_MATRIX_DIM in file rf_evenodd_dagfuncs.h to \n");
-		printf("be 17 to increase performance. \n");
+		printf("Number of stripe units in a parity stripe is smaller"
+		    " than 17. Please\ndefine the macro RF_EO_MATRIX_DIM in"
+		    " file rf_evenodd_dagfuncs.h to\nbe 17 to increase"
+		    " performance.\n");
 		return (EINVAL);
 	}
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 	if (raidPtr->numCol > 17) {
-		printf("Number of stripe units in a parity stripe is bigger than 17. Please\n");
-		printf("define the macro RF_EO_MATRIX_DIM in file rf_evenodd_dagfuncs.h to \n");
-		printf("be 257 for encoding and decoding functions to work. \n");
+		printf("Number of stripe units in a parity stripe is bigger"
+		    " than 17. Please\ndefine the macro RF_EO_MATRIX_DIM in"
+		    " file rf_evenodd_dagfuncs.h to\nbe 257 for encoding and"
+		    " decoding functions to work.\n");
 		return (EINVAL);
 	}
 #endif
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
+	    layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numParityCol = 2;
 	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;
 
 	return (0);
 }
 
-int 
-rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t * raidPtr)
+int
+rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t *raidPtr)
 {
 	return (20);
 }
 
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitEvenOdd(RF_Raid_t * raidPtr)
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimitEvenOdd(RF_Raid_t *raidPtr)
 {
 	return (10);
 }
 
-void 
-rf_IdentifyStripeEvenOdd(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeEvenOdd(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
-	RF_EvenOddConfigInfo_t *info = (RF_EvenOddConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
+	    addr);
+	RF_EvenOddConfigInfo_t *info =
+	    (RF_EvenOddConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 
 	*outRow = 0;
 	*diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
 }
-/* The layout of stripe unit on the disks are:      c0 c1 c2 c3 c4
 
- 						     0  1  2  E  P
-						     5  E  P  3  4
-						     P  6  7  8  E
-	 					    10 11  E  P  9
-						     E  P 12 13 14
-						     ....
 
-  We use the MapSectorRAID5 to map data information because the routine can be shown to map exactly
-  the layout of data stripe unit as shown above although we have 2 redundant information now.
-  But for E and P, we use rf_MapEEvenOdd and rf_MapParityEvenOdd which are different method from raid-5.
-*/
+/*
+ * The layout of stripe unit on the disks are:	c0 c1 c2 c3 c4
+ *
+ *						 0  1  2  E  P
+ *						 5  E  P  3  4
+ *						 P  6  7  8  E
+ *	 					10 11  E  P  9
+ *						 E  P 12 13 14
+ *						....
+ *
+ * We use the MapSectorRAID5 to map data information because the routine can
+ * be shown to map exactly the layout of data stripe unit as shown above,
+ * although we have 2 redundant information now.
+ * But for E and P, we use rf_MapEEvenOdd and rf_MapParityEvenOdd which are
+ * different method from raid-5.
+ */
 
 
-void 
+void
 rf_MapParityEvenOdd(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+    RF_Raid_t		*raidPtr,
+    RF_RaidAddr_t	 raidSector,
+    RF_RowCol_t		*row,
+    RF_RowCol_t		*col,
+    RF_SectorNum_t	*diskSector,
+    int			 remap
+)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	RF_StripeNum_t endSUIDofthisStrip = (SUID / raidPtr->Layout.numDataCol + 1) * raidPtr->Layout.numDataCol - 1;
+	RF_StripeNum_t endSUIDofthisStrip =
+	    (SUID / raidPtr->Layout.numDataCol + 1) *
+	    raidPtr->Layout.numDataCol - 1;
 
 	*row = 0;
 	*col = (endSUIDofthisStrip + 2) % raidPtr->numCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
+void
 rf_MapEEvenOdd(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+    RF_Raid_t		*raidPtr,
+    RF_RaidAddr_t	 raidSector,
+    RF_RowCol_t		*row,
+    RF_RowCol_t		*col,
+    RF_SectorNum_t	*diskSector,
+    int			 remap
+)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	RF_StripeNum_t endSUIDofthisStrip = (SUID / raidPtr->Layout.numDataCol + 1) * raidPtr->Layout.numDataCol - 1;
+	RF_StripeNum_t endSUIDofthisStrip =
+	    (SUID / raidPtr->Layout.numDataCol + 1) *
+	    raidPtr->Layout.numDataCol - 1;
 
 	*row = 0;
 	*col = (endSUIDofthisStrip + 1) % raidPtr->numCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
+void
 rf_EODagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
+    RF_Raid_t		*raidPtr,
+    RF_IoType_t		 type,
+    RF_AccessStripeMap_t *asmap,
+    RF_VoidFuncPtr	*createFunc
+)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	unsigned ndfail = asmap->numDataFailed;
@@ -211,34 +236,47 @@ rf_EODagSelect(
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 	if (ntfail > 2) {
-		RF_ERRORMSG("more than two disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("more than two disks failed in a single group !"
+		    "  Aborting I/O operation.\n");
 		 /* *infoFunc = */ *createFunc = NULL;
 		return;
 	}
-	/* ok, we can do this I/O */
+	/* Ok, we can do this I/O. */
 	if (type == RF_IO_TYPE_READ) {
 		switch (ndfail) {
 		case 0:
-			/* fault free read */
-			*createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;	/* same as raid 5 */
+			/* Fault free read. */
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateFaultFreeReadDAG;	/* Same as raid 5. */
 			break;
 		case 1:
-			/* lost a single data unit */
-			/* two cases: (1) parity is not lost. do a normal raid
-			 * 5 reconstruct read. (2) parity is lost. do a
-			 * reconstruct read using "e". */
-			if (ntfail == 2) {	/* also lost redundancy */
-				if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_PARITY)
-					*createFunc = (RF_VoidFuncPtr) rf_EO_110_CreateReadDAG;
+			/* Lost a single data unit. */
+			/*
+			 * Two cases:
+			 * (1) Parity is not lost. Do a normal raid 5
+			 * reconstruct read.
+			 * (2) Parity is lost. Do a reconstruct read using "e".
+			 */
+			if (ntfail == 2) {	/* Also lost redundancy. */
+				if (asmap->failedPDAs[1]->type ==
+				    RF_PDA_TYPE_PARITY)
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_110_CreateReadDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_101_CreateReadDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_101_CreateReadDAG;
 			} else {
-				/* P and E are ok. But is there a failure in
-				 * some unaccessed data unit? */
-				if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
-					*createFunc = (RF_VoidFuncPtr) rf_EO_200_CreateReadDAG;
+				/*
+				 * P and E are ok. But is there a failure in
+				 * some unaccessed data unit ?
+				 */
+				if (rf_NumFailedDataUnitsInStripe(raidPtr,
+				    asmap) == 2)
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_200_CreateReadDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_100_CreateReadDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_100_CreateReadDAG;
 			}
 			break;
 		case 2:
@@ -248,12 +286,16 @@ rf_EODagSelect(
 		}
 		return;
 	}
-	/* a write */
+	/* A write. */
 	switch (ntfail) {
-	case 0:		/* fault free */
+	case 0:		/* Fault free. */
 		if (rf_suppressLocksAndLargeWrites ||
-		    (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) && (layoutPtr->numDataCol != 1)) ||
-			(asmap->parityInfo->next != NULL) || (asmap->qInfo->next != NULL) || rf_CheckStripeForFailures(raidPtr, asmap))) {
+		    (((asmap->numStripeUnitsAccessed <=
+		       (layoutPtr->numDataCol / 2)) &&
+		      (layoutPtr->numDataCol != 1)) ||
+		     (asmap->parityInfo->next != NULL) ||
+		     (asmap->qInfo->next != NULL) ||
+		     rf_CheckStripeForFailures(raidPtr, asmap))) {
 
 			*createFunc = (RF_VoidFuncPtr) rf_EOCreateSmallWriteDAG;
 		} else {
@@ -261,85 +303,129 @@ rf_EODagSelect(
 		}
 		break;
 
-	case 1:		/* single disk fault */
+	case 1:		/* Single disk fault. */
 		if (npfail == 1) {
-			RF_ASSERT((asmap->failedPDAs[0]->type == RF_PDA_TYPE_PARITY) || (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q));
-			if (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q) {	/* q died, treat like
-										 * normal mode raid5
-										 * write. */
-				if (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) || (asmap->numStripeUnitsAccessed == 1))
-				    || (asmap->parityInfo->next != NULL) || rf_NumFailedDataUnitsInStripe(raidPtr, asmap))
-					*createFunc = (RF_VoidFuncPtr) rf_EO_001_CreateSmallWriteDAG;
+			RF_ASSERT((asmap->failedPDAs[0]->type ==
+			    RF_PDA_TYPE_PARITY) ||
+			    (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q));
+			if (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q) {
+				/*
+				 * q died, treat like normal mode raid5
+				 * write.
+				 */
+				if (((asmap->numStripeUnitsAccessed <=
+				      (layoutPtr->numDataCol / 2)) ||
+				     (asmap->numStripeUnitsAccessed == 1)) ||
+				    (asmap->parityInfo->next != NULL) ||
+				    rf_NumFailedDataUnitsInStripe(raidPtr,
+				     asmap))
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_001_CreateSmallWriteDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_001_CreateLargeWriteDAG;
-			} else {/* parity died, small write only updating Q */
-				if (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) || (asmap->numStripeUnitsAccessed == 1))
-				    || (asmap->qInfo->next != NULL) || rf_NumFailedDataUnitsInStripe(raidPtr, asmap))
-					*createFunc = (RF_VoidFuncPtr) rf_EO_010_CreateSmallWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_001_CreateLargeWriteDAG;
+			} else {
+				/* Parity died, small write only updating Q. */
+				if (((asmap->numStripeUnitsAccessed <=
+				      (layoutPtr->numDataCol / 2)) ||
+				     (asmap->numStripeUnitsAccessed == 1)) ||
+				    (asmap->qInfo->next != NULL) ||
+				    rf_NumFailedDataUnitsInStripe(raidPtr,
+				     asmap))
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_010_CreateSmallWriteDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_010_CreateLargeWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_010_CreateLargeWriteDAG;
 			}
-		} else {	/* data missing. Do a P reconstruct write if
+		} else {	/*
+				 * Data missing. Do a P reconstruct write if
 				 * only a single data unit is lost in the
 				 * stripe, otherwise a reconstruct write which
-				 * employnig both P and E units. */
-			if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2) {
+				 * is employing both P and E units.
+				 */
+			if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
+			{
 				if (asmap->numStripeUnitsAccessed == 1)
-					*createFunc = (RF_VoidFuncPtr) rf_EO_200_CreateWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_200_CreateWriteDAG;
 				else
-					*createFunc = NULL;	/* No direct support for
-								 * this case now, like
-								 * that in Raid-5  */
+					/*
+					 * No direct support for this case now,
+					 * like that in Raid-5.
+					 */
+					*createFunc = NULL;
 			} else {
-				if (asmap->numStripeUnitsAccessed != 1 && asmap->failedPDAs[0]->numSector != layoutPtr->sectorsPerStripeUnit)
-					*createFunc = NULL;	/* No direct support for
-								 * this case now, like
-								 * that in Raid-5  */
+				if (asmap->numStripeUnitsAccessed != 1 &&
+				    asmap->failedPDAs[0]->numSector !=
+				    layoutPtr->sectorsPerStripeUnit)
+					/*
+					 * No direct support for this case now,
+					 * like that in Raid-5.
+					 */
+					*createFunc = NULL;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_100_CreateWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_100_CreateWriteDAG;
 			}
 		}
 		break;
 
-	case 2:		/* two disk faults */
+	case 2:		/* Two disk faults. */
 		switch (npfail) {
-		case 2:	/* both p and q dead */
+		case 2:	/* Both p and q dead. */
 			*createFunc = (RF_VoidFuncPtr) rf_EO_011_CreateWriteDAG;
 			break;
-		case 1:	/* either p or q and dead data */
-			RF_ASSERT(asmap->failedPDAs[0]->type == RF_PDA_TYPE_DATA);
-			RF_ASSERT((asmap->failedPDAs[1]->type == RF_PDA_TYPE_PARITY) || (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q));
+		case 1:	/* Either p or q and dead data. */
+			RF_ASSERT(asmap->failedPDAs[0]->type ==
+			    RF_PDA_TYPE_DATA);
+			RF_ASSERT((asmap->failedPDAs[1]->type ==
+			    RF_PDA_TYPE_PARITY) ||
+			    (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q));
 			if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q) {
-				if (asmap->numStripeUnitsAccessed != 1 && asmap->failedPDAs[0]->numSector != layoutPtr->sectorsPerStripeUnit)
-					*createFunc = NULL;	/* In both PQ and
-								 * EvenOdd, no direct
-								 * support for this case
-								 * now, like that in
-								 * Raid-5  */
+				if (asmap->numStripeUnitsAccessed != 1 &&
+				    asmap->failedPDAs[0]->numSector !=
+				    layoutPtr->sectorsPerStripeUnit)
+					/*
+					 * In both PQ and EvenOdd, no direct
+					 * support for this case now, like that
+					 * in Raid-5.
+					 */
+					*createFunc = NULL;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_101_CreateWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_101_CreateWriteDAG;
 			} else {
-				if (asmap->numStripeUnitsAccessed != 1 && asmap->failedPDAs[0]->numSector != layoutPtr->sectorsPerStripeUnit)
-					*createFunc = NULL;	/* No direct support for
-								 * this case, like that
-								 * in Raid-5  */
+				if (asmap->numStripeUnitsAccessed != 1 &&
+				    asmap->failedPDAs[0]->numSector !=
+				    layoutPtr->sectorsPerStripeUnit)
+					/*
+					 * No direct support for this case,
+					 * like that in Raid-5.
+					 */
+					*createFunc = NULL;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_110_CreateWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_EO_110_CreateWriteDAG;
 			}
 			break;
-		case 0:	/* double data loss */
-			/* if(asmap->failedPDAs[0]->numSector +
+		case 0:	/* Double data loss. */
+			/*
+			 * if(asmap->failedPDAs[0]->numSector +
 			 * asmap->failedPDAs[1]->numSector == 2 *
 			 * layoutPtr->sectorsPerStripeUnit ) createFunc =
-			 * rf_EOCreateLargeWriteDAG; else    							 */
-			*createFunc = NULL;	/* currently, in Evenodd, No
+			 * rf_EOCreateLargeWriteDAG; else
+			 */
+			*createFunc = NULL;	/*
+						 * Currently, in Evenodd, no
 						 * support for simultaneous
-						 * access of both failed SUs */
+						 * access of both failed SUs.
+						 */
 			break;
 		}
 		break;
 
-	default:		/* more than 2 disk faults */
+	default:	/* More than 2 disk faults. */
 		*createFunc = NULL;
 		RF_PANIC();
 	}
@@ -347,34 +433,37 @@ rf_EODagSelect(
 }
 
 
-int 
-rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
-	RF_Raid_t *raidPtr;
-	RF_RaidAddr_t raidAddr;
-	RF_PhysDiskAddr_t *parityPDA;
-	int     correct_it;
-	RF_RaidAccessFlags_t flags;
+int
+rf_VerifyParityEvenOdd(
+	RF_Raid_t		*raidPtr,
+	RF_RaidAddr_t		 raidAddr,
+	RF_PhysDiskAddr_t	*parityPDA,
+	int			 correct_it,
+	RF_RaidAccessFlags_t	 flags
+)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_RaidAddr_t startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
+	RF_RaidAddr_t startAddr =
+	    rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
 	RF_SectorCount_t numsector = parityPDA->numSector;
-	int     numbytes = rf_RaidAddressToByte(raidPtr, numsector);
-	int     bytesPerStripe = numbytes * layoutPtr->numDataCol;
-	RF_DagHeader_t *rd_dag_h, *wr_dag_h;	/* read, write dag */
+	int numbytes = rf_RaidAddressToByte(raidPtr, numsector);
+	int bytesPerStripe = numbytes * layoutPtr->numDataCol;
+	RF_DagHeader_t *rd_dag_h, *wr_dag_h;	/* Read, write dag. */
 	RF_DagNode_t *blockNode, *unblockNode, *wrBlock, *wrUnblock;
 	RF_AccessStripeMapHeader_t *asm_h;
 	RF_AccessStripeMap_t *asmap;
 	RF_AllocListElem_t *alloclist;
 	RF_PhysDiskAddr_t *pda;
-	char   *pbuf, *buf, *end_p, *p;
-	char   *redundantbuf2;
-	int     redundantTwoErr = 0, redundantOneErr = 0;
-	int     parity_cant_correct = RF_FALSE, red2_cant_correct = RF_FALSE,
-	        parity_corrected = RF_FALSE, red2_corrected = RF_FALSE;
-	int     i, retcode;
+	char *pbuf, *buf, *end_p, *p;
+	char *redundantbuf2;
+	int redundantTwoErr = 0, redundantOneErr = 0;
+	int parity_cant_correct = RF_FALSE, red2_cant_correct = RF_FALSE,
+	    parity_corrected = RF_FALSE, red2_corrected = RF_FALSE;
+	int i, retcode;
 	RF_ReconUnitNum_t which_ru;
-	RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
-	int     stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
+	RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr,
+	    raidAddr, &which_ru);
+	int stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
 	RF_AccTraceEntry_t tracerec;
 	RF_MCPair_t *mcpair;
 
@@ -382,32 +471,40 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 
 	mcpair = rf_AllocMCPair();
 	rf_MakeAllocList(alloclist);
-	RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol), (char *), alloclist);
-	RF_CallocAndAdd(pbuf, 1, numbytes, (char *), alloclist);	/* use calloc to make
-									 * sure buffer is zeroed */
+	RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol +
+	    layoutPtr->numParityCol), (char *), alloclist);
+	/* Use calloc to make sure buffer is zeroed. */
+	RF_CallocAndAdd(pbuf, 1, numbytes, (char *), alloclist);
 	end_p = buf + bytesPerStripe;
-	RF_CallocAndAdd(redundantbuf2, 1, numbytes, (char *), alloclist);	/* use calloc to make
-										 * sure buffer is zeroed */
+	/* Use calloc to make sure buffer is zeroed. */
+	RF_CallocAndAdd(redundantbuf2, 1, numbytes, (char *), alloclist);
 
-	rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf, rf_DiskReadFunc, rf_DiskReadUndoFunc,
-	    "Rod", alloclist, flags, RF_IO_NORMAL_PRIORITY);
+	rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf,
+	    rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rod", alloclist, flags,
+	    RF_IO_NORMAL_PRIORITY);
 	blockNode = rd_dag_h->succedents[0];
 	unblockNode = blockNode->succedents[0]->succedents[0];
 
-	/* map the stripe and fill in the PDAs in the dag */
-	asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
+	/* Map the stripe and fill in the PDAs in the dag. */
+	asm_h = rf_MapAccess(raidPtr, startAddr,
+	    layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
 	asmap = asm_h->stripeMap;
 
-	for (pda = asmap->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) {
+	for (pda = asmap->physInfo, i = 0; i < layoutPtr->numDataCol;
+	     i++, pda = pda->next) {
 		RF_ASSERT(pda);
 		rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
 		RF_ASSERT(pda->numSector != 0);
 		if (rf_TryToRedirectPDA(raidPtr, pda, 0))
-			goto out;	/* no way to verify parity if disk is
-					 * dead.  return w/ good status */
+			/*
+			 * No way to verify parity if disk is dead.
+			 * Return w/ good status.
+			 */
+			goto out;
 		blockNode->succedents[i]->params[0].p = pda;
 		blockNode->succedents[i]->params[2].v = psID;
-		blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		blockNode->succedents[i]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 	}
 
 	RF_ASSERT(!asmap->parityInfo->next);
@@ -415,19 +512,23 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 	RF_ASSERT(asmap->parityInfo->numSector != 0);
 	if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
 		goto out;
-	blockNode->succedents[layoutPtr->numDataCol]->params[0].p = asmap->parityInfo;
+	blockNode->succedents[layoutPtr->numDataCol]->params[0].p =
+	    asmap->parityInfo;
 
 	RF_ASSERT(!asmap->qInfo->next);
 	rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->qInfo, 0, 1);
 	RF_ASSERT(asmap->qInfo->numSector != 0);
 	if (rf_TryToRedirectPDA(raidPtr, asmap->qInfo, 1))
 		goto out;
-	/* if disk is dead, b/c no reconstruction is implemented right now,
-	 * the function "rf_TryToRedirectPDA" always return one, which cause
-	 * go to out and return w/ good status   */
-	blockNode->succedents[layoutPtr->numDataCol + 1]->params[0].p = asmap->qInfo;
-
-	/* fire off the DAG */
+	/*
+	 * If disk is dead, b/c no reconstruction is implemented right now,
+	 * the function "rf_TryToRedirectPDA" always return one, which causes
+	 * go to out and return w/ good status.
+	 */
+	blockNode->succedents[layoutPtr->numDataCol + 1]->params[0].p =
+	    asmap->qInfo;
+
+	/* Fire off the DAG. */
 	bzero((char *) &tracerec, sizeof(tracerec));
 	rd_dag_h->tracerec = &tracerec;
 
@@ -443,15 +544,19 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 		RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 	RF_UNLOCK_MUTEX(mcpair->mutex);
 	if (rd_dag_h->status != rf_enable) {
-		RF_ERRORMSG("Unable to verify parity:  can't read the stripe\n");
+		RF_ERRORMSG("Unable to verify parity:  can't read"
+		    " the stripe\n");
 		retcode = RF_PARITY_COULD_NOT_VERIFY;
 		goto out;
 	}
 	for (p = buf, i = 0; p < end_p; p += numbytes, i++) {
-		rf_e_encToBuf(raidPtr, i, p, RF_EO_MATRIX_DIM - 2, redundantbuf2, numsector);
-		/* the corresponding columes in EvenOdd encoding Matrix for
-		 * these p pointers which point to the databuffer in a full
-		 * stripe are sequentially from 0 to layoutPtr->numDataCol-1 */
+		rf_e_encToBuf(raidPtr, i, p, RF_EO_MATRIX_DIM - 2,
+		    redundantbuf2, numsector);
+		/*
+		 * The corresponding columns in EvenOdd encoding Matrix for
+		 * these p pointers that point to the databuffer in a full
+		 * stripe are sequential from 0 to layoutPtr->numDataCol-1.
+		 */
 		rf_bxor(p, pbuf, numbytes, NULL);
 	}
 	RF_ASSERT(i == layoutPtr->numDataCol);
@@ -459,8 +564,10 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 	for (i = 0; i < numbytes; i++) {
 		if (pbuf[i] != buf[bytesPerStripe + i]) {
 			if (!correct_it) {
-				RF_ERRORMSG3("Parity verify error: byte %d of parity is 0x%x should be 0x%x\n",
-				    i, (u_char) buf[bytesPerStripe + i], (u_char) pbuf[i]);
+				RF_ERRORMSG3("Parity verify error: byte %d of"
+				    " parity is 0x%x should be 0x%x\n", i,
+				    (u_char) buf[bytesPerStripe + i],
+				    (u_char) pbuf[i]);
 			}
 		}
 		redundantOneErr = 1;
@@ -470,8 +577,11 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 	for (i = 0; i < numbytes; i++) {
 		if (redundantbuf2[i] != buf[bytesPerStripe + numbytes + i]) {
 			if (!correct_it) {
-				RF_ERRORMSG3("Parity verify error: byte %d of second redundant information is 0x%x should be 0x%x\n",
-				    i, (u_char) buf[bytesPerStripe + numbytes + i], (u_char) redundantbuf2[i]);
+				RF_ERRORMSG3("Parity verify error: byte %d of"
+				    " second redundant information is 0x%x"
+				    " should be 0x%x\n", i,
+				    (u_char) buf[bytesPerStripe + numbytes + i],
+				    (u_char) redundantbuf2[i]);
 			}
 			redundantTwoErr = 1;
 			break;
@@ -480,15 +590,17 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 	if (redundantOneErr || redundantTwoErr)
 		retcode = RF_PARITY_BAD;
 
-	/* correct the first redundant disk, ie parity if it is error    */
+	/* Correct the first redundant disk, ie parity if it is error. */
 	if (redundantOneErr && correct_it) {
-		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-		    "Wnp", alloclist, flags, RF_IO_NORMAL_PRIORITY);
+		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", alloclist,
+		    flags, RF_IO_NORMAL_PRIORITY);
 		wrBlock = wr_dag_h->succedents[0];
 		wrUnblock = wrBlock->succedents[0]->succedents[0];
 		wrBlock->succedents[0]->params[0].p = asmap->parityInfo;
 		wrBlock->succedents[0]->params[2].v = psID;
-		wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wrBlock->succedents[0]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		bzero((char *) &tracerec, sizeof(tracerec));
 		wr_dag_h->tracerec = &tracerec;
 		if (rf_verifyParityDebug) {
@@ -497,13 +609,14 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 		}
 		RF_LOCK_MUTEX(mcpair->mutex);
 		mcpair->flag = 0;
-		rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-		    (void *) mcpair);
+		rf_DispatchDAG(wr_dag_h,
+		    (void (*) (void *)) rf_MCPairWakeupFunc, (void *) mcpair);
 		while (!mcpair->flag)
 			RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 		RF_UNLOCK_MUTEX(mcpair->mutex);
 		if (wr_dag_h->status != rf_enable) {
-			RF_ERRORMSG("Unable to correct parity in VerifyParity:  can't write the stripe\n");
+			RF_ERRORMSG("Unable to correct parity in VerifyParity:"
+			    " can't write the stripe\n");
 			parity_cant_correct = RF_TRUE;
 		} else {
 			parity_corrected = RF_TRUE;
@@ -511,28 +624,33 @@ rf_VerifyParityEvenOdd(raidPtr, raidAddr, parityPDA, correct_it, flags)
 		rf_FreeDAG(wr_dag_h);
 	}
 	if (redundantTwoErr && correct_it) {
-		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, redundantbuf2, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes,
+		    redundantbuf2, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
 		    "Wnred2", alloclist, flags, RF_IO_NORMAL_PRIORITY);
 		wrBlock = wr_dag_h->succedents[0];
 		wrUnblock = wrBlock->succedents[0]->succedents[0];
 		wrBlock->succedents[0]->params[0].p = asmap->qInfo;
 		wrBlock->succedents[0]->params[2].v = psID;
-		wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wrBlock->succedents[0]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		bzero((char *) &tracerec, sizeof(tracerec));
 		wr_dag_h->tracerec = &tracerec;
 		if (rf_verifyParityDebug) {
-			printf("Dag of write new second redundant information in parity verify :\n");
+			printf("Dag of write new second redundant information"
+			    " in parity verify :\n");
 			rf_PrintDAGList(wr_dag_h);
 		}
 		RF_LOCK_MUTEX(mcpair->mutex);
 		mcpair->flag = 0;
-		rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-		    (void *) mcpair);
+		rf_DispatchDAG(wr_dag_h,
+		    (void (*) (void *)) rf_MCPairWakeupFunc, (void *) mcpair);
 		while (!mcpair->flag)
 			RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 		RF_UNLOCK_MUTEX(mcpair->mutex);
 		if (wr_dag_h->status != rf_enable) {
-			RF_ERRORMSG("Unable to correct second redundant information in VerifyParity:  can't write the stripe\n");
+			RF_ERRORMSG("Unable to correct second redundant"
+			    " information in VerifyParity: can't write the"
+			    " stripe\n");
 			red2_cant_correct = RF_TRUE;
 		} else {
 			red2_corrected = RF_TRUE;
@@ -553,4 +671,4 @@ out:
 	rf_FreeMCPair(mcpair);
 	return (retcode);
 }
-#endif				/* RF_INCLUDE_EVENODD > 0 */
+#endif	/* RF_INCLUDE_EVENODD > 0 */
diff --git a/sys/dev/raidframe/rf_evenodd.h b/sys/dev/raidframe/rf_evenodd.h
index 63b0d75c9b9..34b5fc4f664 100644
--- a/sys/dev/raidframe/rf_evenodd.h
+++ b/sys/dev/raidframe/rf_evenodd.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_evenodd.h,v 1.2 1999/02/16 00:02:44 niklas Exp $	*/
+/*	$OpenBSD: rf_evenodd.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_evenodd.h,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,29 +28,22 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_EVENODD_H_
-#define _RF__RF_EVENODD_H_
+#ifndef	_RF__RF_EVENODD_H_
+#define	_RF__RF_EVENODD_H_
 
-/* extern declerations of the failure mode  functions.  */
-int 
-rf_ConfigureEvenOdd(RF_ShutdownList_t ** shutdownListp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int     rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t * raidPtr);
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitEvenOdd(RF_Raid_t * raidPtr);
-void 
-rf_IdentifyStripeEvenOdd(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outrow);
-void 
-rf_MapParityEvenOdd(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapEEvenOdd(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_EODagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
-int 
-rf_VerifyParityEvenOdd(RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-    RF_PhysDiskAddr_t * parityPDA, int correct_it, RF_RaidAccessFlags_t flags);
+/* Extern declarations of the failure mode functions. */
+int  rf_ConfigureEvenOdd(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int  rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t *);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitEvenOdd(RF_Raid_t *);
+void rf_IdentifyStripeEvenOdd(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapParityEvenOdd(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapEEvenOdd(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_EODagSelect(RF_Raid_t *, RF_IoType_t, RF_AccessStripeMap_t *,
+	RF_VoidFuncPtr *);
+int  rf_VerifyParityEvenOdd(RF_Raid_t *, RF_RaidAddr_t, RF_PhysDiskAddr_t *,
+	int, RF_RaidAccessFlags_t);
 
-#endif				/* !_RF__RF_EVENODD_H_ */
+#endif	/* !_RF__RF_EVENODD_H_ */
diff --git a/sys/dev/raidframe/rf_evenodd_dagfuncs.c b/sys/dev/raidframe/rf_evenodd_dagfuncs.c
index 7617b8241a3..d619b1ca50e 100644
--- a/sys/dev/raidframe/rf_evenodd_dagfuncs.c
+++ b/sys/dev/raidframe/rf_evenodd_dagfuncs.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_evenodd_dagfuncs.c,v 1.6 2000/08/08 16:07:41 peter Exp $	*/
+/*	$OpenBSD: rf_evenodd_dagfuncs.c,v 1.7 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_evenodd_dagfuncs.c,v 1.6 2000/03/30 12:45:40 augustss Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,7 +29,7 @@
  */
 
 /*
- * Code for RAID-EVENODD  architecture.
+ * Code for RAID-EVENODD architecture.
  */
 
 #include "rf_types.h"
@@ -47,153 +48,199 @@
 #include "rf_evenodd.h"
 #include "rf_evenodd_dagfuncs.h"
 
-/* These redundant functions are for small write */
-RF_RedFuncs_t rf_EOSmallWritePFuncs = {rf_RegularXorFunc, "Regular Old-New P", rf_SimpleXorFunc, "Simple Old-New P"};
-RF_RedFuncs_t rf_EOSmallWriteEFuncs = {rf_RegularONEFunc, "Regular Old-New E", rf_SimpleONEFunc, "Regular Old-New E"};
-/* These redundant functions are for degraded read */
-RF_RedFuncs_t rf_eoPRecoveryFuncs = {rf_RecoveryXorFunc, "Recovery Xr", rf_RecoveryXorFunc, "Recovery Xr"};
-RF_RedFuncs_t rf_eoERecoveryFuncs = {rf_RecoveryEFunc, "Recovery E Func", rf_RecoveryEFunc, "Recovery E Func"};
-/**********************************************************************************************
- *   the following encoding node functions is used in  EO_000_CreateLargeWriteDAG
- **********************************************************************************************/
-int 
-rf_RegularPEFunc(node)
-	RF_DagNode_t *node;
+/* These redundant functions are for small write. */
+RF_RedFuncs_t rf_EOSmallWritePFuncs = {
+	rf_RegularXorFunc, "Regular Old-New P",
+	rf_SimpleXorFunc, "Simple Old-New P"
+};
+RF_RedFuncs_t rf_EOSmallWriteEFuncs = {
+	rf_RegularONEFunc, "Regular Old-New E",
+	rf_SimpleONEFunc, "Regular Old-New E"
+};
+/* These redundant functions are for degraded read. */
+RF_RedFuncs_t rf_eoPRecoveryFuncs = {
+	rf_RecoveryXorFunc, "Recovery Xr",
+	rf_RecoveryXorFunc, "Recovery Xr"
+};
+RF_RedFuncs_t rf_eoERecoveryFuncs = {
+	rf_RecoveryEFunc, "Recovery E Func",
+	rf_RecoveryEFunc, "Recovery E Func"
+};
+
+
+/*****************************************************************************
+ *   The following encoding node functions is used in
+ *   EO_000_CreateLargeWriteDAG.
+ *****************************************************************************/
+int
+rf_RegularPEFunc(RF_DagNode_t *node)
 {
 	rf_RegularESubroutine(node, node->results[1]);
-	rf_RegularXorFunc(node);/* does the wakeup here! */
+	rf_RegularXorFunc(node);	/* Do the wakeup here ! */
 #if 1
 	return (0);		/* XXX This was missing... GO */
 #endif
 }
 
 
-/************************************************************************************************
- *  For EO_001_CreateSmallWriteDAG, there are (i)RegularONEFunc() and (ii)SimpleONEFunc() to
- *  be used. The previous case is when write access at least sectors of full stripe unit.
- *  The later function is used when the write access two stripe units but with total sectors
- *  less than sectors per SU. In this case, the access of parity and 'E' are shown as disconnected
- *  areas in their stripe unit and  parity write and 'E' write are both devided into two distinct
- *  writes( totally four). This simple old-new write and regular old-new write happen as in RAID-5
- ************************************************************************************************/
-
-/* Algorithm:
-     1. Store the difference of old data and new data in the Rod buffer.
-     2. then encode this buffer into the buffer which already have old 'E' information inside it,
-	the result can be shown to be the new 'E' information.
-     3. xor the Wnd buffer into the difference buffer to recover the  original old data.
-   Here we have another alternative: to allocate a temporary buffer for storing the difference of
-   old data and new data, then encode temp buf into old 'E' buf to form new 'E', but this approach
-   take the same speed as the previous, and need more memory.
-*/
-int 
-rf_RegularONEFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ *  For EO_001_CreateSmallWriteDAG, there are (i) RegularONEFunc() and
+ *  (ii) SimpleONEFunc() to be used. The previous case is when write accesses
+ *  at least sectors of full stripe unit.
+ *  The later function is used when the write accesses two stripe units but
+ *  with total sectors less than sectors per SU. In this case, the access of
+ *  parity and 'E' are shown as disconnected areas in their stripe unit and
+ *  parity write and 'E' write are both divided into two distinct writes
+ *  (totally four). This simple old-new write and regular old-new write happen
+ *  as in RAID-5.
+ *****************************************************************************/
+
+/*
+ * Algorithm:
+ *   1. Store the difference of old data and new data in the Rod buffer.
+ *   2. Then encode this buffer into the buffer that already have old 'E'
+ *	information inside it, the result can be shown to be the new 'E'
+ *	information.
+ *   3. Xor the Wnd buffer into the difference buffer to recover the original
+ *	old data.
+ * Here we have another alternative: to allocate a temporary buffer for
+ * storing the difference of old data and new data, then encode temp buf
+ * into old 'E' buf to form new 'E', but this approach takes the same speed
+ * as the previous, and needs more memory.
+ */
+int
+rf_RegularONEFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
-	int     EpdaIndex = (node->numParams - 1) / 2 - 1;	/* the parameter of node
-								 * where you can find
-								 * e-pda */
-	int     i, k, retcode = 0;
-	int     suoffset, length;
+	int EpdaIndex = (node->numParams - 1) / 2 - 1;	/*
+							 * The parameter of node
+							 * where you can find
+							 * e-pda.
+							 */
+	int i, k, retcode = 0;
+	int suoffset, length;
 	RF_RowCol_t scol;
-	char   *srcbuf, *destbuf;
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	RF_PhysDiskAddr_t *pda, *EPDA = (RF_PhysDiskAddr_t *) node->params[EpdaIndex].p;
-	int     ESUOffset = rf_StripeUnitOffset(layoutPtr, EPDA->startSector);	/* generally zero  */
+	RF_PhysDiskAddr_t *pda, *EPDA = (RF_PhysDiskAddr_t *)
+	    node->params[EpdaIndex].p;
+	/* Generally zero. */
+	int ESUOffset = rf_StripeUnitOffset(layoutPtr, EPDA->startSector);
 
 	RF_ASSERT(EPDA->type == RF_PDA_TYPE_Q);
 	RF_ASSERT(ESUOffset == 0);
 
 	RF_ETIMER_START(timer);
 
-	/* Xor the Wnd buffer into Rod buffer, the difference of old data and
-	 * new data is stored in Rod buffer */
+	/*
+	 * Xor the Wnd buffer into Rod buffer. The difference of old data and
+	 * new data is stored in Rod buffer.
+	 */
 	for (k = 0; k < EpdaIndex; k += 2) {
-		length = rf_RaidAddressToByte(raidPtr, ((RF_PhysDiskAddr_t *) node->params[k].p)->numSector);
-		retcode = rf_bxor(node->params[k + EpdaIndex + 3].p, node->params[k + 1].p, length, node->dagHdr->bp);
+		length = rf_RaidAddressToByte(raidPtr,
+		    ((RF_PhysDiskAddr_t *) node->params[k].p)->numSector);
+		retcode = rf_bxor(node->params[k + EpdaIndex + 3].p,
+		    node->params[k + 1].p, length, node->dagHdr->bp);
 	}
-	/* Start to encoding the buffer storing the difference of old data and
-	 * new data into 'E' buffer  */
+	/*
+	 * Start to encode the buffer, storing the difference of old data and
+	 * new data into 'E' buffer.
+	 */
 	for (i = 0; i < EpdaIndex; i += 2)
-		if (node->params[i + 1].p != node->results[0]) {	/* results[0] is buf ptr
-									 * of E */
+		if (node->params[i + 1].p != node->results[0]) {
+			/* results[0] is buf ptr of E. */
 			pda = (RF_PhysDiskAddr_t *) node->params[i].p;
 			srcbuf = (char *) node->params[i + 1].p;
 			scol = rf_EUCol(layoutPtr, pda->raidAddress);
-			suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-			destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr, suoffset);
-			rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
+			suoffset = rf_StripeUnitOffset(layoutPtr,
+			    pda->startSector);
+			destbuf = ((char *) node->results[0]) +
+			    rf_RaidAddressToByte(raidPtr, suoffset);
+			rf_e_encToBuf(raidPtr, scol, srcbuf,
+			    RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
 		}
-	/* Recover the original old data to be used by parity encoding
-	 * function in XorNode */
+	/*
+	 * Recover the original old data to be used by parity encoding
+	 * function in XorNode.
+	 */
 	for (k = 0; k < EpdaIndex; k += 2) {
-		length = rf_RaidAddressToByte(raidPtr, ((RF_PhysDiskAddr_t *) node->params[k].p)->numSector);
-		retcode = rf_bxor(node->params[k + EpdaIndex + 3].p, node->params[k + 1].p, length, node->dagHdr->bp);
+		length = rf_RaidAddressToByte(raidPtr,
+		    ((RF_PhysDiskAddr_t *) node->params[k].p)->numSector);
+		retcode = rf_bxor(node->params[k + EpdaIndex + 3].p,
+		    node->params[k + 1].p, length, node->dagHdr->bp);
 	}
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->q_us += RF_ETIMER_VAL_US(timer);
 	rf_GenericWakeupFunc(node, 0);
 #if 1
-	return (0);		/* XXX this was missing.. GO */
+	return (0);		/* XXX This was missing... GO */
 #endif
 }
 
-int 
-rf_SimpleONEFunc(node)
-	RF_DagNode_t *node;
+int
+rf_SimpleONEFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
 	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	int     retcode = 0;
-	char   *srcbuf, *destbuf;
+	int retcode = 0;
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	int     length;
+	int length;
 	RF_RowCol_t scol;
 	RF_Etimer_t timer;
 
-	RF_ASSERT(((RF_PhysDiskAddr_t *) node->params[2].p)->type == RF_PDA_TYPE_Q);
+	RF_ASSERT(((RF_PhysDiskAddr_t *) node->params[2].p)->type ==
+	    RF_PDA_TYPE_Q);
 	if (node->dagHdr->status == rf_enable) {
 		RF_ETIMER_START(timer);
-		length = rf_RaidAddressToByte(raidPtr, ((RF_PhysDiskAddr_t *) node->params[4].p)->numSector);	/* this is a pda of
-														 * writeDataNodes */
-		/* bxor to buffer of readDataNodes */
-		retcode = rf_bxor(node->params[5].p, node->params[1].p, length, node->dagHdr->bp);
-		/* find out the corresponding colume in encoding matrix for
-		 * write colume to be encoded into redundant disk 'E' */
+		/* This is a pda of writeDataNodes. */
+		length = rf_RaidAddressToByte(raidPtr,
+		    ((RF_PhysDiskAddr_t *) node->params[4].p)->numSector);
+		/* bxor to buffer of readDataNodes. */
+		retcode = rf_bxor(node->params[5].p, node->params[1].p,
+		    length, node->dagHdr->bp);
+		/*
+		 * Find out the corresponding column in encoding matrix for
+		 * write column to be encoded into redundant disk 'E'.
+		 */
 		scol = rf_EUCol(layoutPtr, pda->raidAddress);
 		srcbuf = node->params[1].p;
 		destbuf = node->params[3].p;
-		/* Start encoding process */
-		rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
-		rf_bxor(node->params[5].p, node->params[1].p, length, node->dagHdr->bp);
+		/* Start encoding process. */
+		rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2,
+		    destbuf, pda->numSector);
+		rf_bxor(node->params[5].p, node->params[1].p, length,
+		    node->dagHdr->bp);
 		RF_ETIMER_STOP(timer);
 		RF_ETIMER_EVAL(timer);
 		tracerec->q_us += RF_ETIMER_VAL_US(timer);
 
 	}
-	return (rf_GenericWakeupFunc(node, retcode));	/* call wake func
+	return (rf_GenericWakeupFunc(node, retcode));	/*
+							 * Call wake func
 							 * explicitly since no
-							 * I/O in this node */
+							 * I/O in this node.
+							 */
 }
 
 
-/****** called by rf_RegularPEFunc(node) and rf_RegularEFunc(node) in f.f. large write  ********/
-void 
-rf_RegularESubroutine(node, ebuf)
-	RF_DagNode_t *node;
-	char   *ebuf;
+/*
+ * Called by rf_RegularPEFunc(node) and rf_RegularEFunc(node)
+ * in f.f. large write.
+ */
+void
+rf_RegularESubroutine(RF_DagNode_t *node, char *ebuf)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
 	RF_PhysDiskAddr_t *pda;
-	int     i, suoffset;
+	int i, suoffset;
 	RF_RowCol_t scol;
-	char   *srcbuf, *destbuf;
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
 
@@ -205,7 +252,8 @@ rf_RegularESubroutine(node, ebuf)
 		scol = rf_EUCol(layoutPtr, pda->raidAddress);
 		srcbuf = (char *) node->params[i + 1].p;
 		destbuf = ebuf + rf_RaidAddressToByte(raidPtr, suoffset);
-		rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
+		rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2,
+		    destbuf, pda->numSector);
 	}
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
@@ -213,44 +261,43 @@ rf_RegularESubroutine(node, ebuf)
 }
 
 
-/*******************************************************************************************
- *			 Used in  EO_001_CreateLargeWriteDAG
- ******************************************************************************************/
-int 
-rf_RegularEFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ *			 Used in  EO_001_CreateLargeWriteDAG.
+ *****************************************************************************/
+int
+rf_RegularEFunc(RF_DagNode_t *node)
 {
 	rf_RegularESubroutine(node, node->results[0]);
 	rf_GenericWakeupFunc(node, 0);
 #if 1
-	return (0);		/* XXX this was missing?.. GO */
+	return (0);		/* XXX This was missing... GO */
 #endif
 }
-/*******************************************************************************************
- * This degraded function allow only two case:
- *  1. when write access the full failed stripe unit, then the access can be more than
- *     one tripe units.
- *  2. when write access only part of the failed SU, we assume accesses of more than
- *     one stripe unit is not allowed so that the write can be dealt with like a
- *     large write.
- *  The following function is based on these assumptions. So except in the second case,
- *  it looks the same as a large write encodeing function. But this is not exactly the
- *  normal way for doing a degraded write, since raidframe have to break cases of access
- *  other than the above two into smaller accesses. We may have to change
- *  DegrESubroutin in the future.
- *******************************************************************************************/
-void 
-rf_DegrESubroutine(node, ebuf)
-	RF_DagNode_t *node;
-	char   *ebuf;
+
+
+/*****************************************************************************
+ * This degraded function allow only two cases:
+ *   1. When write accesses the full failed stripe unit, then the access can
+ *	be more than one stripe unit.
+ *   2. When write accesses only part of the failed SU, we assume accesses of
+ *	more than one stripe unit are not allowed so that the write can be
+ *	dealt with like a large write.
+ * The following function is based on these assumptions. So except in the
+ * second case, it looks the same as a large write encoding function. But
+ * this is not exactly the normal way of doing a degraded write, since
+ * RAIDframe has to break cases of accesses other than the above two into
+ * smaller accesses. We may have to change DegrESubroutin in the future.
+ *****************************************************************************/
+void
+rf_DegrESubroutine(RF_DagNode_t *node, char *ebuf)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
 	RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
 	RF_PhysDiskAddr_t *pda;
-	int     i, suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
+	int i, suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
 	RF_RowCol_t scol;
-	char   *srcbuf, *destbuf;
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
 
@@ -271,90 +318,94 @@ rf_DegrESubroutine(node, ebuf)
 }
 
 
-/**************************************************************************************
- * This function is used in case where one data disk failed and both redundant disks
- * alive. It is used in the EO_100_CreateWriteDAG. Note: if there is another disk
- * failed in the stripe but not accessed at this time, then we should, instead, use
- * the rf_EOWriteDoubleRecoveryFunc().
- **************************************************************************************/
-int 
-rf_Degraded_100_EOFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ * This function is used in case where one data disk failed and both redundant
+ * disks are alive. It is used in the EO_100_CreateWriteDAG. Note: if there is
+ * another disk failed in the stripe but not accessed at this time, then we
+ * should, instead, use the rf_EOWriteDoubleRecoveryFunc().
+ *****************************************************************************/
+int
+rf_Degraded_100_EOFunc(RF_DagNode_t *node)
 {
 	rf_DegrESubroutine(node, node->results[1]);
-	rf_RecoveryXorFunc(node);	/* does the wakeup here! */
+	rf_RecoveryXorFunc(node);	/* Does the wakeup here ! */
 #if 1
-	return (0);		/* XXX this was missing... SHould these be
-				 * void functions??? GO */
+	return (0);		/* XXX This was missing... Should these be
+				 * void functions ??? GO */
 #endif
 }
-/**************************************************************************************
- * This function is to encode one sector in one of the data disks to the E disk.
- * However, in evenodd this function can also be used as decoding function to recover
- * data from dead disk in the case of parity failure and a single data failure.
- **************************************************************************************/
-void 
-rf_e_EncOneSect(
-    RF_RowCol_t srcLogicCol,
-    char *srcSecbuf,
-    RF_RowCol_t destLogicCol,
-    char *destSecbuf,
-    int bytesPerSector)
+
+
+/*****************************************************************************
+ * This function is to encode one sector in one of the data disks to the E
+ * disk. However, in evenodd this function can also be used as decoding
+ * function to recover data from dead disk in the case of parity failure and
+ * a single data failure.
+ *****************************************************************************/
+void
+rf_e_EncOneSect(RF_RowCol_t srcLogicCol, char *srcSecbuf,
+    RF_RowCol_t destLogicCol, char *destSecbuf, int bytesPerSector)
 {
-	int     S_index;	/* index of the EU in the src col which need
-				 * be Xored into all EUs in a dest sector */
-	int     numRowInEncMatix = (RF_EO_MATRIX_DIM) - 1;
-	RF_RowCol_t j, indexInDest,	/* row index of an encoding unit in
-					 * the destination colume of encoding
-					 * matrix */
-	        indexInSrc;	/* row index of an encoding unit in the source
-				 * colume used for recovery */
-	int     bytesPerEU = bytesPerSector / numRowInEncMatix;
-
-#if RF_EO_MATRIX_DIM > 17
-	int     shortsPerEU = bytesPerEU / sizeof(short);
+	int S_index;		/*
+				 * Index of the EU in the src col which need
+				 * be Xored into all EUs in a dest sector.
+				 */
+	int numRowInEncMatrix = (RF_EO_MATRIX_DIM) - 1;
+	RF_RowCol_t j, indexInDest;	/*
+					 * Row index of an encoding unit in
+					 * the destination column of encoding
+					 * matrix.
+					 */
+	RF_RowCol_t indexInSrc;	/*
+				 * Row index of an encoding unit in the source
+				 * column used for recovery.
+				 */
+	int bytesPerEU = bytesPerSector / numRowInEncMatrix;
+
+#if	RF_EO_MATRIX_DIM > 17
+	int shortsPerEU = bytesPerEU / sizeof(short);
 	short  *destShortBuf, *srcShortBuf1, *srcShortBuf2;
 	short temp1;
-#elif RF_EO_MATRIX_DIM == 17
-	int     longsPerEU = bytesPerEU / sizeof(long);
-	long   *destLongBuf, *srcLongBuf1, *srcLongBuf2;
+#elif	RF_EO_MATRIX_DIM == 17
+	int longsPerEU = bytesPerEU / sizeof(long);
+	long *destLongBuf, *srcLongBuf1, *srcLongBuf2;
 	long temp1;
 #endif
 
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 	RF_ASSERT(sizeof(short) == 2 || sizeof(short) == 1);
 	RF_ASSERT(bytesPerEU % sizeof(short) == 0);
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 	RF_ASSERT(sizeof(long) == 8 || sizeof(long) == 4);
 	RF_ASSERT(bytesPerEU % sizeof(long) == 0);
 #endif
 
 	S_index = rf_EO_Mod((RF_EO_MATRIX_DIM - 1 + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM);
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 	srcShortBuf1 = (short *) (srcSecbuf + S_index * bytesPerEU);
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 	srcLongBuf1 = (long *) (srcSecbuf + S_index * bytesPerEU);
 #endif
 
-	for (indexInDest = 0; indexInDest < numRowInEncMatix; indexInDest++) {
+	for (indexInDest = 0; indexInDest < numRowInEncMatrix; indexInDest++) {
 		indexInSrc = rf_EO_Mod((indexInDest + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM);
 
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 		destShortBuf = (short *) (destSecbuf + indexInDest * bytesPerEU);
 		srcShortBuf2 = (short *) (srcSecbuf + indexInSrc * bytesPerEU);
 		for (j = 0; j < shortsPerEU; j++) {
 			temp1 = destShortBuf[j] ^ srcShortBuf1[j];
-			/* note: S_index won't be at the end row for any src
-			 * col! */
+			/* Note: S_index won't be at the end row for any src
+			 * col ! */
 			if (indexInSrc != RF_EO_MATRIX_DIM - 1)
 				destShortBuf[j] = (srcShortBuf2[j]) ^ temp1;
 			/* if indexInSrc is at the end row, ie.
-			 * RF_EO_MATRIX_DIM -1, then all elements are zero! */
+			 * RF_EO_MATRIX_DIM -1, then all elements are zero ! */
 			else
 				destShortBuf[j] = temp1;
 		}
 
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 		destLongBuf = (long *) (destSecbuf + indexInDest * bytesPerEU);
 		srcLongBuf2 = (long *) (srcSecbuf + indexInSrc * bytesPerEU);
 		for (j = 0; j < longsPerEU; j++) {
@@ -368,16 +419,11 @@ rf_e_EncOneSect(
 	}
 }
 
-void 
-rf_e_encToBuf(
-    RF_Raid_t * raidPtr,
-    RF_RowCol_t srcLogicCol,
-    char *srcbuf,
-    RF_RowCol_t destLogicCol,
-    char *destbuf,
-    int numSector)
+void
+rf_e_encToBuf(RF_Raid_t *raidPtr, RF_RowCol_t srcLogicCol, char *srcbuf,
+    RF_RowCol_t destLogicCol, char *destbuf, int numSector)
 {
-	int     i, bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
+	int i, bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
 
 	for (i = 0; i < numSector; i++) {
 		rf_e_EncOneSect(srcLogicCol, srcbuf, destLogicCol, destbuf, bytesPerSector);
@@ -385,25 +431,26 @@ rf_e_encToBuf(
 		destbuf += bytesPerSector;
 	}
 }
-/**************************************************************************************
+
+
+/*****************************************************************************
  * when parity die and one data die, We use second redundant information, 'E',
  * to recover the data in dead disk. This function is used in the recovery node of
  * for EO_110_CreateReadDAG
- **************************************************************************************/
-int 
-rf_RecoveryEFunc(node)
-	RF_DagNode_t *node;
+ *****************************************************************************/
+int
+rf_RecoveryEFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
 	RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
-	RF_RowCol_t scol,	/* source logical column */
-	        fcol = rf_EUCol(layoutPtr, failedPDA->raidAddress);	/* logical column of
+	RF_RowCol_t scol;	/* source logical column */
+	RF_RowCol_t fcol = rf_EUCol(layoutPtr, failedPDA->raidAddress);	/* logical column of
 									 * failed SU */
-	int     i;
+	int i;
 	RF_PhysDiskAddr_t *pda;
-	int     suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
-	char   *srcbuf, *destbuf;
+	int suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
 
@@ -429,62 +476,61 @@ rf_RecoveryEFunc(node)
 	}
 	return (rf_GenericWakeupFunc(node, 0));	/* node execute successfully */
 }
-/**************************************************************************************
+
+
+/*****************************************************************************
  * This function is used in the case where one data and the parity have filed.
- * (in EO_110_CreateWriteDAG )
- **************************************************************************************/
-int 
-rf_EO_DegradedWriteEFunc(RF_DagNode_t * node)
+ * (in EO_110_CreateWriteDAG)
+ *****************************************************************************/
+int
+rf_EO_DegradedWriteEFunc(RF_DagNode_t *node)
 {
 	rf_DegrESubroutine(node, node->results[0]);
 	rf_GenericWakeupFunc(node, 0);
 #if 1
-	return (0);		/* XXX Yet another one!! GO */
+	return (0);		/* XXX Yet another one !!! GO */
 #endif
 }
 
 
 
-/**************************************************************************************
- *  		THE FUNCTION IS FOR DOUBLE DEGRADED READ AND WRITE CASES
- **************************************************************************************/
+/*****************************************************************************
+ *	THE FUNCTION IS FOR DOUBLE DEGRADED READ AND WRITE CASES.
+ *****************************************************************************/
 
-void 
-rf_doubleEOdecode(
-    RF_Raid_t * raidPtr,
-    char **rrdbuf,
-    char **dest,
-    RF_RowCol_t * fcol,
-    char *pbuf,
-    char *ebuf)
+void
+rf_doubleEOdecode(RF_Raid_t *raidPtr, char **rrdbuf, char **dest,
+    RF_RowCol_t *fcol, char *pbuf, char *ebuf)
 {
-	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
-	int     i, j, k, f1, f2, row;
-	int     rrdrow, erow, count = 0;
-	int     bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
-	int     numRowInEncMatix = (RF_EO_MATRIX_DIM) - 1;
+	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
+	int i, j, k, f1, f2, row;
+	int rrdrow, erow, count = 0;
+	int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
+	int numRowInEncMatrix = (RF_EO_MATRIX_DIM) - 1;
 #if 0
-	int     pcol = (RF_EO_MATRIX_DIM) - 1;
+	int pcol = (RF_EO_MATRIX_DIM) - 1;
 #endif
-	int     ecol = (RF_EO_MATRIX_DIM) - 2;
-	int     bytesPerEU = bytesPerSector / numRowInEncMatix;
-	int     numDataCol = layoutPtr->numDataCol;
-#if RF_EO_MATRIX_DIM > 17
-	int     shortsPerEU = bytesPerEU / sizeof(short);
-	short  *rrdbuf_current, *pbuf_current, *ebuf_current;
-	short  *dest_smaller, *dest_smaller_current, *dest_larger, *dest_larger_current;
+	int ecol = (RF_EO_MATRIX_DIM) - 2;
+	int bytesPerEU = bytesPerSector / numRowInEncMatrix;
+	int numDataCol = layoutPtr->numDataCol;
+#if	RF_EO_MATRIX_DIM > 17
+	int shortsPerEU = bytesPerEU / sizeof(short);
+	short *rrdbuf_current, *pbuf_current, *ebuf_current;
+	short *dest_smaller, *dest_smaller_current;
+	short *dest_larger, *dest_larger_current;
 	short *temp;
-	short  *P;
+	short *P;
 
 	RF_ASSERT(bytesPerEU % sizeof(short) == 0);
 	RF_Malloc(P, bytesPerEU, (short *));
 	RF_Malloc(temp, bytesPerEU, (short *));
-#elif RF_EO_MATRIX_DIM == 17
-	int     longsPerEU = bytesPerEU / sizeof(long);
-	long   *rrdbuf_current, *pbuf_current, *ebuf_current;
-	long   *dest_smaller, *dest_smaller_current, *dest_larger, *dest_larger_current;
+#elif	RF_EO_MATRIX_DIM == 17
+	int longsPerEU = bytesPerEU / sizeof(long);
+	long *rrdbuf_current, *pbuf_current, *ebuf_current;
+	long *dest_smaller, *dest_smaller_current;
+	long *dest_larger, *dest_larger_current;
 	long *temp;
-	long   *P;
+	long *P;
 
 	RF_ASSERT(bytesPerEU % sizeof(long) == 0);
 	RF_Malloc(P, bytesPerEU, (long *));
@@ -495,15 +541,17 @@ rf_doubleEOdecode(
 	bzero((char *) P, bytesPerEU);
 	bzero((char *) temp, bytesPerEU);
 	RF_ASSERT(*P == 0);
-	/* calculate the 'P' parameter, which, not parity, is the Xor of all
-	 * elements in the last two column, ie. 'E' and 'parity' colume, see
-	 * the Ref. paper by Blaum, et al 1993  */
-	for (i = 0; i < numRowInEncMatix; i++)
+	/*
+	 * Calculate the 'P' parameter, which, not parity, is the Xor of all
+	 * elements in the last two column, ie. 'E' and 'parity' columns, see
+	 * the Ref. paper by Blaum, et al 1993.
+	 */
+	for (i = 0; i < numRowInEncMatrix; i++)
 		for (k = 0; k < longsPerEU; k++) {
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 			ebuf_current = ((short *) ebuf) + i * shortsPerEU + k;
 			pbuf_current = ((short *) pbuf) + i * shortsPerEU + k;
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 			ebuf_current = ((long *) ebuf) + i * longsPerEU + k;
 			pbuf_current = ((long *) pbuf) + i * longsPerEU + k;
 #endif
@@ -512,20 +560,20 @@ rf_doubleEOdecode(
 		}
 	RF_ASSERT(fcol[0] != fcol[1]);
 	if (fcol[0] < fcol[1]) {
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 		dest_smaller = (short *) (dest[0]);
 		dest_larger = (short *) (dest[1]);
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 		dest_smaller = (long *) (dest[0]);
 		dest_larger = (long *) (dest[1]);
 #endif
 		f1 = fcol[0];
 		f2 = fcol[1];
 	} else {
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 		dest_smaller = (short *) (dest[1]);
 		dest_larger = (short *) (dest[0]);
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 		dest_smaller = (long *) (dest[1]);
 		dest_larger = (long *) (dest[0]);
 #endif
@@ -533,93 +581,107 @@ rf_doubleEOdecode(
 		f2 = fcol[0];
 	}
 	row = (RF_EO_MATRIX_DIM) - 1;
-	while ((row = rf_EO_Mod((row + f1 - f2), RF_EO_MATRIX_DIM)) != ((RF_EO_MATRIX_DIM) - 1)) {
-#if RF_EO_MATRIX_DIM > 17
+	while ((row = rf_EO_Mod((row + f1 - f2), RF_EO_MATRIX_DIM)) !=
+	    ((RF_EO_MATRIX_DIM) - 1)) {
+#if	RF_EO_MATRIX_DIM > 17
 		dest_larger_current = dest_larger + row * shortsPerEU;
 		dest_smaller_current = dest_smaller + row * shortsPerEU;
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 		dest_larger_current = dest_larger + row * longsPerEU;
 		dest_smaller_current = dest_smaller + row * longsPerEU;
 #endif
-		/**    Do the diagonal recovery. Initially, temp[k] = (failed 1),
-		       which is the failed data in the colume which has smaller col index. **/
-		/* step 1:  ^(SUM of nonfailed in-diagonal A(rrdrow,0..m-3))         */
+		/*
+		 * Do the diagonal recovery. Initially, temp[k] = (failed 1),
+		 * which is the failed data in the column that has smaller
+		 * col index.
+		 */
+		/* Step 1:  ^(SUM of nonfailed in-diagonal A(rrdrow,0..m-3)) */
 		for (j = 0; j < numDataCol; j++) {
 			if (j == f1 || j == f2)
 				continue;
 			rrdrow = rf_EO_Mod((row + f2 - j), RF_EO_MATRIX_DIM);
 			if (rrdrow != (RF_EO_MATRIX_DIM) - 1) {
-#if RF_EO_MATRIX_DIM > 17
-				rrdbuf_current = (short *) (rrdbuf[j]) + rrdrow * shortsPerEU;
+#if	RF_EO_MATRIX_DIM > 17
+				rrdbuf_current = (short *) (rrdbuf[j]) +
+				    rrdrow * shortsPerEU;
 				for (k = 0; k < shortsPerEU; k++)
 					temp[k] ^= *(rrdbuf_current + k);
-#elif RF_EO_MATRIX_DIM == 17
-				rrdbuf_current = (long *) (rrdbuf[j]) + rrdrow * longsPerEU;
+#elif	RF_EO_MATRIX_DIM == 17
+				rrdbuf_current = (long *) (rrdbuf[j]) +
+				    rrdrow * longsPerEU;
 				for (k = 0; k < longsPerEU; k++)
 					temp[k] ^= *(rrdbuf_current + k);
 #endif
 			}
 		}
-		/* step 2:  ^E(erow,m-2), If erow is at the buttom row, don't
-		 * Xor into it  E(erow,m-2) = (principle diagonal) ^ (failed
-		 * 1) ^ (failed 2) ^ ( SUM of nonfailed in-diagonal
-		 * A(rrdrow,0..m-3) ) After this step, temp[k] = (principle
-		 * diagonal) ^ (failed 2)       */
+		/*
+		 * Step 2:  ^E(erow,m-2), If erow is at the bottom row, don't
+		 * Xor into it.  E(erow,m-2) = (principle diagonal) ^ (failed
+		 * 1) ^ (failed 2) ^ (SUM of nonfailed in-diagonal
+		 * A(rrdrow,0..m-3))
+		 * After this step, temp[k] = (principle diagonal) ^ (failed 2).
+		 */
 
 		erow = rf_EO_Mod((row + f2 - ecol), (RF_EO_MATRIX_DIM));
 		if (erow != (RF_EO_MATRIX_DIM) - 1) {
-#if RF_EO_MATRIX_DIM > 17
+#if	RF_EO_MATRIX_DIM > 17
 			ebuf_current = (short *) ebuf + shortsPerEU * erow;
 			for (k = 0; k < shortsPerEU; k++)
 				temp[k] ^= *(ebuf_current + k);
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 			ebuf_current = (long *) ebuf + longsPerEU * erow;
 			for (k = 0; k < longsPerEU; k++)
 				temp[k] ^= *(ebuf_current + k);
 #endif
 		}
-		/* step 3: ^P to obtain the failed data (failed 2).  P can be
-		 * proved to be actually  (principle diagonal)  After this
-		 * step, temp[k] = (failed 2), the failed data to be recovered */
-#if RF_EO_MATRIX_DIM > 17
+		/*
+		 * Step 3: ^P to obtain the failed data (failed 2). P can be
+		 * proved to be actually (principal diagonal). After this
+		 * step, temp[k] = (failed 2), the failed data to be recovered.
+		 */
+#if	RF_EO_MATRIX_DIM > 17
 		for (k = 0; k < shortsPerEU; k++)
 			temp[k] ^= P[k];
-		/* Put the data to the destination buffer                              */
+		/* Put the data into the destination buffer. */
 		for (k = 0; k < shortsPerEU; k++)
 			dest_larger_current[k] = temp[k];
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 		for (k = 0; k < longsPerEU; k++)
 			temp[k] ^= P[k];
-		/* Put the data to the destination buffer                              */
+		/* Put the data into the destination buffer. */
 		for (k = 0; k < longsPerEU; k++)
 			dest_larger_current[k] = temp[k];
 #endif
 
-		/**          THE FOLLOWING DO THE HORIZONTAL XOR                **/
-		/* step 1:  ^(SUM of A(row,0..m-3)), ie. all nonfailed data
-		 * columes    */
+		/* THE FOLLOWING DO THE HORIZONTAL XOR. */
+		/*
+		 * Step 1:  ^(SUM of A(row,0..m-3)), ie. all nonfailed data
+		 * columns.
+		 */
 		for (j = 0; j < numDataCol; j++) {
 			if (j == f1 || j == f2)
 				continue;
-#if RF_EO_MATRIX_DIM > 17
-			rrdbuf_current = (short *) (rrdbuf[j]) + row * shortsPerEU;
+#if	RF_EO_MATRIX_DIM > 17
+			rrdbuf_current = (short *) (rrdbuf[j]) +
+			    row * shortsPerEU;
 			for (k = 0; k < shortsPerEU; k++)
 				temp[k] ^= *(rrdbuf_current + k);
-#elif RF_EO_MATRIX_DIM == 17
-			rrdbuf_current = (long *) (rrdbuf[j]) + row * longsPerEU;
+#elif	RF_EO_MATRIX_DIM == 17
+			rrdbuf_current = (long *) (rrdbuf[j]) +
+			    row * longsPerEU;
 			for (k = 0; k < longsPerEU; k++)
 				temp[k] ^= *(rrdbuf_current + k);
 #endif
 		}
-		/* step 2: ^A(row,m-1) */
-		/* step 3: Put the data to the destination buffer                             	 */
-#if RF_EO_MATRIX_DIM > 17
+		/* Step 2: ^A(row,m-1) */
+		/* Step 3: Put the data into the destination buffer. */
+#if	RF_EO_MATRIX_DIM > 17
 		pbuf_current = (short *) pbuf + shortsPerEU * row;
 		for (k = 0; k < shortsPerEU; k++)
 			temp[k] ^= *(pbuf_current + k);
 		for (k = 0; k < shortsPerEU; k++)
 			dest_smaller_current[k] = temp[k];
-#elif RF_EO_MATRIX_DIM == 17
+#elif	RF_EO_MATRIX_DIM == 17
 		pbuf_current = (long *) pbuf + longsPerEU * row;
 		for (k = 0; k < longsPerEU; k++)
 			temp[k] ^= *(pbuf_current + k);
@@ -628,50 +690,56 @@ rf_doubleEOdecode(
 #endif
 		count++;
 	}
-	/* Check if all Encoding Unit in the data buffer have been decoded,
-	 * according EvenOdd theory, if "RF_EO_MATRIX_DIM" is a prime number,
-	 * this algorithm will covered all buffer 				 */
-	RF_ASSERT(count == numRowInEncMatix);
+	/*
+	 * Check if all Encoding Unit in the data buffer have been decoded ?
+	 * According to EvenOdd theory, if "RF_EO_MATRIX_DIM" is a prime
+	 * number, this algorithm will covered all buffer.
+	 */
+	RF_ASSERT(count == numRowInEncMatrix);
 	RF_Free((char *) P, bytesPerEU);
 	RF_Free((char *) temp, bytesPerEU);
 }
 
 
-/***************************************************************************************
-* 	This function is called by double degragded read
-* 	EO_200_CreateReadDAG
-*
-***************************************************************************************/
-int 
-rf_EvenOddDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
+/*****************************************************************************
+ *	This function is called by double degraded read EO_200_CreateReadDAG.
+ *****************************************************************************/
+int
+rf_EvenOddDoubleRecoveryFunc(RF_DagNode_t *node)
 {
-	int     ndataParam = 0;
-	int     np = node->numParams;
-	RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *) node->params[np - 1].p;
+	int ndataParam = 0;
+	int np = node->numParams;
+	RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *)
+	    node->params[np - 1].p;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
-	int     i, prm, sector, nresults = node->numResults;
+	int i, prm, sector, nresults = node->numResults;
 	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
 	unsigned sosAddr;
-	int     two = 0, mallc_one = 0, mallc_two = 0;	/* flags to indicate if
-							 * memory is allocated */
-	int     bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
+	int two = 0, mallc_one = 0, mallc_two = 0;	/*
+							 * Flags to indicate if
+							 * memory is allocated.
+							 */
+	int bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
 	RF_PhysDiskAddr_t *ppda, *ppda2, *epda, *epda2, *pda, *pda0, *pda1,
-	        npda;
-	RF_RowCol_t fcol[2], fsuoff[2], fsuend[2], numDataCol = layoutPtr->numDataCol;
-	char  **buf, *ebuf, *pbuf, *dest[2];
-	long   *suoff = NULL, *suend = NULL, *prmToCol = NULL, psuoff, esuoff;
+	    npda;
+	RF_RowCol_t fcol[2], fsuoff[2], fsuend[2],
+	    numDataCol = layoutPtr->numDataCol;
+	char **buf, *ebuf, *pbuf, *dest[2];
+	long *suoff = NULL, *suend = NULL, *prmToCol = NULL, psuoff, esuoff;
 	RF_SectorNum_t startSector, endSector;
 	RF_Etimer_t timer;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 
 	RF_ETIMER_START(timer);
 
-	/* Find out the number of parameters which are pdas for data
-	 * information */
+	/*
+	 * Find out the number of parameters that are pdas for data
+	 * information.
+	 */
 	for (i = 0; i <= np; i++)
-		if (((RF_PhysDiskAddr_t *) node->params[i].p)->type != RF_PDA_TYPE_DATA) {
+		if (((RF_PhysDiskAddr_t *) node->params[i].p)->type !=
+		    RF_PDA_TYPE_DATA) {
 			ndataParam = i;
 			break;
 		}
@@ -682,8 +750,9 @@ rf_EvenOddDoubleRecoveryFunc(node)
 		RF_Malloc(prmToCol, ndataParam * sizeof(long), (long *));
 	}
 	if (asmap->failedPDAs[1] &&
-	    (asmap->failedPDAs[1]->numSector + asmap->failedPDAs[0]->numSector < secPerSU)) {
-		RF_ASSERT(0);	/* currently, no support for this situation */
+	    (asmap->failedPDAs[1]->numSector +
+	     asmap->failedPDAs[0]->numSector) < secPerSU) {
+		RF_ASSERT(0);	/* Currently, no support for this situation. */
 		ppda = node->params[np - 6].p;
 		ppda2 = node->params[np - 5].p;
 		RF_ASSERT(ppda2->type == RF_PDA_TYPE_PARITY);
@@ -699,13 +768,15 @@ rf_EvenOddDoubleRecoveryFunc(node)
 		RF_ASSERT(psuoff == esuoff);
 	}
 	/*
-            the followings have three goals:
-            1. determine the startSector to begin decoding and endSector to end decoding.
-            2. determine the colume numbers of the two failed disks.
-            3. determine the offset and end offset of the access within each failed stripe unit.
-         */
+	 * The followings have three goals:
+	 *   1. Determine the startSector to begin decoding and endSector
+	 *	to end decoding.
+	 *   2. Determine the column numbers of the two failed disks.
+	 *   3. Determine the offset and end offset of the access within
+	 *	each failed stripe unit.
+	 */
 	if (nresults == 1) {
-		/* find the startSector to begin decoding */
+		/* Find the startSector to begin decoding. */
 		pda = node->results[0];
 		bzero(pda->bufPtr, bytesPerSector * pda->numSector);
 		fsuoff[0] = rf_StripeUnitOffset(layoutPtr, pda->startSector);
@@ -713,16 +784,20 @@ rf_EvenOddDoubleRecoveryFunc(node)
 		startSector = fsuoff[0];
 		endSector = fsuend[0];
 
-		/* find out the column of failed disk being accessed */
+		/* Find out the column of failed disk being accessed. */
 		fcol[0] = rf_EUCol(layoutPtr, pda->raidAddress);
 
-		/* find out the other failed colume not accessed */
-		sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
+		/* Find out the other failed column not accessed. */
+		sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+		    asmap->raidAddress);
 		for (i = 0; i < numDataCol; i++) {
 			npda.raidAddress = sosAddr + (i * secPerSU);
-			(raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress, &(npda.row), &(npda.col), &(npda.startSector), 0);
-			/* skip over dead disks */
-			if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
+			(raidPtr->Layout.map->MapSector) (raidPtr,
+			    npda.raidAddress, &(npda.row), &(npda.col),
+			    &(npda.startSector), 0);
+			/* Skip over dead disks. */
+			if (RF_DEAD_DISK(raidPtr
+			    ->Disks[npda.row][npda.col].status))
 				if (i != fcol[0])
 					break;
 		}
@@ -734,67 +809,87 @@ rf_EvenOddDoubleRecoveryFunc(node)
 		bzero(pda0->bufPtr, bytesPerSector * pda0->numSector);
 		pda1 = node->results[1];
 		bzero(pda1->bufPtr, bytesPerSector * pda1->numSector);
-		/* determine the failed colume numbers of the two failed
-		 * disks. */
+		/*
+		 * Determine the failed column numbers of the two failed
+		 * disks.
+		 */
 		fcol[0] = rf_EUCol(layoutPtr, pda0->raidAddress);
 		fcol[1] = rf_EUCol(layoutPtr, pda1->raidAddress);
-		/* determine the offset and end offset of the access within
-		 * each failed stripe unit. */
+		/*
+		 * Determine the offset and end offset of the access within
+		 * each failed stripe unit.
+		 */
 		fsuoff[0] = rf_StripeUnitOffset(layoutPtr, pda0->startSector);
 		fsuend[0] = fsuoff[0] + pda0->numSector;
 		fsuoff[1] = rf_StripeUnitOffset(layoutPtr, pda1->startSector);
 		fsuend[1] = fsuoff[1] + pda1->numSector;
-		/* determine the startSector to begin decoding */
+		/* Determine the startSector to begin decoding. */
 		startSector = RF_MIN(pda0->startSector, pda1->startSector);
-		/* determine the endSector to end decoding */
+		/* Determine the endSector to end decoding. */
 		endSector = RF_MAX(fsuend[0], fsuend[1]);
 	}
 	/*
-	      assign the beginning sector and the end sector for each parameter
-	      find out the corresponding colume # for each parameter
-        */
+	 * Assign the beginning sector and the end sector for each parameter.
+	 * Find out the corresponding column # for each parameter.
+	 */
 	for (prm = 0; prm < ndataParam; prm++) {
 		pda = node->params[prm].p;
 		suoff[prm] = rf_StripeUnitOffset(layoutPtr, pda->startSector);
 		suend[prm] = suoff[prm] + pda->numSector;
 		prmToCol[prm] = rf_EUCol(layoutPtr, pda->raidAddress);
 	}
-	/* 'sector' is the sector for the current decoding algorithm. For each
-	 * sector in the failed SU, find out the corresponding parameters that
-	 * cover the current sector and that are needed for decoding of this
-	 * sector in failed SU. 2.  Find out if sector is in the shadow of any
-	 * accessed failed SU. If not, malloc a temporary space of a sector in
-	 * size. */
+	/*
+	 * 'sector' is the sector for the current decoding algorithm. For each
+	 * sector in the failed SU
+	 * 1. Find out the corresponding parameters that cover the current
+	 *    sector and that are needed for the decoding of this sector in
+	 *    failed SU.
+	 * 2. Find out if sector is in the shadow of any accessed failed SU.
+	 *    If not, malloc a temporary space of a sector in size.
+	 */
 	for (sector = startSector; sector < endSector; sector++) {
 		if (nresults == 2)
-			if (!(fsuoff[0] <= sector && sector < fsuend[0]) && !(fsuoff[1] <= sector && sector < fsuend[1]))
+			if (!(fsuoff[0] <= sector && sector < fsuend[0]) &&
+			    !(fsuoff[1] <= sector && sector < fsuend[1]))
 				continue;
 		for (prm = 0; prm < ndataParam; prm++)
 			if (suoff[prm] <= sector && sector < suend[prm])
-				buf[(prmToCol[prm])] = ((RF_PhysDiskAddr_t *) node->params[prm].p)->bufPtr +
-				    rf_RaidAddressToByte(raidPtr, sector - suoff[prm]);
-		/* find out if sector is in the shadow of any accessed failed
+				buf[(prmToCol[prm])] = ((RF_PhysDiskAddr_t *)
+				    node->params[prm].p)->bufPtr +
+				    rf_RaidAddressToByte(raidPtr,
+				     sector - suoff[prm]);
+		/*
+		 * Find out if sector is in the shadow of any accessed failed
 		 * SU. If yes, assign dest[0], dest[1] to point at suitable
-		 * position of the buffer corresponding to failed SUs. if no,
+		 * position of the buffer corresponding to failed SUs. If no,
 		 * malloc a temporary space of a sector in size for
-		 * destination of decoding. */
+		 * destination of decoding.
+		 */
 		RF_ASSERT(nresults == 1 || nresults == 2);
 		if (nresults == 1) {
-			dest[0] = ((RF_PhysDiskAddr_t *) node->results[0])->bufPtr + rf_RaidAddressToByte(raidPtr, sector - fsuoff[0]);
-			/* Always malloc temp buffer to dest[1]  */
+			dest[0] = ((RF_PhysDiskAddr_t *)
+			    node->results[0])->bufPtr +
+			    rf_RaidAddressToByte(raidPtr, sector - fsuoff[0]);
+			/* Always malloc temp buffer to dest[1]. */
 			RF_Malloc(dest[1], bytesPerSector, (char *));
 			bzero(dest[1], bytesPerSector);
 			mallc_two = 1;
 		} else {
 			if (fsuoff[0] <= sector && sector < fsuend[0])
-				dest[0] = ((RF_PhysDiskAddr_t *) node->results[0])->bufPtr + rf_RaidAddressToByte(raidPtr, sector - fsuoff[0]);
+				dest[0] = ((RF_PhysDiskAddr_t *)
+				    node->results[0])->bufPtr +
+				    rf_RaidAddressToByte(raidPtr,
+				     sector - fsuoff[0]);
 			else {
 				RF_Malloc(dest[0], bytesPerSector, (char *));
 				bzero(dest[0], bytesPerSector);
 				mallc_one = 1;
 			}
 			if (fsuoff[1] <= sector && sector < fsuend[1])
-				dest[1] = ((RF_PhysDiskAddr_t *) node->results[1])->bufPtr + rf_RaidAddressToByte(raidPtr, sector - fsuoff[1]);
+				dest[1] = ((RF_PhysDiskAddr_t *)
+				    node->results[1])->bufPtr +
+				    rf_RaidAddressToByte(raidPtr,
+				     sector - fsuoff[1]);
 			else {
 				RF_Malloc(dest[1], bytesPerSector, (char *));
 				bzero(dest[1], bytesPerSector);
@@ -802,15 +897,19 @@ rf_EvenOddDoubleRecoveryFunc(node)
 			}
 			RF_ASSERT(mallc_one == 0 || mallc_two == 0);
 		}
-		pbuf = ppda->bufPtr + rf_RaidAddressToByte(raidPtr, sector - psuoff);
-		ebuf = epda->bufPtr + rf_RaidAddressToByte(raidPtr, sector - esuoff);
+		pbuf = ppda->bufPtr + rf_RaidAddressToByte(raidPtr,
+		    sector - psuoff);
+		ebuf = epda->bufPtr + rf_RaidAddressToByte(raidPtr,
+		    sector - esuoff);
 		/*
-	         * After finish finding all needed sectors, call doubleEOdecode function for decoding
-	         * one sector to destination.
-	         */
+		 * After finish finding all needed sectors, call doubleEOdecode
+		 * function for decoding one sector to destination.
+		 */
 		rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
-		/* free all allocated memory, and mark flag to indicate no
-		 * memory is being allocated */
+		/*
+		 * Free all allocated memory, and mark flag to indicate no
+		 * memory is being allocated.
+		 */
 		if (mallc_one == 1)
 			RF_Free(dest[0], bytesPerSector);
 		if (mallc_two == 1)
@@ -830,27 +929,29 @@ rf_EvenOddDoubleRecoveryFunc(node)
 	}
 	rf_GenericWakeupFunc(node, 0);
 #if 1
-	return (0);		/* XXX is this even close!!?!?!!? GO */
+	return (0);		/* XXX Is this even close !!?!?!!? GO */
 #endif
 }
 
 
-/* currently, only access of one of the two failed SU is allowed in this function.
- * also, asmap->numStripeUnitsAccessed is limited to be one, the RaidFrame will break large access into
- * many accesses of single stripe unit.
+/*
+ * Currently, only access of one of the two failed SU is allowed in this
+ * function. Also, asmap->numStripeUnitsAccessed is limited to be one,
+ * the RAIDframe will break large access into many accesses of single
+ * stripe unit.
  */
 
-int 
-rf_EOWriteDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
+int
+rf_EOWriteDoubleRecoveryFunc(RF_DagNode_t *node)
 {
-	int     np = node->numParams;
-	RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *) node->params[np - 1].p;
+	int np = node->numParams;
+	RF_AccessStripeMap_t *asmap =
+	    (RF_AccessStripeMap_t *) node->params[np - 1].p;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
-	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
+	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) &(raidPtr->Layout);
 	RF_SectorNum_t sector;
 	RF_RowCol_t col, scol;
-	int     prm, i, j;
+	int prm, i, j;
 	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
 	unsigned sosAddr;
 	unsigned bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
@@ -858,57 +959,71 @@ rf_EOWriteDoubleRecoveryFunc(node)
 	RF_SectorNum_t startSector, endSector;
 	RF_PhysDiskAddr_t *ppda, *epda, *pda, *fpda, npda;
 	RF_RowCol_t fcol[2], numDataCol = layoutPtr->numDataCol;
-	char  **buf;		/* buf[0], buf[1], buf[2], ...etc. point to
+	char **buf;		/*
+				 * buf[0], buf[1], buf[2], ... etc, point to
 				 * buffer storing data read from col0, col1,
-				 * col2 */
-	char   *ebuf, *pbuf, *dest[2], *olddata[2];
+				 * col2.
+				 */
+	char *ebuf, *pbuf, *dest[2], *olddata[2];
 	RF_Etimer_t timer;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 
-	RF_ASSERT(asmap->numDataFailed == 1);	/* currently only support this
+	RF_ASSERT(asmap->numDataFailed == 1);	/*
+						 * Currently only support this
 						 * case, the other failed SU
-						 * is not being accessed */
+						 * is not being accessed.
+						 */
 	RF_ETIMER_START(timer);
 	RF_Malloc(buf, numDataCol * sizeof(char *), (char **));
 
-	ppda = node->results[0];/* Instead of being buffers, node->results[0]
-				 * and [1] are Ppda and Epda  */
+	ppda = node->results[0];	/*
+					 * Instead of being buffers,
+					 * node->results[0] and [1]
+					 * are Ppda and Epda.
+					 */
 	epda = node->results[1];
 	fpda = asmap->failedPDAs[0];
 
-	/* First, recovery the failed old SU using EvenOdd double decoding      */
-	/* determine the startSector and endSector for decoding */
+	/* First, recovery the failed old SU using EvenOdd double decoding. */
+	/* Determine the startSector and endSector for decoding. */
 	startSector = rf_StripeUnitOffset(layoutPtr, fpda->startSector);
 	endSector = startSector + fpda->numSector;
-	/* Assign buf[col] pointers to point to each non-failed colume  and
+	/*
+	 * Assign buf[col] pointers to point to each non-failed column and
 	 * initialize the pbuf and ebuf to point at the beginning of each
-	 * source buffers and destination buffers */
+	 * source buffers and destination buffers. */
 	for (prm = 0; prm < numDataCol - 2; prm++) {
 		pda = (RF_PhysDiskAddr_t *) node->params[prm].p;
 		col = rf_EUCol(layoutPtr, pda->raidAddress);
 		buf[col] = pda->bufPtr;
 	}
-	/* pbuf and ebuf:  they will change values as double recovery decoding
-	 * goes on */
+	/*
+	 * pbuf and ebuf: They will change values as double recovery decoding
+	 * goes on.
+	 */
 	pbuf = ppda->bufPtr;
 	ebuf = epda->bufPtr;
-	/* find out the logical colume numbers in the encoding matrix of the
-	 * two failed columes */
+	/*
+	 * Find out the logical column numbers in the encoding matrix of the
+	 * two failed columns.
+	 */
 	fcol[0] = rf_EUCol(layoutPtr, fpda->raidAddress);
 
-	/* find out the other failed colume not accessed this time */
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
+	/* Find out the other failed column not accessed this time. */
+	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+	    asmap->raidAddress);
 	for (i = 0; i < numDataCol; i++) {
 		npda.raidAddress = sosAddr + (i * secPerSU);
-		(raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress, &(npda.row), &(npda.col), &(npda.startSector), 0);
-		/* skip over dead disks */
+		(raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress,
+		    &(npda.row), &(npda.col), &(npda.startSector), 0);
+		/* Skip over dead disks. */
 		if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
 			if (i != fcol[0])
 				break;
 	}
 	RF_ASSERT(i < numDataCol);
 	fcol[1] = i;
-	/* assign temporary space to put recovered failed SU */
+	/* Assign temporary space to put recovered failed SU. */
 	numbytes = fpda->numSector * bytesPerSector;
 	RF_Malloc(olddata[0], numbytes, (char *));
 	RF_Malloc(olddata[1], numbytes, (char *));
@@ -916,9 +1031,11 @@ rf_EOWriteDoubleRecoveryFunc(node)
 	dest[1] = olddata[1];
 	bzero(olddata[0], numbytes);
 	bzero(olddata[1], numbytes);
-	/* Begin the recovery decoding, initially buf[j],  ebuf, pbuf, dest[j]
+	/*
+	 * Begin the recovery decoding, initially buf[j], ebuf, pbuf, dest[j]
 	 * have already pointed at the beginning of each source buffers and
-	 * destination buffers */
+	 * destination buffers.
+	 */
 	for (sector = startSector, i = 0; sector < endSector; sector++, i++) {
 		rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
 		for (j = 0; j < numDataCol; j++)
@@ -929,10 +1046,13 @@ rf_EOWriteDoubleRecoveryFunc(node)
 		ebuf += bytesPerSector;
 		pbuf += bytesPerSector;
 	}
-	/* after recovery, the buffer pointed by olddata[0] is the old failed
+	/*
+	 * After recovery, the buffer pointed by olddata[0] is the old failed
 	 * data. With new writing data and this old data, use small write to
-	 * calculate the new redundant informations */
-	/* node->params[ 0, ... PDAPerDisk * (numDataCol - 2)-1 ] are Pdas of
+	 * calculate the new redundant informations.
+	 */
+	/*
+	 * node->params[ 0, ... PDAPerDisk * (numDataCol - 2)-1 ] are Pdas of
 	 * Rrd; params[ PDAPerDisk*(numDataCol - 2), ... PDAPerDisk*numDataCol
 	 * -1 ] are Pdas of Rp, ( Rp2 ), Re, ( Re2 ) ; params[
 	 * PDAPerDisk*numDataCol, ... PDAPerDisk*numDataCol
@@ -942,20 +1062,27 @@ rf_EOWriteDoubleRecoveryFunc(node)
 	 * ie. PDAPerDisk = 1 then node->params[numDataCol] must be the new
 	 * data to be written to the failed disk. We first bxor the new data
 	 * into the old recovered data, then do the same things as small
-	 * write. */
+	 * write.
+	 */
 
-	rf_bxor(((RF_PhysDiskAddr_t *) node->params[numDataCol].p)->bufPtr, olddata[0], numbytes, node->dagHdr->bp);
-	/* do new 'E' calculation  */
-	/* find out the corresponding colume in encoding matrix for write
-	 * colume to be encoded into redundant disk 'E' */
+	rf_bxor(((RF_PhysDiskAddr_t *) node->params[numDataCol].p)->bufPtr,
+	    olddata[0], numbytes, node->dagHdr->bp);
+	/* Do new 'E' calculation. */
+	/*
+	 * Find out the corresponding column in encoding matrix for write
+	 * column to be encoded into redundant disk 'E'.
+	 */
 	scol = rf_EUCol(layoutPtr, fpda->raidAddress);
-	/* olddata[0] now is source buffer pointer; epda->bufPtr is the dest
-	 * buffer pointer               */
-	rf_e_encToBuf(raidPtr, scol, olddata[0], RF_EO_MATRIX_DIM - 2, epda->bufPtr, fpda->numSector);
+	/*
+	 * olddata[0] now is source buffer pointer; epda->bufPtr is the dest
+	 * buffer pointer.
+	 */
+	rf_e_encToBuf(raidPtr, scol, olddata[0], RF_EO_MATRIX_DIM - 2,
+	    epda->bufPtr, fpda->numSector);
 
-	/* do new 'P' calculation  */
+	/* Do new 'P' calculation. */
 	rf_bxor(olddata[0], ppda->bufPtr, numbytes, node->dagHdr->bp);
-	/* Free the allocated buffer  */
+	/* Free the allocated buffer. */
 	RF_Free(olddata[0], numbytes);
 	RF_Free(olddata[1], numbytes);
 	RF_Free(buf, numDataCol * sizeof(char *));
diff --git a/sys/dev/raidframe/rf_evenodd_dagfuncs.h b/sys/dev/raidframe/rf_evenodd_dagfuncs.h
index c00a1d82530..294d1cfea6b 100644
--- a/sys/dev/raidframe/rf_evenodd_dagfuncs.h
+++ b/sys/dev/raidframe/rf_evenodd_dagfuncs.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_evenodd_dagfuncs.h,v 1.2 1999/02/16 00:02:45 niklas Exp $	*/
+/*	$OpenBSD: rf_evenodd_dagfuncs.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_evenodd_dagfuncs.h,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * rf_evenodd_dagfuncs.h
  */
@@ -30,8 +31,8 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_EVENODD_DAGFUNCS_H_
-#define _RF__RF_EVENODD_DAGFUNCS_H_
+#ifndef	_RF__RF_EVENODD_DAGFUNCS_H_
+#define	_RF__RF_EVENODD_DAGFUNCS_H_
 
 extern RF_RedFuncs_t rf_EOSmallWriteEFuncs;
 extern RF_RedFuncs_t rf_EOSmallWritePFuncs;
@@ -39,42 +40,40 @@ extern RF_RedFuncs_t rf_eoERecoveryFuncs;
 extern RF_RedFuncs_t rf_eoPRecoveryFuncs;
 extern RF_RedFuncs_t rf_eoERecoveryFuncs;
 
-int     rf_RegularPEFunc(RF_DagNode_t * node);
-int     rf_RegularONEFunc(RF_DagNode_t * node);
-int     rf_SimpleONEFunc(RF_DagNode_t * node);
-void    rf_RegularESubroutine(RF_DagNode_t * node, char *ebuf);
-int     rf_RegularEFunc(RF_DagNode_t * node);
-void    rf_DegrESubroutine(RF_DagNode_t * node, char *ebuf);
-int     rf_Degraded_100_EOFunc(RF_DagNode_t * node);
-void 
-rf_e_EncOneSect(RF_RowCol_t srcLogicCol, char *srcSecbuf,
-    RF_RowCol_t destLogicCol, char *destSecbuf, int bytesPerSector);
-void 
-rf_e_encToBuf(RF_Raid_t * raidPtr, RF_RowCol_t srcLogicCol,
-    char *srcbuf, RF_RowCol_t destLogicCol, char *destbuf, int numSector);
-int     rf_RecoveryEFunc(RF_DagNode_t * node);
-int     rf_EO_DegradedWriteEFunc(RF_DagNode_t * node);
-void 
-rf_doubleEOdecode(RF_Raid_t * raidPtr, char **rrdbuf, char **dest,
-    RF_RowCol_t * fcol, char *pbuf, char *ebuf);
-int     rf_EvenOddDoubleRecoveryFunc(RF_DagNode_t * node);
-int     rf_EOWriteDoubleRecoveryFunc(RF_DagNode_t * node);
+int  rf_RegularPEFunc(RF_DagNode_t *);
+int  rf_RegularONEFunc(RF_DagNode_t *);
+int  rf_SimpleONEFunc(RF_DagNode_t *);
+void rf_RegularESubroutine(RF_DagNode_t *, char *);
+int  rf_RegularEFunc(RF_DagNode_t *);
+void rf_DegrESubroutine(RF_DagNode_t *, char *);
+int  rf_Degraded_100_EOFunc(RF_DagNode_t *);
+void rf_e_EncOneSect(RF_RowCol_t, char *, RF_RowCol_t, char *, int);
+void rf_e_encToBuf(RF_Raid_t *, RF_RowCol_t, char *, RF_RowCol_t, char *, int);
+int  rf_RecoveryEFunc(RF_DagNode_t *);
+int  rf_EO_DegradedWriteEFunc(RF_DagNode_t *);
+void rf_doubleEOdecode(RF_Raid_t *, char **, char **, RF_RowCol_t *,
+	char *, char *);
+int  rf_EvenOddDoubleRecoveryFunc(RF_DagNode_t *);
+int  rf_EOWriteDoubleRecoveryFunc(RF_DagNode_t *);
 
-#define rf_EUCol(_layoutPtr_, _addr_ ) \
-( (_addr_)%( (_layoutPtr_)->dataSectorsPerStripe ) )/((_layoutPtr_)->sectorsPerStripeUnit)
+#define	rf_EUCol(_layoutPtr_,_addr_)					\
+	((_addr_) % ((_layoutPtr_)->dataSectorsPerStripe)) /		\
+	((_layoutPtr_)->sectorsPerStripeUnit)
 
-#define rf_EO_Mod( _int1_, _int2_ ) \
-( ((_int1_) < 0)? (((_int1_)+(_int2_))%(_int2_)) : (_int1_)%(_int2_) )
+#define	rf_EO_Mod(_int1_,_int2_)					\
+	(((_int1_) < 0) ? (((_int1_) + (_int2_)) % (_int2_))		\
+			: ((_int1_) % (_int2_)))
 
-#define rf_OffsetOfNextEUBoundary(_offset_, sec_per_eu) ((_offset_)/(sec_per_eu) + 1)*(sec_per_eu)
+#define	rf_OffsetOfNextEUBoundary(_offset_, sec_per_eu)			\
+	((_offset_) / (sec_per_eu) + 1) * (sec_per_eu)
 
-#define RF_EO_MATRIX_DIM 17
+#define	RF_EO_MATRIX_DIM	17
 
 /*
  * RF_EO_MATRIX_DIM should be a prime number: and "bytesPerSector" should be
- * dividable by ( RF_EO_MATRIX_DIM - 1) to fully encode and utilize the space
- * in a sector, this number could also be 17. Tha later case doesn't apply
+ * divisible by (RF_EO_MATRIX_DIM - 1) to fully encode and utilize the space
+ * in a sector, this number could also be 17. That later case doesn't apply
  * for disk array larger than 17 columns totally.
  */
 
-#endif				/* !_RF__RF_EVENODD_DAGFUNCS_H_ */
+#endif	/* !_RF__RF_EVENODD_DAGFUNCS_H_ */
diff --git a/sys/dev/raidframe/rf_evenodd_dags.c b/sys/dev/raidframe/rf_evenodd_dags.c
index 512b73b257c..a5010f8af12 100644
--- a/sys/dev/raidframe/rf_evenodd_dags.c
+++ b/sys/dev/raidframe/rf_evenodd_dags.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_evenodd_dags.c,v 1.2 1999/02/16 00:02:45 niklas Exp $	*/
+/*	$OpenBSD: rf_evenodd_dags.c,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_evenodd_dags.c,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * rf_evenodd_dags.c
  */
@@ -32,7 +33,7 @@
 
 #include "rf_archs.h"
 
-#if RF_INCLUDE_EVENODD > 0
+#if	RF_INCLUDE_EVENODD > 0
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -57,16 +58,20 @@
  */
 RF_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateReadDAG)
 {
-	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_eoPRecoveryFuncs);
+	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    &rf_eoPRecoveryFuncs);
 }
+
 /*
  * Lost data + E.
  * Use P to reconstruct missing data.
  */
 RF_CREATE_DAG_FUNC_DECL(rf_EO_101_CreateReadDAG)
 {
-	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_eoPRecoveryFuncs);
+	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    &rf_eoPRecoveryFuncs);
 }
+
 /*
  * Lost data + P.
  * Make E look like P, and use Eor for Xor, and we can
@@ -75,12 +80,14 @@ RF_CREATE_DAG_FUNC_DECL(rf_EO_101_CreateReadDAG)
 RF_CREATE_DAG_FUNC_DECL(rf_EO_110_CreateReadDAG)
 {
 	RF_PhysDiskAddr_t *temp;
-	/* swap P and E pointers to fake out the DegradedReadDAG code */
+	/* Swap P and E pointers to fake out the DegradedReadDAG code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_eoERecoveryFuncs);
+	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    &rf_eoERecoveryFuncs);
 }
+
 /*
  * Lost two data.
  */
@@ -88,34 +95,45 @@ RF_CREATE_DAG_FUNC_DECL(rf_EOCreateDoubleDegradedReadDAG)
 {
 	rf_EO_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
 }
+
 /*
  * Lost two data.
  */
 RF_CREATE_DAG_FUNC_DECL(rf_EO_200_CreateReadDAG)
 {
-	rf_EOCreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList);
+	rf_EOCreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateWriteDAG)
 {
 	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit)
+	    asmap->failedPDAs[0]->numSector !=
+	    raidPtr->Layout.sectorsPerStripeUnit)
 		RF_PANIC();
-	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 2, (int (*) (RF_DagNode_t *)) rf_Degraded_100_EOFunc, RF_TRUE);
+	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList, 2,
+	    (int (*) (RF_DagNode_t *)) rf_Degraded_100_EOFunc, RF_TRUE);
 }
+
 /*
  * E is dead. Small write.
  */
 RF_CREATE_DAG_FUNC_DECL(rf_EO_001_CreateSmallWriteDAG)
 {
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_EOSmallWritePFuncs, NULL);
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_EOSmallWritePFuncs, NULL);
 }
+
 /*
  * E is dead. Large write.
  */
 RF_CREATE_DAG_FUNC_DECL(rf_EO_001_CreateLargeWriteDAG)
 {
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 1, rf_RegularPFunc, RF_TRUE);
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 1, rf_RegularPFunc, RF_TRUE);
 }
+
 /*
  * P is dead. Small write.
  * Swap E + P, use single-degraded stuff.
@@ -123,12 +141,14 @@ RF_CREATE_DAG_FUNC_DECL(rf_EO_001_CreateLargeWriteDAG)
 RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateSmallWriteDAG)
 {
 	RF_PhysDiskAddr_t *temp;
-	/* swap P and E pointers to fake out the DegradedReadDAG code */
+	/* Swap P and E pointers to fake out the DegradedReadDAG code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_EOSmallWriteEFuncs, NULL);
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_EOSmallWriteEFuncs, NULL);
 }
+
 /*
  * P is dead. Large write.
  * Swap E + P, use single-degraded stuff.
@@ -136,54 +156,71 @@ RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateSmallWriteDAG)
 RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateLargeWriteDAG)
 {
 	RF_PhysDiskAddr_t *temp;
-	/* swap P and E pointers to fake out the code */
+	/* Swap P and E pointers to fake out the code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 1, rf_RegularEFunc, RF_FALSE);
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 1, rf_RegularEFunc, RF_FALSE);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EO_011_CreateWriteDAG)
 {
-	rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    RF_IO_TYPE_WRITE);
+	rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, RF_IO_TYPE_WRITE);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EO_110_CreateWriteDAG)
 {
 	RF_PhysDiskAddr_t *temp;
 
 	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit) {
+	    asmap->failedPDAs[0]->numSector !=
+	    raidPtr->Layout.sectorsPerStripeUnit) {
 		RF_PANIC();
 	}
-	/* swap P and E to fake out parity code */
+	/* Swap P and E to fake out parity code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 1, (int (*) (RF_DagNode_t *)) rf_EO_DegradedWriteEFunc, RF_FALSE);
-	/* is the regular E func the right one to call? */
+	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList, 1,
+	    (int (*) (RF_DagNode_t *)) rf_EO_DegradedWriteEFunc, RF_FALSE);
+	/* Is the regular E func the right one to call ? */
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EO_101_CreateWriteDAG)
 {
 	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit)
+	    asmap->failedPDAs[0]->numSector !=
+	    raidPtr->Layout.sectorsPerStripeUnit)
 		RF_PANIC();
-	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 1, rf_RecoveryXorFunc, RF_TRUE);
+	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList, 1, rf_RecoveryXorFunc, RF_TRUE);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EO_DoubleDegRead)
 {
 	rf_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList,
 	    "Re", "EvenOddRecovery", rf_EvenOddDoubleRecoveryFunc);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EOCreateSmallWriteDAG)
 {
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_pFuncs, &rf_EOSmallWriteEFuncs);
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_pFuncs, &rf_EOSmallWriteEFuncs);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EOCreateLargeWriteDAG)
 {
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 2, rf_RegularPEFunc, RF_FALSE);
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 2, rf_RegularPEFunc, RF_FALSE);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_EO_200_CreateWriteDAG)
 {
-	rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList, "Re", "We", "EOWrDDRecovery", rf_EOWriteDoubleRecoveryFunc);
+	rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    "Re", "We", "EOWrDDRecovery", rf_EOWriteDoubleRecoveryFunc);
 }
-#endif				/* RF_INCLUDE_EVENODD > 0 */
+
+#endif	/* RF_INCLUDE_EVENODD > 0 */
diff --git a/sys/dev/raidframe/rf_evenodd_dags.h b/sys/dev/raidframe/rf_evenodd_dags.h
index b2df9a3c7a4..874b377ae8d 100644
--- a/sys/dev/raidframe/rf_evenodd_dags.h
+++ b/sys/dev/raidframe/rf_evenodd_dags.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_evenodd_dags.h,v 1.2 1999/02/16 00:02:45 niklas Exp $	*/
+/*	$OpenBSD: rf_evenodd_dags.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_evenodd_dags.h,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * rf_evenodd_dags.h
  */
@@ -30,16 +31,17 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_EVENODD_DAGS_H_
-#define _RF__RF_EVENODD_DAGS_H_
+#ifndef	_RF__RF_EVENODD_DAGS_H_
+#define	_RF__RF_EVENODD_DAGS_H_
 
 #include "rf_types.h"
 
-#if RF_UTILITY == 0
+#if	RF_UTILITY == 0
 #include "rf_dag.h"
 
-/* extern decl's of the failure mode EO functions.
- * swiped from rf_pqdeg.h
+/*
+ * Extern decl's of the failure mode EO functions.
+ * Swiped from rf_pqdeg.h
  */
 
 RF_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateReadDAG);
@@ -59,6 +61,6 @@ RF_CREATE_DAG_FUNC_DECL(rf_EO_DoubleDegRead);
 RF_CREATE_DAG_FUNC_DECL(rf_EOCreateSmallWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_EOCreateLargeWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_EO_200_CreateWriteDAG);
-#endif				/* RF_UTILITY == 0 */
+#endif	/* RF_UTILITY == 0 */
 
-#endif				/* !_RF__RF_EVENODD_DAGS_H_ */
+#endif	/* !_RF__RF_EVENODD_DAGS_H_ */
diff --git a/sys/dev/raidframe/rf_fifo.c b/sys/dev/raidframe/rf_fifo.c
index 4e37d7e36a0..9a391a8f259 100644
--- a/sys/dev/raidframe/rf_fifo.c
+++ b/sys/dev/raidframe/rf_fifo.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_fifo.c,v 1.5 2000/08/08 16:07:41 peter Exp $	*/
+/*	$OpenBSD: rf_fifo.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_fifo.c,v 1.5 2000/03/04 03:27:13 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -48,30 +49,27 @@
 #include "rf_raid.h"
 #include "rf_types.h"
 
-/* just malloc a header, zero it (via calloc), and return it */
+/* Just malloc a header, zero it (via calloc), and return it. */
 /*ARGSUSED*/
-void   *
-rf_FifoCreate(sectPerDisk, clList, listp)
-	RF_SectorCount_t sectPerDisk;
-	RF_AllocListElem_t *clList;
-	RF_ShutdownList_t **listp;
+void *
+rf_FifoCreate(RF_SectorCount_t sectPerDisk, RF_AllocListElem_t *clList,
+    RF_ShutdownList_t **listp)
 {
 	RF_FifoHeader_t *q;
 
-	RF_CallocAndAdd(q, 1, sizeof(RF_FifoHeader_t), (RF_FifoHeader_t *), clList);
+	RF_CallocAndAdd(q, 1, sizeof(RF_FifoHeader_t), (RF_FifoHeader_t *),
+	    clList);
 	q->hq_count = q->lq_count = 0;
 	return ((void *) q);
 }
 
-void 
-rf_FifoEnqueue(q_in, elem, priority)
-	void   *q_in;
-	RF_DiskQueueData_t *elem;
-	int     priority;
+void
+rf_FifoEnqueue(void *q_in, RF_DiskQueueData_t *elem, int priority)
 {
 	RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
 
-	RF_ASSERT(priority == RF_IO_NORMAL_PRIORITY || priority == RF_IO_LOW_PRIORITY);
+	RF_ASSERT(priority == RF_IO_NORMAL_PRIORITY ||
+	    priority == RF_IO_LOW_PRIORITY);
 
 	elem->next = NULL;
 	if (priority == RF_IO_NORMAL_PRIORITY) {
@@ -87,8 +85,8 @@ rf_FifoEnqueue(q_in, elem, priority)
 	} else {
 		RF_ASSERT(elem->next == NULL);
 		if (rf_fifoDebug) {
-			printf("raid%d: fifo: ENQ lopri\n", 
-			       elem->raidPtr->raidid);
+			printf("raid%d: fifo: ENQ lopri\n",
+			    elem->raidPtr->raidid);
 		}
 		if (!q->lq_tail) {
 			RF_ASSERT(q->lq_count == 0 && q->lq_head == NULL);
@@ -101,7 +99,7 @@ rf_FifoEnqueue(q_in, elem, priority)
 		q->lq_count++;
 	}
 	if ((q->hq_count + q->lq_count) != elem->queue->queueLength) {
-		printf("Queue lengths differ!: %d %d %d\n",
+		printf("Queue lengths differ ! : %d %d %d\n",
 		    q->hq_count, q->lq_count, (int) elem->queue->queueLength);
 		printf("%d %d %d %d\n",
 		    (int) elem->queue->numOutstanding,
@@ -113,8 +111,7 @@ rf_FifoEnqueue(q_in, elem, priority)
 }
 
 RF_DiskQueueData_t *
-rf_FifoDequeue(q_in)
-	void   *q_in;
+rf_FifoDequeue(void *q_in)
 {
 	RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
 	RF_DiskQueueData_t *nd;
@@ -138,17 +135,19 @@ rf_FifoDequeue(q_in)
 			nd->next = NULL;
 			q->lq_count--;
 			if (rf_fifoDebug) {
-				printf("raid%d: fifo: DEQ lopri %lx\n", 
-				       nd->raidPtr->raidid, (long) nd);
+				printf("raid%d: fifo: DEQ lopri %lx\n",
+				    nd->raidPtr->raidid, (long) nd);
 			}
 		} else {
-			RF_ASSERT(q->hq_count == 0 && q->lq_count == 0 && q->hq_tail == NULL && q->lq_tail == NULL);
+			RF_ASSERT(q->hq_count == 0 && q->lq_count == 0 &&
+			    q->hq_tail == NULL && q->lq_tail == NULL);
 			nd = NULL;
 		}
 	return (nd);
 }
 
-/* Return ptr to item at head of queue.  Used to examine request
+/*
+ * Return ptr to item at head of queue. Used to examine request
  * info without actually dequeueing the request.
  */
 RF_DiskQueueData_t *
@@ -165,43 +164,48 @@ rf_FifoPeek(void *q_in)
 			headElement = q->lq_head;
 	return (headElement);
 }
-/* We sometimes need to promote a low priority access to a regular priority access.
- * Currently, this is only used when the user wants to write a stripe which is currently
- * under reconstruction.
- * This routine will promote all accesses tagged with the indicated parityStripeID from
- * the low priority queue to the end of the normal priority queue.
+
+/*
+ * We sometimes need to promote a low priority access to a regular priority
+ * access. Currently, this is only used when the user wants to write a stripe
+ * that is currently under reconstruction.
+ * This routine will promote all accesses tagged with the indicated
+ * parityStripeID from the low priority queue to the end of the normal
+ * priority queue.
  * We assume the queue is locked upon entry.
  */
-int 
-rf_FifoPromote(q_in, parityStripeID, which_ru)
-	void   *q_in;
-	RF_StripeNum_t parityStripeID;
-	RF_ReconUnitNum_t which_ru;
+int
+rf_FifoPromote(void *q_in, RF_StripeNum_t parityStripeID,
+    RF_ReconUnitNum_t which_ru)
 {
 	RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
-	RF_DiskQueueData_t *lp = q->lq_head, *pt = NULL;	/* lp = lo-pri queue
-								 * pointer, pt = trailer */
-	int     retval = 0;
+	/* lp = lo-pri queue pointer, pt = trailer */
+	RF_DiskQueueData_t *lp = q->lq_head, *pt = NULL;
+	int retval = 0;
 
 	while (lp) {
 
-		/* search for the indicated parity stripe in the low-pri queue */
-		if (lp->parityStripeID == parityStripeID && lp->which_ru == which_ru) {
+		/*
+		 * Search for the indicated parity stripe in the low-pri queue.
+		 */
+		if (lp->parityStripeID == parityStripeID &&
+		    lp->which_ru == which_ru) {
 			/* printf("FifoPromote:  promoting access for psid
-			 * %ld\n",parityStripeID); */
+			 * %ld\n", parityStripeID); */
 			if (pt)
-				pt->next = lp->next;	/* delete an entry other
-							 * than the first */
+				/* Delete an entry other than the first. */
+				pt->next = lp->next;
 			else
-				q->lq_head = lp->next;	/* delete the head entry */
+				/* Delete the head entry. */
+				q->lq_head = lp->next;
 
 			if (!q->lq_head)
-				q->lq_tail = NULL;	/* we deleted the only
-							 * entry */
+				/* We deleted the only entry. */
+				q->lq_tail = NULL;
 			else
 				if (lp == q->lq_tail)
-					q->lq_tail = pt;	/* we deleted the tail
-								 * entry */
+					/* We deleted the tail entry. */
+					q->lq_tail = pt;
 
 			lp->next = NULL;
 			q->lq_count--;
@@ -210,17 +214,18 @@ rf_FifoPromote(q_in, parityStripeID, which_ru)
 				q->hq_tail->next = lp;
 				q->hq_tail = lp;
 			}
-			 /* append to hi-priority queue */ 
+			 /* Append to hi-priority queue. */
 			else {
 				q->hq_head = q->hq_tail = lp;
 			}
 			q->hq_count++;
 
+			/* Deal with this later, if ever. */
 			/* UpdateShortestSeekFinishTimeForced(lp->requestPtr,
-			 * lp->diskState); *//* deal with this later, if ever */
+			 * lp->diskState); */
 
-			lp = (pt) ? pt->next : q->lq_head;	/* reset low-pri pointer
-								 * and continue */
+			/* Reset low-pri pointer and continue. */
+			lp = (pt) ? pt->next : q->lq_head;
 			retval++;
 
 		} else {
@@ -229,8 +234,10 @@ rf_FifoPromote(q_in, parityStripeID, which_ru)
 		}
 	}
 
-	/* sanity check.  delete this if you ever put more than one entry in
-	 * the low-pri queue */
+	/*
+	 * Sanity check. Delete this if you ever put more than one entry in
+	 * the low-pri queue.
+	 */
 	RF_ASSERT(retval == 0 || retval == 1);
 	return (retval);
 }
diff --git a/sys/dev/raidframe/rf_fifo.h b/sys/dev/raidframe/rf_fifo.h
index f23d7dcb573..74b4ddb76d5 100644
--- a/sys/dev/raidframe/rf_fifo.h
+++ b/sys/dev/raidframe/rf_fifo.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_fifo.h,v 1.2 1999/02/16 00:02:46 niklas Exp $	*/
+/*	$OpenBSD: rf_fifo.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_fifo.h,v 1.3 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -34,8 +35,8 @@
  */
 
 
-#ifndef _RF__RF_FIFO_H_
-#define _RF__RF_FIFO_H_
+#ifndef	_RF__RF_FIFO_H_
+#define	_RF__RF_FIFO_H_
 
 #include "rf_archs.h"
 #include "rf_types.h"
@@ -44,19 +45,14 @@
 typedef struct RF_FifoHeader_s {
 	RF_DiskQueueData_t *hq_head, *hq_tail;	/* high priority requests */
 	RF_DiskQueueData_t *lq_head, *lq_tail;	/* low priority requests */
-	int     hq_count, lq_count;	/* debug only */
-}       RF_FifoHeader_t;
-
-extern void *
-rf_FifoCreate(RF_SectorCount_t sectPerDisk,
-    RF_AllocListElem_t * clList, RF_ShutdownList_t ** listp);
-extern void 
-rf_FifoEnqueue(void *q_in, RF_DiskQueueData_t * elem,
-    int priority);
-extern RF_DiskQueueData_t *rf_FifoDequeue(void *q_in);
-extern RF_DiskQueueData_t *rf_FifoPeek(void *q_in);
-extern int 
-rf_FifoPromote(void *q_in, RF_StripeNum_t parityStripeID,
-    RF_ReconUnitNum_t which_ru);
-
-#endif				/* !_RF__RF_FIFO_H_ */
+	int		    hq_count, lq_count;	/* debug only */
+}	RF_FifoHeader_t;
+
+extern void *rf_FifoCreate(RF_SectorCount_t, RF_AllocListElem_t *,
+	RF_ShutdownList_t **);
+extern void rf_FifoEnqueue(void *, RF_DiskQueueData_t *, int);
+extern RF_DiskQueueData_t *rf_FifoDequeue(void *);
+extern RF_DiskQueueData_t *rf_FifoPeek(void *);
+extern int rf_FifoPromote(void *, RF_StripeNum_t, RF_ReconUnitNum_t);
+
+#endif	/* !_RF__RF_FIFO_H_ */
diff --git a/sys/dev/raidframe/rf_freelist.h b/sys/dev/raidframe/rf_freelist.h
index c2535109ec3..aba35f48874 100644
--- a/sys/dev/raidframe/rf_freelist.h
+++ b/sys/dev/raidframe/rf_freelist.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_freelist.h,v 1.2 1999/02/16 00:02:47 niklas Exp $	*/
+/*	$OpenBSD: rf_freelist.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_freelist.h,v 1.3 1999/02/05 00:06:11 oster Exp $	*/
+
 /*
  * rf_freelist.h
  */
@@ -31,7 +32,7 @@
  */
 
 /*
- * rf_freelist.h -- code to manage counted freelists
+ * rf_freelist.h -- Code to manage counted freelists.
  *
  * Keep an arena of fixed-size objects. When a new object is needed,
  * allocate it as necessary. When an object is freed, either put it
@@ -39,630 +40,677 @@
  * size.
  */
 
-#ifndef _RF__RF_FREELIST_H_
-#define _RF__RF_FREELIST_H_
+#ifndef	_RF__RF_FREELIST_H_
+#define	_RF__RF_FREELIST_H_
 
 #include "rf_types.h"
 #include "rf_debugMem.h"
 #include "rf_general.h"
 #include "rf_threadstuff.h"
 
-#define RF_FREELIST_STATS 0
+#define	RF_FREELIST_STATS	0
 
-#if RF_FREELIST_STATS > 0
+#if	RF_FREELIST_STATS > 0
 typedef struct RF_FreeListStats_s {
-	char   *file;
-	int     line;
-	int     allocations;
-	int     frees;
-	int     max_free;
-	int     grows;
-	int     outstanding;
-	int     max_outstanding;
-}       RF_FreeListStats_t;
-#define RF_FREELIST_STAT_INIT(_fl_) { \
-	bzero((char *)&((_fl_)->stats), sizeof(RF_FreeListStats_t)); \
-	(_fl_)->stats.file = __FILE__; \
-	(_fl_)->stats.line = __LINE__; \
-}
-
-#define RF_FREELIST_STAT_ALLOC(_fl_) { \
-	(_fl_)->stats.allocations++; \
-	(_fl_)->stats.outstanding++; \
-	if ((_fl_)->stats.outstanding > (_fl_)->stats.max_outstanding) \
-		(_fl_)->stats.max_outstanding = (_fl_)->stats.outstanding; \
-}
-
-#define RF_FREELIST_STAT_FREE_UPDATE(_fl_) { \
-	if ((_fl_)->free_cnt > (_fl_)->stats.max_free) \
-		(_fl_)->stats.max_free = (_fl_)->free_cnt; \
-}
-
-#define RF_FREELIST_STAT_FREE(_fl_) { \
-	(_fl_)->stats.frees++; \
-	(_fl_)->stats.outstanding--; \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-}
-
-#define RF_FREELIST_STAT_GROW(_fl_) { \
-	(_fl_)->stats.grows++; \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-}
-
-#define RF_FREELIST_STAT_REPORT(_fl_) { \
-	printf("Freelist at %s %d (%s)\n", (_fl_)->stats.file, (_fl_)->stats.line, RF_STRING(_fl_)); \
-	printf("  %d allocations, %d frees\n", (_fl_)->stats.allocations, (_fl_)->stats.frees); \
-	printf("  %d grows\n", (_fl_)->stats.grows); \
-	printf("  %d outstanding\n", (_fl_)->stats.outstanding); \
-	printf("  %d free (max)\n", (_fl_)->stats.max_free); \
-	printf("  %d outstanding (max)\n", (_fl_)->stats.max_outstanding); \
-}
-
-#else				/* RF_FREELIST_STATS > 0 */
-
-#define RF_FREELIST_STAT_INIT(_fl_)
-#define RF_FREELIST_STAT_ALLOC(_fl_)
-#define RF_FREELIST_STAT_FREE_UPDATE(_fl_)
-#define RF_FREELIST_STAT_FREE(_fl_)
-#define RF_FREELIST_STAT_GROW(_fl_)
-#define RF_FREELIST_STAT_REPORT(_fl_)
-
-#endif				/* RF_FREELIST_STATS > 0 */
+	char	*file;
+	int	 line;
+	int	 allocations;
+	int	 frees;
+	int	 max_free;
+	int	 grows;
+	int	 outstanding;
+	int	 max_outstanding;
+} RF_FreeListStats_t;
+
+#define	RF_FREELIST_STAT_INIT(_fl_)					\
+do {									\
+	bzero((char *)&((_fl_)->stats), sizeof(RF_FreeListStats_t));	\
+	(_fl_)->stats.file = __FILE__;					\
+	(_fl_)->stats.line = __LINE__;					\
+} while (0)
+
+#define	RF_FREELIST_STAT_ALLOC(_fl_)					\
+do {									\
+	(_fl_)->stats.allocations++;					\
+	(_fl_)->stats.outstanding++;					\
+	if ((_fl_)->stats.outstanding > (_fl_)->stats.max_outstanding)	\
+		(_fl_)->stats.max_outstanding =				\
+		    (_fl_)->stats.outstanding;				\
+} while (0)
+
+#define	RF_FREELIST_STAT_FREE_UPDATE(_fl_)				\
+do {									\
+	if ((_fl_)->free_cnt > (_fl_)->stats.max_free)			\
+		(_fl_)->stats.max_free = (_fl_)->free_cnt;		\
+} while (0)
+
+#define	RF_FREELIST_STAT_FREE(_fl_)					\
+do {									\
+	(_fl_)->stats.frees++;						\
+	(_fl_)->stats.outstanding--;					\
+	RF_FREELIST_STAT_FREE_UPDATE(_fl_);				\
+} while (0)
+
+#define	RF_FREELIST_STAT_GROW(_fl_)					\
+do {									\
+	(_fl_)->stats.grows++;						\
+	RF_FREELIST_STAT_FREE_UPDATE(_fl_);				\
+} while (0)
+
+#define	RF_FREELIST_STAT_REPORT(_fl_)					\
+do {									\
+	printf("Freelist at %s %d (%s)\n", (_fl_)->stats.file,		\
+	    (_fl_)->stats.line, RF_STRING(_fl_));			\
+	printf("  %d allocations, %d frees\n",				\
+	    (_fl_)->stats.allocations, (_fl_)->stats.frees);		\
+	printf("  %d grows\n", (_fl_)->stats.grows);			\
+	printf("  %d outstanding\n", (_fl_)->stats.outstanding);	\
+	printf("  %d free (max)\n", (_fl_)->stats.max_free);		\
+	printf("  %d outstanding (max)\n",				\
+	    (_fl_)->stats.max_outstanding);				\
+} while (0)
+
+#else	/* RF_FREELIST_STATS > 0 */
+
+#define	RF_FREELIST_STAT_INIT(_fl_)
+#define	RF_FREELIST_STAT_ALLOC(_fl_)
+#define	RF_FREELIST_STAT_FREE_UPDATE(_fl_)
+#define	RF_FREELIST_STAT_FREE(_fl_)
+#define	RF_FREELIST_STAT_GROW(_fl_)
+#define	RF_FREELIST_STAT_REPORT(_fl_)
+
+#endif	/* RF_FREELIST_STATS > 0 */
 
 struct RF_FreeList_s {
-	void   *objlist;	/* list of free obj */
-	int     free_cnt;	/* how many free obj */
-	int     max_free_cnt;	/* max free arena size */
-	int     obj_inc;	/* how many to allocate at a time */
-	int     obj_size;	/* size of objects */
-	        RF_DECLARE_MUTEX(lock)
-#if RF_FREELIST_STATS > 0
-	RF_FreeListStats_t stats;	/* statistics */
-#endif				/* RF_FREELIST_STATS > 0 */
+	void	*objlist;	/* List of free obj. */
+	int	 free_cnt;	/* How many free obj. */
+	int	 max_free_cnt;	/* Max free arena size. */
+	int	 obj_inc;	/* How many to allocate at a time. */
+	int	 obj_size;	/* Size of objects. */
+	RF_DECLARE_MUTEX(lock);
+#if	RF_FREELIST_STATS > 0
+	RF_FreeListStats_t stats;	/* Statistics. */
+#endif	/* RF_FREELIST_STATS > 0 */
 };
+
 /*
- * fl     = freelist
- * maxcnt = max number of items in arena
- * inc    = how many to allocate at a time
- * size   = size of object
+ * fl	  = FreeList.
+ * maxcnt = Max number of items in arena.
+ * inc	  = How many to allocate at a time.
+ * size	  = Size of object.
  */
-#define RF_FREELIST_CREATE(_fl_,_maxcnt_,_inc_,_size_) { \
-	int rc; \
-	RF_ASSERT((_inc_) > 0); \
-	RF_Malloc(_fl_, sizeof(RF_FreeList_t), (RF_FreeList_t *)); \
-	(_fl_)->objlist = NULL; \
-	(_fl_)->free_cnt = 0; \
-	(_fl_)->max_free_cnt = _maxcnt_; \
-	(_fl_)->obj_inc = _inc_; \
-	(_fl_)->obj_size = _size_; \
-	rc = rf_mutex_init(&(_fl_)->lock); \
-	if (rc) { \
-		RF_Free(_fl_, sizeof(RF_FreeList_t)); \
-		_fl_ = NULL; \
-	} \
-	RF_FREELIST_STAT_INIT(_fl_); \
-}
+#define	RF_FREELIST_CREATE(_fl_,_maxcnt_,_inc_,_size_)			\
+do {									\
+	int rc;								\
+	RF_ASSERT((_inc_) > 0);						\
+	RF_Malloc(_fl_, sizeof(RF_FreeList_t), (RF_FreeList_t *));	\
+	(_fl_)->objlist = NULL;						\
+	(_fl_)->free_cnt = 0;						\
+	(_fl_)->max_free_cnt = _maxcnt_;				\
+	(_fl_)->obj_inc = _inc_;					\
+	(_fl_)->obj_size = _size_;					\
+	rc = rf_mutex_init(&(_fl_)->lock);				\
+	if (rc) {							\
+		RF_Free(_fl_, sizeof(RF_FreeList_t));			\
+		_fl_ = NULL;						\
+	}								\
+	RF_FREELIST_STAT_INIT(_fl_);					\
+} while (0)
 
 /*
- * fl    = freelist
- * cnt   = number to prime with
- * nextp = name of "next" pointer in obj
- * cast  = object cast
+ * fl	 = FreeList.
+ * cnt	 = Number to prime with.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Object cast.
  */
-#define RF_FREELIST_PRIME(_fl_,_cnt_,_nextp_,_cast_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	for(_i=0;_i<(_cnt_);_i++) { \
-		RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-		if (_p) { \
-			(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _p; \
-			(_fl_)->free_cnt++; \
-		} \
-		else { \
-			break; \
-		} \
-	} \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
-
-#define RF_FREELIST_MUTEX_OF(_fl_) ((_fl_)->lock)
-
-#define RF_FREELIST_DO_UNLOCK(_fl_) { \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
-
-#define RF_FREELIST_DO_LOCK(_fl_) { \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_PRIME(_fl_,_cnt_,_nextp_,_cast_)			\
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	for (_i = 0; _i < (_cnt_); _i++) {				\
+		RF_Calloc(_p, 1, (_fl_)->obj_size, (void *));		\
+		if (_p) {						\
+			(_cast_(_p))->_nextp_ = (_fl_)->objlist;	\
+			(_fl_)->objlist = _p;				\
+			(_fl_)->free_cnt++;				\
+		}							\
+		else {							\
+			break;						\
+		}							\
+	}								\
+	RF_FREELIST_STAT_FREE_UPDATE(_fl_);				\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
+
+#define	RF_FREELIST_MUTEX_OF(_fl_)	((_fl_)->lock)
+
+#define	RF_FREELIST_DO_UNLOCK(_fl_)	RF_UNLOCK_MUTEX((_fl_)->lock)
+
+#define	RF_FREELIST_DO_LOCK(_fl_)	RF_LOCK_MUTEX((_fl_)->lock)
 
 /*
- * fl    = freelist
- * cnt   = number to prime with
- * nextp = name of "next" pointer in obj
- * cast  = object cast
- * init  = func to call to init obj
+ * fl	 = FreeList.
+ * cnt	 = Number to prime with.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Object cast.
+ * init	 = Func to call to init obj.
  */
-#define RF_FREELIST_PRIME_INIT(_fl_,_cnt_,_nextp_,_cast_,_init_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	for(_i=0;_i<(_cnt_);_i++) { \
-		RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-		if (_init_ (_cast_ _p)) { \
-			RF_Free(_p,(_fl_)->obj_size); \
-			_p = NULL; \
-		} \
-		if (_p) { \
-			(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _p; \
-			(_fl_)->free_cnt++; \
-		} \
-		else { \
-			break; \
-		} \
-	} \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_PRIME_INIT(_fl_,_cnt_,_nextp_,_cast_,_init_)	\
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	for (_i = 0; _i < (_cnt_); _i++) {				\
+		RF_Calloc(_p, 1, (_fl_)->obj_size, (void *));		\
+		if (_init_(_cast_ _p)) {				\
+			RF_Free(_p, (_fl_)->obj_size);			\
+			_p = NULL;					\
+		}							\
+		if (_p) {						\
+			(_cast_(_p))->_nextp_ = (_fl_)->objlist;	\
+			(_fl_)->objlist = _p;				\
+			(_fl_)->free_cnt++;				\
+		}							\
+		else {							\
+			break;						\
+		}							\
+	}								\
+	RF_FREELIST_STAT_FREE_UPDATE(_fl_);				\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * cnt   = number to prime with
- * nextp = name of "next" pointer in obj
- * cast  = object cast
- * init  = func to call to init obj
- * arg   = arg to init obj func
+ * fl	 = FreeList.
+ * cnt	 = Number to prime with.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Object cast.
+ * init	 = Func to call to init obj.
+ * arg	 = Arg to init obj func.
  */
-#define RF_FREELIST_PRIME_INIT_ARG(_fl_,_cnt_,_nextp_,_cast_,_init_,_arg_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	for(_i=0;_i<(_cnt_);_i++) { \
-		RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-		if (_init_ (_cast_ _p,_arg_)) { \
-			RF_Free(_p,(_fl_)->obj_size); \
-			_p = NULL; \
-		} \
-		if (_p) { \
-			(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _p; \
-			(_fl_)->free_cnt++; \
-		} \
-		else { \
-			break; \
-		} \
-	} \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_PRIME_INIT_ARG(_fl_,_cnt_,_nextp_,_cast_,_init_,_arg_) \
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	for (_i = 0; _i < (_cnt_); _i++) {				\
+		RF_Calloc(_p, 1, (_fl_)->obj_size, (void *));		\
+		if (_init_(_cast_ _p, _arg_)) {				\
+			RF_Free(_p, (_fl_)->obj_size);			\
+			_p = NULL;					\
+		}							\
+		if (_p) {						\
+			(_cast_(_p))->_nextp_ = (_fl_)->objlist;	\
+			(_fl_)->objlist = _p;				\
+			(_fl_)->free_cnt++;				\
+		}							\
+		else {							\
+			break;						\
+		}							\
+	}								\
+	RF_FREELIST_STAT_FREE_UPDATE(_fl_);				\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to allocate
- * nextp = name of "next" pointer in obj
- * cast  = cast of obj assignment
- * init  = init obj func
+ * fl	 = FreeList.
+ * obj	 = Object to allocate.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast of obj assignment.
+ * init	 = Init obj func.
  */
-#define RF_FREELIST_GET_INIT(_fl_,_obj_,_nextp_,_cast_,_init_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_ASSERT(sizeof(*(_obj_))==((_fl_)->obj_size)); \
-	if (_fl_->objlist) { \
-		_obj_ = _cast_((_fl_)->objlist); \
-		(_fl_)->objlist = (void *)((_obj_)->_nextp_); \
-		(_fl_)->free_cnt--; \
-	} \
-	else { \
-		/* \
-		 * Allocate one at a time so we can free \
-		 * one at a time without cleverness when arena \
-		 * is full. \
-		 */ \
-		RF_Calloc(_obj_,1,(_fl_)->obj_size,_cast_); \
-		if (_obj_) { \
-			if (_init_ (_obj_)) { \
-				RF_Free(_obj_,(_fl_)->obj_size); \
-				_obj_ = NULL; \
-			} \
-			else { \
-				for(_i=1;_i<(_fl_)->obj_inc;_i++) { \
-					RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-					if (_p) { \
-						if (_init_ (_p)) { \
-							RF_Free(_p,(_fl_)->obj_size); \
-							_p = NULL; \
-							break; \
-						} \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-		} \
-		RF_FREELIST_STAT_GROW(_fl_); \
-	} \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_GET_INIT(_fl_,_obj_,_nextp_,_cast_,_init_)		\
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size));		\
+	if (_fl_->objlist) {						\
+		_obj_ = _cast_((_fl_)->objlist);			\
+		(_fl_)->objlist = (void *)((_obj_)->_nextp_);		\
+		(_fl_)->free_cnt--;					\
+	}								\
+	else {								\
+		/*							\
+		 * Allocate one at a time so we can free		\
+		 * one at a time without cleverness when arena		\
+		 * is full.						\
+		 */							\
+		RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_);		\
+		if (_obj_) {						\
+			if (_init_(_obj_)) {				\
+				RF_Free(_obj_, (_fl_)->obj_size);	\
+				_obj_ = NULL;				\
+			}						\
+			else {						\
+				for (_i = 1; _i < (_fl_)->obj_inc;	\
+				     _i++) {				\
+					RF_Calloc(_p, 1,		\
+					    (_fl_)->obj_size,		\
+					    (void *));			\
+					if (_p) {			\
+						if (_init_(_p)) {	\
+							RF_Free(_p,	\
+						  (_fl_)->obj_size);	\
+							_p = NULL;	\
+							break;		\
+						}			\
+						(_cast_(_p))->_nextp_ =	\
+						    (_fl_)->objlist;	\
+						(_fl_)->objlist = _p;	\
+					}				\
+					else {				\
+						break;			\
+					}				\
+				}					\
+			}						\
+		} 							\
+		RF_FREELIST_STAT_GROW(_fl_);				\
+	}								\
+	RF_FREELIST_STAT_ALLOC(_fl_);					\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to allocate
- * nextp = name of "next" pointer in obj
- * cast  = cast of obj assignment
- * init  = init obj func
- * arg   = arg to init obj func
+ * fl	 = FreeList.
+ * obj	 = Object to allocate.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast of obj assignment.
+ * init	 = Init obj func.
+ * arg	 = Arg to init obj func.
  */
-#define RF_FREELIST_GET_INIT_ARG(_fl_,_obj_,_nextp_,_cast_,_init_,_arg_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_ASSERT(sizeof(*(_obj_))==((_fl_)->obj_size)); \
-	if (_fl_->objlist) { \
-		_obj_ = _cast_((_fl_)->objlist); \
-		(_fl_)->objlist = (void *)((_obj_)->_nextp_); \
-		(_fl_)->free_cnt--; \
-	} \
-	else { \
-		/* \
-		 * Allocate one at a time so we can free \
-		 * one at a time without cleverness when arena \
-		 * is full. \
-		 */ \
-		RF_Calloc(_obj_,1,(_fl_)->obj_size,_cast_); \
-		if (_obj_) { \
-			if (_init_ (_obj_,_arg_)) { \
-				RF_Free(_obj_,(_fl_)->obj_size); \
-				_obj_ = NULL; \
-			} \
-			else { \
-				for(_i=1;_i<(_fl_)->obj_inc;_i++) { \
-					RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-					if (_p) { \
-						if (_init_ (_p,_arg_)) { \
-							RF_Free(_p,(_fl_)->obj_size); \
-							_p = NULL; \
-							break; \
-						} \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-		} \
-		RF_FREELIST_STAT_GROW(_fl_); \
-	} \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_GET_INIT_ARG(_fl_,_obj_,_nextp_,_cast_,_init_,_arg_) \
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size));		\
+	if (_fl_->objlist) {						\
+		_obj_ = _cast_((_fl_)->objlist);			\
+		(_fl_)->objlist = (void *)((_obj_)->_nextp_);		\
+		(_fl_)->free_cnt--;					\
+	}								\
+	else {								\
+		/*							\
+		 * Allocate one at a time so we can free		\
+		 * one at a time without cleverness when arena		\
+		 * is full.						\
+		 */							\
+		RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_);		\
+		if (_obj_) {						\
+			if (_init_(_obj_, _arg_)) {			\
+				RF_Free(_obj_, (_fl_)->obj_size);	\
+				_obj_ = NULL;				\
+			}						\
+			else {						\
+				for (_i = 1; _i < (_fl_)->obj_inc;	\
+				     _i++) {				\
+					RF_Calloc(_p, 1,		\
+					   (_fl_)->obj_size, (void *));	\
+					if (_p) {			\
+						if (_init_(_p, _arg_))	\
+						{			\
+							RF_Free(_p,	\
+						    (_fl_)->obj_size);	\
+							_p = NULL;	\
+							break;		\
+						}			\
+						(_cast_(_p))->_nextp_ =	\
+						    (_fl_)->objlist;	\
+						(_fl_)->objlist = _p;	\
+					}				\
+					else {				\
+						break;			\
+					}				\
+				}					\
+			}						\
+		}							\
+		RF_FREELIST_STAT_GROW(_fl_);				\
+	}								\
+	RF_FREELIST_STAT_ALLOC(_fl_);					\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to allocate
- * nextp = name of "next" pointer in obj
- * cast  = cast of obj assignment
- * init  = init obj func
+ * fl	 = FreeList.
+ * obj	 = Object to allocate.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast of obj assignment.
+ * init	 = Init obj func.
  */
-#define RF_FREELIST_GET_INIT_NOUNLOCK(_fl_,_obj_,_nextp_,_cast_,_init_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_ASSERT(sizeof(*(_obj_))==((_fl_)->obj_size)); \
-	if (_fl_->objlist) { \
-		_obj_ = _cast_((_fl_)->objlist); \
-		(_fl_)->objlist = (void *)((_obj_)->_nextp_); \
-		(_fl_)->free_cnt--; \
-	} \
-	else { \
-		/* \
-		 * Allocate one at a time so we can free \
-		 * one at a time without cleverness when arena \
-		 * is full. \
-		 */ \
-		RF_Calloc(_obj_,1,(_fl_)->obj_size,_cast_); \
-		if (_obj_) { \
-			if (_init_ (_obj_)) { \
-				RF_Free(_obj_,(_fl_)->obj_size); \
-				_obj_ = NULL; \
-			} \
-			else { \
-				for(_i=1;_i<(_fl_)->obj_inc;_i++) { \
-					RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-					if (_p) { \
-						if (_init_ (_p)) { \
-							RF_Free(_p,(_fl_)->obj_size); \
-							_p = NULL; \
-							break; \
-						} \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-		} \
-		RF_FREELIST_STAT_GROW(_fl_); \
-	} \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-}
+#define	RF_FREELIST_GET_INIT_NOUNLOCK(_fl_,_obj_,_nextp_,_cast_,_init_)	\
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size));		\
+	if (_fl_->objlist) {						\
+		_obj_ = _cast_((_fl_)->objlist);			\
+		(_fl_)->objlist = (void *)((_obj_)->_nextp_);		\
+		(_fl_)->free_cnt--;					\
+	}								\
+	else {								\
+		/*							\
+		 * Allocate one at a time so we can free		\
+		 * one at a time without cleverness when arena		\
+		 * is full.						\
+		 */							\
+		RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_);		\
+		if (_obj_) {						\
+			if (_init_(_obj_)) {				\
+				RF_Free(_obj_, (_fl_)->obj_size);	\
+				_obj_ = NULL;				\
+			}						\
+			else {						\
+				for (_i = 1; _i < (_fl_)->obj_inc;	\
+				     _i++) {				\
+					RF_Calloc(_p, 1,		\
+					    (_fl_)->obj_size,		\
+					    (void *));			\
+					if (_p) {			\
+						if (_init_(_p)) {	\
+							RF_Free(_p,	\
+						    (_fl_)->obj_size);	\
+							_p = NULL;	\
+							break;		\
+						}			\
+						(_cast_(_p))->_nextp_ =	\
+						    (_fl_)->objlist;	\
+						(_fl_)->objlist = _p;	\
+					}				\
+					else {				\
+						break;			\
+					}				\
+				}					\
+			}						\
+		}							\
+		RF_FREELIST_STAT_GROW(_fl_);				\
+	}								\
+	RF_FREELIST_STAT_ALLOC(_fl_);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to allocate
- * nextp = name of "next" pointer in obj
- * cast  = cast of obj assignment
+ * fl	 = FreeList.
+ * obj	 = Object to allocate.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast of obj assignment.
  */
-#define RF_FREELIST_GET(_fl_,_obj_,_nextp_,_cast_) { \
-	void *_p; \
-	int _i; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_ASSERT(sizeof(*(_obj_))==((_fl_)->obj_size)); \
-	if (_fl_->objlist) { \
-		_obj_ = _cast_((_fl_)->objlist); \
-		(_fl_)->objlist = (void *)((_obj_)->_nextp_); \
-		(_fl_)->free_cnt--; \
-	} \
-	else { \
-		/* \
-		 * Allocate one at a time so we can free \
-		 * one at a time without cleverness when arena \
-		 * is full. \
-		 */ \
-		RF_Calloc(_obj_,1,(_fl_)->obj_size,_cast_); \
-		if (_obj_) { \
-			for(_i=1;_i<(_fl_)->obj_inc;_i++) { \
-				RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-				if (_p) { \
-					(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-					(_fl_)->objlist = _p; \
-				} \
-				else { \
-					break; \
-				} \
-			} \
-		} \
-		RF_FREELIST_STAT_GROW(_fl_); \
-	} \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_GET(_fl_,_obj_,_nextp_,_cast_)			\
+do {									\
+	void *_p;							\
+	int _i;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size));		\
+	if (_fl_->objlist) {						\
+		_obj_ = _cast_((_fl_)->objlist);			\
+		(_fl_)->objlist = (void *)((_obj_)->_nextp_);		\
+		(_fl_)->free_cnt--;					\
+	}								\
+	else {								\
+		/*							\
+		 * Allocate one at a time so we can free		\
+		 * one at a time without cleverness when arena		\
+		 * is full.						\
+		 */							\
+		RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_);		\
+		if (_obj_) {						\
+			for (_i = 1; _i < (_fl_)->obj_inc; _i++) {	\
+				RF_Calloc(_p, 1, (_fl_)->obj_size,	\
+				    (void *));				\
+				if (_p) {				\
+					(_cast_(_p))->_nextp_ =		\
+					    (_fl_)->objlist;		\
+					(_fl_)->objlist = _p;		\
+				}					\
+				else {					\
+					break;				\
+				}					\
+			}						\
+		}							\
+		RF_FREELIST_STAT_GROW(_fl_);				\
+	}								\
+	RF_FREELIST_STAT_ALLOC(_fl_);					\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to allocate
- * nextp = name of "next" pointer in obj
- * cast  = cast of obj assignment
- * num   = num objs to return
+ * fl	 = FreeList.
+ * obj	 = Object to allocate.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast of obj assignment.
+ * num	 = Num objs to return.
  */
-#define RF_FREELIST_GET_N(_fl_,_obj_,_nextp_,_cast_,_num_) { \
-	void *_p, *_l, *_f; \
-	int _i, _n; \
-	_l = _f = NULL; \
-	_n = 0; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_ASSERT(sizeof(*(_obj_))==((_fl_)->obj_size)); \
-	for(_n=0;_n<_num_;_n++) { \
-		if (_fl_->objlist) { \
-			_obj_ = _cast_((_fl_)->objlist); \
-			(_fl_)->objlist = (void *)((_obj_)->_nextp_); \
-			(_fl_)->free_cnt--; \
-		} \
-		else { \
-			/* \
-			 * Allocate one at a time so we can free \
-			 * one at a time without cleverness when arena \
-			 * is full. \
-			 */ \
-			RF_Calloc(_obj_,1,(_fl_)->obj_size,_cast_); \
-			if (_obj_) { \
-				for(_i=1;_i<(_fl_)->obj_inc;_i++) { \
-					RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-					if (_p) { \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-			RF_FREELIST_STAT_GROW(_fl_); \
-		} \
-		if (_f == NULL) \
-			_f = _obj_; \
-		if (_obj_) { \
-			(_cast_(_obj_))->_nextp_ = _l; \
-			_l = _obj_; \
-			RF_FREELIST_STAT_ALLOC(_fl_); \
-		} \
-		else { \
-			(_cast_(_f))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _l; \
-			_n = _num_; \
-		} \
-	} \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_GET_N(_fl_,_obj_,_nextp_,_cast_,_num_)		\
+do {									\
+	void *_p, *_l, *_f;						\
+	int _i, _n;							\
+	_l = _f = NULL;							\
+	_n = 0;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	RF_ASSERT(sizeof(*(_obj_)) == ((_fl_)->obj_size));		\
+	for (_n = 0; _n < _num_; _n++) {				\
+		if (_fl_->objlist) {					\
+			_obj_ = _cast_((_fl_)->objlist);		\
+			(_fl_)->objlist = (void *)((_obj_)->_nextp_);	\
+			(_fl_)->free_cnt--;				\
+		}							\
+		else {							\
+			/*						\
+			 * Allocate one at a time so we can free	\
+			 * one at a time without cleverness when arena	\
+			 * is full.					\
+			 */						\
+			RF_Calloc(_obj_, 1, (_fl_)->obj_size, _cast_);	\
+			if (_obj_) {					\
+				for (_i = 1; _i < (_fl_)->obj_inc;	\
+				     _i++) {				\
+					RF_Calloc(_p, 1,		\
+					    (_fl_)->obj_size,		\
+					    (void *));			\
+					if (_p) {			\
+						(_cast_(_p))->_nextp_ =	\
+						    (_fl_)->objlist;	\
+						(_fl_)->objlist = _p;	\
+					}				\
+					else {				\
+						break;			\
+					}				\
+				}					\
+			}						\
+			RF_FREELIST_STAT_GROW(_fl_);			\
+		}							\
+		if (_f == NULL)						\
+			_f = _obj_;					\
+		if (_obj_) {						\
+			(_cast_(_obj_))->_nextp_ = _l;			\
+			_l = _obj_;					\
+			RF_FREELIST_STAT_ALLOC(_fl_);			\
+		}							\
+		else {							\
+			(_cast_(_f))->_nextp_ = (_fl_)->objlist;	\
+			(_fl_)->objlist = _l;				\
+			_n = _num_;					\
+		}							\
+	}								\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl = freelist
- * obj   = object to free
- * nextp = name of "next" pointer in obj
+ * fl	 = FreeList.
+ * obj	 = Object to free.
+ * nextp = Name of "next" pointer in obj.
  */
-#define RF_FREELIST_FREE(_fl_,_obj_,_nextp_) { \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
-		RF_Free(_obj_,(_fl_)->obj_size); \
-	} \
-	else { \
-		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
-		(_obj_)->_nextp_ = (_fl_)->objlist; \
-		(_fl_)->objlist = (void *)(_obj_); \
-		(_fl_)->free_cnt++; \
-	} \
-	RF_FREELIST_STAT_FREE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_FREE(_fl_,_obj_,_nextp_)				\
+do {									\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) {			\
+		RF_Free(_obj_, (_fl_)->obj_size);			\
+	}								\
+	else {								\
+		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt);	\
+		(_obj_)->_nextp_ = (_fl_)->objlist;			\
+		(_fl_)->objlist = (void *)(_obj_);			\
+		(_fl_)->free_cnt++;					\
+	}								\
+	RF_FREELIST_STAT_FREE(_fl_);					\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to free
- * nextp = name of "next" pointer in obj
- * num   = num to free (debugging)
+ * fl	 = FreeList.
+ * obj	 = Object to free.
+ * nextp = Name of "next" pointer in obj.
+ * num	 = Num to free (debugging).
  */
-#define RF_FREELIST_FREE_N(_fl_,_obj_,_nextp_,_cast_,_num_) { \
-	void *_no; \
-	int _n; \
-	_n = 0; \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	while(_obj_) { \
-		_no = (_cast_(_obj_))->_nextp_; \
-		if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
-			RF_Free(_obj_,(_fl_)->obj_size); \
-		} \
-		else { \
-			RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
-			(_obj_)->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = (void *)(_obj_); \
-			(_fl_)->free_cnt++; \
-		} \
-		_n++; \
-		_obj_ = _no; \
-		RF_FREELIST_STAT_FREE(_fl_); \
-	} \
-	RF_ASSERT(_n==(_num_)); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_FREE_N(_fl_,_obj_,_nextp_,_cast_,_num_)		\
+do {									\
+	void *_no;							\
+	int _n;								\
+	_n = 0;								\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	while(_obj_) {							\
+		_no = (_cast_(_obj_))->_nextp_;				\
+		if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) {		\
+			RF_Free(_obj_, (_fl_)->obj_size);		\
+		}							\
+		else {							\
+			RF_ASSERT((_fl_)->free_cnt <			\
+			    (_fl_)->max_free_cnt);			\
+			(_obj_)->_nextp_ = (_fl_)->objlist;		\
+			(_fl_)->objlist = (void *)(_obj_);		\
+			(_fl_)->free_cnt++;				\
+		}							\
+		_n++;							\
+		_obj_ = _no;						\
+		RF_FREELIST_STAT_FREE(_fl_);				\
+	}								\
+	RF_ASSERT(_n==(_num_));						\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to free
- * nextp = name of "next" pointer in obj
- * clean = undo for init
+ * fl	 = FreeList.
+ * obj	 = Object to free.
+ * nextp = Name of "next" pointer in obj.
+ * clean = Undo for init.
  */
-#define RF_FREELIST_FREE_CLEAN(_fl_,_obj_,_nextp_,_clean_) { \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
-		_clean_ (_obj_); \
-		RF_Free(_obj_,(_fl_)->obj_size); \
-	} \
-	else { \
-		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
-		(_obj_)->_nextp_ = (_fl_)->objlist; \
-		(_fl_)->objlist = (void *)(_obj_); \
-		(_fl_)->free_cnt++; \
-	} \
-	RF_FREELIST_STAT_FREE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_FREE_CLEAN(_fl_,_obj_,_nextp_,_clean_)		\
+do {									\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) {			\
+		_clean_(_obj_);					\
+		RF_Free(_obj_, (_fl_)->obj_size);			\
+	}								\
+	else {								\
+		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt);	\
+		(_obj_)->_nextp_ = (_fl_)->objlist;			\
+		(_fl_)->objlist = (void *)(_obj_);			\
+		(_fl_)->free_cnt++;					\
+	}								\
+	RF_FREELIST_STAT_FREE(_fl_);					\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to free
- * nextp = name of "next" pointer in obj
- * clean = undo for init
- * arg   = arg for undo func
+ * fl	 = FreeList.
+ * obj	 = Object to free.
+ * nextp = Name of "next" pointer in obj.
+ * clean = Undo for init.
+ * arg	 = Arg for undo func.
  */
-#define RF_FREELIST_FREE_CLEAN_ARG(_fl_,_obj_,_nextp_,_clean_,_arg_) { \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
-		_clean_ (_obj_,_arg_); \
-		RF_Free(_obj_,(_fl_)->obj_size); \
-	} \
-	else { \
-		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
-		(_obj_)->_nextp_ = (_fl_)->objlist; \
-		(_fl_)->objlist = (void *)(_obj_); \
-		(_fl_)->free_cnt++; \
-	} \
-	RF_FREELIST_STAT_FREE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
+#define	RF_FREELIST_FREE_CLEAN_ARG(_fl_,_obj_,_nextp_,_clean_,_arg_)	\
+do {									\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) {			\
+		_clean_(_obj_, _arg_);					\
+		RF_Free(_obj_, (_fl_)->obj_size);			\
+	}								\
+	else {								\
+		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt);	\
+		(_obj_)->_nextp_ = (_fl_)->objlist;			\
+		(_fl_)->objlist = (void *)(_obj_);			\
+		(_fl_)->free_cnt++;					\
+	}								\
+	RF_FREELIST_STAT_FREE(_fl_);					\
+	RF_UNLOCK_MUTEX((_fl_)->lock);					\
+} while (0)
 
 /*
- * fl    = freelist
- * obj   = object to free
- * nextp = name of "next" pointer in obj
- * clean = undo for init
+ * fl	 = FreeList.
+ * obj	 = Object to free.
+ * nextp = Name of "next" pointer in obj.
+ * clean = Undo for init.
  */
-#define RF_FREELIST_FREE_CLEAN_NOUNLOCK(_fl_,_obj_,_nextp_,_clean_) { \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) { \
-		_clean_ (_obj_); \
-		RF_Free(_obj_,(_fl_)->obj_size); \
-	} \
-	else { \
-		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt); \
-		(_obj_)->_nextp_ = (_fl_)->objlist; \
-		(_fl_)->objlist = (void *)(_obj_); \
-		(_fl_)->free_cnt++; \
-	} \
-	RF_FREELIST_STAT_FREE(_fl_); \
-}
+#define	RF_FREELIST_FREE_CLEAN_NOUNLOCK(_fl_,_obj_,_nextp_,_clean_)	\
+do {									\
+	RF_LOCK_MUTEX((_fl_)->lock);					\
+	if ((_fl_)->free_cnt == (_fl_)->max_free_cnt) {			\
+		_clean_(_obj_);					\
+		RF_Free(_obj_, (_fl_)->obj_size);			\
+	}								\
+	else {								\
+		RF_ASSERT((_fl_)->free_cnt < (_fl_)->max_free_cnt);	\
+		(_obj_)->_nextp_ = (_fl_)->objlist;			\
+		(_fl_)->objlist = (void *)(_obj_);			\
+		(_fl_)->free_cnt++;					\
+	}								\
+	RF_FREELIST_STAT_FREE(_fl_);					\
+} while (0)
 
 /*
- * fl     = freelist
- * nextp = name of "next" pointer in obj
- * cast  = cast to object type
+ * fl	 = FreeList.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast to object type.
  */
-#define RF_FREELIST_DESTROY(_fl_,_nextp_,_cast_) { \
-	void *_cur, *_next; \
-	RF_FREELIST_STAT_REPORT(_fl_); \
-	rf_mutex_destroy(&((_fl_)->lock)); \
-	for(_cur=(_fl_)->objlist;_cur;_cur=_next) { \
-		_next = (_cast_ _cur)->_nextp_; \
-		RF_Free(_cur,(_fl_)->obj_size); \
-	} \
-	RF_Free(_fl_,sizeof(RF_FreeList_t)); \
-}
+#define	RF_FREELIST_DESTROY(_fl_,_nextp_,_cast_)			\
+do {									\
+	void *_cur, *_next;						\
+	RF_FREELIST_STAT_REPORT(_fl_);					\
+	rf_mutex_destroy(&((_fl_)->lock));				\
+	for (_cur = (_fl_)->objlist; _cur; _cur = _next) {		\
+		_next = (_cast_ _cur)->_nextp_;				\
+		RF_Free(_cur, (_fl_)->obj_size);			\
+	}								\
+	RF_Free(_fl_, sizeof(RF_FreeList_t));				\
+} while (0)
 
 /*
- * fl    = freelist
- * nextp = name of "next" pointer in obj
- * cast  = cast to object type
- * clean = func to undo obj init
+ * fl	 = FreeList.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast to object type.
+ * clean = Func to undo obj init.
  */
-#define RF_FREELIST_DESTROY_CLEAN(_fl_,_nextp_,_cast_,_clean_) { \
-	void *_cur, *_next; \
-	RF_FREELIST_STAT_REPORT(_fl_); \
-	rf_mutex_destroy(&((_fl_)->lock)); \
-	for(_cur=(_fl_)->objlist;_cur;_cur=_next) { \
-		_next = (_cast_ _cur)->_nextp_; \
-		_clean_ (_cur); \
-		RF_Free(_cur,(_fl_)->obj_size); \
-	} \
-	RF_Free(_fl_,sizeof(RF_FreeList_t)); \
-}
+#define	RF_FREELIST_DESTROY_CLEAN(_fl_,_nextp_,_cast_,_clean_)		\
+do {									\
+	void *_cur, *_next;						\
+	RF_FREELIST_STAT_REPORT(_fl_);					\
+	rf_mutex_destroy(&((_fl_)->lock));				\
+	for (_cur = (_fl_)->objlist; _cur; _cur = _next) {		\
+		_next = (_cast_ _cur)->_nextp_;				\
+		_clean_(_cur);						\
+		RF_Free(_cur, (_fl_)->obj_size);			\
+	}								\
+	RF_Free(_fl_, sizeof(RF_FreeList_t));				\
+} while (0)
 
 /*
- * fl    = freelist
- * nextp = name of "next" pointer in obj
- * cast  = cast to object type
- * clean = func to undo obj init
- * arg   = arg for undo func
+ * fl	 = FreeList.
+ * nextp = Name of "next" pointer in obj.
+ * cast	 = Cast to object type.
+ * clean = Func to undo obj init.
+ * arg	 = Arg for undo func.
  */
-#define RF_FREELIST_DESTROY_CLEAN_ARG(_fl_,_nextp_,_cast_,_clean_,_arg_) { \
-	void *_cur, *_next; \
-	RF_FREELIST_STAT_REPORT(_fl_); \
-	rf_mutex_destroy(&((_fl_)->lock)); \
-	for(_cur=(_fl_)->objlist;_cur;_cur=_next) { \
-		_next = (_cast_ _cur)->_nextp_; \
-		_clean_ (_cur,_arg_); \
-		RF_Free(_cur,(_fl_)->obj_size); \
-	} \
-	RF_Free(_fl_,sizeof(RF_FreeList_t)); \
-}
-
-#endif				/* !_RF__RF_FREELIST_H_ */
+#define	RF_FREELIST_DESTROY_CLEAN_ARG(_fl_,_nextp_,_cast_,_clean_,_arg_) \
+do {									\
+	void *_cur, *_next;						\
+	RF_FREELIST_STAT_REPORT(_fl_);					\
+	rf_mutex_destroy(&((_fl_)->lock));				\
+	for (_cur = (_fl_)->objlist; _cur; _cur = _next) {		\
+		_next = (_cast_ _cur)->_nextp_;				\
+		_clean_(_cur, _arg_);					\
+		RF_Free(_cur, (_fl_)->obj_size);			\
+	}								\
+	RF_Free(_fl_, sizeof(RF_FreeList_t));				\
+} while (0)
+
+#endif	/* !_RF__RF_FREELIST_H_ */
diff --git a/sys/dev/raidframe/rf_general.h b/sys/dev/raidframe/rf_general.h
index c69d97088a8..12d40fa82b2 100644
--- a/sys/dev/raidframe/rf_general.h
+++ b/sys/dev/raidframe/rf_general.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_general.h,v 1.4 2000/08/08 16:07:41 peter Exp $	*/
+/*	$OpenBSD: rf_general.h,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_general.h,v 1.5 2000/03/03 02:04:48 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,76 +29,86 @@
  */
 
 /*
- * rf_general.h -- some general-use definitions
+ * rf_general.h -- Some general-use definitions.
  */
 
 /*#define NOASSERT*/
 
-#ifndef _RF__RF_GENERAL_H_
-#define _RF__RF_GENERAL_H_
+#ifndef	_RF__RF_GENERAL_H_
+#define	_RF__RF_GENERAL_H_
 
-/* error reporting and handling */
+/* Error reporting and handling. */
 
-#ifdef _KERNEL
-#include<sys/systm.h>		/* printf, sprintf, and friends */
+#ifdef	_KERNEL
+#include <sys/systm.h>		/* printf, sprintf, and friends. */
 #endif
 
-#define RF_ERRORMSG(s)            printf((s))
-#define RF_ERRORMSG1(s,a)         printf((s),(a))
-#define RF_ERRORMSG2(s,a,b)       printf((s),(a),(b))
-#define RF_ERRORMSG3(s,a,b,c)     printf((s),(a),(b),(c))
+#define	RF_ERRORMSG(s)		printf((s))
+#define	RF_ERRORMSG1(s,a)	printf((s), (a))
+#define	RF_ERRORMSG2(s,a,b)	printf((s), (a), (b))
+#define	RF_ERRORMSG3(s,a,b,c)	printf((s), (a), (b), (c))
 
 extern char rf_panicbuf[];
-#define RF_PANIC() {sprintf(rf_panicbuf,"raidframe error at line %d file %s",__LINE__,__FILE__); panic(rf_panicbuf);}
-
-#ifdef _KERNEL
-#ifdef RF_ASSERT
-#undef RF_ASSERT
-#endif				/* RF_ASSERT */
-#ifndef NOASSERT
-#define RF_ASSERT(_x_) { \
-  if (!(_x_)) { \
-    sprintf(rf_panicbuf, \
-        "raidframe error at line %d file %s (failed asserting %s)\n", \
-        __LINE__, __FILE__, #_x_); \
-    panic(rf_panicbuf); \
-  } \
-}
-#else				/* !NOASSERT */
-#define RF_ASSERT(x) {/*noop*/}
-#endif				/* !NOASSERT */
-#else				/* _KERNEL */
-#define RF_ASSERT(x) {/*noop*/}
-#endif				/* _KERNEL */
-
-/* random stuff */
-#define RF_MAX(a,b) (((a) > (b)) ? (a) : (b))
-#define RF_MIN(a,b) (((a) < (b)) ? (a) : (b))
-
-/* divide-by-zero check */
-#define RF_DB0_CHECK(a,b) ( ((b)==0) ? 0 : (a)/(b) )
-
-/* get time of day */
-#define RF_GETTIME(_t) microtime(&(_t))
+#define	RF_PANIC()							\
+do {									\
+	sprintf(rf_panicbuf, "RAIDframe error at line %d file %s",	\
+	    __LINE__, __FILE__);					\
+	panic(rf_panicbuf);						\
+} while (0)
+
+#ifdef	_KERNEL
+#ifdef	RF_ASSERT
+#undef	RF_ASSERT
+#endif	/* RF_ASSERT */
+#ifndef	NOASSERT
+#define	RF_ASSERT(_x_)							\
+do {									\
+	if (!(_x_)) {							\
+		sprintf(rf_panicbuf, "RAIDframe error at line %d"	\
+		    " file %s (failed asserting %s)\n", __LINE__,	\
+		     __FILE__, #_x_);					\
+		panic(rf_panicbuf);					\
+	}								\
+} while (0)
+#else	/* !NOASSERT */
+#define	RF_ASSERT(x)		{/*noop*/}
+#endif	/* !NOASSERT */
+#else	/* _KERNEL */
+#define	RF_ASSERT(x)		{/*noop*/}
+#endif	/* _KERNEL */
+
+/* Random stuff. */
+#define	RF_MAX(a,b)		(((a) > (b)) ? (a) : (b))
+#define	RF_MIN(a,b)		(((a) < (b)) ? (a) : (b))
+
+/* Divide-by-zero check. */
+#define	RF_DB0_CHECK(a,b)	(((b)==0) ? 0 : (a)/(b))
+
+/* Get time of day. */
+#define	RF_GETTIME(_t)		microtime(&(_t))
 
 /*
- * zero memory- not all bzero calls go through here, only
- * those which in the kernel may have a user address
+ * Zero memory - Not all bzero calls go through here, only
+ * those which in the kernel may have a user address.
  */
 
-#define RF_BZERO(_bp,_b,_l)  bzero(_b,_l)	/* XXX This is likely
-						 * incorrect. GO */
-
-
-#define RF_UL(x)           ((unsigned long) (x))
-#define RF_PGMASK          RF_UL(NBPG-1)
-#define RF_BLIP(x)         (NBPG - (RF_UL(x) & RF_PGMASK))	/* bytes left in page */
-#define RF_PAGE_ALIGNED(x) ((RF_UL(x) & RF_PGMASK) == 0)
-
-#ifdef __STDC__
-#define RF_STRING(_str_) #_str_
-#else				/* __STDC__ */
-#define RF_STRING(_str_) "_str_"
-#endif				/* __STDC__ */
-
-#endif				/* !_RF__RF_GENERAL_H_ */
+#define	RF_BZERO(_bp,_b,_l)	bzero(_b, _l)	/*
+						 * XXX This is likely
+						 * incorrect. GO
+						 */
+
+#define	RF_UL(x)		((unsigned long)(x))
+#define	RF_PGMASK		RF_UL(NBPG-1)
+#define	RF_BLIP(x)		(NBPG - (RF_UL(x) & RF_PGMASK))	/*
+								 * Bytes left
+								 * in page.
+								 */
+#define	RF_PAGE_ALIGNED(x)	((RF_UL(x) & RF_PGMASK) == 0)
+
+#ifdef	__STDC__
+#define	RF_STRING(_str_)	#_str_
+#else	/* __STDC__ */
+#define	RF_STRING(_str_)	"_str_"
+#endif	/* __STDC__ */
+
+#endif	/* !_RF__RF_GENERAL_H_ */
diff --git a/sys/dev/raidframe/rf_geniq.c b/sys/dev/raidframe/rf_geniq.c
index fd824846f6c..a895fd43abd 100644
--- a/sys/dev/raidframe/rf_geniq.c
+++ b/sys/dev/raidframe/rf_geniq.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_geniq.c,v 1.4 2001/07/09 17:20:07 fgsch Exp $	*/
+/*	$OpenBSD: rf_geniq.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_geniq.c,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,23 +28,22 @@
  * rights to redistribute these changes.
  */
 
-/* rf_geniq.c
- *  code which implements Reed-Solomon encoding for RAID level 6
+/*
+ * rf_geniq.c -- Code which implements Reed-Solomon encoding for RAID level 6.
  */
 
 
-#define RF_UTILITY 1
+#define	RF_UTILITY	1
 #include "rf_pqdeg.h"
 
 /*
-   five bit lfsr
-   poly - feedback connections
-
-   val  = value;
-*/
-int 
-lsfr_shift(val, poly)
-	unsigned val, poly;
+ * five bit lfsr
+ * poly - feedback connections
+ *
+ * val  = value;
+ */
+int
+lsfr_shift(unsigned val, unsigned poly)
 {
 	unsigned new;
 	unsigned int i;
@@ -54,19 +54,21 @@ lsfr_shift(val, poly)
 
 	for (i = 1; i <= 4; i++) {
 		bit = (val >> (i - 1)) & 1;
-		if (poly & (1 << i))	/* there is a feedback connection */
+		if (poly & (1 << i))	/* There is a feedback connection. */
 			new = new | ((bit ^ high) << i);
 		else
 			new = new | (bit << i);
 	}
 	return new;
 }
-/* generate Q matricies for the data */
+
+
+/* Generate Q matrices for the data. */
 
 RF_ua32_t rf_qfor[32];
 
-void 
-main()
+int
+main(void)
 {
 	unsigned int i, j, l, a, b;
 	unsigned int val;
@@ -82,20 +84,20 @@ main()
 	printf(" * GENERATED FILE -- DO NOT EDIT\n");
 	printf(" */\n");
 	printf("\n");
-	printf("#ifndef _RF__RF_INVERTQ_H_\n");
-	printf("#define _RF__RF_INVERTQ_H_\n");
+	printf("#ifndef\t_RF__RF_INVERTQ_H_\n");
+	printf("#define\t_RF__RF_INVERTQ_H_\n");
 	printf("\n");
 	printf("/*\n");
 	printf(" * rf_geniq.c must include rf_archs.h before including\n");
 	printf(" * this file (to get VPATH magic right with the way we\n");
-	printf(" * generate this file in kernel trees)\n");
+	printf(" * generate this file in kernel trees).\n");
 	printf(" */\n");
 	printf("/* #include \"rf_archs.h\" */\n");
 	printf("\n");
-	printf("#if (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0)\n");
+	printf("#if\t(RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0)\n");
 	printf("\n");
-	printf("#define RF_Q_COLS 32\n");
-	printf("RF_ua32_t rf_rn = {\n");
+	printf("#define\tRF_Q_COLS\t32\n");
+	printf("RF_ua32_t rf_rn = {");
 	k[0] = 1;
 	for (j = 0; j < 31; j++)
 		k[j + 1] = lsfr_shift(k[j], 5);
@@ -105,7 +107,7 @@ main()
 
 	printf("RF_ua32_t rf_qfor[32] = {\n");
 	for (i = 0; i < 32; i++) {
-		printf("/* i = %d */ { 0, ", i);
+		printf("/* i = %d */\t{0, ", i);
 		rf_qfor[i][0] = 0;
 		for (j = 1; j < 32; j++) {
 			val = j;
@@ -117,47 +119,58 @@ main()
 		printf("},\n");
 	}
 	printf("};\n");
-	printf("#define RF_Q_DATA_COL(col_num) rf_rn[col_num],rf_qfor[28-(col_num)]\n");
+	printf("#define\tRF_Q_DATA_COL(col_num)\trf_rn[col_num],"
+	    " rf_qfor[28-(col_num)]\n");
 
 	/* generate the inverse tables. (i,j,p,q) */
 	/* The table just stores a. Get b back from the parity */
-	printf("#ifdef _KERNEL\n");
-	printf("RF_ua1024_t rf_qinv[1];        /* don't compile monster table into kernel */\n");
-	printf("#elif defined(NO_PQ)\n");
+	printf("#ifdef\t_KERNEL\n");
+	printf("RF_ua1024_t rf_qinv[1];\t/* don't compile monster table"
+	    " into kernel */\n");
+	printf("#elif\tdefined(NO_PQ)\n");
 	printf("RF_ua1024_t rf_qinv[29*29];\n");
-	printf("#else /* !_KERNEL && NO_PQ */\n");
+	printf("#else\t/* !_KERNEL && NO_PQ */\n");
 	printf("RF_ua1024_t rf_qinv[29*29] = {\n");
 	for (i = 0; i < 29; i++) {
 		for (j = 0; j < 29; j++) {
-			printf("/* i %d, j %d */{ ", i, j);
+			printf("/* i %d, j %d */\t{", i, j);
 			if (i == j)
 				for (l = 0; l < 1023; l++)
 					printf("0, ");
 			else {
 				for (p = 0; p < 32; p++)
 					for (q = 0; q < 32; q++) {
-						/* What are a, b such that a ^
-						 * b =  p; and qfor[(28-i)][a
+						/*
+						 * What are a, b such that a ^
+						 * b == p; and qfor[(28-i)][a
 						 * ^ rf_rn[i+1]] ^
 						 * qfor[(28-j)][b ^
-						 * rf_rn[j+1]] =  q. Solve by
-						 * guessing a. Then testing. */
+						 * rf_rn[j+1]] == q. Solve by
+						 * guessing a. Then testing.
+						 */
 						for (a = 0; a < 32; a++) {
 							b = a ^ p;
-							if ((rf_qfor[28 - i][a ^ k[i + 1]] ^ rf_qfor[28 - j][b ^ k[j + 1]]) == q)
+							if ((rf_qfor[28 - i]
+							     [a ^ k[i + 1]] ^
+							    rf_qfor[28 - j]
+							     [b ^ k[j + 1]]) ==
+							    q)
 								break;
 						}
 						if (a == 32)
-							printf("unable to solve %d %d %d %d\n", i, j, p, q);
-						printf("%d,", a);
+							printf("unable to solve"
+							    " %d %d %d %d\n",
+							    i, j, p, q);
+						printf("%d, ", a);
 					}
 			}
 			printf("},\n");
 		}
 	}
 	printf("};\n");
-	printf("\n#endif /* (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */\n\n");
-	printf("#endif /* !_KERNEL && NO_PQ */\n");
-	printf("#endif /* !_RF__RF_INVERTQ_H_ */\n");
+	printf("\n#endif\t/* (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */"
+	    "\n\n");
+	printf("#endif\t/* !_KERNEL && NO_PQ */\n");
+	printf("#endif\t/* !_RF__RF_INVERTQ_H_ */\n");
 	exit(0);
 }
diff --git a/sys/dev/raidframe/rf_hist.h b/sys/dev/raidframe/rf_hist.h
index 70104aa4f90..5f6d984bfa7 100644
--- a/sys/dev/raidframe/rf_hist.h
+++ b/sys/dev/raidframe/rf_hist.h
@@ -1,9 +1,10 @@
-/*	$OpenBSD: rf_hist.h,v 1.2 1999/02/16 00:02:51 niklas Exp $	*/
+/*	$OpenBSD: rf_hist.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_hist.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
+
 /*
  * rf_hist.h
  *
- * Histgram operations for RAIDframe stats
+ * Histgram operations for RAIDframe stats.
  */
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
@@ -32,26 +33,26 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_HIST_H_
-#define _RF__RF_HIST_H_
+#ifndef	_RF__RF_HIST_H_
+#define	_RF__RF_HIST_H_
 
 #include "rf_types.h"
 
-#define RF_HIST_RESOLUTION   5
-#define RF_HIST_MIN_VAL      0
-#define RF_HIST_MAX_VAL      1000
-#define RF_HIST_RANGE        (RF_HIST_MAX_VAL - RF_HIST_MIN_VAL)
-#define RF_HIST_NUM_BUCKETS  (RF_HIST_RANGE / RF_HIST_RESOLUTION + 1)
+#define	RF_HIST_RESOLUTION	   5
+#define	RF_HIST_MIN_VAL		   0
+#define	RF_HIST_MAX_VAL		1000
+#define	RF_HIST_RANGE		(RF_HIST_MAX_VAL - RF_HIST_MIN_VAL)
+#define	RF_HIST_NUM_BUCKETS	(RF_HIST_RANGE / RF_HIST_RESOLUTION + 1)
 
 typedef RF_uint32 RF_Hist_t;
 
-#define RF_HIST_ADD(_hist_,_val_) { \
-	RF_Hist_t val; \
-	val = ((RF_Hist_t)(_val_)) / 1000; \
-	if (val >= RF_HIST_MAX_VAL) \
-		_hist_[RF_HIST_NUM_BUCKETS-1]++; \
-	else \
-		_hist_[(val - RF_HIST_MIN_VAL) / RF_HIST_RESOLUTION]++; \
-}
+#define	RF_HIST_ADD(_hist_,_val_)	do {				\
+	RF_Hist_t val;							\
+	val = ((RF_Hist_t)(_val_)) / 1000;				\
+	if (val >= RF_HIST_MAX_VAL)					\
+		_hist_[RF_HIST_NUM_BUCKETS-1]++;			\
+	else								\
+		_hist_[(val - RF_HIST_MIN_VAL) / RF_HIST_RESOLUTION]++;	\
+} while (0)
 
-#endif				/* !_RF__RF_HIST_H_ */
+#endif	/* !_RF__RF_HIST_H_ */
diff --git a/sys/dev/raidframe/rf_interdecluster.c b/sys/dev/raidframe/rf_interdecluster.c
index e2e395f1a0d..7b0068663f8 100644
--- a/sys/dev/raidframe/rf_interdecluster.c
+++ b/sys/dev/raidframe/rf_interdecluster.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_interdecluster.c,v 1.3 2000/01/11 18:02:22 peter Exp $	*/
+/*	$OpenBSD: rf_interdecluster.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_interdecluster.c,v 1.4 2000/01/07 03:41:00 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/************************************************************
+/*************************************************************
  *
- * rf_interdecluster.c -- implements interleaved declustering
+ * rf_interdecluster.c -- Implements interleaved declustering.
  *
- ************************************************************/
+ *************************************************************/
 
 
 #include "rf_types.h"
@@ -48,34 +49,33 @@
 #include "rf_dagdegwr.h"
 
 typedef struct RF_InterdeclusterConfigInfo_s {
-	RF_RowCol_t **stripeIdentifier;	/* filled in at config time and used
-					 * by IdentifyStripe */
-	RF_StripeCount_t numSparingRegions;
-	RF_StripeCount_t stripeUnitsPerSparingRegion;
-	RF_SectorNum_t mirrorStripeOffset;
-}       RF_InterdeclusterConfigInfo_t;
-
-int 
-rf_ConfigureInterDecluster(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+	/* Filled in at config time and used by IdentifyStripe. */
+	RF_RowCol_t	**stripeIdentifier;
+	RF_StripeCount_t  numSparingRegions;
+	RF_StripeCount_t  stripeUnitsPerSparingRegion;
+	RF_SectorNum_t	  mirrorStripeOffset;
+}	RF_InterdeclusterConfigInfo_t;
+
+int
+rf_ConfigureInterDecluster(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_StripeCount_t num_used_stripeUnitsPerDisk;
 	RF_InterdeclusterConfigInfo_t *info;
 	RF_RowCol_t i, tmp, SUs_per_region;
 
-	/* create an Interleaved Declustering configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_InterdeclusterConfigInfo_t), (RF_InterdeclusterConfigInfo_t *),
-	    raidPtr->cleanupList);
+	/* Create an Interleaved Declustering configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_InterdeclusterConfigInfo_t),
+	    (RF_InterdeclusterConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
-	/* fill in the config structure.  */
+	/* Fill in the config structure. */
 	SUs_per_region = raidPtr->numCol * (raidPtr->numCol - 1);
-	info->stripeIdentifier = rf_make_2d_array(SUs_per_region, 2, raidPtr->cleanupList);
+	info->stripeIdentifier = rf_make_2d_array(SUs_per_region, 2,
+	    raidPtr->cleanupList);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
 	for (i = 0; i < SUs_per_region; i++) {
@@ -84,25 +84,35 @@ rf_ConfigureInterDecluster(
 		info->stripeIdentifier[i][1] = (i + 1 + tmp) % raidPtr->numCol;
 	}
 
-	/* no spare tables */
+	/* No spare tables. */
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	/* fill in the remaining layout parameters */
+	/* Fill in the remaining layout parameters. */
 
-	/* total number of stripes should a multiple of 2*numCol: Each sparing
+	/*
+	 * Total number of stripes should a multiple of 2*numCol: Each sparing
 	 * region consists of 2*numCol stripes: n-1 primary copy, n-1
-	 * secondary copy and 2 for spare .. */
-	num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk - (layoutPtr->stripeUnitsPerDisk %
-	    (2 * raidPtr->numCol));
-	info->numSparingRegions = num_used_stripeUnitsPerDisk / (2 * raidPtr->numCol);
-	/* this is in fact the number of stripe units (that are primary data
-	 * copies) in the sparing region */
-	info->stripeUnitsPerSparingRegion = raidPtr->numCol * (raidPtr->numCol - 1);
-	info->mirrorStripeOffset = info->numSparingRegions * (raidPtr->numCol + 1);
-	layoutPtr->numStripe = info->numSparingRegions * info->stripeUnitsPerSparingRegion;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	 * secondary copy and 2 for spare...
+	 */
+	num_used_stripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk -
+	    (layoutPtr->stripeUnitsPerDisk % (2 * raidPtr->numCol));
+	info->numSparingRegions = num_used_stripeUnitsPerDisk /
+	    (2 * raidPtr->numCol);
+	/*
+	 * This is in fact the number of stripe units (that are primary data
+	 * copies) in the sparing region.
+	 */
+	info->stripeUnitsPerSparingRegion = raidPtr->numCol *
+	    (raidPtr->numCol - 1);
+	info->mirrorStripeOffset = info->numSparingRegions *
+	    (raidPtr->numCol + 1);
+	layoutPtr->numStripe = info->numSparingRegions *
+	    info->stripeUnitsPerSparingRegion;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
+	    layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numParityCol = 1;
 
 	layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
@@ -113,48 +123,48 @@ rf_ConfigureInterDecluster(
 	raidPtr->totalSectors =
 	    (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
 
-	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
+	    layoutPtr->sectorsPerStripeUnit;
 
 	return (0);
 }
 
-int 
-rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t * raidPtr)
+int
+rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *raidPtr)
 {
 	return (30);
 }
 
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t * raidPtr)
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *raidPtr)
 {
 	return (raidPtr->sectorsPerDisk);
 }
 
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsInterDecluster(
-    RF_Raid_t * raidPtr)
+RF_ReconUnitCount_t
+rf_GetNumSpareRUsInterDecluster(RF_Raid_t *raidPtr)
 {
-	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 
 	return (2 * ((RF_ReconUnitCount_t) info->numSparingRegions));
-	/* the layout uses two stripe units per disk as spare within each
-	 * sparing region */
+	/*
+	 * The layout uses two stripe units per disk as spare within each
+	 * sparing region.
+	 */
 }
-/* Maps to the primary copy of the data, i.e. the first mirror pair */
-void 
-rf_MapSectorInterDecluster(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+
+/* Maps to the primary copy of the data, i.e. the first mirror pair. */
+void
+rf_MapSectorInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t* diskSector, int remap)
 {
-	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	RF_StripeNum_t su_offset_into_disk, mirror_su_offset_into_disk;
 	RF_StripeNum_t sparing_region_id, index_within_region;
-	int     col_before_remap;
+	int col_before_remap;
 
 	*row = 0;
 	sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
@@ -164,53 +174,64 @@ rf_MapSectorInterDecluster(
 	col_before_remap = index_within_region / (raidPtr->numCol - 1);
 
 	if (!remap) {
-		*col = col_before_remap;;
-		*diskSector = (su_offset_into_disk + ((raidPtr->numCol - 1) * sparing_region_id)) *
-		    raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		*col = col_before_remap;
+		*diskSector = (su_offset_into_disk + ((raidPtr->numCol - 1) *
+		    sparing_region_id)) * raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector +=
+		    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 	} else {
-		/* remap sector to spare space... */
-		*diskSector = sparing_region_id * (raidPtr->numCol + 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidPtr->numCol - 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
-		*col = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
+		/* Remap sector to spare space... */
+		*diskSector = sparing_region_id * (raidPtr->numCol + 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidPtr->numCol - 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector +=
+		    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		*col = (index_within_region + 1 + mirror_su_offset_into_disk) %
+		    raidPtr->numCol;
 		*col = (*col + 1) % raidPtr->numCol;
 		if (*col == col_before_remap)
 			*col = (*col + 1) % raidPtr->numCol;
 	}
 }
+
 /* Maps to the second copy of the mirror pair. */
-void 
-rf_MapParityInterDecluster(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
-	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
-	RF_StripeNum_t sparing_region_id, index_within_region, mirror_su_offset_into_disk;
+	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
+	RF_StripeNum_t sparing_region_id, index_within_region;
+	RF_StripeNum_t mirror_su_offset_into_disk;
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	int     col_before_remap;
+	int col_before_remap;
 
 	sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
 	index_within_region = SUID % info->stripeUnitsPerSparingRegion;
 	mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
-	col_before_remap = (index_within_region + 1 + mirror_su_offset_into_disk) % raidPtr->numCol;
+	col_before_remap = (index_within_region + 1 +
+	    mirror_su_offset_into_disk) % raidPtr->numCol;
 
 	*row = 0;
 	if (!remap) {
 		*col = col_before_remap;
-		*diskSector = info->mirrorStripeOffset * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += sparing_region_id * (raidPtr->numCol - 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += mirror_su_offset_into_disk * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		*diskSector = info->mirrorStripeOffset *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += sparing_region_id * (raidPtr->numCol - 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += mirror_su_offset_into_disk *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector +=
+		    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 	} else {
-		/* remap parity to spare space ... */
-		*diskSector = sparing_region_id * (raidPtr->numCol + 1) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit;
-		*diskSector += (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+		/* Remap parity to spare space... */
+		*diskSector = sparing_region_id * (raidPtr->numCol + 1) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidPtr->numCol) *
+		    raidPtr->Layout.sectorsPerStripeUnit;
+		*diskSector += (raidSector %
+		    raidPtr->Layout.sectorsPerStripeUnit);
 		*col = index_within_region / (raidPtr->numCol - 1);
 		*col = (*col + 1) % raidPtr->numCol;
 		if (*col == col_before_remap)
@@ -218,14 +239,12 @@ rf_MapParityInterDecluster(
 	}
 }
 
-void 
-rf_IdentifyStripeInterDecluster(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeInterDecluster(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_InterdeclusterConfigInfo_t *info = (RF_InterdeclusterConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 	RF_StripeNum_t SUID;
 
 	SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
@@ -235,45 +254,46 @@ rf_IdentifyStripeInterDecluster(
 	*diskids = info->stripeIdentifier[SUID];
 }
 
-void 
-rf_MapSIDToPSIDInterDecluster(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDInterDecluster( RF_RaidLayout_t *layoutPtr,
+    RF_StripeNum_t stripeID, RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
 }
-/******************************************************************************
- * select a graph to perform a single-stripe access
+
+
+/*****************************************************************************
+ * Select a graph to perform a single-stripe access.
  *
- * Parameters:  raidPtr    - description of the physical array
- *              type       - type of operation (read or write) requested
- *              asmap      - logical & physical addresses for this access
- *              createFunc - name of function to use to create the graph
+ * Parameters:	raidPtr	   - Description of the physical array.
+ *		type	   - Type of operation (read or write) requested.
+ *		asmap	   - Logical & physical addresses for this access.
+ *		createFunc - Name of function to use to create the graph.
  *****************************************************************************/
 
-void 
-rf_RAIDIDagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
+void
+rf_RAIDIDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 {
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 
 	if (asmap->numDataFailed + asmap->numParityFailed > 1) {
-		RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("Multiple disks failed in a single group !"
+		    "  Aborting I/O operation.\n");
 		*createFunc = NULL;
 		return;
 	}
-	*createFunc = (type == RF_IO_TYPE_READ) ? (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
+	*createFunc = (type == RF_IO_TYPE_READ)
+	    ? (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG
+	    : (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
 	if (type == RF_IO_TYPE_READ) {
 		if (asmap->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateMirrorPartitionReadDAG;
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateMirrorPartitionReadDAG;
 		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG;
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateRaidOneDegradedReadDAG;
 	} else
 		*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
 }
diff --git a/sys/dev/raidframe/rf_interdecluster.h b/sys/dev/raidframe/rf_interdecluster.h
index ac9388b45ae..328d1595348 100644
--- a/sys/dev/raidframe/rf_interdecluster.h
+++ b/sys/dev/raidframe/rf_interdecluster.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_interdecluster.h,v 1.2 1999/02/16 00:02:52 niklas Exp $	*/
+/*	$OpenBSD: rf_interdecluster.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_interdecluster.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -31,30 +32,23 @@
  * header file for Interleaved Declustering
  */
 
-#ifndef _RF__RF_INTERDECLUSTER_H_
-#define _RF__RF_INTERDECLUSTER_H_
+#ifndef	_RF__RF_INTERDECLUSTER_H_
+#define	_RF__RF_INTERDECLUSTER_H_
 
-int 
-rf_ConfigureInterDecluster(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int     rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t * raidPtr);
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t * raidPtr);
-RF_ReconUnitCount_t rf_GetNumSpareRUsInterDecluster(RF_Raid_t * raidPtr);
-void 
-rf_MapSectorInterDecluster(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityInterDecluster(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeInterDecluster(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDInterDecluster(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_RAIDIDagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
+int  rf_ConfigureInterDecluster(RF_ShutdownList_t **, RF_Raid_t *,
+	RF_Config_t *);
+int  rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t *);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t *);
+RF_ReconUnitCount_t rf_GetNumSpareRUsInterDecluster(RF_Raid_t *);
+void rf_MapSectorInterDecluster(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityInterDecluster(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+	RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeInterDecluster(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDInterDecluster(RF_RaidLayout_t *, RF_StripeNum_t,
+	RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_RAIDIDagSelect(RF_Raid_t *, RF_IoType_t, RF_AccessStripeMap_t *,
+	RF_VoidFuncPtr *);
 
-#endif				/* !_RF__RF_INTERDECLUSTER_H_ */
+#endif	/* !_RF__RF_INTERDECLUSTER_H_ */
diff --git a/sys/dev/raidframe/rf_invertq.c b/sys/dev/raidframe/rf_invertq.c
index 224e331fe39..d0462e5ffe7 100644
--- a/sys/dev/raidframe/rf_invertq.c
+++ b/sys/dev/raidframe/rf_invertq.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_invertq.c,v 1.2 1999/02/16 00:02:53 niklas Exp $	*/
+/*	$OpenBSD: rf_invertq.c,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_invertq.c,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
diff --git a/sys/dev/raidframe/rf_invertq.h b/sys/dev/raidframe/rf_invertq.h
index 35d387ae70a..99d4347b5e6 100644
--- a/sys/dev/raidframe/rf_invertq.h
+++ b/sys/dev/raidframe/rf_invertq.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_invertq.h,v 1.2 1999/02/16 00:02:53 niklas Exp $	*/
+/*	$OpenBSD: rf_invertq.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_invertq.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
+
 /*
  * rf_invertq.h
  */
@@ -7,19 +8,19 @@
  * This is normally a generated file.  Not so for Net- and OpenBSD.
  */
 
-#ifndef _RF__RF_INVERTQ_H_
-#define _RF__RF_INVERTQ_H_
+#ifndef	_RF__RF_INVERTQ_H_
+#define	_RF__RF_INVERTQ_H_
 
 /*
  * rf_geniq.c must include rf_archs.h before including
  * this file (to get VPATH magic right with the way we
- * generate this file in kernel trees)
+ * generate this file in kernel trees).
  */
 /* #include "rf_archs.h" */
 
-#if (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
+#if	(RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
 
-#define RF_Q_COLS 32
+#define	RF_Q_COLS	32
 RF_ua32_t rf_rn = {
 1, 2, 4, 8, 16, 5, 10, 20, 13, 26, 17, 7, 14, 28, 29, 31, 27, 19, 3, 6, 12, 24, 21, 15, 30, 25, 23, 11, 22, 9, 18, 1,};
 RF_ua32_t rf_qfor[32] = {
@@ -56,9 +57,8 @@ RF_ua32_t rf_qfor[32] = {
 	 /* i = 30 */ {0, 18, 1, 19, 2, 16, 3, 17, 4, 22, 5, 23, 6, 20, 7, 21, 8, 26, 9, 27, 10, 24, 11, 25, 12, 30, 13, 31, 14, 28, 15, 29,},
 	 /* i = 31 */ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,},
 };
-#define RF_Q_DATA_COL(col_num) rf_rn[col_num],rf_qfor[28-(col_num)]
+#define	RF_Q_DATA_COL(col_num)	rf_rn[col_num], rf_qfor[28-(col_num)]
 RF_ua1024_t rf_qinv[1];		/* don't compile monster table into kernel */
 
-#endif				/* (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 >
-				 * 0) */
-#endif				/* !_RF__RF_INVERTQ_H_ */
+#endif	/* (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */
+#endif	/* !_RF__RF_INVERTQ_H_ */
diff --git a/sys/dev/raidframe/rf_kintf.h b/sys/dev/raidframe/rf_kintf.h
index 9b71fea32dc..13fbd4e5878 100644
--- a/sys/dev/raidframe/rf_kintf.h
+++ b/sys/dev/raidframe/rf_kintf.h
@@ -1,9 +1,10 @@
-/*	$OpenBSD: rf_kintf.h,v 1.7 2001/12/29 21:51:18 tdeval Exp $	*/
+/*	$OpenBSD: rf_kintf.h,v 1.8 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_kintf.h,v 1.15 2000/10/20 02:24:45 oster Exp $	*/
+
 /*
  * rf_kintf.h
  *
- * RAIDframe exported kernel interface
+ * RAIDframe exported kernel interface.
  */
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
@@ -32,27 +33,27 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_KINTF_H_
-#define _RF__RF_KINTF_H_
+#ifndef	_RF__RF_KINTF_H_
+#define	_RF__RF_KINTF_H_
 
 #include "rf_types.h"
 
-int     rf_GetSpareTableFromDaemon(RF_SparetWait_t * req);
-void    raidstart(RF_Raid_t * raidPtr);
-int     rf_DispatchKernelIO(RF_DiskQueue_t * queue, RF_DiskQueueData_t * req);
+int  rf_GetSpareTableFromDaemon(RF_SparetWait_t *);
+void raidstart(RF_Raid_t *raidPtr);
+int  rf_DispatchKernelIO(RF_DiskQueue_t *, RF_DiskQueueData_t *);
 
-int raidwrite_component_label(dev_t, struct vnode *, RF_ComponentLabel_t *);
-int raidread_component_label(dev_t, struct vnode *, RF_ComponentLabel_t *);
+int  raidwrite_component_label(dev_t, struct vnode *, RF_ComponentLabel_t *);
+int  raidread_component_label(dev_t, struct vnode *, RF_ComponentLabel_t *);
 
-#define RF_NORMAL_COMPONENT_UPDATE 0
-#define RF_FINAL_COMPONENT_UPDATE 1
+#define	RF_NORMAL_COMPONENT_UPDATE	0
+#define	RF_FINAL_COMPONENT_UPDATE	1
 void rf_update_component_labels(RF_Raid_t *, int);
-int raidlookup(char *, struct proc *, struct vnode **);
-int raidmarkclean(dev_t dev, struct vnode *b_vp, int);
-int raidmarkdirty(dev_t dev, struct vnode *b_vp, int);
+int  raidlookup(char *, struct proc *, struct vnode **);
+int  raidmarkclean(dev_t dev, struct vnode *b_vp, int);
+int  raidmarkdirty(dev_t dev, struct vnode *b_vp, int);
 void raid_init_component_label(RF_Raid_t *, RF_ComponentLabel_t *);
 void rf_print_component_label(RF_ComponentLabel_t *);
 void rf_UnconfigureVnodes( RF_Raid_t * );
 void rf_close_component( RF_Raid_t *, struct vnode *, int);
 void rf_disk_unbusy(RF_RaidAccessDesc_t *);
-#endif				/* _RF__RF_KINTF_H_ */
+#endif	/* _RF__RF_KINTF_H_ */
diff --git a/sys/dev/raidframe/rf_layout.c b/sys/dev/raidframe/rf_layout.c
index bc83f0f7ea5..5b803863920 100644
--- a/sys/dev/raidframe/rf_layout.c
+++ b/sys/dev/raidframe/rf_layout.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_layout.c,v 1.5 2002/08/09 15:10:20 tdeval Exp $	*/
+/*	$OpenBSD: rf_layout.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_layout.c,v 1.6 2000/04/17 19:35:12 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,7 +28,8 @@
  * rights to redistribute these changes.
  */
 
-/* rf_layout.c -- driver code dealing with layout and mapping issues
+/*
+ * rf_layout.c -- Driver code dealing with layout and mapping issues.
  */
 
 #include "rf_types.h"
@@ -44,71 +46,77 @@
 #include "rf_raid4.h"
 #include "rf_raid5.h"
 #include "rf_states.h"
-#if RF_INCLUDE_RAID5_RS > 0
+#if	RF_INCLUDE_RAID5_RS > 0
 #include "rf_raid5_rotatedspare.h"
-#endif				/* RF_INCLUDE_RAID5_RS > 0 */
-#if RF_INCLUDE_CHAINDECLUSTER > 0
+#endif	/* RF_INCLUDE_RAID5_RS > 0 */
+#if	RF_INCLUDE_CHAINDECLUSTER > 0
 #include "rf_chaindecluster.h"
-#endif				/* RF_INCLUDE_CHAINDECLUSTER > 0 */
-#if RF_INCLUDE_INTERDECLUSTER > 0
+#endif	/* RF_INCLUDE_CHAINDECLUSTER > 0 */
+#if	RF_INCLUDE_INTERDECLUSTER > 0
 #include "rf_interdecluster.h"
-#endif				/* RF_INCLUDE_INTERDECLUSTER > 0 */
-#if RF_INCLUDE_PARITYLOGGING > 0
+#endif	/* RF_INCLUDE_INTERDECLUSTER > 0 */
+#if	RF_INCLUDE_PARITYLOGGING > 0
 #include "rf_paritylogging.h"
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-#if RF_INCLUDE_EVENODD > 0
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
+#if	RF_INCLUDE_EVENODD > 0
 #include "rf_evenodd.h"
-#endif				/* RF_INCLUDE_EVENODD > 0 */
+#endif	/* RF_INCLUDE_EVENODD > 0 */
 #include "rf_general.h"
 #include "rf_driver.h"
 #include "rf_parityscan.h"
 #include "rf_reconbuffer.h"
 #include "rf_reconutil.h"
 
-/***********************************************************************
+/*****************************************************************************
  *
- * the layout switch defines all the layouts that are supported.
- *    fields are: layout ID, init routine, shutdown routine, map
- *    sector, map parity, identify stripe, dag selection, map stripeid
- *    to parity stripe id (optional), num faults tolerated, special
- *    flags.
+ * The layout switch defines all the layouts that are supported.
+ * Fields are:	layout ID, init routine, shutdown routine, map sector,
+ *		map parity, identify stripe, dag selection, map stripeid
+ *		to parity stripe id (optional), num faults tolerated,
+ *		special flags.
  *
- ***********************************************************************/
-
-static RF_AccessState_t DefaultStates[] = {rf_QuiesceState,
-	rf_IncrAccessesCountState, rf_MapState, rf_LockState, rf_CreateDAGState,
-	rf_ExecuteDAGState, rf_ProcessDAGState, rf_DecrAccessesCountState,
-rf_CleanupState, rf_LastState};
-#if (defined(__NetBSD__) || defined(__OpenBSD__)) && !defined(_KERNEL)
-/* XXX Gross hack to shutup gcc -- it complains that DefaultStates is not
-used when compiling this in userland..  I hate to burst it's bubble, but
-DefaultStates is used all over the place here in the initialization of
-lots of data structures.  GO */
+ *****************************************************************************/
+
+static RF_AccessState_t DefaultStates[] = {
+	rf_QuiesceState, rf_IncrAccessesCountState, rf_MapState,
+	rf_LockState, rf_CreateDAGState, rf_ExecuteDAGState,
+	rf_ProcessDAGState, rf_DecrAccessesCountState,
+	rf_CleanupState, rf_LastState
+};
+
+#if	(defined(__NetBSD__) || defined(__OpenBSD__)) && !defined(_KERNEL)
+/*
+ * XXX Gross hack to shutup gcc -- It complains that DefaultStates is not
+ * used when compiling this in userland... I hate to burst it's bubble, but
+ * DefaultStates is used all over the place here in the initialization of
+ * lots of data structures. GO
+ */
 RF_AccessState_t *NothingAtAll = DefaultStates;
 #endif
 
-#if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
-/* XXX Remove static so GCC doesn't complain about these being unused! */
-int     distSpareYes = 1;
-int     distSpareNo = 0;
+#if	(defined(__NetBSD__) || defined(__OpenBSD__)) && defined(_KERNEL)
+/* XXX Remove static so GCC doesn't complain about these being unused ! */
+int distSpareYes = 1;
+int distSpareNo = 0;
 #else
 static int distSpareYes = 1;
 static int distSpareNo = 0;
 #endif
-#ifdef _KERNEL
-#define RF_NK2(a,b)
-#else				/* _KERNEL */
-#define RF_NK2(a,b) a,b,
-#endif				/* _KERNEL */
-
-#if RF_UTILITY > 0
-#define RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
-#else				/* RF_UTILITY > 0 */
-#define RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p
-#endif				/* RF_UTILITY > 0 */
+
+#ifdef	_KERNEL
+#define	RF_NK2(a,b)
+#else	/* _KERNEL */
+#define	RF_NK2(a,b)	a,b,
+#endif	/* !_KERNEL */
+
+#if	RF_UTILITY > 0
+#define	RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
+#else	/* RF_UTILITY > 0 */
+#define	RF_NU(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p
+#endif	/* RF_UTILITY > 0 */
 
 static RF_LayoutSW_t mapsw[] = {
-	/* parity declustering */
+	/* Parity declustering. */
 	{'T', "Parity declustering",
 		RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
 		RF_NU(
@@ -127,7 +135,7 @@ static RF_LayoutSW_t mapsw[] = {
 		    0)
 	},
 
-	/* parity declustering with distributed sparing */
+	/* Parity declustering with distributed sparing. */
 	{'D', "Distributed sparing parity declustering",
 		RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareYes)
 		RF_NU(
@@ -146,13 +154,14 @@ static RF_LayoutSW_t mapsw[] = {
 		    RF_DISTRIBUTE_SPARE | RF_BD_DECLUSTERED)
 	},
 
-#if RF_INCLUDE_DECL_PQ > 0
-	/* declustered P+Q */
+#if	RF_INCLUDE_DECL_PQ > 0
+	/* Declustered P+Q. */
 	{'Q', "Declustered P+Q",
 		RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
 		RF_NU(
 		    rf_ConfigureDeclusteredPQ,
-		    rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ, rf_MapQDeclusteredPQ,
+		    rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ,
+		    rf_MapQDeclusteredPQ,
 		    rf_IdentifyStripeDeclusteredPQ,
 		    rf_PQDagSelect,
 		    rf_MapSIDToPSIDDeclustered,
@@ -165,10 +174,10 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_DECL_PQ > 0 */
+#endif	/* RF_INCLUDE_DECL_PQ > 0 */
 
-#if RF_INCLUDE_RAID5_RS > 0
-	/* RAID 5 with rotated sparing */
+#if	RF_INCLUDE_RAID5_RS > 0
+	/* RAID 5 with rotated sparing. */
 	{'R', "RAID Level 5 rotated sparing",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -186,15 +195,16 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    RF_DISTRIBUTE_SPARE)
 	},
-#endif				/* RF_INCLUDE_RAID5_RS > 0 */
+#endif	/* RF_INCLUDE_RAID5_RS > 0 */
 
-#if RF_INCLUDE_CHAINDECLUSTER > 0
-	/* Chained Declustering */
+#if	RF_INCLUDE_CHAINDECLUSTER > 0
+	/* Chained Declustering. */
 	{'C', "Chained Declustering",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
 		    rf_ConfigureChainDecluster,
-		    rf_MapSectorChainDecluster, rf_MapParityChainDecluster, NULL,
+		    rf_MapSectorChainDecluster, rf_MapParityChainDecluster,
+		    NULL,
 		    rf_IdentifyStripeChainDecluster,
 		    rf_RAIDCDagSelect,
 		    rf_MapSIDToPSIDChainDecluster,
@@ -207,15 +217,16 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_CHAINDECLUSTER > 0 */
+#endif	/* RF_INCLUDE_CHAINDECLUSTER > 0 */
 
-#if RF_INCLUDE_INTERDECLUSTER > 0
-	/* Interleaved Declustering */
+#if	RF_INCLUDE_INTERDECLUSTER > 0
+	/* Interleaved Declustering. */
 	{'I', "Interleaved Declustering",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
 		    rf_ConfigureInterDecluster,
-		    rf_MapSectorInterDecluster, rf_MapParityInterDecluster, NULL,
+		    rf_MapSectorInterDecluster, rf_MapParityInterDecluster,
+		    NULL,
 		    rf_IdentifyStripeInterDecluster,
 		    rf_RAIDIDagSelect,
 		    rf_MapSIDToPSIDInterDecluster,
@@ -228,10 +239,10 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    RF_DISTRIBUTE_SPARE)
 	},
-#endif				/* RF_INCLUDE_INTERDECLUSTER > 0 */
+#endif	/* RF_INCLUDE_INTERDECLUSTER > 0 */
 
-#if RF_INCLUDE_RAID0 > 0
-	/* RAID level 0 */
+#if	RF_INCLUDE_RAID0 > 0
+	/* RAID level 0. */
 	{'0', "RAID Level 0",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -249,10 +260,10 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_RAID0 > 0 */
+#endif	/* RF_INCLUDE_RAID0 > 0 */
 
-#if RF_INCLUDE_RAID1 > 0
-	/* RAID level 1 */
+#if	RF_INCLUDE_RAID1 > 0
+	/* RAID level 1. */
 	{'1', "RAID Level 1",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -270,10 +281,10 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_RAID1 > 0 */
+#endif	/* RF_INCLUDE_RAID1 > 0 */
 
-#if RF_INCLUDE_RAID4 > 0
-	/* RAID level 4 */
+#if	RF_INCLUDE_RAID4 > 0
+	/* RAID level 4. */
 	{'4', "RAID Level 4",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -291,10 +302,10 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_RAID4 > 0 */
+#endif	/* RF_INCLUDE_RAID4 > 0 */
 
-#if RF_INCLUDE_RAID5 > 0
-	/* RAID level 5 */
+#if	RF_INCLUDE_RAID5 > 0
+	/* RAID level 5. */
 	{'5', "RAID Level 5",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -312,10 +323,10 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_RAID5 > 0 */
+#endif	/* RF_INCLUDE_RAID5 > 0 */
 
-#if RF_INCLUDE_EVENODD > 0
-	/* Evenodd */
+#if	RF_INCLUDE_EVENODD > 0
+	/* Evenodd. */
 	{'E', "EvenOdd",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -327,37 +338,38 @@ static RF_LayoutSW_t mapsw[] = {
 		    NULL,
 		    NULL,
 		    NULL, NULL,
-		    NULL,	/* no reconstruction, yet */
+		    NULL,	/* No reconstruction, yet. */
 		    rf_VerifyParityEvenOdd,
 		    2,
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_EVENODD > 0 */
+#endif	/* RF_INCLUDE_EVENODD > 0 */
 
-#if RF_INCLUDE_EVENODD > 0
-	/* Declustered Evenodd */
+#if	RF_INCLUDE_EVENODD > 0
+	/* Declustered Evenodd. */
 	{'e', "Declustered EvenOdd",
 		RF_NK2(rf_MakeLayoutSpecificDeclustered, &distSpareNo)
 		RF_NU(
 		    rf_ConfigureDeclusteredPQ,
-		    rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ, rf_MapQDeclusteredPQ,
+		    rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ,
+		    rf_MapQDeclusteredPQ,
 		    rf_IdentifyStripeDeclusteredPQ,
 		    rf_EODagSelect,
 		    rf_MapSIDToPSIDRAID5,
 		    rf_GetDefaultHeadSepLimitDeclustered,
 		    rf_GetDefaultNumFloatingReconBuffersPQ,
 		    NULL, NULL,
-		    NULL,	/* no reconstruction, yet */
+		    NULL,	/* No reconstruction, yet. */
 		    rf_VerifyParityEvenOdd,
 		    2,
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_EVENODD > 0 */
+#endif	/* RF_INCLUDE_EVENODD > 0 */
 
-#if RF_INCLUDE_PARITYLOGGING > 0
-	/* parity logging */
+#if	RF_INCLUDE_PARITYLOGGING > 0
+	/* Parity logging. */
 	{'L', "Parity logging",
 		RF_NK2(rf_MakeLayoutSpecificNULL, NULL)
 		RF_NU(
@@ -375,9 +387,9 @@ static RF_LayoutSW_t mapsw[] = {
 		    DefaultStates,
 		    0)
 	},
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
 
-	/* end-of-list marker */
+	/* End-of-list marker. */
 	{'\0', NULL,
 		RF_NK2(NULL, NULL)
 		RF_NU(
@@ -402,7 +414,7 @@ rf_GetLayout(RF_ParityConfig_t parityConfig)
 {
 	RF_LayoutSW_t *p;
 
-	/* look up the specific layout */
+	/* Look up the specific layout. */
 	for (p = &mapsw[0]; p->parityConfig; p++)
 		if (p->parityConfig == parityConfig)
 			break;
@@ -411,26 +423,25 @@ rf_GetLayout(RF_ParityConfig_t parityConfig)
 	RF_ASSERT(p->parityConfig == parityConfig);
 	return (p);
 }
-#if RF_UTILITY == 0
-/*****************************************************************************************
+
+#if	RF_UTILITY == 0
+/*****************************************************************************
  *
- * ConfigureLayout --
+ * ConfigureLayout
  *
- * read the configuration file and set up the RAID layout parameters.  After reading
- * common params, invokes the layout-specific configuration routine to finish
- * the configuration.
+ * Read the configuration file and set up the RAID layout parameters.
+ * After reading common params, invokes the layout-specific configuration
+ * routine to finish the configuration.
  *
- ****************************************************************************************/
-int 
-rf_ConfigureLayout(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+ *****************************************************************************/
+int
+rf_ConfigureLayout(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_ParityConfig_t parityConfig;
 	RF_LayoutSW_t *p;
-	int     retval;
+	int retval;
 
 	layoutPtr->sectorsPerStripeUnit = cfgPtr->sectPerSU;
 	layoutPtr->SUsPerPU = cfgPtr->SUsPerPU;
@@ -438,13 +449,13 @@ rf_ConfigureLayout(
 	parityConfig = cfgPtr->parityConfig;
 
 	if (layoutPtr->sectorsPerStripeUnit <= 0) {
-		RF_ERRORMSG2("raid%d: Invalid sectorsPerStripeUnit: %d\n",
-			     raidPtr->raidid, 
-			     (int)layoutPtr->sectorsPerStripeUnit );
-		return (EINVAL); 
+		RF_ERRORMSG2("raid%d: Invalid sectorsPerStripeUnit: %d.\n",
+		    raidPtr->raidid, (int)layoutPtr->sectorsPerStripeUnit);
+		return (EINVAL);
 	}
 
-	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk /
+	    layoutPtr->sectorsPerStripeUnit;
 
 	p = rf_GetLayout(parityConfig);
 	if (p == NULL) {
@@ -454,20 +465,23 @@ rf_ConfigureLayout(
 	RF_ASSERT(p->parityConfig == parityConfig);
 	layoutPtr->map = p;
 
-	/* initialize the specific layout */
+	/* Initialize the specific layout. */
 
 	retval = (p->Configure) (listp, raidPtr, cfgPtr);
 
 	if (retval)
 		return (retval);
 
-	layoutPtr->dataBytesPerStripe = layoutPtr->dataSectorsPerStripe << raidPtr->logBytesPerSector;
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataBytesPerStripe = layoutPtr->dataSectorsPerStripe <<
+	    raidPtr->logBytesPerSector;
+	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
+	    layoutPtr->sectorsPerStripeUnit;
 
 	if (rf_forceNumFloatingReconBufs >= 0) {
 		raidPtr->numFloatingReconBufs = rf_forceNumFloatingReconBufs;
 	} else {
-		raidPtr->numFloatingReconBufs = rf_GetDefaultNumFloatingReconBuffers(raidPtr);
+		raidPtr->numFloatingReconBufs =
+		    rf_GetDefaultNumFloatingReconBuffers(raidPtr);
 	}
 
 	if (rf_forceHeadSepLimit >= 0) {
@@ -479,12 +493,12 @@ rf_ConfigureLayout(
 #ifdef	RAIDDEBUG
 	if (raidPtr->headSepLimit >= 0) {
 		printf("RAIDFRAME(%s): Using %ld floating recon bufs"
-		    " with head sep limit %ld\n", layoutPtr->map->configName,
+		    " with head sep limit %ld.\n", layoutPtr->map->configName,
 		    (long) raidPtr->numFloatingReconBufs,
 		    (long) raidPtr->headSepLimit);
 	} else {
 		printf("RAIDFRAME(%s): Using %ld floating recon bufs"
-		    " with no head sep limit\n", layoutPtr->map->configName,
+		    " with no head sep limit.\n", layoutPtr->map->configName,
 		    (long) raidPtr->numFloatingReconBufs);
 	}
 #endif	/* RAIDDEBUG */
@@ -492,28 +506,28 @@ rf_ConfigureLayout(
 	return (0);
 }
 
-/* typically there is a 1-1 mapping between stripes and parity stripes.
- * however, the declustering code supports packing multiple stripes into
+/*
+ * Typically there is a 1-1 mapping between stripes and parity stripes.
+ * However, the declustering code supports packing multiple stripes into
  * a single parity stripe, so as to increase the size of the reconstruction
- * unit without affecting the size of the stripe unit.  This routine finds
- * the parity stripe identifier associated with a stripe ID.  There is also
+ * unit without affecting the size of the stripe unit. This routine finds
+ * the parity stripe identifier associated with a stripe ID. There is also
  * a RaidAddressToParityStripeID macro in layout.h
  */
-RF_StripeNum_t 
-rf_MapStripeIDToParityStripeID(layoutPtr, stripeID, which_ru)
-	RF_RaidLayout_t *layoutPtr;
-	RF_StripeNum_t stripeID;
-	RF_ReconUnitNum_t *which_ru;
+RF_StripeNum_t
+rf_MapStripeIDToParityStripeID(RF_RaidLayout_t *layoutPtr,
+    RF_StripeNum_t stripeID, RF_ReconUnitNum_t *which_ru)
 {
 	RF_StripeNum_t parityStripeID;
 
-	/* quick exit in the common case of SUsPerPU==1 */
+	/* Quick exit in the common case of SUsPerPU == 1. */
 	if ((layoutPtr->SUsPerPU == 1) || !layoutPtr->map->MapSIDToPSID) {
 		*which_ru = 0;
 		return (stripeID);
 	} else {
-		(layoutPtr->map->MapSIDToPSID) (layoutPtr, stripeID, &parityStripeID, which_ru);
+		(layoutPtr->map->MapSIDToPSID) (layoutPtr, stripeID,
+		    &parityStripeID, which_ru);
 	}
 	return (parityStripeID);
 }
-#endif				/* RF_UTILITY == 0 */
+#endif	/* RF_UTILITY == 0 */
diff --git a/sys/dev/raidframe/rf_layout.h b/sys/dev/raidframe/rf_layout.h
index a368fc8663a..beb62689a96 100644
--- a/sys/dev/raidframe/rf_layout.h
+++ b/sys/dev/raidframe/rf_layout.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_layout.h,v 1.4 2000/08/08 16:07:42 peter Exp $	*/
+/*	$OpenBSD: rf_layout.h,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_layout.h,v 1.4 2000/05/23 00:44:38 thorpej Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,324 +28,465 @@
  * rights to redistribute these changes.
  */
 
-/* rf_layout.h -- header file defining layout data structures
+/*
+ * rf_layout.h -- Header file defining layout data structures.
  */
 
-#ifndef _RF__RF_LAYOUT_H_
-#define _RF__RF_LAYOUT_H_
+#ifndef	_RF__RF_LAYOUT_H_
+#define	_RF__RF_LAYOUT_H_
 
 #include "rf_types.h"
 #include "rf_archs.h"
 #include "rf_alloclist.h"
 
-#ifndef _KERNEL
+#ifndef	_KERNEL
 #include <stdio.h>
 #endif
 
-/*****************************************************************************************
+/*****************************************************************************
  *
  * This structure identifies all layout-specific operations and parameters.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 typedef struct RF_LayoutSW_s {
-	RF_ParityConfig_t parityConfig;
-	const char *configName;
-
-#ifndef _KERNEL
-	/* layout-specific parsing */
-	int     (*MakeLayoutSpecific) (FILE * fp, RF_Config_t * cfgPtr, void *arg);
-	void   *makeLayoutSpecificArg;
-#endif				/* !_KERNEL */
-
-#if RF_UTILITY == 0
-	/* initialization routine */
-	int     (*Configure) (RF_ShutdownList_t ** shutdownListp, RF_Raid_t * raidPtr, RF_Config_t * cfgPtr);
-
-	/* routine to map RAID sector address -> physical (row, col, offset) */
-	void    (*MapSector) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-	            RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-
-	/* routine to map RAID sector address -> physical (r,c,o) of parity
-	 * unit */
-	void    (*MapParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-	            RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-
-	/* routine to map RAID sector address -> physical (r,c,o) of Q unit */
-	void    (*MapQ) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector, RF_RowCol_t * row,
-	            RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-
-	/* routine to identify the disks comprising a stripe */
-	void    (*IdentifyStripe) (RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-	            RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-
-	/* routine to select a dag */
-	void    (*SelectionFunc) (RF_Raid_t * raidPtr, RF_IoType_t type,
-	            RF_AccessStripeMap_t * asmap,
-	            RF_VoidFuncPtr *);
-#if 0
-	void    (**createFunc) (RF_Raid_t *,
-	            RF_AccessStripeMap_t *,
-	            RF_DagHeader_t *, void *,
-	            RF_RaidAccessFlags_t,
-/**INDENT** Warning@88: Extra ) */
-	            RF_AllocListElem_t *));
+	RF_ParityConfig_t	  parityConfig;
+	const char		 *configName;
+
+#ifndef	_KERNEL
+	/* Layout-specific parsing. */
+	int			(*MakeLayoutSpecific)
+				(FILE *, RF_Config_t *, void *);
+	void			 *makeLayoutSpecificArg;
+#endif	/* !_KERNEL */
+
+#if	RF_UTILITY == 0
+	/* Initialization routine. */
+	int			(*Configure)
+				(RF_ShutdownList_t **, RF_Raid_t *,
+				    RF_Config_t *);
+
+	/* Routine to map RAID sector address -> physical (row, col, offset). */
+	void			(*MapSector)
+				(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+				    RF_RowCol_t *, RF_SectorNum_t *, int);
 
+	/*
+	 * Routine to map RAID sector address -> physical (r,c,o) of parity
+	 * unit.
+	 */
+	void			(*MapParity)
+				(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+				    RF_RowCol_t *, RF_SectorNum_t *, int);
+
+	/* Routine to map RAID sector address -> physical (r,c,o) of Q unit. */
+	void			(*MapQ)
+				(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t *,
+				    RF_RowCol_t *, RF_SectorNum_t *, int);
+
+	/* Routine to identify the disks comprising a stripe. */
+	void			(*IdentifyStripe)
+				(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t **,
+				    RF_RowCol_t *);
+
+	/* Routine to select a dag. */
+	void			(*SelectionFunc)
+				(RF_Raid_t *, RF_IoType_t,
+				    RF_AccessStripeMap_t *, RF_VoidFuncPtr *);
+#if 0
+	void			(**createFunc)
+				(RF_Raid_t *, RF_AccessStripeMap_t *,
+				    RF_DagHeader_t *, void *,
+				    RF_RaidAccessFlags_t, RF_AllocListElem_t *);
 #endif
 
-	/* map a stripe ID to a parity stripe ID.  This is typically the
-	 * identity mapping */
-	void    (*MapSIDToPSID) (RF_RaidLayout_t * layoutPtr, RF_StripeNum_t stripeID,
-	            RF_StripeNum_t * psID, RF_ReconUnitNum_t * which_ru);
+	/*
+	 * Map a stripe ID to a parity stripe ID. This is typically the
+	 * identity mapping.
+	 */
+	void			(*MapSIDToPSID)
+				(RF_RaidLayout_t *, RF_StripeNum_t,
+				    RF_StripeNum_t *, RF_ReconUnitNum_t *);
 
-	/* get default head separation limit (may be NULL) */
-	        RF_HeadSepLimit_t(*GetDefaultHeadSepLimit) (RF_Raid_t * raidPtr);
+	/* Get default head separation limit (may be NULL). */
+	RF_HeadSepLimit_t	(*GetDefaultHeadSepLimit) (RF_Raid_t *);
 
-	/* get default num recon buffers (may be NULL) */
-	int     (*GetDefaultNumFloatingReconBuffers) (RF_Raid_t * raidPtr);
+	/* Get default num recon buffers (may be NULL). */
+	int			(*GetDefaultNumFloatingReconBuffers)
+				(RF_Raid_t *);
 
-	/* get number of spare recon units (may be NULL) */
-	        RF_ReconUnitCount_t(*GetNumSpareRUs) (RF_Raid_t * raidPtr);
+	/* Get number of spare recon units (may be NULL). */
+	RF_ReconUnitCount_t	(*GetNumSpareRUs) (RF_Raid_t *);
 
-	/* spare table installation (may be NULL) */
-	int     (*InstallSpareTable) (RF_Raid_t * raidPtr, RF_RowCol_t frow, RF_RowCol_t fcol);
+	/* Spare table installation (may be NULL). */
+	int			(*InstallSpareTable)
+				(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
 
-	/* recon buffer submission function */
-	int     (*SubmitReconBuffer) (RF_ReconBuffer_t * rbuf, int keep_it,
-	            int use_committed);
+	/* Recon buffer submission function. */
+	int			(*SubmitReconBuffer)
+				(RF_ReconBuffer_t *, int, int);
 
 	/*
-         * verify that parity information for a stripe is correct
-         * see rf_parityscan.h for return vals
-         */
-	int     (*VerifyParity) (RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-	            RF_PhysDiskAddr_t * parityPDA, int correct_it, RF_RaidAccessFlags_t flags);
+	 * Verify that parity information for a stripe is correct.
+	 * See rf_parityscan.h for return vals.
+	 */
+	int			(*VerifyParity)
+				(RF_Raid_t *, RF_RaidAddr_t,
+				    RF_PhysDiskAddr_t *, int,
+				    RF_RaidAccessFlags_t);
 
-	/* number of faults tolerated by this mapping */
-	int     faultsTolerated;
+	/* Number of faults tolerated by this mapping. */
+	int			  faultsTolerated;
 
-	/* states to step through in an access. Must end with "LastState". The
-	 * default is DefaultStates in rf_layout.c */
-	RF_AccessState_t *states;
+	/*
+	 * States to step through in an access. Must end with "LastState". The
+	 * default is DefaultStates in rf_layout.c .
+	 */
+	RF_AccessState_t	 *states;
 
 	RF_AccessStripeMapFlags_t flags;
-#endif				/* RF_UTILITY == 0 */
-}       RF_LayoutSW_t;
-/* enables remapping to spare location under dist sparing */
-#define RF_REMAP       1
-#define RF_DONT_REMAP  0
+#endif	/* RF_UTILITY == 0 */
+}	RF_LayoutSW_t;
+
+/* Enables remapping to spare location under dist sparing. */
+#define	RF_REMAP			1
+#define	RF_DONT_REMAP			0
 
 /*
- * Flags values for RF_AccessStripeMapFlags_t
+ * Flags values for RF_AccessStripeMapFlags_t.
  */
-#define RF_NO_STRIPE_LOCKS   0x0001	/* suppress stripe locks */
-#define RF_DISTRIBUTE_SPARE  0x0002	/* distribute spare space in archs
-					 * that support it */
-#define RF_BD_DECLUSTERED    0x0004	/* declustering uses block designs */
+#define	RF_NO_STRIPE_LOCKS	   0x0001	/* Suppress stripe locks. */
+#define	RF_DISTRIBUTE_SPARE	   0x0002	/*
+						 * Distribute spare space in
+						 * archs that support it.
+						 */
+#define	RF_BD_DECLUSTERED	   0x0004	/*
+						 * Declustering uses block
+						 * designs.
+						 */
 
 /*************************************************************************
  *
- * this structure forms the layout component of the main Raid
- * structure.  It describes everything needed to define and perform
+ * This structure forms the layout component of the main Raid
+ * structure. It describes everything needed to define and perform
  * the mapping of logical RAID addresses <-> physical disk addresses.
  *
  *************************************************************************/
 struct RF_RaidLayout_s {
-	/* configuration parameters */
-	RF_SectorCount_t sectorsPerStripeUnit;	/* number of sectors in one
-						 * stripe unit */
-	RF_StripeCount_t SUsPerPU;	/* stripe units per parity unit */
-	RF_StripeCount_t SUsPerRU;	/* stripe units per reconstruction
-					 * unit */
-
-	/* redundant-but-useful info computed from the above, used in all
-	 * layouts */
-	RF_StripeCount_t numStripe;	/* total number of stripes in the
-					 * array */
-	RF_SectorCount_t dataSectorsPerStripe;
-	RF_StripeCount_t dataStripeUnitsPerDisk;
-	u_int   bytesPerStripeUnit;
-	u_int   dataBytesPerStripe;
-	RF_StripeCount_t numDataCol;	/* number of SUs of data per stripe
-					 * (name here is a la RAID4) */
-	RF_StripeCount_t numParityCol;	/* number of SUs of parity per stripe.
-					 * Always 1 for now */
-	RF_StripeCount_t numParityLogCol;	/* number of SUs of parity log
-						 * per stripe.  Always 1 for
-						 * now */
-	RF_StripeCount_t stripeUnitsPerDisk;
-
-	RF_LayoutSW_t *map;	/* ptr to struct holding mapping fns and
-				 * information */
-	void   *layoutSpecificInfo;	/* ptr to a structure holding
-					 * layout-specific params */
+	/* Configuration parameters. */
+	RF_SectorCount_t	 sectorsPerStripeUnit;
+						/*
+						 * Number of sectors in one
+						 * stripe unit.
+						 */
+	RF_StripeCount_t	 SUsPerPU;	/*
+						 * Stripe units per parity unit.
+						 */
+	RF_StripeCount_t	 SUsPerRU;	/*
+						 * Stripe units per
+						 * reconstruction unit.
+						 */
+
+	/*
+	 * Redundant-but-useful info computed from the above, used in all
+	 * layouts.
+	 */
+	RF_StripeCount_t	 numStripe;	/*
+						 * Total number of stripes
+						 * in the array.
+						 */
+	RF_SectorCount_t	 dataSectorsPerStripe;
+	RF_StripeCount_t	 dataStripeUnitsPerDisk;
+	u_int			 bytesPerStripeUnit;
+	u_int			 dataBytesPerStripe;
+	RF_StripeCount_t	 numDataCol;	/*
+						 * Number of SUs of data per
+						 * stripe.
+						 * (name here is a la RAID4)
+						 */
+	RF_StripeCount_t	 numParityCol;	/*
+						 * Number of SUs of parity
+						 * per stripe.
+						 * Always 1 for now.
+						 */
+	RF_StripeCount_t	 numParityLogCol;
+						/*
+						 * Number of SUs of parity log
+						 * per stripe.
+						 * Always 1 for now.
+						 */
+	RF_StripeCount_t	 stripeUnitsPerDisk;
+
+	RF_LayoutSW_t		*map;		/*
+						 * Pointer to struct holding
+						 * mapping fns and information.
+						 */
+	void			*layoutSpecificInfo;
+						/* Pointer to a struct holding
+						 * layout-specific params.
+						 */
 };
-/*****************************************************************************************
+
+/*****************************************************************************
  *
- * The mapping code returns a pointer to a list of AccessStripeMap structures, which
- * describes all the mapping information about an access.  The list contains one
- * AccessStripeMap structure per stripe touched by the access.  Each element in the list
- * contains a stripe identifier and a pointer to a list of PhysDiskAddr structuress.  Each
- * element in this latter list describes the physical location of a stripe unit accessed
+ * The mapping code returns a pointer to a list of AccessStripeMap
+ * structures, which describes all the mapping information about an access.
+ * The list contains one AccessStripeMap structure per stripe touched by
+ * the access. Each element in the list contains a stripe identifier and
+ * a pointer to a list of PhysDiskAddr structuress. Each element in this
+ * latter list describes the physical location of a stripe unit accessed
  * within the corresponding stripe.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-#define RF_PDA_TYPE_DATA   0
-#define RF_PDA_TYPE_PARITY 1
-#define RF_PDA_TYPE_Q      2
+#define	RF_PDA_TYPE_DATA		0
+#define	RF_PDA_TYPE_PARITY		1
+#define	RF_PDA_TYPE_Q			2
 
 struct RF_PhysDiskAddr_s {
-	RF_RowCol_t row, col;	/* disk identifier */
-	RF_SectorNum_t startSector;	/* sector offset into the disk */
-	RF_SectorCount_t numSector;	/* number of sectors accessed */
-	int     type;		/* used by higher levels: currently, data,
-				 * parity, or q */
-	caddr_t bufPtr;		/* pointer to buffer supplying/receiving data */
-	RF_RaidAddr_t raidAddress;	/* raid address corresponding to this
-					 * physical disk address */
-	RF_PhysDiskAddr_t *next;
+	RF_RowCol_t		 row, col;	/* Disk identifier. */
+	RF_SectorNum_t		 startSector;	/*
+						 * Sector offset into the disk.
+						 */
+	RF_SectorCount_t	 numSector;	/*
+						 * Number of sectors accessed.
+						 */
+	int			 type;		/*
+						 * Used by higher levels:
+						 * currently data, parity,
+						 * or q.
+						 */
+	caddr_t			 bufPtr;	/*
+						 * Pointer to buffer
+						 * supplying/receiving data.
+						 */
+	RF_RaidAddr_t		 raidAddress;	/*
+						 * Raid address corresponding
+						 * to this physical disk
+						 * address.
+						 */
+	RF_PhysDiskAddr_t	*next;
 };
-#define RF_MAX_FAILED_PDA RF_MAXCOL
+#define	RF_MAX_FAILED_PDA		RF_MAXCOL
 
 struct RF_AccessStripeMap_s {
-	RF_StripeNum_t stripeID;/* the stripe index */
-	RF_RaidAddr_t raidAddress;	/* the starting raid address within
-					 * this stripe */
-	RF_RaidAddr_t endRaidAddress;	/* raid address one sector past the
-					 * end of the access */
-	RF_SectorCount_t totalSectorsAccessed;	/* total num sectors
-						 * identified in physInfo list */
-	RF_StripeCount_t numStripeUnitsAccessed;	/* total num elements in
-							 * physInfo list */
-	int     numDataFailed;	/* number of failed data disks accessed */
-	int     numParityFailed;/* number of failed parity disks accessed (0
-				 * or 1) */
-	int     numQFailed;	/* number of failed Q units accessed (0 or 1) */
-	RF_AccessStripeMapFlags_t flags;	/* various flags */
+	RF_StripeNum_t		 stripeID;	/* The stripe index. */
+	RF_RaidAddr_t		 raidAddress;	/*
+						 * The starting raid address
+						 * within this stripe.
+						 */
+	RF_RaidAddr_t		 endRaidAddress;/*
+						 * Raid address one sector past
+						 * the end of the access.
+						 */
+	RF_SectorCount_t	 totalSectorsAccessed;
+						/*
+						 * Total num sectors
+						 * identified in physInfo list.
+						 */
+	RF_StripeCount_t	 numStripeUnitsAccessed;
+						/*
+						 * Total num elements in
+						 * physInfo list.
+						 */
+	int			 numDataFailed;	/*
+						 * Number of failed data disks
+						 * accessed.
+						 */
+	int			 numParityFailed;
+						/*
+						 * Number of failed parity
+						 * disks accessed (0 or 1).
+						 */
+	int			 numQFailed;	/*
+						 * Number of failed Q units
+						 * accessed (0 or 1).
+						 */
+	RF_AccessStripeMapFlags_t flags;	/* Various flags. */
 #if 0
-	RF_PhysDiskAddr_t *failedPDA;	/* points to the PDA that has failed */
-	RF_PhysDiskAddr_t *failedPDAtwo;	/* points to the second PDA
-						 * that has failed, if any */
+	RF_PhysDiskAddr_t	*failedPDA;	/*
+						 * Points to the PDA that
+						 * has failed.
+						 */
+	RF_PhysDiskAddr_t	*failedPDAtwo;	/*
+						 * Points to the second PDA
+						 * that has failed, if any.
+						 */
 #else
-	int     numFailedPDAs;	/* number of failed phys addrs */
-	RF_PhysDiskAddr_t *failedPDAs[RF_MAX_FAILED_PDA];	/* array of failed phys
-								 * addrs */
+	int			 numFailedPDAs;	/*
+						 * Number of failed phys addrs.
+						 */
+	RF_PhysDiskAddr_t	*failedPDAs[RF_MAX_FAILED_PDA];
+						/*
+						 * Array of failed phys addrs.
+						 */
 #endif
-	RF_PhysDiskAddr_t *physInfo;	/* a list of PhysDiskAddr structs */
-	RF_PhysDiskAddr_t *parityInfo;	/* list of physical addrs for the
-					 * parity (P of P + Q ) */
-	RF_PhysDiskAddr_t *qInfo;	/* list of physical addrs for the Q of
-					 * P + Q */
-	RF_LockReqDesc_t lockReqDesc;	/* used for stripe locking */
-	RF_RowCol_t origRow;	/* the original row:  we may redirect the acc
-				 * to a different row */
-	RF_AccessStripeMap_t *next;
+	RF_PhysDiskAddr_t	*physInfo;	/*
+						 * A list of PhysDiskAddr
+						 * structs.
+						 */
+	RF_PhysDiskAddr_t	*parityInfo;	/*
+						 * List of physical addrs for
+						 * the parity (P of P + Q).
+						 */
+	RF_PhysDiskAddr_t	*qInfo;		/*
+						 * List of physical addrs for
+						 * the Q of P + Q.
+						 */
+	RF_LockReqDesc_t	 lockReqDesc;	/* Used for stripe locking. */
+	RF_RowCol_t		 origRow;	/*
+						 * The original row:  we may
+						 * redirect the acc to a
+						 * different row.
+						 */
+	RF_AccessStripeMap_t	*next;
 };
-/* flag values */
-#define RF_ASM_REDIR_LARGE_WRITE   0x00000001	/* allows large-write creation
-						 * code to redirect failed
-						 * accs */
-#define RF_ASM_BAILOUT_DAG_USED    0x00000002	/* allows us to detect
-						 * recursive calls to the
-						 * bailout write dag */
-#define RF_ASM_FLAGS_LOCK_TRIED    0x00000004	/* we've acquired the lock on
-						 * the first parity range in
-						 * this parity stripe */
-#define RF_ASM_FLAGS_LOCK_TRIED2   0x00000008	/* we've acquired the lock on
-						 * the 2nd   parity range in
-						 * this parity stripe */
-#define RF_ASM_FLAGS_FORCE_TRIED   0x00000010	/* we've done the force-recon
-						 * call on this parity stripe */
-#define RF_ASM_FLAGS_RECON_BLOCKED 0x00000020	/* we blocked recon => we must
-						 * unblock it later */
+/* Flag values. */
+#define	RF_ASM_REDIR_LARGE_WRITE	0x00000001	/*
+							 * Allows large-write
+							 * creation code to
+							 * redirect failed
+							 * accs.
+							 */
+#define	RF_ASM_BAILOUT_DAG_USED		0x00000002	/*
+							 * Allows us to detect
+							 * recursive calls to
+							 * the bailout write
+							 * dag.
+							 */
+#define	RF_ASM_FLAGS_LOCK_TRIED		0x00000004	/*
+							 * We've acquired the
+							 * lock on the first
+							 * parity range in
+							 * this parity stripe.
+							 */
+#define	RF_ASM_FLAGS_LOCK_TRIED2	0x00000008	/*
+							 * we've acquired the
+							 * lock on the 2nd
+							 * parity range in this
+							 * parity stripe.
+							 */
+#define	RF_ASM_FLAGS_FORCE_TRIED	0x00000010	/*
+							 * We've done the
+							 * force-recon call on
+							 * this parity stripe.
+							 */
+#define	RF_ASM_FLAGS_RECON_BLOCKED	0x00000020	/*
+							 * We blocked recon
+							 * => we must unblock
+							 * it later.
+							 */
 
 struct RF_AccessStripeMapHeader_s {
-	RF_StripeCount_t numStripes;	/* total number of stripes touched by
-					 * this acc */
-	RF_AccessStripeMap_t *stripeMap;	/* pointer to the actual map.
-						 * Also used for making lists */
+	RF_StripeCount_t	 numStripes;	/*
+						 * Total number of stripes
+						 * touched by this access.
+						 */
+	RF_AccessStripeMap_t	*stripeMap;	/*
+						 * Pointer to the actual map.
+						 * Also used for making lists.
+						 */
 	RF_AccessStripeMapHeader_t *next;
 };
-/*****************************************************************************************
+
+
+/*****************************************************************************
  *
- * various routines mapping addresses in the RAID address space.  These work across
- * all layouts.  DON'T PUT ANY LAYOUT-SPECIFIC CODE HERE.
+ * Various routines mapping addresses in the RAID address space. These work
+ * across all layouts. DON'T PUT ANY LAYOUT-SPECIFIC CODE HERE.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-/* return the identifier of the stripe containing the given address */
-#define rf_RaidAddressToStripeID(_layoutPtr_, _addr_) \
-  ( ((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) / (_layoutPtr_)->numDataCol )
+/* Return the identifier of the stripe containing the given address. */
+#define	rf_RaidAddressToStripeID(_layoutPtr_,_addr_)			\
+	(((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) /		\
+	 (_layoutPtr_)->numDataCol)
 
-/* return the raid address of the start of the indicates stripe ID */
-#define rf_StripeIDToRaidAddress(_layoutPtr_, _sid_) \
-  ( ((_sid_) * (_layoutPtr_)->sectorsPerStripeUnit) * (_layoutPtr_)->numDataCol )
+/* Return the raid address of the start of the indicates stripe ID. */
+#define	rf_StripeIDToRaidAddress(_layoutPtr_,_sid_)			\
+	(((_sid_) * (_layoutPtr_)->sectorsPerStripeUnit) *		\
+	 (_layoutPtr_)->numDataCol)
 
-/* return the identifier of the stripe containing the given stripe unit id */
-#define rf_StripeUnitIDToStripeID(_layoutPtr_, _addr_) \
-  ( (_addr_) / (_layoutPtr_)->numDataCol )
+/* Return the identifier of the stripe containing the given stripe unit ID. */
+#define	rf_StripeUnitIDToStripeID(_layoutPtr_,_addr_)			\
+	((_addr_) / (_layoutPtr_)->numDataCol)
 
-/* return the identifier of the stripe unit containing the given address */
-#define rf_RaidAddressToStripeUnitID(_layoutPtr_, _addr_) \
-  ( ((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) )
+/* Return the identifier of the stripe unit containing the given address. */
+#define	rf_RaidAddressToStripeUnitID(_layoutPtr_,_addr_)		\
+	(((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit))
 
-/* return the RAID address of next stripe boundary beyond the given address */
-#define rf_RaidAddressOfNextStripeBoundary(_layoutPtr_, _addr_) \
-  ( (((_addr_)/(_layoutPtr_)->dataSectorsPerStripe)+1) * (_layoutPtr_)->dataSectorsPerStripe )
+/* Return the RAID address of next stripe boundary beyond the given address. */
+#define	rf_RaidAddressOfNextStripeBoundary(_layoutPtr_,_addr_)		\
+	((((_addr_) / (_layoutPtr_)->dataSectorsPerStripe) + 1) *	\
+	 (_layoutPtr_)->dataSectorsPerStripe)
 
-/* return the RAID address of the start of the stripe containing the given address */
-#define rf_RaidAddressOfPrevStripeBoundary(_layoutPtr_, _addr_) \
-  ( (((_addr_)/(_layoutPtr_)->dataSectorsPerStripe)+0) * (_layoutPtr_)->dataSectorsPerStripe )
+/*
+ * Return the RAID address of the start of the stripe containing the
+ * given address.
+ */
+#define	rf_RaidAddressOfPrevStripeBoundary(_layoutPtr_,_addr_)		\
+	((((_addr_) / (_layoutPtr_)->dataSectorsPerStripe) + 0) *	\
+	 (_layoutPtr_)->dataSectorsPerStripe)
 
-/* return the RAID address of next stripe unit boundary beyond the given address */
-#define rf_RaidAddressOfNextStripeUnitBoundary(_layoutPtr_, _addr_) \
-  ( (((_addr_)/(_layoutPtr_)->sectorsPerStripeUnit)+1L)*(_layoutPtr_)->sectorsPerStripeUnit )
+/*
+ * Return the RAID address of next stripe unit boundary beyond the
+ * given address.
+ */
+#define	rf_RaidAddressOfNextStripeUnitBoundary(_layoutPtr_,_addr_)	\
+	((((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) + 1L) *	\
+	 (_layoutPtr_)->sectorsPerStripeUnit)
 
-/* return the RAID address of the start of the stripe unit containing RAID address _addr_ */
-#define rf_RaidAddressOfPrevStripeUnitBoundary(_layoutPtr_, _addr_) \
-  ( (((_addr_)/(_layoutPtr_)->sectorsPerStripeUnit)+0)*(_layoutPtr_)->sectorsPerStripeUnit )
+/*
+ * Return the RAID address of the start of the stripe unit containing
+ * RAID address _addr_.
+ */
+#define	rf_RaidAddressOfPrevStripeUnitBoundary(_layoutPtr_,_addr_)	\
+	((((_addr_) / (_layoutPtr_)->sectorsPerStripeUnit) + 0) *	\
+	 (_layoutPtr_)->sectorsPerStripeUnit)
 
-/* returns the offset into the stripe.  used by RaidAddressStripeAligned */
-#define rf_RaidAddressStripeOffset(_layoutPtr_, _addr_) \
-  ( (_addr_) % ((_layoutPtr_)->dataSectorsPerStripe) )
+/* Returns the offset into the stripe. Used by RaidAddressStripeAligned. */
+#define	rf_RaidAddressStripeOffset(_layoutPtr_,_addr_)			\
+	((_addr_) % (_layoutPtr_)->dataSectorsPerStripe)
 
-/* returns the offset into the stripe unit.  */
-#define rf_StripeUnitOffset(_layoutPtr_, _addr_) \
-  ( (_addr_) % ((_layoutPtr_)->sectorsPerStripeUnit) )
+/* Returns the offset into the stripe unit. */
+#define	rf_StripeUnitOffset(_layoutPtr_,_addr_)				\
+	((_addr_) % (_layoutPtr_)->sectorsPerStripeUnit)
 
-/* returns nonzero if the given RAID address is stripe-aligned */
-#define rf_RaidAddressStripeAligned( __layoutPtr__, __addr__ ) \
-  ( rf_RaidAddressStripeOffset(__layoutPtr__, __addr__) == 0 )
+/* Returns nonzero if the given RAID address is stripe-aligned. */
+#define	rf_RaidAddressStripeAligned(__layoutPtr__,__addr__)		\
+	(rf_RaidAddressStripeOffset(__layoutPtr__, __addr__) == 0)
 
-/* returns nonzero if the given address is stripe-unit aligned */
-#define rf_StripeUnitAligned( __layoutPtr__, __addr__ ) \
-  ( rf_StripeUnitOffset(__layoutPtr__, __addr__) == 0 )
+/* Returns nonzero if the given address is stripe-unit aligned. */
+#define	rf_StripeUnitAligned(__layoutPtr__,__addr__)			\
+	(rf_StripeUnitOffset(__layoutPtr__, __addr__) == 0)
 
-/* convert an address expressed in RAID blocks to/from an addr expressed in bytes */
-#define rf_RaidAddressToByte(_raidPtr_, _addr_) \
-  ( (_addr_) << ( (_raidPtr_)->logBytesPerSector ) )
+/*
+ * Convert an address expressed in RAID blocks to/from an addr expressed
+ * in bytes.
+ */
+#define	rf_RaidAddressToByte(_raidPtr_,_addr_)				\
+	((_addr_) << (_raidPtr_)->logBytesPerSector)
 
-#define rf_ByteToRaidAddress(_raidPtr_, _addr_) \
-  ( (_addr_) >> ( (_raidPtr_)->logBytesPerSector ) )
+#define	rf_ByteToRaidAddress(_raidPtr_,_addr_)				\
+	((_addr_) >> (_raidPtr_)->logBytesPerSector)
 
-/* convert a raid address to/from a parity stripe ID.  Conversion to raid address is easy,
- * since we're asking for the address of the first sector in the parity stripe.  Conversion to a
- * parity stripe ID is more complex, since stripes are not contiguously allocated in
- * parity stripes.
+/*
+ * Convert a raid address to/from a parity stripe ID. Conversion to raid
+ * address is easy, since we're asking for the address of the first sector
+ * in the parity stripe. Conversion to a parity stripe ID is more complex,
+ * since stripes are not contiguously allocated in parity stripes.
  */
-#define rf_RaidAddressToParityStripeID(_layoutPtr_, _addr_, _ru_num_) \
-  rf_MapStripeIDToParityStripeID( (_layoutPtr_), rf_RaidAddressToStripeID( (_layoutPtr_), (_addr_) ), (_ru_num_) )
+#define	rf_RaidAddressToParityStripeID(_layoutPtr_,_addr_,_ru_num_)	\
+	rf_MapStripeIDToParityStripeID((_layoutPtr_),			\
+	    rf_RaidAddressToStripeID((_layoutPtr_), (_addr_)), (_ru_num_))
 
-#define rf_ParityStripeIDToRaidAddress(_layoutPtr_, _psid_) \
-  ( (_psid_) * (_layoutPtr_)->SUsPerPU * (_layoutPtr_)->numDataCol * (_layoutPtr_)->sectorsPerStripeUnit )
+#define	rf_ParityStripeIDToRaidAddress(_layoutPtr_,_psid_)		\
+	((_psid_) * (_layoutPtr_)->SUsPerPU *				\
+	 (_layoutPtr_)->numDataCol * (_layoutPtr_)->sectorsPerStripeUnit)
 
-RF_LayoutSW_t *rf_GetLayout(RF_ParityConfig_t parityConfig);
-int 
-rf_ConfigureLayout(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-RF_StripeNum_t 
-rf_MapStripeIDToParityStripeID(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_ReconUnitNum_t * which_ru);
+RF_LayoutSW_t *rf_GetLayout(RF_ParityConfig_t);
+int  rf_ConfigureLayout(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+RF_StripeNum_t rf_MapStripeIDToParityStripeID(RF_RaidLayout_t *,
+	 RF_StripeNum_t, RF_ReconUnitNum_t *);
 
-#endif				/* !_RF__RF_LAYOUT_H_ */
+#endif	/* !_RF__RF_LAYOUT_H_ */
diff --git a/sys/dev/raidframe/rf_map.c b/sys/dev/raidframe/rf_map.c
index db5d6c7fd1c..bc36e17aaa8 100644
--- a/sys/dev/raidframe/rf_map.c
+++ b/sys/dev/raidframe/rf_map.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_map.c,v 1.4 2000/08/08 16:07:42 peter Exp $	*/
+/*	$OpenBSD: rf_map.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_map.c,v 1.5 2000/06/29 00:22:27 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/**************************************************************************
+/*****************************************************************************
  *
- * map.c -- main code for mapping RAID addresses to physical disk addresses
+ * map.c -- Main code for mapping RAID addresses to physical disk addresses.
  *
- **************************************************************************/
+ *****************************************************************************/
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
@@ -41,67 +42,74 @@
 #include "rf_freelist.h"
 #include "rf_shutdown.h"
 
-static void rf_FreePDAList(RF_PhysDiskAddr_t * start, RF_PhysDiskAddr_t * end, int count);
-static void 
-rf_FreeASMList(RF_AccessStripeMap_t * start, RF_AccessStripeMap_t * end,
-    int count);
+void rf_FreePDAList(RF_PhysDiskAddr_t *, RF_PhysDiskAddr_t *, int);
+void rf_FreeASMList(RF_AccessStripeMap_t *, RF_AccessStripeMap_t *, int);
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * MapAccess -- main 1st order mapping routine.
+ * MapAccess -- Main 1st order mapping routine.
  *
- * Maps an access in the RAID address space to the corresponding set of physical disk
- * addresses.  The result is returned as a list of AccessStripeMap structures, one per
- * stripe accessed.  Each ASM structure contains a pointer to a list of PhysDiskAddr
- * structures, which describe the physical locations touched by the user access.  Note
- * that this routine returns only static mapping information, i.e. the list of physical
- * addresses returned does not necessarily identify the set of physical locations that
- * will actually be read or written.
+ * Maps an access in the RAID address space to the corresponding set of
+ * physical disk addresses. The result is returned as a list of
+ * AccessStripeMap structures, one per stripe accessed. Each ASM structure
+ * contains a pointer to a list of PhysDiskAddr structures, which describe
+ * the physical locations touched by the user access. Note that this routine
+ * returns only static mapping information, i.e. the list of physical
+ * addresses returned does not necessarily identify the set of physical
+ * locations that will actually be read or written.
  *
- * The routine also maps the parity.  The physical disk location returned always
- * indicates the entire parity unit, even when only a subset of it is being accessed.
- * This is because an access that is not stripe unit aligned but that spans a stripe
- * unit boundary may require access two distinct portions of the parity unit, and we
- * can't yet tell which portion(s) we'll actually need.  We leave it up to the algorithm
+ * The routine also maps the parity. The physical disk location returned
+ * always indicates the entire parity unit, even when only a subset of it
+ * is being accessed. This is because an access that is not stripe unit
+ * aligned but that spans a stripe unit boundary may require access two
+ * distinct portions of the parity unit, and we can't yet tell which
+ * portion(s) we'll actually need. We leave it up to the algorithm
  * selection code to decide what subset of the parity unit to access.
  *
- * Note that addresses in the RAID address space must always be maintained as
- * longs, instead of ints.
+ * Note that addresses in the RAID address space must always be maintained
+ * as longs, instead of ints.
  *
- * This routine returns NULL if numBlocks is 0
+ * This routine returns NULL if numBlocks is 0.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 RF_AccessStripeMapHeader_t *
-rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
-	RF_Raid_t *raidPtr;
-	RF_RaidAddr_t raidAddress;	/* starting address in RAID address
-					 * space */
-	RF_SectorCount_t numBlocks;	/* number of blocks in RAID address
-					 * space to access */
-	caddr_t buffer;		/* buffer to supply/receive data */
-	int     remap;		/* 1 => remap addresses to spare space */
+rf_MapAccess(
+	RF_Raid_t	*raidPtr,
+	RF_RaidAddr_t	 raidAddress,	/*
+					 * Starting address in RAID address
+					 * space.
+					 */
+	RF_SectorCount_t numBlocks,	/*
+					 * Number of blocks in RAID address
+					 * space to access.
+					 */
+	caddr_t		 buffer,	/* Buffer to supply/receive data. */
+	int		 remap		/*
+					 * 1 => remap addresses to spare space.
+					 */
+)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_AccessStripeMapHeader_t *asm_hdr = NULL;
 	RF_AccessStripeMap_t *asm_list = NULL, *asm_p = NULL;
-	int     faultsTolerated = layoutPtr->map->faultsTolerated;
-	RF_RaidAddr_t startAddress = raidAddress;	/* we'll change
-							 * raidAddress along the
-							 * way */
+	int faultsTolerated = layoutPtr->map->faultsTolerated;
+	/* We'll change raidAddress along the way. */
+	RF_RaidAddr_t startAddress = raidAddress;
 	RF_RaidAddr_t endAddress = raidAddress + numBlocks;
 	RF_RaidDisk_t **disks = raidPtr->Disks;
 
 	RF_PhysDiskAddr_t *pda_p, *pda_q;
 	RF_StripeCount_t numStripes = 0;
-	RF_RaidAddr_t stripeRealEndAddress, stripeEndAddress, nextStripeUnitAddress;
+	RF_RaidAddr_t stripeRealEndAddress, stripeEndAddress;
+	RF_RaidAddr_t nextStripeUnitAddress;
 	RF_RaidAddr_t startAddrWithinStripe, lastRaidAddr;
 	RF_StripeCount_t totStripes;
 	RF_StripeNum_t stripeID, lastSID, SUID, lastSUID;
 	RF_AccessStripeMap_t *asmList, *t_asm;
 	RF_PhysDiskAddr_t *pdaList, *t_pda;
 
-	/* allocate all the ASMs and PDAs up front */
+	/* Allocate all the ASMs and PDAs up front. */
 	lastRaidAddr = raidAddress + numBlocks - 1;
 	stripeID = rf_RaidAddressToStripeID(layoutPtr, raidAddress);
 	lastSID = rf_RaidAddressToStripeID(layoutPtr, lastRaidAddr);
@@ -110,18 +118,21 @@ rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
 	lastSUID = rf_RaidAddressToStripeUnitID(layoutPtr, lastRaidAddr);
 
 	asmList = rf_AllocASMList(totStripes);
-	pdaList = rf_AllocPDAList(lastSUID - SUID + 1 + faultsTolerated * totStripes);	/* may also need pda(s)
-											 * per stripe for parity */
+	pdaList = rf_AllocPDAList(lastSUID - SUID + 1 +
+	    faultsTolerated * totStripes);	/*
+						 * May also need pda(s)
+						 * per stripe for parity.
+						 */
 
 	if (raidAddress + numBlocks > raidPtr->totalSectors) {
-		RF_ERRORMSG1("Unable to map access because offset (%d) was invalid\n",
-		    (int) raidAddress);
+		RF_ERRORMSG1("Unable to map access because offset (%d)"
+		    " was invalid\n", (int) raidAddress);
 		return (NULL);
 	}
 	if (rf_mapDebug)
 		rf_PrintRaidAddressInfo(raidPtr, raidAddress, numBlocks);
 	for (; raidAddress < endAddress;) {
-		/* make the next stripe structure */
+		/* Make the next stripe structure. */
 		RF_ASSERT(asmList);
 		t_asm = asmList;
 		asmList = asmList->next;
@@ -134,20 +145,24 @@ rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
 		}
 		numStripes++;
 
-		/* map SUs from current location to the end of the stripe */
-		asm_p->stripeID =	/* rf_RaidAddressToStripeID(layoutPtr,
-		        raidAddress) */ stripeID++;
-		stripeRealEndAddress = rf_RaidAddressOfNextStripeBoundary(layoutPtr, raidAddress);
+		/* Map SUs from current location to the end of the stripe. */
+		asm_p->stripeID =
+		/* rf_RaidAddressToStripeID(layoutPtr, raidAddress) */
+		    stripeID++;
+		stripeRealEndAddress =
+		    rf_RaidAddressOfNextStripeBoundary(layoutPtr, raidAddress);
 		stripeEndAddress = RF_MIN(endAddress, stripeRealEndAddress);
 		asm_p->raidAddress = raidAddress;
 		asm_p->endRaidAddress = stripeEndAddress;
 
-		/* map each stripe unit in the stripe */
+		/* Map each stripe unit in the stripe. */
 		pda_p = NULL;
-		startAddrWithinStripe = raidAddress;	/* Raid addr of start of
-							 * portion of access
-							 * that is within this
-							 * stripe */
+		/*
+		 * Raid addr of start of portion of access that is within this
+		 * stripe.
+		 */
+		startAddrWithinStripe = raidAddress;
+
 		for (; raidAddress < stripeEndAddress;) {
 			RF_ASSERT(pdaList);
 			t_pda = pdaList;
@@ -161,52 +176,75 @@ rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
 			}
 
 			pda_p->type = RF_PDA_TYPE_DATA;
-			(layoutPtr->map->MapSector) (raidPtr, raidAddress, &(pda_p->row), &(pda_p->col), &(pda_p->startSector), remap);
-
-			/* mark any failures we find.  failedPDA is don't-care
-			 * if there is more than one failure */
-			pda_p->raidAddress = raidAddress;	/* the RAID address
-								 * corresponding to this
-								 * physical disk address */
-			nextStripeUnitAddress = rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, raidAddress);
-			pda_p->numSector = RF_MIN(endAddress, nextStripeUnitAddress) - raidAddress;
+			(layoutPtr->map->MapSector) (raidPtr, raidAddress,
+			    &(pda_p->row), &(pda_p->col),
+			    &(pda_p->startSector), remap);
+
+			/*
+			 * Mark any failures we find.
+			 * failedPDA is don't-care if there is more than
+			 * one failure.
+			 */
+			/*
+			 * The RAID address corresponding to this physical
+			 * disk address.
+			 */
+			pda_p->raidAddress = raidAddress;
+			nextStripeUnitAddress =
+			    rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr,
+			     raidAddress);
+			pda_p->numSector = RF_MIN(endAddress,
+			    nextStripeUnitAddress) - raidAddress;
 			RF_ASSERT(pda_p->numSector != 0);
 			rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 0);
-			pda_p->bufPtr = buffer + rf_RaidAddressToByte(raidPtr, (raidAddress - startAddress));
+			pda_p->bufPtr = buffer + rf_RaidAddressToByte(raidPtr,
+			    (raidAddress - startAddress));
 			asm_p->totalSectorsAccessed += pda_p->numSector;
 			asm_p->numStripeUnitsAccessed++;
-			asm_p->origRow = pda_p->row;	/* redundant but
+			asm_p->origRow = pda_p->row;	/*
+							 * Redundant but
 							 * harmless to do this
 							 * in every loop
-							 * iteration */
+							 * iteration.
+							 */
 
 			raidAddress = RF_MIN(endAddress, nextStripeUnitAddress);
 		}
 
-		/* Map the parity. At this stage, the startSector and
+		/*
+		 * Map the parity. At this stage, the startSector and
 		 * numSector fields for the parity unit are always set to
 		 * indicate the entire parity unit. We may modify this after
-		 * mapping the data portion. */
+		 * mapping the data portion.
+		 */
 		switch (faultsTolerated) {
 		case 0:
 			break;
-		case 1:	/* single fault tolerant */
+		case 1:	/* Single fault tolerant. */
 			RF_ASSERT(pdaList);
 			t_pda = pdaList;
 			pdaList = pdaList->next;
 			bzero((char *) t_pda, sizeof(RF_PhysDiskAddr_t));
 			pda_p = asm_p->parityInfo = t_pda;
 			pda_p->type = RF_PDA_TYPE_PARITY;
-			(layoutPtr->map->MapParity) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe),
-			    &(pda_p->row), &(pda_p->col), &(pda_p->startSector), remap);
+			(layoutPtr->map->MapParity) (raidPtr,
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe), &(pda_p->row),
+			    &(pda_p->col), &(pda_p->startSector), remap);
 			pda_p->numSector = layoutPtr->sectorsPerStripeUnit;
-			/* raidAddr may be needed to find unit to redirect to */
-			pda_p->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe);
+			/*
+			 * raidAddr may be needed to find unit to redirect to.
+			 */
+			pda_p->raidAddress =
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe);
 			rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1);
-			rf_ASMParityAdjust(asm_p->parityInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p);
+			rf_ASMParityAdjust(asm_p->parityInfo,
+			    startAddrWithinStripe, endAddress,
+			    layoutPtr, asm_p);
 
 			break;
-		case 2:	/* two fault tolerant */
+		case 2:	/* Two fault tolerant. */
 			RF_ASSERT(pdaList && pdaList->next);
 			t_pda = pdaList;
 			pdaList = pdaList->next;
@@ -218,24 +256,38 @@ rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
 			bzero((char *) t_pda, sizeof(RF_PhysDiskAddr_t));
 			pda_q = asm_p->qInfo = t_pda;
 			pda_q->type = RF_PDA_TYPE_Q;
-			(layoutPtr->map->MapParity) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe),
-			    &(pda_p->row), &(pda_p->col), &(pda_p->startSector), remap);
-			(layoutPtr->map->MapQ) (raidPtr, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe),
-			    &(pda_q->row), &(pda_q->col), &(pda_q->startSector), remap);
-			pda_q->numSector = pda_p->numSector = layoutPtr->sectorsPerStripeUnit;
-			/* raidAddr may be needed to find unit to redirect to */
-			pda_p->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe);
-			pda_q->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, startAddrWithinStripe);
-			/* failure mode stuff */
+			(layoutPtr->map->MapParity) (raidPtr,
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe), &(pda_p->row),
+			    &(pda_p->col), &(pda_p->startSector), remap);
+			(layoutPtr->map->MapQ) (raidPtr,
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe), &(pda_q->row),
+			    &(pda_q->col), &(pda_q->startSector), remap);
+			pda_q->numSector = pda_p->numSector =
+			    layoutPtr->sectorsPerStripeUnit;
+			/*
+			 * raidAddr may be needed to find unit to redirect to.
+			 */
+			pda_p->raidAddress =
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe);
+			pda_q->raidAddress =
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe);
+			/* Failure mode stuff. */
 			rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 1);
 			rf_ASMCheckStatus(raidPtr, pda_q, asm_p, disks, 1);
-			rf_ASMParityAdjust(asm_p->parityInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p);
-			rf_ASMParityAdjust(asm_p->qInfo, startAddrWithinStripe, endAddress, layoutPtr, asm_p);
+			rf_ASMParityAdjust(asm_p->parityInfo,
+			    startAddrWithinStripe, endAddress,
+			    layoutPtr, asm_p);
+			rf_ASMParityAdjust(asm_p->qInfo, startAddrWithinStripe,
+			    endAddress, layoutPtr, asm_p);
 			break;
 		}
 	}
 	RF_ASSERT(asmList == NULL && pdaList == NULL);
-	/* make the header structure */
+	/* Make the header structure. */
 	asm_hdr = rf_AllocAccessStripeMapHeader();
 	RF_ASSERT(numStripes == totStripes);
 	asm_hdr->numStripes = numStripes;
@@ -245,25 +297,24 @@ rf_MapAccess(raidPtr, raidAddress, numBlocks, buffer, remap)
 		rf_PrintAccessStripeMap(asm_hdr);
 	return (asm_hdr);
 }
-/*****************************************************************************************
+
+/*****************************************************************************
  * This routine walks through an ASM list and marks the PDAs that have failed.
  * It's called only when a disk failure causes an in-flight DAG to fail.
- * The parity may consist of two components, but we want to use only one failedPDA
- * pointer.  Thus we set failedPDA to point to the first parity component, and rely
- * on the rest of the code to do the right thing with this.
- ****************************************************************************************/
-
-void 
-rf_MarkFailuresInASMList(raidPtr, asm_h)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMapHeader_t *asm_h;
+ * The parity may consist of two components, but we want to use only one
+ * failedPDA pointer. Thus we set failedPDA to point to the first parity
+ * component, and rely on the rest of the code to do the right thing with this.
+ *****************************************************************************/
+void
+rf_MarkFailuresInASMList(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asm_h)
 {
 	RF_RaidDisk_t **disks = raidPtr->Disks;
 	RF_AccessStripeMap_t *asmap;
 	RF_PhysDiskAddr_t *pda;
 
 	for (asmap = asm_h->stripeMap; asmap; asmap = asmap->next) {
-		asmap->numDataFailed = asmap->numParityFailed = asmap->numQFailed = 0;
+		asmap->numDataFailed = asmap->numParityFailed =
+		    asmap->numQFailed = 0;
 		asmap->numFailedPDAs = 0;
 		bzero((char *) asmap->failedPDAs,
 		    RF_MAX_FAILED_PDA * sizeof(RF_PhysDiskAddr_t *));
@@ -288,14 +339,14 @@ rf_MarkFailuresInASMList(raidPtr, asm_h)
 		}
 	}
 }
-/*****************************************************************************************
+
+/*****************************************************************************
  *
- * DuplicateASM -- duplicates an ASM and returns the new one
+ * DuplicateASM -- Duplicates an ASM and returns the new one.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 RF_AccessStripeMap_t *
-rf_DuplicateASM(asmap)
-	RF_AccessStripeMap_t *asmap;
+rf_DuplicateASM(RF_AccessStripeMap_t *asmap)
 {
 	RF_AccessStripeMap_t *new_asm;
 	RF_PhysDiskAddr_t *pda, *new_pda, *t_pda;
@@ -309,8 +360,8 @@ rf_DuplicateASM(asmap)
 	new_asm->parityInfo = NULL;
 	new_asm->next = NULL;
 
-	for (pda = asmap->physInfo; pda; pda = pda->next) {	/* copy the physInfo
-								 * list */
+	for (pda = asmap->physInfo; pda; pda = pda->next) {
+		/* Copy the physInfo list. */
 		t_pda = rf_AllocPhysDiskAddr();
 		bcopy((char *) pda, (char *) t_pda, sizeof(RF_PhysDiskAddr_t));
 		t_pda->next = NULL;
@@ -324,8 +375,8 @@ rf_DuplicateASM(asmap)
 		if (pda == asmap->failedPDAs[0])
 			new_asm->failedPDAs[0] = t_pda;
 	}
-	for (pda = asmap->parityInfo; pda; pda = pda->next) {	/* copy the parityInfo
-								 * list */
+	for (pda = asmap->parityInfo; pda; pda = pda->next) {
+		/* Copy the parityInfo list. */
 		t_pda = rf_AllocPhysDiskAddr();
 		bcopy((char *) pda, (char *) t_pda, sizeof(RF_PhysDiskAddr_t));
 		t_pda->next = NULL;
@@ -341,14 +392,14 @@ rf_DuplicateASM(asmap)
 	}
 	return (new_asm);
 }
-/*****************************************************************************************
+
+/*****************************************************************************
  *
- * DuplicatePDA -- duplicates a PDA and returns the new one
+ * DuplicatePDA -- Duplicates a PDA and returns the new one.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 RF_PhysDiskAddr_t *
-rf_DuplicatePDA(pda)
-	RF_PhysDiskAddr_t *pda;
+rf_DuplicatePDA(RF_PhysDiskAddr_t *pda)
 {
 	RF_PhysDiskAddr_t *new;
 
@@ -356,47 +407,50 @@ rf_DuplicatePDA(pda)
 	bcopy((char *) pda, (char *) new, sizeof(RF_PhysDiskAddr_t));
 	return (new);
 }
-/*****************************************************************************************
+
+/*****************************************************************************
  *
- * routines to allocate and free list elements.  All allocation routines zero the
- * structure before returning it.
+ * Routines to allocate and free list elements. All allocation routines zero
+ * the structure before returning it.
  *
- * FreePhysDiskAddr is static.  It should never be called directly, because
+ * FreePhysDiskAddr is static. It should never be called directly, because
  * FreeAccessStripeMap takes care of freeing the PhysDiskAddr list.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
 static RF_FreeList_t *rf_asmhdr_freelist;
-#define RF_MAX_FREE_ASMHDR 128
-#define RF_ASMHDR_INC       16
-#define RF_ASMHDR_INITIAL   32
+#define	RF_MAX_FREE_ASMHDR		128
+#define	RF_ASMHDR_INC			 16
+#define	RF_ASMHDR_INITIAL		 32
 
 static RF_FreeList_t *rf_asm_freelist;
-#define RF_MAX_FREE_ASM 192
-#define RF_ASM_INC       24
-#define RF_ASM_INITIAL   64
+#define	RF_MAX_FREE_ASM			192
+#define	RF_ASM_INC			 24
+#define	RF_ASM_INITIAL			 64
 
 static RF_FreeList_t *rf_pda_freelist;
-#define RF_MAX_FREE_PDA 192
-#define RF_PDA_INC       24
-#define RF_PDA_INITIAL   64
-
-/* called at shutdown time.  So far, all that is necessary is to release all the free lists */
-static void rf_ShutdownMapModule(void *);
-static void 
-rf_ShutdownMapModule(ignored)
-	void   *ignored;
+#define	RF_MAX_FREE_PDA			192
+#define	RF_PDA_INC			 24
+#define	RF_PDA_INITIAL			 64
+
+/*
+ * Called at shutdown time. So far, all that is necessary is to release
+ * all the free lists.
+ */
+void rf_ShutdownMapModule(void *);
+void
+rf_ShutdownMapModule(void *ignored)
 {
-	RF_FREELIST_DESTROY(rf_asmhdr_freelist, next, (RF_AccessStripeMapHeader_t *));
+	RF_FREELIST_DESTROY(rf_asmhdr_freelist, next,
+	    (RF_AccessStripeMapHeader_t *));
 	RF_FREELIST_DESTROY(rf_pda_freelist, next, (RF_PhysDiskAddr_t *));
 	RF_FREELIST_DESTROY(rf_asm_freelist, next, (RF_AccessStripeMap_t *));
 }
 
-int 
-rf_ConfigureMapModule(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureMapModule(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_asmhdr_freelist, RF_MAX_FREE_ASMHDR,
 	    RF_ASMHDR_INC, sizeof(RF_AccessStripeMapHeader_t));
@@ -406,20 +460,23 @@ rf_ConfigureMapModule(listp)
 	RF_FREELIST_CREATE(rf_asm_freelist, RF_MAX_FREE_ASM,
 	    RF_ASM_INC, sizeof(RF_AccessStripeMap_t));
 	if (rf_asm_freelist == NULL) {
-		RF_FREELIST_DESTROY(rf_asmhdr_freelist, next, (RF_AccessStripeMapHeader_t *));
+		RF_FREELIST_DESTROY(rf_asmhdr_freelist, next,
+		    (RF_AccessStripeMapHeader_t *));
 		return (ENOMEM);
 	}
-	RF_FREELIST_CREATE(rf_pda_freelist, RF_MAX_FREE_PDA,
-	    RF_PDA_INC, sizeof(RF_PhysDiskAddr_t));
+	RF_FREELIST_CREATE(rf_pda_freelist, RF_MAX_FREE_PDA, RF_PDA_INC,
+	    sizeof(RF_PhysDiskAddr_t));
 	if (rf_pda_freelist == NULL) {
-		RF_FREELIST_DESTROY(rf_asmhdr_freelist, next, (RF_AccessStripeMapHeader_t *));
-		RF_FREELIST_DESTROY(rf_pda_freelist, next, (RF_PhysDiskAddr_t *));
+		RF_FREELIST_DESTROY(rf_asmhdr_freelist, next,
+		    (RF_AccessStripeMapHeader_t *));
+		RF_FREELIST_DESTROY(rf_pda_freelist, next,
+		    (RF_PhysDiskAddr_t *));
 		return (ENOMEM);
 	}
 	rc = rf_ShutdownCreate(listp, rf_ShutdownMapModule, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownMapModule(NULL);
 		return (rc);
 	}
@@ -434,26 +491,25 @@ rf_ConfigureMapModule(listp)
 }
 
 RF_AccessStripeMapHeader_t *
-rf_AllocAccessStripeMapHeader()
+rf_AllocAccessStripeMapHeader(void)
 {
 	RF_AccessStripeMapHeader_t *p;
 
-	RF_FREELIST_GET(rf_asmhdr_freelist, p, next, (RF_AccessStripeMapHeader_t *));
+	RF_FREELIST_GET(rf_asmhdr_freelist, p, next,
+	    (RF_AccessStripeMapHeader_t *));
 	bzero((char *) p, sizeof(RF_AccessStripeMapHeader_t));
 
 	return (p);
 }
 
-
-void 
-rf_FreeAccessStripeMapHeader(p)
-	RF_AccessStripeMapHeader_t *p;
+void
+rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t *p)
 {
 	RF_FREELIST_FREE(rf_asmhdr_freelist, p, next);
 }
 
 RF_PhysDiskAddr_t *
-rf_AllocPhysDiskAddr()
+rf_AllocPhysDiskAddr(void)
 {
 	RF_PhysDiskAddr_t *p;
 
@@ -462,39 +518,43 @@ rf_AllocPhysDiskAddr()
 
 	return (p);
 }
-/* allocates a list of PDAs, locking the free list only once
- * when we have to call calloc, we do it one component at a time to simplify
- * the process of freeing the list at program shutdown.  This should not be
+
+/*
+ * Allocates a list of PDAs, locking the free list only once.
+ * When we have to call calloc, we do it one component at a time to simplify
+ * the process of freeing the list at program shutdown. This should not be
  * much of a performance hit, because it should be very infrequently executed.
  */
 RF_PhysDiskAddr_t *
-rf_AllocPDAList(count)
-	int     count;
+rf_AllocPDAList(int count)
 {
 	RF_PhysDiskAddr_t *p = NULL;
 
-	RF_FREELIST_GET_N(rf_pda_freelist, p, next, (RF_PhysDiskAddr_t *), count);
+	RF_FREELIST_GET_N(rf_pda_freelist, p, next, (RF_PhysDiskAddr_t *),
+	    count);
 	return (p);
 }
 
-void 
-rf_FreePhysDiskAddr(p)
-	RF_PhysDiskAddr_t *p;
+void
+rf_FreePhysDiskAddr(RF_PhysDiskAddr_t *p)
 {
 	RF_FREELIST_FREE(rf_pda_freelist, p, next);
 }
 
-static void 
-rf_FreePDAList(l_start, l_end, count)
-	RF_PhysDiskAddr_t *l_start, *l_end;	/* pointers to start and end
-						 * of list */
-	int     count;		/* number of elements in list */
+void
+rf_FreePDAList(
+	/* Pointers to start and end of list. */
+	RF_PhysDiskAddr_t	*l_start,
+	RF_PhysDiskAddr_t	*l_end,
+	int			 count	/* Number of elements in list. */
+)
 {
-	RF_FREELIST_FREE_N(rf_pda_freelist, l_start, next, (RF_PhysDiskAddr_t *), count);
+	RF_FREELIST_FREE_N(rf_pda_freelist, l_start, next,
+	    (RF_PhysDiskAddr_t *), count);
 }
 
 RF_AccessStripeMap_t *
-rf_AllocAccessStripeMapComponent()
+rf_AllocAccessStripeMapComponent(void)
 {
 	RF_AccessStripeMap_t *p;
 
@@ -503,47 +563,47 @@ rf_AllocAccessStripeMapComponent()
 
 	return (p);
 }
-/* this is essentially identical to AllocPDAList.  I should combine the two.
- * when we have to call calloc, we do it one component at a time to simplify
- * the process of freeing the list at program shutdown.  This should not be
+
+/*
+ * This is essentially identical to AllocPDAList. I should combine the two.
+ * When we have to call calloc, we do it one component at a time to simplify
+ * the process of freeing the list at program shutdown. This should not be
  * much of a performance hit, because it should be very infrequently executed.
  */
 RF_AccessStripeMap_t *
-rf_AllocASMList(count)
-	int     count;
+rf_AllocASMList(int count)
 {
 	RF_AccessStripeMap_t *p = NULL;
 
-	RF_FREELIST_GET_N(rf_asm_freelist, p, next, (RF_AccessStripeMap_t *), count);
+	RF_FREELIST_GET_N(rf_asm_freelist, p, next, (RF_AccessStripeMap_t *),
+	    count);
 	return (p);
 }
 
-void 
-rf_FreeAccessStripeMapComponent(p)
-	RF_AccessStripeMap_t *p;
+void
+rf_FreeAccessStripeMapComponent(RF_AccessStripeMap_t *p)
 {
 	RF_FREELIST_FREE(rf_asm_freelist, p, next);
 }
 
-static void 
-rf_FreeASMList(l_start, l_end, count)
-	RF_AccessStripeMap_t *l_start, *l_end;
-	int     count;
+void
+rf_FreeASMList(RF_AccessStripeMap_t *l_start, RF_AccessStripeMap_t *l_end,
+    int count)
 {
-	RF_FREELIST_FREE_N(rf_asm_freelist, l_start, next, (RF_AccessStripeMap_t *), count);
+	RF_FREELIST_FREE_N(rf_asm_freelist, l_start, next,
+	    (RF_AccessStripeMap_t *), count);
 }
 
-void 
-rf_FreeAccessStripeMap(hdr)
-	RF_AccessStripeMapHeader_t *hdr;
+void
+rf_FreeAccessStripeMap(RF_AccessStripeMapHeader_t *hdr)
 {
 	RF_AccessStripeMap_t *p, *pt = NULL;
 	RF_PhysDiskAddr_t *pdp, *trailer, *pdaList = NULL, *pdaEnd = NULL;
-	int     count = 0, t, asm_count = 0;
+	int count = 0, t, asm_count = 0;
 
 	for (p = hdr->stripeMap; p; p = p->next) {
 
-		/* link the 3 pda lists into the accumulating pda list */
+		/* Link the 3 pda lists into the accumulating pda list. */
 
 		if (!pdaList)
 			pdaList = p->qInfo;
@@ -585,7 +645,7 @@ rf_FreeAccessStripeMap(hdr)
 		asm_count++;
 	}
 
-	/* debug only */
+	/* Debug only. */
 	for (t = 0, pdp = pdaList; pdp; pdp = pdp->next)
 		t++;
 	RF_ASSERT(t == count);
@@ -595,54 +655,70 @@ rf_FreeAccessStripeMap(hdr)
 	rf_FreeASMList(hdr->stripeMap, pt, asm_count);
 	rf_FreeAccessStripeMapHeader(hdr);
 }
-/* We can't use the large write optimization if there are any failures in the stripe.
- * In the declustered layout, there is no way to immediately determine what disks
- * constitute a stripe, so we actually have to hunt through the stripe looking for failures.
- * The reason we map the parity instead of just using asm->parityInfo->col is because
- * the latter may have been already redirected to a spare drive, which would
- * mess up the computation of the stripe offset.
+
+/*
+ * We can't use the large write optimization if there are any failures in the
+ * stripe.
+ * In the declustered layout, there is no way to immediately determine what
+ * disks constitute a stripe, so we actually have to hunt through the stripe
+ * looking for failures.
+ * The reason we map the parity instead of just using asm->parityInfo->col is
+ * because the latter may have been already redirected to a spare drive, which
+ * would mess up the computation of the stripe offset.
  *
  * ASSUMES AT MOST ONE FAILURE IN THE STRIPE.
  */
-int 
-rf_CheckStripeForFailures(raidPtr, asmap)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *asmap;
+int
+rf_CheckStripeForFailures(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
 {
 	RF_RowCol_t trow, tcol, prow, pcol, *diskids, row, i;
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_StripeCount_t stripeOffset;
-	int     numFailures;
+	int numFailures;
 	RF_RaidAddr_t sosAddr;
 	RF_SectorNum_t diskOffset, poffset;
 	RF_RowCol_t testrow;
 
-	/* quick out in the fault-free case.  */
+	/* Quick out in the fault-free case. */
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	numFailures = raidPtr->numFailures;
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
 	if (numFailures == 0)
 		return (0);
 
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
+	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+	    asmap->raidAddress);
 	row = asmap->physInfo->row;
-	(layoutPtr->map->IdentifyStripe) (raidPtr, asmap->raidAddress, &diskids, &testrow);
-	(layoutPtr->map->MapParity) (raidPtr, asmap->raidAddress, &prow, &pcol, &poffset, 0);	/* get pcol */
-
-	/* this need not be true if we've redirected the access to a spare in
-	 * another row RF_ASSERT(row == testrow); */
+	(layoutPtr->map->IdentifyStripe) (raidPtr, asmap->raidAddress,
+	    &diskids, &testrow);
+	(layoutPtr->map->MapParity) (raidPtr, asmap->raidAddress,
+	    &prow, &pcol, &poffset, 0);	/* get pcol */
+
+	/*
+	 * This needs not be true if we've redirected the access to a spare in
+	 * another row.
+	 * RF_ASSERT(row == testrow);
+	 */
 	stripeOffset = 0;
 	for (i = 0; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++) {
 		if (diskids[i] != pcol) {
-			if (RF_DEAD_DISK(raidPtr->Disks[testrow][diskids[i]].status)) {
-				if (raidPtr->status[testrow] != rf_rs_reconstructing)
+			if (RF_DEAD_DISK(raidPtr
+			    ->Disks[testrow][diskids[i]].status)) {
+				if (raidPtr->status[testrow] !=
+				    rf_rs_reconstructing)
 					return (1);
-				RF_ASSERT(raidPtr->reconControl[testrow]->fcol == diskids[i]);
+				RF_ASSERT(
+				    raidPtr->reconControl[testrow]->fcol ==
+				    diskids[i]);
 				layoutPtr->map->MapSector(raidPtr,
-				    sosAddr + stripeOffset * layoutPtr->sectorsPerStripeUnit,
+				    sosAddr + stripeOffset *
+				    layoutPtr->sectorsPerStripeUnit,
 				    &trow, &tcol, &diskOffset, 0);
-				RF_ASSERT((trow == testrow) && (tcol == diskids[i]));
-				if (!rf_CheckRUReconstructed(raidPtr->reconControl[testrow]->reconMap, diskOffset))
+				RF_ASSERT((trow == testrow) &&
+				    (tcol == diskids[i]));
+				if (!rf_CheckRUReconstructed(raidPtr
+				     ->reconControl[testrow]->reconMap,
+				     diskOffset))
 					return (1);
 				asmap->flags |= RF_ASM_REDIR_LARGE_WRITE;
 				return (0);
@@ -652,22 +728,20 @@ rf_CheckStripeForFailures(raidPtr, asmap)
 	}
 	return (0);
 }
-/*
-   return the number of failed data units in the stripe.
-*/
 
-int 
-rf_NumFailedDataUnitsInStripe(raidPtr, asmap)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *asmap;
+/*
+ * Return the number of failed data units in the stripe.
+ */
+int
+rf_NumFailedDataUnitsInStripe(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_RowCol_t trow, tcol, row, i;
 	RF_SectorNum_t diskOffset;
 	RF_RaidAddr_t sosAddr;
-	int     numFailures;
+	int numFailures;
 
-	/* quick out in the fault-free case.  */
+	/* Quick out in the fault-free case. */
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	numFailures = raidPtr->numFailures;
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
@@ -675,10 +749,12 @@ rf_NumFailedDataUnitsInStripe(raidPtr, asmap)
 		return (0);
 	numFailures = 0;
 
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
+	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+	    asmap->raidAddress);
 	row = asmap->physInfo->row;
 	for (i = 0; i < layoutPtr->numDataCol; i++) {
-		(layoutPtr->map->MapSector) (raidPtr, sosAddr + i * layoutPtr->sectorsPerStripeUnit,
+		(layoutPtr->map->MapSector) (raidPtr, sosAddr + i *
+		    layoutPtr->sectorsPerStripeUnit,
 		    &trow, &tcol, &diskOffset, 0);
 		if (RF_DEAD_DISK(raidPtr->Disks[trow][tcol].status))
 			numFailures++;
@@ -688,58 +764,62 @@ rf_NumFailedDataUnitsInStripe(raidPtr, asmap)
 }
 
 
-/*****************************************************************************************
+/*****************************************************************************
  *
- * debug routines
+ * Debug routines.
  *
- ****************************************************************************************/
+ *****************************************************************************/
 
-void 
-rf_PrintAccessStripeMap(asm_h)
-	RF_AccessStripeMapHeader_t *asm_h;
+void
+rf_PrintAccessStripeMap(RF_AccessStripeMapHeader_t *asm_h)
 {
 	rf_PrintFullAccessStripeMap(asm_h, 0);
 }
 
-void 
-rf_PrintFullAccessStripeMap(asm_h, prbuf)
-	RF_AccessStripeMapHeader_t *asm_h;
-	int     prbuf;		/* flag to print buffer pointers */
+void
+rf_PrintFullAccessStripeMap(RF_AccessStripeMapHeader_t *asm_h,
+    int prbuf	/* Flag to print buffer pointers. */)
 {
-	int     i;
+	int i;
 	RF_AccessStripeMap_t *asmap = asm_h->stripeMap;
 	RF_PhysDiskAddr_t *p;
 	printf("%d stripes total\n", (int) asm_h->numStripes);
 	for (; asmap; asmap = asmap->next) {
-		/* printf("Num failures: %d\n",asmap->numDataFailed); */
-		/* printf("Num sectors:
-		 * %d\n",(int)asmap->totalSectorsAccessed); */
+		/* printf("Num failures: %d\n", asmap->numDataFailed); */
+		/* printf("Num sectors: %d\n",
+		 * (int)asmap->totalSectorsAccessed); */
 		printf("Stripe %d (%d sectors), failures: %d data, %d parity: ",
 		    (int) asmap->stripeID,
 		    (int) asmap->totalSectorsAccessed,
 		    (int) asmap->numDataFailed,
 		    (int) asmap->numParityFailed);
 		if (asmap->parityInfo) {
-			printf("Parity [r%d c%d s%d-%d", asmap->parityInfo->row, asmap->parityInfo->col,
+			printf("Parity [r%d c%d s%d-%d", asmap->parityInfo->row,
+			    asmap->parityInfo->col,
 			    (int) asmap->parityInfo->startSector,
 			    (int) (asmap->parityInfo->startSector +
-				asmap->parityInfo->numSector - 1));
+			    asmap->parityInfo->numSector - 1));
 			if (prbuf)
-				printf(" b0x%lx", (unsigned long) asmap->parityInfo->bufPtr);
+				printf(" b0x%lx",
+				    (unsigned long) asmap->parityInfo->bufPtr);
 			if (asmap->parityInfo->next) {
-				printf(", r%d c%d s%d-%d", asmap->parityInfo->next->row,
+				printf(", r%d c%d s%d-%d",
+				    asmap->parityInfo->next->row,
 				    asmap->parityInfo->next->col,
 				    (int) asmap->parityInfo->next->startSector,
-				    (int) (asmap->parityInfo->next->startSector +
-					asmap->parityInfo->next->numSector - 1));
+				    (int) (asmap->parityInfo->next->startSector
+				    + asmap->parityInfo->next->numSector - 1));
 				if (prbuf)
-					printf(" b0x%lx", (unsigned long) asmap->parityInfo->next->bufPtr);
-				RF_ASSERT(asmap->parityInfo->next->next == NULL);
+					printf(" b0x%lx", (unsigned long)
+					    asmap->parityInfo->next->bufPtr);
+				RF_ASSERT(asmap->parityInfo->next->next
+				    == NULL);
 			}
 			printf("]\n\t");
 		}
 		for (i = 0, p = asmap->physInfo; p; p = p->next, i++) {
-			printf("SU r%d c%d s%d-%d ", p->row, p->col, (int) p->startSector,
+			printf("SU r%d c%d s%d-%d ", p->row, p->col,
+			    (int) p->startSector,
 			    (int) (p->startSector + p->numSector - 1));
 			if (prbuf)
 				printf("b0x%lx ", (unsigned long) p->bufPtr);
@@ -748,26 +828,30 @@ rf_PrintFullAccessStripeMap(asm_h, prbuf)
 		}
 		printf("\n");
 		p = asm_h->stripeMap->failedPDAs[0];
-		if (asm_h->stripeMap->numDataFailed + asm_h->stripeMap->numParityFailed > 1)
+		if (asm_h->stripeMap->numDataFailed +
+		    asm_h->stripeMap->numParityFailed > 1)
 			printf("[multiple failures]\n");
 		else
-			if (asm_h->stripeMap->numDataFailed + asm_h->stripeMap->numParityFailed > 0)
-				printf("\t[Failed PDA: r%d c%d s%d-%d]\n", p->row, p->col,
-				    (int) p->startSector, (int) (p->startSector + p->numSector - 1));
+			if (asm_h->stripeMap->numDataFailed +
+			    asm_h->stripeMap->numParityFailed > 0)
+				printf("\t[Failed PDA: r%d c%d s%d-%d]\n",
+				    p->row, p->col, (int) p->startSector,
+				    (int) (p->startSector + p->numSector - 1));
 	}
 }
 
-void 
-rf_PrintRaidAddressInfo(raidPtr, raidAddr, numBlocks)
-	RF_Raid_t *raidPtr;
-	RF_RaidAddr_t raidAddr;
-	RF_SectorCount_t numBlocks;
+void
+rf_PrintRaidAddressInfo(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
+    RF_SectorCount_t numBlocks)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_RaidAddr_t ra, sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
+	RF_RaidAddr_t ra, sosAddr =
+	    rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
 
-	printf("Raid addrs of SU boundaries from start of stripe to end of access:\n\t");
-	for (ra = sosAddr; ra <= raidAddr + numBlocks; ra += layoutPtr->sectorsPerStripeUnit) {
+	printf("Raid addrs of SU boundaries from start of stripe to end"
+	    " of access:\n\t");
+	for (ra = sosAddr; ra <= raidAddr + numBlocks;
+	     ra += layoutPtr->sectorsPerStripeUnit) {
 		printf("%d (0x%x), ", (int) ra, (int) ra);
 	}
 	printf("\n");
@@ -775,76 +859,93 @@ rf_PrintRaidAddressInfo(raidPtr, raidAddr, numBlocks)
 	    (int) (raidAddr % layoutPtr->sectorsPerStripeUnit),
 	    (int) (raidAddr % layoutPtr->sectorsPerStripeUnit));
 }
+
 /*
-   given a parity descriptor and the starting address within a stripe,
-   range restrict the parity descriptor to touch only the correct stuff.
-*/
-void 
+ * Given a parity descriptor and the starting address within a stripe,
+ * range restrict the parity descriptor to touch only the correct stuff.
+ */
+void
 rf_ASMParityAdjust(
-    RF_PhysDiskAddr_t * toAdjust,
-    RF_StripeNum_t startAddrWithinStripe,
-    RF_SectorNum_t endAddress,
-    RF_RaidLayout_t * layoutPtr,
-    RF_AccessStripeMap_t * asm_p)
+    RF_PhysDiskAddr_t	*toAdjust,
+    RF_StripeNum_t	 startAddrWithinStripe,
+    RF_SectorNum_t	 endAddress,
+    RF_RaidLayout_t	*layoutPtr,
+    RF_AccessStripeMap_t *asm_p
+)
 {
 	RF_PhysDiskAddr_t *new_pda;
 
-	/* when we're accessing only a portion of one stripe unit, we want the
+	/*
+	 * When we're accessing only a portion of one stripe unit, we want the
 	 * parity descriptor to identify only the chunk of parity associated
-	 * with the data.  When the access spans exactly one stripe unit
+	 * with the data. When the access spans exactly one stripe unit
 	 * boundary and is less than a stripe unit in size, it uses two
-	 * disjoint regions of the parity unit.  When an access spans more
+	 * disjoint regions of the parity unit. When an access spans more
 	 * than one stripe unit boundary, it uses all of the parity unit.
-	 * 
+	 *
 	 * To better handle the case where stripe units are small, we may
 	 * eventually want to change the 2nd case so that if the SU size is
 	 * below some threshold, we just read/write the whole thing instead of
-	 * breaking it up into two accesses. */
+	 * breaking it up into two accesses.
+	 */
 	if (asm_p->numStripeUnitsAccessed == 1) {
-		int     x = (startAddrWithinStripe % layoutPtr->sectorsPerStripeUnit);
+		int x = (startAddrWithinStripe %
+		    layoutPtr->sectorsPerStripeUnit);
 		toAdjust->startSector += x;
 		toAdjust->raidAddress += x;
 		toAdjust->numSector = asm_p->physInfo->numSector;
 		RF_ASSERT(toAdjust->numSector != 0);
 	} else
-		if (asm_p->numStripeUnitsAccessed == 2 && asm_p->totalSectorsAccessed < layoutPtr->sectorsPerStripeUnit) {
-			int     x = (startAddrWithinStripe % layoutPtr->sectorsPerStripeUnit);
-
-			/* create a second pda and copy the parity map info
-			 * into it */
+		if (asm_p->numStripeUnitsAccessed == 2 &&
+		    asm_p->totalSectorsAccessed <
+		    layoutPtr->sectorsPerStripeUnit) {
+			int x = (startAddrWithinStripe %
+			    layoutPtr->sectorsPerStripeUnit);
+
+			/*
+			 * Create a second pda and copy the parity map info
+			 * into it.
+			 */
 			RF_ASSERT(toAdjust->next == NULL);
 			new_pda = toAdjust->next = rf_AllocPhysDiskAddr();
-			*new_pda = *toAdjust;	/* structure assignment */
+			*new_pda = *toAdjust;	/* Structure assignment. */
 			new_pda->next = NULL;
 
-			/* adjust the start sector & number of blocks for the
-			 * first parity pda */
+			/*
+			 * Adjust the start sector & number of blocks for the
+			 * first parity pda.
+			 */
 			toAdjust->startSector += x;
 			toAdjust->raidAddress += x;
-			toAdjust->numSector = rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, startAddrWithinStripe) - startAddrWithinStripe;
+			toAdjust->numSector =
+			    rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr,
+			     startAddrWithinStripe) - startAddrWithinStripe;
 			RF_ASSERT(toAdjust->numSector != 0);
 
-			/* adjust the second pda */
-			new_pda->numSector = endAddress - rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, endAddress);
+			/* Adjust the second pda. */
+			new_pda->numSector = endAddress -
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+			     endAddress);
 			/* new_pda->raidAddress =
-			 * rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr,
-			 * toAdjust->raidAddress); */
+			 *     rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr,
+			 *      toAdjust->raidAddress); */
 			RF_ASSERT(new_pda->numSector != 0);
 		}
 }
+
 /*
-   Check if a disk has been spared or failed. If spared,
-   redirect the I/O.
-   If it has been failed, record it in the asm pointer.
-   Fourth arg is whether data or parity.
-*/
-void 
+ * Check if a disk has been spared or failed. If spared, redirect the I/O.
+ * If it has been failed, record it in the asm pointer.
+ * Fourth arg is whether data or parity.
+ */
+void
 rf_ASMCheckStatus(
-    RF_Raid_t * raidPtr,
-    RF_PhysDiskAddr_t * pda_p,
-    RF_AccessStripeMap_t * asm_p,
-    RF_RaidDisk_t ** disks,
-    int parity)
+    RF_Raid_t		 *raidPtr,
+    RF_PhysDiskAddr_t	 *pda_p,
+    RF_AccessStripeMap_t *asm_p,
+    RF_RaidDisk_t	**disks,
+    int			  parity
+)
 {
 	RF_DiskStatus_t dstatus;
 	RF_RowCol_t frow, fcol;
@@ -852,44 +953,54 @@ rf_ASMCheckStatus(
 	dstatus = disks[pda_p->row][pda_p->col].status;
 
 	if (dstatus == rf_ds_spared) {
-		/* if the disk has been spared, redirect access to the spare */
+		/* If the disk has been spared, redirect access to the spare. */
 		frow = pda_p->row;
 		fcol = pda_p->col;
 		pda_p->row = disks[frow][fcol].spareRow;
 		pda_p->col = disks[frow][fcol].spareCol;
 	} else
 		if (dstatus == rf_ds_dist_spared) {
-			/* ditto if disk has been spared to dist spare space */
+			/* Ditto if disk has been spared to dist spare space. */
 			RF_RowCol_t or = pda_p->row, oc = pda_p->col;
 			RF_SectorNum_t oo = pda_p->startSector;
 
 			if (pda_p->type == RF_PDA_TYPE_DATA)
-				raidPtr->Layout.map->MapSector(raidPtr, pda_p->raidAddress, &pda_p->row, &pda_p->col, &pda_p->startSector, RF_REMAP);
+				raidPtr->Layout.map->MapSector(raidPtr,
+				    pda_p->raidAddress, &pda_p->row,
+				    &pda_p->col, &pda_p->startSector, RF_REMAP);
 			else
-				raidPtr->Layout.map->MapParity(raidPtr, pda_p->raidAddress, &pda_p->row, &pda_p->col, &pda_p->startSector, RF_REMAP);
+				raidPtr->Layout.map->MapParity(raidPtr,
+				    pda_p->raidAddress, &pda_p->row,
+				    &pda_p->col, &pda_p->startSector, RF_REMAP);
 
 			if (rf_mapDebug) {
-				printf("Redirected r %d c %d o %d -> r%d c %d o %d\n", or, oc, (int) oo,
-				    pda_p->row, pda_p->col, (int) pda_p->startSector);
+				printf("Redirected r %d c %d o %d -> r%d c %d"
+				    " o %d\n", or, oc, (int) oo, pda_p->row,
+				    pda_p->col, (int) pda_p->startSector);
 			}
 		} else
 			if (RF_DEAD_DISK(dstatus)) {
-				/* if the disk is inaccessible, mark the
-				 * failure */
+				/*
+				 * If the disk is inaccessible, mark the
+				 * failure.
+				 */
 				if (parity)
 					asm_p->numParityFailed++;
 				else {
 					asm_p->numDataFailed++;
 #if 0
-					/* XXX Do we really want this spewing
-					 * out on the console? GO */
-					printf("DATA_FAILED!\n");
+					/*
+					 * XXX Do we really want this spewing
+					 * out on the console ? GO
+					 */
+					printf("DATA_FAILED !\n");
 #endif
 				}
 				asm_p->failedPDAs[asm_p->numFailedPDAs] = pda_p;
 				asm_p->numFailedPDAs++;
 #if 0
-				switch (asm_p->numParityFailed + asm_p->numDataFailed) {
+				switch (asm_p->numParityFailed +
+				    asm_p->numDataFailed) {
 				case 1:
 					asm_p->failedPDAs[0] = pda_p;
 					break;
@@ -900,8 +1011,10 @@ rf_ASMCheckStatus(
 				}
 #endif
 			}
-	/* the redirected access should never span a stripe unit boundary */
-	RF_ASSERT(rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress) ==
-	    rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress + pda_p->numSector - 1));
+	/* The redirected access should never span a stripe unit boundary. */
+	RF_ASSERT(rf_RaidAddressToStripeUnitID(&raidPtr->Layout,
+	     pda_p->raidAddress) ==
+	    rf_RaidAddressToStripeUnitID(&raidPtr->Layout, pda_p->raidAddress +
+	     pda_p->numSector - 1));
 	RF_ASSERT(pda_p->col != -1);
 }
diff --git a/sys/dev/raidframe/rf_map.h b/sys/dev/raidframe/rf_map.h
index 95b2d243083..fac621f6352 100644
--- a/sys/dev/raidframe/rf_map.h
+++ b/sys/dev/raidframe/rf_map.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_map.h,v 1.2 1999/02/16 00:02:56 niklas Exp $	*/
+/*	$OpenBSD: rf_map.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_map.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,66 +30,57 @@
 
 /* rf_map.h */
 
-#ifndef _RF__RF_MAP_H_
-#define _RF__RF_MAP_H_
+#ifndef	_RF__RF_MAP_H_
+#define	_RF__RF_MAP_H_
 
 #include "rf_types.h"
 #include "rf_alloclist.h"
 #include "rf_raid.h"
 
-/* mapping structure allocation and free routines */
-RF_AccessStripeMapHeader_t *
-rf_MapAccess(RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidAddress, RF_SectorCount_t numBlocks,
-    caddr_t buffer, int remap);
+/* Mapping structure allocation and free routines. */
+RF_AccessStripeMapHeader_t *rf_MapAccess(RF_Raid_t *, RF_RaidAddr_t,
+	RF_SectorCount_t, caddr_t, int);
 
-void 
-rf_MarkFailuresInASMList(RF_Raid_t * raidPtr,
-    RF_AccessStripeMapHeader_t * asm_h);
+void rf_MarkFailuresInASMList(RF_Raid_t *, RF_AccessStripeMapHeader_t *);
 
-RF_AccessStripeMap_t *rf_DuplicateASM(RF_AccessStripeMap_t * asmap);
+RF_AccessStripeMap_t *rf_DuplicateASM(RF_AccessStripeMap_t *);
 
-RF_PhysDiskAddr_t *rf_DuplicatePDA(RF_PhysDiskAddr_t * pda);
+RF_PhysDiskAddr_t *rf_DuplicatePDA(RF_PhysDiskAddr_t *);
 
-int     rf_ConfigureMapModule(RF_ShutdownList_t ** listp);
+int  rf_ConfigureMapModule(RF_ShutdownList_t **);
 
 RF_AccessStripeMapHeader_t *rf_AllocAccessStripeMapHeader(void);
 
-void    rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t * p);
+void rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t *);
 
 RF_PhysDiskAddr_t *rf_AllocPhysDiskAddr(void);
 
-RF_PhysDiskAddr_t *rf_AllocPDAList(int count);
+RF_PhysDiskAddr_t *rf_AllocPDAList(int);
 
-void    rf_FreePhysDiskAddr(RF_PhysDiskAddr_t * p);
+void rf_FreePhysDiskAddr(RF_PhysDiskAddr_t *);
 
 RF_AccessStripeMap_t *rf_AllocAccessStripeMapComponent(void);
 
-RF_AccessStripeMap_t *rf_AllocASMList(int count);
+RF_AccessStripeMap_t *rf_AllocASMList(int);
 
-void    rf_FreeAccessStripeMapComponent(RF_AccessStripeMap_t * p);
+void rf_FreeAccessStripeMapComponent(RF_AccessStripeMap_t *);
 
-void    rf_FreeAccessStripeMap(RF_AccessStripeMapHeader_t * hdr);
+void rf_FreeAccessStripeMap(RF_AccessStripeMapHeader_t *);
 
-int     rf_CheckStripeForFailures(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
+int  rf_CheckStripeForFailures(RF_Raid_t *, RF_AccessStripeMap_t *);
 
-int     rf_NumFailedDataUnitsInStripe(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
+int  rf_NumFailedDataUnitsInStripe(RF_Raid_t *, RF_AccessStripeMap_t *);
 
-void    rf_PrintAccessStripeMap(RF_AccessStripeMapHeader_t * asm_h);
+void rf_PrintAccessStripeMap(RF_AccessStripeMapHeader_t *);
 
-void    rf_PrintFullAccessStripeMap(RF_AccessStripeMapHeader_t * asm_h, int prbuf);
+void rf_PrintFullAccessStripeMap(RF_AccessStripeMapHeader_t *, int);
 
-void 
-rf_PrintRaidAddressInfo(RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-    RF_SectorCount_t numBlocks);
+void rf_PrintRaidAddressInfo(RF_Raid_t *, RF_RaidAddr_t, RF_SectorCount_t);
 
-void 
-rf_ASMParityAdjust(RF_PhysDiskAddr_t * toAdjust,
-    RF_StripeNum_t startAddrWithinStripe, RF_SectorNum_t endAddress,
-    RF_RaidLayout_t * layoutPtr, RF_AccessStripeMap_t * asm_p);
+void rf_ASMParityAdjust(RF_PhysDiskAddr_t *, RF_StripeNum_t, RF_SectorNum_t,
+	RF_RaidLayout_t *, RF_AccessStripeMap_t *);
 
-void 
-rf_ASMCheckStatus(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda_p,
-    RF_AccessStripeMap_t * asm_p, RF_RaidDisk_t ** disks, int parity);
+void rf_ASMCheckStatus(RF_Raid_t *, RF_PhysDiskAddr_t *,
+	RF_AccessStripeMap_t *, RF_RaidDisk_t **, int);
 
-#endif				/* !_RF__RF_MAP_H_ */
+#endif	/* !_RF__RF_MAP_H_ */
diff --git a/sys/dev/raidframe/rf_mcpair.c b/sys/dev/raidframe/rf_mcpair.c
index 5b39b182332..d189c1d1127 100644
--- a/sys/dev/raidframe/rf_mcpair.c
+++ b/sys/dev/raidframe/rf_mcpair.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_mcpair.c,v 1.2 1999/02/16 00:02:56 niklas Exp $	*/
+/*	$OpenBSD: rf_mcpair.c,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_mcpair.c,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,9 +28,10 @@
  * rights to redistribute these changes.
  */
 
-/* rf_mcpair.c
- * an mcpair is a structure containing a mutex and a condition variable.
- * it's used to block the current thread until some event occurs.
+/*
+ * rf_mcpair.c
+ * An mcpair is a structure containing a mutex and a condition variable.
+ * It's used to block the current thread until some event occurs.
  */
 
 #include "rf_types.h"
@@ -43,78 +45,76 @@
 
 static RF_FreeList_t *rf_mcpair_freelist;
 
-#define RF_MAX_FREE_MCPAIR 128
-#define RF_MCPAIR_INC       16
-#define RF_MCPAIR_INITIAL   24
+#define	RF_MAX_FREE_MCPAIR	128
+#define	RF_MCPAIR_INC		 16
+#define	RF_MCPAIR_INITIAL	 24
 
-static int init_mcpair(RF_MCPair_t *);
-static void clean_mcpair(RF_MCPair_t *);
-static void rf_ShutdownMCPair(void *);
+int  rf_init_mcpair(RF_MCPair_t *);
+void rf_clean_mcpair(RF_MCPair_t *);
+void rf_ShutdownMCPair(void *);
 
 
-static int 
-init_mcpair(t)
-	RF_MCPair_t *t;
+int
+rf_init_mcpair(RF_MCPair_t *t)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_mutex_init(&t->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(&t->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(&t->mutex);
 		return (rc);
 	}
 	return (0);
 }
 
-static void 
-clean_mcpair(t)
-	RF_MCPair_t *t;
+void
+rf_clean_mcpair(RF_MCPair_t *t)
 {
 	rf_mutex_destroy(&t->mutex);
 	rf_cond_destroy(&t->cond);
 }
 
-static void 
-rf_ShutdownMCPair(ignored)
-	void   *ignored;
+void
+rf_ShutdownMCPair(void *ignored)
 {
-	RF_FREELIST_DESTROY_CLEAN(rf_mcpair_freelist, next, (RF_MCPair_t *), clean_mcpair);
+	RF_FREELIST_DESTROY_CLEAN(rf_mcpair_freelist, next, (RF_MCPair_t *),
+	    rf_clean_mcpair);
 }
 
-int 
-rf_ConfigureMCPair(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureMCPair(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_mcpair_freelist, RF_MAX_FREE_MCPAIR,
 	    RF_MCPAIR_INC, sizeof(RF_MCPair_t));
 	rc = rf_ShutdownCreate(listp, rf_ShutdownMCPair, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownMCPair(NULL);
 		return (rc);
 	}
 	RF_FREELIST_PRIME_INIT(rf_mcpair_freelist, RF_MCPAIR_INITIAL, next,
-	    (RF_MCPair_t *), init_mcpair);
+	    (RF_MCPair_t *), rf_init_mcpair);
 	return (0);
 }
 
 RF_MCPair_t *
-rf_AllocMCPair()
+rf_AllocMCPair(void)
 {
 	RF_MCPair_t *t;
 
-	RF_FREELIST_GET_INIT(rf_mcpair_freelist, t, next, (RF_MCPair_t *), init_mcpair);
+	RF_FREELIST_GET_INIT(rf_mcpair_freelist, t, next, (RF_MCPair_t *),
+	    rf_init_mcpair);
 	if (t) {
 		t->flag = 0;
 		t->next = NULL;
@@ -122,27 +122,33 @@ rf_AllocMCPair()
 	return (t);
 }
 
-void 
-rf_FreeMCPair(t)
-	RF_MCPair_t *t;
+void
+rf_FreeMCPair(RF_MCPair_t *t)
 {
-	RF_FREELIST_FREE_CLEAN(rf_mcpair_freelist, t, next, clean_mcpair);
+	RF_FREELIST_FREE_CLEAN(rf_mcpair_freelist, t, next, rf_clean_mcpair);
 }
-/* the callback function used to wake you up when you use an mcpair to wait for something */
-void 
-rf_MCPairWakeupFunc(mcpair)
-	RF_MCPair_t *mcpair;
+
+/*
+ * The callback function used to wake you up when you use an mcpair to wait
+ * for something.
+ */
+void
+rf_MCPairWakeupFunc(RF_MCPair_t *mcpair)
 {
 	RF_LOCK_MUTEX(mcpair->mutex);
 	mcpair->flag = 1;
 #if 0
 	printf("MCPairWakeupFunc called!\n");
 #endif
-	wakeup(&(mcpair->flag));/* XXX Does this do anything useful!! GO */
-	/* XXX Looks like the following is needed to truly get the
-	 * functionality they were looking for here... This could be a
+	wakeup(&(mcpair->flag)); /* XXX Does this do anything useful !!!  GO */
+	/*
+	 * XXX
+	 * Looks like the following is needed to truly get the
+	 * functionality they were looking for here...  This could be a
 	 * side-effect of my using a tsleep in the Net- and OpenBSD port
-	 * though... XXX */
-	wakeup(&(mcpair->cond));/* XXX XXX XXX GO */
+	 * though...
+	 * XXX
+	 */
+	wakeup(&(mcpair->cond));	/* XXX XXX XXX GO */
 	RF_UNLOCK_MUTEX(mcpair->mutex);
 }
diff --git a/sys/dev/raidframe/rf_mcpair.h b/sys/dev/raidframe/rf_mcpair.h
index 493d4450d5b..8691f62f999 100644
--- a/sys/dev/raidframe/rf_mcpair.h
+++ b/sys/dev/raidframe/rf_mcpair.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_mcpair.h,v 1.3 1999/07/30 14:45:32 peter Exp $	*/
+/*	$OpenBSD: rf_mcpair.h,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_mcpair.h,v 1.4 1999/03/14 21:53:31 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,27 +28,28 @@
  * rights to redistribute these changes.
  */
 
-/* rf_mcpair.h
- * see comments in rf_mcpair.c
+/*
+ * rf_mcpair.h
+ * See comments in rf_mcpair.c
  */
 
-#ifndef _RF__RF_MCPAIR_H_
-#define _RF__RF_MCPAIR_H_
+#ifndef	_RF__RF_MCPAIR_H_
+#define	_RF__RF_MCPAIR_H_
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
 
 struct RF_MCPair_s {
-	RF_DECLARE_MUTEX(mutex)
-	RF_DECLARE_COND(cond)
-	int     flag;
-	RF_MCPair_t *next;
+	RF_DECLARE_MUTEX(mutex);
+	RF_DECLARE_COND (cond);
+	int		 flag;
+	RF_MCPair_t	*next;
 };
-#define RF_WAIT_MCPAIR(_mcp)  tsleep(&((_mcp)->flag), PRIBIO, "mcpair", 0)
+#define	RF_WAIT_MCPAIR(_mcp)	tsleep(&((_mcp)->flag), PRIBIO, "mcpair", 0)
 
-int     rf_ConfigureMCPair(RF_ShutdownList_t ** listp);
+int  rf_ConfigureMCPair(RF_ShutdownList_t **);
 RF_MCPair_t *rf_AllocMCPair(void);
-void    rf_FreeMCPair(RF_MCPair_t * t);
-void    rf_MCPairWakeupFunc(RF_MCPair_t * t);
+void rf_FreeMCPair(RF_MCPair_t *);
+void rf_MCPairWakeupFunc(RF_MCPair_t *);
 
-#endif				/* !_RF__RF_MCPAIR_H_ */
+#endif	/* !_RF__RF_MCPAIR_H_ */
diff --git a/sys/dev/raidframe/rf_memchunk.c b/sys/dev/raidframe/rf_memchunk.c
index a9bea6f29ef..2febacde6d2 100644
--- a/sys/dev/raidframe/rf_memchunk.c
+++ b/sys/dev/raidframe/rf_memchunk.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: rf_memchunk.c,v 1.3 2000/01/07 14:50:21 peter Exp $	*/
+/*	$OpenBSD: rf_memchunk.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_memchunk.c,v 1.4 1999/08/13 03:41:56 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
@@ -76,12 +76,12 @@ struct RF_ChunkHdr_s {
 
 static RF_ChunkHdr_t *chunklist, *chunk_hdr_free_list;
 static RF_ChunkDesc_t *chunk_desc_free_list;
-RF_DECLARE_STATIC_MUTEX(chunkmutex)
-	static void rf_ShutdownMemChunk(void *);
-	static RF_ChunkDesc_t *NewMemChunk(int, char *);
+RF_DECLARE_STATIC_MUTEX(chunkmutex);
+void rf_ShutdownMemChunk(void *);
+RF_ChunkDesc_t *rf_NewMemChunk(int, char *);
 
 
-	static void rf_ShutdownMemChunk(ignored)
+void rf_ShutdownMemChunk(ignored)
 	void   *ignored;
 {
 	RF_ChunkDesc_t *pt, *p;
@@ -133,8 +133,8 @@ rf_ConfigureMemChunk(listp)
  *
  * free list is not currently used
  */
-static RF_ChunkDesc_t *
-NewMemChunk(size, buf)
+RF_ChunkDesc_t *
+rf_NewMemChunk(size, buf)
 	int     size;
 	char   *buf;
 {
@@ -176,7 +176,7 @@ rf_GetMemChunk(size)
 		}
 	if (!p) {
 		RF_Malloc(buf, size, (char *));
-		p = NewMemChunk(size, buf);
+		p = rf_NewMemChunk(size, buf);
 	}
 	RF_UNLOCK_MUTEX(chunkmutex);
 	(void) bzero(p->buf, size);
diff --git a/sys/dev/raidframe/rf_memchunk.h b/sys/dev/raidframe/rf_memchunk.h
index d2585a48987..afd4555e63c 100644
--- a/sys/dev/raidframe/rf_memchunk.h
+++ b/sys/dev/raidframe/rf_memchunk.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_memchunk.h,v 1.2 1999/02/16 00:02:57 niklas Exp $	*/
+/*	$OpenBSD: rf_memchunk.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_memchunk.h,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,22 +28,22 @@
  * rights to redistribute these changes.
  */
 
-/* header file for rf_memchunk.c.  See comments there */
+/* Header file for rf_memchunk.c. See comments there. */
 
-#ifndef _RF__RF_MEMCHUNK_H_
-#define _RF__RF_MEMCHUNK_H_
+#ifndef	_RF__RF_MEMCHUNK_H_
+#define	_RF__RF_MEMCHUNK_H_
 
 #include "rf_types.h"
 
 struct RF_ChunkDesc_s {
-	int     size;
-	int     reuse_count;
-	char   *buf;
-	RF_ChunkDesc_t *next;
+	int		 size;
+	int		 reuse_count;
+	char		*buf;
+	RF_ChunkDesc_t	*next;
 };
 
-int     rf_ConfigureMemChunk(RF_ShutdownList_t ** listp);
-RF_ChunkDesc_t *rf_GetMemChunk(int size);
-void    rf_ReleaseMemChunk(RF_ChunkDesc_t * chunk);
+int  rf_ConfigureMemChunk(RF_ShutdownList_t **);
+RF_ChunkDesc_t *rf_GetMemChunk(int);
+void rf_ReleaseMemChunk(RF_ChunkDesc_t *);
 
-#endif				/* !_RF__RF_MEMCHUNK_H_ */
+#endif	/* !_RF__RF_MEMCHUNK_H_ */
diff --git a/sys/dev/raidframe/rf_netbsd.h b/sys/dev/raidframe/rf_netbsd.h
index 0f3a18d3811..a19148d9d20 100644
--- a/sys/dev/raidframe/rf_netbsd.h
+++ b/sys/dev/raidframe/rf_netbsd.h
@@ -1,7 +1,7 @@
-/*	$OpenBSD: rf_netbsd.h,v 1.5 2000/08/08 16:07:42 peter Exp $	*/
+/*	$OpenBSD: rf_netbsd.h,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_netbsd.h,v 1.12 2000/05/28 22:53:49 oster Exp $	*/
 
-/*-
+/*
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
@@ -18,8 +18,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *        This product includes software developed by the NetBSD
- *        Foundation, Inc. and its contributors.
+ *	This product includes software developed by the NetBSD
+ *	Foundation, Inc. and its contributors.
  * 4. Neither the name of The NetBSD Foundation nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
@@ -37,104 +37,139 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _RF__RF_NETBSDSTUFF_H_
-#define _RF__RF_NETBSDSTUFF_H_
+#ifndef	_RF__RF_NETBSDSTUFF_H_
+#define	_RF__RF_NETBSDSTUFF_H_
 
-#ifdef _KERNEL
+#ifdef	_KERNEL
 #include <sys/fcntl.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
-#endif /* _KERNEL */
- 
-/* The per-component label information that the user can set */
+#endif	/* _KERNEL */
+
+/* The per-component label information that the user can set. */
 typedef struct RF_ComponentInfo_s {
-	int row;              /* the row number of this component */
-	int column;           /* the column number of this component */
-	int serial_number;    /* a user-specified serial number for this
-				 RAID set */
+	int	row;		/* The row number of this component. */
+	int	column;		/* The column number of this component. */
+	int	serial_number;	/*
+				 * A user-specified serial number for this
+				 * RAID set.
+				 */
 } RF_ComponentInfo_t;
 
 /* The per-component label information */
 typedef struct RF_ComponentLabel_s {
-	int version;          /* The version of this label. */
-	int serial_number;    /* a user-specified serial number for this
-				 RAID set */
-	int mod_counter;      /* modification counter.  Changed (usually
-				 by incrementing) every time the label 
-				 is changed */
-	int row;              /* the row number of this component */
-	int column;           /* the column number of this component */
-	int num_rows;         /* number of rows in this RAID set */
-	int num_columns;      /* number of columns in this RAID set */
-	int clean;            /* 1 when clean, 0 when dirty */
-	int status;           /* rf_ds_optimal, rf_ds_dist_spared, whatever. */
-	/* stuff that will be in version 2 of the label */
-	int sectPerSU;        /* Sectors per Stripe Unit */
-	int SUsPerPU;         /* Stripe Units per Parity Units */
-	int SUsPerRU;         /* Stripe Units per Reconstruction Units */
-	int parityConfig;     /* '0' == RAID0, '1' == RAID1, etc. */
-	int maxOutstanding;   /* maxOutstanding disk requests */
-	int blockSize;        /* size of component block. 
-				 (disklabel->d_secsize) */
-	int numBlocks;        /* number of blocks on this component.  May
-			         be smaller than the partition size. */
-	int partitionSize;    /* number of blocks on this *partition*. 
-				 Must exactly match the partition size
-				 from the disklabel. */
-	int future_use[33];   /* Future expansion */
-	int autoconfigure;    /* automatically configure this RAID set. 
-				 0 == no, 1 == yes */
-	int root_partition;   /* Use this set as /
-				 0 == no, 1 == yes*/
-	int last_unit;        /* last unit number (e.g. 0 for /dev/raid0) 
-				 of this component.  Used for autoconfigure
-				 only. */
-	int config_order;     /* 0 .. n.  The order in which the component
-				 should be auto-configured.  E.g. 0 is will 
-				 done first, (and would become raid0).
-				 This may be in conflict with last_unit!!?! */
-	                      /* Not currently used. */
-	int future_use2[44];  /* More future expansion */
+	int	version;	/* The version of this label. */
+	int	serial_number;	/*
+				 * A user-specified serial number for this
+				 * RAID set.
+				 */
+	int	mod_counter;	/*
+				 * Modification counter. Changed (usually
+				 * by incrementing) every time the label
+				 * is changed.
+				 */
+	int	row;		/* The row number of this component. */
+	int	column;		/* The column number of this component. */
+	int	num_rows;	/* Number of rows in this RAID set. */
+	int	num_columns;	/* Number of columns in this RAID set. */
+	int	clean;		/* 1 when clean, 0 when dirty. */
+	int	status;		/*
+				 * rf_ds_optimal, rf_ds_dist_spared, whatever.
+				 */
+	/* Stuff that will be in version 2 of the label. */
+	int	sectPerSU;	/* Sectors per Stripe Unit. */
+	int	SUsPerPU;	/* Stripe Units per Parity Units. */
+	int	SUsPerRU;	/* Stripe Units per Reconstruction Units. */
+	int	parityConfig;	/* '0' == RAID0, '1' == RAID1, etc. */
+	int	maxOutstanding;	/* maxOutstanding disk requests. */
+	int	blockSize;	/*
+				 * Size of component block.
+				 * (disklabel->d_secsize)
+				 */
+	int	numBlocks;	/*
+				 * Number of blocks on this component.
+				 * May be smaller than the partition size.
+				 */
+	int	partitionSize;	/*
+				 * Number of blocks on this *partition*.
+				 * Must exactly match the partition size
+				 * from the disklabel.
+				 */
+	int	future_use[33];	/* Future expansion. */
+	int	autoconfigure;	/*
+				 * Automatically configure this RAID set.
+				 * 0 == no, 1 == yes
+				 */
+	int	root_partition;	/*
+				 * Use this set as :
+				 * 0 == no, 1 == yes
+				 */
+	int	last_unit;	/*
+				 * Last unit number (e.g. 0 for /dev/raid0)
+				 * of this component. Used for autoconfigure
+				 * only.
+				 */
+	int	config_order;	/*
+				 * 0 .. n. The order in which the component
+				 * should be auto-configured. E.g. 0 will be
+				 * done first, (and would become raid0).
+				 * This may be in conflict with last_unit !!?!
+				 */
+				/* Not currently used. */
+	int	fut_use2[44];	/* More future expansion. */
 } RF_ComponentLabel_t;
 
 typedef struct RF_SingleComponent_s {
-	int row;
-	int column;
-	char component_name[50]; /* name of the component */
-} RF_SingleComponent_t; 
+	int	row;
+	int	column;
+	char	component_name[50];	/* Name of the component. */
+} RF_SingleComponent_t;
 
-#ifdef _KERNEL
+#ifdef	_KERNEL
 
- struct raidcinfo {
-	struct vnode *ci_vp;	/* component device's vnode */
-	dev_t   ci_dev;		/* component device's dev_t */
-	RF_ComponentLabel_t ci_label; /* components RAIDframe label */
+struct raidcinfo {
+	struct vnode	*ci_vp;		/* Component device's vnode. */
+	dev_t		 ci_dev;	/* Component device's dev_t. */
+	RF_ComponentLabel_t ci_label;	/* Components RAIDframe label. */
 #if 0
-	size_t  ci_size;	/* size */
-	char   *ci_path;	/* path to component */
-	size_t  ci_pathlen;	/* length of component path */
+	size_t		 ci_size;	/* Size. */
+	char		*ci_path;	/* Path to component. */
+	size_t		 ci_pathlen;	/* Length of component path. */
 #endif
-  };
+};
 
 
-/* XXX probably belongs in a different .h file. */
+/* XXX Probably belongs in a different .h file. */
 typedef struct RF_AutoConfig_s {
-	char devname[56];       /* the name of this component */
-	int flag;               /* a general-purpose flag */
-	dev_t dev;              /* the device for this component */
-	struct vnode *vp;       /* Mr. Vnode Pointer */
-	RF_ComponentLabel_t *clabel;  /* the label */
-	struct RF_AutoConfig_s *next; /* the next autoconfig structure 
-				         in this set. */
+	char			 devname[56];	/*
+						 * The name of this component.
+						 */
+	int			 flag;		/* A general-purpose flag. */
+	dev_t			 dev;		/*
+						 * The device for this
+						 * component.
+						 */
+	struct vnode		*vp;		/* Master Vnode Pointer. */
+	RF_ComponentLabel_t	*clabel;	/* The label. */
+	struct RF_AutoConfig_s	*next;		/*
+						 * The next autoconfig
+						 * structure in this set.
+						 */
 } RF_AutoConfig_t;
 
 typedef struct RF_ConfigSet_s {
-	struct RF_AutoConfig_s *ac; /* all of the autoconfig structures for
-				       this config set. */
-	int rootable;               /* Set to 1 if this set can be root */
-	struct RF_ConfigSet_s *next;
+	struct RF_AutoConfig_s	*ac;		/*
+						 * All of the autoconfig
+						 * structures for this
+						 * config set.
+						 */
+	int			 rootable;	/*
+						 * Set to 1 if this set can
+						 * be root.
+						 */
+	struct RF_ConfigSet_s	*next;
 } RF_ConfigSet_t;
 
-#endif				/* _KERNEL */
-#endif				/* _RF__RF_NETBSDSTUFF_H_ */
+#endif	/* _KERNEL */
+#endif	/* _RF__RF_NETBSDSTUFF_H_ */
diff --git a/sys/dev/raidframe/rf_netbsdkintf.c b/sys/dev/raidframe/rf_netbsdkintf.c
index 0ba733a4133..ff5d1e98b6b 100644
--- a/sys/dev/raidframe/rf_netbsdkintf.c
+++ b/sys/dev/raidframe/rf_netbsdkintf.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: rf_netbsdkintf.c,v 1.10 2002/10/12 01:09:44 krw Exp $	*/
+/*	$OpenBSD: rf_netbsdkintf.c,v 1.11 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_netbsdkintf.c,v 1.93 2000/07/14 15:26:29 oster Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
@@ -1551,7 +1551,7 @@ rf_GetSpareTableFromDaemon(req)
 	/* mpsleep unlocks the mutex */
 	while (!rf_sparet_resp_queue) {
 		tsleep(&rf_sparet_resp_queue, PRIBIO,
-		    "raidframe getsparetable", 0);
+		    "RAIDframe getsparetable", 0);
 	}
 	req = rf_sparet_resp_queue;
 	rf_sparet_resp_queue = req->next;
diff --git a/sys/dev/raidframe/rf_nwayxor.c b/sys/dev/raidframe/rf_nwayxor.c
index df7604650fb..fe35211806d 100644
--- a/sys/dev/raidframe/rf_nwayxor.c
+++ b/sys/dev/raidframe/rf_nwayxor.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_nwayxor.c,v 1.3 2000/08/08 16:07:43 peter Exp $	*/
+/*	$OpenBSD: rf_nwayxor.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_nwayxor.c,v 1.4 2000/03/30 12:45:41 augustss Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,26 +28,25 @@
  * rights to redistribute these changes.
  */
 
-/************************************************************
+/*************************************************************
  *
- * nwayxor.c -- code to do N-way xors for reconstruction
+ * nwayxor.c -- Code to do N-way xors for reconstruction.
  *
  * nWayXorN xors N input buffers into the destination buffer.
- * adapted from danner's longword_bxor code.
+ * Adapted from danner's longword_bxor code.
  *
- ************************************************************/
+ *************************************************************/
 
 #include "rf_nwayxor.h"
 #include "rf_shutdown.h"
 
 static int callcount[10];
-static void rf_ShutdownNWayXor(void *);
+void rf_ShutdownNWayXor(void *);
 
-static void 
-rf_ShutdownNWayXor(ignored)
-	void   *ignored;
+void
+rf_ShutdownNWayXor(void *ignored)
 {
-	int     i;
+	int i;
 
 	if (rf_showXorCallCounts == 0)
 		return;
@@ -56,11 +56,10 @@ rf_ShutdownNWayXor(ignored)
 	printf("\n");
 }
 
-int 
-rf_ConfigureNWayXor(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureNWayXor(RF_ShutdownList_t **listp)
 {
-	int     i, rc;
+	int i, rc;
 
 	for (i = 0; i < 10; i++)
 		callcount[i] = 0;
@@ -68,11 +67,12 @@ rf_ConfigureNWayXor(listp)
 	return (rc);
 }
 
-void 
-rf_nWayXor1(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor1(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *src = (unsigned long *) src_rbs[0]->buffer;
 	unsigned long *dest = (unsigned long *) dest_rb->buffer;
@@ -102,11 +102,12 @@ rf_nWayXor1(src_rbs, dest_rb, len)
 	}
 }
 
-void 
-rf_nWayXor2(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor2(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *a = dst;
@@ -115,7 +116,7 @@ rf_nWayXor2(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[2]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ = *a++ ^ *b++ ^ *c++;
 		len--;
@@ -135,7 +136,7 @@ rf_nWayXor2(src_rbs, dest_rb, len)
 
 		b2 = b[2];
 		b3 = b[3];
-		/* start dual issue */
+		/* Start dual issue. */
 		a0 ^= b0;
 		b0 = c[0];
 
@@ -167,39 +168,41 @@ rf_nWayXor2(src_rbs, dest_rb, len)
 		len--;
 	}
 }
-/* note that first arg is not incremented but 2nd arg is */
-#define LOAD_FIRST(_dst,_b) \
-  a0 = _dst[0]; len -= 4;   \
-  a1 = _dst[1];             \
-  a2 = _dst[2];             \
-  a3 = _dst[3];             \
-  b0 = _b[0];               \
-  b1 = _b[1];               \
-  b2 = _b[2];               \
-  b3 = _b[3];  _b += 4;
-
-/* note: arg is incremented */
-#define XOR_AND_LOAD_NEXT(_n) \
-  a0 ^= b0; b0 = _n[0];       \
-  a1 ^= b1; b1 = _n[1];       \
-  a2 ^= b2; b2 = _n[2];       \
-  a3 ^= b3; b3 = _n[3];       \
-  _n += 4;
-
-/* arg is incremented */
-#define XOR_AND_STORE(_dst)       \
-  a0 ^= b0; _dst[0] = a0;         \
-  a1 ^= b1; _dst[1] = a1;         \
-  a2 ^= b2; _dst[2] = a2;         \
-  a3 ^= b3; _dst[3] = a3;         \
-  _dst += 4;
-
-
-void 
-rf_nWayXor3(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+
+/* Note that first arg is not incremented but 2nd arg is. */
+#define	LOAD_FIRST(_dst,_b)						\
+	a0 = _dst[0]; len -= 4;						\
+	a1 = _dst[1];							\
+	a2 = _dst[2];							\
+	a3 = _dst[3];							\
+	b0 = _b[0];							\
+	b1 = _b[1];							\
+	b2 = _b[2];							\
+	b3 = _b[3];  _b += 4;
+
+/* Note: arg is incremented. */
+#define	XOR_AND_LOAD_NEXT(_n)						\
+	a0 ^= b0; b0 = _n[0];						\
+	a1 ^= b1; b1 = _n[1];						\
+	a2 ^= b2; b2 = _n[2];						\
+	a3 ^= b3; b3 = _n[3];						\
+	_n += 4;
+
+/* Arg is incremented. */
+#define	XOR_AND_STORE(_dst)						\
+	a0 ^= b0; _dst[0] = a0;						\
+	a1 ^= b1; _dst[1] = a1;						\
+	a2 ^= b2; _dst[2] = a2;						\
+	a3 ^= b3; _dst[3] = a3;						\
+	_dst += 4;
+
+
+void
+rf_nWayXor3(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -208,7 +211,7 @@ rf_nWayXor3(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[3]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ ^= *b++ ^ *c++ ^ *d++;
 		len--;
@@ -225,11 +228,12 @@ rf_nWayXor3(src_rbs, dest_rb, len)
 	}
 }
 
-void 
-rf_nWayXor4(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor4(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -239,7 +243,7 @@ rf_nWayXor4(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[4]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++;
 		len--;
@@ -257,11 +261,12 @@ rf_nWayXor4(src_rbs, dest_rb, len)
 	}
 }
 
-void 
-rf_nWayXor5(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor5(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -272,7 +277,7 @@ rf_nWayXor5(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[5]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++;
 		len--;
@@ -291,11 +296,12 @@ rf_nWayXor5(src_rbs, dest_rb, len)
 	}
 }
 
-void 
-rf_nWayXor6(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor6(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -307,7 +313,7 @@ rf_nWayXor6(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[6]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++;
 		len--;
@@ -327,11 +333,12 @@ rf_nWayXor6(src_rbs, dest_rb, len)
 	}
 }
 
-void 
-rf_nWayXor7(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor7(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -344,7 +351,7 @@ rf_nWayXor7(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[7]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++;
 		len--;
@@ -365,11 +372,12 @@ rf_nWayXor7(src_rbs, dest_rb, len)
 	}
 }
 
-void 
-rf_nWayXor8(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor8(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -383,7 +391,7 @@ rf_nWayXor8(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[8]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
 		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++ ^ *i++;
 		len--;
@@ -406,11 +414,12 @@ rf_nWayXor8(src_rbs, dest_rb, len)
 }
 
 
-void 
-rf_nWayXor9(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
+void
+rf_nWayXor9(
+	RF_ReconBuffer_t	**src_rbs,
+	RF_ReconBuffer_t	 *dest_rb,
+	int			  len
+)
 {
 	unsigned long *dst = (unsigned long *) dest_rb->buffer;
 	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
@@ -425,9 +434,10 @@ rf_nWayXor9(src_rbs, dest_rb, len)
 	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
 
 	callcount[9]++;
-	/* align dest to cache line */
+	/* Align dest to cache line. */
 	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++ ^ *i++ ^ *j++;
+		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^
+		    *f++ ^ *g++ ^ *h++ ^ *i++ ^ *j++;
 		len--;
 	}
 	while (len > 4) {
@@ -443,7 +453,8 @@ rf_nWayXor9(src_rbs, dest_rb, len)
 		XOR_AND_STORE(dst);
 	}
 	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++ ^ *i++ ^ *j++;
+		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^
+		    *f++ ^ *g++ ^ *h++ ^ *i++ ^ *j++;
 		len--;
 	}
 }
diff --git a/sys/dev/raidframe/rf_nwayxor.h b/sys/dev/raidframe/rf_nwayxor.h
index e328696220c..046df6d8a84 100644
--- a/sys/dev/raidframe/rf_nwayxor.h
+++ b/sys/dev/raidframe/rf_nwayxor.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_nwayxor.h,v 1.2 1999/02/16 00:03:00 niklas Exp $	*/
+/*	$OpenBSD: rf_nwayxor.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_nwayxor.h,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
+
 /*
  * rf_nwayxor.h
  */
@@ -29,26 +30,27 @@
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
+
 /*
- * rf_nwayxor.h -- types and prototypes for nwayxor module
+ * rf_nwayxor.h -- Types and prototypes for nwayxor module.
  */
 
-#ifndef _RF__RF_NWAYXOR_H_
-#define _RF__RF_NWAYXOR_H_
+#ifndef	_RF__RF_NWAYXOR_H_
+#define	_RF__RF_NWAYXOR_H_
 
 #include "rf_types.h"
 #include "rf_raid.h"
 #include "rf_reconstruct.h"
 
-int     rf_ConfigureNWayXor(RF_ShutdownList_t ** listp);
-void    rf_nWayXor1(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor2(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor3(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor4(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor5(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor6(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor7(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor8(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
-void    rf_nWayXor9(RF_ReconBuffer_t ** src_rbs, RF_ReconBuffer_t * dest_rb, int len);
+int  rf_ConfigureNWayXor(RF_ShutdownList_t **);
+void rf_nWayXor1(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor2(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor3(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor4(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor5(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor6(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor7(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor8(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
+void rf_nWayXor9(RF_ReconBuffer_t **, RF_ReconBuffer_t *, int);
 
-#endif				/* !_RF__RF_NWAYXOR_H_ */
+#endif	/* !_RF__RF_NWAYXOR_H_ */
diff --git a/sys/dev/raidframe/rf_openbsd.h b/sys/dev/raidframe/rf_openbsd.h
index 17333cb9647..5b6a0e680bd 100644
--- a/sys/dev/raidframe/rf_openbsd.h
+++ b/sys/dev/raidframe/rf_openbsd.h
@@ -1,6 +1,6 @@
-/*	$OpenBSD: rf_openbsd.h,v 1.4 2000/08/08 16:07:43 peter Exp $	*/
+/*	$OpenBSD: rf_openbsd.h,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 
-/*-
+/*
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
@@ -17,8 +17,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *        This product includes software developed by the NetBSD
- *        Foundation, Inc. and its contributors.
+ *	This product includes software developed by the NetBSD
+ *	Foundation, Inc. and its contributors.
  * 4. Neither the name of The NetBSD Foundation nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
@@ -36,7 +36,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*-
+/*
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
@@ -53,8 +53,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *        This product includes software developed by the NetBSD
- *        Foundation, Inc. and its contributors.
+ *	This product includes software developed by the NetBSD
+ *	Foundation, Inc. and its contributors.
  * 4. Neither the name of The NetBSD Foundation nor the names of its
  *    contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
@@ -73,102 +73,139 @@
  */
 
 
-#ifndef _RF__RF_OPENBSD_H_
-#define _RF__RF_OPENBSD_H_
+#ifndef	_RF__RF_OPENBSD_H_
+#define	_RF__RF_OPENBSD_H_
 
-#ifdef _KERNEL
+#ifdef	_KERNEL
 #include <sys/fcntl.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
-#endif /* _KERNEL */
- 
-/* The per-component label information that the user can set */
+#endif	/* _KERNEL */
+
+/* The per-component label information that the user can set. */
 typedef struct RF_ComponentInfo_s {
-	int row;              /* the row number of this component */
-	int column;           /* the column number of this component */
-	int serial_number;    /* a user-specified serial number for this
-				 RAID set */
+	int	row;		/* The row number of this component. */
+	int	column;		/* The column number of this component. */
+	int	serial_number;	/*
+				 * A user-specified serial number for this
+				 * RAID set.
+				 */
 } RF_ComponentInfo_t;
 
-/* The per-component label information */
+/* The per-component label information. */
 typedef struct RF_ComponentLabel_s {
-	int version;          /* The version of this label. */
-	int serial_number;    /* a user-specified serial number for this
-				 RAID set */
-	int mod_counter;      /* modification counter.  Changed (usually
-				 by incrementing) every time the label 
-				 is changed */
-	int row;              /* the row number of this component */
-	int column;           /* the column number of this component */
-	int num_rows;         /* number of rows in this RAID set */
-	int num_columns;      /* number of columns in this RAID set */
-	int clean;            /* 1 when clean, 0 when dirty */
-	int status;           /* rf_ds_optimal, rf_ds_dist_spared, whatever. */
-	/* stuff that will be in version 2 of the label */
-	int sectPerSU;        /* Sectors per Stripe Unit */
-	int SUsPerPU;         /* Stripe Units per Parity Units */
-	int SUsPerRU;         /* Stripe Units per Reconstruction Units */
-	int parityConfig;     /* '0' == RAID0, '1' == RAID1, etc. */
-	int maxOutstanding;   /* maxOutstanding disk requests */
-	int blockSize;        /* size of component block. 
-				 (disklabel->d_secsize) */
-	int numBlocks;        /* number of blocks on this component.  May
-			         be smaller than the partition size. */
-	int partitionSize;    /* number of blocks on this *partition*. 
-				 Must exactly match the partition size
-				 from the disklabel. */
-	int future_use[33];   /* Future expansion */
-	int autoconfigure;    /* automatically configure this RAID set. 
-				 0 == no, 1 == yes */
-	int root_partition;   /* Use this set as /
-				 0 == no, 1 == yes*/
-	int last_unit;        /* last unit number (e.g. 0 for /dev/raid0) 
-				 of this component.  Used for autoconfigure
-				 only. */
-	int config_order;     /* 0 .. n.  The order in which the component
-				 should be auto-configured.  E.g. 0 is will 
-				 done first, (and would become raid0).
-				 This may be in conflict with last_unit!!?! */
-	                      /* Not currently used. */
-	int future_use2[44];  /* More future expansion */
+	int	version;	/* The version of this label. */
+	int	serial_number;	/*
+				 * A user-specified serial number for this
+				 * RAID set.
+				 */
+	int	mod_counter;	/*
+				 * Modification counter. Changed (usually
+				 * by incrementing) every time the label
+				 * is changed.
+				 */
+	int	row;		/* The row number of this component. */
+	int	column;		/* The column number of this component. */
+	int	num_rows;	/* Number of rows in this RAID set. */
+	int	num_columns;	/* Number of columns in this RAID set. */
+	int	clean;		/* 1 when clean, 0 when dirty. */
+	int	status;		/*
+				 * rf_ds_optimal, rf_ds_dist_spared, whatever.
+				 */
+	/* Stuff that will be in version 2 of the label. */
+	int	sectPerSU;	/* Sectors per Stripe Unit. */
+	int	SUsPerPU;	/* Stripe Units per Parity Units. */
+	int	SUsPerRU;	/* Stripe Units per Reconstruction Units. */
+	int	parityConfig;	/* '0' == RAID0, '1' == RAID1, etc. */
+	int	maxOutstanding;	/* maxOutstanding disk requests. */
+	int	blockSize;	/*
+				 * Size of component block.
+				 * (disklabel->d_secsize)
+				 */
+	int	numBlocks;	/*
+				 * Number of blocks on this component. May
+				 * be smaller than the partition size.
+				 */
+	int	partitionSize;	/*
+				 * Number of blocks on this *partition*.
+				 * Must exactly match the partition size
+				 * from the disklabel.
+				 */
+	int	future_use[33];	/* Future expansion. */
+	int	autoconfigure;	/*
+				 * Automatically configure this RAID set.
+				 * 0 == no, 1 == yes
+				 */
+	int	root_partition;	/*
+				 * Use this set as :
+				 * 0 == no, 1 == yes
+				 */
+	int	last_unit;	/*
+				 * Last unit number (e.g. 0 for /dev/raid0)
+				 * of this component. Used for autoconfigure
+				 * only.
+				 */
+	int	config_order;	/*
+				 * 0 .. n. The order in which the component
+				 * should be auto-configured. E.g. 0 is will
+				 * done first, (and would become raid0).
+				 * This may be in conflict with last_unit !!?!
+				 */
+				/* Not currently used. */
+	int	fut_use2[44];	/* More future expansion. */
 } RF_ComponentLabel_t;
 
 typedef struct RF_SingleComponent_s {
-	int row;
-	int column;
-	char component_name[50]; /* name of the component */
-} RF_SingleComponent_t; 
- 
-#ifdef _KERNEL
+	int	row;
+	int	column;
+	char	component_name[50];	/* name of the component */
+} RF_SingleComponent_t;
+
+#ifdef	_KERNEL
 
 struct raidcinfo {
-	struct vnode *ci_vp;	/* component device's vnode */
-	dev_t   ci_dev;		/* component device's dev_t */
-	RF_ComponentLabel_t ci_label; /* components RAIDframe label */
+	struct vnode		*ci_vp;		/* Component device's vnode. */
+	dev_t			 ci_dev;	/* Component device's dev_t. */
+	RF_ComponentLabel_t	 ci_label;	/*
+						 * Components RAIDframe label.
+						 */
 #if 0
-	size_t	ci_size; 		/* size */
-	char   *ci_path;		/* path to component */
-	size_t	ci_pathlen;		/* length of component path */
+	size_t			 ci_size; 	/* Size. */
+	char			*ci_path;	/* Path to component. */
+	size_t			 ci_pathlen;	/* Length of component path. */
 #endif
 };
 
-/* XXX probably belongs in a different .h file. */
+/* XXX Probably belongs in a different .h file. */
 typedef struct RF_AutoConfig_s {
-	char devname[56];       /* the name of this component */
-	int flag;               /* a general-purpose flag */
-	dev_t dev;              /* the device for this component */
-	struct vnode *vp;       /* Mr. Vnode Pointer */
-	RF_ComponentLabel_t *clabel;  /* the label */
-	struct RF_AutoConfig_s *next; /* the next autoconfig structure 
-				         in this set. */
+	char			 devname[56];	/*
+						 * The name of this component.
+						 */
+	int			 flag;		/* A general-purpose flag. */
+	dev_t			 dev;		/*
+						 * The device for this
+						 * component.
+						 */
+	struct vnode		*vp;		/* Master Vnode Pointer. */
+	RF_ComponentLabel_t	*clabel;	/* The label. */
+	struct RF_AutoConfig_s	*next;		/*
+						 * The next autoconfig
+						 * structure in this set.
+						 */
 } RF_AutoConfig_t;
 
 typedef struct RF_ConfigSet_s {
-	struct RF_AutoConfig_s *ac; /* all of the autoconfig structures for
-				       this config set. */
-	int rootable;               /* Set to 1 if this set can be root */
-	struct RF_ConfigSet_s *next;
+	struct RF_AutoConfig_s	*ac;		/*
+						 * All of the autoconfig
+						 * structures for this
+						 * config set.
+						 */
+	int			 rootable;	/*
+						 * Set to 1 if this set can
+						 * be root.
+						 */
+	struct RF_ConfigSet_s	*next;
 } RF_ConfigSet_t;
 
 
diff --git a/sys/dev/raidframe/rf_openbsdkintf.c b/sys/dev/raidframe/rf_openbsdkintf.c
index 18964abf085..c8b446653d1 100644
--- a/sys/dev/raidframe/rf_openbsdkintf.c
+++ b/sys/dev/raidframe/rf_openbsdkintf.c
@@ -1,5 +1,6 @@
-/* $OpenBSD: rf_openbsdkintf.c,v 1.20 2002/10/12 02:03:46 krw Exp $	*/
+/* $OpenBSD: rf_openbsdkintf.c,v 1.21 2002/12/16 07:01:04 tdeval Exp $	*/
 /* $NetBSD: rf_netbsdkintf.c,v 1.109 2001/07/27 03:30:07 oster Exp $	*/
+
 /*-
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -78,9 +79,6 @@
  *	@(#)cd.c	8.2 (Berkeley) 11/16/93
  */
 
-
-
-
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -108,11 +106,11 @@
  * rights to redistribute these changes.
  */
 
-/***********************************************************
+/*****************************************************************************
  *
- * rf_kintf.c -- the kernel interface routines for RAIDframe
+ * rf_kintf.c -- The kernel interface routines for RAIDframe.
  *
- ***********************************************************/
+ *****************************************************************************/
 
 #include <sys/errno.h>
 
@@ -156,51 +154,51 @@
 
 int	rf_kdebug_level = 0;
 
-#ifdef RAIDDEBUG
-#define db1_printf(a) do if (rf_kdebug_level > 0) printf a; while(0)
+#ifdef	RAIDDEBUG
+#define	db1_printf(a) do { if (rf_kdebug_level > 0) printf a; } while(0)
 #else	/* RAIDDEBUG */
-#define db1_printf(a) (void)0
-#endif	/* RAIDDEBUG */
+#define	db1_printf(a) (void)0
+#endif	/* ! RAIDDEBUG */
 
-static RF_Raid_t **raidPtrs;	/* global raid device descriptors */
+static RF_Raid_t **raidPtrs;	/* Global raid device descriptors. */
 
-RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex)
+RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex);
 
-/* requests to install a spare table */
+/* Requests to install a spare table. */
 static RF_SparetWait_t *rf_sparet_wait_queue;
 
-/* responses from installation process */
+/* Responses from installation process. */
 static RF_SparetWait_t *rf_sparet_resp_queue;
 
-/* prototypes */
-void	rf_KernelWakeupFunc(struct buf *);
-void	rf_InitBP(struct buf *, struct vnode *, unsigned, dev_t,
-	    RF_SectorNum_t, RF_SectorCount_t, caddr_t, void (*)(struct buf *),
-	    void *, int, struct proc *);
+/* Prototypes. */
+void rf_KernelWakeupFunc(struct buf *);
+void rf_InitBP(struct buf *, struct vnode *, unsigned, dev_t, RF_SectorNum_t,
+    RF_SectorCount_t, caddr_t, void (*)(struct buf *), void *, int,
+    struct proc *);
 void raidinit(RF_Raid_t *);
 
-void	raidattach(int);
-int	raidsize(dev_t);
-int	raidopen(dev_t, int, int, struct proc *);
-int	raidclose(dev_t, int, int, struct proc *);
-int	raidioctl(dev_t, u_long, caddr_t, int, struct proc *);
-int	raidwrite(dev_t, struct uio *, int);
-int	raidread(dev_t, struct uio *, int);
-void	raidstrategy(struct buf *);
-int	raiddump(dev_t, daddr_t, caddr_t, size_t);
+void raidattach(int);
+int  raidsize(dev_t);
+int  raidopen(dev_t, int, int, struct proc *);
+int  raidclose(dev_t, int, int, struct proc *);
+int  raidioctl(dev_t, u_long, caddr_t, int, struct proc *);
+int  raidwrite(dev_t, struct uio *, int);
+int  raidread(dev_t, struct uio *, int);
+void raidstrategy(struct buf *);
+int  raiddump(dev_t, daddr_t, caddr_t, size_t);
 
 /*
  * Pilfered from ccd.c
  */
 struct raidbuf {
-	struct buf rf_buf;	/* new I/O buf.	 MUST BE FIRST!!! */
-	struct buf *rf_obp;	/* ptr. to original I/O buf */
-	int	rf_flags;	/* misc. flags */
-	RF_DiskQueueData_t *req;/* the request that this was part of.. */
+	struct buf	 rf_buf;	/* New I/O buf.	 MUST BE FIRST!!! */
+	struct buf	*rf_obp;	/* Ptr. to original I/O buf. */
+	int		 rf_flags;	/* Miscellaneous flags. */
+	RF_DiskQueueData_t *req;	/* The request that this was part of. */
 };
 
-#define RAIDGETBUF(rs)		pool_get(&(rs)->sc_cbufpool, PR_NOWAIT)
-#define RAIDPUTBUF(rs, cbp)	pool_put(&(rs)->sc_cbufpool, cbp)
+#define	RAIDGETBUF(rs)		pool_get(&(rs)->sc_cbufpool, PR_NOWAIT)
+#define	RAIDPUTBUF(rs, cbp)	pool_put(&(rs)->sc_cbufpool, cbp)
 
 /*
  * Some port (like i386) use a swapgeneric that wants to snoop around
@@ -213,24 +211,24 @@ struct cfdriver raid_cd = {
 
 /*
  * XXX Not sure if the following should be replacing the raidPtrs above,
- * or if it should be used in conjunction with that... 
+ * or if it should be used in conjunction with that...
  */
 struct raid_softc {
-	int	 sc_flags;		/* flags */
-	int	 sc_cflags;		/* configuration flags */
-	size_t	 sc_size;		/* size of the raid device */
-	char	 sc_xname[20];		/* XXX external name */
-	struct disk sc_dkdev;		/* generic disk device info */
-	struct pool sc_cbufpool;	/* component buffer pool */
-	struct buf sc_q;		/* used for the device queue */
+	int		sc_flags;		/* Flags. */
+	int		sc_cflags;		/* Configuration flags. */
+	size_t		sc_size;		/* Size of the raid device. */
+	char		sc_xname[20];		/* XXX external name. */
+	struct disk	sc_dkdev;		/* Generic disk device info. */
+	struct pool	sc_cbufpool;		/* Component buffer pool. */
+	struct buf	sc_q;			/* Used for the device queue. */
 };
 
 /* sc_flags */
-#define RAIDF_INITED	0x01	/* unit has been initialized */
-#define RAIDF_WLABEL	0x02	/* label area is writable */
-#define RAIDF_LABELLING	0x04	/* unit is currently being labelled */
-#define RAIDF_WANTED	0x40	/* someone is waiting to obtain a lock */
-#define RAIDF_LOCKED	0x80	/* unit is locked */
+#define	RAIDF_INITED	0x01	/* Unit has been initialized. */
+#define	RAIDF_WLABEL	0x02	/* Label area is writable. */
+#define	RAIDF_LABELLING	0x04	/* Unit is currently being labelled. */
+#define	RAIDF_WANTED	0x40	/* Someone is waiting to obtain a lock. */
+#define	RAIDF_LOCKED	0x80	/* Unit is locked. */
 
 #define	raidunit(x)	DISKUNIT(x)
 int numraid = 0;
@@ -240,11 +238,11 @@ int numraid = 0;
  * into the device tree.  This is needed by some archs that look for
  * bootable devices in there.
  */
-int	rf_probe(struct device *, void *, void *);
-void	rf_attach(struct device *, struct device *, void *);
-int	rf_detach(struct device *, int);
-int	rf_activate(struct device *, enum devact);
-void	rf_zeroref(struct device *);
+int  rf_probe(struct device *, void *, void *);
+void rf_attach(struct device *, struct device *, void *);
+int  rf_detach(struct device *, int);
+int  rf_activate(struct device *, enum devact);
+void rf_zeroref(struct device *);
 
 struct cfattach raid_ca = {
 	sizeof(struct raid_softc), rf_probe, rf_attach,
@@ -255,132 +253,123 @@ struct cfattach raid_ca = {
  * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device.
  * Be aware that large numbers can allow the driver to consume a lot of
  * kernel memory, especially on writes, and in degraded mode reads.
- * 
- * For example: with a stripe width of 64 blocks (32k) and 5 disks, 
- * a single 64K write will typically require 64K for the old data, 
- * 64K for the old parity, and 64K for the new parity, for a total 
+ *
+ * For example: with a stripe width of 64 blocks (32k) and 5 disks,
+ * a single 64K write will typically require 64K for the old data,
+ * 64K for the old parity, and 64K for the new parity, for a total
  * of 192K (if the parity buffer is not re-used immediately).
  * Even it if is used immedately, that's still 128K, which when multiplied
  * by say 10 requests, is 1280K, *on top* of the 640K of incoming data.
- * 
+ *
  * Now in degraded mode, for example, a 64K read on the above setup may
- * require data reconstruction, which will require *all* of the 4 remaining 
+ * require data reconstruction, which will require *all* of the 4 remaining
  * disks to participate -- 4 * 32K/disk == 128K again.
  */
 
-#ifndef RAIDOUTSTANDING
-#define RAIDOUTSTANDING   6
+#ifndef	RAIDOUTSTANDING
+#define	RAIDOUTSTANDING		6
 #endif
 
-#define RAIDLABELDEV(dev)	\
+#define	RAIDLABELDEV(dev)						\
 	(MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART))
 
-/* declared here, and made public, for the benefit of KVM stuff.. */
-struct raid_softc *raid_softc;
+/* Declared here, and made public, for the benefit of KVM stuff... */
+struct raid_softc  *raid_softc;
 struct raid_softc **raid_scPtrs;
 
-void	rf_shutdown_hook(RF_ThreadArg_t);
-void	raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *, struct disklabel *);
-void	raidgetdisklabel(dev_t);
-void	raidmakedisklabel(struct raid_softc *);
+void rf_shutdown_hook(RF_ThreadArg_t);
+void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *, struct disklabel *);
+void raidgetdisklabel(dev_t);
+void raidmakedisklabel(struct raid_softc *);
 
-int	raidlock(struct raid_softc *);
-void	raidunlock(struct raid_softc *);
+int  raidlock(struct raid_softc *);
+void raidunlock(struct raid_softc *);
 
-void	rf_markalldirty(RF_Raid_t *);
+void rf_markalldirty(RF_Raid_t *);
 
 struct device *raidrootdev;
 
-int findblkmajor(struct device *dv);
+int  findblkmajor(struct device *dv);
 char *findblkname(int);
 
 void rf_ReconThread(struct rf_recon_req *);
 /* XXX what I want is: */
-/*void rf_ReconThread(RF_Raid_t *raidPtr);  */
+/*void rf_ReconThread(RF_Raid_t *raidPtr);*/
 void rf_RewriteParityThread(RF_Raid_t *raidPtr);
 void rf_CopybackThread(RF_Raid_t *raidPtr);
 void rf_ReconstructInPlaceThread(struct rf_recon_req *);
-#ifdef RAID_AUTOCONFIG
+#ifdef	RAID_AUTOCONFIG
 void rf_buildroothack(void *);
-int rf_reasonable_label(RF_ComponentLabel_t *);
-#endif
+int  rf_reasonable_label(RF_ComponentLabel_t *);
+#endif	/* RAID_AUTOCONFIG */
 
 RF_AutoConfig_t *rf_find_raid_components(void);
 RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
-int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
+int  rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
 void rf_create_configuration(RF_AutoConfig_t *,RF_Config_t *,
 				  RF_Raid_t *);
-int rf_set_autoconfig(RF_Raid_t *, int);
-int rf_set_rootpartition(RF_Raid_t *, int);
+int  rf_set_autoconfig(RF_Raid_t *, int);
+int  rf_set_rootpartition(RF_Raid_t *, int);
 void rf_release_all_vps(RF_ConfigSet_t *);
 void rf_cleanup_config_set(RF_ConfigSet_t *);
-int rf_have_enough_components(RF_ConfigSet_t *);
-int rf_auto_config_set(RF_ConfigSet_t *, int *);
-
-#ifdef RAID_AUTOCONFIG
-static int raidautoconfig = 0; /* Debugging, mostly.  Set to 0 to not
-				  allow autoconfig to take place.
-			          Note that this is overridden by having
-			          RAID_AUTOCONFIG as an option in the 
-			          kernel config file.  */
-#endif
+int  rf_have_enough_components(RF_ConfigSet_t *);
+int  rf_auto_config_set(RF_ConfigSet_t *, int *);
+
+#ifdef	RAID_AUTOCONFIG
+static int raidautoconfig = 0;	/*
+				 * Debugging, mostly.  Set to 0 to not
+				 * allow autoconfig to take place.
+				 * Note that this is overridden by having
+				 * RAID_AUTOCONFIG as an option in the
+				 * kernel config file.
+				 */
+#endif	/* RAID_AUTOCONFIG */
 
 int
-rf_probe(parent, match_, aux)
-	struct device *parent;
-	void *match_;
-	void *aux;
+rf_probe(struct device *parent, void *match_, void *aux)
 {
 	return 0;
 }
 
 void
-rf_attach(parent, self, aux)
-	struct device *parent, *self;
-	void *aux;
+rf_attach(struct device *parent, struct device *self, void *aux)
 {
-	/* struct raid_softc *raid = (void *)self; */
+	/*struct raid_softc *raid = (void *)self;*/
 }
 
 int
-rf_detach(self, flags)
-	struct device *self;
-	int flags;
+rf_detach(struct device *self, int flags)
 {
 	return 0;
 }
 
 int
-rf_activate(self, act)
-	struct device *self;
-	enum devact act;
+rf_activate(struct device *self, enum devact act)
 {
 	return 0;
 }
 
 void
-rf_zeroref(self)
-	struct device *self;
+rf_zeroref(struct device *self)
 {
 }
 
 void
-raidattach(num)
-	int num;
+raidattach(int num)
 {
 	int raidID;
 	int i, rc;
-#ifdef RAID_AUTOCONFIG
-	RF_AutoConfig_t *ac_list; /* autoconfig list */
+#ifdef	RAID_AUTOCONFIG
+	RF_AutoConfig_t *ac_list;	/* Autoconfig list. */
 	RF_ConfigSet_t *config_sets;
-#endif
+#endif	/* RAID_AUTOCONFIG */
 
 	db1_printf(("raidattach: Asked for %d units\n", num));
 
 	if (num <= 0) {
-#ifdef DIAGNOSTIC
+#ifdef	DIAGNOSTIC
 		panic("raidattach: count <= 0");
-#endif
+#endif	/* DIAGNOSTIC */
 		return;
 	}
 
@@ -396,27 +385,26 @@ raidattach(num)
 
 	rc = rf_mutex_init(&rf_sparet_wait_mutex);
 	if (rc) {
-	        RF_PANIC();
-        }
+		RF_PANIC();
+	}
 
 	rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
 
 	for (i = 0; i < num; i++)
-	        raidPtrs[i] = NULL;
+		raidPtrs[i] = NULL;
 	rc = rf_BootRaidframe();
 	if (rc == 0)
-	        printf("Kernelized RAIDframe activated\n");
+		printf("Kernelized RAIDframe activated\n");
 	else
-	        panic("Serious error booting RAID!!");
+	        panic("Serious error booting RAID !!!");
 	
 	/*
-	 * Put together some datastructures like the CCD device does..
+	 * Put together some datastructures like the CCD device does...
 	 * This lets us lock the device and what-not when it gets opened.
 	 */
-	
+
 	raid_softc = (struct raid_softc *)
-		malloc(num * sizeof(struct raid_softc),
-		       M_RAIDFRAME, M_NOWAIT);
+		malloc(num * sizeof(struct raid_softc), M_RAIDFRAME, M_NOWAIT);
 	if (raid_softc == NULL) {
 		printf("WARNING: no memory for RAIDframe driver\n");
 		return;
@@ -425,8 +413,8 @@ raidattach(num)
 	bzero(raid_softc, num * sizeof (struct raid_softc));
 
 	raid_scPtrs = (struct raid_softc **)
-		malloc(num * sizeof(struct raid_softc *),
-		       M_RAIDFRAME, M_NOWAIT);
+		malloc(num * sizeof(struct raid_softc *), M_RAIDFRAME,
+		    M_NOWAIT);
 	if (raid_scPtrs == NULL) {
 		printf("WARNING: no memory for RAIDframe driver\n");
 		return;
@@ -435,7 +423,7 @@ raidattach(num)
 	bzero(raid_scPtrs, num * sizeof (struct raid_softc *));
 
 	raidrootdev = (struct device *)malloc(num * sizeof(struct device),
-					      M_RAIDFRAME, M_NOWAIT);
+	    M_RAIDFRAME, M_NOWAIT);
 	if (raidrootdev == NULL) {
 		panic("No memory for RAIDframe driver!!?!?!");
 	}
@@ -464,38 +452,41 @@ raidattach(num)
 	raid_cd.cd_devs = (void **) raid_scPtrs;
 	raid_cd.cd_ndevs = num;
 
-#ifdef RAID_AUTOCONFIG
+#ifdef	RAID_AUTOCONFIG
 	raidautoconfig = 1;
 
 	if (raidautoconfig) {
-		/* 1. locate all RAID components on the system */
+		/* 1. Locate all RAID components on the system. */
 
 #ifdef	RAIDDEBUG
 		printf("Searching for raid components...\n");
-#endif
+#endif	/* RAIDDEBUG */
 		ac_list = rf_find_raid_components();
 
-		/* 2. sort them into their respective sets */
+		/* 2. Sort them into their respective sets. */
 
 		config_sets = rf_create_auto_sets(ac_list);
 
-		/* 3. evaluate each set and configure the valid ones
-		   This gets done in rf_buildroothack() */
+		/*
+		 * 3. Evaluate each set and configure the valid ones
+		 * This gets done in rf_buildroothack().
+		 */
 
-		/* schedule the creation of the thread to do the 
-		   "/ on RAID" stuff */
+		/*
+		 * Schedule the creation of the thread to do the
+		 * "/ on RAID" stuff.
+		 */
 
 		rf_buildroothack(config_sets);
 
 	}
-#endif
+#endif	/* RAID_AUTOCONFIG */
 
 }
 
-#ifdef RAID_AUTOCONFIG
+#ifdef	RAID_AUTOCONFIG
 void
-rf_buildroothack(arg)
-	void *arg;
+rf_buildroothack(void *arg)
 {
 	RF_ConfigSet_t *config_sets = arg;
 	RF_ConfigSet_t *cset;
@@ -511,30 +502,34 @@ rf_buildroothack(arg)
 	cset = config_sets;
 	while(cset != NULL ) {
 		next_cset = cset->next;
-		if (rf_have_enough_components(cset) && 
+		if (rf_have_enough_components(cset) &&
 		    cset->ac->clabel->autoconfigure==1) {
 			retcode = rf_auto_config_set(cset,&raidID);
 			if (!retcode) {
 				if (cset->rootable) {
 					rootID = raidID;
 #ifdef	RAIDDEBUG
-					printf("eligible root device %d: raid%d\n", num_root, rootID);
+					printf("eligible root device %d:"
+					    " raid%d\n", num_root, rootID);
 #endif	/* RAIDDEBUG */
 					num_root++;
 				}
 			} else {
 				/* The autoconfig didn't work :( */
 #ifdef	RAIDDEBUG
-				printf("Autoconfig failed with code %d for raid%d\n", retcode, raidID);
-#endif
+				printf("Autoconfig failed with code %d for"
+				    " raid%d\n", retcode, raidID);
+#endif	/* RAIDDEBUG */
 				rf_release_all_vps(cset);
 			}
 		} else {
-			/* we're not autoconfiguring this set...  
-			   release the associated resources */
+			/*
+			 * We're not autoconfiguring this set...
+			 * Release the associated resources.
+			 */
 			rf_release_all_vps(cset);
 		}
-		/* cleanup */
+		/* Cleanup. */
 		rf_cleanup_config_set(cset);
 		cset = next_cset;
 	}
@@ -548,26 +543,25 @@ rf_buildroothack(arg)
 			if (majdev < 0)
 				boothowto |= RB_ASKNAME;
 			else {
-				rootdev = MAKEDISKDEV(majdev,rootID,0); 
+				rootdev = MAKEDISKDEV(majdev,rootID,0);
 				boothowto |= RB_DFLTROOT;
 			}
 		} else if (num_root > 1) {
-			/* we can't guess.. require the user to answer... */
+			/* We can't guess... Require the user to answer... */
 			boothowto |= RB_ASKNAME;
 		}
 	}
 }
-#endif
+#endif	/* RAID_AUTOCONFIG */
 
 void
-rf_shutdown_hook(arg)
-	RF_ThreadArg_t arg;
+rf_shutdown_hook(RF_ThreadArg_t arg)
 {
 	int unit;
 	struct raid_softc *rs;
 	RF_Raid_t *raidPtr;
 
-	/* Don't do it if we are not "safe" */
+	/* Don't do it if we are not "safe". */
 	if (boothowto & RB_NOSYNC)
 		return;
 
@@ -575,7 +569,7 @@ rf_shutdown_hook(arg)
 	unit = raidPtr->raidid;
 	rs = &raid_softc[unit];
 
-	/* Shutdown the system */
+	/* Shutdown the system. */
 
 	if (rf_hook_cookies != NULL && rf_hook_cookies[unit] != NULL)
 		rf_hook_cookies[unit] = NULL;
@@ -595,8 +589,7 @@ rf_shutdown_hook(arg)
 }
 
 int
-raidsize(dev)
-	dev_t dev;
+raidsize(dev_t dev)
 {
 	struct raid_softc *rs;
 	struct disklabel *lp;
@@ -631,11 +624,7 @@ raidsize(dev)
 }
 
 int
-raiddump(dev, blkno, va, size)
-	dev_t dev;
-	daddr_t blkno;
-	caddr_t va;
-	size_t size;
+raiddump(dev_t dev, daddr_t blkno, caddr_t va, size_t size)
 {
 	/* Not implemented. */
 	return (ENXIO);
@@ -643,17 +632,14 @@ raiddump(dev, blkno, va, size)
 
 /* ARGSUSED */
 int
-raidopen(dev, flags, fmt, p)
-	dev_t dev;
-	int flags, fmt;
-	struct proc *p;
+raidopen(dev_t dev, int flags, int fmt, struct proc *p)
 {
 	int unit = raidunit(dev);
 	struct raid_softc *rs;
 	struct disklabel *lp;
 	int part,pmask;
 	int error = 0;
-	
+
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
@@ -672,7 +658,7 @@ raidopen(dev, flags, fmt, p)
 	if ((rs->sc_flags & RAIDF_INITED) && (rs->sc_dkdev.dk_openmask == 0))
 		raidgetdisklabel(dev);
 
-	/* make sure that this partition exists */
+	/* Make sure that this partition exists. */
 
 	if (part != RAW_PART) {
 		db1_printf(("Not a raw partition..\n"));
@@ -686,7 +672,7 @@ raidopen(dev, flags, fmt, p)
 		}
 	}
 
-	/* Prevent this unit from being unconfigured while open. */
+	/* Prevent this unit from being unconfigured while opened. */
 	switch (fmt) {
 	case S_IFCHR:
 		rs->sc_dkdev.dk_copenmask |= pmask;
@@ -699,15 +685,19 @@ raidopen(dev, flags, fmt, p)
 
 	if ((rs->sc_dkdev.dk_openmask == 0) &&
 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
-	        /* First one... mark things as dirty... Note that we *MUST*
-	         have done a configure before this.  I DO NOT WANT TO BE
-	         SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED
-	         THAT THEY BELONG TOGETHER!!!!! */
-	        /* XXX should check to see if we're only open for reading
-	           here... If so, we needn't do this, but then need some
-	           other way of keeping track of what's happened.. */
+		/*
+		 * First one...  Mark things as dirty...  Note that we *MUST*
+		 * have done a configure before this.  I DO NOT WANT TO BE
+		 * SCRIBBLING TO RANDOM COMPONENTS UNTIL IT'S BEEN DETERMINED
+		 * THAT THEY BELONG TOGETHER!!!!!
+		 */
+		/*
+		 * XXX should check to see if we're only open for reading
+		 * here...  If so, we needn't do this, but then need some
+		 * other way of keeping track of what's happened...
+		 */
 
-	        rf_markalldirty( raidPtrs[unit] );
+		rf_markalldirty( raidPtrs[unit] );
 	}
 
 	rs->sc_dkdev.dk_openmask =
@@ -720,10 +710,7 @@ raidopen(dev, flags, fmt, p)
 
 /* ARGSUSED */
 int
-raidclose(dev, flags, fmt, p)
-	dev_t dev;
-	int flags, fmt;
-	struct proc *p;
+raidclose(dev_t dev, int flags, int fmt, struct proc *p)
 {
 	int unit = raidunit(dev);
 	struct raid_softc *rs;
@@ -754,10 +741,12 @@ raidclose(dev, flags, fmt, p)
 
 	if ((rs->sc_dkdev.dk_openmask == 0) &&
 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
-	        /* Last one... device is not unconfigured yet.
-	           Device shutdown has taken care of setting the
-	           clean bits if RAIDF_INITED is not set
-	           mark things as clean... */
+		/*
+		 * Last one...  Device is not unconfigured yet.
+		 * Device shutdown has taken care of setting the
+		 * clean bits if RAIDF_INITED is not set.
+		 * Mark things as clean...
+		 */
 		db1_printf(("Last one on raid%d.  Updating status.\n",unit));
 		rf_update_component_labels(raidPtrs[unit],
 						 RF_FINAL_COMPONENT_UPDATE);
@@ -768,8 +757,7 @@ raidclose(dev, flags, fmt, p)
 }
 
 void
-raidstrategy(bp)
-	struct buf *bp;
+raidstrategy(struct buf *bp)
 {
 	int s;
 
@@ -838,10 +826,7 @@ raidstrategy_end:
 
 /* ARGSUSED */
 int
-raidread(dev, uio, flags)
-	dev_t dev;
-	struct uio *uio;
-	int flags;
+raidread(dev_t dev, struct uio *uio, int flags)
 {
 	int unit = raidunit(dev);
 	struct raid_softc *rs;
@@ -862,10 +847,7 @@ raidread(dev, uio, flags)
 
 /* ARGSUSED */
 int
-raidwrite(dev, uio, flags)
-	dev_t dev;
-	struct uio *uio;
-	int flags;
+raidwrite(dev_t dev, struct uio *uio, int flags)
 {
 	int unit = raidunit(dev);
 	struct raid_softc *rs;
@@ -881,12 +863,7 @@ raidwrite(dev, uio, flags)
 }
 
 int
-raidioctl(dev, cmd, data, flag, p)
-	dev_t dev;
-	u_long cmd;
-	caddr_t data;
-	int flag;
-	struct proc *p;
+raidioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 {
 	int unit = raidunit(dev);
 	int error = 0;
@@ -965,19 +942,19 @@ raidioctl(dev, cmd, data, flag, p)
 		if ((rs->sc_flags & RAIDF_INITED) == 0)
 			return (ENXIO);
 	}
-	
+
 	switch (cmd) {
-		/* Configure the system */
+		/* Configure the system. */
 	case RAIDFRAME_CONFIGURE:
 
 		if (raidPtr->valid) {
-			/* There is a valid RAID set running on this unit! */
+			/* There is a valid RAID set running on this unit ! */
 			printf("raid%d: Device already configured!\n",unit);
 			return(EINVAL);
 		}
 
 		/*
-		 * Copy-in the configuration information
+		 * Copy-in the configuration information.
 		 * data points to a pointer to the configuration structure.
 		 */
 		u_cfg = *((RF_Config_t **)data);
@@ -998,7 +975,7 @@ raidioctl(dev, cmd, data, flag, p)
 		 */
 		if (k_cfg->layoutSpecificSize) {
 			if (k_cfg->layoutSpecificSize > 10000) {
-				/* sanity check */
+				/* Sanity check. */
 				RF_Free(k_cfg, sizeof(RF_Config_t));
 				return (EINVAL);
 			}
@@ -1012,38 +989,40 @@ raidioctl(dev, cmd, data, flag, p)
 			    (caddr_t)specific_buf, k_cfg->layoutSpecificSize);
 			if (retcode) {
 				RF_Free(k_cfg, sizeof(RF_Config_t));
-				RF_Free(specific_buf, 
+				RF_Free(specific_buf,
 					k_cfg->layoutSpecificSize);
 				return (retcode);
 			}
 		} else
 			specific_buf = NULL;
 		k_cfg->layoutSpecific = specific_buf;
-		
+
 		/*
 		 * We should do some kind of sanity check on the
 		 * configuration.
-		 * Store the sum of all the bytes in the last byte?
+		 * Store the sum of all the bytes in the last byte ?
 		 */
 
 		/*
 		 * Clear the entire RAID descriptor, just to make sure
-		 *  there is no stale data left in the case of a 
-		 *  reconfiguration 
+		 *  there is no stale data left in the case of a
+		 *  reconfiguration.
 		 */
 		bzero((char *) raidPtr, sizeof(RF_Raid_t));
 
-		/* configure the system */
+		/* Configure the system. */
 		raidPtr->raidid = unit;
 
 		retcode = rf_Configure(raidPtr, k_cfg, NULL);
 
 		if (retcode == 0) {
 
-			/* allow this many simultaneous IO's to
-			   this RAID device */
+			/*
+			 * Allow this many simultaneous IO's to
+			 * this RAID device.
+			 */
 			raidPtr->openings = RAIDOUTSTANDING;
-					
+
 			raidinit(raidPtr);
 			rf_markalldirty(raidPtr);
 		}
@@ -1053,12 +1032,12 @@ raidioctl(dev, cmd, data, flag, p)
 			RF_Free(specific_buf, k_cfg->layoutSpecificSize);
 		}
 		RF_Free(k_cfg, sizeof (RF_Config_t));
-		
+
 		return (retcode);
-		
+
 	case RAIDFRAME_SHUTDOWN:
-		/* Shutdown the system */
-		
+		/* Shutdown the system. */
+
 		if ((error = raidlock(rs)) != 0)
 			return (error);
 
@@ -1093,14 +1072,18 @@ raidioctl(dev, cmd, data, flag, p)
 		raidunlock(rs);
 
 		return (retcode);
-		
+
 	case RAIDFRAME_GET_COMPONENT_LABEL:
 		clabel_ptr = (RF_ComponentLabel_t **) data;
-		/* need to read the component label for the disk indicated
-		   by row,column in clabel */
+		/*
+		 * We need to read the component label for the disk indicated
+		 * by row,column in clabel.
+		 */
 
-		/* For practice, let's get it directly fromdisk, rather 
-		   than from the in-core copy */
+		/*
+		 * For practice, let's get it directly from disk, rather
+		 * than from the in-core copy.
+		 */
 		RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ),
 			   (RF_ComponentLabel_t *));
 		if (clabel == NULL)
@@ -1108,14 +1091,14 @@ raidioctl(dev, cmd, data, flag, p)
 
 		bzero((char *) clabel, sizeof(RF_ComponentLabel_t));
 
-		retcode = copyin( *clabel_ptr, clabel, 
+		retcode = copyin( *clabel_ptr, clabel,
 				  sizeof(RF_ComponentLabel_t));
 
 		if (retcode) {
 			RF_Free( clabel, sizeof(RF_ComponentLabel_t));
 			return(retcode);
 		}
- 
+
  		row = clabel->row;
 		column = clabel->column;
 
@@ -1124,12 +1107,10 @@ raidioctl(dev, cmd, data, flag, p)
 			return(EINVAL);
   		}
 
-		raidread_component_label( 
-                              raidPtr->Disks[row][column].dev, 
-			      raidPtr->raid_cinfo[row][column].ci_vp, 
-			      clabel );
+		raidread_component_label(raidPtr->Disks[row][column].dev,
+		    raidPtr->raid_cinfo[row][column].ci_vp, clabel );
 
-		retcode = copyout((caddr_t) clabel, 
+		retcode = copyout((caddr_t) clabel,
 				  (caddr_t) *clabel_ptr,
 				  sizeof(RF_ComponentLabel_t));
 		RF_Free( clabel, sizeof(RF_ComponentLabel_t));
@@ -1139,10 +1120,11 @@ raidioctl(dev, cmd, data, flag, p)
 		clabel = (RF_ComponentLabel_t *) data;
 
 		/* XXX check the label for valid stuff... */
-		/* Note that some things *should not* get modified --
-		   the user should be re-initing the labels instead of 
-		   trying to patch things.
-		   */
+		/*
+		 * Note that some things *should not* get modified --
+		 * the user should be re-initing the labels instead of
+		 * trying to patch things.
+		 */
 
 #ifdef	RAIDDEBUG
 		printf("Got component label:\n");
@@ -1155,7 +1137,7 @@ raidioctl(dev, cmd, data, flag, p)
 		printf("Num Columns: %d\n", clabel->num_columns);
 		printf("Clean: %d\n", clabel->clean);
 		printf("Status: %d\n", clabel->status);
-#endif
+#endif	/* RAIDDEBUG */
 
 		row = clabel->row;
 		column = clabel->column;
@@ -1168,24 +1150,22 @@ raidioctl(dev, cmd, data, flag, p)
 
  		/* XXX this isn't allowed to do anything for now :-) */
 #if 0
-		raidwrite_component_label( 
-                            raidPtr->Disks[row][column].dev, 
-			    raidPtr->raid_cinfo[row][column].ci_vp, 
-			    clabel );
+		raidwrite_component_label(raidPtr->Disks[row][column].dev,
+		    raidPtr->raid_cinfo[row][column].ci_vp, clabel );
 #endif
 		return (0);
 
-	case RAIDFRAME_INIT_LABELS:	
+	case RAIDFRAME_INIT_LABELS:
 		clabel = (RF_ComponentLabel_t *) data;
-		/* 
-		   we only want the serial number from
-		   the above.  We get all the rest of the information
-		   from the config that was used to create this RAID
-		   set. 
-		   */
+		/*
+		 * We only want the serial number from the above.
+		 * We get all the rest of the information from
+		 * the config that was used to create this RAID
+		 * set.
+		 */
 
 		raidPtr->serial_number = clabel->serial_number;
-		
+
 		raid_init_component_label(raidPtr, &ci_label);
 		ci_label.serial_number = clabel->serial_number;
 
@@ -1197,27 +1177,27 @@ raidioctl(dev, cmd, data, flag, p)
 					ci_label.partitionSize =
 					    diskPtr->partitionSize;
 					ci_label.column = column;
-					raidwrite_component_label( 
-					    raidPtr->Disks[row][column].dev, 
-					    raidPtr->raid_cinfo[row][column].ci_vp, 
+					raidwrite_component_label(
+					    raidPtr->Disks[row][column].dev,
+					    raidPtr->raid_cinfo[row][column].ci_vp,
 					    &ci_label );
 				}
 			}
 		}
 
 		return (retcode);
-  
+
 	case RAIDFRAME_REWRITEPARITY:
 
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* Parity for RAID 0 is trivially correct */
+			/* Parity for RAID 0 is trivially correct. */
 			raidPtr->parity_good = RF_RAID_CLEAN;
 			return(0);
 		}
 
-		
+
 		if (raidPtr->parity_rewrite_in_progress == 1) {
-			/* Re-write is already in progress! */
+			/* Re-write is already in progress ! */
 			return(EINVAL);
 		}
 
@@ -1251,14 +1231,14 @@ raidioctl(dev, cmd, data, flag, p)
 
 	case RAIDFRAME_DELETE_COMPONENT:
 		componentPtr = (RF_SingleComponent_t *)data;
-		memcpy( &component, componentPtr, 
+		memcpy( &component, componentPtr,
 			sizeof(RF_SingleComponent_t));
 		retcode = rf_delete_component(raidPtr, &component);
 		return(retcode);
 
 	case RAIDFRAME_INCORPORATE_HOT_SPARE:
 		componentPtr = (RF_SingleComponent_t *)data;
-		memcpy( &component, componentPtr, 
+		memcpy( &component, componentPtr,
 			sizeof(RF_SingleComponent_t));
 		retcode = rf_incorporate_hot_spare(raidPtr, &component);
 		return(retcode);
@@ -1266,17 +1246,17 @@ raidioctl(dev, cmd, data, flag, p)
 	case RAIDFRAME_REBUILD_IN_PLACE:
 
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* Can't do this on a RAID 0!! */
+			/* Can't do this on a RAID 0 !! */
 			return(EINVAL);
 		}
 
 		if (raidPtr->recon_in_progress == 1) {
-			/* a reconstruct is already in progress! */
+			/* A reconstruct is already in progress ! */
 			return(EINVAL);
 		}
 
 		componentPtr = (RF_SingleComponent_t *) data;
-		memcpy( &component, componentPtr, 
+		memcpy( &component, componentPtr,
 			sizeof(RF_SingleComponent_t));
 		row = component.row;
 		column = component.column;
@@ -1345,7 +1325,7 @@ raidioctl(dev, cmd, data, flag, p)
 	case RAIDFRAME_RESET_ACCTOTALS:
 		bzero(&raidPtr->acc_totals, sizeof(raidPtr->acc_totals));
 		return (0);
-  
+
   	case RAIDFRAME_GET_ACCTOTALS:
 		totals = (RF_AccTotals_t *) data;
 		*totals = raidPtr->acc_totals;
@@ -1354,25 +1334,25 @@ raidioctl(dev, cmd, data, flag, p)
 	case RAIDFRAME_KEEP_ACCTOTALS:
 		raidPtr->keep_acc_totals = *(int *)data;
 		return (0);
-  
+
 	case RAIDFRAME_GET_SIZE:
 		*(int *) data = raidPtr->totalSectors;
 		return (0);
 
-	/* fail a disk & optionally start reconstruction */
+	/* Fail a disk & optionally start reconstruction. */
 	case RAIDFRAME_FAIL_DISK:
 		rr = (struct rf_recon_req *)data;
-		
+
 		if (rr->row < 0 || rr->row >= raidPtr->numRow ||
 		    rr->col < 0 || rr->col >= raidPtr->numCol)
 			return (EINVAL);
 
 		db1_printf(("raid%d: Failing the disk: row: %d col: %d\n",
-		       unit, rr->row, rr->col));
-		
+		    unit, rr->row, rr->col));
+
 		/*
 		 * Make a copy of the recon request so that we don't
-		 * rely on the user's buffer
+		 * rely on the user's buffer.
 		 */
 		RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
 		if (rrcopy == NULL)
@@ -1384,32 +1364,34 @@ raidioctl(dev, cmd, data, flag, p)
 					   rf_ReconThread,
 					   rrcopy,"raid_recon");
 		return (0);
-		
+
 	/*
 	 * Invoke a copyback operation after recon on whatever
 	 * disk needs it, if any.
 	 */
-	case RAIDFRAME_COPYBACK:		
+	case RAIDFRAME_COPYBACK:
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* This makes no sense on a RAID 0!! */
+			/* This makes no sense on a RAID 0 !! */
 			return(EINVAL);
 		}
-  
+
 		if (raidPtr->copyback_in_progress == 1) {
-			/* Copyback is already in progress! */
+			/* Copyback is already in progress ! */
 			return(EINVAL);
 		}
-  
+
 		retcode = RF_CREATE_THREAD(raidPtr->copyback_thread,
 					   rf_CopybackThread,
 					   raidPtr,"raid_copyback");
 		return (retcode);
 
-	/* Return the percentage completion of reconstruction */
+	/* Return the percentage completion of reconstruction. */
 	case RAIDFRAME_CHECK_RECON_STATUS:
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* This makes no sense on a RAID 0, so tell the
-			   user it's done. */
+			/*
+			 * This makes no sense on a RAID 0, so tell the
+			 * user it's done.
+			 */
 			*(int *) data = 100;
 			return(0);
 		}
@@ -1429,9 +1411,9 @@ raidioctl(dev, cmd, data, flag, p)
 			progressInfo.completed = 100;
 			progressInfo.total = 100;
 		} else {
-			progressInfo.total = 
+			progressInfo.total =
 				raidPtr->reconControl[row]->numRUsTotal;
-			progressInfo.completed = 
+			progressInfo.completed =
 				raidPtr->reconControl[row]->numRUsComplete;
 			progressInfo.remaining = progressInfo.total -
 				progressInfo.completed;
@@ -1443,14 +1425,16 @@ raidioctl(dev, cmd, data, flag, p)
 
 	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS:
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* This makes no sense on a RAID 0, so tell the
-			   user it's done. */
+			/*
+			 * This makes no sense on a RAID 0, so tell the
+			 * user it's done.
+			 */
 			*(int *) data = 100;
 			return(0);
 		}
 		if (raidPtr->parity_rewrite_in_progress == 1) {
-			*(int *) data = 100 * 
-				raidPtr->parity_rewrite_stripes_done / 
+			*(int *) data = 100 *
+				raidPtr->parity_rewrite_stripes_done /
 				raidPtr->Layout.numStripe;
 		} else {
 			*(int *) data = 100;
@@ -1461,7 +1445,7 @@ raidioctl(dev, cmd, data, flag, p)
 		progressInfoPtr = (RF_ProgressInfo_t **) data;
 		if (raidPtr->parity_rewrite_in_progress == 1) {
 			progressInfo.total = raidPtr->Layout.numStripe;
-			progressInfo.completed = 
+			progressInfo.completed =
 				raidPtr->parity_rewrite_stripes_done;
 			progressInfo.remaining = progressInfo.total -
 				progressInfo.completed;
@@ -1477,7 +1461,7 @@ raidioctl(dev, cmd, data, flag, p)
 
 	case RAIDFRAME_CHECK_COPYBACK_STATUS:
 		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* This makes no sense on a RAID 0 */
+			/* This makes no sense on a RAID 0 !! */
 			*(int *) data = 100;
 			return(0);
 		}
@@ -1493,7 +1477,7 @@ raidioctl(dev, cmd, data, flag, p)
 		progressInfoPtr = (RF_ProgressInfo_t **) data;
 		if (raidPtr->copyback_in_progress == 1) {
 			progressInfo.total = raidPtr->Layout.numStripe;
-			progressInfo.completed = 
+			progressInfo.completed =
 				raidPtr->copyback_stripes_done;
 			progressInfo.remaining = progressInfo.total -
 				progressInfo.completed;
@@ -1529,12 +1513,12 @@ raidioctl(dev, cmd, data, flag, p)
 		waitreq = rf_sparet_wait_queue;
 		rf_sparet_wait_queue = rf_sparet_wait_queue->next;
 		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
-		
+
 		*((RF_SparetWait_t *)data) = *waitreq;
-		
+
 		RF_Free(waitreq, sizeof *waitreq);
 		return (0);
-		
+
 	case RAIDFRAME_ABORT_SPARET_WAIT:
 		/*
 		 * Wakes up a process waiting on SPARET_WAIT and puts an
@@ -1552,15 +1536,15 @@ raidioctl(dev, cmd, data, flag, p)
 	case RAIDFRAME_SEND_SPARET:
 		/*
 		 * Used by the spare table daemon to deliver a spare table
-		 * into the kernel
+		 * into the kernel.
 		 */
-		
-		/* Install the spare table */
+
+		/* Install the spare table. */
 		retcode = rf_SetSpareTable(raidPtr,*(void **)data);
-		
+
 		/*
-		 * Respond to the requestor.  the return status of the
-		 * spare table installation is passed in the "fcol" field
+		 * Respond to the requestor.  The return status of the
+		 * spare table installation is passed in the "fcol" field.
 		 */
 		RF_Malloc(waitreq, sizeof *waitreq, (RF_SparetWait_t *));
 		waitreq->fcol = retcode;
@@ -1569,17 +1553,17 @@ raidioctl(dev, cmd, data, flag, p)
 		rf_sparet_resp_queue = waitreq;
 		wakeup(&rf_sparet_resp_queue);
 		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
-		
+
 		return (retcode);
 #endif
-	/* fall through to the os-specific code below */
+	/* Fall through to the os-specific code below. */
 	default:
 		break;
 	}
-	
+
 	if (!raidPtr->valid)
 		return (EINVAL);
-	
+
 	/*
 	 * Add support for "regular" device ioctls here.
 	 */
@@ -1633,7 +1617,7 @@ raidioctl(dev, cmd, data, flag, p)
 	case DIOCGPDINFO:
   		raidgetdefaultlabel(raidPtr, rs, (struct disklabel *) data);
   		break;
-  
+
 	default:
 		retcode = ENOTTY;
 	}
@@ -1642,35 +1626,34 @@ raidioctl(dev, cmd, data, flag, p)
 }
 
 /*
- * raidinit -- complete the rest of the initialization for the
+ * raidinit -- Complete the rest of the initialization for the
  * RAIDframe device.
  */
 void
-raidinit(raidPtr)
-	RF_Raid_t *raidPtr;
+raidinit(RF_Raid_t *raidPtr)
 {
 	struct raid_softc *rs;
 	struct cfdata	*cf;
-	int      unit;
+	int unit;
 
 	unit = raidPtr->raidid;
 
 	rs = &raid_softc[unit];
 	pool_init(&rs->sc_cbufpool, sizeof(struct raidbuf), 0,
 		0, 0, "raidpl", NULL);
-	
+
 	/* XXX should check return code first... */
 	rs->sc_flags |= RAIDF_INITED;
 
-	/* XXX doesn't check bounds.*/
+	/* XXX doesn't check bounds. */
 	sprintf(rs->sc_xname, "raid%d", unit);
 
-	rs->sc_dkdev.dk_name = rs->sc_xname;	
+	rs->sc_dkdev.dk_name = rs->sc_xname;
 
 	/*
 	 * disk_attach actually creates space for the CPU disklabel, among
-	 * other things, so it's critical to call this *BEFORE* we
-	 * try putzing with disklabels.
+	 * other things, so it's critical to call this *BEFORE* we try
+	 * putzing with disklabels.
 	 */
 	disk_attach(&rs->sc_dkdev);
 
@@ -1699,18 +1682,17 @@ raidinit(raidPtr)
 }
 
 /*
- * Wake up the daemon & tell it to get us a spare table
+ * Wake up the daemon & tell it to get us a spare table.
  * XXX
- * The entries in the queues should be tagged with the raidPtr so that in the
- * extremely rare case that two recons happen at once, we know for
- * which device were requesting a spare table.
+ * The entries in the queues should be tagged with the raidPtr so that
+ * in the extremely rare case that two recons happen at once, we know
+ * which devices were requesting a spare table.
  * XXX
- * 
+ *
  * XXX This code is not currently used. GO
  */
 int
-rf_GetSpareTableFromDaemon(req)
-	RF_SparetWait_t	 *req;
+rf_GetSpareTableFromDaemon(RF_SparetWait_t *req)
 {
 	int retcode;
 
@@ -1719,39 +1701,38 @@ rf_GetSpareTableFromDaemon(req)
 	rf_sparet_wait_queue = req;
 	wakeup(&rf_sparet_wait_queue);
 
-	/* mpsleep unlocks the mutex */
+	/* mpsleep unlocks the mutex. */
 	while (!rf_sparet_resp_queue) {
 		tsleep(&rf_sparet_resp_queue, PRIBIO,
-		       "raidframe getsparetable", 0);
+		    "RAIDframe getsparetable", 0);
 	}
 	req = rf_sparet_resp_queue;
 	rf_sparet_resp_queue = req->next;
 	RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
 
 	retcode = req->fcol;
-	/* this is not the same req as we alloc'd */
+	/* This is not the same req as we alloc'd. */
 	RF_Free(req, sizeof *req);
 	return (retcode);
 }
 
 /*
  * A wrapper around rf_DoAccess that extracts appropriate info from the
- * bp & passes it down.
- * Any calls originating in the kernel must use non-blocking I/O
- * do some extra sanity checking to return "appropriate" error values for
- * certain conditions (to make some standard utilities work)
- * 
+ * bp and passes it down.
+ * Any calls originating in the kernel must use non-blocking I/O.
+ * Do some extra sanity checking to return "appropriate" error values for
+ * certain conditions (to make some standard utilities work).
+ *
  * Formerly known as: rf_DoAccessKernel
  */
 void
-raidstart(raidPtr)
-	RF_Raid_t *raidPtr;
+raidstart(RF_Raid_t *raidPtr)
 {
 	RF_SectorCount_t num_blocks, pb, sum;
 	RF_RaidAddr_t raid_addr;
 	int retcode;
 	struct partition *pp;
-	daddr_t blocknum;	
+	daddr_t blocknum;
 	int unit;
 	struct raid_softc *rs;
 	int	do_async;
@@ -1760,10 +1741,10 @@ raidstart(raidPtr)
 	unit = raidPtr->raidid;
 	rs = &raid_softc[unit];
 
-	/* quick check to see if anything has died recently */
+	/* Quick check to see if anything has died recently. */
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	if (raidPtr->numNewFailures > 0) {
-		rf_update_component_labels(raidPtr, 
+		rf_update_component_labels(raidPtr,
 					   RF_NORMAL_COMPONENT_UPDATE);
 		raidPtr->numNewFailures--;
 	}
@@ -1773,41 +1754,45 @@ raidstart(raidPtr)
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	while (raidPtr->openings > 0) {
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
-  
+
 		bp = rs->sc_q.b_actf;
 		if (bp == NULL) {
-			/* nothing more to do */
+			/* Nothing more to do. */
 			return;
 		}
 		rs->sc_q.b_actf = bp->b_actf;
 
-		/* Ok, for the bp we have here, bp->b_blkno is relative to the
-		 * partition.. Need to make it absolute to the underlying 
-		 * device.. */
-  
+		/*
+		 * Ok, for the bp we have here, bp->b_blkno is relative to the
+		 * partition... We need to make it absolute to the underlying
+		 * device...
+		 */
+
 		blocknum = bp->b_blkno;
 		if (DISKPART(bp->b_dev) != RAW_PART) {
 			pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
 			blocknum += pp->p_offset;
 		}
-  
-		db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno, 
+
+		db1_printf(("Blocks: %d, %d\n", (int) bp->b_blkno,
 			    (int) blocknum));
-		
+
 		db1_printf(("bp->b_bcount = %d\n", (int) bp->b_bcount));
 		db1_printf(("bp->b_resid = %d\n", (int) bp->b_resid));
-		
-		/* *THIS* is where we adjust what block we're going to... 
-		 * but DO NOT TOUCH bp->b_blkno!!! */
+
+		/*
+		 * *THIS* is where we adjust what block we're going to...
+		 * But DO NOT TOUCH bp->b_blkno !!!
+		 */
 		raid_addr = blocknum;
-		
+
 		num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
 		pb = (bp->b_bcount & raidPtr->sectorMask) ? 1 : 0;
 		sum = raid_addr + num_blocks + pb;
 		if (1 || rf_debugKernelAccess) {
-			db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n",
-				    (int) raid_addr, (int) sum, (int) num_blocks,
-				    (int) pb, (int) bp->b_resid));
+			db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d)"
+			    " (%d)\n", (int)raid_addr, (int)sum,
+			    (int)num_blocks, (int)pb, (int)bp->b_resid));
 		}
 		if ((sum > raidPtr->totalSectors) || (sum < raid_addr)
 		    || (sum < num_blocks) || (sum < pb)) {
@@ -1815,31 +1800,31 @@ raidstart(raidPtr)
 			bp->b_flags |= B_ERROR;
 			bp->b_resid = bp->b_bcount;
 			/* db1_printf(("%s: Calling biodone on 0x%x\n",
-				    __func__, bp)); */
+			    __func__, bp)); */
 			splassert(IPL_BIO);
 			biodone(bp);
 			RF_LOCK_MUTEX(raidPtr->mutex);
 			continue;
 		}
 		/*
-		 * XXX rf_DoAccess() should do this, not just DoAccessKernel()
+		 * XXX rf_DoAccess() should do this, not just DoAccessKernel().
 		 */
-		
+
 		if (bp->b_bcount & raidPtr->sectorMask) {
 			bp->b_error = EINVAL;
 			bp->b_flags |= B_ERROR;
 			bp->b_resid = bp->b_bcount;
 			/* db1_printf(("%s: Calling biodone on 0x%x\n",
-				    __func__, bp)); */
+			    __func__, bp)); */
 			splassert(IPL_BIO);
 			biodone(bp);
 			RF_LOCK_MUTEX(raidPtr->mutex);
 			continue;
-			
+
 		}
 		db1_printf(("Calling DoAccess..\n"));
-		
-  
+
+
 		RF_LOCK_MUTEX(raidPtr->mutex);
 		raidPtr->openings--;
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
@@ -1848,19 +1833,23 @@ raidstart(raidPtr)
 		 * Everything is async.
 		 */
 		do_async = 1;
-		
+
 		disk_busy(&rs->sc_dkdev);
-		
-		/* XXX we're still at splbio() here... do we *really* 
-		 * need to be? */
 
-		/* don't ever condition on bp->b_flags & B_WRITE.  
-		 * always condition on B_READ instead */
+		/*
+		 * XXX we're still at splbio() here...  Do we *really*
+		 * need to be ?
+		 */
+
+		/*
+		 * Don't ever condition on bp->b_flags & B_WRITE.
+		 * Always condition on B_READ instead.
+		 */
 
 		retcode = rf_DoAccess(raidPtr, (bp->b_flags & B_READ) ?
 				      RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
 				      do_async, raid_addr, num_blocks,
-				      bp->b_data, bp, NULL, NULL, 
+				      bp->b_data, bp, NULL, NULL,
 				      RF_DAG_NONBLOCKING_IO, NULL, NULL, NULL);
 
 		RF_LOCK_MUTEX(raidPtr->mutex);
@@ -1868,29 +1857,24 @@ raidstart(raidPtr)
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
 }
 
-/* Invoke an I/O from kernel mode.  Disk queue should be locked upon entry */
+/* Invoke an I/O from kernel mode.  Disk queue should be locked upon entry. */
 
 int
-rf_DispatchKernelIO(queue, req)
-	RF_DiskQueue_t *queue;
-	RF_DiskQueueData_t *req;
+rf_DispatchKernelIO(RF_DiskQueue_t *queue, RF_DiskQueueData_t *req)
 {
 	int op = (req->type == RF_IO_TYPE_READ) ? B_READ : B_WRITE;
 	struct buf *bp;
 	struct raidbuf *raidbp = NULL;
 	struct raid_softc *rs;
 	int unit;
-	int s;
-  
-	s=0;
-	/* s = splbio();*/ /* want to test this */
-	
+	/*int s = splbio();*/	/* Want to test this. */
+
 	/*
 	 * XXX along with the vnode, we also need the softc associated with
-	 * this device..
+	 * this device...
 	 */
 	req->queue = queue;
-	
+
 	unit = queue->raidPtr->raidid;
 
 	db1_printf(("DispatchKernelIO unit: %d\n", unit));
@@ -1907,10 +1891,10 @@ rf_DispatchKernelIO(queue, req)
 #if 1
 	/*
 	 * XXX When there is a physical disk failure, someone is passing
-	 * us a buffer that contains old stuff!!  Attempt to deal with
+	 * us a buffer that contains old stuff !!  Attempt to deal with
 	 * this problem without taking a performance hit...
-	 * (not sure where the real bug is.  It's buried in RAIDframe
-	 * somewhere) :-(  GO )
+	 * (not sure where the real bug is; it's buried in RAIDframe
+	 * somewhere) :-( GO )
 	 */
 	if (bp->b_flags & B_ERROR) {
 		bp->b_flags &= ~B_ERROR;
@@ -1922,10 +1906,10 @@ rf_DispatchKernelIO(queue, req)
 
 	raidbp = RAIDGETBUF(rs);
 
-	raidbp->rf_flags = 0; /* XXX not really used anywhere... */
+	raidbp->rf_flags = 0;	/* XXX not really used anywhere... */
 
 	/*
-	 * context for raidiodone
+	 * Context for raidiodone.
 	 */
 	raidbp->rf_obp = bp;
 	raidbp->req = req;
@@ -1939,7 +1923,7 @@ rf_DispatchKernelIO(queue, req)
 		db1_printf(("rf_DispatchKernelIO: NOP to r %d c %d\n",
 		    queue->row, queue->col));
 
-		/* XXX need to do something extra here.. */
+		/* XXX need to do something extra here... */
 
 		/*
 		 * I'm leaving this in, as I've never actually seen it
@@ -1948,11 +1932,11 @@ rf_DispatchKernelIO(queue, req)
 		db1_printf(("WAKEUP CALLED\n"));
 		queue->numOutstanding++;
 
-		/* XXX need to glue the original buffer into this??  */
+		/* XXX need to glue the original buffer into this ?? */
 
 		rf_KernelWakeupFunc(&raidbp->rf_buf);
 		break;
-		
+
 	case RF_IO_TYPE_READ:
 	case RF_IO_TYPE_WRITE:
 		if (req->tracerec) {
@@ -1962,7 +1946,7 @@ rf_DispatchKernelIO(queue, req)
 		rf_InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp,
 		    op | bp->b_flags, queue->rf_cinfo->ci_dev,
 		    req->sectorOffset, req->numSector,
-		    req->buf, rf_KernelWakeupFunc, (void *)req,	
+		    req->buf, rf_KernelWakeupFunc, (void *)req,
 		    queue->raidPtr->logBytesPerSector, req->b_proc);
 
 		if (rf_debugKernelAccess) {
@@ -1990,12 +1974,12 @@ rf_DispatchKernelIO(queue, req)
 
 		VOP_STRATEGY(&raidbp->rf_buf);
 		break;
-		
+
 	default:
 		panic("bad req->type in rf_DispatchKernelIO");
 	}
 	db1_printf(("Exiting from DispatchKernelIO\n"));
-	/* splx(s); */ /* want to test this */
+	/*splx(s);*/	/* want to test this */
 	return (0);
 }
 
@@ -2004,8 +1988,7 @@ rf_DispatchKernelIO(queue, req)
  * kernel code.
  */
 void
-rf_KernelWakeupFunc(vbp)
-	struct buf *vbp;
+rf_KernelWakeupFunc(struct buf *vbp)
 {
 	RF_DiskQueueData_t *req = NULL;
 	RF_DiskQueue_t *queue;
@@ -2046,12 +2029,12 @@ rf_KernelWakeupFunc(vbp)
 		RF_UNLOCK_MUTEX(rf_tracing_mutex);
 	}
 
-	bp->b_bcount = raidbp->rf_buf.b_bcount;/* XXXX ?? */
+	bp->b_bcount = raidbp->rf_buf.b_bcount;	/* XXXX ?? */
 
-	unit = queue->raidPtr->raidid; /* *Much* simpler :-> */
+	unit = queue->raidPtr->raidid;	/* *Much* simpler :-> */
 
 	/*
-	 * XXX Ok, let's get aggressive... If B_ERROR is set, let's go
+	 * XXX Ok, let's get aggressive...  If B_ERROR is set, let's go
 	 * ballistic, and mark the component as hosed...
 	 */
 	if (bp->b_flags & B_ERROR) {
@@ -2086,29 +2069,29 @@ rf_KernelWakeupFunc(vbp)
  * Initialize a buf structure for doing an I/O in the kernel.
  */
 void
-rf_InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg,
-    logBytesPerSector, b_proc)
-	struct buf *bp;
-	struct vnode *b_vp;
-	unsigned rw_flag;
-	dev_t dev;
-	RF_SectorNum_t startSect;
-	RF_SectorCount_t numSect;
-	caddr_t buf;
-	void (*cbFunc)(struct buf *);
-	void *cbArg;
-	int logBytesPerSector;
-	struct proc *b_proc;
+rf_InitBP(
+	struct buf	 *bp,
+	struct vnode	 *b_vp,
+	unsigned	  rw_flag,
+	dev_t		  dev,
+	RF_SectorNum_t	  startSect,
+	RF_SectorCount_t  numSect,
+	caddr_t		  buf,
+	void		(*cbFunc)(struct buf *),
+	void		 *cbArg,
+	int		  logBytesPerSector,
+	struct proc	 *b_proc
+)
 {
-	/* bp->b_flags = B_PHYS | rw_flag; */
-	bp->b_flags = B_CALL | rw_flag; /* XXX need B_PHYS here too??? */
+	/*bp->b_flags = B_PHYS | rw_flag;*/
+	bp->b_flags = B_CALL | rw_flag;	/* XXX need B_PHYS here too ??? */
 	bp->b_bcount = numSect << logBytesPerSector;
 	bp->b_bufsize = bp->b_bcount;
 	bp->b_error = 0;
 	bp->b_dev = dev;
 	bp->b_data = buf;
 	bp->b_blkno = startSect;
-	bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */
+	bp->b_resid = bp->b_bcount;	/* XXX is this right !??!?!! */
 	if (bp->b_bcount == 0) {
 		panic("bp->b_bcount is zero in rf_InitBP!!");
 	}
@@ -2119,21 +2102,19 @@ rf_InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg,
 }
 
 void
-raidgetdefaultlabel(raidPtr, rs, lp)
-	RF_Raid_t *raidPtr;
-	struct raid_softc *rs;
-	struct disklabel *lp;
+raidgetdefaultlabel(RF_Raid_t *raidPtr, struct raid_softc *rs,
+    struct disklabel *lp)
 {
 	db1_printf(("Building a default label...\n"));
 	bzero(lp, sizeof(*lp));
 
-	/* fabricate a label... */
+	/* Fabricate a label... */
 	lp->d_secperunit = raidPtr->totalSectors;
 	lp->d_secsize = raidPtr->bytesPerSector;
 	lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe;
 	lp->d_ntracks = 4 * raidPtr->numCol;
-	lp->d_ncylinders = raidPtr->totalSectors / 
-		(lp->d_nsectors * lp->d_ntracks);
+	lp->d_ncylinders = raidPtr->totalSectors /
+	    (lp->d_nsectors * lp->d_ntracks);
 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
 
 	strncpy(lp->d_typename, "raid", sizeof(lp->d_typename));
@@ -2154,12 +2135,11 @@ raidgetdefaultlabel(raidPtr, rs, lp)
 }
 
 /*
- * Read the disklabel from the raid device.  If one is not present, fake one
- * up.
+ * Read the disklabel from the raid device.
+ * If one is not present, fake one up.
  */
 void
-raidgetdisklabel(dev)
-	dev_t dev;
+raidgetdisklabel(dev_t dev)
 {
 	int unit = raidunit(dev);
 	struct raid_softc *rs = &raid_softc[unit];
@@ -2186,7 +2166,7 @@ raidgetdisklabel(dev)
 	if (errstring) {
 		printf("%s: %s\n", rs->sc_xname, errstring);
 		return;
-		/*raidmakedisklabel(rs); */
+		/*raidmakedisklabel(rs);*/
 	}
 
 	/*
@@ -2218,8 +2198,7 @@ raidgetdisklabel(dev)
  * that a disklabel isn't present.
  */
 void
-raidmakedisklabel(rs)
-	struct raid_softc *rs;
+raidmakedisklabel(struct raid_softc *rs)
 {
 	struct disklabel *lp = rs->sc_dkdev.dk_label;
 	db1_printf(("Making a label..\n"));
@@ -2243,10 +2222,11 @@ raidmakedisklabel(rs)
  * You'll find the original of this in ccd.c
  */
 int
-raidlookup(path, p, vpp)
-	char *path;
-	struct proc *p;
-	struct vnode **vpp;	/* result */
+raidlookup(
+	char		 *path,
+	struct proc	 *p,
+	struct vnode	**vpp	/* result */
+)
 {
 	struct nameidata nd;
 	struct vnode *vp;
@@ -2290,8 +2270,7 @@ raidlookup(path, p, vpp)
  * (Hmm... where have we seen this warning before :->  GO )
  */
 int
-raidlock(rs)
-	struct raid_softc *rs;
+raidlock(struct raid_softc *rs)
 {
 	int error;
 
@@ -2308,8 +2287,7 @@ raidlock(rs)
  * Unlock and wake up any waiters.
  */
 void
-raidunlock(rs)
-	struct raid_softc *rs;
+raidunlock(struct raid_softc *rs)
 {
 	rs->sc_flags &= ~RAIDF_LOCKED;
 	if ((rs->sc_flags & RAIDF_WANTED) != 0) {
@@ -2317,12 +2295,12 @@ raidunlock(rs)
 		wakeup(rs);
 	}
 }
- 
 
-#define RF_COMPONENT_INFO_OFFSET  16384 /* bytes */
-#define RF_COMPONENT_INFO_SIZE     1024 /* bytes */
 
-int 
+#define	RF_COMPONENT_INFO_OFFSET	16384	/* bytes */
+#define	RF_COMPONENT_INFO_SIZE		 1024	/* bytes */
+
+int
 raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter)
 {
 	RF_ComponentLabel_t clabel;
@@ -2334,7 +2312,7 @@ raidmarkclean(dev_t dev, struct vnode *b_vp, int mod_counter)
 }
 
 
-int 
+int
 raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter)
 {
 	RF_ComponentLabel_t clabel;
@@ -2347,28 +2325,30 @@ raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter)
 
 /* ARGSUSED */
 int
-raidread_component_label(dev, b_vp, clabel)
-	dev_t dev;
-	struct vnode *b_vp;
-	RF_ComponentLabel_t *clabel;
+raidread_component_label(dev_t dev, struct vnode *b_vp,
+    RF_ComponentLabel_t *clabel)
 {
 	struct buf *bp;
 	int error;
-	
-	/* XXX should probably ensure that we don't try to do this if
-	   someone has changed rf_protected_sectors. */ 
+
+	/*
+	 * XXX should probably ensure that we don't try to do this if
+	 * someone has changed rf_protected_sectors.
+	 */
 
 	if (b_vp == NULL) {
-		/* For whatever reason, this component is not valid.
-		   Don't try to read a component label from it. */
+		/*
+		 * For whatever reason, this component is not valid.
+		 * Don't try to read a component label from it.
+		 */
 		return(EINVAL);
 	}
 
-	/* get a block of the appropriate size... */
+	/* Get a block of the appropriate size... */
 	bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
 	bp->b_dev = dev;
 
-	/* get our ducks in a row for the read */
+	/* Get our ducks in a row for the read. */
 	bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
 	bp->b_bcount = RF_COMPONENT_INFO_SIZE;
 	bp->b_flags |= B_READ;
@@ -2376,37 +2356,34 @@ raidread_component_label(dev, b_vp, clabel)
 
 	(*bdevsw[major(bp->b_dev)].d_strategy)(bp);
 
-	error = biowait(bp); 
+	error = biowait(bp);
 
 	if (!error) {
-		memcpy(clabel, bp->b_data,
-		       sizeof(RF_ComponentLabel_t));
+		memcpy(clabel, bp->b_data, sizeof(RF_ComponentLabel_t));
 #if 0
 		rf_print_component_label( clabel );
 #endif
-        } else {
+	} else {
 		db1_printf(("Failed to read RAID component label!\n"));
 	}
 
-	brelse(bp); 
+	brelse(bp);
 	return(error);
 }
 
 /* ARGSUSED */
-int 
-raidwrite_component_label(dev, b_vp, clabel)
-	dev_t dev; 
-	struct vnode *b_vp;
-	RF_ComponentLabel_t *clabel;
+int
+raidwrite_component_label(dev_t dev, struct vnode *b_vp,
+    RF_ComponentLabel_t *clabel)
 {
 	struct buf *bp;
 	int error;
 
-	/* get a block of the appropriate size... */
+	/* Get a block of the appropriate size... */
 	bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
 	bp->b_dev = dev;
 
-	/* get our ducks in a row for the write */
+	/* Get our ducks in a row for the write. */
 	bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
 	bp->b_bcount = RF_COMPONENT_INFO_SIZE;
 	bp->b_flags |= B_WRITE;
@@ -2417,7 +2394,7 @@ raidwrite_component_label(dev, b_vp, clabel)
 	memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t));
 
 	(*bdevsw[major(bp->b_dev)].d_strategy)(bp);
-	error = biowait(bp); 
+	error = biowait(bp);
 	brelse(bp);
 	if (error) {
 		printf("Failed to write RAID component info!\n");
@@ -2426,9 +2403,8 @@ raidwrite_component_label(dev, b_vp, clabel)
 	return(error);
 }
 
-void 
-rf_markalldirty(raidPtr)
-	RF_Raid_t *raidPtr;
+void
+rf_markalldirty(RF_Raid_t *raidPtr)
 {
 	RF_ComponentLabel_t clabel;
 	int r,c;
@@ -2436,57 +2412,56 @@ rf_markalldirty(raidPtr)
 	raidPtr->mod_counter++;
 	for (r = 0; r < raidPtr->numRow; r++) {
 		for (c = 0; c < raidPtr->numCol; c++) {
-			/* we don't want to touch (at all) a disk that has
-			   failed */
+			/*
+			 * We don't want to touch (at all) a disk that has
+			 * failed.
+			 */
 			if (!RF_DEAD_DISK(raidPtr->Disks[r][c].status)) {
 				raidread_component_label(
-					raidPtr->Disks[r][c].dev,
-					raidPtr->raid_cinfo[r][c].ci_vp,
-					&clabel);
+				    raidPtr->Disks[r][c].dev,
+				    raidPtr->raid_cinfo[r][c].ci_vp, &clabel);
 				if (clabel.status == rf_ds_spared) {
-					/* XXX do something special... 
-					 but whatever you do, don't 
-					 try to access it!! */
+					/*
+					 * XXX do something special...
+					 * But whatever you do, don't
+					 * try to access it !!!
+					 */
 				} else {
 #if 0
-				clabel.status = 
-					raidPtr->Disks[r][c].status;
-				raidwrite_component_label( 
-					raidPtr->Disks[r][c].dev,
-					raidPtr->raid_cinfo[r][c].ci_vp,
-					&clabel);
+					clabel.status =
+					    raidPtr->Disks[r][c].status;
+					raidwrite_component_label(
+					    raidPtr->Disks[r][c].dev,
+					    raidPtr->raid_cinfo[r][c].ci_vp,
+					    &clabel);
 #endif
-				raidmarkdirty( 
-				       raidPtr->Disks[r][c].dev, 
-				       raidPtr->raid_cinfo[r][c].ci_vp,
-				       raidPtr->mod_counter);
+					raidmarkdirty(
+					    raidPtr->Disks[r][c].dev,
+					    raidPtr->raid_cinfo[r][c].ci_vp,
+					    raidPtr->mod_counter);
 				}
 			}
-		} 
+		}
 	}
-	/* printf("Component labels marked dirty.\n"); */
+	/*printf("Component labels marked dirty.\n");*/
 #if 0
 	for( c = 0; c < raidPtr->numSpare ; c++) {
 		sparecol = raidPtr->numCol + c;
 		if (raidPtr->Disks[r][sparecol].status == rf_ds_used_spare) {
-			/* 
-
-			   XXX this is where we get fancy and map this spare
-			   into it's correct spot in the array.
-
+			/*
+			 * XXX This is where we get fancy and map this spare
+			 * into it's correct spot in the array.
 			 */
-			/* 
-			   
-			   we claim this disk is "optimal" if it's 
-			   rf_ds_used_spare, as that means it should be 
-			   directly substitutable for the disk it replaced. 
-			   We note that too...
-
+			/*
+			 * We claim this disk is "optimal" if it's
+			 * rf_ds_used_spare, as that means it should be
+			 * directly substitutable for the disk it replaced.
+			 * We note that too...
 			 */
 
 			for(i=0;i<raidPtr->numRow;i++) {
 				for(j=0;j<raidPtr->numCol;j++) {
-					if ((raidPtr->Disks[i][j].spareRow == 
+					if ((raidPtr->Disks[i][j].spareRow ==
 					     r) &&
 					    (raidPtr->Disks[i][j].spareCol ==
 					     sparecol)) {
@@ -2496,27 +2471,25 @@ rf_markalldirty(raidPtr)
 					}
 				}
 			}
-			
-			raidread_component_label( 
-				      raidPtr->Disks[r][sparecol].dev,
-				      raidPtr->raid_cinfo[r][sparecol].ci_vp,
-				      &clabel);
-			/* make sure status is noted */
-			clabel.version = RF_COMPONENT_LABEL_VERSION; 
+
+			raidread_component_label(
+			    raidPtr->Disks[r][sparecol].dev,
+			    raidPtr->raid_cinfo[r][sparecol].ci_vp, &clabel);
+			/* Make sure status is noted. */
+			clabel.version = RF_COMPONENT_LABEL_VERSION;
 			clabel.mod_counter = raidPtr->mod_counter;
 			clabel.serial_number = raidPtr->serial_number;
 			clabel.row = srow;
 			clabel.column = scol;
 			clabel.num_rows = raidPtr->numRow;
 			clabel.num_columns = raidPtr->numCol;
-			clabel.clean = RF_RAID_DIRTY; /* changed in a bit*/
+			clabel.clean = RF_RAID_DIRTY;	/* Changed in a bit. */
 			clabel.status = rf_ds_optimal;
 			raidwrite_component_label(
-				      raidPtr->Disks[r][sparecol].dev,
-				      raidPtr->raid_cinfo[r][sparecol].ci_vp,
-				      &clabel);
-			raidmarkclean( raidPtr->Disks[r][sparecol].dev, 
-			              raidPtr->raid_cinfo[r][sparecol].ci_vp);
+			    raidPtr->Disks[r][sparecol].dev,
+			    raidPtr->raid_cinfo[r][sparecol].ci_vp, &clabel);
+			raidmarkclean( raidPtr->Disks[r][sparecol].dev,
+			    raidPtr->raid_cinfo[r][sparecol].ci_vp);
 		}
 	}
 
@@ -2525,9 +2498,7 @@ rf_markalldirty(raidPtr)
 
 
 void
-rf_update_component_labels(raidPtr, final)
-	RF_Raid_t *raidPtr;
-	int final;
+rf_update_component_labels(RF_Raid_t *raidPtr, int final)
 {
 	RF_ComponentLabel_t clabel;
 	int sparecol;
@@ -2538,8 +2509,10 @@ rf_update_component_labels(raidPtr, final)
 	srow = -1;
 	scol = -1;
 
-	/* XXX should do extra checks to make sure things really are clean, 
-	   rather than blindly setting the clean bit... */
+	/*
+	 * XXX should do extra checks to make sure things really are clean,
+	 * rather than blindly setting the clean bit...
+	 */
 
 	raidPtr->mod_counter++;
 
@@ -2550,43 +2523,43 @@ rf_update_component_labels(raidPtr, final)
 					raidPtr->Disks[r][c].dev,
 					raidPtr->raid_cinfo[r][c].ci_vp,
 					&clabel);
-				/* make sure status is noted */
+				/* Make sure status is noted. */
 				clabel.status = rf_ds_optimal;
-				/* bump the counter */
+				/* Bump the counter. */
 				clabel.mod_counter = raidPtr->mod_counter;
 
-				raidwrite_component_label( 
+				raidwrite_component_label(
 					raidPtr->Disks[r][c].dev,
 					raidPtr->raid_cinfo[r][c].ci_vp,
 					&clabel);
 				if (final == RF_FINAL_COMPONENT_UPDATE) {
-					if (raidPtr->parity_good == RF_RAID_CLEAN) {
-						raidmarkclean( 
-							      raidPtr->Disks[r][c].dev, 
-							      raidPtr->raid_cinfo[r][c].ci_vp,
-							      raidPtr->mod_counter);
+					if (raidPtr->parity_good ==
+					    RF_RAID_CLEAN) {
+						raidmarkclean(
+						    raidPtr->Disks[r][c].dev,
+						    raidPtr->
+						    raid_cinfo[r][c].ci_vp,
+						    raidPtr->mod_counter);
 					}
 				}
-			} 
-			/* else we don't touch it.. */
-		} 
+			}
+			/* Else we don't touch it... */
+		}
 	}
 
 	for( c = 0; c < raidPtr->numSpare ; c++) {
 		sparecol = raidPtr->numCol + c;
 		if (raidPtr->Disks[0][sparecol].status == rf_ds_used_spare) {
-			/* 
-			   
-			   we claim this disk is "optimal" if it's 
-			   rf_ds_used_spare, as that means it should be 
-			   directly substitutable for the disk it replaced. 
-			   We note that too...
-
+			/*
+			 * We claim this disk is "optimal" if it's
+			 * rf_ds_used_spare, as that means it should be
+			 * directly substitutable for the disk it replaced.
+			 * We note that too...
 			 */
 
 			for(i=0;i<raidPtr->numRow;i++) {
 				for(j=0;j<raidPtr->numCol;j++) {
-					if ((raidPtr->Disks[i][j].spareRow == 
+					if ((raidPtr->Disks[i][j].spareRow ==
 					     0) &&
 					    (raidPtr->Disks[i][j].spareCol ==
 					     sparecol)) {
@@ -2596,13 +2569,12 @@ rf_update_component_labels(raidPtr, final)
 					}
 				}
 			}
-			
-			/* XXX shouldn't *really* need this... */
-			raidread_component_label( 
-				      raidPtr->Disks[0][sparecol].dev,
-				      raidPtr->raid_cinfo[0][sparecol].ci_vp,
-				      &clabel);
-			/* make sure status is noted */
+
+			/* XXX Shouldn't *really* need this... */
+			raidread_component_label(
+			    raidPtr->Disks[0][sparecol].dev,
+			    raidPtr->raid_cinfo[0][sparecol].ci_vp, &clabel);
+			/* Make sure status is noted. */
 
 			raid_init_component_label(raidPtr, &clabel);
 
@@ -2612,26 +2584,24 @@ rf_update_component_labels(raidPtr, final)
 			clabel.status = rf_ds_optimal;
 
 			raidwrite_component_label(
-				      raidPtr->Disks[0][sparecol].dev,
-				      raidPtr->raid_cinfo[0][sparecol].ci_vp,
-				      &clabel);
+			    raidPtr->Disks[0][sparecol].dev,
+			    raidPtr->raid_cinfo[0][sparecol].ci_vp, &clabel);
 			if (final == RF_FINAL_COMPONENT_UPDATE) {
 				if (raidPtr->parity_good == RF_RAID_CLEAN) {
-					raidmarkclean( raidPtr->Disks[0][sparecol].dev,
-						       raidPtr->raid_cinfo[0][sparecol].ci_vp,
-						       raidPtr->mod_counter);
+					raidmarkclean(raidPtr->
+					    Disks[0][sparecol].dev,
+					    raidPtr->
+					    raid_cinfo[0][sparecol].ci_vp,
+					    raidPtr->mod_counter);
 				}
 			}
 		}
 	}
-	/* 	printf("Component labels updated\n"); */
+	/*printf("Component labels updated\n");*/
 }
 
 void
-rf_close_component(raidPtr, vp, auto_configured)
-	RF_Raid_t *raidPtr;
-	struct vnode *vp;
-	int auto_configured;
+rf_close_component(RF_Raid_t *raidPtr, struct vnode *vp, int auto_configured)
 {
 	struct proc *p;
 
@@ -2642,8 +2612,8 @@ rf_close_component(raidPtr, vp, auto_configured)
 		if (auto_configured == 1) {
 			VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
 			vrele(vp);
-			
-		} else {				
+
+		} else {
 			VOP_UNLOCK(vp, 0, p);
 			(void) vn_close(vp, FREAD | FWRITE, p->p_ucred, p);
 		}
@@ -2654,15 +2624,14 @@ rf_close_component(raidPtr, vp, auto_configured)
 
 
 void
-rf_UnconfigureVnodes(raidPtr)
-	RF_Raid_t *raidPtr;
+rf_UnconfigureVnodes(RF_Raid_t *raidPtr)
 {
-	int r,c; 
+	int r,c;
 	struct vnode *vp;
 	int acd;
 
 
-	/* We take this opportunity to close the vnodes like we should.. */
+	/* We take this opportunity to close the vnodes like we should... */
 
 	for (r = 0; r < raidPtr->numRow; r++) {
 		for (c = 0; c < raidPtr->numCol; c++) {
@@ -2686,11 +2655,10 @@ rf_UnconfigureVnodes(raidPtr)
 }
 
 
-void 
-rf_ReconThread(req)
-	struct rf_recon_req *req;
+void
+rf_ReconThread(struct rf_recon_req *req)
 {
-	int     s;
+	int s;
 	RF_Raid_t *raidPtr;
 
 	s = splbio();
@@ -2700,19 +2668,18 @@ rf_ReconThread(req)
 	rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col,
 		    ((req->flags & RF_FDFLAGS_RECON) ? 1 : 0));
 
-	/* XXX get rid of this! we don't need it at all.. */
+	/* XXX Get rid of this! we don't need it at all... */
 	RF_Free(req, sizeof(*req));
 
 	raidPtr->recon_in_progress = 0;
 	splx(s);
 
 	/* That's all... */
-	kthread_exit(0);        /* does not return */
+	kthread_exit(0);	/* Does not return. */
 }
 
 void
-rf_RewriteParityThread(raidPtr)
-	RF_Raid_t *raidPtr;
+rf_RewriteParityThread(RF_Raid_t *raidPtr)
 {
 	int retcode;
 	int s;
@@ -2723,27 +2690,28 @@ rf_RewriteParityThread(raidPtr)
 	if (retcode) {
 		printf("raid%d: Error re-writing parity!\n",raidPtr->raidid);
 	} else {
-		/* set the clean bit!  If we shutdown correctly,
-		   the clean bit on each component label will get
-		   set */
+		/*
+		 * Set the clean bit !  If we shutdown correctly,
+		 * the clean bit on each component label will get
+		 * set.
+		 */
 		raidPtr->parity_good = RF_RAID_CLEAN;
 	}
 	raidPtr->parity_rewrite_in_progress = 0;
 	splx(s);
 
-	/* Anyone waiting for us to stop?  If so, inform them... */
+	/* Anyone waiting for us to stop ?  If so, inform them... */
 	if (raidPtr->waitShutdown) {
 		wakeup(&raidPtr->parity_rewrite_in_progress);
 	}
 
 	/* That's all... */
-	kthread_exit(0);        /* does not return */
+	kthread_exit(0);	/* Does not return. */
 }
 
 
 void
-rf_CopybackThread(raidPtr)
-	RF_Raid_t *raidPtr;
+rf_CopybackThread(RF_Raid_t *raidPtr)
 {
 	int s;
 
@@ -2754,18 +2722,17 @@ rf_CopybackThread(raidPtr)
 	splx(s);
 
 	/* That's all... */
-	kthread_exit(0);        /* does not return */
+	kthread_exit(0);	/* Does not return. */
 }
 
 
 void
-rf_ReconstructInPlaceThread(req)
-	struct rf_recon_req *req;
+rf_ReconstructInPlaceThread(struct rf_recon_req *req)
 {
 	int retcode;
 	int s;
 	RF_Raid_t *raidPtr;
-	
+
 	s = splbio();
 	raidPtr = req->raidPtr;
 	raidPtr->recon_in_progress = 1;
@@ -2775,14 +2742,14 @@ rf_ReconstructInPlaceThread(req)
 	splx(s);
 
 	/* That's all... */
-	kthread_exit(0);        /* does not return */
+	kthread_exit(0);	/* Does not return. */
 }
 
 
 RF_AutoConfig_t *
-rf_find_raid_components()
+rf_find_raid_components(void)
 {
-#ifdef RAID_AUTOCONFIG
+#ifdef	RAID_AUTOCONFIG
 	int major;
 	struct vnode *vp;
 	struct disklabel label;
@@ -2793,32 +2760,34 @@ rf_find_raid_components()
 	int good_one;
 	RF_ComponentLabel_t *clabel;
 	RF_AutoConfig_t *ac;
-#endif
+#endif	/* RAID_AUTOCONFIG */
 	RF_AutoConfig_t *ac_list;
 
 
-	/* initialize the AutoConfig list */
+	/* Initialize the AutoConfig list. */
 	ac_list = NULL;
 
-#ifdef RAID_AUTOCONFIG
-	/* we begin by trolling through *all* the devices on the system */
+#ifdef	RAID_AUTOCONFIG
+	/* We begin by trolling through *all* the devices on the system. */
 
-	for (dv = alldevs.tqh_first; dv != NULL;
-	     dv = dv->dv_list.tqe_next) {
+	for (dv = alldevs.tqh_first; dv != NULL; dv = dv->dv_list.tqe_next) {
 
-		/* we are only interested in disks... */
+		/* We are only interested in disks... */
 		if (dv->dv_class != DV_DISK)
 			continue;
 
-		/* we don't care about floppies... */
+		/* We don't care about floppies... */
 		if (!strcmp(dv->dv_cfdata->cf_driver->cd_name,"fd")) {
 			continue;
 		}
-		
-		/* need to find the device_name_to_block_device_major stuff */
+
+		/*
+		 * We need to find the device_name_to_block_device_major
+		 * stuff.
+		 */
 		major = findblkmajor(dv);
 
-		/* get a vnode for the raw partition of this disk */
+		/* Get a vnode for the raw partition of this disk. */
 
 		dev = MAKEDISKDEV(major, dv->dv_unit, RAW_PART);
 		if (bdevvp(dev, &vp))
@@ -2827,34 +2796,40 @@ rf_find_raid_components()
 		error = VOP_OPEN(vp, FREAD, NOCRED, 0);
 
 		if (error) {
-			/* "Who cares."  Continue looking 
-			   for something that exists*/
+			/*
+			 * "Who cares."  Continue looking
+			 * for something that exists.
+			 */
 			vput(vp);
 			continue;
 		}
 
 		/* Ok, the disk exists.  Go get the disklabel. */
-		error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)&label, 
+		error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)&label,
 				  FREAD, NOCRED, 0);
 		if (error) {
 			/*
 			 * XXX can't happen - open() would
-			 * have errored out (or faked up one)
+			 * have errored out (or faked up one).
 			 */
 			printf("can't get label for dev %s%c (%d)!?!?\n",
-			       dv->dv_xname, 'a' + RAW_PART, error);
+			    dv->dv_xname, 'a' + RAW_PART, error);
 		}
 
-		/* don't need this any more.  We'll allocate it again
-		   a little later if we really do... */
+		/*
+		 * We don't need this any more.  We'll allocate it again
+		 * a little later if we really do...
+		 */
 		VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
 		vrele(vp);
 
 		for (i=0; i < label.d_npartitions; i++) {
-			/* We only support partitions marked as RAID.	*/
-			/* Aside on sparc/sparc64 where FS_RAID doesn't	*/
-			/* fit in the SUN disklabel and we need to look	*/
-			/* into each and every partition !!!		*/
+			/*
+			 * We only support partitions marked as RAID.
+			 * Except on sparc/sparc64 where FS_RAID doesn't
+			 * fit in the SUN disklabel and we need to look
+			 * into each and every partition !!!
+			 */
 #if !defined(__sparc__) && !defined(__sparc64__) && !defined(__sun3__)
 			if (label.d_partitions[i].p_fstype != FS_RAID)
 				continue;
@@ -2877,37 +2852,38 @@ rf_find_raid_components()
 
 			good_one = 0;
 
-			clabel = (RF_ComponentLabel_t *) 
-				malloc(sizeof(RF_ComponentLabel_t), 
-				       M_RAIDFRAME, M_NOWAIT);
+			clabel = (RF_ComponentLabel_t *)
+				malloc(sizeof(RF_ComponentLabel_t), M_RAIDFRAME,
+				    M_NOWAIT);
 			if (clabel == NULL) {
-				/* XXX CLEANUP HERE */
+				/* XXX CLEANUP HERE. */
 				printf("RAID auto config: out of memory!\n");
-				return(NULL); /* XXX probably should panic? */
+				return(NULL); /* XXX probably should panic ? */
 			}
 
 			if (!raidread_component_label(dev, vp, clabel)) {
-				/* Got the label.  Does it look reasonable? */
+				/* Got the label.  Does it look reasonable ? */
 				if (rf_reasonable_label(clabel) &&
-				    (clabel->partitionSize <= 
+				    (clabel->partitionSize <=
 				     label.d_partitions[i].p_size)) {
 #ifdef	RAIDDEBUG
-					printf("Component on: %s%c: %d\n", 
-					       dv->dv_xname, 'a'+i,
-					       label.d_partitions[i].p_size);
+					printf("Component on: %s%c: %d\n",
+					    dv->dv_xname, 'a'+i,
+					    label.d_partitions[i].p_size);
 					rf_print_component_label(clabel);
-#endif
-					/* if it's reasonable, add it, 
-					   else ignore it. */
+#endif	/* RAIDDEBUG */
+					/*
+					 * If it's reasonable, add it,
+					 * else ignore it.
+					 */
 					ac = (RF_AutoConfig_t *)
 						malloc(sizeof(RF_AutoConfig_t),
-						       M_RAIDFRAME,
-						       M_NOWAIT);
+						    M_RAIDFRAME, M_NOWAIT);
 					if (ac == NULL) {
-						/* XXX should panic?? */
+						/* XXX should panic ??? */
 						return(NULL);
 					}
-					
+
 					sprintf(ac->devname, "%s%c",
 						dv->dv_xname, 'a'+i);
 					ac->dev = dev;
@@ -2916,75 +2892,68 @@ rf_find_raid_components()
 					ac->next = ac_list;
 					ac_list = ac;
 					good_one = 1;
-				} 
+				}
 			}
 			if (!good_one) {
-				/* cleanup */
+				/* Cleanup. */
 				free(clabel, M_RAIDFRAME);
 				VOP_CLOSE(vp, FREAD | FWRITE, NOCRED, 0);
 				vrele(vp);
 			}
 		}
 	}
-#endif
-return(ac_list);
+#endif	/* RAID_AUTOCONFIG */
+	return(ac_list);
 }
-			
-#ifdef RAID_AUTOCONFIG
+
+#ifdef	RAID_AUTOCONFIG
 int
-rf_reasonable_label(clabel)
-	RF_ComponentLabel_t *clabel;
+rf_reasonable_label(RF_ComponentLabel_t *clabel)
 {
-	
+
 	if (((clabel->version==RF_COMPONENT_LABEL_VERSION_1) ||
 	     (clabel->version==RF_COMPONENT_LABEL_VERSION)) &&
 	    ((clabel->clean == RF_RAID_CLEAN) ||
 	     (clabel->clean == RF_RAID_DIRTY)) &&
-	    clabel->row >=0 && 
-	    clabel->column >= 0 && 
+	    clabel->row >=0 &&
+	    clabel->column >= 0 &&
 	    clabel->num_rows > 0 &&
 	    clabel->num_columns > 0 &&
-	    clabel->row < clabel->num_rows && 
+	    clabel->row < clabel->num_rows &&
 	    clabel->column < clabel->num_columns &&
 	    clabel->blockSize > 0 &&
 	    clabel->numBlocks > 0) {
-		/* label looks reasonable enough... */
+		/* Label looks reasonable enough... */
 		return(1);
 	}
 	return(0);
 }
-#endif
+#endif	/* RAID_AUTOCONFIG */
 
 void
-rf_print_component_label(clabel)
-	RF_ComponentLabel_t *clabel;
+rf_print_component_label(RF_ComponentLabel_t *clabel)
 {
 	printf("   Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
-	       clabel->row, clabel->column, 
-	       clabel->num_rows, clabel->num_columns);
+	    clabel->row, clabel->column, clabel->num_rows, clabel->num_columns);
 	printf("   Version: %d Serial Number: %d Mod Counter: %d\n",
-	       clabel->version, clabel->serial_number,
-	       clabel->mod_counter);
-	printf("   Clean: %s Status: %d\n",
-	       clabel->clean ? "Yes" : "No", clabel->status );
+	    clabel->version, clabel->serial_number, clabel->mod_counter);
+	printf("   Clean: %s Status: %d\n", clabel->clean ? "Yes" : "No",
+	    clabel->status );
 	printf("   sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n",
-	       clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
+	    clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
 	printf("   RAID Level: %c  blocksize: %d numBlocks: %d\n",
-	       (char) clabel->parityConfig, clabel->blockSize, 
-	       clabel->numBlocks);
+	    (char) clabel->parityConfig, clabel->blockSize, clabel->numBlocks);
 	printf("   Autoconfig: %s\n", clabel->autoconfigure ? "Yes" : "No" );
-	printf("   Contains root partition: %s\n",  
-	       clabel->root_partition ? "Yes" : "No" );
+	printf("   Contains root partition: %s\n", clabel->root_partition ?
+	    "Yes" : "No" );
 	printf("   Last configured as: raid%d\n", clabel->last_unit );
 #if 0
 	printf("   Config order: %d\n", clabel->config_order);
 #endif
-	       
 }
 
 RF_ConfigSet_t *
-rf_create_auto_sets(ac_list)
-	RF_AutoConfig_t *ac_list;
+rf_create_auto_sets(RF_AutoConfig_t *ac_list)
 {
 	RF_AutoConfig_t *ac;
 	RF_ConfigSet_t *config_sets;
@@ -2994,33 +2963,37 @@ rf_create_auto_sets(ac_list)
 
 	config_sets = NULL;
 
-	/* Go through the AutoConfig list, and figure out which components
-	   belong to what sets.  */
+	/*
+	 * Go through the AutoConfig list, and figure out which components
+	 * belong to what sets.
+	 */
 	ac = ac_list;
 	while(ac!=NULL) {
-		/* we're going to putz with ac->next, so save it here
-		   for use at the end of the loop */
+		/*
+		 * We're going to putz with ac->next, so save it here
+		 * for use at the end of the loop.
+		 */
 		ac_next = ac->next;
 
 		if (config_sets == NULL) {
-			/* will need at least this one... */
+			/* We will need at least this one... */
 			config_sets = (RF_ConfigSet_t *)
-				malloc(sizeof(RF_ConfigSet_t), 
-				       M_RAIDFRAME, M_NOWAIT);
+				malloc(sizeof(RF_ConfigSet_t), M_RAIDFRAME,
+				    M_NOWAIT);
 			if (config_sets == NULL) {
 				panic("rf_create_auto_sets: No memory!");
 			}
-			/* this one is easy :) */
+			/* This one is easy :) */
 			config_sets->ac = ac;
 			config_sets->next = NULL;
 			config_sets->rootable = 0;
 			ac->next = NULL;
 		} else {
-			/* which set does this component fit into? */
+			/* Which set does this component fit into ? */
 			cset = config_sets;
 			while(cset!=NULL) {
 				if (rf_does_it_fit(cset, ac)) {
-					/* looks like it matches... */
+					/* Looks like it matches... */
 					ac->next = cset->ac;
 					cset->ac = ac;
 					break;
@@ -3028,10 +3001,10 @@ rf_create_auto_sets(ac_list)
 				cset = cset->next;
 			}
 			if (cset==NULL) {
-				/* didn't find a match above... new set..*/
+				/* Didn't find a match above... new set... */
 				cset = (RF_ConfigSet_t *)
-					malloc(sizeof(RF_ConfigSet_t), 
-					       M_RAIDFRAME, M_NOWAIT);
+					malloc(sizeof(RF_ConfigSet_t),
+					    M_RAIDFRAME, M_NOWAIT);
 				if (cset == NULL) {
 					panic("rf_create_auto_sets: No memory!");
 				}
@@ -3050,36 +3023,36 @@ rf_create_auto_sets(ac_list)
 }
 
 int
-rf_does_it_fit(cset, ac)	
-	RF_ConfigSet_t *cset;
-	RF_AutoConfig_t *ac;
+rf_does_it_fit(RF_ConfigSet_t *cset, RF_AutoConfig_t *ac)
 {
 	RF_ComponentLabel_t *clabel1, *clabel2;
 
-	/* If this one matches the *first* one in the set, that's good
-	   enough, since the other members of the set would have been
-	   through here too... */
-	/* note that we are not checking partitionSize here..
-
-	   Note that we are also not checking the mod_counters here.
-	   If everything else matches execpt the mod_counter, that's 
-	   good enough for this test.  We will deal with the mod_counters
-	   a little later in the autoconfiguration process.  
-
-	    (clabel1->mod_counter == clabel2->mod_counter) &&
-
-	   The reason we don't check for this is that failed disks
-	   will have lower modification counts.  If those disks are
-	   not added to the set they used to belong to, then they will
-	   form their own set, which may result in 2 different sets,
-	   for example, competing to be configured at raid0, and
-	   perhaps competing to be the root filesystem set.  If the
-	   wrong ones get configured, or both attempt to become /,
-	   weird behaviour and or serious lossage will occur.  Thus we
-	   need to bring them into the fold here, and kick them out at
-	   a later point.
-
-	*/
+	/*
+	 * If this one matches the *first* one in the set, that's good
+	 * enough, since the other members of the set would have been
+	 * through here too...
+	 */
+	/*
+	 * Note that we are not checking partitionSize here...
+	 *
+	 * Note that we are also not checking the mod_counters here.
+	 * If everything else matches except the mod_counter, that's
+	 * good enough for this test.  We will deal with the mod_counters
+	 * a little later in the autoconfiguration process.
+	 *
+	 *  (clabel1->mod_counter == clabel2->mod_counter) &&
+	 *
+	 * The reason we don't check for this is that failed disks
+	 * will have lower modification counts.  If those disks are
+	 * not added to the set they used to belong to, then they will
+	 * form their own set, which may result in 2 different sets,
+	 * for example, competing to be configured at raid0, and
+	 * perhaps competing to be the root filesystem set.  If the
+	 * wrong ones get configured, or both attempt to become /,
+	 * weird behaviour and or serious lossage will occur.  Thus we
+	 * need to bring them into the fold here, and kick them out at
+	 * a later point.
+	 */
 
 	clabel1 = cset->ac->clabel;
 	clabel2 = ac->clabel;
@@ -3098,19 +3071,17 @@ rf_does_it_fit(cset, ac)
 	    (clabel1->root_partition == clabel2->root_partition) &&
 	    (clabel1->last_unit == clabel2->last_unit) &&
 	    (clabel1->config_order == clabel2->config_order)) {
-		/* if it get's here, it almost *has* to be a match */
+		/* If it get's here, it almost *has* to be a match. */
 	} else {
-		/* it's not consistent with somebody in the set.. 
-		   punt */
+		/* It's not consistent with somebody in the set...  Punt. */
 		return(0);
 	}
-	/* all was fine.. it must fit... */
+	/* All was fine.. It must fit... */
 	return(1);
 }
 
 int
-rf_have_enough_components(cset)
-	RF_ConfigSet_t *cset;
+rf_have_enough_components(RF_ConfigSet_t *cset)
 {
 	RF_AutoConfig_t *ac;
 	RF_AutoConfig_t *auto_config;
@@ -3123,16 +3094,18 @@ rf_have_enough_components(cset)
 	int mod_counter_found;
 	int even_pair_failed;
 	char parity_type;
-	
 
-	/* check to see that we have enough 'live' components
-	   of this set.  If so, we can configure it if necessary */
+
+	/*
+	 * Check to see that we have enough 'live' components
+	 * of this set.  If so, we can configure it if necessary.
+	 */
 
 	num_rows = cset->ac->clabel->num_rows;
 	num_cols = cset->ac->clabel->num_columns;
 	parity_type = cset->ac->clabel->parityConfig;
 
-	/* XXX Check for duplicate components!?!?!? */
+	/* XXX Check for duplicate components !?!?!? */
 
 	/* Determine what the mod_counter is supposed to be for this set. */
 
@@ -3160,44 +3133,50 @@ rf_have_enough_components(cset)
 			ac = auto_config;
 			while(ac!=NULL) {
 				if ((ac->clabel->row == r) &&
-				    (ac->clabel->column == c) && 
+				    (ac->clabel->column == c) &&
 				    (ac->clabel->mod_counter == mod_counter)) {
-					/* it's this one... */
+					/* It's this one... */
 #ifdef	RAIDDEBUG
 					printf("Found: %s at %d,%d\n",
-					       ac->devname,r,c);
-#endif
+					    ac->devname,r,c);
+#endif	/* RAIDDEBUG */
 					break;
 				}
 				ac=ac->next;
 			}
 			if (ac==NULL) {
 				/* Didn't find one here! */
-				/* special case for RAID 1, especially
-				   where there are more than 2
-				   components (where RAIDframe treats
-				   things a little differently :( ) */
+				/*
+				 * Special case for RAID 1, especially
+				 * where there are more than 2
+				 * components (where RAIDframe treats
+				 * things a little differently :( )
+				 */
 				if (parity_type == '1') {
-					if (c%2 == 0) { /* even component */
+					if (c%2 == 0) {	/* Even component. */
 						even_pair_failed = 1;
-					} else { /* odd component.  If
-                                                    we're failed, and
-                                                    so is the even
-                                                    component, it's
-                                                    "Good Night, Charlie" */
+					} else {	/*
+							 * Odd component.
+							 * If we're failed,
+							 * and so is the even
+							 * component, it's
+							 * "Good Night, Charlie"
+							 */
 						if (even_pair_failed == 1) {
 							return(0);
 						}
 					}
 				} else {
-					/* normal accounting */
+					/* Normal accounting. */
 					num_missing++;
 				}
 			}
 			if ((parity_type == '1') && (c%2 == 1)) {
-				/* Just did an even component, and we didn't
-				   bail.. reset the even_pair_failed flag, 
-				   and go on to the next component.... */
+				/*
+				 * Just did an even component, and we didn't
+				 * bail... Reset the even_pair_failed flag,
+				 * and go on to the next component...
+				 */
 				even_pair_failed = 0;
 			}
 		}
@@ -3208,30 +3187,30 @@ rf_have_enough_components(cset)
 	if (((clabel->parityConfig == '0') && (num_missing > 0)) ||
 	    ((clabel->parityConfig == '4') && (num_missing > 1)) ||
 	    ((clabel->parityConfig == '5') && (num_missing > 1))) {
-		/* XXX this needs to be made *much* more general */
-		/* Too many failures */
+		/* XXX This needs to be made *much* more general. */
+		/* Too many failures. */
 		return(0);
 	}
-	/* otherwise, all is well, and we've got enough to take a kick
-	   at autoconfiguring this set */
+	/*
+	 * Otherwise, all is well, and we've got enough to take a kick
+	 * at autoconfiguring this set.
+	 */
 	return(1);
 }
 
 void
-rf_create_configuration(ac,config,raidPtr)
-	RF_AutoConfig_t *ac;
-	RF_Config_t *config;
-	RF_Raid_t *raidPtr;
+rf_create_configuration(RF_AutoConfig_t *ac, RF_Config_t *config,
+    RF_Raid_t *raidPtr)
 {
 	RF_ComponentLabel_t *clabel;
 	int i;
 
 	clabel = ac->clabel;
 
-	/* 1. Fill in the common stuff */
+	/* 1. Fill in the common stuff. */
 	config->numRow = clabel->num_rows;
 	config->numCol = clabel->num_columns;
-	config->numSpare = 0; /* XXX should this be set here? */
+	config->numSpare = 0;	/* XXX Should this be set here ? */
 	config->sectPerSU = clabel->sectPerSU;
 	config->SUsPerPU = clabel->SUsPerPU;
 	config->SUsPerRU = clabel->SUsPerRU;
@@ -3239,13 +3218,15 @@ rf_create_configuration(ac,config,raidPtr)
 	/* XXX... */
 	strcpy(config->diskQueueType,"fifo");
 	config->maxOutstandingDiskReqs = clabel->maxOutstanding;
-	config->layoutSpecificSize = 0; /* XXX ?? */
+	config->layoutSpecificSize = 0;	/* XXX ?? */
 
 	while(ac!=NULL) {
-		/* row/col values will be in range due to the checks
-		   in reasonable_label() */
+		/*
+		 * row/col values will be in range due to the checks
+		 * in reasonable_label().
+		 */
 		strcpy(config->devnames[ac->clabel->row][ac->clabel->column],
-		       ac->devname);
+		    ac->devname);
 		ac = ac->next;
 	}
 
@@ -3253,106 +3234,116 @@ rf_create_configuration(ac,config,raidPtr)
 		config->debugVars[i][0] = NULL;
 	}
 
-#ifdef RAID_DEBUG_ALL
-#ifdef RF_DBG_OPTION
-#undef RF_DBG_OPTION
-#endif
+#ifdef	RAID_DEBUG_ALL
+
+#ifdef	RF_DBG_OPTION
+#undef	RF_DBG_OPTION
+#endif	/* RF_DBG_OPTION */
 
-#ifdef __STDC__
-#define RF_DBG_OPTION(_option_,_val_) \
-	snprintf(&(config->debugVars[i++][0]), 50, \
-		 "%s %ld", #_option_, _val_);
-#else                           /* __STDC__ */
-#define RF_DBG_OPTION(_option_,_val_) \
-	snprintf(&(config->debugVars[i++][0]), 50, \
-		 "%s %ld", "/**/_option_/**/", _val_);
-#endif                          /* __STDC__ */
+#ifdef	__STDC__
+#define	RF_DBG_OPTION(_option_,_val_)	do {				\
+	snprintf(&(config->debugVars[i++][0]), 50, "%s %ld",		\
+	    #_option_, _val_);						\
+} while (0)
+#else	/* __STDC__ */
+#define	RF_DBG_OPTION(_option_,_val_)	do {				\
+	snprintf(&(config->debugVars[i++][0]), 50, "%s %ld",		\
+	    "/**/_option_/**/", _val_);					\
+} while (0)
+#endif	/* __STDC__ */
 
 	i = 0;
 
-/*	RF_DBG_OPTION(accessDebug, 0) */
-/*	RF_DBG_OPTION(accessTraceBufSize, 0) */
-	RF_DBG_OPTION(cscanDebug, 1)	/* debug CSCAN sorting */
-	RF_DBG_OPTION(dagDebug, 1)
-/*	RF_DBG_OPTION(debugPrintUseBuffer, 0) */
-	RF_DBG_OPTION(degDagDebug, 1)
-	RF_DBG_OPTION(disableAsyncAccs, 1)
-	RF_DBG_OPTION(diskDebug, 1)
-	RF_DBG_OPTION(enableAtomicRMW, 0)	/* this debug var enables
-					 	 * locking of the disk arm
-					 	 * during small-write
-					 	 * operations.  Setting this
-					 	 * variable to anything other
-						 * than 0 will result in
-						 * deadlock.  (wvcii) */
-	RF_DBG_OPTION(engineDebug, 1)
-	RF_DBG_OPTION(fifoDebug, 1)	/* debug fifo queueing */
-/*	RF_DBG_OPTION(floatingRbufDebug, 1) */
-/*	RF_DBG_OPTION(forceHeadSepLimit, -1) */
-/*	RF_DBG_OPTION(forceNumFloatingReconBufs, -1) */	/* wire down number of
-						 	 * extra recon buffers
-						 	 * to use */
-/*	RF_DBG_OPTION(keepAccTotals, 1) */	/* turn on keep_acc_totals */
-	RF_DBG_OPTION(lockTableSize, RF_DEFAULT_LOCK_TABLE_SIZE)
-	RF_DBG_OPTION(mapDebug, 1)
-	RF_DBG_OPTION(maxNumTraces, -1)
-
-/*	RF_DBG_OPTION(memChunkDebug, 1) */
-/*	RF_DBG_OPTION(memDebug, 1) */
-/*	RF_DBG_OPTION(memDebugAddress, 1) */
-/*	RF_DBG_OPTION(numBufsToAccumulate, 1) */	/* number of buffers to
-						 	 * accumulate before
-							 * doing XOR */
-	RF_DBG_OPTION(prReconSched, 0)
-	RF_DBG_OPTION(printDAGsDebug, 1)
-	RF_DBG_OPTION(printStatesDebug, 1)
-	RF_DBG_OPTION(protectedSectors, 64L)		/* # of sectors at start
-						 	 * of disk to exclude
-						 	 * from RAID address
-							 * space */
-	RF_DBG_OPTION(pssDebug, 1)
-	RF_DBG_OPTION(queueDebug, 1)
-	RF_DBG_OPTION(quiesceDebug, 1)
-	RF_DBG_OPTION(raidSectorOffset, 0)	/* added to all incoming sectors
-					 	 * to debug alignment problems */
-	RF_DBG_OPTION(reconDebug, 1)
-	RF_DBG_OPTION(reconbufferDebug, 1)
-	RF_DBG_OPTION(scanDebug, 1)	/* debug SCAN sorting */
-	RF_DBG_OPTION(showXorCallCounts, 0)	/* show n-way Xor call counts */
-	RF_DBG_OPTION(shutdownDebug, 1)		/* show shutdown calls */
-	RF_DBG_OPTION(sizePercentage, 100)
-	RF_DBG_OPTION(sstfDebug, 1)	/* turn on debugging info for sstf
-					 * queueing */
-	RF_DBG_OPTION(stripeLockDebug, 1)
-	RF_DBG_OPTION(suppressLocksAndLargeWrites, 0)
-	RF_DBG_OPTION(suppressTraceDelays, 0)
-	RF_DBG_OPTION(useMemChunks, 1)
-	RF_DBG_OPTION(validateDAGDebug, 1)
-	RF_DBG_OPTION(validateVisitedDebug, 1)		/* XXX turn to zero by
-						 	 * default? */
-	RF_DBG_OPTION(verifyParityDebug, 1)
-	RF_DBG_OPTION(debugKernelAccess, 1)	/* DoAccessKernel debugging */
-
-#if 0 /* RF_INCLUDE_PARITYLOGGING > 0 */
-	RF_DBG_OPTION(forceParityLogReint, 0)
-	RF_DBG_OPTION(numParityRegions, 0)	/* number of regions in the
-						 * array */
-	RF_DBG_OPTION(numReintegrationThreads, 1)
-	RF_DBG_OPTION(parityLogDebug, 1)	/* if nonzero, enables debugging
-					 	 * of parity logging */
-	RF_DBG_OPTION(totalInCoreLogCapacity, 1024 * 1024)	/* target bytes
-							 	 * available for
-							 	 * in-core
-								 * logs */
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-#endif /* RAID_DEBUG_ALL */
+/*	RF_DBG_OPTION(accessDebug, 0);					*/
+/*	RF_DBG_OPTION(accessTraceBufSize, 0);				*/
+	RF_DBG_OPTION(cscanDebug, 1);		/* Debug CSCAN sorting.	*/
+	RF_DBG_OPTION(dagDebug, 1);
+/*	RF_DBG_OPTION(debugPrintUseBuffer, 0);				*/
+	RF_DBG_OPTION(degDagDebug, 1);
+	RF_DBG_OPTION(disableAsyncAccs, 1);
+	RF_DBG_OPTION(diskDebug, 1);
+	RF_DBG_OPTION(enableAtomicRMW, 0);
+		/*
+		 * This debug variable enables locking of the
+		 * disk arm during small-write operations.
+		 * Setting this variable to anything other than
+		 * 0 will result in deadlock.  (wvcii)
+		 */
+	RF_DBG_OPTION(engineDebug, 1);
+	RF_DBG_OPTION(fifoDebug, 1);		/* Debug fifo queueing.	*/
+/*	RF_DBG_OPTION(floatingRbufDebug, 1);				*/
+/*	RF_DBG_OPTION(forceHeadSepLimit, -1);				*/
+/*	RF_DBG_OPTION(forceNumFloatingReconBufs, -1);			*/
+		/*
+		 * Wire down the number of extra recon buffers
+		 * to use.
+		 */
+/*	RF_DBG_OPTION(keepAccTotals, 1);				*/
+		/* Turn on keep_acc_totals. */
+	RF_DBG_OPTION(lockTableSize, RF_DEFAULT_LOCK_TABLE_SIZE);
+	RF_DBG_OPTION(mapDebug, 1);
+	RF_DBG_OPTION(maxNumTraces, -1);
+
+/*	RF_DBG_OPTION(memChunkDebug, 1);				*/
+/*	RF_DBG_OPTION(memDebug, 1);					*/
+/*	RF_DBG_OPTION(memDebugAddress, 1);				*/
+/*	RF_DBG_OPTION(numBufsToAccumulate, 1);				*/
+		/*
+		 * Number of buffers to accumulate before
+		 * doing XOR.
+		 */
+	RF_DBG_OPTION(prReconSched, 0);
+	RF_DBG_OPTION(printDAGsDebug, 1);
+	RF_DBG_OPTION(printStatesDebug, 1);
+	RF_DBG_OPTION(protectedSectors, 64L);
+		/*
+		 * Number of sectors at start of disk to exclude
+		 * from RAID address space.
+		 */
+	RF_DBG_OPTION(pssDebug, 1);
+	RF_DBG_OPTION(queueDebug, 1);
+	RF_DBG_OPTION(quiesceDebug, 1);
+	RF_DBG_OPTION(raidSectorOffset, 0);
+		/*
+		 * Value added to all incoming sectors to debug
+		 * alignment problems.
+		 */
+	RF_DBG_OPTION(reconDebug, 1);
+	RF_DBG_OPTION(reconbufferDebug, 1);
+	RF_DBG_OPTION(scanDebug, 1);		/* Debug SCAN sorting.	*/
+	RF_DBG_OPTION(showXorCallCounts, 0);
+		/* Show n-way Xor call counts. */
+	RF_DBG_OPTION(shutdownDebug, 1);	/* Show shutdown calls.	*/
+	RF_DBG_OPTION(sizePercentage, 100);
+	RF_DBG_OPTION(sstfDebug, 1);
+		/* Turn on debugging info for sstf queueing. */
+	RF_DBG_OPTION(stripeLockDebug, 1);
+	RF_DBG_OPTION(suppressLocksAndLargeWrites, 0);
+	RF_DBG_OPTION(suppressTraceDelays, 0);
+	RF_DBG_OPTION(useMemChunks, 1);
+	RF_DBG_OPTION(validateDAGDebug, 1);
+	RF_DBG_OPTION(validateVisitedDebug, 1);
+		/* XXX turn to zero by default ? */
+	RF_DBG_OPTION(verifyParityDebug, 1);
+	RF_DBG_OPTION(debugKernelAccess, 1);
+		/* DoAccessKernel debugging. */
+
+#if RF_INCLUDE_PARITYLOGGING > 0
+	RF_DBG_OPTION(forceParityLogReint, 0);
+	RF_DBG_OPTION(numParityRegions, 0);
+		/* Number of regions in the array. */
+	RF_DBG_OPTION(numReintegrationThreads, 1);
+	RF_DBG_OPTION(parityLogDebug, 1);
+		/* If nonzero, enables debugging of parity logging. */
+	RF_DBG_OPTION(totalInCoreLogCapacity, 1024 * 1024);
+		/* Target bytes available for in-core logs. */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
+
+#endif	/* RAID_DEBUG_ALL */
 }
 
 int
-rf_set_autoconfig(raidPtr, new_value)
-	RF_Raid_t *raidPtr;
-	int new_value;
+rf_set_autoconfig(RF_Raid_t *raidPtr, int new_value)
 {
 	RF_ComponentLabel_t clabel;
 	struct vnode *vp;
@@ -3362,7 +3353,7 @@ rf_set_autoconfig(raidPtr, new_value)
 	raidPtr->autoconfigure = new_value;
 	for(row=0; row<raidPtr->numRow; row++) {
 		for(column=0; column<raidPtr->numCol; column++) {
-			if (raidPtr->Disks[row][column].status == 
+			if (raidPtr->Disks[row][column].status ==
 			    rf_ds_optimal) {
 				dev = raidPtr->Disks[row][column].dev;
 				vp = raidPtr->raid_cinfo[row][column].ci_vp;
@@ -3376,9 +3367,7 @@ rf_set_autoconfig(raidPtr, new_value)
 }
 
 int
-rf_set_rootpartition(raidPtr, new_value)
-	RF_Raid_t *raidPtr;
-	int new_value;
+rf_set_rootpartition(RF_Raid_t *raidPtr, int new_value)
 {
 	RF_ComponentLabel_t clabel;
 	struct vnode *vp;
@@ -3388,7 +3377,7 @@ rf_set_rootpartition(raidPtr, new_value)
 	raidPtr->root_partition = new_value;
 	for(row=0; row<raidPtr->numRow; row++) {
 		for(column=0; column<raidPtr->numCol; column++) {
-			if (raidPtr->Disks[row][column].status == 
+			if (raidPtr->Disks[row][column].status ==
 			    rf_ds_optimal) {
 				dev = raidPtr->Disks[row][column].dev;
 				vp = raidPtr->raid_cinfo[row][column].ci_vp;
@@ -3402,14 +3391,13 @@ rf_set_rootpartition(raidPtr, new_value)
 }
 
 void
-rf_release_all_vps(cset)
-	RF_ConfigSet_t *cset;
+rf_release_all_vps(RF_ConfigSet_t *cset)
 {
 	RF_AutoConfig_t *ac;
-	
+
 	ac = cset->ac;
 	while(ac!=NULL) {
-		/* Close the vp, and give it back */
+		/* Close the vp, and give it back. */
 		if (ac->vp) {
 			VOP_CLOSE(ac->vp, FREAD, NOCRED, 0);
 			vrele(ac->vp);
@@ -3421,41 +3409,38 @@ rf_release_all_vps(cset)
 
 
 void
-rf_cleanup_config_set(cset)
-	RF_ConfigSet_t *cset;
+rf_cleanup_config_set(RF_ConfigSet_t *cset)
 {
 	RF_AutoConfig_t *ac;
 	RF_AutoConfig_t *next_ac;
-	
+
 	ac = cset->ac;
 	while(ac!=NULL) {
 		next_ac = ac->next;
-		/* nuke the label */
+		/* Nuke the label. */
 		free(ac->clabel, M_RAIDFRAME);
-		/* cleanup the config structure */
+		/* Cleanup the config structure. */
 		free(ac, M_RAIDFRAME);
-		/* "next.." */
+		/* "next..." */
 		ac = next_ac;
 	}
-	/* and, finally, nuke the config set */
+	/* And, finally, nuke the config set. */
 	free(cset, M_RAIDFRAME);
 }
 
 
 void
-raid_init_component_label(raidPtr, clabel)
-	RF_Raid_t *raidPtr;
-	RF_ComponentLabel_t *clabel;
+raid_init_component_label(RF_Raid_t *raidPtr, RF_ComponentLabel_t *clabel)
 {
-	/* current version number */
-	clabel->version = RF_COMPONENT_LABEL_VERSION; 
+	/* Current version number. */
+	clabel->version = RF_COMPONENT_LABEL_VERSION;
 	clabel->serial_number = raidPtr->serial_number;
 	clabel->mod_counter = raidPtr->mod_counter;
 	clabel->num_rows = raidPtr->numRow;
 	clabel->num_columns = raidPtr->numCol;
-	clabel->clean = RF_RAID_DIRTY; /* not clean */
-	clabel->status = rf_ds_optimal; /* "It's good!" */
-	
+	clabel->clean = RF_RAID_DIRTY;	/* Not clean. */
+	clabel->status = rf_ds_optimal;	/* "It's good !" */
+
 	clabel->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
 	clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
 	clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
@@ -3463,7 +3448,7 @@ raid_init_component_label(raidPtr, clabel)
 	clabel->blockSize = raidPtr->bytesPerSector;
 	clabel->numBlocks = raidPtr->sectorsPerDisk;
 
-	/* XXX not portable */
+	/* XXX Not portable. */
 	clabel->parityConfig = raidPtr->Layout.map->parityConfig;
 	clabel->maxOutstanding = raidPtr->maxOutstanding;
 	clabel->autoconfigure = raidPtr->autoconfigure;
@@ -3473,9 +3458,7 @@ raid_init_component_label(raidPtr, clabel)
 }
 
 int
-rf_auto_config_set(cset,unit)
-	RF_ConfigSet_t *cset;
-	int *unit;
+rf_auto_config_set(RF_ConfigSet_t *cset, int *unit)
 {
 	RF_Raid_t *raidPtr;
 	RF_Config_t *config;
@@ -3487,78 +3470,79 @@ rf_auto_config_set(cset,unit)
 	retcode = 0;
 	*unit = -1;
 
-	/* 1. Create a config structure */
+	/* 1. Create a config structure. */
 
-	config = (RF_Config_t *)malloc(sizeof(RF_Config_t),
-				       M_RAIDFRAME,
-				       M_NOWAIT);
+	config = (RF_Config_t *)malloc(sizeof(RF_Config_t), M_RAIDFRAME,
+	    M_NOWAIT);
 	if (config==NULL) {
 		printf("Out of mem!?!?\n");
-				/* XXX do something more intelligent here. */
+				/* XXX Do something more intelligent here. */
 		return(1);
 	}
 
 	memset(config, 0, sizeof(RF_Config_t));
 
-	/* XXX raidID needs to be set correctly.. */
+	/* XXX raidID needs to be set correctly... */
 
-	/* 
-	   2. Figure out what RAID ID this one is supposed to live at 
-	   See if we can get the same RAID dev that it was configured
-	   on last time.. 
-	*/
+	/*
+	 * 2. Figure out what RAID ID this one is supposed to live at.
+	 * See if we can get the same RAID dev that it was configured
+	 * on last time...
+	 */
 
 	raidID = cset->ac->clabel->last_unit;
 	if ((raidID < 0) || (raidID >= numraid)) {
-		/* let's not wander off into lala land. */
+		/* Let's not wander off into lala land. */
 		raidID = numraid - 1;
 	}
 	if (raidPtrs[raidID]->valid != 0) {
 
-		/* 
-		   Nope... Go looking for an alternative...  
-		   Start high so we don't immediately use raid0 if that's
-		   not taken. 
-		*/
+		/*
+		 * Nope...  Go looking for an alternative...
+		 * Start high so we don't immediately use raid0 if that's
+		 * not taken.
+		 */
 
 		for(raidID = numraid - 1; raidID >= 0; raidID--) {
 			if (raidPtrs[raidID]->valid == 0) {
-				/* can use this one! */
+				/* We can use this one ! */
 				break;
 			}
 		}
 	}
 
 	if (raidID < 0) {
-		/* punt... */
+		/* Punt... */
 		printf("Unable to auto configure this set!\n");
 		printf("(Out of RAID devs!)\n");
 		return(1);
 	}
 	raidPtr = raidPtrs[raidID];
 
-	/* XXX all this stuff should be done SOMEWHERE ELSE! */
+	/* XXX All this stuff should be done SOMEWHERE ELSE ! */
 	raidPtr->raidid = raidID;
 	raidPtr->openings = RAIDOUTSTANDING;
 
-	/* 3. Build the configuration structure */
+	/* 3. Build the configuration structure. */
 	rf_create_configuration(cset->ac, config, raidPtr);
 
-	/* 4. Do the configuration */
+	/* 4. Do the configuration. */
 	retcode = rf_Configure(raidPtr, config, cset->ac);
-	
+
 	if (retcode == 0) {
 
 		raidinit(raidPtrs[raidID]);
 
 		rf_markalldirty(raidPtrs[raidID]);
-		raidPtrs[raidID]->autoconfigure = 1; /* XXX do this here? */
+		raidPtrs[raidID]->autoconfigure = 1; /* XXX Do this here ? */
 		if (cset->ac->clabel->root_partition==1) {
-			/* everything configured just fine.  Make a note
-			   that this set is eligible to be root. */
+			/*
+			 * Everything configured just fine.  Make a note
+			 * that this set is eligible to be root.
+			 */
 			cset->rootable = 1;
-			/* XXX do this here? */
-			raidPtrs[raidID]->root_partition = 1; 
+			/* XXX Do this here ? */
+			raidPtrs[raidID]->root_partition = 1;
 		}
 	}
 
@@ -3569,20 +3553,19 @@ rf_auto_config_set(cset,unit)
 	    (1 << raidPtrs[raidID]->logBytesPerSector) / 1024),
 	    raidPtrs[raidID]->root_partition ? " as root" : "");
 
-	/* 5. Cleanup */
+	/* 5. Cleanup. */
 	free(config, M_RAIDFRAME);
-	
+
 	*unit = raidID;
 	return(retcode);
 }
 
 void
-rf_disk_unbusy(desc)
-	RF_RaidAccessDesc_t *desc;
+rf_disk_unbusy(RF_RaidAccessDesc_t *desc)
 {
 	struct buf *bp;
 
 	bp = (struct buf *)desc->bp;
-	disk_unbusy(&raid_softc[desc->raidPtr->raidid].sc_dkdev, 
+	disk_unbusy(&raid_softc[desc->raidPtr->raidid].sc_dkdev,
 			    (bp->b_bcount - bp->b_resid));
 }
diff --git a/sys/dev/raidframe/rf_options.c b/sys/dev/raidframe/rf_options.c
index dd7a9957c8a..def8a552730 100644
--- a/sys/dev/raidframe/rf_options.c
+++ b/sys/dev/raidframe/rf_options.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_options.c,v 1.2 1999/02/16 00:03:02 niklas Exp $	*/
+/*	$OpenBSD: rf_options.c,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_options.c,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
+
 /*
  * rf_options.c
  */
@@ -37,40 +38,46 @@
 #include "rf_general.h"
 #include "rf_options.h"
 
-#ifdef RF_DBG_OPTION
-#undef RF_DBG_OPTION
-#endif				/* RF_DBG_OPTION */
+#ifdef	RF_DBG_OPTION
+#undef	RF_DBG_OPTION
+#endif	/* RF_DBG_OPTION */
 
-#ifdef __STDC__
-#define RF_DBG_OPTION(_option_,_defval_) long rf_##_option_ = _defval_;
-#else				/* __STDC__ */
-#define RF_DBG_OPTION(_option_,_defval_) long rf_/**/_option_ = _defval_;
-#endif				/* __STDC__ */
+#ifdef	__STDC__
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	long rf_##_option_ = _defval_;
+#else	/* __STDC__ */
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	long rf_/**/_option_ = _defval_;
+#endif	/* __STDC__ */
 
 #include "rf_optnames.h"
 
-#undef RF_DBG_OPTION
+#undef	RF_DBG_OPTION
 
-#ifdef __STDC__
-#define RF_DBG_OPTION(_option_,_defval_) { RF_STRING(_option_), &rf_##_option_ },
-#else				/* __STDC__ */
-#define RF_DBG_OPTION(_option_,_defval_) { RF_STRING(_option_), &rf_/**/_option_ },
-#endif				/* __STDC__ */
+#ifdef	__STDC__
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	{RF_STRING(_option_), &rf_##_option_},
+#else	/* __STDC__ */
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	{RF_STRING(_option_), &rf_/**/_option_},
+#endif	/* __STDC__ */
 
 RF_DebugName_t rf_debugNames[] = {
 #include "rf_optnames.h"
 	{NULL, NULL}
 };
-#undef RF_DBG_OPTION
+#undef	RF_DBG_OPTION
 
-#ifdef __STDC__
-#define RF_DBG_OPTION(_option_,_defval_) rf_##_option_  = _defval_ ;
-#else				/* __STDC__ */
-#define RF_DBG_OPTION(_option_,_defval_) rf_/**/_option_ = _defval_ ;
-#endif				/* __STDC__ */
+#ifdef	__STDC__
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	rf_##_option_  = _defval_;
+#else	/* __STDC__ */
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	rf_/**/_option_ = _defval_;
+#endif	/* __STDC__ */
 
-void 
-rf_ResetDebugOptions()
+void
+rf_ResetDebugOptions(void)
 {
 #include "rf_optnames.h"
 }
diff --git a/sys/dev/raidframe/rf_options.h b/sys/dev/raidframe/rf_options.h
index fa603b61419..e89a9734d89 100644
--- a/sys/dev/raidframe/rf_options.h
+++ b/sys/dev/raidframe/rf_options.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_options.h,v 1.2 1999/02/16 00:03:02 niklas Exp $	*/
+/*	$OpenBSD: rf_options.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_options.h,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
+
 /*
  * rf_options.h
  */
@@ -30,29 +31,31 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_OPTIONS_H_
-#define _RF__RF_OPTIONS_H_
+#ifndef	_RF__RF_OPTIONS_H_
+#define	_RF__RF_OPTIONS_H_
 
-#define RF_DEFAULT_LOCK_TABLE_SIZE 256
+#define	RF_DEFAULT_LOCK_TABLE_SIZE	256
 
 typedef struct RF_DebugNames_s {
-	char   *name;
-	long   *ptr;
-}       RF_DebugName_t;
+	char	*name;
+	long	*ptr;
+} RF_DebugName_t;
 
 extern RF_DebugName_t rf_debugNames[];
 
-#ifdef RF_DBG_OPTION
-#undef RF_DBG_OPTION
-#endif				/* RF_DBG_OPTION */
-
-#ifdef __STDC__
-#define RF_DBG_OPTION(_option_,_defval_) extern long rf_##_option_;
-#else				/* __STDC__ */
-#define RF_DBG_OPTION(_option_,_defval_) extern long rf_/**/_option_;
-#endif				/* __STDC__ */
+#ifdef	RF_DBG_OPTION
+#undef	RF_DBG_OPTION
+#endif	/* RF_DBG_OPTION */
+
+#ifdef	__STDC__
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	extern long rf_##_option_;
+#else	/* __STDC__ */
+#define	RF_DBG_OPTION(_option_,_defval_)				\
+	extern long rf_/**/_option_;
+#endif	/* __STDC__ */
 #include "rf_optnames.h"
 
-void    rf_ResetDebugOptions(void);
+void rf_ResetDebugOptions(void);
 
-#endif				/* !_RF__RF_OPTIONS_H_ */
+#endif	/* !_RF__RF_OPTIONS_H_ */
diff --git a/sys/dev/raidframe/rf_optnames.h b/sys/dev/raidframe/rf_optnames.h
index 3575f1cd792..b4f837027bb 100644
--- a/sys/dev/raidframe/rf_optnames.h
+++ b/sys/dev/raidframe/rf_optnames.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_optnames.h,v 1.4 2000/01/07 14:50:22 peter Exp $	*/
+/*	$OpenBSD: rf_optnames.h,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_optnames.h,v 1.6 1999/12/07 02:54:08 oster Exp $	*/
+
 /*
  * rf_optnames.h
  */
@@ -36,25 +37,28 @@
 
 RF_DBG_OPTION(accessDebug, 0)
 RF_DBG_OPTION(accessTraceBufSize, 0)
-RF_DBG_OPTION(cscanDebug, 0)	/* debug CSCAN sorting */
+RF_DBG_OPTION(cscanDebug, 0)		/* Debug CSCAN sorting. */
 RF_DBG_OPTION(dagDebug, 0)
 RF_DBG_OPTION(debugPrintUseBuffer, 0)
 RF_DBG_OPTION(degDagDebug, 0)
 RF_DBG_OPTION(disableAsyncAccs, 0)
 RF_DBG_OPTION(diskDebug, 0)
-RF_DBG_OPTION(enableAtomicRMW, 0)	/* this debug var enables locking of
+RF_DBG_OPTION(enableAtomicRMW, 0)	/*
+					 * This debug var enables locking of
 					 * the disk arm during small-write
-					 * operations.  Setting this variable
+					 * operations. Setting this variable
 					 * to anything other than 0 will
-					 * result in deadlock.  (wvcii) */
+					 * result in deadlock. (wvcii)
+					 */
 RF_DBG_OPTION(engineDebug, 0)
-RF_DBG_OPTION(fifoDebug, 0)	/* debug fifo queueing */
+RF_DBG_OPTION(fifoDebug, 0)		/* Debug fifo queueing. */
 RF_DBG_OPTION(floatingRbufDebug, 0)
 RF_DBG_OPTION(forceHeadSepLimit, -1)
-RF_DBG_OPTION(forceNumFloatingReconBufs, -1)		/* wire down number of
-							 * extra recon buffers
-							 * to use */
-RF_DBG_OPTION(keepAccTotals, 0)		/* turn on keep_acc_totals */
+RF_DBG_OPTION(forceNumFloatingReconBufs, -1)	/*
+						 * Wire down number of extra
+						 * recon buffers to use.
+						 */
+RF_DBG_OPTION(keepAccTotals, 0)		/* Turn on keep_acc_totals. */
 RF_DBG_OPTION(lockTableSize, RF_DEFAULT_LOCK_TABLE_SIZE)
 RF_DBG_OPTION(mapDebug, 0)
 RF_DBG_OPTION(maxNumTraces, -1)
@@ -62,44 +66,55 @@ RF_DBG_OPTION(maxNumTraces, -1)
 RF_DBG_OPTION(memChunkDebug, 0)
 RF_DBG_OPTION(memDebug, 0)
 RF_DBG_OPTION(memDebugAddress, 0)
-RF_DBG_OPTION(numBufsToAccumulate, 1)		/* number of buffers to
-						 * accumulate before doing XOR */
+RF_DBG_OPTION(numBufsToAccumulate, 1)	/*
+					 * Number of buffers to accumulate
+					 * before doing XOR.
+					 */
 RF_DBG_OPTION(prReconSched, 0)
 RF_DBG_OPTION(printDAGsDebug, 0)
 RF_DBG_OPTION(printStatesDebug, 0)
-RF_DBG_OPTION(protectedSectors, 64L)		/* # of sectors at start of
-						 * disk to exclude from RAID
-						 * address space */
+RF_DBG_OPTION(protectedSectors, 64L)	/*
+					 * # of sectors at start of disk to
+					 * exclude from RAID address space.
+					 */
 RF_DBG_OPTION(pssDebug, 0)
 RF_DBG_OPTION(queueDebug, 0)
 RF_DBG_OPTION(quiesceDebug, 0)
-RF_DBG_OPTION(raidSectorOffset, 0)	/* added to all incoming sectors to
-					 * debug alignment problems */
+RF_DBG_OPTION(raidSectorOffset, 0)	/*
+					 * Added to all incoming sectors to
+					 * debug alignment problems.
+					 */
 RF_DBG_OPTION(reconDebug, 0)
 RF_DBG_OPTION(reconbufferDebug, 0)
-RF_DBG_OPTION(scanDebug, 0)	/* debug SCAN sorting */
-RF_DBG_OPTION(showXorCallCounts, 0)	/* show n-way Xor call counts */
-RF_DBG_OPTION(shutdownDebug, 0)		/* show shutdown calls */
+RF_DBG_OPTION(scanDebug, 0)		/* Debug SCAN sorting. */
+RF_DBG_OPTION(showXorCallCounts, 0)	/* Show n-way Xor call counts. */
+RF_DBG_OPTION(shutdownDebug, 0)		/* Show shutdown calls. */
 RF_DBG_OPTION(sizePercentage, 100)
-RF_DBG_OPTION(sstfDebug, 0)	/* turn on debugging info for sstf queueing */
+RF_DBG_OPTION(sstfDebug, 0)		/*
+					 * Turn on debugging info for sstf
+					 * queueing.
+					 */
 RF_DBG_OPTION(stripeLockDebug, 0)
 RF_DBG_OPTION(suppressLocksAndLargeWrites, 0)
 RF_DBG_OPTION(suppressTraceDelays, 0)
 RF_DBG_OPTION(useMemChunks, 1)
 RF_DBG_OPTION(validateDAGDebug, 0)
-RF_DBG_OPTION(validateVisitedDebug, 1)		/* XXX turn to zero by
-						 * default? */
+RF_DBG_OPTION(validateVisitedDebug, 1)	/* XXX Turn to zero by default ? */
 RF_DBG_OPTION(verifyParityDebug, 0)
-RF_DBG_OPTION(debugKernelAccess, 0)	/* DoAccessKernel debugging */
+RF_DBG_OPTION(debugKernelAccess, 0)	/* DoAccessKernel debugging. */
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 RF_DBG_OPTION(forceParityLogReint, 0)
-RF_DBG_OPTION(numParityRegions, 0)	/* number of regions in the array */
+RF_DBG_OPTION(numParityRegions, 0)	/* Number of regions in the array. */
 RF_DBG_OPTION(numReintegrationThreads, 1)
-RF_DBG_OPTION(parityLogDebug, 0)	/* if nonzero, enables debugging of
-					 * parity logging */
-RF_DBG_OPTION(totalInCoreLogCapacity, 1024 * 1024)	/* target bytes
+RF_DBG_OPTION(parityLogDebug, 0)	/*
+					 * If nonzero, enables debugging of
+					 * parity logging.
+					 */
+RF_DBG_OPTION(totalInCoreLogCapacity, 1024 * 1024)	/*
+							 * Target bytes
 							 * available for in-core
-							 * logs */
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+							 * logs.
+							 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
 
diff --git a/sys/dev/raidframe/rf_paritylog.c b/sys/dev/raidframe/rf_paritylog.c
index 657bb6db9fa..aa318e49cb3 100644
--- a/sys/dev/raidframe/rf_paritylog.c
+++ b/sys/dev/raidframe/rf_paritylog.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_paritylog.c,v 1.4 2000/01/11 18:02:22 peter Exp $	*/
+/*	$OpenBSD: rf_paritylog.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_paritylog.c,v 1.5 2000/01/07 03:41:01 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,16 +28,16 @@
  * rights to redistribute these changes.
  */
 
-/* Code for manipulating in-core parity logs
- *
+/*
+ * Code for manipulating in-core parity logs.
  */
 
 #include "rf_archs.h"
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 
 /*
- * Append-only log for recording parity "update" and "overwrite" records
+ * Append-only log for recording parity "update" and "overwrite" records.
  */
 
 #include "rf_types.h"
@@ -55,28 +56,49 @@
 #include "rf_paritylogging.h"
 #include "rf_paritylogDiskMgr.h"
 
-static RF_CommonLogData_t *
-AllocParityLogCommonData(RF_Raid_t * raidPtr)
+RF_CommonLogData_t *rf_AllocParityLogCommonData(RF_Raid_t *);
+void rf_FreeParityLogCommonData(RF_CommonLogData_t *);
+RF_ParityLogData_t *rf_AllocParityLogData(RF_Raid_t *);
+void rf_FreeParityLogData(RF_ParityLogData_t *);
+void rf_EnqueueParityLogData(RF_ParityLogData_t *, RF_ParityLogData_t **,
+	RF_ParityLogData_t **);
+RF_ParityLogData_t *rf_DequeueParityLogData(RF_Raid_t *, RF_ParityLogData_t **,
+	RF_ParityLogData_t **, int);
+void rf_RequeueParityLogData(RF_ParityLogData_t *, RF_ParityLogData_t **,
+	RF_ParityLogData_t **);
+RF_ParityLogData_t *rf_DequeueMatchingLogData(RF_Raid_t *,
+	RF_ParityLogData_t **, RF_ParityLogData_t **);
+RF_ParityLog_t *rf_AcquireParityLog(RF_ParityLogData_t *, int);
+void rf_ReintLog(RF_Raid_t *, int, RF_ParityLog_t *);
+void rf_FlushLog(RF_Raid_t *, RF_ParityLog_t *);
+int  rf_DumpParityLogToDisk(int, RF_ParityLogData_t *);
+
+RF_CommonLogData_t *
+rf_AllocParityLogCommonData(RF_Raid_t *raidPtr)
 {
 	RF_CommonLogData_t *common = NULL;
-	int     rc;
+	int rc;
 
-	/* Return a struct for holding common parity log information from the
-	 * free list (rf_parityLogDiskQueue.freeCommonList).  If the free list
-	 * is empty, call RF_Malloc to create a new structure. NON-BLOCKING */
+	/*
+	 * Return a struct for holding common parity log information from the
+	 * free list (rf_parityLogDiskQueue.freeCommonList). If the free list
+	 * is empty, call RF_Malloc to create a new structure. NON-BLOCKING
+	 */
 
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	if (raidPtr->parityLogDiskQueue.freeCommonList) {
 		common = raidPtr->parityLogDiskQueue.freeCommonList;
-		raidPtr->parityLogDiskQueue.freeCommonList = raidPtr->parityLogDiskQueue.freeCommonList->next;
+		raidPtr->parityLogDiskQueue.freeCommonList =
+		    raidPtr->parityLogDiskQueue.freeCommonList->next;
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	} else {
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-		RF_Malloc(common, sizeof(RF_CommonLogData_t), (RF_CommonLogData_t *));
+		RF_Malloc(common, sizeof(RF_CommonLogData_t),
+		    (RF_CommonLogData_t *));
 		rc = rf_mutex_init(&common->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);
 			RF_Free(common, sizeof(RF_CommonLogData_t));
 			common = NULL;
 		}
@@ -85,14 +107,16 @@ AllocParityLogCommonData(RF_Raid_t * raidPtr)
 	return (common);
 }
 
-static void 
-FreeParityLogCommonData(RF_CommonLogData_t * common)
+void
+rf_FreeParityLogCommonData(RF_CommonLogData_t *common)
 {
 	RF_Raid_t *raidPtr;
 
-	/* Insert a single struct for holding parity log information (data)
+	/*
+	 * Insert a single struct for holding parity log information (data)
 	 * into the free list (rf_parityLogDiskQueue.freeCommonList).
-	 * NON-BLOCKING */
+	 * NON-BLOCKING
+	 */
 
 	raidPtr = common->raidPtr;
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
@@ -101,23 +125,27 @@ FreeParityLogCommonData(RF_CommonLogData_t * common)
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 }
 
-static RF_ParityLogData_t *
-AllocParityLogData(RF_Raid_t * raidPtr)
+RF_ParityLogData_t *
+rf_AllocParityLogData(RF_Raid_t *raidPtr)
 {
 	RF_ParityLogData_t *data = NULL;
 
-	/* Return a struct for holding parity log information from the free
-	 * list (rf_parityLogDiskQueue.freeList).  If the free list is empty,
-	 * call RF_Malloc to create a new structure. NON-BLOCKING */
+	/*
+	 * Return a struct for holding parity log information from the free
+	 * list (rf_parityLogDiskQueue.freeList). If the free list is empty,
+	 * call RF_Malloc to create a new structure. NON-BLOCKING
+	 */
 
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	if (raidPtr->parityLogDiskQueue.freeDataList) {
 		data = raidPtr->parityLogDiskQueue.freeDataList;
-		raidPtr->parityLogDiskQueue.freeDataList = raidPtr->parityLogDiskQueue.freeDataList->next;
+		raidPtr->parityLogDiskQueue.freeDataList =
+		    raidPtr->parityLogDiskQueue.freeDataList->next;
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	} else {
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-		RF_Malloc(data, sizeof(RF_ParityLogData_t), (RF_ParityLogData_t *));
+		RF_Malloc(data, sizeof(RF_ParityLogData_t),
+		    (RF_ParityLogData_t *));
 	}
 	data->next = NULL;
 	data->prev = NULL;
@@ -125,15 +153,17 @@ AllocParityLogData(RF_Raid_t * raidPtr)
 }
 
 
-static void 
-FreeParityLogData(RF_ParityLogData_t * data)
+void
+rf_FreeParityLogData(RF_ParityLogData_t *data)
 {
 	RF_ParityLogData_t *nextItem;
 	RF_Raid_t *raidPtr;
 
-	/* Insert a linked list of structs for holding parity log information
+	/*
+	 * Insert a linked list of structs for holding parity log information
 	 * (data) into the free list (parityLogDiskQueue.freeList).
-	 * NON-BLOCKING */
+	 * NON-BLOCKING
+	 */
 
 	raidPtr = data->common->raidPtr;
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
@@ -147,32 +177,35 @@ FreeParityLogData(RF_ParityLogData_t * data)
 }
 
 
-static void 
-EnqueueParityLogData(
-    RF_ParityLogData_t * data,
-    RF_ParityLogData_t ** head,
-    RF_ParityLogData_t ** tail)
+void
+rf_EnqueueParityLogData(RF_ParityLogData_t *data, RF_ParityLogData_t **head,
+    RF_ParityLogData_t **tail)
 {
 	RF_Raid_t *raidPtr;
 
-	/* Insert an in-core parity log (*data) into the head of a disk queue
-	 * (*head, *tail). NON-BLOCKING */
+	/*
+	 * Insert an in-core parity log (*data) into the head of a disk queue
+	 * (*head, *tail). NON-BLOCKING
+	 */
 
 	raidPtr = data->common->raidPtr;
 	if (rf_parityLogDebug)
-		printf("[enqueueing parity log data, region %d, raidAddress %d, numSector %d]\n", data->regionID, (int) data->diskAddress.raidAddress, (int) data->diskAddress.numSector);
+		printf("[enqueueing parity log data, region %d,"
+		    " raidAddress %d, numSector %d]\n", data->regionID,
+		    (int) data->diskAddress.raidAddress,
+		    (int) data->diskAddress.numSector);
 	RF_ASSERT(data->prev == NULL);
 	RF_ASSERT(data->next == NULL);
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	if (*head) {
-		/* insert into head of queue */
+		/* Insert into head of queue. */
 		RF_ASSERT((*head)->prev == NULL);
 		RF_ASSERT((*tail)->next == NULL);
 		data->next = *head;
 		(*head)->prev = data;
 		*head = data;
 	} else {
-		/* insert into empty list */
+		/* Insert into empty list. */
 		RF_ASSERT(*head == NULL);
 		RF_ASSERT(*tail == NULL);
 		*head = data;
@@ -183,25 +216,24 @@ EnqueueParityLogData(
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 }
 
-static RF_ParityLogData_t *
-DequeueParityLogData(
-    RF_Raid_t * raidPtr,
-    RF_ParityLogData_t ** head,
-    RF_ParityLogData_t ** tail,
-    int ignoreLocks)
+RF_ParityLogData_t *
+rf_DequeueParityLogData(RF_Raid_t *raidPtr, RF_ParityLogData_t **head,
+    RF_ParityLogData_t **tail, int ignoreLocks)
 {
 	RF_ParityLogData_t *data;
 
-	/* Remove and return an in-core parity log from the tail of a disk
-	 * queue (*head, *tail). NON-BLOCKING */
+	/*
+	 * Remove and return an in-core parity log from the tail of a disk
+	 * queue (*head, *tail). NON-BLOCKING
+	 */
 
-	/* remove from tail, preserving FIFO order */
+	/* Remove from tail, preserving FIFO order. */
 	if (!ignoreLocks)
 		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	data = *tail;
 	if (data) {
 		if (*head == *tail) {
-			/* removing last item from queue */
+			/* Removing last item from queue. */
 			*head = NULL;
 			*tail = NULL;
 		} else {
@@ -213,7 +245,10 @@ DequeueParityLogData(
 		data->next = NULL;
 		data->prev = NULL;
 		if (rf_parityLogDebug)
-			printf("[dequeueing parity log data, region %d, raidAddress %d, numSector %d]\n", data->regionID, (int) data->diskAddress.raidAddress, (int) data->diskAddress.numSector);
+			printf("[dequeueing parity log data, region %d,"
+			    " raidAddress %d, numSector %d]\n", data->regionID,
+			    (int) data->diskAddress.raidAddress,
+			    (int) data->diskAddress.numSector);
 	}
 	if (*head) {
 		RF_ASSERT((*head)->prev == NULL);
@@ -225,30 +260,33 @@ DequeueParityLogData(
 }
 
 
-static void 
-RequeueParityLogData(
-    RF_ParityLogData_t * data,
-    RF_ParityLogData_t ** head,
-    RF_ParityLogData_t ** tail)
+void
+rf_RequeueParityLogData(RF_ParityLogData_t *data, RF_ParityLogData_t **head,
+    RF_ParityLogData_t **tail)
 {
 	RF_Raid_t *raidPtr;
 
-	/* Insert an in-core parity log (*data) into the tail of a disk queue
-	 * (*head, *tail). NON-BLOCKING */
+	/*
+	 * Insert an in-core parity log (*data) into the tail of a disk queue
+	 * (*head, *tail). NON-BLOCKING
+	 */
 
 	raidPtr = data->common->raidPtr;
 	RF_ASSERT(data);
 	if (rf_parityLogDebug)
-		printf("[requeueing parity log data, region %d, raidAddress %d, numSector %d]\n", data->regionID, (int) data->diskAddress.raidAddress, (int) data->diskAddress.numSector);
+		printf("[requeueing parity log data, region %d,"
+		    " raidAddress %d, numSector %d]\n", data->regionID,
+		    (int) data->diskAddress.raidAddress,
+		    (int) data->diskAddress.numSector);
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	if (*tail) {
-		/* append to tail of list */
+		/* Append to tail of list. */
 		data->prev = *tail;
 		data->next = NULL;
 		(*tail)->next = data;
 		*tail = data;
 	} else {
-		/* inserting into an empty list */
+		/* Inserting into an empty list. */
 		*head = data;
 		*tail = data;
 		(*head)->prev = NULL;
@@ -260,28 +298,25 @@ RequeueParityLogData(
 }
 
 RF_ParityLogData_t *
-rf_CreateParityLogData(
-    RF_ParityRecordType_t operation,
-    RF_PhysDiskAddr_t * pda,
-    caddr_t bufPtr,
-    RF_Raid_t * raidPtr,
+rf_CreateParityLogData(RF_ParityRecordType_t operation, RF_PhysDiskAddr_t *pda,
+    caddr_t bufPtr, RF_Raid_t *raidPtr,
     int (*wakeFunc) (RF_DagNode_t * node, int status),
-    void *wakeArg,
-    RF_AccTraceEntry_t * tracerec,
-    RF_Etimer_t startTime)
+    void *wakeArg, RF_AccTraceEntry_t *tracerec, RF_Etimer_t startTime)
 {
 	RF_ParityLogData_t *data, *resultHead = NULL, *resultTail = NULL;
 	RF_CommonLogData_t *common;
 	RF_PhysDiskAddr_t *diskAddress;
-	int     boundary, offset = 0;
+	int boundary, offset = 0;
 
-	/* Return an initialized struct of info to be logged. Build one item
+	/*
+	 * Return an initialized struct of info to be logged. Build one item
 	 * per physical disk address, one item per region.
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * NON-BLOCKING
+	 */
 
 	diskAddress = pda;
-	common = AllocParityLogCommonData(raidPtr);
+	common = rf_AllocParityLogCommonData(raidPtr);
 	RF_ASSERT(common);
 
 	common->operation = operation;
@@ -297,34 +332,38 @@ rf_CreateParityLogData(
 		printf("[entering CreateParityLogData]\n");
 	while (diskAddress) {
 		common->cnt++;
-		data = AllocParityLogData(raidPtr);
+		data = rf_AllocParityLogData(raidPtr);
 		RF_ASSERT(data);
 		data->common = common;
 		data->next = NULL;
 		data->prev = NULL;
-		data->regionID = rf_MapRegionIDParityLogging(raidPtr, diskAddress->startSector);
-		if (data->regionID == rf_MapRegionIDParityLogging(raidPtr, diskAddress->startSector + diskAddress->numSector - 1)) {
-			/* disk address does not cross a region boundary */
+		data->regionID = rf_MapRegionIDParityLogging(raidPtr,
+		    diskAddress->startSector);
+		if (data->regionID == rf_MapRegionIDParityLogging(raidPtr,
+		    diskAddress->startSector + diskAddress->numSector - 1)) {
+			/* Disk address does not cross a region boundary. */
 			data->diskAddress = *diskAddress;
 			data->bufOffset = offset;
 			offset = offset + diskAddress->numSector;
-			EnqueueParityLogData(data, &resultHead, &resultTail);
-			/* adjust disk address */
+			rf_EnqueueParityLogData(data, &resultHead, &resultTail);
+			/* Adjust disk address. */
 			diskAddress = diskAddress->next;
 		} else {
-			/* disk address crosses a region boundary */
-			/* find address where region is crossed */
+			/* Disk address crosses a region boundary. */
+			/* Find address where region is crossed. */
 			boundary = 0;
-			while (data->regionID == rf_MapRegionIDParityLogging(raidPtr, diskAddress->startSector + boundary))
+			while (data->regionID ==
+			    rf_MapRegionIDParityLogging(raidPtr,
+			     diskAddress->startSector + boundary))
 				boundary++;
 
-			/* enter data before the boundary */
+			/* Enter data before the boundary. */
 			data->diskAddress = *diskAddress;
 			data->diskAddress.numSector = boundary;
 			data->bufOffset = offset;
 			offset += boundary;
-			EnqueueParityLogData(data, &resultHead, &resultTail);
-			/* adjust disk address */
+			rf_EnqueueParityLogData(data, &resultHead, &resultTail);
+			/* Adjust disk address. */
 			diskAddress->startSector += boundary;
 			diskAddress->numSector -= boundary;
 		}
@@ -336,35 +375,35 @@ rf_CreateParityLogData(
 
 
 RF_ParityLogData_t *
-rf_SearchAndDequeueParityLogData(
-    RF_Raid_t * raidPtr,
-    int regionID,
-    RF_ParityLogData_t ** head,
-    RF_ParityLogData_t ** tail,
-    int ignoreLocks)
+rf_SearchAndDequeueParityLogData(RF_Raid_t *raidPtr, int regionID,
+    RF_ParityLogData_t **head, RF_ParityLogData_t **tail, int ignoreLocks)
 {
 	RF_ParityLogData_t *w;
 
-	/* Remove and return an in-core parity log from a specified region
+	/*
+	 * Remove and return an in-core parity log from a specified region
 	 * (regionID). If a matching log is not found, return NULL.
-	 * 
-	 * NON-BLOCKING. */
-
-	/* walk backward through a list, looking for an entry with a matching
-	 * region ID */
+	 *
+	 * NON-BLOCKING
+	 */
+
+	/*
+	 * walk backward through a list, looking for an entry with a matching
+	 * region ID.
+	 */
 	if (!ignoreLocks)
 		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	w = (*tail);
 	while (w) {
 		if (w->regionID == regionID) {
-			/* remove an element from the list */
+			/* Remove an element from the list. */
 			if (w == *tail) {
 				if (*head == *tail) {
-					/* removing only element in the list */
+					/* Removing only element in the list. */
 					*head = NULL;
 					*tail = NULL;
 				} else {
-					/* removing last item in the list */
+					/* Removing last item in the list. */
 					*tail = (*tail)->prev;
 					(*tail)->next = NULL;
 					RF_ASSERT((*head)->prev == NULL);
@@ -372,14 +411,16 @@ rf_SearchAndDequeueParityLogData(
 				}
 			} else {
 				if (w == *head) {
-					/* removing first item in the list */
+					/* Removing first item in the list. */
 					*head = (*head)->next;
 					(*head)->prev = NULL;
 					RF_ASSERT((*head)->prev == NULL);
 					RF_ASSERT((*tail)->next == NULL);
 				} else {
-					/* removing an item from the middle of
-					 * the list */
+					/*
+					 * Removing an item from the middle of
+					 * the list.
+					 */
 					w->prev->next = w->next;
 					w->next->prev = w->prev;
 					RF_ASSERT((*head)->prev == NULL);
@@ -389,7 +430,11 @@ rf_SearchAndDequeueParityLogData(
 			w->prev = NULL;
 			w->next = NULL;
 			if (rf_parityLogDebug)
-				printf("[dequeueing parity log data, region %d, raidAddress %d, numSector %d]\n", w->regionID, (int) w->diskAddress.raidAddress, (int) w->diskAddress.numSector);
+				printf("[dequeueing parity log data,"
+				    " region %d, raidAddress %d,"
+				    " numSector %d]\n", w->regionID,
+				    (int) w->diskAddress.raidAddress,
+				    (int) w->diskAddress.numSector);
 			return (w);
 		} else
 			w = w->prev;
@@ -399,93 +444,109 @@ rf_SearchAndDequeueParityLogData(
 	return (NULL);
 }
 
-static RF_ParityLogData_t *
-DequeueMatchingLogData(
-    RF_Raid_t * raidPtr,
-    RF_ParityLogData_t ** head,
-    RF_ParityLogData_t ** tail)
+RF_ParityLogData_t *
+rf_DequeueMatchingLogData(RF_Raid_t *raidPtr, RF_ParityLogData_t **head,
+    RF_ParityLogData_t **tail)
 {
 	RF_ParityLogData_t *logDataList, *logData;
-	int     regionID;
+	int regionID;
 
-	/* Remove and return an in-core parity log from the tail of a disk
-	 * queue (*head, *tail).  Then remove all matching (identical
+	/*
+	 * Remove and return an in-core parity log from the tail of a disk
+	 * queue (*head, *tail). Then remove all matching (identical
 	 * regionIDs) logData and return as a linked list.
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * NON-BLOCKING
+	 */
 
-	logDataList = DequeueParityLogData(raidPtr, head, tail, RF_TRUE);
+	logDataList = rf_DequeueParityLogData(raidPtr, head, tail, RF_TRUE);
 	if (logDataList) {
 		regionID = logDataList->regionID;
 		logData = logDataList;
-		logData->next = rf_SearchAndDequeueParityLogData(raidPtr, regionID, head, tail, RF_TRUE);
+		logData->next = rf_SearchAndDequeueParityLogData(raidPtr,
+		    regionID, head, tail, RF_TRUE);
 		while (logData->next) {
 			logData = logData->next;
-			logData->next = rf_SearchAndDequeueParityLogData(raidPtr, regionID, head, tail, RF_TRUE);
+			logData->next =
+			    rf_SearchAndDequeueParityLogData(raidPtr, regionID,
+			     head, tail, RF_TRUE);
 		}
 	}
 	return (logDataList);
 }
 
 
-static RF_ParityLog_t *
-AcquireParityLog(
-    RF_ParityLogData_t * logData,
-    int finish)
+RF_ParityLog_t *
+rf_AcquireParityLog(RF_ParityLogData_t *logData, int finish)
 {
 	RF_ParityLog_t *log = NULL;
 	RF_Raid_t *raidPtr;
 
-	/* Grab a log buffer from the pool and return it. If no buffers are
-	 * available, return NULL. NON-BLOCKING */
+	/*
+	 * Grab a log buffer from the pool and return it. If no buffers are
+	 * available, return NULL. NON-BLOCKING
+	 */
 	raidPtr = logData->common->raidPtr;
 	RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
 	if (raidPtr->parityLogPool.parityLogs) {
 		log = raidPtr->parityLogPool.parityLogs;
-		raidPtr->parityLogPool.parityLogs = raidPtr->parityLogPool.parityLogs->next;
+		raidPtr->parityLogPool.parityLogs =
+		    raidPtr->parityLogPool.parityLogs->next;
 		log->regionID = logData->regionID;
 		log->numRecords = 0;
 		log->next = NULL;
 		raidPtr->logsInUse++;
-		RF_ASSERT(raidPtr->logsInUse >= 0 && raidPtr->logsInUse <= raidPtr->numParityLogs);
+		RF_ASSERT(raidPtr->logsInUse >= 0 &&
+		    raidPtr->logsInUse <= raidPtr->numParityLogs);
 	} else {
-		/* no logs available, so place ourselves on the queue of work
+		/*
+		 * No logs available, so place ourselves on the queue of work
 		 * waiting on log buffers this is done while
 		 * parityLogPool.mutex is held, to ensure synchronization with
-		 * ReleaseParityLogs. */
+		 * ReleaseParityLogs.
+		 */
 		if (rf_parityLogDebug)
-			printf("[blocked on log, region %d, finish %d]\n", logData->regionID, finish);
+			printf("[blocked on log, region %d, finish %d]\n",
+			    logData->regionID, finish);
 		if (finish)
-			RequeueParityLogData(logData, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
+			rf_RequeueParityLogData(logData,
+			    &raidPtr->parityLogDiskQueue.logBlockHead,
+			    &raidPtr->parityLogDiskQueue.logBlockTail);
 		else
-			EnqueueParityLogData(logData, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
+			rf_EnqueueParityLogData(logData,
+			    &raidPtr->parityLogDiskQueue.logBlockHead,
+			    &raidPtr->parityLogDiskQueue.logBlockTail);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
 	return (log);
 }
 
-void 
-rf_ReleaseParityLogs(
-    RF_Raid_t * raidPtr,
-    RF_ParityLog_t * firstLog)
+void
+rf_ReleaseParityLogs(RF_Raid_t *raidPtr, RF_ParityLog_t *firstLog)
 {
 	RF_ParityLogData_t *logDataList;
 	RF_ParityLog_t *log, *lastLog;
-	int     cnt;
+	int cnt;
 
-	/* Insert a linked list of parity logs (firstLog) to the free list
+	/*
+	 * Insert a linked list of parity logs (firstLog) to the free list
 	 * (parityLogPool.parityLogPool)
-	 * 
-	 * NON-BLOCKING. */
+	 *
+	 * NON-BLOCKING
+	 */
 
 	RF_ASSERT(firstLog);
 
-	/* Before returning logs to global free list, service all requests
-	 * which are blocked on logs.  Holding mutexes for parityLogPool and
-	 * parityLogDiskQueue forces synchronization with AcquireParityLog(). */
+	/*
+	 * Before returning logs to global free list, service all requests
+	 * which are blocked on logs. Holding mutexes for parityLogPool and
+	 * parityLogDiskQueue forces synchronization with rf_AcquireParityLog().
+	 */
 	RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	logDataList = DequeueMatchingLogData(raidPtr, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
+	logDataList = rf_DequeueMatchingLogData(raidPtr,
+	    &raidPtr->parityLogDiskQueue.logBlockHead,
+	    &raidPtr->parityLogDiskQueue.logBlockTail);
 	log = firstLog;
 	if (firstLog)
 		firstLog = firstLog->next;
@@ -496,7 +557,8 @@ rf_ReleaseParityLogs(
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 		rf_ParityLogAppend(logDataList, RF_TRUE, &log, RF_FALSE);
 		if (rf_parityLogDebug)
-			printf("[finishing up buf-blocked log data, region %d]\n", logDataList->regionID);
+			printf("[finishing up buf-blocked log data,"
+			    " region %d]\n", logDataList->regionID);
 		if (log == NULL) {
 			log = firstLog;
 			if (firstLog) {
@@ -508,9 +570,11 @@ rf_ReleaseParityLogs(
 		RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
 		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 		if (log)
-			logDataList = DequeueMatchingLogData(raidPtr, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
+			logDataList = rf_DequeueMatchingLogData(raidPtr,
+			    &raidPtr->parityLogDiskQueue.logBlockHead,
+			    &raidPtr->parityLogDiskQueue.logBlockTail);
 	}
-	/* return remaining logs to pool */
+	/* Return remaining logs to pool. */
 	if (log) {
 		log->next = firstLog;
 		firstLog = log;
@@ -518,11 +582,13 @@ rf_ReleaseParityLogs(
 	if (firstLog) {
 		lastLog = firstLog;
 		raidPtr->logsInUse--;
-		RF_ASSERT(raidPtr->logsInUse >= 0 && raidPtr->logsInUse <= raidPtr->numParityLogs);
+		RF_ASSERT(raidPtr->logsInUse >= 0 &&
+		    raidPtr->logsInUse <= raidPtr->numParityLogs);
 		while (lastLog->next) {
 			lastLog = lastLog->next;
 			raidPtr->logsInUse--;
-			RF_ASSERT(raidPtr->logsInUse >= 0 && raidPtr->logsInUse <= raidPtr->numParityLogs);
+			RF_ASSERT(raidPtr->logsInUse >= 0 &&
+			    raidPtr->logsInUse <= raidPtr->numParityLogs);
 		}
 		lastLog->next = raidPtr->parityLogPool.parityLogs;
 		raidPtr->parityLogPool.parityLogs = firstLog;
@@ -538,26 +604,26 @@ rf_ReleaseParityLogs(
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 }
 
-static void 
-ReintLog(
-    RF_Raid_t * raidPtr,
-    int regionID,
-    RF_ParityLog_t * log)
+void
+rf_ReintLog(RF_Raid_t *raidPtr, int regionID, RF_ParityLog_t *log)
 {
 	RF_ASSERT(log);
 
-	/* Insert an in-core parity log (log) into the disk queue of
-	 * reintegration work.  Set the flag (reintInProgress) for the
+	/*
+	 * Insert an in-core parity log (log) into the disk queue of
+	 * reintegration work. Set the flag (reintInProgress) for the
 	 * specified region (regionID) to indicate that reintegration is in
-	 * progress for this region. NON-BLOCKING */
+	 * progress for this region. NON-BLOCKING
+	 */
 
 	RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
-	raidPtr->regionInfo[regionID].reintInProgress = RF_TRUE;	/* cleared when reint
-									 * complete */
+	/* Cleared when reint complete. */
+	raidPtr->regionInfo[regionID].reintInProgress = RF_TRUE;
 
 	if (rf_parityLogDebug)
-		printf("[requesting reintegration of region %d]\n", log->regionID);
-	/* move record to reintegration queue */
+		printf("[requesting reintegration of region %d]\n",
+		    log->regionID);
+	/* Move record to reintegration queue. */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	log->next = raidPtr->parityLogDiskQueue.reintQueue;
 	raidPtr->parityLogDiskQueue.reintQueue = log;
@@ -566,19 +632,19 @@ ReintLog(
 	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
 }
 
-static void 
-FlushLog(
-    RF_Raid_t * raidPtr,
-    RF_ParityLog_t * log)
+void
+rf_FlushLog(RF_Raid_t *raidPtr, RF_ParityLog_t *log)
 {
-	/* insert a core log (log) into a list of logs
+	/*
+	 * Insert a core log (log) into a list of logs
 	 * (parityLogDiskQueue.flushQueue) waiting to be written to disk.
-	 * NON-BLOCKING */
+	 * NON-BLOCKING
+	 */
 
 	RF_ASSERT(log);
 	RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
 	RF_ASSERT(log->next == NULL);
-	/* move log to flush queue */
+	/* Move log to flush queue. */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	log->next = raidPtr->parityLogDiskQueue.flushQueue;
 	raidPtr->parityLogDiskQueue.flushQueue = log;
@@ -586,27 +652,27 @@ FlushLog(
 	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
 }
 
-static int 
-DumpParityLogToDisk(
-    int finish,
-    RF_ParityLogData_t * logData)
+int
+rf_DumpParityLogToDisk(int finish, RF_ParityLogData_t *logData)
 {
-	int     i, diskCount, regionID = logData->regionID;
+	int i, diskCount, regionID = logData->regionID;
 	RF_ParityLog_t *log;
 	RF_Raid_t *raidPtr;
 
 	raidPtr = logData->common->raidPtr;
 
-	/* Move a core log to disk.  If the log disk is full, initiate
+	/*
+	 * Move a core log to disk. If the log disk is full, initiate
 	 * reintegration.
-	 * 
+	 *
 	 * Return (0) if we can enqueue the dump immediately, otherwise return
 	 * (1) to indicate we are blocked on reintegration and control of the
 	 * thread should be relinquished.
-	 * 
-	 * Caller must hold regionInfo[regionID].mutex
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * Caller must hold regionInfo[regionID].mutex.
+	 *
+	 * NON-BLOCKING
+	 */
 
 	if (rf_parityLogDebug)
 		printf("[dumping parity log to disk, region %d]\n", regionID);
@@ -614,200 +680,293 @@ DumpParityLogToDisk(
 	RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
 	RF_ASSERT(log->next == NULL);
 
-	/* if reintegration is in progress, must queue work */
+	/* If reintegration is in progress, must queue work. */
 	RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
 	if (raidPtr->regionInfo[regionID].reintInProgress) {
-		/* Can not proceed since this region is currently being
+		/*
+		 * Can not proceed since this region is currently being
 		 * reintegrated. We can not block, so queue remaining work and
-		 * return */
+		 * return.
+		 */
 		if (rf_parityLogDebug)
-			printf("[region %d waiting on reintegration]\n", regionID);
-		/* XXX not sure about the use of finish - shouldn't this
-		 * always be "Enqueue"? */
+			printf("[region %d waiting on reintegration]\n",
+			    regionID);
+		/*
+		 * XXX Not sure about the use of finish - shouldn't this
+		 * always be "Enqueue" ?
+		 */
 		if (finish)
-			RequeueParityLogData(logData, &raidPtr->parityLogDiskQueue.reintBlockHead, &raidPtr->parityLogDiskQueue.reintBlockTail);
+			rf_RequeueParityLogData(logData,
+			    &raidPtr->parityLogDiskQueue.reintBlockHead,
+			    &raidPtr->parityLogDiskQueue.reintBlockTail);
 		else
-			EnqueueParityLogData(logData, &raidPtr->parityLogDiskQueue.reintBlockHead, &raidPtr->parityLogDiskQueue.reintBlockTail);
+			rf_EnqueueParityLogData(logData,
+			    &raidPtr->parityLogDiskQueue.reintBlockHead,
+			    &raidPtr->parityLogDiskQueue.reintBlockTail);
 		RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
-		return (1);	/* relenquish control of this thread */
+		return (1);	/* Relenquish control of this thread. */
 	}
 	RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
 	raidPtr->regionInfo[regionID].coreLog = NULL;
-	if ((raidPtr->regionInfo[regionID].diskCount) < raidPtr->regionInfo[regionID].capacity)
-		/* IMPORTANT!! this loop bound assumes region disk holds an
-		 * integral number of core logs */
+	if ((raidPtr->regionInfo[regionID].diskCount) <
+	    raidPtr->regionInfo[regionID].capacity)
+		/*
+		 * IMPORTANT !!!  This loop bound assumes region disk holds an
+		 * integral number of core logs.
+		 */
 	{
-		/* update disk map for this region */
+		/* Update disk map for this region. */
 		diskCount = raidPtr->regionInfo[regionID].diskCount;
 		for (i = 0; i < raidPtr->numSectorsPerLog; i++) {
-			raidPtr->regionInfo[regionID].diskMap[i + diskCount].operation = log->records[i].operation;
-			raidPtr->regionInfo[regionID].diskMap[i + diskCount].parityAddr = log->records[i].parityAddr;
+			raidPtr->regionInfo[regionID].diskMap[i + diskCount]
+			    .operation = log->records[i].operation;
+			raidPtr->regionInfo[regionID].diskMap[i + diskCount]
+			    .parityAddr = log->records[i].parityAddr;
 		}
 		log->diskOffset = diskCount;
-		raidPtr->regionInfo[regionID].diskCount += raidPtr->numSectorsPerLog;
-		FlushLog(raidPtr, log);
+		raidPtr->regionInfo[regionID].diskCount +=
+		    raidPtr->numSectorsPerLog;
+		rf_FlushLog(raidPtr, log);
 	} else {
-		/* no room for log on disk, send it to disk manager and
-		 * request reintegration */
-		RF_ASSERT(raidPtr->regionInfo[regionID].diskCount == raidPtr->regionInfo[regionID].capacity);
-		ReintLog(raidPtr, regionID, log);
+		/*
+		 * No room for log on disk, send it to disk manager and
+		 * request reintegration.
+		 */
+		RF_ASSERT(raidPtr->regionInfo[regionID].diskCount ==
+		    raidPtr->regionInfo[regionID].capacity);
+		rf_ReintLog(raidPtr, regionID, log);
 	}
 	if (rf_parityLogDebug)
-		printf("[finished dumping parity log to disk, region %d]\n", regionID);
+		printf("[finished dumping parity log to disk, region %d]\n",
+		    regionID);
 	return (0);
 }
 
-int 
-rf_ParityLogAppend(
-    RF_ParityLogData_t * logData,
-    int finish,
-    RF_ParityLog_t ** incomingLog,
-    int clearReintFlag)
+int
+rf_ParityLogAppend(RF_ParityLogData_t *logData, int finish,
+    RF_ParityLog_t **incomingLog, int clearReintFlag)
 {
-	int     regionID, logItem, itemDone;
+	int regionID, logItem, itemDone;
 	RF_ParityLogData_t *item;
-	int     punt, done = RF_FALSE;
+	int punt, done = RF_FALSE;
 	RF_ParityLog_t *log;
 	RF_Raid_t *raidPtr;
 	RF_Etimer_t timer;
-	int     (*wakeFunc) (RF_DagNode_t * node, int status);
-	void   *wakeArg;
+	int (*wakeFunc) (RF_DagNode_t * node, int status);
+	void *wakeArg;
 
-	/* Add parity to the appropriate log, one sector at a time. This
+	/*
+	 * Add parity to the appropriate log, one sector at a time. This
 	 * routine is called is called by dag functions ParityLogUpdateFunc
 	 * and ParityLogOverwriteFunc and therefore MUST BE NONBLOCKING.
-	 * 
-	 * Parity to be logged is contained in a linked-list (logData).  When
+	 *
+	 * Parity to be logged is contained in a linked-list (logData). When
 	 * this routine returns, every sector in the list will be in one of
 	 * three places: 1) entered into the parity log 2) queued, waiting on
-	 * reintegration 3) queued, waiting on a core log
-	 * 
-	 * Blocked work is passed to the ParityLoggingDiskManager for completion.
-	 * Later, as conditions which required the block are removed, the work
-	 * reenters this routine with the "finish" parameter set to "RF_TRUE."
-	 * 
-	 * NON-BLOCKING */
+	 * reintegration 3) queued, waiting on a core log.
+	 *
+	 * Blocked work is passed to the ParityLoggingDiskManager for
+	 * completion. Later, as conditions which required the block are
+	 * removed, the work reenters this routine with the "finish" parameter
+	 * set to "RF_TRUE."
+	 *
+	 * NON-BLOCKING
+	 */
 
 	raidPtr = logData->common->raidPtr;
-	/* lock the region for the first item in logData */
+	/* Lock the region for the first item in logData. */
 	RF_ASSERT(logData != NULL);
 	regionID = logData->regionID;
 	RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
 	RF_ASSERT(raidPtr->regionInfo[regionID].loggingEnabled);
 
 	if (clearReintFlag) {
-		/* Enable flushing for this region.  Holding both locks
-		 * provides a synchronization barrier with DumpParityLogToDisk */
+		/*
+		 * Enable flushing for this region. Holding both locks
+		 * provides a synchronization barrier with
+		 * rf_DumpParityLogToDisk.
+		 */
 		RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
 		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-		RF_ASSERT(raidPtr->regionInfo[regionID].reintInProgress == RF_TRUE);
+		RF_ASSERT(raidPtr->regionInfo[regionID].reintInProgress ==
+		    RF_TRUE);
 		raidPtr->regionInfo[regionID].diskCount = 0;
 		raidPtr->regionInfo[regionID].reintInProgress = RF_FALSE;
-		RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);	/* flushing is now
-										 * enabled */
+		/* Flushing is now enabled. */
+		RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	}
-	/* process each item in logData */
+	/* Process each item in logData. */
 	while (logData) {
-		/* remove an item from logData */
+		/* Remove an item from logData. */
 		item = logData;
 		logData = logData->next;
 		item->next = NULL;
 		item->prev = NULL;
 
 		if (rf_parityLogDebug)
-			printf("[appending parity log data, region %d, raidAddress %d, numSector %d]\n", item->regionID, (int) item->diskAddress.raidAddress, (int) item->diskAddress.numSector);
+			printf("[appending parity log data, region %d,"
+			    " raidAddress %d, numSector %d]\n", item->regionID,
+			    (int) item->diskAddress.raidAddress,
+			    (int) item->diskAddress.numSector);
 
-		/* see if we moved to a new region */
+		/* See if we moved to a new region. */
 		if (regionID != item->regionID) {
 			RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
 			regionID = item->regionID;
 			RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
 			RF_ASSERT(raidPtr->regionInfo[regionID].loggingEnabled);
 		}
-		punt = RF_FALSE;/* Set to RF_TRUE if work is blocked.  This
+		punt = RF_FALSE;/*
+				 * Set to RF_TRUE if work is blocked. This
 				 * can happen in one of two ways: 1) no core
-				 * log (AcquireParityLog) 2) waiting on
-				 * reintegration (DumpParityLogToDisk) If punt
-				 * is RF_TRUE, the dataItem was queued, so
-				 * skip to next item. */
-
-		/* process item, one sector at a time, until all sectors
-		 * processed or we punt */
+				 * log (rf_AcquireParityLog) 2) waiting on
+				 * reintegration (rf_DumpParityLogToDisk).
+				 * If punt is RF_TRUE, the dataItem was queued,
+				 * so skip to next item.
+				 */
+
+		/*
+		 * Process item, one sector at a time, until all sectors
+		 * processed or we punt.
+		 */
 		if (item->diskAddress.numSector > 0)
 			done = RF_FALSE;
 		else
 			RF_ASSERT(0);
 		while (!punt && !done) {
-			/* verify that a core log exists for this region */
+			/* Verify that a core log exists for this region. */
 			if (!raidPtr->regionInfo[regionID].coreLog) {
-				/* Attempt to acquire a parity log. If
+				/*
+				 * Attempt to acquire a parity log. If
 				 * acquisition fails, queue remaining work in
-				 * data item and move to nextItem. */
+				 * data item and move to nextItem.
+				 */
 				if (incomingLog) {
 					if (*incomingLog) {
-						RF_ASSERT((*incomingLog)->next == NULL);
-						raidPtr->regionInfo[regionID].coreLog = *incomingLog;
-						raidPtr->regionInfo[regionID].coreLog->regionID = regionID;
+						RF_ASSERT((*incomingLog)->next
+						    == NULL);
+						raidPtr->regionInfo[regionID]
+						    .coreLog = *incomingLog;
+						raidPtr->regionInfo[regionID]
+						    .coreLog->regionID =
+						     regionID;
 						*incomingLog = NULL;
 					} else
-						raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
+						raidPtr->regionInfo[regionID]
+						    .coreLog =
+						     rf_AcquireParityLog(item,
+						      finish);
 				} else
-					raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
-				/* Note: AcquireParityLog either returns a log
-				 * or enqueues currentItem */
+					raidPtr->regionInfo[regionID].coreLog =
+					    rf_AcquireParityLog(item, finish);
+				/*
+				 * Note: rf_AcquireParityLog either returns
+				 * a log or enqueues currentItem.
+				 */
 			}
 			if (!raidPtr->regionInfo[regionID].coreLog)
-				punt = RF_TRUE;	/* failed to find a core log */
+				punt = RF_TRUE;	/* Failed to find a core log. */
 			else {
-				RF_ASSERT(raidPtr->regionInfo[regionID].coreLog->next == NULL);
-				/* verify that the log has room for new
-				 * entries */
-				/* if log is full, dump it to disk and grab a
-				 * new log */
-				if (raidPtr->regionInfo[regionID].coreLog->numRecords == raidPtr->numSectorsPerLog) {
-					/* log is full, dump it to disk */
-					if (DumpParityLogToDisk(finish, item))
-						punt = RF_TRUE;	/* dump unsuccessful,
-								 * blocked on
-								 * reintegration */
+				RF_ASSERT(raidPtr->regionInfo[regionID].coreLog
+				    ->next == NULL);
+				/*
+				 * Verify that the log has room for new
+				 * entries.
+				 */
+				/*
+				 * If log is full, dump it to disk and grab a
+				 * new log.
+				 */
+				if (raidPtr->regionInfo[regionID].coreLog
+				    ->numRecords == raidPtr->numSectorsPerLog)
+				{
+					/* Log is full, dump it to disk. */
+					if (rf_DumpParityLogToDisk(finish,
+					    item))
+						/*
+						 * Dump unsuccessful, blocked
+						 * on reintegration.
+						 */
+						punt = RF_TRUE;
 					else {
-						/* dump was successful */
+						/* Dump was successful. */
 					  if (incomingLog) {
 							if (*incomingLog) {
-								RF_ASSERT((*incomingLog)->next == NULL);
-								raidPtr->regionInfo[regionID].coreLog = *incomingLog;
-								raidPtr->regionInfo[regionID].coreLog->regionID = regionID;
-								*incomingLog = NULL;
+								RF_ASSERT(
+							(*incomingLog)->next ==
+								    NULL);
+								raidPtr->
+						regionInfo[regionID].coreLog =
+								   *incomingLog;
+								raidPtr->
+						regionInfo[regionID].coreLog->
+							    regionID = regionID;
+								*incomingLog =
+								    NULL;
 							} else
-								raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
+								raidPtr->
+						regionInfo[regionID].coreLog =
+						 rf_AcquireParityLog(item,
+						     finish);
 						} else
-							raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
-						/* if a core log is not
+							raidPtr->regionInfo
+							    [regionID].coreLog =
+						 rf_AcquireParityLog(item,
+						     finish);
+						/*
+						 * If a core log is not
 						 * available, must queue work
-						 * and return */
-						if (!raidPtr->regionInfo[regionID].coreLog)
-							punt = RF_TRUE;	/* blocked on log
-									 * availability */
+						 * and return.
+						 */
+						if (!raidPtr->regionInfo
+						    [regionID].coreLog)
+							/*
+							 * Blocked on log
+							 * availability.
+							 */
+							punt = RF_TRUE;
 					}
 				}
 			}
-			/* if we didn't punt on this item, attempt to add a
-			 * sector to the core log */
+			/*
+			 * If we didn't punt on this item, attempt to add a
+			 * sector to the core log.
+			 */
 			if (!punt) {
-				RF_ASSERT(raidPtr->regionInfo[regionID].coreLog->next == NULL);
-				/* at this point, we have a core log with
-				 * enough room for a sector */
-				/* copy a sector into the log */
+				RF_ASSERT(raidPtr->regionInfo[regionID].coreLog
+				    ->next == NULL);
+				/*
+				 * At this point, we have a core log with
+				 * enough room for a sector.
+				 */
+				/* Copy a sector into the log. */
 				log = raidPtr->regionInfo[regionID].coreLog;
-				RF_ASSERT(log->numRecords < raidPtr->numSectorsPerLog);
+				RF_ASSERT(log->numRecords <
+				    raidPtr->numSectorsPerLog);
 				logItem = log->numRecords++;
-				log->records[logItem].parityAddr = item->diskAddress;
-				RF_ASSERT(log->records[logItem].parityAddr.startSector >= raidPtr->regionInfo[regionID].parityStartAddr);
-				RF_ASSERT(log->records[logItem].parityAddr.startSector < raidPtr->regionInfo[regionID].parityStartAddr + raidPtr->regionInfo[regionID].numSectorsParity);
+				log->records[logItem].parityAddr =
+				    item->diskAddress;
+				RF_ASSERT(log->records[logItem].parityAddr
+				    .startSector >=
+				    raidPtr->regionInfo[regionID]
+				    .parityStartAddr);
+				RF_ASSERT(log->records[logItem].parityAddr
+				    .startSector <
+				    raidPtr->regionInfo[regionID]
+				    .parityStartAddr +
+				    raidPtr->regionInfo[regionID]
+				    .numSectorsParity);
 				log->records[logItem].parityAddr.numSector = 1;
-				log->records[logItem].operation = item->common->operation;
-				bcopy((item->common->bufPtr + (item->bufOffset++ * (1 << item->common->raidPtr->logBytesPerSector))), log->bufPtr + (logItem * (1 << item->common->raidPtr->logBytesPerSector)), (1 << item->common->raidPtr->logBytesPerSector));
+				log->records[logItem].operation =
+				    item->common->operation;
+				bcopy((item->common->bufPtr +
+				    (item->bufOffset++ * (1 <<
+				    item->common->raidPtr->logBytesPerSector))),
+				    log->bufPtr + (logItem * (1 <<
+				    item->common->raidPtr->logBytesPerSector)),
+				    (1 << item->common->raidPtr
+				     ->logBytesPerSector));
 				item->diskAddress.numSector--;
 				item->diskAddress.startSector++;
 				if (item->diskAddress.numSector == 0)
@@ -816,8 +975,10 @@ rf_ParityLogAppend(
 		}
 
 		if (!punt) {
-			/* Processed this item completely, decrement count of
-			 * items to be processed. */
+			/*
+			 * Processed this item completely, decrement count of
+			 * items to be processed.
+			 */
 			RF_ASSERT(item->diskAddress.numSector == 0);
 			RF_LOCK_MUTEX(item->common->mutex);
 			item->common->cnt--;
@@ -827,23 +988,27 @@ rf_ParityLogAppend(
 				itemDone = RF_FALSE;
 			RF_UNLOCK_MUTEX(item->common->mutex);
 			if (itemDone) {
-				/* Finished processing all log data for this
+				/*
+				 * Finished processing all log data for this
 				 * IO Return structs to free list and invoke
-				 * wakeup function. */
-				timer = item->common->startTime;	/* grab initial value of
-									 * timer */
+				 * wakeup function.
+				 */
+				/* Grab initial value of timer. */
+				timer = item->common->startTime;
 				RF_ETIMER_STOP(timer);
 				RF_ETIMER_EVAL(timer);
-				item->common->tracerec->plog_us += RF_ETIMER_VAL_US(timer);
+				item->common->tracerec->plog_us +=
+				    RF_ETIMER_VAL_US(timer);
 				if (rf_parityLogDebug)
-					printf("[waking process for region %d]\n", item->regionID);
+					printf("[waking process for region"
+					    " %d]\n", item->regionID);
 				wakeFunc = item->common->wakeFunc;
 				wakeArg = item->common->wakeArg;
-				FreeParityLogCommonData(item->common);
-				FreeParityLogData(item);
+				rf_FreeParityLogCommonData(item->common);
+				rf_FreeParityLogData(item);
 				(wakeFunc) (wakeArg, 0);
 			} else
-				FreeParityLogData(item);
+				rf_FreeParityLogData(item);
 		}
 	}
 	RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
@@ -853,10 +1018,10 @@ rf_ParityLogAppend(
 }
 
 
-void 
-rf_EnableParityLogging(RF_Raid_t * raidPtr)
+void
+rf_EnableParityLogging(RF_Raid_t *raidPtr)
 {
-	int     regionID;
+	int regionID;
 
 	for (regionID = 0; regionID < rf_numParityRegions; regionID++) {
 		RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
@@ -866,4 +1031,4 @@ rf_EnableParityLogging(RF_Raid_t * raidPtr)
 	if (rf_parityLogDebug)
 		printf("[parity logging enabled]\n");
 }
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_paritylog.h b/sys/dev/raidframe/rf_paritylog.h
index 43c5711c666..f50bfa0b0d6 100644
--- a/sys/dev/raidframe/rf_paritylog.h
+++ b/sys/dev/raidframe/rf_paritylog.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_paritylog.h,v 1.2 1999/02/16 00:03:05 niklas Exp $	*/
+/*	$OpenBSD: rf_paritylog.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_paritylog.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,16 +28,16 @@
  * rights to redistribute these changes.
  */
 
-/* header file for parity log
- *
+/*
+ * Header file for parity log.
  */
 
-#ifndef _RF__RF_PARITYLOG_H_
-#define _RF__RF_PARITYLOG_H_
+#ifndef	_RF__RF_PARITYLOG_H_
+#define	_RF__RF_PARITYLOG_H_
 
 #include "rf_types.h"
 
-#define RF_DEFAULT_NUM_SECTORS_PER_LOG 64
+#define	RF_DEFAULT_NUM_SECTORS_PER_LOG		64
 
 typedef int RF_RegionId_t;
 
@@ -44,138 +45,187 @@ typedef enum RF_ParityRecordType_e {
 	RF_STOP,
 	RF_UPDATE,
 	RF_OVERWRITE
-}       RF_ParityRecordType_t;
+} RF_ParityRecordType_t;
 
 struct RF_CommonLogData_s {
-	RF_DECLARE_MUTEX(mutex)	/* protects cnt */
-	int     cnt;		/* when 0, time to call wakeFunc */
-	RF_Raid_t *raidPtr;
-/*   int                    (*wakeFunc)(struct buf *); */
-	int     (*wakeFunc) (RF_DagNode_t * node, int status);
-	void   *wakeArg;
-	RF_AccTraceEntry_t *tracerec;
-	RF_Etimer_t startTime;
-	caddr_t bufPtr;
-	RF_ParityRecordType_t operation;
-	RF_CommonLogData_t *next;
+	RF_DECLARE_MUTEX(mutex);	/* Protects cnt. */
+	int			  cnt;	/* When 0, time to call wakeFunc. */
+	RF_Raid_t		 *raidPtr;
+/*	int			(*wakeFunc) (struct buf *); */
+	int			(*wakeFunc) (RF_DagNode_t *, int);
+	void			 *wakeArg;
+	RF_AccTraceEntry_t	 *tracerec;
+	RF_Etimer_t		  startTime;
+	caddr_t			  bufPtr;
+	RF_ParityRecordType_t	  operation;
+	RF_CommonLogData_t	 *next;
 };
 
 struct RF_ParityLogData_s {
-	RF_RegionId_t regionID;	/* this struct guaranteed to span a single
-				 * region */
-	int     bufOffset;	/* offset from common->bufPtr */
-	RF_PhysDiskAddr_t diskAddress;
-	RF_CommonLogData_t *common;	/* info shared by one or more
-					 * parityLogData structs */
-	RF_ParityLogData_t *next;
-	RF_ParityLogData_t *prev;
+	RF_RegionId_t		 regionID;	/*
+						 * This struct guaranteed to
+						 * span a single region.
+						 */
+	int			 bufOffset;	/*
+						 * Offset from common->bufPtr.
+						 */
+	RF_PhysDiskAddr_t	 diskAddress;
+	RF_CommonLogData_t	*common;	/*
+						 * Info shared by one or more
+						 * parityLogData structs.
+						 */
+	RF_ParityLogData_t	*next;
+	RF_ParityLogData_t	*prev;
 };
 
 struct RF_ParityLogAppendQueue_s {
-	RF_DECLARE_MUTEX(mutex)
+	RF_DECLARE_MUTEX(mutex);
 };
 
 struct RF_ParityLogRecord_s {
-	RF_PhysDiskAddr_t parityAddr;
-	RF_ParityRecordType_t operation;
+	RF_PhysDiskAddr_t	 parityAddr;
+	RF_ParityRecordType_t	 operation;
 };
 
 struct RF_ParityLog_s {
-	RF_RegionId_t regionID;
-	int     numRecords;
-	int     diskOffset;
-	RF_ParityLogRecord_t *records;
-	caddr_t bufPtr;
-	RF_ParityLog_t *next;
+	RF_RegionId_t		 regionID;
+	int			 numRecords;
+	int			 diskOffset;
+	RF_ParityLogRecord_t	*records;
+	caddr_t			 bufPtr;
+	RF_ParityLog_t		*next;
 };
 
 struct RF_ParityLogQueue_s {
-	RF_DECLARE_MUTEX(mutex)
-	RF_ParityLog_t *parityLogs;
+	RF_DECLARE_MUTEX(mutex);
+	RF_ParityLog_t	*parityLogs;
 };
 
 struct RF_RegionBufferQueue_s {
-	RF_DECLARE_MUTEX(mutex)
-	RF_DECLARE_COND(cond)
-	int     bufferSize;
-	int     totalBuffers;	/* size of array 'buffers' */
-	int     availableBuffers;	/* num available 'buffers' */
-	int     emptyBuffersIndex;	/* stick next freed buffer here */
-	int     availBuffersIndex;	/* grab next buffer from here */
-	caddr_t *buffers;	/* array buffers used to hold parity */
+	RF_DECLARE_MUTEX(mutex);
+	RF_DECLARE_COND(cond);
+	int	 bufferSize;
+	int	 totalBuffers;		/* Size of array 'buffers'. */
+	int	 availableBuffers;	/* Num available 'buffers'. */
+	int	 emptyBuffersIndex;	/* Stick next freed buffer here. */
+	int	 availBuffersIndex;	/* Grab next buffer from here. */
+	caddr_t	*buffers;		/* Array buffers used to hold parity. */
 };
-#define RF_PLOG_CREATED   (1<<0)/* thread is created */
-#define RF_PLOG_RUNNING   (1<<1)/* thread is running */
-#define RF_PLOG_TERMINATE (1<<2)/* thread is terminated (should exit) */
-#define RF_PLOG_SHUTDOWN  (1<<3)/* thread is aware and exiting/exited */
+#define	RF_PLOG_CREATED		(1<<0)	/* Thread is created. */
+#define	RF_PLOG_RUNNING		(1<<1)	/* Thread is running. */
+#define	RF_PLOG_TERMINATE	(1<<2)	/* Thread is terminated (should exit).*/
+#define	RF_PLOG_SHUTDOWN	(1<<3)	/* Thread is aware and exiting/exited.*/
 
 struct RF_ParityLogDiskQueue_s {
-	RF_DECLARE_MUTEX(mutex)	/* protects all vars in this struct */
-	RF_DECLARE_COND(cond)
-	int     threadState;	/* is thread running, should it shutdown  (see
-				 * above) */
-	RF_ParityLog_t *flushQueue;	/* list of parity logs to be flushed
-					 * to log disk */
-	RF_ParityLog_t *reintQueue;	/* list of parity logs waiting to be
-					 * reintegrated */
-	RF_ParityLogData_t *bufHead;	/* head of FIFO list of log data,
-					 * waiting on a buffer */
-	RF_ParityLogData_t *bufTail;	/* tail of FIFO list of log data,
-					 * waiting on a buffer */
-	RF_ParityLogData_t *reintHead;	/* head of FIFO list of log data,
-					 * waiting on reintegration */
-	RF_ParityLogData_t *reintTail;	/* tail of FIFO list of log data,
-					 * waiting on reintegration */
-	RF_ParityLogData_t *logBlockHead;	/* queue of work, blocked
-						 * until a log is available */
-	RF_ParityLogData_t *logBlockTail;
-	RF_ParityLogData_t *reintBlockHead;	/* queue of work, blocked
+	RF_DECLARE_MUTEX(mutex);	/* Protects all vars in this struct. */
+	RF_DECLARE_COND(cond);
+	int			 threadState;	/*
+						 * Is thread running, should it
+						 * shutdown ?  (see above)
+						 */
+	RF_ParityLog_t		*flushQueue;	/*
+						 * List of parity logs to be
+						 * flushed to log disk.
+						 */
+	RF_ParityLog_t		*reintQueue;	/*
+						 * List of parity logs waiting
+						 * to be reintegrated.
+						 */
+	RF_ParityLogData_t	*bufHead;	/*
+						 * Head of FIFO list of log
+						 * data, waiting on a buffer.
+						 */
+	RF_ParityLogData_t	*bufTail;	/*
+						 * Tail of FIFO list of log
+						 * data, waiting on a buffer.
+						 */
+	RF_ParityLogData_t	*reintHead;	/*
+						 * Head of FIFO list of
+						 * log data, waiting on
+						 * reintegration.
+						 */
+	RF_ParityLogData_t	*reintTail;	/*
+						 * Tail of FIFO list of
+						 * log data, waiting on
+						 * reintegration.
+						 */
+	RF_ParityLogData_t	*logBlockHead;	/*
+						 * Queue of work, blocked
+						 * until a log is available.
+						 */
+	RF_ParityLogData_t	*logBlockTail;
+	RF_ParityLogData_t	*reintBlockHead;/*
+						 * Queue of work, blocked
 						 * until reintegration is
-						 * complete */
-	RF_ParityLogData_t *reintBlockTail;
-	RF_CommonLogData_t *freeCommonList;	/* list of unused common data
-						 * structs */
-	RF_ParityLogData_t *freeDataList;	/* list of unused log data
-						 * structs */
+						 * complete.
+						 */
+	RF_ParityLogData_t	*reintBlockTail;
+	RF_CommonLogData_t	*freeCommonList;/*
+						 * List of unused common
+						 * data structs.
+						 */
+	RF_ParityLogData_t	*freeDataList;	/*
+						 * List of unused log
+						 * data structs.
+						 */
 };
 
 struct RF_DiskMap_s {
-	RF_PhysDiskAddr_t parityAddr;
-	RF_ParityRecordType_t operation;
+	RF_PhysDiskAddr_t	parityAddr;
+	RF_ParityRecordType_t	operation;
 };
 
 struct RF_RegionInfo_s {
-	RF_DECLARE_MUTEX(mutex)	/* protects: diskCount, diskMap,
-				 * loggingEnabled, coreLog */
-	RF_DECLARE_MUTEX(reintMutex)	/* protects: reintInProgress */
-	int     reintInProgress;/* flag used to suspend flushing operations */
-	RF_SectorCount_t capacity;	/* capacity of this region in sectors */
-	RF_SectorNum_t regionStartAddr;	/* starting disk address for this
-					 * region */
-	RF_SectorNum_t parityStartAddr;	/* starting disk address for this
-					 * region */
-	RF_SectorCount_t numSectorsParity;	/* number of parity sectors
-						 * protected by this region */
-	RF_SectorCount_t diskCount;	/* num of sectors written to this
-					 * region's disk log */
-	RF_DiskMap_t *diskMap;	/* in-core map of what's in this region's disk
-				 * log */
-	int     loggingEnabled;	/* logging enable for this region */
-	RF_ParityLog_t *coreLog;/* in-core log for this region */
+	RF_DECLARE_MUTEX(mutex);		/*
+						 * Protects: diskCount, diskMap,
+						 * loggingEnabled, coreLog.
+						 */
+	RF_DECLARE_MUTEX(reintMutex);		/* Protects: reintInProgress. */
+	int		 reintInProgress;	/*
+						 * Flag used to suspend flushing
+						 * operations.
+						 */
+	RF_SectorCount_t capacity;		/*
+						 * Capacity of this region
+						 * in sectors.
+						*/
+	RF_SectorNum_t	 regionStartAddr;	/*
+						 * Starting disk address for
+						 * this region.
+						 */
+	RF_SectorNum_t	 parityStartAddr;	/*
+						 * Starting disk address for
+						 * this region.
+						 */
+	RF_SectorCount_t numSectorsParity;	/*
+						 * Number of parity sectors
+						 * protected by this region.
+						 */
+	RF_SectorCount_t diskCount;		/*
+						 * Num of sectors written to
+						 * this region's disk log.
+						 */
+	RF_DiskMap_t	*diskMap;		/*
+						 * In-core map of what's in
+						 * this region's disk log.
+						 */
+	int		 loggingEnabled;	/*
+						 * Logging enable for this
+						 * region.
+						 */
+	RF_ParityLog_t	*coreLog;		/*
+						 * In-core log for this region.
+						 */
 };
 
-RF_ParityLogData_t *
-rf_CreateParityLogData(RF_ParityRecordType_t operation,
-    RF_PhysDiskAddr_t * pda, caddr_t bufPtr, RF_Raid_t * raidPtr,
-    int (*wakeFunc) (RF_DagNode_t * node, int status),
-    void *wakeArg, RF_AccTraceEntry_t * tracerec,
-    RF_Etimer_t startTime);
-	RF_ParityLogData_t *rf_SearchAndDequeueParityLogData(RF_Raid_t * raidPtr,
-            RF_RegionId_t regionID, RF_ParityLogData_t ** head,
-            RF_ParityLogData_t ** tail, int ignoreLocks);
-	void    rf_ReleaseParityLogs(RF_Raid_t * raidPtr, RF_ParityLog_t * firstLog);
-	int     rf_ParityLogAppend(RF_ParityLogData_t * logData, int finish,
-            RF_ParityLog_t ** incomingLog, int clearReintFlag);
-	void    rf_EnableParityLogging(RF_Raid_t * raidPtr);
-
-#endif				/* !_RF__RF_PARITYLOG_H_ */
+RF_ParityLogData_t *rf_CreateParityLogData(RF_ParityRecordType_t,
+	RF_PhysDiskAddr_t *, caddr_t, RF_Raid_t *,
+	int (*) (RF_DagNode_t *, int), void *,
+	RF_AccTraceEntry_t *, RF_Etimer_t);
+RF_ParityLogData_t *rf_SearchAndDequeueParityLogData(RF_Raid_t *, RF_RegionId_t,
+	RF_ParityLogData_t **, RF_ParityLogData_t **, int);
+void rf_ReleaseParityLogs(RF_Raid_t *, RF_ParityLog_t *);
+int  rf_ParityLogAppend(RF_ParityLogData_t *, int, RF_ParityLog_t **, int);
+void rf_EnableParityLogging(RF_Raid_t *);
+
+#endif	/* !_RF__RF_PARITYLOG_H_ */
diff --git a/sys/dev/raidframe/rf_paritylogDiskMgr.c b/sys/dev/raidframe/rf_paritylogDiskMgr.c
index 6914b19e535..65f699d4f5f 100644
--- a/sys/dev/raidframe/rf_paritylogDiskMgr.c
+++ b/sys/dev/raidframe/rf_paritylogDiskMgr.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_paritylogDiskMgr.c,v 1.5 2000/08/08 16:07:43 peter Exp $	*/
+/*	$OpenBSD: rf_paritylogDiskMgr.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_paritylogDiskMgr.c,v 1.10 2000/01/15 01:57:57 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -26,13 +27,13 @@
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
-/* Code for flushing and reintegration operations related to parity logging.
- *
+/*
+ * Code for flushing and reintegrating operations related to parity logging.
  */
 
 #include "rf_archs.h"
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
@@ -54,16 +55,30 @@
 
 #include "rf_paritylogDiskMgr.h"
 
-static caddr_t AcquireReintBuffer(RF_RegionBufferQueue_t *);
-
-static caddr_t 
-AcquireReintBuffer(pool)
-	RF_RegionBufferQueue_t *pool;
+caddr_t rf_AcquireReintBuffer(RF_RegionBufferQueue_t *);
+void rf_ReleaseReintBuffer(RF_RegionBufferQueue_t *, caddr_t);
+void rf_ReadRegionLog(RF_RegionId_t, RF_MCPair_t *, caddr_t, RF_Raid_t *,
+	RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
+void rf_WriteCoreLog(RF_ParityLog_t *, RF_MCPair_t *, RF_Raid_t *,
+	RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
+void rf_ReadRegionParity(RF_RegionId_t, RF_MCPair_t *, caddr_t, RF_Raid_t *,
+	RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
+void rf_WriteRegionParity(RF_RegionId_t, RF_MCPair_t *, caddr_t, RF_Raid_t *,
+	RF_DagHeader_t **, RF_AllocListElem_t **, RF_PhysDiskAddr_t **);
+void rf_FlushLogsToDisk(RF_Raid_t *, RF_ParityLog_t *);
+void rf_ReintegrateRegion(RF_Raid_t *, RF_RegionId_t, RF_ParityLog_t *);
+void rf_ReintegrateLogs(RF_Raid_t *, RF_ParityLog_t *);
+
+
+caddr_t
+rf_AcquireReintBuffer(RF_RegionBufferQueue_t *pool)
 {
 	caddr_t bufPtr = NULL;
 
-	/* Return a region buffer from the free list (pool). If the free list
-	 * is empty, WAIT. BLOCKING */
+	/*
+	 * Return a region buffer from the free list (pool). If the free list
+	 * is empty, WAIT. BLOCKING
+	 */
 
 	RF_LOCK_MUTEX(pool->mutex);
 	if (pool->availableBuffers > 0) {
@@ -74,20 +89,23 @@ AcquireReintBuffer(pool)
 			pool->availBuffersIndex = 0;
 		RF_UNLOCK_MUTEX(pool->mutex);
 	} else {
-		RF_PANIC();	/* should never happen in correct config,
-				 * single reint */
+		RF_PANIC();	/*
+				 * Should never happen in correct config,
+				 * single reint.
+				 */
 		RF_WAIT_COND(pool->cond, pool->mutex);
 	}
 	return (bufPtr);
 }
 
-static void 
-ReleaseReintBuffer(
-    RF_RegionBufferQueue_t * pool,
-    caddr_t bufPtr)
+
+void
+rf_ReleaseReintBuffer(RF_RegionBufferQueue_t *pool, caddr_t bufPtr)
 {
-	/* Insert a region buffer (bufPtr) into the free list (pool).
-	 * NON-BLOCKING */
+	/*
+	 * Insert a region buffer (bufPtr) into the free list (pool).
+	 * NON-BLOCKING
+	 */
 
 	RF_LOCK_MUTEX(pool->mutex);
 	pool->availableBuffers++;
@@ -101,147 +119,133 @@ ReleaseReintBuffer(
 }
 
 
-
-static void 
-ReadRegionLog(
-    RF_RegionId_t regionID,
-    RF_MCPair_t * rrd_mcpair,
-    caddr_t regionBuffer,
-    RF_Raid_t * raidPtr,
-    RF_DagHeader_t ** rrd_dag_h,
-    RF_AllocListElem_t ** rrd_alloclist,
-    RF_PhysDiskAddr_t ** rrd_pda)
+void
+rf_ReadRegionLog(RF_RegionId_t regionID, RF_MCPair_t *rrd_mcpair,
+    caddr_t regionBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **rrd_dag_h,
+    RF_AllocListElem_t **rrd_alloclist, RF_PhysDiskAddr_t **rrd_pda)
 {
-	/* Initiate the read a region log from disk.  Once initiated, return
+	/*
+	 * Initiate the read a region log from disk. Once initiated, return
 	 * to the calling routine.
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * NON-BLOCKING
+	 */
 
 	RF_AccTraceEntry_t *tracerec;
 	RF_DagNode_t *rrd_rdNode;
 
-	/* create DAG to read region log from disk */
+	/* Create DAG to read region log from disk. */
 	rf_MakeAllocList(*rrd_alloclist);
-	*rrd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, regionBuffer, 
-				      rf_DiskReadFunc, rf_DiskReadUndoFunc,
-				      "Rrl", *rrd_alloclist, 
-				      RF_DAG_FLAGS_NONE, 
-				      RF_IO_NORMAL_PRIORITY);
-
-	/* create and initialize PDA for the core log */
-	/* RF_Malloc(*rrd_pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t
-	 * *)); */
+	*rrd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, regionBuffer,
+	    rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rrl", *rrd_alloclist,
+	    RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
+
+	/* Create and initialize PDA for the core log. */
+	/* RF_Malloc(*rrd_pda, sizeof(RF_PhysDiskAddr_t),
+	 * (RF_PhysDiskAddr_t *)); */
 	*rrd_pda = rf_AllocPDAList(1);
-	rf_MapLogParityLogging(raidPtr, regionID, 0, &((*rrd_pda)->row), 
-			       &((*rrd_pda)->col), &((*rrd_pda)->startSector));
+	rf_MapLogParityLogging(raidPtr, regionID, 0, &((*rrd_pda)->row),
+	    &((*rrd_pda)->col), &((*rrd_pda)->startSector));
 	(*rrd_pda)->numSector = raidPtr->regionInfo[regionID].capacity;
 
 	if ((*rrd_pda)->next) {
 		(*rrd_pda)->next = NULL;
 		printf("set rrd_pda->next to NULL\n");
 	}
-	/* initialize DAG parameters */
-	RF_Malloc(tracerec,sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
+	/* Initialize DAG parameters. */
+	RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
 	bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
 	(*rrd_dag_h)->tracerec = tracerec;
 	rrd_rdNode = (*rrd_dag_h)->succedents[0]->succedents[0];
 	rrd_rdNode->params[0].p = *rrd_pda;
-/*  rrd_rdNode->params[1] = regionBuffer; */
+	/* rrd_rdNode->params[1] = regionBuffer; */
 	rrd_rdNode->params[2].v = 0;
-	rrd_rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 
+	rrd_rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
 						   0, 0, 0);
 
-	/* launch region log read dag */
+	/* Launch region log read dag. */
 	rf_DispatchDAG(*rrd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
 	    (void *) rrd_mcpair);
 }
 
 
-
-static void 
-WriteCoreLog(
-    RF_ParityLog_t * log,
-    RF_MCPair_t * fwr_mcpair,
-    RF_Raid_t * raidPtr,
-    RF_DagHeader_t ** fwr_dag_h,
-    RF_AllocListElem_t ** fwr_alloclist,
-    RF_PhysDiskAddr_t ** fwr_pda)
+void
+rf_WriteCoreLog(RF_ParityLog_t *log, RF_MCPair_t *fwr_mcpair,
+    RF_Raid_t *raidPtr, RF_DagHeader_t **fwr_dag_h,
+    RF_AllocListElem_t **fwr_alloclist, RF_PhysDiskAddr_t **fwr_pda)
 {
 	RF_RegionId_t regionID = log->regionID;
 	RF_AccTraceEntry_t *tracerec;
 	RF_SectorNum_t regionOffset;
 	RF_DagNode_t *fwr_wrNode;
 
-	/* Initiate the write of a core log to a region log disk. Once
+	/*
+	 * Initiate the write of a core log to a region log disk. Once
 	 * initiated, return to the calling routine.
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * NON-BLOCKING
+	 */
 
-	/* create DAG to write a core log to a region log disk */
+	/* Create DAG to write a core log to a region log disk. */
 	rf_MakeAllocList(*fwr_alloclist);
-	*fwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, log->bufPtr, 
-				      rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-	    "Wcl", *fwr_alloclist, RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
+	*fwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, log->bufPtr,
+	    rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wcl", *fwr_alloclist,
+	    RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
 
-	/* create and initialize PDA for the region log */
-	/* RF_Malloc(*fwr_pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t
-	 * *)); */
+	/* Create and initialize PDA for the region log. */
+	/* RF_Malloc(*fwr_pda, sizeof(RF_PhysDiskAddr_t),
+	 * (RF_PhysDiskAddr_t *)); */
 	*fwr_pda = rf_AllocPDAList(1);
 	regionOffset = log->diskOffset;
-	rf_MapLogParityLogging(raidPtr, regionID, regionOffset, 
-			       &((*fwr_pda)->row), &((*fwr_pda)->col), 
-			       &((*fwr_pda)->startSector));
+	rf_MapLogParityLogging(raidPtr, regionID, regionOffset,
+	    &((*fwr_pda)->row), &((*fwr_pda)->col), &((*fwr_pda)->startSector));
 	(*fwr_pda)->numSector = raidPtr->numSectorsPerLog;
 
-	/* initialize DAG parameters */
-	RF_Malloc(tracerec,sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
+	/* Initialize DAG parameters. */
+	RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
 	bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
 	(*fwr_dag_h)->tracerec = tracerec;
 	fwr_wrNode = (*fwr_dag_h)->succedents[0]->succedents[0];
 	fwr_wrNode->params[0].p = *fwr_pda;
-/*  fwr_wrNode->params[1] = log->bufPtr; */
+	/* fwr_wrNode->params[1] = log->bufPtr; */
 	fwr_wrNode->params[2].v = 0;
-	fwr_wrNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 
-						   0, 0, 0);
+	fwr_wrNode->params[3].v =
+	    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
 
-	/* launch the dag to write the core log to disk */
+	/* Launch the dag to write the core log to disk. */
 	rf_DispatchDAG(*fwr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
 	    (void *) fwr_mcpair);
 }
 
 
-static void 
-ReadRegionParity(
-    RF_RegionId_t regionID,
-    RF_MCPair_t * prd_mcpair,
-    caddr_t parityBuffer,
-    RF_Raid_t * raidPtr,
-    RF_DagHeader_t ** prd_dag_h,
-    RF_AllocListElem_t ** prd_alloclist,
-    RF_PhysDiskAddr_t ** prd_pda)
+void
+rf_ReadRegionParity(RF_RegionId_t regionID, RF_MCPair_t *prd_mcpair,
+    caddr_t parityBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **prd_dag_h,
+    RF_AllocListElem_t **prd_alloclist, RF_PhysDiskAddr_t **prd_pda)
 {
-	/* Initiate the read region parity from disk. Once initiated, return
+	/*
+	 * Initiate the read region parity from disk. Once initiated, return
 	 * to the calling routine.
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * NON-BLOCKING
+	 */
 
 	RF_AccTraceEntry_t *tracerec;
 	RF_DagNode_t *prd_rdNode;
 
-	/* create DAG to read region parity from disk */
+	/* Create DAG to read region parity from disk. */
 	rf_MakeAllocList(*prd_alloclist);
-	*prd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, NULL, rf_DiskReadFunc, 
-				      rf_DiskReadUndoFunc, "Rrp", 
-				      *prd_alloclist, RF_DAG_FLAGS_NONE, 
-				      RF_IO_NORMAL_PRIORITY);
-
-	/* create and initialize PDA for region parity */
-	/* RF_Malloc(*prd_pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t
-	 * *)); */
+	*prd_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, NULL, rf_DiskReadFunc,
+	    rf_DiskReadUndoFunc, "Rrp", *prd_alloclist, RF_DAG_FLAGS_NONE,
+	    RF_IO_NORMAL_PRIORITY);
+
+	/* Create and initialize PDA for region parity. */
+	/* RF_Malloc(*prd_pda, sizeof(RF_PhysDiskAddr_t),
+	 * (RF_PhysDiskAddr_t *)); */
 	*prd_pda = rf_AllocPDAList(1);
-	rf_MapRegionParity(raidPtr, regionID, &((*prd_pda)->row), 
-			   &((*prd_pda)->col), &((*prd_pda)->startSector), 
-			   &((*prd_pda)->numSector));
+	rf_MapRegionParity(raidPtr, regionID, &((*prd_pda)->row),
+	    &((*prd_pda)->col), &((*prd_pda)->startSector),
+	    &((*prd_pda)->numSector));
 	if (rf_parityLogDebug)
 		printf("[reading %d sectors of parity from region %d]\n",
 		    (int) (*prd_pda)->numSector, regionID);
@@ -249,86 +253,82 @@ ReadRegionParity(
 		(*prd_pda)->next = NULL;
 		printf("set prd_pda->next to NULL\n");
 	}
-	/* initialize DAG parameters */
-	RF_Malloc(tracerec,sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
+	/* Initialize DAG parameters. */
+	RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
 	bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
 	(*prd_dag_h)->tracerec = tracerec;
 	prd_rdNode = (*prd_dag_h)->succedents[0]->succedents[0];
 	prd_rdNode->params[0].p = *prd_pda;
 	prd_rdNode->params[1].p = parityBuffer;
 	prd_rdNode->params[2].v = 0;
-	prd_rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 
-						   0, 0, 0);
+	prd_rdNode->params[3].v =
+	    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
 	if (rf_validateDAGDebug)
 		rf_ValidateDAG(*prd_dag_h);
-	/* launch region parity read dag */
+	/* Launch region parity read dag. */
 	rf_DispatchDAG(*prd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
 	    (void *) prd_mcpair);
 }
 
-static void 
-WriteRegionParity(
-    RF_RegionId_t regionID,
-    RF_MCPair_t * pwr_mcpair,
-    caddr_t parityBuffer,
-    RF_Raid_t * raidPtr,
-    RF_DagHeader_t ** pwr_dag_h,
-    RF_AllocListElem_t ** pwr_alloclist,
-    RF_PhysDiskAddr_t ** pwr_pda)
+void
+rf_WriteRegionParity(RF_RegionId_t regionID, RF_MCPair_t *pwr_mcpair,
+    caddr_t parityBuffer, RF_Raid_t *raidPtr, RF_DagHeader_t **pwr_dag_h,
+    RF_AllocListElem_t **pwr_alloclist, RF_PhysDiskAddr_t **pwr_pda)
 {
-	/* Initiate the write of region parity to disk. Once initiated, return
+	/*
+	 * Initiate the write of region parity to disk. Once initiated, return
 	 * to the calling routine.
-	 * 
-	 * NON-BLOCKING */
+	 *
+	 * NON-BLOCKING
+	 */
 
 	RF_AccTraceEntry_t *tracerec;
 	RF_DagNode_t *pwr_wrNode;
 
-	/* create DAG to write region log from disk */
+	/* Create DAG to write region log from disk. */
 	rf_MakeAllocList(*pwr_alloclist);
-	*pwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, parityBuffer, 
-				      rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
-				      "Wrp", *pwr_alloclist, 
-				      RF_DAG_FLAGS_NONE, 
-				      RF_IO_NORMAL_PRIORITY);
-
-	/* create and initialize PDA for region parity */
-	/* RF_Malloc(*pwr_pda, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t
-	 * *)); */
+	*pwr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, 0, parityBuffer,
+	    rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wrp", *pwr_alloclist,
+	    RF_DAG_FLAGS_NONE, RF_IO_NORMAL_PRIORITY);
+
+	/* Create and initialize PDA for region parity. */
+	/* RF_Malloc(*pwr_pda, sizeof(RF_PhysDiskAddr_t),
+	 * (RF_PhysDiskAddr_t *)); */
 	*pwr_pda = rf_AllocPDAList(1);
-	rf_MapRegionParity(raidPtr, regionID, &((*pwr_pda)->row), 
-			   &((*pwr_pda)->col), &((*pwr_pda)->startSector), 
-			   &((*pwr_pda)->numSector));
+	rf_MapRegionParity(raidPtr, regionID, &((*pwr_pda)->row),
+	    &((*pwr_pda)->col), &((*pwr_pda)->startSector),
+	    &((*pwr_pda)->numSector));
 
-	/* initialize DAG parameters */
-	RF_Malloc(tracerec,sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
+	/* Initialize DAG parameters. */
+	RF_Malloc(tracerec, sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
 	bzero((char *) tracerec, sizeof(RF_AccTraceEntry_t));
 	(*pwr_dag_h)->tracerec = tracerec;
 	pwr_wrNode = (*pwr_dag_h)->succedents[0]->succedents[0];
 	pwr_wrNode->params[0].p = *pwr_pda;
-/*  pwr_wrNode->params[1] = parityBuffer; */
+	/* pwr_wrNode->params[1] = parityBuffer; */
 	pwr_wrNode->params[2].v = 0;
-	pwr_wrNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 
-						   0, 0, 0);
+	pwr_wrNode->params[3].v =
+	    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, 0);
 
-	/* launch the dag to write region parity to disk */
+	/* Launch the dag to write region parity to disk. */
 	rf_DispatchDAG(*pwr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
 	    (void *) pwr_mcpair);
 }
 
-static void 
-FlushLogsToDisk(
-    RF_Raid_t * raidPtr,
-    RF_ParityLog_t * logList)
+void
+rf_FlushLogsToDisk(RF_Raid_t *raidPtr, RF_ParityLog_t *logList)
 {
-	/* Flush a linked list of core logs to the log disk. Logs contain the
-	 * disk location where they should be written.  Logs were written in
+	/*
+	 * Flush a linked list of core logs to the log disk. Logs contain the
+	 * disk location where they should be written. Logs were written in
 	 * FIFO order and that order must be preserved.
-	 * 
-	 * Recommended optimizations: 1) allow multiple flushes to occur
-	 * simultaneously 2) coalesce contiguous flush operations
-	 * 
-	 * BLOCKING */
+	 *
+	 * Recommended optimizations:
+	 * 1) Allow multiple flushes to occur simultaneously.
+	 * 2) Coalesce contiguous flush operations.
+	 *
+	 * BLOCKING
+	 */
 
 	RF_ParityLog_t *log;
 	RF_RegionId_t regionID;
@@ -345,18 +345,20 @@ FlushLogsToDisk(
 	while (log) {
 		regionID = log->regionID;
 
-		/* create and launch a DAG to write the core log */
+		/* Create and launch a DAG to write the core log. */
 		if (rf_parityLogDebug)
-			printf("[initiating write of core log for region %d]\n", regionID);
+			printf("[initiating write of core log for region"
+			    " %d]\n", regionID);
 		fwr_mcpair->flag = RF_FALSE;
-		WriteCoreLog(log, fwr_mcpair, raidPtr, &fwr_dag_h, 
-			     &fwr_alloclist, &fwr_pda);
+		rf_WriteCoreLog(log, fwr_mcpair, raidPtr, &fwr_dag_h,
+		    &fwr_alloclist, &fwr_pda);
 
-		/* wait for the DAG to complete */
+		/* Wait for the DAG to complete. */
 		while (!fwr_mcpair->flag)
 			RF_WAIT_COND(fwr_mcpair->cond, fwr_mcpair->mutex);
 		if (fwr_dag_h->status != rf_enable) {
-			RF_ERRORMSG1("Unable to write core log to disk (region %d)\n", regionID);
+			RF_ERRORMSG1("Unable to write core log to disk"
+			    " (region %d)\n", regionID);
 			RF_ASSERT(0);
 		}
 		/* RF_Free(fwr_pda, sizeof(RF_PhysDiskAddr_t)); */
@@ -371,11 +373,9 @@ FlushLogsToDisk(
 	rf_ReleaseParityLogs(raidPtr, logList);
 }
 
-static void 
-ReintegrateRegion(
-    RF_Raid_t * raidPtr,
-    RF_RegionId_t regionID,
-    RF_ParityLog_t * coreLog)
+void
+rf_ReintegrateRegion(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
+    RF_ParityLog_t *coreLog)
 {
 	RF_MCPair_t *rrd_mcpair = NULL, *prd_mcpair, *pwr_mcpair;
 	RF_DagHeader_t *rrd_dag_h, *prd_dag_h, *pwr_dag_h;
@@ -383,101 +383,104 @@ ReintegrateRegion(
 	RF_PhysDiskAddr_t *rrd_pda, *prd_pda, *pwr_pda;
 	caddr_t parityBuffer, regionBuffer = NULL;
 
-	/* Reintegrate a region (regionID). 
+	/*
+	 * Reintegrate a region (regionID).
 	 *
-	 * 1. acquire region and parity buffers 
-	 * 2. read log from disk 
-	 * 3. read parity from disk 
-	 * 4. apply log to parity 
-	 * 5. apply core log to parity 
-	 * 6. write new parity to disk
-	 * 
-	 * BLOCKING */
+	 * 1. Acquire region and parity buffers.
+	 * 2. Read log from disk.
+	 * 3. Read parity from disk.
+	 * 4. Apply log to parity.
+	 * 5. Apply core log to parity.
+	 * 6. Write new parity to disk.
+	 *
+	 * BLOCKING
+	 */
 
 	if (rf_parityLogDebug)
 		printf("[reintegrating region %d]\n", regionID);
 
-	/* initiate read of region parity */
+	/* Initiate read of region parity. */
 	if (rf_parityLogDebug)
-		printf("[initiating read of parity for region %d]\n",regionID);
-	parityBuffer = AcquireReintBuffer(&raidPtr->parityBufferPool);
+		printf("[initiating read of parity for region %d]\n", regionID);
+	parityBuffer = rf_AcquireReintBuffer(&raidPtr->parityBufferPool);
 	prd_mcpair = rf_AllocMCPair();
 	RF_LOCK_MUTEX(prd_mcpair->mutex);
 	prd_mcpair->flag = RF_FALSE;
-	ReadRegionParity(regionID, prd_mcpair, parityBuffer, raidPtr, 
+	rf_ReadRegionParity(regionID, prd_mcpair, parityBuffer, raidPtr,
 			 &prd_dag_h, &prd_alloclist, &prd_pda);
 
-	/* if region log nonempty, initiate read */
+	/* If region log nonempty, initiate read. */
 	if (raidPtr->regionInfo[regionID].diskCount > 0) {
 		if (rf_parityLogDebug)
 			printf("[initiating read of disk log for region %d]\n",
-			       regionID);
-		regionBuffer = AcquireReintBuffer(&raidPtr->regionBufferPool);
+			    regionID);
+		regionBuffer =
+		    rf_AcquireReintBuffer(&raidPtr->regionBufferPool);
 		rrd_mcpair = rf_AllocMCPair();
 		RF_LOCK_MUTEX(rrd_mcpair->mutex);
 		rrd_mcpair->flag = RF_FALSE;
-		ReadRegionLog(regionID, rrd_mcpair, regionBuffer, raidPtr, 
-			      &rrd_dag_h, &rrd_alloclist, &rrd_pda);
+		rf_ReadRegionLog(regionID, rrd_mcpair, regionBuffer, raidPtr,
+		    &rrd_dag_h, &rrd_alloclist, &rrd_pda);
 	}
-	/* wait on read of region parity to complete */
+	/* Wait on read of region parity to complete. */
 	while (!prd_mcpair->flag) {
 		RF_WAIT_COND(prd_mcpair->cond, prd_mcpair->mutex);
 	}
 	RF_UNLOCK_MUTEX(prd_mcpair->mutex);
 	if (prd_dag_h->status != rf_enable) {
 		RF_ERRORMSG("Unable to read parity from disk\n");
-		/* add code to fail the parity disk */
+		/* Add code to fail the parity disk. */
 		RF_ASSERT(0);
 	}
-	/* apply core log to parity */
+	/* Apply core log to parity. */
 	/* if (coreLog) ApplyLogsToParity(coreLog, parityBuffer); */
 
 	if (raidPtr->regionInfo[regionID].diskCount > 0) {
-		/* wait on read of region log to complete */
+		/* Wait on read of region log to complete. */
 		while (!rrd_mcpair->flag)
 			RF_WAIT_COND(rrd_mcpair->cond, rrd_mcpair->mutex);
 		RF_UNLOCK_MUTEX(rrd_mcpair->mutex);
 		if (rrd_dag_h->status != rf_enable) {
 			RF_ERRORMSG("Unable to read region log from disk\n");
-			/* add code to fail the log disk */
+			/* Add code to fail the log disk. */
 			RF_ASSERT(0);
 		}
-		/* apply region log to parity */
+		/* Apply region log to parity. */
 		/* ApplyRegionToParity(regionID, regionBuffer, parityBuffer); */
-		/* release resources associated with region log */
+		/* Release resources associated with region log. */
 		/* RF_Free(rrd_pda, sizeof(RF_PhysDiskAddr_t)); */
 		rf_FreePhysDiskAddr(rrd_pda);
 		rf_FreeDAG(rrd_dag_h);
 		rf_FreeAllocList(rrd_alloclist);
 		rf_FreeMCPair(rrd_mcpair);
-		ReleaseReintBuffer(&raidPtr->regionBufferPool, regionBuffer);
+		rf_ReleaseReintBuffer(&raidPtr->regionBufferPool, regionBuffer);
 	}
-	/* write reintegrated parity to disk */
+	/* Write reintegrated parity to disk. */
 	if (rf_parityLogDebug)
 		printf("[initiating write of parity for region %d]\n",
-		       regionID);
+		    regionID);
 	pwr_mcpair = rf_AllocMCPair();
 	RF_LOCK_MUTEX(pwr_mcpair->mutex);
 	pwr_mcpair->flag = RF_FALSE;
-	WriteRegionParity(regionID, pwr_mcpair, parityBuffer, raidPtr, 
-			  &pwr_dag_h, &pwr_alloclist, &pwr_pda);
+	rf_WriteRegionParity(regionID, pwr_mcpair, parityBuffer, raidPtr,
+	    &pwr_dag_h, &pwr_alloclist, &pwr_pda);
 	while (!pwr_mcpair->flag)
 		RF_WAIT_COND(pwr_mcpair->cond, pwr_mcpair->mutex);
 	RF_UNLOCK_MUTEX(pwr_mcpair->mutex);
 	if (pwr_dag_h->status != rf_enable) {
 		RF_ERRORMSG("Unable to write parity to disk\n");
-		/* add code to fail the parity disk */
+		/* Add code to fail the parity disk. */
 		RF_ASSERT(0);
 	}
-	/* release resources associated with read of old parity */
+	/* Release resources associated with read of old parity. */
 	/* RF_Free(prd_pda, sizeof(RF_PhysDiskAddr_t)); */
 	rf_FreePhysDiskAddr(prd_pda);
 	rf_FreeDAG(prd_dag_h);
 	rf_FreeAllocList(prd_alloclist);
 	rf_FreeMCPair(prd_mcpair);
 
-	/* release resources associated with write of new parity */
-	ReleaseReintBuffer(&raidPtr->parityBufferPool, parityBuffer);
+	/* Release resources associated with write of new parity. */
+	rf_ReleaseReintBuffer(&raidPtr->parityBufferPool, parityBuffer);
 	/* RF_Free(pwr_pda, sizeof(RF_PhysDiskAddr_t)); */
 	rf_FreePhysDiskAddr(pwr_pda);
 	rf_FreeDAG(pwr_dag_h);
@@ -489,11 +492,8 @@ ReintegrateRegion(
 }
 
 
-
-static void 
-ReintegrateLogs(
-    RF_Raid_t * raidPtr,
-    RF_ParityLog_t * logList)
+void
+rf_ReintegrateLogs(RF_Raid_t *raidPtr, RF_ParityLog_t *logList)
 {
 	RF_ParityLog_t *log, *freeLogList = NULL;
 	RF_ParityLogData_t *logData, *logDataList;
@@ -505,47 +505,55 @@ ReintegrateLogs(
 		logList = logList->next;
 		log->next = NULL;
 		regionID = log->regionID;
-		ReintegrateRegion(raidPtr, regionID, log);
+		rf_ReintegrateRegion(raidPtr, regionID, log);
 		log->numRecords = 0;
 
-		/* remove all items which are blocked on reintegration of this
-		 * region */
+		/*
+		 * Remove all items which are blocked on reintegration of this
+		 * region.
+		 */
 		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-		logData = rf_SearchAndDequeueParityLogData(raidPtr, regionID, 
-			   &raidPtr->parityLogDiskQueue.reintBlockHead, 
-			   &raidPtr->parityLogDiskQueue.reintBlockTail, 
-							   RF_TRUE);
+		logData = rf_SearchAndDequeueParityLogData(raidPtr, regionID,
+		    &raidPtr->parityLogDiskQueue.reintBlockHead,
+		    &raidPtr->parityLogDiskQueue.reintBlockTail, RF_TRUE);
 		logDataList = logData;
 		while (logData) {
-			logData->next = rf_SearchAndDequeueParityLogData(
-					 raidPtr, regionID, 
-					 &raidPtr->parityLogDiskQueue.reintBlockHead, 
-					 &raidPtr->parityLogDiskQueue.reintBlockTail, 
-					 RF_TRUE);
+			logData->next =
+			    rf_SearchAndDequeueParityLogData(raidPtr, regionID,
+			     &raidPtr->parityLogDiskQueue.reintBlockHead,
+			     &raidPtr->parityLogDiskQueue.reintBlockTail,
+			     RF_TRUE);
 			logData = logData->next;
 		}
 		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 
-		/* process blocked log data and clear reintInProgress flag for
-		 * this region */
+		/*
+		 * Process blocked log data and clear reintInProgress flag for
+		 * this region.
+		 */
 		if (logDataList)
 			rf_ParityLogAppend(logDataList, RF_TRUE, &log, RF_TRUE);
 		else {
-			/* Enable flushing for this region.  Holding both
+			/*
+			 * Enable flushing for this region. Holding both
 			 * locks provides a synchronization barrier with
-			 * DumpParityLogToDisk */
+			 * DumpParityLogToDisk.
+			 */
 			RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
 			RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
 			RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 			raidPtr->regionInfo[regionID].diskCount = 0;
-			raidPtr->regionInfo[regionID].reintInProgress = RF_FALSE;
+			raidPtr->regionInfo[regionID].reintInProgress =
+			    RF_FALSE;
 			RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-			RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);	/* flushing is now
-											 * enabled */
+			RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID]
+			    .reintMutex);	/* Flushing is now enabled. */
 			RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 		}
-		/* if log wasn't used, attach it to the list of logs to be
-		 * returned */
+		/*
+		 * If log wasn't used, attach it to the list of logs to be
+		 * returned.
+		 */
 		if (log) {
 			log->next = freeLogList;
 			freeLogList = log;
@@ -555,11 +563,14 @@ ReintegrateLogs(
 		rf_ReleaseParityLogs(raidPtr, freeLogList);
 }
 
-int 
-rf_ShutdownLogging(RF_Raid_t * raidPtr)
+int
+rf_ShutdownLogging(RF_Raid_t *raidPtr)
 {
-	/* shutdown parity logging 1) disable parity logging in all regions 2)
-	 * reintegrate all regions */
+	/*
+	 * Shutdown parity logging:
+	 * 1) Disable parity logging in all regions.
+	 * 2) Reintegrate all regions.
+	 */
 
 	RF_SectorCount_t diskCount;
 	RF_RegionId_t regionID;
@@ -567,57 +578,60 @@ rf_ShutdownLogging(RF_Raid_t * raidPtr)
 
 	if (rf_parityLogDebug)
 		printf("[shutting down parity logging]\n");
-	/* Since parity log maps are volatile, we must reintegrate all
-	 * regions. */
+	/*
+	 * Since parity log maps are volatile, we must reintegrate all
+	 * regions.
+	 */
 	if (rf_forceParityLogReint) {
 		for (regionID = 0; regionID < rf_numParityRegions; regionID++) {
 			RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-			raidPtr->regionInfo[regionID].loggingEnabled = 
-				RF_FALSE;
+			raidPtr->regionInfo[regionID].loggingEnabled = RF_FALSE;
 			log = raidPtr->regionInfo[regionID].coreLog;
 			raidPtr->regionInfo[regionID].coreLog = NULL;
 			diskCount = raidPtr->regionInfo[regionID].diskCount;
 			RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
 			if (diskCount > 0 || log != NULL)
-				ReintegrateRegion(raidPtr, regionID, log);
+				rf_ReintegrateRegion(raidPtr, regionID, log);
 			if (log != NULL)
 				rf_ReleaseParityLogs(raidPtr, log);
 		}
 	}
 	if (rf_parityLogDebug) {
 		printf("[parity logging disabled]\n");
-		printf("[should be done!]\n");
+		printf("[should be done !]\n");
 	}
 	return (0);
 }
 
-int 
-rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr)
+int
+rf_ParityLoggingDiskManager(RF_Raid_t *raidPtr)
 {
 	RF_ParityLog_t *reintQueue, *flushQueue;
-	int     workNeeded, done = RF_FALSE;
+	int workNeeded, done = RF_FALSE;
 	int s;
 
-	/* Main program for parity logging disk thread.  This routine waits
+	/*
+	 * Main program for parity logging disk thread. This routine waits
 	 * for work to appear in either the flush or reintegration queues and
 	 * is responsible for flushing core logs to the log disk as well as
 	 * reintegrating parity regions.
-	 * 
-	 * BLOCKING */
+	 *
+	 * BLOCKING
+	 */
 
 	s = splbio();
 
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 
 	/*
-         * Inform our creator that we're running. Don't bother doing the
-         * mutex lock/unlock dance- we locked above, and we'll unlock
-         * below with nothing to do, yet.
-         */
+	 * Inform our creator that we're running. Don't bother doing the
+	 * mutex lock/unlock dance: we locked above, and we'll unlock
+	 * below with nothing to do, yet.
+	 */
 	raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_RUNNING;
 	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
 
-	/* empty the work queues */
+	/* Empty the work queues. */
 	flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
 	raidPtr->parityLogDiskQueue.flushQueue = NULL;
 	reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
@@ -626,30 +640,36 @@ rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr)
 
 	while (!done) {
 		while (workNeeded) {
-			/* First, flush all logs in the flush queue, freeing
-			 * buffers Second, reintegrate all regions which are
+			/*
+			 * First, flush all logs in the flush queue, freeing
+			 * buffers. Second, reintegrate all regions that are
 			 * reported as full. Third, append queued log data
 			 * until blocked.
-			 * 
-			 * Note: Incoming appends (ParityLogAppend) can block on
-			 * either 1. empty buffer pool 2. region under
-			 * reintegration To preserve a global FIFO ordering of
+			 *
+			 * Note: Incoming appends (ParityLogAppend) can block
+			 * on either 1. empty buffer pool 2. region under
+			 * reintegration. To preserve a global FIFO ordering of
 			 * appends, buffers are not released to the world
 			 * until those appends blocked on buffers are removed
-			 * from the append queue.  Similarly, regions which
-			 * are reintegrated are not opened for general use
-			 * until the append queue has been emptied. */
+			 * from the append queue. Similarly, regions that are
+			 * reintegrated are not opened for general use until
+			 * the append queue has been emptied.
+			 */
 
 			RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 
-			/* empty flushQueue, using free'd log buffers to
-			 * process bufTail */
+			/*
+			 * Empty flushQueue, using free'd log buffers to
+			 * process bufTail.
+			 */
 			if (flushQueue)
-			       FlushLogsToDisk(raidPtr, flushQueue);
+				rf_FlushLogsToDisk(raidPtr, flushQueue);
 
-			/* empty reintQueue, flushing from reintTail as we go */
+			/*
+			 * Empty reintQueue, flushing from reintTail as we go.
+			 */
 			if (reintQueue)
-				ReintegrateLogs(raidPtr, reintQueue);
+				rf_ReintegrateLogs(raidPtr, reintQueue);
 
 			RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 			flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
@@ -658,22 +678,27 @@ rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr)
 			raidPtr->parityLogDiskQueue.reintQueue = NULL;
 			workNeeded = (flushQueue || reintQueue);
 		}
-		/* no work is needed at this point */
+		/* No work is needed at this point. */
 		if (raidPtr->parityLogDiskQueue.threadState & RF_PLOG_TERMINATE) {
-			/* shutdown parity logging 1. disable parity logging
-			 * in all regions 2. reintegrate all regions */
-			done = RF_TRUE;	/* thread disabled, no work needed */
+			/*
+			 * Shutdown parity logging:
+			 * 1. Disable parity logging in all regions.
+			 * 2. Reintegrate all regions.
+			 */
+			done = RF_TRUE;	/* Thread disabled, no work needed. */
 			RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 			rf_ShutdownLogging(raidPtr);
 		}
 		if (!done) {
-			/* thread enabled, no work needed, so sleep */
+			/* Thread enabled, no work needed, so sleep. */
 			if (rf_parityLogDebug)
-				printf("[parity logging disk manager sleeping]\n");
-			RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, 
-				     raidPtr->parityLogDiskQueue.mutex);
+				printf("[parity logging disk manager"
+				    " sleeping]\n");
+			RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
+			    raidPtr->parityLogDiskQueue.mutex);
 			if (rf_parityLogDebug)
-				printf("[parity logging disk manager just woke up]\n");
+				printf("[parity logging disk manager just"
+				    " woke up]\n");
 			flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
 			raidPtr->parityLogDiskQueue.flushQueue = NULL;
 			reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
@@ -682,8 +707,8 @@ rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr)
 		}
 	}
 	/*
-         * Announce that we're done.
-         */
+	 * Announce that we're done.
+	 */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_SHUTDOWN;
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
@@ -692,9 +717,9 @@ rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr)
 	splx(s);
 
 	/*
-         * In the Net- & OpenBSD kernel, the thread must exit; returning would
-         * cause the proc trampoline to attempt to return to userspace.
-         */
+	 * In the Net- & OpenBSD kernel, the thread must exit; returning would
+	 * cause the proc trampoline to attempt to return to userspace.
+	 */
 	kthread_exit(0);	/* does not return */
 }
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_paritylogDiskMgr.h b/sys/dev/raidframe/rf_paritylogDiskMgr.h
index 96e0ac7485f..cc8a01bd08e 100644
--- a/sys/dev/raidframe/rf_paritylogDiskMgr.h
+++ b/sys/dev/raidframe/rf_paritylogDiskMgr.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_paritylogDiskMgr.h,v 1.2 1999/02/16 00:03:06 niklas Exp $	*/
+/*	$OpenBSD: rf_paritylogDiskMgr.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_paritylogDiskMgr.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,16 +28,16 @@
  * rights to redistribute these changes.
  */
 
-/* header file for parity log disk mgr code
- *
+/*
+ * Header file for parity log disk mgr code.
  */
 
-#ifndef _RF__RF_PARITYLOGDISKMGR_H_
-#define _RF__RF_PARITYLOGDISKMGR_H_
+#ifndef	_RF__RF_PARITYLOGDISKMGR_H_
+#define	_RF__RF_PARITYLOGDISKMGR_H_
 
 #include "rf_types.h"
 
-int     rf_ShutdownLogging(RF_Raid_t * raidPtr);
-int     rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr);
+int  rf_ShutdownLogging(RF_Raid_t *);
+int  rf_ParityLoggingDiskManager(RF_Raid_t *);
 
-#endif				/* !_RF__RF_PARITYLOGDISKMGR_H_ */
+#endif	/* !_RF__RF_PARITYLOGDISKMGR_H_ */
diff --git a/sys/dev/raidframe/rf_paritylogging.c b/sys/dev/raidframe/rf_paritylogging.c
index c0a04bbd062..bc730bb6001 100644
--- a/sys/dev/raidframe/rf_paritylogging.c
+++ b/sys/dev/raidframe/rf_paritylogging.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_paritylogging.c,v 1.5 2000/08/08 16:07:44 peter Exp $	*/
+/*	$OpenBSD: rf_paritylogging.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_paritylogging.c,v 1.10 2000/02/12 16:06:27 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,12 +30,12 @@
 
 
 /*
-  parity logging configuration, dag selection, and mapping is implemented here
+ * Parity logging configuration, dag selection, and mapping is implemented here.
  */
 
 #include "rf_archs.h"
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -55,25 +56,28 @@
 #include "rf_shutdown.h"
 
 typedef struct RF_ParityLoggingConfigInfo_s {
-	RF_RowCol_t **stripeIdentifier;	/* filled in at config time & used by
-					 * IdentifyStripe */
-}       RF_ParityLoggingConfigInfo_t;
-
-static void FreeRegionInfo(RF_Raid_t * raidPtr, RF_RegionId_t regionID);
-static void rf_ShutdownParityLogging(RF_ThreadArg_t arg);
-static void rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t arg);
-static void rf_ShutdownParityLoggingPool(RF_ThreadArg_t arg);
-static void rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t arg);
-static void rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t arg);
-static void rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg);
-
-int 
-rf_ConfigureParityLogging(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+	RF_RowCol_t **stripeIdentifier;	/*
+					 * Filled in at config time & used by
+					 * IdentifyStripe.
+					 */
+} RF_ParityLoggingConfigInfo_t;
+
+void rf_FreeRegionInfo(RF_Raid_t *, RF_RegionId_t);
+void rf_FreeParityLogQueue(RF_Raid_t *, RF_ParityLogQueue_t *);
+void rf_FreeRegionBufferQueue(RF_RegionBufferQueue_t *);
+void rf_ShutdownParityLogging(RF_ThreadArg_t);
+void rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t);
+void rf_ShutdownParityLoggingPool(RF_ThreadArg_t);
+void rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t);
+void rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t);
+void rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t);
+
+
+int
+rf_ConfigureParityLogging(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
-	int     i, j, startdisk, rc;
+	int i, j, startdisk, rc;
 	RF_SectorCount_t totalLogCapacity, fragmentation, lastRegionCapacity;
 	RF_SectorCount_t parityBufferCapacity, maxRegionParityRange;
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
@@ -85,17 +89,17 @@ rf_ConfigureParityLogging(
 		return(EINVAL);
 
 	/*
-         * We create multiple entries on the shutdown list here, since
-         * this configuration routine is fairly complicated in and of
-         * itself, and this makes backing out of a failed configuration
-         * much simpler.
-         */
+	 * We create multiple entries on the shutdown list here, since
+	 * this configuration routine is fairly complicated in and of
+	 * itself, and this makes backing out of a failed configuration
+	 * much simpler.
+	 */
 
 	raidPtr->numSectorsPerLog = RF_DEFAULT_NUM_SECTORS_PER_LOG;
 
-	/* create a parity logging configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_ParityLoggingConfigInfo_t), 
-			(RF_ParityLoggingConfigInfo_t *), 
+	/* Create a parity logging configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_ParityLoggingConfigInfo_t),
+			(RF_ParityLoggingConfigInfo_t *),
 			raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
@@ -103,10 +107,12 @@ rf_ConfigureParityLogging(
 
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	/* 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), 
+	/*
+	 * 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);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
@@ -114,161 +120,168 @@ rf_ConfigureParityLogging(
 	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;
 	}
 
-	/* fill in the remaining layout parameters */
+	/* 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->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
-	 * 
-	 * 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
-	 * 
+	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk *
+	    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.
+	 *
+	 * 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.
+	 *
 	 */
 
-	totalLogCapacity = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit * layoutPtr->numParityLogCol;
+	totalLogCapacity = layoutPtr->stripeUnitsPerDisk *
+	    layoutPtr->sectorsPerStripeUnit * layoutPtr->numParityLogCol;
 	raidPtr->regionLogCapacity = totalLogCapacity / rf_numParityRegions;
 	if (rf_parityLogDebug)
 		printf("bytes per sector %d\n", raidPtr->bytesPerSector);
 
-	/* reduce fragmentation within a disk region by adjusting the number
+	/*
+	 * Reduce fragmentation within a disk region by adjusting the number
 	 * of regions in an attempt to allow an integral number of logs to fit
-	 * into a disk region */
+	 * into a disk region.
+	 */
 	fragmentation = raidPtr->regionLogCapacity % raidPtr->numSectorsPerLog;
 	if (fragmentation > 0)
 		for (i = 1; i < (raidPtr->numSectorsPerLog / 2); i++) {
-			if (((totalLogCapacity / (rf_numParityRegions + i)) % 
+			if (((totalLogCapacity / (rf_numParityRegions + i)) %
 			     raidPtr->numSectorsPerLog) < fragmentation) {
 				rf_numParityRegions++;
 				raidPtr->regionLogCapacity = totalLogCapacity /
-					rf_numParityRegions;
-				fragmentation = raidPtr->regionLogCapacity % 
-					raidPtr->numSectorsPerLog;
+				    rf_numParityRegions;
+				fragmentation = raidPtr->regionLogCapacity %
+				    raidPtr->numSectorsPerLog;
 			}
-			if (((totalLogCapacity / (rf_numParityRegions - i)) % 
+			if (((totalLogCapacity / (rf_numParityRegions - i)) %
 			     raidPtr->numSectorsPerLog) < fragmentation) {
 				rf_numParityRegions--;
 				raidPtr->regionLogCapacity = totalLogCapacity /
-					rf_numParityRegions;
-				fragmentation = raidPtr->regionLogCapacity % 
-					raidPtr->numSectorsPerLog;
+				    rf_numParityRegions;
+				fragmentation = raidPtr->regionLogCapacity %
+				    raidPtr->numSectorsPerLog;
 			}
 		}
-	/* ensure integral number of regions per log */
-	raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity / 
-				      raidPtr->numSectorsPerLog) * 
-		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 */
+	/* Ensure integral number of regions per log. */
+	raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity /
+	    raidPtr->numSectorsPerLog) * 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 */
+	/* Create region information structs. */
 	printf("Allocating %d bytes for in-core parity region info\n",
 	       (int) (rf_numParityRegions * sizeof(RF_RegionInfo_t)));
-	RF_Malloc(raidPtr->regionInfo, 
-		  (rf_numParityRegions * sizeof(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 */
+	/* Last region may not be full capacity. */
 	lastRegionCapacity = raidPtr->regionLogCapacity;
-	while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity + 
+	while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity +
 	       lastRegionCapacity > totalLogCapacity)
-		lastRegionCapacity = lastRegionCapacity - 
-			raidPtr->numSectorsPerLog;
+		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 */
-/*  if (raidPtr->sectorsPerDisk % rf_numParityRegions > 0)
-    regionParityRange++; */
+	/* I can't remember why this line is in the code -wvcii 6/30/95. */
+	/* if (raidPtr->sectorsPerDisk % rf_numParityRegions > 0)
+	 *	regionParityRange++; */
 
-	/* build pool of unused parity logs */
+	/* Build pool of unused parity logs. */
 	printf("Allocating %d bytes for %d parity logs\n",
-	       raidPtr->numParityLogs * raidPtr->numSectorsPerLog * 
+	       raidPtr->numParityLogs * raidPtr->numSectorsPerLog *
 	       raidPtr->bytesPerSector,
 	       raidPtr->numParityLogs);
-	RF_Malloc(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
-		  raidPtr->numSectorsPerLog * raidPtr->bytesPerSector, 
+	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", 
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n",
 			     __FILE__, __LINE__, rc);
-		RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
+		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, 
+			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 * 
+				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_Calloc(l->next, 1, sizeof(RF_ParityLog_t),
 				  (RF_ParityLog_t *));
 			if (l->next == NULL) {
-				RF_Free(raidPtr->parityLogBufferHeap, 
-					raidPtr->numParityLogs * 
-					raidPtr->numSectorsPerLog * 
+				RF_Free(raidPtr->parityLogBufferHeap,
+					raidPtr->numParityLogs *
+					raidPtr->numSectorsPerLog *
 					raidPtr->bytesPerSector);
-				for (l = raidPtr->parityLogPool.parityLogs; 
+				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);
@@ -276,23 +289,23 @@ rf_ConfigureParityLogging(
 			l = l->next;
 		}
 		l->bufPtr = lHeapPtr;
-		lHeapPtr += raidPtr->numSectorsPerLog * 
-			raidPtr->bytesPerSector;
-		RF_Malloc(l->records, (raidPtr->numSectorsPerLog * 
-				       sizeof(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 * 
+			RF_Free(raidPtr->parityLogBufferHeap,
+				raidPtr->numParityLogs *
+				raidPtr->numSectorsPerLog *
 				raidPtr->bytesPerSector);
-			for (l = raidPtr->parityLogPool.parityLogs; 
-			     l; 
+			for (l = raidPtr->parityLogPool.parityLogs;
+			     l;
 			     l = next) {
 				next = l->next;
 				if (l->records)
-					RF_Free(l->records, 
-						(raidPtr->numSectorsPerLog * 
+					RF_Free(l->records,
+						(raidPtr->numSectorsPerLog *
 						 sizeof(RF_ParityLogRecord_t)));
 				RF_Free(l, sizeof(RF_ParityLog_t));
 			}
@@ -301,42 +314,42 @@ rf_ConfigureParityLogging(
 	}
 	rc = rf_ShutdownCreate(listp, rf_ShutdownParityLoggingPool, raidPtr);
 	if (rc) {
-		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
+			     " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownParityLoggingPool(raidPtr);
 		return (rc);
 	}
-	/* build pool of region buffers */
+	/* 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", 
+		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", 
+		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->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;	
+	/* For now, only one region at a time may be reintegrated. */
+	raidPtr->regionBufferPool.totalBuffers = 1;
 
-	raidPtr->regionBufferPool.availableBuffers = 
-		raidPtr->regionBufferPool.totalBuffers;
+	raidPtr->regionBufferPool.availableBuffers =
+	    raidPtr->regionBufferPool.totalBuffers;
 	raidPtr->regionBufferPool.availBuffersIndex = 0;
 	raidPtr->regionBufferPool.emptyBuffersIndex = 0;
 	printf("Allocating %d bytes for regionBufferPool\n",
-	       (int) (raidPtr->regionBufferPool.totalBuffers * 
+	       (int) (raidPtr->regionBufferPool.totalBuffers *
 		      sizeof(caddr_t)));
-	RF_Malloc(raidPtr->regionBufferPool.buffers, 
-		  raidPtr->regionBufferPool.totalBuffers * sizeof(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);
@@ -345,69 +358,69 @@ rf_ConfigureParityLogging(
 	}
 	for (i = 0; i < raidPtr->regionBufferPool.totalBuffers; i++) {
 		printf("Allocating %d bytes for regionBufferPool#%d\n",
-		       (int) (raidPtr->regionBufferPool.bufferSize * 
+		       (int) (raidPtr->regionBufferPool.bufferSize *
 			      sizeof(char)), i);
-		RF_Malloc(raidPtr->regionBufferPool.buffers[i], 
+		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], 
+				RF_Free(raidPtr->regionBufferPool.buffers[i],
 					raidPtr->regionBufferPool.bufferSize *
 					sizeof(char));
 			}
-			RF_Free(raidPtr->regionBufferPool.buffers, 
-				raidPtr->regionBufferPool.totalBuffers * 
+			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, 
+	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);
+		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
+			     " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownParityLoggingRegionBufferPool(raidPtr);
 		return (rc);
 	}
-	/* build pool of parity buffers */
+	/* Build pool of parity buffers. */
 	parityBufferCapacity = maxRegionParityRange;
 	rc = rf_mutex_init(&raidPtr->parityBufferPool.mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
+		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", 
+		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 = 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;	
+	/* For now, only one region at a time may be reintegrated. */
+	raidPtr->parityBufferPool.totalBuffers = 1;
 
-	raidPtr->parityBufferPool.availableBuffers = 
-		raidPtr->parityBufferPool.totalBuffers;
+	raidPtr->parityBufferPool.availableBuffers =
+	    raidPtr->parityBufferPool.totalBuffers;
 	raidPtr->parityBufferPool.availBuffersIndex = 0;
 	raidPtr->parityBufferPool.emptyBuffersIndex = 0;
 	printf("Allocating %d bytes for parityBufferPool of %d units\n",
-	       (int) (raidPtr->parityBufferPool.totalBuffers * 
+	       (int) (raidPtr->parityBufferPool.totalBuffers *
 		      sizeof(caddr_t)),
-	       raidPtr->parityBufferPool.totalBuffers );
-	RF_Malloc(raidPtr->parityBufferPool.buffers, 
-		  raidPtr->parityBufferPool.totalBuffers * sizeof(caddr_t), 
+	       raidPtr->parityBufferPool.totalBuffers);
+	RF_Malloc(raidPtr->parityBufferPool.buffers,
+		  raidPtr->parityBufferPool.totalBuffers * sizeof(caddr_t),
 		  (caddr_t *));
 	if (raidPtr->parityBufferPool.buffers == NULL) {
 		rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
@@ -416,47 +429,47 @@ rf_ConfigureParityLogging(
 	}
 	for (i = 0; i < raidPtr->parityBufferPool.totalBuffers; i++) {
 		printf("Allocating %d bytes for parityBufferPool#%d\n",
-		       (int) (raidPtr->parityBufferPool.bufferSize * 
-			      sizeof(char)),i);
-		RF_Malloc(raidPtr->parityBufferPool.buffers[i], 
+		       (int) (raidPtr->parityBufferPool.bufferSize *
+			      sizeof(char)), i);
+		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 * 
+				RF_Free(raidPtr->parityBufferPool.buffers[i],
+					raidPtr->regionBufferPool.bufferSize *
 					sizeof(char));
 			}
-			RF_Free(raidPtr->parityBufferPool.buffers, 
-				raidPtr->regionBufferPool.totalBuffers * 
+			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, 
+	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);
+		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
+			     " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownParityLoggingParityBufferPool(raidPtr);
 		return (rc);
 	}
-	/* initialize parityLogDiskQueue */
-	rc = rf_create_managed_mutex(listp, 
+	/* Initialize parityLogDiskQueue. */
+	rc = rf_create_managed_mutex(listp,
 				     &raidPtr->parityLogDiskQueue.mutex);
 	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
+		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", 
+		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n",
 			     __FILE__, __LINE__, rc);
 		return (rc);
 	}
@@ -473,80 +486,79 @@ rf_ConfigureParityLogging(
 	raidPtr->parityLogDiskQueue.freeDataList = NULL;
 	raidPtr->parityLogDiskQueue.freeCommonList = NULL;
 
-	rc = rf_ShutdownCreate(listp, 
-			       rf_ShutdownParityLoggingDiskQueue, 
+	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);
+		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
+			     " rc=%d\n", __FILE__, __LINE__, rc);
 		return (rc);
 	}
 	for (i = 0; i < rf_numParityRegions; i++) {
 		rc = rf_mutex_init(&raidPtr->regionInfo[i].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);
 			for (j = 0; j < i; j++)
-				FreeRegionInfo(raidPtr, j);
-			RF_Free(raidPtr->regionInfo, 
-				(rf_numParityRegions * 
+				rf_FreeRegionInfo(raidPtr, j);
+			RF_Free(raidPtr->regionInfo,
+				(rf_numParityRegions *
 				 sizeof(RF_RegionInfo_t)));
 			return (ENOMEM);
 		}
 		rc = rf_mutex_init(&raidPtr->regionInfo[i].reintMutex);
 		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);
 			rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
 			for (j = 0; j < i; j++)
-				FreeRegionInfo(raidPtr, j);
-			RF_Free(raidPtr->regionInfo, 
-				(rf_numParityRegions * 
+				rf_FreeRegionInfo(raidPtr, j);
+			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 > 
+			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;
+				maxRegionParityRange =
+				    raidPtr->regionInfo[i].numSectorsParity;
 		}
 		raidPtr->regionInfo[i].diskCount = 0;
-		RF_ASSERT(raidPtr->regionInfo[i].capacity + 
-			  raidPtr->regionInfo[i].regionStartAddr <= 
+		RF_ASSERT(raidPtr->regionInfo[i].capacity +
+			  raidPtr->regionInfo[i].regionStartAddr <=
 			  totalLogCapacity);
-		RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr + 
-			  raidPtr->regionInfo[i].numSectorsParity <= 
+		RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr +
+			  raidPtr->regionInfo[i].numSectorsParity <=
 			  raidPtr->sectorsPerDisk);
 		printf("Allocating %d bytes for region %d\n",
 		       (int) (raidPtr->regionInfo[i].capacity *
 			   sizeof(RF_DiskMap_t)), i);
-		RF_Malloc(raidPtr->regionInfo[i].diskMap, 
+		RF_Malloc(raidPtr->regionInfo[i].diskMap,
 			  (raidPtr->regionInfo[i].capacity *
-			   sizeof(RF_DiskMap_t)), 
+			   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 * 
+				rf_FreeRegionInfo(raidPtr, j);
+			RF_Free(raidPtr->regionInfo,
+				(rf_numParityRegions *
 				 sizeof(RF_RegionInfo_t)));
 			return (ENOMEM);
 		}
@@ -554,64 +566,71 @@ rf_ConfigureParityLogging(
 		raidPtr->regionInfo[i].coreLog = NULL;
 	}
 	rc = rf_ShutdownCreate(listp,
-			       rf_ShutdownParityLoggingRegionInfo, 
+			       rf_ShutdownParityLoggingRegionInfo,
 			       raidPtr);
 	if (rc) {
-		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d"
+			     " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownParityLoggingRegionInfo(raidPtr);
 		return (rc);
 	}
 	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",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to create parity logging disk thread"
+			     " file %s line %d rc=%d\n",
+			     __FILE__, __LINE__, rc);
 		return (ENOMEM);
 	}
-	/* wait for thread to start */
+	/* Wait for thread to start. */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
-		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, 
+		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
 			     raidPtr->parityLogDiskQueue.mutex);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 
 	rc = rf_ShutdownCreate(listp, rf_ShutdownParityLogging, raidPtr);
 	if (rc) {
-		RF_ERRORMSG1("Got rc=%d adding parity logging shutdown event\n", rc);
+		RF_ERRORMSG1("Got rc=%d adding parity logging shutdown"
+			     " event.\n", rc);
 		rf_ShutdownParityLogging(raidPtr);
 		return (rc);
 	}
 	if (rf_parityLogDebug) {
-		printf("                            size of disk log in sectors: %d\n",
-		    (int) totalLogCapacity);
-		printf("                            total number of parity regions is %d\n", (int) rf_numParityRegions);
-		printf("                            nominal sectors of log per parity region is %d\n", (int) raidPtr->regionLogCapacity);
-		printf("                            nominal region fragmentation is %d sectors\n", (int) fragmentation);
-		printf("                            total number of parity logs is %d\n", raidPtr->numParityLogs);
-		printf("                            parity log size is %d sectors\n", raidPtr->numSectorsPerLog);
-		printf("                            total in-core log space is %d bytes\n", (int) rf_totalInCoreLogCapacity);
+		printf("\t\t\tsize of disk log in sectors: %d\n",
+		       (int) totalLogCapacity);
+		printf("\t\t\ttotal number of parity regions is %d\n",
+		       (int) rf_numParityRegions);
+		printf("\t\t\tnominal sectors of log per parity region is %d\n",
+		       (int) raidPtr->regionLogCapacity);
+		printf("\t\t\tnominal region fragmentation is %d sectors\n",
+		       (int) fragmentation);
+		printf("\t\t\ttotal number of parity logs is %d\n",
+		       raidPtr->numParityLogs);
+		printf("\t\t\tparity log size is %d sectors\n",
+		       raidPtr->numSectorsPerLog);
+		printf("\t\t\ttotal in-core log space is %d bytes\n",
+		       (int) rf_totalInCoreLogCapacity);
 	}
 	rf_EnableParityLogging(raidPtr);
 
 	return (0);
 }
 
-static void 
-FreeRegionInfo(
-    RF_Raid_t * raidPtr,
-    RF_RegionId_t regionID)
+
+void
+rf_FreeRegionInfo(RF_Raid_t *raidPtr, RF_RegionId_t regionID)
 {
 	RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-	RF_Free(raidPtr->regionInfo[regionID].diskMap, 
-		(raidPtr->regionInfo[regionID].capacity * 
+	RF_Free(raidPtr->regionInfo[regionID].diskMap,
+		(raidPtr->regionInfo[regionID].capacity *
 		 sizeof(RF_DiskMap_t)));
 	if (!rf_forceParityLogReint && raidPtr->regionInfo[regionID].coreLog) {
-		rf_ReleaseParityLogs(raidPtr, 
+		rf_ReleaseParityLogs(raidPtr,
 				     raidPtr->regionInfo[regionID].coreLog);
 		raidPtr->regionInfo[regionID].coreLog = NULL;
 	} else {
@@ -624,10 +643,8 @@ FreeRegionInfo(
 }
 
 
-static void 
-FreeParityLogQueue(
-    RF_Raid_t * raidPtr,
-    RF_ParityLogQueue_t * queue)
+void
+rf_FreeParityLogQueue(RF_Raid_t *raidPtr, RF_ParityLogQueue_t *queue)
 {
 	RF_ParityLog_t *l1, *l2;
 
@@ -636,7 +653,7 @@ FreeParityLogQueue(
 	while (l1) {
 		l2 = l1;
 		l1 = l2->next;
-		RF_Free(l2->records, (raidPtr->numSectorsPerLog * 
+		RF_Free(l2->records, (raidPtr->numSectorsPerLog *
 				      sizeof(RF_ParityLogRecord_t)));
 		RF_Free(l2, sizeof(RF_ParityLog_t));
 	}
@@ -645,14 +662,14 @@ FreeParityLogQueue(
 }
 
 
-static void 
-FreeRegionBufferQueue(RF_RegionBufferQueue_t * queue)
+void
+rf_FreeRegionBufferQueue(RF_RegionBufferQueue_t *queue)
 {
-	int     i;
+	int i;
 
 	RF_LOCK_MUTEX(queue->mutex);
 	if (queue->availableBuffers != queue->totalBuffers) {
-		printf("Attempt to free region queue which is still in use!\n");
+		printf("Attempt to free region queue that is still in use !\n");
 		RF_ASSERT(0);
 	}
 	for (i = 0; i < queue->totalBuffers; i++)
@@ -662,7 +679,8 @@ FreeRegionBufferQueue(RF_RegionBufferQueue_t * queue)
 	rf_mutex_destroy(&queue->mutex);
 }
 
-static void 
+
+void
 rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t arg)
 {
 	RF_Raid_t *raidPtr;
@@ -670,18 +688,19 @@ rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t arg)
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLoggingRegionInfo\n", 
+		printf("raid%d: ShutdownParityLoggingRegionInfo\n",
 		       raidPtr->raidid);
 	}
-	/* free region information structs */
+	/* Free region information structs. */
 	for (i = 0; i < rf_numParityRegions; i++)
-		FreeRegionInfo(raidPtr, i);
-	RF_Free(raidPtr->regionInfo, (rf_numParityRegions * 
+		rf_FreeRegionInfo(raidPtr, i);
+	RF_Free(raidPtr->regionInfo, (rf_numParityRegions *
 				      sizeof(raidPtr->regionInfo)));
 	raidPtr->regionInfo = NULL;
 }
 
-static void 
+
+void
 rf_ShutdownParityLoggingPool(RF_ThreadArg_t arg)
 {
 	RF_Raid_t *raidPtr;
@@ -690,26 +709,28 @@ rf_ShutdownParityLoggingPool(RF_ThreadArg_t arg)
 	if (rf_parityLogDebug) {
 		printf("raid%d: ShutdownParityLoggingPool\n", raidPtr->raidid);
 	}
-	/* free contents of parityLogPool */
-	FreeParityLogQueue(raidPtr, &raidPtr->parityLogPool);
-	RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
+	/* Free contents of parityLogPool. */
+	rf_FreeParityLogQueue(raidPtr, &raidPtr->parityLogPool);
+	RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs *
 		raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
 }
 
-static void 
+
+void
 rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t arg)
 {
 	RF_Raid_t *raidPtr;
 
 	raidPtr = (RF_Raid_t *) arg;
 	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLoggingRegionBufferPool\n", 
+		printf("raid%d: ShutdownParityLoggingRegionBufferPool\n",
 		       raidPtr->raidid);
 	}
-	FreeRegionBufferQueue(&raidPtr->regionBufferPool);
+	rf_FreeRegionBufferQueue(&raidPtr->regionBufferPool);
 }
 
-static void 
+
+void
 rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t arg)
 {
 	RF_Raid_t *raidPtr;
@@ -719,10 +740,11 @@ rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t arg)
 		printf("raid%d: ShutdownParityLoggingParityBufferPool\n",
 		       raidPtr->raidid);
 	}
-	FreeRegionBufferQueue(&raidPtr->parityBufferPool);
+	rf_FreeRegionBufferQueue(&raidPtr->parityBufferPool);
 }
 
-static void 
+
+void
 rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg)
 {
 	RF_ParityLogData_t *d;
@@ -734,27 +756,28 @@ rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg)
 		printf("raid%d: ShutdownParityLoggingDiskQueue\n",
 		       raidPtr->raidid);
 	}
-	/* free disk manager stuff */
+	/* Free disk manager stuff. */
 	RF_ASSERT(raidPtr->parityLogDiskQueue.bufHead == NULL);
 	RF_ASSERT(raidPtr->parityLogDiskQueue.bufTail == NULL);
 	RF_ASSERT(raidPtr->parityLogDiskQueue.reintHead == NULL);
 	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));
 	}
 }
 
-static void 
+
+void
 rf_ShutdownParityLogging(RF_ThreadArg_t arg)
 {
 	RF_Raid_t *raidPtr;
@@ -763,135 +786,129 @@ rf_ShutdownParityLogging(RF_ThreadArg_t arg)
 	if (rf_parityLogDebug) {
 		printf("raid%d: ShutdownParityLogging\n", raidPtr->raidid);
 	}
-	/* shutdown disk thread */
-	/* This has the desirable side-effect of forcing all regions to be
-	 * reintegrated.  This is necessary since all parity log maps are
-	 * currently held in volatile memory. */
+	/* Shutdown disk thread. */
+	/*
+	 * This has the desirable side-effect of forcing all regions to be
+	 * reintegrated. This is necessary since all parity log maps are
+	 * currently held in volatile memory.
+	 */
 
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_TERMINATE;
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
 	/*
-         * pLogDiskThread will now terminate when queues are cleared
-         * now wait for it to be done
-         */
+	 * pLogDiskThread will now terminate when queues are cleared.
+	 * Now wait for it to be done.
+	 */
 	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
-		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, 
+		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond,
 			     raidPtr->parityLogDiskQueue.mutex);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
 	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLogging done (thread completed)\n", raidPtr->raidid);
+		printf("raid%d: ShutdownParityLogging done"
+		       " (thread completed)\n", raidPtr->raidid);
 	}
 }
 
-int 
-rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t * raidPtr)
+
+int
+rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t *raidPtr)
 {
 	return (20);
 }
 
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t * raidPtr)
+
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t *raidPtr)
 {
 	return (10);
 }
-/* return the region ID for a given RAID address */
-RF_RegionId_t 
-rf_MapRegionIDParityLogging(
-    RF_Raid_t * raidPtr,
-    RF_SectorNum_t address)
+
+
+/* Return the region ID for a given RAID address. */
+RF_RegionId_t
+rf_MapRegionIDParityLogging(RF_Raid_t *raidPtr, RF_SectorNum_t address)
 {
 	RF_RegionId_t regionID;
 
-/*  regionID = address / (raidPtr->regionParityRange * raidPtr->Layout.numDataCol); */
+	/* regionID = address / (raidPtr->regionParityRange *
+	 *     raidPtr->Layout.numDataCol); */
 	regionID = address / raidPtr->regionParityRange;
 	if (regionID == rf_numParityRegions) {
-		/* last region may be larger than other regions */
+		/* Last region may be larger than other regions. */
 		regionID--;
 	}
 	RF_ASSERT(address >= raidPtr->regionInfo[regionID].parityStartAddr);
-	RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr + 
+	RF_ASSERT(address < raidPtr->regionInfo[regionID].parityStartAddr +
 		  raidPtr->regionInfo[regionID].numSectorsParity);
 	RF_ASSERT(regionID < rf_numParityRegions);
 	return (regionID);
 }
 
 
-/* given a logical RAID sector, determine physical disk address of data */
-void 
-rf_MapSectorParityLogging(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+/* Given a logical RAID sector, determine physical disk address of data. */
+void
+rf_MapSectorParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
-	RF_StripeNum_t SUID = raidSector / 
+	RF_StripeNum_t SUID = raidSector /
 		raidPtr->Layout.sectorsPerStripeUnit;
 	*row = 0;
 	/* *col = (SUID % (raidPtr->numCol -
-	 * raidPtr->Layout.numParityLogCol)); */
+	 *     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);
 }
 
 
-/* given a logical RAID sector, determine physical disk address of parity  */
-void 
-rf_MapParityParityLogging(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+/* Given a logical RAID sector, determine physical disk address of parity. */
+void
+rf_MapParityParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, 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); */
+	 *     raidPtr->Layout.numDataCol-(SUID / raidPtr->Layout.numDataCol) %
+	 *      (raidPtr->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);
 }
 
 
-/* given a regionID and sector offset, determine the physical disk address of the parity log */
-void 
-rf_MapLogParityLogging(
-    RF_Raid_t * raidPtr,
-    RF_RegionId_t regionID,
-    RF_SectorNum_t regionOffset,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * startSector)
+/*
+ * Given a regionID and sector offset, determine the physical disk address
+ * of the parity log.
+ */
+void
+rf_MapLogParityLogging(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
+    RF_SectorNum_t regionOffset, RF_RowCol_t *row, RF_RowCol_t *col,
+    RF_SectorNum_t *startSector)
 {
 	*row = 0;
 	*col = raidPtr->numCol - 1;
-	*startSector = raidPtr->regionInfo[regionID].regionStartAddr + regionOffset;
+	*startSector =
+	    raidPtr->regionInfo[regionID].regionStartAddr + regionOffset;
 }
 
 
-/* given a regionID, determine the physical disk address of the logged
-   parity for that region */
-void 
-rf_MapRegionParity(
-    RF_Raid_t * raidPtr,
-    RF_RegionId_t regionID,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * startSector,
-    RF_SectorCount_t * numSector)
+/*
+ * Given a regionID, determine the physical disk address of the logged
+ * parity for that region.
+ */
+void
+rf_MapRegionParity(RF_Raid_t *raidPtr, RF_RegionId_t regionID,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *startSector,
+    RF_SectorCount_t *numSector)
 {
 	*row = 0;
 	*col = raidPtr->numCol - 2;
@@ -900,135 +917,181 @@ rf_MapRegionParity(
 }
 
 
-/* given a logical RAID address, determine the participating disks in
-   the stripe */
-void 
-rf_IdentifyStripeParityLogging(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+/*
+ * Given a logical RAID address, determine the participating disks in
+ * the stripe.
+ */
+void
+rf_IdentifyStripeParityLogging(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, 
+	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
 							   addr);
-	RF_ParityLoggingConfigInfo_t *info = (RF_ParityLoggingConfigInfo_t *) 
-		raidPtr->Layout.layoutSpecificInfo;
+	RF_ParityLoggingConfigInfo_t *info = (RF_ParityLoggingConfigInfo_t *)
+	    raidPtr->Layout.layoutSpecificInfo;
 	*outRow = 0;
 	*diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
 }
 
 
-void 
-rf_MapSIDToPSIDParityLogging(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDParityLogging(RF_RaidLayout_t *layoutPtr,
+    RF_StripeNum_t stripeID, RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
 }
 
 
-/* select an algorithm for performing an access.  Returns two pointers,
+/*
+ * Select an algorithm for performing an access. Returns two pointers,
  * one to a function that will return information about the DAG, and
  * another to a function that will create the dag.
  */
-void 
-rf_ParityLoggingDagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmp,
-    RF_VoidFuncPtr * createFunc)
+void
+rf_ParityLoggingDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmp, RF_VoidFuncPtr *createFunc)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_PhysDiskAddr_t *failedPDA = NULL;
 	RF_RowCol_t frow, fcol;
 	RF_RowStatus_t rstat;
-	int     prior_recon;
+	int prior_recon;
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 
 	if (asmp->numDataFailed + asmp->numParityFailed > 1) {
-		RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("Multiple disks failed in a single group !"
+			    "  Aborting I/O operation.\n");
 		 /* *infoFunc = */ *createFunc = NULL;
 		return;
 	} else
 		if (asmp->numDataFailed + asmp->numParityFailed == 1) {
 
-			/* if under recon & already reconstructed, redirect
+			/*
+			 * If under recon & already reconstructed, redirect
 			 * the access to the spare drive and eliminate the
-			 * failure indication */
+			 * failure indication.
+			 */
 			failedPDA = asmp->failedPDAs[0];
 			frow = failedPDA->row;
 			fcol = failedPDA->col;
 			rstat = raidPtr->status[failedPDA->row];
-			prior_recon = (rstat == rf_rs_reconfigured) || (
-			    (rstat == rf_rs_reconstructing) ?
-			    rf_CheckRUReconstructed(raidPtr->reconControl[frow]->reconMap, failedPDA->startSector) : 0
-			    );
+			prior_recon = (rstat == rf_rs_reconfigured) ||
+			    ((rstat == rf_rs_reconstructing) ?
+			     rf_CheckRUReconstructed(raidPtr->reconControl[frow]
+			      ->reconMap, failedPDA->startSector) : 0);
 			if (prior_recon) {
-				RF_RowCol_t or = failedPDA->row, oc = failedPDA->col;
+				RF_RowCol_t or = failedPDA->row;
+				RF_RowCol_t 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) {
 
-						/* parity has failed */
-						(layoutPtr->map->MapParity) (raidPtr, failedPDA->raidAddress, &failedPDA->row,
-						    &failedPDA->col, &failedPDA->startSector, RF_REMAP);
-
-						if (asmp->parityInfo->next) {	/* redir 2nd component,
-										 * if any */
-							RF_PhysDiskAddr_t *p = asmp->parityInfo->next;
-							RF_SectorNum_t SUoffs = p->startSector % layoutPtr->sectorsPerStripeUnit;
+						/* Parity has failed. */
+						(layoutPtr->map->MapParity)
+						    (raidPtr,
+						     failedPDA->raidAddress,
+						     &failedPDA->row,
+						     &failedPDA->col,
+						     &failedPDA->startSector,
+						     RF_REMAP);
+
+						if (asmp->parityInfo->next) {
+							/*
+							 * Redir 2nd component,
+							 * if any.
+							 */
+							RF_PhysDiskAddr_t *p =
+							 asmp->parityInfo->next;
+							RF_SectorNum_t SUoffs =
+							    p->startSector %
+						layoutPtr->sectorsPerStripeUnit;
 							p->row = failedPDA->row;
 							p->col = failedPDA->col;
-							p->startSector = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, failedPDA->startSector) +
-							    SUoffs;	/* cheating:
-									 * startSector is not
-									 * really a RAID address */
+							/*
+							 * Cheating:
+							 * startSector is not
+							 * really a RAID
+							 * address.
+							 */
+							p->startSector =
+			    rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr,
+				failedPDA->startSector) + SUoffs;
 						}
 					} else
-						if (asmp->parityInfo->next && failedPDA == asmp->parityInfo->next) {
-							RF_ASSERT(0);	/* should not ever
-									 * happen */
+						if (asmp->parityInfo->next &&
+						    failedPDA ==
+						    asmp->parityInfo->next) {
+							/*
+							 * Should not ever
+							 * happen.
+							 */
+							RF_ASSERT(0);
 						} else {
-
-							/* data has failed */
-							(layoutPtr->map->MapSector) (raidPtr, failedPDA->raidAddress, &failedPDA->row,
-							    &failedPDA->col, &failedPDA->startSector, RF_REMAP);
-
+							/* Data has failed. */
+							(layoutPtr->map
+							 ->MapSector)
+							    (raidPtr,
+							 failedPDA->raidAddress,
+							    &failedPDA->row,
+							    &failedPDA->col,
+							&failedPDA->startSector,
+							    RF_REMAP);
 						}
 
-				} 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;
+					failedPDA->row =
+					    raidPtr->Disks[frow][fcol].spareRow;
+					failedPDA->col =
+					    raidPtr->Disks[frow][fcol].spareCol;
 
-					/* the parity may have two distinct
+					/*
+					 * The parity may have two distinct
 					 * components, both of which may need
-					 * to be redirected */
+					 * to be redirected.
+					 */
 					if (asmp->parityInfo->next) {
-						if (failedPDA == asmp->parityInfo) {
-							failedPDA->next->row = failedPDA->row;
-							failedPDA->next->col = failedPDA->col;
-						} else
-							if (failedPDA == asmp->parityInfo->next) {	/* paranoid:  should never occur */
-								asmp->parityInfo->row = failedPDA->row;
-								asmp->parityInfo->col = failedPDA->col;
+						if (failedPDA ==
+						    asmp->parityInfo) {
+							failedPDA->next->row =
+							    failedPDA->row;
+							failedPDA->next->col =
+							    failedPDA->col;
+						} else {
+							if (failedPDA ==
+							    asmp->parityInfo
+							     ->next) {
+								/*
+								 * Paranoid:
+								 * Should never
+								 * occur.
+								 */
+								asmp->parityInfo
+								->row =
+								 failedPDA->row;
+								asmp->parityInfo
+								->col =
+								 failedPDA->col;
 							}
+						}
 					}
 				}
 
 				RF_ASSERT(failedPDA->col != -1);
 
 				if (rf_dagDebug || rf_mapDebug) {
-					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);
+					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;
 			}
@@ -1036,38 +1099,48 @@ rf_ParityLoggingDagSelect(
 	if (type == RF_IO_TYPE_READ) {
 
 		if (asmp->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
+			*createFunc =
+			    (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
 		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
+			*createFunc =
+			    (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
 
 	} else {
 
 
-		/* if mirroring, always use large writes.  If the access
+		/*
+		 * If mirroring, always use large writes. If the access
 		 * requires two distinct parity updates, always do a small
-		 * write.  If the stripe contains a failure but the access
+		 * write. If the stripe contains a failure but the access
 		 * does not, do a small write. The first conditional
 		 * (numStripeUnitsAccessed <= numDataCol/2) uses a
 		 * less-than-or-equal rather than just a less-than because
 		 * when G is 3 or 4, numDataCol/2 is 1, and I want
-		 * single-stripe-unit updates to use just one disk. */
+		 * single-stripe-unit updates to use just one disk.
+		 */
 		if ((asmp->numDataFailed + asmp->numParityFailed) == 0) {
-			if (((asmp->numStripeUnitsAccessed <= 
-			      (layoutPtr->numDataCol / 2)) && 
+			if (((asmp->numStripeUnitsAccessed <=
+			      (layoutPtr->numDataCol / 2)) &&
 			     (layoutPtr->numDataCol != 1)) ||
-			    (asmp->parityInfo->next != NULL) || 
+			    (asmp->parityInfo->next != NULL) ||
 			    rf_CheckStripeForFailures(raidPtr, asmp)) {
-				*createFunc = (RF_VoidFuncPtr) rf_CreateParityLoggingSmallWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_CreateParityLoggingSmallWriteDAG;
 			} else
-				*createFunc = (RF_VoidFuncPtr) rf_CreateParityLoggingLargeWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_CreateParityLoggingLargeWriteDAG;
 		} else
 			if (asmp->numParityFailed == 1)
-				*createFunc = (RF_VoidFuncPtr) rf_CreateNonRedundantWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_CreateNonRedundantWriteDAG;
 			else
-				if (asmp->numStripeUnitsAccessed != 1 && failedPDA->numSector != layoutPtr->sectorsPerStripeUnit)
+				if (asmp->numStripeUnitsAccessed != 1 &&
+				    failedPDA->numSector !=
+				    layoutPtr->sectorsPerStripeUnit)
 					*createFunc = NULL;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_CreateDegradedWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_CreateDegradedWriteDAG;
 	}
 }
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_paritylogging.h b/sys/dev/raidframe/rf_paritylogging.h
index 532da664940..6f6caaeb039 100644
--- a/sys/dev/raidframe/rf_paritylogging.h
+++ b/sys/dev/raidframe/rf_paritylogging.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_paritylogging.h,v 1.2 1999/02/16 00:03:07 niklas Exp $	*/
+/*	$OpenBSD: rf_paritylogging.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_paritylogging.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,44 +28,29 @@
  * rights to redistribute these changes.
  */
 
-/* header file for Parity Logging */
+/* Header file for Parity Logging. */
 
-#ifndef _RF__RF_PARITYLOGGING_H_
-#define _RF__RF_PARITYLOGGING_H_
+#ifndef	_RF__RF_PARITYLOGGING_H_
+#define	_RF__RF_PARITYLOGGING_H_
 
-int 
-rf_ConfigureParityLogging(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int     rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t * raidPtr);
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t * raidPtr);
-RF_RegionId_t 
-rf_MapRegionIDParityLogging(RF_Raid_t * raidPtr,
-    RF_SectorNum_t address);
-void 
-rf_MapSectorParityLogging(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector,
-    int remap);
-void 
-rf_MapParityParityLogging(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector,
-    int remap);
-void 
-rf_MapLogParityLogging(RF_Raid_t * raidPtr, RF_RegionId_t regionID,
-    RF_SectorNum_t regionOffset, RF_RowCol_t * row, RF_RowCol_t * col,
-    RF_SectorNum_t * startSector);
-void 
-rf_MapRegionParity(RF_Raid_t * raidPtr, RF_RegionId_t regionID,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * startSector,
-    RF_SectorCount_t * numSector);
-void 
-rf_IdentifyStripeParityLogging(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDParityLogging(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_ParityLoggingDagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
+int  rf_ConfigureParityLogging(RF_ShutdownList_t **, RF_Raid_t *,
+	RF_Config_t *);
+int  rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t *);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitParityLogging(RF_Raid_t *);
+RF_RegionId_t rf_MapRegionIDParityLogging(RF_Raid_t *, RF_SectorNum_t);
+void rf_MapSectorParityLogging(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityParityLogging(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapLogParityLogging(RF_Raid_t *, RF_RegionId_t, RF_SectorNum_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *);
+void rf_MapRegionParity(RF_Raid_t *, RF_RegionId_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, RF_SectorCount_t *);
+void rf_IdentifyStripeParityLogging(RF_Raid_t *, RF_RaidAddr_t, RF_RowCol_t **,
+	RF_RowCol_t *);
+void rf_MapSIDToPSIDParityLogging(RF_RaidLayout_t *, RF_StripeNum_t,
+	RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_ParityLoggingDagSelect(RF_Raid_t *, RF_IoType_t,
+	RF_AccessStripeMap_t *, RF_VoidFuncPtr *);
 
-#endif				/* !_RF__RF_PARITYLOGGING_H_ */
+#endif	/* !_RF__RF_PARITYLOGGING_H_ */
diff --git a/sys/dev/raidframe/rf_parityloggingdags.c b/sys/dev/raidframe/rf_parityloggingdags.c
index cd7cd3c6be6..fff383d5737 100644
--- a/sys/dev/raidframe/rf_parityloggingdags.c
+++ b/sys/dev/raidframe/rf_parityloggingdags.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_parityloggingdags.c,v 1.3 2000/01/11 18:02:22 peter Exp $	*/
+/*	$OpenBSD: rf_parityloggingdags.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_parityloggingdags.c,v 1.4 2000/01/07 03:41:04 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,10 +30,10 @@
 
 #include "rf_archs.h"
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 
 /*
-  DAGs specific to parity logging are created here
+ * DAGs specific to parity logging are created here.
  */
 
 #include "rf_types.h"
@@ -47,56 +48,57 @@
 
 #include "rf_parityloggingdags.h"
 
-/******************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a large-write operation:
+ * Creates a DAG to perform a large-write operation:
  *
  *         / Rod \     / Wnd \
  * H -- NIL- Rod - NIL - Wnd ------ NIL - T
  *         \ Rod /     \ Xor - Lpo /
  *
- * The writes are not done until the reads complete because if they were done in
- * parallel, a failure on one of the reads could leave the parity in an inconsistent
- * state, so that the retry with a new DAG would produce erroneous parity.
+ * The writes are not done until the reads complete because if they were done
+ * in parallel, a failure on one of the reads could leave the parity in an
+ * inconsistent state, so that the retry with a new DAG would produce
+ * erroneous parity.
  *
- * Note:  this DAG has the nasty property that none of the buffers allocated for reading
- *        old data can be freed until the XOR node fires.  Need to fix this.
+ * Note:  This DAG has the nasty property that none of the buffers allocated
+ *        for reading old data can be freed until the XOR node fires.
+ *        Need to fix this.
  *
- * The last two arguments are the number of faults tolerated, and function for the
- * redundancy calculation. The undo for the redundancy calc is assumed to be null
+ * The last two arguments are the number of faults tolerated, and function
+ * for the redundancy calculation. The undo for the redundancy calc is assumed
+ * to be null.
  *
  *****************************************************************************/
 
-void 
-rf_CommonCreateParityLoggingLargeWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    int nfaults,
+void
+rf_CommonCreateParityLoggingLargeWriteDAG(RF_Raid_t * raidPtr,
+    RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
+    RF_RaidAccessFlags_t flags, RF_AllocListElem_t *allocList, int nfaults,
     int (*redFunc) (RF_DagNode_t *))
 {
-	RF_DagNode_t *nodes, *wndNodes, *rodNodes = NULL, *syncNode, *xorNode,
-	       *lpoNode, *blockNode, *unblockNode, *termNode;
-	int     nWndNodes, nRodNodes, i;
+	RF_DagNode_t *nodes, *wndNodes, *rodNodes = NULL, *syncNode, *xorNode;
+	RF_DagNode_t *lpoNode, *blockNode, *unblockNode, *termNode;
+	int nWndNodes, nRodNodes, i;
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_AccessStripeMapHeader_t *new_asm_h[2];
-	int     nodeNum, asmNum;
+	int nodeNum, asmNum;
 	RF_ReconUnitNum_t which_ru;
-	char   *sosBuffer, *eosBuffer;
+	char *sosBuffer, *eosBuffer;
 	RF_PhysDiskAddr_t *pda;
-	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout), asmap->raidAddress, &which_ru);
+	RF_StripeNum_t parityStripeID =
+	    rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
+	     asmap->raidAddress, &which_ru);
 
 	if (rf_dagDebug)
 		printf("[Creating parity-logging large-write DAG]\n");
-	RF_ASSERT(nfaults == 1);/* this arch only single fault tolerant */
+	RF_ASSERT(nfaults == 1); /* This arch only single fault tolerant. */
 	dag_h->creator = "ParityLoggingLargeWriteDAG";
 
-	/* alloc the Wnd nodes, the xor node, and the Lpo node */
+	/* Alloc the Wnd nodes, the xor node, and the Lpo node. */
 	nWndNodes = asmap->numStripeUnitsAccessed;
-	RF_CallocAndAdd(nodes, nWndNodes + 6, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	RF_CallocAndAdd(nodes, nWndNodes + 6, sizeof(RF_DagNode_t),
+	    (RF_DagNode_t *), allocList);
 	i = 0;
 	wndNodes = &nodes[i];
 	i += nWndNodes;
@@ -117,26 +119,40 @@ rf_CommonCreateParityLoggingLargeWriteDAG(
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h, new_asm_h, &nRodNodes, &sosBuffer, &eosBuffer, allocList);
+	rf_MapUnaccessedPortionOfStripe(raidPtr, layoutPtr, asmap, dag_h,
+	    new_asm_h, &nRodNodes, &sosBuffer, &eosBuffer, allocList);
 	if (nRodNodes > 0)
-		RF_CallocAndAdd(rodNodes, nRodNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
-
-	/* begin node initialization */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nRodNodes + 1, 0, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nWndNodes + 1, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(syncNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nWndNodes + 1, nRodNodes + 1, 0, 0, dag_h, "Nil", allocList);
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
-
-	/* initialize the Rod nodes */
+		RF_CallocAndAdd(rodNodes, nRodNodes, sizeof(RF_DagNode_t),
+		    (RF_DagNode_t *), allocList);
+
+	/* Begin node initialization. */
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nRodNodes + 1, 0, 0, 0, dag_h,
+	    "Nil", allocList);
+	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, nWndNodes + 1, 0, 0, dag_h,
+	    "Nil", allocList);
+	rf_InitNode(syncNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nWndNodes + 1, nRodNodes + 1,
+	    0, 0, dag_h, "Nil", allocList);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+
+	/* Initialize the Rod nodes. */
 	for (nodeNum = asmNum = 0; asmNum < 2; asmNum++) {
 		if (new_asm_h[asmNum]) {
 			pda = new_asm_h[asmNum]->stripeMap->physInfo;
 			while (pda) {
-				rf_InitNode(&rodNodes[nodeNum], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Rod", allocList);
+				rf_InitNode(&rodNodes[nodeNum], rf_wait,
+				    RF_FALSE, rf_DiskReadFunc,
+				    rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+				    1, 1, 4, 0, dag_h, "Rod", allocList);
 				rodNodes[nodeNum].params[0].p = pda;
 				rodNodes[nodeNum].params[1].p = pda->bufPtr;
 				rodNodes[nodeNum].params[2].v = parityStripeID;
-				rodNodes[nodeNum].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+				rodNodes[nodeNum].params[3].v =
+				    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,
+				     0, 0, which_ru);
 				nodeNum++;
 				pda = pda->next;
 			}
@@ -144,62 +160,78 @@ rf_CommonCreateParityLoggingLargeWriteDAG(
 	}
 	RF_ASSERT(nodeNum == nRodNodes);
 
-	/* initialize the wnd nodes */
+	/* Initialize the wnd nodes. */
 	pda = asmap->physInfo;
 	for (i = 0; i < nWndNodes; i++) {
-		rf_InitNode(&wndNodes[i], rf_wait, RF_TRUE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, "Wnd", allocList);
+		rf_InitNode(&wndNodes[i], rf_wait, RF_TRUE, rf_DiskWriteFunc,
+		    rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0,
+		    dag_h, "Wnd", allocList);
 		RF_ASSERT(pda != NULL);
 		wndNodes[i].params[0].p = pda;
 		wndNodes[i].params[1].p = pda->bufPtr;
 		wndNodes[i].params[2].v = parityStripeID;
-		wndNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wndNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		pda = pda->next;
 	}
 
-	/* initialize the redundancy node */
-	rf_InitNode(xorNode, rf_wait, RF_TRUE, redFunc, rf_NullNodeUndoFunc, NULL, 1, 1, 2 * (nWndNodes + nRodNodes) + 1, 1, dag_h, "Xr ", allocList);
+	/* Initialize the redundancy node. */
+	rf_InitNode(xorNode, rf_wait, RF_TRUE, redFunc, rf_NullNodeUndoFunc,
+	    NULL, 1, 1, 2 * (nWndNodes + nRodNodes) + 1, 1, dag_h,
+	    "Xr ", allocList);
 	xorNode->flags |= RF_DAGNODE_FLAG_YIELD;
 	for (i = 0; i < nWndNodes; i++) {
-		xorNode->params[2 * i + 0] = wndNodes[i].params[0];	/* pda */
-		xorNode->params[2 * i + 1] = wndNodes[i].params[1];	/* buf ptr */
+		/* pda */
+		xorNode->params[2 * i + 0] = wndNodes[i].params[0];
+		/* buf ptr */
+		xorNode->params[2 * i + 1] = wndNodes[i].params[1];
 	}
 	for (i = 0; i < nRodNodes; i++) {
-		xorNode->params[2 * (nWndNodes + i) + 0] = rodNodes[i].params[0];	/* pda */
-		xorNode->params[2 * (nWndNodes + i) + 1] = rodNodes[i].params[1];	/* buf ptr */
+		xorNode->params[2 * (nWndNodes + i) + 0] =
+		    rodNodes[i].params[0];	/* pda */
+		xorNode->params[2 * (nWndNodes + i) + 1] =
+		    rodNodes[i].params[1];	/* buf ptr */
 	}
-	xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;	/* xor node needs to get
-									 * at RAID information */
+	/* Xor node needs to get at RAID information. */
+	xorNode->params[2 * (nWndNodes + nRodNodes)].p = raidPtr;
 
-	/* look for an Rod node that reads a complete SU.  If none, alloc a
+	/*
+	 * Look for an Rod node that reads a complete SU. If none, alloc a
 	 * buffer to receive the parity info. Note that we can't use a new
 	 * data buffer because it will not have gotten written when the xor
-	 * occurs. */
+	 * occurs.
+	 */
 	for (i = 0; i < nRodNodes; i++)
-		if (((RF_PhysDiskAddr_t *) rodNodes[i].params[0].p)->numSector == raidPtr->Layout.sectorsPerStripeUnit)
+		if (((RF_PhysDiskAddr_t *) rodNodes[i].params[0].p)
+		    ->numSector == raidPtr->Layout.sectorsPerStripeUnit)
 			break;
 	if (i == nRodNodes) {
-		RF_CallocAndAdd(xorNode->results[0], 1, rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit), (void *), allocList);
+		RF_CallocAndAdd(xorNode->results[0], 1,
+		    rf_RaidAddressToByte(raidPtr,
+		     raidPtr->Layout.sectorsPerStripeUnit), (void *),
+		    allocList);
 	} else {
 		xorNode->results[0] = rodNodes[i].params[1].p;
 	}
 
-	/* initialize the Lpo node */
-	rf_InitNode(lpoNode, rf_wait, RF_FALSE, rf_ParityLogOverwriteFunc, rf_ParityLogOverwriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Lpo", allocList);
+	/* Initialize the Lpo node. */
+	rf_InitNode(lpoNode, rf_wait, RF_FALSE, rf_ParityLogOverwriteFunc,
+	    rf_ParityLogOverwriteUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0,
+	    dag_h, "Lpo", allocList);
 
 	lpoNode->params[0].p = asmap->parityInfo;
 	lpoNode->params[1].p = xorNode->results[0];
-	RF_ASSERT(asmap->parityInfo->next == NULL);	/* parityInfo must
-							 * describe entire
-							 * parity unit */
+	/* parityInfo must describe entire parity unit. */
+	RF_ASSERT(asmap->parityInfo->next == NULL);
 
-	/* connect nodes to form graph */
+	/* Connect nodes to form graph. */
 
-	/* connect dag header to block node */
+	/* Connect dag header to block node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* connect the block node to the Rod nodes */
+	/* Connect the block node to the Rod nodes. */
 	RF_ASSERT(blockNode->numSuccedents == nRodNodes + 1);
 	for (i = 0; i < nRodNodes; i++) {
 		RF_ASSERT(rodNodes[i].numAntecedents == 1);
@@ -208,28 +240,28 @@ rf_CommonCreateParityLoggingLargeWriteDAG(
 		rodNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect the block node to the sync node */
+	/* Connect the block node to the sync node. */
 	/* necessary if nRodNodes == 0 */
 	RF_ASSERT(syncNode->numAntecedents == nRodNodes + 1);
 	blockNode->succedents[nRodNodes] = syncNode;
 	syncNode->antecedents[0] = blockNode;
 	syncNode->antType[0] = rf_control;
 
-	/* connect the Rod nodes to the syncNode */
+	/* Connect the Rod nodes to the syncNode. */
 	for (i = 0; i < nRodNodes; i++) {
 		rodNodes[i].succedents[0] = syncNode;
 		syncNode->antecedents[1 + i] = &rodNodes[i];
 		syncNode->antType[1 + i] = rf_control;
 	}
 
-	/* connect the sync node to the xor node */
+	/* Connect the sync node to the xor node. */
 	RF_ASSERT(syncNode->numSuccedents == nWndNodes + 1);
 	RF_ASSERT(xorNode->numAntecedents == 1);
 	syncNode->succedents[0] = xorNode;
 	xorNode->antecedents[0] = syncNode;
-	xorNode->antType[0] = rf_trueData;	/* carry forward from sync */
+	xorNode->antType[0] = rf_trueData;	/* Carry forward from sync. */
 
-	/* connect the sync node to the Wnd nodes */
+	/* Connect the sync node to the Wnd nodes. */
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNodes->numAntecedents == 1);
 		syncNode->succedents[1 + i] = &wndNodes[i];
@@ -237,14 +269,14 @@ rf_CommonCreateParityLoggingLargeWriteDAG(
 		wndNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect the xor node to the Lpo node */
+	/* Connect the xor node to the Lpo node. */
 	RF_ASSERT(xorNode->numSuccedents == 1);
 	RF_ASSERT(lpoNode->numAntecedents == 1);
 	xorNode->succedents[0] = lpoNode;
 	lpoNode->antecedents[0] = xorNode;
 	lpoNode->antType[0] = rf_trueData;
 
-	/* connect the Wnd nodes to the unblock node */
+	/* Connect the Wnd nodes to the unblock node. */
 	RF_ASSERT(unblockNode->numAntecedents == nWndNodes + 1);
 	for (i = 0; i < nWndNodes; i++) {
 		RF_ASSERT(wndNodes->numSuccedents == 1);
@@ -253,13 +285,13 @@ rf_CommonCreateParityLoggingLargeWriteDAG(
 		unblockNode->antType[i] = rf_control;
 	}
 
-	/* connect the Lpo node to the unblock node */
+	/* Connect the Lpo node to the unblock node. */
 	RF_ASSERT(lpoNode->numSuccedents == 1);
 	lpoNode->succedents[0] = unblockNode;
 	unblockNode->antecedents[nWndNodes] = lpoNode;
 	unblockNode->antType[nWndNodes] = rf_control;
 
-	/* connect unblock node to terminator */
+	/* Connect unblock node to terminator. */
 	RF_ASSERT(unblockNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -269,72 +301,73 @@ rf_CommonCreateParityLoggingLargeWriteDAG(
 }
 
 
-
-
-/******************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a small-write operation (either raid 5 or pq), which is as follows:
+ * Creates a DAG to perform a small-write operation (either raid 5 or pq),
+ * which is as follows:
  *
- *                                     Header
- *                                       |
- *                                     Block
- *                                 / |  ... \   \
- *                                /  |       \   \
- *                             Rod  Rod      Rod  Rop
- *                             | \ /| \    / |  \/ |
- *                             |    |        |  /\ |
- *                             Wnd  Wnd      Wnd   X
- *                              |    \       /     |
- *                              |     \     /      |
- *                               \     \   /      Lpo
- *                                \     \ /       /
- *                                 +-> Unblock <-+
- *                                       |
- *                                       T
+ *				       Header
+ *				          |
+ *				        Block
+ *				    / |  ... \   \
+ *				   /  |       \   \
+ *				Rod  Rod      Rod  Rop
+ *				 | \ /| \    / |  \/ |
+ *				 |    |        |  /\ |
+ *				Wnd  Wnd      Wnd   X
+ *				 |    \       /     |
+ *				 |     \     /      |
+ *				  \     \   /      Lpo
+ *				   \     \ /       /
+ *				    +-> Unblock <-+
+ *				          |
+ *				          T
  *
  *
  * R = Read, W = Write, X = Xor, o = old, n = new, d = data, p = parity.
- * When the access spans a stripe unit boundary and is less than one SU in size, there will
- * be two Rop -- X -- Wnp branches.  I call this the "double-XOR" case.
- * The second output from each Rod node goes to the X node.  In the double-XOR
- * case, there are exactly 2 Rod nodes, and each sends one output to one X node.
+ * When the access spans a stripe unit boundary and is less than one SU in
+ * size, there will be two Rop -- X -- Wnp branches. I call this the
+ * "double-XOR" case.
+ * The second output from each Rod node goes to the X node. In the double-XOR
+ * case, there are exactly 2 Rod nodes, and each sends one output to one X
+ * node.
  * There is one Rod -- Wnd -- T branch for each stripe unit being updated.
  *
- * The block and unblock nodes are unused.  See comment above CreateFaultFreeReadDAG.
+ * The block and unblock nodes are unused. See comment above
+ * CreateFaultFreeReadDAG.
  *
- * Note:  this DAG ignores all the optimizations related to making the RMWs atomic.
- *        it also has the nasty property that none of the buffers allocated for reading
- *        old data & parity can be freed until the XOR node fires.  Need to fix this.
+ * Note:  This DAG ignores all the optimizations related to making the RMWs
+ *        atomic.
+ *        It also has the nasty property that none of the buffers allocated
+ *        for reading old data & parity can be freed until the XOR node fires.
+ *        Need to fix this.
  *
- * A null qfuncs indicates single fault tolerant
+ * A null qfuncs indicates single fault tolerant.
  *****************************************************************************/
 
-void 
-rf_CommonCreateParityLoggingSmallWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_RedFuncs_t * pfuncs,
-    RF_RedFuncs_t * qfuncs)
+void
+rf_CommonCreateParityLoggingSmallWriteDAG(RF_Raid_t *raidPtr,
+    RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
+    RF_RaidAccessFlags_t flags, RF_AllocListElem_t *allocList,
+    RF_RedFuncs_t *pfuncs, RF_RedFuncs_t *qfuncs)
 {
 	RF_DagNode_t *xorNodes, *blockNode, *unblockNode, *nodes;
 	RF_DagNode_t *readDataNodes, *readParityNodes;
 	RF_DagNode_t *writeDataNodes, *lpuNodes;
 	RF_DagNode_t *unlockDataNodes = NULL, *termNode;
 	RF_PhysDiskAddr_t *pda = asmap->physInfo;
-	int     numDataNodes = asmap->numStripeUnitsAccessed;
-	int     numParityNodes = (asmap->parityInfo->next) ? 2 : 1;
-	int     i, j, nNodes, totalNumNodes;
+	int numDataNodes = asmap->numStripeUnitsAccessed;
+	int numParityNodes = (asmap->parityInfo->next) ? 2 : 1;
+	int i, j, nNodes, totalNumNodes;
 	RF_ReconUnitNum_t which_ru;
-	int     (*func) (RF_DagNode_t * node), (*undoFunc) (RF_DagNode_t * node);
-	int     (*qfunc) (RF_DagNode_t * node);
-	char   *name, *qname;
-	RF_StripeNum_t parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout), asmap->raidAddress, &which_ru);
-	long    nfaults = qfuncs ? 2 : 1;
-	int     lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* lock/unlock flag */
+	int (*func) (RF_DagNode_t * node), (*undoFunc) (RF_DagNode_t * node);
+	int (*qfunc) (RF_DagNode_t * node);
+	char*name, *qname;
+	RF_StripeNum_t parityStripeID =
+	    rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
+	     asmap->raidAddress, &which_ru);
+	long nfaults = qfuncs ? 2 : 1;
+	int lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* Lock/unlock flag. */
 
 	if (rf_dagDebug)
 		printf("[Creating parity-logging small-write DAG]\n");
@@ -342,17 +375,24 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 	RF_ASSERT(nfaults == 1);
 	dag_h->creator = "ParityLoggingSmallWriteDAG";
 
-	/* DAG creation occurs in three steps: 1. count the number of nodes in
-	 * the DAG 2. create the nodes 3. initialize the nodes 4. connect the
-	 * nodes */
-
-	/* Step 1. compute number of nodes in the graph */
-
-	/* number of nodes: a read and write for each data unit a redundancy
-	 * computation node for each parity node a read and Lpu for each
-	 * parity unit a block and unblock node (2) a terminator node if
-	 * atomic RMW an unlock node for each data unit, redundancy unit */
-	totalNumNodes = (2 * numDataNodes) + numParityNodes + (2 * numParityNodes) + 3;
+	/*
+	 * DAG creation occurs in three steps:
+	 * 1. Count the number of nodes in the DAG.
+	 * 2. Create the nodes.
+	 * 3. Initialize the nodes.
+	 * 4. Connect the nodes.
+	 */
+
+	/* Step 1. Compute number of nodes in the graph. */
+
+	/*
+	 * Number of nodes: a read and write for each data unit, a redundancy
+	 * computation node for each parity node, a read and Lpu for each
+	 * parity unit, a block and unblock node (2), a terminator node if
+	 * atomic RMW, an unlock node for each data and redundancy unit.
+	 */
+	totalNumNodes = (2 * numDataNodes) + numParityNodes +
+	    (2 * numParityNodes) + 3;
 	if (lu_flag)
 		totalNumNodes += numDataNodes;
 
@@ -362,8 +402,9 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 	dag_h->numCommits = 0;
 	dag_h->numSuccedents = 1;
 
-	/* Step 2. create the nodes */
-	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
+	/* Step 2. Create the nodes. */
+	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
+	    (RF_DagNode_t *), allocList);
 	i = 0;
 	blockNode = &nodes[i];
 	i += 1;
@@ -387,78 +428,103 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 	}
 	RF_ASSERT(i == totalNumNodes);
 
-	/* Step 3. initialize the nodes */
-	/* initialize block node (Nil) */
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h, "Nil", allocList);
+	/* Step 3. Initialize the nodes. */
+	/* Initialize block node (Nil). */
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h,
+	    "Nil", allocList);
 
-	/* initialize unblock node (Nil) */
-	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h, "Nil", allocList);
+	/* Initialize unblock node (Nil). */
+	rf_InitNode(unblockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h,
+	    "Nil", allocList);
 
-	/* initialize terminatory node (Trm) */
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
+	/* Initialize terminatory node (Trm). */
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", allocList);
 
-	/* initialize nodes which read old data (Rod) */
+	/* Initialize nodes which read old data (Rod). */
 	for (i = 0; i < numDataNodes; i++) {
-		rf_InitNode(&readDataNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, nNodes, 1, 4, 0, dag_h, "Rod", allocList);
+		rf_InitNode(&readDataNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+		    nNodes, 1, 4, 0, dag_h, "Rod", allocList);
 		RF_ASSERT(pda != NULL);
-		readDataNodes[i].params[0].p = pda;	/* physical disk addr
-							 * desc */
-		readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda, allocList);	/* buffer to hold old
-												 * data */
+		/* Physical disk addr desc. */
+		readDataNodes[i].params[0].p = pda;
+		readDataNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h,
+		    pda, allocList);	/* Buffer to hold old data. */
 		readDataNodes[i].params[2].v = parityStripeID;
-		readDataNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, lu_flag, 0, which_ru);
+		readDataNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, lu_flag,
+		    0, which_ru);
 		pda = pda->next;
 		readDataNodes[i].propList[0] = NULL;
 		readDataNodes[i].propList[1] = NULL;
 	}
 
-	/* initialize nodes which read old parity (Rop) */
+	/* Initialize nodes which read old parity (Rop). */
 	pda = asmap->parityInfo;
 	i = 0;
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&readParityNodes[i], rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, nNodes, 1, 4, 0, dag_h, "Rop", allocList);
+		rf_InitNode(&readParityNodes[i], rf_wait, RF_FALSE,
+		    rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc,
+		    nNodes, 1, 4, 0, dag_h, "Rop", allocList);
 		readParityNodes[i].params[0].p = pda;
-		readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda, allocList);	/* buffer to hold old
-													 * parity */
+		readParityNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h,
+		    pda, allocList);	/* Buffer to hold old parity. */
 		readParityNodes[i].params[2].v = parityStripeID;
-		readParityNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		readParityNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		readParityNodes[i].propList[0] = NULL;
 		pda = pda->next;
 	}
 
-	/* initialize nodes which write new data (Wnd) */
+	/* Initialize nodes which write new data (Wnd). */
 	pda = asmap->physInfo;
 	for (i = 0; i < numDataNodes; i++) {
 		RF_ASSERT(pda != NULL);
-		rf_InitNode(&writeDataNodes[i], rf_wait, RF_TRUE, rf_DiskWriteFunc, rf_DiskWriteUndoFunc, rf_GenericWakeupFunc, 1, nNodes, 4, 0, dag_h, "Wnd", allocList);
-		writeDataNodes[i].params[0].p = pda;	/* physical disk addr
-							 * desc */
-		writeDataNodes[i].params[1].p = pda->bufPtr;	/* buffer holding new
-								 * data to be written */
+		rf_InitNode(&writeDataNodes[i], rf_wait, RF_TRUE,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		    rf_GenericWakeupFunc, 1, nNodes, 4, 0, dag_h,
+		    "Wnd", allocList);
+		/* Physical disk addr desc. */
+		writeDataNodes[i].params[0].p = pda;
+		/* Buffer holding new data to be written. */
+		writeDataNodes[i].params[1].p = pda->bufPtr;
 		writeDataNodes[i].params[2].v = parityStripeID;
-		writeDataNodes[i].params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		writeDataNodes[i].params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 
 		if (lu_flag) {
-			/* initialize node to unlock the disk queue */
-			rf_InitNode(&unlockDataNodes[i], rf_wait, RF_FALSE, rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Und", allocList);
-			unlockDataNodes[i].params[0].p = pda;	/* physical disk addr
-								 * desc */
-			unlockDataNodes[i].params[1].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, lu_flag, which_ru);
+			/* Initialize node to unlock the disk queue. */
+			rf_InitNode(&unlockDataNodes[i], rf_wait, RF_FALSE,
+			    rf_DiskUnlockFunc, rf_DiskUnlockUndoFunc,
+			    rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h,
+			    "Und", allocList);
+			/* Physical disk addr desc. */
+			unlockDataNodes[i].params[0].p = pda;
+			unlockDataNodes[i].params[1].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0,
+			    lu_flag, which_ru);
 		}
 		pda = pda->next;
 	}
 
 
-	/* initialize nodes which compute new parity */
-	/* we use the simple XOR func in the double-XOR case, and when we're
-	 * accessing only a portion of one stripe unit. the distinction
+	/* Initialize nodes which compute new parity. */
+	/*
+	 * We use the simple XOR func in the double-XOR case, and when we're
+	 * accessing only a portion of one stripe unit. The distinction
 	 * between the two is that the regular XOR func assumes that the
 	 * targbuf is a full SU in size, and examines the pda associated with
 	 * the buffer to decide where within the buffer to XOR the data,
 	 * whereas the simple XOR func just XORs the data into the start of
-	 * the buffer. */
-	if ((numParityNodes == 2) || ((numDataNodes == 1) && (asmap->totalSectorsAccessed < raidPtr->Layout.sectorsPerStripeUnit))) {
+	 * the buffer.
+	 */
+	if ((numParityNodes == 2) || ((numDataNodes == 1) &&
+	    (asmap->totalSectorsAccessed <
+	     raidPtr->Layout.sectorsPerStripeUnit))) {
 		func = pfuncs->simple;
 		undoFunc = rf_NullNodeUndoFunc;
 		name = pfuncs->SimpleName;
@@ -475,12 +541,15 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 			qname = qfuncs->RegularName;
 		}
 	}
-	/* initialize the xor nodes: params are {pda,buf} from {Rod,Wnd,Rop}
-	 * nodes, and raidPtr  */
-	if (numParityNodes == 2) {	/* double-xor case */
+	/*
+	 * Initialize the xor nodes: params are {pda,buf} from {Rod,Wnd,Rop}
+	 * nodes, and raidPtr.
+	 */
+	if (numParityNodes == 2) {	/* Double-XOR case. */
 		for (i = 0; i < numParityNodes; i++) {
-			rf_InitNode(&xorNodes[i], rf_wait, RF_TRUE, func, undoFunc, NULL, 1, nNodes, 7, 1, dag_h, name, allocList);	/* no wakeup func for
-																	 * xor */
+			rf_InitNode(&xorNodes[i], rf_wait, RF_TRUE, func,
+			    undoFunc, NULL, 1, nNodes, 7, 1, dag_h, name,
+			    allocList);	/* No wakeup func for XOR. */
 			xorNodes[i].flags |= RF_DAGNODE_FLAG_YIELD;
 			xorNodes[i].params[0] = readDataNodes[i].params[0];
 			xorNodes[i].params[1] = readDataNodes[i].params[1];
@@ -489,48 +558,57 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 			xorNodes[i].params[4] = writeDataNodes[i].params[0];
 			xorNodes[i].params[5] = writeDataNodes[i].params[1];
 			xorNodes[i].params[6].p = raidPtr;
-			xorNodes[i].results[0] = readParityNodes[i].params[1].p;	/* use old parity buf as
-											 * target buf */
+			/* Use old parity buf as target buf. */
+			xorNodes[i].results[0] = readParityNodes[i].params[1].p;
 		}
 	} else {
-		/* there is only one xor node in this case */
-		rf_InitNode(&xorNodes[0], rf_wait, RF_TRUE, func, undoFunc, NULL, 1, nNodes, (2 * (numDataNodes + numDataNodes + 1) + 1), 1, dag_h, name, allocList);
+		/* There is only one xor node in this case. */
+		rf_InitNode(&xorNodes[0], rf_wait, RF_TRUE, func, undoFunc,
+		    NULL, 1, nNodes,
+		    (2 * (numDataNodes + numDataNodes + 1) + 1), 1,
+		    dag_h, name, allocList);
 		xorNodes[0].flags |= RF_DAGNODE_FLAG_YIELD;
 		for (i = 0; i < numDataNodes + 1; i++) {
-			/* set up params related to Rod and Rop nodes */
-			xorNodes[0].params[2 * i + 0] = readDataNodes[i].params[0];	/* pda */
-			xorNodes[0].params[2 * i + 1] = readDataNodes[i].params[1];	/* buffer pointer */
+			/* Set up params related to Rod and Rop nodes. */
+			xorNodes[0].params[2 * i + 0] =
+			    readDataNodes[i].params[0];	/* pda */
+			xorNodes[0].params[2 * i + 1] =
+			    readDataNodes[i].params[1];	/* Buffer pointer */
 		}
 		for (i = 0; i < numDataNodes; i++) {
-			/* set up params related to Wnd and Wnp nodes */
-			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 0] = writeDataNodes[i].params[0];	/* pda */
-			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 1] = writeDataNodes[i].params[1];	/* buffer pointer */
+			/* Set up params related to Wnd and Wnp nodes. */
+			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 0] =
+			    writeDataNodes[i].params[0]; /* pda */
+			xorNodes[0].params[2 * (numDataNodes + 1 + i) + 1] =
+			    writeDataNodes[i].params[1]; /* Buffer pointer */
 		}
-		xorNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;	/* xor node needs to get
-											 * at RAID information */
+		xorNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p =
+		    raidPtr;	/* Xor node needs to get at RAID information. */
 		xorNodes[0].results[0] = readParityNodes[0].params[1].p;
 	}
 
-	/* initialize the log node(s) */
+	/* Initialize the log node(s). */
 	pda = asmap->parityInfo;
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(pda);
-		rf_InitNode(&lpuNodes[i], rf_wait, RF_FALSE, rf_ParityLogUpdateFunc, rf_ParityLogUpdateUndoFunc, rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Lpu", allocList);
-		lpuNodes[i].params[0].p = pda;	/* PhysDiskAddr of parity */
-		lpuNodes[i].params[1].p = xorNodes[i].results[0];	/* buffer pointer to
-									 * parity */
+		rf_InitNode(&lpuNodes[i], rf_wait, RF_FALSE,
+		    rf_ParityLogUpdateFunc, rf_ParityLogUpdateUndoFunc,
+		    rf_GenericWakeupFunc, 1, 1, 2, 0, dag_h, "Lpu", allocList);
+		lpuNodes[i].params[0].p = pda;	/* PhysDiskAddr of parity. */
+		/* Buffer pointer to parity. */
+		lpuNodes[i].params[1].p = xorNodes[i].results[0];
 		pda = pda->next;
 	}
 
 
-	/* Step 4. connect the nodes */
+	/* Step 4. Connect the nodes. */
 
-	/* connect header to block node */
+	/* Connect header to block node. */
 	RF_ASSERT(dag_h->numSuccedents == 1);
 	RF_ASSERT(blockNode->numAntecedents == 0);
 	dag_h->succedents[0] = blockNode;
 
-	/* connect block node to read old data nodes */
+	/* Connect block node to read old data nodes. */
 	RF_ASSERT(blockNode->numSuccedents == (numDataNodes + numParityNodes));
 	for (i = 0; i < numDataNodes; i++) {
 		blockNode->succedents[i] = &readDataNodes[i];
@@ -539,7 +617,7 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 		readDataNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect block node to read old parity nodes */
+	/* Connect block node to read old parity nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		blockNode->succedents[numDataNodes + i] = &readParityNodes[i];
 		RF_ASSERT(readParityNodes[i].numAntecedents == 1);
@@ -547,11 +625,13 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 		readParityNodes[i].antType[0] = rf_control;
 	}
 
-	/* connect read old data nodes to write new data nodes */
+	/* Connect read old data nodes to write new data nodes. */
 	for (i = 0; i < numDataNodes; i++) {
-		RF_ASSERT(readDataNodes[i].numSuccedents == numDataNodes + numParityNodes);
+		RF_ASSERT(readDataNodes[i].numSuccedents ==
+		          numDataNodes + numParityNodes);
 		for (j = 0; j < numDataNodes; j++) {
-			RF_ASSERT(writeDataNodes[j].numAntecedents == numDataNodes + numParityNodes);
+			RF_ASSERT(writeDataNodes[j].numAntecedents ==
+			          numDataNodes + numParityNodes);
 			readDataNodes[i].succedents[j] = &writeDataNodes[j];
 			writeDataNodes[j].antecedents[i] = &readDataNodes[i];
 			if (i == j)
@@ -561,34 +641,41 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 		}
 	}
 
-	/* connect read old data nodes to xor nodes */
+	/* Connect read old data nodes to xor nodes. */
 	for (i = 0; i < numDataNodes; i++)
 		for (j = 0; j < numParityNodes; j++) {
-			RF_ASSERT(xorNodes[j].numAntecedents == numDataNodes + numParityNodes);
-			readDataNodes[i].succedents[numDataNodes + j] = &xorNodes[j];
+			RF_ASSERT(xorNodes[j].numAntecedents ==
+			          numDataNodes + numParityNodes);
+			readDataNodes[i].succedents[numDataNodes + j] =
+			    &xorNodes[j];
 			xorNodes[j].antecedents[i] = &readDataNodes[i];
 			xorNodes[j].antType[i] = rf_trueData;
 		}
 
-	/* connect read old parity nodes to write new data nodes */
+	/* Connect read old parity nodes to write new data nodes. */
 	for (i = 0; i < numParityNodes; i++) {
-		RF_ASSERT(readParityNodes[i].numSuccedents == numDataNodes + numParityNodes);
+		RF_ASSERT(readParityNodes[i].numSuccedents ==
+		          numDataNodes + numParityNodes);
 		for (j = 0; j < numDataNodes; j++) {
 			readParityNodes[i].succedents[j] = &writeDataNodes[j];
-			writeDataNodes[j].antecedents[numDataNodes + i] = &readParityNodes[i];
-			writeDataNodes[j].antType[numDataNodes + i] = rf_control;
+			writeDataNodes[j].antecedents[numDataNodes + i] =
+			    &readParityNodes[i];
+			writeDataNodes[j].antType[numDataNodes + i] =
+			    rf_control;
 		}
 	}
 
-	/* connect read old parity nodes to xor nodes */
+	/* Connect read old parity nodes to xor nodes. */
 	for (i = 0; i < numParityNodes; i++)
 		for (j = 0; j < numParityNodes; j++) {
-			readParityNodes[i].succedents[numDataNodes + j] = &xorNodes[j];
-			xorNodes[j].antecedents[numDataNodes + i] = &readParityNodes[i];
+			readParityNodes[i].succedents[numDataNodes + j] =
+			    &xorNodes[j];
+			xorNodes[j].antecedents[numDataNodes + i] =
+			    &readParityNodes[i];
 			xorNodes[j].antType[numDataNodes + i] = rf_trueData;
 		}
 
-	/* connect xor nodes to write new parity nodes */
+	/* Connect xor nodes to write new parity nodes. */
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(xorNodes[i].numSuccedents == 1);
 		RF_ASSERT(lpuNodes[i].numAntecedents == 1);
@@ -599,30 +686,32 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 
 	for (i = 0; i < numDataNodes; i++) {
 		if (lu_flag) {
-			/* connect write new data nodes to unlock nodes */
+			/* Connect write new data nodes to unlock nodes. */
 			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
 			RF_ASSERT(unlockDataNodes[i].numAntecedents == 1);
 			writeDataNodes[i].succedents[0] = &unlockDataNodes[i];
 			unlockDataNodes[i].antecedents[0] = &writeDataNodes[i];
 			unlockDataNodes[i].antType[0] = rf_control;
 
-			/* connect unlock nodes to unblock node */
+			/* Connect unlock nodes to unblock node. */
 			RF_ASSERT(unlockDataNodes[i].numSuccedents == 1);
-			RF_ASSERT(unblockNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
+			RF_ASSERT(unblockNode->numAntecedents ==
+			          (numDataNodes + (nfaults * numParityNodes)));
 			unlockDataNodes[i].succedents[0] = unblockNode;
 			unblockNode->antecedents[i] = &unlockDataNodes[i];
 			unblockNode->antType[i] = rf_control;
 		} else {
-			/* connect write new data nodes to unblock node */
+			/* Connect write new data nodes to unblock node. */
 			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
-			RF_ASSERT(unblockNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
+			RF_ASSERT(unblockNode->numAntecedents ==
+			          (numDataNodes + (nfaults * numParityNodes)));
 			writeDataNodes[i].succedents[0] = unblockNode;
 			unblockNode->antecedents[i] = &writeDataNodes[i];
 			unblockNode->antType[i] = rf_control;
 		}
 	}
 
-	/* connect write new parity nodes to unblock node */
+	/* Connect write new parity nodes to unblock node. */
 	for (i = 0; i < numParityNodes; i++) {
 		RF_ASSERT(lpuNodes[i].numSuccedents == 1);
 		lpuNodes[i].succedents[0] = unblockNode;
@@ -630,7 +719,7 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 		unblockNode->antType[numDataNodes + i] = rf_control;
 	}
 
-	/* connect unblock node to terminator */
+	/* Connect unblock node to terminator. */
 	RF_ASSERT(unblockNode->numSuccedents == 1);
 	RF_ASSERT(termNode->numAntecedents == 1);
 	RF_ASSERT(termNode->numSuccedents == 0);
@@ -640,34 +729,26 @@ rf_CommonCreateParityLoggingSmallWriteDAG(
 }
 
 
-void 
-rf_CreateParityLoggingSmallWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    RF_RedFuncs_t * pfuncs,
-    RF_RedFuncs_t * qfuncs)
+void
+rf_CreateParityLoggingSmallWriteDAG(RF_Raid_t *raidPtr,
+    RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
+    RF_RaidAccessFlags_t flags, RF_AllocListElem_t *allocList,
+    RF_RedFuncs_t *pfuncs, RF_RedFuncs_t *qfuncs)
 {
 	dag_h->creator = "ParityLoggingSmallWriteDAG";
-	rf_CommonCreateParityLoggingSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_xorFuncs, NULL);
+	rf_CommonCreateParityLoggingSmallWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList, &rf_xorFuncs, NULL);
 }
 
 
-void 
-rf_CreateParityLoggingLargeWriteDAG(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_DagHeader_t * dag_h,
-    void *bp,
-    RF_RaidAccessFlags_t flags,
-    RF_AllocListElem_t * allocList,
-    int nfaults,
+void
+rf_CreateParityLoggingLargeWriteDAG(RF_Raid_t *raidPtr,
+    RF_AccessStripeMap_t *asmap, RF_DagHeader_t *dag_h, void *bp,
+    RF_RaidAccessFlags_t flags, RF_AllocListElem_t *allocList, int nfaults,
     int (*redFunc) (RF_DagNode_t *))
 {
 	dag_h->creator = "ParityLoggingSmallWriteDAG";
-	rf_CommonCreateParityLoggingLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 1, rf_RegularXorFunc);
+	rf_CommonCreateParityLoggingLargeWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList, 1, rf_RegularXorFunc);
 }
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_parityloggingdags.h b/sys/dev/raidframe/rf_parityloggingdags.h
index 91ee70a9487..8067e9d95ad 100644
--- a/sys/dev/raidframe/rf_parityloggingdags.h
+++ b/sys/dev/raidframe/rf_parityloggingdags.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_parityloggingdags.h,v 1.2 1999/02/16 00:03:08 niklas Exp $	*/
+/*	$OpenBSD: rf_parityloggingdags.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_parityloggingdags.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,31 +30,29 @@
 
 /****************************************************************************
  *                                                                          *
- * rf_parityloggingdags.h -- header file for parity logging dags            *
+ * rf_parityloggingdags.h -- Header file for parity logging dags.           *
  *                                                                          *
  ****************************************************************************/
 
-#ifndef _RF__RF_PARITYLOGGINGDAGS_H_
-#define _RF__RF_PARITYLOGGINGDAGS_H_
+#ifndef	_RF__RF_PARITYLOGGINGDAGS_H_
+#define	_RF__RF_PARITYLOGGINGDAGS_H_
+
+/* Routines that create DAGs. */
 
-/* routines that create DAGs */
-void 
-rf_CommonCreateParityLoggingLargeWriteDAG(RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h,
-    void *bp, RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-    int nfaults, int (*redFunc) (RF_DagNode_t *));
-	void    rf_CommonCreateParityLoggingSmallWriteDAG(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h,
-            void *bp, RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-            RF_RedFuncs_t * pfuncs, RF_RedFuncs_t * qfuncs);
+void rf_CommonCreateParityLoggingLargeWriteDAG(RF_Raid_t *,
+	RF_AccessStripeMap_t *, RF_DagHeader_t *, void *,
+	RF_RaidAccessFlags_t, RF_AllocListElem_t *, int,
+	int (*) (RF_DagNode_t *));
+void rf_CommonCreateParityLoggingSmallWriteDAG(RF_Raid_t *,
+	RF_AccessStripeMap_t *, RF_DagHeader_t *, void *,
+	RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_RedFuncs_t *, RF_RedFuncs_t *);
 
-	void    rf_CreateParityLoggingLargeWriteDAG(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h,
-            void *bp, RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-            int nfaults, int (*redFunc) (RF_DagNode_t *));
-	void    rf_CreateParityLoggingSmallWriteDAG(RF_Raid_t * raidPtr,
-            RF_AccessStripeMap_t * asmap, RF_DagHeader_t * dag_h,
-            void *bp, RF_RaidAccessFlags_t flags, RF_AllocListElem_t * allocList,
-            RF_RedFuncs_t * pfuncs, RF_RedFuncs_t * qfuncs);
+void rf_CreateParityLoggingLargeWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	int, int (*) (RF_DagNode_t *));
+void rf_CreateParityLoggingSmallWriteDAG(RF_Raid_t *, RF_AccessStripeMap_t *,
+	RF_DagHeader_t *, void *, RF_RaidAccessFlags_t, RF_AllocListElem_t *,
+	RF_RedFuncs_t *, RF_RedFuncs_t *);
 
-#endif				/* !_RF__RF_PARITYLOGGINGDAGS_H_ */
+#endif	/* !_RF__RF_PARITYLOGGINGDAGS_H_ */
diff --git a/sys/dev/raidframe/rf_parityscan.c b/sys/dev/raidframe/rf_parityscan.c
index 3a46b610d53..860388c33d8 100644
--- a/sys/dev/raidframe/rf_parityscan.c
+++ b/sys/dev/raidframe/rf_parityscan.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_parityscan.c,v 1.6 2000/08/08 16:07:44 peter Exp $	*/
+/*	$OpenBSD: rf_parityscan.c,v 1.7 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_parityscan.c,v 1.9 2000/05/28 03:00:31 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,7 +30,7 @@
 
 /*****************************************************************************
  *
- * rf_parityscan.c -- misc utilities related to parity verification
+ * rf_parityscan.c -- Misc utilities related to parity verification.
  *
  *****************************************************************************/
 
@@ -44,22 +45,21 @@
 #include "rf_parityscan.h"
 #include "rf_map.h"
 
-/*****************************************************************************************
+
+/*****************************************************************************
  *
- * walk through the entire arry and write new parity.
+ * Walk through the entire arry and write new parity.
  * This works by creating two DAGs, one to read a stripe of data and one to
- * write new parity.  The first is executed, the data is xored together, and
- * then the second is executed.  To avoid constantly building and tearing down
+ * write new parity. The first is executed, the data is xored together, and
+ * then the second is executed. To avoid constantly building and tearing down
  * the DAGs, we create them a priori and fill them in with the mapping
  * information as we go along.
  *
- * there should never be more than one thread running this.
+ * There should never be more than one thread running this.
  *
- ****************************************************************************************/
-
-int 
-rf_RewriteParity(raidPtr)
-	RF_Raid_t *raidPtr;
+ *****************************************************************************/
+int
+rf_RewriteParity(RF_Raid_t *raidPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_AccessStripeMapHeader_t *asm_h;
@@ -74,9 +74,9 @@ rf_RewriteParity(raidPtr)
 	}
 	if (raidPtr->status[0] != rf_rs_optimal) {
 		/*
-		 * We're in degraded mode.  Don't try to verify parity now! 
-		 * XXX: this should be a "we don't want to", not a 
-		 * "we can't" error. 
+		 * We're in degraded mode. Don't try to verify parity now !
+		 * XXX: This should be a "we don't want to", not a
+		 * "we can't" error.
 		 */
 		return (RF_PARITY_COULD_NOT_VERIFY);
 	}
@@ -87,18 +87,18 @@ rf_RewriteParity(raidPtr)
 	pda.numSector = raidPtr->Layout.sectorsPerStripeUnit;
 	rc = RF_PARITY_OKAY;
 
-	for (i = 0; i < raidPtr->totalSectors && 
-		     rc <= RF_PARITY_CORRECTED; 
+	for (i = 0; i < raidPtr->totalSectors && rc <= RF_PARITY_CORRECTED;
 	     i += layoutPtr->dataSectorsPerStripe) {
 		if (raidPtr->waitShutdown) {
-			/* Someone is pulling the plug on this set...
-			   abort the re-write */
+			/*
+			 * Someone is pulling the plug on this set...
+			 * Abort the re-write.
+			 */
 			return (1);
 		}
-		asm_h = rf_MapAccess(raidPtr, i, 
-				     layoutPtr->dataSectorsPerStripe, 
-				     NULL, RF_DONT_REMAP);
-		raidPtr->parity_rewrite_stripes_done = 
+		asm_h = rf_MapAccess(raidPtr, i,
+		    layoutPtr->dataSectorsPerStripe, NULL, RF_DONT_REMAP);
+		raidPtr->parity_rewrite_stripes_done =
 			i / layoutPtr->dataSectorsPerStripe ;
 		rc = rf_VerifyParity(raidPtr, asm_h->stripeMap, 1, 0);
 		switch (rc) {
@@ -106,65 +106,66 @@ rf_RewriteParity(raidPtr)
 		case RF_PARITY_CORRECTED:
 			break;
 		case RF_PARITY_BAD:
-			printf("Parity bad during correction\n");
+			printf("Parity bad during correction.\n");
 			ret_val = 1;
 			break;
 		case RF_PARITY_COULD_NOT_CORRECT:
-			printf("Could not correct bad parity\n");
+			printf("Could not correct bad parity.\n");
 			ret_val = 1;
 			break;
 		case RF_PARITY_COULD_NOT_VERIFY:
-			printf("Could not verify parity\n");
+			printf("Could not verify parity.\n");
 			ret_val = 1;
 			break;
 		default:
-			printf("Bad rc=%d from VerifyParity in RewriteParity\n", rc);
+			printf("Bad rc=%d from VerifyParity in"
+			    " RewriteParity.\n", rc);
 			ret_val = 1;
 		}
 		rf_FreeAccessStripeMap(asm_h);
 	}
 	return (ret_val);
 }
-/*****************************************************************************************
+
+
+/*****************************************************************************
  *
- * verify that the parity in a particular stripe is correct.
- * we validate only the range of parity defined by parityPDA, since
- * this is all we have locked.  The way we do this is to create an asm
+ * Verify that the parity in a particular stripe is correct.
+ * We validate only the range of parity defined by parityPDA, since
+ * this is all we have locked. The way we do this is to create an asm
  * that maps the whole stripe and then range-restrict it to the parity
  * region defined by the parityPDA.
  *
- ****************************************************************************************/
-int 
-rf_VerifyParity(raidPtr, aasm, correct_it, flags)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *aasm;
-	int     correct_it;
-	RF_RaidAccessFlags_t flags;
+ *****************************************************************************/
+int
+rf_VerifyParity(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *aasm, int correct_it,
+    RF_RaidAccessFlags_t flags)
 {
 	RF_PhysDiskAddr_t *parityPDA;
 	RF_AccessStripeMap_t *doasm;
 	RF_LayoutSW_t *lp;
-	int     lrc, rc;
+	int lrc, rc;
 
 	lp = raidPtr->Layout.map;
 	if (lp->faultsTolerated == 0) {
 		/*
-	         * There isn't any parity. Call it "okay."
-	         */
+		 * There isn't any parity. Call it "okay."
+		 */
 		return (RF_PARITY_OKAY);
 	}
 	rc = RF_PARITY_OKAY;
 	if (lp->VerifyParity) {
 		for (doasm = aasm; doasm; doasm = doasm->next) {
-			for (parityPDA = doasm->parityInfo; parityPDA; 
+			for (parityPDA = doasm->parityInfo; parityPDA;
 			     parityPDA = parityPDA->next) {
-				lrc = lp->VerifyParity(raidPtr, 
-						       doasm->raidAddress, 
-						       parityPDA,
-						       correct_it, flags);
+				lrc = lp->VerifyParity(raidPtr,
+				    doasm->raidAddress, parityPDA, correct_it,
+				    flags);
 				if (lrc > rc) {
-					/* see rf_parityscan.h for why this
-					 * works */
+					/*
+					 * see rf_parityscan.h for why this
+					 * works.
+					 */
 					rc = lrc;
 				}
 			}
@@ -175,33 +176,28 @@ rf_VerifyParity(raidPtr, aasm, correct_it, flags)
 	return (rc);
 }
 
-int 
-rf_VerifyParityBasic(raidPtr, raidAddr, parityPDA, correct_it, flags)
-	RF_Raid_t *raidPtr;
-	RF_RaidAddr_t raidAddr;
-	RF_PhysDiskAddr_t *parityPDA;
-	int     correct_it;
-	RF_RaidAccessFlags_t flags;
+int
+rf_VerifyParityBasic(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
+    RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_RaidAddr_t startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
-								     raidAddr);
+	    raidAddr);
 	RF_SectorCount_t numsector = parityPDA->numSector;
-	int     numbytes = rf_RaidAddressToByte(raidPtr, numsector);
-	int     bytesPerStripe = numbytes * layoutPtr->numDataCol;
-	RF_DagHeader_t *rd_dag_h, *wr_dag_h;	/* read, write dag */
+	int numbytes = rf_RaidAddressToByte(raidPtr, numsector);
+	int bytesPerStripe = numbytes * layoutPtr->numDataCol;
+	RF_DagHeader_t *rd_dag_h, *wr_dag_h;	/* Read, write dag. */
 	RF_DagNode_t *blockNode, *unblockNode, *wrBlock, *wrUnblock;
 	RF_AccessStripeMapHeader_t *asm_h;
 	RF_AccessStripeMap_t *asmap;
 	RF_AllocListElem_t *alloclist;
 	RF_PhysDiskAddr_t *pda;
-	char   *pbuf, *buf, *end_p, *p;
-	int     i, retcode;
+	char *pbuf, *buf, *end_p, *p;
+	int i, retcode;
 	RF_ReconUnitNum_t which_ru;
 	RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr,
-							     raidAddr,
-							     &which_ru);
-	int     stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
+	    raidAddr, &which_ru);
+	int stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
 	RF_AccTraceEntry_t tracerec;
 	RF_MCPair_t *mcpair;
 
@@ -209,30 +205,37 @@ rf_VerifyParityBasic(raidPtr, raidAddr, parityPDA, correct_it, flags)
 
 	mcpair = rf_AllocMCPair();
 	rf_MakeAllocList(alloclist);
-	RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol), (char *), alloclist);
-	RF_CallocAndAdd(pbuf, 1, numbytes, (char *), alloclist);	/* use calloc to make
-									 * sure buffer is zeroed */
+	RF_MallocAndAdd(buf, numbytes * (layoutPtr->numDataCol +
+	    layoutPtr->numParityCol), (char *), alloclist);
+	/* Use calloc to make sure buffer is zeroed. */
+	RF_CallocAndAdd(pbuf, 1, numbytes, (char *), alloclist);
 	end_p = buf + bytesPerStripe;
 
-	rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf, rf_DiskReadFunc, rf_DiskReadUndoFunc,
+	rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, numbytes, buf,
+	    rf_DiskReadFunc, rf_DiskReadUndoFunc,
 	    "Rod", alloclist, flags, RF_IO_NORMAL_PRIORITY);
 	blockNode = rd_dag_h->succedents[0];
 	unblockNode = blockNode->succedents[0]->succedents[0];
 
-	/* map the stripe and fill in the PDAs in the dag */
-	asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
+	/* Map the stripe and fill in the PDAs in the dag. */
+	asm_h = rf_MapAccess(raidPtr, startAddr,
+	    layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
 	asmap = asm_h->stripeMap;
 
-	for (pda = asmap->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) {
+	for (pda = asmap->physInfo, i = 0; i < layoutPtr->numDataCol;
+	     i++, pda = pda->next) {
 		RF_ASSERT(pda);
 		rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
 		RF_ASSERT(pda->numSector != 0);
 		if (rf_TryToRedirectPDA(raidPtr, pda, 0))
-			goto out;	/* no way to verify parity if disk is
-					 * dead.  return w/ good status */
+			goto out;	/*
+					 * No way to verify parity if disk is
+					 * dead. Return w/ good status.
+					 */
 		blockNode->succedents[i]->params[0].p = pda;
 		blockNode->succedents[i]->params[2].v = psID;
-		blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		blockNode->succedents[i]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 	}
 
 	RF_ASSERT(!asmap->parityInfo->next);
@@ -240,9 +243,10 @@ rf_VerifyParityBasic(raidPtr, raidAddr, parityPDA, correct_it, flags)
 	RF_ASSERT(asmap->parityInfo->numSector != 0);
 	if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
 		goto out;
-	blockNode->succedents[layoutPtr->numDataCol]->params[0].p = asmap->parityInfo;
+	blockNode->succedents[layoutPtr->numDataCol]->params[0].p =
+	    asmap->parityInfo;
 
-	/* fire off the DAG */
+	/* Fire off the DAG. */
 	bzero((char *) &tracerec, sizeof(tracerec));
 	rd_dag_h->tracerec = &tracerec;
 
@@ -258,7 +262,8 @@ rf_VerifyParityBasic(raidPtr, raidAddr, parityPDA, correct_it, flags)
 		RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 	RF_UNLOCK_MUTEX(mcpair->mutex);
 	if (rd_dag_h->status != rf_enable) {
-		RF_ERRORMSG("Unable to verify parity:  can't read the stripe\n");
+		RF_ERRORMSG("Unable to verify parity:  can't read the"
+		            " stripe.\n");
 		retcode = RF_PARITY_COULD_NOT_VERIFY;
 		goto out;
 	}
@@ -268,26 +273,31 @@ rf_VerifyParityBasic(raidPtr, raidAddr, parityPDA, correct_it, flags)
 	for (i = 0; i < numbytes; i++) {
 #if 0
 		if (pbuf[i] != 0 || buf[bytesPerStripe + i] != 0) {
-			printf("Bytes: %d %d %d\n", i, pbuf[i], buf[bytesPerStripe + i]);
+			printf("Bytes: %d %d %d\n", i, pbuf[i],
+			    buf[bytesPerStripe + i]);
 		}
 #endif
 		if (pbuf[i] != buf[bytesPerStripe + i]) {
 			if (!correct_it)
-				RF_ERRORMSG3("Parity verify error: byte %d of parity is 0x%x should be 0x%x\n",
-				    i, (u_char) buf[bytesPerStripe + i], (u_char) pbuf[i]);
+				RF_ERRORMSG3("Parity verify error: byte %d of"
+				    " parity is 0x%x should be 0x%x.\n", i,
+				    (u_char) buf[bytesPerStripe + i],
+				    (u_char) pbuf[i]);
 			retcode = RF_PARITY_BAD;
 			break;
 		}
 	}
 
 	if (retcode && correct_it) {
-		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf, rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
+		wr_dag_h = rf_MakeSimpleDAG(raidPtr, 1, numbytes, pbuf,
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc,
 		    "Wnp", alloclist, flags, RF_IO_NORMAL_PRIORITY);
 		wrBlock = wr_dag_h->succedents[0];
 		wrUnblock = wrBlock->succedents[0]->succedents[0];
 		wrBlock->succedents[0]->params[0].p = asmap->parityInfo;
 		wrBlock->succedents[0]->params[2].v = psID;
-		wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		wrBlock->succedents[0]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		bzero((char *) &tracerec, sizeof(tracerec));
 		wr_dag_h->tracerec = &tracerec;
 		if (rf_verifyParityDebug) {
@@ -296,13 +306,14 @@ rf_VerifyParityBasic(raidPtr, raidAddr, parityPDA, correct_it, flags)
 		}
 		RF_LOCK_MUTEX(mcpair->mutex);
 		mcpair->flag = 0;
-		rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-		    (void *) mcpair);
+		rf_DispatchDAG(wr_dag_h, (void (*) (void *))
+		    rf_MCPairWakeupFunc, (void *) mcpair);
 		while (!mcpair->flag)
 			RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 		RF_UNLOCK_MUTEX(mcpair->mutex);
 		if (wr_dag_h->status != rf_enable) {
-			RF_ERRORMSG("Unable to correct parity in VerifyParity:  can't write the stripe\n");
+			RF_ERRORMSG("Unable to correct parity in VerifyParity:"
+			    "  can't write the stripe.\n");
 			retcode = RF_PARITY_COULD_NOT_CORRECT;
 		}
 		rf_FreeDAG(wr_dag_h);
@@ -317,31 +328,45 @@ out:
 	return (retcode);
 }
 
-int 
-rf_TryToRedirectPDA(raidPtr, pda, parity)
-	RF_Raid_t *raidPtr;
-	RF_PhysDiskAddr_t *pda;
-	int     parity;
+int
+rf_TryToRedirectPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda, int parity)
 {
 	if (raidPtr->Disks[pda->row][pda->col].status == rf_ds_reconstructing) {
-		if (rf_CheckRUReconstructed(raidPtr->reconControl[pda->row]->reconMap, pda->startSector)) {
+		if (rf_CheckRUReconstructed(raidPtr->reconControl[pda->row]
+		     ->reconMap, pda->startSector)) {
 			if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
 				RF_RowCol_t or = pda->row, oc = pda->col;
 				RF_SectorNum_t os = pda->startSector;
 				if (parity) {
-					(raidPtr->Layout.map->MapParity) (raidPtr, pda->raidAddress, &pda->row, &pda->col, &pda->startSector, RF_REMAP);
+					(raidPtr->Layout.map->MapParity)
+					    (raidPtr, pda->raidAddress,
+					     &pda->row, &pda->col,
+					     &pda->startSector, RF_REMAP);
 					if (rf_verifyParityDebug)
-						printf("VerifyParity: Redir P r %d c %d sect %ld -> r %d c %d sect %ld\n",
-						    or, oc, (long) os, pda->row, pda->col, (long) pda->startSector);
+						printf("VerifyParity: Redir P"
+						    " r %d c %d sect %ld ->"
+						    " r %d c %d sect %ld.\n",
+						    or, oc, (long) os,
+						    pda->row, pda->col,
+						    (long) pda->startSector);
 				} else {
-					(raidPtr->Layout.map->MapSector) (raidPtr, pda->raidAddress, &pda->row, &pda->col, &pda->startSector, RF_REMAP);
+					(raidPtr->Layout.map->MapSector)
+					    (raidPtr, pda->raidAddress,
+					     &pda->row, &pda->col,
+					     &pda->startSector, RF_REMAP);
 					if (rf_verifyParityDebug)
-						printf("VerifyParity: Redir D r %d c %d sect %ld -> r %d c %d sect %ld\n",
-						    or, oc, (long) os, pda->row, pda->col, (long) pda->startSector);
+						printf("VerifyParity: Redir D"
+						    " r %d c %d sect %ld ->"
+						    " r %d c %d sect %ld.\n",
+						    or, oc, (long) os,
+						    pda->row, pda->col,
+						    (long) pda->startSector);
 				}
 			} else {
-				RF_RowCol_t spRow = raidPtr->Disks[pda->row][pda->col].spareRow;
-				RF_RowCol_t spCol = raidPtr->Disks[pda->row][pda->col].spareCol;
+				RF_RowCol_t spRow =
+				    raidPtr->Disks[pda->row][pda->col].spareRow;
+				RF_RowCol_t spCol =
+				    raidPtr->Disks[pda->row][pda->col].spareCol;
 				pda->row = spRow;
 				pda->col = spCol;
 			}
@@ -351,90 +376,99 @@ rf_TryToRedirectPDA(raidPtr, pda, parity)
 		return (1);
 	return (0);
 }
-/*****************************************************************************************
+
+
+/*****************************************************************************
  *
- * currently a stub.
+ * Currently a stub.
  *
- * takes as input an ASM describing a write operation and containing one failure, and
- * verifies that the parity was correctly updated to reflect the write.
+ * Takes as input an ASM describing a write operation and containing one
+ * failure, and verifies that the parity was correctly updated to reflect the
+ * write.
  *
- * if it's a data unit that's failed, we read the other data units in the stripe and
- * the parity unit, XOR them together, and verify that we get the data intended for
- * the failed disk.  Since it's easy, we also validate that the right data got written
- * to the surviving data disks.
+ * If it's a data unit that has failed, we read the other data units in the
+ * stripe and the parity unit, XOR them together, and verify that we get the
+ * data intended for the failed disk. Since it's easy, we also validate that
+ * the right data got written to the surviving data disks.
  *
- * If it's the parity that failed, there's really no validation we can do except the
- * above verification that the right data got written to all disks.  This is because
- * the new data intended for the failed disk is supplied in the ASM, but this is of
- * course not the case for the new parity.
+ * If it's the parity that failed, there's really no validation we can do
+ * except the above verification that the right data got written to all disks.
+ * This is because the new data intended for the failed disk is supplied in
+ * the ASM, but this is of course not the case for the new parity.
  *
- ****************************************************************************************/
-int 
-rf_VerifyDegrModeWrite(raidPtr, asmh)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMapHeader_t *asmh;
+ *****************************************************************************/
+int
+rf_VerifyDegrModeWrite(RF_Raid_t *raidPtr, RF_AccessStripeMapHeader_t *asmh)
 {
 	return (0);
 }
-/* creates a simple DAG with a header, a block-recon node at level 1,
+
+
+/*
+ * Creates a simple DAG with a header, a block-recon node at level 1,
  * nNodes nodes at level 2, an unblock-recon node at level 3, and
- * a terminator node at level 4.  The stripe address field in
+ * a terminator node at level 4. The stripe address field in
  * the block and unblock nodes are not touched, nor are the pda
  * fields in the second-level nodes, so they must be filled in later.
  *
- * commit point is established at unblock node - this means that any
- * failure during dag execution causes the dag to fail
+ * Commit point is established at unblock node - this means that any
+ * failure during dag execution causes the dag to fail.
  */
 RF_DagHeader_t *
-rf_MakeSimpleDAG(raidPtr, nNodes, bytesPerSU, databuf, doFunc, undoFunc, name, alloclist, flags, priority)
-	RF_Raid_t *raidPtr;
-	int     nNodes;
-	int     bytesPerSU;
-	char   *databuf;
-	int     (*doFunc) (RF_DagNode_t * node);
-	int     (*undoFunc) (RF_DagNode_t * node);
-	char   *name;		/* node names at the second level */
-	RF_AllocListElem_t *alloclist;
-	RF_RaidAccessFlags_t flags;
-	int     priority;
+rf_MakeSimpleDAG(RF_Raid_t *raidPtr, int nNodes, int bytesPerSU, char *databuf,
+    int (*doFunc) (RF_DagNode_t * node), int (*undoFunc) (RF_DagNode_t * node),
+    char *name	/* Node names at the second level. */,
+    RF_AllocListElem_t *alloclist, RF_RaidAccessFlags_t flags, int priority)
 {
 	RF_DagHeader_t *dag_h;
 	RF_DagNode_t *nodes, *termNode, *blockNode, *unblockNode;
-	int     i;
+	int i;
 
-	/* create the nodes, the block & unblock nodes, and the terminator
-	 * node */
-	RF_CallocAndAdd(nodes, nNodes + 3, sizeof(RF_DagNode_t), (RF_DagNode_t *), alloclist);
+	/*
+	 * Create the nodes, the block & unblock nodes, and the terminator
+	 * node.
+	 */
+	RF_CallocAndAdd(nodes, nNodes + 3, sizeof(RF_DagNode_t),
+	    (RF_DagNode_t *), alloclist);
 	blockNode = &nodes[nNodes];
 	unblockNode = blockNode + 1;
 	termNode = unblockNode + 1;
 
 	dag_h = rf_AllocDAGHeader();
 	dag_h->raidPtr = (void *) raidPtr;
-	dag_h->allocList = NULL;/* we won't use this alloc list */
+	dag_h->allocList = NULL;	/* We won't use this alloc list. */
 	dag_h->status = rf_enable;
 	dag_h->numSuccedents = 1;
 	dag_h->creator = "SimpleDAG";
 
-	/* this dag can not commit until the unblock node is reached errors
-	 * prior to the commit point imply the dag has failed */
+	/*
+	 * This dag can not commit until the unblock node is reached.
+	 * Errors prior to the commit point imply the dag has failed.
+	 */
 	dag_h->numCommitNodes = 1;
 	dag_h->numCommits = 0;
 
 	dag_h->succedents[0] = blockNode;
-	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h, "Nil", alloclist);
-	rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc, rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h, "Nil", alloclist);
+	rf_InitNode(blockNode, rf_wait, RF_FALSE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, nNodes, 0, 0, 0, dag_h,
+	    "Nil", alloclist);
+	rf_InitNode(unblockNode, rf_wait, RF_TRUE, rf_NullNodeFunc,
+	    rf_NullNodeUndoFunc, NULL, 1, nNodes, 0, 0, dag_h,
+	    "Nil", alloclist);
 	unblockNode->succedents[0] = termNode;
 	for (i = 0; i < nNodes; i++) {
-		blockNode->succedents[i] = unblockNode->antecedents[i] = &nodes[i];
+		blockNode->succedents[i] = unblockNode->antecedents[i]
+					 = &nodes[i];
 		unblockNode->antType[i] = rf_control;
-		rf_InitNode(&nodes[i], rf_wait, RF_FALSE, doFunc, undoFunc, rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, alloclist);
+		rf_InitNode(&nodes[i], rf_wait, RF_FALSE, doFunc, undoFunc,
+		    rf_GenericWakeupFunc, 1, 1, 4, 0, dag_h, name, alloclist);
 		nodes[i].succedents[0] = unblockNode;
 		nodes[i].antecedents[0] = blockNode;
 		nodes[i].antType[0] = rf_control;
 		nodes[i].params[1].p = (databuf + (i * bytesPerSU));
 	}
-	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", alloclist);
+	rf_InitNode(termNode, rf_wait, RF_FALSE, rf_TerminateFunc,
+	    rf_TerminateUndoFunc, NULL, 0, 1, 0, 0, dag_h, "Trm", alloclist);
 	termNode->antecedents[0] = unblockNode;
 	termNode->antType[0] = rf_control;
 	return (dag_h);
diff --git a/sys/dev/raidframe/rf_parityscan.h b/sys/dev/raidframe/rf_parityscan.h
index 66324207abc..e43b001db15 100644
--- a/sys/dev/raidframe/rf_parityscan.h
+++ b/sys/dev/raidframe/rf_parityscan.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_parityscan.h,v 1.2 1999/02/16 00:03:09 niklas Exp $	*/
+/*	$OpenBSD: rf_parityscan.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_parityscan.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,41 +28,35 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_PARITYSCAN_H_
-#define _RF__RF_PARITYSCAN_H_
+#ifndef	_RF__RF_PARITYSCAN_H_
+#define	_RF__RF_PARITYSCAN_H_
 
 #include "rf_types.h"
 #include "rf_alloclist.h"
 
-int     rf_RewriteParity(RF_Raid_t * raidPtr);
-int 
-rf_VerifyParityBasic(RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-    RF_PhysDiskAddr_t * parityPDA, int correct_it, RF_RaidAccessFlags_t flags);
-int 
-rf_VerifyParity(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * stripeMap,
-    int correct_it, RF_RaidAccessFlags_t flags);
-int     rf_TryToRedirectPDA(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda, int parity);
-int     rf_VerifyDegrModeWrite(RF_Raid_t * raidPtr, RF_AccessStripeMapHeader_t * asmh);
-RF_DagHeader_t *
-rf_MakeSimpleDAG(RF_Raid_t * raidPtr, int nNodes,
-    int bytesPerSU, char *databuf,
-    int (*doFunc) (RF_DagNode_t *),
-    int (*undoFunc) (RF_DagNode_t *),
-    char *name, RF_AllocListElem_t * alloclist,
-    RF_RaidAccessFlags_t flags, int priority);
+int rf_RewriteParity(RF_Raid_t *);
+int rf_VerifyParityBasic(RF_Raid_t *, RF_RaidAddr_t, RF_PhysDiskAddr_t *, int,
+	RF_RaidAccessFlags_t);
+int rf_VerifyParity(RF_Raid_t *, RF_AccessStripeMap_t *, int,
+	RF_RaidAccessFlags_t);
+int rf_TryToRedirectPDA(RF_Raid_t *, RF_PhysDiskAddr_t *, int);
+int rf_VerifyDegrModeWrite(RF_Raid_t *, RF_AccessStripeMapHeader_t *);
+RF_DagHeader_t *rf_MakeSimpleDAG(RF_Raid_t *, int, int, char *,
+	int (*) (RF_DagNode_t *), int (*) (RF_DagNode_t *), char *,
+	RF_AllocListElem_t *, RF_RaidAccessFlags_t, int);
 
-#define RF_DO_CORRECT_PARITY   1
-#define RF_DONT_CORRECT_PARITY 0
+#define	RF_DO_CORRECT_PARITY		1
+#define	RF_DONT_CORRECT_PARITY		0
 
 /*
- * Return vals for VerifyParity operation
+ * Return vals for VerifyParity operation.
  *
  * Ordering is important here.
  */
-#define RF_PARITY_OKAY               0	/* or no parity information */
-#define RF_PARITY_CORRECTED          1
-#define RF_PARITY_BAD                2
-#define RF_PARITY_COULD_NOT_CORRECT  3
-#define RF_PARITY_COULD_NOT_VERIFY   4
+#define	RF_PARITY_OKAY			0	/* Or no parity information. */
+#define	RF_PARITY_CORRECTED		1
+#define	RF_PARITY_BAD			2
+#define	RF_PARITY_COULD_NOT_CORRECT	3
+#define	RF_PARITY_COULD_NOT_VERIFY	4
 
-#endif				/* !_RF__RF_PARITYSCAN_H_ */
+#endif	/* !_RF__RF_PARITYSCAN_H_ */
diff --git a/sys/dev/raidframe/rf_pq.c b/sys/dev/raidframe/rf_pq.c
index 06a04287e16..20a56eb52c5 100644
--- a/sys/dev/raidframe/rf_pq.c
+++ b/sys/dev/raidframe/rf_pq.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_pq.c,v 1.5 2000/01/11 18:02:22 peter Exp $	*/
+/*	$OpenBSD: rf_pq.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_pq.c,v 1.7 2000/01/07 03:41:02 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -47,58 +48,68 @@
 #include "rf_map.h"
 #include "rf_pq.h"
 
-RF_RedFuncs_t rf_pFuncs = {rf_RegularONPFunc, "Regular Old-New P", rf_SimpleONPFunc, "Simple Old-New P"};
-RF_RedFuncs_t rf_pRecoveryFuncs = {rf_RecoveryPFunc, "Recovery P Func", rf_RecoveryPFunc, "Recovery P Func"};
-
-int 
-rf_RegularONPFunc(node)
-	RF_DagNode_t *node;
+RF_RedFuncs_t rf_pFuncs = {
+	rf_RegularONPFunc, "Regular Old-New P",
+	rf_SimpleONPFunc, "Simple Old-New P"
+};
+RF_RedFuncs_t rf_pRecoveryFuncs = {
+	rf_RecoveryPFunc, "Recovery P Func",
+	rf_RecoveryPFunc, "Recovery P Func"
+};
+
+int
+rf_RegularONPFunc(RF_DagNode_t *node)
 {
 	return (rf_RegularXorFunc(node));
 }
+
+
 /*
-   same as simpleONQ func, but the coefficient is always 1
-*/
+ * Same as simpleONQ func, but the coefficient is always 1.
+ */
 
-int 
-rf_SimpleONPFunc(node)
-	RF_DagNode_t *node;
+int
+rf_SimpleONPFunc(RF_DagNode_t *node)
 {
 	return (rf_SimpleXorFunc(node));
 }
 
-int 
-rf_RecoveryPFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RecoveryPFunc(RF_DagNode_t *node)
 {
 	return (rf_RecoveryXorFunc(node));
 }
 
-int 
-rf_RegularPFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RegularPFunc(RF_DagNode_t *node)
 {
 	return (rf_RegularXorFunc(node));
 }
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
-
-static void 
-QDelta(char *dest, char *obuf, char *nbuf, unsigned length,
-    unsigned char coeff);
-static void 
-rf_InvertQ(unsigned long *qbuf, unsigned long *abuf,
-    unsigned length, unsigned coeff);
-
-RF_RedFuncs_t rf_qFuncs = {rf_RegularONQFunc, "Regular Old-New Q", rf_SimpleONQFunc, "Simple Old-New Q"};
-RF_RedFuncs_t rf_qRecoveryFuncs = {rf_RecoveryQFunc, "Recovery Q Func", rf_RecoveryQFunc, "Recovery Q Func"};
-RF_RedFuncs_t rf_pqRecoveryFuncs = {rf_RecoveryPQFunc, "Recovery PQ Func", rf_RecoveryPQFunc, "Recovery PQ Func"};
-
-void 
-rf_PQDagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
+
+
+#if	(RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
+
+void rf_QDelta(char *dest, char *obuf, char *nbuf, unsigned length,
+	unsigned char coeff);
+void rf_InvertQ(unsigned long *qbuf, unsigned long *abuf, unsigned length,
+	unsigned coeff);
+
+RF_RedFuncs_t rf_qFuncs = {
+	rf_RegularONQFunc, "Regular Old-New Q",
+	rf_SimpleONQFunc, "Simple Old-New Q"
+};
+RF_RedFuncs_t rf_qRecoveryFuncs = {
+	rf_RecoveryQFunc, "Recovery Q Func",
+	rf_RecoveryQFunc, "Recovery Q Func"
+};
+RF_RedFuncs_t rf_pqRecoveryFuncs = {
+	rf_RecoveryPQFunc, "Recovery PQ Func",
+	rf_RecoveryPQFunc, "Recovery PQ Func"
+};
+
+void
+rf_PQDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	unsigned ndfail = asmap->numDataFailed;
@@ -107,50 +118,67 @@ rf_PQDagSelect(
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 	if (ntfail > 2) {
-		RF_ERRORMSG("more than two disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("more than two disks failed in a single group !"
+		            "  Aborting I/O operation.\n");
 		 /* *infoFunc = */ *createFunc = NULL;
 		return;
 	}
-	/* ok, we can do this I/O */
+	/* Ok, we can do this I/O. */
 	if (type == RF_IO_TYPE_READ) {
 		switch (ndfail) {
 		case 0:
-			/* fault free read */
-			*createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;	/* same as raid 5 */
+			/* Fault free read. */
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateFaultFreeReadDAG;	/* Same as raid 5. */
 			break;
 		case 1:
-			/* lost a single data unit */
-			/* two cases: (1) parity is not lost. do a normal raid
-			 * 5 reconstruct read. (2) parity is lost. do a
-			 * reconstruct read using "q". */
-			if (ntfail == 2) {	/* also lost redundancy */
-				if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_PARITY)
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_110_CreateReadDAG;
+			/* Lost a single data unit. */
+			/*
+			 * Two cases:
+			 * (1) Parity is not lost. Do a normal raid 5
+			 *     reconstruct read.
+			 * (2) Parity is lost. Do a reconstruct read using "q".
+			 */
+			if (ntfail == 2) {	/* Also lost redundancy. */
+				if (asmap->failedPDAs[1]->type ==
+				    RF_PDA_TYPE_PARITY)
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_110_CreateReadDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_101_CreateReadDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_101_CreateReadDAG;
 			} else {
-				/* P and Q are ok. But is there a failure in
-				 * some unaccessed data unit? */
-				if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateReadDAG;
+				/*
+				 * P and Q are ok. But is there a failure in
+				 * some unaccessed data unit ?
+				 */
+				if (rf_NumFailedDataUnitsInStripe(raidPtr,
+				    asmap) == 2)
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_200_CreateReadDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_100_CreateReadDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_100_CreateReadDAG;
 			}
 			break;
 		case 2:
-			/* lost two data units */
-			/* *infoFunc = PQOneTwo; */
+			/* Lost two data units. */
+			/* *infoFunc = rf_PQOneTwo; */
 			*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateReadDAG;
 			break;
 		}
 		return;
 	}
-	/* a write */
+	/* A write. */
 	switch (ntfail) {
-	case 0:		/* fault free */
+	case 0:		/* Fault free. */
 		if (rf_suppressLocksAndLargeWrites ||
-		    (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) && (layoutPtr->numDataCol != 1)) ||
-			(asmap->parityInfo->next != NULL) || (asmap->qInfo->next != NULL) || rf_CheckStripeForFailures(raidPtr, asmap))) {
+		    (((asmap->numStripeUnitsAccessed <=
+		       (layoutPtr->numDataCol / 2)) &&
+		      (layoutPtr->numDataCol != 1)) ||
+		     (asmap->parityInfo->next != NULL) ||
+		     (asmap->qInfo->next != NULL) ||
+		     rf_CheckStripeForFailures(raidPtr, asmap))) {
 
 			*createFunc = (RF_VoidFuncPtr) rf_PQCreateSmallWriteDAG;
 		} else {
@@ -158,79 +186,98 @@ rf_PQDagSelect(
 		}
 		break;
 
-	case 1:		/* single disk fault */
+	case 1:		/* Single disk fault. */
 		if (npfail == 1) {
-			RF_ASSERT((asmap->failedPDAs[0]->type == RF_PDA_TYPE_PARITY) || (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q));
-			if (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q) {	/* q died, treat like
-										 * normal mode raid5
-										 * write. */
-				if (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) || (asmap->numStripeUnitsAccessed == 1))
-				    || rf_NumFailedDataUnitsInStripe(raidPtr, asmap))
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_001_CreateSmallWriteDAG;
+			RF_ASSERT((asmap->failedPDAs[0]->type ==
+			    RF_PDA_TYPE_PARITY) ||
+			    (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q));
+			if (asmap->failedPDAs[0]->type == RF_PDA_TYPE_Q) {
+				/*
+				 * Q died, treat like normal mode raid5 write.
+				 */
+				if (((asmap->numStripeUnitsAccessed <=
+				      (layoutPtr->numDataCol / 2)) ||
+				     (asmap->numStripeUnitsAccessed == 1)) ||
+				    rf_NumFailedDataUnitsInStripe(raidPtr,
+				     asmap))
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_001_CreateSmallWriteDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_001_CreateLargeWriteDAG;
-			} else {/* parity died, small write only updating Q */
-				if (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) || (asmap->numStripeUnitsAccessed == 1))
-				    || rf_NumFailedDataUnitsInStripe(raidPtr, asmap))
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_010_CreateSmallWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_001_CreateLargeWriteDAG;
+			} else {/* Parity died, small write only updating Q. */
+				if (((asmap->numStripeUnitsAccessed <=
+				      (layoutPtr->numDataCol / 2)) ||
+				     (asmap->numStripeUnitsAccessed == 1)) ||
+				    rf_NumFailedDataUnitsInStripe(raidPtr,
+				     asmap))
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_010_CreateSmallWriteDAG;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_010_CreateLargeWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_PQ_010_CreateLargeWriteDAG;
 			}
-		} else {	/* data missing. Do a P reconstruct write if
+		} else {	/*
+				 * Data missing. Do a P reconstruct write if
 				 * only a single data unit is lost in the
-				 * stripe, otherwise a PQ reconstruct write. */
+				 * stripe, otherwise a PQ reconstruct write.
+				 */
 			if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_PQ_200_CreateWriteDAG;
 			else
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_100_CreateWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_PQ_100_CreateWriteDAG;
 		}
 		break;
 
-	case 2:		/* two disk faults */
+	case 2:		/* Two disk faults. */
 		switch (npfail) {
-		case 2:	/* both p and q dead */
+		case 2:	/* Both p and q dead. */
 			*createFunc = (RF_VoidFuncPtr) rf_PQ_011_CreateWriteDAG;
 			break;
-		case 1:	/* either p or q and dead data */
-			RF_ASSERT(asmap->failedPDAs[0]->type == RF_PDA_TYPE_DATA);
-			RF_ASSERT((asmap->failedPDAs[1]->type == RF_PDA_TYPE_PARITY) || (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q));
+		case 1:	/* Either p or q and dead data. */
+			RF_ASSERT(asmap->failedPDAs[0]->type ==
+			          RF_PDA_TYPE_DATA);
+			RF_ASSERT((asmap->failedPDAs[1]->type ==
+			           RF_PDA_TYPE_PARITY) ||
+			          (asmap->failedPDAs[1]->type ==
+			           RF_PDA_TYPE_Q));
 			if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q)
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_101_CreateWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_PQ_101_CreateWriteDAG;
 			else
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_110_CreateWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_PQ_110_CreateWriteDAG;
 			break;
-		case 0:	/* double data loss */
+		case 0:	/* Double data loss. */
 			*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateWriteDAG;
 			break;
 		}
 		break;
 
-	default:		/* more than 2 disk faults */
+	default:	/* More than 2 disk faults. */
 		*createFunc = NULL;
 		RF_PANIC();
 	}
 	return;
 }
+
+
 /*
-   Used as a stop gap info function
-*/
+ * Used as a stop gap info function.
+ */
 #if 0
-static void 
-PQOne(raidPtr, nSucc, nAnte, asmap)
-	RF_Raid_t *raidPtr;
-	int    *nSucc;
-	int    *nAnte;
-	RF_AccessStripeMap_t *asmap;
+void
+rf_PQOne(RF_Raid_t *raidPtr, int *nSucc, int *nAnte,
+    RF_AccessStripeMap_t *asmap)
 {
 	*nSucc = *nAnte = 1;
 }
 
-static void 
-PQOneTwo(raidPtr, nSucc, nAnte, asmap)
-	RF_Raid_t *raidPtr;
-	int    *nSucc;
-	int    *nAnte;
-	RF_AccessStripeMap_t *asmap;
+void
+rf_PQOneTwo(RF_Raid_t *raidPtr, int *nSucc, int *nAnte,
+    RF_AccessStripeMap_t *asmap)
 {
 	*nSucc = 1;
 	*nAnte = 2;
@@ -239,22 +286,21 @@ PQOneTwo(raidPtr, nSucc, nAnte, asmap)
 
 RF_CREATE_DAG_FUNC_DECL(rf_PQCreateLargeWriteDAG)
 {
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 2,
-	    rf_RegularPQFunc, RF_FALSE);
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 2, rf_RegularPQFunc, RF_FALSE);
 }
 
-int 
-rf_RegularONQFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RegularONQFunc(RF_DagNode_t *node)
 {
-	int     np = node->numParams;
-	int     d;
+	int np = node->numParams;
+	int d;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
-	int     i;
+	int i;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	char   *qbuf, *qpbuf;
-	char   *obuf, *nbuf;
+	char *qbuf, *qpbuf;
+	char *obuf, *nbuf;
 	RF_PhysDiskAddr_t *old, *new;
 	unsigned long coeff;
 	unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
@@ -263,7 +309,7 @@ rf_RegularONQFunc(node)
 
 	d = (np - 3) / 4;
 	RF_ASSERT(4 * d + 3 == np);
-	qbuf = (char *) node->params[2 * d + 1].p;	/* q buffer */
+	qbuf = (char *) node->params[2 * d + 1].p;	/* Q buffer. */
 	for (i = 0; i < d; i++) {
 		old = (RF_PhysDiskAddr_t *) node->params[2 * i].p;
 		obuf = (char *) node->params[2 * i + 1].p;
@@ -271,55 +317,63 @@ rf_RegularONQFunc(node)
 		nbuf = (char *) node->params[2 * (d + 1 + i) + 1].p;
 		RF_ASSERT(new->numSector == old->numSector);
 		RF_ASSERT(new->raidAddress == old->raidAddress);
-		/* the stripe unit within the stripe tells us the coefficient
-		 * to use for the multiply. */
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), new->raidAddress);
-		/* compute the data unit offset within the column, then add
-		 * one */
+		/*
+		 * The stripe unit within the stripe tells us the coefficient
+		 * to use for the multiply.
+		 */
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    new->raidAddress);
+		/*
+		 * Compute the data unit offset within the column, then add
+		 * one.
+		 */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
-		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, old->startSector % secPerSU);
-		QDelta(qpbuf, obuf, nbuf, rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
+		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr,
+		    old->startSector % secPerSU);
+		rf_QDelta(qpbuf, obuf, nbuf, rf_RaidAddressToByte(raidPtr,
+		    old->numSector), coeff);
 	}
 
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->q_us += RF_ETIMER_VAL_US(timer);
-	rf_GenericWakeupFunc(node, 0);	/* call wake func explicitly since no
-					 * I/O in this node */
+	rf_GenericWakeupFunc(node, 0);	/*
+					 * Call wake func explicitly since no
+					 * I/O in this node.
+					 */
 	return (0);
 }
-/*
-   See the SimpleXORFunc for the difference between a simple and regular func.
-   These Q functions should be used for
 
-         new q = Q(data,old data,old q)
 
-   style updates and not for
-
-         q = ( new data, new data, .... )
-
-   computations.
-
-   The simple q takes 2(2d+1)+1 params, where d is the number
-   of stripes written. The order of params is
-   old data pda_0, old data buffer_0, old data pda_1, old data buffer_1, ... old data pda_d, old data buffer_d
-   [2d] old q pda_0, old q buffer
-   [2d_2] new data pda_0, new data buffer_0, ...                                    new data pda_d, new data buffer_d
-   raidPtr
-*/
+/*
+ * See the SimpleXORFunc for the difference between a simple and regular func.
+ * These Q functions should be used for
+ *	new q = Q(data, old data, old q)
+ * style updates and not for
+ *	q = (new data, new data, ...)
+ * computations.
+ *
+ * The simple q takes 2(2d+1)+1 params, where d is the number
+ * of stripes written. The order of params is
+ *   old data pda_0, old data buffer_0, old data pda_1, old data buffer_1, ...
+ *   old data pda_d, old data buffer_d
+ *   [2d] old q pda_0, old q buffer
+ *   [2d_2] new data pda_0, new data buffer_0, ...
+ *   new data pda_d, new data buffer_d
+ *   raidPtr
+ */
 
-int 
-rf_SimpleONQFunc(node)
-	RF_DagNode_t *node;
+int
+rf_SimpleONQFunc(RF_DagNode_t *node)
 {
-	int     np = node->numParams;
-	int     d;
+	int np = node->numParams;
+	int d;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
-	int     i;
+	int i;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	char   *qbuf;
-	char   *obuf, *nbuf;
+	char *qbuf;
+	char *obuf, *nbuf;
 	RF_PhysDiskAddr_t *old, *new;
 	unsigned long coeff;
 
@@ -327,7 +381,7 @@ rf_SimpleONQFunc(node)
 
 	d = (np - 3) / 4;
 	RF_ASSERT(4 * d + 3 == np);
-	qbuf = (char *) node->params[2 * d + 1].p;	/* q buffer */
+	qbuf = (char *) node->params[2 * d + 1].p;	/* Q buffer. */
 	for (i = 0; i < d; i++) {
 		old = (RF_PhysDiskAddr_t *) node->params[2 * i].p;
 		obuf = (char *) node->params[2 * i + 1].p;
@@ -335,42 +389,51 @@ rf_SimpleONQFunc(node)
 		nbuf = (char *) node->params[2 * (d + 1 + i) + 1].p;
 		RF_ASSERT(new->numSector == old->numSector);
 		RF_ASSERT(new->raidAddress == old->raidAddress);
-		/* the stripe unit within the stripe tells us the coefficient
-		 * to use for the multiply. */
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), new->raidAddress);
-		/* compute the data unit offset within the column, then add
-		 * one */
+		/*
+		 * The stripe unit within the stripe tells us the coefficient
+		 * to use for the multiply.
+		 */
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    new->raidAddress);
+		/*
+		 * Compute the data unit offset within the column, then add
+		 * one.
+		 */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
-		QDelta(qbuf, obuf, nbuf, rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
+		rf_QDelta(qbuf, obuf, nbuf, rf_RaidAddressToByte(raidPtr,
+		    old->numSector), coeff);
 	}
 
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->q_us += RF_ETIMER_VAL_US(timer);
-	rf_GenericWakeupFunc(node, 0);	/* call wake func explicitly since no
-					 * I/O in this node */
+	rf_GenericWakeupFunc(node, 0);	/*
+					 * Call wake func explicitly since no
+					 * I/O in this node.
+					 */
 	return (0);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_PQCreateSmallWriteDAG)
 {
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_pFuncs, &rf_qFuncs);
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_pFuncs, &rf_qFuncs);
 }
 
-static void RegularQSubr(RF_DagNode_t *node, char   *qbuf);
 
-static void 
-RegularQSubr(node, qbuf)
-	RF_DagNode_t *node;
-	char   *qbuf;
+void rf_RegularQSubr(RF_DagNode_t *, char *);
+
+void
+rf_RegularQSubr(RF_DagNode_t *node, char *qbuf)
 {
-	int     np = node->numParams;
-	int     d;
+	int np = node->numParams;
+	int d;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
 	unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	int     i;
+	int i;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	char   *obuf, *qpbuf;
+	char *obuf, *qpbuf;
 	RF_PhysDiskAddr_t *old;
 	unsigned long coeff;
 
@@ -381,44 +444,51 @@ RegularQSubr(node, qbuf)
 	for (i = 0; i < d; i++) {
 		old = (RF_PhysDiskAddr_t *) node->params[2 * i].p;
 		obuf = (char *) node->params[2 * i + 1].p;
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), old->raidAddress);
-		/* compute the data unit offset within the column, then add
-		 * one */
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    old->raidAddress);
+		/*
+		 * Compute the data unit offset within the column, then add
+		 * one.
+		 */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
-		/* the input buffers may not all be aligned with the start of
-		 * the stripe. so shift by their sector offset within the
-		 * stripe unit */
-		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, old->startSector % secPerSU);
-		rf_IncQ((unsigned long *) qpbuf, (unsigned long *) obuf, rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
+		/*
+		 * The input buffers may not all be aligned with the start of
+		 * the stripe. So shift by their sector offset within the
+		 * stripe unit.
+		 */
+		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr,
+		    old->startSector % secPerSU);
+		rf_IncQ((unsigned long *) qpbuf, (unsigned long *) obuf,
+		    rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
 	}
 
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->q_us += RF_ETIMER_VAL_US(timer);
 }
+
+
 /*
-   used in degraded writes.
-*/
+ * Used in degraded writes.
+ */
 
-static void DegrQSubr(RF_DagNode_t *node);
+void rf_DegrQSubr(RF_DagNode_t *);
 
-static void 
-DegrQSubr(node)
-	RF_DagNode_t *node;
+void
+rf_DegrQSubr(RF_DagNode_t *node)
 {
-	int     np = node->numParams;
-	int     d;
+	int np = node->numParams;
+	int d;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
 	unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	int     i;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	char   *qbuf = node->results[1];
-	char   *obuf, *qpbuf;
+	char *qbuf = node->results[1];
+	char *obuf, *qpbuf;
 	RF_PhysDiskAddr_t *old;
 	unsigned long coeff;
 	unsigned fail_start;
-	int     j;
+	int i, j;
 
 	old = (RF_PhysDiskAddr_t *) node->params[np - 2].p;
 	fail_start = old->startSector % secPerSU;
@@ -430,137 +500,151 @@ DegrQSubr(node)
 	for (i = 0; i < d; i++) {
 		old = (RF_PhysDiskAddr_t *) node->params[2 * i].p;
 		obuf = (char *) node->params[2 * i + 1].p;
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), old->raidAddress);
-		/* compute the data unit offset within the column, then add
-		 * one */
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    old->raidAddress);
+		/*
+		 * Compute the data unit offset within the column, then add
+		 * one.
+		 */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
-		/* the input buffers may not all be aligned with the start of
-		 * the stripe. so shift by their sector offset within the
-		 * stripe unit */
+		/*
+		 * The input buffers may not all be aligned with the start of
+		 * the stripe. So shift by their sector offset within the
+		 * stripe unit.
+		 */
 		j = old->startSector % secPerSU;
 		RF_ASSERT(j >= fail_start);
 		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, j - fail_start);
-		rf_IncQ((unsigned long *) qpbuf, (unsigned long *) obuf, rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
+		rf_IncQ((unsigned long *) qpbuf, (unsigned long *) obuf,
+		    rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
 	}
 
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->q_us += RF_ETIMER_VAL_US(timer);
 }
-/*
-   Called by large write code to compute the new parity and the new q.
 
-   structure of the params:
 
-   pda_0, buffer_0, pda_1 , buffer_1, ... , pda_d, buffer_d ( d = numDataCol
-   raidPtr
-
-   for a total of 2d+1 arguments.
-   The result buffers results[0], results[1] are the buffers for the p and q,
-   respectively.
-
-   We compute Q first, then compute P. The P calculation may try to reuse
-   one of the input buffers for its output, so if we computed P first, we would
-   corrupt the input for the q calculation.
-*/
+/*
+ * Called by large write code to compute the new parity and the new q.
+ *
+ * Structure of the params:
+ *
+ *   pda_0, buffer_0, pda_1 , buffer_1, ..., pda_d, buffer_d (d = numDataCol)
+ *   raidPtr
+ *
+ * For a total of 2d+1 arguments.
+ * The result buffers results[0], results[1] are the buffers for the p and q,
+ * respectively.
+ *
+ * We compute Q first, then compute P. The P calculation may try to reuse
+ * one of the input buffers for its output, so if we computed P first, we would
+ * corrupt the input for the q calculation.
+ */
 
-int 
-rf_RegularPQFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RegularPQFunc(RF_DagNode_t *node)
 {
-	RegularQSubr(node, node->results[1]);
-	return (rf_RegularXorFunc(node));	/* does the wakeup */
+	rf_RegularQSubr(node, node->results[1]);
+	return (rf_RegularXorFunc(node));	/* Does the wakeup. */
 }
 
-int 
-rf_RegularQFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RegularQFunc(RF_DagNode_t *node)
 {
-	/* Almost ... adjust Qsubr args */
-	RegularQSubr(node, node->results[0]);
-	rf_GenericWakeupFunc(node, 0);	/* call wake func explicitly since no
-					 * I/O in this node */
+	/* Almost ... adjust Qsubr args. */
+	rf_RegularQSubr(node, node->results[0]);
+	rf_GenericWakeupFunc(node, 0);	/*
+					 * Call wake func explicitly since no
+					 * I/O in this node.
+					 */
 	return (0);
 }
-/*
-   Called by singly degraded write code to compute the new parity and the new q.
 
-   structure of the params:
 
-   pda_0, buffer_0, pda_1 , buffer_1, ... , pda_d, buffer_d
-   failedPDA raidPtr
-
-   for a total of 2d+2 arguments.
-   The result buffers results[0], results[1] are the buffers for the parity and q,
-   respectively.
-
-   We compute Q first, then compute parity. The parity calculation may try to reuse
-   one of the input buffers for its output, so if we computed parity first, we would
-   corrupt the input for the q calculation.
-
-   We treat this identically to the regularPQ case, ignoring the failedPDA extra argument.
-*/
+/*
+ * Called by singly degraded write code to compute the new parity and
+ * the new q.
+ *
+ * Structure of the params:
+ *
+ *   pda_0, buffer_0, pda_1 , buffer_1, ..., pda_d, buffer_d
+ *   failedPDA raidPtr
+ *
+ * for a total of 2d+2 arguments.
+ * The result buffers results[0], results[1] are the buffers for the parity
+ * and q, respectively.
+ *
+ * We compute Q first, then compute parity. The parity calculation may try
+ * to reuse one of the input buffers for its output, so if we computed parity
+ * first, we would corrupt the input for the q calculation.
+ *
+ * We treat this identically to the regularPQ case, ignoring the failedPDA
+ * extra argument.
+ */
 
-void 
-rf_Degraded_100_PQFunc(node)
-	RF_DagNode_t *node;
+void
+rf_Degraded_100_PQFunc(RF_DagNode_t *node)
 {
 	int     np = node->numParams;
 
 	RF_ASSERT(np >= 2);
-	DegrQSubr(node);
+	rf_DegrQSubr(node);
 	rf_RecoveryXorFunc(node);
 }
 
 
 /*
-   The two below are used when reading a stripe with a single lost data unit.
-   The parameters are
-
-   pda_0, buffer_0, .... pda_n, buffer_n, P pda, P buffer, failedPDA, raidPtr
-
-   and results[0] contains the data buffer. Which is originally zero-filled.
-
-*/
+ * The two below are used when reading a stripe with a single lost data unit.
+ * The parameters are
+ *
+ *  pda_0, buffer_0, ..., pda_n, buffer_n, P pda, P buffer, failedPDA, raidPtr
+ *
+ * and results[0] contains the data buffer, which is originally zero-filled.
+ */
 
-/* this Q func is used by the degraded-mode dag functions to recover lost data.
- * the second-to-last parameter is the PDA for the failed portion of the access.
- * the code here looks at this PDA and assumes that the xor target buffer is
- * equal in size to the number of sectors in the failed PDA.  It then uses
- * the other PDAs in the parameter list to determine where within the target
- * buffer the corresponding data should be xored.
+/*
+ * This Q func is used by the degraded-mode dag functions to recover lost data.
+ * The second-to-last parameter is the PDA for the failed portion of the
+ * access. The code here looks at this PDA and assumes that the xor target
+ * buffer is equal in size to the number of sectors in the failed PDA. It then
+ * uses the other PDAs in the parameter list to determine where within the
+ * target buffer the corresponding data should be xored.
  *
  * Recall the basic equation is
  *
- *     Q = ( data_1 + 2 * data_2 ... + k * data_k  ) mod 256
+ *     Q = (data_1 + 2 * data_2 ... + k * data_k) mod 256
  *
  * so to recover data_j we need
  *
- *    J data_j = (Q - data_1 - 2 data_2 ....- k* data_k) mod 256
+ *    J data_j = (Q - data_1 - 2 data_2 ... - k * data_k) mod 256
  *
- * So the coefficient for each buffer is (255 - data_col), and j should be initialized by
- * copying Q into it. Then we need to do a table lookup to convert to solve
+ * So the coefficient for each buffer is (255 - data_col), and j should be
+ * initialized by copying Q into it. Then we need to do a table lookup to
+ * convert to solve
  *   data_j /= J
  *
- *
  */
-int 
-rf_RecoveryQFunc(node)
-	RF_DagNode_t *node;
+
+int
+rf_RecoveryQFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & raidPtr->Layout;
-	RF_PhysDiskAddr_t *failedPDA = (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
-	int     i;
+	RF_PhysDiskAddr_t *failedPDA =
+	    (RF_PhysDiskAddr_t *) node->params[node->numParams - 2].p;
+	int i;
 	RF_PhysDiskAddr_t *pda;
-	RF_RaidAddr_t suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
-	char   *srcbuf, *destbuf;
+	RF_RaidAddr_t suoffset;
+	RF_RaidAddr_t failedSUOffset =
+	    rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
+	char *srcbuf, *destbuf;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
 	unsigned long coeff;
 
 	RF_ETIMER_START(timer);
-	/* start by copying Q into the buffer */
+	/* Start by copying Q into the buffer. */
 	bcopy(node->params[node->numParams - 3].p, node->results[0],
 	    rf_RaidAddressToByte(raidPtr, failedPDA->numSector));
 	for (i = 0; i < node->numParams - 4; i += 2) {
@@ -568,15 +652,20 @@ rf_RecoveryQFunc(node)
 		pda = (RF_PhysDiskAddr_t *) node->params[i].p;
 		srcbuf = (char *) node->params[i + 1].p;
 		suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-		destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), pda->raidAddress);
-		/* compute the data unit offset within the column */
+		destbuf = ((char *) node->results[0]) +
+		    rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    pda->raidAddress);
+		/* Compute the data unit offset within the column. */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
-		rf_IncQ((unsigned long *) destbuf, (unsigned long *) srcbuf, rf_RaidAddressToByte(raidPtr, pda->numSector), coeff);
+		rf_IncQ((unsigned long *) destbuf, (unsigned long *) srcbuf,
+		    rf_RaidAddressToByte(raidPtr, pda->numSector), coeff);
 	}
-	/* Do the nasty inversion now */
-	coeff = (rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), failedPDA->startSector) % raidPtr->Layout.numDataCol);
-	rf_InvertQ(node->results[0], node->results[0], rf_RaidAddressToByte(raidPtr, pda->numSector), coeff);
+	/* Do the nasty inversion now. */
+	coeff = (rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+	    failedPDA->startSector) % raidPtr->Layout.numDataCol);
+	rf_InvertQ(node->results[0], node->results[0],
+	    rf_RaidAddressToByte(raidPtr, pda->numSector), coeff);
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
 	tracerec->q_us += RF_ETIMER_VAL_US(timer);
@@ -584,43 +673,42 @@ rf_RecoveryQFunc(node)
 	return (0);
 }
 
-int 
-rf_RecoveryPQFunc(node)
-	RF_DagNode_t *node;
+int
+rf_RecoveryPQFunc(RF_DagNode_t *node)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
-	printf("raid%d: Recovery from PQ not implemented.\n",raidPtr->raidid);
+	printf("raid%d: Recovery from PQ not implemented.\n", raidPtr->raidid);
 	return (1);
 }
-/*
-   Degraded write Q subroutine.
-   Used when P is dead.
-   Large-write style Q computation.
-   Parameters
-
-   (pda,buf),(pda,buf),.....,(failedPDA,bufPtr),failedPDA,raidPtr.
 
-   We ignore failedPDA.
 
-   This is a "simple style" recovery func.
-*/
+/*
+ * Degraded write Q subroutine.
+ * Used when P is dead.
+ * Large-write style Q computation.
+ * Parameters:
+ *
+ * (pda, buf), (pda, buf), ..., (failedPDA, bufPtr), failedPDA, raidPtr.
+ *
+ * We ignore failedPDA.
+ *
+ * This is a "simple style" recovery func.
+ */
 
-void 
-rf_PQ_DegradedWriteQFunc(node)
-	RF_DagNode_t *node;
+void
+rf_PQ_DegradedWriteQFunc(RF_DagNode_t *node)
 {
-	int     np = node->numParams;
-	int     d;
+	int np = node->numParams;
+	int d;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
 	unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	int     i;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 	RF_Etimer_t timer;
-	char   *qbuf = node->results[0];
-	char   *obuf, *qpbuf;
+	char *qbuf = node->results[0];
+	char *obuf, *qpbuf;
 	RF_PhysDiskAddr_t *old;
 	unsigned long coeff;
-	int     fail_start, j;
+	int fail_start, i, j;
 
 	old = (RF_PhysDiskAddr_t *) node->params[np - 2].p;
 	fail_start = old->startSector % secPerSU;
@@ -633,14 +721,18 @@ rf_PQ_DegradedWriteQFunc(node)
 	for (i = 0; i < d; i++) {
 		old = (RF_PhysDiskAddr_t *) node->params[2 * i].p;
 		obuf = (char *) node->params[2 * i + 1].p;
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), old->raidAddress);
-		/* compute the data unit offset within the column, then add
-		 * one */
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    old->raidAddress);
+		/*
+		 * Compute the data unit offset within the column, then add
+		 * one.
+		 */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
 		j = old->startSector % secPerSU;
 		RF_ASSERT(j >= fail_start);
 		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, j - fail_start);
-		rf_IncQ((unsigned long *) qpbuf, (unsigned long *) obuf, rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
+		rf_IncQ((unsigned long *) qpbuf, (unsigned long *) obuf,
+		    rf_RaidAddressToByte(raidPtr, old->numSector), coeff);
 	}
 
 	RF_ETIMER_STOP(timer);
@@ -650,36 +742,31 @@ rf_PQ_DegradedWriteQFunc(node)
 }
 
 
-
-
-/* Q computations */
+/* Q computations. */
 
 /*
-   coeff - colummn;
-
-   compute  dest ^= qfor[28-coeff][rn[coeff+1] a]
-
-   on 5-bit basis;
-   length in bytes;
-*/
+ * Coeff - colummn;
+ *
+ * Compute  dest ^= qfor[28-coeff][rn[coeff+1] a]
+ *
+ * On 5-bit basis;
+ * Length in bytes;
+ */
 
-void 
-rf_IncQ(dest, buf, length, coeff)
-	unsigned long *dest;
-	unsigned long *buf;
-	unsigned length;
-	unsigned coeff;
+void
+rf_IncQ(unsigned long *dest, unsigned long *buf, unsigned length,
+    unsigned coeff)
 {
 	unsigned long a, d, new;
 	unsigned long a1, a2;
 	unsigned int *q = &(rf_qfor[28 - coeff][0]);
 	unsigned r = rf_rn[coeff + 1];
 
-#define EXTRACT(a,i) ((a >> (5L*i)) & 0x1f)
-#define INSERT(a,i) (a << (5L*i))
+#define	EXTRACT(a,i)	((a >> (5L*i)) & 0x1f)
+#define	INSERT(a,i)	(a << (5L*i))
 
 	length /= 8;
-	/* 13 5 bit quants in a 64 bit word */
+	/* 13 5 bit quants in a 64 bit word. */
 	while (length) {
 		a = *buf++;
 		d = *dest;
@@ -701,7 +788,7 @@ rf_IncQ(dest, buf, length, coeff)
 		a1 = q[a1];
 		a2 = q[a2];
 		new = new | INSERT(a1, 5) | INSERT(a2, 6);
-#if RF_LONGSHIFT > 2
+#if	RF_LONGSHIFT > 2
 		a1 = EXTRACT(a, 7) ^ r;
 		a2 = EXTRACT(a, 8) ^ r;
 		a1 = q[a1];
@@ -717,29 +804,27 @@ rf_IncQ(dest, buf, length, coeff)
 		a1 = q[a1];
 		a2 = q[a2];
 		new = new | INSERT(a1, 11) | INSERT(a2, 12);
-#endif				/* RF_LONGSHIFT > 2 */
+#endif	/* RF_LONGSHIFT > 2 */
 		d ^= new;
 		*dest++ = d;
 		length--;
 	}
 }
-/*
-   compute
 
-   dest ^= rf_qfor[28-coeff][rf_rn[coeff+1] (old^new) ]
 
-   on a five bit basis.
-   optimization: compute old ^ new on 64 bit basis.
-
-   length in bytes.
-*/
+/*
+ * Compute.
+ *
+ * dest ^= rf_qfor[28-coeff][rf_rn[coeff+1] (old^new)]
+ *
+ * On a five bit basis.
+ * Optimization: compute old ^ new on 64 bit basis.
+ *
+ * Length in bytes.
+ */
 
-static void 
-QDelta(
-    char *dest,
-    char *obuf,
-    char *nbuf,
-    unsigned length,
+void
+rf_QDelta(char *dest, char *obuf, char *nbuf, unsigned length,
     unsigned char coeff)
 {
 	unsigned long a, d, new;
@@ -747,19 +832,23 @@ QDelta(
 	unsigned int *q = &(rf_qfor[28 - coeff][0]);
 	unsigned int r = rf_rn[coeff + 1];
 
-	r = a1 = a2 = new = d = a = 0; /* XXX for now... */
-	q = NULL; /* XXX for now */
+	r = a1 = a2 = new = d = a = 0; /* XXX For now... */
+	q = NULL; /* XXX For now */
 
-#ifdef _KERNEL
-	/* PQ in kernel currently not supported because the encoding/decoding
-	 * table is not present */
+#ifdef	_KERNEL
+	/*
+	 * PQ in kernel currently not supported because the encoding/decoding
+	 * table is not present.
+	 */
 	bzero(dest, length);
-#else				/* _KERNEL */
-	/* this code probably doesn't work and should be rewritten  -wvcii */
-	/* 13 5 bit quants in a 64 bit word */
+#else	/* _KERNEL */
+	/* This code probably doesn't work and should be rewritten. -wvcii */
+	/* 13 5 bit quants in a 64 bit word. */
 	length /= 8;
 	while (length) {
-		a = *obuf++;	/* XXX need to reorg to avoid cache conflicts */
+		a = *obuf++;	/*
+				 * XXX Need to reorg to avoid cache conflicts.
+				 */
 		a ^= *nbuf++;
 		d = *dest;
 		a1 = EXTRACT(a, 0) ^ r;
@@ -782,7 +871,7 @@ QDelta(
 		a1 = q[a1];
 		a2 = q[a2];
 		new = new | INSERT(a1, 5) | INSERT(a2, 6);
-#if RF_LONGSHIFT > 2
+#if	RF_LONGSHIFT > 2
 		a1 = EXTRACT(a, 7) ^ r;
 		a2 = EXTRACT(a, 8) ^ r;
 		a1 = q[a1];
@@ -798,37 +887,33 @@ QDelta(
 		a1 = q[a1];
 		a2 = q[a2];
 		new = new | INSERT(a1, 11) | INSERT(a2, 12);
-#endif				/* RF_LONGSHIFT > 2 */
+#endif	/* RF_LONGSHIFT > 2 */
 		d ^= new;
 		*dest++ = d;
 		length--;
 	}
-#endif				/* _KERNEL */
+#endif	/* _KERNEL */
 }
-/*
-   recover columns a and b from the given p and q into
-   bufs abuf and bbuf. All bufs are word aligned.
-   Length is in bytes.
-*/
 
 
 /*
+ * Recover columns a and b from the given p and q into
+ * bufs abuf and bbuf. All bufs are word aligned.
+ * Length is in bytes.
+ */
+
+/*
  * XXX
  *
  * Everything about this seems wrong.
  */
-void 
-rf_PQ_recover(pbuf, qbuf, abuf, bbuf, length, coeff_a, coeff_b)
-	unsigned long *pbuf;
-	unsigned long *qbuf;
-	unsigned long *abuf;
-	unsigned long *bbuf;
-	unsigned length;
-	unsigned coeff_a;
-	unsigned coeff_b;
+
+void
+rf_PQ_recover(unsigned long *pbuf, unsigned long *qbuf, unsigned long *abuf,
+    unsigned long *bbuf, unsigned length, unsigned coeff_a, unsigned coeff_b)
 {
 	unsigned long p, q, a, a0, a1;
-	int     col = (29 * coeff_a) + coeff_b;
+	int col = (29 * coeff_a) + coeff_b;
 	unsigned char *q0 = &(rf_qinv[col][0]);
 
 	length /= 8;
@@ -838,10 +923,13 @@ rf_PQ_recover(pbuf, qbuf, abuf, bbuf, length, coeff_a, coeff_b)
 		a0 = EXTRACT(p, 0);
 		a1 = EXTRACT(q, 0);
 		a = q0[a0 << 5 | a1];
-#define MF(i) \
-      a0 = EXTRACT(p,i); \
-      a1 = EXTRACT(q,i); \
-      a  = a | INSERT(q0[a0<<5 | a1],i)
+
+#define	MF(i)								\
+do {									\
+	a0 = EXTRACT(p, i);						\
+	a1 = EXTRACT(q, i);						\
+	a  = a | INSERT(q0[a0<<5 | a1], i);				\
+} while (0)
 
 		MF(1);
 		MF(2);
@@ -856,37 +944,34 @@ rf_PQ_recover(pbuf, qbuf, abuf, bbuf, length, coeff_a, coeff_b)
 		MF(10);
 		MF(11);
 		MF(12);
-#endif				/* 0 */
+#endif	/* 0 */
 		*abuf++ = a;
 		*bbuf++ = a ^ p;
 		length--;
 	}
 }
-/*
-   Lost parity and a data column. Recover that data column.
-   Assume col coeff is lost. Let q the contents of Q after
-   all surviving data columns have been q-xored out of it.
-   Then we have the equation
-
-   q[28-coeff][a_i ^ r_i+1] = q
-
-   but q is cyclic with period 31.
-   So q[3+coeff][q[28-coeff][a_i ^ r_{i+1}]] =
-      q[31][a_i ^ r_{i+1}] = a_i ^ r_{i+1} .
-
-   so a_i = r_{coeff+1} ^ q[3+coeff][q]
-
-   The routine is passed q buffer and the buffer
-   the data is to be recoverd into. They can be the same.
-*/
 
 
+/*
+ * Lost parity and a data column. Recover that data column.
+ * Assume col coeff is lost. Let q the contents of Q after
+ * all surviving data columns have been q-xored out of it.
+ * Then we have the equation
+ *
+ *   q[28-coeff][a_i ^ r_i+1] = q
+ *
+ * but q is cyclic with period 31.
+ * So q[3+coeff][q[28-coeff][a_i ^ r_{i+1}]] =
+ *    q[31][a_i ^ r_{i+1}] = a_i ^ r_{i+1} .
+ *
+ * so a_i = r_{coeff+1} ^ q[3+coeff][q]
+ *
+ * The routine is passed q buffer and the buffer
+ * the data is to be recoverd into. They can be the same.
+ */
 
-static void 
-rf_InvertQ(
-    unsigned long *qbuf,
-    unsigned long *abuf,
-    unsigned length,
+void
+rf_InvertQ(unsigned long *qbuf, unsigned long *abuf, unsigned length,
     unsigned coeff)
 {
 	unsigned long a, new;
@@ -894,7 +979,7 @@ rf_InvertQ(
 	unsigned int *q = &(rf_qfor[3 + coeff][0]);
 	unsigned r = rf_rn[coeff + 1];
 
-	/* 13 5 bit quants in a 64 bit word */
+	/* 13 5 bit quants in a 64 bit word. */
 	length /= 8;
 	while (length) {
 		a = *qbuf++;
@@ -903,24 +988,26 @@ rf_InvertQ(
 		a1 = r ^ q[a1];
 		a2 = r ^ q[a2];
 		new = INSERT(a2, 1) | a1;
-#define M(i,j) \
-      a1 = EXTRACT(a,i); \
-      a2 = EXTRACT(a,j); \
-      a1 = r ^ q[a1]; \
-      a2 = r ^ q[a2]; \
-      new = new | INSERT(a1,i) | INSERT(a2,j)
+
+#define	M(i,j)								\
+do {									\
+	a1 = EXTRACT(a, i);						\
+	a2 = EXTRACT(a, j);						\
+	a1 = r ^ q[a1];							\
+	a2 = r ^ q[a2];							\
+	new = new | INSERT(a1, i) | INSERT(a2, j);			\
+} while (0)
 
 		M(2, 3);
 		M(4, 5);
 		M(5, 6);
-#if RF_LONGSHIFT > 2
+#if	RF_LONGSHIFT > 2
 		M(7, 8);
 		M(9, 10);
 		M(11, 12);
-#endif				/* RF_LONGSHIFT > 2 */
+#endif	/* RF_LONGSHIFT > 2 */
 		*abuf++ = new;
 		length--;
 	}
 }
-#endif				/* (RF_INCLUDE_DECL_PQ > 0) ||
-				 * (RF_INCLUDE_RAID6 > 0) */
+#endif	/* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */
diff --git a/sys/dev/raidframe/rf_pq.h b/sys/dev/raidframe/rf_pq.h
index 70472786c85..36ce43cead4 100644
--- a/sys/dev/raidframe/rf_pq.h
+++ b/sys/dev/raidframe/rf_pq.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_pq.h,v 1.2 1999/02/16 00:03:10 niklas Exp $	*/
+/*	$OpenBSD: rf_pq.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_pq.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
+
 /*
  * rf_pq.h
  */
@@ -30,46 +31,41 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_PQ_H_
-#define _RF__RF_PQ_H_
+#ifndef	_RF__RF_PQ_H_
+#define	_RF__RF_PQ_H_
 
 #include "rf_archs.h"
 
 extern RF_RedFuncs_t rf_pFuncs;
 extern RF_RedFuncs_t rf_pRecoveryFuncs;
 
-int     rf_RegularONPFunc(RF_DagNode_t * node);
-int     rf_SimpleONPFunc(RF_DagNode_t * node);
-int     rf_RecoveryPFunc(RF_DagNode_t * node);
-int     rf_RegularPFunc(RF_DagNode_t * node);
+int  rf_RegularONPFunc(RF_DagNode_t *);
+int  rf_SimpleONPFunc(RF_DagNode_t *);
+int  rf_RecoveryPFunc(RF_DagNode_t *);
+int  rf_RegularPFunc(RF_DagNode_t *);
 
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
+#if	(RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
 
 extern RF_RedFuncs_t rf_qFuncs;
 extern RF_RedFuncs_t rf_qRecoveryFuncs;
 extern RF_RedFuncs_t rf_pqRecoveryFuncs;
 
-void 
-rf_PQDagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
+void rf_PQDagSelect(RF_Raid_t *, RF_IoType_t, RF_AccessStripeMap_t *,
+	RF_VoidFuncPtr *);
 RF_CREATE_DAG_FUNC_DECL(rf_PQCreateLargeWriteDAG);
-int     rf_RegularONQFunc(RF_DagNode_t * node);
-int     rf_SimpleONQFunc(RF_DagNode_t * node);
+int  rf_RegularONQFunc(RF_DagNode_t *);
+int  rf_SimpleONQFunc(RF_DagNode_t *);
 RF_CREATE_DAG_FUNC_DECL(rf_PQCreateSmallWriteDAG);
-int     rf_RegularPQFunc(RF_DagNode_t * node);
-int     rf_RegularQFunc(RF_DagNode_t * node);
-void    rf_Degraded_100_PQFunc(RF_DagNode_t * node);
-int     rf_RecoveryQFunc(RF_DagNode_t * node);
-int     rf_RecoveryPQFunc(RF_DagNode_t * node);
-void    rf_PQ_DegradedWriteQFunc(RF_DagNode_t * node);
-void 
-rf_IncQ(unsigned long *dest, unsigned long *buf, unsigned length,
-    unsigned coeff);
-void 
-rf_PQ_recover(unsigned long *pbuf, unsigned long *qbuf, unsigned long *abuf,
-    unsigned long *bbuf, unsigned length, unsigned coeff_a, unsigned coeff_b);
+int  rf_RegularPQFunc(RF_DagNode_t *);
+int  rf_RegularQFunc(RF_DagNode_t *);
+void rf_Degraded_100_PQFunc(RF_DagNode_t *);
+int  rf_RecoveryQFunc(RF_DagNode_t *);
+int  rf_RecoveryPQFunc(RF_DagNode_t *);
+void rf_PQ_DegradedWriteQFunc(RF_DagNode_t *);
+void rf_IncQ(unsigned long *, unsigned long *, unsigned, unsigned);
+void rf_PQ_recover(unsigned long *, unsigned long *, unsigned long *,
+	unsigned long *, unsigned, unsigned, unsigned);
 
-#endif				/* (RF_INCLUDE_DECL_PQ > 0) ||
-				 * (RF_INCLUDE_RAID6 > 0) */
+#endif	/* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */
 
-#endif				/* !_RF__RF_PQ_H_ */
+#endif	/* !_RF__RF_PQ_H_ */
diff --git a/sys/dev/raidframe/rf_pqdeg.c b/sys/dev/raidframe/rf_pqdeg.c
index 6cfbebc4430..f90c72f82ff 100644
--- a/sys/dev/raidframe/rf_pqdeg.c
+++ b/sys/dev/raidframe/rf_pqdeg.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_pqdeg.c,v 1.4 2000/01/11 18:02:22 peter Exp $	*/
+/*	$OpenBSD: rf_pqdeg.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_pqdeg.c,v 1.5 2000/01/07 03:41:04 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,7 +30,7 @@
 
 #include "rf_archs.h"
 
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
+#if	(RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -47,171 +48,177 @@
 #include "rf_pq.h"
 
 /*
-   Degraded mode dag functions for P+Q calculations.
-
-   The following nomenclature is used.
-
-   PQ_<D><P><Q>_Create{Large,Small}<Write|Read>DAG
-
-   where <D><P><Q> are single digits representing the number of failed
-   data units <D> (0,1,2), parity units <P> (0,1), and Q units <Q>, effecting
-   the I/O. The reads have only  PQ_<D><P><Q>_CreateReadDAG variants, while
-   the single fault writes have both large and small write versions. (Single fault
-   PQ is equivalent to normal mode raid 5 in many aspects.
-
-   Some versions degenerate into the same case, and are grouped together below.
-*/
+ * Degraded mode dag functions for P+Q calculations.
+ *
+ * The following nomenclature is used.
+ *
+ *   PQ_<D><P><Q>_Create{Large,Small}<Write|Read>DAG
+ *
+ * where <D><P><Q> are single digits representing the number of failed
+ * data units <D> (0,1,2), parity units <P> (0,1), and Q units <Q>, effecting
+ * the I/O. The reads have only  PQ_<D><P><Q>_CreateReadDAG variants, while
+ * the single fault writes have both large and small write versions.
+ * Single fault PQ is equivalent to normal mode raid 5 in many aspects.
+ *
+ * Some versions degenerate into the same case, and are grouped together below.
+ */
 
-/* Reads, single failure
 
-   we have parity, so we can do a raid 5
-   reconstruct read.
-*/
+/* Reads, single failure. */
 
+/* We have parity, so we can do a raid 5 reconstruct read. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateReadDAG)
 {
-	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_pRecoveryFuncs);
+	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    &rf_pRecoveryFuncs);
 }
-/* Reads double failure  */
 
-/*
-   Q is lost, but not parity
-   so we can a raid 5 reconstruct read.
-*/
 
+/* Reads double failure. */
+
+/*
+ * Q is lost, but not parity.
+ * So we can a raid 5 reconstruct read.
+ */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_101_CreateReadDAG)
 {
-	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_pRecoveryFuncs);
+	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    &rf_pRecoveryFuncs);
 }
-/*
-  parity is lost, so we need to
-  do a reconstruct read and recompute
-  the data with Q.
-*/
 
+/*
+ * Parity is lost, so we need to
+ * do a reconstruct read and recompute
+ * the data with Q.
+ */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateReadDAG)
 {
 	RF_PhysDiskAddr_t *temp;
-	/* swap P and Q pointers to fake out the DegradedReadDAG code */
+	/* Swap P and Q pointers to fake out the DegradedReadDAG code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList, &rf_qRecoveryFuncs);
+	rf_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    &rf_qRecoveryFuncs);
 }
+
 /*
-  Two data units are dead in this stripe, so we will need read
-  both P and Q to reconstruct the data. Note that only
-  one data unit we are reading may actually be missing.
-*/
+ * Two data units are dead in this stripe, so we will need read
+ * both P and Q to reconstruct the data. Note that only
+ * one data unit we are reading may actually be missing.
+ */
 RF_CREATE_DAG_FUNC_DECL(rf_CreateDoubleDegradedReadDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_CreateDoubleDegradedReadDAG)
 {
 	rf_PQ_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateReadDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateReadDAG)
 {
-	rf_CreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList);
+	rf_CreateDoubleDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList);
 }
-/* Writes, single failure */
+
+
+/* Writes, single failure. */
 
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateWriteDAG)
 {
 	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != 
+	    asmap->failedPDAs[0]->numSector !=
 	    raidPtr->Layout.sectorsPerStripeUnit)
 		RF_PANIC();
-	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, 
-		      flags, allocList, 2, 
-		      (int (*) (RF_DagNode_t *)) rf_Degraded_100_PQFunc, 
-		      RF_FALSE);
+	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp,
+	    flags, allocList, 2, (int (*) (RF_DagNode_t *))
+	    rf_Degraded_100_PQFunc, RF_FALSE);
 }
-/* Dead  P - act like a RAID 5 small write with parity = Q */
+
+/* Dead  P - act like a RAID 5 small write with parity = Q. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_010_CreateSmallWriteDAG)
 {
 	RF_PhysDiskAddr_t *temp;
-	/* swap P and Q pointers to fake out the DegradedReadDAG code */
+	/* Swap P and Q pointers to fake out the DegradedReadDAG code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, 
-				     allocList, &rf_qFuncs, NULL);
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_qFuncs, NULL);
 }
-/* Dead Q - act like a RAID 5 small write */
+
+/* Dead Q - act like a RAID 5 small write. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_001_CreateSmallWriteDAG)
 {
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, 
-				     allocList, &rf_pFuncs, NULL);
+	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, &rf_pFuncs, NULL);
 }
-/* Dead P - act like a RAID 5 large write but for Q */
+
+/* Dead P - act like a RAID 5 large write but for Q. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_010_CreateLargeWriteDAG)
 {
 	RF_PhysDiskAddr_t *temp;
-	/* swap P and Q pointers to fake out the code */
+	/* Swap P and Q pointers to fake out the code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, 
-				     allocList, 1, rf_RegularQFunc, RF_FALSE);
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 1, rf_RegularQFunc, RF_FALSE);
 }
-/* Dead Q - act like a RAID 5 large write */
+
+/* Dead Q - act like a RAID 5 large write. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_001_CreateLargeWriteDAG)
 {
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, 
-				     allocList, 1, rf_RegularPFunc, RF_FALSE);
+	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, 1, rf_RegularPFunc, RF_FALSE);
 }
 
 
-/*
- * writes, double failure
- */
+/* Writes, double failure. */
 
-/*
- * Lost P & Q - do a nonredundant write
- */
+/* Lost P & Q - do a nonredundant write. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_011_CreateWriteDAG)
 {
-	rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    RF_IO_TYPE_WRITE);
+	rf_CreateNonRedundantWriteDAG(raidPtr, asmap, dag_h, bp, flags,
+	    allocList, RF_IO_TYPE_WRITE);
 }
-/*
-   In the two cases below,
-   A nasty case arises when the write a (strict) portion of a failed stripe unit
-   and parts of another su. For now, we do not support this.
-*/
+
 
 /*
-  Lost Data and  P - do a Q write.
-*/
+ * In the two cases below, a nasty case arises when it's a write for a
+ * (strict) portion of a failed stripe unit and parts of another su.
+ * For now, we do not support this.
+ */
+
+/* Lost Data and  P - do a Q write. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateWriteDAG)
 {
 	RF_PhysDiskAddr_t *temp;
 
 	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit) {
+	    asmap->failedPDAs[0]->numSector !=
+	    raidPtr->Layout.sectorsPerStripeUnit) {
 		RF_PANIC();
 	}
-	/* swap P and Q to fake out parity code */
+	/* Swap P and Q to fake out parity code. */
 	temp = asmap->parityInfo;
 	asmap->parityInfo = asmap->qInfo;
 	asmap->qInfo = temp;
 	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
-		      allocList, 1, 
-		      (int (*) (RF_DagNode_t *)) rf_PQ_DegradedWriteQFunc,
-		      RF_FALSE);
-	/* is the regular Q func the right one to call? */
+	    allocList, 1, (int (*) (RF_DagNode_t *))
+	    rf_PQ_DegradedWriteQFunc, RF_FALSE);
+	/* Is the regular Q func the right one to call ? */
 }
-/*
-   Lost Data and Q - do degraded mode P write
-*/
+
+/* Lost Data and Q - do degraded mode P write. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_101_CreateWriteDAG)
 {
 	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit)
+	    asmap->failedPDAs[0]->numSector !=
+	    raidPtr->Layout.sectorsPerStripeUnit)
 		RF_PANIC();
 	rf_CommonCreateSimpleDegradedWriteDAG(raidPtr, asmap, dag_h, bp, flags,
 	    allocList, 1, rf_RecoveryXorFunc, RF_FALSE);
 }
-#endif				/* (RF_INCLUDE_DECL_PQ > 0) ||
-				 * (RF_INCLUDE_RAID6 > 0) */
+
+#endif	/* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */
diff --git a/sys/dev/raidframe/rf_pqdeg.h b/sys/dev/raidframe/rf_pqdeg.h
index 5841231c014..2479ad1e10f 100644
--- a/sys/dev/raidframe/rf_pqdeg.h
+++ b/sys/dev/raidframe/rf_pqdeg.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_pqdeg.h,v 1.2 1999/02/16 00:03:11 niklas Exp $	*/
+/*	$OpenBSD: rf_pqdeg.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_pqdeg.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,49 +28,52 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_PQDEG_H_
-#define _RF__RF_PQDEG_H_
+#ifndef	_RF__RF_PQDEG_H_
+#define	_RF__RF_PQDEG_H_
 
 #include "rf_types.h"
 
-#if RF_UTILITY == 0
+#if	RF_UTILITY == 0
 #include "rf_dag.h"
 
-/* extern decl's of the failure mode PQ functions.
+/*
+ * Extern decl's of the failure mode PQ functions.
  * See pddeg.c for nomenclature discussion.
  */
 
-/* reads, single failure  */
+/* Reads, single failure. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateReadDAG);
-/* reads, two failure */
+/* Reads, two failures. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateReadDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_101_CreateReadDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateReadDAG);
 
-/* writes, single failure */
+/* Writes, single failure. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_010_CreateSmallWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_010_CreateLargeWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_001_CreateSmallWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_001_CreateLargeWriteDAG);
 
-/* writes, double failure */
+/* Writes, double failures. */
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_011_CreateWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_101_CreateWriteDAG);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateWriteDAG);
-#endif				/* RF_UTILITY == 0 */
+#endif	/* RF_UTILITY == 0 */
 
-typedef RF_uint32 RF_ua32_t[32];
-typedef RF_uint8 RF_ua1024_t[1024];
+typedef	RF_uint32	RF_ua32_t[32];
+typedef	RF_uint8	RF_ua1024_t[1024];
 
 extern RF_ua32_t rf_rn;
 extern RF_ua32_t rf_qfor[32];
-#ifndef _KERNEL			/* we don't support PQ in the kernel yet, so
-				 * don't link in this monster table */
+#ifndef	_KERNEL			/*
+				 * We don't support PQ in the kernel yet, so
+				 * don't link in this monster table.
+				 */
 extern RF_ua1024_t rf_qinv[29 * 29];
-#else				/* !_KERNEL */
+#else	/* !_KERNEL */
 extern RF_ua1024_t rf_qinv[1];
-#endif				/* !_KERNEL */
+#endif	/* !_KERNEL */
 
-#endif				/* !_RF__RF_PQDEG_H_ */
+#endif	/* !_RF__RF_PQDEG_H_ */
diff --git a/sys/dev/raidframe/rf_pqdegdags.c b/sys/dev/raidframe/rf_pqdegdags.c
index b66c1ccfe2b..8fc3429b302 100644
--- a/sys/dev/raidframe/rf_pqdegdags.c
+++ b/sys/dev/raidframe/rf_pqdegdags.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_pqdegdags.c,v 1.4 2000/01/07 14:50:22 peter Exp $	*/
+/*	$OpenBSD: rf_pqdegdags.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_pqdegdags.c,v 1.5 1999/08/15 02:36:40 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -30,12 +31,12 @@
 /*
  * rf_pqdegdags.c
  * Degraded mode dags for double fault cases.
-*/
+ */
 
 
 #include "rf_archs.h"
 
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
+#if	(RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -50,66 +51,75 @@
 #include "rf_pqdegdags.h"
 #include "rf_pq.h"
 
-static void 
-applyPDA(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda, RF_PhysDiskAddr_t * ppda,
-    RF_PhysDiskAddr_t * qpda, void *bp);
+void rf_applyPDA(RF_Raid_t *, RF_PhysDiskAddr_t *, RF_PhysDiskAddr_t *,
+	RF_PhysDiskAddr_t *, void *);
 
 /*
-   Two data drives have failed, and we are doing a read that covers one of them.
-   We may also be reading some of the surviving drives.
+ * Two data drives have failed, and we are doing a read that covers one of them.
+ * We may also be reading some of the surviving drives.
+ */
 
 
- *****************************************************************************************
+/*****************************************************************************
  *
- * creates a DAG to perform a degraded-mode read of data within one stripe.
+ * Creates a DAG to perform a degraded-mode read of data within one stripe.
  * This DAG is as follows:
  *
- *                                      Hdr
- *                                       |
- *                                     Block
- *                       /         /           \         \     \   \
- *                      Rud  ...  Rud         Rrd  ...  Rrd    Rp  Rq
- *                      | \       | \         | \       | \    | \ | \
+ *			                Hdr
+ *			                 |
+ *			               Block
+ *			 /         /           \         \     \   \
+ *			Rud  ...  Rud         Rrd  ...  Rrd    Rp  Rq
+ *			| \       | \         | \       | \    | \ | \
  *
- *                                 |                 |
- *                              Unblock              X
- *                                  \               /
- *                                   ------ T ------
+ *			           |                 |
+ *			        Unblock              X
+ *			            \               /
+ *			             ------ T ------
  *
- * Each R node is a successor of the L node
- * One successor arc from each R node goes to U, and the other to X
- * There is one Rud for each chunk of surviving user data requested by the user,
- * and one Rrd for each chunk of surviving user data _not_ being read by the user
- * R = read, ud = user data, rd = recovery (surviving) data, p = P data, q = Qdata
- * X = pq recovery node, T = terminate
+ * Each R node is a successor of the L node.
+ * One successor arc from each R node goes to U, and the other to X.
+ * There is one Rud for each chunk of surviving user data requested by the
+ * user, and one Rrd for each chunk of surviving user data _not_ being read
+ * by the user.
+ * R = read, ud = user data, rd = recovery (surviving) data, p = P data,
+ * q = Qdata, X = pq recovery node, T = terminate
  *
- * The block & unblock nodes are leftovers from a previous version.  They
+ * The block & unblock nodes are leftovers from a previous version. They
  * do nothing, but I haven't deleted them because it would be a tremendous
  * effort to put them back in.
  *
- * Note:  The target buffer for the XOR node is set to the actual user buffer where the
- * failed data is supposed to end up.  This buffer is zero'd by the code here.  Thus,
- * if you create a degraded read dag, use it, and then re-use, you have to be sure to
- * zero the target buffer prior to the re-use.
+ * Note:  The target buffer for the XOR node is set to the actual user buffer
+ * where the failed data is supposed to end up. This buffer is zero'd by the
+ * code here. Thus, if you create a degraded read dag, use it, and then
+ * re-use. You have to be sure to zero the target buffer prior to the re-use.
  *
- * Every buffer read is passed to the pq recovery node, whose job it is to sort out whats
- * needs and what's not.
- ****************************************************************************************/
-/*   init a disk node with 2 successors and one predecessor */
-#define INIT_DISK_NODE(node,name) \
-rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc, rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 2,1,4,0, dag_h, name, allocList); \
-(node)->succedents[0] = unblockNode; \
-(node)->succedents[1] = recoveryNode; \
-(node)->antecedents[0] = blockNode; \
-(node)->antType[0] = rf_control
-
-#define DISK_NODE_PARAMS(_node_,_p_) \
-  (_node_).params[0].p = _p_ ; \
-  (_node_).params[1].p = (_p_)->bufPtr; \
-  (_node_).params[2].v = parityStripeID; \
-  (_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru)
-
-#define DISK_NODE_PDA(node)  ((node)->params[0].p)
+ * Every buffer read is passed to the pq recovery node, whose job it is to
+ * sort out what's needed and what's not.
+ *****************************************************************************/
+
+/* Init a disk node with 2 successors and one predecessor. */
+#define	INIT_DISK_NODE(node,name)					\
+do {									\
+	rf_InitNode(node, rf_wait, RF_FALSE, rf_DiskReadFunc,		\
+	    rf_DiskReadUndoFunc, rf_GenericWakeupFunc, 2, 1, 4, 0,	\
+	    dag_h, name, allocList);					\
+	(node)->succedents[0] = unblockNode;				\
+	(node)->succedents[1] = recoveryNode;				\
+	(node)->antecedents[0] = blockNode;				\
+	(node)->antType[0] = rf_control;				\
+} while (0)
+
+#define	DISK_NODE_PARAMS(_node_,_p_)					\
+do {									\
+	(_node_).params[0].p = _p_ ;					\
+	(_node_).params[1].p = (_p_)->bufPtr;				\
+	(_node_).params[2].v = parityStripeID;				\
+	(_node_).params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY,	\
+	    0, 0, which_ru);						\
+} while (0)
+
+#define	DISK_NODE_PDA(node)	((node)->params[0].p)
 
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_DoubleDegRead)
 {
@@ -117,96 +127,99 @@ RF_CREATE_DAG_FUNC_DECL(rf_PQ_DoubleDegRead)
 	    "Rq", "PQ Recovery", rf_PQDoubleRecoveryFunc);
 }
 
-static void 
-applyPDA(raidPtr, pda, ppda, qpda, bp)
-	RF_Raid_t *raidPtr;
-	RF_PhysDiskAddr_t *pda;
-	RF_PhysDiskAddr_t *ppda;
-	RF_PhysDiskAddr_t *qpda;
-	void   *bp;
+void
+rf_applyPDA(RF_Raid_t *raidPtr, RF_PhysDiskAddr_t *pda,
+    RF_PhysDiskAddr_t *ppda, RF_PhysDiskAddr_t *qpda, void *bp)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_RaidAddr_t s0off = rf_StripeUnitOffset(layoutPtr, ppda->startSector);
 	RF_SectorCount_t s0len = ppda->numSector, len;
 	RF_SectorNum_t suoffset;
 	unsigned coeff;
-	char   *pbuf = ppda->bufPtr;
-	char   *qbuf = qpda->bufPtr;
-	char   *buf;
-	int     delta;
+	char *pbuf = ppda->bufPtr;
+	char *qbuf = qpda->bufPtr;
+	char *buf;
+	int delta;
 
 	suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
 	len = pda->numSector;
-	/* see if pda intersects a recovery pda */
+	/* See if pda intersects a recovery pda. */
 	if ((suoffset < s0off + s0len) && (suoffset + len > s0off)) {
 		buf = pda->bufPtr;
-		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), pda->raidAddress);
+		coeff = rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+		    pda->raidAddress);
 		coeff = (coeff % raidPtr->Layout.numDataCol);
 
 		if (suoffset < s0off) {
 			delta = s0off - suoffset;
-			buf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), delta);
+			buf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+			    delta);
 			suoffset = s0off;
 			len -= delta;
 		}
 		if (suoffset > s0off) {
 			delta = suoffset - s0off;
-			pbuf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), delta);
-			qbuf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout), delta);
+			pbuf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+			    delta);
+			qbuf += rf_RaidAddressToStripeUnitID(&(raidPtr->Layout),
+			    delta);
 		}
 		if ((suoffset + len) > (s0len + s0off))
 			len = s0len + s0off - suoffset;
 
-		/* src, dest, len */
+		/* Src, dest, len. */
 		rf_bxor(buf, pbuf, rf_RaidAddressToByte(raidPtr, len), bp);
 
-		/* dest, src, len, coeff */
-		rf_IncQ((unsigned long *) qbuf, (unsigned long *) buf, rf_RaidAddressToByte(raidPtr, len), coeff);
+		/* Dest, src, len, coeff. */
+		rf_IncQ((unsigned long *) qbuf, (unsigned long *) buf,
+		    rf_RaidAddressToByte(raidPtr, len), coeff);
 	}
 }
-/*
-   Recover data in the case of a double failure. There can be two
-   result buffers, one for each chunk of data trying to be recovered.
-   The params are pda's that have not been range restricted or otherwise
-   politely massaged - this should be done here. The last params are the
-   pdas of P and Q, followed by the raidPtr. The list can look like
-
-   pda, pda, ... , p pda, q pda, raidptr, asm
 
-   or
-
-   pda, pda, ... , p_1 pda, p_2 pda, q_1 pda, q_2 pda, raidptr, asm
-
-   depending on wether two chunks of recovery data were required.
-
-   The second condition only arises if there are two failed buffers
-   whose lengths do not add up a stripe unit.
-*/
 
+/*
+ * Recover data in the case of a double failure. There can be two
+ * result buffers, one for each chunk of data trying to be recovered.
+ * The params are pda's that have not been range restricted or otherwise
+ * politely massaged - this should be done here. The last params are the
+ * pdas of P and Q, followed by the raidPtr. The list can look like
+ *
+ *   pda, pda, ..., p pda, q pda, raidptr, asm
+ *
+ * or
+ *
+ *   pda, pda, ..., p_1 pda, p_2 pda, q_1 pda, q_2 pda, raidptr, asm
+ *
+ * depending on whether two chunks of recovery data were required.
+ *
+ * The second condition only arises if there are two failed buffers
+ * whose lengths do not add up a stripe unit.
+ */
 
-int 
-rf_PQDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
+int
+rf_PQDoubleRecoveryFunc(RF_DagNode_t *node)
 {
-	int     np = node->numParams;
-	RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *) node->params[np - 1].p;
+	int np = node->numParams;
+	RF_AccessStripeMap_t *asmap =
+	    (RF_AccessStripeMap_t *) node->params[np - 1].p;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
-	int     d, i;
+	int d, i;
 	unsigned coeff;
 	RF_RaidAddr_t sosAddr, suoffset;
 	RF_SectorCount_t len, secPerSU = layoutPtr->sectorsPerStripeUnit;
-	int     two = 0;
+	int two = 0;
 	RF_PhysDiskAddr_t *ppda, *ppda2, *qpda, *qpda2, *pda, npda;
-	char   *buf;
-	int     numDataCol = layoutPtr->numDataCol;
+	char *buf;
+	int numDataCol = layoutPtr->numDataCol;
 	RF_Etimer_t timer;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 
 	RF_ETIMER_START(timer);
 
 	if (asmap->failedPDAs[1] &&
-	    (asmap->failedPDAs[1]->numSector + asmap->failedPDAs[0]->numSector < secPerSU)) {
+	    (asmap->failedPDAs[1]->numSector +
+	     asmap->failedPDAs[0]->numSector < secPerSU)) {
 		RF_ASSERT(0);
 		ppda = node->params[np - 6].p;
 		ppda2 = node->params[np - 5].p;
@@ -225,43 +238,65 @@ rf_PQDoubleRecoveryFunc(node)
 		buf = pda->bufPtr;
 		suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
 		len = pda->numSector;
-		coeff = rf_RaidAddressToStripeUnitID(layoutPtr, pda->raidAddress);
-		/* compute the data unit offset within the column */
+		coeff = rf_RaidAddressToStripeUnitID(layoutPtr,
+		    pda->raidAddress);
+		/* Compute the data unit offset within the column. */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
-		/* see if pda intersects a recovery pda */
-		applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
+		/* See if pda intersects a recovery pda. */
+		rf_applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
 		if (two)
-			applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
+			rf_applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
 	}
 
-	/* ok, we got the parity back to the point where we can recover. We
+	/*
+	 * Ok, we got the parity back to the point where we can recover. We
 	 * now need to determine the coeff of the columns that need to be
-	 * recovered. We can also only need to recover a single stripe unit. */
+	 * recovered. We can also only need to recover a single stripe unit.
+	 */
 
-	if (asmap->failedPDAs[1] == NULL) {	/* only a single stripe unit
-						 * to recover. */
+	if (asmap->failedPDAs[1] == NULL) {	/*
+						 * Only a single stripe unit
+						 * to recover.
+						 */
 		pda = asmap->failedPDAs[0];
-		sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
-		/* need to determine the column of the other failed disk */
-		coeff = rf_RaidAddressToStripeUnitID(layoutPtr, pda->raidAddress);
-		/* compute the data unit offset within the column */
+		sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+		    asmap->raidAddress);
+		/* Need to determine the column of the other failed disk. */
+		coeff = rf_RaidAddressToStripeUnitID(layoutPtr,
+		    pda->raidAddress);
+		/* Compute the data unit offset within the column. */
 		coeff = (coeff % raidPtr->Layout.numDataCol);
 		for (i = 0; i < numDataCol; i++) {
 			npda.raidAddress = sosAddr + (i * secPerSU);
-			(raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress, &(npda.row), &(npda.col), &(npda.startSector), 0);
-			/* skip over dead disks */
-			if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
+			(raidPtr->Layout.map->MapSector) (raidPtr,
+			    npda.raidAddress, &(npda.row), &(npda.col),
+			    &(npda.startSector), 0);
+			/* Skip over dead disks. */
+			if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col]
+			    .status))
 				if (i != coeff)
 					break;
 		}
 		RF_ASSERT(i < numDataCol);
 		RF_ASSERT(two == 0);
-		/* recover the data. Since we need only want to recover one
-		 * column, we overwrite the parity with the other one. */
-		if (coeff < i)	/* recovering 'a' */
-			rf_PQ_recover((unsigned long *) ppda->bufPtr, (unsigned long *) qpda->bufPtr, (unsigned long *) pda->bufPtr, (unsigned long *) ppda->bufPtr, rf_RaidAddressToByte(raidPtr, pda->numSector), coeff, i);
-		else		/* recovering 'b' */
-			rf_PQ_recover((unsigned long *) ppda->bufPtr, (unsigned long *) qpda->bufPtr, (unsigned long *) ppda->bufPtr, (unsigned long *) pda->bufPtr, rf_RaidAddressToByte(raidPtr, pda->numSector), i, coeff);
+		/*
+		 * Recover the data. Since we need only to recover one
+		 * column, we overwrite the parity with the other one.
+		 */
+		if (coeff < i)	/* Recovering 'a'. */
+			rf_PQ_recover((unsigned long *) ppda->bufPtr,
+			    (unsigned long *) qpda->bufPtr,
+			    (unsigned long *) pda->bufPtr,
+			    (unsigned long *) ppda->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda->numSector),
+			    coeff, i);
+		else		/* Recovering 'b'. */
+			rf_PQ_recover((unsigned long *) ppda->bufPtr,
+			    (unsigned long *) qpda->bufPtr,
+			    (unsigned long *) ppda->bufPtr,
+			    (unsigned long *) pda->bufPtr,
+			    rf_RaidAddressToByte(raidPtr, pda->numSector),
+			    i, coeff);
 	} else
 		RF_PANIC();
 
@@ -273,43 +308,46 @@ rf_PQDoubleRecoveryFunc(node)
 	return (0);
 }
 
-int 
-rf_PQWriteDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
+int
+rf_PQWriteDoubleRecoveryFunc(RF_DagNode_t *node)
 {
-	/* The situation:
-	 * 
+	/*
+	 * The situation:
+	 *
 	 * We are doing a write that hits only one failed data unit. The other
 	 * failed data unit is not being overwritten, so we need to generate
 	 * it.
-	 * 
+	 *
 	 * For the moment, we assume all the nonfailed data being written is in
-	 * the shadow of the failed data unit. (i.e,, either a single data
-	 * unit write or the entire failed stripe unit is being overwritten. )
-	 * 
-	 * Recovery strategy: apply the recovery data to the parity and q. Use P
-	 * & Q to recover the second failed data unit in P. Zero fill Q, then
-	 * apply the recovered data to p. Then apply the data being written to
-	 * the failed drive. Then walk through the surviving drives, applying
-	 * new data when it exists, othewise the recovery data. Quite a mess.
-	 * 
-	 * 
-	 * The params
-	 * 
-	 * read pda0, read pda1, ... read pda (numDataCol-3), write pda0, ... ,
-	 * write pda (numStripeUnitAccess - numDataFailed), failed pda,
-	 * raidPtr, asmap */
-
-	int     np = node->numParams;
-	RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *) node->params[np - 1].p;
+	 * the shadow of the failed data unit. (i.e., either a single data
+	 * unit write or the entire failed stripe unit is being overwritten.)
+	 *
+	 * Recovery strategy: apply the recovery data to the parity and Q.
+	 * Use P & Q to recover the second failed data unit in P. Zero fill
+	 * Q, then apply the recovered data to P. Then apply the data being
+	 * written to the failed drive. Then walk through the surviving drives,
+	 * applying new data when it exists, othewise the recovery data.
+	 * Quite a mess.
+	 *
+	 *
+	 * The params:
+	 *
+	 *   read pda0, read pda1, ..., read pda (numDataCol-3),
+	 *   write pda0, ..., write pda (numStripeUnitAccess - numDataFailed),
+	 *   failed pda, raidPtr, asmap
+	 */
+
+	int np = node->numParams;
+	RF_AccessStripeMap_t *asmap = (RF_AccessStripeMap_t *)
+	    node->params[np - 1].p;
 	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
 	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
-	int     i;
+	int i;
 	RF_RaidAddr_t sosAddr;
 	unsigned coeff;
 	RF_StripeCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
 	RF_PhysDiskAddr_t *ppda, *qpda, *pda, npda;
-	int     numDataCol = layoutPtr->numDataCol;
+	int numDataCol = layoutPtr->numDataCol;
 	RF_Etimer_t timer;
 	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
 
@@ -320,46 +358,66 @@ rf_PQWriteDoubleRecoveryFunc(node)
 	qpda = node->results[1];
 	/* apply the recovery data */
 	for (i = 0; i < numDataCol - 2; i++)
-		applyPDA(raidPtr, node->params[i].p, ppda, qpda, node->dagHdr->bp);
+		rf_applyPDA(raidPtr, node->params[i].p, ppda, qpda,
+		    node->dagHdr->bp);
 
-	/* determine the other failed data unit */
+	/* Determine the other failed data unit. */
 	pda = asmap->failedPDAs[0];
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
-	/* need to determine the column of the other failed disk */
+	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr,
+	    asmap->raidAddress);
+	/* Need to determine the column of the other failed disk. */
 	coeff = rf_RaidAddressToStripeUnitID(layoutPtr, pda->raidAddress);
-	/* compute the data unit offset within the column */
+	/* Compute the data unit offset within the column. */
 	coeff = (coeff % raidPtr->Layout.numDataCol);
 	for (i = 0; i < numDataCol; i++) {
 		npda.raidAddress = sosAddr + (i * secPerSU);
-		(raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress, &(npda.row), &(npda.col), &(npda.startSector), 0);
-		/* skip over dead disks */
+		(raidPtr->Layout.map->MapSector) (raidPtr, npda.raidAddress,
+		    &(npda.row), &(npda.col), &(npda.startSector), 0);
+		/* Skip over dead disks. */
 		if (RF_DEAD_DISK(raidPtr->Disks[npda.row][npda.col].status))
 			if (i != coeff)
 				break;
 	}
 	RF_ASSERT(i < numDataCol);
-	/* recover the data. The column we want to recover we write over the
-	 * parity. The column we don't care about we dump in q. */
-	if (coeff < i)		/* recovering 'a' */
-		rf_PQ_recover((unsigned long *) ppda->bufPtr, (unsigned long *) qpda->bufPtr, (unsigned long *) ppda->bufPtr, (unsigned long *) qpda->bufPtr, rf_RaidAddressToByte(raidPtr, pda->numSector), coeff, i);
-	else			/* recovering 'b' */
-		rf_PQ_recover((unsigned long *) ppda->bufPtr, (unsigned long *) qpda->bufPtr, (unsigned long *) qpda->bufPtr, (unsigned long *) ppda->bufPtr, rf_RaidAddressToByte(raidPtr, pda->numSector), i, coeff);
+	/*
+	 * Recover the data. The column we want to recover, we write over the
+	 * parity. The column we don't care about, we dump in q.
+	 */
+	if (coeff < i)		/* Recovering 'a'. */
+		rf_PQ_recover((unsigned long *) ppda->bufPtr,
+		    (unsigned long *) qpda->bufPtr,
+		    (unsigned long *) ppda->bufPtr,
+		    (unsigned long *) qpda->bufPtr,
+		    rf_RaidAddressToByte(raidPtr, pda->numSector), coeff, i);
+	else			/* Recovering 'b'. */
+		rf_PQ_recover((unsigned long *) ppda->bufPtr,
+		    (unsigned long *) qpda->bufPtr,
+		    (unsigned long *) qpda->bufPtr,
+		    (unsigned long *) ppda->bufPtr,
+		    rf_RaidAddressToByte(raidPtr, pda->numSector), i, coeff);
 
 	/* OK. The valid data is in P. Zero fill Q, then inc it into it. */
 	bzero(qpda->bufPtr, rf_RaidAddressToByte(raidPtr, qpda->numSector));
-	rf_IncQ((unsigned long *) qpda->bufPtr, (unsigned long *) ppda->bufPtr, rf_RaidAddressToByte(raidPtr, qpda->numSector), i);
-
-	/* now apply all the write data to the buffer */
-	/* single stripe unit write case: the failed data is only thing we are
-	 * writing. */
+	rf_IncQ((unsigned long *) qpda->bufPtr, (unsigned long *) ppda->bufPtr,
+	    rf_RaidAddressToByte(raidPtr, qpda->numSector), i);
+
+	/* Now apply all the write data to the buffer. */
+	/*
+	 * Single stripe unit write case: The failed data is the only thing
+	 * we are writing.
+	 */
 	RF_ASSERT(asmap->numStripeUnitsAccessed == 1);
-	/* dest, src, len, coeff */
-	rf_IncQ((unsigned long *) qpda->bufPtr, (unsigned long *) asmap->failedPDAs[0]->bufPtr, rf_RaidAddressToByte(raidPtr, qpda->numSector), coeff);
-	rf_bxor(asmap->failedPDAs[0]->bufPtr, ppda->bufPtr, rf_RaidAddressToByte(raidPtr, ppda->numSector), node->dagHdr->bp);
-
-	/* now apply all the recovery data */
+	/* Dest, src, len, coeff. */
+	rf_IncQ((unsigned long *) qpda->bufPtr,
+	    (unsigned long *) asmap->failedPDAs[0]->bufPtr,
+	    rf_RaidAddressToByte(raidPtr, qpda->numSector), coeff);
+	rf_bxor(asmap->failedPDAs[0]->bufPtr, ppda->bufPtr,
+	    rf_RaidAddressToByte(raidPtr, ppda->numSector), node->dagHdr->bp);
+
+	/* Now apply all the recovery data. */
 	for (i = 0; i < numDataCol - 2; i++)
-		applyPDA(raidPtr, node->params[i].p, ppda, qpda, node->dagHdr->bp);
+		rf_applyPDA(raidPtr, node->params[i].p, ppda, qpda,
+		    node->dagHdr->bp);
 
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
@@ -369,62 +427,69 @@ rf_PQWriteDoubleRecoveryFunc(node)
 	rf_GenericWakeupFunc(node, 0);
 	return (0);
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_DDLargeWrite)
 {
 	RF_PANIC();
 }
-/*
-   Two lost data unit write case.
-
-   There are really two cases here:
-
-   (1) The write completely covers the two lost data units.
-       In that case, a reconstruct write that doesn't write the
-       failed data units will do the correct thing. So in this case,
-       the dag looks like
-
-            full stripe read of surviving data units (not being overwritten)
-	    write new data (ignoring failed units)   compute P&Q
-	                                             write P&Q
-
 
-   (2) The write does not completely cover both failed data units
-       (but touches at least one of them). Then we need to do the
-       equivalent of a reconstruct read to recover the missing data
-       unit from the other stripe.
 
-       For any data we are writing that is not in the "shadow"
-       of the failed units, we need to do a four cycle update.
-       PANIC on this case. for now
-
-*/
+/*
+ * Two lost data unit write case.
+ *
+ * There are really two cases here:
+ *
+ * (1) The write completely covers the two lost data units.
+ *     In that case, a reconstruct write that doesn't write the
+ *     failed data units will do the correct thing. So in this case,
+ *     the dag looks like
+ *
+ *	   Full stripe read of surviving data units (not being overwritten)
+ *	   Write new data (ignoring failed units)
+ *	   Compute P&Q
+ *	   Write P&Q
+ *
+ *
+ * (2) The write does not completely cover both failed data units
+ *     (but touches at least one of them). Then we need to do the
+ *     equivalent of a reconstruct read to recover the missing data
+ *     unit from the other stripe.
+ *
+ *     For any data we are writing that is not in the "shadow"
+ *     of the failed units, we need to do a four cycle update.
+ *     PANIC on this case. For now.
+ *
+ */
 
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateWriteDAG)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_SectorCount_t sectorsPerSU = layoutPtr->sectorsPerStripeUnit;
-	int     sum;
-	int     nf = asmap->numDataFailed;
+	int sum;
+	int nf = asmap->numDataFailed;
 
 	sum = asmap->failedPDAs[0]->numSector;
 	if (nf == 2)
 		sum += asmap->failedPDAs[1]->numSector;
 
 	if ((nf == 2) && (sum == (2 * sectorsPerSU))) {
-		/* large write case */
+		/* Large write case. */
 		rf_PQ_DDLargeWrite(raidPtr, asmap, dag_h, bp, flags, allocList);
 		return;
 	}
 	if ((nf == asmap->numStripeUnitsAccessed) || (sum >= sectorsPerSU)) {
-		/* small write case, no user data not in shadow */
-		rf_PQ_DDSimpleSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList);
+		/* Small write case, no user data not in shadow. */
+		rf_PQ_DDSimpleSmallWrite(raidPtr, asmap, dag_h, bp, flags,
+		    allocList);
 		return;
 	}
 	RF_PANIC();
 }
+
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_DDSimpleSmallWrite)
 {
-	rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList, "Rq", "Wq", "PQ Recovery", rf_PQWriteDoubleRecoveryFunc);
+	rf_DoubleDegSmallWrite(raidPtr, asmap, dag_h, bp, flags, allocList,
+	    "Rq", "Wq", "PQ Recovery", rf_PQWriteDoubleRecoveryFunc);
 }
-#endif				/* (RF_INCLUDE_DECL_PQ > 0) ||
-				 * (RF_INCLUDE_RAID6 > 0) */
+
+#endif	/* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) */
diff --git a/sys/dev/raidframe/rf_pqdegdags.h b/sys/dev/raidframe/rf_pqdegdags.h
index 8fc1f3dbf97..00ee5f04cf4 100644
--- a/sys/dev/raidframe/rf_pqdegdags.h
+++ b/sys/dev/raidframe/rf_pqdegdags.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_pqdegdags.h,v 1.2 1999/02/16 00:03:12 niklas Exp $	*/
+/*	$OpenBSD: rf_pqdegdags.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_pqdegdags.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
+
 /*
  * rf_pqdegdags.h
  */
@@ -34,16 +35,16 @@
  * Degraded mode dags for double fault cases.
  */
 
-#ifndef _RF__RF_PQDEGDAGS_H_
-#define _RF__RF_PQDEGDAGS_H_
+#ifndef	_RF__RF_PQDEGDAGS_H_
+#define	_RF__RF_PQDEGDAGS_H_
 
 #include "rf_dag.h"
 
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_DoubleDegRead);
-int     rf_PQDoubleRecoveryFunc(RF_DagNode_t * node);
-int     rf_PQWriteDoubleRecoveryFunc(RF_DagNode_t * node);
+int  rf_PQDoubleRecoveryFunc(RF_DagNode_t *);
+int  rf_PQWriteDoubleRecoveryFunc(RF_DagNode_t *);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_DDLargeWrite);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_DDSimpleSmallWrite);
 RF_CREATE_DAG_FUNC_DECL(rf_PQ_200_CreateWriteDAG);
 
-#endif				/* !_RF__RF_PQDEGDAGS_H_ */
+#endif	/* !_RF__RF_PQDEGDAGS_H_ */
diff --git a/sys/dev/raidframe/rf_psstatus.c b/sys/dev/raidframe/rf_psstatus.c
index 6581f97d7c7..c6abe9f0afb 100644
--- a/sys/dev/raidframe/rf_psstatus.c
+++ b/sys/dev/raidframe/rf_psstatus.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_psstatus.c,v 1.5 2002/12/03 11:31:35 tdeval Exp $	*/
+/*	$OpenBSD: rf_psstatus.c,v 1.6 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_psstatus.c,v 1.5 2000/01/08 22:57:31 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -32,7 +33,7 @@
  * psstatus.c
  *
  * The reconstruction code maintains a bunch of status related to the parity
- * stripes that are currently under reconstruction.  This header file defines
+ * stripes that are currently under reconstruction. This header file defines
  * the status structures.
  *
  *****************************************************************************/
@@ -45,26 +46,43 @@
 #include "rf_psstatus.h"
 #include "rf_shutdown.h"
 
-#define Dprintf1(s,a)         if (rf_pssDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf2(s,a,b)       if (rf_pssDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf3(s,a,b,c)     if (rf_pssDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
-
-static void 
-RealPrintPSStatusTable(RF_Raid_t * raidPtr,
-    RF_PSStatusHeader_t * pssTable);
-
-#define RF_MAX_FREE_PSS  32
-#define RF_PSS_INC        8
-#define RF_PSS_INITIAL    4
-
-static int init_pss(RF_ReconParityStripeStatus_t *, RF_Raid_t *);
-static void clean_pss(RF_ReconParityStripeStatus_t *, RF_Raid_t *);
-static void rf_ShutdownPSStatus(void *);
-
-static int 
-init_pss(p, raidPtr)
-	RF_ReconParityStripeStatus_t *p;
-	RF_Raid_t *raidPtr;
+#define	Dprintf1(s,a)							\
+do {									\
+	if (rf_pssDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    NULL, NULL, NULL, NULL, NULL, NULL, NULL);		\
+} while(0)
+#define	Dprintf2(s,a,b)							\
+do {									\
+	if (rf_pssDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    NULL, NULL, NULL, NULL, NULL, NULL);		\
+} while(0)
+#define	Dprintf3(s,a,b,c)						\
+do {									\
+	if (rf_pssDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    NULL, NULL, NULL, NULL, NULL);			\
+} while(0)
+
+void rf_RealPrintPSStatusTable(RF_Raid_t *, RF_PSStatusHeader_t *);
+
+#define	RF_MAX_FREE_PSS		32
+#define	RF_PSS_INC		 8
+#define	RF_PSS_INITIAL		 4
+
+int  rf_init_pss(RF_ReconParityStripeStatus_t *, RF_Raid_t *);
+void rf_clean_pss(RF_ReconParityStripeStatus_t *, RF_Raid_t *);
+void rf_ShutdownPSStatus(void *);
+
+int
+rf_init_pss(RF_ReconParityStripeStatus_t *p, RF_Raid_t *raidPtr)
 {
 	RF_Calloc(p->issued, raidPtr->numCol, sizeof(char), (char *));
 	if (p->issued == NULL)
@@ -72,88 +90,87 @@ init_pss(p, raidPtr)
 	return (0);
 }
 
-static void 
-clean_pss(p, raidPtr)
-	RF_ReconParityStripeStatus_t *p;
-	RF_Raid_t *raidPtr;
+void
+rf_clean_pss(RF_ReconParityStripeStatus_t *p, RF_Raid_t *raidPtr)
 {
 	RF_Free(p->issued, raidPtr->numCol * sizeof(char));
 }
 
-static void 
-rf_ShutdownPSStatus(arg)
-	void   *arg;
+void
+rf_ShutdownPSStatus(void *arg)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) arg;
 
-	RF_FREELIST_DESTROY_CLEAN_ARG(raidPtr->pss_freelist, next, (RF_ReconParityStripeStatus_t *), clean_pss, raidPtr);
+	RF_FREELIST_DESTROY_CLEAN_ARG(raidPtr->pss_freelist, next,
+	    (RF_ReconParityStripeStatus_t *), rf_clean_pss, raidPtr);
 }
 
-int 
-rf_ConfigurePSStatus(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigurePSStatus(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
-	int     rc;
+	int rc;
 
 	raidPtr->pssTableSize = RF_PSS_DEFAULT_TABLESIZE;
-	RF_FREELIST_CREATE(raidPtr->pss_freelist, RF_MAX_FREE_PSS,
-	    RF_PSS_INC, sizeof(RF_ReconParityStripeStatus_t));
+	RF_FREELIST_CREATE(raidPtr->pss_freelist, RF_MAX_FREE_PSS, RF_PSS_INC,
+	    sizeof(RF_ReconParityStripeStatus_t));
 	if (raidPtr->pss_freelist == NULL)
 		return (ENOMEM);
 	rc = rf_ShutdownCreate(listp, rf_ShutdownPSStatus, raidPtr);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		             " rc=%d.\n", __FILE__, __LINE__, rc);
 		rf_ShutdownPSStatus(raidPtr);
 		return (rc);
 	}
 	RF_FREELIST_PRIME_INIT_ARG(raidPtr->pss_freelist, RF_PSS_INITIAL, next,
-	    (RF_ReconParityStripeStatus_t *), init_pss, raidPtr);
+	    (RF_ReconParityStripeStatus_t *), rf_init_pss, raidPtr);
 	return (0);
 }
-/*****************************************************************************************
- * sets up the pss table
+
+
+/*****************************************************************************
+ * Sets up the pss table.
  * We pre-allocate a bunch of entries to avoid as much as possible having to
  * malloc up hash chain entries.
- ****************************************************************************************/
+ *****************************************************************************/
 RF_PSStatusHeader_t *
-rf_MakeParityStripeStatusTable(raidPtr)
-	RF_Raid_t *raidPtr;
+rf_MakeParityStripeStatusTable(RF_Raid_t *raidPtr)
 {
 	RF_PSStatusHeader_t *pssTable;
-	int     i, j, rc;
+	int i, j, rc;
 
-	RF_Calloc(pssTable, raidPtr->pssTableSize, sizeof(RF_PSStatusHeader_t), (RF_PSStatusHeader_t *));
+	RF_Calloc(pssTable, raidPtr->pssTableSize, sizeof(RF_PSStatusHeader_t),
+	    (RF_PSStatusHeader_t *));
 	for (i = 0; i < raidPtr->pssTableSize; i++) {
 		rc = rf_mutex_init(&pssTable[i].mutex);
 		if (rc) {
-			RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-			    __LINE__, rc);
-			/* fail and deallocate */
+			RF_ERRORMSG3("Unable to init mutex file %s line %d"
+			             " rc=%d.\n", __FILE__, __LINE__, rc);
+			/* Fail and deallocate. */
 			for (j = 0; j < i; j++) {
 				rf_mutex_destroy(&pssTable[i].mutex);
 			}
-			RF_Free(pssTable, raidPtr->pssTableSize * sizeof(RF_PSStatusHeader_t));
+			RF_Free(pssTable, raidPtr->pssTableSize *
+			    sizeof(RF_PSStatusHeader_t));
 			return (NULL);
 		}
 	}
 	return (pssTable);
 }
 
-void 
-rf_FreeParityStripeStatusTable(raidPtr, pssTable)
-	RF_Raid_t *raidPtr;
-	RF_PSStatusHeader_t *pssTable;
+void
+rf_FreeParityStripeStatusTable(RF_Raid_t *raidPtr,
+    RF_PSStatusHeader_t *pssTable)
 {
-	int     i;
+	int i;
 
 	if (rf_pssDebug)
-		RealPrintPSStatusTable(raidPtr, pssTable);
+		rf_RealPrintPSStatusTable(raidPtr, pssTable);
 	for (i = 0; i < raidPtr->pssTableSize; i++) {
 		if (pssTable[i].chain) {
-			printf("ERROR: pss hash chain not null at recon shutdown\n");
+			printf("ERROR: pss hash chain not null at recon"
+			       " shutdown.\n");
 		}
 		rf_mutex_destroy(&pssTable[i].mutex);
 	}
@@ -161,20 +178,20 @@ rf_FreeParityStripeStatusTable(raidPtr, pssTable)
 }
 
 
-/* looks up the status structure for a parity stripe.
- * if the create_flag is on, creates and returns the status structure it it doesn't exist
- * otherwise returns NULL if the status structure does not exist
+/*
+ * Looks up the status structure for a parity stripe.
+ * If the create_flag is on, returns the status structure, creating it if
+ * it doesn't exist. Otherwise returns NULL if the status structure does
+ * not exist already.
+ *
+ * The flags tell whether or not to create it if it doesn't exist + what
+ * flags to set initially.
  *
- * ASSUMES THE PSS DESCRIPTOR IS LOCKED UPON ENTRY
+ * ASSUMES THE PSS DESCRIPTOR IS LOCKED UPON ENTRY.
  */
 RF_ReconParityStripeStatus_t *
-rf_LookupRUStatus(
-    RF_Raid_t * raidPtr,
-    RF_PSStatusHeader_t * pssTable,
-    RF_StripeNum_t psID,
-    RF_ReconUnitNum_t which_ru,
-    RF_PSSFlags_t flags,	/* whether or not to create it if it doesn't
-				 * exist + what flags to set initially */
+rf_LookupRUStatus(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable,
+    RF_StripeNum_t psID, RF_ReconUnitNum_t which_ru, RF_PSSFlags_t flags,
     int *created)
 {
 	RF_PSStatusHeader_t *hdr = &pssTable[RF_HASH_PSID(raidPtr, psID)];
@@ -187,7 +204,8 @@ rf_LookupRUStatus(
 	}
 
 	if (!p && (flags & RF_PSS_CREATE)) {
-		Dprintf2("PSS: creating pss for psid %ld ru %d\n", psID, which_ru);
+		Dprintf2("PSS: creating pss for psid %ld ru %d.\n",
+		    psID, which_ru);
 		p = rf_AllocPSStatus(raidPtr);
 		p->next = hdr->chain;
 		hdr->chain = p;
@@ -204,31 +222,38 @@ rf_LookupRUStatus(
 		p->bufWaitList = NULL;
 		*created = 1;
 	} else
-		if (p) {	/* we didn't create, but we want to specify
-				 * some new status */
-			p->flags |= flags;	/* add in whatever flags we're
-						 * specifying */
+		if (p) {
+			/*
+			 * We didn't create, but we want to specify
+			 * some new status.
+			 */
+			p->flags |= flags;	/*
+						 * Add in whatever flags we're
+						 * specifying.
+						 */
 		}
 	if (p && (flags & RF_PSS_RECON_BLOCKED)) {
-		p->blockCount++;/* if we're asking to block recon, bump the
-				 * count */
-		Dprintf3("raid%d: Blocked recon on psid %ld.  count now %d\n",
+		/* If we're asking to block recon, bump the count. */
+		p->blockCount++;
+		Dprintf3("raid%d: Blocked recon on psid %ld. count now %d.\n",
 			 raidPtr->raidid, psID, p->blockCount);
 	}
 	return (p);
 }
-/* deletes an entry from the parity stripe status table.  typically used
+
+
+/*
+ * Deletes an entry from the parity stripe status table. Typically used
  * when an entry has been allocated solely to block reconstruction, and
- * no recon was requested while recon was blocked.  Assumes the hash
+ * no recon was requested while recon was blocked. Assumes the hash
  * chain is ALREADY LOCKED.
  */
-void 
-rf_PSStatusDelete(raidPtr, pssTable, pssPtr)
-	RF_Raid_t *raidPtr;
-	RF_PSStatusHeader_t *pssTable;
-	RF_ReconParityStripeStatus_t *pssPtr;
+void
+rf_PSStatusDelete(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable,
+    RF_ReconParityStripeStatus_t *pssPtr)
 {
-	RF_PSStatusHeader_t *hdr = &(pssTable[RF_HASH_PSID(raidPtr, pssPtr->parityStripeID)]);
+	RF_PSStatusHeader_t *hdr =
+	    &(pssTable[RF_HASH_PSID(raidPtr, pssPtr->parityStripeID)]);
 	RF_ReconParityStripeStatus_t *p = hdr->chain, *pt = NULL;
 
 	while (p) {
@@ -244,17 +269,21 @@ rf_PSStatusDelete(raidPtr, pssTable, pssPtr)
 		pt = p;
 		p = p->next;
 	}
-	RF_ASSERT(0);		/* we must find it here */
+	RF_ASSERT(0);		/* We must find it here. */
 }
-/* deletes an entry from the ps status table after reconstruction has completed */
-void 
-rf_RemoveFromActiveReconTable(raidPtr, row, psid, which_ru)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_ReconUnitNum_t which_ru;
-	RF_StripeNum_t psid;
+
+
+/*
+ * Deletes an entry from the ps status table after reconstruction has
+ * completed.
+ */
+void
+rf_RemoveFromActiveReconTable(RF_Raid_t *raidPtr, RF_RowCol_t row,
+    RF_StripeNum_t psid, RF_ReconUnitNum_t which_ru)
 {
-	RF_PSStatusHeader_t *hdr = &(raidPtr->reconControl[row]->pssTable[RF_HASH_PSID(raidPtr, psid)]);
+	RF_PSStatusHeader_t *hdr =
+	    &(raidPtr->reconControl[row]
+	     ->pssTable[RF_HASH_PSID(raidPtr, psid)]);
 	RF_ReconParityStripeStatus_t *p, *pt;
 	RF_CallbackDesc_t *cb, *cb1;
 
@@ -266,11 +295,11 @@ rf_RemoveFromActiveReconTable(raidPtr, row, psid, which_ru)
 	if (p == NULL) {
 		rf_PrintPSStatusTable(raidPtr, row);
 	}
-	RF_ASSERT(p);		/* it must be there */
+	RF_ASSERT(p);		/* It must be there. */
 
-	Dprintf2("PSS: deleting pss for psid %ld ru %d\n", psid, which_ru);
+	Dprintf2("PSS: deleting pss for psid %ld ru %d.\n", psid, which_ru);
 
-	/* delete this entry from the hash chain */
+	/* Delete this entry from the hash chain. */
 	if (pt)
 		pt->next = p->next;
 	else
@@ -279,16 +308,19 @@ rf_RemoveFromActiveReconTable(raidPtr, row, psid, which_ru)
 
 	RF_UNLOCK_MUTEX(hdr->mutex);
 
-	/* wakup anyone waiting on the parity stripe ID */
+	/* Wake-up anyone waiting on the parity stripe ID. */
 	cb = p->procWaitList;
 	p->procWaitList = NULL;
 	while (cb) {
-		Dprintf1("Waking up access waiting on parity stripe ID %ld\n", p->parityStripeID);
+		Dprintf1("Waking up access waiting on parity stripe ID %ld.\n",
+		    p->parityStripeID);
 		cb1 = cb->next;
 		(cb->callbackFunc) (cb->callbackArg);
 
-		/* THIS IS WHAT THE ORIGINAL CODE HAD... the extra 0 is bogus,
-		 * IMHO */
+		/*
+		 * THIS IS WHAT THE ORIGINAL CODE HAD... the extra 0 is bogus,
+		 * IMHO.
+		 */
 		/* (cb->callbackFunc)(cb->callbackArg, 0); */
 		rf_FreeCallbackDesc(cb);
 		cb = cb1;
@@ -298,39 +330,38 @@ rf_RemoveFromActiveReconTable(raidPtr, row, psid, which_ru)
 }
 
 RF_ReconParityStripeStatus_t *
-rf_AllocPSStatus(raidPtr)
-	RF_Raid_t *raidPtr;
+rf_AllocPSStatus(RF_Raid_t *raidPtr)
 {
 	RF_ReconParityStripeStatus_t *p;
 
-	RF_FREELIST_GET_INIT_ARG(raidPtr->pss_freelist, p, next, (RF_ReconParityStripeStatus_t *), init_pss, raidPtr);
+	RF_FREELIST_GET_INIT_ARG(raidPtr->pss_freelist, p, next,
+	    (RF_ReconParityStripeStatus_t *), rf_init_pss, raidPtr);
 	if (p) {
 		bzero(p->issued, raidPtr->numCol);
 	}
 	p->next = NULL;
-	/* no need to initialize here b/c the only place we're called from is
-	 * the above Lookup */
+	/*
+	 * No need to initialize here b/c the only place we're called from is
+	 * the above Lookup.
+	 */
 	return (p);
 }
 
-void 
-rf_FreePSStatus(raidPtr, p)
-	RF_Raid_t *raidPtr;
-	RF_ReconParityStripeStatus_t *p;
+void
+rf_FreePSStatus(RF_Raid_t *raidPtr, RF_ReconParityStripeStatus_t *p)
 {
 	RF_ASSERT(p->procWaitList == NULL);
 	RF_ASSERT(p->blockWaitList == NULL);
 	RF_ASSERT(p->bufWaitList == NULL);
 
-	RF_FREELIST_FREE_CLEAN_ARG(raidPtr->pss_freelist, p, next, clean_pss, raidPtr);
+	RF_FREELIST_FREE_CLEAN_ARG(raidPtr->pss_freelist, p, next,
+	    rf_clean_pss, raidPtr);
 }
 
-static void 
-RealPrintPSStatusTable(raidPtr, pssTable)
-	RF_Raid_t *raidPtr;
-	RF_PSStatusHeader_t *pssTable;
+void
+rf_RealPrintPSStatusTable(RF_Raid_t *raidPtr, RF_PSStatusHeader_t *pssTable)
 {
-	int     i, j, procsWaiting, blocksWaiting, bufsWaiting;
+	int i, j, procsWaiting, blocksWaiting, bufsWaiting;
 	RF_ReconParityStripeStatus_t *p;
 	RF_CallbackDesc_t *cb;
 
@@ -344,8 +375,11 @@ RealPrintPSStatusTable(raidPtr, pssTable)
 				blocksWaiting++;
 			for (cb = p->bufWaitList; cb; cb = cb->next)
 				bufsWaiting++;
-			printf("PSID %ld RU %d : blockCount %d %d/%d/%d proc/block/buf waiting, issued ",
-			    (long) p->parityStripeID, p->which_ru, p->blockCount, procsWaiting, blocksWaiting, bufsWaiting);
+			printf("PSID %ld RU %d : blockCount %d %d/%d/%d"
+			    " proc/block/buf waiting, issued ",
+			    (long) p->parityStripeID, p->which_ru,
+			    p->blockCount, procsWaiting, blocksWaiting,
+			    bufsWaiting);
 			for (j = 0; j < raidPtr->numCol; j++)
 				printf("%c", (p->issued[j]) ? '1' : '0');
 			if (!p->flags)
@@ -367,11 +401,9 @@ RealPrintPSStatusTable(raidPtr, pssTable)
 	}
 }
 
-void 
-rf_PrintPSStatusTable(raidPtr, row)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
+void
+rf_PrintPSStatusTable(RF_Raid_t *raidPtr, RF_RowCol_t row)
 {
 	RF_PSStatusHeader_t *pssTable = raidPtr->reconControl[row]->pssTable;
-	RealPrintPSStatusTable(raidPtr, pssTable);
+	rf_RealPrintPSStatusTable(raidPtr, pssTable);
 }
diff --git a/sys/dev/raidframe/rf_psstatus.h b/sys/dev/raidframe/rf_psstatus.h
index 76fbb6999a0..2fa397981e9 100644
--- a/sys/dev/raidframe/rf_psstatus.h
+++ b/sys/dev/raidframe/rf_psstatus.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_psstatus.h,v 1.2 1999/02/16 00:03:13 niklas Exp $	*/
+/*	$OpenBSD: rf_psstatus.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_psstatus.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -32,101 +33,145 @@
  * psstatus.h
  *
  * The reconstruction code maintains a bunch of status related to the parity
- * stripes that are currently under reconstruction.  This header file defines
+ * stripes that are currently under reconstruction. This header file defines
  * the status structures.
  *
  *****************************************************************************/
 
-#ifndef _RF__RF_PSSTATUS_H_
-#define _RF__RF_PSSTATUS_H_
+#ifndef	_RF__RF_PSSTATUS_H_
+#define	_RF__RF_PSSTATUS_H_
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
 #include "rf_callback.h"
 
-#define RF_PS_MAX_BUFS 10	/* max number of bufs we'll accumulate before
-				 * we do an XOR */
+#define	RF_PS_MAX_BUFS			 10	/*
+						 * Max number of bufs we'll
+						 * accumulate before we do
+						 * an XOR.
+						 */
 
-#define RF_PSS_DEFAULT_TABLESIZE 200
+#define	RF_PSS_DEFAULT_TABLESIZE	200
 
 /*
  * Macros to acquire/release the mutex lock on a parity stripe status
  * descriptor. Note that we use just one lock for the whole hash chain.
  */
-#define RF_HASH_PSID(_raid_,_psid_) ( (_psid_) % ((_raid_)->pssTableSize) )	/* simple hash function */
-#define RF_LOCK_PSS_MUTEX(_raidPtr, _row, _psid) \
-  RF_LOCK_MUTEX((_raidPtr)->reconControl[_row]->pssTable[ RF_HASH_PSID(_raidPtr,_psid) ].mutex)
-#define RF_UNLOCK_PSS_MUTEX(_raidPtr, _row, _psid) \
-  RF_UNLOCK_MUTEX((_raidPtr)->reconControl[_row]->pssTable[ RF_HASH_PSID(_raidPtr,_psid) ].mutex)
+/* Simple hash function. */
+#define	RF_HASH_PSID(_raid_,_psid_)	((_psid_) % ((_raid_)->pssTableSize))
+
+#define	RF_LOCK_PSS_MUTEX(_raidPtr,_row,_psid)				\
+	RF_LOCK_MUTEX((_raidPtr)->reconControl[_row]			\
+	    ->pssTable[RF_HASH_PSID(_raidPtr, _psid)].mutex)
+#define	RF_UNLOCK_PSS_MUTEX(_raidPtr, _row, _psid)			\
+	RF_UNLOCK_MUTEX((_raidPtr)->reconControl[_row]			\
+	    ->pssTable[RF_HASH_PSID(_raidPtr, _psid)].mutex)
 
 struct RF_ReconParityStripeStatus_s {
-	RF_StripeNum_t parityStripeID;	/* the parity stripe ID */
-	RF_ReconUnitNum_t which_ru;	/* which reconstruction unit with the
-					 * indicated parity stripe */
-	RF_PSSFlags_t flags;	/* flags indicating various conditions */
-	void   *rbuf;		/* this is the accumulating xor sum */
-	void   *writeRbuf;	/* DEBUG ONLY:  a pointer to the rbuf after it
-				 * has filled & been sent to disk */
-	void   *rbufsForXor[RF_PS_MAX_BUFS];	/* these are buffers still to
+	RF_StripeNum_t		 parityStripeID;/* The parity stripe ID. */
+	RF_ReconUnitNum_t	 which_ru;	/*
+						 * Which reconstruction unit
+						 * with the indicated parity
+						 * stripe.
+						 */
+	RF_PSSFlags_t		 flags;		/*
+						 * Flags indicating various
+						 * conditions.
+						 */
+	void			*rbuf;		/*
+						 * This is the accumulating
+						 * xor sum.
+						 */
+	void			*writeRbuf;	/*
+						 * DEBUG ONLY:  A pointer to
+						 * the rbuf after it has filled
+						 * & been sent to disk.
+						 */
+	void			*rbufsForXor[RF_PS_MAX_BUFS];
+						/*
+						 * These are buffers still to
 						 * be xored into the
-						 * accumulating sum */
-	int     xorBufCount;	/* num buffers waiting to be xored */
-	int     blockCount;	/* count of # proc that have blocked recon on
-				 * this parity stripe */
-	char   *issued;		/* issued[i]==1 <=> column i has already
-				 * issued a read request for the indicated RU */
-	RF_CallbackDesc_t *procWaitList;	/* list of user procs waiting
-						 * for recon to be done */
-	RF_CallbackDesc_t *blockWaitList;	/* list of disks blocked
+						 * accumulating sum.
+						 */
+	int			 xorBufCount;	/*
+						 * Num buffers waiting to be
+						 * xored.
+						 */
+	int			 blockCount;	/*
+						 * Count of # proc that have
+						 * blocked recon on this parity
+						 * stripe.
+						 */
+	char			*issued;	/*
+						 * issued[i]==1 <=> column i
+						 * has already issued a read
+						 * request for the indicated
+						 * RU.
+						 */
+	RF_CallbackDesc_t	*procWaitList;	/*
+						 * List of user procs waiting
+						 * for recon to be done.
+						 */
+	RF_CallbackDesc_t	*blockWaitList;	/*
+						 * List of disks blocked
 						 * waiting for user write to
-						 * complete */
-	RF_CallbackDesc_t *bufWaitList;	/* list of disks blocked waiting to
-					 * acquire a buffer for this RU */
+						 * complete.
+						 */
+	RF_CallbackDesc_t	*bufWaitList;	/*
+						 * List of disks blocked
+						 * waiting to acquire a buffer
+						 * for this RU.
+						 */
 	RF_ReconParityStripeStatus_t *next;
 };
 
 struct RF_PSStatusHeader_s {
-	RF_DECLARE_MUTEX(mutex)	/* mutex for this hash chain */
-	RF_ReconParityStripeStatus_t *chain;	/* the hash chain */
+	RF_DECLARE_MUTEX(mutex);		/* Mutex for this hash chain. */
+	RF_ReconParityStripeStatus_t *chain;	/* The hash chain. */
 };
-/* masks for the "flags" field above */
-#define RF_PSS_NONE            0x00000000	/* no flags */
-#define RF_PSS_UNDER_RECON     0x00000001	/* this parity stripe is
+
+/* Masks for the "flags" field above. */
+#define	RF_PSS_NONE		0x00000000	/* No flags. */
+#define	RF_PSS_UNDER_RECON	0x00000001	/*
+						 * This parity stripe is
 						 * currently under
-						 * reconstruction */
-#define RF_PSS_FORCED_ON_WRITE 0x00000002	/* indicates a recon was
+						 * reconstruction.
+						 */
+#define	RF_PSS_FORCED_ON_WRITE	0x00000002	/*
+						 * Indicates a recon was
 						 * forced due to a user-write
-						 * operation */
-#define RF_PSS_FORCED_ON_READ  0x00000004	/* ditto for read, but not
-						 * currently implemented */
-#define RF_PSS_RECON_BLOCKED   0x00000008	/* reconstruction is currently
+						 * operation.
+						 */
+#define	RF_PSS_FORCED_ON_READ	0x00000004	/*
+						 * Ditto for read, but not
+						 * currently implemented.
+						 */
+#define	RF_PSS_RECON_BLOCKED	0x00000008	/*
+						 * Reconstruction is currently
 						 * blocked due to a pending
-						 * user I/O */
-#define RF_PSS_CREATE          0x00000010	/* tells LookupRUStatus to
-						 * create the entry */
-#define RF_PSS_BUFFERWAIT      0x00000020	/* someone is waiting for a
-						 * buffer for this RU */
-
-int 
-rf_ConfigurePSStatus(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
+						 * user I/O.
+						 */
+#define	RF_PSS_CREATE		0x00000010	/*
+						 * Tells LookupRUStatus to
+						 * create the entry.
+						 */
+#define	RF_PSS_BUFFERWAIT	0x00000020	/*
+						 * Someone is waiting for a
+						 * buffer for this RU.
+						 */
 
-RF_PSStatusHeader_t *rf_MakeParityStripeStatusTable(RF_Raid_t * raidPtr);
-void 
-rf_FreeParityStripeStatusTable(RF_Raid_t * raidPtr,
-    RF_PSStatusHeader_t * pssTable);
-RF_ReconParityStripeStatus_t *
-rf_LookupRUStatus(RF_Raid_t * raidPtr,
-    RF_PSStatusHeader_t * pssTable, RF_StripeNum_t psID,
-    RF_ReconUnitNum_t which_ru, RF_PSSFlags_t flags, int *created);
-void 
-rf_PSStatusDelete(RF_Raid_t * raidPtr, RF_PSStatusHeader_t * pssTable,
-    RF_ReconParityStripeStatus_t * pssPtr);
-void 
-rf_RemoveFromActiveReconTable(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_StripeNum_t psid, RF_ReconUnitNum_t which_ru);
-RF_ReconParityStripeStatus_t *rf_AllocPSStatus(RF_Raid_t * raidPtr);
-void    rf_FreePSStatus(RF_Raid_t * raidPtr, RF_ReconParityStripeStatus_t * p);
-void    rf_PrintPSStatusTable(RF_Raid_t * raidPtr, RF_RowCol_t row);
+int  rf_ConfigurePSStatus(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+RF_PSStatusHeader_t *rf_MakeParityStripeStatusTable(RF_Raid_t *);
+void rf_FreeParityStripeStatusTable(RF_Raid_t *, RF_PSStatusHeader_t *);
+RF_ReconParityStripeStatus_t *rf_LookupRUStatus(RF_Raid_t *,
+	RF_PSStatusHeader_t *, RF_StripeNum_t, RF_ReconUnitNum_t,
+	RF_PSSFlags_t, int *);
+void rf_PSStatusDelete(RF_Raid_t *, RF_PSStatusHeader_t *,
+	RF_ReconParityStripeStatus_t *);
+void rf_RemoveFromActiveReconTable(RF_Raid_t *, RF_RowCol_t,
+	RF_StripeNum_t, RF_ReconUnitNum_t);
+RF_ReconParityStripeStatus_t *rf_AllocPSStatus(RF_Raid_t *);
+void rf_FreePSStatus(RF_Raid_t *, RF_ReconParityStripeStatus_t *);
+void rf_PrintPSStatusTable(RF_Raid_t *, RF_RowCol_t);
 
-#endif				/* !_RF__RF_PSSTATUS_H_ */
+#endif	/* !_RF__RF_PSSTATUS_H_ */
diff --git a/sys/dev/raidframe/rf_raid.h b/sys/dev/raidframe/rf_raid.h
index a78b4a41841..d1277a723ca 100644
--- a/sys/dev/raidframe/rf_raid.h
+++ b/sys/dev/raidframe/rf_raid.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid.h,v 1.6 2000/08/08 16:07:44 peter Exp $	*/
+/*	$OpenBSD: rf_raid.h,v 1.7 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid.h,v 1.12 2000/02/24 17:12:10 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,21 +28,21 @@
  * rights to redistribute these changes.
  */
 
-/**********************************************
- * rf_raid.h -- main header file for RAID driver
- **********************************************/
+/*************************************************
+ * rf_raid.h -- Main header file for RAID driver.
+ *************************************************/
 
 
-#ifndef _RF__RF_RAID_H_
-#define _RF__RF_RAID_H_
+#ifndef	_RF__RF_RAID_H_
+#define	_RF__RF_RAID_H_
 
 #include "rf_archs.h"
 #include "rf_types.h"
 #include "rf_threadstuff.h"
 
-#if defined(__NetBSD__)
+#if	defined(__NetBSD__)
 #include "rf_netbsd.h"
-#elif defined(__OpenBSD__)
+#elif	defined(__OpenBSD__)
 #include "rf_openbsd.h"
 #endif
 
@@ -57,17 +58,17 @@
 #include "rf_reconstruct.h"
 #include "rf_acctrace.h"
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 #include "rf_paritylog.h"
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
 
-#define RF_MAX_DISKS 128	/* max disks per array */
-#define RF_DEV2RAIDID(_dev)  (DISKUNIT(_dev))
+#define	RF_MAX_DISKS			128	/* Max disks per array. */
+#define	RF_DEV2RAIDID(_dev)		(DISKUNIT(_dev))
 
-#define RF_COMPONENT_LABEL_VERSION_1 1
-#define RF_COMPONENT_LABEL_VERSION 2
-#define RF_RAID_DIRTY 0
-#define RF_RAID_CLEAN 1
+#define	RF_COMPONENT_LABEL_VERSION_1	1
+#define	RF_COMPONENT_LABEL_VERSION	2
+#define	RF_RAID_DIRTY			0
+#define	RF_RAID_CLEAN			1
 
 /*
  * Each row in the array is a distinct parity group, so
@@ -78,218 +79,345 @@ typedef enum RF_RowStatus_e {
 	rf_rs_degraded,
 	rf_rs_reconstructing,
 	rf_rs_reconfigured
-}       RF_RowStatus_t;
+} RF_RowStatus_t;
 
 struct RF_CumulativeStats_s {
-	struct timeval start;	/* the time when the stats were last started */
-	struct timeval stop;	/* the time when the stats were last stopped */
-	long    sum_io_us;	/* sum of all user response times (us) */
-	long    num_ios;	/* total number of I/Os serviced */
-	long    num_sect_moved;	/* total number of sectors read or written */
+	struct timeval		start;		/*
+						 * The time when the stats were
+						 * last started.
+						 */
+	struct timeval		stop;		/*
+						 * The time when the stats were
+						 * last stopped.
+						 */
+	long			sum_io_us;	/*
+						 * Sum of all user response
+						 * times (us).
+						 */
+	long			num_ios;	/*
+						 * Total number of I/Os
+						 * serviced.
+						 */
+	long			num_sect_moved;	/*
+						 * Total number of sectors read
+						 * or written.
+						 */
 };
 
 struct RF_ThroughputStats_s {
-	RF_DECLARE_MUTEX(mutex)	/* a mutex used to lock the configuration
-				 * stuff */
-	struct timeval start;	/* timer started when numOutstandingRequests
-				 * moves from 0 to 1 */
-	struct timeval stop;	/* timer stopped when numOutstandingRequests
-				 * moves from 1 to 0 */
-	RF_uint64 sum_io_us;	/* total time timer is enabled */
-	RF_uint64 num_ios;	/* total number of ios processed by RAIDframe */
-	long    num_out_ios;	/* number of outstanding ios */
+	RF_DECLARE_MUTEX	(mutex);	/*
+						 * A mutex used to lock the
+						 * configuration stuff.
+						 */
+	struct timeval		 start;		/*
+						 * Timer started when
+						 * numOutstandingRequests
+						 * moves from 0 to 1.
+						 */
+	struct timeval		 stop;		/*
+						 * Timer stopped when
+						 * numOutstandingRequests
+						 * moves from 1 to 0.
+						 */
+	RF_uint64		 sum_io_us;	/*
+						 * Total time timer is enabled.
+						 */
+	RF_uint64		 num_ios;	/*
+						 * Total number of I/Os
+						 * processed by RAIDframe.
+						 */
+	long			 num_out_ios;	/*
+						 * Number of outstanding I/Os.
+						 */
 };
 
 struct RF_Raid_s {
 	/* This portion never changes, and can be accessed without locking */
-	/* an exception is Disks[][].status, which requires locking when it is
-	 * changed.  XXX this is no longer true.  numSpare and friends can 
-	 * change now. 
-         */
-	u_int   numRow;		/* number of rows of disks, typically == # of
-				 * ranks */
-	u_int   numCol;		/* number of columns of disks, typically == #
-				 * of disks/rank */
-	u_int   numSpare;	/* number of spare disks */
-	int     maxQueueDepth;	/* max disk queue depth */
-	RF_SectorCount_t totalSectors;	/* total number of sectors in the
-					 * array */
-	RF_SectorCount_t sectorsPerDisk;	/* number of sectors on each
-						 * disk */
-	u_int   logBytesPerSector;	/* base-2 log of the number of bytes
-					 * in a sector */
-	u_int   bytesPerSector;	/* bytes in a sector */
-	RF_int32 sectorMask;	/* mask of bytes-per-sector */
-
-	RF_RaidLayout_t Layout;	/* all information related to layout */
-	RF_RaidDisk_t **Disks;	/* all information related to physical disks */
-	RF_DiskQueue_t **Queues;/* all information related to disk queues */
-	RF_DiskQueueSW_t *qType;/* pointer to the DiskQueueSW used for the
-				   component queues. */
-	/* NOTE:  This is an anchor point via which the queues can be
+	/*
+	 * An exception is Disks[][].status, which requires locking when it is
+	 * changed. XXX This is no longer true. numSpare and friends can
+	 * change now.
+	 */
+	u_int			  numRow;	/*
+						 * Number of rows of disks,
+						 * typically == # of ranks.
+						 */
+	u_int			  numCol;	/*
+						 * Number of columns of disks,
+						 * typically == # of disks/rank.
+						 */
+	u_int			  numSpare;	/* Number of spare disks. */
+	int			  maxQueueDepth;/* Max disk queue depth. */
+	RF_SectorCount_t	  totalSectors;	/*
+						 * Total number of sectors
+						 * in the array.
+						 */
+	RF_SectorCount_t	  sectorsPerDisk;
+						/*
+						 * Number of sectors on each
+						 * disk.
+						 */
+	u_int			  logBytesPerSector;
+						/*
+						 * Base-2 log of the number
+						 * of bytes in a sector.
+						 */
+	u_int			  bytesPerSector;
+						/* Bytes in a sector. */
+	RF_int32		  sectorMask;	/* Mask of bytes-per-sector. */
+
+	RF_RaidLayout_t		  Layout;	/*
+						 * All information related to
+						 * layout.
+						 */
+	RF_RaidDisk_t		**Disks;	/*
+						 * All information related to
+						 * physical disks.
+						 */
+	RF_DiskQueue_t		**Queues;	/*
+						 * All information related to
+						 * disk queues.
+						 */
+	RF_DiskQueueSW_t	 *qType;	/*
+						 * Pointer to the DiskQueueSW
+						 * used for the component
+						 * queues.
+						 */
+	/*
+	 * NOTE:  This is an anchor point via which the queues can be
 	 * accessed, but the enqueue/dequeue routines in diskqueue.c use a
-	 * local copy of this pointer for the actual accesses. */
-	/* The remainder of the structure can change, and therefore requires
-	 * locking on reads and updates */
-	        RF_DECLARE_MUTEX(mutex)	/* mutex used to serialize access to
-					 * the fields below */
-	RF_RowStatus_t *status;	/* the status of each row in the array */
-	int     valid;		/* indicates successful configuration */
-	RF_LockTableEntry_t *lockTable;	/* stripe-lock table */
-	RF_LockTableEntry_t *quiesceLock;	/* quiesnce table */
-	int     numFailures;	/* total number of failures in the array */
-	int     numNewFailures; /* number of *new* failures (that havn't 
-				   caused a mod_counter update */
-
-	int     parity_good;    /* !0 if parity is known to be correct */
-	int     serial_number;  /* a "serial number" for this set */
-	int     mod_counter;    /* modification counter for component labels */
-	int     clean;          /* the clean bit for this array. */
-
-	int     openings;       /* Number of IO's which can be scheduled
-				   simultaneously (high-level - not a 
-				   per-component limit)*/
-
-	int maxOutstanding;   /* maxOutstanding requests (per-component) */
-	int autoconfigure;    /* automatically configure this RAID set. 
-				 0 == no, 1 == yes */
-	int root_partition;   /* Use this set as /
-				 0 == no, 1 == yes*/
-	int last_unit;        /* last unit number (e.g. 0 for /dev/raid0) 
-				 of this component.  Used for autoconfigure
-				 only. */
-	int config_order;     /* 0 .. n.  The order in which the component
-				 should be auto-configured.  E.g. 0 is will 
-				 done first, (and would become raid0).
-				 This may be in conflict with last_unit!!?! */
-	                      /* Not currently used. */
+	 * local copy of this pointer for the actual accesses.
+	 */
+	/*
+	 * The remainder of the structure can change, and therefore requires
+	 * locking on reads and updates.
+	 */
+	RF_DECLARE_MUTEX	 (mutex);	/*
+						 * Mutex used to serialize
+						 * access to the fields below.
+						 */
+	RF_RowStatus_t		 *status;	/*
+						 * The status of each row in
+						 * the array.
+						 */
+	int			  valid;	/*
+						 * Indicates successful
+						 * configuration.
+						 */
+	RF_LockTableEntry_t	 *lockTable;	/* Stripe-lock table. */
+	RF_LockTableEntry_t	 *quiesceLock;	/* Quiescence table. */
+	int			  numFailures;	/*
+						 * Total number of failures
+						 * in the array.
+						 */
+	int			  numNewFailures;
+						/*
+						 * Number of *new* failures
+						 * (that haven't caused a
+						 * mod_counter update).
+						 */
+
+	int			  parity_good;	/*
+						 * !0 if parity is known to be
+						 * correct.
+						 */
+	int			  serial_number;/*
+						 * A "serial number" for this
+						 * set.
+						 */
+	int			  mod_counter;	/*
+						 * Modification counter for
+						 * component labels.
+						 */
+	int			  clean;	/*
+						 * The clean bit for this array.
+						 */
+
+	int			  openings;	/*
+						 * Number of I/Os that can be
+						 * scheduled simultaneously
+						 * (high-level - not a
+				 		 * per-component limit).
+						 */
+
+	int			  maxOutstanding;
+						/*
+						 * maxOutstanding requests
+						 * (per-component).
+						 */
+	int			  autoconfigure;
+						/*
+						 * Automatically configure
+						 * this RAID set.
+						 * 0 == no, 1 == yes
+						 */
+	int			  root_partition;
+						/*
+						 * Use this set as
+						 * 0 == no, 1 == yes.
+						 */
+	int			  last_unit;	/*
+						 * Last unit number (e.g. 0
+						 * for /dev/raid0) of this
+						 * component. Used for
+						 * autoconfigure only.
+						 */
+	int			  config_order;	/*
+						 * 0 .. n. The order in which
+						 * the component should be
+						 * auto-configured.
+						 * E.g. 0 is will done first,
+						 * (and would become raid0).
+						 * This may be in conflict
+						 * with last_unit !!?!
+						 */
+						/* Not currently used. */
 
 	/*
-         * Cleanup stuff
-         */
-	RF_ShutdownList_t *shutdownList;	/* shutdown activities */
-	RF_AllocListElem_t *cleanupList;	/* memory to be freed at
-						 * shutdown time */
+	 * Cleanup stuff.
+	 */
+	RF_ShutdownList_t	 *shutdownList;	/* Shutdown activities. */
+	RF_AllocListElem_t	 *cleanupList;	/*
+						 * Memory to be freed at
+						 * shutdown time.
+						 */
 
 	/*
-         * Recon stuff
-         */
-	RF_HeadSepLimit_t headSepLimit;
-	int     numFloatingReconBufs;
-	int     reconInProgress;
-	        RF_DECLARE_COND(waitForReconCond)
-	RF_RaidReconDesc_t *reconDesc;	/* reconstruction descriptor */
-	RF_ReconCtrl_t **reconControl;	/* reconstruction control structure
-					 * pointers for each row in the array */
+	 * Recon stuff.
+	 */
+	RF_HeadSepLimit_t	  headSepLimit;
+	int			  numFloatingReconBufs;
+	int			  reconInProgress;
+	RF_DECLARE_COND		 (waitForReconCond);
+	RF_RaidReconDesc_t	 *reconDesc;	/* Reconstruction descriptor. */
+	RF_ReconCtrl_t		**reconControl;	/*
+						 * Reconstruction control
+						 * structure pointers for each
+						 * row in the array.
+						 */
 
 	/*
-         * Array-quiescence stuff
-         */
-	        RF_DECLARE_MUTEX(access_suspend_mutex)
-	        RF_DECLARE_COND(quiescent_cond)
-	RF_IoCount_t accesses_suspended;
-	RF_IoCount_t accs_in_flight;
-	int     access_suspend_release;
-	int     waiting_for_quiescence;
-	RF_CallbackDesc_t *quiesce_wait_list;
+	 * Array-quiescence stuff.
+	 */
+	RF_DECLARE_MUTEX	 (access_suspend_mutex);
+	RF_DECLARE_COND		 (quiescent_cond);
+	RF_IoCount_t		  accesses_suspended;
+	RF_IoCount_t		  accs_in_flight;
+	int			  access_suspend_release;
+	int			  waiting_for_quiescence;
+	RF_CallbackDesc_t	 *quiesce_wait_list;
 
 	/*
-         * Statistics
-         */
-#if !defined(_KERNEL) && !defined(SIMULATE)
-	RF_ThroughputStats_t throughputstats;
-#endif				/* !_KERNEL && !SIMULATE */
-	RF_CumulativeStats_t userstats;
-	int     parity_rewrite_stripes_done;
-	int     recon_stripes_done;
-	int     copyback_stripes_done;
-
-	int     recon_in_progress;
-	int     parity_rewrite_in_progress;
-	int     copyback_in_progress;
+	 * Statistics.
+	 */
+#if	!defined(_KERNEL) && !defined(SIMULATE)
+	RF_ThroughputStats_t	  throughputstats;
+#endif	/* !_KERNEL && !SIMULATE */
+	RF_CumulativeStats_t	  userstats;
+	int			  parity_rewrite_stripes_done;
+	int			  recon_stripes_done;
+	int			  copyback_stripes_done;
+
+	int			  recon_in_progress;
+	int			  parity_rewrite_in_progress;
+	int			  copyback_in_progress;
 
 	/*
-         * Engine thread control
-         */
-	RF_DECLARE_MUTEX(node_queue_mutex)
-	RF_DECLARE_COND(node_queue_cond)
-	RF_DagNode_t *node_queue;
-	RF_Thread_t parity_rewrite_thread;
-	RF_Thread_t copyback_thread;
-	RF_Thread_t engine_thread;
-	RF_Thread_t recon_thread;
-	RF_ThreadGroup_t engine_tg;
-	int     shutdown_engine;
-	int     dags_in_flight;	/* debug */
+	 * Engine thread control.
+	 */
+	RF_DECLARE_MUTEX	 (node_queue_mutex);
+	RF_DECLARE_COND		 (node_queue_cond);
+	RF_DagNode_t		 *node_queue;
+	RF_Thread_t		  parity_rewrite_thread;
+	RF_Thread_t		  copyback_thread;
+	RF_Thread_t		  engine_thread;
+	RF_Thread_t		  recon_thread;
+	RF_ThreadGroup_t	  engine_tg;
+	int			  shutdown_engine;
+	int			  dags_in_flight;	/* Debug. */
 
 	/*
-         * PSS (Parity Stripe Status) stuff
-         */
-	RF_FreeList_t *pss_freelist;
-	long    pssTableSize;
+	 * PSS (Parity Stripe Status) stuff.
+	 */
+	RF_FreeList_t		 *pss_freelist;
+	long			  pssTableSize;
 
 	/*
-         * Reconstruction stuff
-         */
-	int     procsInBufWait;
-	int     numFullReconBuffers;
-	RF_AccTraceEntry_t *recon_tracerecs;
-	unsigned long accumXorTimeUs;
-	RF_ReconDoneProc_t *recon_done_procs;
-	        RF_DECLARE_MUTEX(recon_done_proc_mutex)
+	 * Reconstruction stuff.
+	 */
+	int			  procsInBufWait;
+	int			  numFullReconBuffers;
+	RF_AccTraceEntry_t	 *recon_tracerecs;
+	unsigned long		  accumXorTimeUs;
+	RF_ReconDoneProc_t	 *recon_done_procs;
+	RF_DECLARE_MUTEX	 (recon_done_proc_mutex);
 	/*
-         * nAccOutstanding, waitShutdown protected by desc freelist lock
-         * (This may seem strange, since that's a central serialization point
-         * for a per-array piece of data, but otherwise, it'd be an extra
-         * per-array lock, and that'd only be less efficient...)
-         */
-	        RF_DECLARE_COND(outstandingCond)
-	int     waitShutdown;
-	int     nAccOutstanding;
+	 * nAccOutstanding, waitShutdown protected by desc freelist lock
+	 * (This may seem strange, since that's a central serialization point
+	 * for a per-array piece of data, but otherwise, it'd be an extra
+	 * per-array lock, and that'd only be less efficient...)
+	 */
+	RF_DECLARE_COND		 (outstandingCond);
+	int			  waitShutdown;
+	int			  nAccOutstanding;
 
-	RF_DiskId_t **diskids;
-	RF_DiskId_t *sparediskids;
+	RF_DiskId_t		**diskids;
+	RF_DiskId_t		 *sparediskids;
 
-	int     raidid;
-	RF_AccTotals_t acc_totals;
-	int     keep_acc_totals;
+	int			  raidid;
+	RF_AccTotals_t		  acc_totals;
+	int			  keep_acc_totals;
 
-	struct raidcinfo **raid_cinfo;	/* array of component info */
+	struct raidcinfo	**raid_cinfo;	/* Array of component info. */
 
-	int     terminate_disk_queues;
+	int			  terminate_disk_queues;
 
 	/*
-         * XXX
-         *
-         * config-specific information should be moved
-         * somewhere else, or at least hung off this
-         * in some generic way
-         */
+	 * XXX
+	 *
+	 * Config-specific information should be moved
+	 * somewhere else, or at least hung off this
+	 * in some generic way.
+	 */
 
-	/* used by rf_compute_workload_shift */
-	RF_RowCol_t hist_diskreq[RF_MAXROW][RF_MAXCOL];
+	/* Used by rf_compute_workload_shift. */
+	RF_RowCol_t		  hist_diskreq[RF_MAXROW][RF_MAXCOL];
 
-	/* used by declustering */
-	int     noRotate;
+	/* Used by declustering. */
+	int			  noRotate;
 
-#if RF_INCLUDE_PARITYLOGGING > 0
+#if	RF_INCLUDE_PARITYLOGGING > 0
 	/* used by parity logging */
-	RF_SectorCount_t regionLogCapacity;
-	RF_ParityLogQueue_t parityLogPool;	/* pool of unused parity logs */
-	RF_RegionInfo_t *regionInfo;	/* array of region state */
-	int     numParityLogs;
-	int     numSectorsPerLog;
-	int     regionParityRange;
-	int     logsInUse;	/* debugging */
-	RF_ParityLogDiskQueue_t parityLogDiskQueue;	/* state of parity
-							 * logging disk work */
-	RF_RegionBufferQueue_t regionBufferPool;	/* buffers for holding
-							 * region log */
-	RF_RegionBufferQueue_t parityBufferPool;	/* buffers for holding
-							 * parity */
-	caddr_t parityLogBufferHeap;	/* pool of unused parity logs */
-	RF_Thread_t pLogDiskThreadHandle;
-
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
+	RF_SectorCount_t	  regionLogCapacity;
+	RF_ParityLogQueue_t	  parityLogPool;/*
+						 * Pool of unused parity logs.
+						 */
+	RF_RegionInfo_t		 *regionInfo;	/* Array of region state. */
+	int			  numParityLogs;
+	int			  numSectorsPerLog;
+	int			  regionParityRange;
+	int			  logsInUse;	/* Debugging. */
+	RF_ParityLogDiskQueue_t	  parityLogDiskQueue;
+						/*
+						 * State of parity logging
+						 * disk work.
+						 */
+	RF_RegionBufferQueue_t	  regionBufferPool;
+					 	/*
+						 * buffers for holding region
+						 * log.
+						 */
+	RF_RegionBufferQueue_t	  parityBufferPool;
+						/*
+						 * Buffers for holding parity.
+						 */
+	caddr_t			  parityLogBufferHeap;
+						/*
+						 * Pool of unused parity logs.
+						 */
+	RF_Thread_t		  pLogDiskThreadHandle;
+
+#endif	/* RF_INCLUDE_PARITYLOGGING > 0 */
 };
-#endif				/* !_RF__RF_RAID_H_ */
+
+#endif	/* !_RF__RF_RAID_H_ */
diff --git a/sys/dev/raidframe/rf_raid0.c b/sys/dev/raidframe/rf_raid0.c
index be28e945deb..0cf113db220 100644
--- a/sys/dev/raidframe/rf_raid0.c
+++ b/sys/dev/raidframe/rf_raid0.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid0.c,v 1.3 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_raid0.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid0.c,v 1.4 2000/01/07 03:41:02 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/***************************************
+/*****************************************
  *
- * rf_raid0.c -- implements RAID Level 0
+ * rf_raid0.c -- Implements RAID Level 0.
  *
- ***************************************/
+ *****************************************/
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -47,75 +48,67 @@
 
 typedef struct RF_Raid0ConfigInfo_s {
 	RF_RowCol_t *stripeIdentifier;
-}       RF_Raid0ConfigInfo_t;
+} RF_Raid0ConfigInfo_t;
 
-int 
-rf_ConfigureRAID0(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureRAID0(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_Raid0ConfigInfo_t *info;
 	RF_RowCol_t i;
 
-	/* create a RAID level 0 configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_Raid0ConfigInfo_t), (RF_Raid0ConfigInfo_t *), raidPtr->cleanupList);
+	/* Create a RAID level 0 configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_Raid0ConfigInfo_t),
+	    (RF_Raid0ConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
-	RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol * sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
+	RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol *
+	    sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
 	for (i = 0; i < raidPtr->numCol; i++)
 		info->stripeIdentifier[i] = i;
 
 	RF_ASSERT(raidPtr->numRow == 1);
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
+	    raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->dataSectorsPerStripe = raidPtr->numCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	layoutPtr->dataSectorsPerStripe = raidPtr->numCol *
+	    layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = raidPtr->numCol;
 	layoutPtr->numParityCol = 0;
 	return (0);
 }
 
-void 
-rf_MapSectorRAID0(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapSectorRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, 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;
-	*diskSector = (SUID / raidPtr->numCol) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / raidPtr->numCol) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
-rf_MapParityRAID0(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	*row = *col = 0;
 	*diskSector = 0;
 }
 
-void 
-rf_IdentifyStripeRAID0(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeRAID0( RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
 	RF_Raid0ConfigInfo_t *info;
 
@@ -124,38 +117,29 @@ rf_IdentifyStripeRAID0(
 	*outRow = 0;
 }
 
-void 
-rf_MapSIDToPSIDRAID0(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDRAID0(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
+    RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
 }
 
-void 
-rf_RAID0DagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
+void
+rf_RAID0DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 {
 	*createFunc = ((type == RF_IO_TYPE_READ) ?
-	    (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG : (RF_VoidFuncPtr) rf_CreateRAID0WriteDAG);
+	    (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG :
+	    (RF_VoidFuncPtr) rf_CreateRAID0WriteDAG);
 }
 
-int 
-rf_VerifyParityRAID0(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidAddr,
-    RF_PhysDiskAddr_t * parityPDA,
-    int correct_it,
-    RF_RaidAccessFlags_t flags)
+int
+rf_VerifyParityRAID0(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
+    RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
 {
 	/*
-         * No parity is always okay.
-         */
+	 * No parity is always okay.
+	 */
 	return (RF_PARITY_OKAY);
 }
diff --git a/sys/dev/raidframe/rf_raid0.h b/sys/dev/raidframe/rf_raid0.h
index fbc74006cc7..11de277a470 100644
--- a/sys/dev/raidframe/rf_raid0.h
+++ b/sys/dev/raidframe/rf_raid0.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid0.h,v 1.2 1999/02/16 00:03:14 niklas Exp $	*/
+/*	$OpenBSD: rf_raid0.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid0.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,32 +28,23 @@
  * rights to redistribute these changes.
  */
 
-/* rf_raid0.h - header file for RAID Level 0 */
+/* rf_raid0.h - Header file for RAID Level 0. */
 
-#ifndef _RF__RF_RAID0_H_
-#define _RF__RF_RAID0_H_
+#ifndef	_RF__RF_RAID0_H_
+#define	_RF__RF_RAID0_H_
 
-int 
-rf_ConfigureRAID0(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-void 
-rf_MapSectorRAID0(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityRAID0(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeRAID0(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDRAID0(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_RAID0DagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
-int 
-rf_VerifyParityRAID0(RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-    RF_PhysDiskAddr_t * parityPDA, int correct_it, RF_RaidAccessFlags_t flags);
+int  rf_ConfigureRAID0(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+void rf_MapSectorRAID0(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityRAID0(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeRAID0(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDRAID0(RF_RaidLayout_t *, RF_StripeNum_t,
+	RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_RAID0DagSelect(RF_Raid_t *, RF_IoType_t, RF_AccessStripeMap_t *,
+	RF_VoidFuncPtr *);
+int  rf_VerifyParityRAID0(RF_Raid_t *, RF_RaidAddr_t, RF_PhysDiskAddr_t *,
+	int, RF_RaidAccessFlags_t);
 
-#endif				/* !_RF__RF_RAID0_H_ */
+#endif	/* !_RF__RF_RAID0_H_ */
diff --git a/sys/dev/raidframe/rf_raid1.c b/sys/dev/raidframe/rf_raid1.c
index aad180d4e33..e9a3dd31fe1 100644
--- a/sys/dev/raidframe/rf_raid1.c
+++ b/sys/dev/raidframe/rf_raid1.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid1.c,v 1.4 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_raid1.c,v 1.5 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid1.c,v 1.5 2000/01/08 22:57:30 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,7 +30,7 @@
 
 /*****************************************************************************
  *
- * rf_raid1.c -- implements RAID Level 1
+ * rf_raid1.c -- Implements RAID Level 1.
  *
  *****************************************************************************/
 
@@ -53,26 +54,28 @@
 
 typedef struct RF_Raid1ConfigInfo_s {
 	RF_RowCol_t **stripeIdentifier;
-}       RF_Raid1ConfigInfo_t;
-/* start of day code specific to RAID level 1 */
-int 
-rf_ConfigureRAID1(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+} RF_Raid1ConfigInfo_t;
+
+
+/* Start of day code specific to RAID level 1. */
+int
+rf_ConfigureRAID1(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_Raid1ConfigInfo_t *info;
 	RF_RowCol_t i;
 
-	/* create a RAID level 1 configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_Raid1ConfigInfo_t), (RF_Raid1ConfigInfo_t *), raidPtr->cleanupList);
+	/* Create a RAID level 1 configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_Raid1ConfigInfo_t),
+	    (RF_Raid1ConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
 	/* ... and fill it in. */
-	info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2, raidPtr->cleanupList);
+	info->stripeIdentifier = rf_make_2d_array(raidPtr->numCol / 2, 2,
+	    raidPtr->cleanupList);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
 	for (i = 0; i < (raidPtr->numCol / 2); i++) {
@@ -82,52 +85,52 @@ rf_ConfigureRAID1(
 
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	/* this implementation of RAID level 1 uses one row of numCol disks
-	 * and allows multiple (numCol / 2) stripes per row.  A stripe
+	/*
+	 * This implementation of RAID level 1 uses one row of numCol disks
+	 * and allows multiple (numCol / 2) stripes per row. A stripe
 	 * consists of a single data unit and a single parity (mirror) unit.
-	 * stripe id = raidAddr / stripeUnitSize */
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk * (raidPtr->numCol / 2);
+	 * Stripe id = raidAddr / stripeUnitSize.
+	 */
+	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
+	    (raidPtr->numCol / 2) * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk *
+	    (raidPtr->numCol / 2);
 	layoutPtr->dataSectorsPerStripe = layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = 1;
 	layoutPtr->numParityCol = 1;
 	return (0);
 }
 
 
-/* returns the physical disk location of the primary copy in the mirror pair */
-void 
-rf_MapSectorRAID1(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+/*
+ * Returns the physical disk location of the primary copy in the mirror pair.
+ */
+void
+rf_MapSectorRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
 
 	*row = 0;
 	*col = 2 * mirrorPair;
-	*diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+	*diskSector = ((SUID / (raidPtr->numCol / 2)) *
+	     raidPtr->Layout.sectorsPerStripeUnit) +
+	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
 
-/* Map Parity
+/*
+ * Map Parity.
  *
- * returns the physical disk location of the secondary copy in the mirror
- * pair
+ * Returns the physical disk location of the secondary copy in the mirror
+ * pair.
  */
-void 
-rf_MapParityRAID1(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
@@ -135,22 +138,23 @@ rf_MapParityRAID1(
 	*row = 0;
 	*col = (2 * mirrorPair) + 1;
 
-	*diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
+	*diskSector = ((SUID / (raidPtr->numCol / 2)) *
+	     raidPtr->Layout.sectorsPerStripeUnit) +
+	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
 
-/* IdentifyStripeRAID1
+/*
+ * IdentifyStripeRAID1
  *
- * returns a list of disks for a given redundancy group
+ * Returns a list of disks for a given redundancy group.
  */
-void 
-rf_IdentifyStripeRAID1(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
+	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout,
+	    addr);
 	RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
 	RF_ASSERT(stripeID >= 0);
 	RF_ASSERT(addr >= 0);
@@ -160,16 +164,14 @@ rf_IdentifyStripeRAID1(
 }
 
 
-/* MapSIDToPSIDRAID1
+/*
+ * MapSIDToPSIDRAID1
  *
- * maps a logical stripe to a stripe in the redundant array
+ * Maps a logical stripe to a stripe in the redundant array.
  */
-void 
-rf_MapSIDToPSIDRAID1(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDRAID1(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
+    RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
@@ -177,25 +179,22 @@ rf_MapSIDToPSIDRAID1(
 
 
 
-/******************************************************************************
- * select a graph to perform a single-stripe access
+/*****************************************************************************
+ * Select a graph to perform a single-stripe access.
  *
- * Parameters:  raidPtr    - description of the physical array
- *              type       - type of operation (read or write) requested
- *              asmap      - logical & physical addresses for this access
- *              createFunc - name of function to use to create the graph
+ * Parameters:	raidPtr	   - Description of the physical array.
+ *		type	   - Type of operation (read or write) requested.
+ *		asmap	   - Logical & physical addresses for this access.
+ *		createFunc - Name of function to use to create the graph.
  *****************************************************************************/
 
-void 
-rf_RAID1DagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
+void
+rf_RAID1DagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 {
 	RF_RowCol_t frow, fcol, or, oc;
 	RF_PhysDiskAddr_t *failedPDA;
-	int     prior_recon;
+	int prior_recon;
 	RF_RowStatus_t rstat;
 	RF_SectorNum_t oo;
 
@@ -203,58 +202,63 @@ rf_RAID1DagSelect(
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 
 	if (asmap->numDataFailed + asmap->numParityFailed > 1) {
-		RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("Multiple disks failed in a single group !"
+		            "  Aborting I/O operation.\n");
 		*createFunc = NULL;
 		return;
 	}
 	if (asmap->numDataFailed + asmap->numParityFailed) {
 		/*
-	         * We've got a fault. Re-map to spare space, iff applicable.
-	         * Shouldn't the arch-independent code do this for us?
-	         * Anyway, it turns out if we don't do this here, then when
-	         * we're reconstructing, writes go only to the surviving
-	         * original disk, and aren't reflected on the reconstructed
-	         * spare. Oops. --jimz
-	         */
+		 * We've got a fault. Re-map to spare space, iff applicable.
+		 * Shouldn't the arch-independent code do this for us ?
+		 * Anyway, it turns out if we don't do this here, then when
+		 * we're reconstructing, writes go only to the surviving
+		 * original disk, and aren't reflected on the reconstructed
+		 * spare. Oops. --jimz
+		 */
 		failedPDA = asmap->failedPDAs[0];
 		frow = failedPDA->row;
 		fcol = failedPDA->col;
 		rstat = raidPtr->status[frow];
 		prior_recon = (rstat == rf_rs_reconfigured) || (
 		    (rstat == rf_rs_reconstructing) ?
-		    rf_CheckRUReconstructed(raidPtr->reconControl[frow]->reconMap, failedPDA->startSector) : 0
-		    );
+		    rf_CheckRUReconstructed(raidPtr->reconControl[frow]
+		     ->reconMap, failedPDA->startSector) : 0);
 		if (prior_recon) {
 			or = frow;
 			oc = fcol;
 			oo = failedPDA->startSector;
 			/*
-		         * If we did distributed sparing, we'd monkey with that here.
-		         * But we don't, so we'll
-		         */
+			 * If we did distributed sparing, we'd monkey with
+			 * that here.
+			 * But we don't, so we'll.
+			 */
 			failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
 			failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
 			/*
-		         * Redirect other components, iff necessary. This looks
-		         * pretty suspicious to me, but it's what the raid5
-		         * DAG select does.
-		         */
+			 * Redirect other components, iff necessary. This looks
+			 * pretty suspicious to me, but it's what the raid5
+			 * DAG select does.
+			 */
 			if (asmap->parityInfo->next) {
 				if (failedPDA == asmap->parityInfo) {
 					failedPDA->next->row = failedPDA->row;
 					failedPDA->next->col = failedPDA->col;
 				} else {
-					if (failedPDA == asmap->parityInfo->next) {
-						asmap->parityInfo->row = failedPDA->row;
-						asmap->parityInfo->col = failedPDA->col;
+					if (failedPDA ==
+					    asmap->parityInfo->next) {
+						asmap->parityInfo->row =
+						    failedPDA->row;
+						asmap->parityInfo->col =
+						    failedPDA->col;
 					}
 				}
 			}
 			if (rf_dagDebug || rf_mapDebug) {
-				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,
+				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);
 			}
 			asmap->numDataFailed = asmap->numParityFailed = 0;
@@ -262,23 +266,21 @@ rf_RAID1DagSelect(
 	}
 	if (type == RF_IO_TYPE_READ) {
 		if (asmap->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateMirrorIdleReadDAG;
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateMirrorIdleReadDAG;
 		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG;
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateRaidOneDegradedReadDAG;
 	} else {
 		*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
 	}
 }
 
-int 
-rf_VerifyParityRAID1(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidAddr,
-    RF_PhysDiskAddr_t * parityPDA,
-    int correct_it,
-    RF_RaidAccessFlags_t flags)
+int
+rf_VerifyParityRAID1(RF_Raid_t *raidPtr, RF_RaidAddr_t raidAddr,
+    RF_PhysDiskAddr_t *parityPDA, int correct_it, RF_RaidAccessFlags_t flags)
 {
-	int     nbytes, bcount, stripeWidth, ret, i, j, nbad, *bbufs;
+	int nbytes, bcount, stripeWidth, ret, i, j, nbad, *bbufs;
 	RF_DagNode_t *blockNode, *unblockNode, *wrBlock;
 	RF_DagHeader_t *rd_dag_h, *wr_dag_h;
 	RF_AccessStripeMapHeader_t *asm_h;
@@ -289,7 +291,7 @@ rf_VerifyParityRAID1(
 	RF_AccessStripeMap_t *aasm;
 	RF_SectorCount_t nsector;
 	RF_RaidAddr_t startAddr;
-	char   *buf, *buf1, *buf2;
+	char *buf, *buf1, *buf2;
 	RF_PhysDiskAddr_t *pda;
 	RF_StripeNum_t psID;
 	RF_MCPair_t *mcpair;
@@ -319,14 +321,14 @@ rf_VerifyParityRAID1(
 	if (buf == NULL)
 		goto done;
 	if (rf_verifyParityDebug) {
-		printf("raid%d: RAID1 parity verify: buf=%lx bcount=%d (%lx - %lx)\n",
-		       raidPtr->raidid, (long) buf, bcount, (long) buf, 
-		       (long) buf + bcount);
+		printf("raid%d: RAID1 parity verify: buf=%lx bcount=%d"
+		    " (%lx - %lx).\n", raidPtr->raidid, (long) buf, bcount,
+		    (long) buf, (long) buf + bcount);
 	}
 	/*
-         * Generate a DAG which will read the entire stripe- then we can
-         * just compare data chunks versus "parity" chunks.
-         */
+	 * Generate a DAG that will read the entire stripe- then we can
+	 * just compare data chunks versus "parity" chunks.
+	 */
 
 	rd_dag_h = rf_MakeSimpleDAG(raidPtr, stripeWidth, nbytes, buf,
 	    rf_DiskReadFunc, rf_DiskReadUndoFunc, "Rod", allocList, flags,
@@ -337,19 +339,20 @@ rf_VerifyParityRAID1(
 	unblockNode = blockNode->succedents[0]->succedents[0];
 
 	/*
-         * Map the access to physical disk addresses (PDAs)- this will
-         * get us both a list of data addresses, and "parity" addresses
-         * (which are really mirror copies).
-         */
-	asm_h = rf_MapAccess(raidPtr, startAddr, layoutPtr->dataSectorsPerStripe,
-	    buf, RF_DONT_REMAP);
+	 * Map the access to physical disk addresses (PDAs)- this will
+	 * get us both a list of data addresses, and "parity" addresses
+	 * (which are really mirror copies).
+	 */
+	asm_h = rf_MapAccess(raidPtr, startAddr,
+	    layoutPtr->dataSectorsPerStripe, buf, RF_DONT_REMAP);
 	aasm = asm_h->stripeMap;
 
 	buf1 = buf;
 	/*
-         * Loop through the data blocks, setting up read nodes for each.
-         */
-	for (pda = aasm->physInfo, i = 0; i < layoutPtr->numDataCol; i++, pda = pda->next) {
+	 * Loop through the data blocks, setting up read nodes for each.
+	 */
+	for (pda = aasm->physInfo, i = 0; i < layoutPtr->numDataCol;
+	     i++, pda = pda->next) {
 		RF_ASSERT(pda);
 
 		rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
@@ -363,28 +366,31 @@ rf_VerifyParityRAID1(
 		blockNode->succedents[i]->params[0].p = pda;
 		blockNode->succedents[i]->params[1].p = buf1;
 		blockNode->succedents[i]->params[2].v = psID;
-		blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		blockNode->succedents[i]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		buf1 += nbytes;
 	}
 	RF_ASSERT(pda == NULL);
 	/*
-         * keep i, buf1 running
-         *
-         * Loop through parity blocks, setting up read nodes for each.
-         */
-	for (pda = aasm->parityInfo; i < layoutPtr->numDataCol + layoutPtr->numParityCol; i++, pda = pda->next) {
+	 * Keep i, buf1 running.
+	 *
+	 * Loop through parity blocks, setting up read nodes for each.
+	 */
+	for (pda = aasm->parityInfo; i < layoutPtr->numDataCol +
+	     layoutPtr->numParityCol; i++, pda = pda->next) {
 		RF_ASSERT(pda);
 		rf_RangeRestrictPDA(raidPtr, parityPDA, pda, 0, 1);
 		RF_ASSERT(pda->numSector != 0);
 		if (rf_TryToRedirectPDA(raidPtr, pda, 0)) {
-			/* cannot verify parity with dead disk */
+			/* Cannot verify parity with dead disk. */
 			goto done;
 		}
 		pda->bufPtr = buf1;
 		blockNode->succedents[i]->params[0].p = pda;
 		blockNode->succedents[i]->params[1].p = buf1;
 		blockNode->succedents[i]->params[2].v = psID;
-		blockNode->succedents[i]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+		blockNode->succedents[i]->params[3].v =
+		    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
 		buf1 += nbytes;
 	}
 	RF_ASSERT(pda == NULL);
@@ -393,8 +399,8 @@ rf_VerifyParityRAID1(
 	rd_dag_h->tracerec = &tracerec;
 
 	if (rf_verifyParityDebug > 1) {
-		printf("raid%d: RAID1 parity verify read dag:\n", 
-		       raidPtr->raidid);
+		printf("raid%d: RAID1 parity verify read dag:\n",
+		    raidPtr->raidid);
 		rf_PrintDAGList(rd_dag_h);
 	}
 	RF_LOCK_MUTEX(mcpair->mutex);
@@ -407,34 +413,35 @@ rf_VerifyParityRAID1(
 	RF_UNLOCK_MUTEX(mcpair->mutex);
 
 	if (rd_dag_h->status != rf_enable) {
-		RF_ERRORMSG("Unable to verify raid1 parity: can't read stripe\n");
+		RF_ERRORMSG("Unable to verify raid1 parity:"
+		            " can't read stripe.\n");
 		ret = RF_PARITY_COULD_NOT_VERIFY;
 		goto done;
 	}
 	/*
-         * buf1 is the beginning of the data blocks chunk
-         * buf2 is the beginning of the parity blocks chunk
-         */
+	 * buf1 is the beginning of the data blocks chunk.
+	 * buf2 is the beginning of the parity blocks chunk.
+	 */
 	buf1 = buf;
 	buf2 = buf + (nbytes * layoutPtr->numDataCol);
 	ret = RF_PARITY_OKAY;
 	/*
-         * bbufs is "bad bufs"- an array whose entries are the data
-         * column numbers where we had miscompares. (That is, column 0
-         * and column 1 of the array are mirror copies, and are considered
-         * "data column 0" for this purpose).
-         */
+	 * bbufs is "bad bufs"- an array whose entries are the data
+	 * column numbers where we had miscompares. (That is, column 0
+	 * and column 1 of the array are mirror copies, and are considered
+	 * "data column 0" for this purpose).
+	 */
 	RF_MallocAndAdd(bbufs, layoutPtr->numParityCol * sizeof(int), (int *),
 	    allocList);
 	nbad = 0;
 	/*
-         * Check data vs "parity" (mirror copy).
-         */
+	 * Check data vs "parity" (mirror copy).
+	 */
 	for (i = 0; i < layoutPtr->numDataCol; i++) {
 		if (rf_verifyParityDebug) {
-			printf("raid%d: RAID1 parity verify %d bytes: i=%d buf1=%lx buf2=%lx buf=%lx\n",
-			       raidPtr->raidid, nbytes, i, (long) buf1, 
-			       (long) buf2, (long) buf);
+			printf("raid%d: RAID1 parity verify %d bytes: i=%d"
+			    " buf1=%lx buf2=%lx buf=%lx.\n", raidPtr->raidid,
+			    nbytes, i, (long) buf1, (long) buf2, (long) buf);
 		}
 		ret = bcmp(buf1, buf2, nbytes);
 		if (ret) {
@@ -444,17 +451,22 @@ rf_VerifyParityRAID1(
 						break;
 				}
 				printf("psid=%ld j=%d\n", (long) psID, j);
-				printf("buf1 %02x %02x %02x %02x %02x\n", buf1[0] & 0xff,
-				    buf1[1] & 0xff, buf1[2] & 0xff, buf1[3] & 0xff, buf1[4] & 0xff);
-				printf("buf2 %02x %02x %02x %02x %02x\n", buf2[0] & 0xff,
-				    buf2[1] & 0xff, buf2[2] & 0xff, buf2[3] & 0xff, buf2[4] & 0xff);
+				printf("buf1 %02x %02x %02x %02x %02x\n",
+				    buf1[0] & 0xff, buf1[1] & 0xff,
+				    buf1[2] & 0xff, buf1[3] & 0xff,
+				    buf1[4] & 0xff);
+				printf("buf2 %02x %02x %02x %02x %02x\n",
+				    buf2[0] & 0xff, buf2[1] & 0xff,
+				    buf2[2] & 0xff, buf2[3] & 0xff,
+				    buf2[4] & 0xff);
 			}
 			if (rf_verifyParityDebug) {
-				printf("raid%d: RAID1: found bad parity, i=%d\n", raidPtr->raidid, i);
+				printf("raid%d: RAID1: found bad parity,"
+				    " i=%d.\n", raidPtr->raidid, i);
 			}
 			/*
-		         * Parity is bad. Keep track of which columns were bad.
-		         */
+			 * Parity is bad. Keep track of which columns were bad.
+			 */
 			if (bbufs)
 				bbufs[nbad] = i;
 			nbad++;
@@ -467,26 +479,27 @@ rf_VerifyParityRAID1(
 	if ((ret != RF_PARITY_OKAY) && correct_it) {
 		ret = RF_PARITY_COULD_NOT_CORRECT;
 		if (rf_verifyParityDebug) {
-			printf("raid%d: RAID1 parity verify: parity not correct\n", raidPtr->raidid);
+			printf("raid%d: RAID1 parity verify:"
+			    " parity not correct.\n", raidPtr->raidid);
 		}
 		if (bbufs == NULL)
 			goto done;
 		/*
-	         * Make a DAG with one write node for each bad unit. We'll simply
-	         * write the contents of the data unit onto the parity unit for
-	         * correction. (It's possible that the mirror copy was the correct
-	         * copy, and that we're spooging good data by writing bad over it,
-	         * but there's no way we can know that.
-	         */
+		 * Make a DAG with one write node for each bad unit. We'll
+		 * simply write the contents of the data unit onto the parity
+		 * unit for correction. (It's possible that the mirror copy
+		 * was the correct copy, and that we're spooging good data by
+		 * writing bad over it, but there's no way we can know that.
+		 */
 		wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, buf,
-		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", allocList, flags,
-		    RF_IO_NORMAL_PRIORITY);
+		    rf_DiskWriteFunc, rf_DiskWriteUndoFunc, "Wnp", allocList,
+		    flags, RF_IO_NORMAL_PRIORITY);
 		if (wr_dag_h == NULL)
 			goto done;
 		wrBlock = wr_dag_h->succedents[0];
 		/*
-	         * Fill in a write node for each bad compare.
-	         */
+		 * Fill in a write node for each bad compare.
+		 */
 		for (i = 0; i < nbad; i++) {
 			j = i + layoutPtr->numDataCol;
 			pda = blockNode->succedents[j]->params[0].p;
@@ -494,7 +507,9 @@ rf_VerifyParityRAID1(
 			wrBlock->succedents[i]->params[0].p = pda;
 			wrBlock->succedents[i]->params[1].p = pda->bufPtr;
 			wrBlock->succedents[i]->params[2].v = psID;
-			wrBlock->succedents[0]->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0, which_ru);
+			wrBlock->succedents[0]->params[3].v =
+			    RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 0, 0,
+			     which_ru);
 		}
 		bzero((char *) &tracerec, sizeof(tracerec));
 		wr_dag_h->tracerec = &tracerec;
@@ -504,24 +519,25 @@ rf_VerifyParityRAID1(
 		}
 		RF_LOCK_MUTEX(mcpair->mutex);
 		mcpair->flag = 0;
-		/* fire off the write DAG */
-		rf_DispatchDAG(wr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-		    (void *) mcpair);
+		/* Fire off the write DAG. */
+		rf_DispatchDAG(wr_dag_h, (void (*) (void *))
+		    rf_MCPairWakeupFunc, (void *) mcpair);
 		while (!mcpair->flag) {
 			RF_WAIT_COND(mcpair->cond, mcpair->mutex);
 		}
 		RF_UNLOCK_MUTEX(mcpair->mutex);
 		if (wr_dag_h->status != rf_enable) {
-			RF_ERRORMSG("Unable to correct RAID1 parity in VerifyParity\n");
+			RF_ERRORMSG("Unable to correct RAID1 parity in"
+			            " VerifyParity.\n");
 			goto done;
 		}
 		ret = RF_PARITY_CORRECTED;
 	}
 done:
 	/*
-         * All done. We might've gotten here without doing part of the function,
-         * so cleanup what we have to and return our running status.
-         */
+	 * All done. We might've gotten here without doing part of the function,
+	 * so cleanup what we have to and return our running status.
+	 */
 	if (asm_h)
 		rf_FreeAccessStripeMap(asm_h);
 	if (rd_dag_h)
@@ -532,24 +548,29 @@ done:
 		rf_FreeMCPair(mcpair);
 	rf_FreeAllocList(allocList);
 	if (rf_verifyParityDebug) {
-		printf("raid%d: RAID1 parity verify, returning %d\n", 
-		       raidPtr->raidid, ret);
+		printf("raid%d: RAID1 parity verify, returning %d.\n",
+		    raidPtr->raidid, ret);
 	}
 	return (ret);
 }
 
-int 
-rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
-	RF_ReconBuffer_t *rbuf;	/* the recon buffer to submit */
-	int     keep_it;	/* whether we can keep this buffer or we have
-				 * to return it */
-	int     use_committed;	/* whether to use a committed or an available
-				 * recon buffer */
+int
+rf_SubmitReconBufferRAID1(
+    RF_ReconBuffer_t	*rbuf,		/* The recon buffer to submit. */
+    int			 keep_it,	/*
+					 * Whether we can keep this buffer
+					 * or we have to return it ?
+					 */
+    int			 use_committed	/*
+					 * Whether to use a committed or
+					 * an available recon buffer ?
+					 */
+)
 {
 	RF_ReconParityStripeStatus_t *pssPtr;
 	RF_ReconCtrl_t *reconCtrlPtr;
 	RF_RaidLayout_t *layoutPtr;
-	int     retcode, created;
+	int retcode, created;
 	RF_CallbackDesc_t *cb, *p;
 	RF_ReconBuffer_t *t;
 	RF_Raid_t *raidPtr;
@@ -566,9 +587,9 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 	RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
 
 	if (rf_reconbufferDebug) {
-		printf("raid%d: RAID1 reconbuffer submission r%d c%d psid %ld ru%d (failed offset %ld)\n",
-		       raidPtr->raidid, rbuf->row, rbuf->col, 
-		       (long) rbuf->parityStripeID, rbuf->which_ru,
+		printf("raid%d: RAID1 reconbuffer submission r%d c%d psid %ld"
+		    " ru%d (failed offset %ld).\n", raidPtr->raidid, rbuf->row,
+		    rbuf->col, (long) rbuf->parityStripeID, rbuf->which_ru,
 		    (long) rbuf->failedDiskSectorOffset);
 	}
 	if (rf_reconDebug) {
@@ -576,8 +597,8 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 		    (long) rbuf->parityStripeID, (long) rbuf->buffer);
 		printf("RAID1 psid %ld   %02x %02x %02x %02x %02x\n",
 		    (long) rbuf->parityStripeID,
-		    rbuf->buffer[0], rbuf->buffer[1], rbuf->buffer[2], rbuf->buffer[3],
-		    rbuf->buffer[4]);
+		    rbuf->buffer[0], rbuf->buffer[1], rbuf->buffer[2],
+		    rbuf->buffer[3], rbuf->buffer[4]);
 	}
 	RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
 
@@ -585,25 +606,29 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 
 	pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
 	    rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
-	RF_ASSERT(pssPtr);	/* if it didn't exist, we wouldn't have gotten
-				 * an rbuf for it */
+	RF_ASSERT(pssPtr);	/*
+				 * If it didn't exist, we wouldn't have gotten
+				 * an rbuf for it.
+				 */
 
 	/*
-         * Since this is simple mirroring, the first submission for a stripe is also
-         * treated as the last.
-         */
+	 * Since this is simple mirroring, the first submission for a stripe
+	 * is also treated as the last.
+	 */
 
 	t = NULL;
 	if (keep_it) {
 		if (rf_reconbufferDebug) {
-			printf("raid%d: RAID1 rbuf submission: keeping rbuf\n", 
-			       raidPtr->raidid);
+			printf("raid%d: RAID1 rbuf submission: keeping rbuf.\n",
+			    raidPtr->raidid);
 		}
 		t = rbuf;
 	} else {
 		if (use_committed) {
 			if (rf_reconbufferDebug) {
-				printf("raid%d: RAID1 rbuf submission: using committed rbuf\n", raidPtr->raidid);
+				printf("raid%d: RAID1 rbuf submission:"
+				    " using committed rbuf.\n",
+				    raidPtr->raidid);
 			}
 			t = reconCtrlPtr->committedRbufs;
 			RF_ASSERT(t);
@@ -612,7 +637,9 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 		} else
 			if (reconCtrlPtr->floatingRbufs) {
 				if (rf_reconbufferDebug) {
-					printf("raid%d: RAID1 rbuf submission: using floating rbuf\n", raidPtr->raidid);
+					printf("raid%d: RAID1 rbuf submission:"
+					    " using floating rbuf.\n",
+					    raidPtr->raidid);
 				}
 				t = reconCtrlPtr->floatingRbufs;
 				reconCtrlPtr->floatingRbufs = t->next;
@@ -621,14 +648,15 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 	}
 	if (t == NULL) {
 		if (rf_reconbufferDebug) {
-			printf("raid%d: RAID1 rbuf submission: waiting for rbuf\n", raidPtr->raidid);
+			printf("raid%d: RAID1 rbuf submission:"
+			    " waiting for rbuf.\n", raidPtr->raidid);
 		}
 		RF_ASSERT((keep_it == 0) && (use_committed == 0));
 		raidPtr->procsInBufWait++;
 		if ((raidPtr->procsInBufWait == (raidPtr->numCol - 1))
 		    && (raidPtr->numFullReconBuffers == 0)) {
 			/* ruh-ro */
-			RF_ERRORMSG("Buffer wait deadlock\n");
+			RF_ERRORMSG("Buffer wait deadlock.\n");
 			rf_PrintPSStatusTable(raidPtr, rbuf->row);
 			RF_PANIC();
 		}
@@ -640,11 +668,12 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 		cb->callbackArg2.v = rbuf->which_ru;
 		cb->next = NULL;
 		if (reconCtrlPtr->bufferWaitList == NULL) {
-			/* we are the wait list- lucky us */
+			/* We are the wait list- lucky us. */
 			reconCtrlPtr->bufferWaitList = cb;
 		} else {
-			/* append to wait list */
-			for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next);
+			/* Append to wait list. */
+			for (p = reconCtrlPtr->bufferWaitList; p->next;
+			     p = p->next);
 			p->next = cb;
 		}
 		retcode = 1;
@@ -659,30 +688,30 @@ rf_SubmitReconBufferRAID1(rbuf, keep_it, use_committed)
 		t->spRow = rbuf->spRow;
 		t->spCol = rbuf->spCol;
 		t->spOffset = rbuf->spOffset;
-		/* Swap buffers. DANCE! */
+		/* Swap buffers. DANCE ! */
 		ta = t->buffer;
 		t->buffer = rbuf->buffer;
 		rbuf->buffer = ta;
 	}
 	/*
-         * Use the rbuf we've been given as the target.
-         */
+	 * Use the rbuf we've been given as the target.
+	 */
 	RF_ASSERT(pssPtr->rbuf == NULL);
 	pssPtr->rbuf = t;
 
 	t->count = 1;
 	/*
-         * Below, we use 1 for numDataCol (which is equal to the count in the
-         * previous line), so we'll always be done.
-         */
+	 * Below, we use 1 for numDataCol (which is equal to the count in the
+	 * previous line), so we'll always be done.
+	 */
 	rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, 1);
 
 out:
 	RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
 	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
 	if (rf_reconbufferDebug) {
-		printf("raid%d: RAID1 rbuf submission: returning %d\n", 
-		       raidPtr->raidid, retcode);
+		printf("raid%d: RAID1 rbuf submission: returning %d.\n",
+		    raidPtr->raidid, retcode);
 	}
 	return (retcode);
 }
diff --git a/sys/dev/raidframe/rf_raid1.h b/sys/dev/raidframe/rf_raid1.h
index ef2201cacfa..fefcff4f35c 100644
--- a/sys/dev/raidframe/rf_raid1.h
+++ b/sys/dev/raidframe/rf_raid1.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid1.h,v 1.2 1999/02/16 00:03:16 niklas Exp $	*/
+/*	$OpenBSD: rf_raid1.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid1.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,37 +28,26 @@
  * rights to redistribute these changes.
  */
 
-/* header file for RAID Level 1 */
+/* Header file for RAID Level 1. */
 
-#ifndef _RF__RF_RAID1_H_
-#define _RF__RF_RAID1_H_
+#ifndef	_RF__RF_RAID1_H_
+#define	_RF__RF_RAID1_H_
 
 #include "rf_types.h"
 
-int 
-rf_ConfigureRAID1(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-void 
-rf_MapSectorRAID1(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityRAID1(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeRAID1(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDRAID1(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_RAID1DagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
-int 
-rf_VerifyParityRAID1(RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-    RF_PhysDiskAddr_t * parityPDA, int correct_it, RF_RaidAccessFlags_t flags);
-int 
-rf_SubmitReconBufferRAID1(RF_ReconBuffer_t * rbuf, int keep_int,
-    int use_committed);
+int  rf_ConfigureRAID1(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+void rf_MapSectorRAID1(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityRAID1(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeRAID1(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDRAID1(RF_RaidLayout_t *,
+	RF_StripeNum_t, RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_RAID1DagSelect(RF_Raid_t *, RF_IoType_t,
+	RF_AccessStripeMap_t *, RF_VoidFuncPtr *);
+int  rf_VerifyParityRAID1(RF_Raid_t *, RF_RaidAddr_t,
+	RF_PhysDiskAddr_t *, int, RF_RaidAccessFlags_t);
+int  rf_SubmitReconBufferRAID1(RF_ReconBuffer_t *, int, int);
 
-#endif				/* !_RF__RF_RAID1_H_ */
+#endif	/* !_RF__RF_RAID1_H_ */
diff --git a/sys/dev/raidframe/rf_raid4.c b/sys/dev/raidframe/rf_raid4.c
index c0c4af22e4c..3d0ba575c7e 100644
--- a/sys/dev/raidframe/rf_raid4.c
+++ b/sys/dev/raidframe/rf_raid4.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid4.c,v 1.3 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_raid4.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid4.c,v 1.4 2000/01/07 03:41:02 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/***************************************
+/*****************************************
  *
- * rf_raid4.c -- implements RAID Level 4
+ * rf_raid4.c -- Implements RAID Level 4.
  *
- ***************************************/
+ *****************************************/
 
 #include "rf_raid.h"
 #include "rf_dag.h"
@@ -45,30 +46,31 @@
 #include "rf_general.h"
 
 typedef struct RF_Raid4ConfigInfo_s {
-	RF_RowCol_t *stripeIdentifier;	/* filled in at config time & used by
-					 * IdentifyStripe */
-}       RF_Raid4ConfigInfo_t;
-
+	RF_RowCol_t *stripeIdentifier;	/*
+					 * Filled in at config time & used by
+					 * IdentifyStripe.
+					 */
+} RF_Raid4ConfigInfo_t;
 
 
-int 
-rf_ConfigureRAID4(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureRAID4(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_Raid4ConfigInfo_t *info;
-	int     i;
+	int i;
 
-	/* create a RAID level 4 configuration structure ... */
-	RF_MallocAndAdd(info, sizeof(RF_Raid4ConfigInfo_t), (RF_Raid4ConfigInfo_t *), raidPtr->cleanupList);
+	/* Create a RAID level 4 configuration structure... */
+	RF_MallocAndAdd(info, sizeof(RF_Raid4ConfigInfo_t),
+	    (RF_Raid4ConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
 	/* ... and fill it in. */
-	RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol * sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
+	RF_MallocAndAdd(info->stripeIdentifier, raidPtr->numCol *
+	    sizeof(RF_RowCol_t), (RF_RowCol_t *), raidPtr->cleanupList);
 	if (info->stripeIdentifier == NULL)
 		return (ENOMEM);
 	for (i = 0; i < raidPtr->numCol; i++)
@@ -76,68 +78,60 @@ rf_ConfigureRAID4(
 
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	/* fill in the remaining layout parameters */
+	/* Fill in the remaining layout parameters. */
 	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = raidPtr->numCol - 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
+	    layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numParityCol = 1;
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
+	    layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
 
 	return (0);
 }
 
-int 
-rf_GetDefaultNumFloatingReconBuffersRAID4(RF_Raid_t * raidPtr)
+int
+rf_GetDefaultNumFloatingReconBuffersRAID4(RF_Raid_t *raidPtr)
 {
 	return (20);
 }
 
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitRAID4(RF_Raid_t * raidPtr)
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimitRAID4(RF_Raid_t *raidPtr)
 {
 	return (20);
 }
 
-void 
-rf_MapSectorRAID4(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapSectorRAID4(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	*row = 0;
 	*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);
 }
 
-void 
-rf_MapParityRAID4(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityRAID4(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 
 	*row = 0;
 	*col = raidPtr->Layout.numDataCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
-rf_IdentifyStripeRAID4(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeRAID4(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
 	RF_Raid4ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
 
@@ -145,12 +139,9 @@ rf_IdentifyStripeRAID4(
 	*diskids = info->stripeIdentifier;
 }
 
-void 
-rf_MapSIDToPSIDRAID4(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDRAID4(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
+    RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
diff --git a/sys/dev/raidframe/rf_raid4.h b/sys/dev/raidframe/rf_raid4.h
index 9d84a594961..36149060270 100644
--- a/sys/dev/raidframe/rf_raid4.h
+++ b/sys/dev/raidframe/rf_raid4.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid4.h,v 1.2 1999/02/16 00:03:17 niklas Exp $	*/
+/*	$OpenBSD: rf_raid4.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid4.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,31 +28,23 @@
  * rights to redistribute these changes.
  */
 
-/* rf_raid4.h header file for RAID Level 4 */
+/* rf_raid4.h -- Header file for RAID Level 4. */
 
-#ifndef _RF__RF_RAID4_H_
-#define _RF__RF_RAID4_H_
+#ifndef	_RF__RF_RAID4_H_
+#define	_RF__RF_RAID4_H_
 
-int 
-rf_ConfigureRAID4(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int     rf_GetDefaultNumFloatingReconBuffersRAID4(RF_Raid_t * raidPtr);
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitRAID4(RF_Raid_t * raidPtr);
-void 
-rf_MapSectorRAID4(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityRAID4(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeRAID4(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDRAID4(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_RAID4DagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
+int  rf_ConfigureRAID4(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int  rf_GetDefaultNumFloatingReconBuffersRAID4(RF_Raid_t *);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitRAID4(RF_Raid_t *);
+void rf_MapSectorRAID4(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityRAID4(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeRAID4(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDRAID4(RF_RaidLayout_t *,
+	RF_StripeNum_t, RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_RAID4DagSelect(RF_Raid_t *, RF_IoType_t, RF_AccessStripeMap_t *,
+	RF_VoidFuncPtr *);
 
-#endif				/* !_RF__RF_RAID4_H_ */
+#endif	/* !_RF__RF_RAID4_H_ */
diff --git a/sys/dev/raidframe/rf_raid5.c b/sys/dev/raidframe/rf_raid5.c
index 48f7fda379d..c2276333b1e 100644
--- a/sys/dev/raidframe/rf_raid5.c
+++ b/sys/dev/raidframe/rf_raid5.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid5.c,v 1.3 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_raid5.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid5.c,v 1.4 2000/01/08 22:57:30 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,9 +28,9 @@
  * rights to redistribute these changes.
  */
 
-/******************************************************************************
+/*****************************************************************************
  *
- * rf_raid5.c -- implements RAID Level 5
+ * rf_raid5.c -- Implements RAID Level 5.
  *
  *****************************************************************************/
 
@@ -47,274 +48,339 @@
 #include "rf_utils.h"
 
 typedef struct RF_Raid5ConfigInfo_s {
-	RF_RowCol_t **stripeIdentifier;	/* filled in at config time and used
-					 * by IdentifyStripe */
-}       RF_Raid5ConfigInfo_t;
-
-int 
-rf_ConfigureRAID5(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+	RF_RowCol_t **stripeIdentifier;	/*
+					 * Filled in at config time and used
+					 * by IdentifyStripe.
+					 */
+} RF_Raid5ConfigInfo_t;
+
+
+int
+rf_ConfigureRAID5(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_Raid5ConfigInfo_t *info;
 	RF_RowCol_t i, j, startdisk;
 
-	/* create a RAID level 5 configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_Raid5ConfigInfo_t), (RF_Raid5ConfigInfo_t *), raidPtr->cleanupList);
+	/* Create a RAID level 5 configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_Raid5ConfigInfo_t),
+	    (RF_Raid5ConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
 
 	RF_ASSERT(raidPtr->numRow == 1);
 
-	/* 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);
+	/*
+	 * 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);
 	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;
+			info->stripeIdentifier[i][j] = (startdisk + j) %
+			    raidPtr->numCol;
 		}
 		if ((--startdisk) < 0)
 			startdisk = raidPtr->numCol - 1;
 	}
 
-	/* fill in the remaining layout parameters */
+	/* Fill in the remaining layout parameters. */
 	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = raidPtr->numCol - 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
+	    layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numParityCol = 1;
 	layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
 
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk *
+	    layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
 
 	return (0);
 }
 
-int 
-rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t * raidPtr)
+int
+rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t *raidPtr)
 {
 	return (20);
 }
 
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t * raidPtr)
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t *raidPtr)
 {
 	return (10);
 }
+
 #if !defined(__NetBSD__) && !defined(__OpenBSD__) && !defined(_KERNEL)
-/* not currently used */
-int 
-rf_ShutdownRAID5(RF_Raid_t * raidPtr)
+/* Not currently used. */
+int
+rf_ShutdownRAID5(RF_Raid_t *raidPtr)
 {
 	return (0);
 }
 #endif
 
-void 
-rf_MapSectorRAID5(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapSectorRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 	*row = 0;
 	*col = (SUID % raidPtr->numCol);
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
-rf_MapParityRAID5(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 
 	*row = 0;
-	*col = raidPtr->Layout.numDataCol - (SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*col = raidPtr->Layout.numDataCol -
+	    (SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
-rf_IdentifyStripeRAID5(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeRAID5(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
-	RF_Raid5ConfigInfo_t *info = (RF_Raid5ConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_StripeNum_t stripeID =
+	    rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
+	RF_Raid5ConfigInfo_t *info =
+	    (RF_Raid5ConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 
 	*outRow = 0;
 	*diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
 }
 
-void 
-rf_MapSIDToPSIDRAID5(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDRAID5(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
+    RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
 }
-/* select an algorithm for performing an access.  Returns two pointers,
+
+
+/*
+ * Select an algorithm for performing an access.  Returns two pointers,
  * one to a function that will return information about the DAG, and
  * another to a function that will create the dag.
  */
-void 
-rf_RaidFiveDagSelect(
-    RF_Raid_t * raidPtr,
-    RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap,
-    RF_VoidFuncPtr * createFunc)
+void
+rf_RaidFiveDagSelect(RF_Raid_t *raidPtr, RF_IoType_t type,
+    RF_AccessStripeMap_t *asmap, RF_VoidFuncPtr *createFunc)
 {
 	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
 	RF_PhysDiskAddr_t *failedPDA = NULL;
 	RF_RowCol_t frow, fcol;
 	RF_RowStatus_t rstat;
-	int     prior_recon;
+	int prior_recon;
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 
 	if (asmap->numDataFailed + asmap->numParityFailed > 1) {
-		RF_ERRORMSG("Multiple disks failed in a single group!  Aborting I/O operation.\n");
+		RF_ERRORMSG("Multiple disks failed in a single group !"
+		            "  Aborting I/O operation.\n");
 		 /* *infoFunc = */ *createFunc = NULL;
 		return;
 	} else
 		if (asmap->numDataFailed + asmap->numParityFailed == 1) {
 
-			/* if under recon & already reconstructed, redirect
+			/*
+			 * If under recon & already reconstructed, redirect
 			 * the access to the spare drive and eliminate the
-			 * failure indication */
+			 * failure indication.
+			 */
 			failedPDA = asmap->failedPDAs[0];
 			frow = failedPDA->row;
 			fcol = failedPDA->col;
 			rstat = raidPtr->status[failedPDA->row];
 			prior_recon = (rstat == rf_rs_reconfigured) || (
 			    (rstat == rf_rs_reconstructing) ?
-			    rf_CheckRUReconstructed(raidPtr->reconControl[frow]->reconMap, failedPDA->startSector) : 0
-			    );
+			    rf_CheckRUReconstructed(raidPtr
+			     ->reconControl[frow]->reconMap,
+			     failedPDA->startSector) : 0);
 			if (prior_recon) {
-				RF_RowCol_t or = failedPDA->row, oc = failedPDA->col;
+				RF_RowCol_t or = failedPDA->row;
+				RF_RowCol_t 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 == asmap->parityInfo) {
 
-						/* parity has failed */
-						(layoutPtr->map->MapParity) (raidPtr, failedPDA->raidAddress, &failedPDA->row,
-						    &failedPDA->col, &failedPDA->startSector, RF_REMAP);
-
-						if (asmap->parityInfo->next) {	/* redir 2nd component,
-										 * if any */
-							RF_PhysDiskAddr_t *p = asmap->parityInfo->next;
-							RF_SectorNum_t SUoffs = p->startSector % layoutPtr->sectorsPerStripeUnit;
+						/* Parity has failed. */
+						(layoutPtr->map->MapParity)
+						    (raidPtr,
+						     failedPDA->raidAddress,
+						     &failedPDA->row,
+						     &failedPDA->col,
+						     &failedPDA->startSector,
+						     RF_REMAP);
+
+						if (asmap->parityInfo->next) {
+							/*
+							 * Redir 2nd component,
+							 * if any.
+							 */
+							RF_PhysDiskAddr_t *p =
+							    asmap
+							     ->parityInfo->next;
+							RF_SectorNum_t SUoffs =
+							    p->startSector %
+						layoutPtr->sectorsPerStripeUnit;
 							p->row = failedPDA->row;
 							p->col = failedPDA->col;
-							p->startSector = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, failedPDA->startSector) +
-							    SUoffs;	/* cheating:
-									 * startSector is not
-									 * really a RAID address */
+							/*
+							 * Cheating:
+							 * startSector is not
+							 * really a RAID
+							 * address.
+							 */
+							p->startSector =
+					rf_RaidAddressOfPrevStripeUnitBoundary(
+					    layoutPtr, failedPDA->startSector) +
+							    SUoffs;
 						}
 					} else
-						if (asmap->parityInfo->next && failedPDA == asmap->parityInfo->next) {
-							RF_ASSERT(0);	/* should not ever
-									 * happen */
+						if (asmap->parityInfo->next &&
+						    failedPDA ==
+						    asmap->parityInfo->next) {
+							/*
+							 * Should never happen.
+							 */
+							RF_ASSERT(0);
 						} else {
-
-							/* data has failed */
-							(layoutPtr->map->MapSector) (raidPtr, failedPDA->raidAddress, &failedPDA->row,
-							    &failedPDA->col, &failedPDA->startSector, RF_REMAP);
-
+							/* Data has failed. */
+							(layoutPtr->map
+							 ->MapSector) (raidPtr,
+							 failedPDA->raidAddress,
+							    &failedPDA->row,
+							    &failedPDA->col,
+							&failedPDA->startSector,
+							    RF_REMAP);
 						}
 
-				} 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;
+					failedPDA->row =
+					    raidPtr->Disks[frow][fcol].spareRow;
+					failedPDA->col =
+					    raidPtr->Disks[frow][fcol].spareCol;
 
-					/* the parity may have two distinct
+					/*
+					 * The parity may have two distinct
 					 * components, both of which may need
-					 * to be redirected */
+					 * to be redirected.
+					 */
 					if (asmap->parityInfo->next) {
-						if (failedPDA == asmap->parityInfo) {
-							failedPDA->next->row = failedPDA->row;
-							failedPDA->next->col = failedPDA->col;
-						} else
-							if (failedPDA == asmap->parityInfo->next) {	/* paranoid:  should
-													 * never occur */
-								asmap->parityInfo->row = failedPDA->row;
-								asmap->parityInfo->col = failedPDA->col;
+						if (failedPDA ==
+						    asmap->parityInfo) {
+							failedPDA->next->row =
+							    failedPDA->row;
+							failedPDA->next->col =
+							    failedPDA->col;
+						} else {
+							if (failedPDA ==
+							    asmap->parityInfo
+							     ->next) {
+								/*
+								 * Paranoid:
+								 * Should never
+								 * occur.
+								 */
+								asmap
+								 ->parityInfo
+								 ->row =
+								 failedPDA->row;
+								asmap
+								 ->parityInfo
+								 ->col =
+								 failedPDA->col;
 							}
+						}
 					}
 				}
 
 				RF_ASSERT(failedPDA->col != -1);
 
 				if (rf_dagDebug || rf_mapDebug) {
-					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);
+					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);
 				}
-				asmap->numDataFailed = asmap->numParityFailed = 0;
+				asmap->numDataFailed = asmap->numParityFailed
+				                     = 0;
 			}
 		}
-	/* all dags begin/end with block/unblock node therefore, hdrSucc &
-	 * termAnt counts should always be 1 also, these counts should not be
-	 * visible outside dag creation routines - manipulating the counts
-	 * here should be removed */
+	/*
+	 * All DAGs begin/end with block/unblock node. Therefore, hdrSucc &
+	 * termAnt counts should always be 1. Also, these counts should not be
+	 * visible outside DAG creation routines - manipulating the counts
+	 * here should be removed.
+	 */
 	if (type == RF_IO_TYPE_READ) {
 		if (asmap->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateFaultFreeReadDAG;
 		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
+			*createFunc = (RF_VoidFuncPtr)
+			    rf_CreateRaidFiveDegradedReadDAG;
 	} else {
-
-
-		/* if mirroring, always use large writes.  If the access
+		/*
+		 * If mirroring, always use large writes. If the access
 		 * requires two distinct parity updates, always do a small
-		 * write.  If the stripe contains a failure but the access
+		 * write. If the stripe contains a failure but the access
 		 * does not, do a small write. The first conditional
 		 * (numStripeUnitsAccessed <= numDataCol/2) uses a
 		 * less-than-or-equal rather than just a less-than because
 		 * when G is 3 or 4, numDataCol/2 is 1, and I want
-		 * single-stripe-unit updates to use just one disk. */
+		 * single-stripe-unit updates to use just one disk.
+		 */
 		if ((asmap->numDataFailed + asmap->numParityFailed) == 0) {
 			if (rf_suppressLocksAndLargeWrites ||
-			    (((asmap->numStripeUnitsAccessed <= (layoutPtr->numDataCol / 2)) && (layoutPtr->numDataCol != 1)) ||
-				(asmap->parityInfo->next != NULL) || rf_CheckStripeForFailures(raidPtr, asmap))) {
-				*createFunc = (RF_VoidFuncPtr) rf_CreateSmallWriteDAG;
+			    (((asmap->numStripeUnitsAccessed <=
+			       (layoutPtr->numDataCol / 2)) &&
+			      (layoutPtr->numDataCol != 1)) ||
+			     (asmap->parityInfo->next != NULL) ||
+			     rf_CheckStripeForFailures(raidPtr, asmap))) {
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_CreateSmallWriteDAG;
 			} else
-				*createFunc = (RF_VoidFuncPtr) rf_CreateLargeWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_CreateLargeWriteDAG;
 		} else {
 			if (asmap->numParityFailed == 1)
-				*createFunc = (RF_VoidFuncPtr) rf_CreateNonRedundantWriteDAG;
+				*createFunc = (RF_VoidFuncPtr)
+				    rf_CreateNonRedundantWriteDAG;
 			else
-				if (asmap->numStripeUnitsAccessed != 1 && failedPDA->numSector != layoutPtr->sectorsPerStripeUnit)
+				if (asmap->numStripeUnitsAccessed != 1 &&
+				    failedPDA->numSector !=
+				    layoutPtr->sectorsPerStripeUnit)
 					*createFunc = NULL;
 				else
-					*createFunc = (RF_VoidFuncPtr) rf_CreateDegradedWriteDAG;
+					*createFunc = (RF_VoidFuncPtr)
+					    rf_CreateDegradedWriteDAG;
 		}
 	}
 }
diff --git a/sys/dev/raidframe/rf_raid5.h b/sys/dev/raidframe/rf_raid5.h
index 06eecda486e..b961cb05522 100644
--- a/sys/dev/raidframe/rf_raid5.h
+++ b/sys/dev/raidframe/rf_raid5.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid5.h,v 1.2 1999/02/16 00:03:17 niklas Exp $	*/
+/*	$OpenBSD: rf_raid5.h,v 1.3 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid5.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,31 +28,23 @@
  * rights to redistribute these changes.
  */
 
-/* rf_raid5.h - header file for RAID Level 5 */
+/* rf_raid5.h - Header file for RAID Level 5. */
 
 #ifndef _RF__RF_RAID5_H_
 #define _RF__RF_RAID5_H_
 
-int 
-rf_ConfigureRAID5(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int     rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t * raidPtr);
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t * raidPtr);
-void 
-rf_MapSectorRAID5(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityRAID5(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeRAID5(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDRAID5(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
-void 
-rf_RaidFiveDagSelect(RF_Raid_t * raidPtr, RF_IoType_t type,
-    RF_AccessStripeMap_t * asmap, RF_VoidFuncPtr * createFunc);
+int  rf_ConfigureRAID5(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int  rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t *);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t *);
+void rf_MapSectorRAID5(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityRAID5(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeRAID5(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDRAID5(RF_RaidLayout_t *,
+	RF_StripeNum_t, RF_StripeNum_t *, RF_ReconUnitNum_t *);
+void rf_RaidFiveDagSelect(RF_Raid_t *, RF_IoType_t, RF_AccessStripeMap_t *,
+	RF_VoidFuncPtr *);
 
-#endif				/* !_RF__RF_RAID5_H_ */
+#endif	/* !_RF__RF_RAID5_H_ */
diff --git a/sys/dev/raidframe/rf_raid5_rotatedspare.c b/sys/dev/raidframe/rf_raid5_rotatedspare.c
index ad7defb05ca..23725b2c4a9 100644
--- a/sys/dev/raidframe/rf_raid5_rotatedspare.c
+++ b/sys/dev/raidframe/rf_raid5_rotatedspare.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid5_rotatedspare.c,v 1.3 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_raid5_rotatedspare.c,v 1.4 2002/12/16 07:01:04 tdeval Exp $	*/
 /*	$NetBSD: rf_raid5_rotatedspare.c,v 1.4 2000/01/07 03:41:03 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/**************************************************************************
+/*****************************************************************************
  *
- * rf_raid5_rotated_spare.c -- implements RAID Level 5 with rotated sparing
+ * rf_raid5_rotated_spare.c -- Implements RAID Level 5 with rotated sparing.
  *
- **************************************************************************/
+ *****************************************************************************/
 
 #include "rf_raid.h"
 #include "rf_raid5.h"
@@ -43,22 +44,23 @@
 #include "rf_raid5_rotatedspare.h"
 
 typedef struct RF_Raid5RSConfigInfo_s {
-	RF_RowCol_t **stripeIdentifier;	/* filled in at config time & used by
-					 * IdentifyStripe */
-}       RF_Raid5RSConfigInfo_t;
-
-int 
-rf_ConfigureRAID5_RS(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+	RF_RowCol_t **stripeIdentifier;	/*
+					 * Filled in at config time & used by
+					 * IdentifyStripe.
+					 */
+} RF_Raid5RSConfigInfo_t;
+
+int
+rf_ConfigureRAID5_RS(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_Raid5RSConfigInfo_t *info;
 	RF_RowCol_t i, j, startdisk;
 
-	/* create a RAID level 5 configuration structure */
-	RF_MallocAndAdd(info, sizeof(RF_Raid5RSConfigInfo_t), (RF_Raid5RSConfigInfo_t *), raidPtr->cleanupList);
+	/* Create a RAID level 5 configuration structure. */
+	RF_MallocAndAdd(info, sizeof(RF_Raid5RSConfigInfo_t),
+	    (RF_Raid5RSConfigInfo_t *), raidPtr->cleanupList);
 	if (info == NULL)
 		return (ENOMEM);
 	layoutPtr->layoutSpecificInfo = (void *) info;
@@ -66,104 +68,104 @@ rf_ConfigureRAID5_RS(
 	RF_ASSERT(raidPtr->numRow == 1);
 	RF_ASSERT(raidPtr->numCol >= 3);
 
-	/* 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);
+	/*
+	 * 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);
 	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;
+			info->stripeIdentifier[i][j] = (startdisk + j) %
+			    raidPtr->numCol;
 		}
 		if ((--startdisk) < 0)
 			startdisk = raidPtr->numCol - 1;
 	}
 
-	/* fill in the remaining layout parameters */
+	/* Fill in the remaining layout parameters. */
 	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
+	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit <<
+	    raidPtr->logBytesPerSector;
 	layoutPtr->numDataCol = raidPtr->numCol - 2;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
+	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol *
+	    layoutPtr->sectorsPerStripeUnit;
 	layoutPtr->numParityCol = 1;
 	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;
 
 	return (0);
 }
 
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsRAID5_RS(raidPtr)
-	RF_Raid_t *raidPtr;
+RF_ReconUnitCount_t
+rf_GetNumSpareRUsRAID5_RS(RF_Raid_t *raidPtr)
 {
 	return (raidPtr->Layout.stripeUnitsPerDisk / raidPtr->numCol);
 }
 
-void 
-rf_MapSectorRAID5_RS(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapSectorRAID5_RS(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 
 	*row = 0;
 	if (remap) {
-		*col = raidPtr->numCol - 1 - (1 + SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
-		*col = (*col + 1) % raidPtr->numCol;	/* spare unit is rotated
+		*col = raidPtr->numCol - 1 -
+		    (1 + SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
+		*col = (*col + 1) % raidPtr->numCol;	/*
+							 * Spare unit is rotated
 							 * with parity; line
-							 * above maps to parity */
+							 * above maps to parity.
+							 */
 	} else {
-		*col = (SUID + (SUID / raidPtr->Layout.numDataCol)) % raidPtr->numCol;
+		*col = (SUID + (SUID / raidPtr->Layout.numDataCol)) %
+		    raidPtr->numCol;
 	}
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 }
 
-void 
-rf_MapParityRAID5_RS(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row,
-    RF_RowCol_t * col,
-    RF_SectorNum_t * diskSector,
-    int remap)
+void
+rf_MapParityRAID5_RS(RF_Raid_t *raidPtr, RF_RaidAddr_t raidSector,
+    RF_RowCol_t *row, RF_RowCol_t *col, RF_SectorNum_t *diskSector, int remap)
 {
 	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
 
 	*row = 0;
-	*col = raidPtr->numCol - 1 - (1 + SUID / raidPtr->Layout.numDataCol) % raidPtr->numCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * raidPtr->Layout.sectorsPerStripeUnit +
+	*col = raidPtr->numCol - 1 - (1 + SUID / raidPtr->Layout.numDataCol) %
+	    raidPtr->numCol;
+	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) *
+	    raidPtr->Layout.sectorsPerStripeUnit +
 	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
 	if (remap)
 		*col = (*col + 1) % raidPtr->numCol;
 }
 
-void 
-rf_IdentifyStripeRAID5_RS(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
+void
+rf_IdentifyStripeRAID5_RS(RF_Raid_t *raidPtr, RF_RaidAddr_t addr,
+    RF_RowCol_t **diskids, RF_RowCol_t *outRow)
 {
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
-	RF_Raid5RSConfigInfo_t *info = (RF_Raid5RSConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
+	RF_StripeNum_t stripeID =
+	    rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
+	RF_Raid5RSConfigInfo_t *info =
+	    (RF_Raid5RSConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
 	*outRow = 0;
 	*diskids = info->stripeIdentifier[stripeID % raidPtr->numCol];
 
 }
 
-void 
-rf_MapSIDToPSIDRAID5_RS(
-    RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID,
-    RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru)
+void
+rf_MapSIDToPSIDRAID5_RS(RF_RaidLayout_t *layoutPtr, RF_StripeNum_t stripeID,
+    RF_StripeNum_t *psID, RF_ReconUnitNum_t *which_ru)
 {
 	*which_ru = 0;
 	*psID = stripeID;
diff --git a/sys/dev/raidframe/rf_raid5_rotatedspare.h b/sys/dev/raidframe/rf_raid5_rotatedspare.h
index d3d13cb57c4..8b98c222d14 100644
--- a/sys/dev/raidframe/rf_raid5_rotatedspare.h
+++ b/sys/dev/raidframe/rf_raid5_rotatedspare.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raid5_rotatedspare.h,v 1.2 1999/02/16 00:03:18 niklas Exp $	*/
+/*	$OpenBSD: rf_raid5_rotatedspare.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_raid5_rotatedspare.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,27 +28,24 @@
  * rights to redistribute these changes.
  */
 
-/* rf_raid5_rotatedspare.h - header file for RAID Level 5 with rotated sparing */
+/*
+ * rf_raid5_rotatedspare.h
+ *
+ * Header file for RAID Level 5 with rotated sparing.
+ */
 
-#ifndef _RF__RF_RAID5_ROTATEDSPARE_H_
-#define _RF__RF_RAID5_ROTATEDSPARE_H_
+#ifndef	_RF__RF_RAID5_ROTATEDSPARE_H_
+#define	_RF__RF_RAID5_ROTATEDSPARE_H_
 
-int 
-rf_ConfigureRAID5_RS(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-RF_ReconUnitCount_t rf_GetNumSpareRUsRAID5_RS(RF_Raid_t * raidPtr);
-void 
-rf_MapSectorRAID5_RS(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_MapParityRAID5_RS(RF_Raid_t * raidPtr, RF_RaidAddr_t raidSector,
-    RF_RowCol_t * row, RF_RowCol_t * col, RF_SectorNum_t * diskSector, int remap);
-void 
-rf_IdentifyStripeRAID5_RS(RF_Raid_t * raidPtr, RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids, RF_RowCol_t * outRow);
-void 
-rf_MapSIDToPSIDRAID5_RS(RF_RaidLayout_t * layoutPtr,
-    RF_StripeNum_t stripeID, RF_StripeNum_t * psID,
-    RF_ReconUnitNum_t * which_ru);
+int  rf_ConfigureRAID5_RS(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+RF_ReconUnitCount_t rf_GetNumSpareRUsRAID5_RS(RF_Raid_t *);
+void rf_MapSectorRAID5_RS(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_MapParityRAID5_RS(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *, int);
+void rf_IdentifyStripeRAID5_RS(RF_Raid_t *, RF_RaidAddr_t,
+	RF_RowCol_t **, RF_RowCol_t *);
+void rf_MapSIDToPSIDRAID5_RS(RF_RaidLayout_t *,
+	RF_StripeNum_t, RF_StripeNum_t *, RF_ReconUnitNum_t *);
 
-#endif				/* !_RF__RF_RAID5_ROTATEDSPARE_H_ */
+#endif	/* !_RF__RF_RAID5_ROTATEDSPARE_H_ */
diff --git a/sys/dev/raidframe/rf_raidframe.h b/sys/dev/raidframe/rf_raidframe.h
index f92a2d6540e..c92f4aa4e1a 100644
--- a/sys/dev/raidframe/rf_raidframe.h
+++ b/sys/dev/raidframe/rf_raidframe.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_raidframe.h,v 1.5 2000/08/08 16:07:44 peter Exp $	*/
+/*	$OpenBSD: rf_raidframe.h,v 1.6 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_raidframe.h,v 1.11 2000/05/28 00:48:31 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -31,13 +32,13 @@
  *
  * rf_raidframe.h
  *
- * main header file for using raidframe in the kernel.
+ * Main header file for using RAIDframe in the kernel.
  *
  *****************************************************/
 
 
-#ifndef _RF__RF_RAIDFRAME_H_
-#define _RF__RF_RAIDFRAME_H_
+#ifndef	_RF__RF_RAIDFRAME_H_
+#define	_RF__RF_RAIDFRAME_H_
 
 #include "rf_types.h"
 #include "rf_configure.h"
@@ -46,108 +47,126 @@
 
 typedef RF_uint32 RF_ReconReqFlags_t;
 
-struct rf_recon_req {		/* used to tell the kernel to fail a disk */
-	RF_RowCol_t row, col;
-	RF_ReconReqFlags_t flags;
-	void   *raidPtr;	/* used internally; need not be set at ioctl
-				 * time */
-	struct rf_recon_req *next;	/* used internally; need not be set at
-					 * ioctl time */
+struct rf_recon_req {	/* Used to tell the kernel to fail a disk. */
+	RF_RowCol_t		 row, col;
+	RF_ReconReqFlags_t	 flags;
+	void			*raidPtr;	/*
+						 * Used internally; need not be
+						 * set at ioctl time.
+						 */
+	struct rf_recon_req	*next;		/*
+						 * Used internally; need not be
+						 * set at ioctl time.
+						 */
 };
 
 struct RF_SparetWait_s {
-	int     C, G, fcol;	/* C = # disks in row, G = # units in stripe,
-				 * fcol = which disk has failed */
-
-	RF_StripeCount_t SUsPerPU;	/* this stuff is the info required to
-					 * create a spare table */
-	int     TablesPerSpareRegion;
-	int     BlocksPerTable;
-	RF_StripeCount_t TableDepthInPUs;
-	RF_StripeCount_t SpareSpaceDepthPerRegionInSUs;
-
-	RF_SparetWait_t *next;	/* used internally; need not be set at ioctl
-				 * time */
+	int			 C, G, fcol;	/*
+						 * C = # disks in row,
+						 * G = # units in stripe,
+						 * fcol = which disk has failed
+						 */
+
+	RF_StripeCount_t	 SUsPerPU;	/*
+						 * This stuff is the info
+						 * required to create a spare
+						 * table.
+						 */
+	int			 TablesPerSpareRegion;
+	int			 BlocksPerTable;
+	RF_StripeCount_t	 TableDepthInPUs;
+	RF_StripeCount_t	 SpareSpaceDepthPerRegionInSUs;
+
+	RF_SparetWait_t		*next;		/*
+						 * Used internally; need not be
+						 * set at ioctl time.
+						 */
 };
 
 typedef struct RF_DeviceConfig_s {
-	u_int   rows;
-	u_int   cols;
-	u_int   maxqdepth;
-	int     ndevs;
-	RF_RaidDisk_t devs[RF_MAX_DISKS];
-	int     nspares;
-	RF_RaidDisk_t spares[RF_MAX_DISKS];
-}       RF_DeviceConfig_t;
+	u_int			rows;
+	u_int			cols;
+	u_int			maxqdepth;
+	int			ndevs;
+	RF_RaidDisk_t		devs[RF_MAX_DISKS];
+	int			nspares;
+	RF_RaidDisk_t		spares[RF_MAX_DISKS];
+} RF_DeviceConfig_t;
 
 
 typedef struct RF_ProgressInfo_s {
-	RF_uint64 remaining;
-	RF_uint64 completed;
-	RF_uint64 total;
+	RF_uint64		remaining;
+	RF_uint64		completed;
+	RF_uint64		total;
 } RF_ProgressInfo_t;
 
-/* flags that can be put in the rf_recon_req structure */
-#define RF_FDFLAGS_NONE   0x0	/* just fail the disk */
-#define RF_FDFLAGS_RECON  0x1	/* fail and initiate recon */
-
-#define RF_SCSI_DISK_MAJOR   8	/* the device major number for disks in the
-				 * system */
-
-#define RAIDFRAME_CONFIGURE         _IOW ('r',  1, void *)	/* configure the driver */
-#define RAIDFRAME_SHUTDOWN          _IO  ('r',  2)	/* shutdown the driver */
-#define RAIDFRAME_TUR               _IOW ('r',  3, dev_t)	/* debug only: test unit
-								 * ready */
-#define RAIDFRAME_TEST_ACC          _IOWR('r',  4, struct rf_test_acc)	/* run a test access */
-#define RAIDFRAME_FAIL_DISK         _IOW ('r',  5, struct rf_recon_req)	/* fail a disk &
-									 * optionally start
-									 * recon */
-#define RAIDFRAME_CHECK_RECON_STATUS _IOWR('r',  6, int)	/* get reconstruction %
-							 * complete on indicated
-							 * row */
-#define RAIDFRAME_REWRITEPARITY     _IO  ('r',  7)	/* rewrite (initialize)
-							 * all parity */
-#define RAIDFRAME_COPYBACK          _IO  ('r',  8)	/* copy reconstructed
-							 * data back to replaced
-							 * disk */
-#define RAIDFRAME_SPARET_WAIT       _IOR ('r',  9, RF_SparetWait_t)	/* does not return until
-									 * kernel needs a spare
-									 * table */
-#define RAIDFRAME_SEND_SPARET       _IOW ('r', 10, void *)	/* used to send a spare
-								 * table down into the
-								 * kernel */
-#define RAIDFRAME_ABORT_SPARET_WAIT _IO  ('r', 11)	/* used to wake up the
-							 * sparemap daemon &
-							 * tell it to exit */
-#define RAIDFRAME_START_ATRACE      _IO  ('r', 12)	/* start tracing
-							 * accesses */
-#define RAIDFRAME_STOP_ATRACE       _IO  ('r', 13)	/* stop tracing accesses */
-#define RAIDFRAME_GET_SIZE          _IOR ('r', 14, int)	/* get size (# sectors)
-							 * in raid device */
-#define RAIDFRAME_GET_INFO          _IOWR('r', 15, RF_DeviceConfig_t *)	/* get configuration */
-#define RAIDFRAME_RESET_ACCTOTALS   _IO  ('r', 16)	/* reset AccTotals for
-							 * device */
-#define RAIDFRAME_GET_ACCTOTALS     _IOR ('r', 17, RF_AccTotals_t)	/* retrieve AccTotals
-									 * for device */
-#define RAIDFRAME_KEEP_ACCTOTALS    _IOW ('r', 18, int)	/* turn AccTotals on or
-							 * off for device */
-#define RAIDFRAME_GET_COMPONENT_LABEL _IOWR ('r', 19, RF_ComponentLabel_t *) 
-#define RAIDFRAME_SET_COMPONENT_LABEL _IOW ('r', 20, RF_ComponentLabel_t) 
-
-#define RAIDFRAME_INIT_LABELS _IOW ('r', 21, RF_ComponentLabel_t)
-#define RAIDFRAME_ADD_HOT_SPARE     _IOW ('r', 22, RF_SingleComponent_t)
-#define RAIDFRAME_REMOVE_HOT_SPARE  _IOW ('r', 23, RF_SingleComponent_t)
-#define RAIDFRAME_REBUILD_IN_PLACE  _IOW ('r', 24, RF_SingleComponent_t)
-#define RAIDFRAME_CHECK_PARITY      _IOWR ('r', 25, int)
-#define RAIDFRAME_CHECK_PARITYREWRITE_STATUS _IOWR ('r', 26, int)
-#define RAIDFRAME_CHECK_COPYBACK_STATUS _IOWR ('r', 27, int)
-#define RAIDFRAME_SET_AUTOCONFIG _IOWR ('r', 28, int)
-#define RAIDFRAME_SET_ROOT _IOWR ('r', 29, int)
-#define RAIDFRAME_DELETE_COMPONENT _IOW ('r', 30, RF_SingleComponent_t)
-#define RAIDFRAME_INCORPORATE_HOT_SPARE _IOW ('r', 31, RF_SingleComponent_t)
-/* 'Extended' status versions */
-#define RAIDFRAME_CHECK_RECON_STATUS_EXT _IOWR('r',  32, RF_ProgressInfo_t *)
-#define RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT _IOWR ('r', 33, RF_ProgressInfo_t *)
-#define RAIDFRAME_CHECK_COPYBACK_STATUS_EXT _IOWR ('r', 34, RF_ProgressInfo_t *)
-
-#endif				/* !_RF__RF_RAIDFRAME_H_ */
+/* Flags that can be put in the rf_recon_req structure. */
+#define	RF_FDFLAGS_NONE		0x0	/* Just fail the disk. */
+#define	RF_FDFLAGS_RECON	0x1	/* Fail and initiate recon. */
+
+#define	RF_SCSI_DISK_MAJOR	8	/*
+					 * The device major number for disks
+					 * in the system.
+					 */
+
+	/* Configure the driver. */
+#define	RAIDFRAME_CONFIGURE		_IOW ('r',  1, void *)
+	/* Shutdown the driver. */
+#define	RAIDFRAME_SHUTDOWN		_IO  ('r',  2)
+	/* Debug only: test unit ready. */
+#define	RAIDFRAME_TUR			_IOW ('r',  3, dev_t)
+	/* Run a test access. */
+#define	RAIDFRAME_TEST_ACC		_IOWR('r',  4, struct rf_test_acc)
+	/* Fail a disk & optionally start recon. */
+#define	RAIDFRAME_FAIL_DISK		_IOW ('r',  5, struct rf_recon_req)
+	/* Get reconstruction % complete on indicated row. */
+#define	RAIDFRAME_CHECK_RECON_STATUS	 _IOWR('r',  6, int)
+	/* Rewrite (initialize) all parity. */
+#define	RAIDFRAME_REWRITEPARITY		_IO  ('r',  7)
+	/* Copy reconstructed data back to replaced disk. */
+#define	RAIDFRAME_COPYBACK		_IO  ('r',  8)
+	/* Does not return until kernel needs a spare table. */
+#define	RAIDFRAME_SPARET_WAIT		_IOR ('r',  9, RF_SparetWait_t)
+	/* Used to send a spare table down into the kernel. */
+#define	RAIDFRAME_SEND_SPARET		_IOW ('r', 10, void *)
+	/* Used to wake up the sparemap daemon & tell it to exit. */
+#define	RAIDFRAME_ABORT_SPARET_WAIT	_IO  ('r', 11)
+	/* Start tracing accesses. */
+#define	RAIDFRAME_START_ATRAC		_IO  ('r', 12)
+	/* Stop tracing accesses. */
+#define	RAIDFRAME_STOP_ATRACE		_IO  ('r', 13)
+	/* Get size (# sectors) in raid device. */
+#define	RAIDFRAME_GET_SIZE		_IOR ('r', 14, int)
+	/* Get configuration. */
+#define	RAIDFRAME_GET_INFO		_IOWR('r', 15, RF_DeviceConfig_t *)
+	/* Reset AccTotals for device. */
+#define	RAIDFRAME_RESET_ACCTOTALS	_IO  ('r', 16)
+	/* Retrieve AccTotals for device. */
+#define	RAIDFRAME_GET_ACCTOTALS		_IOR ('r', 17, RF_AccTotals_t)
+	/* Turn AccTotals on or off for device. */
+#define	RAIDFRAME_KEEP_ACCTOTALS	_IOW ('r', 18, int)
+
+#define	RAIDFRAME_GET_COMPONENT_LABEL	_IOWR ('r', 19, RF_ComponentLabel_t *)
+#define	RAIDFRAME_SET_COMPONENT_LABEL	_IOW ('r', 20, RF_ComponentLabel_t)
+
+#define	RAIDFRAME_INIT_LABELS		_IOW ('r', 21, RF_ComponentLabel_t)
+#define	RAIDFRAME_ADD_HOT_SPARE		_IOW ('r', 22, RF_SingleComponent_t)
+#define	RAIDFRAME_REMOVE_HOT_SPARE	_IOW ('r', 23, RF_SingleComponent_t)
+#define	RAIDFRAME_REBUILD_IN_PLACE	_IOW ('r', 24, RF_SingleComponent_t)
+#define	RAIDFRAME_CHECK_PARITY		_IOWR ('r', 25, int)
+#define	RAIDFRAME_CHECK_PARITYREWRITE_STATUS _IOWR ('r', 26, int)
+#define	RAIDFRAME_CHECK_COPYBACK_STATUS	_IOWR ('r', 27, int)
+#define	RAIDFRAME_SET_AUTOCONFIG	_IOWR ('r', 28, int)
+#define	RAIDFRAME_SET_ROOT		_IOWR ('r', 29, int)
+#define	RAIDFRAME_DELETE_COMPONENT	_IOW ('r', 30, RF_SingleComponent_t)
+#define	RAIDFRAME_INCORPORATE_HOT_SPARE	_IOW ('r', 31, RF_SingleComponent_t)
+
+/* 'Extended' status versions. */
+#define	RAIDFRAME_CHECK_RECON_STATUS_EXT				\
+					_IOWR('r',  32, RF_ProgressInfo_t *)
+#define	RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT			\
+					_IOWR ('r', 33, RF_ProgressInfo_t *)
+#define	RAIDFRAME_CHECK_COPYBACK_STATUS_EXT				\
+					_IOWR ('r', 34, RF_ProgressInfo_t *)
+
+#endif	/* !_RF__RF_RAIDFRAME_H_ */
diff --git a/sys/dev/raidframe/rf_reconbuffer.c b/sys/dev/raidframe/rf_reconbuffer.c
index d1ec64672d5..c99f18b40ad 100644
--- a/sys/dev/raidframe/rf_reconbuffer.c
+++ b/sys/dev/raidframe/rf_reconbuffer.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconbuffer.c,v 1.3 2000/08/08 16:07:44 peter Exp $	*/
+/*	$OpenBSD: rf_reconbuffer.c,v 1.4 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconbuffer.c,v 1.4 2000/03/13 23:52:36 soren Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/***************************************************
+/*****************************************************
  *
- * rf_reconbuffer.c -- reconstruction buffer manager
+ * rf_reconbuffer.c -- Reconstruction buffer manager.
  *
- ***************************************************/
+ *****************************************************/
 
 #include "rf_raid.h"
 #include "rf_reconbuffer.h"
@@ -43,36 +44,42 @@
 #include "rf_reconutil.h"
 #include "rf_nwayxor.h"
 
-#define Dprintf1(s,a) if (rf_reconbufferDebug) printf(s,a)
-#define Dprintf2(s,a,b) if (rf_reconbufferDebug) printf(s,a,b)
-#define Dprintf3(s,a,b,c) if (rf_reconbufferDebug) printf(s,a,b,c)
-#define Dprintf4(s,a,b,c,d) if (rf_reconbufferDebug) printf(s,a,b,c,d)
-#define Dprintf5(s,a,b,c,d,e) if (rf_reconbufferDebug) printf(s,a,b,c,d,e)
+#define	Dprintf1(s,a) if (rf_reconbufferDebug) printf(s, a)
+#define	Dprintf2(s,a,b) if (rf_reconbufferDebug) printf(s, a, b)
+#define	Dprintf3(s,a,b,c) if (rf_reconbufferDebug) printf(s, a, b, c)
+#define	Dprintf4(s,a,b,c,d) if (rf_reconbufferDebug) printf(s, a, b, c, d)
+#define	Dprintf5(s,a,b,c,d,e) if (rf_reconbufferDebug) printf(s, a, b, c, d, e)
 
-/*****************************************************************************************
+/*****************************************************************************
  *
  * Submit a reconstruction buffer to the manager for XOR.
- * We can only submit a buffer if (1) we can xor into an existing buffer, which means
- * we don't have to acquire a new one, (2) we can acquire a floating
- * recon buffer, or (3) the caller has indicated that we are allowed to keep the
- * submitted buffer.
+ * We can only submit a buffer if (1) we can xor into an existing buffer,
+ * which means we don't have to acquire a new one, (2) we can acquire a
+ * floating recon buffer, or (3) the caller has indicated that we are allowed
+ * to keep the submitted buffer.
  *
  * Returns non-zero if and only if we were not able to submit.
- * In this case, we append the current disk ID to the wait list on the indicated
- * RU, so that it will be re-enabled when we acquire a buffer for this RU.
+ * In this case, we append the current disk ID to the wait list on the
+ * indicated RU, so that it will be re-enabled when we acquire a buffer for
+ * this RU.
  *
- ****************************************************************************************/
-
-/* just to make the code below more readable */
-#define BUFWAIT_APPEND(_cb_, _pssPtr_, _row_, _col_) \
-  _cb_ = rf_AllocCallbackDesc();                    \
-  (_cb_)->row = (_row_); (_cb_)->col = (_col_); (_cb_)->next = (_pssPtr_)->bufWaitList; (_pssPtr_)->bufWaitList = (_cb_);
+ *****************************************************************************/
+
+/* Just to make the code below more readable. */
+#define	BUFWAIT_APPEND(_cb_,_pssPtr_,_row_,_col_)			\
+do {									\
+	_cb_ = rf_AllocCallbackDesc();					\
+	(_cb_)->row = (_row_);						\
+	(_cb_)->col = (_col_);						\
+	(_cb_)->next = (_pssPtr_)->bufWaitList;				\
+	(_pssPtr_)->bufWaitList = (_cb_);				\
+} while (0)
 
 /*
- * nWayXorFuncs[i] is a pointer to a function that will xor "i"
+ * rf_nWayXorFuncs[i] is a pointer to a function that will xor "i"
  * bufs into the accumulating sum.
  */
-static RF_VoidFuncPtr nWayXorFuncs[] = {
+static RF_VoidFuncPtr rf_nWayXorFuncs[] = {
 	NULL,
 	(RF_VoidFuncPtr) rf_nWayXor1,
 	(RF_VoidFuncPtr) rf_nWayXor2,
@@ -85,89 +92,122 @@ static RF_VoidFuncPtr nWayXorFuncs[] = {
 	(RF_VoidFuncPtr) rf_nWayXor9
 };
 
-int 
-rf_SubmitReconBuffer(rbuf, keep_it, use_committed)
-	RF_ReconBuffer_t *rbuf;	/* the recon buffer to submit */
-	int     keep_it;	/* whether we can keep this buffer or we have
-				 * to return it */
-	int     use_committed;	/* whether to use a committed or an available
-				 * recon buffer */
+
+int
+rf_SubmitReconBuffer(
+    RF_ReconBuffer_t	*rbuf,		/* The recon buffer to submit. */
+    int			 keep_it,	/*
+					 * Whether we can keep this buffer or
+					 * we have to return it.
+					 */
+    int			 use_committed	/*
+					 * Whether to use a committed or an
+					 * available recon buffer.
+					 */
+)
 {
 	RF_LayoutSW_t *lp;
-	int     rc;
+	int rc;
 
 	lp = rbuf->raidPtr->Layout.map;
 	rc = lp->SubmitReconBuffer(rbuf, keep_it, use_committed);
 	return (rc);
 }
 
-int 
-rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
-	RF_ReconBuffer_t *rbuf;	/* the recon buffer to submit */
-	int     keep_it;	/* whether we can keep this buffer or we have
-				 * to return it */
-	int     use_committed;	/* whether to use a committed or an available
-				 * recon buffer */
+int
+rf_SubmitReconBufferBasic(
+    RF_ReconBuffer_t	*rbuf,		/* The recon buffer to submit. */
+    int			 keep_it,	/*
+					 * Whether we can keep this buffer
+					 * or we have to return it.
+					 */
+    int			 use_committed	/*
+					 * Whether to use a committed or
+					 * an available recon buffer.
+					 */
+)
 {
 	RF_Raid_t *raidPtr = rbuf->raidPtr;
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[rbuf->row];
 	RF_ReconParityStripeStatus_t *pssPtr;
-	RF_ReconBuffer_t *targetRbuf, *t = NULL;	/* temporary rbuf
-							 * pointers */
-	caddr_t ta;		/* temporary data buffer pointer */
+	/* Temporary rbuf pointers. */
+	RF_ReconBuffer_t *targetRbuf, *t = NULL;
+	/* Temporary data buffer pointer. */
+	caddr_t ta;
 	RF_CallbackDesc_t *cb, *p;
-	int     retcode = 0, created = 0;
+	int retcode = 0, created = 0;
 
 	RF_Etimer_t timer;
 
-	/* makes no sense to have a submission from the failed disk */
+	/* Makes no sense to have a submission from the failed disk. */
 	RF_ASSERT(rbuf);
 	RF_ASSERT(rbuf->col != reconCtrlPtr->fcol);
 
-	Dprintf5("RECON: submission by row %d col %d for psid %ld ru %d (failed offset %ld)\n",
-	    rbuf->row, rbuf->col, (long) rbuf->parityStripeID, rbuf->which_ru, (long) rbuf->failedDiskSectorOffset);
+	Dprintf5("RECON: submission by row %d col %d for psid %ld ru %d"
+	    " (failed offset %ld).\n", rbuf->row, rbuf->col,
+	    (long) rbuf->parityStripeID, rbuf->which_ru,
+	    (long) rbuf->failedDiskSectorOffset);
 
 	RF_LOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
 
 	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
 
-	pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable, rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
-	RF_ASSERT(pssPtr);	/* if it didn't exist, we wouldn't have gotten
-				 * an rbuf for it */
+	pssPtr = rf_LookupRUStatus(raidPtr, reconCtrlPtr->pssTable,
+	    rbuf->parityStripeID, rbuf->which_ru, RF_PSS_NONE, &created);
+	RF_ASSERT(pssPtr);	/*
+				 * If it didn't exist, we wouldn't have gotten
+				 * an rbuf for it.
+				 */
 
-	/* check to see if enough buffers have accumulated to do an XOR.  If
-	 * so, there's no need to acquire a floating rbuf.  Before we can do
-	 * any XORing, we must have acquired a destination buffer.  If we
+	/*
+	 * Check to see if enough buffers have accumulated to do an XOR. If
+	 * so, there's no need to acquire a floating rbuf. Before we can do
+	 * any XORing, we must have acquired a destination buffer. If we
 	 * have, then we can go ahead and do the XOR if (1) including this
 	 * buffer, enough bufs have accumulated, or (2) this is the last
 	 * submission for this stripe. Otherwise, we have to go acquire a
-	 * floating rbuf. */
+	 * floating rbuf.
+	 */
 
 	targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
 	if ((targetRbuf != NULL) &&
-	    ((pssPtr->xorBufCount == rf_numBufsToAccumulate - 1) || (targetRbuf->count + pssPtr->xorBufCount + 1 == layoutPtr->numDataCol))) {
-		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = rbuf;	/* install this buffer */
-		Dprintf3("RECON: row %d col %d invoking a %d-way XOR\n", rbuf->row, rbuf->col, pssPtr->xorBufCount);
+	    ((pssPtr->xorBufCount == rf_numBufsToAccumulate - 1) ||
+	     (targetRbuf->count + pssPtr->xorBufCount + 1 ==
+	      layoutPtr->numDataCol))) {
+		/* Install this buffer. */
+		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = rbuf;
+		Dprintf3("RECON: row %d col %d invoking a %d-way XOR.\n",
+		    rbuf->row, rbuf->col, pssPtr->xorBufCount);
 		RF_ETIMER_START(timer);
 		rf_MultiWayReconXor(raidPtr, pssPtr);
 		RF_ETIMER_STOP(timer);
 		RF_ETIMER_EVAL(timer);
 		raidPtr->accumXorTimeUs += RF_ETIMER_VAL_US(timer);
 		if (!keep_it) {
-			raidPtr->recon_tracerecs[rbuf->col].xor_us = RF_ETIMER_VAL_US(timer);
-			RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-			RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-			raidPtr->recon_tracerecs[rbuf->col].specific.recon.recon_return_to_submit_us +=
-			    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-			RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-
-			rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
+			raidPtr->recon_tracerecs[rbuf->col].xor_us =
+			    RF_ETIMER_VAL_US(timer);
+			RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col]
+			    .recon_timer);
+			RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col]
+			    .recon_timer);
+			raidPtr->recon_tracerecs[rbuf->col]
+			    .specific.recon.recon_return_to_submit_us +=
+			     RF_ETIMER_VAL_US(raidPtr
+			      ->recon_tracerecs[rbuf->col].recon_timer);
+			RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col]
+			   .recon_timer);
+
+			rf_LogTraceRec(raidPtr,
+			    &raidPtr->recon_tracerecs[rbuf->col]);
 		}
-		rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);
+		rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr,
+		    layoutPtr->numDataCol);
 
-		/* if use_committed is on, we _must_ consume a buffer off the
-		 * committed list. */
+		/*
+		 * If use_committed is on, we _must_ consume a buffer off the
+		 * committed list.
+		 */
 		if (use_committed) {
 			t = reconCtrlPtr->committedRbufs;
 			RF_ASSERT(t);
@@ -175,19 +215,21 @@ rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
 			rf_ReleaseFloatingReconBuffer(raidPtr, rbuf->row, t);
 		}
 		if (keep_it) {
-			RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
+			RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row,
+			    rbuf->parityStripeID);
 			RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
 			rf_FreeReconBuffer(rbuf);
 			return (retcode);
 		}
 		goto out;
 	}
-	/* set the value of "t", which we'll use as the rbuf from here on */
+	/* Set the value of "t", which we'll use as the rbuf from here on. */
 	if (keep_it) {
 		t = rbuf;
 	} else {
-		if (use_committed) {	/* if a buffer has been committed to
-					 * us, use it */
+		if (use_committed) {
+			/* If a buffer has been committed to us, use it. */
+
 			t = reconCtrlPtr->committedRbufs;
 			RF_ASSERT(t);
 			reconCtrlPtr->committedRbufs = t->next;
@@ -200,21 +242,25 @@ rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
 			}
 	}
 
-	/* If we weren't able to acquire a buffer, append to the end of the
-	 * buf list in the recon ctrl struct. */
+	/*
+	 * If we weren't able to acquire a buffer, append to the end of the
+	 * buf list in the recon ctrl struct.
+	 */
 	if (!t) {
 		RF_ASSERT(!keep_it && !use_committed);
-		Dprintf2("RECON: row %d col %d failed to acquire floating rbuf\n", rbuf->row, rbuf->col);
+		Dprintf2("RECON: row %d col %d failed to acquire floating"
+		    " rbuf.\n", rbuf->row, rbuf->col);
 
 		raidPtr->procsInBufWait++;
-		if ((raidPtr->procsInBufWait == raidPtr->numCol - 1) && (raidPtr->numFullReconBuffers == 0)) {
-			printf("Buffer wait deadlock detected.  Exiting.\n");
+		if ((raidPtr->procsInBufWait == raidPtr->numCol - 1) &&
+		    (raidPtr->numFullReconBuffers == 0)) {
+			printf("Buffer wait deadlock detected. Exiting.\n");
 			rf_PrintPSStatusTable(raidPtr, rbuf->row);
 			RF_PANIC();
 		}
 		pssPtr->flags |= RF_PSS_BUFFERWAIT;
-		cb = rf_AllocCallbackDesc();	/* append to buf wait list in
-						 * recon ctrl structure */
+		/* Append to buf wait list in recon ctrl structure. */
+		cb = rf_AllocCallbackDesc();
 		cb->row = rbuf->row;
 		cb->col = rbuf->col;
 		cb->callbackArg.v = rbuf->parityStripeID;
@@ -222,24 +268,29 @@ rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
 		cb->next = NULL;
 		if (!reconCtrlPtr->bufferWaitList)
 			reconCtrlPtr->bufferWaitList = cb;
-		else {		/* might want to maintain head/tail pointers
-				 * here rather than search for end of list */
-			for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next);
+		else {
+			/*
+			 * Might want to maintain head/tail pointers
+			 * here rather than search for end of list.
+			 */
+			for (p = reconCtrlPtr->bufferWaitList; p->next;
+			     p = p->next);
 			p->next = cb;
 		}
 		retcode = 1;
 		goto out;
 	}
-	Dprintf2("RECON: row %d col %d acquired rbuf\n", rbuf->row, rbuf->col);
+	Dprintf2("RECON: row %d col %d acquired rbuf.\n", rbuf->row, rbuf->col);
 	RF_ETIMER_STOP(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
 	RF_ETIMER_EVAL(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-	raidPtr->recon_tracerecs[rbuf->col].specific.recon.recon_return_to_submit_us +=
-	    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
+	raidPtr->recon_tracerecs[rbuf->col]
+	    .specific.recon.recon_return_to_submit_us +=
+	     RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
 	RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
 
 	rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
 
-	/* initialize the buffer */
+	/* Initialize the buffer. */
 	if (t != rbuf) {
 		t->row = rbuf->row;
 		t->col = reconCtrlPtr->fcol;
@@ -252,19 +303,23 @@ rf_SubmitReconBufferBasic(rbuf, keep_it, use_committed)
 
 		ta = t->buffer;
 		t->buffer = rbuf->buffer;
-		rbuf->buffer = ta;	/* swap buffers */
+		rbuf->buffer = ta;	/* Swap buffers. */
 	}
-	/* the first installation always gets installed as the destination
-	 * buffer. subsequent installations get stacked up to allow for
-	 * multi-way XOR */
+	/*
+	 * The first installation always gets installed as the destination
+	 * buffer. Subsequent installations get stacked up to allow for
+	 * multi-way XOR.
+	 */
 	if (!pssPtr->rbuf) {
 		pssPtr->rbuf = t;
 		t->count = 1;
 	} else
-		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = t;	/* install this buffer */
+		/* Install this buffer. */
+		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = t;
 
-	rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);	/* the buffer is full if
-											 * G=2 */
+	/* The buffer is full if G=2. */
+	rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr,
+	    layoutPtr->numDataCol);
 
 out:
 	RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
@@ -272,36 +327,45 @@ out:
 	return (retcode);
 }
 
-int 
-rf_MultiWayReconXor(raidPtr, pssPtr)
-	RF_Raid_t *raidPtr;
-	RF_ReconParityStripeStatus_t *pssPtr;	/* the pss descriptor for this
-						 * parity stripe */
+int
+rf_MultiWayReconXor(
+    RF_Raid_t			 *raidPtr,
+    RF_ReconParityStripeStatus_t *pssPtr	/*
+						 * The pss descriptor for this
+						 * parity stripe.
+						 */
+)
 {
-	int     i, numBufs = pssPtr->xorBufCount;
-	int     numBytes = rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU);
+	int i, numBufs = pssPtr->xorBufCount;
+	int numBytes = rf_RaidAddressToByte(raidPtr,
+	    raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU);
 	RF_ReconBuffer_t **rbufs = (RF_ReconBuffer_t **) pssPtr->rbufsForXor;
 	RF_ReconBuffer_t *targetRbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
 
 	RF_ASSERT(pssPtr->rbuf != NULL);
 	RF_ASSERT(numBufs > 0 && numBufs < RF_PS_MAX_BUFS);
-#ifdef _KERNEL
-#if !defined(__NetBSD__) && !defined(__OpenBSD__)
-	thread_block();		/* yield the processor before doing a big XOR */
+#ifdef	_KERNEL
+#if	!defined(__NetBSD__) && !defined(__OpenBSD__)
+	/* Yield the processor before doing a big XOR. */
+	thread_block();
 #endif
-#endif				/* _KERNEL */
+#endif	/* _KERNEL */
+	/*
+	 * XXX
+	 *
+	 * What if more than 9 bufs ?
+	 */
+	rf_nWayXorFuncs[numBufs] (pssPtr->rbufsForXor, targetRbuf,
+	    numBytes / sizeof(long));
+
 	/*
-         * XXX
-         *
-         * What if more than 9 bufs?
-         */
-	nWayXorFuncs[numBufs] (pssPtr->rbufsForXor, targetRbuf, numBytes / sizeof(long));
-
-	/* release all the reconstruction buffers except the last one, which
-	 * belongs to the disk whose submission caused this XOR to take place */
+	 * Release all the reconstruction buffers except the last one, which
+	 * belongs to the disk whose submission caused this XOR to take place.
+	 */
 	for (i = 0; i < numBufs - 1; i++) {
 		if (rbufs[i]->type == RF_RBUF_TYPE_FLOATING)
-			rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row, rbufs[i]);
+			rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row,
+			    rbufs[i]);
 		else
 			if (rbufs[i]->type == RF_RBUF_TYPE_FORCED)
 				rf_FreeReconBuffer(rbufs[i]);
@@ -312,13 +376,15 @@ rf_MultiWayReconXor(raidPtr, pssPtr)
 	pssPtr->xorBufCount = 0;
 	return (0);
 }
-/* removes one full buffer from one of the full-buffer lists and returns it.
+
+
+/*
+ * Removes one full buffer from one of the full-buffer lists and returns it.
  *
  * ASSUMES THE RB_MUTEX IS UNLOCKED AT ENTRY.
  */
 RF_ReconBuffer_t *
-rf_GetFullReconBuffer(reconCtrlPtr)
-	RF_ReconCtrl_t *reconCtrlPtr;
+rf_GetFullReconBuffer(RF_ReconCtrl_t *reconCtrlPtr)
 {
 	RF_ReconBuffer_t *p;
 
@@ -340,75 +406,84 @@ out:
 }
 
 
-/* if the reconstruction buffer is full, move it to the full list, which is maintained
- * sorted by failed disk sector offset
+/*
+ * If the reconstruction buffer is full, move it to the full list, which
+ * is maintained sorted by failed disk sector offset.
  *
  * ASSUMES THE RB_MUTEX IS LOCKED AT ENTRY.
  */
-int 
-rf_CheckForFullRbuf(raidPtr, reconCtrl, pssPtr, numDataCol)
-	RF_Raid_t *raidPtr;
-	RF_ReconCtrl_t *reconCtrl;
-	RF_ReconParityStripeStatus_t *pssPtr;
-	int     numDataCol;
+int
+rf_CheckForFullRbuf(RF_Raid_t *raidPtr, RF_ReconCtrl_t *reconCtrl,
+    RF_ReconParityStripeStatus_t *pssPtr, int numDataCol)
 {
 	RF_ReconBuffer_t *p, *pt, *rbuf = (RF_ReconBuffer_t *) pssPtr->rbuf;
 
 	if (rbuf->count == numDataCol) {
 		raidPtr->numFullReconBuffers++;
-		Dprintf2("RECON: rbuf for psid %ld ru %d has filled\n",
+		Dprintf2("RECON: rbuf for psid %ld ru %d has filled.\n",
 		    (long) rbuf->parityStripeID, rbuf->which_ru);
-		if (!reconCtrl->fullBufferList || (rbuf->failedDiskSectorOffset < reconCtrl->fullBufferList->failedDiskSectorOffset)) {
-			Dprintf2("RECON: rbuf for psid %ld ru %d is head of list\n",
-			    (long) rbuf->parityStripeID, rbuf->which_ru);
+		if (!reconCtrl->fullBufferList ||
+		    (rbuf->failedDiskSectorOffset <
+		     reconCtrl->fullBufferList->failedDiskSectorOffset)) {
+			Dprintf2("RECON: rbuf for psid %ld ru %d is head of"
+			    " list.\n", (long) rbuf->parityStripeID,
+			    rbuf->which_ru);
 			rbuf->next = reconCtrl->fullBufferList;
 			reconCtrl->fullBufferList = rbuf;
 		} else {
-			for (pt = reconCtrl->fullBufferList, p = pt->next; p && p->failedDiskSectorOffset < rbuf->failedDiskSectorOffset; pt = p, p = p->next);
+			for (pt = reconCtrl->fullBufferList, p = pt->next;
+			     p && p->failedDiskSectorOffset <
+			      rbuf->failedDiskSectorOffset;
+			     pt = p, p = p->next);
 			rbuf->next = p;
 			pt->next = rbuf;
-			Dprintf2("RECON: rbuf for psid %ld ru %d is in list\n",
+			Dprintf2("RECON: rbuf for psid %ld ru %d is in list.\n",
 			    (long) rbuf->parityStripeID, rbuf->which_ru);
 		}
 #if 0
-		pssPtr->writeRbuf = pssPtr->rbuf;	/* DEBUG ONLY:  we like
+		pssPtr->writeRbuf = pssPtr->rbuf;	/*
+							 * DEBUG ONLY: We like
 							 * to be able to find
 							 * this rbuf while it's
-							 * awaiting write */
+							 * awaiting write.
+							 */
 #else
 		rbuf->pssPtr = pssPtr;
 #endif
 		pssPtr->rbuf = NULL;
-		rf_CauseReconEvent(raidPtr, rbuf->row, rbuf->col, NULL, RF_REVENT_BUFREADY);
+		rf_CauseReconEvent(raidPtr, rbuf->row, rbuf->col, NULL,
+		    RF_REVENT_BUFREADY);
 	}
 	return (0);
 }
 
 
-/* release a floating recon buffer for someone else to use.
- * assumes the rb_mutex is LOCKED at entry
+/*
+ * Release a floating recon buffer for someone else to use.
+ * Assumes the rb_mutex is LOCKED at entry.
  */
-void 
-rf_ReleaseFloatingReconBuffer(raidPtr, row, rbuf)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_ReconBuffer_t *rbuf;
+void
+rf_ReleaseFloatingReconBuffer(RF_Raid_t *raidPtr, RF_RowCol_t row,
+    RF_ReconBuffer_t *rbuf)
 {
 	RF_ReconCtrl_t *rcPtr = raidPtr->reconControl[row];
 	RF_CallbackDesc_t *cb;
 
-	Dprintf2("RECON: releasing rbuf for psid %ld ru %d\n",
+	Dprintf2("RECON: releasing rbuf for psid %ld ru %d.\n",
 	    (long) rbuf->parityStripeID, rbuf->which_ru);
 
-	/* if anyone is waiting on buffers, wake one of them up.  They will
-	 * subsequently wake up anyone else waiting on their RU */
+	/*
+	 * If anyone is waiting on buffers, wake one of them up. They will
+	 * subsequently wake up anyone else waiting on their RU.
+	 */
 	if (rcPtr->bufferWaitList) {
 		rbuf->next = rcPtr->committedRbufs;
 		rcPtr->committedRbufs = rbuf;
 		cb = rcPtr->bufferWaitList;
 		rcPtr->bufferWaitList = cb->next;
-		rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 1, RF_REVENT_BUFCLEAR);	/* arg==1 => we've
-												 * committed a buffer */
+		/* arg==1 => We've committed a buffer. */
+		rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 1,
+		    RF_REVENT_BUFCLEAR);
 		rf_FreeCallbackDesc(cb);
 		raidPtr->procsInBufWait--;
 	} else {
@@ -416,52 +491,63 @@ rf_ReleaseFloatingReconBuffer(raidPtr, row, rbuf)
 		rcPtr->floatingRbufs = rbuf;
 	}
 }
-/* release any disk that is waiting on a buffer for the indicated RU.
- * assumes the rb_mutex is LOCKED at entry
+
+
+/*
+ * Release any disk that is waiting on a buffer for the indicated RU.
+ * Assumes the rb_mutex is LOCKED at entry.
  */
-void 
-rf_ReleaseBufferWaiters(raidPtr, pssPtr)
-	RF_Raid_t *raidPtr;
-	RF_ReconParityStripeStatus_t *pssPtr;
+void
+rf_ReleaseBufferWaiters(
+    RF_Raid_t			 *raidPtr,
+    RF_ReconParityStripeStatus_t *pssPtr
+)
 {
 	RF_CallbackDesc_t *cb1, *cb = pssPtr->bufWaitList;
 
-	Dprintf2("RECON: releasing buf waiters for psid %ld ru %d\n",
+	Dprintf2("RECON: releasing buf waiters for psid %ld ru %d.\n",
 	    (long) pssPtr->parityStripeID, pssPtr->which_ru);
 	pssPtr->flags &= ~RF_PSS_BUFFERWAIT;
 	while (cb) {
 		cb1 = cb->next;
 		cb->next = NULL;
-		rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 0, RF_REVENT_BUFCLEAR);	/* arg==0 => we haven't
-												 * committed a buffer */
+		/* arg==0 => We haven't committed a buffer. */
+		rf_CauseReconEvent(raidPtr, cb->row, cb->col, (void *) 0,
+		    RF_REVENT_BUFCLEAR);
 		rf_FreeCallbackDesc(cb);
 		cb = cb1;
 	}
 	pssPtr->bufWaitList = NULL;
 }
-/* when reconstruction is forced on an RU, there may be some disks waiting to
- * acquire a buffer for that RU.  Since we allocate a new buffer as part of
+
+
+/*
+ * When reconstruction is forced on an RU, there may be some disks waiting to
+ * acquire a buffer for that RU. Since we allocate a new buffer as part of
  * the forced-reconstruction process, we no longer have to wait for any
- * buffers, so we wakeup any waiter that we find in the bufferWaitList
+ * buffers, so we wakeup any waiter that we find in the bufferWaitList.
  *
- * assumes the rb_mutex is LOCKED at entry
+ * Assumes the rb_mutex is LOCKED at entry.
  */
-void 
-rf_ReleaseBufferWaiter(rcPtr, rbuf)
-	RF_ReconCtrl_t *rcPtr;
-	RF_ReconBuffer_t *rbuf;
+void
+rf_ReleaseBufferWaiter(RF_ReconCtrl_t *rcPtr, RF_ReconBuffer_t *rbuf)
 {
 	RF_CallbackDesc_t *cb, *cbt;
 
-	for (cbt = NULL, cb = rcPtr->bufferWaitList; cb; cbt = cb, cb = cb->next) {
-		if ((cb->callbackArg.v == rbuf->parityStripeID) && (cb->callbackArg2.v == rbuf->which_ru)) {
-			Dprintf2("RECON: Dropping row %d col %d from buffer wait list\n", cb->row, cb->col);
+	for (cbt = NULL, cb = rcPtr->bufferWaitList; cb;
+	     cbt = cb, cb = cb->next) {
+		if ((cb->callbackArg.v == rbuf->parityStripeID) &&
+		    (cb->callbackArg2.v == rbuf->which_ru)) {
+			Dprintf2("RECON: Dropping row %d col %d from buffer"
+			    " wait list.\n", cb->row, cb->col);
 			if (cbt)
 				cbt->next = cb->next;
 			else
 				rcPtr->bufferWaitList = cb->next;
-			rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, cb->row, cb->col, (void *) 0, RF_REVENT_BUFREADY);	/* arg==0 => no
-																 * committed buffer */
+
+			/* arg==0 => No committed buffer. */
+			rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr,
+			    cb->row, cb->col, (void *) 0, RF_REVENT_BUFREADY);
 			rf_FreeCallbackDesc(cb);
 			return;
 		}
diff --git a/sys/dev/raidframe/rf_reconbuffer.h b/sys/dev/raidframe/rf_reconbuffer.h
index 84921fc5393..5a51b01ae6b 100644
--- a/sys/dev/raidframe/rf_reconbuffer.h
+++ b/sys/dev/raidframe/rf_reconbuffer.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconbuffer.h,v 1.2 1999/02/16 00:03:21 niklas Exp $	*/
+/*	$OpenBSD: rf_reconbuffer.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconbuffer.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,37 +28,27 @@
  * rights to redistribute these changes.
  */
 
-/*******************************************************************
+/*********************************************************************
  *
- * rf_reconbuffer.h -- header file for reconstruction buffer manager
+ * rf_reconbuffer.h -- Header file for reconstruction buffer manager.
  *
- *******************************************************************/
+ *********************************************************************/
 
-#ifndef _RF__RF_RECONBUFFER_H_
-#define _RF__RF_RECONBUFFER_H_
+#ifndef	_RF__RF_RECONBUFFER_H_
+#define	_RF__RF_RECONBUFFER_H_
 
 #include "rf_types.h"
 #include "rf_reconstruct.h"
 
-int 
-rf_SubmitReconBuffer(RF_ReconBuffer_t * rbuf, int keep_int,
-    int use_committed);
-int 
-rf_SubmitReconBufferBasic(RF_ReconBuffer_t * rbuf, int keep_int,
-    int use_committed);
-int 
-rf_MultiWayReconXor(RF_Raid_t * raidPtr,
-    RF_ReconParityStripeStatus_t * pssPtr);
-RF_ReconBuffer_t *rf_GetFullReconBuffer(RF_ReconCtrl_t * reconCtrlPtr);
-int 
-rf_CheckForFullRbuf(RF_Raid_t * raidPtr, RF_ReconCtrl_t * reconCtrl,
-    RF_ReconParityStripeStatus_t * pssPtr, int numDataCol);
-void 
-rf_ReleaseFloatingReconBuffer(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_ReconBuffer_t * rbuf);
-void 
-rf_ReleaseBufferWaiters(RF_Raid_t * raidPtr,
-    RF_ReconParityStripeStatus_t * pssPtr);
-void    rf_ReleaseBufferWaiter(RF_ReconCtrl_t * rcPtr, RF_ReconBuffer_t * rbuf);
+int  rf_SubmitReconBuffer(RF_ReconBuffer_t *, int, int);
+int  rf_SubmitReconBufferBasic(RF_ReconBuffer_t *, int, int);
+int  rf_MultiWayReconXor(RF_Raid_t *, RF_ReconParityStripeStatus_t *);
+RF_ReconBuffer_t *rf_GetFullReconBuffer(RF_ReconCtrl_t *);
+int  rf_CheckForFullRbuf(RF_Raid_t *, RF_ReconCtrl_t *,
+	RF_ReconParityStripeStatus_t *, int);
+void rf_ReleaseFloatingReconBuffer(RF_Raid_t *, RF_RowCol_t,
+	RF_ReconBuffer_t *);
+void rf_ReleaseBufferWaiters(RF_Raid_t *, RF_ReconParityStripeStatus_t *);
+void rf_ReleaseBufferWaiter(RF_ReconCtrl_t *, RF_ReconBuffer_t *);
 
-#endif				/* !_RF__RF_RECONBUFFER_H_ */
+#endif	/* !_RF__RF_RECONBUFFER_H_ */
diff --git a/sys/dev/raidframe/rf_reconmap.c b/sys/dev/raidframe/rf_reconmap.c
index 1d614c02f0a..3288c501ff7 100644
--- a/sys/dev/raidframe/rf_reconmap.c
+++ b/sys/dev/raidframe/rf_reconmap.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconmap.c,v 1.3 2000/01/07 14:50:22 peter Exp $	*/
+/*	$OpenBSD: rf_reconmap.c,v 1.4 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconmap.c,v 1.6 1999/08/14 21:44:24 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,64 +28,67 @@
  * rights to redistribute these changes.
  */
 
-/*************************************************************************
+/*****************************************************************************
  * rf_reconmap.c
  *
- * code to maintain a map of what sectors have/have not been reconstructed
+ * Code to maintain a map of what sectors have/have not been reconstructed.
  *
- *************************************************************************/
+ *****************************************************************************/
 
 #include "rf_raid.h"
 #include <sys/time.h>
 #include "rf_general.h"
 #include "rf_utils.h"
 
-/* special pointer values indicating that a reconstruction unit
- * has been either totally reconstructed or not at all.  Both
+/*
+ * Special pointer values indicating that a reconstruction unit
+ * has been either totally reconstructed or not at all. Both
  * are illegal pointer values, so you have to be careful not to
- * dereference through them.  RU_NOTHING must be zero, since
- * MakeReconMap uses bzero to initialize the structure.  These are used
+ * dereference through them. RU_NOTHING must be zero, since
+ * MakeReconMap uses bzero to initialize the structure. These are used
  * only at the head of the list.
  */
-#define RU_ALL      ((RF_ReconMapListElem_t *) -1)
-#define RU_NOTHING  ((RF_ReconMapListElem_t *) 0)
-
-/* used to mark the end of the list */
-#define RU_NIL      ((RF_ReconMapListElem_t *) 0)
-
-
-static void 
-compact_stat_entry(RF_Raid_t * raidPtr, RF_ReconMap_t * mapPtr,
-    int i);
-static void crunch_list(RF_ReconMap_t * mapPtr, RF_ReconMapListElem_t * listPtr);
-static RF_ReconMapListElem_t *
-MakeReconMapListElem(RF_SectorNum_t startSector,
-    RF_SectorNum_t stopSector, RF_ReconMapListElem_t * next);
-static void 
-FreeReconMapListElem(RF_ReconMap_t * mapPtr,
-    RF_ReconMapListElem_t * p);
-static void update_size(RF_ReconMap_t * mapPtr, int size);
-static void PrintList(RF_ReconMapListElem_t * listPtr);
-
-/*-----------------------------------------------------------------------------
+#define	RU_ALL		((RF_ReconMapListElem_t *) -1)
+#define	RU_NOTHING	((RF_ReconMapListElem_t *) 0)
+
+/* Used to mark the end of the list. */
+#define	RU_NIL		((RF_ReconMapListElem_t *) 0)
+
+
+void rf_compact_stat_entry(RF_Raid_t *, RF_ReconMap_t *, int);
+void rf_crunch_list(RF_ReconMap_t *, RF_ReconMapListElem_t *);
+RF_ReconMapListElem_t * rf_MakeReconMapListElem(RF_SectorNum_t, RF_SectorNum_t,
+	RF_ReconMapListElem_t *);
+void rf_FreeReconMapListElem(RF_ReconMap_t *, RF_ReconMapListElem_t *);
+void rf_update_size(RF_ReconMap_t *, int);
+void rf_PrintList(RF_ReconMapListElem_t *);
+
+
+/*****************************************************************************
  *
- * Creates and initializes new Reconstruction map
+ * Creates and initializes new Reconstruction map.
  *
- *-----------------------------------------------------------------------------*/
+ *****************************************************************************/
 
 RF_ReconMap_t *
-rf_MakeReconMap(raidPtr, ru_sectors, disk_sectors, spareUnitsPerDisk)
-	RF_Raid_t *raidPtr;
-	RF_SectorCount_t ru_sectors;	/* size of reconstruction unit in
-					 * sectors */
-	RF_SectorCount_t disk_sectors;	/* size of disk in sectors */
-	RF_ReconUnitCount_t spareUnitsPerDisk;	/* zero unless distributed
-						 * sparing */
+rf_MakeReconMap(
+    RF_Raid_t		*raidPtr,
+    RF_SectorCount_t	 ru_sectors,		/*
+						 * Size of reconstruction unit
+						 * in sectors.
+						 */
+    RF_SectorCount_t	 disk_sectors,		/* Size of disk in sectors. */
+    RF_ReconUnitCount_t	 spareUnitsPerDisk	/*
+						 * Zero unless distributed
+						 * sparing.
+						 */
+)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_ReconUnitCount_t num_rus = layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerRU;
+	RF_ReconUnitCount_t num_rus = layoutPtr->stripeUnitsPerDisk /
+	    layoutPtr->SUsPerRU;
 	RF_ReconMap_t *p;
-	int     rc;
+	int rc;
 
 	RF_Malloc(p, sizeof(RF_ReconMap_t), (RF_ReconMap_t *));
 	p->sectorsPerReconUnit = ru_sectors;
@@ -94,18 +98,21 @@ rf_MakeReconMap(raidPtr, ru_sectors, disk_sectors, spareUnitsPerDisk)
 	p->spareRUs = spareUnitsPerDisk;
 	p->unitsLeft = num_rus - spareUnitsPerDisk;
 
-	RF_Malloc(p->status, num_rus * sizeof(RF_ReconMapListElem_t *), (RF_ReconMapListElem_t **));
+	RF_Malloc(p->status, num_rus * sizeof(RF_ReconMapListElem_t *),
+	    (RF_ReconMapListElem_t **));
 	RF_ASSERT(p->status != (RF_ReconMapListElem_t **) NULL);
 
-	(void) bzero((char *) p->status, num_rus * sizeof(RF_ReconMapListElem_t *));
+	(void) bzero((char *) p->status, num_rus *
+	    sizeof(RF_ReconMapListElem_t *));
 
-	p->size = sizeof(RF_ReconMap_t) + num_rus * sizeof(RF_ReconMapListElem_t *);
+	p->size = sizeof(RF_ReconMap_t) + num_rus *
+	    sizeof(RF_ReconMapListElem_t *);
 	p->maxSize = p->size;
 
 	rc = rf_mutex_init(&p->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);
 		RF_Free(p->status, num_rus * sizeof(RF_ReconMapListElem_t *));
 		RF_Free(p, sizeof(RF_ReconMap_t));
 		return (NULL);
@@ -114,33 +121,32 @@ rf_MakeReconMap(raidPtr, ru_sectors, disk_sectors, spareUnitsPerDisk)
 }
 
 
-/*-----------------------------------------------------------------------------
+/*****************************************************************************
  *
- * marks a new set of sectors as reconstructed.  All the possible mergings get
- * complicated.  To simplify matters, the approach I take is to just dump
+ * Marks a new set of sectors as reconstructed. All the possible mergings get
+ * complicated. To simplify matters, the approach I take is to just dump
  * something into the list, and then clean it up (i.e. merge elements and
- * eliminate redundant ones) in a second pass over the list (compact_stat_entry()).
+ * eliminate redundant ones) in a second pass over the list
+ * (rf_compact_stat_entry()).
  * Not 100% efficient, since a structure can be allocated and then immediately
  * freed, but it keeps this code from becoming (more of) a nightmare of
- * special cases.  The only thing that compact_stat_entry() assumes is that the
- * list is sorted by startSector, and so this is the only condition I maintain
- * here.  (MCH)
+ * special cases. The only thing that rf_compact_stat_entry() assumes is that
+ * the list is sorted by startSector, and so this is the only condition I
+ * maintain here. (MCH)
  *
- *-----------------------------------------------------------------------------*/
-
-void 
-rf_ReconMapUpdate(raidPtr, mapPtr, startSector, stopSector)
-	RF_Raid_t *raidPtr;
-	RF_ReconMap_t *mapPtr;
-	RF_SectorNum_t startSector;
-	RF_SectorNum_t stopSector;
+ *****************************************************************************/
+
+void
+rf_ReconMapUpdate(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr,
+    RF_SectorNum_t startSector, RF_SectorNum_t stopSector)
 {
 	RF_SectorCount_t sectorsPerReconUnit = mapPtr->sectorsPerReconUnit;
 	RF_SectorNum_t i, first_in_RU, last_in_RU;
 	RF_ReconMapListElem_t *p, *pt;
 
 	RF_LOCK_MUTEX(mapPtr->mutex);
-	RF_ASSERT(startSector >= 0 && stopSector < mapPtr->sectorsInDisk && stopSector >= startSector);
+	RF_ASSERT(startSector >= 0 && stopSector < mapPtr->sectorsInDisk &&
+	    stopSector >= startSector);
 
 	while (startSector <= stopSector) {
 		i = startSector / mapPtr->sectorsPerReconUnit;
@@ -148,21 +154,27 @@ rf_ReconMapUpdate(raidPtr, mapPtr, startSector, stopSector)
 		last_in_RU = first_in_RU + sectorsPerReconUnit - 1;
 		p = mapPtr->status[i];
 		if (p != RU_ALL) {
-			if (p == RU_NOTHING || p->startSector > startSector) {	/* insert at front of
-										 * list */
-
-				mapPtr->status[i] = MakeReconMapListElem(startSector, RF_MIN(stopSector, last_in_RU), (p == RU_NOTHING) ? NULL : p);
-				update_size(mapPtr, sizeof(RF_ReconMapListElem_t));
-
-			} else {/* general case */
-				do {	/* search for place to insert */
+			if (p == RU_NOTHING || p->startSector > startSector) {
+				/* Insert at front of list. */
+
+				mapPtr->status[i] =
+				    rf_MakeReconMapListElem(startSector,
+				     RF_MIN(stopSector, last_in_RU),
+				     (p == RU_NOTHING) ? NULL : p);
+				rf_update_size(mapPtr,
+				    sizeof(RF_ReconMapListElem_t));
+
+			} else {/* General case. */
+				do {	/* Search for place to insert. */
 					pt = p;
 					p = p->next;
 				} while (p && (p->startSector < startSector));
-				pt->next = MakeReconMapListElem(startSector, RF_MIN(stopSector, last_in_RU), p);
-				update_size(mapPtr, sizeof(RF_ReconMapListElem_t));
+				pt->next = rf_MakeReconMapListElem(startSector,
+				    RF_MIN(stopSector, last_in_RU), p);
+				rf_update_size(mapPtr,
+				    sizeof(RF_ReconMapListElem_t));
 			}
-			compact_stat_entry(raidPtr, mapPtr, i);
+			rf_compact_stat_entry(raidPtr, mapPtr, i);
 		}
 		startSector = RF_MIN(stopSector, last_in_RU) + 1;
 	}
@@ -170,46 +182,41 @@ rf_ReconMapUpdate(raidPtr, mapPtr, startSector, stopSector)
 }
 
 
-
-/*-----------------------------------------------------------------------------
+/*****************************************************************************
  *
- * performs whatever list compactions can be done, and frees any space
- * that is no longer necessary.  Assumes only that the list is sorted
- * by startSector.  crunch_list() compacts a single list as much as possible,
+ * Performs whatever list compactions can be done, and frees any space
+ * that is no longer necessary. Assumes only that the list is sorted
+ * by startSector. rf_crunch_list() compacts a single list as much as possible,
  * and the second block of code deletes the entire list if possible.
- * crunch_list() is also called from MakeReconMapAccessList().
+ * rf_crunch_list() is also called from MakeReconMapAccessList().
  *
  * When a recon unit is detected to be fully reconstructed, we set the
  * corresponding bit in the parity stripe map so that the head follow
- * code will not select this parity stripe again.  This is redundant (but
- * harmless) when compact_stat_entry is called from the reconstruction code,
- * but necessary when called from the user-write code.
+ * code will not select this parity stripe again. This is redundant (but
+ * harmless) when rf_compact_stat_entry is called from the reconstruction
+ * code, but necessary when called from the user-write code.
  *
- *-----------------------------------------------------------------------------*/
+ *****************************************************************************/
 
-static void 
-compact_stat_entry(raidPtr, mapPtr, i)
-	RF_Raid_t *raidPtr;
-	RF_ReconMap_t *mapPtr;
-	int     i;
+void
+rf_compact_stat_entry(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr, int i)
 {
 	RF_SectorCount_t sectorsPerReconUnit = mapPtr->sectorsPerReconUnit;
 	RF_ReconMapListElem_t *p = mapPtr->status[i];
 
-	crunch_list(mapPtr, p);
+	rf_crunch_list(mapPtr, p);
 
 	if ((p->startSector == i * sectorsPerReconUnit) &&
-	    (p->stopSector == i * sectorsPerReconUnit + sectorsPerReconUnit - 1)) {
+	    (p->stopSector == i * sectorsPerReconUnit +
+	     sectorsPerReconUnit - 1)) {
 		mapPtr->status[i] = RU_ALL;
 		mapPtr->unitsLeft--;
-		FreeReconMapListElem(mapPtr, p);
+		rf_FreeReconMapListElem(mapPtr, p);
 	}
 }
 
-static void 
-crunch_list(mapPtr, listPtr)
-	RF_ReconMap_t *mapPtr;
-	RF_ReconMapListElem_t *listPtr;
+void
+rf_crunch_list(RF_ReconMap_t *mapPtr, RF_ReconMapListElem_t *listPtr)
 {
 	RF_ReconMapListElem_t *pt, *p = listPtr;
 
@@ -221,7 +228,7 @@ crunch_list(mapPtr, listPtr)
 		if (pt->stopSector >= p->startSector - 1) {
 			pt->stopSector = RF_MAX(pt->stopSector, p->stopSector);
 			pt->next = p->next;
-			FreeReconMapListElem(mapPtr, p);
+			rf_FreeReconMapListElem(mapPtr, p);
 			p = pt->next;
 		} else {
 			pt = p;
@@ -229,17 +236,17 @@ crunch_list(mapPtr, listPtr)
 		}
 	}
 }
-/*-----------------------------------------------------------------------------
+
+
+/*****************************************************************************
  *
- * Allocate and fill a new list element
+ * Allocate and fill a new list element.
  *
- *-----------------------------------------------------------------------------*/
+ *****************************************************************************/
 
-static RF_ReconMapListElem_t *
-MakeReconMapListElem(
-    RF_SectorNum_t startSector,
-    RF_SectorNum_t stopSector,
-    RF_ReconMapListElem_t * next)
+RF_ReconMapListElem_t *
+rf_MakeReconMapListElem(RF_SectorNum_t startSector, RF_SectorNum_t stopSector,
+    RF_ReconMapListElem_t *next)
 {
 	RF_ReconMapListElem_t *p;
 
@@ -251,33 +258,36 @@ MakeReconMapListElem(
 	p->next = next;
 	return (p);
 }
-/*-----------------------------------------------------------------------------
+
+
+/*****************************************************************************
  *
- * Free a list element
+ * Free a list element.
  *
- *-----------------------------------------------------------------------------*/
+ *****************************************************************************/
 
-static void 
-FreeReconMapListElem(mapPtr, p)
-	RF_ReconMap_t *mapPtr;
-	RF_ReconMapListElem_t *p;
+void
+rf_FreeReconMapListElem(RF_ReconMap_t *mapPtr, RF_ReconMapListElem_t *p)
 {
-	int     delta;
+	int delta;
 
 	if (mapPtr) {
 		delta = 0 - (int) sizeof(RF_ReconMapListElem_t);
-		update_size(mapPtr, delta);
+		rf_update_size(mapPtr, delta);
 	}
 	RF_Free(p, sizeof(*p));
 }
-/*-----------------------------------------------------------------------------
+
+
+/*****************************************************************************
  *
- * Free an entire status structure.  Inefficient, but can be called at any time.
+ * Free an entire status structure. Inefficient, but can be called at any
+ * time.
  *
- *-----------------------------------------------------------------------------*/
-void 
-rf_FreeReconMap(mapPtr)
-	RF_ReconMap_t *mapPtr;
+ *****************************************************************************/
+
+void
+rf_FreeReconMap(RF_ReconMap_t *mapPtr)
 {
 	RF_ReconMapListElem_t *p, *q;
 	RF_ReconUnitCount_t numRUs;
@@ -296,21 +306,22 @@ rf_FreeReconMap(mapPtr)
 		}
 	}
 	rf_mutex_destroy(&mapPtr->mutex);
-	RF_Free(mapPtr->status, mapPtr->totalRUs * sizeof(RF_ReconMapListElem_t *));
+	RF_Free(mapPtr->status, mapPtr->totalRUs *
+	    sizeof(RF_ReconMapListElem_t *));
 	RF_Free(mapPtr, sizeof(RF_ReconMap_t));
 }
-/*-----------------------------------------------------------------------------
+
+
+/*****************************************************************************
  *
- * returns nonzero if the indicated RU has been reconstructed already
+ * Returns nonzero if the indicated RU has been reconstructed already.
  *
- *---------------------------------------------------------------------------*/
+ *****************************************************************************/
 
-int 
-rf_CheckRUReconstructed(mapPtr, startSector)
-	RF_ReconMap_t *mapPtr;
-	RF_SectorNum_t startSector;
+int
+rf_CheckRUReconstructed(RF_ReconMap_t *mapPtr, RF_SectorNum_t startSector)
 {
-	RF_ReconMapListElem_t *l;	/* used for searching */
+	RF_ReconMapListElem_t *l;	/* Used for searching. */
 	RF_ReconUnitNum_t i;
 
 	i = startSector / mapPtr->sectorsPerReconUnit;
@@ -318,40 +329,35 @@ rf_CheckRUReconstructed(mapPtr, startSector)
 	return ((l == RU_ALL) ? 1 : 0);
 }
 
-RF_ReconUnitCount_t 
-rf_UnitsLeftToReconstruct(mapPtr)
-	RF_ReconMap_t *mapPtr;
+RF_ReconUnitCount_t
+rf_UnitsLeftToReconstruct(RF_ReconMap_t *mapPtr)
 {
 	RF_ASSERT(mapPtr != NULL);
 	return (mapPtr->unitsLeft);
 }
-/* updates the size fields of a status descriptor */
-static void 
-update_size(mapPtr, size)
-	RF_ReconMap_t *mapPtr;
-	int     size;
+
+/* Updates the size fields of a status descriptor. */
+void
+rf_update_size(RF_ReconMap_t *mapPtr, int size)
 {
 	mapPtr->size += size;
 	mapPtr->maxSize = RF_MAX(mapPtr->size, mapPtr->maxSize);
 }
 
-static void 
-PrintList(listPtr)
-	RF_ReconMapListElem_t *listPtr;
+void
+rf_PrintList(RF_ReconMapListElem_t *listPtr)
 {
 	while (listPtr) {
-		printf("%d,%d -> ", (int) listPtr->startSector, (int) listPtr->stopSector);
+		printf("%d,%d -> ", (int) listPtr->startSector,
+		    (int) listPtr->stopSector);
 		listPtr = listPtr->next;
 	}
 	printf("\n");
 }
 
-void 
-rf_PrintReconMap(raidPtr, mapPtr, frow, fcol)
-	RF_Raid_t *raidPtr;
-	RF_ReconMap_t *mapPtr;
-	RF_RowCol_t frow;
-	RF_RowCol_t fcol;
+void
+rf_PrintReconMap(RF_Raid_t *raidPtr, RF_ReconMap_t *mapPtr, RF_RowCol_t frow,
+    RF_RowCol_t fcol)
 {
 	RF_ReconUnitCount_t numRUs;
 	RF_ReconMapListElem_t *p;
@@ -363,32 +369,32 @@ rf_PrintReconMap(raidPtr, mapPtr, frow, fcol)
 
 	for (i = 0; i < numRUs; i++) {
 		p = mapPtr->status[i];
-		if (p == RU_ALL)/* printf("[%d] ALL\n",i) */
-			;
+		if (p == RU_ALL)
+			/* printf("[%d] ALL.\n", i) */;
 		else
 			if (p == RU_NOTHING) {
-				printf("%d: Unreconstructed\n", i);
+				printf("%d: Unreconstructed.\n", i);
 			} else {
 				printf("%d: ", i);
-				PrintList(p);
+				rf_PrintList(p);
 			}
 	}
 }
 
-void 
-rf_PrintReconSchedule(mapPtr, starttime)
-	RF_ReconMap_t *mapPtr;
-	struct timeval *starttime;
+void
+rf_PrintReconSchedule(RF_ReconMap_t *mapPtr, struct timeval *starttime)
 {
 	static int old_pctg = -1;
 	struct timeval tv, diff;
-	int     new_pctg;
+	int new_pctg;
 
-	new_pctg = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
+	new_pctg = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 /
+	    mapPtr->totalRUs);
 	if (new_pctg != old_pctg) {
 		RF_GETTIME(tv);
 		RF_TIMEVAL_DIFF(starttime, &tv, &diff);
-		printf("%d %d.%06d\n", (int) new_pctg, (int) diff.tv_sec, (int) diff.tv_usec);
+		printf("%d %d.%06d\n", (int) new_pctg, (int) diff.tv_sec,
+		    (int) diff.tv_usec);
 		old_pctg = new_pctg;
 	}
 }
diff --git a/sys/dev/raidframe/rf_reconmap.h b/sys/dev/raidframe/rf_reconmap.h
index 476acab9cb2..9910e4cc94e 100644
--- a/sys/dev/raidframe/rf_reconmap.h
+++ b/sys/dev/raidframe/rf_reconmap.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconmap.h,v 1.2 1999/02/16 00:03:21 niklas Exp $	*/
+/*	$OpenBSD: rf_reconmap.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconmap.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,59 +29,73 @@
  */
 
 /******************************************************************************
- * rf_reconMap.h -- Header file describing reconstruction status data structure
+ * rf_reconMap.h
+ *
+ * -- Header file describing reconstruction status data structure.
  ******************************************************************************/
 
-#ifndef _RF__RF_RECONMAP_H_
-#define _RF__RF_RECONMAP_H_
+#ifndef	_RF__RF_RECONMAP_H_
+#define	_RF__RF_RECONMAP_H_
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
 
 /*
- * Main reconstruction status descriptor. size and maxsize are used for
- * monitoring only:  they have no function for reconstruction.
+ * Main reconstruction status descriptor; size and maxsize are used for
+ * monitoring only: they have no function for reconstruction.
  */
 struct RF_ReconMap_s {
-	RF_SectorCount_t sectorsPerReconUnit;	/* sectors per reconstruct
-						 * unit */
-	RF_SectorCount_t sectorsInDisk;	/* total sectors in disk */
-	RF_SectorCount_t unitsLeft;	/* recon units left to recon */
-	RF_ReconUnitCount_t totalRUs;	/* total recon units on disk */
-	RF_ReconUnitCount_t spareRUs;	/* total number of spare RUs on failed
-					 * disk */
-	RF_StripeCount_t totalParityStripes;	/* total number of parity
-						 * stripes in array */
-	u_int   size;		/* overall size of this structure */
-	u_int   maxSize;	/* maximum size so far */
-	RF_ReconMapListElem_t **status;	/* array of ptrs to list elements */
-	        RF_DECLARE_MUTEX(mutex)
+	RF_SectorCount_t	  sectorsPerReconUnit;
+						/*
+						 * Sectors per reconstruct
+						 * unit.
+						 */
+	RF_SectorCount_t	  sectorsInDisk;/* Total sectors in disk. */
+	RF_SectorCount_t	  unitsLeft;	/* Recon units left to recon. */
+	RF_ReconUnitCount_t	  totalRUs;	/* Total recon units on disk. */
+	RF_ReconUnitCount_t	  spareRUs;	/*
+						 * Total number of spare RUs on
+						 * failed disk.
+						 */
+	RF_StripeCount_t	  totalParityStripes;
+						/*
+						 * Total number of parity
+						 * stripes in array.
+						 */
+	u_int			  size;		/*
+						 * Overall size of this
+						 * structure.
+						 */
+	u_int			  maxSize;	/* Maximum size so far. */
+	RF_ReconMapListElem_t	**status;	/*
+						 * Array of ptrs to list
+						 * elements.
+						 */
+	RF_DECLARE_MUTEX	 (mutex);
 };
-/* a list element */
+
+/* A list element. */
 struct RF_ReconMapListElem_s {
-	RF_SectorNum_t startSector;	/* bounding sect nums on this block */
-	RF_SectorNum_t stopSector;
-	RF_ReconMapListElem_t *next;	/* next element in list */
+	/* Bounding sect nums on this block. */
+	RF_SectorNum_t		 startSector;
+	RF_SectorNum_t		 stopSector;
+	RF_ReconMapListElem_t	*next;		/* Next element in list. */
 };
 
-RF_ReconMap_t *
-rf_MakeReconMap(RF_Raid_t * raidPtr, RF_SectorCount_t ru_sectors,
-    RF_SectorCount_t disk_sectors, RF_ReconUnitCount_t spareUnitsPerDisk);
+RF_ReconMap_t *rf_MakeReconMap(RF_Raid_t *,
+	RF_SectorCount_t, RF_SectorCount_t, RF_ReconUnitCount_t);
 
-void 
-rf_ReconMapUpdate(RF_Raid_t * raidPtr, RF_ReconMap_t * mapPtr,
-    RF_SectorNum_t startSector, RF_SectorNum_t stopSector);
+void rf_ReconMapUpdate(RF_Raid_t *, RF_ReconMap_t *,
+	RF_SectorNum_t, RF_SectorNum_t);
 
-void    rf_FreeReconMap(RF_ReconMap_t * mapPtr);
+void rf_FreeReconMap(RF_ReconMap_t *);
 
-int     rf_CheckRUReconstructed(RF_ReconMap_t * mapPtr, RF_SectorNum_t startSector);
+int  rf_CheckRUReconstructed(RF_ReconMap_t *, RF_SectorNum_t);
 
-RF_ReconUnitCount_t rf_UnitsLeftToReconstruct(RF_ReconMap_t * mapPtr);
+RF_ReconUnitCount_t rf_UnitsLeftToReconstruct(RF_ReconMap_t *);
 
-void 
-rf_PrintReconMap(RF_Raid_t * raidPtr, RF_ReconMap_t * mapPtr,
-    RF_RowCol_t frow, RF_RowCol_t fcol);
+void rf_PrintReconMap(RF_Raid_t *, RF_ReconMap_t *, RF_RowCol_t, RF_RowCol_t);
 
-void    rf_PrintReconSchedule(RF_ReconMap_t * mapPtr, struct timeval * starttime);
+void rf_PrintReconSchedule(RF_ReconMap_t *, struct timeval *);
 
-#endif				/* !_RF__RF_RECONMAP_H_ */
+#endif	/* !_RF__RF_RECONMAP_H_ */
diff --git a/sys/dev/raidframe/rf_reconstruct.c b/sys/dev/raidframe/rf_reconstruct.c
index 90a6435e1df..6d9ac0a05ca 100644
--- a/sys/dev/raidframe/rf_reconstruct.c
+++ b/sys/dev/raidframe/rf_reconstruct.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconstruct.c,v 1.12 2002/08/09 15:10:20 tdeval Exp $	*/
+/*	$OpenBSD: rf_reconstruct.c,v 1.13 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconstruct.c,v 1.26 2000/06/04 02:05:13 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/************************************************************
+/**************************************************************
  *
- * rf_reconstruct.c -- code to perform on-line reconstruction
+ * rf_reconstruct.c -- Code to perform on-line reconstruction.
  *
- ************************************************************/
+ **************************************************************/
 
 #include "rf_types.h"
 #include <sys/time.h>
@@ -44,7 +45,7 @@
 #include <sys/proc.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
-#if __NETBSD__
+#if	__NETBSD__
 #include <sys/vnode.h>
 #endif
 
@@ -65,57 +66,148 @@
 
 #include "rf_kintf.h"
 
-/* setting these to -1 causes them to be set to their default values if not set by debug options */
-
-#define Dprintf(s)         if (rf_reconDebug) rf_debug_printf(s,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf1(s,a)         if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf2(s,a,b)       if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf3(s,a,b,c)     if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
-#define Dprintf4(s,a,b,c,d)   if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),NULL,NULL,NULL,NULL)
-#define Dprintf5(s,a,b,c,d,e) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),NULL,NULL,NULL)
-#define Dprintf6(s,a,b,c,d,e,f) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),NULL,NULL)
-#define Dprintf7(s,a,b,c,d,e,f,g) if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),(void *)((unsigned long)g),NULL)
+/*
+ * Setting these to -1 causes them to be set to their default values if not set
+ * by debug options.
+ */
 
-#define DDprintf1(s,a)         if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define DDprintf2(s,a,b)       if (rf_reconDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
+#define	Dprintf(s)							\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);	\
+} while (0)
+#define	Dprintf1(s,a)							\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    NULL, NULL, NULL, NULL, NULL, NULL, NULL);		\
+} while (0)
+#define	Dprintf2(s,a,b)							\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    NULL, NULL, NULL, NULL, NULL, NULL);		\
+} while (0)
+#define	Dprintf3(s,a,b,c)						\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    NULL, NULL, NULL, NULL, NULL);			\
+} while (0)
+#define	Dprintf4(s,a,b,c,d)						\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    (void *)((unsigned long)d),				\
+		    NULL, NULL, NULL, NULL);				\
+} while (0)
+#define	Dprintf5(s,a,b,c,d,e)						\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    (void *)((unsigned long)d),				\
+		    (void *)((unsigned long)e),				\
+		    NULL, NULL, NULL);					\
+} while (0)
+#define	Dprintf6(s,a,b,c,d,e,f)						\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    (void *)((unsigned long)d),				\
+		    (void *)((unsigned long)e),				\
+		    (void *)((unsigned long)f),				\
+		    NULL, NULL);					\
+} while (0)
+#define	Dprintf7(s,a,b,c,d,e,f,g)					\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    (void *)((unsigned long)c),				\
+		    (void *)((unsigned long)d),				\
+		    (void *)((unsigned long)e),				\
+		    (void *)((unsigned long)f),				\
+		    (void *)((unsigned long)g),				\
+		    NULL);						\
+} while (0)
+
+#define	DDprintf1(s,a)							\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    NULL, NULL, NULL, NULL, NULL, NULL, NULL);		\
+} while (0)
+#define	DDprintf2(s,a,b)						\
+do {									\
+	if (rf_reconDebug)						\
+		rf_debug_printf(s,					\
+		    (void *)((unsigned long)a),				\
+		    (void *)((unsigned long)b),				\
+		    NULL, NULL, NULL, NULL, NULL, NULL);		\
+} while (0)
 
 static RF_FreeList_t *rf_recond_freelist;
-#define RF_MAX_FREE_RECOND  4
-#define RF_RECOND_INC       1
-
-RF_RaidReconDesc_t *rf_AllocRaidReconDesc(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t, RF_RaidDisk_t *, int, RF_RowCol_t, RF_RowCol_t);
-int rf_ProcessReconEvent(RF_Raid_t *, RF_RowCol_t, RF_ReconEvent_t *);
-int rf_IssueNextReadRequest(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
-int rf_TryToRead(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
-int rf_ComputePSDiskOffsets(RF_Raid_t *, RF_StripeNum_t, RF_RowCol_t, RF_RowCol_t, RF_SectorNum_t *, RF_SectorNum_t *, RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *);
-int rf_ReconReadDoneProc(void *, int);
-int rf_ReconWriteDoneProc(void *, int);
+#define	RF_MAX_FREE_RECOND	4
+#define	RF_RECOND_INC		1
+
+RF_RaidReconDesc_t *rf_AllocRaidReconDesc(RF_Raid_t *,
+	RF_RowCol_t, RF_RowCol_t, RF_RaidDisk_t *, int,
+	RF_RowCol_t, RF_RowCol_t);
+int  rf_ProcessReconEvent(RF_Raid_t *, RF_RowCol_t, RF_ReconEvent_t *);
+int  rf_IssueNextReadRequest(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+int  rf_TryToRead(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+int  rf_ComputePSDiskOffsets(RF_Raid_t *, RF_StripeNum_t,
+	RF_RowCol_t, RF_RowCol_t, RF_SectorNum_t *, RF_SectorNum_t *,
+	RF_RowCol_t *, RF_RowCol_t *, RF_SectorNum_t *);
+int  rf_ReconReadDoneProc(void *, int);
+int  rf_ReconWriteDoneProc(void *, int);
 void rf_CheckForNewMinHeadSep(RF_Raid_t *, RF_RowCol_t, RF_HeadSepLimit_t);
-int rf_CheckHeadSeparation(RF_Raid_t *, RF_PerDiskReconCtrl_t *, RF_RowCol_t, RF_RowCol_t, RF_HeadSepLimit_t, RF_ReconUnitNum_t);
+int  rf_CheckHeadSeparation(RF_Raid_t *, RF_PerDiskReconCtrl_t *,
+	RF_RowCol_t, RF_RowCol_t, RF_HeadSepLimit_t, RF_ReconUnitNum_t);
 void rf_ForceReconReadDoneProc(void *, int);
 void rf_ShutdownReconstruction(void *);
 
 /*
- * these functions are inlined on gcc. If they are used more than
- * once, it is strongly advised to un-line them
+ * These functions are inlined on gcc. If they are used more than
+ * once, it is strongly advised to un-line them.
  */
 void rf_FreeReconDesc(RF_RaidReconDesc_t *);
-int rf_IssueNextWriteRequest(RF_Raid_t *, RF_RowCol_t);
-int rf_CheckForcedOrBlockedReconstruction(RF_Raid_t *, RF_ReconParityStripeStatus_t *, RF_PerDiskReconCtrl_t *, RF_RowCol_t, RF_RowCol_t, RF_StripeNum_t, RF_ReconUnitNum_t);
+int  rf_IssueNextWriteRequest(RF_Raid_t *, RF_RowCol_t);
+int  rf_CheckForcedOrBlockedReconstruction(RF_Raid_t *,
+	RF_ReconParityStripeStatus_t *, RF_PerDiskReconCtrl_t *,
+	RF_RowCol_t, RF_RowCol_t, RF_StripeNum_t, RF_ReconUnitNum_t);
 void rf_SignalReconDone(RF_Raid_t *);
 
 struct RF_ReconDoneProc_s {
-	void    (*proc) (RF_Raid_t *, void *);
-	void   *arg;
-	RF_ReconDoneProc_t *next;
+	void			(*proc) (RF_Raid_t *, void *);
+	void			 *arg;
+	RF_ReconDoneProc_t	 *next;
 };
 
 static RF_FreeList_t *rf_rdp_freelist;
-#define RF_MAX_FREE_RDP 4
-#define RF_RDP_INC      1
+#define	RF_MAX_FREE_RDP		4
+#define	RF_RDP_INC		1
 
-void 
-rf_SignalReconDone(RF_Raid_t * raidPtr)
+void
+rf_SignalReconDone(RF_Raid_t *raidPtr)
 {
 	RF_ReconDoneProc_t *p;
 
@@ -126,12 +218,9 @@ rf_SignalReconDone(RF_Raid_t * raidPtr)
 	RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex);
 }
 
-int 
-rf_RegisterReconDoneProc(
-    RF_Raid_t * raidPtr,
-    void (*proc) (RF_Raid_t *, void *),
-    void *arg,
-    RF_ReconDoneProc_t ** handlep)
+int
+rf_RegisterReconDoneProc(RF_Raid_t *raidPtr, void (*proc) (RF_Raid_t *, void *),
+    void *arg, RF_ReconDoneProc_t **handlep)
 {
 	RF_ReconDoneProc_t *p;
 
@@ -148,28 +237,27 @@ rf_RegisterReconDoneProc(
 		*handlep = p;
 	return (0);
 }
-/**************************************************************************
+
+/*****************************************************************************
  *
- * sets up the parameters that will be used by the reconstruction process
- * currently there are none, except for those that the layout-specific
+ * Sets up the parameters that will be used by the reconstruction process.
+ * Currently there are none, except for those that the layout-specific
  * configuration (e.g. rf_ConfigureDeclustered) routine sets up.
  *
- * in the kernel, we fire off the recon thread.
+ * In the kernel, we fire off the recon thread.
  *
- **************************************************************************/
-void 
-rf_ShutdownReconstruction(ignored)
-	void   *ignored;
+ *****************************************************************************/
+void
+rf_ShutdownReconstruction(void *ignored)
 {
 	RF_FREELIST_DESTROY(rf_recond_freelist, next, (RF_RaidReconDesc_t *));
 	RF_FREELIST_DESTROY(rf_rdp_freelist, next, (RF_ReconDoneProc_t *));
 }
 
-int 
-rf_ConfigureReconstruction(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureReconstruction(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_recond_freelist, RF_MAX_FREE_RECOND,
 	    RF_RECOND_INC, sizeof(RF_RaidReconDesc_t));
@@ -178,13 +266,14 @@ rf_ConfigureReconstruction(listp)
 	RF_FREELIST_CREATE(rf_rdp_freelist, RF_MAX_FREE_RDP,
 	    RF_RDP_INC, sizeof(RF_ReconDoneProc_t));
 	if (rf_rdp_freelist == NULL) {
-		RF_FREELIST_DESTROY(rf_recond_freelist, next, (RF_RaidReconDesc_t *));
+		RF_FREELIST_DESTROY(rf_recond_freelist, next,
+		    (RF_RaidReconDesc_t *));
 		return (ENOMEM);
 	}
 	rc = rf_ShutdownCreate(listp, rf_ShutdownReconstruction, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		rf_ShutdownReconstruction(NULL);
 		return (rc);
 	}
@@ -192,19 +281,15 @@ rf_ConfigureReconstruction(listp)
 }
 
 RF_RaidReconDesc_t *
-rf_AllocRaidReconDesc(raidPtr, row, col, spareDiskPtr, numDisksDone, srow, scol)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
-	RF_RaidDisk_t *spareDiskPtr;
-	int     numDisksDone;
-	RF_RowCol_t srow;
-	RF_RowCol_t scol;
+rf_AllocRaidReconDesc(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
+    RF_RaidDisk_t *spareDiskPtr, int numDisksDone, RF_RowCol_t srow,
+    RF_RowCol_t scol)
 {
 
 	RF_RaidReconDesc_t *reconDesc;
 
-	RF_FREELIST_GET(rf_recond_freelist, reconDesc, next, (RF_RaidReconDesc_t *));
+	RF_FREELIST_GET(rf_recond_freelist, reconDesc, next,
+	    (RF_RaidReconDesc_t *));
 
 	reconDesc->raidPtr = raidPtr;
 	reconDesc->row = row;
@@ -219,46 +304,43 @@ rf_AllocRaidReconDesc(raidPtr, row, col, spareDiskPtr, numDisksDone, srow, scol)
 	return (reconDesc);
 }
 
-void 
-rf_FreeReconDesc(reconDesc)
-	RF_RaidReconDesc_t *reconDesc;
+void
+rf_FreeReconDesc(RF_RaidReconDesc_t *reconDesc)
 {
-#if RF_RECON_STATS > 0
-	printf("RAIDframe: %qu recon event waits, %qu recon delays\n",
+#if	RF_RECON_STATS > 0
+	printf("RAIDframe: %qu recon event waits, %qu recon delays.\n",
 	    reconDesc->numReconEventWaits, reconDesc->numReconExecDelays);
-#endif /* RF_RECON_STATS > 0 */
+#endif	/* RF_RECON_STATS > 0 */
 
-	printf("RAIDframe: %qu max exec ticks\n", reconDesc->maxReconExecTicks);
+	printf("RAIDframe: %qu max exec ticks.\n",
+	    reconDesc->maxReconExecTicks);
 
-#if (RF_RECON_STATS > 0) || defined(_KERNEL)
+#if	(RF_RECON_STATS > 0) || defined(_KERNEL)
 	printf("\n");
-#endif /* (RF_RECON_STATS > 0) || _KERNEL */
+#endif	/* (RF_RECON_STATS > 0) || _KERNEL */
 	RF_FREELIST_FREE(rf_recond_freelist, reconDesc, next);
 }
 
 
-/***********************************************************************
+/*****************************************************************************
  *
- * primary routine to reconstruct a failed disk.  This should be called from
- * within its own thread.  It won't return until reconstruction completes,
+ * Primary routine to reconstruct a failed disk. This should be called from
+ * within its own thread. It won't return until reconstruction completes,
  * fails, or is aborted.
  *
- ***********************************************************************/
-int 
-rf_ReconstructFailedDisk(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
+ *****************************************************************************/
+int
+rf_ReconstructFailedDisk(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
 {
 	RF_LayoutSW_t *lp;
-	int     rc;
+	int rc;
 
 	lp = raidPtr->Layout.map;
 	if (lp->SubmitReconBuffer) {
 		/*
-	         * The current infrastructure only supports reconstructing one
-	         * disk at a time for each array.
-	         */
+		 * The current infrastructure only supports reconstructing one
+		 * disk at a time for each array.
+		 */
 		RF_LOCK_MUTEX(raidPtr->mutex);
 		while (raidPtr->reconInProgress) {
 			RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex);
@@ -270,38 +352,41 @@ rf_ReconstructFailedDisk(raidPtr, row, col)
 		raidPtr->reconInProgress--;
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
 	} else {
-		RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n",
-		    lp->parityConfig);
+		RF_ERRORMSG1("RECON: no way to reconstruct failed disk for"
+		    " arch %c.\n", lp->parityConfig);
 		rc = EIO;
 	}
 	RF_SIGNAL_COND(raidPtr->waitForReconCond);
-	wakeup(&raidPtr->waitForReconCond);	/* XXX Methinks this will be
-						 * needed at some point... GO */
+	wakeup(&raidPtr->waitForReconCond);	/*
+						 * XXX Methinks this will be
+						 * needed at some point... GO
+						 */
 	return (rc);
 }
 
-int 
-rf_ReconstructFailedDiskBasic(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
+int
+rf_ReconstructFailedDiskBasic(RF_Raid_t *raidPtr, RF_RowCol_t row,
+    RF_RowCol_t col)
 {
 	RF_ComponentLabel_t c_label;
 	RF_RaidDisk_t *spareDiskPtr = NULL;
 	RF_RaidReconDesc_t *reconDesc;
 	RF_RowCol_t srow, scol;
-	int     numDisksDone = 0, rc;
+	int numDisksDone = 0, rc;
 
-	/* first look for a spare drive onto which to reconstruct the data */
-	/* spare disk descriptors are stored in row 0.  This may have to
-	 * change eventually */
+	/* First look for a spare drive onto which to reconstruct the data. */
+	/*
+	 * Spare disk descriptors are stored in row 0. This may have to
+	 * change eventually.
+	 */
 
 	RF_LOCK_MUTEX(raidPtr->mutex);
 	RF_ASSERT(raidPtr->Disks[row][col].status == rf_ds_failed);
 
 	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
 		if (raidPtr->status[row] != rf_rs_degraded) {
-			RF_ERRORMSG2("Unable to reconstruct disk at row %d col %d because status not degraded\n", row, col);
+			RF_ERRORMSG2("Unable to reconstruct disk at row %d"
+			    " col %d because status not degraded.\n", row, col);
 			RF_UNLOCK_MUTEX(raidPtr->mutex);
 			return (EINVAL);
 		}
@@ -309,7 +394,8 @@ rf_ReconstructFailedDiskBasic(raidPtr, row, col)
 		scol = (-1);
 	} else {
 		srow = 0;
-		for (scol = raidPtr->numCol; scol < raidPtr->numCol + raidPtr->numSpare; scol++) {
+		for (scol = raidPtr->numCol;
+		     scol < raidPtr->numCol + raidPtr->numSpare; scol++) {
 			if (raidPtr->Disks[srow][scol].status == rf_ds_spare) {
 				spareDiskPtr = &raidPtr->Disks[srow][scol];
 				spareDiskPtr->status = rf_ds_used_spare;
@@ -317,73 +403,74 @@ rf_ReconstructFailedDiskBasic(raidPtr, row, col)
 			}
 		}
 		if (!spareDiskPtr) {
-			RF_ERRORMSG2("Unable to reconstruct disk at row %d col %d because no spares are available\n", row, col);
+			RF_ERRORMSG2("Unable to reconstruct disk at row %d"
+			    " col %d because no spares are available.\n",
+			    row, col);
 			RF_UNLOCK_MUTEX(raidPtr->mutex);
 			return (ENOSPC);
 		}
-		printf("RECON: initiating reconstruction on row %d col %d -> spare at row %d col %d\n", row, col, srow, scol);
+		printf("RECON: initiating reconstruction on row %d col %d"
+		    " -> spare at row %d col %d.\n", row, col, srow, scol);
 	}
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
 
-	reconDesc = rf_AllocRaidReconDesc((void *) raidPtr, row, col, spareDiskPtr, numDisksDone, srow, scol);
+	reconDesc = rf_AllocRaidReconDesc((void *) raidPtr, row, col,
+	    spareDiskPtr, numDisksDone, srow, scol);
 	raidPtr->reconDesc = (void *) reconDesc;
-#if RF_RECON_STATS > 0
+#if	RF_RECON_STATS > 0
 	reconDesc->hsStallCount = 0;
 	reconDesc->numReconExecDelays = 0;
 	reconDesc->numReconEventWaits = 0;
-#endif				/* RF_RECON_STATS > 0 */
+#endif	/* RF_RECON_STATS > 0 */
 	reconDesc->reconExecTimerRunning = 0;
 	reconDesc->reconExecTicks = 0;
 	reconDesc->maxReconExecTicks = 0;
 	rc = rf_ContinueReconstructFailedDisk(reconDesc);
 
 	if (!rc) {
-		/* fix up the component label */
-		/* Don't actually need the read here.. */
+		/* Fix up the component label. */
+		/* Don't actually need the read here... */
 		raidread_component_label(
-                        raidPtr->raid_cinfo[srow][scol].ci_dev,
-			raidPtr->raid_cinfo[srow][scol].ci_vp,
-			&c_label);
-		
-		raid_init_component_label( raidPtr, &c_label);
+		    raidPtr->raid_cinfo[srow][scol].ci_dev,
+		    raidPtr->raid_cinfo[srow][scol].ci_vp,
+		    &c_label);
+
+		raid_init_component_label(raidPtr, &c_label);
 		c_label.row = row;
 		c_label.column = col;
 		c_label.clean = RF_RAID_DIRTY;
 		c_label.status = rf_ds_optimal;
 
-		/* XXXX MORE NEEDED HERE */
-		
+		/* XXXX MORE NEEDED HERE. */
+
 		raidwrite_component_label(
-                        raidPtr->raid_cinfo[srow][scol].ci_dev,
-			raidPtr->raid_cinfo[srow][scol].ci_vp,
-			&c_label);
-		
+		    raidPtr->raid_cinfo[srow][scol].ci_dev,
+		    raidPtr->raid_cinfo[srow][scol].ci_vp,
+		    &c_label);
+
 	}
 	return (rc);
 }
 
-/* 
-
-   Allow reconstructing a disk in-place -- i.e. component /dev/sd2e goes AWOL,
-   and you don't get a spare until the next Monday.  With this function 
-   (and hot-swappable drives) you can now put your new disk containing 
-   /dev/sd2e on the bus, scsictl it alive, and then use raidctl(8) to
-   rebuild the data "on the spot".
-
-*/
+/*
+ *
+ * Allow reconstructing a disk in-place -- i.e. component /dev/sd2e goes AWOL,
+ * and you don't get a spare until the next Monday. With this function
+ * (and hot-swappable drives) you can now put your new disk containing
+ * /dev/sd2e on the bus, scsictl it alive, and then use raidctl(8) to
+ * rebuild the data "on the spot".
+ *
+ */
 
 int
-rf_ReconstructInPlace(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
+rf_ReconstructInPlace(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
 {
 	RF_RaidDisk_t *spareDiskPtr = NULL;
 	RF_RaidReconDesc_t *reconDesc;
 	RF_LayoutSW_t *lp;
 	RF_RaidDisk_t *badDisk;
 	RF_ComponentLabel_t c_label;
-	int     numDisksDone = 0, rc;
+	int numDisksDone = 0, rc;
 	struct partinfo dpart;
 	struct vnode *vp;
 	struct vattr va;
@@ -394,28 +481,31 @@ rf_ReconstructInPlace(raidPtr, row, col)
 	lp = raidPtr->Layout.map;
 	if (lp->SubmitReconBuffer) {
 		/*
-	         * The current infrastructure only supports reconstructing one
-	         * disk at a time for each array.
-	         */
+		 * The current infrastructure only supports reconstructing one
+		 * disk at a time for each array.
+		 */
 		RF_LOCK_MUTEX(raidPtr->mutex);
 		if ((raidPtr->Disks[row][col].status == rf_ds_optimal) &&
-		    (raidPtr->numFailures > 0)) { 
-			/* XXX 0 above shouldn't be constant!!! */
-			/* some component other than this has failed.
-			   Let's not make things worse than they already
-			   are... */
+		    (raidPtr->numFailures > 0)) {
+			/* XXX 0 above shouldn't be constant !!! */
+			/*
+			 * Some component other than this has failed.
+			 * Let's not make things worse than they already
+			 * are...
+			 */
 #ifdef	RAIDDEBUG
-			printf("RAIDFRAME: Unable to reconstruct to disk at:\n");
-			printf("      Row: %d Col: %d   Too many failures.\n",
-			       row, col);
+			printf("RAIDFRAME: Unable to reconstruct to disk at:\n"
+			    "      Row: %d Col: %d   Too many failures.\n",
+			    row, col);
 #endif	/* RAIDDEBUG */
 			RF_UNLOCK_MUTEX(raidPtr->mutex);
 			return (EINVAL);
 		}
 		if (raidPtr->Disks[row][col].status == rf_ds_reconstructing) {
 #ifdef	RAIDDEBUG
-			printf("RAIDFRAME: Unable to reconstruct to disk at:\n");
-			printf("      Row: %d Col: %d   Reconstruction already occuring!\n", row, col);
+			printf("RAIDFRAME: Unable to reconstruct to disk at:\n"
+			    "      Row: %d Col: %d   Reconstruction already"
+			    " occuring !\n", row, col);
 #endif	/* RAIDDEBUG */
 
 			RF_UNLOCK_MUTEX(raidPtr->mutex);
@@ -428,8 +518,8 @@ rf_ReconstructInPlace(raidPtr, row, col)
 			raidPtr->numFailures++;
 			raidPtr->Disks[row][col].status = rf_ds_failed;
 			raidPtr->status[row] = rf_rs_degraded;
-			rf_update_component_labels(raidPtr, 
-						   RF_NORMAL_COMPONENT_UPDATE);
+			rf_update_component_labels(raidPtr,
+			    RF_NORMAL_COMPONENT_UPDATE);
 		}
 
 		while (raidPtr->reconInProgress) {
@@ -438,123 +528,135 @@ rf_ReconstructInPlace(raidPtr, row, col)
 
 		raidPtr->reconInProgress++;
 
+		/*
+		 * First look for a spare drive onto which to reconstruct
+		 * the data. Spare disk descriptors are stored in row 0.
+		 * This may have to change eventually.
+		 */
 
-		/* first look for a spare drive onto which to reconstruct 
-		   the data.  spare disk descriptors are stored in row 0. 
-		   This may have to change eventually */
-
-		/* Actually, we don't care if it's failed or not... 
-		   On a RAID set with correct parity, this function
-		   should be callable on any component without ill affects. */
-		/* RF_ASSERT(raidPtr->Disks[row][col].status == rf_ds_failed);
+		/*
+		 * Actually, we don't care if it's failed or not...
+		 * On a RAID set with correct parity, this function
+		 * should be callable on any component without ill effects.
+		 */
+		/*
+		 * RF_ASSERT(raidPtr->Disks[row][col].status == rf_ds_failed);
 		 */
 
 		if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
-			RF_ERRORMSG2("Unable to reconstruct to disk at row %d col %d: operation not supported for RF_DISTRIBUTE_SPARE\n", row, col);
+			RF_ERRORMSG2("Unable to reconstruct to disk at row %d"
+			    " col %d: operation not supported for"
+			    " RF_DISTRIBUTE_SPARE.\n", row, col);
 
 			raidPtr->reconInProgress--;
 			RF_UNLOCK_MUTEX(raidPtr->mutex);
 			return (EINVAL);
-		}			
-
-		/* XXX need goop here to see if the disk is alive,
-		   and, if not, make it so...  */
-		
+		}
 
+		/*
+		 * XXX Need goop here to see if the disk is alive,
+		 * and, if not, make it so...
+		 */
 
 		badDisk = &raidPtr->Disks[row][col];
 
 		proc = raidPtr->recon_thread;
 
-		/* This device may have been opened successfully the 
-		   first time. Close it before trying to open it again.. */
+		/*
+		 * This device may have been opened successfully the
+		 * first time. Close it before trying to open it again...
+		 */
 
 		if (raidPtr->raid_cinfo[row][col].ci_vp != NULL) {
 			printf("Closing the open device: %s\n",
-			       raidPtr->Disks[row][col].devname);
+			    raidPtr->Disks[row][col].devname);
 			vp = raidPtr->raid_cinfo[row][col].ci_vp;
 			ac = raidPtr->Disks[row][col].auto_configured;
 			rf_close_component(raidPtr, vp, ac);
 			raidPtr->raid_cinfo[row][col].ci_vp = NULL;
 		}
-		/* note that this disk was *not* auto_configured (any longer)*/
+		/*
+		 * Note that this disk was *not* auto_configured (any longer).
+		 */
 		raidPtr->Disks[row][col].auto_configured = 0;
 
 		printf("About to (re-)open the device for rebuilding: %s\n",
-		       raidPtr->Disks[row][col].devname);
-		
-		retcode = raidlookup(raidPtr->Disks[row][col].devname, 
-				     proc, &vp);
-	
-		if (retcode) {
-			printf("raid%d: rebuilding: raidlookup on device: %s failed: %d!\n",
-			       raidPtr->raidid,
-			       raidPtr->Disks[row][col].devname, retcode);
+		    raidPtr->Disks[row][col].devname);
 
-			/* XXX the component isn't responding properly... 
-			   must be still dead :-( */
+		retcode = raidlookup(raidPtr->Disks[row][col].devname,
+		    proc, &vp);
+
+		if (retcode) {
+			printf("raid%d: rebuilding: raidlookup on device: %s"
+			    " failed: %d !\n", raidPtr->raidid,
+			    raidPtr->Disks[row][col].devname, retcode);
+
+			/*
+			 * XXX the component isn't responding properly...
+			 * Must still be dead :-(
+			 */
 			raidPtr->reconInProgress--;
 			RF_UNLOCK_MUTEX(raidPtr->mutex);
 			return(retcode);
 
 		} else {
 
-			/* Ok, so we can at least do a lookup... 
-			   How about actually getting a vp for it? */
+			/*
+			 * Ok, so we can at least do a lookup...
+			 * How about actually getting a vp for it ?
+			 */
 
-			if ((retcode = VOP_GETATTR(vp, &va, proc->p_ucred, 
-						   proc)) != 0) {
+			if ((retcode =
+			     VOP_GETATTR(vp, &va, proc->p_ucred, proc)) != 0) {
 				raidPtr->reconInProgress--;
 				RF_UNLOCK_MUTEX(raidPtr->mutex);
 				return(retcode);
 			}
 			retcode = VOP_IOCTL(vp, DIOCGPART, (caddr_t) & dpart,
-					    FREAD, proc->p_ucred, proc);
+			    FREAD, proc->p_ucred, proc);
 			if (retcode) {
 				raidPtr->reconInProgress--;
 				RF_UNLOCK_MUTEX(raidPtr->mutex);
 				return(retcode);
 			}
 			raidPtr->Disks[row][col].blockSize =
-				dpart.disklab->d_secsize;
+			    dpart.disklab->d_secsize;
+
+			raidPtr->Disks[row][col].numBlocks =
+			    dpart.part->p_size - rf_protectedSectors;
 
-			raidPtr->Disks[row][col].numBlocks = 
-				dpart.part->p_size - rf_protectedSectors;
-			
 			raidPtr->raid_cinfo[row][col].ci_vp = vp;
 			raidPtr->raid_cinfo[row][col].ci_dev = va.va_rdev;
-			
+
 			raidPtr->Disks[row][col].dev = va.va_rdev;
-			
-			/* we allow the user to specify that only a 
-			   fraction of the disks should be used this is 
-			   just for debug:  it speeds up
-			 * the parity scan */
+
+			/*
+			 * We allow the user to specify that only a
+			 * fraction of the disks should be used this is
+			 * just for debug:  it speeds up the parity scan.
+			 */
 			raidPtr->Disks[row][col].numBlocks =
-				raidPtr->Disks[row][col].numBlocks *
-				rf_sizePercentage / 100;
+			    raidPtr->Disks[row][col].numBlocks *
+			    rf_sizePercentage / 100;
 		}
 
-
-
 		spareDiskPtr = &raidPtr->Disks[row][col];
 		spareDiskPtr->status = rf_ds_used_spare;
 
 		printf("RECON: initiating in-place reconstruction on\n");
-		printf("       row %d col %d -> spare at row %d col %d\n", 
-		       row, col, row, col);
+		printf("       row %d col %d -> spare at row %d col %d.\n",
+		    row, col, row, col);
 
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
-		
-		reconDesc = rf_AllocRaidReconDesc((void *) raidPtr, row, col, 
-					       spareDiskPtr, numDisksDone, 
-					       row, col);
+
+		reconDesc = rf_AllocRaidReconDesc((void *) raidPtr, row, col,
+		    spareDiskPtr, numDisksDone, row, col);
 		raidPtr->reconDesc = (void *) reconDesc;
-#if RF_RECON_STATS > 0
+#if	RF_RECON_STATS > 0
 		reconDesc->hsStallCount = 0;
 		reconDesc->numReconExecDelays = 0;
 		reconDesc->numReconEventWaits = 0;
-#endif				/* RF_RECON_STATS > 0 */
+#endif	/* RF_RECON_STATS > 0 */
 		reconDesc->reconExecTimerRunning = 0;
 		reconDesc->reconExecTicks = 0;
 		reconDesc->maxReconExecTicks = 0;
@@ -565,45 +667,46 @@ rf_ReconstructInPlace(raidPtr, row, col)
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
 
 	} else {
-		RF_ERRORMSG1("RECON: no way to reconstruct failed disk for arch %c\n",
-			     lp->parityConfig);
+		RF_ERRORMSG1("RECON: no way to reconstruct failed disk for"
+		    " arch %c.\n", lp->parityConfig);
 		rc = EIO;
 	}
 	RF_LOCK_MUTEX(raidPtr->mutex);
-	
+
 	if (!rc) {
-		/* Need to set these here, as at this point it'll be claiming
-		   that the disk is in rf_ds_spared!  But we know better :-) */
-		
+		/*
+		 * Need to set these here, as at this point it'll be claiming
+		 * that the disk is in rf_ds_spared !  But we know better :-)
+		 */
+
 		raidPtr->Disks[row][col].status = rf_ds_optimal;
 		raidPtr->status[row] = rf_rs_optimal;
-		
-		/* fix up the component label */
-		/* Don't actually need the read here.. */
-		raidread_component_label(raidPtr->raid_cinfo[row][col].ci_dev,
-					 raidPtr->raid_cinfo[row][col].ci_vp,
-					 &c_label);
+
+		/* Fix up the component label. */
+		/* Don't actually need the read here... */
+		raidread_component_label(
+		    raidPtr->raid_cinfo[row][col].ci_dev,
+		    raidPtr->raid_cinfo[row][col].ci_vp,
+		    &c_label);
 
 		raid_init_component_label(raidPtr, &c_label);
 
 		c_label.row = row;
 		c_label.column = col;
-		
+
 		raidwrite_component_label(raidPtr->raid_cinfo[row][col].ci_dev,
-					  raidPtr->raid_cinfo[row][col].ci_vp,
-					  &c_label);
+		    raidPtr->raid_cinfo[row][col].ci_vp, &c_label);
 
 	}
 	RF_UNLOCK_MUTEX(raidPtr->mutex);
 	RF_SIGNAL_COND(raidPtr->waitForReconCond);
-	wakeup(&raidPtr->waitForReconCond);	
+	wakeup(&raidPtr->waitForReconCond);
 	return (rc);
 }
 
 
-int 
-rf_ContinueReconstructFailedDisk(reconDesc)
-	RF_RaidReconDesc_t *reconDesc;
+int
+rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *reconDesc)
 {
 	RF_Raid_t *raidPtr = reconDesc->raidPtr;
 	RF_RowCol_t row = reconDesc->row;
@@ -615,32 +718,40 @@ rf_ContinueReconstructFailedDisk(reconDesc)
 	RF_ReconEvent_t *event;
 	struct timeval etime, elpsd;
 	unsigned long xor_s, xor_resid_us;
-	int     retcode, i, ds;
+	int retcode, i, ds;
 
 	switch (reconDesc->state) {
 	case 0:
 		raidPtr->accumXorTimeUs = 0;
 
-		/* create one trace record per physical disk */
-		RF_Malloc(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
+		/* Create one trace record per physical disk. */
+		RF_Malloc(raidPtr->recon_tracerecs, raidPtr->numCol *
+		    sizeof(RF_AccTraceEntry_t), (RF_AccTraceEntry_t *));
 
-		/* quiesce the array prior to starting recon.  this is needed
+		/*
+		 * Quiesce the array prior to starting recon. This is needed
 		 * to assure no nasty interactions with pending user writes.
-		 * We need to do this before we change the disk or row status. */
+		 * We need to do this before we change the disk or row status.
+		 */
 		reconDesc->state = 1;
 
-		Dprintf("RECON: begin request suspend\n");
+		Dprintf("RECON: begin request suspend.\n");
 		retcode = rf_SuspendNewRequestsAndWait(raidPtr);
-		Dprintf("RECON: end request suspend\n");
-		rf_StartUserStats(raidPtr);	/* zero out the stats kept on
-						 * user accs */
-		/* fall through to state 1 */
+		Dprintf("RECON: end request suspend.\n");
+		rf_StartUserStats(raidPtr);	/*
+						 * Zero out the stats kept on
+						 * user accs.
+						 */
+		/* Fall through to state 1. */
 	case 1:
 		RF_LOCK_MUTEX(raidPtr->mutex);
 
-		/* create the reconstruction control pointer and install it in
-		 * the right slot */
-		raidPtr->reconControl[row] = rf_MakeReconControl(reconDesc, row, col, srow, scol);
+		/*
+		 * Create the reconstruction control pointer and install it in
+		 * the right slot.
+		 */
+		raidPtr->reconControl[row] =
+		    rf_MakeReconControl(reconDesc, row, col, srow, scol);
 		mapPtr = raidPtr->reconControl[row]->reconMap;
 		raidPtr->status[row] = rf_rs_reconstructing;
 		raidPtr->Disks[row][col].status = rf_ds_reconstructing;
@@ -651,16 +762,21 @@ rf_ContinueReconstructFailedDisk(reconDesc)
 
 		RF_GETTIME(raidPtr->reconControl[row]->starttime);
 
-		/* now start up the actual reconstruction: issue a read for
-		 * each surviving disk */
+		/*
+		 * Now start up the actual reconstruction: issue a read for
+		 * each surviving disk.
+		 */
 
 		reconDesc->numDisksDone = 0;
 		for (i = 0; i < raidPtr->numCol; i++) {
 			if (i != col) {
-				/* find and issue the next I/O on the
-				 * indicated disk */
+				/*
+				 * Find and issue the next I/O on the
+				 * indicated disk.
+				 */
 				if (rf_IssueNextReadRequest(raidPtr, row, i)) {
-					Dprintf2("RECON: done issuing for r%d c%d\n", row, i);
+					Dprintf2("RECON: done issuing for r%d"
+					    " c%d.\n", row, i);
 					reconDesc->numDisksDone++;
 				}
 			}
@@ -669,35 +785,41 @@ rf_ContinueReconstructFailedDisk(reconDesc)
 		reconDesc->state = 2;
 
 	case 2:
-		Dprintf("RECON: resume requests\n");
+		Dprintf("RECON: resume requests.\n");
 		rf_ResumeNewRequests(raidPtr);
 
-
 		reconDesc->state = 3;
 
 	case 3:
 
-		/* process reconstruction events until all disks report that
-		 * they've completed all work */
+		/*
+		 * Process reconstruction events until all disks report that
+		 * they've completed all work.
+		 */
 		mapPtr = raidPtr->reconControl[row]->reconMap;
 
 		while (reconDesc->numDisksDone < raidPtr->numCol - 1) {
 
-			event = rf_GetNextReconEvent(reconDesc, row, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc);
+			event = rf_GetNextReconEvent(reconDesc, row,
+			   (void (*) (void *)) rf_ContinueReconstructFailedDisk,
+			    reconDesc);
 			RF_ASSERT(event);
 
 			if (rf_ProcessReconEvent(raidPtr, row, event))
 				reconDesc->numDisksDone++;
-			raidPtr->reconControl[row]->numRUsTotal = 
+			raidPtr->reconControl[row]->numRUsTotal =
 				mapPtr->totalRUs;
-			raidPtr->reconControl[row]->numRUsComplete = 
-				mapPtr->totalRUs - 
+			raidPtr->reconControl[row]->numRUsComplete =
+				mapPtr->totalRUs -
 				rf_UnitsLeftToReconstruct(mapPtr);
 
-			raidPtr->reconControl[row]->percentComplete = 
-				(raidPtr->reconControl[row]->numRUsComplete * 100 / raidPtr->reconControl[row]->numRUsTotal);
+			raidPtr->reconControl[row]->percentComplete =
+			    (raidPtr->reconControl[row]->numRUsComplete * 100 /
+			     raidPtr->reconControl[row]->numRUsTotal);
 			if (rf_prReconSched) {
-				rf_PrintReconSchedule(raidPtr->reconControl[row]->reconMap, &(raidPtr->reconControl[row]->starttime));
+				rf_PrintReconSchedule(
+				    raidPtr->reconControl[row]->reconMap,
+				    &(raidPtr->reconControl[row]->starttime));
 			}
 		}
 
@@ -706,75 +828,98 @@ rf_ContinueReconstructFailedDisk(reconDesc)
 	case 4:
 		mapPtr = raidPtr->reconControl[row]->reconMap;
 		if (rf_reconDebug) {
-			printf("RECON: all reads completed\n");
+			printf("RECON: all reads completed.\n");
 		}
-		/* at this point all the reads have completed.  We now wait
-		 * for any pending writes to complete, and then we're done */
+		/*
+		 * At this point all the reads have completed. We now wait
+		 * for any pending writes to complete, and then we're done.
+		 */
 
-		while (rf_UnitsLeftToReconstruct(raidPtr->reconControl[row]->reconMap) > 0) {
+		while (rf_UnitsLeftToReconstruct(
+		    raidPtr->reconControl[row]->reconMap) > 0) {
 
-			event = rf_GetNextReconEvent(reconDesc, row, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc);
+			event = rf_GetNextReconEvent(reconDesc, row,
+			   (void (*) (void *)) rf_ContinueReconstructFailedDisk,
+			    reconDesc);
 			RF_ASSERT(event);
 
-			(void) rf_ProcessReconEvent(raidPtr, row, event);	/* ignore return code */
-			raidPtr->reconControl[row]->percentComplete = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
+			/* Ignore return code. */
+			(void) rf_ProcessReconEvent(raidPtr, row, event);
+			raidPtr->reconControl[row]->percentComplete =
+			    100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 /
+			    mapPtr->totalRUs);
 			if (rf_prReconSched) {
-				rf_PrintReconSchedule(raidPtr->reconControl[row]->reconMap, &(raidPtr->reconControl[row]->starttime));
+				rf_PrintReconSchedule(
+				    raidPtr->reconControl[row]->reconMap,
+				    &(raidPtr->reconControl[row]->starttime));
 			}
 		}
 		reconDesc->state = 5;
 
 	case 5:
-		/* Success:  mark the dead disk as reconstructed.  We quiesce
+		/*
+		 * Success:  mark the dead disk as reconstructed. We quiesce
 		 * the array here to assure no nasty interactions with pending
-		 * user accesses when we free up the psstatus structure as
-		 * part of FreeReconControl() */
+		 * user accesses, when we free up the psstatus structure as
+		 * part of FreeReconControl().
+		 */
 
 		reconDesc->state = 6;
 
 		retcode = rf_SuspendNewRequestsAndWait(raidPtr);
 		rf_StopUserStats(raidPtr);
-		rf_PrintUserStats(raidPtr);	/* print out the stats on user
+		rf_PrintUserStats(raidPtr);	/*
+						 * Print out the stats on user
 						 * accs accumulated during
-						 * recon */
+						 * recon.
+						 */
 
-		/* fall through to state 6 */
+		/* Fall through to state 6. */
 	case 6:
 		RF_LOCK_MUTEX(raidPtr->mutex);
 		raidPtr->numFailures--;
 		ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE);
-		raidPtr->Disks[row][col].status = (ds) ? rf_ds_dist_spared : rf_ds_spared;
-		raidPtr->status[row] = (ds) ? rf_rs_reconfigured : rf_rs_optimal;
+		raidPtr->Disks[row][col].status = (ds) ? rf_ds_dist_spared :
+							 rf_ds_spared;
+		raidPtr->status[row] = (ds) ? rf_rs_reconfigured :
+					      rf_rs_optimal;
 		RF_UNLOCK_MUTEX(raidPtr->mutex);
 		RF_GETTIME(etime);
-		RF_TIMEVAL_DIFF(&(raidPtr->reconControl[row]->starttime), &etime, &elpsd);
+		RF_TIMEVAL_DIFF(&(raidPtr->reconControl[row]->starttime),
+		    &etime, &elpsd);
 
-		/* XXX -- why is state 7 different from state 6 if there is no
-		 * return() here? -- XXX Note that I set elpsd above & use it
+		/*
+		 * XXX -- Why is state 7 different from state 6 if there is no
+		 * return() here ? -- XXX Note that I set elpsd above & use it
 		 * below, so if you put a return here you'll have to fix this.
-		 * (also, FreeReconControl is called below) */
+		 * (also, FreeReconControl is called below).
+		 */
 
 	case 7:
 
 		rf_ResumeNewRequests(raidPtr);
 
-		printf("Reconstruction of disk at row %d col %d completed\n", 
-		       row, col);
+		printf("Reconstruction of disk at row %d col %d completed.\n",
+		    row, col);
 		xor_s = raidPtr->accumXorTimeUs / 1000000;
 		xor_resid_us = raidPtr->accumXorTimeUs % 1000000;
-		printf("Recon time was %d.%06d seconds, accumulated XOR time was %ld us (%ld.%06ld)\n",
-		    (int) elpsd.tv_sec, (int) elpsd.tv_usec, raidPtr->accumXorTimeUs, xor_s, xor_resid_us);
-		printf("  (start time %d sec %d usec, end time %d sec %d usec)\n",
+		printf("Recon time was %d.%06d seconds, accumulated XOR time"
+		    " was %ld us (%ld.%06ld).\n", (int) elpsd.tv_sec,
+		    (int) elpsd.tv_usec, raidPtr->accumXorTimeUs, xor_s,
+		    xor_resid_us);
+		printf("  (start time %d sec %d usec, end time %d sec %d"
+		    " usec)\n",
 		    (int) raidPtr->reconControl[row]->starttime.tv_sec,
 		    (int) raidPtr->reconControl[row]->starttime.tv_usec,
 		    (int) etime.tv_sec, (int) etime.tv_usec);
 
-#if RF_RECON_STATS > 0
-		printf("Total head-sep stall count was %d\n",
+#if	RF_RECON_STATS > 0
+		printf("Total head-sep stall count was %d.\n",
 		    (int) reconDesc->hsStallCount);
-#endif				/* RF_RECON_STATS > 0 */
+#endif	/* RF_RECON_STATS > 0 */
 		rf_FreeReconControl(raidPtr, row);
-		RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t));
+		RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol *
+		    sizeof(RF_AccTraceEntry_t));
 		rf_FreeReconDesc(reconDesc);
 
 	}
@@ -782,52 +927,62 @@ rf_ContinueReconstructFailedDisk(reconDesc)
 	rf_SignalReconDone(raidPtr);
 	return (0);
 }
+
+
 /*****************************************************************************
- * do the right thing upon each reconstruction event.
- * returns nonzero if and only if there is nothing left unread on the 
- * indicated disk
+ * Do the right thing upon each reconstruction event.
+ * Returns nonzero if and only if there is nothing left unread on the
+ * indicated disk.
  *****************************************************************************/
-int 
-rf_ProcessReconEvent(raidPtr, frow, event)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t frow;
-	RF_ReconEvent_t *event;
+int
+rf_ProcessReconEvent(RF_Raid_t *raidPtr, RF_RowCol_t frow,
+    RF_ReconEvent_t *event)
 {
-	int     retcode = 0, submitblocked;
+	int retcode = 0, submitblocked;
 	RF_ReconBuffer_t *rbuf;
 	RF_SectorCount_t sectorsPerRU;
 
-	Dprintf1("RECON: rf_ProcessReconEvent type %d\n", event->type);
+	Dprintf1("RECON: rf_ProcessReconEvent type %d.\n", event->type);
+
 	switch (event->type) {
 
-		/* a read I/O has completed */
+		/* A read I/O has completed. */
 	case RF_REVENT_READDONE:
-		rbuf = raidPtr->reconControl[frow]->perDiskInfo[event->col].rbuf;
-		Dprintf3("RECON: READDONE EVENT: row %d col %d psid %ld\n",
+		rbuf = raidPtr->reconControl[frow]
+		    ->perDiskInfo[event->col].rbuf;
+		Dprintf3("RECON: READDONE EVENT: row %d col %d psid %ld.\n",
 		    frow, event->col, rbuf->parityStripeID);
-		Dprintf7("RECON: done read  psid %ld buf %lx  %02x %02x %02x %02x %02x\n",
-		    rbuf->parityStripeID, rbuf->buffer, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
-		    rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
+		Dprintf7("RECON: done read  psid %ld buf %lx  %02x %02x %02x"
+		    " %02x %02x.\n", rbuf->parityStripeID, rbuf->buffer,
+		    rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
+		    rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff,
+		    rbuf->buffer[4] & 0xff);
 		rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
 		submitblocked = rf_SubmitReconBuffer(rbuf, 0, 0);
-		Dprintf1("RECON: submitblocked=%d\n", submitblocked);
+		Dprintf1("RECON: submitblocked=%d.\n", submitblocked);
 		if (!submitblocked)
-			retcode = rf_IssueNextReadRequest(raidPtr, frow, event->col);
+			retcode = rf_IssueNextReadRequest(raidPtr, frow,
+			    event->col);
 		break;
 
-		/* a write I/O has completed */
+		/* A write I/O has completed. */
 	case RF_REVENT_WRITEDONE:
 		if (rf_floatingRbufDebug) {
 			rf_CheckFloatingRbufCount(raidPtr, 1);
 		}
-		sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
+		sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit *
+		    raidPtr->Layout.SUsPerRU;
 		rbuf = (RF_ReconBuffer_t *) event->arg;
 		rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
-		Dprintf3("RECON: WRITEDONE EVENT: psid %d ru %d (%d %% complete)\n",
-		    rbuf->parityStripeID, rbuf->which_ru, raidPtr->reconControl[frow]->percentComplete);
-		rf_ReconMapUpdate(raidPtr, raidPtr->reconControl[frow]->reconMap,
-		    rbuf->failedDiskSectorOffset, rbuf->failedDiskSectorOffset + sectorsPerRU - 1);
-		rf_RemoveFromActiveReconTable(raidPtr, frow, rbuf->parityStripeID, rbuf->which_ru);
+		Dprintf3("RECON: WRITEDONE EVENT: psid %d ru %d"
+		    " (%d %% complete).\n",
+		    rbuf->parityStripeID, rbuf->which_ru,
+		    raidPtr->reconControl[frow]->percentComplete);
+		rf_ReconMapUpdate(raidPtr, raidPtr->reconControl[frow]
+		    ->reconMap, rbuf->failedDiskSectorOffset,
+		    rbuf->failedDiskSectorOffset + sectorsPerRU - 1);
+		rf_RemoveFromActiveReconTable(raidPtr, frow,
+		    rbuf->parityStripeID, rbuf->which_ru);
 
 		if (rbuf->type == RF_RBUF_TYPE_FLOATING) {
 			RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
@@ -841,51 +996,67 @@ rf_ProcessReconEvent(raidPtr, frow, event)
 				RF_ASSERT(0);
 		break;
 
-	case RF_REVENT_BUFCLEAR:	/* A buffer-stall condition has been
-					 * cleared */
-		Dprintf2("RECON: BUFCLEAR EVENT: row %d col %d\n", frow, event->col);
-		submitblocked = rf_SubmitReconBuffer(raidPtr->reconControl[frow]->perDiskInfo[event->col].rbuf, 0, (int) (long) event->arg);
-		RF_ASSERT(!submitblocked);	/* we wouldn't have gotten the
+		/* A buffer-stall condition has been cleared. */
+	case RF_REVENT_BUFCLEAR:
+		Dprintf2("RECON: BUFCLEAR EVENT: row %d col %d.\n", frow,
+		    event->col);
+		submitblocked = rf_SubmitReconBuffer(raidPtr
+		    ->reconControl[frow]->perDiskInfo[event->col].rbuf, 0,
+		    (int) (long) event->arg);
+		RF_ASSERT(!submitblocked);	/*
+						 * We wouldn't have gotten the
 						 * BUFCLEAR event if we
-						 * couldn't submit */
+						 * couldn't submit.
+						 */
 		retcode = rf_IssueNextReadRequest(raidPtr, frow, event->col);
 		break;
 
-	case RF_REVENT_BLOCKCLEAR:	/* A user-write reconstruction
-					 * blockage has been cleared */
-		DDprintf2("RECON: BLOCKCLEAR EVENT: row %d col %d\n", frow, event->col);
+		/* A user-write reconstruction blockage has been cleared. */
+	case RF_REVENT_BLOCKCLEAR:
+		DDprintf2("RECON: BLOCKCLEAR EVENT: row %d col %d.\n",
+		    frow, event->col);
 		retcode = rf_TryToRead(raidPtr, frow, event->col);
 		break;
 
-	case RF_REVENT_HEADSEPCLEAR:	/* A max-head-separation
-					 * reconstruction blockage has been
-					 * cleared */
-		Dprintf2("RECON: HEADSEPCLEAR EVENT: row %d col %d\n", frow, event->col);
+		/*
+		 * A max-head-separation reconstruction blockage has been
+		 * cleared.
+		 */
+	case RF_REVENT_HEADSEPCLEAR:
+		Dprintf2("RECON: HEADSEPCLEAR EVENT: row %d col %d.\n",
+		    frow, event->col);
 		retcode = rf_TryToRead(raidPtr, frow, event->col);
 		break;
 
-		/* a buffer has become ready to write */
+		/* A buffer has become ready to write. */
 	case RF_REVENT_BUFREADY:
-		Dprintf2("RECON: BUFREADY EVENT: row %d col %d\n", frow, event->col);
+		Dprintf2("RECON: BUFREADY EVENT: row %d col %d.\n",
+		    frow, event->col);
 		retcode = rf_IssueNextWriteRequest(raidPtr, frow);
 		if (rf_floatingRbufDebug) {
 			rf_CheckFloatingRbufCount(raidPtr, 1);
 		}
 		break;
 
-		/* we need to skip the current RU entirely because it got
-		 * recon'd while we were waiting for something else to happen */
+		/*
+		 * We need to skip the current RU entirely because it got
+		 * recon'd while we were waiting for something else to happen.
+		 */
 	case RF_REVENT_SKIP:
-		DDprintf2("RECON: SKIP EVENT: row %d col %d\n", frow, event->col);
+		DDprintf2("RECON: SKIP EVENT: row %d col %d.\n",
+		    frow, event->col);
 		retcode = rf_IssueNextReadRequest(raidPtr, frow, event->col);
 		break;
 
-		/* a forced-reconstruction read access has completed.  Just
-		 * submit the buffer */
+		/*
+		 * A forced-reconstruction read access has completed. Just
+		 * submit the buffer.
+		 */
 	case RF_REVENT_FORCEDREADDONE:
 		rbuf = (RF_ReconBuffer_t *) event->arg;
 		rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
-		DDprintf2("RECON: FORCEDREADDONE EVENT: row %d col %d\n", frow, event->col);
+		DDprintf2("RECON: FORCEDREADDONE EVENT: row %d col %d.\n",
+		    frow, event->col);
 		submitblocked = rf_SubmitReconBuffer(rbuf, 1, 0);
 		RF_ASSERT(!submitblocked);
 		break;
@@ -899,9 +1070,9 @@ rf_ProcessReconEvent(raidPtr, frow, event)
 
 /*****************************************************************************
  *
- * find the next thing that's needed on the indicated disk, and issue
- * a read request for it.  We assume that the reconstruction buffer
- * associated with this process is free to receive the data.  If
+ * Find the next thing that's needed on the indicated disk, and issue
+ * a read request for it. We assume that the reconstruction buffer
+ * associated with this process is free to receive the data. If
  * reconstruction is blocked on the indicated RU, we issue a
  * blockage-release request instead of a physical disk read request.
  * If the current disk gets too far ahead of the others, we issue a
@@ -909,31 +1080,34 @@ rf_ProcessReconEvent(raidPtr, frow, event)
  *
  * ctrl->{ru_count, curPSID, diskOffset} and
  * rbuf->failedDiskSectorOffset are maintained to point to the unit
- * we're currently accessing.  Note that this deviates from the
+ * we're currently accessing. Note that this deviates from the
  * standard C idiom of having counters point to the next thing to be
- * accessed.  This allows us to easily retry when we're blocked by
+ * accessed. This allows us to easily retry when we're blocked by
  * head separation or reconstruction-blockage events.
  *
- * returns nonzero if and only if there is nothing left unread on the
- * indicated disk
+ * Returns nonzero if and only if there is nothing left unread on the
+ * indicated disk.
  *
  *****************************************************************************/
-int 
-rf_IssueNextReadRequest(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
+int
+rf_IssueNextReadRequest(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
 {
-	RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl[row]->perDiskInfo[col];
+	RF_PerDiskReconCtrl_t *ctrl =
+	    &raidPtr->reconControl[row]->perDiskInfo[col];
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_ReconBuffer_t *rbuf = ctrl->rbuf;
-	RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU / layoutPtr->SUsPerRU;
-	RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
-	int     do_new_check = 0, retcode = 0, status;
-
-	/* if we are currently the slowest disk, mark that we have to do a new
-	 * check */
-	if (ctrl->headSepCounter <= raidPtr->reconControl[row]->minHeadSepCounter)
+	RF_ReconUnitCount_t RUsPerPU =
+	    layoutPtr->SUsPerPU / layoutPtr->SUsPerRU;
+	RF_SectorCount_t sectorsPerRU =
+	    layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
+	int do_new_check = 0, retcode = 0, status;
+
+	/*
+	 * If we are currently the slowest disk, mark that we have to do a new
+	 * check.
+	 */
+	if (ctrl->headSepCounter <=
+	    raidPtr->reconControl[row]->minHeadSepCounter)
 		do_new_check = 1;
 
 	while (1) {
@@ -947,16 +1121,22 @@ rf_IssueNextReadRequest(raidPtr, row, col)
 			ctrl->ru_count = 0;
 			/* code left over from when head-sep was based on
 			 * parity stripe id */
-			if (ctrl->curPSID >= raidPtr->reconControl[row]->lastPSID) {
-				rf_CheckForNewMinHeadSep(raidPtr, row, ++(ctrl->headSepCounter));
-				return (1);	/* finito! */
+			if (ctrl->curPSID >=
+			    raidPtr->reconControl[row]->lastPSID) {
+				rf_CheckForNewMinHeadSep(raidPtr, row,
+				    ++(ctrl->headSepCounter));
+				return (1);	/* Finito ! */
 			}
-			/* find the disk offsets of the start of the parity
+			/*
+			 * Find the disk offsets of the start of the parity
 			 * stripe on both the current disk and the failed
-			 * disk. skip this entire parity stripe if either disk
-			 * does not appear in the indicated PS */
-			status = rf_ComputePSDiskOffsets(raidPtr, ctrl->curPSID, row, col, &ctrl->diskOffset, &rbuf->failedDiskSectorOffset,
-			    &rbuf->spRow, &rbuf->spCol, &rbuf->spOffset);
+			 * disk. Skip this entire parity stripe if either disk
+			 * does not appear in the indicated PS.
+			 */
+			status = rf_ComputePSDiskOffsets(raidPtr,
+			    ctrl->curPSID, row, col, &ctrl->diskOffset,
+			    &rbuf->failedDiskSectorOffset, &rbuf->spRow,
+			    &rbuf->spCol, &rbuf->spOffset);
 			if (status) {
 				ctrl->ru_count = RUsPerPU - 1;
 				continue;
@@ -964,23 +1144,28 @@ rf_IssueNextReadRequest(raidPtr, row, col)
 		}
 		rbuf->which_ru = ctrl->ru_count;
 
-		/* skip this RU if it's already been reconstructed */
-		if (rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, rbuf->failedDiskSectorOffset)) {
-			Dprintf2("Skipping psid %ld ru %d: already reconstructed\n", ctrl->curPSID, ctrl->ru_count);
+		/* Skip this RU if it's already been reconstructed. */
+		if (rf_CheckRUReconstructed(raidPtr->reconControl[row]
+		    ->reconMap, rbuf->failedDiskSectorOffset)) {
+			Dprintf2("Skipping psid %ld ru %d: already"
+			    " reconstructed.\n", ctrl->curPSID, ctrl->ru_count);
 			continue;
 		}
 		break;
 	}
 	ctrl->headSepCounter++;
-	if (do_new_check)
-		rf_CheckForNewMinHeadSep(raidPtr, row, ctrl->headSepCounter);	/* update min if needed */
+	if (do_new_check)	/* Update min if needed. */
+		rf_CheckForNewMinHeadSep(raidPtr, row, ctrl->headSepCounter);
 
 
-	/* at this point, we have definitely decided what to do, and we have
-	 * only to see if we can actually do it now */
+	/*
+	 * At this point, we have definitely decided what to do, and we have
+	 * only to see if we can actually do it now.
+	 */
 	rbuf->parityStripeID = ctrl->curPSID;
 	rbuf->which_ru = ctrl->ru_count;
-	bzero((char *) &raidPtr->recon_tracerecs[col], sizeof(raidPtr->recon_tracerecs[col]));
+	bzero((char *) &raidPtr->recon_tracerecs[col],
+	    sizeof(raidPtr->recon_tracerecs[col]));
 	raidPtr->recon_tracerecs[col].reconacc = 1;
 	RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
 	retcode = rf_TryToRead(raidPtr, row, col);
@@ -988,76 +1173,94 @@ rf_IssueNextReadRequest(raidPtr, row, col)
 }
 
 /*
- * tries to issue the next read on the indicated disk.  We may be
+ * Tries to issue the next read on the indicated disk. We may be
  * blocked by (a) the heads being too far apart, or (b) recon on the
- * indicated RU being blocked due to a write by a user thread.  In
+ * indicated RU being blocked due to a write by a user thread. In
  * this case, we issue a head-sep or blockage wait request, which will
  * cause this same routine to be invoked again later when the blockage
- * has cleared.  
+ * has cleared.
  */
 
-int 
-rf_TryToRead(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
+int
+rf_TryToRead(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
 {
-	RF_PerDiskReconCtrl_t *ctrl = &raidPtr->reconControl[row]->perDiskInfo[col];
-	RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
+	RF_PerDiskReconCtrl_t *ctrl =
+	    &raidPtr->reconControl[row]->perDiskInfo[col];
+	RF_SectorCount_t sectorsPerRU =
+	    raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;
 	RF_StripeNum_t psid = ctrl->curPSID;
 	RF_ReconUnitNum_t which_ru = ctrl->ru_count;
 	RF_DiskQueueData_t *req;
-	int     status, created = 0;
+	int status, created = 0;
 	RF_ReconParityStripeStatus_t *pssPtr;
 
-	/* if the current disk is too far ahead of the others, issue a
-	 * head-separation wait and return */
-	if (rf_CheckHeadSeparation(raidPtr, ctrl, row, col, ctrl->headSepCounter, which_ru))
+	/*
+	 * If the current disk is too far ahead of the others, issue a
+	 * head-separation wait and return.
+	 */
+	if (rf_CheckHeadSeparation(raidPtr, ctrl, row, col,
+	    ctrl->headSepCounter, which_ru))
 		return (0);
 	RF_LOCK_PSS_MUTEX(raidPtr, row, psid);
-	pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]->pssTable, psid, which_ru, RF_PSS_CREATE, &created);
+	pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]
+	    ->pssTable, psid, which_ru, RF_PSS_CREATE, &created);
 
-	/* if recon is blocked on the indicated parity stripe, issue a
-	 * block-wait request and return. this also must mark the indicated RU
-	 * in the stripe as under reconstruction if not blocked. */
-	status = rf_CheckForcedOrBlockedReconstruction(raidPtr, pssPtr, ctrl, row, col, psid, which_ru);
+	/*
+	 * If recon is blocked on the indicated parity stripe, issue a
+	 * block-wait request and return. This also must mark the indicated RU
+	 * in the stripe as under reconstruction if not blocked.
+	 */
+	status = rf_CheckForcedOrBlockedReconstruction(raidPtr, pssPtr, ctrl,
+	    row, col, psid, which_ru);
 	if (status == RF_PSS_RECON_BLOCKED) {
-		Dprintf2("RECON: Stalling psid %ld ru %d: recon blocked\n", psid, which_ru);
+		Dprintf2("RECON: Stalling psid %ld ru %d: recon blocked.\n",
+		    psid, which_ru);
 		goto out;
 	} else
 		if (status == RF_PSS_FORCED_ON_WRITE) {
-			rf_CauseReconEvent(raidPtr, row, col, NULL, RF_REVENT_SKIP);
+			rf_CauseReconEvent(raidPtr, row, col, NULL,
+			    RF_REVENT_SKIP);
 			goto out;
 		}
-	/* make one last check to be sure that the indicated RU didn't get
+	/*
+	 * Make one last check to be sure that the indicated RU didn't get
 	 * reconstructed while we were waiting for something else to happen.
 	 * This is unfortunate in that it causes us to make this check twice
-	 * in the normal case.  Might want to make some attempt to re-work
+	 * in the normal case. Might want to make some attempt to re-work
 	 * this so that we only do this check if we've definitely blocked on
-	 * one of the above checks.  When this condition is detected, we may
-	 * have just created a bogus status entry, which we need to delete. */
-	if (rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, ctrl->rbuf->failedDiskSectorOffset)) {
-		Dprintf2("RECON: Skipping psid %ld ru %d: prior recon after stall\n", psid, which_ru);
+	 * one of the above checks. When this condition is detected, we may
+	 * have just created a bogus status entry, which we need to delete.
+	 */
+	if (rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap,
+	    ctrl->rbuf->failedDiskSectorOffset)) {
+		Dprintf2("RECON: Skipping psid %ld ru %d: prior recon after"
+		    " stall.\n", psid, which_ru);
 		if (created)
-			rf_PSStatusDelete(raidPtr, raidPtr->reconControl[row]->pssTable, pssPtr);
+			rf_PSStatusDelete(raidPtr,
+			    raidPtr->reconControl[row]->pssTable, pssPtr);
 		rf_CauseReconEvent(raidPtr, row, col, NULL, RF_REVENT_SKIP);
 		goto out;
 	}
-	/* found something to read.  issue the I/O */
-	Dprintf5("RECON: Read for psid %ld on row %d col %d offset %ld buf %lx\n",
-	    psid, row, col, ctrl->diskOffset, ctrl->rbuf->buffer);
+	/* Found something to read. Issue the I/O. */
+	Dprintf5("RECON: Read for psid %ld on row %d col %d offset %ld"
+	    " buf %lx.\n", psid, row, col, ctrl->diskOffset,
+	    ctrl->rbuf->buffer);
 	RF_ETIMER_STOP(raidPtr->recon_tracerecs[col].recon_timer);
 	RF_ETIMER_EVAL(raidPtr->recon_tracerecs[col].recon_timer);
 	raidPtr->recon_tracerecs[col].specific.recon.recon_start_to_fetch_us =
 	    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[col].recon_timer);
 	RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
 
-	/* should be ok to use a NULL proc pointer here, all the bufs we use
-	 * should be in kernel space */
-	req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, ctrl->diskOffset, sectorsPerRU, ctrl->rbuf->buffer, psid, which_ru,
-	    rf_ReconReadDoneProc, (void *) ctrl, NULL, &raidPtr->recon_tracerecs[col], (void *) raidPtr, 0, NULL);
+	/*
+	 * Should be ok to use a NULL proc pointer here, all the bufs we use
+	 * should be in kernel space.
+	 */
+	req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, ctrl->diskOffset,
+	    sectorsPerRU, ctrl->rbuf->buffer, psid, which_ru,
+	    rf_ReconReadDoneProc, (void *) ctrl, NULL,
+	    &raidPtr->recon_tracerecs[col], (void *) raidPtr, 0, NULL);
 
-	RF_ASSERT(req);		/* XXX -- fix this -- XXX */
+	RF_ASSERT(req);		/* XXX -- Fix this. -- XXX */
 
 	ctrl->rbuf->arg = (void *) req;
 	rf_DiskIOEnqueue(&raidPtr->Queues[row][col], req, RF_IO_RECON_PRIORITY);
@@ -1070,61 +1273,75 @@ out:
 
 
 /*
- * given a parity stripe ID, we want to find out whether both the
- * current disk and the failed disk exist in that parity stripe.  If
- * not, we want to skip this whole PS.  If so, we want to find the
+ * Given a parity stripe ID, we want to find out whether both the
+ * current disk and the failed disk exist in that parity stripe. If
+ * not, we want to skip this whole PS. If so, we want to find the
  * disk offset of the start of the PS on both the current disk and the
  * failed disk.
  *
- * this works by getting a list of disks comprising the indicated
+ * This works by getting a list of disks comprising the indicated
  * parity stripe, and searching the list for the current and failed
- * disks.  Once we've decided they both exist in the parity stripe, we
+ * disks. Once we've decided they both exist in the parity stripe, we
  * need to decide whether each is data or parity, so that we'll know
  * which mapping function to call to get the corresponding disk
  * offsets.
  *
- * this is kind of unpleasant, but doing it this way allows the
+ * This is kind of unpleasant, but doing it this way allows the
  * reconstruction code to use parity stripe IDs rather than physical
  * disks address to march through the failed disk, which greatly
  * simplifies a lot of code, as well as eliminating the need for a
- * reverse-mapping function.  I also think it will execute faster,
+ * reverse-mapping function. I also think it will execute faster,
  * since the calls to the mapping module are kept to a minimum.
  *
  * ASSUMES THAT THE STRIPE IDENTIFIER IDENTIFIES THE DISKS COMPRISING
- * THE STRIPE IN THE CORRECT ORDER */
+ * THE STRIPE IN THE CORRECT ORDER.
+ */
 
-int 
+int
 rf_ComputePSDiskOffsets(
-    RF_Raid_t * raidPtr,	/* raid descriptor */
-    RF_StripeNum_t psid,	/* parity stripe identifier */
-    RF_RowCol_t row,		/* row and column of disk to find the offsets
-				 * for */
-    RF_RowCol_t col,
-    RF_SectorNum_t * outDiskOffset,
-    RF_SectorNum_t * outFailedDiskSectorOffset,
-    RF_RowCol_t * spRow,	/* OUT: row,col of spare unit for failed unit */
-    RF_RowCol_t * spCol,
-    RF_SectorNum_t * spOffset)
-{				/* OUT: offset into disk containing spare unit */
+    RF_Raid_t		*raidPtr,	/* RAID descriptor. */
+    RF_StripeNum_t	 psid,		/* Parity stripe identifier. */
+    RF_RowCol_t		 row,		/*
+					 * Row and column of disk to find
+					 * the offsets for.
+					 */
+    RF_RowCol_t		 col,
+    RF_SectorNum_t	*outDiskOffset,
+    RF_SectorNum_t	*outFailedDiskSectorOffset,
+    RF_RowCol_t		*spRow,		/*
+					 * OUT: Row,col of spare unit for
+					 * failed unit.
+					 */
+    RF_RowCol_t		*spCol,
+    RF_SectorNum_t	*spOffset	/*
+					 * OUT: Offset into disk containing
+					 * spare unit.
+					 */
+)
+{
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_RowCol_t fcol = raidPtr->reconControl[row]->fcol;
 	RF_RaidAddr_t sosRaidAddress;	/* start-of-stripe */
 	RF_RowCol_t *diskids;
-	u_int   i, j, k, i_offset, j_offset;
+	u_int i, j, k, i_offset, j_offset;
 	RF_RowCol_t prow, pcol;
-	int     testcol, testrow;
+	int testcol, testrow;
 	RF_RowCol_t stripe;
 	RF_SectorNum_t poffset;
-	char    i_is_parity = 0, j_is_parity = 0;
-	RF_RowCol_t stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
+	char i_is_parity = 0, j_is_parity = 0;
+	RF_RowCol_t stripeWidth =
+	    layoutPtr->numDataCol + layoutPtr->numParityCol;
 
-	/* get a listing of the disks comprising that stripe */
+	/* Get a listing of the disks comprising that stripe. */
 	sosRaidAddress = rf_ParityStripeIDToRaidAddress(layoutPtr, psid);
-	(layoutPtr->map->IdentifyStripe) (raidPtr, sosRaidAddress, &diskids, &stripe);
+	(layoutPtr->map->IdentifyStripe) (raidPtr, sosRaidAddress, &diskids,
+	    &stripe);
 	RF_ASSERT(diskids);
 
-	/* reject this entire parity stripe if it does not contain the
-	 * indicated disk or it does not contain the failed disk */
+	/*
+	 * Reject this entire parity stripe if it does not contain the
+	 * indicated disk or it does not contain the failed disk.
+	 */
 	if (row != stripe)
 		goto skipit;
 	for (i = 0; i < stripeWidth; i++) {
@@ -1140,12 +1357,15 @@ rf_ComputePSDiskOffsets(
 	if (j == stripeWidth) {
 		goto skipit;
 	}
-	/* find out which disk the parity is on */
-	(layoutPtr->map->MapParity) (raidPtr, sosRaidAddress, &prow, &pcol, &poffset, RF_DONT_REMAP);
-
-	/* find out if either the current RU or the failed RU is parity */
-	/* also, if the parity occurs in this stripe prior to the data and/or
-	 * failed col, we need to decrement i and/or j */
+	/* Find out which disk the parity is on. */
+	(layoutPtr->map->MapParity) (raidPtr, sosRaidAddress, &prow, &pcol,
+	    &poffset, RF_DONT_REMAP);
+
+	/* Find out if either the current RU or the failed RU is parity. */
+	/*
+	 * Also, if the parity occurs in this stripe prior to the data and/or
+	 * failed col, we need to decrement i and/or j.
+	 */
 	for (k = 0; k < stripeWidth; k++)
 		if (diskids[k] == pcol)
 			break;
@@ -1158,8 +1378,10 @@ rf_ComputePSDiskOffsets(
 		if (k == i) {
 			i_is_parity = 1;
 			i_offset = 0;
-		}		/* set offsets to zero to disable multiply
-				 * below */
+		}		/*
+				 * Set offsets to zero to disable multiply
+				 * below.
+				 */
 	if (k < j)
 		j_offset--;
 	else
@@ -1167,31 +1389,47 @@ rf_ComputePSDiskOffsets(
 			j_is_parity = 1;
 			j_offset = 0;
 		}
-	/* at this point, [ij]_is_parity tells us whether the [current,failed]
+	/*
+	 * At this point, [ij]_is_parity tells us whether the [current,failed]
 	 * disk is parity at the start of this RU, and, if data, "[ij]_offset"
-	 * tells us how far into the stripe the [current,failed] disk is. */
+	 * tells us how far into the stripe the [current,failed] disk is.
+	 */
 
-	/* call the mapping routine to get the offset into the current disk,
-	 * repeat for failed disk. */
+	/*
+	 * Call the mapping routine to get the offset into the current disk,
+	 * repeat for failed disk.
+	 */
 	if (i_is_parity)
-		layoutPtr->map->MapParity(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outDiskOffset, RF_DONT_REMAP);
+		layoutPtr->map->MapParity(raidPtr, sosRaidAddress + i_offset *
+		    layoutPtr->sectorsPerStripeUnit, &testrow, &testcol,
+		    outDiskOffset, RF_DONT_REMAP);
 	else
-		layoutPtr->map->MapSector(raidPtr, sosRaidAddress + i_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outDiskOffset, RF_DONT_REMAP);
+		layoutPtr->map->MapSector(raidPtr, sosRaidAddress + i_offset *
+		    layoutPtr->sectorsPerStripeUnit, &testrow, &testcol,
+		    outDiskOffset, RF_DONT_REMAP);
 
 	RF_ASSERT(row == testrow && col == testcol);
 
 	if (j_is_parity)
-		layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP);
+		layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset *
+		    layoutPtr->sectorsPerStripeUnit, &testrow, &testcol,
+		    outFailedDiskSectorOffset, RF_DONT_REMAP);
 	else
-		layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, &testrow, &testcol, outFailedDiskSectorOffset, RF_DONT_REMAP);
+		layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset *
+		    layoutPtr->sectorsPerStripeUnit, &testrow, &testcol,
+		    outFailedDiskSectorOffset, RF_DONT_REMAP);
 	RF_ASSERT(row == testrow && fcol == testcol);
 
-	/* now locate the spare unit for the failed unit */
+	/* Now locate the spare unit for the failed unit. */
 	if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {
 		if (j_is_parity)
-			layoutPtr->map->MapParity(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spRow, spCol, spOffset, RF_REMAP);
+			layoutPtr->map->MapParity(raidPtr, sosRaidAddress +
+			    j_offset * layoutPtr->sectorsPerStripeUnit, spRow,
+			    spCol, spOffset, RF_REMAP);
 		else
-			layoutPtr->map->MapSector(raidPtr, sosRaidAddress + j_offset * layoutPtr->sectorsPerStripeUnit, spRow, spCol, spOffset, RF_REMAP);
+			layoutPtr->map->MapSector(raidPtr, sosRaidAddress +
+			    j_offset * layoutPtr->sectorsPerStripeUnit, spRow,
+			    spCol, spOffset, RF_REMAP);
 	} else {
 		*spRow = raidPtr->reconControl[row]->spareRow;
 		*spCol = raidPtr->reconControl[row]->spareCol;
@@ -1201,125 +1439,135 @@ rf_ComputePSDiskOffsets(
 	return (0);
 
 skipit:
-	Dprintf3("RECON: Skipping psid %ld: nothing needed from r%d c%d\n",
+	Dprintf3("RECON: Skipping psid %ld: nothing needed from r%d c%d.\n",
 	    psid, row, col);
 	return (1);
 }
-/* this is called when a buffer has become ready to write to the replacement disk */
-int 
-rf_IssueNextWriteRequest(raidPtr, row)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
+
+
+/*
+ * This is called when a buffer has become ready to write to the replacement
+ * disk.
+ */
+int
+rf_IssueNextWriteRequest(RF_Raid_t *raidPtr, RF_RowCol_t row)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_SectorCount_t sectorsPerRU = layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
+	RF_SectorCount_t sectorsPerRU =
+	    layoutPtr->sectorsPerStripeUnit * layoutPtr->SUsPerRU;
 	RF_RowCol_t fcol = raidPtr->reconControl[row]->fcol;
 	RF_ReconBuffer_t *rbuf;
 	RF_DiskQueueData_t *req;
 
 	rbuf = rf_GetFullReconBuffer(raidPtr->reconControl[row]);
-	RF_ASSERT(rbuf);	/* there must be one available, or we wouldn't
-				 * have gotten the event that sent us here */
+	RF_ASSERT(rbuf);	/*
+				 * There must be one available, or we wouldn't
+				 * have gotten the event that sent us here.
+				 */
 	RF_ASSERT(rbuf->pssPtr);
 
 	rbuf->pssPtr->writeRbuf = rbuf;
 	rbuf->pssPtr = NULL;
 
-	Dprintf7("RECON: New write (r %d c %d offs %d) for psid %ld ru %d (failed disk offset %ld) buf %lx\n",
+	Dprintf7("RECON: New write (r %d c %d offs %d) for psid %ld ru %d"
+	    " (failed disk offset %ld) buf %lx.\n",
 	    rbuf->spRow, rbuf->spCol, rbuf->spOffset, rbuf->parityStripeID,
 	    rbuf->which_ru, rbuf->failedDiskSectorOffset, rbuf->buffer);
-	Dprintf6("RECON: new write psid %ld   %02x %02x %02x %02x %02x\n",
-	    rbuf->parityStripeID, rbuf->buffer[0] & 0xff, rbuf->buffer[1] & 0xff,
-	    rbuf->buffer[2] & 0xff, rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
-
-	/* should be ok to use a NULL b_proc here b/c all addrs should be in
-	 * kernel space */
+	Dprintf6("RECON: new write psid %ld   %02x %02x %02x %02x %02x.\n",
+	    rbuf->parityStripeID, rbuf->buffer[0] & 0xff,
+	    rbuf->buffer[1] & 0xff, rbuf->buffer[2] & 0xff,
+	    rbuf->buffer[3] & 0xff, rbuf->buffer[4] & 0xff);
+
+	/*
+	 * Should be ok to use a NULL b_proc here b/c all addrs should be in
+	 * kernel space.
+	 */
 	req = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, rbuf->spOffset,
-	    sectorsPerRU, rbuf->buffer,
-	    rbuf->parityStripeID, rbuf->which_ru,
+	    sectorsPerRU, rbuf->buffer, rbuf->parityStripeID, rbuf->which_ru,
 	    rf_ReconWriteDoneProc, (void *) rbuf, NULL,
-	    &raidPtr->recon_tracerecs[fcol],
-	    (void *) raidPtr, 0, NULL);
+	    &raidPtr->recon_tracerecs[fcol], (void *) raidPtr, 0, NULL);
 
-	RF_ASSERT(req);		/* XXX -- fix this -- XXX */
+	RF_ASSERT(req);		/* XXX -- Fix this. -- XXX */
 
 	rbuf->arg = (void *) req;
-	rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spRow][rbuf->spCol], req, RF_IO_RECON_PRIORITY);
+	rf_DiskIOEnqueue(&raidPtr->Queues[rbuf->spRow][rbuf->spCol], req,
+	    RF_IO_RECON_PRIORITY);
 
 	return (0);
 }
 
 /*
- * this gets called upon the completion of a reconstruction read
- * operation the arg is a pointer to the per-disk reconstruction
+ * This gets called upon the completion of a reconstruction read
+ * operation. The arg is a pointer to the per-disk reconstruction
  * control structure for the process that just finished a read.
  *
- * called at interrupt context in the kernel, so don't do anything
- * illegal here.  
+ * Called at interrupt context in the kernel, so don't do anything
+ * illegal here.
  */
-int 
-rf_ReconReadDoneProc(arg, status)
-	void   *arg;
-	int     status;
+int
+rf_ReconReadDoneProc(void *arg, int status)
 {
 	RF_PerDiskReconCtrl_t *ctrl = (RF_PerDiskReconCtrl_t *) arg;
 	RF_Raid_t *raidPtr = ctrl->reconCtrl->reconDesc->raidPtr;
 
 	if (status) {
 		/*
-	         * XXX
-	         */
-		printf("Recon read failed!\n");
+		 * XXX
+		 */
+		printf("Recon read failed !\n");
 		RF_PANIC();
 	}
 	RF_ETIMER_STOP(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
 	RF_ETIMER_EVAL(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
-	raidPtr->recon_tracerecs[ctrl->col].specific.recon.recon_fetch_to_return_us =
-	    RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
+	raidPtr->recon_tracerecs[ctrl->col].specific.recon.
+	   recon_fetch_to_return_us =
+	     RF_ETIMER_VAL_US(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
 	RF_ETIMER_START(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
 
-	rf_CauseReconEvent(raidPtr, ctrl->row, ctrl->col, NULL, RF_REVENT_READDONE);
+	rf_CauseReconEvent(raidPtr, ctrl->row, ctrl->col, NULL,
+	    RF_REVENT_READDONE);
 	return (0);
 }
-/* this gets called upon the completion of a reconstruction write operation.
- * the arg is a pointer to the rbuf that was just written
+
+
+/*
+ * This gets called upon the completion of a reconstruction write operation.
+ * The arg is a pointer to the rbuf that was just written.
  *
- * called at interrupt context in the kernel, so don't do anything illegal here.
+ * Called at interrupt context in the kernel, so don't do anything illegal here.
  */
-int 
-rf_ReconWriteDoneProc(arg, status)
-	void   *arg;
-	int     status;
+int
+rf_ReconWriteDoneProc(void *arg, int status)
 {
 	RF_ReconBuffer_t *rbuf = (RF_ReconBuffer_t *) arg;
 
-	Dprintf2("Reconstruction completed on psid %ld ru %d\n", rbuf->parityStripeID, rbuf->which_ru);
+	Dprintf2("Reconstruction completed on psid %ld ru %d.\n",
+	    rbuf->parityStripeID, rbuf->which_ru);
 	if (status) {
-		printf("Recon write failed!\n");	/* fprintf(stderr,"Recon
-							 * write failed!\n"); */
+		/* fprintf(stderr, "Recon write failed !\n"); */
+		printf("Recon write failed !\n");
 		RF_PANIC();
 	}
-	rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col, arg, RF_REVENT_WRITEDONE);
+	rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col,
+	    arg, RF_REVENT_WRITEDONE);
 	return (0);
 }
 
 
-/* 
- * computes a new minimum head sep, and wakes up anyone who needs to
- * be woken as a result 
+/*
+ * Computes a new minimum head sep, and wakes up anyone who needs to
+ * be woken as a result.
  */
-void 
-rf_CheckForNewMinHeadSep(raidPtr, row, hsCtr)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_HeadSepLimit_t hsCtr;
+void
+rf_CheckForNewMinHeadSep(RF_Raid_t *raidPtr, RF_RowCol_t row,
+    RF_HeadSepLimit_t hsCtr)
 {
 	RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
 	RF_HeadSepLimit_t new_min;
 	RF_RowCol_t i;
 	RF_CallbackDesc_t *p;
-	RF_ASSERT(hsCtr >= reconCtrlPtr->minHeadSepCounter);	/* from the definition
-								 * of a minimum */
+	/* From the definition of a minimum. */
+	RF_ASSERT(hsCtr >= reconCtrlPtr->minHeadSepCounter);
 
 
 	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
@@ -1327,20 +1575,25 @@ rf_CheckForNewMinHeadSep(raidPtr, row, hsCtr)
 	new_min = ~(1L << (8 * sizeof(long) - 1));	/* 0x7FFF....FFF */
 	for (i = 0; i < raidPtr->numCol; i++)
 		if (i != reconCtrlPtr->fcol) {
-			if (reconCtrlPtr->perDiskInfo[i].headSepCounter < new_min)
-				new_min = reconCtrlPtr->perDiskInfo[i].headSepCounter;
+			if (reconCtrlPtr->perDiskInfo[i].headSepCounter <
+			    new_min)
+				new_min =
+				    reconCtrlPtr->perDiskInfo[i].headSepCounter;
 		}
-	/* set the new minimum and wake up anyone who can now run again */
+	/* Set the new minimum and wake up anyone who can now run again. */
 	if (new_min != reconCtrlPtr->minHeadSepCounter) {
 		reconCtrlPtr->minHeadSepCounter = new_min;
-		Dprintf1("RECON:  new min head pos counter val is %ld\n", new_min);
+		Dprintf1("RECON:  new min head pos counter val is %ld.\n",
+		    new_min);
 		while (reconCtrlPtr->headSepCBList) {
-			if (reconCtrlPtr->headSepCBList->callbackArg.v > new_min)
+			if (reconCtrlPtr->headSepCBList->callbackArg.v >
+			    new_min)
 				break;
 			p = reconCtrlPtr->headSepCBList;
 			reconCtrlPtr->headSepCBList = p->next;
 			p->next = NULL;
-			rf_CauseReconEvent(raidPtr, p->row, p->col, NULL, RF_REVENT_HEADSEPCLEAR);
+			rf_CauseReconEvent(raidPtr, p->row, p->col, NULL,
+			    RF_REVENT_HEADSEPCLEAR);
 			rf_FreeCallbackDesc(p);
 		}
 
@@ -1349,7 +1602,7 @@ rf_CheckForNewMinHeadSep(raidPtr, row, hsCtr)
 }
 
 /*
- * checks to see that the maximum head separation will not be violated
+ * Checks to see that the maximum head separation will not be violated
  * if we initiate a reconstruction I/O on the indicated disk.
  * Limiting the maximum head separation between two disks eliminates
  * the nasty buffer-stall conditions that occur when one disk races
@@ -1357,47 +1610,54 @@ rf_CheckForNewMinHeadSep(raidPtr, row, hsCtr)
  * This code is complex and unpleasant but it's necessary to avoid
  * some very nasty, albeit fairly rare, reconstruction behavior.
  *
- * returns non-zero if and only if we have to stop working on the
- * indicated disk due to a head-separation delay.  
+ * Returns non-zero if and only if we have to stop working on the
+ * indicated disk due to a head-separation delay.
  */
-int 
+int
 rf_CheckHeadSeparation(
-    RF_Raid_t * raidPtr,
-    RF_PerDiskReconCtrl_t * ctrl,
-    RF_RowCol_t row,
-    RF_RowCol_t col,
-    RF_HeadSepLimit_t hsCtr,
-    RF_ReconUnitNum_t which_ru)
+    RF_Raid_t			*raidPtr,
+    RF_PerDiskReconCtrl_t	*ctrl,
+    RF_RowCol_t			 row,
+    RF_RowCol_t			 col,
+    RF_HeadSepLimit_t		 hsCtr,
+    RF_ReconUnitNum_t		 which_ru
+)
 {
 	RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
 	RF_CallbackDesc_t *cb, *p, *pt;
-	int     retval = 0;
+	int retval = 0;
 
-	/* if we're too far ahead of the slowest disk, stop working on this
-	 * disk until the slower ones catch up.  We do this by scheduling a
+	/*
+	 * If we're too far ahead of the slowest disk, stop working on this
+	 * disk until the slower ones catch up. We do this by scheduling a
 	 * wakeup callback for the time when the slowest disk has caught up.
 	 * We define "caught up" with 20% hysteresis, i.e. the head separation
 	 * must have fallen to at most 80% of the max allowable head
 	 * separation before we'll wake up.
-	 * 
 	 */
 	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
 	if ((raidPtr->headSepLimit >= 0) &&
-	    ((ctrl->headSepCounter - reconCtrlPtr->minHeadSepCounter) > raidPtr->headSepLimit)) {
-		Dprintf6("raid%d: RECON: head sep stall: row %d col %d hsCtr %ld minHSCtr %ld limit %ld\n",
-			 raidPtr->raidid, row, col, ctrl->headSepCounter, 
-			 reconCtrlPtr->minHeadSepCounter, 
-			 raidPtr->headSepLimit);
+	    ((ctrl->headSepCounter - reconCtrlPtr->minHeadSepCounter) >
+	     raidPtr->headSepLimit)) {
+		Dprintf6("raid%d: RECON: head sep stall: row %d col %d hsCtr"
+		    " %ld minHSCtr %ld limit %ld.\n",
+		    raidPtr->raidid, row, col, ctrl->headSepCounter,
+		    reconCtrlPtr->minHeadSepCounter, raidPtr->headSepLimit);
 		cb = rf_AllocCallbackDesc();
-		/* the minHeadSepCounter value we have to get to before we'll
-		 * wake up.  build in 20% hysteresis. */
-		cb->callbackArg.v = (ctrl->headSepCounter - raidPtr->headSepLimit + raidPtr->headSepLimit / 5);
+		/*
+		 * The minHeadSepCounter value we have to get to before we'll
+		 * wake up. Build in 20% hysteresis.
+		 */
+		cb->callbackArg.v = (ctrl->headSepCounter -
+		    raidPtr->headSepLimit + raidPtr->headSepLimit / 5);
 		cb->row = row;
 		cb->col = col;
 		cb->next = NULL;
 
-		/* insert this callback descriptor into the sorted list of
-		 * pending head-sep callbacks */
+		/*
+		 * Insert this callback descriptor into the sorted list of
+		 * pending head-sep callbacks.
+		 */
 		p = reconCtrlPtr->headSepCBList;
 		if (!p)
 			reconCtrlPtr->headSepCBList = cb;
@@ -1406,47 +1666,57 @@ rf_CheckHeadSeparation(
 				cb->next = reconCtrlPtr->headSepCBList;
 				reconCtrlPtr->headSepCBList = cb;
 			} else {
-				for (pt = p, p = p->next; p && (p->callbackArg.v < cb->callbackArg.v); pt = p, p = p->next);
+				for (pt = p, p = p->next;
+				    p && (p->callbackArg.v < cb->callbackArg.v);
+				    pt = p, p = p->next);
 				cb->next = p;
 				pt->next = cb;
 			}
 		retval = 1;
-#if RF_RECON_STATS > 0
+#if	RF_RECON_STATS > 0
 		ctrl->reconCtrl->reconDesc->hsStallCount++;
-#endif				/* RF_RECON_STATS > 0 */
+#endif	/* RF_RECON_STATS > 0 */
 	}
 	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
 
 	return (retval);
 }
-/* 
- * checks to see if reconstruction has been either forced or blocked
- * by a user operation.  if forced, we skip this RU entirely.  else if
- * blocked, put ourselves on the wait list.  else return 0.
+
+
+
+/*
+ * Checks to see if reconstruction has been either forced or blocked
+ * by a user operation. If forced, we skip this RU entirely. Else if
+ * blocked, put ourselves on the wait list. Else return 0.
  *
- * ASSUMES THE PSS MUTEX IS LOCKED UPON ENTRY
+ * ASSUMES THE PSS MUTEX IS LOCKED UPON ENTRY.
  */
-int 
+int
 rf_CheckForcedOrBlockedReconstruction(
-    RF_Raid_t * raidPtr,
-    RF_ReconParityStripeStatus_t * pssPtr,
-    RF_PerDiskReconCtrl_t * ctrl,
-    RF_RowCol_t row,
-    RF_RowCol_t col,
-    RF_StripeNum_t psid,
-    RF_ReconUnitNum_t which_ru)
+    RF_Raid_t			 *raidPtr,
+    RF_ReconParityStripeStatus_t *pssPtr,
+    RF_PerDiskReconCtrl_t	 *ctrl,
+    RF_RowCol_t			  row,
+    RF_RowCol_t			  col,
+    RF_StripeNum_t		  psid,
+    RF_ReconUnitNum_t		  which_ru
+)
 {
 	RF_CallbackDesc_t *cb;
-	int     retcode = 0;
+	int retcode = 0;
 
-	if ((pssPtr->flags & RF_PSS_FORCED_ON_READ) || (pssPtr->flags & RF_PSS_FORCED_ON_WRITE))
+	if ((pssPtr->flags & RF_PSS_FORCED_ON_READ) ||
+	    (pssPtr->flags & RF_PSS_FORCED_ON_WRITE))
 		retcode = RF_PSS_FORCED_ON_WRITE;
 	else
 		if (pssPtr->flags & RF_PSS_RECON_BLOCKED) {
-			Dprintf4("RECON: row %d col %d blocked at psid %ld ru %d\n", row, col, psid, which_ru);
-			cb = rf_AllocCallbackDesc();	/* append ourselves to
+			Dprintf4("RECON: row %d col %d blocked at psid %ld"
+			    " ru %d.\n", row, col, psid, which_ru);
+			cb = rf_AllocCallbackDesc();	/*
+							 * Append ourselves to
 							 * the blockage-wait
-							 * list */
+							 * list.
+							 */
 			cb->row = row;
 			cb->col = col;
 			cb->next = pssPtr->blockWaitList;
@@ -1454,201 +1724,274 @@ rf_CheckForcedOrBlockedReconstruction(
 			retcode = RF_PSS_RECON_BLOCKED;
 		}
 	if (!retcode)
-		pssPtr->flags |= RF_PSS_UNDER_RECON;	/* mark this RU as under
-							 * reconstruction */
+		pssPtr->flags |= RF_PSS_UNDER_RECON;	/*
+							 * Mark this RU as under
+							 * reconstruction.
+							 */
 
 	return (retcode);
 }
+
+
 /*
- * if reconstruction is currently ongoing for the indicated stripeID,
+ * If reconstruction is currently ongoing for the indicated stripeID,
  * reconstruction is forced to completion and we return non-zero to
- * indicate that the caller must wait.  If not, then reconstruction is
- * blocked on the indicated stripe and the routine returns zero.  If
+ * indicate that the caller must wait. If not, then reconstruction is
+ * blocked on the indicated stripe and the routine returns zero. If
  * and only if we return non-zero, we'll cause the cbFunc to get
- * invoked with the cbArg when the reconstruction has completed.  
+ * invoked with the cbArg when the reconstruction has completed.
  */
-int 
-rf_ForceOrBlockRecon(raidPtr, asmap, cbFunc, cbArg)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *asmap;
-	void    (*cbFunc) (RF_Raid_t *, void *);
-	void   *cbArg;
+int
+rf_ForceOrBlockRecon(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap,
+	void (*cbFunc) (RF_Raid_t *, void *), void *cbArg)
 {
-	RF_RowCol_t row = asmap->physInfo->row;	/* which row of the array
-						 * we're working on */
-	RF_StripeNum_t stripeID = asmap->stripeID;	/* the stripe ID we're
-							 * forcing recon on */
-	RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit * raidPtr->Layout.SUsPerRU;	/* num sects in one RU */
-	RF_ReconParityStripeStatus_t *pssPtr;	/* a pointer to the parity
-						 * stripe status structure */
-	RF_StripeNum_t psid;	/* parity stripe id */
-	RF_SectorNum_t offset, fd_offset;	/* disk offset, failed-disk
-						 * offset */
+	RF_RowCol_t row = asmap->physInfo->row;	/*
+						 * Which row of the array
+						 * we're working on.
+						 */
+	RF_StripeNum_t stripeID = asmap->stripeID;	/*
+							 * The stripe ID we're
+							 * forcing recon on.
+							 */
+	RF_SectorCount_t sectorsPerRU = raidPtr->Layout.sectorsPerStripeUnit *
+	    raidPtr->Layout.SUsPerRU;		/* Num sects in one RU. */
+	RF_ReconParityStripeStatus_t *pssPtr;	/*
+						 * A pointer to the parity
+						 * stripe status structure.
+						 */
+	RF_StripeNum_t psid;			/* Parity stripe id. */
+	RF_SectorNum_t offset, fd_offset;	/*
+						 * Disk offset, failed-disk
+						 * offset.
+						 */
 	RF_RowCol_t *diskids;
 	RF_RowCol_t stripe;
-	RF_ReconUnitNum_t which_ru;	/* RU within parity stripe */
+	RF_ReconUnitNum_t which_ru;	/* RU within parity stripe. */
 	RF_RowCol_t fcol, diskno, i;
-	RF_ReconBuffer_t *new_rbuf;	/* ptr to newly allocated rbufs */
-	RF_DiskQueueData_t *req;/* disk I/O req to be enqueued */
+	RF_ReconBuffer_t *new_rbuf;	/* Ptr to newly allocated rbufs. */
+	RF_DiskQueueData_t *req;	/* Disk I/O req to be enqueued. */
 	RF_CallbackDesc_t *cb;
-	int     created = 0, nPromoted;
+	int created = 0, nPromoted;
 
-	psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru);
+	psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID,
+	    &which_ru);
 
 	RF_LOCK_PSS_MUTEX(raidPtr, row, psid);
 
-	pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]->pssTable, psid, which_ru, RF_PSS_CREATE | RF_PSS_RECON_BLOCKED, &created);
+	pssPtr = rf_LookupRUStatus(raidPtr,
+	    raidPtr->reconControl[row]->pssTable, psid, which_ru,
+	    RF_PSS_CREATE | RF_PSS_RECON_BLOCKED, &created);
 
-	/* if recon is not ongoing on this PS, just return */
+	/* If recon is not ongoing on this PS, just return. */
 	if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) {
 		RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
 		return (0);
 	}
-	/* otherwise, we have to wait for reconstruction to complete on this
-	 * RU. */
-	/* In order to avoid waiting for a potentially large number of
+	/*
+	 * Otherwise, we have to wait for reconstruction to complete on this
+	 * RU.
+	 */
+	/*
+	 * In order to avoid waiting for a potentially large number of
 	 * low-priority accesses to complete, we force a normal-priority (i.e.
-	 * not low-priority) reconstruction on this RU. */
-	if (!(pssPtr->flags & RF_PSS_FORCED_ON_WRITE) && !(pssPtr->flags & RF_PSS_FORCED_ON_READ)) {
-		DDprintf1("Forcing recon on psid %ld\n", psid);
-		pssPtr->flags |= RF_PSS_FORCED_ON_WRITE;	/* mark this RU as under
-								 * forced recon */
-		pssPtr->flags &= ~RF_PSS_RECON_BLOCKED;	/* clear the blockage
-							 * that we just set */
+	 * not low-priority) reconstruction on this RU.
+	 */
+	if (!(pssPtr->flags & RF_PSS_FORCED_ON_WRITE) &&
+	    !(pssPtr->flags & RF_PSS_FORCED_ON_READ)) {
+		DDprintf1("Forcing recon on psid %ld.\n", psid);
+		/* Mark this RU as under forced recon. */
+		pssPtr->flags |= RF_PSS_FORCED_ON_WRITE;
+		/* Clear the blockage that we just set. */
+		pssPtr->flags &= ~RF_PSS_RECON_BLOCKED;
 		fcol = raidPtr->reconControl[row]->fcol;
 
-		/* get a listing of the disks comprising the indicated stripe */
-		(raidPtr->Layout.map->IdentifyStripe) (raidPtr, asmap->raidAddress, &diskids, &stripe);
+		/*
+		 * Get a listing of the disks comprising the indicated stripe.
+		 */
+		(raidPtr->Layout.map->IdentifyStripe) (raidPtr,
+		    asmap->raidAddress, &diskids, &stripe);
 		RF_ASSERT(row == stripe);
 
-		/* For previously issued reads, elevate them to normal
-		 * priority.  If the I/O has already completed, it won't be
+		/*
+		 * For previously issued reads, elevate them to normal
+		 * priority. If the I/O has already completed, it won't be
 		 * found in the queue, and hence this will be a no-op. For
-		 * unissued reads, allocate buffers and issue new reads.  The
+		 * unissued reads, allocate buffers and issue new reads. The
 		 * fact that we've set the FORCED bit means that the regular
-		 * recon procs will not re-issue these reqs */
-		for (i = 0; i < raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol; i++)
+		 * recon procs will not re-issue these reqs.
+		 */
+		for (i = 0; i < raidPtr->Layout.numDataCol +
+		    raidPtr->Layout.numParityCol; i++)
 			if ((diskno = diskids[i]) != fcol) {
 				if (pssPtr->issued[diskno]) {
-					nPromoted = rf_DiskIOPromote(&raidPtr->Queues[row][diskno], psid, which_ru);
+					nPromoted = rf_DiskIOPromote(&raidPtr
+					    ->Queues[row][diskno], psid,
+					    which_ru);
 					if (rf_reconDebug && nPromoted)
-						printf("raid%d: promoted read from row %d col %d\n", raidPtr->raidid, row, diskno);
+						printf("raid%d: promoted read"
+						    " from row %d col %d.\n",
+						    raidPtr->raidid, row,
+						    diskno);
 				} else {
-					new_rbuf = rf_MakeReconBuffer(raidPtr, row, diskno, RF_RBUF_TYPE_FORCED);	/* create new buf */
-					rf_ComputePSDiskOffsets(raidPtr, psid, row, diskno, &offset, &fd_offset,
-					    &new_rbuf->spRow, &new_rbuf->spCol, &new_rbuf->spOffset);	/* find offsets & spare
-													 * location */
-					new_rbuf->parityStripeID = psid;	/* fill in the buffer */
+					/* Create new buf. */
+					new_rbuf = rf_MakeReconBuffer(raidPtr,
+					    row, diskno, RF_RBUF_TYPE_FORCED);
+					/* Find offsets & spare locationp */
+					rf_ComputePSDiskOffsets(raidPtr, psid,
+					    row, diskno, &offset, &fd_offset,
+					    &new_rbuf->spRow, &new_rbuf->spCol,
+					    &new_rbuf->spOffset);
+					new_rbuf->parityStripeID = psid;
+					/* Fill in the buffer. */
 					new_rbuf->which_ru = which_ru;
-					new_rbuf->failedDiskSectorOffset = fd_offset;
-					new_rbuf->priority = RF_IO_NORMAL_PRIORITY;
-
-					/* use NULL b_proc b/c all addrs
-					 * should be in kernel space */
-					req = rf_CreateDiskQueueData(RF_IO_TYPE_READ, offset + which_ru * sectorsPerRU, sectorsPerRU, new_rbuf->buffer,
-					    psid, which_ru, (int (*) (void *, int)) rf_ForceReconReadDoneProc, (void *) new_rbuf, NULL,
+					new_rbuf->failedDiskSectorOffset =
+					    fd_offset;
+					new_rbuf->priority =
+					    RF_IO_NORMAL_PRIORITY;
+
+					/*
+					 * Use NULL b_proc b/c all addrs
+					 * should be in kernel space.
+					 */
+					req = rf_CreateDiskQueueData(
+					    RF_IO_TYPE_READ, offset +
+					    which_ru * sectorsPerRU,
+					    sectorsPerRU, new_rbuf->buffer,
+					    psid, which_ru, (int (*)
+					    (void *, int))
+					      rf_ForceReconReadDoneProc,
+					    (void *) new_rbuf, NULL,
 					    NULL, (void *) raidPtr, 0, NULL);
 
-					RF_ASSERT(req);	/* XXX -- fix this --
-							 * XXX */
+					RF_ASSERT(req);	/*
+							 * XXX -- Fix this. --
+							 * XXX
+							 */
 
 					new_rbuf->arg = req;
-					rf_DiskIOEnqueue(&raidPtr->Queues[row][diskno], req, RF_IO_NORMAL_PRIORITY);	/* enqueue the I/O */
-					Dprintf3("raid%d: Issued new read req on row %d col %d\n", raidPtr->raidid, row, diskno);
+					/* Enqueue the I/O. */
+					rf_DiskIOEnqueue(&raidPtr
+					    ->Queues[row][diskno], req,
+					    RF_IO_NORMAL_PRIORITY);
+					Dprintf3("raid%d: Issued new read req"
+					    " on row %d col %d.\n",
+					    raidPtr->raidid, row, diskno);
 				}
 			}
-		/* if the write is sitting in the disk queue, elevate its
-		 * priority */
-		if (rf_DiskIOPromote(&raidPtr->Queues[row][fcol], psid, which_ru))
-			printf("raid%d: promoted write to row %d col %d\n", 
-			       raidPtr->raidid, row, fcol);
+		/*
+		 * If the write is sitting in the disk queue, elevate its
+		 * priority.
+		 */
+		if (rf_DiskIOPromote(&raidPtr->Queues[row][fcol],
+		    psid, which_ru))
+			printf("raid%d: promoted write to row %d col %d.\n",
+			    raidPtr->raidid, row, fcol);
 	}
-	/* install a callback descriptor to be invoked when recon completes on
-	 * this parity stripe. */
+	/*
+	 * Install a callback descriptor to be invoked when recon completes on
+	 * this parity stripe.
+	 */
 	cb = rf_AllocCallbackDesc();
-	/* XXX the following is bogus.. These functions don't really match!!
-	 * GO */
+	/*
+	 * XXX The following is bogus... These functions don't really match !!!
+	 * GO
+	 */
 	cb->callbackFunc = (void (*) (RF_CBParam_t)) cbFunc;
 	cb->callbackArg.p = (void *) cbArg;
 	cb->next = pssPtr->procWaitList;
 	pssPtr->procWaitList = cb;
-	DDprintf2("raid%d: Waiting for forced recon on psid %ld\n", 
-		  raidPtr->raidid, psid);
+	DDprintf2("raid%d: Waiting for forced recon on psid %ld.\n",
+	    raidPtr->raidid, psid);
 
 	RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
 	return (1);
 }
-/* called upon the completion of a forced reconstruction read.
- * all we do is schedule the FORCEDREADONE event.
- * called at interrupt context in the kernel, so don't do anything illegal here.
+
+
+/*
+ * Called upon the completion of a forced reconstruction read.
+ * All we do is schedule the FORCEDREADONE event.
+ * Called at interrupt context in the kernel, so don't do anything illegal here.
  */
-void 
-rf_ForceReconReadDoneProc(arg, status)
-	void   *arg;
-	int     status;
+void
+rf_ForceReconReadDoneProc(void *arg, int status)
 {
 	RF_ReconBuffer_t *rbuf = arg;
 
 	if (status) {
-		printf("Forced recon read failed!\n");	/* fprintf(stderr,"Forced
-							 *  recon read
-							 * failed!\n"); */
+		/* fprintf(stderr, "Forced recon read failed !\n"); */
+		printf("Forced recon read failed !\n");
 		RF_PANIC();
 	}
-	rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col, (void *) rbuf, RF_REVENT_FORCEDREADDONE);
+	rf_CauseReconEvent((RF_Raid_t *) rbuf->raidPtr, rbuf->row, rbuf->col,
+	    (void *) rbuf, RF_REVENT_FORCEDREADDONE);
 }
-/* releases a block on the reconstruction of the indicated stripe */
-int 
-rf_UnblockRecon(raidPtr, asmap)
-	RF_Raid_t *raidPtr;
-	RF_AccessStripeMap_t *asmap;
+
+
+/* Releases a block on the reconstruction of the indicated stripe. */
+int
+rf_UnblockRecon(RF_Raid_t *raidPtr, RF_AccessStripeMap_t *asmap)
 {
 	RF_RowCol_t row = asmap->origRow;
 	RF_StripeNum_t stripeID = asmap->stripeID;
 	RF_ReconParityStripeStatus_t *pssPtr;
 	RF_ReconUnitNum_t which_ru;
 	RF_StripeNum_t psid;
-	int     created = 0;
+	int created = 0;
 	RF_CallbackDesc_t *cb;
 
-	psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID, &which_ru);
+	psid = rf_MapStripeIDToParityStripeID(&raidPtr->Layout, stripeID,
+	    &which_ru);
 	RF_LOCK_PSS_MUTEX(raidPtr, row, psid);
-	pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]->pssTable, psid, which_ru, RF_PSS_NONE, &created);
+	pssPtr = rf_LookupRUStatus(raidPtr, raidPtr->reconControl[row]
+	    ->pssTable, psid, which_ru, RF_PSS_NONE, &created);
 
-	/* When recon is forced, the pss desc can get deleted before we get
+	/*
+	 * When recon is forced, the pss desc can get deleted before we get
 	 * back to unblock recon. But, this can _only_ happen when recon is
 	 * forced. It would be good to put some kind of sanity check here, but
-	 * how to decide if recon was just forced or not? */
+	 * how to decide if recon was just forced or not ?
+	 */
 	if (!pssPtr) {
-		/* printf("Warning: no pss descriptor upon unblock on psid %ld
-		 * RU %d\n",psid,which_ru); */
+		/*
+		 * printf("Warning: no pss descriptor upon unblock on psid %ld"
+		 *     " RU %d.\n", psid, which_ru);
+		 */
 		if (rf_reconDebug || rf_pssDebug)
-			printf("Warning: no pss descriptor upon unblock on psid %ld RU %d\n", (long) psid, which_ru);
+			printf("Warning: no pss descriptor upon unblock on"
+			    " psid %ld RU %d.\n", (long) psid, which_ru);
 		goto out;
 	}
 	pssPtr->blockCount--;
-	Dprintf3("raid%d: unblocking recon on psid %ld: blockcount is %d\n",
-		 raidPtr->raidid, psid, pssPtr->blockCount);
-	if (pssPtr->blockCount == 0) {	/* if recon blockage has been released */
+	Dprintf3("raid%d: unblocking recon on psid %ld: blockcount is %d.\n",
+	    raidPtr->raidid, psid, pssPtr->blockCount);
+	if (pssPtr->blockCount == 0) {
+		/* If recon blockage has been released. */
 
-		/* unblock recon before calling CauseReconEvent in case
+		/*
+		 * Unblock recon before calling CauseReconEvent in case
 		 * CauseReconEvent causes us to try to issue a new read before
-		 * returning here. */
+		 * returning here.
+		 */
 		pssPtr->flags &= ~RF_PSS_RECON_BLOCKED;
 
 
-		while (pssPtr->blockWaitList) {	
-			/* spin through the block-wait list and
-			   release all the waiters */
+		while (pssPtr->blockWaitList) {
+			/*
+			 * Spin through the block-wait list and
+			 * release all the waiters.
+			 */
 			cb = pssPtr->blockWaitList;
 			pssPtr->blockWaitList = cb->next;
 			cb->next = NULL;
-			rf_CauseReconEvent(raidPtr, cb->row, cb->col, NULL, RF_REVENT_BLOCKCLEAR);
+			rf_CauseReconEvent(raidPtr, cb->row, cb->col, NULL,
+			    RF_REVENT_BLOCKCLEAR);
 			rf_FreeCallbackDesc(cb);
 		}
 		if (!(pssPtr->flags & RF_PSS_UNDER_RECON)) {
-			/* if no recon was requested while recon was blocked */
-			rf_PSStatusDelete(raidPtr, raidPtr->reconControl[row]->pssTable, pssPtr);
+			/* If no recon was requested while recon was blocked. */
+			rf_PSStatusDelete(raidPtr, raidPtr->reconControl[row]
+			    ->pssTable, pssPtr);
 		}
 	}
 out:
diff --git a/sys/dev/raidframe/rf_reconstruct.h b/sys/dev/raidframe/rf_reconstruct.h
index 8a0842ce867..42296b5db1d 100644
--- a/sys/dev/raidframe/rf_reconstruct.h
+++ b/sys/dev/raidframe/rf_reconstruct.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconstruct.h,v 1.4 2000/08/08 16:07:45 peter Exp $	*/
+/*	$OpenBSD: rf_reconstruct.h,v 1.5 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconstruct.h,v 1.5 2000/05/28 00:48:30 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,9 +28,9 @@
  * rights to redistribute these changes.
  */
 
-/*********************************************************
- * rf_reconstruct.h -- header file for reconstruction code
- *********************************************************/
+/***********************************************************
+ * rf_reconstruct.h -- Header file for reconstruction code.
+ ***********************************************************/
 
 #ifndef _RF__RF_RECONSTRUCT_H_
 #define _RF__RF_RECONSTRUCT_H_
@@ -39,47 +40,93 @@
 #include "rf_reconmap.h"
 #include "rf_psstatus.h"
 
-/* reconstruction configuration information */
+/* Reconstruction configuration information. */
 struct RF_ReconConfig_s {
-	unsigned numFloatingReconBufs;	/* number of floating recon bufs to
-					 * use */
-	RF_HeadSepLimit_t headSepLimit;	/* how far apart the heads are allow
-					 * to become, in parity stripes */
+	unsigned		numFloatingReconBufs;
+						/*
+						 * Number of floating recon
+						 * bufs to use.
+						 */
+	RF_HeadSepLimit_t	headSepLimit;	/*
+						 * How far apart the heads are
+						 * allowed to become, in parity
+						 * stripes.
+						 */
 };
-/* a reconstruction buffer */
+
+/* A reconstruction buffer. */
 struct RF_ReconBuffer_s {
-	RF_Raid_t *raidPtr;	/* void * to avoid recursive includes */
-	caddr_t buffer;		/* points to the data */
-	RF_StripeNum_t parityStripeID;	/* the parity stripe that this data
-					 * relates to */
-	int     which_ru;	/* which reconstruction unit within the PSS */
-	RF_SectorNum_t failedDiskSectorOffset;	/* the offset into the failed
-						 * disk */
-	RF_RowCol_t row, col;	/* which disk this buffer belongs to or is
-				 * targeted at */
-	RF_StripeCount_t count;	/* counts the # of SUs installed so far */
-	int     priority;	/* used to force hi priority recon */
-	RF_RbufType_t type;	/* FORCED or FLOATING */
-	char   *arrived;	/* [x] = 1/0 if SU from disk x has/hasn't
-				 * arrived */
-	RF_ReconBuffer_t *next;	/* used for buffer management */
-	void   *arg;		/* generic field for general use */
-	RF_RowCol_t spRow, spCol;	/* spare disk to which this buf should
-					 * be written */
-	/* if dist sparing off, always identifies the replacement disk */
-	RF_SectorNum_t spOffset;/* offset into the spare disk */
-	/* if dist sparing off, identical to failedDiskSectorOffset */
-	RF_ReconParityStripeStatus_t *pssPtr;	/* debug- pss associated with
-						 * issue-pending write */
+	RF_Raid_t		*raidPtr;	/*
+						 * (void *) to avoid recursive
+						 * includes.
+						 */
+	caddr_t			 buffer;	/* Points to the data. */
+	RF_StripeNum_t		 parityStripeID;/*
+						 * The parity stripe that this
+						 * data relates to.
+						 */
+	int			 which_ru;	/*
+						 * Which reconstruction unit
+						 * within the PSS.
+						 */
+	RF_SectorNum_t		 failedDiskSectorOffset;
+						/*
+						 * The offset into the failed
+						 * disk.
+						 */
+	RF_RowCol_t		 row, col;	/*
+						 * Which disk this buffer
+						 * belongs to or is targeted at.
+						 */
+	RF_StripeCount_t	 count;		/*
+						 * Counts the # of SUs
+						 * installed so far.
+						 */
+	int			 priority;	/*
+						 * Used to force high priority
+						 * recon.
+						 */
+	RF_RbufType_t		 type;		/* FORCED or FLOATING. */
+	char			*arrived;	/*
+						 * [x] = 1/0 if SU from disk x
+						 * has/hasn't arrived.
+						 */
+	RF_ReconBuffer_t	*next;		/*
+						 * Used for buffer management.
+						 */
+	void			*arg;		/*
+						 * Generic field for general
+						 * use.
+						 */
+	RF_RowCol_t		 spRow, spCol;	/*
+						 * Spare disk to which this buf
+						 * should be written.
+						 */
+	/* If dist sparing off, always identifies the replacement disk */
+	RF_SectorNum_t		 spOffset;	/*
+						 * Offset into the spare disk.
+						 */
+	/* If dist sparing off, identical to failedDiskSectorOffset */
+	RF_ReconParityStripeStatus_t *pssPtr;	/*
+						 * Debug pss associated with
+						 * issue-pending write.
+						 */
 };
-/* a reconstruction event descriptor.  The event types currently are:
- *    RF_REVENT_READDONE    -- a read operation has completed
- *    RF_REVENT_WRITEDONE   -- a write operation has completed
- *    RF_REVENT_BUFREADY    -- the buffer manager has produced a full buffer
- *    RF_REVENT_BLOCKCLEAR  -- a reconstruction blockage has been cleared
- *    RF_REVENT_BUFCLEAR    -- the buffer manager has released a process blocked on submission
- *    RF_REVENT_SKIP        -- we need to skip the current RU and go on to the next one, typ. b/c we found recon forced
- *    RF_REVENT_FORCEDREADONE- a forced-reconstructoin read operation has completed
+
+/*
+ * A reconstruction event descriptor. The event types currently are:
+ *    RF_REVENT_READDONE	-- A read operation has completed.
+ *    RF_REVENT_WRITEDONE	-- A write operation has completed.
+ *    RF_REVENT_BUFREADY	-- The buffer manager has produced a
+ *				   full buffer.
+ *    RF_REVENT_BLOCKCLEAR	-- A reconstruction blockage has been cleared.
+ *    RF_REVENT_BUFCLEAR	-- The buffer manager has released a process
+ *				   blocked on submission.
+ *    RF_REVENT_SKIP		-- We need to skip the current RU and go on
+ *				   to the next one, typ. b/c we found recon
+ *				   forced.
+ *    RF_REVENT_FORCEDREADONE	-- A forced-reconstructoin read operation has
+ *				   completed.
  */
 typedef enum RF_Revent_e {
 	RF_REVENT_READDONE,
@@ -90,113 +137,171 @@ typedef enum RF_Revent_e {
 	RF_REVENT_HEADSEPCLEAR,
 	RF_REVENT_SKIP,
 	RF_REVENT_FORCEDREADDONE
-}       RF_Revent_t;
+} RF_Revent_t;
 
 struct RF_ReconEvent_s {
-	RF_Revent_t type;	/* what kind of event has occurred */
-	RF_RowCol_t col;	/* row ID is implicit in the queue in which
-				 * the event is placed */
-	void   *arg;		/* a generic argument */
-	RF_ReconEvent_t *next;
+	RF_Revent_t		 type;	/* What kind of event has occurred. */
+	RF_RowCol_t		 col;	/*
+					 * Row ID is implicit in the queue in
+					 * which the event is placed.
+					 */
+	void			*arg;	/* A generic argument. */
+	RF_ReconEvent_t		*next;
 };
+
 /*
- * Reconstruction control information maintained per-disk
+ * Reconstruction control information maintained per-disk.
  * (for surviving disks)
  */
 struct RF_PerDiskReconCtrl_s {
-	RF_ReconCtrl_t *reconCtrl;
-	RF_RowCol_t row, col;	/* to make this structure self-identifying */
-	RF_StripeNum_t curPSID;	/* the next parity stripe ID to check on this
-				 * disk */
-	RF_HeadSepLimit_t headSepCounter;	/* counter used to control
-						 * maximum head separation */
-	RF_SectorNum_t diskOffset;	/* the offset into the indicated disk
-					 * of the current PU */
-	RF_ReconUnitNum_t ru_count;	/* this counts off the recon units
-					 * within each parity unit */
-	RF_ReconBuffer_t *rbuf;	/* the recon buffer assigned to this disk */
+	RF_ReconCtrl_t		*reconCtrl;
+	RF_RowCol_t		 row, col;	/*
+						 * To make this structure
+						 * self-identifying.
+						 */
+	RF_StripeNum_t		 curPSID;	/*
+						 * The next parity stripe ID
+						 * to check on this disk.
+						 */
+	RF_HeadSepLimit_t	 headSepCounter;/*
+						 * Counter used to control
+						 * maximum head separation.
+						 */
+	RF_SectorNum_t		 diskOffset;	/*
+						 * The offset into the
+						 * indicated disk
+						 * of the current PU.
+						 */
+	RF_ReconUnitNum_t	 ru_count;	/*
+						 * This counts off the recon
+						 * units within each parity
+						 * unit.
+						 */
+	RF_ReconBuffer_t	*rbuf;		/*
+						 * The recon buffer assigned
+						 * to this disk.
+						 */
 };
-/* main reconstruction control structure */
+
+/* Main reconstruction control structure. */
 struct RF_ReconCtrl_s {
-	RF_RaidReconDesc_t *reconDesc;
-	RF_RowCol_t fcol;	/* which column has failed */
-	RF_PerDiskReconCtrl_t *perDiskInfo;	/* information maintained
-						 * per-disk */
-	RF_ReconMap_t *reconMap;/* map of what has/has not been reconstructed */
-	RF_RowCol_t spareRow;	/* which of the spare disks we're using */
-	RF_RowCol_t spareCol;
-	RF_StripeNum_t lastPSID;/* the ID of the last parity stripe we want
-				 * reconstructed */
-	int     percentComplete;/* percentage completion of reconstruction */
-	int     numRUsComplete; /* number of Reconstruction Units done */
-	int     numRUsTotal;    /* total number of Reconstruction Units */
-
-	/* reconstruction event queue */
-	RF_ReconEvent_t *eventQueue;	/* queue of pending reconstruction
-					 * events */
-	        RF_DECLARE_MUTEX(eq_mutex)	/* mutex for locking event
-						 * queue */
-	        RF_DECLARE_COND(eq_cond)	/* condition variable for
-						 * signalling recon events */
-	int     eq_count;	/* debug only */
-
-	/* reconstruction buffer management */
-	        RF_DECLARE_MUTEX(rb_mutex)	/* mutex for messing around
-						 * with recon buffers */
-	RF_ReconBuffer_t *floatingRbufs;	/* available floating
-						 * reconstruction buffers */
-	RF_ReconBuffer_t *committedRbufs;	/* recon buffers that have
-						 * been committed to some
-						 * waiting disk */
-	RF_ReconBuffer_t *fullBufferList;	/* full buffers waiting to be
-						 * written out */
-	RF_ReconBuffer_t *priorityList;	/* full buffers that have been
-					 * elevated to higher priority */
-	RF_CallbackDesc_t *bufferWaitList;	/* disks that are currently
-						 * blocked waiting for buffers */
-
-	/* parity stripe status table */
-	RF_PSStatusHeader_t *pssTable;	/* stores the reconstruction status of
-					 * active parity stripes */
-
-	/* maximum-head separation control */
-	RF_HeadSepLimit_t minHeadSepCounter;	/* the minimum hs counter over
-						 * all disks */
-	RF_CallbackDesc_t *headSepCBList;	/* list of callbacks to be
-						 * done as minPSID advances */
-
-	/* performance monitoring */
-	struct timeval starttime;	/* recon start time */
-
-	void    (*continueFunc) (void *);	/* function to call when io
-						 * returns */
-	void   *continueArg;	/* argument for Func */
-};
-/* the default priority for reconstruction accesses */
-#define RF_IO_RECON_PRIORITY RF_IO_LOW_PRIORITY
+	RF_RaidReconDesc_t	*reconDesc;
+	RF_RowCol_t		 fcol;		/* Which column has failed. */
+	RF_PerDiskReconCtrl_t	*perDiskInfo;	/*
+						 * Information maintained
+						 * per-disk.
+						 */
+	RF_ReconMap_t		*reconMap;	/*
+						 * Map of what has/has not
+						 * been reconstructed.
+						 */
+	RF_RowCol_t		 spareRow;	/*
+						 * Which of the spare disks
+						 * we're using.
+						 */
+	RF_RowCol_t		 spareCol;
+	RF_StripeNum_t		 lastPSID;	/*
+						 * The ID of the last
+						 * parity stripe we want
+						 * reconstructed.
+						 */
+	int			 percentComplete;
+						/*
+						 * Percentage completion of
+						 * reconstruction.
+						 */
+	int			 numRUsComplete;/*
+						 * Number of Reconstruction
+						 * Units done.
+						 */
+	int			 numRUsTotal;	/*
+						 * Total number of
+						 * Reconstruction Units.
+						 */
 
-int     rf_ConfigureReconstruction(RF_ShutdownList_t ** listp);
+	/* Reconstruction event queue. */
+	RF_ReconEvent_t		*eventQueue;	/*
+						 * Queue of pending
+						 * reconstruction events.
+						 */
+	RF_DECLARE_MUTEX	(eq_mutex);	/*
+						 * Mutex for locking event
+						 * queue.
+						 */
+	RF_DECLARE_COND		(eq_cond);	/*
+						 * Condition variable for
+						 * signalling recon events.
+						 */
+	int			 eq_count;	/* Debug only. */
 
-int 
-rf_ReconstructFailedDisk(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_RowCol_t col);
+	/* Reconstruction buffer management. */
+	RF_DECLARE_MUTEX	(rb_mutex);	/*
+						 * Mutex for messing around
+						 * with recon buffers.
+						 */
+	RF_ReconBuffer_t	*floatingRbufs;	/*
+						 * Available floating
+						 * reconstruction buffers.
+						 */
+	RF_ReconBuffer_t	*committedRbufs;/*
+						 * Recon buffers that have
+						 * been committed to some
+						 * waiting disk.
+						 */
+	RF_ReconBuffer_t	*fullBufferList;/*
+						 * Full buffers waiting to be
+						 * written out.
+						 */
+	RF_ReconBuffer_t	*priorityList;	/*
+						 * Full buffers that have been
+						 * elevated to higher priority.
+						 */
+	RF_CallbackDesc_t	*bufferWaitList;/*
+						 * Disks that are currently
+						 * blocked waiting for buffers.
+						 */
 
-int 
-rf_ReconstructFailedDiskBasic(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_RowCol_t col);
+	/* Parity stripe status table. */
+	RF_PSStatusHeader_t	*pssTable;	/*
+						 * Stores the reconstruction
+						 * status of active parity
+						 * stripes.
+						 */
 
-int 
-rf_ReconstructInPlace(RF_Raid_t * raidPtr, RF_RowCol_t row, RF_RowCol_t col);
+	/* Maximum-head separation control. */
+	RF_HeadSepLimit_t	 minHeadSepCounter;
+						/*
+						 * The minimum hs counter over
+						 * all disks.
+						 */
+	RF_CallbackDesc_t	*headSepCBList;	/*
+						 * List of callbacks to be
+						 * done as minPSID advances.
+						 */
 
-int     rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t * reconDesc);
+	/* Performance monitoring. */
+	struct timeval		 starttime;	/* Recon start time. */
 
-int 
-rf_ForceOrBlockRecon(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    void (*cbFunc) (RF_Raid_t *, void *), void *cbArg);
+	void		       (*continueFunc) (void *);
+						/*
+						 * Function to call when io
+						 * returns.
+						 */
+	void			*continueArg;	/* Argument for Func. */
+};
 
-	int     rf_UnblockRecon(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
+/* The default priority for reconstruction accesses. */
+#define RF_IO_RECON_PRIORITY RF_IO_LOW_PRIORITY
 
-	int     rf_RegisterReconDoneProc(RF_Raid_t * raidPtr, void (*proc) (RF_Raid_t *, void *), void *arg,
-            RF_ReconDoneProc_t ** handlep);
+int  rf_ConfigureReconstruction(RF_ShutdownList_t **);
+int  rf_ReconstructFailedDisk(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+int  rf_ReconstructFailedDiskBasic(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+int  rf_ReconstructInPlace(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
+int  rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t *);
+int  rf_ForceOrBlockRecon(RF_Raid_t *, RF_AccessStripeMap_t *,
+	void (*) (RF_Raid_t *, void *), void *);
+int  rf_UnblockRecon(RF_Raid_t *, RF_AccessStripeMap_t *);
+int  rf_RegisterReconDoneProc(RF_Raid_t *, void (*) (RF_Raid_t *, void *),
+	void *, RF_ReconDoneProc_t **);
 
-#endif				/* !_RF__RF_RECONSTRUCT_H_ */
+#endif	/* !_RF__RF_RECONSTRUCT_H_ */
diff --git a/sys/dev/raidframe/rf_reconutil.c b/sys/dev/raidframe/rf_reconutil.c
index f4c83910850..b75c6425a76 100644
--- a/sys/dev/raidframe/rf_reconutil.c
+++ b/sys/dev/raidframe/rf_reconutil.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconutil.c,v 1.2 1999/02/16 00:03:23 niklas Exp $	*/
+/*	$OpenBSD: rf_reconutil.c,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconutil.c,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,9 +28,9 @@
  * rights to redistribute these changes.
  */
 
-/********************************************
- * rf_reconutil.c -- reconstruction utilities
- ********************************************/
+/**********************************************
+ * rf_reconutil.c -- Reconstruction utilities.
+ **********************************************/
 
 #include "rf_types.h"
 #include "rf_raid.h"
@@ -42,33 +43,40 @@
 #include "rf_interdecluster.h"
 #include "rf_chaindecluster.h"
 
-/*******************************************************************
- * allocates/frees the reconstruction control information structures
- *******************************************************************/
+
+/*********************************************************************
+ * Allocates/frees the reconstruction control information structures.
+ *********************************************************************/
 RF_ReconCtrl_t *
-rf_MakeReconControl(reconDesc, frow, fcol, srow, scol)
-	RF_RaidReconDesc_t *reconDesc;
-	RF_RowCol_t frow;	/* failed row and column */
-	RF_RowCol_t fcol;
-	RF_RowCol_t srow;	/* identifies which spare we're using */
-	RF_RowCol_t scol;
+rf_MakeReconControl(
+    RF_RaidReconDesc_t	*reconDesc,
+    RF_RowCol_t		 frow,	/* Failed row and column. */
+    RF_RowCol_t		 fcol,
+    RF_RowCol_t		 srow,	/* Identifies which spare we're using. */
+    RF_RowCol_t		 scol
+)
 {
 	RF_Raid_t *raidPtr = reconDesc->raidPtr;
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU / layoutPtr->SUsPerRU;
+	RF_ReconUnitCount_t RUsPerPU = layoutPtr->SUsPerPU /
+	    layoutPtr->SUsPerRU;
 	RF_ReconUnitCount_t numSpareRUs;
 	RF_ReconCtrl_t *reconCtrlPtr;
 	RF_ReconBuffer_t *rbuf;
 	RF_LayoutSW_t *lp;
-	int     retcode, rc;
+	int retcode, rc;
 	RF_RowCol_t i;
 
 	lp = raidPtr->Layout.map;
 
-	/* make and zero the global reconstruction structure and the per-disk
-	 * structure */
+	/*
+	 * Make and zero the global reconstruction structure and the per-disk
+	 * structure.
+	 */
 	RF_Calloc(reconCtrlPtr, 1, sizeof(RF_ReconCtrl_t), (RF_ReconCtrl_t *));
-	RF_Calloc(reconCtrlPtr->perDiskInfo, raidPtr->numCol, sizeof(RF_PerDiskReconCtrl_t), (RF_PerDiskReconCtrl_t *));	/* this zeros it */
+	/* This zeros it. */
+	RF_Calloc(reconCtrlPtr->perDiskInfo, raidPtr->numCol,
+	    sizeof(RF_PerDiskReconCtrl_t), (RF_PerDiskReconCtrl_t *));
 	reconCtrlPtr->reconDesc = reconDesc;
 	reconCtrlPtr->fcol = fcol;
 	reconCtrlPtr->spareRow = srow;
@@ -76,19 +84,20 @@ rf_MakeReconControl(reconDesc, frow, fcol, srow, scol)
 	reconCtrlPtr->lastPSID = layoutPtr->numStripe / layoutPtr->SUsPerPU;
 	reconCtrlPtr->percentComplete = 0;
 
-	/* initialize each per-disk recon information structure */
+	/* Initialize each per-disk recon information structure. */
 	for (i = 0; i < raidPtr->numCol; i++) {
 		reconCtrlPtr->perDiskInfo[i].reconCtrl = reconCtrlPtr;
 		reconCtrlPtr->perDiskInfo[i].row = frow;
 		reconCtrlPtr->perDiskInfo[i].col = i;
-		reconCtrlPtr->perDiskInfo[i].curPSID = -1;	/* make it appear as if
-								 * we just finished an
-								 * RU */
+		/* Make it appear as if we just finished an RU. */
+		reconCtrlPtr->perDiskInfo[i].curPSID = -1;
 		reconCtrlPtr->perDiskInfo[i].ru_count = RUsPerPU - 1;
 	}
 
-	/* Get the number of spare units per disk and the sparemap in case
-	 * spare is distributed  */
+	/*
+	 * Get the number of spare units per disk and the sparemap in case
+	 * spare is distributed.
+	 */
 
 	if (lp->GetNumSpareRUs) {
 		numSpareRUs = lp->GetNumSpareRUs(raidPtr);
@@ -97,47 +106,50 @@ rf_MakeReconControl(reconDesc, frow, fcol, srow, scol)
 	}
 
 	/*
-         * Not all distributed sparing archs need dynamic mappings
-         */
+	 * Not all distributed sparing archs need dynamic mappings.
+	 */
 	if (lp->InstallSpareTable) {
 		retcode = rf_InstallSpareTable(raidPtr, frow, fcol);
 		if (retcode) {
-			RF_PANIC();	/* XXX fix this */
+			RF_PANIC();	/* XXX Fix this. */
 		}
 	}
-	/* make the reconstruction map */
-	reconCtrlPtr->reconMap = rf_MakeReconMap(raidPtr, (int) (layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit),
+	/* Make the reconstruction map. */
+	reconCtrlPtr->reconMap = rf_MakeReconMap(raidPtr,
+	    (int) (layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit),
 	    raidPtr->sectorsPerDisk, numSpareRUs);
 
-	/* make the per-disk reconstruction buffers */
+	/* Make the per-disk reconstruction buffers. */
 	for (i = 0; i < raidPtr->numCol; i++) {
-		reconCtrlPtr->perDiskInfo[i].rbuf = (i == fcol) ? NULL : rf_MakeReconBuffer(raidPtr, frow, i, RF_RBUF_TYPE_EXCLUSIVE);
+		reconCtrlPtr->perDiskInfo[i].rbuf = (i == fcol) ? NULL :
+		    rf_MakeReconBuffer(raidPtr, frow, i,
+		     RF_RBUF_TYPE_EXCLUSIVE);
 	}
 
-	/* initialize the event queue */
+	/* Initialize the event queue. */
 	rc = rf_mutex_init(&reconCtrlPtr->eq_mutex);
 	if (rc) {
-		/* XXX deallocate, cleanup */
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		/* XXX Deallocate, cleanup. */
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
+		    __FILE__, __LINE__, rc);
 		return (NULL);
 	}
 	rc = rf_cond_init(&reconCtrlPtr->eq_cond);
 	if (rc) {
-		/* XXX deallocate, cleanup */
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		/* XXX Deallocate, cleanup. */
+		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d.\n",
+		    __FILE__, __LINE__, rc);
 		return (NULL);
 	}
 	reconCtrlPtr->eventQueue = NULL;
 	reconCtrlPtr->eq_count = 0;
 
-	/* make the floating recon buffers and append them to the free list */
+	/* Make the floating recon buffers and append them to the free list. */
 	rc = rf_mutex_init(&reconCtrlPtr->rb_mutex);
 	if (rc) {
-		/* XXX deallocate, cleanup */
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		/* XXX Deallocate, cleanup. */
+		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d.\n",
+		    __FILE__, __LINE__, rc);
 		return (NULL);
 	}
 	reconCtrlPtr->fullBufferList = NULL;
@@ -145,24 +157,23 @@ rf_MakeReconControl(reconDesc, frow, fcol, srow, scol)
 	reconCtrlPtr->floatingRbufs = NULL;
 	reconCtrlPtr->committedRbufs = NULL;
 	for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
-		rbuf = rf_MakeReconBuffer(raidPtr, frow, fcol, RF_RBUF_TYPE_FLOATING);
+		rbuf = rf_MakeReconBuffer(raidPtr, frow, fcol,
+		    RF_RBUF_TYPE_FLOATING);
 		rbuf->next = reconCtrlPtr->floatingRbufs;
 		reconCtrlPtr->floatingRbufs = rbuf;
 	}
 
-	/* create the parity stripe status table */
+	/* Create the parity stripe status table. */
 	reconCtrlPtr->pssTable = rf_MakeParityStripeStatusTable(raidPtr);
 
-	/* set the initial min head sep counter val */
+	/* Set the initial min head sep counter val. */
 	reconCtrlPtr->minHeadSepCounter = 0;
 
 	return (reconCtrlPtr);
 }
 
-void 
-rf_FreeReconControl(raidPtr, row)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
+void
+rf_FreeReconControl(RF_Raid_t *raidPtr, RF_RowCol_t row)
 {
 	RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
 	RF_ReconBuffer_t *t;
@@ -183,17 +194,17 @@ rf_FreeReconControl(raidPtr, row)
 	rf_cond_destroy(&reconCtrlPtr->eq_cond);
 	rf_FreeReconMap(reconCtrlPtr->reconMap);
 	rf_FreeParityStripeStatusTable(raidPtr, reconCtrlPtr->pssTable);
-	RF_Free(reconCtrlPtr->perDiskInfo, raidPtr->numCol * sizeof(RF_PerDiskReconCtrl_t));
+	RF_Free(reconCtrlPtr->perDiskInfo, raidPtr->numCol *
+	    sizeof(RF_PerDiskReconCtrl_t));
 	RF_Free(reconCtrlPtr, sizeof(*reconCtrlPtr));
 }
 
 
-/******************************************************************************
- * computes the default head separation limit
+/*****************************************************************************
+ * Computes the default head separation limit.
  *****************************************************************************/
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimit(raidPtr)
-	RF_Raid_t *raidPtr;
+RF_HeadSepLimit_t
+rf_GetDefaultHeadSepLimit(RF_Raid_t *raidPtr)
 {
 	RF_HeadSepLimit_t hsl;
 	RF_LayoutSW_t *lp;
@@ -206,15 +217,14 @@ rf_GetDefaultHeadSepLimit(raidPtr)
 }
 
 
-/******************************************************************************
- * computes the default number of floating recon buffers
+/*****************************************************************************
+ * Computes the default number of floating recon buffers.
  *****************************************************************************/
-int 
-rf_GetDefaultNumFloatingReconBuffers(raidPtr)
-	RF_Raid_t *raidPtr;
+int
+rf_GetDefaultNumFloatingReconBuffers(RF_Raid_t *raidPtr)
 {
 	RF_LayoutSW_t *lp;
-	int     nrb;
+	int nrb;
 
 	lp = raidPtr->Layout.map;
 	if (lp->GetDefaultNumFloatingReconBuffers == NULL)
@@ -224,19 +234,17 @@ rf_GetDefaultNumFloatingReconBuffers(raidPtr)
 }
 
 
-/******************************************************************************
- * creates and initializes a reconstruction buffer
+/*****************************************************************************
+ * Creates and initializes a reconstruction buffer.
  *****************************************************************************/
 RF_ReconBuffer_t *
-rf_MakeReconBuffer(
-    RF_Raid_t * raidPtr,
-    RF_RowCol_t row,
-    RF_RowCol_t col,
+rf_MakeReconBuffer(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
     RF_RbufType_t type)
 {
 	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
 	RF_ReconBuffer_t *t;
-	u_int   recon_buffer_size = rf_RaidAddressToByte(raidPtr, layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit);
+	u_int recon_buffer_size = rf_RaidAddressToByte(raidPtr,
+	    layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit);
 
 	RF_Malloc(t, sizeof(RF_ReconBuffer_t), (RF_ReconBuffer_t *));
 	RF_Malloc(t->buffer, recon_buffer_size, (caddr_t));
@@ -250,15 +258,17 @@ rf_MakeReconBuffer(
 	t->next = NULL;
 	return (t);
 }
-/******************************************************************************
- * frees a reconstruction buffer
+
+
+/*****************************************************************************
+ * Frees a reconstruction buffer.
  *****************************************************************************/
-void 
-rf_FreeReconBuffer(rbuf)
-	RF_ReconBuffer_t *rbuf;
+void
+rf_FreeReconBuffer(RF_ReconBuffer_t *rbuf)
 {
 	RF_Raid_t *raidPtr = rbuf->raidPtr;
-	u_int   recon_buffer_size = rf_RaidAddressToByte(raidPtr, raidPtr->Layout.SUsPerRU * raidPtr->Layout.sectorsPerStripeUnit);
+	u_int recon_buffer_size = rf_RaidAddressToByte(raidPtr,
+	    raidPtr->Layout.SUsPerRU * raidPtr->Layout.sectorsPerStripeUnit);
 
 	RF_Free(rbuf->arrived, raidPtr->numCol * sizeof(char));
 	RF_Free(rbuf->buffer, recon_buffer_size);
@@ -266,18 +276,16 @@ rf_FreeReconBuffer(rbuf)
 }
 
 
-/******************************************************************************
- * debug only:  sanity check the number of floating recon bufs in use
+/*****************************************************************************
+ * Debug only:  Sanity check the number of floating recon bufs in use.
  *****************************************************************************/
-void 
-rf_CheckFloatingRbufCount(raidPtr, dolock)
-	RF_Raid_t *raidPtr;
-	int     dolock;
+void
+rf_CheckFloatingRbufCount(RF_Raid_t *raidPtr, int dolock)
 {
 	RF_ReconParityStripeStatus_t *p;
 	RF_PSStatusHeader_t *pssTable;
 	RF_ReconBuffer_t *rbuf;
-	int     i, j, sum = 0;
+	int i, j, sum = 0;
 	RF_RowCol_t frow = 0;
 
 	for (i = 0; i < raidPtr->numRow; i++)
@@ -312,19 +320,23 @@ rf_CheckFloatingRbufCount(raidPtr, dolock)
 		RF_UNLOCK_MUTEX(pssTable[i].mutex);
 	}
 
-	for (rbuf = raidPtr->reconControl[frow]->floatingRbufs; rbuf; rbuf = rbuf->next) {
+	for (rbuf = raidPtr->reconControl[frow]->floatingRbufs; rbuf;
+	     rbuf = rbuf->next) {
 		if (rbuf->type == RF_RBUF_TYPE_FLOATING)
 			sum++;
 	}
-	for (rbuf = raidPtr->reconControl[frow]->committedRbufs; rbuf; rbuf = rbuf->next) {
+	for (rbuf = raidPtr->reconControl[frow]->committedRbufs; rbuf;
+	     rbuf = rbuf->next) {
 		if (rbuf->type == RF_RBUF_TYPE_FLOATING)
 			sum++;
 	}
-	for (rbuf = raidPtr->reconControl[frow]->fullBufferList; rbuf; rbuf = rbuf->next) {
+	for (rbuf = raidPtr->reconControl[frow]->fullBufferList; rbuf;
+	     rbuf = rbuf->next) {
 		if (rbuf->type == RF_RBUF_TYPE_FLOATING)
 			sum++;
 	}
-	for (rbuf = raidPtr->reconControl[frow]->priorityList; rbuf; rbuf = rbuf->next) {
+	for (rbuf = raidPtr->reconControl[frow]->priorityList; rbuf;
+	     rbuf = rbuf->next) {
 		if (rbuf->type == RF_RBUF_TYPE_FLOATING)
 			sum++;
 	}
diff --git a/sys/dev/raidframe/rf_reconutil.h b/sys/dev/raidframe/rf_reconutil.h
index 4c8d1b9924f..24051b05d63 100644
--- a/sys/dev/raidframe/rf_reconutil.h
+++ b/sys/dev/raidframe/rf_reconutil.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_reconutil.h,v 1.2 1999/02/16 00:03:24 niklas Exp $	*/
+/*	$OpenBSD: rf_reconutil.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_reconutil.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,26 +28,24 @@
  * rights to redistribute these changes.
  */
 
-/************************************************************
- * rf_reconutil.h -- header file for reconstruction utilities
- ************************************************************/
+/**************************************************************
+ * rf_reconutil.h -- Header file for reconstruction utilities.
+ **************************************************************/
 
-#ifndef _RF__RF_RECONUTIL_H_
-#define _RF__RF_RECONUTIL_H_
+#ifndef	_RF__RF_RECONUTIL_H_
+#define	_RF__RF_RECONUTIL_H_
 
 #include "rf_types.h"
 #include "rf_reconstruct.h"
 
-RF_ReconCtrl_t *
-rf_MakeReconControl(RF_RaidReconDesc_t * reconDesc,
-    RF_RowCol_t frow, RF_RowCol_t fcol, RF_RowCol_t srow, RF_RowCol_t scol);
-void    rf_FreeReconControl(RF_Raid_t * raidPtr, RF_RowCol_t row);
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimit(RF_Raid_t * raidPtr);
-int     rf_GetDefaultNumFloatingReconBuffers(RF_Raid_t * raidPtr);
-RF_ReconBuffer_t *
-rf_MakeReconBuffer(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_RowCol_t col, RF_RbufType_t type);
-void    rf_FreeReconBuffer(RF_ReconBuffer_t * rbuf);
-void    rf_CheckFloatingRbufCount(RF_Raid_t * raidPtr, int dolock);
+RF_ReconCtrl_t *rf_MakeReconControl(RF_RaidReconDesc_t *,
+	RF_RowCol_t, RF_RowCol_t, RF_RowCol_t, RF_RowCol_t);
+void rf_FreeReconControl(RF_Raid_t *, RF_RowCol_t);
+RF_HeadSepLimit_t rf_GetDefaultHeadSepLimit(RF_Raid_t *);
+int  rf_GetDefaultNumFloatingReconBuffers(RF_Raid_t *);
+RF_ReconBuffer_t *rf_MakeReconBuffer(RF_Raid_t *,
+	RF_RowCol_t, RF_RowCol_t, RF_RbufType_t);
+void rf_FreeReconBuffer(RF_ReconBuffer_t *);
+void rf_CheckFloatingRbufCount(RF_Raid_t *, int);
 
-#endif				/* !_RF__RF_RECONUTIL_H_ */
+#endif	/* !_RF__RF_RECONUTIL_H_ */
diff --git a/sys/dev/raidframe/rf_revent.c b/sys/dev/raidframe/rf_revent.c
index e664e361110..24864943c3f 100644
--- a/sys/dev/raidframe/rf_revent.c
+++ b/sys/dev/raidframe/rf_revent.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_revent.c,v 1.9 2000/08/08 16:07:45 peter Exp $	*/
+/*	$OpenBSD: rf_revent.c,v 1.10 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_revent.c,v 1.7 2000/05/30 02:04:29 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -26,8 +27,9 @@
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
+
 /*
- * revent.c -- reconstruction event handling code
+ * revent.c -- Reconstruction event handling code.
  */
 
 #include <sys/errno.h>
@@ -41,39 +43,36 @@
 #include "rf_shutdown.h"
 
 static RF_FreeList_t *rf_revent_freelist;
-#define RF_MAX_FREE_REVENT 128
-#define RF_REVENT_INC        8
-#define RF_REVENT_INITIAL    8
+#define	RF_MAX_FREE_REVENT	128
+#define	RF_REVENT_INC		  8
+#define	RF_REVENT_INITIAL	  8
 
 
 
 #include <sys/proc.h>
 #include <sys/kernel.h>
 
-#define DO_WAIT(_rc)  \
-	tsleep(&(_rc)->eventQueue, PRIBIO,  "raidframe eventq", 0)
+#define	DO_WAIT(_rc)							\
+	tsleep(&(_rc)->eventQueue, PRIBIO, "RAIDframe eventq", 0)
 
-#define DO_SIGNAL(_rc)     wakeup(&(_rc)->eventQueue)
+#define	DO_SIGNAL(_rc)	wakeup(&(_rc)->eventQueue)
 
 
-static void rf_ShutdownReconEvent(void *);
+void rf_ShutdownReconEvent(void *);
 
-static RF_ReconEvent_t *
-GetReconEventDesc(RF_RowCol_t row, RF_RowCol_t col,
-    void *arg, RF_Revent_t type);
+RF_ReconEvent_t *GetReconEventDesc(RF_RowCol_t, RF_RowCol_t, void *,
+	RF_Revent_t);
 
-static void
-rf_ShutdownReconEvent(ignored)
-	void   *ignored;
+void
+rf_ShutdownReconEvent(void *ignored)
 {
 	RF_FREELIST_DESTROY(rf_revent_freelist, next, (RF_ReconEvent_t *));
 }
 
-int 
-rf_ConfigureReconEvent(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureReconEvent(RF_ShutdownList_t **listp)
 {
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_revent_freelist, RF_MAX_FREE_REVENT,
 	    RF_REVENT_INC, sizeof(RF_ReconEvent_t));
@@ -81,8 +80,8 @@ rf_ConfigureReconEvent(listp)
 		return (ENOMEM);
 	rc = rf_ShutdownCreate(listp, rf_ShutdownReconEvent, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d\n", __FILE__, __LINE__, rc);
 		rf_ShutdownReconEvent(NULL);
 		return (rc);
 	}
@@ -91,16 +90,15 @@ rf_ConfigureReconEvent(listp)
 	return (0);
 }
 
-/* returns the next reconstruction event, blocking the calling thread
- * until one becomes available.  will now return null if it is blocked
- * or will return an event if it is not */
+/*
+ * Returns the next reconstruction event, blocking the calling thread
+ * until one becomes available. Will now return null if it is blocked
+ * or will return an event if it is not.
+ */
 
 RF_ReconEvent_t *
-rf_GetNextReconEvent(reconDesc, row, continueFunc, continueArg)
-	RF_RaidReconDesc_t *reconDesc;
-	RF_RowCol_t row;
-	void    (*continueFunc) (void *);
-	void   *continueArg;
+rf_GetNextReconEvent(RF_RaidReconDesc_t *reconDesc, RF_RowCol_t row,
+    void (*continueFunc) (void *), void *continueArg)
 {
 	RF_Raid_t *raidPtr = reconDesc->raidPtr;
 	RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
@@ -108,41 +106,45 @@ rf_GetNextReconEvent(reconDesc, row, continueFunc, continueArg)
 
 	RF_ASSERT(row >= 0 && row <= raidPtr->numRow);
 	RF_LOCK_MUTEX(rctrl->eq_mutex);
-	/* q null and count==0 must be equivalent conditions */
+	/* q NULL and count==0 must be equivalent conditions. */
 	RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
 
 	rctrl->continueFunc = continueFunc;
 	rctrl->continueArg = continueArg;
 
-	/* mpsleep timeout value: secs = timo_val/hz.  'ticks' here is
-	   defined as cycle-counter ticks, not softclock ticks */
+	/*
+	 * mpsleep timeout value: secs = timo_val/hz. 'ticks' here is
+	 * defined as cycle-counter ticks, not softclock ticks.
+	 */
 
-#define MAX_RECON_EXEC_USECS		(100 * 1000)	/* 100 ms */
-#define RECON_DELAY_MS			25
-#define RECON_TIMO    			((RECON_DELAY_MS * hz) / 1000)
+#define	MAX_RECON_EXEC_USECS		(100 * 1000)	/* 100 ms */
+#define	RECON_DELAY_MS			25
+#define	RECON_TIMO			((RECON_DELAY_MS * hz) / 1000)
 
-	/* we are not pre-emptible in the kernel, but we don't want to run
+	/*
+	 * We are not pre-emptible in the kernel, but we don't want to run
 	 * forever. If we run w/o blocking for more than MAX_RECON_EXEC_USECS
-	 * delay for RECON_DELAY_MS before continuing. this may murder us with
+	 * delay for RECON_DELAY_MS before continuing. This may murder us with
 	 * context switches, so we may need to increase both the
-	 * MAX...TICKS and the RECON_DELAY_MS. */
+	 * MAX...TICKS and the RECON_DELAY_MS.
+	 */
 	if (reconDesc->reconExecTimerRunning) {
-		int	status;
+		int status;
 
 		RF_ETIMER_STOP(reconDesc->recon_exec_timer);
 		RF_ETIMER_EVAL(reconDesc->recon_exec_timer);
-		reconDesc->reconExecTicks += 
-			RF_ETIMER_VAL_US(reconDesc->recon_exec_timer);
+		reconDesc->reconExecTicks +=
+		    RF_ETIMER_VAL_US(reconDesc->recon_exec_timer);
 		if (reconDesc->reconExecTicks > reconDesc->maxReconExecTicks)
-			reconDesc->maxReconExecTicks = 
-				reconDesc->reconExecTicks;
+			reconDesc->maxReconExecTicks =
+			    reconDesc->reconExecTicks;
 		if (reconDesc->reconExecTicks >= MAX_RECON_EXEC_USECS) {
-			/* we've been running too long - sleep */
+			/* We've been running too long - sleep. */
 #if RF_RECON_STATS > 0
 			reconDesc->numReconExecDelays++;
 #endif /* RF_RECON_STATS > 0 */
-			status = tsleep(&reconDesc->reconExecTicks, 
-					PRIBIO, "recon delay", RECON_TIMO);
+			status = tsleep(&reconDesc->reconExecTicks,
+			    PRIBIO, "recon delay", RECON_TIMO);
 			RF_ASSERT(status == EWOULDBLOCK);
 			reconDesc->reconExecTicks = 0;
 		}
@@ -152,7 +154,7 @@ rf_GetNextReconEvent(reconDesc, row, continueFunc, continueArg)
 		reconDesc->numReconEventWaits++;
 #endif				/* RF_RECON_STATS > 0 */
 		DO_WAIT(rctrl);
-		reconDesc->reconExecTicks = 0;	/* we've just waited */
+		reconDesc->reconExecTicks = 0;	/* We've just waited. */
 	}
 
 	RF_ETIMER_START(reconDesc->recon_exec_timer);
@@ -163,19 +165,16 @@ rf_GetNextReconEvent(reconDesc, row, continueFunc, continueArg)
 	event->next = NULL;
 	rctrl->eq_count--;
 
-	/* q null and count==0 must be equivalent conditions */
+	/* q NULL and count==0 must be equivalent conditions. */
 	RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
 	RF_UNLOCK_MUTEX(rctrl->eq_mutex);
 	return (event);
 }
-/* enqueues a reconstruction event on the indicated queue */
-void 
-rf_CauseReconEvent(raidPtr, row, col, arg, type)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
-	void   *arg;
-	RF_Revent_t type;
+
+/* Enqueues a reconstruction event on the indicated queue. */
+void
+rf_CauseReconEvent(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col,
+    void *arg, RF_Revent_t type)
 {
 	RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
 	RF_ReconEvent_t *event = GetReconEventDesc(row, col, arg, type);
@@ -183,9 +182,10 @@ rf_CauseReconEvent(raidPtr, row, col, arg, type)
 	if (type == RF_REVENT_BUFCLEAR) {
 		RF_ASSERT(col != rctrl->fcol);
 	}
-	RF_ASSERT(row >= 0 && row <= raidPtr->numRow && col >= 0 && col <= raidPtr->numCol);
+	RF_ASSERT(row >= 0 && row <= raidPtr->numRow && col >= 0 &&
+	    col <= raidPtr->numCol);
 	RF_LOCK_MUTEX(rctrl->eq_mutex);
-	/* q null and count==0 must be equivalent conditions */
+	/* q NULL and count==0 must be equivalent conditions. */
 	RF_ASSERT((rctrl->eventQueue == NULL) == (rctrl->eq_count == 0));
 	event->next = rctrl->eventQueue;
 	rctrl->eventQueue = event;
@@ -194,13 +194,10 @@ rf_CauseReconEvent(raidPtr, row, col, arg, type)
 
 	DO_SIGNAL(rctrl);
 }
-/* allocates and initializes a recon event descriptor */
-static RF_ReconEvent_t *
-GetReconEventDesc(row, col, arg, type)
-	RF_RowCol_t row;
-	RF_RowCol_t col;
-	void   *arg;
-	RF_Revent_t type;
+
+/* Allocates and initializes a recon event descriptor. */
+RF_ReconEvent_t *
+GetReconEventDesc(RF_RowCol_t row, RF_RowCol_t col, void *arg, RF_Revent_t type)
 {
 	RF_ReconEvent_t *t;
 
@@ -213,9 +210,8 @@ GetReconEventDesc(row, col, arg, type)
 	return (t);
 }
 
-void 
-rf_FreeReconEventDesc(event)
-	RF_ReconEvent_t *event;
+void
+rf_FreeReconEventDesc(RF_ReconEvent_t *event)
 {
 	RF_FREELIST_FREE(rf_revent_freelist, event, next);
 }
diff --git a/sys/dev/raidframe/rf_revent.h b/sys/dev/raidframe/rf_revent.h
index a4be2d4d03a..f22f57c67e9 100644
--- a/sys/dev/raidframe/rf_revent.h
+++ b/sys/dev/raidframe/rf_revent.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_revent.h,v 1.2 1999/02/16 00:03:25 niklas Exp $	*/
+/*	$OpenBSD: rf_revent.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_revent.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,26 +28,22 @@
  * rights to redistribute these changes.
  */
 
-/*******************************************************************
+/*********************************************************************
  *
- * rf_revent.h -- header file for reconstruction event handling code
+ * rf_revent.h -- Header file for reconstruction event handling code.
  *
- *******************************************************************/
+ *********************************************************************/
 
-#ifndef _RF__RF_REVENT_H_
-#define _RF__RF_REVENT_H_
+#ifndef	_RF__RF_REVENT_H_
+#define	_RF__RF_REVENT_H_
 
 #include "rf_types.h"
 
-int     rf_ConfigureReconEvent(RF_ShutdownList_t ** listp);
-
-RF_ReconEvent_t *
-rf_GetNextReconEvent(RF_RaidReconDesc_t * reconDesc,
-    RF_RowCol_t row, void (*continueFunc) (void *), void *continueArg);
-
-	void    rf_CauseReconEvent(RF_Raid_t * raidPtr, RF_RowCol_t row, RF_RowCol_t col,
-            void *arg, RF_Revent_t type);
-
-	void    rf_FreeReconEventDesc(RF_ReconEvent_t * event);
+int  rf_ConfigureReconEvent(RF_ShutdownList_t **);
+RF_ReconEvent_t *rf_GetNextReconEvent(RF_RaidReconDesc_t *,
+	RF_RowCol_t, void (*) (void *), void *);
+void rf_CauseReconEvent(RF_Raid_t *,
+	RF_RowCol_t, RF_RowCol_t, void *, RF_Revent_t);
+void rf_FreeReconEventDesc(RF_ReconEvent_t *);
 
-#endif				/* !_RF__RF_REVENT_H_ */
+#endif	/* !_RF__RF_REVENT_H_ */
diff --git a/sys/dev/raidframe/rf_shutdown.c b/sys/dev/raidframe/rf_shutdown.c
index 293ead367e6..be13f747f50 100644
--- a/sys/dev/raidframe/rf_shutdown.c
+++ b/sys/dev/raidframe/rf_shutdown.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_shutdown.c,v 1.4 2000/08/08 16:07:45 peter Exp $	*/
+/*	$OpenBSD: rf_shutdown.c,v 1.5 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_shutdown.c,v 1.6 2000/01/13 23:41:18 oster Exp $	*/
+
 /*
  * rf_shutdown.c
  */
@@ -40,19 +41,16 @@
 #include "rf_debugMem.h"
 #include "rf_freelist.h"
 
-static void 
-rf_FreeShutdownEnt(RF_ShutdownList_t * ent)
+void rf_FreeShutdownEnt(RF_ShutdownList_t *);
+void
+rf_FreeShutdownEnt(RF_ShutdownList_t *ent)
 {
 	FREE(ent, M_RAIDFRAME);
 }
 
-int 
-_rf_ShutdownCreate(
-    RF_ShutdownList_t ** listp,
-    void (*cleanup) (void *arg),
-    void *arg,
-    char *file,
-    int line)
+int
+_rf_ShutdownCreate(RF_ShutdownList_t **listp, void (*cleanup) (void *arg),
+    void *arg, char *file, int line)
 {
 	RF_ShutdownList_t *ent;
 
@@ -60,10 +58,10 @@ _rf_ShutdownCreate(
          * Have to directly allocate memory here, since we start up before
          * and shutdown after RAIDframe internal allocation system.
          */
-	/* 	ent = (RF_ShutdownList_t *) malloc(sizeof(RF_ShutdownList_t), 
-		M_RAIDFRAME, M_WAITOK); */
-	ent = (RF_ShutdownList_t *) malloc(sizeof(RF_ShutdownList_t), 
-					   M_RAIDFRAME, M_NOWAIT);
+	/* ent = (RF_ShutdownList_t *) malloc(sizeof(RF_ShutdownList_t),
+	 *     M_RAIDFRAME, M_WAITOK); */
+	ent = (RF_ShutdownList_t *) malloc(sizeof(RF_ShutdownList_t),
+	    M_RAIDFRAME, M_NOWAIT);
 	if (ent == NULL)
 		return (ENOMEM);
 	ent->cleanup = cleanup;
@@ -75,12 +73,12 @@ _rf_ShutdownCreate(
 	return (0);
 }
 
-int 
-rf_ShutdownList(RF_ShutdownList_t ** list)
+int
+rf_ShutdownList(RF_ShutdownList_t **list)
 {
 	RF_ShutdownList_t *r, *next;
-	char   *file;
-	int     line;
+	char *file;
+	int line;
 
 	for (r = *list; r; r = next) {
 		next = r->next;
@@ -93,7 +91,8 @@ rf_ShutdownList(RF_ShutdownList_t ** list)
 		r->cleanup(r->arg);
 
 		if (rf_shutdownDebug) {
-			printf("completed shutdown, created %s:%d\n", file, line);
+			printf("completed shutdown, created %s:%d\n", file,
+			    line);
 		}
 		rf_FreeShutdownEnt(r);
 	}
diff --git a/sys/dev/raidframe/rf_shutdown.h b/sys/dev/raidframe/rf_shutdown.h
index 77ff2a14fe2..7bd2f72889f 100644
--- a/sys/dev/raidframe/rf_shutdown.h
+++ b/sys/dev/raidframe/rf_shutdown.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_shutdown.h,v 1.3 2002/03/06 11:28:27 tdeval Exp $	*/
+/*	$OpenBSD: rf_shutdown.h,v 1.4 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_shutdown.h,v 1.2 1999/02/05 00:06:17 oster Exp $	*/
+
 /*
  * rf_shutdown.h
  */
@@ -34,14 +35,14 @@
  * thread startup and shutdown.
  */
 
-#ifndef _RF__RF_SHUTDOWN_H_
-#define _RF__RF_SHUTDOWN_H_
+#ifndef	_RF__RF_SHUTDOWN_H_
+#define	_RF__RF_SHUTDOWN_H_
 
 #include "rf_types.h"
 #include "rf_threadstuff.h"
 
 /*
- * Important note: the shutdown list is run like a stack, new
+ * Important note: The shutdown list is run like a stack, new
  * entries pushed on top. Therefore, the most recently added
  * entry (last started) is the first removed (stopped). This
  * should handle system-dependencies pretty nicely- if a system
@@ -51,19 +52,18 @@
  */
 
 struct RF_ShutdownList_s {
-	void    (*cleanup) (void *arg);
-	void   *arg;
-	char   *file;
-	int     line;
+	void		 (*cleanup) (void *arg);
+	void		  *arg;
+	char		  *file;
+	int		   line;
 	RF_ShutdownList_t *next;
 };
-#define rf_ShutdownCreate(_listp_,_func_,_arg_) \
-  _rf_ShutdownCreate(_listp_,_func_,_arg_,__FILE__,__LINE__)
-
-int     _rf_ShutdownCreate(RF_ShutdownList_t ** listp, void (*cleanup) (void *arg),
-            void *arg, char *file, int line);
-int     rf_ShutdownList(RF_ShutdownList_t ** listp);
+#define	rf_ShutdownCreate(_listp_,_func_,_arg_)				\
+	_rf_ShutdownCreate(_listp_, _func_, _arg_, __FILE__, __LINE__)
 
-void	rf_shutdown_hook(RF_ThreadArg_t);
+int  _rf_ShutdownCreate(RF_ShutdownList_t **, void (*) (void *arg), void *,
+	char *, int);
+int  rf_ShutdownList(RF_ShutdownList_t **);
+void rf_shutdown_hook(RF_ThreadArg_t);
 
-#endif				/* !_RF__RF_SHUTDOWN_H_ */
+#endif	/* !_RF__RF_SHUTDOWN_H_ */
diff --git a/sys/dev/raidframe/rf_sstf.c b/sys/dev/raidframe/rf_sstf.c
index e603b98b859..748e3aee5db 100644
--- a/sys/dev/raidframe/rf_sstf.c
+++ b/sys/dev/raidframe/rf_sstf.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_sstf.c,v 1.3 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_sstf.c,v 1.4 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_sstf.c,v 1.4 2000/01/08 23:45:05 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/*******************************************************************************
+/*****************************************************************************
  *
- * sstf.c --  prioritized shortest seek time first disk queueing code
+ * sstf.c --  Prioritized shortest seek time first disk queueing code.
  *
- ******************************************************************************/
+ *****************************************************************************/
 
 #include "rf_alloclist.h"
 #include "rf_stripelocks.h"
@@ -44,33 +45,28 @@
 #include "rf_raid.h"
 #include "rf_types.h"
 
-#define DIR_LEFT   1
-#define DIR_RIGHT  2
-#define DIR_EITHER 3
-
-#define SNUM_DIFF(_a_,_b_) (((_a_)>(_b_))?((_a_)-(_b_)):((_b_)-(_a_)))
+#define	DIR_LEFT	1
+#define	DIR_RIGHT	2
+#define	DIR_EITHER	3
 
-#define QSUM(_sstfq_) (((_sstfq_)->lopri.qlen)+((_sstfq_)->left.qlen)+((_sstfq_)->right.qlen))
+#define	SNUM_DIFF(_a_,_b_)						\
+	(((_a_) > (_b_)) ? ((_a_) - (_b_)) : ((_b_) - (_a_)))
 
+#define	QSUM(_sstfq_)							\
+	(((_sstfq_)->lopri.qlen) + ((_sstfq_)->left.qlen) +		\
+	 ((_sstfq_)->right.qlen))
 
-static void 
-do_sstf_ord_q(RF_DiskQueueData_t **,
-    RF_DiskQueueData_t **,
-    RF_DiskQueueData_t *);
 
-static RF_DiskQueueData_t *
-closest_to_arm(RF_SstfQ_t *,
-    RF_SectorNum_t,
-    int *,
-    int);
-static void do_dequeue(RF_SstfQ_t *, RF_DiskQueueData_t *);
+void rf_do_sstf_ord_q(RF_DiskQueueData_t **, RF_DiskQueueData_t **,
+	RF_DiskQueueData_t *);
+void rf_do_dequeue(RF_SstfQ_t *, RF_DiskQueueData_t *);
+RF_DiskQueueData_t *rf_closest_to_arm(RF_SstfQ_t *, RF_SectorNum_t,
+	int *, int);
 
 
-static void 
-do_sstf_ord_q(queuep, tailp, req)
-	RF_DiskQueueData_t **queuep;
-	RF_DiskQueueData_t **tailp;
-	RF_DiskQueueData_t *req;
+void
+rf_do_sstf_ord_q(RF_DiskQueueData_t **queuep, RF_DiskQueueData_t **tailp,
+    RF_DiskQueueData_t *req)
 {
 	RF_DiskQueueData_t *r, *s;
 
@@ -89,14 +85,14 @@ do_sstf_ord_q(queuep, tailp, req)
 		return;
 	}
 	if (req->sectorOffset > (*tailp)->sectorOffset) {
-		/* optimization */
+		/* Optimization. */
 		r = NULL;
 		s = *tailp;
 		goto q_at_end;
 	}
 	for (s = NULL, r = *queuep; r; s = r, r = r->next) {
 		if (r->sectorOffset >= req->sectorOffset) {
-			/* insert after s, before r */
+			/* Insert after s, before r. */
 			RF_ASSERT(s);
 			req->next = r;
 			r->prev = req;
@@ -106,7 +102,7 @@ do_sstf_ord_q(queuep, tailp, req)
 		}
 	}
 q_at_end:
-	/* insert after s, at end of queue */
+	/* Insert after s, at end of queue. */
 	RF_ASSERT(r == NULL);
 	RF_ASSERT(s);
 	RF_ASSERT(s == (*tailp));
@@ -115,57 +111,55 @@ q_at_end:
 	s->next = req;
 	*tailp = req;
 }
-/* for removing from head-of-queue */
-#define DO_HEAD_DEQ(_r_,_q_) { \
-	_r_ = (_q_)->queue; \
-	RF_ASSERT((_r_) != NULL); \
-	(_q_)->queue = (_r_)->next; \
-	(_q_)->qlen--; \
-	if ((_q_)->qlen == 0) { \
-		RF_ASSERT((_r_) == (_q_)->qtail); \
-		RF_ASSERT((_q_)->queue == NULL); \
-		(_q_)->qtail = NULL; \
-	} \
-	else { \
-		RF_ASSERT((_q_)->queue->prev == (_r_)); \
-		(_q_)->queue->prev = NULL; \
-	} \
-}
-
-/* for removing from end-of-queue */
-#define DO_TAIL_DEQ(_r_,_q_) { \
-	_r_ = (_q_)->qtail; \
-	RF_ASSERT((_r_) != NULL); \
-	(_q_)->qtail = (_r_)->prev; \
-	(_q_)->qlen--; \
-	if ((_q_)->qlen == 0) { \
-		RF_ASSERT((_r_) == (_q_)->queue); \
-		RF_ASSERT((_q_)->qtail == NULL); \
-		(_q_)->queue = NULL; \
-	} \
-	else { \
-		RF_ASSERT((_q_)->qtail->next == (_r_)); \
-		(_q_)->qtail->next = NULL; \
-	} \
-}
 
-#define DO_BEST_DEQ(_l_,_r_,_q_) { \
-	if (SNUM_DIFF((_q_)->queue->sectorOffset,_l_) \
-		< SNUM_DIFF((_q_)->qtail->sectorOffset,_l_)) \
-	{ \
-		DO_HEAD_DEQ(_r_,_q_); \
-	} \
-	else { \
-		DO_TAIL_DEQ(_r_,_q_); \
-	} \
-}
+/* For removing from head-of-queue. */
+#define	DO_HEAD_DEQ(_r_,_q_)						\
+do {									\
+	_r_ = (_q_)->queue;						\
+	RF_ASSERT((_r_) != NULL);					\
+	(_q_)->queue = (_r_)->next;					\
+	(_q_)->qlen--;							\
+	if ((_q_)->qlen == 0) {						\
+		RF_ASSERT((_r_) == (_q_)->qtail);			\
+		RF_ASSERT((_q_)->queue == NULL);			\
+		(_q_)->qtail = NULL;					\
+	} else {							\
+		RF_ASSERT((_q_)->queue->prev == (_r_));			\
+		(_q_)->queue->prev = NULL;				\
+	}								\
+} while (0)
+
+/* For removing from end-of-queue. */
+#define	DO_TAIL_DEQ(_r_,_q_)						\
+do {									\
+	_r_ = (_q_)->qtail;						\
+	RF_ASSERT((_r_) != NULL);					\
+	(_q_)->qtail = (_r_)->prev;					\
+	(_q_)->qlen--;							\
+	if ((_q_)->qlen == 0) {						\
+		RF_ASSERT((_r_) == (_q_)->queue);			\
+		RF_ASSERT((_q_)->qtail == NULL);			\
+		(_q_)->queue = NULL;					\
+	} else {							\
+		RF_ASSERT((_q_)->qtail->next == (_r_));			\
+		(_q_)->qtail->next = NULL;				\
+	}								\
+} while (0)
+
+#define	DO_BEST_DEQ(_l_,_r_,_q_)					\
+do {									\
+	if (SNUM_DIFF((_q_)->queue->sectorOffset,_l_)			\
+		< SNUM_DIFF((_q_)->qtail->sectorOffset,_l_))		\
+	{								\
+		DO_HEAD_DEQ(_r_,_q_);					\
+	} else {							\
+		DO_TAIL_DEQ(_r_,_q_);					\
+	}								\
+} while (0)
 
-static RF_DiskQueueData_t *
-closest_to_arm(queue, arm_pos, dir, allow_reverse)
-	RF_SstfQ_t *queue;
-	RF_SectorNum_t arm_pos;
-	int    *dir;
-	int     allow_reverse;
+RF_DiskQueueData_t *
+rf_closest_to_arm(RF_SstfQ_t *queue, RF_SectorNum_t arm_pos, int *dir,
+    int allow_reverse)
 {
 	RF_SectorNum_t best_pos_l = 0, this_pos_l = 0, last_pos = 0;
 	RF_SectorNum_t best_pos_r = 0, this_pos_r = 0;
@@ -199,7 +193,7 @@ closest_to_arm(queue, arm_pos, dir, allow_reverse)
 					last_pos = this_pos_r;
 				}
 				if (this_pos_r > last_pos) {
-					/* getting farther away */
+					/* Getting farther away. */
 					break;
 				}
 			}
@@ -242,11 +236,9 @@ closest_to_arm(queue, arm_pos, dir, allow_reverse)
 	return (queue->queue);
 }
 
-void   *
-rf_SstfCreate(sect_per_disk, cl_list, listp)
-	RF_SectorCount_t sect_per_disk;
-	RF_AllocListElem_t *cl_list;
-	RF_ShutdownList_t **listp;
+void *
+rf_SstfCreate(RF_SectorCount_t sect_per_disk, RF_AllocListElem_t *cl_list,
+    RF_ShutdownList_t **listp)
 {
 	RF_Sstf_t *sstfq;
 
@@ -256,11 +248,9 @@ rf_SstfCreate(sect_per_disk, cl_list, listp)
 	return ((void *) sstfq);
 }
 
-void   *
-rf_ScanCreate(sect_per_disk, cl_list, listp)
-	RF_SectorCount_t sect_per_disk;
-	RF_AllocListElem_t *cl_list;
-	RF_ShutdownList_t **listp;
+void *
+rf_ScanCreate(RF_SectorCount_t sect_per_disk, RF_AllocListElem_t *cl_list,
+    RF_ShutdownList_t **listp)
 {
 	RF_Sstf_t *scanq;
 
@@ -270,11 +260,9 @@ rf_ScanCreate(sect_per_disk, cl_list, listp)
 	return ((void *) scanq);
 }
 
-void   *
-rf_CscanCreate(sect_per_disk, cl_list, listp)
-	RF_SectorCount_t sect_per_disk;
-	RF_AllocListElem_t *cl_list;
-	RF_ShutdownList_t **listp;
+void *
+rf_CscanCreate(RF_SectorCount_t sect_per_disk, RF_AllocListElem_t *cl_list,
+    RF_ShutdownList_t **listp)
 {
 	RF_Sstf_t *cscanq;
 
@@ -283,11 +271,8 @@ rf_CscanCreate(sect_per_disk, cl_list, listp)
 	return ((void *) cscanq);
 }
 
-void 
-rf_SstfEnqueue(qptr, req, priority)
-	void   *qptr;
-	RF_DiskQueueData_t *req;
-	int     priority;
+void
+rf_SstfEnqueue(void *qptr, RF_DiskQueueData_t *req, int priority)
 {
 	RF_Sstf_t *sstfq;
 
@@ -297,34 +282,33 @@ rf_SstfEnqueue(qptr, req, priority)
 		if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
 			RF_DiskQueue_t *dq;
 			dq = (RF_DiskQueue_t *) req->queue;
-			printf("raid%d: ENQ lopri %d,%d queues are %d,%d,%d\n",
-			       req->raidPtr->raidid,
-			       dq->row, dq->col, 
+			printf("raid%d: ENQ lopri %d,%d queues are %d,%d,%d.\n",
+			       req->raidPtr->raidid, dq->row, dq->col,
 			       sstfq->left.qlen, sstfq->right.qlen,
-			    sstfq->lopri.qlen);
+			       sstfq->lopri.qlen);
 		}
-		do_sstf_ord_q(&sstfq->lopri.queue, &sstfq->lopri.qtail, req);
+		rf_do_sstf_ord_q(&sstfq->lopri.queue, &sstfq->lopri.qtail, req);
 		sstfq->lopri.qlen++;
 	} else {
 		if (req->sectorOffset < sstfq->last_sector) {
-			do_sstf_ord_q(&sstfq->left.queue, &sstfq->left.qtail, req);
+			rf_do_sstf_ord_q(&sstfq->left.queue,
+			    &sstfq->left.qtail, req);
 			sstfq->left.qlen++;
 		} else {
-			do_sstf_ord_q(&sstfq->right.queue, &sstfq->right.qtail, req);
+			rf_do_sstf_ord_q(&sstfq->right.queue,
+			    &sstfq->right.qtail, req);
 			sstfq->right.qlen++;
 		}
 	}
 }
 
-static void 
-do_dequeue(queue, req)
-	RF_SstfQ_t *queue;
-	RF_DiskQueueData_t *req;
+void
+rf_do_dequeue(RF_SstfQ_t *queue, RF_DiskQueueData_t *req)
 {
 	RF_DiskQueueData_t *req2;
 
 	if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
-		printf("raid%d: do_dequeue\n", req->raidPtr->raidid);
+		printf("raid%d: rf_do_dequeue.\n", req->raidPtr->raidid);
 	}
 	if (req == queue->queue) {
 		DO_HEAD_DEQ(req2, queue);
@@ -334,7 +318,7 @@ do_dequeue(queue, req)
 			DO_TAIL_DEQ(req2, queue);
 			RF_ASSERT(req2 == req);
 		} else {
-			/* dequeue from middle of list */
+			/* Dequeue from middle of list. */
 			RF_ASSERT(req->next);
 			RF_ASSERT(req->prev);
 			queue->qlen--;
@@ -345,8 +329,7 @@ do_dequeue(queue, req)
 }
 
 RF_DiskQueueData_t *
-rf_SstfDequeue(qptr)
-	void   *qptr;
+rf_SstfDequeue(void *qptr)
 {
 	RF_DiskQueueData_t *req = NULL;
 	RF_Sstf_t *sstfq;
@@ -357,8 +340,8 @@ rf_SstfDequeue(qptr)
 		RF_DiskQueue_t *dq;
 		dq = (RF_DiskQueue_t *) req->queue;
 		RF_ASSERT(QSUM(sstfq) == dq->queueLength);
-		printf("raid%d: sstf: Dequeue %d,%d queues are %d,%d,%d\n",
-		       req->raidPtr->raidid, dq->row, dq->col, 
+		printf("raid%d: sstf: Dequeue %d,%d queues are %d,%d,%d.\n",
+		       req->raidPtr->raidid, dq->row, dq->col,
 		       sstfq->left.qlen, sstfq->right.qlen, sstfq->lopri.qlen);
 	}
 	if (sstfq->left.queue == NULL) {
@@ -370,18 +353,20 @@ rf_SstfDequeue(qptr)
 				return (NULL);
 			}
 			if (rf_sstfDebug) {
-				printf("raid%d: sstf: check for close lopri",
+				printf("raid%d: sstf: check for close lopri.\n",
 				       req->raidPtr->raidid);
 			}
-			req = closest_to_arm(&sstfq->lopri, sstfq->last_sector,
-			    &sstfq->dir, sstfq->allow_reverse);
+			req = rf_closest_to_arm(&sstfq->lopri,
+			    sstfq->last_sector, &sstfq->dir,
+			    sstfq->allow_reverse);
 			if (rf_sstfDebug) {
-				printf("raid%d: sstf: closest_to_arm said %lx",
-				       req->raidPtr->raidid, (long) req);
+				printf("raid%d: sstf: rf_closest_to_arm said"
+				       " %lx.\n", req->raidPtr->raidid,
+				       (long) req);
 			}
 			if (req == NULL)
 				return (NULL);
-			do_dequeue(&sstfq->lopri, req);
+			rf_do_dequeue(&sstfq->lopri, req);
 		} else {
 			DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->right);
 		}
@@ -390,8 +375,10 @@ rf_SstfDequeue(qptr)
 			RF_ASSERT(sstfq->right.qlen == 0);
 			DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->left);
 		} else {
-			if (SNUM_DIFF(sstfq->last_sector, sstfq->right.queue->sectorOffset)
-			    < SNUM_DIFF(sstfq->last_sector, sstfq->left.qtail->sectorOffset)) {
+			if (SNUM_DIFF(sstfq->last_sector,
+			     sstfq->right.queue->sectorOffset) <
+			    SNUM_DIFF(sstfq->last_sector,
+			     sstfq->left.qtail->sectorOffset)) {
 				DO_HEAD_DEQ(req, &sstfq->right);
 			} else {
 				DO_TAIL_DEQ(req, &sstfq->left);
@@ -404,8 +391,7 @@ rf_SstfDequeue(qptr)
 }
 
 RF_DiskQueueData_t *
-rf_ScanDequeue(qptr)
-	void   *qptr;
+rf_ScanDequeue(void *qptr)
 {
 	RF_DiskQueueData_t *req = NULL;
 	RF_Sstf_t *scanq;
@@ -416,8 +402,8 @@ rf_ScanDequeue(qptr)
 		RF_DiskQueue_t *dq;
 		dq = (RF_DiskQueue_t *) req->queue;
 		RF_ASSERT(QSUM(scanq) == dq->queueLength);
-		printf("raid%d: scan: Dequeue %d,%d queues are %d,%d,%d\n", 
-		       req->raidPtr->raidid, dq->row, dq->col, 
+		printf("raid%d: scan: Dequeue %d,%d queues are %d,%d,%d.\n",
+		       req->raidPtr->raidid, dq->row, dq->col,
 		       scanq->left.qlen, scanq->right.qlen, scanq->lopri.qlen);
 	}
 	if (scanq->left.queue == NULL) {
@@ -428,11 +414,12 @@ rf_ScanDequeue(qptr)
 				RF_ASSERT(scanq->lopri.qlen == 0);
 				return (NULL);
 			}
-			req = closest_to_arm(&scanq->lopri, scanq->last_sector,
-			    &scanq->dir, scanq->allow_reverse);
+			req = rf_closest_to_arm(&scanq->lopri,
+			    scanq->last_sector, &scanq->dir,
+			    scanq->allow_reverse);
 			if (req == NULL)
 				return (NULL);
-			do_dequeue(&scanq->lopri, req);
+			rf_do_dequeue(&scanq->lopri, req);
 		} else {
 			scanq->dir = DIR_RIGHT;
 			DO_HEAD_DEQ(req, &scanq->right);
@@ -458,8 +445,7 @@ rf_ScanDequeue(qptr)
 }
 
 RF_DiskQueueData_t *
-rf_CscanDequeue(qptr)
-	void   *qptr;
+rf_CscanDequeue(void *qptr)
 {
 	RF_DiskQueueData_t *req = NULL;
 	RF_Sstf_t *cscanq;
@@ -471,10 +457,10 @@ rf_CscanDequeue(qptr)
 		RF_DiskQueue_t *dq;
 		dq = (RF_DiskQueue_t *) req->queue;
 		RF_ASSERT(QSUM(cscanq) == dq->queueLength);
-		printf("raid%d: scan: Dequeue %d,%d queues are %d,%d,%d\n", 
+		printf("raid%d: scan: Dequeue %d,%d queues are %d,%d,%d.\n",
 		       req->raidPtr->raidid, dq->row, dq->col,
 		       cscanq->left.qlen, cscanq->right.qlen,
-		    cscanq->lopri.qlen);
+		       cscanq->lopri.qlen);
 	}
 	if (cscanq->right.queue) {
 		DO_HEAD_DEQ(req, &cscanq->right);
@@ -486,11 +472,12 @@ rf_CscanDequeue(qptr)
 				RF_ASSERT(cscanq->lopri.qlen == 0);
 				return (NULL);
 			}
-			req = closest_to_arm(&cscanq->lopri, cscanq->last_sector,
-			    &cscanq->dir, cscanq->allow_reverse);
+			req = rf_closest_to_arm(&cscanq->lopri,
+			    cscanq->last_sector, &cscanq->dir,
+			    cscanq->allow_reverse);
 			if (req == NULL)
 				return (NULL);
-			do_dequeue(&cscanq->lopri, req);
+			rf_do_dequeue(&cscanq->lopri, req);
 		} else {
 			/*
 			 * There's I/Os to the left of the arm. Swing
@@ -508,8 +495,7 @@ rf_CscanDequeue(qptr)
 }
 
 RF_DiskQueueData_t *
-rf_SstfPeek(qptr)
-	void   *qptr;
+rf_SstfPeek(void *qptr)
 {
 	RF_DiskQueueData_t *req;
 	RF_Sstf_t *sstfq;
@@ -517,8 +503,8 @@ rf_SstfPeek(qptr)
 	sstfq = (RF_Sstf_t *) qptr;
 
 	if ((sstfq->left.queue == NULL) && (sstfq->right.queue == NULL)) {
-		req = closest_to_arm(&sstfq->lopri, sstfq->last_sector, &sstfq->dir,
-		    sstfq->allow_reverse);
+		req = rf_closest_to_arm(&sstfq->lopri, sstfq->last_sector,
+		    &sstfq->dir, sstfq->allow_reverse);
 	} else {
 		if (sstfq->left.queue == NULL)
 			req = sstfq->right.queue;
@@ -526,8 +512,10 @@ rf_SstfPeek(qptr)
 			if (sstfq->right.queue == NULL)
 				req = sstfq->left.queue;
 			else {
-				if (SNUM_DIFF(sstfq->last_sector, sstfq->right.queue->sectorOffset)
-				    < SNUM_DIFF(sstfq->last_sector, sstfq->left.qtail->sectorOffset)) {
+				if (SNUM_DIFF(sstfq->last_sector,
+				     sstfq->right.queue->sectorOffset) <
+				    SNUM_DIFF(sstfq->last_sector,
+				     sstfq->left.qtail->sectorOffset)) {
 					req = sstfq->right.queue;
 				} else {
 					req = sstfq->left.qtail;
@@ -542,12 +530,11 @@ rf_SstfPeek(qptr)
 }
 
 RF_DiskQueueData_t *
-rf_ScanPeek(qptr)
-	void   *qptr;
+rf_ScanPeek(void *qptr)
 {
 	RF_DiskQueueData_t *req;
 	RF_Sstf_t *scanq;
-	int     dir;
+	int dir;
 
 	scanq = (RF_Sstf_t *) qptr;
 	dir = scanq->dir;
@@ -560,8 +547,8 @@ rf_ScanPeek(qptr)
 				RF_ASSERT(scanq->lopri.qlen == 0);
 				return (NULL);
 			}
-			req = closest_to_arm(&scanq->lopri, scanq->last_sector,
-			    &dir, scanq->allow_reverse);
+			req = rf_closest_to_arm(&scanq->lopri,
+			    scanq->last_sector, &dir, scanq->allow_reverse);
 		} else {
 			req = scanq->right.queue;
 		}
@@ -586,8 +573,7 @@ rf_ScanPeek(qptr)
 }
 
 RF_DiskQueueData_t *
-rf_CscanPeek(qptr)
-	void   *qptr;
+rf_CscanPeek(void *qptr)
 {
 	RF_DiskQueueData_t *req;
 	RF_Sstf_t *cscanq;
@@ -605,8 +591,9 @@ rf_CscanPeek(qptr)
 				RF_ASSERT(cscanq->lopri.qlen == 0);
 				return (NULL);
 			}
-			req = closest_to_arm(&cscanq->lopri, cscanq->last_sector,
-			    &cscanq->dir, cscanq->allow_reverse);
+			req = rf_closest_to_arm(&cscanq->lopri,
+			    cscanq->last_sector, &cscanq->dir,
+			    cscanq->allow_reverse);
 		} else {
 			/*
 			 * There's I/Os to the left of the arm. We'll end
@@ -621,43 +608,39 @@ rf_CscanPeek(qptr)
 	return (req);
 }
 
-int 
-rf_SstfPromote(qptr, parityStripeID, which_ru)
-	void   *qptr;
-	RF_StripeNum_t parityStripeID;
-	RF_ReconUnitNum_t which_ru;
+int
+rf_SstfPromote(void *qptr, RF_StripeNum_t parityStripeID,
+    RF_ReconUnitNum_t which_ru)
 {
 	RF_DiskQueueData_t *r, *next;
 	RF_Sstf_t *sstfq;
-	int     n;
+	int n;
 
 	sstfq = (RF_Sstf_t *) qptr;
 
 	n = 0;
 	if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
-		printf("raid%d: promote %ld %d  queues are %d,%d,%d\n",
-		       r->raidPtr->raidid, (long) parityStripeID, 
-		       (int) which_ru,
-		    sstfq->left.qlen,
-		    sstfq->right.qlen,
-		    sstfq->lopri.qlen);
+		printf("raid%d: promote %ld %d  queues are %d,%d,%d.\n",
+		       r->raidPtr->raidid, (long) parityStripeID,
+		       (int) which_ru, sstfq->left.qlen, sstfq->right.qlen,
+		       sstfq->lopri.qlen);
 	}
 	for (r = sstfq->lopri.queue; r; r = next) {
 		next = r->next;
 		if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
-			printf("raid%d: check promote %lx\n",
+			printf("raid%d: check promote %lx.\n",
 			       r->raidPtr->raidid, (long) r);
 		}
 		if ((r->parityStripeID == parityStripeID)
 		    && (r->which_ru == which_ru)) {
-			do_dequeue(&sstfq->lopri, r);
+			rf_do_dequeue(&sstfq->lopri, r);
 			rf_SstfEnqueue(qptr, r, RF_IO_NORMAL_PRIORITY);
 			n++;
 		}
 	}
 	if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
-		printf("raid%d: promoted %d matching I/Os queues are %d,%d,%d\n",
-		       r->raidPtr->raidid, n, sstfq->left.qlen, 
+		printf("raid%d: promoted %d matching I/Os queues are"
+		       " %d,%d,%d.\n", r->raidPtr->raidid, n, sstfq->left.qlen,
 		       sstfq->right.qlen, sstfq->lopri.qlen);
 	}
 	return (n);
diff --git a/sys/dev/raidframe/rf_sstf.h b/sys/dev/raidframe/rf_sstf.h
index d704e62d206..985cad729b8 100644
--- a/sys/dev/raidframe/rf_sstf.h
+++ b/sys/dev/raidframe/rf_sstf.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_sstf.h,v 1.2 1999/02/16 00:03:27 niklas Exp $	*/
+/*	$OpenBSD: rf_sstf.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_sstf.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,44 +28,39 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_SSTF_H_
-#define _RF__RF_SSTF_H_
+#ifndef	_RF__RF_SSTF_H_
+#define	_RF__RF_SSTF_H_
 
 #include "rf_diskqueue.h"
 
 typedef struct RF_SstfQ_s {
-	RF_DiskQueueData_t *queue;
-	RF_DiskQueueData_t *qtail;
-	int     qlen;
-}       RF_SstfQ_t;
+	RF_DiskQueueData_t	*queue;
+	RF_DiskQueueData_t	*qtail;
+	int			 qlen;
+} RF_SstfQ_t;
 
 typedef struct RF_Sstf_s {
-	RF_SstfQ_t left;
-	RF_SstfQ_t right;
-	RF_SstfQ_t lopri;
-	RF_SectorNum_t last_sector;
-	int     dir;
-	int     allow_reverse;
-}       RF_Sstf_t;
+	RF_SstfQ_t		 left;
+	RF_SstfQ_t		 right;
+	RF_SstfQ_t		 lopri;
+	RF_SectorNum_t		 last_sector;
+	int			 dir;
+	int			 allow_reverse;
+} RF_Sstf_t;
 
-void   *
-rf_SstfCreate(RF_SectorCount_t sect_per_disk,
-    RF_AllocListElem_t * cl_list, RF_ShutdownList_t ** listp);
-void   *
-rf_ScanCreate(RF_SectorCount_t sect_per_disk,
-    RF_AllocListElem_t * cl_list, RF_ShutdownList_t ** listp);
-void   *
-rf_CscanCreate(RF_SectorCount_t sect_per_disk,
-    RF_AllocListElem_t * cl_list, RF_ShutdownList_t ** listp);
-void    rf_SstfEnqueue(void *qptr, RF_DiskQueueData_t * req, int priority);
-RF_DiskQueueData_t *rf_SstfDequeue(void *qptr);
-RF_DiskQueueData_t *rf_SstfPeek(void *qptr);
-int 
-rf_SstfPromote(void *qptr, RF_StripeNum_t parityStripeID,
-    RF_ReconUnitNum_t which_ru);
-RF_DiskQueueData_t *rf_ScanDequeue(void *qptr);
-RF_DiskQueueData_t *rf_ScanPeek(void *qptr);
-RF_DiskQueueData_t *rf_CscanDequeue(void *qptr);
-RF_DiskQueueData_t *rf_CscanPeek(void *qptr);
+void *rf_SstfCreate(RF_SectorCount_t, RF_AllocListElem_t *,
+	RF_ShutdownList_t **);
+void *rf_ScanCreate(RF_SectorCount_t, RF_AllocListElem_t *,
+	RF_ShutdownList_t **);
+void *rf_CscanCreate(RF_SectorCount_t, RF_AllocListElem_t *,
+	RF_ShutdownList_t **);
+void  rf_SstfEnqueue(void *, RF_DiskQueueData_t *, int);
+RF_DiskQueueData_t *rf_SstfDequeue(void *);
+RF_DiskQueueData_t *rf_SstfPeek(void *);
+int   rf_SstfPromote(void *, RF_StripeNum_t, RF_ReconUnitNum_t);
+RF_DiskQueueData_t *rf_ScanDequeue(void *);
+RF_DiskQueueData_t *rf_ScanPeek(void *);
+RF_DiskQueueData_t *rf_CscanDequeue(void *);
+RF_DiskQueueData_t *rf_CscanPeek(void *);
 
-#endif				/* !_RF__RF_SSTF_H_ */
+#endif	/* !_RF__RF_SSTF_H_ */
diff --git a/sys/dev/raidframe/rf_states.c b/sys/dev/raidframe/rf_states.c
index 0b78cc14233..3d0aa8ef813 100644
--- a/sys/dev/raidframe/rf_states.c
+++ b/sys/dev/raidframe/rf_states.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_states.c,v 1.8 2002/05/28 23:38:10 tdeval Exp $	*/
+/*	$OpenBSD: rf_states.c,v 1.9 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_states.c,v 1.15 2000/10/20 02:24:45 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -44,19 +45,22 @@
 #include "rf_etimer.h"
 #include "rf_kintf.h"
 
-/* prototypes for some of the available states.
-
-   States must:
-
-     - not block.
-
-     - either schedule rf_ContinueRaidAccess as a callback and return
-       RF_TRUE, or complete all of their work and return RF_FALSE.
+/*
+ * Prototypes for some of the available states.
+ *
+ * States must:
+ *
+ *   - not block.
+ *
+ *   - either schedule rf_ContinueRaidAccess as a callback and return
+ *     RF_TRUE, or complete all of their work and return RF_FALSE.
+ *
+ *   - increment desc->state when they have finished their work.
+ */
 
-     - increment desc->state when they have finished their work.
-*/
+char *StateName(RF_AccessState_t);
 
-static char *
+char *
 StateName(RF_AccessState_t state)
 {
 	switch (state) {
@@ -84,16 +88,15 @@ StateName(RF_AccessState_t state)
 	}
 }
 
-void 
-rf_ContinueRaidAccess(RF_RaidAccessDesc_t * desc)
+void
+rf_ContinueRaidAccess(RF_RaidAccessDesc_t *desc)
 {
-	int     suspended = RF_FALSE;
-	int     current_state_index = desc->state;
+	int suspended = RF_FALSE;
+	int current_state_index = desc->state;
 	RF_AccessState_t current_state = desc->states[current_state_index];
-	int     unit = desc->raidPtr->raidid;
+	int unit = desc->raidPtr->raidid;
 
 	do {
-
 		current_state_index = desc->state;
 		current_state = desc->states[current_state_index];
 
@@ -131,15 +134,17 @@ rf_ContinueRaidAccess(RF_RaidAccessDesc_t * desc)
 			break;
 		}
 
-		/* after this point, we cannot dereference desc since desc may
+		/*
+		 * After this point, we cannot dereference desc since desc may
 		 * have been freed. desc is only freed in LastState, so if we
-		 * renter this function or loop back up, desc should be valid. */
+		 * reenter this function or loop back up, desc should be valid.
+		 */
 
 		if (rf_printStatesDebug) {
-			printf("raid%d: State: %-24s StateIndex: %3i desc: 0x%ld %s\n",
-			       unit, StateName(current_state), 
-			       current_state_index, (long) desc,
-			    suspended ? "callback scheduled" : "looping");
+			printf("raid%d: State: %-24s StateIndex: %3i desc:"
+			       " 0x%ld %s.\n", unit, StateName(current_state),
+			       current_state_index, (long) desc, suspended ?
+			       "callback scheduled" : "looping");
 		}
 	} while (!suspended && current_state != rf_LastState);
 
@@ -147,14 +152,14 @@ rf_ContinueRaidAccess(RF_RaidAccessDesc_t * desc)
 }
 
 
-void 
-rf_ContinueDagAccess(RF_DagList_t * dagList)
+void
+rf_ContinueDagAccess(RF_DagList_t *dagList)
 {
 	RF_AccTraceEntry_t *tracerec = &(dagList->desc->tracerec);
 	RF_RaidAccessDesc_t *desc;
 	RF_DagHeader_t *dag_h;
 	RF_Etimer_t timer;
-	int     i;
+	int i;
 
 	desc = dagList->desc;
 
@@ -164,24 +169,27 @@ rf_ContinueDagAccess(RF_DagList_t * dagList)
 	tracerec->specific.user.exec_us = RF_ETIMER_VAL_US(timer);
 	RF_ETIMER_START(tracerec->timer);
 
-	/* skip to dag which just finished */
+	/* Skip to dag which just finished. */
 	dag_h = dagList->dags;
 	for (i = 0; i < dagList->numDagsDone; i++) {
 		dag_h = dag_h->next;
 	}
 
-	/* check to see if retry is required */
+	/* Check to see if retry is required. */
 	if (dag_h->status == rf_rollBackward) {
-		/* when a dag fails, mark desc status as bad and allow all
-		 * other dags in the desc to execute to completion.  then,
-		 * free all dags and start over */
-		desc->status = 1;	/* bad status */
+		/*
+		 * When a dag fails, mark desc status as bad and allow all
+		 * other dags in the desc to execute to completion. Then,
+		 * free all dags and start over.
+		 */
+		desc->status = 1;	/* Bad status. */
 		{
-			printf("raid%d: DAG failure: %c addr 0x%lx (%ld) nblk 0x%x (%d) buf 0x%lx\n",
-			       desc->raidPtr->raidid, desc->type, 
+			printf("raid%d: DAG failure: %c addr 0x%lx (%ld)"
+			       " nblk 0x%x (%d) buf 0x%lx.\n",
+			       desc->raidPtr->raidid, desc->type,
+			       (long) desc->raidAddress,
 			       (long) desc->raidAddress,
-			    (long) desc->raidAddress, (int) desc->numBlocks,
-			       (int) desc->numBlocks, 
+			       (int) desc->numBlocks, (int) desc->numBlocks,
 			       (unsigned long) (desc->bufPtr));
 		}
 	}
@@ -189,27 +197,27 @@ rf_ContinueDagAccess(RF_DagList_t * dagList)
 	rf_ContinueRaidAccess(desc);
 }
 
-int 
-rf_State_LastState(RF_RaidAccessDesc_t * desc)
+int
+rf_State_LastState(RF_RaidAccessDesc_t *desc)
 {
-	void    (*callbackFunc) (RF_CBParam_t) = desc->callbackFunc;
+	void (*callbackFunc) (RF_CBParam_t) = desc->callbackFunc;
 	RF_CBParam_t callbackArg;
 
 	callbackArg.p = desc->callbackArg;
 
 	/*
-         * If this is not an async request, wake up the caller
-         */
+	 * If this is not an async request, wake up the caller.
+	 */
 	if (desc->async_flag == 0)
 		wakeup(desc->bp);
 
-	/* 
-	 * That's all the IO for this one... unbusy the 'disk'.
+	/*
+	 * That's all the IO for this one... Unbusy the 'disk'.
 	 */
 
 	rf_disk_unbusy(desc);
 
-	/* 
+	/*
 	 * Wakeup any requests waiting to go.
 	 */
 
@@ -217,12 +225,12 @@ rf_State_LastState(RF_RaidAccessDesc_t * desc)
 	((RF_Raid_t *) desc->raidPtr)->openings++;
 	RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
 
-	/* wake up any pending IO */
+	/* Wake up any pending I/O. */
 	raidstart(((RF_Raid_t *) desc->raidPtr));
 
-	/* printf("%s: Calling biodone on 0x%x\n", __func__, desc->bp); */
+	/* printf("%s: Calling biodone on 0x%x.\n", __func__, desc->bp); */
 	splassert(IPL_BIO);
-	biodone(desc->bp);	/* access came through ioctl */
+	biodone(desc->bp);	/* Access came through ioctl. */
 
 	if (callbackFunc)
 		callbackFunc(callbackArg);
@@ -231,24 +239,26 @@ rf_State_LastState(RF_RaidAccessDesc_t * desc)
 	return RF_FALSE;
 }
 
-int 
-rf_State_IncrAccessCount(RF_RaidAccessDesc_t * desc)
+int
+rf_State_IncrAccessCount(RF_RaidAccessDesc_t *desc)
 {
 	RF_Raid_t *raidPtr;
 
 	raidPtr = desc->raidPtr;
-	/* Bummer. We have to do this to be 100% safe w.r.t. the increment
-	 * below */
+	/*
+	 * Bummer. We have to do this to be 100% safe w.r.t. the increment
+	 * below.
+	 */
 	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
-	raidPtr->accs_in_flight++;	/* used to detect quiescence */
+	raidPtr->accs_in_flight++;	/* Used to detect quiescence. */
 	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
 
 	desc->state++;
 	return RF_FALSE;
 }
 
-int 
-rf_State_DecrAccessCount(RF_RaidAccessDesc_t * desc)
+int
+rf_State_DecrAccessCount(RF_RaidAccessDesc_t *desc)
 {
 	RF_Raid_t *raidPtr;
 
@@ -259,19 +269,20 @@ rf_State_DecrAccessCount(RF_RaidAccessDesc_t * desc)
 	if (raidPtr->accesses_suspended && raidPtr->accs_in_flight == 0) {
 		rf_SignalQuiescenceLock(raidPtr, raidPtr->reconDesc);
 	}
-	rf_UpdateUserStats(raidPtr, RF_ETIMER_VAL_US(desc->timer), desc->numBlocks);
+	rf_UpdateUserStats(raidPtr, RF_ETIMER_VAL_US(desc->timer),
+	    desc->numBlocks);
 	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
 
 	desc->state++;
 	return RF_FALSE;
 }
 
-int 
-rf_State_Quiesce(RF_RaidAccessDesc_t * desc)
+int
+rf_State_Quiesce(RF_RaidAccessDesc_t *desc)
 {
 	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
 	RF_Etimer_t timer;
-	int     suspended = RF_FALSE;
+	int suspended = RF_FALSE;
 	RF_Raid_t *raidPtr;
 
 	raidPtr = desc->raidPtr;
@@ -283,10 +294,13 @@ rf_State_Quiesce(RF_RaidAccessDesc_t * desc)
 	if (raidPtr->accesses_suspended) {
 		RF_CallbackDesc_t *cb;
 		cb = rf_AllocCallbackDesc();
-		/* XXX the following cast is quite bogus...
-		 * rf_ContinueRaidAccess takes a (RF_RaidAccessDesc_t *) as an
-		 * argument..  GO */
-		cb->callbackFunc = (void (*) (RF_CBParam_t)) rf_ContinueRaidAccess;
+		/*
+		 * XXX The following cast is quite bogus...
+		 * rf_ContinueRaidAccess takes a (RF_RaidAccessDesc_t *)
+		 * as an argument... GO
+		 */
+		cb->callbackFunc = (void (*) (RF_CBParam_t))
+		    rf_ContinueRaidAccess;
 		cb->callbackArg.p = (void *) desc;
 		cb->next = raidPtr->quiesce_wait_list;
 		raidPtr->quiesce_wait_list = cb;
@@ -299,14 +313,14 @@ rf_State_Quiesce(RF_RaidAccessDesc_t * desc)
 	tracerec->specific.user.suspend_ovhd_us += RF_ETIMER_VAL_US(timer);
 
 	if (suspended && rf_quiesceDebug)
-		printf("Stalling access due to quiescence lock\n");
+		printf("Stalling access due to quiescence lock.\n");
 
 	desc->state++;
 	return suspended;
 }
 
-int 
-rf_State_Map(RF_RaidAccessDesc_t * desc)
+int
+rf_State_Map(RF_RaidAccessDesc_t *desc)
 {
 	RF_Raid_t *raidPtr = desc->raidPtr;
 	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
@@ -314,8 +328,8 @@ rf_State_Map(RF_RaidAccessDesc_t * desc)
 
 	RF_ETIMER_START(timer);
 
-	if (!(desc->asmap = rf_MapAccess(raidPtr, desc->raidAddress, desc->numBlocks,
-		    desc->bufPtr, RF_DONT_REMAP)))
+	if (!(desc->asmap = rf_MapAccess(raidPtr, desc->raidAddress,
+	     desc->numBlocks, desc->bufPtr, RF_DONT_REMAP)))
 		RF_PANIC();
 
 	RF_ETIMER_STOP(timer);
@@ -326,21 +340,21 @@ rf_State_Map(RF_RaidAccessDesc_t * desc)
 	return RF_FALSE;
 }
 
-int 
-rf_State_Lock(RF_RaidAccessDesc_t * desc)
+int
+rf_State_Lock(RF_RaidAccessDesc_t *desc)
 {
 	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
 	RF_Raid_t *raidPtr = desc->raidPtr;
 	RF_AccessStripeMapHeader_t *asmh = desc->asmap;
 	RF_AccessStripeMap_t *asm_p;
 	RF_Etimer_t timer;
-	int     suspended = RF_FALSE;
+	int suspended = RF_FALSE;
 
 	RF_ETIMER_START(timer);
 	if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) {
 		RF_StripeNum_t lastStripeID = -1;
 
-		/* acquire each lock that we don't already hold */
+		/* Acquire each lock that we don't already hold. */
 		for (asm_p = asmh->stripeMap; asm_p; asm_p = asm_p->next) {
 			RF_ASSERT(RF_IO_IS_R_OR_W(desc->type));
 			if (!rf_suppressLocksAndLargeWrites &&
@@ -348,48 +362,63 @@ rf_State_Lock(RF_RaidAccessDesc_t * desc)
 			    !(desc->flags & RF_DAG_SUPPRESS_LOCKS) &&
 			    !(asm_p->flags & RF_ASM_FLAGS_LOCK_TRIED)) {
 				asm_p->flags |= RF_ASM_FLAGS_LOCK_TRIED;
-				RF_ASSERT(asm_p->stripeID > lastStripeID);	/* locks must be
-										 * acquired
-										 * hierarchically */
+				/* Locks must be acquired hierarchically. */
+				RF_ASSERT(asm_p->stripeID > lastStripeID);
 				lastStripeID = asm_p->stripeID;
-				/* XXX the cast to (void (*)(RF_CBParam_t))
-				 * below is bogus!  GO */
-				RF_INIT_LOCK_REQ_DESC(asm_p->lockReqDesc, desc->type,
-				    (void (*) (struct buf *)) rf_ContinueRaidAccess, desc, asm_p,
+				/*
+				 * XXX The cast to (void (*)(RF_CBParam_t))
+				 * below is bogus !  GO
+				 */
+				RF_INIT_LOCK_REQ_DESC(asm_p->lockReqDesc,
+				    desc->type, (void (*) (struct buf *))
+				     rf_ContinueRaidAccess, desc, asm_p,
 				    raidPtr->Layout.dataSectorsPerStripe);
-				if (rf_AcquireStripeLock(raidPtr->lockTable, asm_p->stripeID,
-					&asm_p->lockReqDesc)) {
+				if (rf_AcquireStripeLock(raidPtr->lockTable,
+				     asm_p->stripeID, &asm_p->lockReqDesc)) {
 					suspended = RF_TRUE;
 					break;
 				}
 			}
 			if (desc->type == RF_IO_TYPE_WRITE &&
-			    raidPtr->status[asm_p->physInfo->row] == rf_rs_reconstructing) {
-				if (!(asm_p->flags & RF_ASM_FLAGS_FORCE_TRIED)) {
-					int     val;
-
-					asm_p->flags |= RF_ASM_FLAGS_FORCE_TRIED;
-					/* XXX the cast below is quite
-					 * bogus!!! XXX  GO */
-					val = rf_ForceOrBlockRecon(raidPtr, asm_p,
-					    (void (*) (RF_Raid_t *, void *)) rf_ContinueRaidAccess, desc);
+			    raidPtr->status[asm_p->physInfo->row] ==
+			    rf_rs_reconstructing) {
+				if (!(asm_p->flags & RF_ASM_FLAGS_FORCE_TRIED))
+				{
+					int val;
+
+					asm_p->flags |=
+					    RF_ASM_FLAGS_FORCE_TRIED;
+					/*
+					 * XXX The cast below is quite
+					 * bogus !!! XXX  GO
+					 */
+					val = rf_ForceOrBlockRecon(raidPtr,
+					    asm_p,
+					    (void (*) (RF_Raid_t *, void *))
+					     rf_ContinueRaidAccess, desc);
 					if (val == 0) {
-						asm_p->flags |= RF_ASM_FLAGS_RECON_BLOCKED;
+						asm_p->flags |=
+						    RF_ASM_FLAGS_RECON_BLOCKED;
 					} else {
 						suspended = RF_TRUE;
 						break;
 					}
 				} else {
 					if (rf_pssDebug) {
-						printf("raid%d: skipping force/block because already done, psid %ld\n",
-						       desc->raidPtr->raidid, 
+						printf("raid%d: skipping"
+						       " force/block because"
+						       " already done, psid"
+						       " %ld.\n",
+						       desc->raidPtr->raidid,
 						       (long) asm_p->stripeID);
 					}
 				}
 			} else {
 				if (rf_pssDebug) {
-					printf("raid%d: skipping force/block because not write or not under recon, psid %ld\n",
-					       desc->raidPtr->raidid, 
+					printf("raid%d: skipping force/block"
+					       " because not write or not"
+					       " under recon, psid %ld.\n",
+					       desc->raidPtr->raidid,
 					       (long) asm_p->stripeID);
 				}
 			}
@@ -405,15 +434,16 @@ rf_State_Lock(RF_RaidAccessDesc_t * desc)
 	desc->state++;
 	return (RF_FALSE);
 }
+
 /*
- * the following three states create, execute, and post-process dags
- * the error recovery unit is a single dag.
- * by default, SelectAlgorithm creates an array of dags, one per parity stripe
- * in some tricky cases, multiple dags per stripe are created
- *   - dags within a parity stripe are executed sequentially (arbitrary order)
- *   - dags for distinct parity stripes are executed concurrently
+ * The following three states create, execute, and post-process DAGs.
+ * The error recovery unit is a single DAG.
+ * By default, SelectAlgorithm creates an array of DAGs, one per parity stripe.
+ * In some tricky cases, multiple dags per stripe are created.
+ *   - DAGs within a parity stripe are executed sequentially (arbitrary order).
+ *   - DAGs for distinct parity stripes are executed concurrently.
  *
- * repeat until all dags complete successfully -or- dag selection fails
+ * Repeat until all DAGs complete successfully -or- DAG selection fails.
  *
  * while !done
  *   create dag(s) (SelectAlgorithm)
@@ -426,37 +456,42 @@ rf_State_Lock(RF_RaidAccessDesc_t * desc)
  *   else
  *     done (FAIL)
  */
-int 
-rf_State_CreateDAG(RF_RaidAccessDesc_t * desc)
+int
+rf_State_CreateDAG(RF_RaidAccessDesc_t *desc)
 {
 	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
 	RF_Etimer_t timer;
 	RF_DagHeader_t *dag_h;
-	int     i, selectStatus;
+	int i, selectStatus;
 
-	/* generate a dag for the access, and fire it off.  When the dag
-	 * completes, we'll get re-invoked in the next state. */
+	/*
+	 * Generate a dag for the access, and fire it off. When the dag
+	 * completes, we'll get re-invoked in the next state.
+	 */
 	RF_ETIMER_START(timer);
-	/* SelectAlgorithm returns one or more dags */
-	selectStatus = rf_SelectAlgorithm(desc, desc->flags | RF_DAG_SUPPRESS_LOCKS);
+	/* SelectAlgorithm returns one or more dags. */
+	selectStatus = rf_SelectAlgorithm(desc,
+	    desc->flags | RF_DAG_SUPPRESS_LOCKS);
 	if (rf_printDAGsDebug)
 		for (i = 0; i < desc->numStripes; i++)
 			rf_PrintDAGList(desc->dagArray[i].dags);
 	RF_ETIMER_STOP(timer);
 	RF_ETIMER_EVAL(timer);
-	/* update time to create all dags */
+	/* Update time to create all dags. */
 	tracerec->specific.user.dag_create_us = RF_ETIMER_VAL_US(timer);
 
-	desc->status = 0;	/* good status */
+	desc->status = 0;	/* Good status. */
 
 	if (selectStatus) {
-		/* failed to create a dag */
-		/* this happens when there are too many faults or incomplete
-		 * dag libraries */
+		/* Failed to create a dag. */
+		/*
+		 * This happens when there are too many faults or incomplete
+		 * dag libraries.
+		 */
 		printf("[Failed to create a DAG]\n");
 		RF_PANIC();
 	} else {
-		/* bind dags to desc */
+		/* Bind dags to desc. */
 		for (i = 0; i < desc->numStripes; i++) {
 			dag_h = desc->dagArray[i].dags;
 			while (dag_h) {
@@ -466,118 +501,135 @@ rf_State_CreateDAG(RF_RaidAccessDesc_t * desc)
 			}
 		}
 		desc->flags |= RF_DAG_DISPATCH_RETURNED;
-		desc->state++;	/* next state should be rf_State_ExecuteDAG */
+		desc->state++;	/* Next state should be rf_State_ExecuteDAG. */
 	}
 	return RF_FALSE;
 }
 
 
-
-/* the access has an array of dagLists, one dagList per parity stripe.
- * fire the first dag in each parity stripe (dagList).
- * dags within a stripe (dagList) must be executed sequentially
- *  - this preserves atomic parity update
- * dags for independents parity groups (stripes) are fired concurrently */
-
-int 
-rf_State_ExecuteDAG(RF_RaidAccessDesc_t * desc)
+/*
+ * The access has an array of dagLists, one dagList per parity stripe.
+ * Fire the first DAG in each parity stripe (dagList).
+ * DAGs within a stripe (dagList) must be executed sequentially.
+ *  - This preserves atomic parity update.
+ * DAGs for independents parity groups (stripes) are fired concurrently.
+ */
+int
+rf_State_ExecuteDAG(RF_RaidAccessDesc_t *desc)
 {
-	int     i;
+	int i;
 	RF_DagHeader_t *dag_h;
 	RF_DagList_t *dagArray = desc->dagArray;
 
-	/* next state is always rf_State_ProcessDAG important to do this
+	/*
+	 * Next state is always rf_State_ProcessDAG. Important to do this
 	 * before firing the first dag (it may finish before we leave this
-	 * routine) */
+	 * routine).
+	 */
 	desc->state++;
 
-	/* sweep dag array, a stripe at a time, firing the first dag in each
-	 * stripe */
+	/*
+	 * Sweep dag array, a stripe at a time, firing the first dag in each
+	 * stripe.
+	 */
 	for (i = 0; i < desc->numStripes; i++) {
 		RF_ASSERT(dagArray[i].numDags > 0);
 		RF_ASSERT(dagArray[i].numDagsDone == 0);
 		RF_ASSERT(dagArray[i].numDagsFired == 0);
 		RF_ETIMER_START(dagArray[i].tracerec.timer);
-		/* fire first dag in this stripe */
+		/* Fire first dag in this stripe. */
 		dag_h = dagArray[i].dags;
 		RF_ASSERT(dag_h);
 		dagArray[i].numDagsFired++;
-		/* XXX Yet another case where we pass in a conflicting
-		 * function pointer :-(  XXX  GO */
-		rf_DispatchDAG(dag_h, (void (*) (void *)) rf_ContinueDagAccess, &dagArray[i]);
+		/*
+		 * XXX Yet another case where we pass in a conflicting
+		 * function pointer :-(  XXX  GO
+		 */
+		rf_DispatchDAG(dag_h, (void (*) (void *)) rf_ContinueDagAccess,
+		    &dagArray[i]);
 	}
 
-	/* the DAG will always call the callback, even if there was no
-	 * blocking, so we are always suspended in this state */
+	/*
+	 * The DAG will always call the callback, even if there was no
+	 * blocking, so we are always suspended in this state.
+	 */
 	return RF_TRUE;
 }
 
 
-
-/* rf_State_ProcessDAG is entered when a dag completes.
- * first, check to all dags in the access have completed
- * if not, fire as many dags as possible */
-
-int 
-rf_State_ProcessDAG(RF_RaidAccessDesc_t * desc)
+/*
+ * rf_State_ProcessDAG is entered when a dag completes.
+ * First, check that all DAGs in the access have completed.
+ * If not, fire as many DAGs as possible.
+ */
+int
+rf_State_ProcessDAG(RF_RaidAccessDesc_t *desc)
 {
 	RF_AccessStripeMapHeader_t *asmh = desc->asmap;
 	RF_Raid_t *raidPtr = desc->raidPtr;
 	RF_DagHeader_t *dag_h;
-	int     i, j, done = RF_TRUE;
+	int i, j, done = RF_TRUE;
 	RF_DagList_t *dagArray = desc->dagArray;
 	RF_Etimer_t timer;
 
-	/* check to see if this is the last dag */
+	/* Check to see if this is the last dag. */
 	for (i = 0; i < desc->numStripes; i++)
 		if (dagArray[i].numDags != dagArray[i].numDagsDone)
 			done = RF_FALSE;
 
 	if (done) {
 		if (desc->status) {
-			/* a dag failed, retry */
+			/* A dag failed, retry. */
 			RF_ETIMER_START(timer);
-			/* free all dags */
+			/* Free all dags. */
 			for (i = 0; i < desc->numStripes; i++) {
 				rf_FreeDAG(desc->dagArray[i].dags);
 			}
 			rf_MarkFailuresInASMList(raidPtr, asmh);
-			/* back up to rf_State_CreateDAG */
+			/* Back up to rf_State_CreateDAG. */
 			desc->state = desc->state - 2;
 			return RF_FALSE;
 		} else {
-			/* move on to rf_State_Cleanup */
+			/* Move on to rf_State_Cleanup. */
 			desc->state++;
 		}
 		return RF_FALSE;
 	} else {
-		/* more dags to execute */
-		/* see if any are ready to be fired.  if so, fire them */
-		/* don't fire the initial dag in a list, it's fired in
-		 * rf_State_ExecuteDAG */
+		/* More dags to execute. */
+		/* See if any are ready to be fired. If so, fire them. */
+		/*
+		 * Don't fire the initial dag in a list, it's fired in
+		 * rf_State_ExecuteDAG.
+		 */
 		for (i = 0; i < desc->numStripes; i++) {
-			if ((dagArray[i].numDagsDone < dagArray[i].numDags)
-			    && (dagArray[i].numDagsDone == dagArray[i].numDagsFired)
-			    && (dagArray[i].numDagsFired > 0)) {
+			if ((dagArray[i].numDagsDone < dagArray[i].numDags) &&
+			    (dagArray[i].numDagsDone ==
+			     dagArray[i].numDagsFired) &&
+			    (dagArray[i].numDagsFired > 0)) {
 				RF_ETIMER_START(dagArray[i].tracerec.timer);
-				/* fire next dag in this stripe */
-				/* first, skip to next dag awaiting execution */
+				/* Fire next dag in this stripe. */
+				/*
+				 * First, skip to next dag awaiting execution.
+				 */
 				dag_h = dagArray[i].dags;
 				for (j = 0; j < dagArray[i].numDagsDone; j++)
 					dag_h = dag_h->next;
 				dagArray[i].numDagsFired++;
-				/* XXX and again we pass a different function
-				 * pointer.. GO */
-				rf_DispatchDAG(dag_h, (void (*) (void *)) rf_ContinueDagAccess,
-				    &dagArray[i]);
+				/*
+				 * XXX And again we pass a different function
+				 * pointer... GO
+				 */
+				rf_DispatchDAG(dag_h, (void (*) (void *))
+				    rf_ContinueDagAccess, &dagArray[i]);
 			}
 		}
 		return RF_TRUE;
 	}
 }
-/* only make it this far if all dags complete successfully */
-int 
-rf_State_Cleanup(RF_RaidAccessDesc_t * desc)
+
+/* Only make it this far if all dags complete successfully. */
+int
+rf_State_Cleanup(RF_RaidAccessDesc_t *desc)
 {
 	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
 	RF_AccessStripeMapHeader_t *asmh = desc->asmap;
@@ -594,23 +646,23 @@ rf_State_Cleanup(RF_RaidAccessDesc_t * desc)
 	RF_ETIMER_EVAL(timer);
 	tracerec->specific.user.dag_retry_us = RF_ETIMER_VAL_US(timer);
 
-	/* the RAID I/O is complete.  Clean up. */
+	/* The RAID I/O is complete. Clean up. */
 	tracerec->specific.user.dag_retry_us = 0;
 
 	RF_ETIMER_START(timer);
 	if (desc->flags & RF_DAG_RETURN_DAG) {
-		/* copy dags into paramDAG */
+		/* Copy dags into paramDAG. */
 		*(desc->paramDAG) = desc->dagArray[0].dags;
 		dag_h = *(desc->paramDAG);
 		for (i = 1; i < desc->numStripes; i++) {
-			/* concatenate dags from remaining stripes */
+			/* Concatenate dags from remaining stripes. */
 			RF_ASSERT(dag_h);
 			while (dag_h->next)
 				dag_h = dag_h->next;
 			dag_h->next = desc->dagArray[i].dags;
 		}
 	} else {
-		/* free all dags */
+		/* Free all dags. */
 		for (i = 0; i < desc->numStripes; i++) {
 			rf_FreeDAG(desc->dagArray[i].dags);
 		}
@@ -627,9 +679,8 @@ rf_State_Cleanup(RF_RaidAccessDesc_t * desc)
 			    asm_p->parityInfo &&
 			    !(desc->flags & RF_DAG_SUPPRESS_LOCKS)) {
 				RF_ASSERT_VALID_LOCKREQ(&asm_p->lockReqDesc);
-				rf_ReleaseStripeLock(raidPtr->lockTable, 
-						     asm_p->stripeID,
-				    &asm_p->lockReqDesc);
+				rf_ReleaseStripeLock(raidPtr->lockTable,
+				    asm_p->stripeID, &asm_p->lockReqDesc);
 			}
 			if (asm_p->flags & RF_ASM_FLAGS_RECON_BLOCKED) {
 				rf_UnblockRecon(raidPtr, asm_p);
diff --git a/sys/dev/raidframe/rf_states.h b/sys/dev/raidframe/rf_states.h
index 25beba5905a..bb1f395e7f1 100644
--- a/sys/dev/raidframe/rf_states.h
+++ b/sys/dev/raidframe/rf_states.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_states.h,v 1.2 1999/02/16 00:03:28 niklas Exp $	*/
+/*	$OpenBSD: rf_states.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_states.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,22 +28,22 @@
  * rights to redistribute these changes.
  */
 
-#ifndef _RF__RF_STATES_H_
-#define _RF__RF_STATES_H_
+#ifndef	_RF__RF_STATES_H_
+#define	_RF__RF_STATES_H_
 
 #include "rf_types.h"
 
-void    rf_ContinueRaidAccess(RF_RaidAccessDesc_t * desc);
-void    rf_ContinueDagAccess(RF_DagList_t * dagList);
-int     rf_State_LastState(RF_RaidAccessDesc_t * desc);
-int     rf_State_IncrAccessCount(RF_RaidAccessDesc_t * desc);
-int     rf_State_DecrAccessCount(RF_RaidAccessDesc_t * desc);
-int     rf_State_Quiesce(RF_RaidAccessDesc_t * desc);
-int     rf_State_Map(RF_RaidAccessDesc_t * desc);
-int     rf_State_Lock(RF_RaidAccessDesc_t * desc);
-int     rf_State_CreateDAG(RF_RaidAccessDesc_t * desc);
-int     rf_State_ExecuteDAG(RF_RaidAccessDesc_t * desc);
-int     rf_State_ProcessDAG(RF_RaidAccessDesc_t * desc);
-int     rf_State_Cleanup(RF_RaidAccessDesc_t * desc);
+void rf_ContinueRaidAccess(RF_RaidAccessDesc_t *);
+void rf_ContinueDagAccess(RF_DagList_t *);
+int  rf_State_LastState(RF_RaidAccessDesc_t *);
+int  rf_State_IncrAccessCount(RF_RaidAccessDesc_t *);
+int  rf_State_DecrAccessCount(RF_RaidAccessDesc_t *);
+int  rf_State_Quiesce(RF_RaidAccessDesc_t *);
+int  rf_State_Map(RF_RaidAccessDesc_t *);
+int  rf_State_Lock(RF_RaidAccessDesc_t *);
+int  rf_State_CreateDAG(RF_RaidAccessDesc_t *);
+int  rf_State_ExecuteDAG(RF_RaidAccessDesc_t *);
+int  rf_State_ProcessDAG(RF_RaidAccessDesc_t *);
+int  rf_State_Cleanup(RF_RaidAccessDesc_t *);
 
-#endif				/* !_RF__RF_STATES_H_ */
+#endif	/* !_RF__RF_STATES_H_ */
diff --git a/sys/dev/raidframe/rf_stripelocks.c b/sys/dev/raidframe/rf_stripelocks.c
index 34eff4c4b47..72b658a2e5a 100644
--- a/sys/dev/raidframe/rf_stripelocks.c
+++ b/sys/dev/raidframe/rf_stripelocks.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_stripelocks.c,v 1.4 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_stripelocks.c,v 1.5 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_stripelocks.c,v 1.5 2000/01/08 23:45:05 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,14 +29,14 @@
  */
 
 /*
- * stripelocks.c -- code to lock stripes for read and write access
+ * stripelocks.c -- Code to lock stripes for read and write access.
  *
  * The code distinguishes between read locks and write locks. There can be
  * as many readers to given stripe as desired. When a write request comes
  * in, no further readers are allowed to enter, and all subsequent requests
- * are queued in FIFO order. When a the number of readers goes to zero, the
+ * are queued in FIFO order. When the number of readers goes to zero, the
  * writer is given the lock. When a writer releases the lock, the list of
- * queued requests is scanned, and all readersq up to the next writer are
+ * queued requests is scanned, and all readers up to the next writer are
  * given the lock.
  *
  * The lock table size must be one less than a power of two, but HASH_STRIPEID
@@ -46,12 +47,12 @@
  * you acquire the lock, you've locked only this range of addresses, and
  * other threads can concurrently read/write any non-overlapping portions
  * of the stripe. The "addresses" that you lock are abstract in that you
- * can pass in anything you like.  The expectation is that you'll pass in
+ * can pass in anything you like. The expectation is that you'll pass in
  * the range of physical disk offsets of the parity bits you're planning
  * to update. The idea behind this, of course, is to allow sub-stripe
  * locking. The implementation is perhaps not the best imaginable; in the
  * worst case a lock release is O(n^2) in the total number of outstanding
- * requests to a given stripe.  Note that if you're striping with a
+ * requests to a given stripe. Note that if you're striping with a
  * stripe unit size equal to an entire disk (i.e. not striping), there will
  * be only one stripe and you may spend some significant number of cycles
  * searching through stripe lock descriptors.
@@ -67,78 +68,118 @@
 #include "rf_driver.h"
 #include "rf_shutdown.h"
 
-#define Dprintf1(s,a)         rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf2(s,a,b)       rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
-#define Dprintf3(s,a,b,c)     rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
-#define Dprintf4(s,a,b,c,d)   rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),NULL,NULL,NULL,NULL)
-#define Dprintf5(s,a,b,c,d,e) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),NULL,NULL,NULL)
-#define Dprintf6(s,a,b,c,d,e,f) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),NULL,NULL)
-#define Dprintf7(s,a,b,c,d,e,f,g) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),(void *)((unsigned long)g),NULL)
-#define Dprintf8(s,a,b,c,d,e,f,g,h) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),(void *)((unsigned long)d),(void *)((unsigned long)e),(void *)((unsigned long)f),(void *)((unsigned long)g),(void *)((unsigned long)h))
-
-#define FLUSH
-
-#define HASH_STRIPEID(_sid_)  ( (_sid_) & (rf_lockTableSize-1) )
-
-static void AddToWaitersQueue(RF_LockTableEntry_t * lockTable, RF_StripeLockDesc_t * lockDesc, RF_LockReqDesc_t * lockReqDesc);
-static RF_StripeLockDesc_t *AllocStripeLockDesc(RF_StripeNum_t stripeID);
-static void FreeStripeLockDesc(RF_StripeLockDesc_t * p);
-static void PrintLockedStripes(RF_LockTableEntry_t * lockTable);
-
-/* determines if two ranges overlap.  always yields false if either start value is negative  */
-#define SINGLE_RANGE_OVERLAP(_strt1, _stop1, _strt2, _stop2)                                     \
-  ( (_strt1 >= 0) && (_strt2 >= 0) && (RF_MAX(_strt1, _strt2) <= RF_MIN(_stop1, _stop2)) )
-
-/* determines if any of the ranges specified in the two lock descriptors overlap each other */
-#define RANGE_OVERLAP(_cand, _pred)                                                  \
-  ( SINGLE_RANGE_OVERLAP((_cand)->start,  (_cand)->stop,  (_pred)->start,  (_pred)->stop ) ||    \
-    SINGLE_RANGE_OVERLAP((_cand)->start2, (_cand)->stop2, (_pred)->start,  (_pred)->stop ) ||    \
-    SINGLE_RANGE_OVERLAP((_cand)->start,  (_cand)->stop,  (_pred)->start2, (_pred)->stop2) ||    \
-    SINGLE_RANGE_OVERLAP((_cand)->start2, (_cand)->stop2, (_pred)->start2, (_pred)->stop2) )
-
-/* Determines if a candidate lock request conflicts with a predecessor lock req.
- * Note that the arguments are not interchangeable.
+#define	Dprintf1(s,a)							\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    NULL, NULL, NULL, NULL, NULL, NULL, NULL)
+#define	Dprintf2(s,a,b)							\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), NULL, NULL, NULL, NULL, NULL, NULL)
+#define	Dprintf3(s,a,b,c)						\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), (void *)((unsigned long)c),	\
+	    NULL, NULL, NULL, NULL, NULL)
+#define	Dprintf4(s,a,b,c,d)						\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), (void *)((unsigned long)c),	\
+	    (void *)((unsigned long)d), NULL, NULL, NULL, NULL)
+#define	Dprintf5(s,a,b,c,d,e)						\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), (void *)((unsigned long)c),	\
+	    (void *)((unsigned long)d), (void *)((unsigned long)e),	\
+	    NULL, NULL, NULL)
+#define	Dprintf6(s,a,b,c,d,e,f)						\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), (void *)((unsigned long)c),	\
+	    (void *)((unsigned long)d), (void *)((unsigned long)e),	\
+	    (void *)((unsigned long)f), NULL, NULL)
+#define	Dprintf7(s,a,b,c,d,e,f,g)					\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), (void *)((unsigned long)c),	\
+	    (void *)((unsigned long)d), (void *)((unsigned long)e),	\
+	    (void *)((unsigned long)f), (void *)((unsigned long)g), NULL)
+#define	Dprintf8(s,a,b,c,d,e,f,g,h)					\
+	rf_debug_printf(s, (void *)((unsigned long)a),			\
+	    (void *)((unsigned long)b), (void *)((unsigned long)c),	\
+	    (void *)((unsigned long)d), (void *)((unsigned long)e),	\
+	    (void *)((unsigned long)f), (void *)((unsigned long)g),	\
+	    (void *)((unsigned long)h))
+
+#define	FLUSH
+
+#define	HASH_STRIPEID(_sid_)	((_sid_) & (rf_lockTableSize-1))
+
+void rf_AddToWaitersQueue(RF_LockTableEntry_t *, RF_StripeLockDesc_t *,
+	RF_LockReqDesc_t *);
+RF_StripeLockDesc_t *rf_AllocStripeLockDesc(RF_StripeNum_t);
+void rf_FreeStripeLockDesc(RF_StripeLockDesc_t *);
+void rf_PrintLockedStripes(RF_LockTableEntry_t *);
+
+/*
+ * Determines if two ranges overlap. Always yields false if either start
+ * value is negative.
+ */
+#define	SINGLE_RANGE_OVERLAP(_strt1,_stop1,_strt2,_stop2)		\
+	((_strt1 >= 0) && (_strt2 >= 0) &&				\
+	 (RF_MAX(_strt1, _strt2) <= RF_MIN(_stop1, _stop2)))
+
+/*
+ * Determines if any of the ranges specified in the two lock descriptors
+ * overlap each other.
+ */
+#define	RANGE_OVERLAP(_cand,_pred)					\
+	(SINGLE_RANGE_OVERLAP((_cand)->start,  (_cand)->stop,		\
+			      (_pred)->start,  (_pred)->stop) ||	\
+	 SINGLE_RANGE_OVERLAP((_cand)->start2, (_cand)->stop2,		\
+			      (_pred)->start,  (_pred)->stop) ||	\
+	 SINGLE_RANGE_OVERLAP((_cand)->start,  (_cand)->stop,		\
+			      (_pred)->start2, (_pred)->stop2) ||	\
+	 SINGLE_RANGE_OVERLAP((_cand)->start2, (_cand)->stop2,		\
+			      (_pred)->start2, (_pred)->stop2))
+
+/*
+ * Determines if a candidate lock request conflicts with a predecessor
+ * lock req. Note that the arguments are not interchangeable.
  * The rules are:
- *      a candidate read conflicts with a predecessor write if any ranges overlap
- *      a candidate write conflicts with a predecessor read if any ranges overlap
- *      a candidate write conflicts with a predecessor write if any ranges overlap
+ *  A candidate read conflicts with a predecessor write if any ranges overlap.
+ *  A candidate write conflicts with a predecessor read if any ranges overlap.
+ *  A candidate write conflicts with a predecessor write if any ranges overlap.
  */
-#define STRIPELOCK_CONFLICT(_cand, _pred)                                        \
-  RANGE_OVERLAP((_cand), (_pred)) &&                                        \
-  ( ( (((_cand)->type == RF_IO_TYPE_READ) && ((_pred)->type == RF_IO_TYPE_WRITE)) ||                      \
-      (((_cand)->type == RF_IO_TYPE_WRITE) && ((_pred)->type == RF_IO_TYPE_READ)) ||                      \
-      (((_cand)->type == RF_IO_TYPE_WRITE) && ((_pred)->type == RF_IO_TYPE_WRITE))                         \
-    )                                                                            \
-  )
+#define	STRIPELOCK_CONFLICT(_cand,_pred)				\
+	(RANGE_OVERLAP((_cand), (_pred)) &&				\
+	 (((((_cand)->type == RF_IO_TYPE_READ) &&			\
+	    ((_pred)->type == RF_IO_TYPE_WRITE)) ||			\
+	   (((_cand)->type == RF_IO_TYPE_WRITE) &&			\
+	    ((_pred)->type == RF_IO_TYPE_READ)) ||			\
+	   (((_cand)->type == RF_IO_TYPE_WRITE) &&			\
+	    ((_pred)->type == RF_IO_TYPE_WRITE)))))
 
 static RF_FreeList_t *rf_stripelock_freelist;
-#define RF_MAX_FREE_STRIPELOCK 128
-#define RF_STRIPELOCK_INC        8
-#define RF_STRIPELOCK_INITIAL   32
+#define	RF_MAX_FREE_STRIPELOCK		128
+#define	RF_STRIPELOCK_INC		  8
+#define	RF_STRIPELOCK_INITIAL		 32
 
-static void rf_ShutdownStripeLockFreeList(void *);
-static void rf_RaidShutdownStripeLocks(void *);
+void rf_ShutdownStripeLockFreeList(void *);
+void rf_RaidShutdownStripeLocks(void *);
 
-static void 
-rf_ShutdownStripeLockFreeList(ignored)
-	void   *ignored;
+void
+rf_ShutdownStripeLockFreeList(void *ignored)
 {
-	RF_FREELIST_DESTROY(rf_stripelock_freelist, next, (RF_StripeLockDesc_t *));
+	RF_FREELIST_DESTROY(rf_stripelock_freelist, next,
+	    (RF_StripeLockDesc_t *));
 }
 
-int 
-rf_ConfigureStripeLockFreeList(listp)
-	RF_ShutdownList_t **listp;
+int
+rf_ConfigureStripeLockFreeList(RF_ShutdownList_t **listp)
 {
 	unsigned mask;
-	int     rc;
+	int rc;
 
 	RF_FREELIST_CREATE(rf_stripelock_freelist, RF_MAX_FREE_STRIPELOCK,
 	    RF_STRIPELOCK_INITIAL, sizeof(RF_StripeLockDesc_t));
 	rc = rf_ShutdownCreate(listp, rf_ShutdownStripeLockFreeList, NULL);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s"
+		    " line %d rc=%d.\n", __FILE__, __LINE__, rc);
 		rf_ShutdownStripeLockFreeList(NULL);
 		return (rc);
 	}
@@ -148,40 +189,42 @@ rf_ConfigureStripeLockFreeList(listp)
 		if (rf_lockTableSize == mask)
 			break;
 	if (!mask) {
-		printf("[WARNING:  lock table size must be a power of two.  Setting to %d.]\n", RF_DEFAULT_LOCK_TABLE_SIZE);
+		printf("[WARNING:  lock table size must be a power of two."
+		    " Setting to %d.]\n", RF_DEFAULT_LOCK_TABLE_SIZE);
 		rf_lockTableSize = RF_DEFAULT_LOCK_TABLE_SIZE;
 	}
 	return (0);
 }
 
 RF_LockTableEntry_t *
-rf_MakeLockTable()
+rf_MakeLockTable(void)
 {
 	RF_LockTableEntry_t *lockTable;
-	int     i, rc;
+	int i, rc;
 
-	RF_Calloc(lockTable, ((int) rf_lockTableSize), sizeof(RF_LockTableEntry_t), (RF_LockTableEntry_t *));
+	RF_Calloc(lockTable, ((int) rf_lockTableSize),
+	    sizeof(RF_LockTableEntry_t), (RF_LockTableEntry_t *));
 	if (lockTable == NULL)
 		return (NULL);
 	for (i = 0; i < rf_lockTableSize; i++) {
 		rc = rf_mutex_init(&lockTable[i].mutex);
 		if (rc) {
-			RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-			    __LINE__, rc);
-			/* XXX clean up other mutexes */
+			RF_ERRORMSG3("Unable to init mutex file %s line %d"
+			    " rc=%d.\n", __FILE__, __LINE__, rc);
+			/* XXX Clean up other mutexes. */
 			return (NULL);
 		}
 	}
 	return (lockTable);
 }
 
-void 
-rf_ShutdownStripeLocks(RF_LockTableEntry_t * lockTable)
+void
+rf_ShutdownStripeLocks(RF_LockTableEntry_t *lockTable)
 {
-	int     i;
+	int i;
 
 	if (rf_stripeLockDebug) {
-		PrintLockedStripes(lockTable);
+		rf_PrintLockedStripes(lockTable);
 	}
 	for (i = 0; i < rf_lockTableSize; i++) {
 		rf_mutex_destroy(&lockTable[i].mutex);
@@ -189,84 +232,91 @@ rf_ShutdownStripeLocks(RF_LockTableEntry_t * lockTable)
 	RF_Free(lockTable, rf_lockTableSize * sizeof(RF_LockTableEntry_t));
 }
 
-static void 
-rf_RaidShutdownStripeLocks(arg)
-	void   *arg;
+void
+rf_RaidShutdownStripeLocks(void *arg)
 {
 	RF_Raid_t *raidPtr = (RF_Raid_t *) arg;
 	rf_ShutdownStripeLocks(raidPtr->lockTable);
 }
 
-int 
-rf_ConfigureStripeLocks(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
+int
+rf_ConfigureStripeLocks(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
+    RF_Config_t *cfgPtr)
 {
-	int     rc;
+	int rc;
 
 	raidPtr->lockTable = rf_MakeLockTable();
 	if (raidPtr->lockTable == NULL)
 		return (ENOMEM);
 	rc = rf_ShutdownCreate(listp, rf_RaidShutdownStripeLocks, raidPtr);
 	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
+		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d"
+		    " rc=%d.\n", __FILE__, __LINE__, rc);
 		rf_ShutdownStripeLocks(raidPtr->lockTable);
 		return (rc);
 	}
 	return (0);
 }
-/* returns 0 if you've got the lock, and non-zero if you have to wait.
- * if and only if you have to wait, we'll cause cbFunc to get invoked
- * with cbArg when you are granted the lock.  We store a tag in *releaseTag
+
+/*
+ * Returns 0 if you've got the lock, and non-zero if you have to wait.
+ * If and only if you have to wait, we'll cause cbFunc to get invoked
+ * with cbArg when you are granted the lock. We store a tag in *releaseTag
  * that you need to give back to us when you release the lock.
  */
-int 
-rf_AcquireStripeLock(
-    RF_LockTableEntry_t * lockTable,
-    RF_StripeNum_t stripeID,
-    RF_LockReqDesc_t * lockReqDesc)
+int
+rf_AcquireStripeLock(RF_LockTableEntry_t *lockTable, RF_StripeNum_t stripeID,
+    RF_LockReqDesc_t *lockReqDesc)
 {
 	RF_StripeLockDesc_t *lockDesc;
 	RF_LockReqDesc_t *p;
-	int     tid = 0, hashval = HASH_STRIPEID(stripeID);
-	int     retcode = 0;
+	int tid = 0, hashval = HASH_STRIPEID(stripeID);
+	int retcode = 0;
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(lockReqDesc->type));
 
 	if (rf_stripeLockDebug) {
 		if (stripeID == -1)
-			Dprintf1("[%d] Lock acquisition supressed (stripeID == -1)\n", tid);
+			Dprintf1("[%d] Lock acquisition supressed"
+			    " (stripeID == -1).\n", tid);
 		else {
-			Dprintf8("[%d] Trying to acquire stripe lock table 0x%lx SID %ld type %c range %ld-%ld, range2 %ld-%ld hashval %d\n",
-			    tid, (unsigned long) lockTable, stripeID, lockReqDesc->type, lockReqDesc->start,
-			    lockReqDesc->stop, lockReqDesc->start2, lockReqDesc->stop2);
-			Dprintf3("[%d] lock %ld hashval %d\n", tid, stripeID, hashval);
+			Dprintf8("[%d] Trying to acquire stripe lock table"
+			    " 0x%lx SID %ld type %c range %ld-%ld, range2"
+			    " %ld-%ld hashval %d.\n", tid,
+			    (unsigned long) lockTable, stripeID,
+			    lockReqDesc->type, lockReqDesc->start,
+			    lockReqDesc->stop, lockReqDesc->start2,
+			    lockReqDesc->stop2);
+			Dprintf3("[%d] lock %ld hashval %d.\n", tid, stripeID,
+			    hashval);
 			FLUSH;
 		}
 	}
 	if (stripeID == -1)
 		return (0);
-	lockReqDesc->next = NULL;	/* just to be sure */
+	lockReqDesc->next = NULL;	/* Just to be sure. */
 
 	RF_LOCK_MUTEX(lockTable[hashval].mutex);
-	for (lockDesc = lockTable[hashval].descList; lockDesc; lockDesc = lockDesc->next) {
+	for (lockDesc = lockTable[hashval].descList; lockDesc;
+	     lockDesc = lockDesc->next) {
 		if (lockDesc->stripeID == stripeID)
 			break;
 	}
 
-	if (!lockDesc) {	/* no entry in table => no one reading or
-				 * writing */
-		lockDesc = AllocStripeLockDesc(stripeID);
+	if (!lockDesc) {
+		/* No entry in table => no one reading or writing. */
+		lockDesc = rf_AllocStripeLockDesc(stripeID);
 		lockDesc->next = lockTable[hashval].descList;
 		lockTable[hashval].descList = lockDesc;
 		if (lockReqDesc->type == RF_IO_TYPE_WRITE)
 			lockDesc->nWriters++;
 		lockDesc->granted = lockReqDesc;
 		if (rf_stripeLockDebug) {
-			Dprintf7("[%d] no one waiting: lock %ld %c %ld-%ld %ld-%ld granted\n",
-			    tid, stripeID, lockReqDesc->type, lockReqDesc->start, lockReqDesc->stop, lockReqDesc->start2, lockReqDesc->stop2);
+			Dprintf7("[%d] no one waiting: lock %ld %c %ld-%ld"
+			    " %ld-%ld granted.\n", tid, stripeID,
+			    lockReqDesc->type,
+			    lockReqDesc->start, lockReqDesc->stop,
+			    lockReqDesc->start2, lockReqDesc->stop2);
 			FLUSH;
 		}
 	} else {
@@ -274,20 +324,26 @@ rf_AcquireStripeLock(
 		if (lockReqDesc->type == RF_IO_TYPE_WRITE)
 			lockDesc->nWriters++;
 
-		if (lockDesc->nWriters == 0) {	/* no need to search any lists
-						 * if there are no writers
-						 * anywhere */
+		if (lockDesc->nWriters == 0) {
+			/*
+			 * No need to search any lists if there are no writers
+			 * anywhere.
+			 */
 			lockReqDesc->next = lockDesc->granted;
 			lockDesc->granted = lockReqDesc;
 			if (rf_stripeLockDebug) {
-				Dprintf7("[%d] no writers: lock %ld %c %ld-%ld %ld-%ld granted\n",
-				    tid, stripeID, lockReqDesc->type, lockReqDesc->start, lockReqDesc->stop, lockReqDesc->start2, lockReqDesc->stop2);
+				Dprintf7("[%d] no writers: lock %ld %c %ld-%ld"
+				    " %ld-%ld granted.\n", tid,
+				    stripeID, lockReqDesc->type,
+				    lockReqDesc->start, lockReqDesc->stop,
+				    lockReqDesc->start2, lockReqDesc->stop2);
 				FLUSH;
 			}
 		} else {
-
-			/* search the granted & waiting lists for a conflict.
-			 * stop searching as soon as we find one */
+			/*
+			 * Search the granted & waiting lists for a conflict.
+			 * Stop searching as soon as we find one.
+			 */
 			retcode = 0;
 			for (p = lockDesc->granted; p; p = p->next)
 				if (STRIPELOCK_CONFLICT(lockReqDesc, p)) {
@@ -296,31 +352,41 @@ rf_AcquireStripeLock(
 				}
 			if (!retcode)
 				for (p = lockDesc->waitersH; p; p = p->next)
-					if (STRIPELOCK_CONFLICT(lockReqDesc, p)) {
+					if (STRIPELOCK_CONFLICT(lockReqDesc, p))
+					{
 						retcode = 2;
 						break;
 					}
 			if (!retcode) {
-				lockReqDesc->next = lockDesc->granted;	/* no conflicts found =>
-									 * grant lock */
+				/* No conflicts found => grant lock */
+				lockReqDesc->next = lockDesc->granted;
 				lockDesc->granted = lockReqDesc;
 				if (rf_stripeLockDebug) {
-					Dprintf7("[%d] no conflicts: lock %ld %c %ld-%ld %ld-%ld granted\n",
-					    tid, stripeID, lockReqDesc->type, lockReqDesc->start, lockReqDesc->stop,
-					    lockReqDesc->start2, lockReqDesc->stop2);
+					Dprintf7("[%d] no conflicts: lock %ld"
+					    " %c %ld-%ld %ld-%ld granted.\n",
+					    tid, stripeID, lockReqDesc->type,
+					    lockReqDesc->start,
+					    lockReqDesc->stop,
+					    lockReqDesc->start2,
+					    lockReqDesc->stop2);
 					FLUSH;
 				}
 			} else {
 				if (rf_stripeLockDebug) {
-					Dprintf6("[%d] conflict: lock %ld %c %ld-%ld hashval=%d not granted\n",
-					    tid, stripeID, lockReqDesc->type, lockReqDesc->start, lockReqDesc->stop,
+					Dprintf6("[%d] conflict: lock %ld %c"
+					    " %ld-%ld hashval=%d not"
+					    " granted.\n", tid, stripeID,
+					    lockReqDesc->type,
+					    lockReqDesc->start,
+					    lockReqDesc->stop,
 					    hashval);
-					Dprintf3("[%d] lock %ld retcode=%d\n", tid, stripeID, retcode);
+					Dprintf3("[%d] lock %ld retcode=%d.\n",
+					    tid, stripeID, retcode);
 					FLUSH;
 				}
-				AddToWaitersQueue(lockTable, lockDesc, lockReqDesc);	/* conflict => the
-											 * current access must
-											 * wait */
+				/* Conflict => the current access must wait. */
+				rf_AddToWaitersQueue(lockTable, lockDesc,
+				    lockReqDesc);
 			}
 		}
 	}
@@ -329,27 +395,30 @@ rf_AcquireStripeLock(
 	return (retcode);
 }
 
-void 
-rf_ReleaseStripeLock(
-    RF_LockTableEntry_t * lockTable,
-    RF_StripeNum_t stripeID,
-    RF_LockReqDesc_t * lockReqDesc)
+void
+rf_ReleaseStripeLock(RF_LockTableEntry_t *lockTable, RF_StripeNum_t stripeID,
+    RF_LockReqDesc_t *lockReqDesc)
 {
 	RF_StripeLockDesc_t *lockDesc, *ld_t;
 	RF_LockReqDesc_t *lr, *lr_t, *callbacklist, *t;
 	RF_IoType_t type = lockReqDesc->type;
-	int     tid = 0, hashval = HASH_STRIPEID(stripeID);
-	int     release_it, consider_it;
+	int tid = 0, hashval = HASH_STRIPEID(stripeID);
+	int release_it, consider_it;
 	RF_LockReqDesc_t *candidate, *candidate_t, *predecessor;
 
 	RF_ASSERT(RF_IO_IS_R_OR_W(type));
 
 	if (rf_stripeLockDebug) {
 		if (stripeID == -1)
-			Dprintf1("[%d] Lock release supressed (stripeID == -1)\n", tid);
+			Dprintf1("[%d] Lock release supressed"
+			    " (stripeID == -1).\n", tid);
 		else {
-			Dprintf8("[%d] Releasing stripe lock on stripe ID %ld, type %c range %ld-%ld %ld-%ld table 0x%lx\n",
-			    tid, stripeID, lockReqDesc->type, lockReqDesc->start, lockReqDesc->stop, lockReqDesc->start2, lockReqDesc->stop2, lockTable);
+			Dprintf8("[%d] Releasing stripe lock on stripe ID %ld,"
+			    " type %c range %ld-%ld %ld-%ld table 0x%lx.\n",
+			    tid, stripeID, lockReqDesc->type,
+			    lockReqDesc->start, lockReqDesc->stop,
+			    lockReqDesc->start2, lockReqDesc->stop2,
+			    lockTable);
 			FLUSH;
 		}
 	}
@@ -358,22 +427,27 @@ rf_ReleaseStripeLock(
 
 	RF_LOCK_MUTEX(lockTable[hashval].mutex);
 
-	/* find the stripe lock descriptor */
-	for (ld_t = NULL, lockDesc = lockTable[hashval].descList; lockDesc; ld_t = lockDesc, lockDesc = lockDesc->next) {
+	/* Find the stripe lock descriptor. */
+	for (ld_t = NULL, lockDesc = lockTable[hashval].descList;
+	     lockDesc; ld_t = lockDesc, lockDesc = lockDesc->next) {
 		if (lockDesc->stripeID == stripeID)
 			break;
 	}
-	RF_ASSERT(lockDesc);	/* major error to release a lock that doesn't
-				 * exist */
+	RF_ASSERT(lockDesc);	/*
+				 * Major error to release a lock that doesn't
+				 * exist.
+				 */
 
-	/* find the stripe lock request descriptor & delete it from the list */
+	/* Find the stripe lock request descriptor & delete it from the list. */
 	for (lr_t = NULL, lr = lockDesc->granted; lr; lr_t = lr, lr = lr->next)
 		if (lr == lockReqDesc)
 			break;
 
-	RF_ASSERT(lr && (lr == lockReqDesc));	/* major error to release a
+	RF_ASSERT(lr && (lr == lockReqDesc));	/*
+						 * Major error to release a
 						 * lock that hasn't been
-						 * granted */
+						 * granted.
+						 */
 	if (lr_t)
 		lr_t->next = lr->next;
 	else {
@@ -385,56 +459,73 @@ rf_ReleaseStripeLock(
 	if (lockReqDesc->type == RF_IO_TYPE_WRITE)
 		lockDesc->nWriters--;
 
-	/* search through the waiters list to see if anyone needs to be woken
-	 * up. for each such descriptor in the wait list, we check it against
+	/*
+	 * Search through the waiters list to see if anyone needs to be woken
+	 * up. For each such descriptor in the wait list, we check it against
 	 * everything granted and against everything _in front_ of it in the
-	 * waiters queue.  If it conflicts with none of these, we release it.
-	 * 
-	 * DON'T TOUCH THE TEMPLINK POINTER OF ANYTHING IN THE GRANTED LIST HERE.
+	 * waiters queue. If it conflicts with none of these, we release it.
+	 *
+	 * DON'T TOUCH THE TEMPLINK POINTER OF ANYTHING IN THE GRANTED LIST
+	 * HERE.
 	 * This will roach the case where the callback tries to acquire a new
-	 * lock in the same stripe.  There are some asserts to try and detect
+	 * lock in the same stripe. There are some asserts to try and detect
 	 * this.
-	 * 
-	 * We apply 2 performance optimizations: (1) if releasing this lock
-	 * results in no more writers to this stripe, we just release
-	 * everybody waiting, since we place no restrictions on the number of
-	 * concurrent reads. (2) we consider as candidates for wakeup only
-	 * those waiters that have a range overlap with either the descriptor
-	 * being woken up or with something in the callbacklist (i.e.
-	 * something we've just now woken up). This allows us to avoid the
-	 * long evaluation for some descriptors. */
+	 *
+	 * We apply 2 performance optimizations:
+	 * (1) If releasing this lock results in no more writers to this
+	 *     stripe, we just release everybody waiting, since we place no
+	 *     restrictions on the number of concurrent reads.
+	 * (2) We consider as candidates for wakeup only those waiters that
+	 *     have a range overlap with either the descriptor being woken up
+	 *     or with something in the callbacklist (i.e. something we've
+	 *     just now woken up).
+	 * This allows us to avoid the long evaluation for some descriptors.
+	 */
 
 	callbacklist = NULL;
-	if (lockDesc->nWriters == 0) {	/* performance tweak (1) */
+	if (lockDesc->nWriters == 0) {	/* Performance tweak (1). */
 		while (lockDesc->waitersH) {
 
-			lr = lockDesc->waitersH;	/* delete from waiters
-							 * list */
+			lr = lockDesc->waitersH;	/*
+							 * Delete from waiters
+							 * list.
+							 */
 			lockDesc->waitersH = lr->next;
 
 			RF_ASSERT(lr->type == RF_IO_TYPE_READ);
 
-			lr->next = lockDesc->granted;	/* add to granted list */
+			lr->next = lockDesc->granted;	/*
+							 * Add to granted list.
+							 */
 			lockDesc->granted = lr;
 
 			RF_ASSERT(!lr->templink);
-			lr->templink = callbacklist;	/* put on callback list
+			lr->templink = callbacklist;	/*
+							 * Put on callback list
 							 * so that we'll invoke
-							 * callback below */
+							 * callback below.
+							 */
 			callbacklist = lr;
 			if (rf_stripeLockDebug) {
-				Dprintf8("[%d] No writers: granting lock stripe ID %ld, type %c range %ld-%ld %ld-%ld table 0x%lx\n",
-				    tid, stripeID, lr->type, lr->start, lr->stop, lr->start2, lr->stop2, (unsigned long) lockTable);
+				Dprintf8("[%d] No writers: granting lock"
+				    " stripe ID %ld, type %c range %ld-%l"
+				    "d %ld-%ld table 0x%lx.\n", tid, stripeID,
+				    lr->type, lr->start, lr->stop,
+				    lr->start2, lr->stop2,
+				    (unsigned long) lockTable);
 				FLUSH;
 			}
 		}
-		lockDesc->waitersT = NULL;	/* we've purged the whole
-						 * waiters list */
+		lockDesc->waitersT = NULL;	/*
+						 * We've purged the whole
+						 * waiters list.
+						 */
 
 	} else
-		for (candidate_t = NULL, candidate = lockDesc->waitersH; candidate;) {
+		for (candidate_t = NULL, candidate = lockDesc->waitersH;
+		     candidate;) {
 
-			/* performance tweak (2) */
+			/* Performance tweak (2). */
 			consider_it = 0;
 			if (RANGE_OVERLAP(lockReqDesc, candidate))
 				consider_it = 1;
@@ -446,8 +537,13 @@ rf_ReleaseStripeLock(
 					}
 			if (!consider_it) {
 				if (rf_stripeLockDebug) {
-					Dprintf8("[%d] No overlap: rejecting candidate stripeID %ld, type %c range %ld-%ld %ld-%ld table 0x%lx\n",
-					    tid, stripeID, candidate->type, candidate->start, candidate->stop, candidate->start2, candidate->stop2,
+					Dprintf8("[%d] No overlap: rejecting"
+					    " candidate stripeID %ld, type %c"
+					    " range %ld-%ld %ld-%ld table"
+					    " 0x%lx.\n", tid, stripeID,
+					    candidate->type,
+					    candidate->start, candidate->stop,
+					    candidate->start2, candidate->stop2,
 					    (unsigned long) lockTable);
 					FLUSH;
 				}
@@ -455,14 +551,27 @@ rf_ReleaseStripeLock(
 				candidate = candidate->next;
 				continue;
 			}
-			/* we have a candidate for release.  check to make
-			 * sure it is not blocked by any granted locks */
+			/*
+			 * We have a candidate for release. Check to make
+			 * sure it is not blocked by any granted locks.
+			 */
 			release_it = 1;
-			for (predecessor = lockDesc->granted; predecessor; predecessor = predecessor->next) {
-				if (STRIPELOCK_CONFLICT(candidate, predecessor)) {
+			for (predecessor = lockDesc->granted; predecessor;
+			     predecessor = predecessor->next) {
+				if (STRIPELOCK_CONFLICT(candidate, predecessor))
+				{
 					if (rf_stripeLockDebug) {
-						Dprintf8("[%d] Conflicts with granted lock: rejecting candidate stripeID %ld, type %c range %ld-%ld %ld-%ld table 0x%lx\n",
-						    tid, stripeID, candidate->type, candidate->start, candidate->stop, candidate->start2, candidate->stop2,
+						Dprintf8("[%d] Conflicts with"
+						    " granted lock: rejecting"
+						    " candidate stripeID %ld,"
+						    " type %c range %ld-%ld"
+						    " %ld-%ld table 0x%lx.\n",
+						    tid, stripeID,
+						    candidate->type,
+						    candidate->start,
+						    candidate->stop,
+						    candidate->start2,
+						    candidate->stop2,
 						    (unsigned long) lockTable);
 						FLUSH;
 					}
@@ -471,15 +580,35 @@ rf_ReleaseStripeLock(
 				}
 			}
 
-			/* now check to see if the candidate is blocked by any
-			 * waiters that occur before it it the wait queue */
+			/*
+			 * Now check to see if the candidate is blocked by any
+			 * waiters that occur before it in the wait queue.
+			 */
 			if (release_it)
-				for (predecessor = lockDesc->waitersH; predecessor != candidate; predecessor = predecessor->next) {
-					if (STRIPELOCK_CONFLICT(candidate, predecessor)) {
+				for (predecessor = lockDesc->waitersH;
+				     predecessor != candidate;
+				     predecessor = predecessor->next) {
+					if (STRIPELOCK_CONFLICT(candidate,
+					    predecessor)) {
 						if (rf_stripeLockDebug) {
-							Dprintf8("[%d] Conflicts with waiting lock: rejecting candidate stripeID %ld, type %c range %ld-%ld %ld-%ld table 0x%lx\n",
-							    tid, stripeID, candidate->type, candidate->start, candidate->stop, candidate->start2, candidate->stop2,
-							    (unsigned long) lockTable);
+							Dprintf8("[%d]"
+							    " Conflicts with"
+							    " waiting lock:"
+							    " rejecting"
+							    " candidate"
+							    " stripeID %ld,"
+							    " type %c"
+							    " range %ld-%ld"
+							    " %ld-%ld"
+							    " table 0x%lx.\n",
+							    tid, stripeID,
+							    candidate->type,
+							    candidate->start,
+							    candidate->stop,
+							    candidate->start2,
+							    candidate->stop2,
+							    (unsigned long)
+							     lockTable);
 							FLUSH;
 						}
 						release_it = 0;
@@ -487,54 +616,70 @@ rf_ReleaseStripeLock(
 					}
 				}
 
-			/* release it if indicated */
+			/* Release it if indicated. */
 			if (release_it) {
 				if (rf_stripeLockDebug) {
-					Dprintf8("[%d] Granting lock to candidate stripeID %ld, type %c range %ld-%ld %ld-%ld table 0x%lx\n",
-					    tid, stripeID, candidate->type, candidate->start, candidate->stop, candidate->start2, candidate->stop2,
+					Dprintf8("[%d] Granting lock to"
+					    " candidate stripeID %ld, type %c"
+					    " range %ld-%ld %ld-%ld table"
+					    " 0x%lx.\n", tid, stripeID,
+					    candidate->type,
+					    candidate->start, candidate->stop,
+					    candidate->start2, candidate->stop2,
 					    (unsigned long) lockTable);
 					FLUSH;
 				}
 				if (candidate_t) {
 					candidate_t->next = candidate->next;
 					if (lockDesc->waitersT == candidate)
-						lockDesc->waitersT = candidate_t;	/* cannot be waitersH
-											 * since candidate_t is
-											 * not NULL */
+						/*
+						 * Cannot be waitersH
+						 * since candidate_t is
+						 * not NULL.
+						 */
+						lockDesc->waitersT =
+						    candidate_t;
 				} else {
-					RF_ASSERT(candidate == lockDesc->waitersH);
-					lockDesc->waitersH = lockDesc->waitersH->next;
+					RF_ASSERT(candidate ==
+					    lockDesc->waitersH);
+					lockDesc->waitersH =
+					    lockDesc->waitersH->next;
 					if (!lockDesc->waitersH)
 						lockDesc->waitersT = NULL;
 				}
-				candidate->next = lockDesc->granted;	/* move it to the
-									 * granted list */
+				/* Move it to the granted list. */
+				candidate->next = lockDesc->granted;
 				lockDesc->granted = candidate;
 
 				RF_ASSERT(!candidate->templink);
-				candidate->templink = callbacklist;	/* put it on the list of
-									 * things to be called
-									 * after we release the
-									 * mutex */
+				/*
+				 * Put it on the list of things to be called
+				 * after we release the mutex.
+				 */
+				candidate->templink = callbacklist;
 				callbacklist = candidate;
 
 				if (!candidate_t)
 					candidate = lockDesc->waitersH;
 				else
-					candidate = candidate_t->next;	/* continue with the
-									 * rest of the list */
+					/*
+					 * Continue with the rest of the list.
+					 */
+					candidate = candidate_t->next;
 			} else {
 				candidate_t = candidate;
-				candidate = candidate->next;	/* continue with the
-								 * rest of the list */
+				/* Continue with the rest of the list. */
+				candidate = candidate->next;
 			}
 		}
 
-	/* delete the descriptor if no one is waiting or active */
+	/* Delete the descriptor if no one is waiting or active. */
 	if (!lockDesc->granted && !lockDesc->waitersH) {
 		RF_ASSERT(lockDesc->nWriters == 0);
 		if (rf_stripeLockDebug) {
-			Dprintf3("[%d] Last lock released (table 0x%lx): deleting desc for stripeID %ld\n", tid, (unsigned long) lockTable, stripeID);
+			Dprintf3("[%d] Last lock released (table 0x%lx):"
+			    " deleting desc for stripeID %ld.\n", tid,
+			    (unsigned long) lockTable, stripeID);
 			FLUSH;
 		}
 		if (ld_t)
@@ -543,17 +688,21 @@ rf_ReleaseStripeLock(
 			RF_ASSERT(lockDesc == lockTable[hashval].descList);
 			lockTable[hashval].descList = lockDesc->next;
 		}
-		FreeStripeLockDesc(lockDesc);
-		lockDesc = NULL;/* only for the ASSERT below */
+		rf_FreeStripeLockDesc(lockDesc);
+		lockDesc = NULL;	/* Only for the ASSERT below. */
 	}
 	RF_UNLOCK_MUTEX(lockTable[hashval].mutex);
 
-	/* now that we've unlocked the mutex, invoke the callback on all the
-	 * descriptors in the list */
-	RF_ASSERT(!((callbacklist) && (!lockDesc)));	/* if we deleted the
+	/*
+	 * Now that we've unlocked the mutex, invoke the callback on all the
+	 * descriptors in the list.
+	 */
+	RF_ASSERT(!((callbacklist) && (!lockDesc)));	/*
+							 * If we deleted the
 							 * descriptor, we should
 							 * have no callbacks to
-							 * do */
+							 * do.
+							 */
 	for (candidate = callbacklist; candidate;) {
 		t = candidate;
 		candidate = candidate->templink;
@@ -561,17 +710,17 @@ rf_ReleaseStripeLock(
 		(t->cbFunc) (t->cbArg);
 	}
 }
-/* must have the indicated lock table mutex upon entry */
-static void 
-AddToWaitersQueue(
-    RF_LockTableEntry_t * lockTable,
-    RF_StripeLockDesc_t * lockDesc,
-    RF_LockReqDesc_t * lockReqDesc)
+
+/* Must have the indicated lock table mutex upon entry. */
+void
+rf_AddToWaitersQueue(RF_LockTableEntry_t *lockTable,
+    RF_StripeLockDesc_t *lockDesc, RF_LockReqDesc_t *lockReqDesc)
 {
-	int     tid;
+	int tid;
 
 	if (rf_stripeLockDebug) {
-		Dprintf3("[%d] Waiting on lock for stripe %ld table 0x%lx\n", tid, lockDesc->stripeID, (unsigned long) lockTable);
+		Dprintf3("[%d] Waiting on lock for stripe %ld table 0x%lx.\n",
+		    tid, lockDesc->stripeID, (unsigned long) lockTable);
 		FLUSH;
 	}
 	if (!lockDesc->waitersH) {
@@ -582,29 +731,29 @@ AddToWaitersQueue(
 	}
 }
 
-static RF_StripeLockDesc_t *
-AllocStripeLockDesc(RF_StripeNum_t stripeID)
+RF_StripeLockDesc_t *
+rf_AllocStripeLockDesc(RF_StripeNum_t stripeID)
 {
 	RF_StripeLockDesc_t *p;
 
-	RF_FREELIST_GET(rf_stripelock_freelist, p, next, (RF_StripeLockDesc_t *));
+	RF_FREELIST_GET(rf_stripelock_freelist, p, next,
+	    (RF_StripeLockDesc_t *));
 	if (p) {
 		p->stripeID = stripeID;
 	}
 	return (p);
 }
 
-static void 
-FreeStripeLockDesc(RF_StripeLockDesc_t * p)
+void
+rf_FreeStripeLockDesc(RF_StripeLockDesc_t *p)
 {
 	RF_FREELIST_FREE(rf_stripelock_freelist, p, next);
 }
 
-static void 
-PrintLockedStripes(lockTable)
-	RF_LockTableEntry_t *lockTable;
+void
+rf_PrintLockedStripes(RF_LockTableEntry_t *lockTable)
 {
-	int     i, j, foundone = 0, did;
+	int i, j, foundone = 0, did;
 	RF_StripeLockDesc_t *p;
 	RF_LockReqDesc_t *q;
 
@@ -615,16 +764,20 @@ PrintLockedStripes(lockTable)
 			foundone = 1;
 			for (p = lockTable[i].descList; p; p = p->next) {
 				printf("Stripe ID 0x%lx (%d) nWriters %d\n",
-				    (long) p->stripeID, (int) p->stripeID, p->nWriters);
+				    (long) p->stripeID, (int) p->stripeID,
+				    p->nWriters);
 
 				if (!(p->granted))
 					printf("Granted: (none)\n");
 				else
 					printf("Granted:\n");
-				for (did = 1, j = 0, q = p->granted; q; j++, q = q->next) {
-					printf("  %c(%ld-%ld", q->type, (long) q->start, (long) q->stop);
+				for (did = 1, j = 0, q = p->granted; q;
+				     j++, q = q->next) {
+					printf("  %c(%ld-%ld", q->type,
+					    (long) q->start, (long) q->stop);
 					if (q->start2 != -1)
-						printf(",%ld-%ld) ", (long) q->start2,
+						printf(",%ld-%ld) ",
+						    (long) q->start2,
 						    (long) q->stop2);
 					else
 						printf(") ");
@@ -641,10 +794,14 @@ PrintLockedStripes(lockTable)
 					printf("Waiting: (none)\n");
 				else
 					printf("Waiting:\n");
-				for (did = 1, j = 0, q = p->waitersH; q; j++, q = q->next) {
-					printf("%c(%ld-%ld", q->type, (long) q->start, (long) q->stop);
+				for (did = 1, j = 0, q = p->waitersH; q;
+				     j++, q = q->next) {
+					printf("%c(%ld-%ld", q->type,
+					    (long) q->start, (long) q->stop);
 					if (q->start2 != -1)
-						printf(",%ld-%ld) ", (long) q->start2, (long) q->stop2);
+						printf(",%ld-%ld) ",
+						    (long) q->start2,
+						    (long) q->stop2);
 					else
 						printf(") ");
 					if (j && !(j % 4)) {
diff --git a/sys/dev/raidframe/rf_stripelocks.h b/sys/dev/raidframe/rf_stripelocks.h
index d339e2ae520..2c7a596a213 100644
--- a/sys/dev/raidframe/rf_stripelocks.h
+++ b/sys/dev/raidframe/rf_stripelocks.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_stripelocks.h,v 1.2 1999/02/16 00:03:29 niklas Exp $	*/
+/*	$OpenBSD: rf_stripelocks.h,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_stripelocks.h,v 1.3 1999/02/05 00:06:18 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -29,21 +30,21 @@
 
 /*****************************************************************************
  *
- * stripelocks.h -- header file for locking stripes
+ * stripelocks.h -- Header file for locking stripes.
  *
  * Note that these functions are called from the execution routines of certain
  * DAG Nodes, and so they must be NON-BLOCKING to assure maximum parallelism
- * in the DAG.  Accordingly, when a node wants to acquire a lock, it calls
- * AcquireStripeLock, supplying a pointer to a callback function.  If the lock
+ * in the DAG. Accordingly, when a node wants to acquire a lock, it calls
+ * AcquireStripeLock, supplying a pointer to a callback function. If the lock
  * is free at the time of the call, 0 is returned, indicating that the lock
- * has been acquired.  If the lock is not free, 1 is returned, and a copy of
- * the function pointer and argument are held in the lock table.  When the
+ * has been acquired. If the lock is not free, 1 is returned, and a copy of
+ * the function pointer and argument are held in the lock table. When the
  * lock becomes free, the callback function is invoked.
  *
  *****************************************************************************/
 
-#ifndef _RF__RF_STRIPELOCKS_H_
-#define _RF__RF_STRIPELOCKS_H_
+#ifndef	_RF__RF_STRIPELOCKS_H_
+#define	_RF__RF_STRIPELOCKS_H_
 
 #include <sys/buf.h>
 
@@ -52,70 +53,98 @@
 #include "rf_general.h"
 
 struct RF_LockReqDesc_s {
-	RF_IoType_t type;	/* read or write */
-	RF_int64 start, stop;	/* start and end of range to be locked */
-	RF_int64 start2, stop2;	/* start and end of 2nd range to be locked */
-	void    (*cbFunc) (struct buf *);	/* callback function */
-	void   *cbArg;		/* argument to callback function */
-	RF_LockReqDesc_t *next;	/* next element in chain */
-	RF_LockReqDesc_t *templink;	/* for making short-lived lists of
-					 * request descriptors */
+	RF_IoType_t		  type;		/* Read or write. */
+	RF_int64		  start, stop;	/*
+						 * Start and end of range to
+						 * be locked.
+						 */
+	RF_int64		  start2, stop2;/*
+						 * Start and end of 2nd range
+						 * to be locked.
+						 */
+	void			(*cbFunc) (struct buf *);
+						/* Callback function. */
+	void			 *cbArg;	/*
+						 * Argument to callback
+						 * function.
+						 */
+	RF_LockReqDesc_t	 *next;		/* Next element in chain. */
+	RF_LockReqDesc_t	 *templink;	/*
+						 * For making short-lived lists
+						 * of request descriptors.
+						 */
 };
-#define RF_ASSERT_VALID_LOCKREQ(_lr_) { \
-	RF_ASSERT(RF_IO_IS_R_OR_W((_lr_)->type)); \
-}
+
+#define	RF_ASSERT_VALID_LOCKREQ(_lr_)	do {				\
+	RF_ASSERT(RF_IO_IS_R_OR_W((_lr_)->type));			\
+} while (0)
 
 struct RF_StripeLockDesc_s {
-	RF_StripeNum_t stripeID;/* the stripe ID */
-	RF_LockReqDesc_t *granted;	/* unordered list of granted requests */
-	RF_LockReqDesc_t *waitersH;	/* FIFO queue of all waiting reqs,
-					 * both read and write (Head and Tail) */
-	RF_LockReqDesc_t *waitersT;
-	int     nWriters;	/* number of writers either granted or waiting */
-	RF_StripeLockDesc_t *next;	/* for hash table collision resolution */
+	RF_StripeNum_t		 stripeID;	/* The stripe ID. */
+	RF_LockReqDesc_t	*granted;	/*
+						 * Unordered list of granted
+						 * requests.
+						 */
+	RF_LockReqDesc_t	*waitersH;	/* FIFO queue of all waiting
+						 * reqs, both read and write
+						 * (Head and Tail).
+						 */
+	RF_LockReqDesc_t	*waitersT;
+	int			 nWriters;	/*
+						 * Number of writers either
+						 * granted or waiting.
+						 */
+	RF_StripeLockDesc_t	*next;		/*
+						 * For hash table collision
+						 * resolution.
+						 */
 };
 
 struct RF_LockTableEntry_s {
-	RF_DECLARE_MUTEX(mutex)	/* mutex on this hash chain */
-	RF_StripeLockDesc_t *descList;	/* hash chain of lock descriptors */
+	RF_DECLARE_MUTEX	(mutex);	/* Mutex on this hash chain. */
+	RF_StripeLockDesc_t	*descList;	/*
+						 * Hash chain of lock
+						 * descriptors.
+						 */
 };
+
 /*
- * Initializes a stripe lock descriptor.  _defSize is the number of sectors
+ * Initializes a stripe lock descriptor. _defSize is the number of sectors
  * that we lock when there is no parity information in the ASM (e.g. RAID0).
  */
 
-#define RF_INIT_LOCK_REQ_DESC(_lrd, _typ, _cbf, _cba, _asm, _defSize)                                           \
-  {                                                                                                          \
-    (_lrd).type    = _typ;                                                                                   \
-    (_lrd).start2  = -1;                                                                                     \
-    (_lrd).stop2   = -1;                                                                                     \
-    if ((_asm)->parityInfo) {                                                                                \
-      (_lrd).start = (_asm)->parityInfo->startSector;                                                        \
-      (_lrd).stop  = (_asm)->parityInfo->startSector + (_asm)->parityInfo->numSector-1;                      \
-      if ((_asm)->parityInfo->next) {                                                                        \
-        (_lrd).start2  = (_asm)->parityInfo->next->startSector;                                              \
-        (_lrd).stop2   = (_asm)->parityInfo->next->startSector + (_asm)->parityInfo->next->numSector-1;      \
-      }                                                                                                      \
-    } else {                                                                                                 \
-      (_lrd).start = 0;                                                                                      \
-      (_lrd).stop  = (_defSize);                                                                             \
-    }													     \
-    (_lrd).templink= NULL;                                                                                   \
-    (_lrd).cbFunc  = (_cbf);                                                                                 \
-    (_lrd).cbArg   = (void *) (_cba);                                                                        \
-  }
+#define RF_INIT_LOCK_REQ_DESC(_lrd, _typ, _cbf, _cba, _asm, _defSize)	\
+do {									\
+	(_lrd).type    = _typ;						\
+	(_lrd).start2  = -1;						\
+	(_lrd).stop2   = -1;						\
+	if ((_asm)->parityInfo) {					\
+		(_lrd).start = (_asm)->parityInfo->startSector;		\
+		(_lrd).stop  = (_asm)->parityInfo->startSector +	\
+		    (_asm)->parityInfo->numSector-1;			\
+		if ((_asm)->parityInfo->next) {				\
+			(_lrd).start2  =				\
+			    (_asm)->parityInfo->next->startSector;	\
+			(_lrd).stop2   =				\
+			    (_asm)->parityInfo->next->startSector +	\
+			    (_asm)->parityInfo->next->numSector-1;	\
+		}							\
+	} else {							\
+		(_lrd).start = 0;					\
+		(_lrd).stop  = (_defSize);				\
+	}								\
+	(_lrd).templink= NULL;						\
+	(_lrd).cbFunc  = (_cbf);					\
+	(_lrd).cbArg   = (void *) (_cba);				\
+} while (0)
 
-int     rf_ConfigureStripeLockFreeList(RF_ShutdownList_t ** listp);
+int  rf_ConfigureStripeLockFreeList(RF_ShutdownList_t **);
 RF_LockTableEntry_t *rf_MakeLockTable(void);
-void    rf_ShutdownStripeLocks(RF_LockTableEntry_t * lockTable);
-int 
-rf_ConfigureStripeLocks(RF_ShutdownList_t ** listp, RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr);
-int 
-rf_AcquireStripeLock(RF_LockTableEntry_t * lockTable,
-    RF_StripeNum_t stripeID, RF_LockReqDesc_t * lockReqDesc);
-void 
-rf_ReleaseStripeLock(RF_LockTableEntry_t * lockTable,
-    RF_StripeNum_t stripeID, RF_LockReqDesc_t * lockReqDesc);
+void rf_ShutdownStripeLocks(RF_LockTableEntry_t *);
+int  rf_ConfigureStripeLocks(RF_ShutdownList_t **, RF_Raid_t *, RF_Config_t *);
+int  rf_AcquireStripeLock(RF_LockTableEntry_t *, RF_StripeNum_t,
+	RF_LockReqDesc_t *);
+void rf_ReleaseStripeLock(RF_LockTableEntry_t *, RF_StripeNum_t,
+	RF_LockReqDesc_t *);
 
-#endif				/* !_RF__RF_STRIPELOCKS_H_ */
+#endif	/* !_RF__RF_STRIPELOCKS_H_ */
diff --git a/sys/dev/raidframe/rf_strutils.c b/sys/dev/raidframe/rf_strutils.c
index c55e98a77bb..b551dac2f5d 100644
--- a/sys/dev/raidframe/rf_strutils.c
+++ b/sys/dev/raidframe/rf_strutils.c
@@ -1,9 +1,10 @@
-/*	$OpenBSD: rf_strutils.c,v 1.2 1999/02/16 00:03:29 niklas Exp $	*/
+/*	$OpenBSD: rf_strutils.c,v 1.3 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_strutils.c,v 1.3 1999/02/05 00:06:18 oster Exp $	*/
+
 /*
  * rf_strutils.c
  *
- * String-parsing funcs
+ * String-parsing funcs.
  */
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
@@ -40,15 +41,16 @@
 
 #include "rf_utils.h"
 
-/* finds a non-white character in the line */
-char   *
+/* Finds a non-white character in the line. */
+char *
 rf_find_non_white(char *p)
 {
 	for (; *p != '\0' && (*p == ' ' || *p == '\t'); p++);
 	return (p);
 }
-/* finds a white character in the line */
-char   *
+
+/* Finds a white character in the line. */
+char *
 rf_find_white(char *p)
 {
 	for (; *p != '\0' && (*p != ' ' && *p != '\t'); p++);
diff --git a/sys/dev/raidframe/rf_threadstuff.c b/sys/dev/raidframe/rf_threadstuff.c
index cfd1d05ca13..9ea9e20448e 100644
--- a/sys/dev/raidframe/rf_threadstuff.c
+++ b/sys/dev/raidframe/rf_threadstuff.c
@@ -1,8 +1,10 @@
-/*	$OpenBSD: rf_threadstuff.c,v 1.3 2000/01/07 14:50:23 peter Exp $	*/
+/*	$OpenBSD: rf_threadstuff.c,v 1.4 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_threadstuff.c,v 1.5 1999/12/07 02:13:28 oster Exp $	*/
+
 /*
  * rf_threadstuff.c
  */
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -35,18 +37,17 @@
 #include "rf_general.h"
 #include "rf_shutdown.h"
 
-static void mutex_destroyer(void *);
-static void cond_destroyer(void *);
+void mutex_destroyer(void *);
+void cond_destroyer(void *);
 
 /*
- * Shared stuff
+ * Shared stuff.
  */
 
-static void 
-mutex_destroyer(arg)
-	void   *arg;
+void
+mutex_destroyer(void *arg)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_mutex_destroy(arg);
 	if (rc) {
@@ -54,148 +55,141 @@ mutex_destroyer(arg)
 	}
 }
 
-static void 
-cond_destroyer(arg)
-	void   *arg;
+void
+cond_destroyer(void *arg)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_cond_destroy(arg);
 	if (rc) {
-		RF_ERRORMSG1("RAIDFRAME: Error %d auto-destroying condition\n", rc);
+		RF_ERRORMSG1("RAIDFRAME: Error %d auto-destroying condition\n",
+		    rc);
 	}
 }
 
-int 
-_rf_create_managed_mutex(listp, m, file, line)
-	RF_ShutdownList_t **listp;
-RF_DECLARE_MUTEX(*m)
-	char   *file;
-	int     line;
+int
+_rf_create_managed_mutex(RF_ShutdownList_t **listp, RF_DECLARE_MUTEX(*m),
+    char *file, int line)
 {
-	int     rc, rc1;
+	int rc, rc1;
 
 	rc = rf_mutex_init(m);
 	if (rc)
 		return (rc);
+
 	rc = _rf_ShutdownCreate(listp, mutex_destroyer, (void *) m, file, line);
 	if (rc) {
 		RF_ERRORMSG1("RAIDFRAME: Error %d adding shutdown entry\n", rc);
 		rc1 = rf_mutex_destroy(m);
 		if (rc1) {
-			RF_ERRORMSG1("RAIDFRAME: Error %d destroying mutex\n", rc1);
+			RF_ERRORMSG1("RAIDFRAME: Error %d destroying mutex\n",
+			    rc1);
 		}
 	}
+
 	return (rc);
 }
 
-int 
-_rf_create_managed_cond(listp, c, file, line)
-	RF_ShutdownList_t **listp;
-RF_DECLARE_COND(*c)
-	char   *file;
-	int     line;
+int
+_rf_create_managed_cond(RF_ShutdownList_t **listp, RF_DECLARE_COND(*c),
+    char *file, int line)
 {
-	int     rc, rc1;
+	int rc, rc1;
 
 	rc = rf_cond_init(c);
 	if (rc)
 		return (rc);
+
 	rc = _rf_ShutdownCreate(listp, cond_destroyer, (void *) c, file, line);
 	if (rc) {
 		RF_ERRORMSG1("RAIDFRAME: Error %d adding shutdown entry\n", rc);
 		rc1 = rf_cond_destroy(c);
 		if (rc1) {
-			RF_ERRORMSG1("RAIDFRAME: Error %d destroying cond\n", rc1);
+			RF_ERRORMSG1("RAIDFRAME: Error %d destroying cond\n",
+			    rc1);
 		}
 	}
 	return (rc);
 }
 
-int 
-_rf_init_managed_threadgroup(listp, g, file, line)
-	RF_ShutdownList_t **listp;
-	RF_ThreadGroup_t *g;
-	char   *file;
-	int     line;
+int
+_rf_init_managed_threadgroup(RF_ShutdownList_t **listp, RF_ThreadGroup_t *g,
+    char *file, int line)
 {
-	int     rc;
+	int rc;
 
 	rc = _rf_create_managed_mutex(listp, &g->mutex, file, line);
 	if (rc)
 		return (rc);
+
 	rc = _rf_create_managed_cond(listp, &g->cond, file, line);
 	if (rc)
 		return (rc);
+
 	g->created = g->running = g->shutdown = 0;
 	return (0);
 }
 
-int 
-_rf_destroy_threadgroup(g, file, line)
-	RF_ThreadGroup_t *g;
-	char   *file;
-	int     line;
+int
+_rf_destroy_threadgroup(RF_ThreadGroup_t *g, char *file, int line)
 {
-	int     rc1, rc2;
+	int rc1, rc2;
 
 	rc1 = rf_mutex_destroy(&g->mutex);
 	rc2 = rf_cond_destroy(&g->cond);
+
 	if (rc1)
 		return (rc1);
+
 	return (rc2);
 }
 
-int 
-_rf_init_threadgroup(g, file, line)
-	RF_ThreadGroup_t *g;
-	char   *file;
-	int     line;
+int
+_rf_init_threadgroup(RF_ThreadGroup_t *g, char *file, int line)
 {
-	int     rc;
+	int rc;
 
 	rc = rf_mutex_init(&g->mutex);
 	if (rc)
 		return (rc);
+
 	rc = rf_cond_init(&g->cond);
 	if (rc) {
 		rf_mutex_destroy(&g->mutex);
 		return (rc);
 	}
+
 	g->created = g->running = g->shutdown = 0;
 	return (0);
 }
 
 
 /*
- * Kernel
+ * Kernel.
  */
-int 
-rf_mutex_init(m)
-decl_simple_lock_data(, *m)
+
+int
+rf_mutex_init(decl_simple_lock_data(, *m))
 {
 	simple_lock_init(m);
 	return (0);
 }
 
-int 
-rf_mutex_destroy(m)
-decl_simple_lock_data(, *m)
+int
+rf_mutex_destroy(decl_simple_lock_data(, *m))
 {
 	return (0);
 }
 
-int 
-rf_cond_init(c)
-RF_DECLARE_COND(*c)
+int
+rf_cond_init(RF_DECLARE_COND(*c))
 {
-	*c = 0;			/* no reason */
+	*c = 0;			/* No reason. */
 	return (0);
 }
 
-int 
-rf_cond_destroy(c)
-RF_DECLARE_COND(*c)
+int
+rf_cond_destroy(RF_DECLARE_COND(*c))
 {
 	return (0);
 }
diff --git a/sys/dev/raidframe/rf_threadstuff.h b/sys/dev/raidframe/rf_threadstuff.h
index 046d6428bd5..93f9706b3a7 100644
--- a/sys/dev/raidframe/rf_threadstuff.h
+++ b/sys/dev/raidframe/rf_threadstuff.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_threadstuff.h,v 1.7 2002/03/14 01:27:02 millert Exp $	*/
+/*	$OpenBSD: rf_threadstuff.h,v 1.8 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_threadstuff.h,v 1.8 2000/06/11 03:35:38 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -28,157 +29,162 @@
  */
 
 /*
- * threadstuff.h -- definitions for threads, locks, and synchronization
+ * threadstuff.h -- Definitions for threads, locks, and synchronization.
  *
  * The purpose of this file is provide some illusion of portability.
  * If the functions below can be implemented with the same semantics on
  * some new system, then at least the synchronization and thread control
  * part of the code should not require modification to port to a new machine.
- * the only other place where the pthread package is explicitly used is
+ * The only other place where the pthread package is explicitly used is
  * threadid.h
  *
- * this file should be included above stdio.h to get some necessary defines.
+ * This file should be included above stdio.h to get some necessary defines.
  *
  */
 
-#ifndef _RF__RF_THREADSTUFF_H_
-#define _RF__RF_THREADSTUFF_H_
+#ifndef	_RF__RF_THREADSTUFF_H_
+#define	_RF__RF_THREADSTUFF_H_
 
 #include "rf_types.h"
 #include <sys/types.h>
 #include <sys/param.h>
-#ifdef _KERNEL
+#ifdef	_KERNEL
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kthread.h>
 #endif
 
-#define rf_create_managed_mutex(a,b) _rf_create_managed_mutex(a,b,__FILE__,__LINE__)
-#define rf_create_managed_cond(a,b) _rf_create_managed_cond(a,b,__FILE__,__LINE__)
-#define rf_init_managed_threadgroup(a,b) _rf_init_managed_threadgroup(a,b,__FILE__,__LINE__)
-#define rf_init_threadgroup(a) _rf_init_threadgroup(a,__FILE__,__LINE__)
-#define rf_destroy_threadgroup(a) _rf_destroy_threadgroup(a,__FILE__,__LINE__)
-
-int     _rf_init_threadgroup(RF_ThreadGroup_t * g, char *file, int line);
-int     _rf_destroy_threadgroup(RF_ThreadGroup_t * g, char *file, int line);
-int
-_rf_init_managed_threadgroup(RF_ShutdownList_t ** listp,
-    RF_ThreadGroup_t * g, char *file, int line);
+#define	rf_create_managed_mutex(a,b)					\
+	_rf_create_managed_mutex(a,b,__FILE__,__LINE__)
+#define	rf_create_managed_cond(a,b)					\
+	_rf_create_managed_cond(a,b,__FILE__,__LINE__)
+#define	rf_init_managed_threadgroup(a,b)				\
+	_rf_init_managed_threadgroup(a,b,__FILE__,__LINE__)
+#define	rf_init_threadgroup(a)						\
+	_rf_init_threadgroup(a,__FILE__,__LINE__)
+#define	rf_destroy_threadgroup(a)					\
+	_rf_destroy_threadgroup(a,__FILE__,__LINE__)
+
+int _rf_init_threadgroup(RF_ThreadGroup_t *, char *, int);
+int _rf_destroy_threadgroup(RF_ThreadGroup_t *, char *, int);
+int _rf_init_managed_threadgroup(RF_ShutdownList_t **, RF_ThreadGroup_t *,
+    char *, int);
 
 #include <sys/lock.h>
-#define decl_simple_lock_data(a,b) a struct simplelock b;
-#define simple_lock_addr(a) ((struct simplelock *)&(a))
+#define	decl_simple_lock_data(a,b)	a struct simplelock b
+#define	simple_lock_addr(a)		((struct simplelock *)&(a))
 
-typedef struct proc *RF_Thread_t;
-typedef void *RF_ThreadArg_t;
+typedef struct proc	*RF_Thread_t;
+typedef void		*RF_ThreadArg_t;
 
-#define RF_DECLARE_MUTEX(_m_)           decl_simple_lock_data(,(_m_))
-#define RF_DECLARE_STATIC_MUTEX(_m_)    decl_simple_lock_data(static,(_m_))
-#define RF_DECLARE_EXTERN_MUTEX(_m_)    decl_simple_lock_data(extern,(_m_))
+#define	RF_DECLARE_MUTEX(_m_)		decl_simple_lock_data(,(_m_))
+#define	RF_DECLARE_STATIC_MUTEX(_m_)	decl_simple_lock_data(static,(_m_))
+#define	RF_DECLARE_EXTERN_MUTEX(_m_)	decl_simple_lock_data(extern,(_m_))
 
-#define RF_DECLARE_COND(_c_)            int _c_;
-#define RF_DECLARE_STATIC_COND(_c_)     static int _c_;
-#define RF_DECLARE_EXTERN_COND(_c_)     extern int _c_;
+#define	RF_DECLARE_COND(_c_)		int _c_
+#define	RF_DECLARE_STATIC_COND(_c_)	static int _c_
+#define	RF_DECLARE_EXTERN_COND(_c_)	extern int _c_
 
-#define RF_LOCK_MUTEX(_m_)              simple_lock(&(_m_))
-#define RF_UNLOCK_MUTEX(_m_)            simple_unlock(&(_m_))
+#define	RF_LOCK_MUTEX(_m_)		simple_lock(&(_m_))
+#define	RF_UNLOCK_MUTEX(_m_)		simple_unlock(&(_m_))
 
 /*
- * In Net- and OpenBSD, kernel threads are simply processes which share several
+ * In Net- and OpenBSD, kernel threads are simply processes that share several
  * substructures and never run in userspace.
  */
-#define RF_WAIT_COND(_c_,_m_)           { \
-	RF_UNLOCK_MUTEX(_m_); \
-	tsleep(&_c_, PRIBIO, "rfwcond", 0); \
-	RF_LOCK_MUTEX(_m_); \
-}
-#define RF_SIGNAL_COND(_c_)            wakeup(&(_c_))
-#define RF_BROADCAST_COND(_c_)         wakeup(&(_c_))
-#define	RF_CREATE_THREAD(_handle_, _func_, _arg_, _name_) \
-	kthread_create((void (*)(void *))(_func_), (void *)(_arg_), \
+#define	RF_WAIT_COND(_c_,_m_)	do {					\
+	RF_UNLOCK_MUTEX(_m_);						\
+	tsleep(&_c_, PRIBIO, "rfwcond", 0);				\
+	RF_LOCK_MUTEX(_m_);						\
+} while (0)
+#define	RF_SIGNAL_COND(_c_)	wakeup(&(_c_))
+#define	RF_BROADCAST_COND(_c_)	wakeup(&(_c_))
+#define	RF_CREATE_THREAD(_handle_, _func_, _arg_, _name_)		\
+	kthread_create((void (*)(void *))(_func_), (void *)(_arg_),	\
 	    (struct proc **)&(_handle_), _name_)
 
 struct RF_ThreadGroup_s {
-	int     created;
-	int     running;
-	int     shutdown;
-	        RF_DECLARE_MUTEX(mutex)
-	        RF_DECLARE_COND(cond)
+	int			 created;
+	int			 running;
+	int			 shutdown;
+	RF_DECLARE_MUTEX	(mutex);
+	RF_DECLARE_COND		(cond);
 };
+
 /*
- * Someone has started a thread in the group
+ * Someone has started a thread in the group.
  */
-#define RF_THREADGROUP_STARTED(_g_) { \
-	RF_LOCK_MUTEX((_g_)->mutex); \
-	(_g_)->created++; \
-	RF_UNLOCK_MUTEX((_g_)->mutex); \
-}
+#define	RF_THREADGROUP_STARTED(_g_)	do {				\
+	RF_LOCK_MUTEX((_g_)->mutex);					\
+	(_g_)->created++;						\
+	RF_UNLOCK_MUTEX((_g_)->mutex);					\
+} while (0)
 
 /*
- * Thread announcing that it is now running
+ * Thread announcing that it is now running.
  */
-#define RF_THREADGROUP_RUNNING(_g_) { \
-	RF_LOCK_MUTEX((_g_)->mutex); \
-	(_g_)->running++; \
-	RF_UNLOCK_MUTEX((_g_)->mutex); \
-	RF_SIGNAL_COND((_g_)->cond); \
-}
+#define	RF_THREADGROUP_RUNNING(_g_)	do {				\
+	RF_LOCK_MUTEX((_g_)->mutex);					\
+	(_g_)->running++;						\
+	RF_UNLOCK_MUTEX((_g_)->mutex);					\
+	RF_SIGNAL_COND((_g_)->cond);					\
+} while (0)
 
 /*
- * Thread announcing that it is now done
+ * Thread announcing that it is now done.
  */
-#define RF_THREADGROUP_DONE(_g_) { \
-	RF_LOCK_MUTEX((_g_)->mutex); \
-	(_g_)->shutdown++; \
-	RF_UNLOCK_MUTEX((_g_)->mutex); \
-	RF_SIGNAL_COND((_g_)->cond); \
-}
+#define	RF_THREADGROUP_DONE(_g_)	do {				\
+	RF_LOCK_MUTEX((_g_)->mutex);					\
+	(_g_)->shutdown++;						\
+	RF_UNLOCK_MUTEX((_g_)->mutex);					\
+	RF_SIGNAL_COND((_g_)->cond);					\
+} while (0)
 
 /*
- * Wait for all threads to start running
+ * Wait for all threads to start running.
  */
-#define RF_THREADGROUP_WAIT_START(_g_) { \
-	RF_LOCK_MUTEX((_g_)->mutex); \
-	while((_g_)->running < (_g_)->created) { \
-		RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
-	} \
-	RF_UNLOCK_MUTEX((_g_)->mutex); \
-}
+#define	RF_THREADGROUP_WAIT_START(_g_)	do {				\
+	RF_LOCK_MUTEX((_g_)->mutex);					\
+	while((_g_)->running < (_g_)->created) {			\
+		RF_WAIT_COND((_g_)->cond, (_g_)->mutex);		\
+	}								\
+	RF_UNLOCK_MUTEX((_g_)->mutex);					\
+} while (0)
 
 /*
- * Wait for all threads to stop running
+ * Wait for all threads to stop running.
  */
-#if !defined(__NetBSD__) && !defined(__OpenBSD__)
-#define RF_THREADGROUP_WAIT_STOP(_g_) { \
-	RF_LOCK_MUTEX((_g_)->mutex); \
-	RF_ASSERT((_g_)->running == (_g_)->created); \
-	while((_g_)->shutdown < (_g_)->running) { \
-		RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
-	} \
-	RF_UNLOCK_MUTEX((_g_)->mutex); \
-}
+#if	!defined(__NetBSD__) && !defined(__OpenBSD__)
+#define	RF_THREADGROUP_WAIT_STOP(_g_)	do {				\
+	RF_LOCK_MUTEX((_g_)->mutex);					\
+	RF_ASSERT((_g_)->running == (_g_)->created);			\
+	while((_g_)->shutdown < (_g_)->running) {			\
+		RF_WAIT_COND((_g_)->cond, (_g_)->mutex);		\
+	}								\
+	RF_UNLOCK_MUTEX((_g_)->mutex);					\
+} while (0)
 #else
- /* XXX Note that we've removed the assert.  That should get put back in once
-  * we actually get something like a kernel thread running */
-#define RF_THREADGROUP_WAIT_STOP(_g_) { \
-	RF_LOCK_MUTEX((_g_)->mutex); \
-	while((_g_)->shutdown < (_g_)->running) { \
-		RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
-	} \
-	RF_UNLOCK_MUTEX((_g_)->mutex); \
-}
+ /*
+  * XXX Note that we've removed the assert. That should be put back in once
+  * we actually get something like a kernel thread running.
+  */
+#define	RF_THREADGROUP_WAIT_STOP(_g_)	do {				\
+	RF_LOCK_MUTEX((_g_)->mutex);					\
+	while((_g_)->shutdown < (_g_)->running) {			\
+		RF_WAIT_COND((_g_)->cond, (_g_)->mutex);		\
+	}								\
+	RF_UNLOCK_MUTEX((_g_)->mutex);					\
+} while (0)
 #endif
 
 
-int     rf_mutex_init(struct simplelock *);
-int     rf_mutex_destroy(struct simplelock *);
-int 
-_rf_create_managed_mutex(RF_ShutdownList_t **, struct simplelock *,
-    char *, int);
-int 
-_rf_create_managed_cond(RF_ShutdownList_t ** listp, int *,
-    char *file, int line);
+int  rf_mutex_init(struct simplelock *);
+int  rf_mutex_destroy(struct simplelock *);
+int _rf_create_managed_mutex(RF_ShutdownList_t **, struct simplelock *,
+	char *, int);
+int _rf_create_managed_cond(RF_ShutdownList_t ** listp, int *, char *, int);
+
+int  rf_cond_init(int *);
+int  rf_cond_destroy(int *);
 
-int     rf_cond_init(int *c);
-int     rf_cond_destroy(int *c);
-#endif				/* !_RF__RF_THREADSTUFF_H_ */
+#endif	/* !_RF__RF_THREADSTUFF_H_ */
diff --git a/sys/dev/raidframe/rf_types.h b/sys/dev/raidframe/rf_types.h
index 73e252d17fd..a5fb966c214 100644
--- a/sys/dev/raidframe/rf_types.h
+++ b/sys/dev/raidframe/rf_types.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_types.h,v 1.5 2002/05/22 21:22:32 tdeval Exp $	*/
+/*	$OpenBSD: rf_types.h,v 1.6 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_types.h,v 1.6 1999/09/05 03:05:55 oster Exp $	*/
+
 /*
  * rf_types.h
  */
@@ -31,12 +32,12 @@
  */
 /***********************************************************
  *
- * rf_types.h -- standard types for RAIDframe
+ * rf_types.h -- Standard types for RAIDframe.
  *
  ***********************************************************/
 
-#ifndef _RF__RF_TYPES_H_
-#define _RF__RF_TYPES_H_
+#ifndef	_RF__RF_TYPES_H_
+#define	_RF__RF_TYPES_H_
 
 
 #include "rf_archs.h"
@@ -57,7 +58,7 @@
  * The various integer types should be self-explanatory; we
  * use these elsewhere to avoid size confusion.
  *
- * LONGSHIFT is lg(sizeof(long)) (that is, log base two of sizeof(long)
+ * LONGSHIFT is lg(sizeof(long)) (that is, log base two of sizeof(long))
  *
  */
 
@@ -65,25 +66,25 @@
 #include <sys/limits.h>
 #include <machine/endian.h>
 
-#if BYTE_ORDER == BIG_ENDIAN
-#define RF_IS_BIG_ENDIAN    1
-#elif BYTE_ORDER == LITTLE_ENDIAN
-#define RF_IS_BIG_ENDIAN    0
+#if	BYTE_ORDER == BIG_ENDIAN
+#define	RF_IS_BIG_ENDIAN	1
+#elif	BYTE_ORDER == LITTLE_ENDIAN
+#define	RF_IS_BIG_ENDIAN	0
 #else
 #error byte order not defined
 #endif
-typedef int8_t RF_int8;
-typedef u_int8_t RF_uint8;
-typedef int16_t RF_int16;
-typedef u_int16_t RF_uint16;
-typedef int32_t RF_int32;
-typedef u_int32_t RF_uint32;
-typedef int64_t RF_int64;
-typedef u_int64_t RF_uint64;
-#if LONG_BIT == 32
-#define RF_LONGSHIFT        2
-#elif LONG_BIT == 64
-#define RF_LONGSHIFT        3
+typedef int8_t		RF_int8;
+typedef u_int8_t	RF_uint8;
+typedef int16_t		RF_int16;
+typedef u_int16_t	RF_uint16;
+typedef int32_t		RF_int32;
+typedef u_int32_t	RF_uint32;
+typedef int64_t		RF_int64;
+typedef u_int64_t	RF_uint64;
+#if	LONG_BIT == 32
+#define	RF_LONGSHIFT		2
+#elif	LONG_BIT == 64
+#define	RF_LONGSHIFT		3
 #else
 #error word size not defined
 #endif
@@ -95,143 +96,153 @@ typedef u_int64_t RF_uint64;
  * the different places they may be defined in system header
  * files.
  */
-#define RF_TRUE  1
-#define RF_FALSE 0
+#define	RF_TRUE			1
+#define	RF_FALSE		0
 
 /*
- * Now, some generic types
+ * Now, some generic types.
  */
-typedef RF_uint64 RF_IoCount_t;
-typedef RF_uint64 RF_Offset_t;
-typedef RF_uint32 RF_PSSFlags_t;
-typedef RF_uint64 RF_SectorCount_t;
-typedef RF_uint64 RF_StripeCount_t;
-typedef RF_int64 RF_SectorNum_t;/* these are unsigned so we can set them to
-				 * (-1) for "uninitialized" */
-typedef RF_int64 RF_StripeNum_t;
-typedef RF_int64 RF_RaidAddr_t;
-typedef int RF_RowCol_t;	/* unsigned so it can be (-1) */
-typedef RF_int64 RF_HeadSepLimit_t;
-typedef RF_int64 RF_ReconUnitCount_t;
-typedef int RF_ReconUnitNum_t;
-
-typedef char RF_ParityConfig_t;
-
-typedef char RF_DiskQueueType_t[1024];
-#define RF_DISK_QUEUE_TYPE_NONE ""
-
-/* values for the 'type' field in a reconstruction buffer */
-typedef int RF_RbufType_t;
-#define RF_RBUF_TYPE_EXCLUSIVE   0	/* this buf assigned exclusively to
-					 * one disk */
-#define RF_RBUF_TYPE_FLOATING    1	/* this is a floating recon buf */
-#define RF_RBUF_TYPE_FORCED      2	/* this rbuf was allocated to complete
-					 * a forced recon */
-
-typedef char RF_IoType_t;
-#define RF_IO_TYPE_READ          'r'
-#define RF_IO_TYPE_WRITE         'w'
-#define RF_IO_TYPE_NOP           'n'
-#define RF_IO_IS_R_OR_W(_type_) (((_type_) == RF_IO_TYPE_READ) \
-                                || ((_type_) == RF_IO_TYPE_WRITE))
-
-typedef void (*RF_VoidFuncPtr) (void *,...);
-
-typedef RF_uint32 RF_AccessStripeMapFlags_t;
-typedef RF_uint32 RF_DiskQueueDataFlags_t;
-typedef RF_uint32 RF_DiskQueueFlags_t;
-typedef RF_uint32 RF_RaidAccessFlags_t;
-
-#define RF_DISKQUEUE_DATA_FLAGS_NONE ((RF_DiskQueueDataFlags_t)0)
-
-typedef struct RF_AccessStripeMap_s RF_AccessStripeMap_t;
-typedef struct RF_AccessStripeMapHeader_s RF_AccessStripeMapHeader_t;
-typedef struct RF_AllocListElem_s RF_AllocListElem_t;
-typedef struct RF_CallbackDesc_s RF_CallbackDesc_t;
-typedef struct RF_ChunkDesc_s RF_ChunkDesc_t;
-typedef struct RF_CommonLogData_s RF_CommonLogData_t;
-typedef struct RF_Config_s RF_Config_t;
-typedef struct RF_CumulativeStats_s RF_CumulativeStats_t;
-typedef struct RF_DagHeader_s RF_DagHeader_t;
-typedef struct RF_DagList_s RF_DagList_t;
-typedef struct RF_DagNode_s RF_DagNode_t;
-typedef struct RF_DeclusteredConfigInfo_s RF_DeclusteredConfigInfo_t;
-typedef struct RF_DiskId_s RF_DiskId_t;
-typedef struct RF_DiskMap_s RF_DiskMap_t;
-typedef struct RF_DiskQueue_s RF_DiskQueue_t;
-typedef struct RF_DiskQueueData_s RF_DiskQueueData_t;
-typedef struct RF_DiskQueueSW_s RF_DiskQueueSW_t;
-typedef struct RF_Etimer_s RF_Etimer_t;
-typedef struct RF_EventCreate_s RF_EventCreate_t;
-typedef struct RF_FreeList_s RF_FreeList_t;
-typedef struct RF_LockReqDesc_s RF_LockReqDesc_t;
-typedef struct RF_LockTableEntry_s RF_LockTableEntry_t;
-typedef struct RF_MCPair_s RF_MCPair_t;
-typedef struct RF_OwnerInfo_s RF_OwnerInfo_t;
-typedef struct RF_ParityLog_s RF_ParityLog_t;
-typedef struct RF_ParityLogAppendQueue_s RF_ParityLogAppendQueue_t;
-typedef struct RF_ParityLogData_s RF_ParityLogData_t;
-typedef struct RF_ParityLogDiskQueue_s RF_ParityLogDiskQueue_t;
-typedef struct RF_ParityLogQueue_s RF_ParityLogQueue_t;
-typedef struct RF_ParityLogRecord_s RF_ParityLogRecord_t;
-typedef struct RF_PerDiskReconCtrl_s RF_PerDiskReconCtrl_t;
-typedef struct RF_PSStatusHeader_s RF_PSStatusHeader_t;
-typedef struct RF_PhysDiskAddr_s RF_PhysDiskAddr_t;
-typedef struct RF_PropHeader_s RF_PropHeader_t;
-typedef struct RF_Raid_s RF_Raid_t;
-typedef struct RF_RaidAccessDesc_s RF_RaidAccessDesc_t;
-typedef struct RF_RaidDisk_s RF_RaidDisk_t;
-typedef struct RF_RaidLayout_s RF_RaidLayout_t;
-typedef struct RF_RaidReconDesc_s RF_RaidReconDesc_t;
-typedef struct RF_ReconBuffer_s RF_ReconBuffer_t;
-typedef struct RF_ReconConfig_s RF_ReconConfig_t;
-typedef struct RF_ReconCtrl_s RF_ReconCtrl_t;
-typedef struct RF_ReconDoneProc_s RF_ReconDoneProc_t;
-typedef struct RF_ReconEvent_s RF_ReconEvent_t;
-typedef struct RF_ReconMap_s RF_ReconMap_t;
-typedef struct RF_ReconMapListElem_s RF_ReconMapListElem_t;
-typedef struct RF_ReconParityStripeStatus_s RF_ReconParityStripeStatus_t;
-typedef struct RF_RedFuncs_s RF_RedFuncs_t;
-typedef struct RF_RegionBufferQueue_s RF_RegionBufferQueue_t;
-typedef struct RF_RegionInfo_s RF_RegionInfo_t;
-typedef struct RF_ShutdownList_s RF_ShutdownList_t;
-typedef struct RF_SpareTableEntry_s RF_SpareTableEntry_t;
-typedef struct RF_SparetWait_s RF_SparetWait_t;
-typedef struct RF_StripeLockDesc_s RF_StripeLockDesc_t;
-typedef struct RF_ThreadGroup_s RF_ThreadGroup_t;
-typedef struct RF_ThroughputStats_s RF_ThroughputStats_t;
+typedef RF_uint64	RF_IoCount_t;
+typedef RF_uint64	RF_Offset_t;
+typedef RF_uint32	RF_PSSFlags_t;
+typedef RF_uint64	RF_SectorCount_t;
+typedef RF_uint64	RF_StripeCount_t;
+typedef RF_int64	RF_SectorNum_t;	/*
+					 * These are unsigned so we can set
+					 * them to (-1) for "uninitialized".
+					 */
+typedef RF_int64	RF_StripeNum_t;
+typedef RF_int64	RF_RaidAddr_t;
+typedef int		RF_RowCol_t;	/* Unsigned so it can be (-1). */
+typedef RF_int64	RF_HeadSepLimit_t;
+typedef RF_int64	RF_ReconUnitCount_t;
+typedef int		RF_ReconUnitNum_t;
+
+typedef char		RF_ParityConfig_t;
+
+typedef char		RF_DiskQueueType_t[1024];
+#define	RF_DISK_QUEUE_TYPE_NONE	""
+
+/* Values for the 'type' field in a reconstruction buffer. */
+typedef int		RF_RbufType_t;
+#define	RF_RBUF_TYPE_EXCLUSIVE	0	/*
+					 * This buf assigned exclusively to
+					 * one disk.
+					 */
+#define	RF_RBUF_TYPE_FLOATING	1	/* This is a floating recon buf. */
+#define	RF_RBUF_TYPE_FORCED	2	/*
+					 * This rbuf was allocated to complete
+					 * a forced recon.
+					 */
+
+typedef char		RF_IoType_t;
+#define	RF_IO_TYPE_READ		'r'
+#define	RF_IO_TYPE_WRITE	'w'
+#define	RF_IO_TYPE_NOP		'n'
+#define	RF_IO_IS_R_OR_W(_type_)						\
+	(((_type_) == RF_IO_TYPE_READ) || ((_type_) == RF_IO_TYPE_WRITE))
+
+typedef void		(*RF_VoidFuncPtr) (void *,...);
+
+typedef RF_uint32	RF_AccessStripeMapFlags_t;
+typedef RF_uint32	RF_DiskQueueDataFlags_t;
+typedef RF_uint32	RF_DiskQueueFlags_t;
+typedef RF_uint32	RF_RaidAccessFlags_t;
+
+#define	RF_DISKQUEUE_DATA_FLAGS_NONE	((RF_DiskQueueDataFlags_t)0)
+
+typedef struct RF_AccessStripeMap_s		RF_AccessStripeMap_t;
+typedef struct RF_AccessStripeMapHeader_s	RF_AccessStripeMapHeader_t;
+typedef struct RF_AllocListElem_s		RF_AllocListElem_t;
+typedef struct RF_CallbackDesc_s		RF_CallbackDesc_t;
+typedef struct RF_ChunkDesc_s			RF_ChunkDesc_t;
+typedef struct RF_CommonLogData_s		RF_CommonLogData_t;
+typedef struct RF_Config_s			RF_Config_t;
+typedef struct RF_CumulativeStats_s		RF_CumulativeStats_t;
+typedef struct RF_DagHeader_s			RF_DagHeader_t;
+typedef struct RF_DagList_s			RF_DagList_t;
+typedef struct RF_DagNode_s			RF_DagNode_t;
+typedef struct RF_DeclusteredConfigInfo_s	RF_DeclusteredConfigInfo_t;
+typedef struct RF_DiskId_s			RF_DiskId_t;
+typedef struct RF_DiskMap_s			RF_DiskMap_t;
+typedef struct RF_DiskQueue_s			RF_DiskQueue_t;
+typedef struct RF_DiskQueueData_s		RF_DiskQueueData_t;
+typedef struct RF_DiskQueueSW_s			RF_DiskQueueSW_t;
+typedef struct RF_Etimer_s			RF_Etimer_t;
+typedef struct RF_EventCreate_s			RF_EventCreate_t;
+typedef struct RF_FreeList_s			RF_FreeList_t;
+typedef struct RF_LockReqDesc_s			RF_LockReqDesc_t;
+typedef struct RF_LockTableEntry_s		RF_LockTableEntry_t;
+typedef struct RF_MCPair_s			RF_MCPair_t;
+typedef struct RF_OwnerInfo_s			RF_OwnerInfo_t;
+typedef struct RF_ParityLog_s			RF_ParityLog_t;
+typedef struct RF_ParityLogAppendQueue_s	RF_ParityLogAppendQueue_t;
+typedef struct RF_ParityLogData_s		RF_ParityLogData_t;
+typedef struct RF_ParityLogDiskQueue_s		RF_ParityLogDiskQueue_t;
+typedef struct RF_ParityLogQueue_s		RF_ParityLogQueue_t;
+typedef struct RF_ParityLogRecord_s		RF_ParityLogRecord_t;
+typedef struct RF_PerDiskReconCtrl_s		RF_PerDiskReconCtrl_t;
+typedef struct RF_PSStatusHeader_s		RF_PSStatusHeader_t;
+typedef struct RF_PhysDiskAddr_s		RF_PhysDiskAddr_t;
+typedef struct RF_PropHeader_s			RF_PropHeader_t;
+typedef struct RF_Raid_s			RF_Raid_t;
+typedef struct RF_RaidAccessDesc_s		RF_RaidAccessDesc_t;
+typedef struct RF_RaidDisk_s			RF_RaidDisk_t;
+typedef struct RF_RaidLayout_s			RF_RaidLayout_t;
+typedef struct RF_RaidReconDesc_s		RF_RaidReconDesc_t;
+typedef struct RF_ReconBuffer_s			RF_ReconBuffer_t;
+typedef struct RF_ReconConfig_s			RF_ReconConfig_t;
+typedef struct RF_ReconCtrl_s			RF_ReconCtrl_t;
+typedef struct RF_ReconDoneProc_s		RF_ReconDoneProc_t;
+typedef struct RF_ReconEvent_s			RF_ReconEvent_t;
+typedef struct RF_ReconMap_s			RF_ReconMap_t;
+typedef struct RF_ReconMapListElem_s		RF_ReconMapListElem_t;
+typedef struct RF_ReconParityStripeStatus_s	RF_ReconParityStripeStatus_t;
+typedef struct RF_RedFuncs_s			RF_RedFuncs_t;
+typedef struct RF_RegionBufferQueue_s		RF_RegionBufferQueue_t;
+typedef struct RF_RegionInfo_s			RF_RegionInfo_t;
+typedef struct RF_ShutdownList_s		RF_ShutdownList_t;
+typedef struct RF_SpareTableEntry_s		RF_SpareTableEntry_t;
+typedef struct RF_SparetWait_s			RF_SparetWait_t;
+typedef struct RF_StripeLockDesc_s		RF_StripeLockDesc_t;
+typedef struct RF_ThreadGroup_s			RF_ThreadGroup_t;
+typedef struct RF_ThroughputStats_s		RF_ThroughputStats_t;
 
 /*
  * Important assumptions regarding ordering of the states in this list
- * have been made!!!
+ * have been made !!!
  * Before disturbing this ordering, look at code in rf_states.c
  */
 typedef enum RF_AccessState_e {
-	/* original states */
-	rf_QuiesceState,	/* handles queisence for reconstruction */
-	rf_IncrAccessesCountState,	/* count accesses in flight */
+	/* Original states. */
+	rf_QuiesceState,	/* Handles quiescence for reconstruction. */
+	rf_IncrAccessesCountState, /* Count accesses in flight. */
 	rf_DecrAccessesCountState,
-	rf_MapState,		/* map access to disk addresses */
-	rf_LockState,		/* take stripe locks */
-	rf_CreateDAGState,	/* create DAGs */
-	rf_ExecuteDAGState,	/* execute DAGs */
-	rf_ProcessDAGState,	/* DAGs are completing- check if correct, or
-				 * if we need to retry */
-	rf_CleanupState,	/* release stripe locks, clean up */
-	rf_LastState		/* must be the last state */
+	rf_MapState,		/* Map access to disk addresses. */
+	rf_LockState,		/* Take stripe locks. */
+	rf_CreateDAGState,	/* Create DAGs. */
+	rf_ExecuteDAGState,	/* Execute DAGs. */
+	rf_ProcessDAGState,	/*
+				 * DAGs are completing - check if correct, or
+				 * if we need to retry.
+				 */
+	rf_CleanupState,	/* Release stripe locks, clean up. */
+	rf_LastState		/* Must be the last state. */
 }       RF_AccessState_t;
-#define RF_MAXROW	10	/* these are arbitrary and can be modified at
-				 * will */
-#define RF_MAXCOL	40
-#define RF_MAXSPARE	10
-#define RF_MAXDBGV	75	/* max number of debug variables */
-#define RF_MAXDBGVLEN	50	/* max length of debug variables */
+#define	RF_MAXROW	10	/*
+				 * These are arbitrary and can be modified at
+				 * will.
+				 */
+#define	RF_MAXCOL	40
+#define	RF_MAXSPARE	10
+#define	RF_MAXDBGV	75	/* Max number of debug variables. */
+#define	RF_MAXDBGVLEN	50	/* Max length of debug variables. */
 
 union RF_GenericParam_u {
-	void   *p;
-	RF_uint64 v;
+	void		*p;
+	RF_uint64	 v;
 };
-typedef union RF_GenericParam_u RF_DagParam_t;
-typedef union RF_GenericParam_u RF_CBParam_t;
+typedef union RF_GenericParam_u	RF_DagParam_t;
+typedef union RF_GenericParam_u	RF_CBParam_t;
 
-#endif				/* _RF__RF_TYPES_H_ */
+#endif	/* _RF__RF_TYPES_H_ */
diff --git a/sys/dev/raidframe/rf_utils.c b/sys/dev/raidframe/rf_utils.c
index 2b5a99cbebf..c136b0fe7fa 100644
--- a/sys/dev/raidframe/rf_utils.c
+++ b/sys/dev/raidframe/rf_utils.c
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_utils.c,v 1.4 2000/01/11 18:02:23 peter Exp $	*/
+/*	$OpenBSD: rf_utils.c,v 1.5 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_utils.c,v 1.5 2000/01/07 03:41:03 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,11 +28,11 @@
  * rights to redistribute these changes.
  */
 
-/****************************************
+/******************************************
  *
- * rf_utils.c -- various support routines
+ * rf_utils.c -- Various support routines.
  *
- ****************************************/
+ ******************************************/
 
 
 #include "rf_threadstuff.h"
@@ -43,28 +44,24 @@
 #include "rf_alloclist.h"
 #include "rf_general.h"
 
-/* creates & zeros 2-d array with b rows and k columns (MCH) */
+/* Creates & zeros 2-d array with b rows and k columns. (MCH) */
 RF_RowCol_t **
-rf_make_2d_array(b, k, allocList)
-	int     b;
-	int     k;
-	RF_AllocListElem_t *allocList;
+rf_make_2d_array(int b, int k, RF_AllocListElem_t *allocList)
 {
 	RF_RowCol_t **retval, i;
 
-	RF_MallocAndAdd(retval, b * sizeof(RF_RowCol_t *), (RF_RowCol_t **), allocList);
+	RF_MallocAndAdd(retval, b * sizeof(RF_RowCol_t *), (RF_RowCol_t **),
+	    allocList);
 	for (i = 0; i < b; i++) {
-		RF_MallocAndAdd(retval[i], k * sizeof(RF_RowCol_t), (RF_RowCol_t *), allocList);
-		(void) bzero((char *) retval[i], k * sizeof(RF_RowCol_t));
+		RF_MallocAndAdd(retval[i], k * sizeof(RF_RowCol_t),
+		    (RF_RowCol_t *), allocList);
+		bzero((char *) retval[i], k * sizeof(RF_RowCol_t));
 	}
 	return (retval);
 }
 
-void 
-rf_free_2d_array(a, b, k)
-	RF_RowCol_t **a;
-	int     b;
-	int     k;
+void
+rf_free_2d_array(RF_RowCol_t **a, int b, int k)
 {
 	RF_RowCol_t i;
 
@@ -73,36 +70,32 @@ rf_free_2d_array(a, b, k)
 	RF_Free(a, b * sizeof(RF_RowCol_t));
 }
 
-
-/* creates & zeros a 1-d array with c columns */
+/* Creates & zeroes a 1-d array with c columns. */
 RF_RowCol_t *
-rf_make_1d_array(c, allocList)
-	int     c;
-	RF_AllocListElem_t *allocList;
+rf_make_1d_array(int c, RF_AllocListElem_t *allocList)
 {
 	RF_RowCol_t *retval;
 
-	RF_MallocAndAdd(retval, c * sizeof(RF_RowCol_t), (RF_RowCol_t *), allocList);
-	(void) bzero((char *) retval, c * sizeof(RF_RowCol_t));
+	RF_MallocAndAdd(retval, c * sizeof(RF_RowCol_t), (RF_RowCol_t *),
+	    allocList);
+	bzero((char *) retval, c * sizeof(RF_RowCol_t));
 	return (retval);
 }
 
-void 
-rf_free_1d_array(a, n)
-	RF_RowCol_t *a;
-	int     n;
+void
+rf_free_1d_array(RF_RowCol_t *a, int n)
 {
 	RF_Free(a, n * sizeof(RF_RowCol_t));
 }
-/* Euclid's algorithm:  finds and returns the greatest common divisor
- * between a and b.     (MCH)
+
+/*
+ * Euclid's algorithm: Finds and returns the greatest common divisor
+ * between a and b. (MCH)
  */
-int 
-rf_gcd(m, n)
-	int     m;
-	int     n;
+int
+rf_gcd(int m, int n)
 {
-	int     t;
+	int t;
 
 	while (m > 0) {
 		t = n % m;
@@ -111,21 +104,25 @@ rf_gcd(m, n)
 	}
 	return (n);
 }
-/* these convert between text and integer.  Apparently the regular C macros
- * for doing this are not available in the kernel
- */
 
-#define ISDIGIT(x)   ( (x) >= '0' && (x) <= '9' )
-#define ISHEXCHAR(x) ( ((x) >= 'a' && (x) <= 'f') || ((x) >= 'A' && (x) <= 'F') )
-#define ISHEX(x)     ( ISDIGIT(x) || ISHEXCHAR(x) )
-#define HC2INT(x)    ( ((x) >= 'a' && (x) <= 'f') ? (x) - 'a' + 10 :                    \
-		       ( ((x) >= 'A' && (x) <= 'F') ? (x) - 'A' + 10 : (x - '0') ) )
+/*
+ * These convert between text and integer. Apparently the regular C macros
+ * for doing this are not available in the kernel.
+ */
 
-int 
-rf_atoi(p)
-	char   *p;
+#define	ISDIGIT(x)	((x) >= '0' && (x) <= '9')
+#define	ISHEXCHAR(x)	(((x) >= 'a' && (x) <= 'f') ||			\
+			 ((x) >= 'A' && (x) <= 'F'))
+#define	ISHEX(x)	(ISDIGIT(x) || ISHEXCHAR(x))
+#define	HC2INT(x)	(((x) >= 'a' && (x) <= 'f') ?			\
+			 (x) - 'a' + 10 :				\
+			 (((x) >= 'A' && (x) <= 'F') ?			\
+			   (x) - 'A' + 10 : (x - '0')))
+
+int
+rf_atoi(char *p)
 {
-	int     val = 0, negate = 0;
+	int val = 0, negate = 0;
 
 	if (*p == '-') {
 		negate = 1;
@@ -136,11 +133,10 @@ rf_atoi(p)
 	return ((negate) ? -val : val);
 }
 
-int 
-rf_htoi(p)
-	char   *p;
+int
+rf_htoi(char *p)
 {
-	int     val = 0;
+	int val = 0;
 	for (; ISHEXCHAR(*p); p++)
 		val = 16 * val + HC2INT(*p);
 	return (val);
diff --git a/sys/dev/raidframe/rf_utils.h b/sys/dev/raidframe/rf_utils.h
index 622e2061b45..731899521ee 100644
--- a/sys/dev/raidframe/rf_utils.h
+++ b/sys/dev/raidframe/rf_utils.h
@@ -1,5 +1,6 @@
-/*	$OpenBSD: rf_utils.h,v 1.4 2000/01/07 14:50:23 peter Exp $	*/
+/*	$OpenBSD: rf_utils.h,v 1.5 2002/12/16 07:01:05 tdeval Exp $	*/
 /*	$NetBSD: rf_utils.h,v 1.4 1999/08/13 03:26:55 oster Exp $	*/
+
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
@@ -27,44 +28,48 @@
  * rights to redistribute these changes.
  */
 
-/***************************************
+/****************************************
  *
- * rf_utils.c -- header file for utils.c
+ * rf_utils.c -- Header file for utils.c
  *
- ***************************************/
+ ****************************************/
 
 
-#ifndef _RF__RF_UTILS_H_
-#define _RF__RF_UTILS_H_
+#ifndef	_RF__RF_UTILS_H_
+#define	_RF__RF_UTILS_H_
 
 #include "rf_types.h"
 #include "rf_alloclist.h"
 #include "rf_threadstuff.h"
 
-char   *rf_find_non_white(char *p);
-char   *rf_find_white(char *p);
-RF_RowCol_t **rf_make_2d_array(int b, int k, RF_AllocListElem_t * allocList);
-RF_RowCol_t *rf_make_1d_array(int c, RF_AllocListElem_t * allocList);
-void    rf_free_2d_array(RF_RowCol_t ** a, int b, int k);
-void    rf_free_1d_array(RF_RowCol_t * a, int n);
-int     rf_gcd(int m, int n);
-int     rf_atoi(char *p);
-int     rf_htoi(char *p);
+char *rf_find_non_white(char *);
+char *rf_find_white(char *);
+RF_RowCol_t **rf_make_2d_array(int, int, RF_AllocListElem_t *);
+RF_RowCol_t *rf_make_1d_array(int, RF_AllocListElem_t *);
+void  rf_free_2d_array(RF_RowCol_t **, int, int);
+void  rf_free_1d_array(RF_RowCol_t *, int);
+int   rf_gcd(int, int);
+int   rf_atoi(char *);
+int   rf_htoi(char *);
 
-#define RF_USEC_PER_SEC 1000000
-#define RF_TIMEVAL_TO_US(_t_) (((_t_).tv_sec) \
-                * RF_USEC_PER_SEC + (_t_).tv_usec)
+#define	RF_USEC_PER_SEC			1000000
+#define	RF_TIMEVAL_TO_US(_t_)						\
+	(((_t_).tv_sec) * RF_USEC_PER_SEC + (_t_).tv_usec)
 
-#define RF_TIMEVAL_DIFF(_start_,_end_,_diff_) { \
-	if ((_end_)->tv_usec < (_start_)->tv_usec) { \
-		(_diff_)->tv_usec = ((_end_)->tv_usec + RF_USEC_PER_SEC) \
-				- (_start_)->tv_usec; \
-		(_diff_)->tv_sec = ((_end_)->tv_sec-1) - (_start_)->tv_sec; \
-	} \
-	else { \
-		(_diff_)->tv_usec = (_end_)->tv_usec - (_start_)->tv_usec; \
-		(_diff_)->tv_sec  = (_end_)->tv_sec  - (_start_)->tv_sec; \
-	} \
-}
+#define	RF_TIMEVAL_DIFF(_start_,_end_,_diff_)				\
+do {									\
+	if ((_end_)->tv_usec < (_start_)->tv_usec) {			\
+		(_diff_)->tv_usec = ((_end_)->tv_usec +			\
+		    RF_USEC_PER_SEC) - (_start_)->tv_usec;		\
+		(_diff_)->tv_sec = ((_end_)->tv_sec-1) -		\
+		    (_start_)->tv_sec;					\
+	}								\
+	else {								\
+		(_diff_)->tv_usec = (_end_)->tv_usec -			\
+		    (_start_)->tv_usec;					\
+		(_diff_)->tv_sec  = (_end_)->tv_sec  -			\
+		    (_start_)->tv_sec;					\
+	}								\
+} while (0)
 
-#endif				/* !_RF__RF_UTILS_H_ */
+#endif	/* !_RF__RF_UTILS_H_ */